xref: /openbmc/linux/fs/btrfs/ctree.h (revision ff4a7481c3898ffc3cc271d6aca431d190c37247)
1 /* SPDX-License-Identifier: GPL-2.0 */
2 /*
3  * Copyright (C) 2007 Oracle.  All rights reserved.
4  */
5 
6 #ifndef BTRFS_CTREE_H
7 #define BTRFS_CTREE_H
8 
9 #include <linux/mm.h>
10 #include <linux/sched/signal.h>
11 #include <linux/highmem.h>
12 #include <linux/fs.h>
13 #include <linux/rwsem.h>
14 #include <linux/semaphore.h>
15 #include <linux/completion.h>
16 #include <linux/backing-dev.h>
17 #include <linux/wait.h>
18 #include <linux/slab.h>
19 #include <linux/kobject.h>
20 #include <trace/events/btrfs.h>
21 #include <asm/kmap_types.h>
22 #include <linux/pagemap.h>
23 #include <linux/btrfs.h>
24 #include <linux/btrfs_tree.h>
25 #include <linux/workqueue.h>
26 #include <linux/security.h>
27 #include <linux/sizes.h>
28 #include <linux/dynamic_debug.h>
29 #include <linux/refcount.h>
30 #include <linux/crc32c.h>
31 #include "extent_io.h"
32 #include "extent_map.h"
33 #include "async-thread.h"
34 
35 struct btrfs_trans_handle;
36 struct btrfs_transaction;
37 struct btrfs_pending_snapshot;
38 extern struct kmem_cache *btrfs_trans_handle_cachep;
39 extern struct kmem_cache *btrfs_bit_radix_cachep;
40 extern struct kmem_cache *btrfs_path_cachep;
41 extern struct kmem_cache *btrfs_free_space_cachep;
42 struct btrfs_ordered_sum;
43 
44 #define BTRFS_MAGIC 0x4D5F53665248425FULL /* ascii _BHRfS_M, no null */
45 
46 #define BTRFS_MAX_MIRRORS 3
47 
48 #define BTRFS_MAX_LEVEL 8
49 
50 #define BTRFS_OLDEST_GENERATION	0ULL
51 
52 /*
53  * the max metadata block size.  This limit is somewhat artificial,
54  * but the memmove costs go through the roof for larger blocks.
55  */
56 #define BTRFS_MAX_METADATA_BLOCKSIZE 65536
57 
58 /*
59  * we can actually store much bigger names, but lets not confuse the rest
60  * of linux
61  */
62 #define BTRFS_NAME_LEN 255
63 
64 /*
65  * Theoretical limit is larger, but we keep this down to a sane
66  * value. That should limit greatly the possibility of collisions on
67  * inode ref items.
68  */
69 #define BTRFS_LINK_MAX 65535U
70 
71 /* four bytes for CRC32 */
72 static const int btrfs_csum_sizes[] = { 4 };
73 
74 #define BTRFS_EMPTY_DIR_SIZE 0
75 
76 /* ioprio of readahead is set to idle */
77 #define BTRFS_IOPRIO_READA (IOPRIO_PRIO_VALUE(IOPRIO_CLASS_IDLE, 0))
78 
79 #define BTRFS_DIRTY_METADATA_THRESH	SZ_32M
80 
81 /*
82  * Use large batch size to reduce overhead of metadata updates.  On the reader
83  * side, we only read it when we are close to ENOSPC and the read overhead is
84  * mostly related to the number of CPUs, so it is OK to use arbitrary large
85  * value here.
86  */
87 #define BTRFS_TOTAL_BYTES_PINNED_BATCH	SZ_128M
88 
89 #define BTRFS_MAX_EXTENT_SIZE SZ_128M
90 
91 
92 /*
93  * Count how many BTRFS_MAX_EXTENT_SIZE cover the @size
94  */
95 static inline u32 count_max_extents(u64 size)
96 {
97 	return div_u64(size + BTRFS_MAX_EXTENT_SIZE - 1, BTRFS_MAX_EXTENT_SIZE);
98 }
99 
100 struct btrfs_mapping_tree {
101 	struct extent_map_tree map_tree;
102 };
103 
104 static inline unsigned long btrfs_chunk_item_size(int num_stripes)
105 {
106 	BUG_ON(num_stripes == 0);
107 	return sizeof(struct btrfs_chunk) +
108 		sizeof(struct btrfs_stripe) * (num_stripes - 1);
109 }
110 
111 /*
112  * Runtime (in-memory) states of filesystem
113  */
114 enum {
115 	/* Global indicator of serious filesystem errors */
116 	BTRFS_FS_STATE_ERROR,
117 	/*
118 	 * Filesystem is being remounted, allow to skip some operations, like
119 	 * defrag
120 	 */
121 	BTRFS_FS_STATE_REMOUNTING,
122 	/* Track if a transaction abort has been reported on this filesystem */
123 	BTRFS_FS_STATE_TRANS_ABORTED,
124 	/*
125 	 * Bio operations should be blocked on this filesystem because a source
126 	 * or target device is being destroyed as part of a device replace
127 	 */
128 	BTRFS_FS_STATE_DEV_REPLACING,
129 	/* The btrfs_fs_info created for self-tests */
130 	BTRFS_FS_STATE_DUMMY_FS_INFO,
131 };
132 
133 #define BTRFS_BACKREF_REV_MAX		256
134 #define BTRFS_BACKREF_REV_SHIFT		56
135 #define BTRFS_BACKREF_REV_MASK		(((u64)BTRFS_BACKREF_REV_MAX - 1) << \
136 					 BTRFS_BACKREF_REV_SHIFT)
137 
138 #define BTRFS_OLD_BACKREF_REV		0
139 #define BTRFS_MIXED_BACKREF_REV		1
140 
141 /*
142  * every tree block (leaf or node) starts with this header.
143  */
144 struct btrfs_header {
145 	/* these first four must match the super block */
146 	u8 csum[BTRFS_CSUM_SIZE];
147 	u8 fsid[BTRFS_FSID_SIZE]; /* FS specific uuid */
148 	__le64 bytenr; /* which block this node is supposed to live in */
149 	__le64 flags;
150 
151 	/* allowed to be different from the super from here on down */
152 	u8 chunk_tree_uuid[BTRFS_UUID_SIZE];
153 	__le64 generation;
154 	__le64 owner;
155 	__le32 nritems;
156 	u8 level;
157 } __attribute__ ((__packed__));
158 
159 /*
160  * this is a very generous portion of the super block, giving us
161  * room to translate 14 chunks with 3 stripes each.
162  */
163 #define BTRFS_SYSTEM_CHUNK_ARRAY_SIZE 2048
164 
165 /*
166  * just in case we somehow lose the roots and are not able to mount,
167  * we store an array of the roots from previous transactions
168  * in the super.
169  */
170 #define BTRFS_NUM_BACKUP_ROOTS 4
171 struct btrfs_root_backup {
172 	__le64 tree_root;
173 	__le64 tree_root_gen;
174 
175 	__le64 chunk_root;
176 	__le64 chunk_root_gen;
177 
178 	__le64 extent_root;
179 	__le64 extent_root_gen;
180 
181 	__le64 fs_root;
182 	__le64 fs_root_gen;
183 
184 	__le64 dev_root;
185 	__le64 dev_root_gen;
186 
187 	__le64 csum_root;
188 	__le64 csum_root_gen;
189 
190 	__le64 total_bytes;
191 	__le64 bytes_used;
192 	__le64 num_devices;
193 	/* future */
194 	__le64 unused_64[4];
195 
196 	u8 tree_root_level;
197 	u8 chunk_root_level;
198 	u8 extent_root_level;
199 	u8 fs_root_level;
200 	u8 dev_root_level;
201 	u8 csum_root_level;
202 	/* future and to align */
203 	u8 unused_8[10];
204 } __attribute__ ((__packed__));
205 
206 /*
207  * the super block basically lists the main trees of the FS
208  * it currently lacks any block count etc etc
209  */
210 struct btrfs_super_block {
211 	/* the first 4 fields must match struct btrfs_header */
212 	u8 csum[BTRFS_CSUM_SIZE];
213 	/* FS specific UUID, visible to user */
214 	u8 fsid[BTRFS_FSID_SIZE];
215 	__le64 bytenr; /* this block number */
216 	__le64 flags;
217 
218 	/* allowed to be different from the btrfs_header from here own down */
219 	__le64 magic;
220 	__le64 generation;
221 	__le64 root;
222 	__le64 chunk_root;
223 	__le64 log_root;
224 
225 	/* this will help find the new super based on the log root */
226 	__le64 log_root_transid;
227 	__le64 total_bytes;
228 	__le64 bytes_used;
229 	__le64 root_dir_objectid;
230 	__le64 num_devices;
231 	__le32 sectorsize;
232 	__le32 nodesize;
233 	__le32 __unused_leafsize;
234 	__le32 stripesize;
235 	__le32 sys_chunk_array_size;
236 	__le64 chunk_root_generation;
237 	__le64 compat_flags;
238 	__le64 compat_ro_flags;
239 	__le64 incompat_flags;
240 	__le16 csum_type;
241 	u8 root_level;
242 	u8 chunk_root_level;
243 	u8 log_root_level;
244 	struct btrfs_dev_item dev_item;
245 
246 	char label[BTRFS_LABEL_SIZE];
247 
248 	__le64 cache_generation;
249 	__le64 uuid_tree_generation;
250 
251 	/* the UUID written into btree blocks */
252 	u8 metadata_uuid[BTRFS_FSID_SIZE];
253 
254 	/* future expansion */
255 	__le64 reserved[28];
256 	u8 sys_chunk_array[BTRFS_SYSTEM_CHUNK_ARRAY_SIZE];
257 	struct btrfs_root_backup super_roots[BTRFS_NUM_BACKUP_ROOTS];
258 } __attribute__ ((__packed__));
259 
260 /*
261  * Compat flags that we support.  If any incompat flags are set other than the
262  * ones specified below then we will fail to mount
263  */
264 #define BTRFS_FEATURE_COMPAT_SUPP		0ULL
265 #define BTRFS_FEATURE_COMPAT_SAFE_SET		0ULL
266 #define BTRFS_FEATURE_COMPAT_SAFE_CLEAR		0ULL
267 
268 #define BTRFS_FEATURE_COMPAT_RO_SUPP			\
269 	(BTRFS_FEATURE_COMPAT_RO_FREE_SPACE_TREE |	\
270 	 BTRFS_FEATURE_COMPAT_RO_FREE_SPACE_TREE_VALID)
271 
272 #define BTRFS_FEATURE_COMPAT_RO_SAFE_SET	0ULL
273 #define BTRFS_FEATURE_COMPAT_RO_SAFE_CLEAR	0ULL
274 
275 #define BTRFS_FEATURE_INCOMPAT_SUPP			\
276 	(BTRFS_FEATURE_INCOMPAT_MIXED_BACKREF |		\
277 	 BTRFS_FEATURE_INCOMPAT_DEFAULT_SUBVOL |	\
278 	 BTRFS_FEATURE_INCOMPAT_MIXED_GROUPS |		\
279 	 BTRFS_FEATURE_INCOMPAT_BIG_METADATA |		\
280 	 BTRFS_FEATURE_INCOMPAT_COMPRESS_LZO |		\
281 	 BTRFS_FEATURE_INCOMPAT_COMPRESS_ZSTD |		\
282 	 BTRFS_FEATURE_INCOMPAT_RAID56 |		\
283 	 BTRFS_FEATURE_INCOMPAT_EXTENDED_IREF |		\
284 	 BTRFS_FEATURE_INCOMPAT_SKINNY_METADATA |	\
285 	 BTRFS_FEATURE_INCOMPAT_NO_HOLES	|	\
286 	 BTRFS_FEATURE_INCOMPAT_METADATA_UUID)
287 
288 #define BTRFS_FEATURE_INCOMPAT_SAFE_SET			\
289 	(BTRFS_FEATURE_INCOMPAT_EXTENDED_IREF)
290 #define BTRFS_FEATURE_INCOMPAT_SAFE_CLEAR		0ULL
291 
292 /*
293  * A leaf is full of items. offset and size tell us where to find
294  * the item in the leaf (relative to the start of the data area)
295  */
296 struct btrfs_item {
297 	struct btrfs_disk_key key;
298 	__le32 offset;
299 	__le32 size;
300 } __attribute__ ((__packed__));
301 
302 /*
303  * leaves have an item area and a data area:
304  * [item0, item1....itemN] [free space] [dataN...data1, data0]
305  *
306  * The data is separate from the items to get the keys closer together
307  * during searches.
308  */
309 struct btrfs_leaf {
310 	struct btrfs_header header;
311 	struct btrfs_item items[];
312 } __attribute__ ((__packed__));
313 
314 /*
315  * all non-leaf blocks are nodes, they hold only keys and pointers to
316  * other blocks
317  */
318 struct btrfs_key_ptr {
319 	struct btrfs_disk_key key;
320 	__le64 blockptr;
321 	__le64 generation;
322 } __attribute__ ((__packed__));
323 
324 struct btrfs_node {
325 	struct btrfs_header header;
326 	struct btrfs_key_ptr ptrs[];
327 } __attribute__ ((__packed__));
328 
329 /*
330  * btrfs_paths remember the path taken from the root down to the leaf.
331  * level 0 is always the leaf, and nodes[1...BTRFS_MAX_LEVEL] will point
332  * to any other levels that are present.
333  *
334  * The slots array records the index of the item or block pointer
335  * used while walking the tree.
336  */
337 enum { READA_NONE, READA_BACK, READA_FORWARD };
338 struct btrfs_path {
339 	struct extent_buffer *nodes[BTRFS_MAX_LEVEL];
340 	int slots[BTRFS_MAX_LEVEL];
341 	/* if there is real range locking, this locks field will change */
342 	u8 locks[BTRFS_MAX_LEVEL];
343 	u8 reada;
344 	/* keep some upper locks as we walk down */
345 	u8 lowest_level;
346 
347 	/*
348 	 * set by btrfs_split_item, tells search_slot to keep all locks
349 	 * and to force calls to keep space in the nodes
350 	 */
351 	unsigned int search_for_split:1;
352 	unsigned int keep_locks:1;
353 	unsigned int skip_locking:1;
354 	unsigned int leave_spinning:1;
355 	unsigned int search_commit_root:1;
356 	unsigned int need_commit_sem:1;
357 	unsigned int skip_release_on_error:1;
358 };
359 #define BTRFS_MAX_EXTENT_ITEM_SIZE(r) ((BTRFS_LEAF_DATA_SIZE(r->fs_info) >> 4) - \
360 					sizeof(struct btrfs_item))
361 struct btrfs_dev_replace {
362 	u64 replace_state;	/* see #define above */
363 	time64_t time_started;	/* seconds since 1-Jan-1970 */
364 	time64_t time_stopped;	/* seconds since 1-Jan-1970 */
365 	atomic64_t num_write_errors;
366 	atomic64_t num_uncorrectable_read_errors;
367 
368 	u64 cursor_left;
369 	u64 committed_cursor_left;
370 	u64 cursor_left_last_write_of_item;
371 	u64 cursor_right;
372 
373 	u64 cont_reading_from_srcdev_mode;	/* see #define above */
374 
375 	int is_valid;
376 	int item_needs_writeback;
377 	struct btrfs_device *srcdev;
378 	struct btrfs_device *tgtdev;
379 
380 	struct mutex lock_finishing_cancel_unmount;
381 	struct rw_semaphore rwsem;
382 
383 	struct btrfs_scrub_progress scrub_progress;
384 
385 	struct percpu_counter bio_counter;
386 	wait_queue_head_t replace_wait;
387 };
388 
389 /* For raid type sysfs entries */
390 struct raid_kobject {
391 	u64 flags;
392 	struct kobject kobj;
393 	struct list_head list;
394 };
395 
396 struct btrfs_space_info {
397 	spinlock_t lock;
398 
399 	u64 total_bytes;	/* total bytes in the space,
400 				   this doesn't take mirrors into account */
401 	u64 bytes_used;		/* total bytes used,
402 				   this doesn't take mirrors into account */
403 	u64 bytes_pinned;	/* total bytes pinned, will be freed when the
404 				   transaction finishes */
405 	u64 bytes_reserved;	/* total bytes the allocator has reserved for
406 				   current allocations */
407 	u64 bytes_may_use;	/* number of bytes that may be used for
408 				   delalloc/allocations */
409 	u64 bytes_readonly;	/* total bytes that are read only */
410 
411 	u64 max_extent_size;	/* This will hold the maximum extent size of
412 				   the space info if we had an ENOSPC in the
413 				   allocator. */
414 
415 	unsigned int full:1;	/* indicates that we cannot allocate any more
416 				   chunks for this space */
417 	unsigned int chunk_alloc:1;	/* set if we are allocating a chunk */
418 
419 	unsigned int flush:1;		/* set if we are trying to make space */
420 
421 	unsigned int force_alloc;	/* set if we need to force a chunk
422 					   alloc for this space */
423 
424 	u64 disk_used;		/* total bytes used on disk */
425 	u64 disk_total;		/* total bytes on disk, takes mirrors into
426 				   account */
427 
428 	u64 flags;
429 
430 	/*
431 	 * bytes_pinned is kept in line with what is actually pinned, as in
432 	 * we've called update_block_group and dropped the bytes_used counter
433 	 * and increased the bytes_pinned counter.  However this means that
434 	 * bytes_pinned does not reflect the bytes that will be pinned once the
435 	 * delayed refs are flushed, so this counter is inc'ed every time we
436 	 * call btrfs_free_extent so it is a realtime count of what will be
437 	 * freed once the transaction is committed.  It will be zeroed every
438 	 * time the transaction commits.
439 	 */
440 	struct percpu_counter total_bytes_pinned;
441 
442 	struct list_head list;
443 	/* Protected by the spinlock 'lock'. */
444 	struct list_head ro_bgs;
445 	struct list_head priority_tickets;
446 	struct list_head tickets;
447 	/*
448 	 * tickets_id just indicates the next ticket will be handled, so note
449 	 * it's not stored per ticket.
450 	 */
451 	u64 tickets_id;
452 
453 	struct rw_semaphore groups_sem;
454 	/* for block groups in our same type */
455 	struct list_head block_groups[BTRFS_NR_RAID_TYPES];
456 	wait_queue_head_t wait;
457 
458 	struct kobject kobj;
459 	struct kobject *block_group_kobjs[BTRFS_NR_RAID_TYPES];
460 };
461 
462 /*
463  * Types of block reserves
464  */
465 enum {
466 	BTRFS_BLOCK_RSV_GLOBAL,
467 	BTRFS_BLOCK_RSV_DELALLOC,
468 	BTRFS_BLOCK_RSV_TRANS,
469 	BTRFS_BLOCK_RSV_CHUNK,
470 	BTRFS_BLOCK_RSV_DELOPS,
471 	BTRFS_BLOCK_RSV_DELREFS,
472 	BTRFS_BLOCK_RSV_EMPTY,
473 	BTRFS_BLOCK_RSV_TEMP,
474 };
475 
476 struct btrfs_block_rsv {
477 	u64 size;
478 	u64 reserved;
479 	struct btrfs_space_info *space_info;
480 	spinlock_t lock;
481 	unsigned short full;
482 	unsigned short type;
483 	unsigned short failfast;
484 
485 	/*
486 	 * Qgroup equivalent for @size @reserved
487 	 *
488 	 * Unlike normal @size/@reserved for inode rsv, qgroup doesn't care
489 	 * about things like csum size nor how many tree blocks it will need to
490 	 * reserve.
491 	 *
492 	 * Qgroup cares more about net change of the extent usage.
493 	 *
494 	 * So for one newly inserted file extent, in worst case it will cause
495 	 * leaf split and level increase, nodesize for each file extent is
496 	 * already too much.
497 	 *
498 	 * In short, qgroup_size/reserved is the upper limit of possible needed
499 	 * qgroup metadata reservation.
500 	 */
501 	u64 qgroup_rsv_size;
502 	u64 qgroup_rsv_reserved;
503 };
504 
505 /*
506  * free clusters are used to claim free space in relatively large chunks,
507  * allowing us to do less seeky writes. They are used for all metadata
508  * allocations. In ssd_spread mode they are also used for data allocations.
509  */
510 struct btrfs_free_cluster {
511 	spinlock_t lock;
512 	spinlock_t refill_lock;
513 	struct rb_root root;
514 
515 	/* largest extent in this cluster */
516 	u64 max_size;
517 
518 	/* first extent starting offset */
519 	u64 window_start;
520 
521 	/* We did a full search and couldn't create a cluster */
522 	bool fragmented;
523 
524 	struct btrfs_block_group_cache *block_group;
525 	/*
526 	 * when a cluster is allocated from a block group, we put the
527 	 * cluster onto a list in the block group so that it can
528 	 * be freed before the block group is freed.
529 	 */
530 	struct list_head block_group_list;
531 };
532 
533 enum btrfs_caching_type {
534 	BTRFS_CACHE_NO,
535 	BTRFS_CACHE_STARTED,
536 	BTRFS_CACHE_FAST,
537 	BTRFS_CACHE_FINISHED,
538 	BTRFS_CACHE_ERROR,
539 };
540 
541 enum btrfs_disk_cache_state {
542 	BTRFS_DC_WRITTEN,
543 	BTRFS_DC_ERROR,
544 	BTRFS_DC_CLEAR,
545 	BTRFS_DC_SETUP,
546 };
547 
548 struct btrfs_caching_control {
549 	struct list_head list;
550 	struct mutex mutex;
551 	wait_queue_head_t wait;
552 	struct btrfs_work work;
553 	struct btrfs_block_group_cache *block_group;
554 	u64 progress;
555 	refcount_t count;
556 };
557 
558 /* Once caching_thread() finds this much free space, it will wake up waiters. */
559 #define CACHING_CTL_WAKE_UP SZ_2M
560 
561 struct btrfs_io_ctl {
562 	void *cur, *orig;
563 	struct page *page;
564 	struct page **pages;
565 	struct btrfs_fs_info *fs_info;
566 	struct inode *inode;
567 	unsigned long size;
568 	int index;
569 	int num_pages;
570 	int entries;
571 	int bitmaps;
572 	unsigned check_crcs:1;
573 };
574 
575 /*
576  * Tree to record all locked full stripes of a RAID5/6 block group
577  */
578 struct btrfs_full_stripe_locks_tree {
579 	struct rb_root root;
580 	struct mutex lock;
581 };
582 
583 struct btrfs_block_group_cache {
584 	struct btrfs_key key;
585 	struct btrfs_block_group_item item;
586 	struct btrfs_fs_info *fs_info;
587 	struct inode *inode;
588 	spinlock_t lock;
589 	u64 pinned;
590 	u64 reserved;
591 	u64 delalloc_bytes;
592 	u64 bytes_super;
593 	u64 flags;
594 	u64 cache_generation;
595 
596 	/*
597 	 * If the free space extent count exceeds this number, convert the block
598 	 * group to bitmaps.
599 	 */
600 	u32 bitmap_high_thresh;
601 
602 	/*
603 	 * If the free space extent count drops below this number, convert the
604 	 * block group back to extents.
605 	 */
606 	u32 bitmap_low_thresh;
607 
608 	/*
609 	 * It is just used for the delayed data space allocation because
610 	 * only the data space allocation and the relative metadata update
611 	 * can be done cross the transaction.
612 	 */
613 	struct rw_semaphore data_rwsem;
614 
615 	/* for raid56, this is a full stripe, without parity */
616 	unsigned long full_stripe_len;
617 
618 	unsigned int ro;
619 	unsigned int iref:1;
620 	unsigned int has_caching_ctl:1;
621 	unsigned int removed:1;
622 
623 	int disk_cache_state;
624 
625 	/* cache tracking stuff */
626 	int cached;
627 	struct btrfs_caching_control *caching_ctl;
628 	u64 last_byte_to_unpin;
629 
630 	struct btrfs_space_info *space_info;
631 
632 	/* free space cache stuff */
633 	struct btrfs_free_space_ctl *free_space_ctl;
634 
635 	/* block group cache stuff */
636 	struct rb_node cache_node;
637 
638 	/* for block groups in the same raid type */
639 	struct list_head list;
640 
641 	/* usage count */
642 	atomic_t count;
643 
644 	/* List of struct btrfs_free_clusters for this block group.
645 	 * Today it will only have one thing on it, but that may change
646 	 */
647 	struct list_head cluster_list;
648 
649 	/* For delayed block group creation or deletion of empty block groups */
650 	struct list_head bg_list;
651 
652 	/* For read-only block groups */
653 	struct list_head ro_list;
654 
655 	atomic_t trimming;
656 
657 	/* For dirty block groups */
658 	struct list_head dirty_list;
659 	struct list_head io_list;
660 
661 	struct btrfs_io_ctl io_ctl;
662 
663 	/*
664 	 * Incremented when doing extent allocations and holding a read lock
665 	 * on the space_info's groups_sem semaphore.
666 	 * Decremented when an ordered extent that represents an IO against this
667 	 * block group's range is created (after it's added to its inode's
668 	 * root's list of ordered extents) or immediately after the allocation
669 	 * if it's a metadata extent or fallocate extent (for these cases we
670 	 * don't create ordered extents).
671 	 */
672 	atomic_t reservations;
673 
674 	/*
675 	 * Incremented while holding the spinlock *lock* by a task checking if
676 	 * it can perform a nocow write (incremented if the value for the *ro*
677 	 * field is 0). Decremented by such tasks once they create an ordered
678 	 * extent or before that if some error happens before reaching that step.
679 	 * This is to prevent races between block group relocation and nocow
680 	 * writes through direct IO.
681 	 */
682 	atomic_t nocow_writers;
683 
684 	/* Lock for free space tree operations. */
685 	struct mutex free_space_lock;
686 
687 	/*
688 	 * Does the block group need to be added to the free space tree?
689 	 * Protected by free_space_lock.
690 	 */
691 	int needs_free_space;
692 
693 	/* Record locked full stripes for RAID5/6 block group */
694 	struct btrfs_full_stripe_locks_tree full_stripe_locks_root;
695 };
696 
697 /* delayed seq elem */
698 struct seq_list {
699 	struct list_head list;
700 	u64 seq;
701 };
702 
703 #define SEQ_LIST_INIT(name)	{ .list = LIST_HEAD_INIT((name).list), .seq = 0 }
704 
705 #define SEQ_LAST	((u64)-1)
706 
707 enum btrfs_orphan_cleanup_state {
708 	ORPHAN_CLEANUP_STARTED	= 1,
709 	ORPHAN_CLEANUP_DONE	= 2,
710 };
711 
712 /* used by the raid56 code to lock stripes for read/modify/write */
713 struct btrfs_stripe_hash {
714 	struct list_head hash_list;
715 	spinlock_t lock;
716 };
717 
718 /* used by the raid56 code to lock stripes for read/modify/write */
719 struct btrfs_stripe_hash_table {
720 	struct list_head stripe_cache;
721 	spinlock_t cache_lock;
722 	int cache_size;
723 	struct btrfs_stripe_hash table[];
724 };
725 
726 #define BTRFS_STRIPE_HASH_TABLE_BITS 11
727 
728 void btrfs_init_async_reclaim_work(struct work_struct *work);
729 
730 /* fs_info */
731 struct reloc_control;
732 struct btrfs_device;
733 struct btrfs_fs_devices;
734 struct btrfs_balance_control;
735 struct btrfs_delayed_root;
736 
737 /*
738  * Block group or device which contains an active swapfile. Used for preventing
739  * unsafe operations while a swapfile is active.
740  *
741  * These are sorted on (ptr, inode) (note that a block group or device can
742  * contain more than one swapfile). We compare the pointer values because we
743  * don't actually care what the object is, we just need a quick check whether
744  * the object exists in the rbtree.
745  */
746 struct btrfs_swapfile_pin {
747 	struct rb_node node;
748 	void *ptr;
749 	struct inode *inode;
750 	/*
751 	 * If true, ptr points to a struct btrfs_block_group_cache. Otherwise,
752 	 * ptr points to a struct btrfs_device.
753 	 */
754 	bool is_block_group;
755 };
756 
757 bool btrfs_pinned_by_swapfile(struct btrfs_fs_info *fs_info, void *ptr);
758 
759 enum {
760 	BTRFS_FS_BARRIER,
761 	BTRFS_FS_CLOSING_START,
762 	BTRFS_FS_CLOSING_DONE,
763 	BTRFS_FS_LOG_RECOVERING,
764 	BTRFS_FS_OPEN,
765 	BTRFS_FS_QUOTA_ENABLED,
766 	BTRFS_FS_UPDATE_UUID_TREE_GEN,
767 	BTRFS_FS_CREATING_FREE_SPACE_TREE,
768 	BTRFS_FS_BTREE_ERR,
769 	BTRFS_FS_LOG1_ERR,
770 	BTRFS_FS_LOG2_ERR,
771 	BTRFS_FS_QUOTA_OVERRIDE,
772 	/* Used to record internally whether fs has been frozen */
773 	BTRFS_FS_FROZEN,
774 	/*
775 	 * Indicate that a whole-filesystem exclusive operation is running
776 	 * (device replace, resize, device add/delete, balance)
777 	 */
778 	BTRFS_FS_EXCL_OP,
779 	/*
780 	 * To info transaction_kthread we need an immediate commit so it
781 	 * doesn't need to wait for commit_interval
782 	 */
783 	BTRFS_FS_NEED_ASYNC_COMMIT,
784 	/*
785 	 * Indicate that balance has been set up from the ioctl and is in the
786 	 * main phase. The fs_info::balance_ctl is initialized.
787 	 */
788 	BTRFS_FS_BALANCE_RUNNING,
789 };
790 
791 struct btrfs_fs_info {
792 	u8 chunk_tree_uuid[BTRFS_UUID_SIZE];
793 	unsigned long flags;
794 	struct btrfs_root *extent_root;
795 	struct btrfs_root *tree_root;
796 	struct btrfs_root *chunk_root;
797 	struct btrfs_root *dev_root;
798 	struct btrfs_root *fs_root;
799 	struct btrfs_root *csum_root;
800 	struct btrfs_root *quota_root;
801 	struct btrfs_root *uuid_root;
802 	struct btrfs_root *free_space_root;
803 
804 	/* the log root tree is a directory of all the other log roots */
805 	struct btrfs_root *log_root_tree;
806 
807 	spinlock_t fs_roots_radix_lock;
808 	struct radix_tree_root fs_roots_radix;
809 
810 	/* block group cache stuff */
811 	spinlock_t block_group_cache_lock;
812 	u64 first_logical_byte;
813 	struct rb_root block_group_cache_tree;
814 
815 	/* keep track of unallocated space */
816 	atomic64_t free_chunk_space;
817 
818 	struct extent_io_tree freed_extents[2];
819 	struct extent_io_tree *pinned_extents;
820 
821 	/* logical->physical extent mapping */
822 	struct btrfs_mapping_tree mapping_tree;
823 
824 	/*
825 	 * block reservation for extent, checksum, root tree and
826 	 * delayed dir index item
827 	 */
828 	struct btrfs_block_rsv global_block_rsv;
829 	/* block reservation for metadata operations */
830 	struct btrfs_block_rsv trans_block_rsv;
831 	/* block reservation for chunk tree */
832 	struct btrfs_block_rsv chunk_block_rsv;
833 	/* block reservation for delayed operations */
834 	struct btrfs_block_rsv delayed_block_rsv;
835 	/* block reservation for delayed refs */
836 	struct btrfs_block_rsv delayed_refs_rsv;
837 
838 	struct btrfs_block_rsv empty_block_rsv;
839 
840 	u64 generation;
841 	u64 last_trans_committed;
842 	u64 avg_delayed_ref_runtime;
843 
844 	/*
845 	 * this is updated to the current trans every time a full commit
846 	 * is required instead of the faster short fsync log commits
847 	 */
848 	u64 last_trans_log_full_commit;
849 	unsigned long mount_opt;
850 	/*
851 	 * Track requests for actions that need to be done during transaction
852 	 * commit (like for some mount options).
853 	 */
854 	unsigned long pending_changes;
855 	unsigned long compress_type:4;
856 	unsigned int compress_level;
857 	u32 commit_interval;
858 	/*
859 	 * It is a suggestive number, the read side is safe even it gets a
860 	 * wrong number because we will write out the data into a regular
861 	 * extent. The write side(mount/remount) is under ->s_umount lock,
862 	 * so it is also safe.
863 	 */
864 	u64 max_inline;
865 
866 	struct btrfs_transaction *running_transaction;
867 	wait_queue_head_t transaction_throttle;
868 	wait_queue_head_t transaction_wait;
869 	wait_queue_head_t transaction_blocked_wait;
870 	wait_queue_head_t async_submit_wait;
871 
872 	/*
873 	 * Used to protect the incompat_flags, compat_flags, compat_ro_flags
874 	 * when they are updated.
875 	 *
876 	 * Because we do not clear the flags for ever, so we needn't use
877 	 * the lock on the read side.
878 	 *
879 	 * We also needn't use the lock when we mount the fs, because
880 	 * there is no other task which will update the flag.
881 	 */
882 	spinlock_t super_lock;
883 	struct btrfs_super_block *super_copy;
884 	struct btrfs_super_block *super_for_commit;
885 	struct super_block *sb;
886 	struct inode *btree_inode;
887 	struct mutex tree_log_mutex;
888 	struct mutex transaction_kthread_mutex;
889 	struct mutex cleaner_mutex;
890 	struct mutex chunk_mutex;
891 
892 	/*
893 	 * this is taken to make sure we don't set block groups ro after
894 	 * the free space cache has been allocated on them
895 	 */
896 	struct mutex ro_block_group_mutex;
897 
898 	/* this is used during read/modify/write to make sure
899 	 * no two ios are trying to mod the same stripe at the same
900 	 * time
901 	 */
902 	struct btrfs_stripe_hash_table *stripe_hash_table;
903 
904 	/*
905 	 * this protects the ordered operations list only while we are
906 	 * processing all of the entries on it.  This way we make
907 	 * sure the commit code doesn't find the list temporarily empty
908 	 * because another function happens to be doing non-waiting preflush
909 	 * before jumping into the main commit.
910 	 */
911 	struct mutex ordered_operations_mutex;
912 
913 	struct rw_semaphore commit_root_sem;
914 
915 	struct rw_semaphore cleanup_work_sem;
916 
917 	struct rw_semaphore subvol_sem;
918 	struct srcu_struct subvol_srcu;
919 
920 	spinlock_t trans_lock;
921 	/*
922 	 * the reloc mutex goes with the trans lock, it is taken
923 	 * during commit to protect us from the relocation code
924 	 */
925 	struct mutex reloc_mutex;
926 
927 	struct list_head trans_list;
928 	struct list_head dead_roots;
929 	struct list_head caching_block_groups;
930 
931 	spinlock_t delayed_iput_lock;
932 	struct list_head delayed_iputs;
933 	struct mutex cleaner_delayed_iput_mutex;
934 
935 	/* this protects tree_mod_seq_list */
936 	spinlock_t tree_mod_seq_lock;
937 	atomic64_t tree_mod_seq;
938 	struct list_head tree_mod_seq_list;
939 
940 	/* this protects tree_mod_log */
941 	rwlock_t tree_mod_log_lock;
942 	struct rb_root tree_mod_log;
943 
944 	atomic_t async_delalloc_pages;
945 
946 	/*
947 	 * this is used to protect the following list -- ordered_roots.
948 	 */
949 	spinlock_t ordered_root_lock;
950 
951 	/*
952 	 * all fs/file tree roots in which there are data=ordered extents
953 	 * pending writeback are added into this list.
954 	 *
955 	 * these can span multiple transactions and basically include
956 	 * every dirty data page that isn't from nodatacow
957 	 */
958 	struct list_head ordered_roots;
959 
960 	struct mutex delalloc_root_mutex;
961 	spinlock_t delalloc_root_lock;
962 	/* all fs/file tree roots that have delalloc inodes. */
963 	struct list_head delalloc_roots;
964 
965 	/*
966 	 * there is a pool of worker threads for checksumming during writes
967 	 * and a pool for checksumming after reads.  This is because readers
968 	 * can run with FS locks held, and the writers may be waiting for
969 	 * those locks.  We don't want ordering in the pending list to cause
970 	 * deadlocks, and so the two are serviced separately.
971 	 *
972 	 * A third pool does submit_bio to avoid deadlocking with the other
973 	 * two
974 	 */
975 	struct btrfs_workqueue *workers;
976 	struct btrfs_workqueue *delalloc_workers;
977 	struct btrfs_workqueue *flush_workers;
978 	struct btrfs_workqueue *endio_workers;
979 	struct btrfs_workqueue *endio_meta_workers;
980 	struct btrfs_workqueue *endio_raid56_workers;
981 	struct btrfs_workqueue *endio_repair_workers;
982 	struct btrfs_workqueue *rmw_workers;
983 	struct btrfs_workqueue *endio_meta_write_workers;
984 	struct btrfs_workqueue *endio_write_workers;
985 	struct btrfs_workqueue *endio_freespace_worker;
986 	struct btrfs_workqueue *submit_workers;
987 	struct btrfs_workqueue *caching_workers;
988 	struct btrfs_workqueue *readahead_workers;
989 
990 	/*
991 	 * fixup workers take dirty pages that didn't properly go through
992 	 * the cow mechanism and make them safe to write.  It happens
993 	 * for the sys_munmap function call path
994 	 */
995 	struct btrfs_workqueue *fixup_workers;
996 	struct btrfs_workqueue *delayed_workers;
997 
998 	/* the extent workers do delayed refs on the extent allocation tree */
999 	struct btrfs_workqueue *extent_workers;
1000 	struct task_struct *transaction_kthread;
1001 	struct task_struct *cleaner_kthread;
1002 	u32 thread_pool_size;
1003 
1004 	struct kobject *space_info_kobj;
1005 	struct list_head pending_raid_kobjs;
1006 	spinlock_t pending_raid_kobjs_lock; /* uncontended */
1007 
1008 	u64 total_pinned;
1009 
1010 	/* used to keep from writing metadata until there is a nice batch */
1011 	struct percpu_counter dirty_metadata_bytes;
1012 	struct percpu_counter delalloc_bytes;
1013 	s32 dirty_metadata_batch;
1014 	s32 delalloc_batch;
1015 
1016 	struct list_head dirty_cowonly_roots;
1017 
1018 	struct btrfs_fs_devices *fs_devices;
1019 
1020 	/*
1021 	 * The space_info list is effectively read only after initial
1022 	 * setup.  It is populated at mount time and cleaned up after
1023 	 * all block groups are removed.  RCU is used to protect it.
1024 	 */
1025 	struct list_head space_info;
1026 
1027 	struct btrfs_space_info *data_sinfo;
1028 
1029 	struct reloc_control *reloc_ctl;
1030 
1031 	/* data_alloc_cluster is only used in ssd_spread mode */
1032 	struct btrfs_free_cluster data_alloc_cluster;
1033 
1034 	/* all metadata allocations go through this cluster */
1035 	struct btrfs_free_cluster meta_alloc_cluster;
1036 
1037 	/* auto defrag inodes go here */
1038 	spinlock_t defrag_inodes_lock;
1039 	struct rb_root defrag_inodes;
1040 	atomic_t defrag_running;
1041 
1042 	/* Used to protect avail_{data, metadata, system}_alloc_bits */
1043 	seqlock_t profiles_lock;
1044 	/*
1045 	 * these three are in extended format (availability of single
1046 	 * chunks is denoted by BTRFS_AVAIL_ALLOC_BIT_SINGLE bit, other
1047 	 * types are denoted by corresponding BTRFS_BLOCK_GROUP_* bits)
1048 	 */
1049 	u64 avail_data_alloc_bits;
1050 	u64 avail_metadata_alloc_bits;
1051 	u64 avail_system_alloc_bits;
1052 
1053 	/* restriper state */
1054 	spinlock_t balance_lock;
1055 	struct mutex balance_mutex;
1056 	atomic_t balance_pause_req;
1057 	atomic_t balance_cancel_req;
1058 	struct btrfs_balance_control *balance_ctl;
1059 	wait_queue_head_t balance_wait_q;
1060 
1061 	u32 data_chunk_allocations;
1062 	u32 metadata_ratio;
1063 
1064 	void *bdev_holder;
1065 
1066 	/* private scrub information */
1067 	struct mutex scrub_lock;
1068 	atomic_t scrubs_running;
1069 	atomic_t scrub_pause_req;
1070 	atomic_t scrubs_paused;
1071 	atomic_t scrub_cancel_req;
1072 	wait_queue_head_t scrub_pause_wait;
1073 	int scrub_workers_refcnt;
1074 	struct btrfs_workqueue *scrub_workers;
1075 	struct btrfs_workqueue *scrub_wr_completion_workers;
1076 	struct btrfs_workqueue *scrub_nocow_workers;
1077 	struct btrfs_workqueue *scrub_parity_workers;
1078 
1079 #ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
1080 	u32 check_integrity_print_mask;
1081 #endif
1082 	/* is qgroup tracking in a consistent state? */
1083 	u64 qgroup_flags;
1084 
1085 	/* holds configuration and tracking. Protected by qgroup_lock */
1086 	struct rb_root qgroup_tree;
1087 	struct rb_root qgroup_op_tree;
1088 	spinlock_t qgroup_lock;
1089 	spinlock_t qgroup_op_lock;
1090 	atomic_t qgroup_op_seq;
1091 
1092 	/*
1093 	 * used to avoid frequently calling ulist_alloc()/ulist_free()
1094 	 * when doing qgroup accounting, it must be protected by qgroup_lock.
1095 	 */
1096 	struct ulist *qgroup_ulist;
1097 
1098 	/* protect user change for quota operations */
1099 	struct mutex qgroup_ioctl_lock;
1100 
1101 	/* list of dirty qgroups to be written at next commit */
1102 	struct list_head dirty_qgroups;
1103 
1104 	/* used by qgroup for an efficient tree traversal */
1105 	u64 qgroup_seq;
1106 
1107 	/* qgroup rescan items */
1108 	struct mutex qgroup_rescan_lock; /* protects the progress item */
1109 	struct btrfs_key qgroup_rescan_progress;
1110 	struct btrfs_workqueue *qgroup_rescan_workers;
1111 	struct completion qgroup_rescan_completion;
1112 	struct btrfs_work qgroup_rescan_work;
1113 	bool qgroup_rescan_running;	/* protected by qgroup_rescan_lock */
1114 
1115 	/* filesystem state */
1116 	unsigned long fs_state;
1117 
1118 	struct btrfs_delayed_root *delayed_root;
1119 
1120 	/* readahead tree */
1121 	spinlock_t reada_lock;
1122 	struct radix_tree_root reada_tree;
1123 
1124 	/* readahead works cnt */
1125 	atomic_t reada_works_cnt;
1126 
1127 	/* Extent buffer radix tree */
1128 	spinlock_t buffer_lock;
1129 	struct radix_tree_root buffer_radix;
1130 
1131 	/* next backup root to be overwritten */
1132 	int backup_root_index;
1133 
1134 	/* device replace state */
1135 	struct btrfs_dev_replace dev_replace;
1136 
1137 	struct semaphore uuid_tree_rescan_sem;
1138 
1139 	/* Used to reclaim the metadata space in the background. */
1140 	struct work_struct async_reclaim_work;
1141 
1142 	spinlock_t unused_bgs_lock;
1143 	struct list_head unused_bgs;
1144 	struct mutex unused_bg_unpin_mutex;
1145 	struct mutex delete_unused_bgs_mutex;
1146 
1147 	/* For btrfs to record security options */
1148 	struct security_mnt_opts security_opts;
1149 
1150 	/*
1151 	 * Chunks that can't be freed yet (under a trim/discard operation)
1152 	 * and will be latter freed. Protected by fs_info->chunk_mutex.
1153 	 */
1154 	struct list_head pinned_chunks;
1155 
1156 	/* Cached block sizes */
1157 	u32 nodesize;
1158 	u32 sectorsize;
1159 	u32 stripesize;
1160 
1161 	/* Block groups and devices containing active swapfiles. */
1162 	spinlock_t swapfile_pins_lock;
1163 	struct rb_root swapfile_pins;
1164 
1165 #ifdef CONFIG_BTRFS_FS_REF_VERIFY
1166 	spinlock_t ref_verify_lock;
1167 	struct rb_root block_tree;
1168 #endif
1169 };
1170 
1171 static inline struct btrfs_fs_info *btrfs_sb(struct super_block *sb)
1172 {
1173 	return sb->s_fs_info;
1174 }
1175 
1176 struct btrfs_subvolume_writers {
1177 	struct percpu_counter	counter;
1178 	wait_queue_head_t	wait;
1179 };
1180 
1181 /*
1182  * The state of btrfs root
1183  */
1184 enum {
1185 	/*
1186 	 * btrfs_record_root_in_trans is a multi-step process, and it can race
1187 	 * with the balancing code.   But the race is very small, and only the
1188 	 * first time the root is added to each transaction.  So IN_TRANS_SETUP
1189 	 * is used to tell us when more checks are required
1190 	 */
1191 	BTRFS_ROOT_IN_TRANS_SETUP,
1192 	BTRFS_ROOT_REF_COWS,
1193 	BTRFS_ROOT_TRACK_DIRTY,
1194 	BTRFS_ROOT_IN_RADIX,
1195 	BTRFS_ROOT_ORPHAN_ITEM_INSERTED,
1196 	BTRFS_ROOT_DEFRAG_RUNNING,
1197 	BTRFS_ROOT_FORCE_COW,
1198 	BTRFS_ROOT_MULTI_LOG_TASKS,
1199 	BTRFS_ROOT_DIRTY,
1200 	BTRFS_ROOT_DELETING,
1201 };
1202 
1203 /*
1204  * in ram representation of the tree.  extent_root is used for all allocations
1205  * and for the extent tree extent_root root.
1206  */
1207 struct btrfs_root {
1208 	struct extent_buffer *node;
1209 
1210 	struct extent_buffer *commit_root;
1211 	struct btrfs_root *log_root;
1212 	struct btrfs_root *reloc_root;
1213 
1214 	unsigned long state;
1215 	struct btrfs_root_item root_item;
1216 	struct btrfs_key root_key;
1217 	struct btrfs_fs_info *fs_info;
1218 	struct extent_io_tree dirty_log_pages;
1219 
1220 	struct mutex objectid_mutex;
1221 
1222 	spinlock_t accounting_lock;
1223 	struct btrfs_block_rsv *block_rsv;
1224 
1225 	/* free ino cache stuff */
1226 	struct btrfs_free_space_ctl *free_ino_ctl;
1227 	enum btrfs_caching_type ino_cache_state;
1228 	spinlock_t ino_cache_lock;
1229 	wait_queue_head_t ino_cache_wait;
1230 	struct btrfs_free_space_ctl *free_ino_pinned;
1231 	u64 ino_cache_progress;
1232 	struct inode *ino_cache_inode;
1233 
1234 	struct mutex log_mutex;
1235 	wait_queue_head_t log_writer_wait;
1236 	wait_queue_head_t log_commit_wait[2];
1237 	struct list_head log_ctxs[2];
1238 	atomic_t log_writers;
1239 	atomic_t log_commit[2];
1240 	atomic_t log_batch;
1241 	int log_transid;
1242 	/* No matter the commit succeeds or not*/
1243 	int log_transid_committed;
1244 	/* Just be updated when the commit succeeds. */
1245 	int last_log_commit;
1246 	pid_t log_start_pid;
1247 
1248 	u64 last_trans;
1249 
1250 	u32 type;
1251 
1252 	u64 highest_objectid;
1253 
1254 	u64 defrag_trans_start;
1255 	struct btrfs_key defrag_progress;
1256 	struct btrfs_key defrag_max;
1257 
1258 	/* the dirty list is only used by non-reference counted roots */
1259 	struct list_head dirty_list;
1260 
1261 	struct list_head root_list;
1262 
1263 	spinlock_t log_extents_lock[2];
1264 	struct list_head logged_list[2];
1265 
1266 	int orphan_cleanup_state;
1267 
1268 	spinlock_t inode_lock;
1269 	/* red-black tree that keeps track of in-memory inodes */
1270 	struct rb_root inode_tree;
1271 
1272 	/*
1273 	 * radix tree that keeps track of delayed nodes of every inode,
1274 	 * protected by inode_lock
1275 	 */
1276 	struct radix_tree_root delayed_nodes_tree;
1277 	/*
1278 	 * right now this just gets used so that a root has its own devid
1279 	 * for stat.  It may be used for more later
1280 	 */
1281 	dev_t anon_dev;
1282 
1283 	spinlock_t root_item_lock;
1284 	refcount_t refs;
1285 
1286 	struct mutex delalloc_mutex;
1287 	spinlock_t delalloc_lock;
1288 	/*
1289 	 * all of the inodes that have delalloc bytes.  It is possible for
1290 	 * this list to be empty even when there is still dirty data=ordered
1291 	 * extents waiting to finish IO.
1292 	 */
1293 	struct list_head delalloc_inodes;
1294 	struct list_head delalloc_root;
1295 	u64 nr_delalloc_inodes;
1296 
1297 	struct mutex ordered_extent_mutex;
1298 	/*
1299 	 * this is used by the balancing code to wait for all the pending
1300 	 * ordered extents
1301 	 */
1302 	spinlock_t ordered_extent_lock;
1303 
1304 	/*
1305 	 * all of the data=ordered extents pending writeback
1306 	 * these can span multiple transactions and basically include
1307 	 * every dirty data page that isn't from nodatacow
1308 	 */
1309 	struct list_head ordered_extents;
1310 	struct list_head ordered_root;
1311 	u64 nr_ordered_extents;
1312 
1313 	/*
1314 	 * Number of currently running SEND ioctls to prevent
1315 	 * manipulation with the read-only status via SUBVOL_SETFLAGS
1316 	 */
1317 	int send_in_progress;
1318 	struct btrfs_subvolume_writers *subv_writers;
1319 	atomic_t will_be_snapshotted;
1320 	atomic_t snapshot_force_cow;
1321 
1322 	/* For qgroup metadata reserved space */
1323 	spinlock_t qgroup_meta_rsv_lock;
1324 	u64 qgroup_meta_rsv_pertrans;
1325 	u64 qgroup_meta_rsv_prealloc;
1326 
1327 	/* Number of active swapfiles */
1328 	atomic_t nr_swapfiles;
1329 
1330 #ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS
1331 	u64 alloc_bytenr;
1332 #endif
1333 };
1334 
1335 struct btrfs_file_private {
1336 	void *filldir_buf;
1337 };
1338 
1339 static inline u32 btrfs_inode_sectorsize(const struct inode *inode)
1340 {
1341 	return btrfs_sb(inode->i_sb)->sectorsize;
1342 }
1343 
1344 static inline u32 BTRFS_LEAF_DATA_SIZE(const struct btrfs_fs_info *info)
1345 {
1346 
1347 	return info->nodesize - sizeof(struct btrfs_header);
1348 }
1349 
1350 #define BTRFS_LEAF_DATA_OFFSET		offsetof(struct btrfs_leaf, items)
1351 
1352 static inline u32 BTRFS_MAX_ITEM_SIZE(const struct btrfs_fs_info *info)
1353 {
1354 	return BTRFS_LEAF_DATA_SIZE(info) - sizeof(struct btrfs_item);
1355 }
1356 
1357 static inline u32 BTRFS_NODEPTRS_PER_BLOCK(const struct btrfs_fs_info *info)
1358 {
1359 	return BTRFS_LEAF_DATA_SIZE(info) / sizeof(struct btrfs_key_ptr);
1360 }
1361 
1362 #define BTRFS_FILE_EXTENT_INLINE_DATA_START		\
1363 		(offsetof(struct btrfs_file_extent_item, disk_bytenr))
1364 static inline u32 BTRFS_MAX_INLINE_DATA_SIZE(const struct btrfs_fs_info *info)
1365 {
1366 	return BTRFS_MAX_ITEM_SIZE(info) -
1367 	       BTRFS_FILE_EXTENT_INLINE_DATA_START;
1368 }
1369 
1370 static inline u32 BTRFS_MAX_XATTR_SIZE(const struct btrfs_fs_info *info)
1371 {
1372 	return BTRFS_MAX_ITEM_SIZE(info) - sizeof(struct btrfs_dir_item);
1373 }
1374 
1375 /*
1376  * Flags for mount options.
1377  *
1378  * Note: don't forget to add new options to btrfs_show_options()
1379  */
1380 #define BTRFS_MOUNT_NODATASUM		(1 << 0)
1381 #define BTRFS_MOUNT_NODATACOW		(1 << 1)
1382 #define BTRFS_MOUNT_NOBARRIER		(1 << 2)
1383 #define BTRFS_MOUNT_SSD			(1 << 3)
1384 #define BTRFS_MOUNT_DEGRADED		(1 << 4)
1385 #define BTRFS_MOUNT_COMPRESS		(1 << 5)
1386 #define BTRFS_MOUNT_NOTREELOG           (1 << 6)
1387 #define BTRFS_MOUNT_FLUSHONCOMMIT       (1 << 7)
1388 #define BTRFS_MOUNT_SSD_SPREAD		(1 << 8)
1389 #define BTRFS_MOUNT_NOSSD		(1 << 9)
1390 #define BTRFS_MOUNT_DISCARD		(1 << 10)
1391 #define BTRFS_MOUNT_FORCE_COMPRESS      (1 << 11)
1392 #define BTRFS_MOUNT_SPACE_CACHE		(1 << 12)
1393 #define BTRFS_MOUNT_CLEAR_CACHE		(1 << 13)
1394 #define BTRFS_MOUNT_USER_SUBVOL_RM_ALLOWED (1 << 14)
1395 #define BTRFS_MOUNT_ENOSPC_DEBUG	 (1 << 15)
1396 #define BTRFS_MOUNT_AUTO_DEFRAG		(1 << 16)
1397 #define BTRFS_MOUNT_INODE_MAP_CACHE	(1 << 17)
1398 #define BTRFS_MOUNT_USEBACKUPROOT	(1 << 18)
1399 #define BTRFS_MOUNT_SKIP_BALANCE	(1 << 19)
1400 #define BTRFS_MOUNT_CHECK_INTEGRITY	(1 << 20)
1401 #define BTRFS_MOUNT_CHECK_INTEGRITY_INCLUDING_EXTENT_DATA (1 << 21)
1402 #define BTRFS_MOUNT_PANIC_ON_FATAL_ERROR	(1 << 22)
1403 #define BTRFS_MOUNT_RESCAN_UUID_TREE	(1 << 23)
1404 #define BTRFS_MOUNT_FRAGMENT_DATA	(1 << 24)
1405 #define BTRFS_MOUNT_FRAGMENT_METADATA	(1 << 25)
1406 #define BTRFS_MOUNT_FREE_SPACE_TREE	(1 << 26)
1407 #define BTRFS_MOUNT_NOLOGREPLAY		(1 << 27)
1408 #define BTRFS_MOUNT_REF_VERIFY		(1 << 28)
1409 
1410 #define BTRFS_DEFAULT_COMMIT_INTERVAL	(30)
1411 #define BTRFS_DEFAULT_MAX_INLINE	(2048)
1412 
1413 #define btrfs_clear_opt(o, opt)		((o) &= ~BTRFS_MOUNT_##opt)
1414 #define btrfs_set_opt(o, opt)		((o) |= BTRFS_MOUNT_##opt)
1415 #define btrfs_raw_test_opt(o, opt)	((o) & BTRFS_MOUNT_##opt)
1416 #define btrfs_test_opt(fs_info, opt)	((fs_info)->mount_opt & \
1417 					 BTRFS_MOUNT_##opt)
1418 
1419 #define btrfs_set_and_info(fs_info, opt, fmt, args...)			\
1420 {									\
1421 	if (!btrfs_test_opt(fs_info, opt))				\
1422 		btrfs_info(fs_info, fmt, ##args);			\
1423 	btrfs_set_opt(fs_info->mount_opt, opt);				\
1424 }
1425 
1426 #define btrfs_clear_and_info(fs_info, opt, fmt, args...)		\
1427 {									\
1428 	if (btrfs_test_opt(fs_info, opt))				\
1429 		btrfs_info(fs_info, fmt, ##args);			\
1430 	btrfs_clear_opt(fs_info->mount_opt, opt);			\
1431 }
1432 
1433 #ifdef CONFIG_BTRFS_DEBUG
1434 static inline int
1435 btrfs_should_fragment_free_space(struct btrfs_block_group_cache *block_group)
1436 {
1437 	struct btrfs_fs_info *fs_info = block_group->fs_info;
1438 
1439 	return (btrfs_test_opt(fs_info, FRAGMENT_METADATA) &&
1440 		block_group->flags & BTRFS_BLOCK_GROUP_METADATA) ||
1441 	       (btrfs_test_opt(fs_info, FRAGMENT_DATA) &&
1442 		block_group->flags &  BTRFS_BLOCK_GROUP_DATA);
1443 }
1444 #endif
1445 
1446 /*
1447  * Requests for changes that need to be done during transaction commit.
1448  *
1449  * Internal mount options that are used for special handling of the real
1450  * mount options (eg. cannot be set during remount and have to be set during
1451  * transaction commit)
1452  */
1453 
1454 #define BTRFS_PENDING_SET_INODE_MAP_CACHE	(0)
1455 #define BTRFS_PENDING_CLEAR_INODE_MAP_CACHE	(1)
1456 #define BTRFS_PENDING_COMMIT			(2)
1457 
1458 #define btrfs_test_pending(info, opt)	\
1459 	test_bit(BTRFS_PENDING_##opt, &(info)->pending_changes)
1460 #define btrfs_set_pending(info, opt)	\
1461 	set_bit(BTRFS_PENDING_##opt, &(info)->pending_changes)
1462 #define btrfs_clear_pending(info, opt)	\
1463 	clear_bit(BTRFS_PENDING_##opt, &(info)->pending_changes)
1464 
1465 /*
1466  * Helpers for setting pending mount option changes.
1467  *
1468  * Expects corresponding macros
1469  * BTRFS_PENDING_SET_ and CLEAR_ + short mount option name
1470  */
1471 #define btrfs_set_pending_and_info(info, opt, fmt, args...)            \
1472 do {                                                                   \
1473        if (!btrfs_raw_test_opt((info)->mount_opt, opt)) {              \
1474                btrfs_info((info), fmt, ##args);                        \
1475                btrfs_set_pending((info), SET_##opt);                   \
1476                btrfs_clear_pending((info), CLEAR_##opt);               \
1477        }                                                               \
1478 } while(0)
1479 
1480 #define btrfs_clear_pending_and_info(info, opt, fmt, args...)          \
1481 do {                                                                   \
1482        if (btrfs_raw_test_opt((info)->mount_opt, opt)) {               \
1483                btrfs_info((info), fmt, ##args);                        \
1484                btrfs_set_pending((info), CLEAR_##opt);                 \
1485                btrfs_clear_pending((info), SET_##opt);                 \
1486        }                                                               \
1487 } while(0)
1488 
1489 /*
1490  * Inode flags
1491  */
1492 #define BTRFS_INODE_NODATASUM		(1 << 0)
1493 #define BTRFS_INODE_NODATACOW		(1 << 1)
1494 #define BTRFS_INODE_READONLY		(1 << 2)
1495 #define BTRFS_INODE_NOCOMPRESS		(1 << 3)
1496 #define BTRFS_INODE_PREALLOC		(1 << 4)
1497 #define BTRFS_INODE_SYNC		(1 << 5)
1498 #define BTRFS_INODE_IMMUTABLE		(1 << 6)
1499 #define BTRFS_INODE_APPEND		(1 << 7)
1500 #define BTRFS_INODE_NODUMP		(1 << 8)
1501 #define BTRFS_INODE_NOATIME		(1 << 9)
1502 #define BTRFS_INODE_DIRSYNC		(1 << 10)
1503 #define BTRFS_INODE_COMPRESS		(1 << 11)
1504 
1505 #define BTRFS_INODE_ROOT_ITEM_INIT	(1 << 31)
1506 
1507 struct btrfs_map_token {
1508 	const struct extent_buffer *eb;
1509 	char *kaddr;
1510 	unsigned long offset;
1511 };
1512 
1513 #define BTRFS_BYTES_TO_BLKS(fs_info, bytes) \
1514 				((bytes) >> (fs_info)->sb->s_blocksize_bits)
1515 
1516 static inline void btrfs_init_map_token (struct btrfs_map_token *token)
1517 {
1518 	token->kaddr = NULL;
1519 }
1520 
1521 /* some macros to generate set/get functions for the struct fields.  This
1522  * assumes there is a lefoo_to_cpu for every type, so lets make a simple
1523  * one for u8:
1524  */
1525 #define le8_to_cpu(v) (v)
1526 #define cpu_to_le8(v) (v)
1527 #define __le8 u8
1528 
1529 #define read_eb_member(eb, ptr, type, member, result) (\
1530 	read_extent_buffer(eb, (char *)(result),			\
1531 			   ((unsigned long)(ptr)) +			\
1532 			    offsetof(type, member),			\
1533 			   sizeof(((type *)0)->member)))
1534 
1535 #define write_eb_member(eb, ptr, type, member, result) (\
1536 	write_extent_buffer(eb, (char *)(result),			\
1537 			   ((unsigned long)(ptr)) +			\
1538 			    offsetof(type, member),			\
1539 			   sizeof(((type *)0)->member)))
1540 
1541 #define DECLARE_BTRFS_SETGET_BITS(bits)					\
1542 u##bits btrfs_get_token_##bits(const struct extent_buffer *eb,		\
1543 			       const void *ptr, unsigned long off,	\
1544 			       struct btrfs_map_token *token);		\
1545 void btrfs_set_token_##bits(struct extent_buffer *eb, const void *ptr,	\
1546 			    unsigned long off, u##bits val,		\
1547 			    struct btrfs_map_token *token);		\
1548 static inline u##bits btrfs_get_##bits(const struct extent_buffer *eb,	\
1549 				       const void *ptr,			\
1550 				       unsigned long off)		\
1551 {									\
1552 	return btrfs_get_token_##bits(eb, ptr, off, NULL);		\
1553 }									\
1554 static inline void btrfs_set_##bits(struct extent_buffer *eb, void *ptr,\
1555 				    unsigned long off, u##bits val)	\
1556 {									\
1557        btrfs_set_token_##bits(eb, ptr, off, val, NULL);			\
1558 }
1559 
1560 DECLARE_BTRFS_SETGET_BITS(8)
1561 DECLARE_BTRFS_SETGET_BITS(16)
1562 DECLARE_BTRFS_SETGET_BITS(32)
1563 DECLARE_BTRFS_SETGET_BITS(64)
1564 
1565 #define BTRFS_SETGET_FUNCS(name, type, member, bits)			\
1566 static inline u##bits btrfs_##name(const struct extent_buffer *eb,	\
1567 				   const type *s)			\
1568 {									\
1569 	BUILD_BUG_ON(sizeof(u##bits) != sizeof(((type *)0))->member);	\
1570 	return btrfs_get_##bits(eb, s, offsetof(type, member));		\
1571 }									\
1572 static inline void btrfs_set_##name(struct extent_buffer *eb, type *s,	\
1573 				    u##bits val)			\
1574 {									\
1575 	BUILD_BUG_ON(sizeof(u##bits) != sizeof(((type *)0))->member);	\
1576 	btrfs_set_##bits(eb, s, offsetof(type, member), val);		\
1577 }									\
1578 static inline u##bits btrfs_token_##name(const struct extent_buffer *eb,\
1579 					 const type *s,			\
1580 					 struct btrfs_map_token *token)	\
1581 {									\
1582 	BUILD_BUG_ON(sizeof(u##bits) != sizeof(((type *)0))->member);	\
1583 	return btrfs_get_token_##bits(eb, s, offsetof(type, member), token); \
1584 }									\
1585 static inline void btrfs_set_token_##name(struct extent_buffer *eb,	\
1586 					  type *s, u##bits val,		\
1587                                          struct btrfs_map_token *token)	\
1588 {									\
1589 	BUILD_BUG_ON(sizeof(u##bits) != sizeof(((type *)0))->member);	\
1590 	btrfs_set_token_##bits(eb, s, offsetof(type, member), val, token); \
1591 }
1592 
1593 #define BTRFS_SETGET_HEADER_FUNCS(name, type, member, bits)		\
1594 static inline u##bits btrfs_##name(const struct extent_buffer *eb)	\
1595 {									\
1596 	const type *p = page_address(eb->pages[0]);			\
1597 	u##bits res = le##bits##_to_cpu(p->member);			\
1598 	return res;							\
1599 }									\
1600 static inline void btrfs_set_##name(struct extent_buffer *eb,		\
1601 				    u##bits val)			\
1602 {									\
1603 	type *p = page_address(eb->pages[0]);				\
1604 	p->member = cpu_to_le##bits(val);				\
1605 }
1606 
1607 #define BTRFS_SETGET_STACK_FUNCS(name, type, member, bits)		\
1608 static inline u##bits btrfs_##name(const type *s)			\
1609 {									\
1610 	return le##bits##_to_cpu(s->member);				\
1611 }									\
1612 static inline void btrfs_set_##name(type *s, u##bits val)		\
1613 {									\
1614 	s->member = cpu_to_le##bits(val);				\
1615 }
1616 
1617 
1618 static inline u64 btrfs_device_total_bytes(struct extent_buffer *eb,
1619 					   struct btrfs_dev_item *s)
1620 {
1621 	BUILD_BUG_ON(sizeof(u64) !=
1622 		     sizeof(((struct btrfs_dev_item *)0))->total_bytes);
1623 	return btrfs_get_64(eb, s, offsetof(struct btrfs_dev_item,
1624 					    total_bytes));
1625 }
1626 static inline void btrfs_set_device_total_bytes(struct extent_buffer *eb,
1627 						struct btrfs_dev_item *s,
1628 						u64 val)
1629 {
1630 	BUILD_BUG_ON(sizeof(u64) !=
1631 		     sizeof(((struct btrfs_dev_item *)0))->total_bytes);
1632 	WARN_ON(!IS_ALIGNED(val, eb->fs_info->sectorsize));
1633 	btrfs_set_64(eb, s, offsetof(struct btrfs_dev_item, total_bytes), val);
1634 }
1635 
1636 
1637 BTRFS_SETGET_FUNCS(device_type, struct btrfs_dev_item, type, 64);
1638 BTRFS_SETGET_FUNCS(device_bytes_used, struct btrfs_dev_item, bytes_used, 64);
1639 BTRFS_SETGET_FUNCS(device_io_align, struct btrfs_dev_item, io_align, 32);
1640 BTRFS_SETGET_FUNCS(device_io_width, struct btrfs_dev_item, io_width, 32);
1641 BTRFS_SETGET_FUNCS(device_start_offset, struct btrfs_dev_item,
1642 		   start_offset, 64);
1643 BTRFS_SETGET_FUNCS(device_sector_size, struct btrfs_dev_item, sector_size, 32);
1644 BTRFS_SETGET_FUNCS(device_id, struct btrfs_dev_item, devid, 64);
1645 BTRFS_SETGET_FUNCS(device_group, struct btrfs_dev_item, dev_group, 32);
1646 BTRFS_SETGET_FUNCS(device_seek_speed, struct btrfs_dev_item, seek_speed, 8);
1647 BTRFS_SETGET_FUNCS(device_bandwidth, struct btrfs_dev_item, bandwidth, 8);
1648 BTRFS_SETGET_FUNCS(device_generation, struct btrfs_dev_item, generation, 64);
1649 
1650 BTRFS_SETGET_STACK_FUNCS(stack_device_type, struct btrfs_dev_item, type, 64);
1651 BTRFS_SETGET_STACK_FUNCS(stack_device_total_bytes, struct btrfs_dev_item,
1652 			 total_bytes, 64);
1653 BTRFS_SETGET_STACK_FUNCS(stack_device_bytes_used, struct btrfs_dev_item,
1654 			 bytes_used, 64);
1655 BTRFS_SETGET_STACK_FUNCS(stack_device_io_align, struct btrfs_dev_item,
1656 			 io_align, 32);
1657 BTRFS_SETGET_STACK_FUNCS(stack_device_io_width, struct btrfs_dev_item,
1658 			 io_width, 32);
1659 BTRFS_SETGET_STACK_FUNCS(stack_device_sector_size, struct btrfs_dev_item,
1660 			 sector_size, 32);
1661 BTRFS_SETGET_STACK_FUNCS(stack_device_id, struct btrfs_dev_item, devid, 64);
1662 BTRFS_SETGET_STACK_FUNCS(stack_device_group, struct btrfs_dev_item,
1663 			 dev_group, 32);
1664 BTRFS_SETGET_STACK_FUNCS(stack_device_seek_speed, struct btrfs_dev_item,
1665 			 seek_speed, 8);
1666 BTRFS_SETGET_STACK_FUNCS(stack_device_bandwidth, struct btrfs_dev_item,
1667 			 bandwidth, 8);
1668 BTRFS_SETGET_STACK_FUNCS(stack_device_generation, struct btrfs_dev_item,
1669 			 generation, 64);
1670 
1671 static inline unsigned long btrfs_device_uuid(struct btrfs_dev_item *d)
1672 {
1673 	return (unsigned long)d + offsetof(struct btrfs_dev_item, uuid);
1674 }
1675 
1676 static inline unsigned long btrfs_device_fsid(struct btrfs_dev_item *d)
1677 {
1678 	return (unsigned long)d + offsetof(struct btrfs_dev_item, fsid);
1679 }
1680 
1681 BTRFS_SETGET_FUNCS(chunk_length, struct btrfs_chunk, length, 64);
1682 BTRFS_SETGET_FUNCS(chunk_owner, struct btrfs_chunk, owner, 64);
1683 BTRFS_SETGET_FUNCS(chunk_stripe_len, struct btrfs_chunk, stripe_len, 64);
1684 BTRFS_SETGET_FUNCS(chunk_io_align, struct btrfs_chunk, io_align, 32);
1685 BTRFS_SETGET_FUNCS(chunk_io_width, struct btrfs_chunk, io_width, 32);
1686 BTRFS_SETGET_FUNCS(chunk_sector_size, struct btrfs_chunk, sector_size, 32);
1687 BTRFS_SETGET_FUNCS(chunk_type, struct btrfs_chunk, type, 64);
1688 BTRFS_SETGET_FUNCS(chunk_num_stripes, struct btrfs_chunk, num_stripes, 16);
1689 BTRFS_SETGET_FUNCS(chunk_sub_stripes, struct btrfs_chunk, sub_stripes, 16);
1690 BTRFS_SETGET_FUNCS(stripe_devid, struct btrfs_stripe, devid, 64);
1691 BTRFS_SETGET_FUNCS(stripe_offset, struct btrfs_stripe, offset, 64);
1692 
1693 static inline char *btrfs_stripe_dev_uuid(struct btrfs_stripe *s)
1694 {
1695 	return (char *)s + offsetof(struct btrfs_stripe, dev_uuid);
1696 }
1697 
1698 BTRFS_SETGET_STACK_FUNCS(stack_chunk_length, struct btrfs_chunk, length, 64);
1699 BTRFS_SETGET_STACK_FUNCS(stack_chunk_owner, struct btrfs_chunk, owner, 64);
1700 BTRFS_SETGET_STACK_FUNCS(stack_chunk_stripe_len, struct btrfs_chunk,
1701 			 stripe_len, 64);
1702 BTRFS_SETGET_STACK_FUNCS(stack_chunk_io_align, struct btrfs_chunk,
1703 			 io_align, 32);
1704 BTRFS_SETGET_STACK_FUNCS(stack_chunk_io_width, struct btrfs_chunk,
1705 			 io_width, 32);
1706 BTRFS_SETGET_STACK_FUNCS(stack_chunk_sector_size, struct btrfs_chunk,
1707 			 sector_size, 32);
1708 BTRFS_SETGET_STACK_FUNCS(stack_chunk_type, struct btrfs_chunk, type, 64);
1709 BTRFS_SETGET_STACK_FUNCS(stack_chunk_num_stripes, struct btrfs_chunk,
1710 			 num_stripes, 16);
1711 BTRFS_SETGET_STACK_FUNCS(stack_chunk_sub_stripes, struct btrfs_chunk,
1712 			 sub_stripes, 16);
1713 BTRFS_SETGET_STACK_FUNCS(stack_stripe_devid, struct btrfs_stripe, devid, 64);
1714 BTRFS_SETGET_STACK_FUNCS(stack_stripe_offset, struct btrfs_stripe, offset, 64);
1715 
1716 static inline struct btrfs_stripe *btrfs_stripe_nr(struct btrfs_chunk *c,
1717 						   int nr)
1718 {
1719 	unsigned long offset = (unsigned long)c;
1720 	offset += offsetof(struct btrfs_chunk, stripe);
1721 	offset += nr * sizeof(struct btrfs_stripe);
1722 	return (struct btrfs_stripe *)offset;
1723 }
1724 
1725 static inline char *btrfs_stripe_dev_uuid_nr(struct btrfs_chunk *c, int nr)
1726 {
1727 	return btrfs_stripe_dev_uuid(btrfs_stripe_nr(c, nr));
1728 }
1729 
1730 static inline u64 btrfs_stripe_offset_nr(struct extent_buffer *eb,
1731 					 struct btrfs_chunk *c, int nr)
1732 {
1733 	return btrfs_stripe_offset(eb, btrfs_stripe_nr(c, nr));
1734 }
1735 
1736 static inline u64 btrfs_stripe_devid_nr(struct extent_buffer *eb,
1737 					 struct btrfs_chunk *c, int nr)
1738 {
1739 	return btrfs_stripe_devid(eb, btrfs_stripe_nr(c, nr));
1740 }
1741 
1742 /* struct btrfs_block_group_item */
1743 BTRFS_SETGET_STACK_FUNCS(block_group_used, struct btrfs_block_group_item,
1744 			 used, 64);
1745 BTRFS_SETGET_FUNCS(disk_block_group_used, struct btrfs_block_group_item,
1746 			 used, 64);
1747 BTRFS_SETGET_STACK_FUNCS(block_group_chunk_objectid,
1748 			struct btrfs_block_group_item, chunk_objectid, 64);
1749 
1750 BTRFS_SETGET_FUNCS(disk_block_group_chunk_objectid,
1751 		   struct btrfs_block_group_item, chunk_objectid, 64);
1752 BTRFS_SETGET_FUNCS(disk_block_group_flags,
1753 		   struct btrfs_block_group_item, flags, 64);
1754 BTRFS_SETGET_STACK_FUNCS(block_group_flags,
1755 			struct btrfs_block_group_item, flags, 64);
1756 
1757 /* struct btrfs_free_space_info */
1758 BTRFS_SETGET_FUNCS(free_space_extent_count, struct btrfs_free_space_info,
1759 		   extent_count, 32);
1760 BTRFS_SETGET_FUNCS(free_space_flags, struct btrfs_free_space_info, flags, 32);
1761 
1762 /* struct btrfs_inode_ref */
1763 BTRFS_SETGET_FUNCS(inode_ref_name_len, struct btrfs_inode_ref, name_len, 16);
1764 BTRFS_SETGET_FUNCS(inode_ref_index, struct btrfs_inode_ref, index, 64);
1765 
1766 /* struct btrfs_inode_extref */
1767 BTRFS_SETGET_FUNCS(inode_extref_parent, struct btrfs_inode_extref,
1768 		   parent_objectid, 64);
1769 BTRFS_SETGET_FUNCS(inode_extref_name_len, struct btrfs_inode_extref,
1770 		   name_len, 16);
1771 BTRFS_SETGET_FUNCS(inode_extref_index, struct btrfs_inode_extref, index, 64);
1772 
1773 /* struct btrfs_inode_item */
1774 BTRFS_SETGET_FUNCS(inode_generation, struct btrfs_inode_item, generation, 64);
1775 BTRFS_SETGET_FUNCS(inode_sequence, struct btrfs_inode_item, sequence, 64);
1776 BTRFS_SETGET_FUNCS(inode_transid, struct btrfs_inode_item, transid, 64);
1777 BTRFS_SETGET_FUNCS(inode_size, struct btrfs_inode_item, size, 64);
1778 BTRFS_SETGET_FUNCS(inode_nbytes, struct btrfs_inode_item, nbytes, 64);
1779 BTRFS_SETGET_FUNCS(inode_block_group, struct btrfs_inode_item, block_group, 64);
1780 BTRFS_SETGET_FUNCS(inode_nlink, struct btrfs_inode_item, nlink, 32);
1781 BTRFS_SETGET_FUNCS(inode_uid, struct btrfs_inode_item, uid, 32);
1782 BTRFS_SETGET_FUNCS(inode_gid, struct btrfs_inode_item, gid, 32);
1783 BTRFS_SETGET_FUNCS(inode_mode, struct btrfs_inode_item, mode, 32);
1784 BTRFS_SETGET_FUNCS(inode_rdev, struct btrfs_inode_item, rdev, 64);
1785 BTRFS_SETGET_FUNCS(inode_flags, struct btrfs_inode_item, flags, 64);
1786 BTRFS_SETGET_STACK_FUNCS(stack_inode_generation, struct btrfs_inode_item,
1787 			 generation, 64);
1788 BTRFS_SETGET_STACK_FUNCS(stack_inode_sequence, struct btrfs_inode_item,
1789 			 sequence, 64);
1790 BTRFS_SETGET_STACK_FUNCS(stack_inode_transid, struct btrfs_inode_item,
1791 			 transid, 64);
1792 BTRFS_SETGET_STACK_FUNCS(stack_inode_size, struct btrfs_inode_item, size, 64);
1793 BTRFS_SETGET_STACK_FUNCS(stack_inode_nbytes, struct btrfs_inode_item,
1794 			 nbytes, 64);
1795 BTRFS_SETGET_STACK_FUNCS(stack_inode_block_group, struct btrfs_inode_item,
1796 			 block_group, 64);
1797 BTRFS_SETGET_STACK_FUNCS(stack_inode_nlink, struct btrfs_inode_item, nlink, 32);
1798 BTRFS_SETGET_STACK_FUNCS(stack_inode_uid, struct btrfs_inode_item, uid, 32);
1799 BTRFS_SETGET_STACK_FUNCS(stack_inode_gid, struct btrfs_inode_item, gid, 32);
1800 BTRFS_SETGET_STACK_FUNCS(stack_inode_mode, struct btrfs_inode_item, mode, 32);
1801 BTRFS_SETGET_STACK_FUNCS(stack_inode_rdev, struct btrfs_inode_item, rdev, 64);
1802 BTRFS_SETGET_STACK_FUNCS(stack_inode_flags, struct btrfs_inode_item, flags, 64);
1803 BTRFS_SETGET_FUNCS(timespec_sec, struct btrfs_timespec, sec, 64);
1804 BTRFS_SETGET_FUNCS(timespec_nsec, struct btrfs_timespec, nsec, 32);
1805 BTRFS_SETGET_STACK_FUNCS(stack_timespec_sec, struct btrfs_timespec, sec, 64);
1806 BTRFS_SETGET_STACK_FUNCS(stack_timespec_nsec, struct btrfs_timespec, nsec, 32);
1807 
1808 /* struct btrfs_dev_extent */
1809 BTRFS_SETGET_FUNCS(dev_extent_chunk_tree, struct btrfs_dev_extent,
1810 		   chunk_tree, 64);
1811 BTRFS_SETGET_FUNCS(dev_extent_chunk_objectid, struct btrfs_dev_extent,
1812 		   chunk_objectid, 64);
1813 BTRFS_SETGET_FUNCS(dev_extent_chunk_offset, struct btrfs_dev_extent,
1814 		   chunk_offset, 64);
1815 BTRFS_SETGET_FUNCS(dev_extent_length, struct btrfs_dev_extent, length, 64);
1816 
1817 static inline unsigned long btrfs_dev_extent_chunk_tree_uuid(struct btrfs_dev_extent *dev)
1818 {
1819 	unsigned long ptr = offsetof(struct btrfs_dev_extent, chunk_tree_uuid);
1820 	return (unsigned long)dev + ptr;
1821 }
1822 
1823 BTRFS_SETGET_FUNCS(extent_refs, struct btrfs_extent_item, refs, 64);
1824 BTRFS_SETGET_FUNCS(extent_generation, struct btrfs_extent_item,
1825 		   generation, 64);
1826 BTRFS_SETGET_FUNCS(extent_flags, struct btrfs_extent_item, flags, 64);
1827 
1828 BTRFS_SETGET_FUNCS(extent_refs_v0, struct btrfs_extent_item_v0, refs, 32);
1829 
1830 
1831 BTRFS_SETGET_FUNCS(tree_block_level, struct btrfs_tree_block_info, level, 8);
1832 
1833 static inline void btrfs_tree_block_key(struct extent_buffer *eb,
1834 					struct btrfs_tree_block_info *item,
1835 					struct btrfs_disk_key *key)
1836 {
1837 	read_eb_member(eb, item, struct btrfs_tree_block_info, key, key);
1838 }
1839 
1840 static inline void btrfs_set_tree_block_key(struct extent_buffer *eb,
1841 					    struct btrfs_tree_block_info *item,
1842 					    struct btrfs_disk_key *key)
1843 {
1844 	write_eb_member(eb, item, struct btrfs_tree_block_info, key, key);
1845 }
1846 
1847 BTRFS_SETGET_FUNCS(extent_data_ref_root, struct btrfs_extent_data_ref,
1848 		   root, 64);
1849 BTRFS_SETGET_FUNCS(extent_data_ref_objectid, struct btrfs_extent_data_ref,
1850 		   objectid, 64);
1851 BTRFS_SETGET_FUNCS(extent_data_ref_offset, struct btrfs_extent_data_ref,
1852 		   offset, 64);
1853 BTRFS_SETGET_FUNCS(extent_data_ref_count, struct btrfs_extent_data_ref,
1854 		   count, 32);
1855 
1856 BTRFS_SETGET_FUNCS(shared_data_ref_count, struct btrfs_shared_data_ref,
1857 		   count, 32);
1858 
1859 BTRFS_SETGET_FUNCS(extent_inline_ref_type, struct btrfs_extent_inline_ref,
1860 		   type, 8);
1861 BTRFS_SETGET_FUNCS(extent_inline_ref_offset, struct btrfs_extent_inline_ref,
1862 		   offset, 64);
1863 
1864 static inline u32 btrfs_extent_inline_ref_size(int type)
1865 {
1866 	if (type == BTRFS_TREE_BLOCK_REF_KEY ||
1867 	    type == BTRFS_SHARED_BLOCK_REF_KEY)
1868 		return sizeof(struct btrfs_extent_inline_ref);
1869 	if (type == BTRFS_SHARED_DATA_REF_KEY)
1870 		return sizeof(struct btrfs_shared_data_ref) +
1871 		       sizeof(struct btrfs_extent_inline_ref);
1872 	if (type == BTRFS_EXTENT_DATA_REF_KEY)
1873 		return sizeof(struct btrfs_extent_data_ref) +
1874 		       offsetof(struct btrfs_extent_inline_ref, offset);
1875 	return 0;
1876 }
1877 
1878 BTRFS_SETGET_FUNCS(ref_root_v0, struct btrfs_extent_ref_v0, root, 64);
1879 BTRFS_SETGET_FUNCS(ref_generation_v0, struct btrfs_extent_ref_v0,
1880 		   generation, 64);
1881 BTRFS_SETGET_FUNCS(ref_objectid_v0, struct btrfs_extent_ref_v0, objectid, 64);
1882 BTRFS_SETGET_FUNCS(ref_count_v0, struct btrfs_extent_ref_v0, count, 32);
1883 
1884 /* struct btrfs_node */
1885 BTRFS_SETGET_FUNCS(key_blockptr, struct btrfs_key_ptr, blockptr, 64);
1886 BTRFS_SETGET_FUNCS(key_generation, struct btrfs_key_ptr, generation, 64);
1887 BTRFS_SETGET_STACK_FUNCS(stack_key_blockptr, struct btrfs_key_ptr,
1888 			 blockptr, 64);
1889 BTRFS_SETGET_STACK_FUNCS(stack_key_generation, struct btrfs_key_ptr,
1890 			 generation, 64);
1891 
1892 static inline u64 btrfs_node_blockptr(struct extent_buffer *eb, int nr)
1893 {
1894 	unsigned long ptr;
1895 	ptr = offsetof(struct btrfs_node, ptrs) +
1896 		sizeof(struct btrfs_key_ptr) * nr;
1897 	return btrfs_key_blockptr(eb, (struct btrfs_key_ptr *)ptr);
1898 }
1899 
1900 static inline void btrfs_set_node_blockptr(struct extent_buffer *eb,
1901 					   int nr, u64 val)
1902 {
1903 	unsigned long ptr;
1904 	ptr = offsetof(struct btrfs_node, ptrs) +
1905 		sizeof(struct btrfs_key_ptr) * nr;
1906 	btrfs_set_key_blockptr(eb, (struct btrfs_key_ptr *)ptr, val);
1907 }
1908 
1909 static inline u64 btrfs_node_ptr_generation(struct extent_buffer *eb, int nr)
1910 {
1911 	unsigned long ptr;
1912 	ptr = offsetof(struct btrfs_node, ptrs) +
1913 		sizeof(struct btrfs_key_ptr) * nr;
1914 	return btrfs_key_generation(eb, (struct btrfs_key_ptr *)ptr);
1915 }
1916 
1917 static inline void btrfs_set_node_ptr_generation(struct extent_buffer *eb,
1918 						 int nr, u64 val)
1919 {
1920 	unsigned long ptr;
1921 	ptr = offsetof(struct btrfs_node, ptrs) +
1922 		sizeof(struct btrfs_key_ptr) * nr;
1923 	btrfs_set_key_generation(eb, (struct btrfs_key_ptr *)ptr, val);
1924 }
1925 
1926 static inline unsigned long btrfs_node_key_ptr_offset(int nr)
1927 {
1928 	return offsetof(struct btrfs_node, ptrs) +
1929 		sizeof(struct btrfs_key_ptr) * nr;
1930 }
1931 
1932 void btrfs_node_key(const struct extent_buffer *eb,
1933 		    struct btrfs_disk_key *disk_key, int nr);
1934 
1935 static inline void btrfs_set_node_key(struct extent_buffer *eb,
1936 				      struct btrfs_disk_key *disk_key, int nr)
1937 {
1938 	unsigned long ptr;
1939 	ptr = btrfs_node_key_ptr_offset(nr);
1940 	write_eb_member(eb, (struct btrfs_key_ptr *)ptr,
1941 		       struct btrfs_key_ptr, key, disk_key);
1942 }
1943 
1944 /* struct btrfs_item */
1945 BTRFS_SETGET_FUNCS(item_offset, struct btrfs_item, offset, 32);
1946 BTRFS_SETGET_FUNCS(item_size, struct btrfs_item, size, 32);
1947 BTRFS_SETGET_STACK_FUNCS(stack_item_offset, struct btrfs_item, offset, 32);
1948 BTRFS_SETGET_STACK_FUNCS(stack_item_size, struct btrfs_item, size, 32);
1949 
1950 static inline unsigned long btrfs_item_nr_offset(int nr)
1951 {
1952 	return offsetof(struct btrfs_leaf, items) +
1953 		sizeof(struct btrfs_item) * nr;
1954 }
1955 
1956 static inline struct btrfs_item *btrfs_item_nr(int nr)
1957 {
1958 	return (struct btrfs_item *)btrfs_item_nr_offset(nr);
1959 }
1960 
1961 static inline u32 btrfs_item_end(const struct extent_buffer *eb,
1962 				 struct btrfs_item *item)
1963 {
1964 	return btrfs_item_offset(eb, item) + btrfs_item_size(eb, item);
1965 }
1966 
1967 static inline u32 btrfs_item_end_nr(const struct extent_buffer *eb, int nr)
1968 {
1969 	return btrfs_item_end(eb, btrfs_item_nr(nr));
1970 }
1971 
1972 static inline u32 btrfs_item_offset_nr(const struct extent_buffer *eb, int nr)
1973 {
1974 	return btrfs_item_offset(eb, btrfs_item_nr(nr));
1975 }
1976 
1977 static inline u32 btrfs_item_size_nr(const struct extent_buffer *eb, int nr)
1978 {
1979 	return btrfs_item_size(eb, btrfs_item_nr(nr));
1980 }
1981 
1982 static inline void btrfs_item_key(const struct extent_buffer *eb,
1983 			   struct btrfs_disk_key *disk_key, int nr)
1984 {
1985 	struct btrfs_item *item = btrfs_item_nr(nr);
1986 	read_eb_member(eb, item, struct btrfs_item, key, disk_key);
1987 }
1988 
1989 static inline void btrfs_set_item_key(struct extent_buffer *eb,
1990 			       struct btrfs_disk_key *disk_key, int nr)
1991 {
1992 	struct btrfs_item *item = btrfs_item_nr(nr);
1993 	write_eb_member(eb, item, struct btrfs_item, key, disk_key);
1994 }
1995 
1996 BTRFS_SETGET_FUNCS(dir_log_end, struct btrfs_dir_log_item, end, 64);
1997 
1998 /*
1999  * struct btrfs_root_ref
2000  */
2001 BTRFS_SETGET_FUNCS(root_ref_dirid, struct btrfs_root_ref, dirid, 64);
2002 BTRFS_SETGET_FUNCS(root_ref_sequence, struct btrfs_root_ref, sequence, 64);
2003 BTRFS_SETGET_FUNCS(root_ref_name_len, struct btrfs_root_ref, name_len, 16);
2004 
2005 /* struct btrfs_dir_item */
2006 BTRFS_SETGET_FUNCS(dir_data_len, struct btrfs_dir_item, data_len, 16);
2007 BTRFS_SETGET_FUNCS(dir_type, struct btrfs_dir_item, type, 8);
2008 BTRFS_SETGET_FUNCS(dir_name_len, struct btrfs_dir_item, name_len, 16);
2009 BTRFS_SETGET_FUNCS(dir_transid, struct btrfs_dir_item, transid, 64);
2010 BTRFS_SETGET_STACK_FUNCS(stack_dir_type, struct btrfs_dir_item, type, 8);
2011 BTRFS_SETGET_STACK_FUNCS(stack_dir_data_len, struct btrfs_dir_item,
2012 			 data_len, 16);
2013 BTRFS_SETGET_STACK_FUNCS(stack_dir_name_len, struct btrfs_dir_item,
2014 			 name_len, 16);
2015 BTRFS_SETGET_STACK_FUNCS(stack_dir_transid, struct btrfs_dir_item,
2016 			 transid, 64);
2017 
2018 static inline void btrfs_dir_item_key(const struct extent_buffer *eb,
2019 				      const struct btrfs_dir_item *item,
2020 				      struct btrfs_disk_key *key)
2021 {
2022 	read_eb_member(eb, item, struct btrfs_dir_item, location, key);
2023 }
2024 
2025 static inline void btrfs_set_dir_item_key(struct extent_buffer *eb,
2026 					  struct btrfs_dir_item *item,
2027 					  const struct btrfs_disk_key *key)
2028 {
2029 	write_eb_member(eb, item, struct btrfs_dir_item, location, key);
2030 }
2031 
2032 BTRFS_SETGET_FUNCS(free_space_entries, struct btrfs_free_space_header,
2033 		   num_entries, 64);
2034 BTRFS_SETGET_FUNCS(free_space_bitmaps, struct btrfs_free_space_header,
2035 		   num_bitmaps, 64);
2036 BTRFS_SETGET_FUNCS(free_space_generation, struct btrfs_free_space_header,
2037 		   generation, 64);
2038 
2039 static inline void btrfs_free_space_key(const struct extent_buffer *eb,
2040 					const struct btrfs_free_space_header *h,
2041 					struct btrfs_disk_key *key)
2042 {
2043 	read_eb_member(eb, h, struct btrfs_free_space_header, location, key);
2044 }
2045 
2046 static inline void btrfs_set_free_space_key(struct extent_buffer *eb,
2047 					    struct btrfs_free_space_header *h,
2048 					    const struct btrfs_disk_key *key)
2049 {
2050 	write_eb_member(eb, h, struct btrfs_free_space_header, location, key);
2051 }
2052 
2053 /* struct btrfs_disk_key */
2054 BTRFS_SETGET_STACK_FUNCS(disk_key_objectid, struct btrfs_disk_key,
2055 			 objectid, 64);
2056 BTRFS_SETGET_STACK_FUNCS(disk_key_offset, struct btrfs_disk_key, offset, 64);
2057 BTRFS_SETGET_STACK_FUNCS(disk_key_type, struct btrfs_disk_key, type, 8);
2058 
2059 static inline void btrfs_disk_key_to_cpu(struct btrfs_key *cpu,
2060 					 const struct btrfs_disk_key *disk)
2061 {
2062 	cpu->offset = le64_to_cpu(disk->offset);
2063 	cpu->type = disk->type;
2064 	cpu->objectid = le64_to_cpu(disk->objectid);
2065 }
2066 
2067 static inline void btrfs_cpu_key_to_disk(struct btrfs_disk_key *disk,
2068 					 const struct btrfs_key *cpu)
2069 {
2070 	disk->offset = cpu_to_le64(cpu->offset);
2071 	disk->type = cpu->type;
2072 	disk->objectid = cpu_to_le64(cpu->objectid);
2073 }
2074 
2075 static inline void btrfs_node_key_to_cpu(const struct extent_buffer *eb,
2076 					 struct btrfs_key *key, int nr)
2077 {
2078 	struct btrfs_disk_key disk_key;
2079 	btrfs_node_key(eb, &disk_key, nr);
2080 	btrfs_disk_key_to_cpu(key, &disk_key);
2081 }
2082 
2083 static inline void btrfs_item_key_to_cpu(const struct extent_buffer *eb,
2084 					 struct btrfs_key *key, int nr)
2085 {
2086 	struct btrfs_disk_key disk_key;
2087 	btrfs_item_key(eb, &disk_key, nr);
2088 	btrfs_disk_key_to_cpu(key, &disk_key);
2089 }
2090 
2091 static inline void btrfs_dir_item_key_to_cpu(const struct extent_buffer *eb,
2092 					     const struct btrfs_dir_item *item,
2093 					     struct btrfs_key *key)
2094 {
2095 	struct btrfs_disk_key disk_key;
2096 	btrfs_dir_item_key(eb, item, &disk_key);
2097 	btrfs_disk_key_to_cpu(key, &disk_key);
2098 }
2099 
2100 static inline u8 btrfs_key_type(const struct btrfs_key *key)
2101 {
2102 	return key->type;
2103 }
2104 
2105 static inline void btrfs_set_key_type(struct btrfs_key *key, u8 val)
2106 {
2107 	key->type = val;
2108 }
2109 
2110 /* struct btrfs_header */
2111 BTRFS_SETGET_HEADER_FUNCS(header_bytenr, struct btrfs_header, bytenr, 64);
2112 BTRFS_SETGET_HEADER_FUNCS(header_generation, struct btrfs_header,
2113 			  generation, 64);
2114 BTRFS_SETGET_HEADER_FUNCS(header_owner, struct btrfs_header, owner, 64);
2115 BTRFS_SETGET_HEADER_FUNCS(header_nritems, struct btrfs_header, nritems, 32);
2116 BTRFS_SETGET_HEADER_FUNCS(header_flags, struct btrfs_header, flags, 64);
2117 BTRFS_SETGET_HEADER_FUNCS(header_level, struct btrfs_header, level, 8);
2118 BTRFS_SETGET_STACK_FUNCS(stack_header_generation, struct btrfs_header,
2119 			 generation, 64);
2120 BTRFS_SETGET_STACK_FUNCS(stack_header_owner, struct btrfs_header, owner, 64);
2121 BTRFS_SETGET_STACK_FUNCS(stack_header_nritems, struct btrfs_header,
2122 			 nritems, 32);
2123 BTRFS_SETGET_STACK_FUNCS(stack_header_bytenr, struct btrfs_header, bytenr, 64);
2124 
2125 static inline int btrfs_header_flag(const struct extent_buffer *eb, u64 flag)
2126 {
2127 	return (btrfs_header_flags(eb) & flag) == flag;
2128 }
2129 
2130 static inline int btrfs_set_header_flag(struct extent_buffer *eb, u64 flag)
2131 {
2132 	u64 flags = btrfs_header_flags(eb);
2133 	btrfs_set_header_flags(eb, flags | flag);
2134 	return (flags & flag) == flag;
2135 }
2136 
2137 static inline int btrfs_clear_header_flag(struct extent_buffer *eb, u64 flag)
2138 {
2139 	u64 flags = btrfs_header_flags(eb);
2140 	btrfs_set_header_flags(eb, flags & ~flag);
2141 	return (flags & flag) == flag;
2142 }
2143 
2144 static inline int btrfs_header_backref_rev(const struct extent_buffer *eb)
2145 {
2146 	u64 flags = btrfs_header_flags(eb);
2147 	return flags >> BTRFS_BACKREF_REV_SHIFT;
2148 }
2149 
2150 static inline void btrfs_set_header_backref_rev(struct extent_buffer *eb,
2151 						int rev)
2152 {
2153 	u64 flags = btrfs_header_flags(eb);
2154 	flags &= ~BTRFS_BACKREF_REV_MASK;
2155 	flags |= (u64)rev << BTRFS_BACKREF_REV_SHIFT;
2156 	btrfs_set_header_flags(eb, flags);
2157 }
2158 
2159 static inline unsigned long btrfs_header_fsid(void)
2160 {
2161 	return offsetof(struct btrfs_header, fsid);
2162 }
2163 
2164 static inline unsigned long btrfs_header_chunk_tree_uuid(const struct extent_buffer *eb)
2165 {
2166 	return offsetof(struct btrfs_header, chunk_tree_uuid);
2167 }
2168 
2169 static inline int btrfs_is_leaf(const struct extent_buffer *eb)
2170 {
2171 	return btrfs_header_level(eb) == 0;
2172 }
2173 
2174 /* struct btrfs_root_item */
2175 BTRFS_SETGET_FUNCS(disk_root_generation, struct btrfs_root_item,
2176 		   generation, 64);
2177 BTRFS_SETGET_FUNCS(disk_root_refs, struct btrfs_root_item, refs, 32);
2178 BTRFS_SETGET_FUNCS(disk_root_bytenr, struct btrfs_root_item, bytenr, 64);
2179 BTRFS_SETGET_FUNCS(disk_root_level, struct btrfs_root_item, level, 8);
2180 
2181 BTRFS_SETGET_STACK_FUNCS(root_generation, struct btrfs_root_item,
2182 			 generation, 64);
2183 BTRFS_SETGET_STACK_FUNCS(root_bytenr, struct btrfs_root_item, bytenr, 64);
2184 BTRFS_SETGET_STACK_FUNCS(root_level, struct btrfs_root_item, level, 8);
2185 BTRFS_SETGET_STACK_FUNCS(root_dirid, struct btrfs_root_item, root_dirid, 64);
2186 BTRFS_SETGET_STACK_FUNCS(root_refs, struct btrfs_root_item, refs, 32);
2187 BTRFS_SETGET_STACK_FUNCS(root_flags, struct btrfs_root_item, flags, 64);
2188 BTRFS_SETGET_STACK_FUNCS(root_used, struct btrfs_root_item, bytes_used, 64);
2189 BTRFS_SETGET_STACK_FUNCS(root_limit, struct btrfs_root_item, byte_limit, 64);
2190 BTRFS_SETGET_STACK_FUNCS(root_last_snapshot, struct btrfs_root_item,
2191 			 last_snapshot, 64);
2192 BTRFS_SETGET_STACK_FUNCS(root_generation_v2, struct btrfs_root_item,
2193 			 generation_v2, 64);
2194 BTRFS_SETGET_STACK_FUNCS(root_ctransid, struct btrfs_root_item,
2195 			 ctransid, 64);
2196 BTRFS_SETGET_STACK_FUNCS(root_otransid, struct btrfs_root_item,
2197 			 otransid, 64);
2198 BTRFS_SETGET_STACK_FUNCS(root_stransid, struct btrfs_root_item,
2199 			 stransid, 64);
2200 BTRFS_SETGET_STACK_FUNCS(root_rtransid, struct btrfs_root_item,
2201 			 rtransid, 64);
2202 
2203 static inline bool btrfs_root_readonly(const struct btrfs_root *root)
2204 {
2205 	return (root->root_item.flags & cpu_to_le64(BTRFS_ROOT_SUBVOL_RDONLY)) != 0;
2206 }
2207 
2208 static inline bool btrfs_root_dead(const struct btrfs_root *root)
2209 {
2210 	return (root->root_item.flags & cpu_to_le64(BTRFS_ROOT_SUBVOL_DEAD)) != 0;
2211 }
2212 
2213 /* struct btrfs_root_backup */
2214 BTRFS_SETGET_STACK_FUNCS(backup_tree_root, struct btrfs_root_backup,
2215 		   tree_root, 64);
2216 BTRFS_SETGET_STACK_FUNCS(backup_tree_root_gen, struct btrfs_root_backup,
2217 		   tree_root_gen, 64);
2218 BTRFS_SETGET_STACK_FUNCS(backup_tree_root_level, struct btrfs_root_backup,
2219 		   tree_root_level, 8);
2220 
2221 BTRFS_SETGET_STACK_FUNCS(backup_chunk_root, struct btrfs_root_backup,
2222 		   chunk_root, 64);
2223 BTRFS_SETGET_STACK_FUNCS(backup_chunk_root_gen, struct btrfs_root_backup,
2224 		   chunk_root_gen, 64);
2225 BTRFS_SETGET_STACK_FUNCS(backup_chunk_root_level, struct btrfs_root_backup,
2226 		   chunk_root_level, 8);
2227 
2228 BTRFS_SETGET_STACK_FUNCS(backup_extent_root, struct btrfs_root_backup,
2229 		   extent_root, 64);
2230 BTRFS_SETGET_STACK_FUNCS(backup_extent_root_gen, struct btrfs_root_backup,
2231 		   extent_root_gen, 64);
2232 BTRFS_SETGET_STACK_FUNCS(backup_extent_root_level, struct btrfs_root_backup,
2233 		   extent_root_level, 8);
2234 
2235 BTRFS_SETGET_STACK_FUNCS(backup_fs_root, struct btrfs_root_backup,
2236 		   fs_root, 64);
2237 BTRFS_SETGET_STACK_FUNCS(backup_fs_root_gen, struct btrfs_root_backup,
2238 		   fs_root_gen, 64);
2239 BTRFS_SETGET_STACK_FUNCS(backup_fs_root_level, struct btrfs_root_backup,
2240 		   fs_root_level, 8);
2241 
2242 BTRFS_SETGET_STACK_FUNCS(backup_dev_root, struct btrfs_root_backup,
2243 		   dev_root, 64);
2244 BTRFS_SETGET_STACK_FUNCS(backup_dev_root_gen, struct btrfs_root_backup,
2245 		   dev_root_gen, 64);
2246 BTRFS_SETGET_STACK_FUNCS(backup_dev_root_level, struct btrfs_root_backup,
2247 		   dev_root_level, 8);
2248 
2249 BTRFS_SETGET_STACK_FUNCS(backup_csum_root, struct btrfs_root_backup,
2250 		   csum_root, 64);
2251 BTRFS_SETGET_STACK_FUNCS(backup_csum_root_gen, struct btrfs_root_backup,
2252 		   csum_root_gen, 64);
2253 BTRFS_SETGET_STACK_FUNCS(backup_csum_root_level, struct btrfs_root_backup,
2254 		   csum_root_level, 8);
2255 BTRFS_SETGET_STACK_FUNCS(backup_total_bytes, struct btrfs_root_backup,
2256 		   total_bytes, 64);
2257 BTRFS_SETGET_STACK_FUNCS(backup_bytes_used, struct btrfs_root_backup,
2258 		   bytes_used, 64);
2259 BTRFS_SETGET_STACK_FUNCS(backup_num_devices, struct btrfs_root_backup,
2260 		   num_devices, 64);
2261 
2262 /* struct btrfs_balance_item */
2263 BTRFS_SETGET_FUNCS(balance_flags, struct btrfs_balance_item, flags, 64);
2264 
2265 static inline void btrfs_balance_data(const struct extent_buffer *eb,
2266 				      const struct btrfs_balance_item *bi,
2267 				      struct btrfs_disk_balance_args *ba)
2268 {
2269 	read_eb_member(eb, bi, struct btrfs_balance_item, data, ba);
2270 }
2271 
2272 static inline void btrfs_set_balance_data(struct extent_buffer *eb,
2273 				  struct btrfs_balance_item *bi,
2274 				  const struct btrfs_disk_balance_args *ba)
2275 {
2276 	write_eb_member(eb, bi, struct btrfs_balance_item, data, ba);
2277 }
2278 
2279 static inline void btrfs_balance_meta(const struct extent_buffer *eb,
2280 				      const struct btrfs_balance_item *bi,
2281 				      struct btrfs_disk_balance_args *ba)
2282 {
2283 	read_eb_member(eb, bi, struct btrfs_balance_item, meta, ba);
2284 }
2285 
2286 static inline void btrfs_set_balance_meta(struct extent_buffer *eb,
2287 				  struct btrfs_balance_item *bi,
2288 				  const struct btrfs_disk_balance_args *ba)
2289 {
2290 	write_eb_member(eb, bi, struct btrfs_balance_item, meta, ba);
2291 }
2292 
2293 static inline void btrfs_balance_sys(const struct extent_buffer *eb,
2294 				     const struct btrfs_balance_item *bi,
2295 				     struct btrfs_disk_balance_args *ba)
2296 {
2297 	read_eb_member(eb, bi, struct btrfs_balance_item, sys, ba);
2298 }
2299 
2300 static inline void btrfs_set_balance_sys(struct extent_buffer *eb,
2301 				 struct btrfs_balance_item *bi,
2302 				 const struct btrfs_disk_balance_args *ba)
2303 {
2304 	write_eb_member(eb, bi, struct btrfs_balance_item, sys, ba);
2305 }
2306 
2307 static inline void
2308 btrfs_disk_balance_args_to_cpu(struct btrfs_balance_args *cpu,
2309 			       const struct btrfs_disk_balance_args *disk)
2310 {
2311 	memset(cpu, 0, sizeof(*cpu));
2312 
2313 	cpu->profiles = le64_to_cpu(disk->profiles);
2314 	cpu->usage = le64_to_cpu(disk->usage);
2315 	cpu->devid = le64_to_cpu(disk->devid);
2316 	cpu->pstart = le64_to_cpu(disk->pstart);
2317 	cpu->pend = le64_to_cpu(disk->pend);
2318 	cpu->vstart = le64_to_cpu(disk->vstart);
2319 	cpu->vend = le64_to_cpu(disk->vend);
2320 	cpu->target = le64_to_cpu(disk->target);
2321 	cpu->flags = le64_to_cpu(disk->flags);
2322 	cpu->limit = le64_to_cpu(disk->limit);
2323 	cpu->stripes_min = le32_to_cpu(disk->stripes_min);
2324 	cpu->stripes_max = le32_to_cpu(disk->stripes_max);
2325 }
2326 
2327 static inline void
2328 btrfs_cpu_balance_args_to_disk(struct btrfs_disk_balance_args *disk,
2329 			       const struct btrfs_balance_args *cpu)
2330 {
2331 	memset(disk, 0, sizeof(*disk));
2332 
2333 	disk->profiles = cpu_to_le64(cpu->profiles);
2334 	disk->usage = cpu_to_le64(cpu->usage);
2335 	disk->devid = cpu_to_le64(cpu->devid);
2336 	disk->pstart = cpu_to_le64(cpu->pstart);
2337 	disk->pend = cpu_to_le64(cpu->pend);
2338 	disk->vstart = cpu_to_le64(cpu->vstart);
2339 	disk->vend = cpu_to_le64(cpu->vend);
2340 	disk->target = cpu_to_le64(cpu->target);
2341 	disk->flags = cpu_to_le64(cpu->flags);
2342 	disk->limit = cpu_to_le64(cpu->limit);
2343 	disk->stripes_min = cpu_to_le32(cpu->stripes_min);
2344 	disk->stripes_max = cpu_to_le32(cpu->stripes_max);
2345 }
2346 
2347 /* struct btrfs_super_block */
2348 BTRFS_SETGET_STACK_FUNCS(super_bytenr, struct btrfs_super_block, bytenr, 64);
2349 BTRFS_SETGET_STACK_FUNCS(super_flags, struct btrfs_super_block, flags, 64);
2350 BTRFS_SETGET_STACK_FUNCS(super_generation, struct btrfs_super_block,
2351 			 generation, 64);
2352 BTRFS_SETGET_STACK_FUNCS(super_root, struct btrfs_super_block, root, 64);
2353 BTRFS_SETGET_STACK_FUNCS(super_sys_array_size,
2354 			 struct btrfs_super_block, sys_chunk_array_size, 32);
2355 BTRFS_SETGET_STACK_FUNCS(super_chunk_root_generation,
2356 			 struct btrfs_super_block, chunk_root_generation, 64);
2357 BTRFS_SETGET_STACK_FUNCS(super_root_level, struct btrfs_super_block,
2358 			 root_level, 8);
2359 BTRFS_SETGET_STACK_FUNCS(super_chunk_root, struct btrfs_super_block,
2360 			 chunk_root, 64);
2361 BTRFS_SETGET_STACK_FUNCS(super_chunk_root_level, struct btrfs_super_block,
2362 			 chunk_root_level, 8);
2363 BTRFS_SETGET_STACK_FUNCS(super_log_root, struct btrfs_super_block,
2364 			 log_root, 64);
2365 BTRFS_SETGET_STACK_FUNCS(super_log_root_transid, struct btrfs_super_block,
2366 			 log_root_transid, 64);
2367 BTRFS_SETGET_STACK_FUNCS(super_log_root_level, struct btrfs_super_block,
2368 			 log_root_level, 8);
2369 BTRFS_SETGET_STACK_FUNCS(super_total_bytes, struct btrfs_super_block,
2370 			 total_bytes, 64);
2371 BTRFS_SETGET_STACK_FUNCS(super_bytes_used, struct btrfs_super_block,
2372 			 bytes_used, 64);
2373 BTRFS_SETGET_STACK_FUNCS(super_sectorsize, struct btrfs_super_block,
2374 			 sectorsize, 32);
2375 BTRFS_SETGET_STACK_FUNCS(super_nodesize, struct btrfs_super_block,
2376 			 nodesize, 32);
2377 BTRFS_SETGET_STACK_FUNCS(super_stripesize, struct btrfs_super_block,
2378 			 stripesize, 32);
2379 BTRFS_SETGET_STACK_FUNCS(super_root_dir, struct btrfs_super_block,
2380 			 root_dir_objectid, 64);
2381 BTRFS_SETGET_STACK_FUNCS(super_num_devices, struct btrfs_super_block,
2382 			 num_devices, 64);
2383 BTRFS_SETGET_STACK_FUNCS(super_compat_flags, struct btrfs_super_block,
2384 			 compat_flags, 64);
2385 BTRFS_SETGET_STACK_FUNCS(super_compat_ro_flags, struct btrfs_super_block,
2386 			 compat_ro_flags, 64);
2387 BTRFS_SETGET_STACK_FUNCS(super_incompat_flags, struct btrfs_super_block,
2388 			 incompat_flags, 64);
2389 BTRFS_SETGET_STACK_FUNCS(super_csum_type, struct btrfs_super_block,
2390 			 csum_type, 16);
2391 BTRFS_SETGET_STACK_FUNCS(super_cache_generation, struct btrfs_super_block,
2392 			 cache_generation, 64);
2393 BTRFS_SETGET_STACK_FUNCS(super_magic, struct btrfs_super_block, magic, 64);
2394 BTRFS_SETGET_STACK_FUNCS(super_uuid_tree_generation, struct btrfs_super_block,
2395 			 uuid_tree_generation, 64);
2396 
2397 static inline int btrfs_super_csum_size(const struct btrfs_super_block *s)
2398 {
2399 	u16 t = btrfs_super_csum_type(s);
2400 	/*
2401 	 * csum type is validated at mount time
2402 	 */
2403 	return btrfs_csum_sizes[t];
2404 }
2405 
2406 
2407 /*
2408  * The leaf data grows from end-to-front in the node.
2409  * this returns the address of the start of the last item,
2410  * which is the stop of the leaf data stack
2411  */
2412 static inline unsigned int leaf_data_end(const struct btrfs_fs_info *fs_info,
2413 					 const struct extent_buffer *leaf)
2414 {
2415 	u32 nr = btrfs_header_nritems(leaf);
2416 
2417 	if (nr == 0)
2418 		return BTRFS_LEAF_DATA_SIZE(fs_info);
2419 	return btrfs_item_offset_nr(leaf, nr - 1);
2420 }
2421 
2422 /* struct btrfs_file_extent_item */
2423 BTRFS_SETGET_FUNCS(file_extent_type, struct btrfs_file_extent_item, type, 8);
2424 BTRFS_SETGET_STACK_FUNCS(stack_file_extent_disk_bytenr,
2425 			 struct btrfs_file_extent_item, disk_bytenr, 64);
2426 BTRFS_SETGET_STACK_FUNCS(stack_file_extent_offset,
2427 			 struct btrfs_file_extent_item, offset, 64);
2428 BTRFS_SETGET_STACK_FUNCS(stack_file_extent_generation,
2429 			 struct btrfs_file_extent_item, generation, 64);
2430 BTRFS_SETGET_STACK_FUNCS(stack_file_extent_num_bytes,
2431 			 struct btrfs_file_extent_item, num_bytes, 64);
2432 BTRFS_SETGET_STACK_FUNCS(stack_file_extent_disk_num_bytes,
2433 			 struct btrfs_file_extent_item, disk_num_bytes, 64);
2434 BTRFS_SETGET_STACK_FUNCS(stack_file_extent_compression,
2435 			 struct btrfs_file_extent_item, compression, 8);
2436 
2437 static inline unsigned long
2438 btrfs_file_extent_inline_start(const struct btrfs_file_extent_item *e)
2439 {
2440 	return (unsigned long)e + BTRFS_FILE_EXTENT_INLINE_DATA_START;
2441 }
2442 
2443 static inline u32 btrfs_file_extent_calc_inline_size(u32 datasize)
2444 {
2445 	return BTRFS_FILE_EXTENT_INLINE_DATA_START + datasize;
2446 }
2447 
2448 BTRFS_SETGET_FUNCS(file_extent_disk_bytenr, struct btrfs_file_extent_item,
2449 		   disk_bytenr, 64);
2450 BTRFS_SETGET_FUNCS(file_extent_generation, struct btrfs_file_extent_item,
2451 		   generation, 64);
2452 BTRFS_SETGET_FUNCS(file_extent_disk_num_bytes, struct btrfs_file_extent_item,
2453 		   disk_num_bytes, 64);
2454 BTRFS_SETGET_FUNCS(file_extent_offset, struct btrfs_file_extent_item,
2455 		  offset, 64);
2456 BTRFS_SETGET_FUNCS(file_extent_num_bytes, struct btrfs_file_extent_item,
2457 		   num_bytes, 64);
2458 BTRFS_SETGET_FUNCS(file_extent_ram_bytes, struct btrfs_file_extent_item,
2459 		   ram_bytes, 64);
2460 BTRFS_SETGET_FUNCS(file_extent_compression, struct btrfs_file_extent_item,
2461 		   compression, 8);
2462 BTRFS_SETGET_FUNCS(file_extent_encryption, struct btrfs_file_extent_item,
2463 		   encryption, 8);
2464 BTRFS_SETGET_FUNCS(file_extent_other_encoding, struct btrfs_file_extent_item,
2465 		   other_encoding, 16);
2466 
2467 /*
2468  * this returns the number of bytes used by the item on disk, minus the
2469  * size of any extent headers.  If a file is compressed on disk, this is
2470  * the compressed size
2471  */
2472 static inline u32 btrfs_file_extent_inline_item_len(
2473 						const struct extent_buffer *eb,
2474 						struct btrfs_item *e)
2475 {
2476 	return btrfs_item_size(eb, e) - BTRFS_FILE_EXTENT_INLINE_DATA_START;
2477 }
2478 
2479 /* btrfs_dev_stats_item */
2480 static inline u64 btrfs_dev_stats_value(const struct extent_buffer *eb,
2481 					const struct btrfs_dev_stats_item *ptr,
2482 					int index)
2483 {
2484 	u64 val;
2485 
2486 	read_extent_buffer(eb, &val,
2487 			   offsetof(struct btrfs_dev_stats_item, values) +
2488 			    ((unsigned long)ptr) + (index * sizeof(u64)),
2489 			   sizeof(val));
2490 	return val;
2491 }
2492 
2493 static inline void btrfs_set_dev_stats_value(struct extent_buffer *eb,
2494 					     struct btrfs_dev_stats_item *ptr,
2495 					     int index, u64 val)
2496 {
2497 	write_extent_buffer(eb, &val,
2498 			    offsetof(struct btrfs_dev_stats_item, values) +
2499 			     ((unsigned long)ptr) + (index * sizeof(u64)),
2500 			    sizeof(val));
2501 }
2502 
2503 /* btrfs_qgroup_status_item */
2504 BTRFS_SETGET_FUNCS(qgroup_status_generation, struct btrfs_qgroup_status_item,
2505 		   generation, 64);
2506 BTRFS_SETGET_FUNCS(qgroup_status_version, struct btrfs_qgroup_status_item,
2507 		   version, 64);
2508 BTRFS_SETGET_FUNCS(qgroup_status_flags, struct btrfs_qgroup_status_item,
2509 		   flags, 64);
2510 BTRFS_SETGET_FUNCS(qgroup_status_rescan, struct btrfs_qgroup_status_item,
2511 		   rescan, 64);
2512 
2513 /* btrfs_qgroup_info_item */
2514 BTRFS_SETGET_FUNCS(qgroup_info_generation, struct btrfs_qgroup_info_item,
2515 		   generation, 64);
2516 BTRFS_SETGET_FUNCS(qgroup_info_rfer, struct btrfs_qgroup_info_item, rfer, 64);
2517 BTRFS_SETGET_FUNCS(qgroup_info_rfer_cmpr, struct btrfs_qgroup_info_item,
2518 		   rfer_cmpr, 64);
2519 BTRFS_SETGET_FUNCS(qgroup_info_excl, struct btrfs_qgroup_info_item, excl, 64);
2520 BTRFS_SETGET_FUNCS(qgroup_info_excl_cmpr, struct btrfs_qgroup_info_item,
2521 		   excl_cmpr, 64);
2522 
2523 BTRFS_SETGET_STACK_FUNCS(stack_qgroup_info_generation,
2524 			 struct btrfs_qgroup_info_item, generation, 64);
2525 BTRFS_SETGET_STACK_FUNCS(stack_qgroup_info_rfer, struct btrfs_qgroup_info_item,
2526 			 rfer, 64);
2527 BTRFS_SETGET_STACK_FUNCS(stack_qgroup_info_rfer_cmpr,
2528 			 struct btrfs_qgroup_info_item, rfer_cmpr, 64);
2529 BTRFS_SETGET_STACK_FUNCS(stack_qgroup_info_excl, struct btrfs_qgroup_info_item,
2530 			 excl, 64);
2531 BTRFS_SETGET_STACK_FUNCS(stack_qgroup_info_excl_cmpr,
2532 			 struct btrfs_qgroup_info_item, excl_cmpr, 64);
2533 
2534 /* btrfs_qgroup_limit_item */
2535 BTRFS_SETGET_FUNCS(qgroup_limit_flags, struct btrfs_qgroup_limit_item,
2536 		   flags, 64);
2537 BTRFS_SETGET_FUNCS(qgroup_limit_max_rfer, struct btrfs_qgroup_limit_item,
2538 		   max_rfer, 64);
2539 BTRFS_SETGET_FUNCS(qgroup_limit_max_excl, struct btrfs_qgroup_limit_item,
2540 		   max_excl, 64);
2541 BTRFS_SETGET_FUNCS(qgroup_limit_rsv_rfer, struct btrfs_qgroup_limit_item,
2542 		   rsv_rfer, 64);
2543 BTRFS_SETGET_FUNCS(qgroup_limit_rsv_excl, struct btrfs_qgroup_limit_item,
2544 		   rsv_excl, 64);
2545 
2546 /* btrfs_dev_replace_item */
2547 BTRFS_SETGET_FUNCS(dev_replace_src_devid,
2548 		   struct btrfs_dev_replace_item, src_devid, 64);
2549 BTRFS_SETGET_FUNCS(dev_replace_cont_reading_from_srcdev_mode,
2550 		   struct btrfs_dev_replace_item, cont_reading_from_srcdev_mode,
2551 		   64);
2552 BTRFS_SETGET_FUNCS(dev_replace_replace_state, struct btrfs_dev_replace_item,
2553 		   replace_state, 64);
2554 BTRFS_SETGET_FUNCS(dev_replace_time_started, struct btrfs_dev_replace_item,
2555 		   time_started, 64);
2556 BTRFS_SETGET_FUNCS(dev_replace_time_stopped, struct btrfs_dev_replace_item,
2557 		   time_stopped, 64);
2558 BTRFS_SETGET_FUNCS(dev_replace_num_write_errors, struct btrfs_dev_replace_item,
2559 		   num_write_errors, 64);
2560 BTRFS_SETGET_FUNCS(dev_replace_num_uncorrectable_read_errors,
2561 		   struct btrfs_dev_replace_item, num_uncorrectable_read_errors,
2562 		   64);
2563 BTRFS_SETGET_FUNCS(dev_replace_cursor_left, struct btrfs_dev_replace_item,
2564 		   cursor_left, 64);
2565 BTRFS_SETGET_FUNCS(dev_replace_cursor_right, struct btrfs_dev_replace_item,
2566 		   cursor_right, 64);
2567 
2568 BTRFS_SETGET_STACK_FUNCS(stack_dev_replace_src_devid,
2569 			 struct btrfs_dev_replace_item, src_devid, 64);
2570 BTRFS_SETGET_STACK_FUNCS(stack_dev_replace_cont_reading_from_srcdev_mode,
2571 			 struct btrfs_dev_replace_item,
2572 			 cont_reading_from_srcdev_mode, 64);
2573 BTRFS_SETGET_STACK_FUNCS(stack_dev_replace_replace_state,
2574 			 struct btrfs_dev_replace_item, replace_state, 64);
2575 BTRFS_SETGET_STACK_FUNCS(stack_dev_replace_time_started,
2576 			 struct btrfs_dev_replace_item, time_started, 64);
2577 BTRFS_SETGET_STACK_FUNCS(stack_dev_replace_time_stopped,
2578 			 struct btrfs_dev_replace_item, time_stopped, 64);
2579 BTRFS_SETGET_STACK_FUNCS(stack_dev_replace_num_write_errors,
2580 			 struct btrfs_dev_replace_item, num_write_errors, 64);
2581 BTRFS_SETGET_STACK_FUNCS(stack_dev_replace_num_uncorrectable_read_errors,
2582 			 struct btrfs_dev_replace_item,
2583 			 num_uncorrectable_read_errors, 64);
2584 BTRFS_SETGET_STACK_FUNCS(stack_dev_replace_cursor_left,
2585 			 struct btrfs_dev_replace_item, cursor_left, 64);
2586 BTRFS_SETGET_STACK_FUNCS(stack_dev_replace_cursor_right,
2587 			 struct btrfs_dev_replace_item, cursor_right, 64);
2588 
2589 /* helper function to cast into the data area of the leaf. */
2590 #define btrfs_item_ptr(leaf, slot, type) \
2591 	((type *)(BTRFS_LEAF_DATA_OFFSET + \
2592 	btrfs_item_offset_nr(leaf, slot)))
2593 
2594 #define btrfs_item_ptr_offset(leaf, slot) \
2595 	((unsigned long)(BTRFS_LEAF_DATA_OFFSET + \
2596 	btrfs_item_offset_nr(leaf, slot)))
2597 
2598 static inline u64 btrfs_name_hash(const char *name, int len)
2599 {
2600        return crc32c((u32)~1, name, len);
2601 }
2602 
2603 /*
2604  * Figure the key offset of an extended inode ref
2605  */
2606 static inline u64 btrfs_extref_hash(u64 parent_objectid, const char *name,
2607                                    int len)
2608 {
2609        return (u64) crc32c(parent_objectid, name, len);
2610 }
2611 
2612 static inline bool btrfs_mixed_space_info(struct btrfs_space_info *space_info)
2613 {
2614 	return ((space_info->flags & BTRFS_BLOCK_GROUP_METADATA) &&
2615 		(space_info->flags & BTRFS_BLOCK_GROUP_DATA));
2616 }
2617 
2618 static inline gfp_t btrfs_alloc_write_mask(struct address_space *mapping)
2619 {
2620 	return mapping_gfp_constraint(mapping, ~__GFP_FS);
2621 }
2622 
2623 /* extent-tree.c */
2624 
2625 enum btrfs_inline_ref_type {
2626 	BTRFS_REF_TYPE_INVALID,
2627 	BTRFS_REF_TYPE_BLOCK,
2628 	BTRFS_REF_TYPE_DATA,
2629 	BTRFS_REF_TYPE_ANY,
2630 };
2631 
2632 int btrfs_get_extent_inline_ref_type(const struct extent_buffer *eb,
2633 				     struct btrfs_extent_inline_ref *iref,
2634 				     enum btrfs_inline_ref_type is_data);
2635 
2636 u64 btrfs_csum_bytes_to_leaves(struct btrfs_fs_info *fs_info, u64 csum_bytes);
2637 
2638 static inline u64 btrfs_calc_trans_metadata_size(struct btrfs_fs_info *fs_info,
2639 						 unsigned num_items)
2640 {
2641 	return (u64)fs_info->nodesize * BTRFS_MAX_LEVEL * 2 * num_items;
2642 }
2643 
2644 /*
2645  * Doing a truncate won't result in new nodes or leaves, just what we need for
2646  * COW.
2647  */
2648 static inline u64 btrfs_calc_trunc_metadata_size(struct btrfs_fs_info *fs_info,
2649 						 unsigned num_items)
2650 {
2651 	return (u64)fs_info->nodesize * BTRFS_MAX_LEVEL * num_items;
2652 }
2653 
2654 int btrfs_should_throttle_delayed_refs(struct btrfs_trans_handle *trans);
2655 bool btrfs_check_space_for_delayed_refs(struct btrfs_fs_info *fs_info);
2656 void btrfs_dec_block_group_reservations(struct btrfs_fs_info *fs_info,
2657 					 const u64 start);
2658 void btrfs_wait_block_group_reservations(struct btrfs_block_group_cache *bg);
2659 bool btrfs_inc_nocow_writers(struct btrfs_fs_info *fs_info, u64 bytenr);
2660 void btrfs_dec_nocow_writers(struct btrfs_fs_info *fs_info, u64 bytenr);
2661 void btrfs_wait_nocow_writers(struct btrfs_block_group_cache *bg);
2662 void btrfs_put_block_group(struct btrfs_block_group_cache *cache);
2663 int btrfs_run_delayed_refs(struct btrfs_trans_handle *trans,
2664 			   unsigned long count);
2665 int btrfs_async_run_delayed_refs(struct btrfs_fs_info *fs_info,
2666 				 unsigned long count, u64 transid, int wait);
2667 int btrfs_lookup_data_extent(struct btrfs_fs_info *fs_info, u64 start, u64 len);
2668 int btrfs_lookup_extent_info(struct btrfs_trans_handle *trans,
2669 			     struct btrfs_fs_info *fs_info, u64 bytenr,
2670 			     u64 offset, int metadata, u64 *refs, u64 *flags);
2671 int btrfs_pin_extent(struct btrfs_fs_info *fs_info,
2672 		     u64 bytenr, u64 num, int reserved);
2673 int btrfs_pin_extent_for_log_replay(struct btrfs_fs_info *fs_info,
2674 				    u64 bytenr, u64 num_bytes);
2675 int btrfs_exclude_logged_extents(struct btrfs_fs_info *fs_info,
2676 				 struct extent_buffer *eb);
2677 int btrfs_cross_ref_exist(struct btrfs_root *root,
2678 			  u64 objectid, u64 offset, u64 bytenr);
2679 struct btrfs_block_group_cache *btrfs_lookup_block_group(
2680 						 struct btrfs_fs_info *info,
2681 						 u64 bytenr);
2682 void btrfs_get_block_group(struct btrfs_block_group_cache *cache);
2683 void btrfs_put_block_group(struct btrfs_block_group_cache *cache);
2684 struct extent_buffer *btrfs_alloc_tree_block(struct btrfs_trans_handle *trans,
2685 					     struct btrfs_root *root,
2686 					     u64 parent, u64 root_objectid,
2687 					     const struct btrfs_disk_key *key,
2688 					     int level, u64 hint,
2689 					     u64 empty_size);
2690 void btrfs_free_tree_block(struct btrfs_trans_handle *trans,
2691 			   struct btrfs_root *root,
2692 			   struct extent_buffer *buf,
2693 			   u64 parent, int last_ref);
2694 int btrfs_alloc_reserved_file_extent(struct btrfs_trans_handle *trans,
2695 				     struct btrfs_root *root, u64 owner,
2696 				     u64 offset, u64 ram_bytes,
2697 				     struct btrfs_key *ins);
2698 int btrfs_alloc_logged_file_extent(struct btrfs_trans_handle *trans,
2699 				   u64 root_objectid, u64 owner, u64 offset,
2700 				   struct btrfs_key *ins);
2701 int btrfs_reserve_extent(struct btrfs_root *root, u64 ram_bytes, u64 num_bytes,
2702 			 u64 min_alloc_size, u64 empty_size, u64 hint_byte,
2703 			 struct btrfs_key *ins, int is_data, int delalloc);
2704 int btrfs_inc_ref(struct btrfs_trans_handle *trans, struct btrfs_root *root,
2705 		  struct extent_buffer *buf, int full_backref);
2706 int btrfs_dec_ref(struct btrfs_trans_handle *trans, struct btrfs_root *root,
2707 		  struct extent_buffer *buf, int full_backref);
2708 int btrfs_set_disk_extent_flags(struct btrfs_trans_handle *trans,
2709 				struct btrfs_fs_info *fs_info,
2710 				u64 bytenr, u64 num_bytes, u64 flags,
2711 				int level, int is_data);
2712 int btrfs_free_extent(struct btrfs_trans_handle *trans,
2713 		      struct btrfs_root *root,
2714 		      u64 bytenr, u64 num_bytes, u64 parent, u64 root_objectid,
2715 		      u64 owner, u64 offset);
2716 
2717 int btrfs_free_reserved_extent(struct btrfs_fs_info *fs_info,
2718 			       u64 start, u64 len, int delalloc);
2719 int btrfs_free_and_pin_reserved_extent(struct btrfs_fs_info *fs_info,
2720 				       u64 start, u64 len);
2721 void btrfs_prepare_extent_commit(struct btrfs_fs_info *fs_info);
2722 int btrfs_finish_extent_commit(struct btrfs_trans_handle *trans);
2723 int btrfs_inc_extent_ref(struct btrfs_trans_handle *trans,
2724 			 struct btrfs_root *root,
2725 			 u64 bytenr, u64 num_bytes, u64 parent,
2726 			 u64 root_objectid, u64 owner, u64 offset);
2727 
2728 int btrfs_start_dirty_block_groups(struct btrfs_trans_handle *trans);
2729 int btrfs_write_dirty_block_groups(struct btrfs_trans_handle *trans,
2730 				   struct btrfs_fs_info *fs_info);
2731 int btrfs_setup_space_cache(struct btrfs_trans_handle *trans,
2732 			    struct btrfs_fs_info *fs_info);
2733 int btrfs_extent_readonly(struct btrfs_fs_info *fs_info, u64 bytenr);
2734 int btrfs_free_block_groups(struct btrfs_fs_info *info);
2735 int btrfs_read_block_groups(struct btrfs_fs_info *info);
2736 int btrfs_can_relocate(struct btrfs_fs_info *fs_info, u64 bytenr);
2737 int btrfs_make_block_group(struct btrfs_trans_handle *trans,
2738 			   u64 bytes_used, u64 type, u64 chunk_offset,
2739 			   u64 size);
2740 void btrfs_add_raid_kobjects(struct btrfs_fs_info *fs_info);
2741 struct btrfs_trans_handle *btrfs_start_trans_remove_block_group(
2742 				struct btrfs_fs_info *fs_info,
2743 				const u64 chunk_offset);
2744 int btrfs_remove_block_group(struct btrfs_trans_handle *trans,
2745 			     u64 group_start, struct extent_map *em);
2746 void btrfs_delete_unused_bgs(struct btrfs_fs_info *fs_info);
2747 void btrfs_get_block_group_trimming(struct btrfs_block_group_cache *cache);
2748 void btrfs_put_block_group_trimming(struct btrfs_block_group_cache *cache);
2749 void btrfs_create_pending_block_groups(struct btrfs_trans_handle *trans);
2750 u64 btrfs_data_alloc_profile(struct btrfs_fs_info *fs_info);
2751 u64 btrfs_metadata_alloc_profile(struct btrfs_fs_info *fs_info);
2752 u64 btrfs_system_alloc_profile(struct btrfs_fs_info *fs_info);
2753 void btrfs_clear_space_info_full(struct btrfs_fs_info *info);
2754 
2755 enum btrfs_reserve_flush_enum {
2756 	/* If we are in the transaction, we can't flush anything.*/
2757 	BTRFS_RESERVE_NO_FLUSH,
2758 	/*
2759 	 * Flushing delalloc may cause deadlock somewhere, in this
2760 	 * case, use FLUSH LIMIT
2761 	 */
2762 	BTRFS_RESERVE_FLUSH_LIMIT,
2763 	BTRFS_RESERVE_FLUSH_ALL,
2764 };
2765 
2766 enum btrfs_flush_state {
2767 	FLUSH_DELAYED_ITEMS_NR	=	1,
2768 	FLUSH_DELAYED_ITEMS	=	2,
2769 	FLUSH_DELAYED_REFS_NR	=	3,
2770 	FLUSH_DELAYED_REFS	=	4,
2771 	FLUSH_DELALLOC		=	5,
2772 	FLUSH_DELALLOC_WAIT	=	6,
2773 	ALLOC_CHUNK		=	7,
2774 	COMMIT_TRANS		=	8,
2775 };
2776 
2777 int btrfs_alloc_data_chunk_ondemand(struct btrfs_inode *inode, u64 bytes);
2778 int btrfs_check_data_free_space(struct inode *inode,
2779 			struct extent_changeset **reserved, u64 start, u64 len);
2780 void btrfs_free_reserved_data_space(struct inode *inode,
2781 			struct extent_changeset *reserved, u64 start, u64 len);
2782 void btrfs_delalloc_release_space(struct inode *inode,
2783 				  struct extent_changeset *reserved,
2784 				  u64 start, u64 len, bool qgroup_free);
2785 void btrfs_free_reserved_data_space_noquota(struct inode *inode, u64 start,
2786 					    u64 len);
2787 void btrfs_trans_release_chunk_metadata(struct btrfs_trans_handle *trans);
2788 int btrfs_subvolume_reserve_metadata(struct btrfs_root *root,
2789 				     struct btrfs_block_rsv *rsv,
2790 				     int nitems, bool use_global_rsv);
2791 void btrfs_subvolume_release_metadata(struct btrfs_fs_info *fs_info,
2792 				      struct btrfs_block_rsv *rsv);
2793 void btrfs_delalloc_release_extents(struct btrfs_inode *inode, u64 num_bytes,
2794 				    bool qgroup_free);
2795 
2796 int btrfs_delalloc_reserve_metadata(struct btrfs_inode *inode, u64 num_bytes);
2797 void btrfs_delalloc_release_metadata(struct btrfs_inode *inode, u64 num_bytes,
2798 				     bool qgroup_free);
2799 int btrfs_delalloc_reserve_space(struct inode *inode,
2800 			struct extent_changeset **reserved, u64 start, u64 len);
2801 void btrfs_init_block_rsv(struct btrfs_block_rsv *rsv, unsigned short type);
2802 struct btrfs_block_rsv *btrfs_alloc_block_rsv(struct btrfs_fs_info *fs_info,
2803 					      unsigned short type);
2804 void btrfs_init_metadata_block_rsv(struct btrfs_fs_info *fs_info,
2805 				   struct btrfs_block_rsv *rsv,
2806 				   unsigned short type);
2807 void btrfs_free_block_rsv(struct btrfs_fs_info *fs_info,
2808 			  struct btrfs_block_rsv *rsv);
2809 int btrfs_block_rsv_add(struct btrfs_root *root,
2810 			struct btrfs_block_rsv *block_rsv, u64 num_bytes,
2811 			enum btrfs_reserve_flush_enum flush);
2812 int btrfs_block_rsv_check(struct btrfs_block_rsv *block_rsv, int min_factor);
2813 int btrfs_block_rsv_refill(struct btrfs_root *root,
2814 			   struct btrfs_block_rsv *block_rsv, u64 min_reserved,
2815 			   enum btrfs_reserve_flush_enum flush);
2816 int btrfs_block_rsv_migrate(struct btrfs_block_rsv *src_rsv,
2817 			    struct btrfs_block_rsv *dst_rsv, u64 num_bytes,
2818 			    bool update_size);
2819 int btrfs_cond_migrate_bytes(struct btrfs_fs_info *fs_info,
2820 			     struct btrfs_block_rsv *dest, u64 num_bytes,
2821 			     int min_factor);
2822 void btrfs_block_rsv_release(struct btrfs_fs_info *fs_info,
2823 			     struct btrfs_block_rsv *block_rsv,
2824 			     u64 num_bytes);
2825 void btrfs_delayed_refs_rsv_release(struct btrfs_fs_info *fs_info, int nr);
2826 void btrfs_update_delayed_refs_rsv(struct btrfs_trans_handle *trans);
2827 int btrfs_delayed_refs_rsv_refill(struct btrfs_fs_info *fs_info,
2828 				  enum btrfs_reserve_flush_enum flush);
2829 void btrfs_migrate_to_delayed_refs_rsv(struct btrfs_fs_info *fs_info,
2830 				       struct btrfs_block_rsv *src,
2831 				       u64 num_bytes);
2832 int btrfs_inc_block_group_ro(struct btrfs_block_group_cache *cache);
2833 void btrfs_dec_block_group_ro(struct btrfs_block_group_cache *cache);
2834 void btrfs_put_block_group_cache(struct btrfs_fs_info *info);
2835 u64 btrfs_account_ro_block_groups_free_space(struct btrfs_space_info *sinfo);
2836 int btrfs_error_unpin_extent_range(struct btrfs_fs_info *fs_info,
2837 				   u64 start, u64 end);
2838 int btrfs_discard_extent(struct btrfs_fs_info *fs_info, u64 bytenr,
2839 			 u64 num_bytes, u64 *actual_bytes);
2840 int btrfs_force_chunk_alloc(struct btrfs_trans_handle *trans, u64 type);
2841 int btrfs_trim_fs(struct btrfs_fs_info *fs_info, struct fstrim_range *range);
2842 
2843 int btrfs_init_space_info(struct btrfs_fs_info *fs_info);
2844 int btrfs_delayed_refs_qgroup_accounting(struct btrfs_trans_handle *trans,
2845 					 struct btrfs_fs_info *fs_info);
2846 int btrfs_start_write_no_snapshotting(struct btrfs_root *root);
2847 void btrfs_end_write_no_snapshotting(struct btrfs_root *root);
2848 void btrfs_wait_for_snapshot_creation(struct btrfs_root *root);
2849 void check_system_chunk(struct btrfs_trans_handle *trans, const u64 type);
2850 u64 add_new_free_space(struct btrfs_block_group_cache *block_group,
2851 		       u64 start, u64 end);
2852 void btrfs_mark_bg_unused(struct btrfs_block_group_cache *bg);
2853 
2854 /* ctree.c */
2855 int btrfs_bin_search(struct extent_buffer *eb, const struct btrfs_key *key,
2856 		     int level, int *slot);
2857 int btrfs_comp_cpu_keys(const struct btrfs_key *k1, const struct btrfs_key *k2);
2858 int btrfs_previous_item(struct btrfs_root *root,
2859 			struct btrfs_path *path, u64 min_objectid,
2860 			int type);
2861 int btrfs_previous_extent_item(struct btrfs_root *root,
2862 			struct btrfs_path *path, u64 min_objectid);
2863 void btrfs_set_item_key_safe(struct btrfs_fs_info *fs_info,
2864 			     struct btrfs_path *path,
2865 			     const struct btrfs_key *new_key);
2866 struct extent_buffer *btrfs_root_node(struct btrfs_root *root);
2867 struct extent_buffer *btrfs_lock_root_node(struct btrfs_root *root);
2868 struct extent_buffer *btrfs_read_lock_root_node(struct btrfs_root *root);
2869 int btrfs_find_next_key(struct btrfs_root *root, struct btrfs_path *path,
2870 			struct btrfs_key *key, int lowest_level,
2871 			u64 min_trans);
2872 int btrfs_search_forward(struct btrfs_root *root, struct btrfs_key *min_key,
2873 			 struct btrfs_path *path,
2874 			 u64 min_trans);
2875 enum btrfs_compare_tree_result {
2876 	BTRFS_COMPARE_TREE_NEW,
2877 	BTRFS_COMPARE_TREE_DELETED,
2878 	BTRFS_COMPARE_TREE_CHANGED,
2879 	BTRFS_COMPARE_TREE_SAME,
2880 };
2881 typedef int (*btrfs_changed_cb_t)(struct btrfs_path *left_path,
2882 				  struct btrfs_path *right_path,
2883 				  struct btrfs_key *key,
2884 				  enum btrfs_compare_tree_result result,
2885 				  void *ctx);
2886 int btrfs_compare_trees(struct btrfs_root *left_root,
2887 			struct btrfs_root *right_root,
2888 			btrfs_changed_cb_t cb, void *ctx);
2889 int btrfs_cow_block(struct btrfs_trans_handle *trans,
2890 		    struct btrfs_root *root, struct extent_buffer *buf,
2891 		    struct extent_buffer *parent, int parent_slot,
2892 		    struct extent_buffer **cow_ret);
2893 int btrfs_copy_root(struct btrfs_trans_handle *trans,
2894 		      struct btrfs_root *root,
2895 		      struct extent_buffer *buf,
2896 		      struct extent_buffer **cow_ret, u64 new_root_objectid);
2897 int btrfs_block_can_be_shared(struct btrfs_root *root,
2898 			      struct extent_buffer *buf);
2899 void btrfs_extend_item(struct btrfs_fs_info *fs_info, struct btrfs_path *path,
2900 		       u32 data_size);
2901 void btrfs_truncate_item(struct btrfs_fs_info *fs_info,
2902 			 struct btrfs_path *path, u32 new_size, int from_end);
2903 int btrfs_split_item(struct btrfs_trans_handle *trans,
2904 		     struct btrfs_root *root,
2905 		     struct btrfs_path *path,
2906 		     const struct btrfs_key *new_key,
2907 		     unsigned long split_offset);
2908 int btrfs_duplicate_item(struct btrfs_trans_handle *trans,
2909 			 struct btrfs_root *root,
2910 			 struct btrfs_path *path,
2911 			 const struct btrfs_key *new_key);
2912 int btrfs_find_item(struct btrfs_root *fs_root, struct btrfs_path *path,
2913 		u64 inum, u64 ioff, u8 key_type, struct btrfs_key *found_key);
2914 int btrfs_search_slot(struct btrfs_trans_handle *trans, struct btrfs_root *root,
2915 		      const struct btrfs_key *key, struct btrfs_path *p,
2916 		      int ins_len, int cow);
2917 int btrfs_search_old_slot(struct btrfs_root *root, const struct btrfs_key *key,
2918 			  struct btrfs_path *p, u64 time_seq);
2919 int btrfs_search_slot_for_read(struct btrfs_root *root,
2920 			       const struct btrfs_key *key,
2921 			       struct btrfs_path *p, int find_higher,
2922 			       int return_any);
2923 int btrfs_realloc_node(struct btrfs_trans_handle *trans,
2924 		       struct btrfs_root *root, struct extent_buffer *parent,
2925 		       int start_slot, u64 *last_ret,
2926 		       struct btrfs_key *progress);
2927 void btrfs_release_path(struct btrfs_path *p);
2928 struct btrfs_path *btrfs_alloc_path(void);
2929 void btrfs_free_path(struct btrfs_path *p);
2930 void btrfs_set_path_blocking(struct btrfs_path *p);
2931 void btrfs_unlock_up_safe(struct btrfs_path *p, int level);
2932 
2933 int btrfs_del_items(struct btrfs_trans_handle *trans, struct btrfs_root *root,
2934 		   struct btrfs_path *path, int slot, int nr);
2935 static inline int btrfs_del_item(struct btrfs_trans_handle *trans,
2936 				 struct btrfs_root *root,
2937 				 struct btrfs_path *path)
2938 {
2939 	return btrfs_del_items(trans, root, path, path->slots[0], 1);
2940 }
2941 
2942 void setup_items_for_insert(struct btrfs_root *root, struct btrfs_path *path,
2943 			    const struct btrfs_key *cpu_key, u32 *data_size,
2944 			    u32 total_data, u32 total_size, int nr);
2945 int btrfs_insert_item(struct btrfs_trans_handle *trans, struct btrfs_root *root,
2946 		      const struct btrfs_key *key, void *data, u32 data_size);
2947 int btrfs_insert_empty_items(struct btrfs_trans_handle *trans,
2948 			     struct btrfs_root *root,
2949 			     struct btrfs_path *path,
2950 			     const struct btrfs_key *cpu_key, u32 *data_size,
2951 			     int nr);
2952 
2953 static inline int btrfs_insert_empty_item(struct btrfs_trans_handle *trans,
2954 					  struct btrfs_root *root,
2955 					  struct btrfs_path *path,
2956 					  const struct btrfs_key *key,
2957 					  u32 data_size)
2958 {
2959 	return btrfs_insert_empty_items(trans, root, path, key, &data_size, 1);
2960 }
2961 
2962 int btrfs_next_leaf(struct btrfs_root *root, struct btrfs_path *path);
2963 int btrfs_prev_leaf(struct btrfs_root *root, struct btrfs_path *path);
2964 int btrfs_next_old_leaf(struct btrfs_root *root, struct btrfs_path *path,
2965 			u64 time_seq);
2966 static inline int btrfs_next_old_item(struct btrfs_root *root,
2967 				      struct btrfs_path *p, u64 time_seq)
2968 {
2969 	++p->slots[0];
2970 	if (p->slots[0] >= btrfs_header_nritems(p->nodes[0]))
2971 		return btrfs_next_old_leaf(root, p, time_seq);
2972 	return 0;
2973 }
2974 static inline int btrfs_next_item(struct btrfs_root *root, struct btrfs_path *p)
2975 {
2976 	return btrfs_next_old_item(root, p, 0);
2977 }
2978 int btrfs_leaf_free_space(struct btrfs_fs_info *fs_info,
2979 			  struct extent_buffer *leaf);
2980 int __must_check btrfs_drop_snapshot(struct btrfs_root *root,
2981 				     struct btrfs_block_rsv *block_rsv,
2982 				     int update_ref, int for_reloc);
2983 int btrfs_drop_subtree(struct btrfs_trans_handle *trans,
2984 			struct btrfs_root *root,
2985 			struct extent_buffer *node,
2986 			struct extent_buffer *parent);
2987 static inline int btrfs_fs_closing(struct btrfs_fs_info *fs_info)
2988 {
2989 	/*
2990 	 * Do it this way so we only ever do one test_bit in the normal case.
2991 	 */
2992 	if (test_bit(BTRFS_FS_CLOSING_START, &fs_info->flags)) {
2993 		if (test_bit(BTRFS_FS_CLOSING_DONE, &fs_info->flags))
2994 			return 2;
2995 		return 1;
2996 	}
2997 	return 0;
2998 }
2999 
3000 /*
3001  * If we remount the fs to be R/O or umount the fs, the cleaner needn't do
3002  * anything except sleeping. This function is used to check the status of
3003  * the fs.
3004  */
3005 static inline int btrfs_need_cleaner_sleep(struct btrfs_fs_info *fs_info)
3006 {
3007 	return fs_info->sb->s_flags & SB_RDONLY || btrfs_fs_closing(fs_info);
3008 }
3009 
3010 static inline void free_fs_info(struct btrfs_fs_info *fs_info)
3011 {
3012 	kfree(fs_info->balance_ctl);
3013 	kfree(fs_info->delayed_root);
3014 	kfree(fs_info->extent_root);
3015 	kfree(fs_info->tree_root);
3016 	kfree(fs_info->chunk_root);
3017 	kfree(fs_info->dev_root);
3018 	kfree(fs_info->csum_root);
3019 	kfree(fs_info->quota_root);
3020 	kfree(fs_info->uuid_root);
3021 	kfree(fs_info->free_space_root);
3022 	kfree(fs_info->super_copy);
3023 	kfree(fs_info->super_for_commit);
3024 	security_free_mnt_opts(&fs_info->security_opts);
3025 	kvfree(fs_info);
3026 }
3027 
3028 /* tree mod log functions from ctree.c */
3029 u64 btrfs_get_tree_mod_seq(struct btrfs_fs_info *fs_info,
3030 			   struct seq_list *elem);
3031 void btrfs_put_tree_mod_seq(struct btrfs_fs_info *fs_info,
3032 			    struct seq_list *elem);
3033 int btrfs_old_root_level(struct btrfs_root *root, u64 time_seq);
3034 
3035 /* root-item.c */
3036 int btrfs_add_root_ref(struct btrfs_trans_handle *trans, u64 root_id,
3037 		       u64 ref_id, u64 dirid, u64 sequence, const char *name,
3038 		       int name_len);
3039 int btrfs_del_root_ref(struct btrfs_trans_handle *trans, u64 root_id,
3040 		       u64 ref_id, u64 dirid, u64 *sequence, const char *name,
3041 		       int name_len);
3042 int btrfs_del_root(struct btrfs_trans_handle *trans,
3043 		   const struct btrfs_key *key);
3044 int btrfs_insert_root(struct btrfs_trans_handle *trans, struct btrfs_root *root,
3045 		      const struct btrfs_key *key,
3046 		      struct btrfs_root_item *item);
3047 int __must_check btrfs_update_root(struct btrfs_trans_handle *trans,
3048 				   struct btrfs_root *root,
3049 				   struct btrfs_key *key,
3050 				   struct btrfs_root_item *item);
3051 int btrfs_find_root(struct btrfs_root *root, const struct btrfs_key *search_key,
3052 		    struct btrfs_path *path, struct btrfs_root_item *root_item,
3053 		    struct btrfs_key *root_key);
3054 int btrfs_find_orphan_roots(struct btrfs_fs_info *fs_info);
3055 void btrfs_set_root_node(struct btrfs_root_item *item,
3056 			 struct extent_buffer *node);
3057 void btrfs_check_and_init_root_item(struct btrfs_root_item *item);
3058 void btrfs_update_root_times(struct btrfs_trans_handle *trans,
3059 			     struct btrfs_root *root);
3060 
3061 /* uuid-tree.c */
3062 int btrfs_uuid_tree_add(struct btrfs_trans_handle *trans, u8 *uuid, u8 type,
3063 			u64 subid);
3064 int btrfs_uuid_tree_remove(struct btrfs_trans_handle *trans, u8 *uuid, u8 type,
3065 			u64 subid);
3066 int btrfs_uuid_tree_iterate(struct btrfs_fs_info *fs_info,
3067 			    int (*check_func)(struct btrfs_fs_info *, u8 *, u8,
3068 					      u64));
3069 
3070 /* dir-item.c */
3071 int btrfs_check_dir_item_collision(struct btrfs_root *root, u64 dir,
3072 			  const char *name, int name_len);
3073 int btrfs_insert_dir_item(struct btrfs_trans_handle *trans, const char *name,
3074 			  int name_len, struct btrfs_inode *dir,
3075 			  struct btrfs_key *location, u8 type, u64 index);
3076 struct btrfs_dir_item *btrfs_lookup_dir_item(struct btrfs_trans_handle *trans,
3077 					     struct btrfs_root *root,
3078 					     struct btrfs_path *path, u64 dir,
3079 					     const char *name, int name_len,
3080 					     int mod);
3081 struct btrfs_dir_item *
3082 btrfs_lookup_dir_index_item(struct btrfs_trans_handle *trans,
3083 			    struct btrfs_root *root,
3084 			    struct btrfs_path *path, u64 dir,
3085 			    u64 objectid, const char *name, int name_len,
3086 			    int mod);
3087 struct btrfs_dir_item *
3088 btrfs_search_dir_index_item(struct btrfs_root *root,
3089 			    struct btrfs_path *path, u64 dirid,
3090 			    const char *name, int name_len);
3091 int btrfs_delete_one_dir_name(struct btrfs_trans_handle *trans,
3092 			      struct btrfs_root *root,
3093 			      struct btrfs_path *path,
3094 			      struct btrfs_dir_item *di);
3095 int btrfs_insert_xattr_item(struct btrfs_trans_handle *trans,
3096 			    struct btrfs_root *root,
3097 			    struct btrfs_path *path, u64 objectid,
3098 			    const char *name, u16 name_len,
3099 			    const void *data, u16 data_len);
3100 struct btrfs_dir_item *btrfs_lookup_xattr(struct btrfs_trans_handle *trans,
3101 					  struct btrfs_root *root,
3102 					  struct btrfs_path *path, u64 dir,
3103 					  const char *name, u16 name_len,
3104 					  int mod);
3105 struct btrfs_dir_item *btrfs_match_dir_item_name(struct btrfs_fs_info *fs_info,
3106 						 struct btrfs_path *path,
3107 						 const char *name,
3108 						 int name_len);
3109 
3110 /* orphan.c */
3111 int btrfs_insert_orphan_item(struct btrfs_trans_handle *trans,
3112 			     struct btrfs_root *root, u64 offset);
3113 int btrfs_del_orphan_item(struct btrfs_trans_handle *trans,
3114 			  struct btrfs_root *root, u64 offset);
3115 int btrfs_find_orphan_item(struct btrfs_root *root, u64 offset);
3116 
3117 /* inode-item.c */
3118 int btrfs_insert_inode_ref(struct btrfs_trans_handle *trans,
3119 			   struct btrfs_root *root,
3120 			   const char *name, int name_len,
3121 			   u64 inode_objectid, u64 ref_objectid, u64 index);
3122 int btrfs_del_inode_ref(struct btrfs_trans_handle *trans,
3123 			   struct btrfs_root *root,
3124 			   const char *name, int name_len,
3125 			   u64 inode_objectid, u64 ref_objectid, u64 *index);
3126 int btrfs_insert_empty_inode(struct btrfs_trans_handle *trans,
3127 			     struct btrfs_root *root,
3128 			     struct btrfs_path *path, u64 objectid);
3129 int btrfs_lookup_inode(struct btrfs_trans_handle *trans, struct btrfs_root
3130 		       *root, struct btrfs_path *path,
3131 		       struct btrfs_key *location, int mod);
3132 
3133 struct btrfs_inode_extref *
3134 btrfs_lookup_inode_extref(struct btrfs_trans_handle *trans,
3135 			  struct btrfs_root *root,
3136 			  struct btrfs_path *path,
3137 			  const char *name, int name_len,
3138 			  u64 inode_objectid, u64 ref_objectid, int ins_len,
3139 			  int cow);
3140 
3141 int btrfs_find_name_in_backref(struct extent_buffer *leaf, int slot,
3142 			       const char *name,
3143 			       int name_len, struct btrfs_inode_ref **ref_ret);
3144 int btrfs_find_name_in_ext_backref(struct extent_buffer *leaf, int slot,
3145 				   u64 ref_objectid, const char *name,
3146 				   int name_len,
3147 				   struct btrfs_inode_extref **extref_ret);
3148 
3149 /* file-item.c */
3150 struct btrfs_dio_private;
3151 int btrfs_del_csums(struct btrfs_trans_handle *trans,
3152 		    struct btrfs_fs_info *fs_info, u64 bytenr, u64 len);
3153 blk_status_t btrfs_lookup_bio_sums(struct inode *inode, struct bio *bio, u32 *dst);
3154 blk_status_t btrfs_lookup_bio_sums_dio(struct inode *inode, struct bio *bio,
3155 			      u64 logical_offset);
3156 int btrfs_insert_file_extent(struct btrfs_trans_handle *trans,
3157 			     struct btrfs_root *root,
3158 			     u64 objectid, u64 pos,
3159 			     u64 disk_offset, u64 disk_num_bytes,
3160 			     u64 num_bytes, u64 offset, u64 ram_bytes,
3161 			     u8 compression, u8 encryption, u16 other_encoding);
3162 int btrfs_lookup_file_extent(struct btrfs_trans_handle *trans,
3163 			     struct btrfs_root *root,
3164 			     struct btrfs_path *path, u64 objectid,
3165 			     u64 bytenr, int mod);
3166 int btrfs_csum_file_blocks(struct btrfs_trans_handle *trans,
3167 			   struct btrfs_root *root,
3168 			   struct btrfs_ordered_sum *sums);
3169 blk_status_t btrfs_csum_one_bio(struct inode *inode, struct bio *bio,
3170 		       u64 file_start, int contig);
3171 int btrfs_lookup_csums_range(struct btrfs_root *root, u64 start, u64 end,
3172 			     struct list_head *list, int search_commit);
3173 void btrfs_extent_item_to_extent_map(struct btrfs_inode *inode,
3174 				     const struct btrfs_path *path,
3175 				     struct btrfs_file_extent_item *fi,
3176 				     const bool new_inline,
3177 				     struct extent_map *em);
3178 
3179 /* inode.c */
3180 struct extent_map *btrfs_get_extent_fiemap(struct btrfs_inode *inode,
3181 		struct page *page, size_t pg_offset, u64 start,
3182 		u64 len, int create);
3183 noinline int can_nocow_extent(struct inode *inode, u64 offset, u64 *len,
3184 			      u64 *orig_start, u64 *orig_block_len,
3185 			      u64 *ram_bytes);
3186 
3187 void __btrfs_del_delalloc_inode(struct btrfs_root *root,
3188 				struct btrfs_inode *inode);
3189 struct inode *btrfs_lookup_dentry(struct inode *dir, struct dentry *dentry);
3190 int btrfs_set_inode_index(struct btrfs_inode *dir, u64 *index);
3191 int btrfs_unlink_inode(struct btrfs_trans_handle *trans,
3192 		       struct btrfs_root *root,
3193 		       struct btrfs_inode *dir, struct btrfs_inode *inode,
3194 		       const char *name, int name_len);
3195 int btrfs_add_link(struct btrfs_trans_handle *trans,
3196 		   struct btrfs_inode *parent_inode, struct btrfs_inode *inode,
3197 		   const char *name, int name_len, int add_backref, u64 index);
3198 int btrfs_delete_subvolume(struct inode *dir, struct dentry *dentry);
3199 int btrfs_truncate_block(struct inode *inode, loff_t from, loff_t len,
3200 			int front);
3201 int btrfs_truncate_inode_items(struct btrfs_trans_handle *trans,
3202 			       struct btrfs_root *root,
3203 			       struct inode *inode, u64 new_size,
3204 			       u32 min_type);
3205 
3206 int btrfs_start_delalloc_snapshot(struct btrfs_root *root);
3207 int btrfs_start_delalloc_roots(struct btrfs_fs_info *fs_info, int nr);
3208 int btrfs_set_extent_delalloc(struct inode *inode, u64 start, u64 end,
3209 			      unsigned int extra_bits,
3210 			      struct extent_state **cached_state, int dedupe);
3211 int btrfs_create_subvol_root(struct btrfs_trans_handle *trans,
3212 			     struct btrfs_root *new_root,
3213 			     struct btrfs_root *parent_root,
3214 			     u64 new_dirid);
3215  void btrfs_set_delalloc_extent(struct inode *inode, struct extent_state *state,
3216 			       unsigned *bits);
3217 void btrfs_clear_delalloc_extent(struct inode *inode,
3218 				 struct extent_state *state, unsigned *bits);
3219 void btrfs_merge_delalloc_extent(struct inode *inode, struct extent_state *new,
3220 				 struct extent_state *other);
3221 void btrfs_split_delalloc_extent(struct inode *inode,
3222 				 struct extent_state *orig, u64 split);
3223 int btrfs_bio_fits_in_stripe(struct page *page, size_t size, struct bio *bio,
3224 			     unsigned long bio_flags);
3225 void btrfs_set_range_writeback(struct extent_io_tree *tree, u64 start, u64 end);
3226 vm_fault_t btrfs_page_mkwrite(struct vm_fault *vmf);
3227 int btrfs_readpage(struct file *file, struct page *page);
3228 void btrfs_evict_inode(struct inode *inode);
3229 int btrfs_write_inode(struct inode *inode, struct writeback_control *wbc);
3230 struct inode *btrfs_alloc_inode(struct super_block *sb);
3231 void btrfs_destroy_inode(struct inode *inode);
3232 int btrfs_drop_inode(struct inode *inode);
3233 int __init btrfs_init_cachep(void);
3234 void __cold btrfs_destroy_cachep(void);
3235 struct inode *btrfs_iget_path(struct super_block *s, struct btrfs_key *location,
3236 			      struct btrfs_root *root, int *new,
3237 			      struct btrfs_path *path);
3238 struct inode *btrfs_iget(struct super_block *s, struct btrfs_key *location,
3239 			 struct btrfs_root *root, int *was_new);
3240 struct extent_map *btrfs_get_extent(struct btrfs_inode *inode,
3241 				    struct page *page, size_t pg_offset,
3242 				    u64 start, u64 end, int create);
3243 int btrfs_update_inode(struct btrfs_trans_handle *trans,
3244 			      struct btrfs_root *root,
3245 			      struct inode *inode);
3246 int btrfs_update_inode_fallback(struct btrfs_trans_handle *trans,
3247 				struct btrfs_root *root, struct inode *inode);
3248 int btrfs_orphan_add(struct btrfs_trans_handle *trans,
3249 		struct btrfs_inode *inode);
3250 int btrfs_orphan_cleanup(struct btrfs_root *root);
3251 int btrfs_cont_expand(struct inode *inode, loff_t oldsize, loff_t size);
3252 void btrfs_add_delayed_iput(struct inode *inode);
3253 void btrfs_run_delayed_iputs(struct btrfs_fs_info *fs_info);
3254 int btrfs_prealloc_file_range(struct inode *inode, int mode,
3255 			      u64 start, u64 num_bytes, u64 min_size,
3256 			      loff_t actual_len, u64 *alloc_hint);
3257 int btrfs_prealloc_file_range_trans(struct inode *inode,
3258 				    struct btrfs_trans_handle *trans, int mode,
3259 				    u64 start, u64 num_bytes, u64 min_size,
3260 				    loff_t actual_len, u64 *alloc_hint);
3261 int btrfs_run_delalloc_range(void *private_data, struct page *locked_page,
3262 		u64 start, u64 end, int *page_started, unsigned long *nr_written,
3263 		struct writeback_control *wbc);
3264 int btrfs_writepage_cow_fixup(struct page *page, u64 start, u64 end);
3265 void btrfs_writepage_endio_finish_ordered(struct page *page, u64 start,
3266 					  u64 end, int uptodate);
3267 extern const struct dentry_operations btrfs_dentry_operations;
3268 
3269 /* ioctl.c */
3270 long btrfs_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
3271 long btrfs_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
3272 int btrfs_ioctl_get_supported_features(void __user *arg);
3273 void btrfs_sync_inode_flags_to_i_flags(struct inode *inode);
3274 int btrfs_is_empty_uuid(u8 *uuid);
3275 int btrfs_defrag_file(struct inode *inode, struct file *file,
3276 		      struct btrfs_ioctl_defrag_range_args *range,
3277 		      u64 newer_than, unsigned long max_pages);
3278 void btrfs_get_block_group_info(struct list_head *groups_list,
3279 				struct btrfs_ioctl_space_info *space);
3280 void btrfs_update_ioctl_balance_args(struct btrfs_fs_info *fs_info,
3281 			       struct btrfs_ioctl_balance_args *bargs);
3282 
3283 /* file.c */
3284 int __init btrfs_auto_defrag_init(void);
3285 void __cold btrfs_auto_defrag_exit(void);
3286 int btrfs_add_inode_defrag(struct btrfs_trans_handle *trans,
3287 			   struct btrfs_inode *inode);
3288 int btrfs_run_defrag_inodes(struct btrfs_fs_info *fs_info);
3289 void btrfs_cleanup_defrag_inodes(struct btrfs_fs_info *fs_info);
3290 int btrfs_sync_file(struct file *file, loff_t start, loff_t end, int datasync);
3291 void btrfs_drop_extent_cache(struct btrfs_inode *inode, u64 start, u64 end,
3292 			     int skip_pinned);
3293 extern const struct file_operations btrfs_file_operations;
3294 int __btrfs_drop_extents(struct btrfs_trans_handle *trans,
3295 			 struct btrfs_root *root, struct inode *inode,
3296 			 struct btrfs_path *path, u64 start, u64 end,
3297 			 u64 *drop_end, int drop_cache,
3298 			 int replace_extent,
3299 			 u32 extent_item_size,
3300 			 int *key_inserted);
3301 int btrfs_drop_extents(struct btrfs_trans_handle *trans,
3302 		       struct btrfs_root *root, struct inode *inode, u64 start,
3303 		       u64 end, int drop_cache);
3304 int btrfs_mark_extent_written(struct btrfs_trans_handle *trans,
3305 			      struct btrfs_inode *inode, u64 start, u64 end);
3306 int btrfs_release_file(struct inode *inode, struct file *file);
3307 int btrfs_dirty_pages(struct inode *inode, struct page **pages,
3308 		      size_t num_pages, loff_t pos, size_t write_bytes,
3309 		      struct extent_state **cached);
3310 int btrfs_fdatawrite_range(struct inode *inode, loff_t start, loff_t end);
3311 loff_t btrfs_remap_file_range(struct file *file_in, loff_t pos_in,
3312 			      struct file *file_out, loff_t pos_out,
3313 			      loff_t len, unsigned int remap_flags);
3314 
3315 /* tree-defrag.c */
3316 int btrfs_defrag_leaves(struct btrfs_trans_handle *trans,
3317 			struct btrfs_root *root);
3318 
3319 /* sysfs.c */
3320 int __init btrfs_init_sysfs(void);
3321 void __cold btrfs_exit_sysfs(void);
3322 int btrfs_sysfs_add_mounted(struct btrfs_fs_info *fs_info);
3323 void btrfs_sysfs_remove_mounted(struct btrfs_fs_info *fs_info);
3324 
3325 /* super.c */
3326 int btrfs_parse_options(struct btrfs_fs_info *info, char *options,
3327 			unsigned long new_flags);
3328 int btrfs_sync_fs(struct super_block *sb, int wait);
3329 
3330 static inline __printf(2, 3) __cold
3331 void btrfs_no_printk(const struct btrfs_fs_info *fs_info, const char *fmt, ...)
3332 {
3333 }
3334 
3335 #ifdef CONFIG_PRINTK
3336 __printf(2, 3)
3337 __cold
3338 void btrfs_printk(const struct btrfs_fs_info *fs_info, const char *fmt, ...);
3339 #else
3340 #define btrfs_printk(fs_info, fmt, args...) \
3341 	btrfs_no_printk(fs_info, fmt, ##args)
3342 #endif
3343 
3344 #define btrfs_emerg(fs_info, fmt, args...) \
3345 	btrfs_printk(fs_info, KERN_EMERG fmt, ##args)
3346 #define btrfs_alert(fs_info, fmt, args...) \
3347 	btrfs_printk(fs_info, KERN_ALERT fmt, ##args)
3348 #define btrfs_crit(fs_info, fmt, args...) \
3349 	btrfs_printk(fs_info, KERN_CRIT fmt, ##args)
3350 #define btrfs_err(fs_info, fmt, args...) \
3351 	btrfs_printk(fs_info, KERN_ERR fmt, ##args)
3352 #define btrfs_warn(fs_info, fmt, args...) \
3353 	btrfs_printk(fs_info, KERN_WARNING fmt, ##args)
3354 #define btrfs_notice(fs_info, fmt, args...) \
3355 	btrfs_printk(fs_info, KERN_NOTICE fmt, ##args)
3356 #define btrfs_info(fs_info, fmt, args...) \
3357 	btrfs_printk(fs_info, KERN_INFO fmt, ##args)
3358 
3359 /*
3360  * Wrappers that use printk_in_rcu
3361  */
3362 #define btrfs_emerg_in_rcu(fs_info, fmt, args...) \
3363 	btrfs_printk_in_rcu(fs_info, KERN_EMERG fmt, ##args)
3364 #define btrfs_alert_in_rcu(fs_info, fmt, args...) \
3365 	btrfs_printk_in_rcu(fs_info, KERN_ALERT fmt, ##args)
3366 #define btrfs_crit_in_rcu(fs_info, fmt, args...) \
3367 	btrfs_printk_in_rcu(fs_info, KERN_CRIT fmt, ##args)
3368 #define btrfs_err_in_rcu(fs_info, fmt, args...) \
3369 	btrfs_printk_in_rcu(fs_info, KERN_ERR fmt, ##args)
3370 #define btrfs_warn_in_rcu(fs_info, fmt, args...) \
3371 	btrfs_printk_in_rcu(fs_info, KERN_WARNING fmt, ##args)
3372 #define btrfs_notice_in_rcu(fs_info, fmt, args...) \
3373 	btrfs_printk_in_rcu(fs_info, KERN_NOTICE fmt, ##args)
3374 #define btrfs_info_in_rcu(fs_info, fmt, args...) \
3375 	btrfs_printk_in_rcu(fs_info, KERN_INFO fmt, ##args)
3376 
3377 /*
3378  * Wrappers that use a ratelimited printk_in_rcu
3379  */
3380 #define btrfs_emerg_rl_in_rcu(fs_info, fmt, args...) \
3381 	btrfs_printk_rl_in_rcu(fs_info, KERN_EMERG fmt, ##args)
3382 #define btrfs_alert_rl_in_rcu(fs_info, fmt, args...) \
3383 	btrfs_printk_rl_in_rcu(fs_info, KERN_ALERT fmt, ##args)
3384 #define btrfs_crit_rl_in_rcu(fs_info, fmt, args...) \
3385 	btrfs_printk_rl_in_rcu(fs_info, KERN_CRIT fmt, ##args)
3386 #define btrfs_err_rl_in_rcu(fs_info, fmt, args...) \
3387 	btrfs_printk_rl_in_rcu(fs_info, KERN_ERR fmt, ##args)
3388 #define btrfs_warn_rl_in_rcu(fs_info, fmt, args...) \
3389 	btrfs_printk_rl_in_rcu(fs_info, KERN_WARNING fmt, ##args)
3390 #define btrfs_notice_rl_in_rcu(fs_info, fmt, args...) \
3391 	btrfs_printk_rl_in_rcu(fs_info, KERN_NOTICE fmt, ##args)
3392 #define btrfs_info_rl_in_rcu(fs_info, fmt, args...) \
3393 	btrfs_printk_rl_in_rcu(fs_info, KERN_INFO fmt, ##args)
3394 
3395 /*
3396  * Wrappers that use a ratelimited printk
3397  */
3398 #define btrfs_emerg_rl(fs_info, fmt, args...) \
3399 	btrfs_printk_ratelimited(fs_info, KERN_EMERG fmt, ##args)
3400 #define btrfs_alert_rl(fs_info, fmt, args...) \
3401 	btrfs_printk_ratelimited(fs_info, KERN_ALERT fmt, ##args)
3402 #define btrfs_crit_rl(fs_info, fmt, args...) \
3403 	btrfs_printk_ratelimited(fs_info, KERN_CRIT fmt, ##args)
3404 #define btrfs_err_rl(fs_info, fmt, args...) \
3405 	btrfs_printk_ratelimited(fs_info, KERN_ERR fmt, ##args)
3406 #define btrfs_warn_rl(fs_info, fmt, args...) \
3407 	btrfs_printk_ratelimited(fs_info, KERN_WARNING fmt, ##args)
3408 #define btrfs_notice_rl(fs_info, fmt, args...) \
3409 	btrfs_printk_ratelimited(fs_info, KERN_NOTICE fmt, ##args)
3410 #define btrfs_info_rl(fs_info, fmt, args...) \
3411 	btrfs_printk_ratelimited(fs_info, KERN_INFO fmt, ##args)
3412 
3413 #if defined(CONFIG_DYNAMIC_DEBUG)
3414 #define btrfs_debug(fs_info, fmt, args...)				\
3415 do {									\
3416         DEFINE_DYNAMIC_DEBUG_METADATA(descriptor, fmt);         	\
3417         if (unlikely(descriptor.flags & _DPRINTK_FLAGS_PRINT))  	\
3418 		btrfs_printk(fs_info, KERN_DEBUG fmt, ##args);		\
3419 } while (0)
3420 #define btrfs_debug_in_rcu(fs_info, fmt, args...) 			\
3421 do {									\
3422         DEFINE_DYNAMIC_DEBUG_METADATA(descriptor, fmt); 	        \
3423         if (unlikely(descriptor.flags & _DPRINTK_FLAGS_PRINT)) 		\
3424 		btrfs_printk_in_rcu(fs_info, KERN_DEBUG fmt, ##args);	\
3425 } while (0)
3426 #define btrfs_debug_rl_in_rcu(fs_info, fmt, args...)			\
3427 do {									\
3428         DEFINE_DYNAMIC_DEBUG_METADATA(descriptor, fmt);         	\
3429         if (unlikely(descriptor.flags & _DPRINTK_FLAGS_PRINT))  	\
3430 		btrfs_printk_rl_in_rcu(fs_info, KERN_DEBUG fmt,		\
3431 				       ##args);\
3432 } while (0)
3433 #define btrfs_debug_rl(fs_info, fmt, args...) 				\
3434 do {									\
3435         DEFINE_DYNAMIC_DEBUG_METADATA(descriptor, fmt);         	\
3436         if (unlikely(descriptor.flags & _DPRINTK_FLAGS_PRINT))  	\
3437 		btrfs_printk_ratelimited(fs_info, KERN_DEBUG fmt,	\
3438 					 ##args);			\
3439 } while (0)
3440 #elif defined(DEBUG)
3441 #define btrfs_debug(fs_info, fmt, args...) \
3442 	btrfs_printk(fs_info, KERN_DEBUG fmt, ##args)
3443 #define btrfs_debug_in_rcu(fs_info, fmt, args...) \
3444 	btrfs_printk_in_rcu(fs_info, KERN_DEBUG fmt, ##args)
3445 #define btrfs_debug_rl_in_rcu(fs_info, fmt, args...) \
3446 	btrfs_printk_rl_in_rcu(fs_info, KERN_DEBUG fmt, ##args)
3447 #define btrfs_debug_rl(fs_info, fmt, args...) \
3448 	btrfs_printk_ratelimited(fs_info, KERN_DEBUG fmt, ##args)
3449 #else
3450 #define btrfs_debug(fs_info, fmt, args...) \
3451 	btrfs_no_printk(fs_info, KERN_DEBUG fmt, ##args)
3452 #define btrfs_debug_in_rcu(fs_info, fmt, args...) \
3453 	btrfs_no_printk_in_rcu(fs_info, KERN_DEBUG fmt, ##args)
3454 #define btrfs_debug_rl_in_rcu(fs_info, fmt, args...) \
3455 	btrfs_no_printk_in_rcu(fs_info, KERN_DEBUG fmt, ##args)
3456 #define btrfs_debug_rl(fs_info, fmt, args...) \
3457 	btrfs_no_printk(fs_info, KERN_DEBUG fmt, ##args)
3458 #endif
3459 
3460 #define btrfs_printk_in_rcu(fs_info, fmt, args...)	\
3461 do {							\
3462 	rcu_read_lock();				\
3463 	btrfs_printk(fs_info, fmt, ##args);		\
3464 	rcu_read_unlock();				\
3465 } while (0)
3466 
3467 #define btrfs_no_printk_in_rcu(fs_info, fmt, args...)	\
3468 do {							\
3469 	rcu_read_lock();				\
3470 	btrfs_no_printk(fs_info, fmt, ##args);		\
3471 	rcu_read_unlock();				\
3472 } while (0)
3473 
3474 #define btrfs_printk_ratelimited(fs_info, fmt, args...)		\
3475 do {								\
3476 	static DEFINE_RATELIMIT_STATE(_rs,			\
3477 		DEFAULT_RATELIMIT_INTERVAL,			\
3478 		DEFAULT_RATELIMIT_BURST);       		\
3479 	if (__ratelimit(&_rs))					\
3480 		btrfs_printk(fs_info, fmt, ##args);		\
3481 } while (0)
3482 
3483 #define btrfs_printk_rl_in_rcu(fs_info, fmt, args...)		\
3484 do {								\
3485 	rcu_read_lock();					\
3486 	btrfs_printk_ratelimited(fs_info, fmt, ##args);		\
3487 	rcu_read_unlock();					\
3488 } while (0)
3489 
3490 #ifdef CONFIG_BTRFS_ASSERT
3491 
3492 __cold
3493 static inline void assfail(const char *expr, const char *file, int line)
3494 {
3495 	pr_err("assertion failed: %s, file: %s, line: %d\n",
3496 	       expr, file, line);
3497 	BUG();
3498 }
3499 
3500 #define ASSERT(expr)	\
3501 	(likely(expr) ? (void)0 : assfail(#expr, __FILE__, __LINE__))
3502 #else
3503 #define ASSERT(expr)	((void)0)
3504 #endif
3505 
3506 /*
3507  * Use that for functions that are conditionally exported for sanity tests but
3508  * otherwise static
3509  */
3510 #ifndef CONFIG_BTRFS_FS_RUN_SANITY_TESTS
3511 #define EXPORT_FOR_TESTS static
3512 #else
3513 #define EXPORT_FOR_TESTS
3514 #endif
3515 
3516 __cold
3517 static inline void btrfs_print_v0_err(struct btrfs_fs_info *fs_info)
3518 {
3519 	btrfs_err(fs_info,
3520 "Unsupported V0 extent filesystem detected. Aborting. Please re-create your filesystem with a newer kernel");
3521 }
3522 
3523 __printf(5, 6)
3524 __cold
3525 void __btrfs_handle_fs_error(struct btrfs_fs_info *fs_info, const char *function,
3526 		     unsigned int line, int errno, const char *fmt, ...);
3527 
3528 const char *btrfs_decode_error(int errno);
3529 
3530 __cold
3531 void __btrfs_abort_transaction(struct btrfs_trans_handle *trans,
3532 			       const char *function,
3533 			       unsigned int line, int errno);
3534 
3535 /*
3536  * Call btrfs_abort_transaction as early as possible when an error condition is
3537  * detected, that way the exact line number is reported.
3538  */
3539 #define btrfs_abort_transaction(trans, errno)		\
3540 do {								\
3541 	/* Report first abort since mount */			\
3542 	if (!test_and_set_bit(BTRFS_FS_STATE_TRANS_ABORTED,	\
3543 			&((trans)->fs_info->fs_state))) {	\
3544 		if ((errno) != -EIO) {				\
3545 			WARN(1, KERN_DEBUG				\
3546 			"BTRFS: Transaction aborted (error %d)\n",	\
3547 			(errno));					\
3548 		} else {						\
3549 			btrfs_debug((trans)->fs_info,			\
3550 				    "Transaction aborted (error %d)", \
3551 				  (errno));			\
3552 		}						\
3553 	}							\
3554 	__btrfs_abort_transaction((trans), __func__,		\
3555 				  __LINE__, (errno));		\
3556 } while (0)
3557 
3558 #define btrfs_handle_fs_error(fs_info, errno, fmt, args...)		\
3559 do {								\
3560 	__btrfs_handle_fs_error((fs_info), __func__, __LINE__,	\
3561 			  (errno), fmt, ##args);		\
3562 } while (0)
3563 
3564 __printf(5, 6)
3565 __cold
3566 void __btrfs_panic(struct btrfs_fs_info *fs_info, const char *function,
3567 		   unsigned int line, int errno, const char *fmt, ...);
3568 /*
3569  * If BTRFS_MOUNT_PANIC_ON_FATAL_ERROR is in mount_opt, __btrfs_panic
3570  * will panic().  Otherwise we BUG() here.
3571  */
3572 #define btrfs_panic(fs_info, errno, fmt, args...)			\
3573 do {									\
3574 	__btrfs_panic(fs_info, __func__, __LINE__, errno, fmt, ##args);	\
3575 	BUG();								\
3576 } while (0)
3577 
3578 
3579 /* compatibility and incompatibility defines */
3580 
3581 #define btrfs_set_fs_incompat(__fs_info, opt) \
3582 	__btrfs_set_fs_incompat((__fs_info), BTRFS_FEATURE_INCOMPAT_##opt)
3583 
3584 static inline void __btrfs_set_fs_incompat(struct btrfs_fs_info *fs_info,
3585 					   u64 flag)
3586 {
3587 	struct btrfs_super_block *disk_super;
3588 	u64 features;
3589 
3590 	disk_super = fs_info->super_copy;
3591 	features = btrfs_super_incompat_flags(disk_super);
3592 	if (!(features & flag)) {
3593 		spin_lock(&fs_info->super_lock);
3594 		features = btrfs_super_incompat_flags(disk_super);
3595 		if (!(features & flag)) {
3596 			features |= flag;
3597 			btrfs_set_super_incompat_flags(disk_super, features);
3598 			btrfs_info(fs_info, "setting %llu feature flag",
3599 					 flag);
3600 		}
3601 		spin_unlock(&fs_info->super_lock);
3602 	}
3603 }
3604 
3605 #define btrfs_clear_fs_incompat(__fs_info, opt) \
3606 	__btrfs_clear_fs_incompat((__fs_info), BTRFS_FEATURE_INCOMPAT_##opt)
3607 
3608 static inline void __btrfs_clear_fs_incompat(struct btrfs_fs_info *fs_info,
3609 					     u64 flag)
3610 {
3611 	struct btrfs_super_block *disk_super;
3612 	u64 features;
3613 
3614 	disk_super = fs_info->super_copy;
3615 	features = btrfs_super_incompat_flags(disk_super);
3616 	if (features & flag) {
3617 		spin_lock(&fs_info->super_lock);
3618 		features = btrfs_super_incompat_flags(disk_super);
3619 		if (features & flag) {
3620 			features &= ~flag;
3621 			btrfs_set_super_incompat_flags(disk_super, features);
3622 			btrfs_info(fs_info, "clearing %llu feature flag",
3623 					 flag);
3624 		}
3625 		spin_unlock(&fs_info->super_lock);
3626 	}
3627 }
3628 
3629 #define btrfs_fs_incompat(fs_info, opt) \
3630 	__btrfs_fs_incompat((fs_info), BTRFS_FEATURE_INCOMPAT_##opt)
3631 
3632 static inline bool __btrfs_fs_incompat(struct btrfs_fs_info *fs_info, u64 flag)
3633 {
3634 	struct btrfs_super_block *disk_super;
3635 	disk_super = fs_info->super_copy;
3636 	return !!(btrfs_super_incompat_flags(disk_super) & flag);
3637 }
3638 
3639 #define btrfs_set_fs_compat_ro(__fs_info, opt) \
3640 	__btrfs_set_fs_compat_ro((__fs_info), BTRFS_FEATURE_COMPAT_RO_##opt)
3641 
3642 static inline void __btrfs_set_fs_compat_ro(struct btrfs_fs_info *fs_info,
3643 					    u64 flag)
3644 {
3645 	struct btrfs_super_block *disk_super;
3646 	u64 features;
3647 
3648 	disk_super = fs_info->super_copy;
3649 	features = btrfs_super_compat_ro_flags(disk_super);
3650 	if (!(features & flag)) {
3651 		spin_lock(&fs_info->super_lock);
3652 		features = btrfs_super_compat_ro_flags(disk_super);
3653 		if (!(features & flag)) {
3654 			features |= flag;
3655 			btrfs_set_super_compat_ro_flags(disk_super, features);
3656 			btrfs_info(fs_info, "setting %llu ro feature flag",
3657 				   flag);
3658 		}
3659 		spin_unlock(&fs_info->super_lock);
3660 	}
3661 }
3662 
3663 #define btrfs_clear_fs_compat_ro(__fs_info, opt) \
3664 	__btrfs_clear_fs_compat_ro((__fs_info), BTRFS_FEATURE_COMPAT_RO_##opt)
3665 
3666 static inline void __btrfs_clear_fs_compat_ro(struct btrfs_fs_info *fs_info,
3667 					      u64 flag)
3668 {
3669 	struct btrfs_super_block *disk_super;
3670 	u64 features;
3671 
3672 	disk_super = fs_info->super_copy;
3673 	features = btrfs_super_compat_ro_flags(disk_super);
3674 	if (features & flag) {
3675 		spin_lock(&fs_info->super_lock);
3676 		features = btrfs_super_compat_ro_flags(disk_super);
3677 		if (features & flag) {
3678 			features &= ~flag;
3679 			btrfs_set_super_compat_ro_flags(disk_super, features);
3680 			btrfs_info(fs_info, "clearing %llu ro feature flag",
3681 				   flag);
3682 		}
3683 		spin_unlock(&fs_info->super_lock);
3684 	}
3685 }
3686 
3687 #define btrfs_fs_compat_ro(fs_info, opt) \
3688 	__btrfs_fs_compat_ro((fs_info), BTRFS_FEATURE_COMPAT_RO_##opt)
3689 
3690 static inline int __btrfs_fs_compat_ro(struct btrfs_fs_info *fs_info, u64 flag)
3691 {
3692 	struct btrfs_super_block *disk_super;
3693 	disk_super = fs_info->super_copy;
3694 	return !!(btrfs_super_compat_ro_flags(disk_super) & flag);
3695 }
3696 
3697 /* acl.c */
3698 #ifdef CONFIG_BTRFS_FS_POSIX_ACL
3699 struct posix_acl *btrfs_get_acl(struct inode *inode, int type);
3700 int btrfs_set_acl(struct inode *inode, struct posix_acl *acl, int type);
3701 int btrfs_init_acl(struct btrfs_trans_handle *trans,
3702 		   struct inode *inode, struct inode *dir);
3703 #else
3704 #define btrfs_get_acl NULL
3705 #define btrfs_set_acl NULL
3706 static inline int btrfs_init_acl(struct btrfs_trans_handle *trans,
3707 				 struct inode *inode, struct inode *dir)
3708 {
3709 	return 0;
3710 }
3711 #endif
3712 
3713 /* relocation.c */
3714 int btrfs_relocate_block_group(struct btrfs_fs_info *fs_info, u64 group_start);
3715 int btrfs_init_reloc_root(struct btrfs_trans_handle *trans,
3716 			  struct btrfs_root *root);
3717 int btrfs_update_reloc_root(struct btrfs_trans_handle *trans,
3718 			    struct btrfs_root *root);
3719 int btrfs_recover_relocation(struct btrfs_root *root);
3720 int btrfs_reloc_clone_csums(struct inode *inode, u64 file_pos, u64 len);
3721 int btrfs_reloc_cow_block(struct btrfs_trans_handle *trans,
3722 			  struct btrfs_root *root, struct extent_buffer *buf,
3723 			  struct extent_buffer *cow);
3724 void btrfs_reloc_pre_snapshot(struct btrfs_pending_snapshot *pending,
3725 			      u64 *bytes_to_reserve);
3726 int btrfs_reloc_post_snapshot(struct btrfs_trans_handle *trans,
3727 			      struct btrfs_pending_snapshot *pending);
3728 
3729 /* scrub.c */
3730 int btrfs_scrub_dev(struct btrfs_fs_info *fs_info, u64 devid, u64 start,
3731 		    u64 end, struct btrfs_scrub_progress *progress,
3732 		    int readonly, int is_dev_replace);
3733 void btrfs_scrub_pause(struct btrfs_fs_info *fs_info);
3734 void btrfs_scrub_continue(struct btrfs_fs_info *fs_info);
3735 int btrfs_scrub_cancel(struct btrfs_fs_info *info);
3736 int btrfs_scrub_cancel_dev(struct btrfs_fs_info *info,
3737 			   struct btrfs_device *dev);
3738 int btrfs_scrub_progress(struct btrfs_fs_info *fs_info, u64 devid,
3739 			 struct btrfs_scrub_progress *progress);
3740 static inline void btrfs_init_full_stripe_locks_tree(
3741 			struct btrfs_full_stripe_locks_tree *locks_root)
3742 {
3743 	locks_root->root = RB_ROOT;
3744 	mutex_init(&locks_root->lock);
3745 }
3746 
3747 /* dev-replace.c */
3748 void btrfs_bio_counter_inc_blocked(struct btrfs_fs_info *fs_info);
3749 void btrfs_bio_counter_inc_noblocked(struct btrfs_fs_info *fs_info);
3750 void btrfs_bio_counter_sub(struct btrfs_fs_info *fs_info, s64 amount);
3751 
3752 static inline void btrfs_bio_counter_dec(struct btrfs_fs_info *fs_info)
3753 {
3754 	btrfs_bio_counter_sub(fs_info, 1);
3755 }
3756 
3757 /* reada.c */
3758 struct reada_control {
3759 	struct btrfs_fs_info	*fs_info;		/* tree to prefetch */
3760 	struct btrfs_key	key_start;
3761 	struct btrfs_key	key_end;	/* exclusive */
3762 	atomic_t		elems;
3763 	struct kref		refcnt;
3764 	wait_queue_head_t	wait;
3765 };
3766 struct reada_control *btrfs_reada_add(struct btrfs_root *root,
3767 			      struct btrfs_key *start, struct btrfs_key *end);
3768 int btrfs_reada_wait(void *handle);
3769 void btrfs_reada_detach(void *handle);
3770 int btree_readahead_hook(struct extent_buffer *eb, int err);
3771 
3772 static inline int is_fstree(u64 rootid)
3773 {
3774 	if (rootid == BTRFS_FS_TREE_OBJECTID ||
3775 	    ((s64)rootid >= (s64)BTRFS_FIRST_FREE_OBJECTID &&
3776 	      !btrfs_qgroup_level(rootid)))
3777 		return 1;
3778 	return 0;
3779 }
3780 
3781 static inline int btrfs_defrag_cancelled(struct btrfs_fs_info *fs_info)
3782 {
3783 	return signal_pending(current);
3784 }
3785 
3786 /* Sanity test specific functions */
3787 #ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS
3788 void btrfs_test_inode_set_ops(struct inode *inode);
3789 void btrfs_test_destroy_inode(struct inode *inode);
3790 
3791 static inline int btrfs_is_testing(struct btrfs_fs_info *fs_info)
3792 {
3793 	return test_bit(BTRFS_FS_STATE_DUMMY_FS_INFO, &fs_info->fs_state);
3794 }
3795 #else
3796 static inline int btrfs_is_testing(struct btrfs_fs_info *fs_info)
3797 {
3798 	return 0;
3799 }
3800 #endif
3801 
3802 static inline void cond_wake_up(struct wait_queue_head *wq)
3803 {
3804 	/*
3805 	 * This implies a full smp_mb barrier, see comments for
3806 	 * waitqueue_active why.
3807 	 */
3808 	if (wq_has_sleeper(wq))
3809 		wake_up(wq);
3810 }
3811 
3812 static inline void cond_wake_up_nomb(struct wait_queue_head *wq)
3813 {
3814 	/*
3815 	 * Special case for conditional wakeup where the barrier required for
3816 	 * waitqueue_active is implied by some of the preceding code. Eg. one
3817 	 * of such atomic operations (atomic_dec_and_return, ...), or a
3818 	 * unlock/lock sequence, etc.
3819 	 */
3820 	if (waitqueue_active(wq))
3821 		wake_up(wq);
3822 }
3823 
3824 #endif
3825