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