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