~hc/RK356X_SDK_RELEASE.git

..	..	@@ -16,9 +16,9 @@
16	16	#include <linux/backing-dev.h>
17	17	#include <linux/wait.h>
18	18	#include <linux/slab.h>
19		-#include <linux/kobject.h>
20	19	#include <trace/events/btrfs.h>
21	20	#include <asm/kmap_types.h>
	21	+#include <asm/unaligned.h>
22	22	#include <linux/pagemap.h>
23	23	#include <linux/btrfs.h>
24	24	#include <linux/btrfs_tree.h>
..	..	@@ -28,29 +28,39 @@
28	28	#include <linux/dynamic_debug.h>
29	29	#include <linux/refcount.h>
30	30	#include <linux/crc32c.h>
	31	+#include "extent-io-tree.h"
31	32	#include "extent_io.h"
32	33	#include "extent_map.h"
33	34	#include "async-thread.h"
	35	+#include "block-rsv.h"
	36	+#include "locking.h"
34	37
35	38	struct btrfs_trans_handle;
36	39	struct btrfs_transaction;
37	40	struct btrfs_pending_snapshot;
	41	+struct btrfs_delayed_ref_root;
	42	+struct btrfs_space_info;
	43	+struct btrfs_block_group;
38	44	extern struct kmem_cache *btrfs_trans_handle_cachep;
39	45	extern struct kmem_cache *btrfs_bit_radix_cachep;
40	46	extern struct kmem_cache *btrfs_path_cachep;
41	47	extern struct kmem_cache *btrfs_free_space_cachep;
42	48	extern struct kmem_cache *btrfs_free_space_bitmap_cachep;
43	49	struct btrfs_ordered_sum;
44		-
45		-#ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS
46		-#define STATIC noinline
47		-#else
48		-#define STATIC static noinline
49		-#endif
	50	+struct btrfs_ref;
50	51
51	52	#define BTRFS_MAGIC 0x4D5F53665248425FULL /* ascii _BHRfS_M, no null */
52	53
53		-#define BTRFS_MAX_MIRRORS 3
	54	+/*
	55	+ * Maximum number of mirrors that can be available for all profiles counting
	56	+ * the target device of dev-replace as one. During an active device replace
	57	+ * procedure, the target device of the copy operation is a mirror for the
	58	+ * filesystem data as well that can be used to read data in order to repair
	59	+ * read errors on other disks.
	60	+ *
	61	+ * Current value is derived from RAID1C4 with 4 copies.
	62	+ */
	63	+#define BTRFS_MAX_MIRRORS (4 + 1)
54	64
55	65	#define BTRFS_MAX_LEVEL 8
56	66
..	..	@@ -75,9 +85,6 @@
75	85	*/
76	86	#define BTRFS_LINK_MAX 65535U
77	87
78		-/* four bytes for CRC32 */
79		-static const int btrfs_csum_sizes[] = { 4 };
80		-
81	88	#define BTRFS_EMPTY_DIR_SIZE 0
82	89
83	90	/* ioprio of readahead is set to idle */
..	..	@@ -95,6 +102,14 @@
95	102
96	103	#define BTRFS_MAX_EXTENT_SIZE SZ_128M
97	104
	105	+/*
	106	+ * Deltas are an effective way to populate global statistics. Give macro names
	107	+ * to make it clear what we're doing. An example is discard_extents in
	108	+ * btrfs_free_space_ctl.
	109	+ */
	110	+#define BTRFS_STAT_NR_ENTRIES 2
	111	+#define BTRFS_STAT_CURR 0
	112	+#define BTRFS_STAT_PREV 1
98	113
99	114	/*
100	115	* Count how many BTRFS_MAX_EXTENT_SIZE cover the @size
..	..	@@ -104,10 +119,6 @@
104	119	return div_u64(size + BTRFS_MAX_EXTENT_SIZE - 1, BTRFS_MAX_EXTENT_SIZE);
105	120	}
106	121
107		-struct btrfs_mapping_tree {
108		- struct extent_map_tree map_tree;
109		-};
110		-
111	122	static inline unsigned long btrfs_chunk_item_size(int num_stripes)
112	123	{
113	124	BUG_ON(num_stripes == 0);
..	..	@@ -116,13 +127,26 @@
116	127	}
117	128
118	129	/*
119		- * File system states
	130	+ * Runtime (in-memory) states of filesystem
120	131	*/
121		-#define BTRFS_FS_STATE_ERROR 0
122		-#define BTRFS_FS_STATE_REMOUNTING 1
123		-#define BTRFS_FS_STATE_TRANS_ABORTED 2
124		-#define BTRFS_FS_STATE_DEV_REPLACING 3
125		-#define BTRFS_FS_STATE_DUMMY_FS_INFO 4
	132	+enum {
	133	+ /* Global indicator of serious filesystem errors */
	134	+ BTRFS_FS_STATE_ERROR,
	135	+ /*
	136	+ * Filesystem is being remounted, allow to skip some operations, like
	137	+ * defrag
	138	+ */
	139	+ BTRFS_FS_STATE_REMOUNTING,
	140	+ /* Track if a transaction abort has been reported on this filesystem */
	141	+ BTRFS_FS_STATE_TRANS_ABORTED,
	142	+ /*
	143	+ * Bio operations should be blocked on this filesystem because a source
	144	+ * or target device is being destroyed as part of a device replace
	145	+ */
	146	+ BTRFS_FS_STATE_DEV_REPLACING,
	147	+ /* The btrfs_fs_info created for self-tests */
	148	+ BTRFS_FS_STATE_DUMMY_FS_INFO,
	149	+};
126	150
127	151	#define BTRFS_BACKREF_REV_MAX 256
128	152	#define BTRFS_BACKREF_REV_SHIFT 56
..	..	@@ -202,9 +226,10 @@
202	226	* it currently lacks any block count etc etc
203	227	*/
204	228	struct btrfs_super_block {
205		- u8 csum[BTRFS_CSUM_SIZE];
206	229	/* the first 4 fields must match struct btrfs_header */
207		- u8 fsid[BTRFS_FSID_SIZE]; /* FS specific uuid */
	230	+ u8 csum[BTRFS_CSUM_SIZE];
	231	+ /* FS specific UUID, visible to user */
	232	+ u8 fsid[BTRFS_FSID_SIZE];
208	233	__le64 bytenr; /* this block number */
209	234	__le64 flags;
210	235
..	..	@@ -241,8 +266,11 @@
241	266	__le64 cache_generation;
242	267	__le64 uuid_tree_generation;
243	268
	269	+ /* the UUID written into btree blocks */
	270	+ u8 metadata_uuid[BTRFS_FSID_SIZE];
	271	+
244	272	/* future expansion */
245		- __le64 reserved[30];
	273	+ __le64 reserved[28];
246	274	u8 sys_chunk_array[BTRFS_SYSTEM_CHUNK_ARRAY_SIZE];
247	275	struct btrfs_root_backup super_roots[BTRFS_NUM_BACKUP_ROOTS];
248	276	} __attribute__ ((__packed__));
..	..	@@ -272,7 +300,9 @@
272	300	BTRFS_FEATURE_INCOMPAT_RAID56 \| \
273	301	BTRFS_FEATURE_INCOMPAT_EXTENDED_IREF \| \
274	302	BTRFS_FEATURE_INCOMPAT_SKINNY_METADATA \| \
275		- BTRFS_FEATURE_INCOMPAT_NO_HOLES)
	303	+ BTRFS_FEATURE_INCOMPAT_NO_HOLES \| \
	304	+ BTRFS_FEATURE_INCOMPAT_METADATA_UUID \| \
	305	+ BTRFS_FEATURE_INCOMPAT_RAID1C34)
276	306
277	307	#define BTRFS_FEATURE_INCOMPAT_SAFE_SET \
278	308	(BTRFS_FEATURE_INCOMPAT_EXTENDED_IREF)
..	..	@@ -323,7 +353,7 @@
323	353	* The slots array records the index of the item or block pointer
324	354	* used while walking the tree.
325	355	*/
326		-enum { READA_NONE = 0, READA_BACK, READA_FORWARD };
	356	+enum { READA_NONE, READA_BACK, READA_FORWARD };
327	357	struct btrfs_path {
328	358	struct extent_buffer *nodes[BTRFS_MAX_LEVEL];
329	359	int slots[BTRFS_MAX_LEVEL];
..	..	@@ -344,6 +374,7 @@
344	374	unsigned int search_commit_root:1;
345	375	unsigned int need_commit_sem:1;
346	376	unsigned int skip_release_on_error:1;
	377	+ unsigned int recurse:1;
347	378	};
348	379	#define BTRFS_MAX_EXTENT_ITEM_SIZE(r) ((BTRFS_LEAF_DATA_SIZE(r->fs_info) >> 4) - \
349	380	sizeof(struct btrfs_item))
..	..	@@ -367,122 +398,12 @@
367	398	struct btrfs_device *tgtdev;
368	399
369	400	struct mutex lock_finishing_cancel_unmount;
370		- rwlock_t lock;
371		- atomic_t read_locks;
372		- atomic_t blocking_readers;
373		- wait_queue_head_t read_lock_wq;
	401	+ struct rw_semaphore rwsem;
374	402
375	403	struct btrfs_scrub_progress scrub_progress;
376		-};
377	404
378		-/* For raid type sysfs entries */
379		-struct raid_kobject {
380		- u64 flags;
381		- struct kobject kobj;
382		- struct list_head list;
383		-};
384		-
385		-struct btrfs_space_info {
386		- spinlock_t lock;
387		-
388		- u64 total_bytes; /* total bytes in the space,
389		- this doesn't take mirrors into account */
390		- u64 bytes_used; /* total bytes used,
391		- this doesn't take mirrors into account */
392		- u64 bytes_pinned; /* total bytes pinned, will be freed when the
393		- transaction finishes */
394		- u64 bytes_reserved; /* total bytes the allocator has reserved for
395		- current allocations */
396		- u64 bytes_may_use; /* number of bytes that may be used for
397		- delalloc/allocations */
398		- u64 bytes_readonly; /* total bytes that are read only */
399		-
400		- u64 max_extent_size; /* This will hold the maximum extent size of
401		- the space info if we had an ENOSPC in the
402		- allocator. */
403		-
404		- unsigned int full:1; /* indicates that we cannot allocate any more
405		- chunks for this space */
406		- unsigned int chunk_alloc:1; /* set if we are allocating a chunk */
407		-
408		- unsigned int flush:1; /* set if we are trying to make space */
409		-
410		- unsigned int force_alloc; /* set if we need to force a chunk
411		- alloc for this space */
412		-
413		- u64 disk_used; /* total bytes used on disk */
414		- u64 disk_total; /* total bytes on disk, takes mirrors into
415		- account */
416		-
417		- u64 flags;
418		-
419		- /*
420		- * bytes_pinned is kept in line with what is actually pinned, as in
421		- * we've called update_block_group and dropped the bytes_used counter
422		- * and increased the bytes_pinned counter. However this means that
423		- * bytes_pinned does not reflect the bytes that will be pinned once the
424		- * delayed refs are flushed, so this counter is inc'ed every time we
425		- * call btrfs_free_extent so it is a realtime count of what will be
426		- * freed once the transaction is committed. It will be zeroed every
427		- * time the transaction commits.
428		- */
429		- struct percpu_counter total_bytes_pinned;
430		-
431		- struct list_head list;
432		- /* Protected by the spinlock 'lock'. */
433		- struct list_head ro_bgs;
434		- struct list_head priority_tickets;
435		- struct list_head tickets;
436		- /*
437		- * tickets_id just indicates the next ticket will be handled, so note
438		- * it's not stored per ticket.
439		- */
440		- u64 tickets_id;
441		-
442		- struct rw_semaphore groups_sem;
443		- /* for block groups in our same type */
444		- struct list_head block_groups[BTRFS_NR_RAID_TYPES];
445		- wait_queue_head_t wait;
446		-
447		- struct kobject kobj;
448		- struct kobject *block_group_kobjs[BTRFS_NR_RAID_TYPES];
449		-};
450		-
451		-#define BTRFS_BLOCK_RSV_GLOBAL 1
452		-#define BTRFS_BLOCK_RSV_DELALLOC 2
453		-#define BTRFS_BLOCK_RSV_TRANS 3
454		-#define BTRFS_BLOCK_RSV_CHUNK 4
455		-#define BTRFS_BLOCK_RSV_DELOPS 5
456		-#define BTRFS_BLOCK_RSV_EMPTY 6
457		-#define BTRFS_BLOCK_RSV_TEMP 7
458		-
459		-struct btrfs_block_rsv {
460		- u64 size;
461		- u64 reserved;
462		- struct btrfs_space_info *space_info;
463		- spinlock_t lock;
464		- unsigned short full;
465		- unsigned short type;
466		- unsigned short failfast;
467		-
468		- /*
469		- * Qgroup equivalent for @size @reserved
470		- *
471		- * Unlike normal @size/@reserved for inode rsv, qgroup doesn't care
472		- * about things like csum size nor how many tree blocks it will need to
473		- * reserve.
474		- *
475		- * Qgroup cares more about net change of the extent usage.
476		- *
477		- * So for one newly inserted file extent, in worst case it will cause
478		- * leaf split and level increase, nodesize for each file extent is
479		- * already too much.
480		- *
481		- * In short, qgroup_size/reserved is the upper limit of possible needed
482		- * qgroup metadata reservation.
483		- */
484		- u64 qgroup_rsv_size;
485		- u64 qgroup_rsv_reserved;
	405	+ struct percpu_counter bio_counter;
	406	+ wait_queue_head_t replace_wait;
486	407	};
487	408
488	409	/*
..	..	@@ -504,7 +425,7 @@
504	425	/* We did a full search and couldn't create a cluster */
505	426	bool fragmented;
506	427
507		- struct btrfs_block_group_cache *block_group;
	428	+ struct btrfs_block_group *block_group;
508	429	/*
509	430	* when a cluster is allocated from a block group, we put the
510	431	* cluster onto a list in the block group so that it can
..	..	@@ -514,45 +435,11 @@
514	435	};
515	436
516	437	enum btrfs_caching_type {
517		- BTRFS_CACHE_NO = 0,
518		- BTRFS_CACHE_STARTED = 1,
519		- BTRFS_CACHE_FAST = 2,
520		- BTRFS_CACHE_FINISHED = 3,
521		- BTRFS_CACHE_ERROR = 4,
522		-};
523		-
524		-enum btrfs_disk_cache_state {
525		- BTRFS_DC_WRITTEN = 0,
526		- BTRFS_DC_ERROR = 1,
527		- BTRFS_DC_CLEAR = 2,
528		- BTRFS_DC_SETUP = 3,
529		-};
530		-
531		-struct btrfs_caching_control {
532		- struct list_head list;
533		- struct mutex mutex;
534		- wait_queue_head_t wait;
535		- struct btrfs_work work;
536		- struct btrfs_block_group_cache *block_group;
537		- u64 progress;
538		- refcount_t count;
539		-};
540		-
541		-/* Once caching_thread() finds this much free space, it will wake up waiters. */
542		-#define CACHING_CTL_WAKE_UP SZ_2M
543		-
544		-struct btrfs_io_ctl {
545		- void cur, orig;
546		- struct page *page;
547		- struct page **pages;
548		- struct btrfs_fs_info *fs_info;
549		- struct inode *inode;
550		- unsigned long size;
551		- int index;
552		- int num_pages;
553		- int entries;
554		- int bitmaps;
555		- unsigned check_crcs:1;
	438	+ BTRFS_CACHE_NO,
	439	+ BTRFS_CACHE_STARTED,
	440	+ BTRFS_CACHE_FAST,
	441	+ BTRFS_CACHE_FINISHED,
	442	+ BTRFS_CACHE_ERROR,
556	443	};
557	444
558	445	/*
..	..	@@ -563,118 +450,34 @@
563	450	struct mutex lock;
564	451	};
565	452
566		-struct btrfs_block_group_cache {
567		- struct btrfs_key key;
568		- struct btrfs_block_group_item item;
569		- struct btrfs_fs_info *fs_info;
570		- struct inode *inode;
	453	+/* Discard control. */
	454	+/*
	455	+ * Async discard uses multiple lists to differentiate the discard filter
	456	+ * parameters. Index 0 is for completely free block groups where we need to
	457	+ * ensure the entire block group is trimmed without being lossy. Indices
	458	+ * afterwards represent monotonically decreasing discard filter sizes to
	459	+ * prioritize what should be discarded next.
	460	+ */
	461	+#define BTRFS_NR_DISCARD_LISTS 3
	462	+#define BTRFS_DISCARD_INDEX_UNUSED 0
	463	+#define BTRFS_DISCARD_INDEX_START 1
	464	+
	465	+struct btrfs_discard_ctl {
	466	+ struct workqueue_struct *discard_workers;
	467	+ struct delayed_work work;
571	468	spinlock_t lock;
572		- u64 pinned;
573		- u64 reserved;
574		- u64 delalloc_bytes;
575		- u64 bytes_super;
576		- u64 flags;
577		- u64 cache_generation;
578		-
579		- /*
580		- * If the free space extent count exceeds this number, convert the block
581		- * group to bitmaps.
582		- */
583		- u32 bitmap_high_thresh;
584		-
585		- /*
586		- * If the free space extent count drops below this number, convert the
587		- * block group back to extents.
588		- */
589		- u32 bitmap_low_thresh;
590		-
591		- /*
592		- * It is just used for the delayed data space allocation because
593		- * only the data space allocation and the relative metadata update
594		- * can be done cross the transaction.
595		- */
596		- struct rw_semaphore data_rwsem;
597		-
598		- /* for raid56, this is a full stripe, without parity */
599		- unsigned long full_stripe_len;
600		-
601		- unsigned int ro;
602		- unsigned int iref:1;
603		- unsigned int has_caching_ctl:1;
604		- unsigned int removed:1;
605		-
606		- int disk_cache_state;
607		-
608		- /* cache tracking stuff */
609		- int cached;
610		- struct btrfs_caching_control *caching_ctl;
611		- u64 last_byte_to_unpin;
612		-
613		- struct btrfs_space_info *space_info;
614		-
615		- /* free space cache stuff */
616		- struct btrfs_free_space_ctl *free_space_ctl;
617		-
618		- /* block group cache stuff */
619		- struct rb_node cache_node;
620		-
621		- /* for block groups in the same raid type */
622		- struct list_head list;
623		-
624		- /* usage count */
625		- atomic_t count;
626		-
627		- /* List of struct btrfs_free_clusters for this block group.
628		- * Today it will only have one thing on it, but that may change
629		- */
630		- struct list_head cluster_list;
631		-
632		- /* For delayed block group creation or deletion of empty block groups */
633		- struct list_head bg_list;
634		-
635		- /* For read-only block groups */
636		- struct list_head ro_list;
637		-
638		- atomic_t trimming;
639		-
640		- /* For dirty block groups */
641		- struct list_head dirty_list;
642		- struct list_head io_list;
643		-
644		- struct btrfs_io_ctl io_ctl;
645		-
646		- /*
647		- * Incremented when doing extent allocations and holding a read lock
648		- * on the space_info's groups_sem semaphore.
649		- * Decremented when an ordered extent that represents an IO against this
650		- * block group's range is created (after it's added to its inode's
651		- * root's list of ordered extents) or immediately after the allocation
652		- * if it's a metadata extent or fallocate extent (for these cases we
653		- * don't create ordered extents).
654		- */
655		- atomic_t reservations;
656		-
657		- /*
658		- * Incremented while holding the spinlock lock by a task checking if
659		- * it can perform a nocow write (incremented if the value for the ro
660		- * field is 0). Decremented by such tasks once they create an ordered
661		- * extent or before that if some error happens before reaching that step.
662		- * This is to prevent races between block group relocation and nocow
663		- * writes through direct IO.
664		- */
665		- atomic_t nocow_writers;
666		-
667		- /* Lock for free space tree operations. */
668		- struct mutex free_space_lock;
669		-
670		- /*
671		- * Does the block group need to be added to the free space tree?
672		- * Protected by free_space_lock.
673		- */
674		- int needs_free_space;
675		-
676		- /* Record locked full stripes for RAID5/6 block group */
677		- struct btrfs_full_stripe_locks_tree full_stripe_locks_root;
	469	+ struct btrfs_block_group *block_group;
	470	+ struct list_head discard_list[BTRFS_NR_DISCARD_LISTS];
	471	+ u64 prev_discard;
	472	+ atomic_t discardable_extents;
	473	+ atomic64_t discardable_bytes;
	474	+ u64 max_discard_size;
	475	+ unsigned long delay;
	476	+ u32 iops_limit;
	477	+ u32 kbps_limit;
	478	+ u64 discard_extent_bytes;
	479	+ u64 discard_bitmap_bytes;
	480	+ atomic64_t discard_bytes_saved;
678	481	};
679	482
680	483	/* delayed seq elem */
..	..	@@ -692,23 +495,7 @@
692	495	ORPHAN_CLEANUP_DONE = 2,
693	496	};
694	497
695		-/* used by the raid56 code to lock stripes for read/modify/write */
696		-struct btrfs_stripe_hash {
697		- struct list_head hash_list;
698		- spinlock_t lock;
699		-};
700		-
701		-/* used by the raid56 code to lock stripes for read/modify/write */
702		-struct btrfs_stripe_hash_table {
703		- struct list_head stripe_cache;
704		- spinlock_t cache_lock;
705		- int cache_size;
706		- struct btrfs_stripe_hash table[];
707		-};
708		-
709		-#define BTRFS_STRIPE_HASH_TABLE_BITS 11
710		-
711		-void btrfs_init_async_reclaim_work(struct work_struct *work);
	498	+void btrfs_init_async_reclaim_work(struct btrfs_fs_info *fs_info);
712	499
713	500	/* fs_info */
714	501	struct reloc_control;
..	..	@@ -717,41 +504,83 @@
717	504	struct btrfs_balance_control;
718	505	struct btrfs_delayed_root;
719	506
720		-#define BTRFS_FS_BARRIER 1
721		-#define BTRFS_FS_CLOSING_START 2
722		-#define BTRFS_FS_CLOSING_DONE 3
723		-#define BTRFS_FS_LOG_RECOVERING 4
724		-#define BTRFS_FS_OPEN 5
725		-#define BTRFS_FS_QUOTA_ENABLED 6
726		-#define BTRFS_FS_UPDATE_UUID_TREE_GEN 9
727		-#define BTRFS_FS_CREATING_FREE_SPACE_TREE 10
728		-#define BTRFS_FS_BTREE_ERR 11
729		-#define BTRFS_FS_LOG1_ERR 12
730		-#define BTRFS_FS_LOG2_ERR 13
731		-#define BTRFS_FS_QUOTA_OVERRIDE 14
732		-/* Used to record internally whether fs has been frozen */
733		-#define BTRFS_FS_FROZEN 15
	507	+/*
	508	+ * Block group or device which contains an active swapfile. Used for preventing
	509	+ * unsafe operations while a swapfile is active.
	510	+ *
	511	+ * These are sorted on (ptr, inode) (note that a block group or device can
	512	+ * contain more than one swapfile). We compare the pointer values because we
	513	+ * don't actually care what the object is, we just need a quick check whether
	514	+ * the object exists in the rbtree.
	515	+ */
	516	+struct btrfs_swapfile_pin {
	517	+ struct rb_node node;
	518	+ void *ptr;
	519	+ struct inode *inode;
	520	+ /*
	521	+ * If true, ptr points to a struct btrfs_block_group. Otherwise, ptr
	522	+ * points to a struct btrfs_device.
	523	+ */
	524	+ bool is_block_group;
	525	+ /*
	526	+ * Only used when 'is_block_group' is true and it is the number of
	527	+ * extents used by a swapfile for this block group ('ptr' field).
	528	+ */
	529	+ int bg_extent_count;
	530	+};
	531	+
	532	+enum {
	533	+ BTRFS_FS_BARRIER,
	534	+ BTRFS_FS_CLOSING_START,
	535	+ BTRFS_FS_CLOSING_DONE,
	536	+ BTRFS_FS_LOG_RECOVERING,
	537	+ BTRFS_FS_OPEN,
	538	+ BTRFS_FS_QUOTA_ENABLED,
	539	+ BTRFS_FS_UPDATE_UUID_TREE_GEN,
	540	+ BTRFS_FS_CREATING_FREE_SPACE_TREE,
	541	+ BTRFS_FS_BTREE_ERR,
	542	+ BTRFS_FS_LOG1_ERR,
	543	+ BTRFS_FS_LOG2_ERR,
	544	+ BTRFS_FS_QUOTA_OVERRIDE,
	545	+ /* Used to record internally whether fs has been frozen */
	546	+ BTRFS_FS_FROZEN,
	547	+ /*
	548	+ * Indicate that balance has been set up from the ioctl and is in the
	549	+ * main phase. The fs_info::balance_ctl is initialized.
	550	+ * Set and cleared while holding fs_info::balance_mutex.
	551	+ */
	552	+ BTRFS_FS_BALANCE_RUNNING,
	553	+
	554	+ /* Indicate that the cleaner thread is awake and doing something. */
	555	+ BTRFS_FS_CLEANER_RUNNING,
	556	+
	557	+ /*
	558	+ * The checksumming has an optimized version and is considered fast,
	559	+ * so we don't need to offload checksums to workqueues.
	560	+ */
	561	+ BTRFS_FS_CSUM_IMPL_FAST,
	562	+
	563	+ /* Indicate that the discard workqueue can service discards. */
	564	+ BTRFS_FS_DISCARD_RUNNING,
	565	+
	566	+ /* Indicate that we can't trust the free space tree for caching yet */
	567	+ BTRFS_FS_FREE_SPACE_TREE_UNTRUSTED,
	568	+};
734	569
735	570	/*
736		- * Indicate that a whole-filesystem exclusive operation is running
737		- * (device replace, resize, device add/delete, balance)
	571	+ * Exclusive operations (device replace, resize, device add/remove, balance)
738	572	*/
739		-#define BTRFS_FS_EXCL_OP 16
740		-
741		-/*
742		- * To info transaction_kthread we need an immediate commit so it doesn't
743		- * need to wait for commit_interval
744		- */
745		-#define BTRFS_FS_NEED_ASYNC_COMMIT 17
746		-
747		-/*
748		- * Indicate that balance has been set up from the ioctl and is in the main
749		- * phase. The fs_info::balance_ctl is initialized.
750		- */
751		-#define BTRFS_FS_BALANCE_RUNNING 18
	573	+enum btrfs_exclusive_operation {
	574	+ BTRFS_EXCLOP_NONE,
	575	+ BTRFS_EXCLOP_BALANCE,
	576	+ BTRFS_EXCLOP_DEV_ADD,
	577	+ BTRFS_EXCLOP_DEV_REMOVE,
	578	+ BTRFS_EXCLOP_DEV_REPLACE,
	579	+ BTRFS_EXCLOP_RESIZE,
	580	+ BTRFS_EXCLOP_SWAP_ACTIVATE,
	581	+};
752	582
753	583	struct btrfs_fs_info {
754		- u8 fsid[BTRFS_FSID_SIZE];
755	584	u8 chunk_tree_uuid[BTRFS_UUID_SIZE];
756	585	unsigned long flags;
757	586	struct btrfs_root *extent_root;
..	..	@@ -763,6 +592,7 @@
763	592	struct btrfs_root *quota_root;
764	593	struct btrfs_root *uuid_root;
765	594	struct btrfs_root *free_space_root;
	595	+ struct btrfs_root *data_reloc_root;
766	596
767	597	/* the log root tree is a directory of all the other log roots */
768	598	struct btrfs_root *log_root_tree;
..	..	@@ -778,11 +608,11 @@
778	608	/* keep track of unallocated space */
779	609	atomic64_t free_chunk_space;
780	610
781		- struct extent_io_tree freed_extents[2];
782		- struct extent_io_tree *pinned_extents;
	611	+ /* Track ranges which are used by log trees blocks/logged data extents */
	612	+ struct extent_io_tree excluded_extents;
783	613
784	614	/* logical->physical extent mapping */
785		- struct btrfs_mapping_tree mapping_tree;
	615	+ struct extent_map_tree mapping_tree;
786	616
787	617	/*
788	618	* block reservation for extent, checksum, root tree and
..	..	@@ -795,6 +625,8 @@
795	625	struct btrfs_block_rsv chunk_block_rsv;
796	626	/* block reservation for delayed operations */
797	627	struct btrfs_block_rsv delayed_block_rsv;
	628	+ /* block reservation for delayed refs */
	629	+ struct btrfs_block_rsv delayed_refs_rsv;
798	630
799	631	struct btrfs_block_rsv empty_block_rsv;
800	632
..	..	@@ -876,7 +708,6 @@
876	708	struct rw_semaphore cleanup_work_sem;
877	709
878	710	struct rw_semaphore subvol_sem;
879		- struct srcu_struct subvol_srcu;
880	711
881	712	spinlock_t trans_lock;
882	713	/*
..	..	@@ -891,7 +722,8 @@
891	722
892	723	spinlock_t delayed_iput_lock;
893	724	struct list_head delayed_iputs;
894		- struct mutex cleaner_delayed_iput_mutex;
	725	+ atomic_t nr_delayed_iputs;
	726	+ wait_queue_head_t delayed_iputs_wait;
895	727
896	728	atomic64_t tree_mod_seq;
897	729
..	..	@@ -937,12 +769,10 @@
937	769	struct btrfs_workqueue *endio_workers;
938	770	struct btrfs_workqueue *endio_meta_workers;
939	771	struct btrfs_workqueue *endio_raid56_workers;
940		- struct btrfs_workqueue *endio_repair_workers;
941	772	struct btrfs_workqueue *rmw_workers;
942	773	struct btrfs_workqueue *endio_meta_write_workers;
943	774	struct btrfs_workqueue *endio_write_workers;
944	775	struct btrfs_workqueue *endio_freespace_worker;
945		- struct btrfs_workqueue *submit_workers;
946	776	struct btrfs_workqueue *caching_workers;
947	777	struct btrfs_workqueue *readahead_workers;
948	778
..	..	@@ -954,21 +784,19 @@
954	784	struct btrfs_workqueue *fixup_workers;
955	785	struct btrfs_workqueue *delayed_workers;
956	786
957		- /* the extent workers do delayed refs on the extent allocation tree */
958		- struct btrfs_workqueue *extent_workers;
959	787	struct task_struct *transaction_kthread;
960	788	struct task_struct *cleaner_kthread;
961	789	u32 thread_pool_size;
962	790
963	791	struct kobject *space_info_kobj;
964		- struct list_head pending_raid_kobjs;
965		- spinlock_t pending_raid_kobjs_lock; /* uncontended */
	792	+ struct kobject *qgroups_kobj;
966	793
967	794	u64 total_pinned;
968	795
969	796	/* used to keep from writing metadata until there is a nice batch */
970	797	struct percpu_counter dirty_metadata_bytes;
971	798	struct percpu_counter delalloc_bytes;
	799	+ struct percpu_counter dio_bytes;
972	800	s32 dirty_metadata_batch;
973	801	s32 delalloc_batch;
974	802
..	..	@@ -1029,11 +857,16 @@
1029	857	atomic_t scrubs_paused;
1030	858	atomic_t scrub_cancel_req;
1031	859	wait_queue_head_t scrub_pause_wait;
1032		- int scrub_workers_refcnt;
	860	+ /*
	861	+ * The worker pointers are NULL iff the refcount is 0, ie. scrub is not
	862	+ * running.
	863	+ */
	864	+ refcount_t scrub_workers_refcnt;
1033	865	struct btrfs_workqueue *scrub_workers;
1034	866	struct btrfs_workqueue *scrub_wr_completion_workers;
1035		- struct btrfs_workqueue *scrub_nocow_workers;
1036	867	struct btrfs_workqueue *scrub_parity_workers;
	868	+
	869	+ struct btrfs_discard_ctl discard_ctl;
1037	870
1038	871	#ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
1039	872	u32 check_integrity_print_mask;
..	..	@@ -1043,10 +876,7 @@
1043	876
1044	877	/* holds configuration and tracking. Protected by qgroup_lock */
1045	878	struct rb_root qgroup_tree;
1046		- struct rb_root qgroup_op_tree;
1047	879	spinlock_t qgroup_lock;
1048		- spinlock_t qgroup_op_lock;
1049		- atomic_t qgroup_op_seq;
1050	880
1051	881	/*
1052	882	* used to avoid frequently calling ulist_alloc()/ulist_free()
..	..	@@ -1054,7 +884,10 @@
1054	884	*/
1055	885	struct ulist *qgroup_ulist;
1056	886
1057		- /* protect user change for quota operations */
	887	+ /*
	888	+ * Protect user change for quota operations. If a transaction is needed,
	889	+ * it must be started before locking this lock.
	890	+ */
1058	891	struct mutex qgroup_ioctl_lock;
1059	892
1060	893	/* list of dirty qgroups to be written at next commit */
..	..	@@ -1093,36 +926,49 @@
1093	926	/* device replace state */
1094	927	struct btrfs_dev_replace dev_replace;
1095	928
1096		- struct percpu_counter bio_counter;
1097		- wait_queue_head_t replace_wait;
1098		-
1099	929	struct semaphore uuid_tree_rescan_sem;
1100	930
1101	931	/* Used to reclaim the metadata space in the background. */
1102	932	struct work_struct async_reclaim_work;
	933	+ struct work_struct async_data_reclaim_work;
1103	934
1104	935	spinlock_t unused_bgs_lock;
1105	936	struct list_head unused_bgs;
1106	937	struct mutex unused_bg_unpin_mutex;
1107	938	struct mutex delete_unused_bgs_mutex;
1108	939
1109		- /* For btrfs to record security options */
1110		- struct security_mnt_opts security_opts;
1111		-
1112		- /*
1113		- * Chunks that can't be freed yet (under a trim/discard operation)
1114		- * and will be latter freed. Protected by fs_info->chunk_mutex.
1115		- */
1116		- struct list_head pinned_chunks;
1117		-
1118	940	/* Cached block sizes */
1119	941	u32 nodesize;
1120	942	u32 sectorsize;
1121	943	u32 stripesize;
1122	944
	945	+ /* Block groups and devices containing active swapfiles. */
	946	+ spinlock_t swapfile_pins_lock;
	947	+ struct rb_root swapfile_pins;
	948	+
	949	+ struct crypto_shash *csum_shash;
	950	+
	951	+ /*
	952	+ * Number of send operations in progress.
	953	+ * Updated while holding fs_info::balance_mutex.
	954	+ */
	955	+ int send_in_progress;
	956	+
	957	+ /* Type of exclusive operation running */
	958	+ unsigned long exclusive_operation;
	959	+
1123	960	#ifdef CONFIG_BTRFS_FS_REF_VERIFY
1124	961	spinlock_t ref_verify_lock;
1125	962	struct rb_root block_tree;
	963	+#endif
	964	+
	965	+#ifdef CONFIG_BTRFS_DEBUG
	966	+ struct kobject *debug_kobj;
	967	+ struct kobject *discard_debug_kobj;
	968	+ struct list_head allocated_roots;
	969	+
	970	+ spinlock_t eb_leak_lock;
	971	+ struct list_head allocated_ebs;
1126	972	#endif
1127	973	};
1128	974
..	..	@@ -1131,30 +977,72 @@
1131	977	return sb->s_fs_info;
1132	978	}
1133	979
1134		-struct btrfs_subvolume_writers {
1135		- struct percpu_counter counter;
1136		- wait_queue_head_t wait;
1137		-};
1138		-
1139	980	/*
1140	981	* The state of btrfs root
1141	982	*/
	983	+enum {
	984	+ /*
	985	+ * btrfs_record_root_in_trans is a multi-step process, and it can race
	986	+ * with the balancing code. But the race is very small, and only the
	987	+ * first time the root is added to each transaction. So IN_TRANS_SETUP
	988	+ * is used to tell us when more checks are required
	989	+ */
	990	+ BTRFS_ROOT_IN_TRANS_SETUP,
	991	+
	992	+ /*
	993	+ * Set if tree blocks of this root can be shared by other roots.
	994	+ * Only subvolume trees and their reloc trees have this bit set.
	995	+ * Conflicts with TRACK_DIRTY bit.
	996	+ *
	997	+ * This affects two things:
	998	+ *
	999	+ * - How balance works
	1000	+ * For shareable roots, we need to use reloc tree and do path
	1001	+ * replacement for balance, and need various pre/post hooks for
	1002	+ * snapshot creation to handle them.
	1003	+ *
	1004	+ * While for non-shareable trees, we just simply do a tree search
	1005	+ * with COW.
	1006	+ *
	1007	+ * - How dirty roots are tracked
	1008	+ * For shareable roots, btrfs_record_root_in_trans() is needed to
	1009	+ * track them, while non-subvolume roots have TRACK_DIRTY bit, they
	1010	+ * don't need to set this manually.
	1011	+ */
	1012	+ BTRFS_ROOT_SHAREABLE,
	1013	+ BTRFS_ROOT_TRACK_DIRTY,
	1014	+ BTRFS_ROOT_IN_RADIX,
	1015	+ BTRFS_ROOT_ORPHAN_ITEM_INSERTED,
	1016	+ BTRFS_ROOT_DEFRAG_RUNNING,
	1017	+ BTRFS_ROOT_FORCE_COW,
	1018	+ BTRFS_ROOT_MULTI_LOG_TASKS,
	1019	+ BTRFS_ROOT_DIRTY,
	1020	+ BTRFS_ROOT_DELETING,
	1021	+
	1022	+ /*
	1023	+ * Reloc tree is orphan, only kept here for qgroup delayed subtree scan
	1024	+ *
	1025	+ * Set for the subvolume tree owning the reloc tree.
	1026	+ */
	1027	+ BTRFS_ROOT_DEAD_RELOC_TREE,
	1028	+ /* Mark dead root stored on device whose cleanup needs to be resumed */
	1029	+ BTRFS_ROOT_DEAD_TREE,
	1030	+ /* The root has a log tree. Used only for subvolume roots. */
	1031	+ BTRFS_ROOT_HAS_LOG_TREE,
	1032	+ /* Qgroup flushing is in progress */
	1033	+ BTRFS_ROOT_QGROUP_FLUSHING,
	1034	+};
	1035	+
1142	1036	/*
1143		- * btrfs_record_root_in_trans is a multi-step process,
1144		- * and it can race with the balancing code. But the
1145		- * race is very small, and only the first time the root
1146		- * is added to each transaction. So IN_TRANS_SETUP
1147		- * is used to tell us when more checks are required
	1037	+ * Record swapped tree blocks of a subvolume tree for delayed subtree trace
	1038	+ * code. For detail check comment in fs/btrfs/qgroup.c.
1148	1039	*/
1149		-#define BTRFS_ROOT_IN_TRANS_SETUP 0
1150		-#define BTRFS_ROOT_REF_COWS 1
1151		-#define BTRFS_ROOT_TRACK_DIRTY 2
1152		-#define BTRFS_ROOT_IN_RADIX 3
1153		-#define BTRFS_ROOT_ORPHAN_ITEM_INSERTED 4
1154		-#define BTRFS_ROOT_DEFRAG_RUNNING 5
1155		-#define BTRFS_ROOT_FORCE_COW 6
1156		-#define BTRFS_ROOT_MULTI_LOG_TASKS 7
1157		-#define BTRFS_ROOT_DIRTY 8
	1040	+struct btrfs_qgroup_swapped_blocks {
	1041	+ spinlock_t lock;
	1042	+ /* RM_EMPTY_ROOT() of above blocks[] */
	1043	+ bool swapped;
	1044	+ struct rb_root blocks[BTRFS_MAX_LEVEL];
	1045	+};
1158	1046
1159	1047	/*
1160	1048	* in ram representation of the tree. extent_root is used for all allocations
..	..	@@ -1191,8 +1079,10 @@
1191	1079	wait_queue_head_t log_writer_wait;
1192	1080	wait_queue_head_t log_commit_wait[2];
1193	1081	struct list_head log_ctxs[2];
	1082	+ /* Used only for log trees of subvolumes, not for the log root tree */
1194	1083	atomic_t log_writers;
1195	1084	atomic_t log_commit[2];
	1085	+ /* Used only for log trees of subvolumes, not for the log root tree */
1196	1086	atomic_t log_batch;
1197	1087	int log_transid;
1198	1088	/* No matter the commit succeeds or not*/
..	..	@@ -1201,23 +1091,16 @@
1201	1091	int last_log_commit;
1202	1092	pid_t log_start_pid;
1203	1093
1204		- u64 objectid;
1205	1094	u64 last_trans;
1206	1095
1207	1096	u32 type;
1208	1097
1209	1098	u64 highest_objectid;
1210	1099
1211		-#ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS
1212		- /* only used with CONFIG_BTRFS_FS_RUN_SANITY_TESTS is enabled */
1213		- u64 alloc_bytenr;
1214		-#endif
1215		-
1216		- u64 defrag_trans_start;
1217	1100	struct btrfs_key defrag_progress;
1218	1101	struct btrfs_key defrag_max;
1219	1102
1220		- /* the dirty list is only used by non-reference counted roots */
	1103	+ /* The dirty list is only used by non-shareable roots */
1221	1104	struct list_head dirty_list;
1222	1105
1223	1106	struct list_head root_list;
..	..	@@ -1273,28 +1156,87 @@
1273	1156	u64 nr_ordered_extents;
1274	1157
1275	1158	/*
	1159	+ * Not empty if this subvolume root has gone through tree block swap
	1160	+ * (relocation)
	1161	+ *
	1162	+ * Will be used by reloc_control::dirty_subvol_roots.
	1163	+ */
	1164	+ struct list_head reloc_dirty_list;
	1165	+
	1166	+ /*
1276	1167	* Number of currently running SEND ioctls to prevent
1277	1168	* manipulation with the read-only status via SUBVOL_SETFLAGS
1278	1169	*/
1279	1170	int send_in_progress;
1280		- struct btrfs_subvolume_writers *subv_writers;
1281		- atomic_t will_be_snapshotted;
	1171	+ /*
	1172	+ * Number of currently running deduplication operations that have a
	1173	+ * destination inode belonging to this root. Protected by the lock
	1174	+ * root_item_lock.
	1175	+ */
	1176	+ int dedupe_in_progress;
	1177	+ /* For exclusion of snapshot creation and nocow writes */
	1178	+ struct btrfs_drew_lock snapshot_lock;
	1179	+
1282	1180	atomic_t snapshot_force_cow;
1283	1181
1284	1182	/* For qgroup metadata reserved space */
1285	1183	spinlock_t qgroup_meta_rsv_lock;
1286	1184	u64 qgroup_meta_rsv_pertrans;
1287	1185	u64 qgroup_meta_rsv_prealloc;
	1186	+ wait_queue_head_t qgroup_flush_wait;
	1187	+
	1188	+ /* Number of active swapfiles */
	1189	+ atomic_t nr_swapfiles;
	1190	+
	1191	+ /* Record pairs of swapped blocks for qgroup */
	1192	+ struct btrfs_qgroup_swapped_blocks swapped_blocks;
	1193	+
	1194	+ /* Used only by log trees, when logging csum items */
	1195	+ struct extent_io_tree log_csum_range;
	1196	+
	1197	+#ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS
	1198	+ u64 alloc_bytenr;
	1199	+#endif
	1200	+
	1201	+#ifdef CONFIG_BTRFS_DEBUG
	1202	+ struct list_head leak_list;
	1203	+#endif
	1204	+};
	1205	+
	1206	+/*
	1207	+ * Structure that conveys information about an extent that is going to replace
	1208	+ * all the extents in a file range.
	1209	+ */
	1210	+struct btrfs_replace_extent_info {
	1211	+ u64 disk_offset;
	1212	+ u64 disk_len;
	1213	+ u64 data_offset;
	1214	+ u64 data_len;
	1215	+ u64 file_offset;
	1216	+ /* Pointer to a file extent item of type regular or prealloc. */
	1217	+ char *extent_buf;
	1218	+ /*
	1219	+ * Set to true when attempting to replace a file range with a new extent
	1220	+ * described by this structure, set to false when attempting to clone an
	1221	+ * existing extent into a file range.
	1222	+ */
	1223	+ bool is_new_extent;
	1224	+ /* Meaningful only if is_new_extent is true. */
	1225	+ int qgroup_reserved;
	1226	+ /*
	1227	+ * Meaningful only if is_new_extent is true.
	1228	+ * Used to track how many extent items we have already inserted in a
	1229	+ * subvolume tree that refer to the extent described by this structure,
	1230	+ * so that we know when to create a new delayed ref or update an existing
	1231	+ * one.
	1232	+ */
	1233	+ int insertions;
1288	1234	};
1289	1235
1290	1236	struct btrfs_file_private {
1291	1237	void *filldir_buf;
1292	1238	};
1293	1239
1294		-static inline u32 btrfs_inode_sectorsize(const struct inode *inode)
1295		-{
1296		- return btrfs_sb(inode->i_sb)->sectorsize;
1297		-}
1298	1240
1299	1241	static inline u32 BTRFS_LEAF_DATA_SIZE(const struct btrfs_fs_info *info)
1300	1242	{
..	..	@@ -1342,7 +1284,7 @@
1342	1284	#define BTRFS_MOUNT_FLUSHONCOMMIT (1 << 7)
1343	1285	#define BTRFS_MOUNT_SSD_SPREAD (1 << 8)
1344	1286	#define BTRFS_MOUNT_NOSSD (1 << 9)
1345		-#define BTRFS_MOUNT_DISCARD (1 << 10)
	1287	+#define BTRFS_MOUNT_DISCARD_SYNC (1 << 10)
1346	1288	#define BTRFS_MOUNT_FORCE_COMPRESS (1 << 11)
1347	1289	#define BTRFS_MOUNT_SPACE_CACHE (1 << 12)
1348	1290	#define BTRFS_MOUNT_CLEAR_CACHE (1 << 13)
..	..	@@ -1361,6 +1303,7 @@
1361	1303	#define BTRFS_MOUNT_FREE_SPACE_TREE (1 << 26)
1362	1304	#define BTRFS_MOUNT_NOLOGREPLAY (1 << 27)
1363	1305	#define BTRFS_MOUNT_REF_VERIFY (1 << 28)
	1306	+#define BTRFS_MOUNT_DISCARD_ASYNC (1 << 29)
1364	1307
1365	1308	#define BTRFS_DEFAULT_COMMIT_INTERVAL (30)
1366	1309	#define BTRFS_DEFAULT_MAX_INLINE (2048)
..	..	@@ -1372,31 +1315,18 @@
1372	1315	BTRFS_MOUNT_##opt)
1373	1316
1374	1317	#define btrfs_set_and_info(fs_info, opt, fmt, args...) \
1375		-{ \
	1318	+do { \
1376	1319	if (!btrfs_test_opt(fs_info, opt)) \
1377	1320	btrfs_info(fs_info, fmt, ##args); \
1378	1321	btrfs_set_opt(fs_info->mount_opt, opt); \
1379		-}
	1322	+} while (0)
1380	1323
1381	1324	#define btrfs_clear_and_info(fs_info, opt, fmt, args...) \
1382		-{ \
	1325	+do { \
1383	1326	if (btrfs_test_opt(fs_info, opt)) \
1384	1327	btrfs_info(fs_info, fmt, ##args); \
1385	1328	btrfs_clear_opt(fs_info->mount_opt, opt); \
1386		-}
1387		-
1388		-#ifdef CONFIG_BTRFS_DEBUG
1389		-static inline int
1390		-btrfs_should_fragment_free_space(struct btrfs_block_group_cache *block_group)
1391		-{
1392		- struct btrfs_fs_info *fs_info = block_group->fs_info;
1393		-
1394		- return (btrfs_test_opt(fs_info, FRAGMENT_METADATA) &&
1395		- block_group->flags & BTRFS_BLOCK_GROUP_METADATA) \|\|
1396		- (btrfs_test_opt(fs_info, FRAGMENT_DATA) &&
1397		- block_group->flags & BTRFS_BLOCK_GROUP_DATA);
1398		-}
1399		-#endif
	1329	+} while (0)
1400	1330
1401	1331	/*
1402	1332	* Requests for changes that need to be done during transaction commit.
..	..	@@ -1475,7 +1405,7 @@
1475	1405	BTRFS_INODE_ROOT_ITEM_INIT)
1476	1406
1477	1407	struct btrfs_map_token {
1478		- const struct extent_buffer *eb;
	1408	+ struct extent_buffer *eb;
1479	1409	char *kaddr;
1480	1410	unsigned long offset;
1481	1411	};
..	..	@@ -1483,9 +1413,12 @@
1483	1413	#define BTRFS_BYTES_TO_BLKS(fs_info, bytes) \
1484	1414	((bytes) >> (fs_info)->sb->s_blocksize_bits)
1485	1415
1486		-static inline void btrfs_init_map_token (struct btrfs_map_token *token)
	1416	+static inline void btrfs_init_map_token(struct btrfs_map_token *token,
	1417	+ struct extent_buffer *eb)
1487	1418	{
1488		- token->kaddr = NULL;
	1419	+ token->eb = eb;
	1420	+ token->kaddr = page_address(eb->pages[0]);
	1421	+ token->offset = 0;
1489	1422	}
1490	1423
1491	1424	/* some macros to generate set/get functions for the struct fields. This
..	..	@@ -1495,6 +1428,16 @@
1495	1428	#define le8_to_cpu(v) (v)
1496	1429	#define cpu_to_le8(v) (v)
1497	1430	#define __le8 u8
	1431	+
	1432	+static inline u8 get_unaligned_le8(const void *p)
	1433	+{
	1434	+ return (u8 )p;
	1435	+}
	1436	+
	1437	+static inline void put_unaligned_le8(u8 val, void *p)
	1438	+{
	1439	+ (u8 )p = val;
	1440	+}
1498	1441
1499	1442	#define read_eb_member(eb, ptr, type, member, result) (\
1500	1443	read_extent_buffer(eb, (char *)(result), \
..	..	@@ -1509,23 +1452,15 @@
1509	1452	sizeof(((type *)0)->member)))
1510	1453
1511	1454	#define DECLARE_BTRFS_SETGET_BITS(bits) \
1512		-u##bits btrfs_get_token_##bits(const struct extent_buffer *eb, \
1513		- const void *ptr, unsigned long off, \
1514		- struct btrfs_map_token *token); \
1515		-void btrfs_set_token_##bits(struct extent_buffer eb, const void ptr, \
1516		- unsigned long off, u##bits val, \
1517		- struct btrfs_map_token *token); \
1518		-static inline u##bits btrfs_get_##bits(const struct extent_buffer *eb, \
1519		- const void *ptr, \
1520		- unsigned long off) \
1521		-{ \
1522		- return btrfs_get_token_##bits(eb, ptr, off, NULL); \
1523		-} \
1524		-static inline void btrfs_set_##bits(struct extent_buffer eb, void ptr,\
1525		- unsigned long off, u##bits val) \
1526		-{ \
1527		- btrfs_set_token_##bits(eb, ptr, off, val, NULL); \
1528		-}
	1455	+u##bits btrfs_get_token_##bits(struct btrfs_map_token *token, \
	1456	+ const void *ptr, unsigned long off); \
	1457	+void btrfs_set_token_##bits(struct btrfs_map_token *token, \
	1458	+ const void *ptr, unsigned long off, \
	1459	+ u##bits val); \
	1460	+u##bits btrfs_get_##bits(const struct extent_buffer *eb, \
	1461	+ const void *ptr, unsigned long off); \
	1462	+void btrfs_set_##bits(const struct extent_buffer eb, void ptr, \
	1463	+ unsigned long off, u##bits val);
1529	1464
1530	1465	DECLARE_BTRFS_SETGET_BITS(8)
1531	1466	DECLARE_BTRFS_SETGET_BITS(16)
..	..	@@ -1539,53 +1474,49 @@
1539	1474	BUILD_BUG_ON(sizeof(u##bits) != sizeof(((type *)0))->member); \
1540	1475	return btrfs_get_##bits(eb, s, offsetof(type, member)); \
1541	1476	} \
1542		-static inline void btrfs_set_##name(struct extent_buffer eb, type s, \
	1477	+static inline void btrfs_set_##name(const struct extent_buffer eb, type s, \
1543	1478	u##bits val) \
1544	1479	{ \
1545	1480	BUILD_BUG_ON(sizeof(u##bits) != sizeof(((type *)0))->member); \
1546	1481	btrfs_set_##bits(eb, s, offsetof(type, member), val); \
1547	1482	} \
1548		-static inline u##bits btrfs_token_##name(const struct extent_buffer *eb,\
1549		- const type *s, \
1550		- struct btrfs_map_token *token) \
	1483	+static inline u##bits btrfs_token_##name(struct btrfs_map_token *token, \
	1484	+ const type *s) \
1551	1485	{ \
1552	1486	BUILD_BUG_ON(sizeof(u##bits) != sizeof(((type *)0))->member); \
1553		- return btrfs_get_token_##bits(eb, s, offsetof(type, member), token); \
	1487	+ return btrfs_get_token_##bits(token, s, offsetof(type, member));\
1554	1488	} \
1555		-static inline void btrfs_set_token_##name(struct extent_buffer *eb, \
1556		- type *s, u##bits val, \
1557		- struct btrfs_map_token *token) \
	1489	+static inline void btrfs_set_token_##name(struct btrfs_map_token *token,\
	1490	+ type *s, u##bits val) \
1558	1491	{ \
1559	1492	BUILD_BUG_ON(sizeof(u##bits) != sizeof(((type *)0))->member); \
1560		- btrfs_set_token_##bits(eb, s, offsetof(type, member), val, token); \
	1493	+ btrfs_set_token_##bits(token, s, offsetof(type, member), val); \
1561	1494	}
1562	1495
1563	1496	#define BTRFS_SETGET_HEADER_FUNCS(name, type, member, bits) \
1564	1497	static inline u##bits btrfs_##name(const struct extent_buffer *eb) \
1565	1498	{ \
1566	1499	const type *p = page_address(eb->pages[0]); \
1567		- u##bits res = le##bits##_to_cpu(p->member); \
1568		- return res; \
	1500	+ return get_unaligned_le##bits(&p->member); \
1569	1501	} \
1570		-static inline void btrfs_set_##name(struct extent_buffer *eb, \
	1502	+static inline void btrfs_set_##name(const struct extent_buffer *eb, \
1571	1503	u##bits val) \
1572	1504	{ \
1573	1505	type *p = page_address(eb->pages[0]); \
1574		- p->member = cpu_to_le##bits(val); \
	1506	+ put_unaligned_le##bits(val, &p->member); \
1575	1507	}
1576	1508
1577	1509	#define BTRFS_SETGET_STACK_FUNCS(name, type, member, bits) \
1578	1510	static inline u##bits btrfs_##name(const type *s) \
1579	1511	{ \
1580		- return le##bits##_to_cpu(s->member); \
	1512	+ return get_unaligned_le##bits(&s->member); \
1581	1513	} \
1582	1514	static inline void btrfs_set_##name(type *s, u##bits val) \
1583	1515	{ \
1584		- s->member = cpu_to_le##bits(val); \
	1516	+ put_unaligned_le##bits(val, &s->member); \
1585	1517	}
1586	1518
1587		-
1588		-static inline u64 btrfs_device_total_bytes(struct extent_buffer *eb,
	1519	+static inline u64 btrfs_device_total_bytes(const struct extent_buffer *eb,
1589	1520	struct btrfs_dev_item *s)
1590	1521	{
1591	1522	BUILD_BUG_ON(sizeof(u64) !=
..	..	@@ -1593,7 +1524,7 @@
1593	1524	return btrfs_get_64(eb, s, offsetof(struct btrfs_dev_item,
1594	1525	total_bytes));
1595	1526	}
1596		-static inline void btrfs_set_device_total_bytes(struct extent_buffer *eb,
	1527	+static inline void btrfs_set_device_total_bytes(const struct extent_buffer *eb,
1597	1528	struct btrfs_dev_item *s,
1598	1529	u64 val)
1599	1530	{
..	..	@@ -1697,31 +1628,31 @@
1697	1628	return btrfs_stripe_dev_uuid(btrfs_stripe_nr(c, nr));
1698	1629	}
1699	1630
1700		-static inline u64 btrfs_stripe_offset_nr(struct extent_buffer *eb,
	1631	+static inline u64 btrfs_stripe_offset_nr(const struct extent_buffer *eb,
1701	1632	struct btrfs_chunk *c, int nr)
1702	1633	{
1703	1634	return btrfs_stripe_offset(eb, btrfs_stripe_nr(c, nr));
1704	1635	}
1705	1636
1706		-static inline u64 btrfs_stripe_devid_nr(struct extent_buffer *eb,
	1637	+static inline u64 btrfs_stripe_devid_nr(const struct extent_buffer *eb,
1707	1638	struct btrfs_chunk *c, int nr)
1708	1639	{
1709	1640	return btrfs_stripe_devid(eb, btrfs_stripe_nr(c, nr));
1710	1641	}
1711	1642
1712	1643	/* struct btrfs_block_group_item */
1713		-BTRFS_SETGET_STACK_FUNCS(block_group_used, struct btrfs_block_group_item,
	1644	+BTRFS_SETGET_STACK_FUNCS(stack_block_group_used, struct btrfs_block_group_item,
1714	1645	used, 64);
1715		-BTRFS_SETGET_FUNCS(disk_block_group_used, struct btrfs_block_group_item,
	1646	+BTRFS_SETGET_FUNCS(block_group_used, struct btrfs_block_group_item,
1716	1647	used, 64);
1717		-BTRFS_SETGET_STACK_FUNCS(block_group_chunk_objectid,
	1648	+BTRFS_SETGET_STACK_FUNCS(stack_block_group_chunk_objectid,
1718	1649	struct btrfs_block_group_item, chunk_objectid, 64);
1719	1650
1720		-BTRFS_SETGET_FUNCS(disk_block_group_chunk_objectid,
	1651	+BTRFS_SETGET_FUNCS(block_group_chunk_objectid,
1721	1652	struct btrfs_block_group_item, chunk_objectid, 64);
1722		-BTRFS_SETGET_FUNCS(disk_block_group_flags,
	1653	+BTRFS_SETGET_FUNCS(block_group_flags,
1723	1654	struct btrfs_block_group_item, flags, 64);
1724		-BTRFS_SETGET_STACK_FUNCS(block_group_flags,
	1655	+BTRFS_SETGET_STACK_FUNCS(stack_block_group_flags,
1725	1656	struct btrfs_block_group_item, flags, 64);
1726	1657
1727	1658	/* struct btrfs_free_space_info */
..	..	@@ -1783,31 +1714,21 @@
1783	1714	BTRFS_SETGET_FUNCS(dev_extent_chunk_offset, struct btrfs_dev_extent,
1784	1715	chunk_offset, 64);
1785	1716	BTRFS_SETGET_FUNCS(dev_extent_length, struct btrfs_dev_extent, length, 64);
1786		-
1787		-static inline unsigned long btrfs_dev_extent_chunk_tree_uuid(struct btrfs_dev_extent *dev)
1788		-{
1789		- unsigned long ptr = offsetof(struct btrfs_dev_extent, chunk_tree_uuid);
1790		- return (unsigned long)dev + ptr;
1791		-}
1792		-
1793	1717	BTRFS_SETGET_FUNCS(extent_refs, struct btrfs_extent_item, refs, 64);
1794	1718	BTRFS_SETGET_FUNCS(extent_generation, struct btrfs_extent_item,
1795	1719	generation, 64);
1796	1720	BTRFS_SETGET_FUNCS(extent_flags, struct btrfs_extent_item, flags, 64);
1797	1721
1798		-BTRFS_SETGET_FUNCS(extent_refs_v0, struct btrfs_extent_item_v0, refs, 32);
1799		-
1800		-
1801	1722	BTRFS_SETGET_FUNCS(tree_block_level, struct btrfs_tree_block_info, level, 8);
1802	1723
1803		-static inline void btrfs_tree_block_key(struct extent_buffer *eb,
	1724	+static inline void btrfs_tree_block_key(const struct extent_buffer *eb,
1804	1725	struct btrfs_tree_block_info *item,
1805	1726	struct btrfs_disk_key *key)
1806	1727	{
1807	1728	read_eb_member(eb, item, struct btrfs_tree_block_info, key, key);
1808	1729	}
1809	1730
1810		-static inline void btrfs_set_tree_block_key(struct extent_buffer *eb,
	1731	+static inline void btrfs_set_tree_block_key(const struct extent_buffer *eb,
1811	1732	struct btrfs_tree_block_info *item,
1812	1733	struct btrfs_disk_key *key)
1813	1734	{
..	..	@@ -1845,12 +1766,6 @@
1845	1766	return 0;
1846	1767	}
1847	1768
1848		-BTRFS_SETGET_FUNCS(ref_root_v0, struct btrfs_extent_ref_v0, root, 64);
1849		-BTRFS_SETGET_FUNCS(ref_generation_v0, struct btrfs_extent_ref_v0,
1850		- generation, 64);
1851		-BTRFS_SETGET_FUNCS(ref_objectid_v0, struct btrfs_extent_ref_v0, objectid, 64);
1852		-BTRFS_SETGET_FUNCS(ref_count_v0, struct btrfs_extent_ref_v0, count, 32);
1853		-
1854	1769	/* struct btrfs_node */
1855	1770	BTRFS_SETGET_FUNCS(key_blockptr, struct btrfs_key_ptr, blockptr, 64);
1856	1771	BTRFS_SETGET_FUNCS(key_generation, struct btrfs_key_ptr, generation, 64);
..	..	@@ -1859,7 +1774,7 @@
1859	1774	BTRFS_SETGET_STACK_FUNCS(stack_key_generation, struct btrfs_key_ptr,
1860	1775	generation, 64);
1861	1776
1862		-static inline u64 btrfs_node_blockptr(struct extent_buffer *eb, int nr)
	1777	+static inline u64 btrfs_node_blockptr(const struct extent_buffer *eb, int nr)
1863	1778	{
1864	1779	unsigned long ptr;
1865	1780	ptr = offsetof(struct btrfs_node, ptrs) +
..	..	@@ -1867,7 +1782,7 @@
1867	1782	return btrfs_key_blockptr(eb, (struct btrfs_key_ptr *)ptr);
1868	1783	}
1869	1784
1870		-static inline void btrfs_set_node_blockptr(struct extent_buffer *eb,
	1785	+static inline void btrfs_set_node_blockptr(const struct extent_buffer *eb,
1871	1786	int nr, u64 val)
1872	1787	{
1873	1788	unsigned long ptr;
..	..	@@ -1876,7 +1791,7 @@
1876	1791	btrfs_set_key_blockptr(eb, (struct btrfs_key_ptr *)ptr, val);
1877	1792	}
1878	1793
1879		-static inline u64 btrfs_node_ptr_generation(struct extent_buffer *eb, int nr)
	1794	+static inline u64 btrfs_node_ptr_generation(const struct extent_buffer *eb, int nr)
1880	1795	{
1881	1796	unsigned long ptr;
1882	1797	ptr = offsetof(struct btrfs_node, ptrs) +
..	..	@@ -1884,7 +1799,7 @@
1884	1799	return btrfs_key_generation(eb, (struct btrfs_key_ptr *)ptr);
1885	1800	}
1886	1801
1887		-static inline void btrfs_set_node_ptr_generation(struct extent_buffer *eb,
	1802	+static inline void btrfs_set_node_ptr_generation(const struct extent_buffer *eb,
1888	1803	int nr, u64 val)
1889	1804	{
1890	1805	unsigned long ptr;
..	..	@@ -1902,7 +1817,7 @@
1902	1817	void btrfs_node_key(const struct extent_buffer *eb,
1903	1818	struct btrfs_disk_key *disk_key, int nr);
1904	1819
1905		-static inline void btrfs_set_node_key(struct extent_buffer *eb,
	1820	+static inline void btrfs_set_node_key(const struct extent_buffer *eb,
1906	1821	struct btrfs_disk_key *disk_key, int nr)
1907	1822	{
1908	1823	unsigned long ptr;
..	..	@@ -2026,6 +1941,52 @@
2026	1941	BTRFS_SETGET_STACK_FUNCS(disk_key_offset, struct btrfs_disk_key, offset, 64);
2027	1942	BTRFS_SETGET_STACK_FUNCS(disk_key_type, struct btrfs_disk_key, type, 8);
2028	1943
	1944	+#ifdef __LITTLE_ENDIAN
	1945	+
	1946	+/*
	1947	+ * Optimized helpers for little-endian architectures where CPU and on-disk
	1948	+ * structures have the same endianness and we can skip conversions.
	1949	+ */
	1950	+
	1951	+static inline void btrfs_disk_key_to_cpu(struct btrfs_key *cpu_key,
	1952	+ const struct btrfs_disk_key *disk_key)
	1953	+{
	1954	+ memcpy(cpu_key, disk_key, sizeof(struct btrfs_key));
	1955	+}
	1956	+
	1957	+static inline void btrfs_cpu_key_to_disk(struct btrfs_disk_key *disk_key,
	1958	+ const struct btrfs_key *cpu_key)
	1959	+{
	1960	+ memcpy(disk_key, cpu_key, sizeof(struct btrfs_key));
	1961	+}
	1962	+
	1963	+static inline void btrfs_node_key_to_cpu(const struct extent_buffer *eb,
	1964	+ struct btrfs_key *cpu_key, int nr)
	1965	+{
	1966	+ struct btrfs_disk_key disk_key = (struct btrfs_disk_key )cpu_key;
	1967	+
	1968	+ btrfs_node_key(eb, disk_key, nr);
	1969	+}
	1970	+
	1971	+static inline void btrfs_item_key_to_cpu(const struct extent_buffer *eb,
	1972	+ struct btrfs_key *cpu_key, int nr)
	1973	+{
	1974	+ struct btrfs_disk_key disk_key = (struct btrfs_disk_key )cpu_key;
	1975	+
	1976	+ btrfs_item_key(eb, disk_key, nr);
	1977	+}
	1978	+
	1979	+static inline void btrfs_dir_item_key_to_cpu(const struct extent_buffer *eb,
	1980	+ const struct btrfs_dir_item *item,
	1981	+ struct btrfs_key *cpu_key)
	1982	+{
	1983	+ struct btrfs_disk_key disk_key = (struct btrfs_disk_key )cpu_key;
	1984	+
	1985	+ btrfs_dir_item_key(eb, item, disk_key);
	1986	+}
	1987	+
	1988	+#else
	1989	+
2029	1990	static inline void btrfs_disk_key_to_cpu(struct btrfs_key *cpu,
2030	1991	const struct btrfs_disk_key *disk)
2031	1992	{
..	..	@@ -2067,15 +2028,7 @@
2067	2028	btrfs_disk_key_to_cpu(key, &disk_key);
2068	2029	}
2069	2030
2070		-static inline u8 btrfs_key_type(const struct btrfs_key *key)
2071		-{
2072		- return key->type;
2073		-}
2074		-
2075		-static inline void btrfs_set_key_type(struct btrfs_key *key, u8 val)
2076		-{
2077		- key->type = val;
2078		-}
	2031	+#endif
2079	2032
2080	2033	/* struct btrfs_header */
2081	2034	BTRFS_SETGET_HEADER_FUNCS(header_bytenr, struct btrfs_header, bytenr, 64);
..	..	@@ -2097,18 +2050,16 @@
2097	2050	return (btrfs_header_flags(eb) & flag) == flag;
2098	2051	}
2099	2052
2100		-static inline int btrfs_set_header_flag(struct extent_buffer *eb, u64 flag)
	2053	+static inline void btrfs_set_header_flag(struct extent_buffer *eb, u64 flag)
2101	2054	{
2102	2055	u64 flags = btrfs_header_flags(eb);
2103	2056	btrfs_set_header_flags(eb, flags \| flag);
2104		- return (flags & flag) == flag;
2105	2057	}
2106	2058
2107		-static inline int btrfs_clear_header_flag(struct extent_buffer *eb, u64 flag)
	2059	+static inline void btrfs_clear_header_flag(struct extent_buffer *eb, u64 flag)
2108	2060	{
2109	2061	u64 flags = btrfs_header_flags(eb);
2110	2062	btrfs_set_header_flags(eb, flags & ~flag);
2111		- return (flags & flag) == flag;
2112	2063	}
2113	2064
2114	2065	static inline int btrfs_header_backref_rev(const struct extent_buffer *eb)
..	..	@@ -2124,16 +2075,6 @@
2124	2075	flags &= ~BTRFS_BACKREF_REV_MASK;
2125	2076	flags \|= (u64)rev << BTRFS_BACKREF_REV_SHIFT;
2126	2077	btrfs_set_header_flags(eb, flags);
2127		-}
2128		-
2129		-static inline unsigned long btrfs_header_fsid(void)
2130		-{
2131		- return offsetof(struct btrfs_header, fsid);
2132		-}
2133		-
2134		-static inline unsigned long btrfs_header_chunk_tree_uuid(const struct extent_buffer *eb)
2135		-{
2136		- return offsetof(struct btrfs_header, chunk_tree_uuid);
2137	2078	}
2138	2079
2139	2080	static inline int btrfs_is_leaf(const struct extent_buffer *eb)
..	..	@@ -2364,14 +2305,10 @@
2364	2305	BTRFS_SETGET_STACK_FUNCS(super_uuid_tree_generation, struct btrfs_super_block,
2365	2306	uuid_tree_generation, 64);
2366	2307
2367		-static inline int btrfs_super_csum_size(const struct btrfs_super_block *s)
2368		-{
2369		- u16 t = btrfs_super_csum_type(s);
2370		- /*
2371		- * csum type is validated at mount time
2372		- */
2373		- return btrfs_csum_sizes[t];
2374		-}
	2308	+int btrfs_super_csum_size(const struct btrfs_super_block *s);
	2309	+const char *btrfs_super_csum_name(u16 csum_type);
	2310	+const char *btrfs_super_csum_driver(u16 csum_type);
	2311	+size_t __attribute_const__ btrfs_get_num_csums(void);
2375	2312
2376	2313
2377	2314	/*
..	..	@@ -2379,18 +2316,18 @@
2379	2316	* this returns the address of the start of the last item,
2380	2317	* which is the stop of the leaf data stack
2381	2318	*/
2382		-static inline unsigned int leaf_data_end(const struct btrfs_fs_info *fs_info,
2383		- const struct extent_buffer *leaf)
	2319	+static inline unsigned int leaf_data_end(const struct extent_buffer *leaf)
2384	2320	{
2385	2321	u32 nr = btrfs_header_nritems(leaf);
2386	2322
2387	2323	if (nr == 0)
2388		- return BTRFS_LEAF_DATA_SIZE(fs_info);
	2324	+ return BTRFS_LEAF_DATA_SIZE(leaf->fs_info);
2389	2325	return btrfs_item_offset_nr(leaf, nr - 1);
2390	2326	}
2391	2327
2392	2328	/* struct btrfs_file_extent_item */
2393		-BTRFS_SETGET_FUNCS(file_extent_type, struct btrfs_file_extent_item, type, 8);
	2329	+BTRFS_SETGET_STACK_FUNCS(stack_file_extent_type, struct btrfs_file_extent_item,
	2330	+ type, 8);
2394	2331	BTRFS_SETGET_STACK_FUNCS(stack_file_extent_disk_bytenr,
2395	2332	struct btrfs_file_extent_item, disk_bytenr, 64);
2396	2333	BTRFS_SETGET_STACK_FUNCS(stack_file_extent_offset,
..	..	@@ -2399,6 +2336,8 @@
2399	2336	struct btrfs_file_extent_item, generation, 64);
2400	2337	BTRFS_SETGET_STACK_FUNCS(stack_file_extent_num_bytes,
2401	2338	struct btrfs_file_extent_item, num_bytes, 64);
	2339	+BTRFS_SETGET_STACK_FUNCS(stack_file_extent_ram_bytes,
	2340	+ struct btrfs_file_extent_item, ram_bytes, 64);
2402	2341	BTRFS_SETGET_STACK_FUNCS(stack_file_extent_disk_num_bytes,
2403	2342	struct btrfs_file_extent_item, disk_num_bytes, 64);
2404	2343	BTRFS_SETGET_STACK_FUNCS(stack_file_extent_compression,
..	..	@@ -2415,6 +2354,7 @@
2415	2354	return BTRFS_FILE_EXTENT_INLINE_DATA_START + datasize;
2416	2355	}
2417	2356
	2357	+BTRFS_SETGET_FUNCS(file_extent_type, struct btrfs_file_extent_item, type, 8);
2418	2358	BTRFS_SETGET_FUNCS(file_extent_disk_bytenr, struct btrfs_file_extent_item,
2419	2359	disk_bytenr, 64);
2420	2360	BTRFS_SETGET_FUNCS(file_extent_generation, struct btrfs_file_extent_item,
..	..	@@ -2444,30 +2384,6 @@
2444	2384	struct btrfs_item *e)
2445	2385	{
2446	2386	return btrfs_item_size(eb, e) - BTRFS_FILE_EXTENT_INLINE_DATA_START;
2447		-}
2448		-
2449		-/* btrfs_dev_stats_item */
2450		-static inline u64 btrfs_dev_stats_value(const struct extent_buffer *eb,
2451		- const struct btrfs_dev_stats_item *ptr,
2452		- int index)
2453		-{
2454		- u64 val;
2455		-
2456		- read_extent_buffer(eb, &val,
2457		- offsetof(struct btrfs_dev_stats_item, values) +
2458		- ((unsigned long)ptr) + (index * sizeof(u64)),
2459		- sizeof(val));
2460		- return val;
2461		-}
2462		-
2463		-static inline void btrfs_set_dev_stats_value(struct extent_buffer *eb,
2464		- struct btrfs_dev_stats_item *ptr,
2465		- int index, u64 val)
2466		-{
2467		- write_extent_buffer(eb, &val,
2468		- offsetof(struct btrfs_dev_stats_item, values) +
2469		- ((unsigned long)ptr) + (index * sizeof(u64)),
2470		- sizeof(val));
2471	2387	}
2472	2388
2473	2389	/* btrfs_qgroup_status_item */
..	..	@@ -2565,6 +2481,16 @@
2565	2481	((unsigned long)(BTRFS_LEAF_DATA_OFFSET + \
2566	2482	btrfs_item_offset_nr(leaf, slot)))
2567	2483
	2484	+static inline u32 btrfs_crc32c(u32 crc, const void *address, unsigned length)
	2485	+{
	2486	+ return crc32c(crc, address, length);
	2487	+}
	2488	+
	2489	+static inline void btrfs_crc32c_final(u32 crc, u8 *result)
	2490	+{
	2491	+ put_unaligned_le32(~crc, result);
	2492	+}
	2493	+
2568	2494	static inline u64 btrfs_name_hash(const char *name, int len)
2569	2495	{
2570	2496	return crc32c((u32)~1, name, len);
..	..	@@ -2579,12 +2505,6 @@
2579	2505	return (u64) crc32c(parent_objectid, name, len);
2580	2506	}
2581	2507
2582		-static inline bool btrfs_mixed_space_info(struct btrfs_space_info *space_info)
2583		-{
2584		- return ((space_info->flags & BTRFS_BLOCK_GROUP_METADATA) &&
2585		- (space_info->flags & BTRFS_BLOCK_GROUP_DATA));
2586		-}
2587		-
2588	2508	static inline gfp_t btrfs_alloc_write_mask(struct address_space *mapping)
2589	2509	{
2590	2510	return mapping_gfp_constraint(mapping, ~__GFP_FS);
..	..	@@ -2593,72 +2513,65 @@
2593	2513	/* extent-tree.c */
2594	2514
2595	2515	enum btrfs_inline_ref_type {
2596		- BTRFS_REF_TYPE_INVALID = 0,
2597		- BTRFS_REF_TYPE_BLOCK = 1,
2598		- BTRFS_REF_TYPE_DATA = 2,
2599		- BTRFS_REF_TYPE_ANY = 3,
	2516	+ BTRFS_REF_TYPE_INVALID,
	2517	+ BTRFS_REF_TYPE_BLOCK,
	2518	+ BTRFS_REF_TYPE_DATA,
	2519	+ BTRFS_REF_TYPE_ANY,
2600	2520	};
2601	2521
2602	2522	int btrfs_get_extent_inline_ref_type(const struct extent_buffer *eb,
2603	2523	struct btrfs_extent_inline_ref *iref,
2604	2524	enum btrfs_inline_ref_type is_data);
	2525	+u64 hash_extent_data_ref(u64 root_objectid, u64 owner, u64 offset);
2605	2526
2606	2527	u64 btrfs_csum_bytes_to_leaves(struct btrfs_fs_info *fs_info, u64 csum_bytes);
2607	2528
2608		-static inline u64 btrfs_calc_trans_metadata_size(struct btrfs_fs_info *fs_info,
2609		- unsigned num_items)
	2529	+/*
	2530	+ * Use this if we would be adding new items, as we could split nodes as we cow
	2531	+ * down the tree.
	2532	+ */
	2533	+static inline u64 btrfs_calc_insert_metadata_size(struct btrfs_fs_info *fs_info,
	2534	+ unsigned num_items)
2610	2535	{
2611	2536	return (u64)fs_info->nodesize * BTRFS_MAX_LEVEL * 2 * num_items;
2612	2537	}
2613	2538
2614	2539	/*
2615		- * Doing a truncate won't result in new nodes or leaves, just what we need for
2616		- * COW.
	2540	+ * Doing a truncate or a modification won't result in new nodes or leaves, just
	2541	+ * what we need for COW.
2617	2542	*/
2618		-static inline u64 btrfs_calc_trunc_metadata_size(struct btrfs_fs_info *fs_info,
	2543	+static inline u64 btrfs_calc_metadata_size(struct btrfs_fs_info *fs_info,
2619	2544	unsigned num_items)
2620	2545	{
2621	2546	return (u64)fs_info->nodesize * BTRFS_MAX_LEVEL * num_items;
2622	2547	}
2623	2548
2624		-int btrfs_should_throttle_delayed_refs(struct btrfs_trans_handle *trans,
2625		- struct btrfs_fs_info *fs_info);
2626		-int btrfs_check_space_for_delayed_refs(struct btrfs_trans_handle *trans,
2627		- struct btrfs_fs_info *fs_info);
2628		-void btrfs_dec_block_group_reservations(struct btrfs_fs_info *fs_info,
2629		- const u64 start);
2630		-void btrfs_wait_block_group_reservations(struct btrfs_block_group_cache *bg);
2631		-bool btrfs_inc_nocow_writers(struct btrfs_fs_info *fs_info, u64 bytenr);
2632		-void btrfs_dec_nocow_writers(struct btrfs_fs_info *fs_info, u64 bytenr);
2633		-void btrfs_wait_nocow_writers(struct btrfs_block_group_cache *bg);
2634		-void btrfs_put_block_group(struct btrfs_block_group_cache *cache);
	2549	+int btrfs_add_excluded_extent(struct btrfs_fs_info *fs_info,
	2550	+ u64 start, u64 num_bytes);
	2551	+void btrfs_free_excluded_extents(struct btrfs_block_group *cache);
2635	2552	int btrfs_run_delayed_refs(struct btrfs_trans_handle *trans,
2636	2553	unsigned long count);
2637		-int btrfs_async_run_delayed_refs(struct btrfs_fs_info *fs_info,
2638		- unsigned long count, u64 transid, int wait);
	2554	+void btrfs_cleanup_ref_head_accounting(struct btrfs_fs_info *fs_info,
	2555	+ struct btrfs_delayed_ref_root *delayed_refs,
	2556	+ struct btrfs_delayed_ref_head *head);
2639	2557	int btrfs_lookup_data_extent(struct btrfs_fs_info *fs_info, u64 start, u64 len);
2640	2558	int btrfs_lookup_extent_info(struct btrfs_trans_handle *trans,
2641	2559	struct btrfs_fs_info *fs_info, u64 bytenr,
2642	2560	u64 offset, int metadata, u64 refs, u64 flags);
2643		-int btrfs_pin_extent(struct btrfs_fs_info *fs_info,
2644		- u64 bytenr, u64 num, int reserved);
2645		-int btrfs_pin_extent_for_log_replay(struct btrfs_fs_info *fs_info,
	2561	+int btrfs_pin_extent(struct btrfs_trans_handle *trans, u64 bytenr, u64 num,
	2562	+ int reserved);
	2563	+int btrfs_pin_extent_for_log_replay(struct btrfs_trans_handle *trans,
2646	2564	u64 bytenr, u64 num_bytes);
2647		-int btrfs_exclude_logged_extents(struct btrfs_fs_info *fs_info,
2648		- struct extent_buffer *eb);
	2565	+int btrfs_exclude_logged_extents(struct extent_buffer *eb);
2649	2566	int btrfs_cross_ref_exist(struct btrfs_root *root,
2650		- u64 objectid, u64 offset, u64 bytenr);
2651		-struct btrfs_block_group_cache *btrfs_lookup_block_group(
2652		- struct btrfs_fs_info *info,
2653		- u64 bytenr);
2654		-void btrfs_get_block_group(struct btrfs_block_group_cache *cache);
2655		-void btrfs_put_block_group(struct btrfs_block_group_cache *cache);
	2567	+ u64 objectid, u64 offset, u64 bytenr, bool strict);
2656	2568	struct extent_buffer btrfs_alloc_tree_block(struct btrfs_trans_handle trans,
2657	2569	struct btrfs_root *root,
2658	2570	u64 parent, u64 root_objectid,
2659	2571	const struct btrfs_disk_key *key,
2660	2572	int level, u64 hint,
2661		- u64 empty_size);
	2573	+ u64 empty_size,
	2574	+ enum btrfs_lock_nesting nest);
2662	2575	void btrfs_free_tree_block(struct btrfs_trans_handle *trans,
2663	2576	struct btrfs_root *root,
2664	2577	struct extent_buffer *buf,
..	..	@@ -2678,128 +2591,92 @@
2678	2591	int btrfs_dec_ref(struct btrfs_trans_handle trans, struct btrfs_root root,
2679	2592	struct extent_buffer *buf, int full_backref);
2680	2593	int btrfs_set_disk_extent_flags(struct btrfs_trans_handle *trans,
2681		- struct btrfs_fs_info *fs_info,
2682		- u64 bytenr, u64 num_bytes, u64 flags,
	2594	+ struct extent_buffer *eb, u64 flags,
2683	2595	int level, int is_data);
2684		-int btrfs_free_extent(struct btrfs_trans_handle *trans,
2685		- struct btrfs_root *root,
2686		- u64 bytenr, u64 num_bytes, u64 parent, u64 root_objectid,
2687		- u64 owner, u64 offset);
	2596	+int btrfs_free_extent(struct btrfs_trans_handle trans, struct btrfs_ref ref);
2688	2597
2689	2598	int btrfs_free_reserved_extent(struct btrfs_fs_info *fs_info,
2690	2599	u64 start, u64 len, int delalloc);
2691		-int btrfs_free_and_pin_reserved_extent(struct btrfs_fs_info *fs_info,
2692		- u64 start, u64 len);
2693		-void btrfs_prepare_extent_commit(struct btrfs_fs_info *fs_info);
	2600	+int btrfs_pin_reserved_extent(struct btrfs_trans_handle *trans, u64 start,
	2601	+ u64 len);
2694	2602	int btrfs_finish_extent_commit(struct btrfs_trans_handle *trans);
2695	2603	int btrfs_inc_extent_ref(struct btrfs_trans_handle *trans,
2696		- struct btrfs_root *root,
2697		- u64 bytenr, u64 num_bytes, u64 parent,
2698		- u64 root_objectid, u64 owner, u64 offset);
	2604	+ struct btrfs_ref *generic_ref);
2699	2605
2700		-int btrfs_start_dirty_block_groups(struct btrfs_trans_handle *trans);
2701		-int btrfs_write_dirty_block_groups(struct btrfs_trans_handle *trans,
2702		- struct btrfs_fs_info *fs_info);
2703		-int btrfs_setup_space_cache(struct btrfs_trans_handle *trans,
2704		- struct btrfs_fs_info *fs_info);
2705	2606	int btrfs_extent_readonly(struct btrfs_fs_info *fs_info, u64 bytenr);
2706		-int btrfs_free_block_groups(struct btrfs_fs_info *info);
2707		-int btrfs_read_block_groups(struct btrfs_fs_info *info);
2708		-int btrfs_can_relocate(struct btrfs_fs_info *fs_info, u64 bytenr);
2709		-int btrfs_make_block_group(struct btrfs_trans_handle *trans,
2710		- u64 bytes_used, u64 type, u64 chunk_offset,
2711		- u64 size);
2712		-void btrfs_add_raid_kobjects(struct btrfs_fs_info *fs_info);
2713		-struct btrfs_trans_handle *btrfs_start_trans_remove_block_group(
2714		- struct btrfs_fs_info *fs_info,
2715		- const u64 chunk_offset);
2716		-int btrfs_remove_block_group(struct btrfs_trans_handle *trans,
2717		- u64 group_start, struct extent_map *em);
2718		-void btrfs_delete_unused_bgs(struct btrfs_fs_info *fs_info);
2719		-void btrfs_get_block_group_trimming(struct btrfs_block_group_cache *cache);
2720		-void btrfs_put_block_group_trimming(struct btrfs_block_group_cache *cache);
2721		-void btrfs_create_pending_block_groups(struct btrfs_trans_handle *trans);
2722		-u64 btrfs_data_alloc_profile(struct btrfs_fs_info *fs_info);
2723		-u64 btrfs_metadata_alloc_profile(struct btrfs_fs_info *fs_info);
2724		-u64 btrfs_system_alloc_profile(struct btrfs_fs_info *fs_info);
2725	2607	void btrfs_clear_space_info_full(struct btrfs_fs_info *info);
2726	2608
	2609	+/*
	2610	+ * Different levels for to flush space when doing space reservations.
	2611	+ *
	2612	+ * The higher the level, the more methods we try to reclaim space.
	2613	+ */
2727	2614	enum btrfs_reserve_flush_enum {
2728	2615	/* If we are in the transaction, we can't flush anything.*/
2729	2616	BTRFS_RESERVE_NO_FLUSH,
	2617	+
2730	2618	/*
2731		- * Flushing delalloc may cause deadlock somewhere, in this
2732		- * case, use FLUSH LIMIT
	2619	+ * Flush space by:
	2620	+ * - Running delayed inode items
	2621	+ * - Allocating a new chunk
2733	2622	*/
2734	2623	BTRFS_RESERVE_FLUSH_LIMIT,
	2624	+
	2625	+ /*
	2626	+ * Flush space by:
	2627	+ * - Running delayed inode items
	2628	+ * - Running delayed refs
	2629	+ * - Running delalloc and waiting for ordered extents
	2630	+ * - Allocating a new chunk
	2631	+ */
	2632	+ BTRFS_RESERVE_FLUSH_EVICT,
	2633	+
	2634	+ /*
	2635	+ * Flush space by above mentioned methods and by:
	2636	+ * - Running delayed iputs
	2637	+ * - Commiting transaction
	2638	+ *
	2639	+ * Can be interruped by fatal signal.
	2640	+ */
	2641	+ BTRFS_RESERVE_FLUSH_DATA,
	2642	+ BTRFS_RESERVE_FLUSH_FREE_SPACE_INODE,
2735	2643	BTRFS_RESERVE_FLUSH_ALL,
	2644	+
	2645	+ /*
	2646	+ * Pretty much the same as FLUSH_ALL, but can also steal space from
	2647	+ * global rsv.
	2648	+ *
	2649	+ * Can be interruped by fatal signal.
	2650	+ */
	2651	+ BTRFS_RESERVE_FLUSH_ALL_STEAL,
2736	2652	};
2737	2653
2738	2654	enum btrfs_flush_state {
2739	2655	FLUSH_DELAYED_ITEMS_NR = 1,
2740	2656	FLUSH_DELAYED_ITEMS = 2,
2741		- FLUSH_DELALLOC = 3,
2742		- FLUSH_DELALLOC_WAIT = 4,
2743		- ALLOC_CHUNK = 5,
2744		- COMMIT_TRANS = 6,
	2657	+ FLUSH_DELAYED_REFS_NR = 3,
	2658	+ FLUSH_DELAYED_REFS = 4,
	2659	+ FLUSH_DELALLOC = 5,
	2660	+ FLUSH_DELALLOC_WAIT = 6,
	2661	+ ALLOC_CHUNK = 7,
	2662	+ ALLOC_CHUNK_FORCE = 8,
	2663	+ RUN_DELAYED_IPUTS = 9,
	2664	+ COMMIT_TRANS = 10,
2745	2665	};
2746	2666
2747		-int btrfs_alloc_data_chunk_ondemand(struct btrfs_inode *inode, u64 bytes);
2748		-int btrfs_check_data_free_space(struct inode *inode,
2749		- struct extent_changeset **reserved, u64 start, u64 len);
2750		-void btrfs_free_reserved_data_space(struct inode *inode,
2751		- struct extent_changeset *reserved, u64 start, u64 len);
2752		-void btrfs_delalloc_release_space(struct inode *inode,
2753		- struct extent_changeset *reserved,
2754		- u64 start, u64 len, bool qgroup_free);
2755		-void btrfs_free_reserved_data_space_noquota(struct inode *inode, u64 start,
2756		- u64 len);
2757		-void btrfs_trans_release_chunk_metadata(struct btrfs_trans_handle *trans);
2758	2667	int btrfs_subvolume_reserve_metadata(struct btrfs_root *root,
2759	2668	struct btrfs_block_rsv *rsv,
2760	2669	int nitems, bool use_global_rsv);
2761		-void btrfs_subvolume_release_metadata(struct btrfs_fs_info *fs_info,
	2670	+void btrfs_subvolume_release_metadata(struct btrfs_root *root,
2762	2671	struct btrfs_block_rsv *rsv);
2763	2672	void btrfs_delalloc_release_extents(struct btrfs_inode *inode, u64 num_bytes);
2764	2673
2765	2674	int btrfs_delalloc_reserve_metadata(struct btrfs_inode *inode, u64 num_bytes);
2766		-void btrfs_delalloc_release_metadata(struct btrfs_inode *inode, u64 num_bytes,
2767		- bool qgroup_free);
2768		-int btrfs_delalloc_reserve_space(struct inode *inode,
2769		- struct extent_changeset **reserved, u64 start, u64 len);
2770		-void btrfs_init_block_rsv(struct btrfs_block_rsv *rsv, unsigned short type);
2771		-struct btrfs_block_rsv btrfs_alloc_block_rsv(struct btrfs_fs_info fs_info,
2772		- unsigned short type);
2773		-void btrfs_init_metadata_block_rsv(struct btrfs_fs_info *fs_info,
2774		- struct btrfs_block_rsv *rsv,
2775		- unsigned short type);
2776		-void btrfs_free_block_rsv(struct btrfs_fs_info *fs_info,
2777		- struct btrfs_block_rsv *rsv);
2778		-int btrfs_block_rsv_add(struct btrfs_root *root,
2779		- struct btrfs_block_rsv *block_rsv, u64 num_bytes,
2780		- enum btrfs_reserve_flush_enum flush);
2781		-int btrfs_block_rsv_check(struct btrfs_block_rsv *block_rsv, int min_factor);
2782		-int btrfs_block_rsv_refill(struct btrfs_root *root,
2783		- struct btrfs_block_rsv *block_rsv, u64 min_reserved,
2784		- enum btrfs_reserve_flush_enum flush);
2785		-int btrfs_block_rsv_migrate(struct btrfs_block_rsv *src_rsv,
2786		- struct btrfs_block_rsv *dst_rsv, u64 num_bytes,
2787		- int update_size);
2788		-int btrfs_cond_migrate_bytes(struct btrfs_fs_info *fs_info,
2789		- struct btrfs_block_rsv *dest, u64 num_bytes,
2790		- int min_factor);
2791		-void btrfs_block_rsv_release(struct btrfs_fs_info *fs_info,
2792		- struct btrfs_block_rsv *block_rsv,
2793		- u64 num_bytes);
2794		-int btrfs_inc_block_group_ro(struct btrfs_block_group_cache *cache);
2795		-void btrfs_dec_block_group_ro(struct btrfs_block_group_cache *cache);
2796		-void btrfs_put_block_group_cache(struct btrfs_fs_info *info);
2797	2675	u64 btrfs_account_ro_block_groups_free_space(struct btrfs_space_info *sinfo);
2798	2676	int btrfs_error_unpin_extent_range(struct btrfs_fs_info *fs_info,
2799	2677	u64 start, u64 end);
2800	2678	int btrfs_discard_extent(struct btrfs_fs_info *fs_info, u64 bytenr,
2801	2679	u64 num_bytes, u64 *actual_bytes);
2802		-int btrfs_force_chunk_alloc(struct btrfs_trans_handle *trans, u64 type);
2803	2680	int btrfs_trim_fs(struct btrfs_fs_info fs_info, struct fstrim_range range);
2804	2681
2805	2682	int btrfs_init_space_info(struct btrfs_fs_info *fs_info);
..	..	@@ -2808,15 +2685,11 @@
2808	2685	int btrfs_start_write_no_snapshotting(struct btrfs_root *root);
2809	2686	void btrfs_end_write_no_snapshotting(struct btrfs_root *root);
2810	2687	void btrfs_wait_for_snapshot_creation(struct btrfs_root *root);
2811		-void check_system_chunk(struct btrfs_trans_handle *trans, const u64 type);
2812		-u64 add_new_free_space(struct btrfs_block_group_cache *block_group,
2813		- u64 start, u64 end);
2814		-void btrfs_mark_bg_unused(struct btrfs_block_group_cache *bg);
2815	2688
2816	2689	/* ctree.c */
2817	2690	int btrfs_bin_search(struct extent_buffer eb, const struct btrfs_key key,
2818		- int level, int *slot);
2819		-int btrfs_comp_cpu_keys(const struct btrfs_key k1, const struct btrfs_key k2);
	2691	+ int *slot);
	2692	+int __pure btrfs_comp_cpu_keys(const struct btrfs_key k1, const struct btrfs_key k2);
2820	2693	int btrfs_previous_item(struct btrfs_root *root,
2821	2694	struct btrfs_path *path, u64 min_objectid,
2822	2695	int type);
..	..	@@ -2826,42 +2699,28 @@
2826	2699	struct btrfs_path *path,
2827	2700	const struct btrfs_key *new_key);
2828	2701	struct extent_buffer btrfs_root_node(struct btrfs_root root);
2829		-struct extent_buffer btrfs_lock_root_node(struct btrfs_root root);
2830		-struct extent_buffer btrfs_read_lock_root_node(struct btrfs_root root);
2831	2702	int btrfs_find_next_key(struct btrfs_root root, struct btrfs_path path,
2832	2703	struct btrfs_key *key, int lowest_level,
2833	2704	u64 min_trans);
2834	2705	int btrfs_search_forward(struct btrfs_root root, struct btrfs_key min_key,
2835	2706	struct btrfs_path *path,
2836	2707	u64 min_trans);
2837		-enum btrfs_compare_tree_result {
2838		- BTRFS_COMPARE_TREE_NEW,
2839		- BTRFS_COMPARE_TREE_DELETED,
2840		- BTRFS_COMPARE_TREE_CHANGED,
2841		- BTRFS_COMPARE_TREE_SAME,
2842		-};
2843		-typedef int (btrfs_changed_cb_t)(struct btrfs_path left_path,
2844		- struct btrfs_path *right_path,
2845		- struct btrfs_key *key,
2846		- enum btrfs_compare_tree_result result,
2847		- void *ctx);
2848		-int btrfs_compare_trees(struct btrfs_root *left_root,
2849		- struct btrfs_root *right_root,
2850		- btrfs_changed_cb_t cb, void *ctx);
	2708	+struct extent_buffer btrfs_read_node_slot(struct extent_buffer parent,
	2709	+ int slot);
	2710	+
2851	2711	int btrfs_cow_block(struct btrfs_trans_handle *trans,
2852	2712	struct btrfs_root root, struct extent_buffer buf,
2853	2713	struct extent_buffer *parent, int parent_slot,
2854		- struct extent_buffer **cow_ret);
	2714	+ struct extent_buffer **cow_ret,
	2715	+ enum btrfs_lock_nesting nest);
2855	2716	int btrfs_copy_root(struct btrfs_trans_handle *trans,
2856	2717	struct btrfs_root *root,
2857	2718	struct extent_buffer *buf,
2858	2719	struct extent_buffer **cow_ret, u64 new_root_objectid);
2859	2720	int btrfs_block_can_be_shared(struct btrfs_root *root,
2860	2721	struct extent_buffer *buf);
2861		-void btrfs_extend_item(struct btrfs_fs_info fs_info, struct btrfs_path path,
2862		- u32 data_size);
2863		-void btrfs_truncate_item(struct btrfs_fs_info *fs_info,
2864		- struct btrfs_path *path, u32 new_size, int from_end);
	2722	+void btrfs_extend_item(struct btrfs_path *path, u32 data_size);
	2723	+void btrfs_truncate_item(struct btrfs_path *path, u32 new_size, int from_end);
2865	2724	int btrfs_split_item(struct btrfs_trans_handle *trans,
2866	2725	struct btrfs_root *root,
2867	2726	struct btrfs_path *path,
..	..	@@ -2889,10 +2748,6 @@
2889	2748	void btrfs_release_path(struct btrfs_path *p);
2890	2749	struct btrfs_path *btrfs_alloc_path(void);
2891	2750	void btrfs_free_path(struct btrfs_path *p);
2892		-void btrfs_set_path_blocking(struct btrfs_path *p);
2893		-void btrfs_clear_path_blocking(struct btrfs_path *p,
2894		- struct extent_buffer *held, int held_rw);
2895		-void btrfs_unlock_up_safe(struct btrfs_path *p, int level);
2896	2751
2897	2752	int btrfs_del_items(struct btrfs_trans_handle trans, struct btrfs_root root,
2898	2753	struct btrfs_path *path, int slot, int nr);
..	..	@@ -2905,7 +2760,7 @@
2905	2760
2906	2761	void setup_items_for_insert(struct btrfs_root root, struct btrfs_path path,
2907	2762	const struct btrfs_key cpu_key, u32 data_size,
2908		- u32 total_data, u32 total_size, int nr);
	2763	+ int nr);
2909	2764	int btrfs_insert_item(struct btrfs_trans_handle trans, struct btrfs_root root,
2910	2765	const struct btrfs_key key, void data, u32 data_size);
2911	2766	int btrfs_insert_empty_items(struct btrfs_trans_handle *trans,
..	..	@@ -2939,11 +2794,9 @@
2939	2794	{
2940	2795	return btrfs_next_old_item(root, p, 0);
2941	2796	}
2942		-int btrfs_leaf_free_space(struct btrfs_fs_info *fs_info,
2943		- struct extent_buffer *leaf);
2944		-int __must_check btrfs_drop_snapshot(struct btrfs_root *root,
2945		- struct btrfs_block_rsv *block_rsv,
2946		- int update_ref, int for_reloc);
	2797	+int btrfs_leaf_free_space(struct extent_buffer *leaf);
	2798	+int __must_check btrfs_drop_snapshot(struct btrfs_root *root, int update_ref,
	2799	+ int for_reloc);
2947	2800	int btrfs_drop_subtree(struct btrfs_trans_handle *trans,
2948	2801	struct btrfs_root *root,
2949	2802	struct extent_buffer *node,
..	..	@@ -2969,24 +2822,6 @@
2969	2822	static inline int btrfs_need_cleaner_sleep(struct btrfs_fs_info *fs_info)
2970	2823	{
2971	2824	return fs_info->sb->s_flags & SB_RDONLY \|\| btrfs_fs_closing(fs_info);
2972		-}
2973		-
2974		-static inline void free_fs_info(struct btrfs_fs_info *fs_info)
2975		-{
2976		- kfree(fs_info->balance_ctl);
2977		- kfree(fs_info->delayed_root);
2978		- kfree(fs_info->extent_root);
2979		- kfree(fs_info->tree_root);
2980		- kfree(fs_info->chunk_root);
2981		- kfree(fs_info->dev_root);
2982		- kfree(fs_info->csum_root);
2983		- kfree(fs_info->quota_root);
2984		- kfree(fs_info->uuid_root);
2985		- kfree(fs_info->free_space_root);
2986		- kfree(fs_info->super_copy);
2987		- kfree(fs_info->super_for_commit);
2988		- security_free_mnt_opts(&fs_info->security_opts);
2989		- kvfree(fs_info);
2990	2825	}
2991	2826
2992	2827	/* tree mod log functions from ctree.c */
..	..	@@ -3027,15 +2862,12 @@
3027	2862	u64 subid);
3028	2863	int btrfs_uuid_tree_remove(struct btrfs_trans_handle trans, u8 uuid, u8 type,
3029	2864	u64 subid);
3030		-int btrfs_uuid_tree_iterate(struct btrfs_fs_info *fs_info,
3031		- int (check_func)(struct btrfs_fs_info , u8 *, u8,
3032		- u64));
	2865	+int btrfs_uuid_tree_iterate(struct btrfs_fs_info *fs_info);
3033	2866
3034	2867	/* dir-item.c */
3035	2868	int btrfs_check_dir_item_collision(struct btrfs_root *root, u64 dir,
3036	2869	const char *name, int name_len);
3037		-int btrfs_insert_dir_item(struct btrfs_trans_handle *trans,
3038		- struct btrfs_root root, const char name,
	2870	+int btrfs_insert_dir_item(struct btrfs_trans_handle trans, const char name,
3039	2871	int name_len, struct btrfs_inode *dir,
3040	2872	struct btrfs_key *location, u8 type, u64 index);
3041	2873	struct btrfs_dir_item btrfs_lookup_dir_item(struct btrfs_trans_handle trans,
..	..	@@ -3103,21 +2935,18 @@
3103	2935	u64 inode_objectid, u64 ref_objectid, int ins_len,
3104	2936	int cow);
3105	2937
3106		-int btrfs_find_name_in_backref(struct extent_buffer *leaf, int slot,
3107		- const char *name,
3108		- int name_len, struct btrfs_inode_ref **ref_ret);
3109		-int btrfs_find_name_in_ext_backref(struct extent_buffer *leaf, int slot,
3110		- u64 ref_objectid, const char *name,
3111		- int name_len,
3112		- struct btrfs_inode_extref **extref_ret);
3113		-
	2938	+struct btrfs_inode_ref btrfs_find_name_in_backref(struct extent_buffer leaf,
	2939	+ int slot, const char *name,
	2940	+ int name_len);
	2941	+struct btrfs_inode_extref *btrfs_find_name_in_ext_backref(
	2942	+ struct extent_buffer *leaf, int slot, u64 ref_objectid,
	2943	+ const char *name, int name_len);
3114	2944	/* file-item.c */
3115	2945	struct btrfs_dio_private;
3116	2946	int btrfs_del_csums(struct btrfs_trans_handle *trans,
3117	2947	struct btrfs_root *root, u64 bytenr, u64 len);
3118		-blk_status_t btrfs_lookup_bio_sums(struct inode inode, struct bio bio, u32 *dst);
3119		-blk_status_t btrfs_lookup_bio_sums_dio(struct inode inode, struct bio bio,
3120		- u64 logical_offset);
	2948	+blk_status_t btrfs_lookup_bio_sums(struct inode inode, struct bio bio,
	2949	+ u64 offset, u8 *dst);
3121	2950	int btrfs_insert_file_extent(struct btrfs_trans_handle *trans,
3122	2951	struct btrfs_root *root,
3123	2952	u64 objectid, u64 pos,
..	..	@@ -3131,8 +2960,8 @@
3131	2960	int btrfs_csum_file_blocks(struct btrfs_trans_handle *trans,
3132	2961	struct btrfs_root *root,
3133	2962	struct btrfs_ordered_sum *sums);
3134		-blk_status_t btrfs_csum_one_bio(struct inode inode, struct bio bio,
3135		- u64 file_start, int contig);
	2963	+blk_status_t btrfs_csum_one_bio(struct btrfs_inode inode, struct bio bio,
	2964	+ u64 file_start, int contig);
3136	2965	int btrfs_lookup_csums_range(struct btrfs_root *root, u64 start, u64 end,
3137	2966	struct list_head *list, int search_commit);
3138	2967	void btrfs_extent_item_to_extent_map(struct btrfs_inode *inode,
..	..	@@ -3140,14 +2969,23 @@
3140	2969	struct btrfs_file_extent_item *fi,
3141	2970	const bool new_inline,
3142	2971	struct extent_map *em);
	2972	+int btrfs_inode_clear_file_extent_range(struct btrfs_inode *inode, u64 start,
	2973	+ u64 len);
	2974	+int btrfs_inode_set_file_extent_range(struct btrfs_inode *inode, u64 start,
	2975	+ u64 len);
	2976	+void btrfs_inode_safe_disk_i_size_write(struct inode *inode, u64 new_i_size);
	2977	+u64 btrfs_file_extent_end(const struct btrfs_path *path);
3143	2978
3144	2979	/* inode.c */
	2980	+blk_status_t btrfs_submit_data_bio(struct inode inode, struct bio bio,
	2981	+ int mirror_num, unsigned long bio_flags);
	2982	+int btrfs_verify_data_csum(struct btrfs_io_bio *io_bio, u64 phy_offset,
	2983	+ struct page *page, u64 start, u64 end, int mirror);
3145	2984	struct extent_map btrfs_get_extent_fiemap(struct btrfs_inode inode,
3146		- struct page *page, size_t pg_offset, u64 start,
3147		- u64 len, int create);
	2985	+ u64 start, u64 len);
3148	2986	noinline int can_nocow_extent(struct inode inode, u64 offset, u64 len,
3149	2987	u64 orig_start, u64 orig_block_len,
3150		- u64 *ram_bytes);
	2988	+ u64 *ram_bytes, bool strict);
3151	2989
3152	2990	void __btrfs_del_delalloc_inode(struct btrfs_root *root,
3153	2991	struct btrfs_inode *inode);
..	..	@@ -3169,17 +3007,25 @@
3169	3007	u32 min_type);
3170	3008
3171	3009	int btrfs_start_delalloc_snapshot(struct btrfs_root *root);
3172		-int btrfs_start_delalloc_roots(struct btrfs_fs_info *fs_info, int nr);
3173		-int btrfs_set_extent_delalloc(struct inode *inode, u64 start, u64 end,
	3010	+int btrfs_start_delalloc_roots(struct btrfs_fs_info *fs_info, u64 nr,
	3011	+ bool in_reclaim_context);
	3012	+int btrfs_set_extent_delalloc(struct btrfs_inode *inode, u64 start, u64 end,
3174	3013	unsigned int extra_bits,
3175		- struct extent_state **cached_state, int dedupe);
	3014	+ struct extent_state **cached_state);
3176	3015	int btrfs_create_subvol_root(struct btrfs_trans_handle *trans,
3177	3016	struct btrfs_root *new_root,
3178	3017	struct btrfs_root *parent_root,
3179	3018	u64 new_dirid);
3180		-int btrfs_merge_bio_hook(struct page *page, unsigned long offset,
3181		- size_t size, struct bio *bio,
3182		- unsigned long bio_flags);
	3019	+ void btrfs_set_delalloc_extent(struct inode inode, struct extent_state state,
	3020	+ unsigned *bits);
	3021	+void btrfs_clear_delalloc_extent(struct inode *inode,
	3022	+ struct extent_state state, unsigned bits);
	3023	+void btrfs_merge_delalloc_extent(struct inode inode, struct extent_state new,
	3024	+ struct extent_state *other);
	3025	+void btrfs_split_delalloc_extent(struct inode *inode,
	3026	+ struct extent_state *orig, u64 split);
	3027	+int btrfs_bio_fits_in_stripe(struct page page, size_t size, struct bio bio,
	3028	+ unsigned long bio_flags);
3183	3029	void btrfs_set_range_writeback(struct extent_io_tree *tree, u64 start, u64 end);
3184	3030	vm_fault_t btrfs_page_mkwrite(struct vm_fault *vmf);
3185	3031	int btrfs_readpage(struct file file, struct page page);
..	..	@@ -3187,17 +3033,16 @@
3187	3033	int btrfs_write_inode(struct inode inode, struct writeback_control wbc);
3188	3034	struct inode btrfs_alloc_inode(struct super_block sb);
3189	3035	void btrfs_destroy_inode(struct inode *inode);
	3036	+void btrfs_free_inode(struct inode *inode);
3190	3037	int btrfs_drop_inode(struct inode *inode);
3191	3038	int __init btrfs_init_cachep(void);
3192	3039	void __cold btrfs_destroy_cachep(void);
3193		-struct inode btrfs_iget_path(struct super_block s, struct btrfs_key *location,
3194		- struct btrfs_root root, int new,
3195		- struct btrfs_path *path);
3196		-struct inode btrfs_iget(struct super_block s, struct btrfs_key *location,
3197		- struct btrfs_root root, int was_new);
	3040	+struct inode btrfs_iget_path(struct super_block s, u64 ino,
	3041	+ struct btrfs_root root, struct btrfs_path path);
	3042	+struct inode btrfs_iget(struct super_block s, u64 ino, struct btrfs_root *root);
3198	3043	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);
	3044	+ struct page *page, size_t pg_offset,
	3045	+ u64 start, u64 end);
3201	3046	int btrfs_update_inode(struct btrfs_trans_handle *trans,
3202	3047	struct btrfs_root *root,
3203	3048	struct inode *inode);
..	..	@@ -3209,6 +3054,7 @@
3209	3054	int btrfs_cont_expand(struct inode *inode, loff_t oldsize, loff_t size);
3210	3055	void btrfs_add_delayed_iput(struct inode *inode);
3211	3056	void btrfs_run_delayed_iputs(struct btrfs_fs_info *fs_info);
	3057	+int btrfs_wait_on_delayed_iputs(struct btrfs_fs_info *fs_info);
3212	3058	int btrfs_prealloc_file_range(struct inode *inode, int mode,
3213	3059	u64 start, u64 num_bytes, u64 min_size,
3214	3060	loff_t actual_len, u64 *alloc_hint);
..	..	@@ -3216,20 +3062,21 @@
3216	3062	struct btrfs_trans_handle *trans, int mode,
3217	3063	u64 start, u64 num_bytes, u64 min_size,
3218	3064	loff_t actual_len, u64 *alloc_hint);
3219		-int btrfs_run_delalloc_range(void private_data, struct page locked_page,
	3065	+int btrfs_run_delalloc_range(struct btrfs_inode inode, struct page locked_page,
3220	3066	u64 start, u64 end, int page_started, unsigned long nr_written,
3221	3067	struct writeback_control *wbc);
	3068	+int btrfs_writepage_cow_fixup(struct page *page, u64 start, u64 end);
	3069	+void btrfs_writepage_endio_finish_ordered(struct page *page, u64 start,
	3070	+ u64 end, int uptodate);
3222	3071	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
	3072	+ssize_t btrfs_direct_IO(struct kiocb iocb, struct iov_iter iter);
3226	3073
3227	3074	/* ioctl.c */
3228	3075	long btrfs_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
3229	3076	long btrfs_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
3230	3077	int btrfs_ioctl_get_supported_features(void __user *arg);
3231	3078	void btrfs_sync_inode_flags_to_i_flags(struct inode *inode);
3232		-int btrfs_is_empty_uuid(u8 *uuid);
	3079	+int __pure btrfs_is_empty_uuid(u8 *uuid);
3233	3080	int btrfs_defrag_file(struct inode inode, struct file file,
3234	3081	struct btrfs_ioctl_defrag_range_args *range,
3235	3082	u64 newer_than, unsigned long max_pages);
..	..	@@ -3237,9 +3084,9 @@
3237	3084	struct btrfs_ioctl_space_info *space);
3238	3085	void btrfs_update_ioctl_balance_args(struct btrfs_fs_info *fs_info,
3239	3086	struct btrfs_ioctl_balance_args *bargs);
3240		-int btrfs_dedupe_file_range(struct file *src_file, loff_t src_loff,
3241		- struct file *dst_file, loff_t dst_loff,
3242		- u64 olen);
	3087	+bool btrfs_exclop_start(struct btrfs_fs_info *fs_info,
	3088	+ enum btrfs_exclusive_operation type);
	3089	+void btrfs_exclop_finish(struct btrfs_fs_info *fs_info);
3243	3090
3244	3091	/* file.c */
3245	3092	int __init btrfs_auto_defrag_init(void);
..	..	@@ -3253,7 +3100,7 @@
3253	3100	int skip_pinned);
3254	3101	extern const struct file_operations btrfs_file_operations;
3255	3102	int __btrfs_drop_extents(struct btrfs_trans_handle *trans,
3256		- struct btrfs_root root, struct inode inode,
	3103	+ struct btrfs_root root, struct btrfs_inode inode,
3257	3104	struct btrfs_path *path, u64 start, u64 end,
3258	3105	u64 *drop_end, int drop_cache,
3259	3106	int replace_extent,
..	..	@@ -3262,25 +3109,24 @@
3262	3109	int btrfs_drop_extents(struct btrfs_trans_handle *trans,
3263	3110	struct btrfs_root root, struct inode inode, u64 start,
3264	3111	u64 end, int drop_cache);
	3112	+int btrfs_replace_file_extents(struct inode inode, struct btrfs_path path,
	3113	+ const u64 start, const u64 end,
	3114	+ struct btrfs_replace_extent_info *extent_info,
	3115	+ struct btrfs_trans_handle **trans_out);
3265	3116	int btrfs_mark_extent_written(struct btrfs_trans_handle *trans,
3266	3117	struct btrfs_inode *inode, u64 start, u64 end);
3267	3118	int btrfs_release_file(struct inode inode, struct file file);
3268		-int btrfs_dirty_pages(struct inode inode, struct page *pages,
	3119	+int btrfs_dirty_pages(struct btrfs_inode inode, struct page *pages,
3269	3120	size_t num_pages, loff_t pos, size_t write_bytes,
3270	3121	struct extent_state **cached);
3271	3122	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);
	3123	+int btrfs_check_nocow_lock(struct btrfs_inode *inode, loff_t pos,
	3124	+ size_t *write_bytes);
	3125	+void btrfs_check_nocow_unlock(struct btrfs_inode *inode);
3274	3126
3275	3127	/* tree-defrag.c */
3276	3128	int btrfs_defrag_leaves(struct btrfs_trans_handle *trans,
3277	3129	struct btrfs_root *root);
3278		-
3279		-/* sysfs.c */
3280		-int __init btrfs_init_sysfs(void);
3281		-void __cold 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	3130
3285	3131	/* super.c */
3286	3132	int btrfs_parse_options(struct btrfs_fs_info info, char options,
..	..	@@ -3374,31 +3220,17 @@
3374	3220
3375	3221	#if defined(CONFIG_DYNAMIC_DEBUG)
3376	3222	#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)
	3223	+ _dynamic_func_call_no_desc(fmt, btrfs_printk, \
	3224	+ fs_info, KERN_DEBUG fmt, ##args)
	3225	+#define btrfs_debug_in_rcu(fs_info, fmt, args...) \
	3226	+ _dynamic_func_call_no_desc(fmt, btrfs_printk_in_rcu, \
	3227	+ fs_info, KERN_DEBUG fmt, ##args)
3388	3228	#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)
	3229	+ _dynamic_func_call_no_desc(fmt, btrfs_printk_rl_in_rcu, \
	3230	+ fs_info, KERN_DEBUG fmt, ##args)
	3231	+#define btrfs_debug_rl(fs_info, fmt, args...) \
	3232	+ _dynamic_func_call_no_desc(fmt, btrfs_printk_ratelimited, \
	3233	+ fs_info, KERN_DEBUG fmt, ##args)
3402	3234	#elif defined(DEBUG)
3403	3235	#define btrfs_debug(fs_info, fmt, args...) \
3404	3236	btrfs_printk(fs_info, KERN_DEBUG fmt, ##args)
..	..	@@ -3450,19 +3282,29 @@
3450	3282	} while (0)
3451	3283
3452	3284	#ifdef CONFIG_BTRFS_ASSERT
3453		-
3454		-__cold
3455		-static inline void assfail(const char expr, const char file, int line)
	3285	+__cold __noreturn
	3286	+static inline void assertfail(const char expr, const char file, int line)
3456	3287	{
3457		- pr_err("assertion failed: %s, file: %s, line: %d\n",
3458		- expr, file, line);
	3288	+ pr_err("assertion failed: %s, in %s:%d\n", expr, file, line);
3459	3289	BUG();
3460	3290	}
3461	3291
3462		-#define ASSERT(expr) \
3463		- (likely(expr) ? (void)0 : assfail(#expr, __FILE__, __LINE__))
	3292	+#define ASSERT(expr) \
	3293	+ (likely(expr) ? (void)0 : assertfail(#expr, __FILE__, __LINE__))
	3294	+
3464	3295	#else
3465		-#define ASSERT(expr) ((void)0)
	3296	+static inline void assertfail(const char expr, const char file, int line) { }
	3297	+#define ASSERT(expr) (void)(expr)
	3298	+#endif
	3299	+
	3300	+/*
	3301	+ * Use that for functions that are conditionally exported for sanity tests but
	3302	+ * otherwise static
	3303	+ */
	3304	+#ifndef CONFIG_BTRFS_FS_RUN_SANITY_TESTS
	3305	+#define EXPORT_FOR_TESTS static
	3306	+#else
	3307	+#define EXPORT_FOR_TESTS
3466	3308	#endif
3467	3309
3468	3310	__cold
..	..	@@ -3477,7 +3319,7 @@
3477	3319	void __btrfs_handle_fs_error(struct btrfs_fs_info fs_info, const char function,
3478	3320	unsigned int line, int errno, const char *fmt, ...);
3479	3321
3480		-const char *btrfs_decode_error(int errno);
	3322	+const char * __attribute_const__ btrfs_decode_error(int errno);
3481	3323
3482	3324	__cold
3483	3325	void __btrfs_abort_transaction(struct btrfs_trans_handle *trans,
..	..	@@ -3493,7 +3335,7 @@
3493	3335	/* Report first abort since mount */ \
3494	3336	if (!test_and_set_bit(BTRFS_FS_STATE_TRANS_ABORTED, \
3495	3337	&((trans)->fs_info->fs_state))) { \
3496		- if ((errno) != -EIO) { \
	3338	+ if ((errno) != -EIO && (errno) != -EROFS) { \
3497	3339	WARN(1, KERN_DEBUG \
3498	3340	"BTRFS: Transaction aborted (error %d)\n", \
3499	3341	(errno)); \
..	..	@@ -3531,10 +3373,11 @@
3531	3373	/* compatibility and incompatibility defines */
3532	3374
3533	3375	#define btrfs_set_fs_incompat(__fs_info, opt) \
3534		- __btrfs_set_fs_incompat((__fs_info), BTRFS_FEATURE_INCOMPAT_##opt)
	3376	+ __btrfs_set_fs_incompat((__fs_info), BTRFS_FEATURE_INCOMPAT_##opt, \
	3377	+ #opt)
3535	3378
3536	3379	static inline void __btrfs_set_fs_incompat(struct btrfs_fs_info *fs_info,
3537		- u64 flag)
	3380	+ u64 flag, const char* name)
3538	3381	{
3539	3382	struct btrfs_super_block *disk_super;
3540	3383	u64 features;
..	..	@@ -3547,18 +3390,20 @@
3547	3390	if (!(features & flag)) {
3548	3391	features \|= flag;
3549	3392	btrfs_set_super_incompat_flags(disk_super, features);
3550		- btrfs_info(fs_info, "setting %llu feature flag",
3551		- flag);
	3393	+ btrfs_info(fs_info,
	3394	+ "setting incompat feature flag for %s (0x%llx)",
	3395	+ name, flag);
3552	3396	}
3553	3397	spin_unlock(&fs_info->super_lock);
3554	3398	}
3555	3399	}
3556	3400
3557	3401	#define btrfs_clear_fs_incompat(__fs_info, opt) \
3558		- __btrfs_clear_fs_incompat((__fs_info), BTRFS_FEATURE_INCOMPAT_##opt)
	3402	+ __btrfs_clear_fs_incompat((__fs_info), BTRFS_FEATURE_INCOMPAT_##opt, \
	3403	+ #opt)
3559	3404
3560	3405	static inline void __btrfs_clear_fs_incompat(struct btrfs_fs_info *fs_info,
3561		- u64 flag)
	3406	+ u64 flag, const char* name)
3562	3407	{
3563	3408	struct btrfs_super_block *disk_super;
3564	3409	u64 features;
..	..	@@ -3571,8 +3416,9 @@
3571	3416	if (features & flag) {
3572	3417	features &= ~flag;
3573	3418	btrfs_set_super_incompat_flags(disk_super, features);
3574		- btrfs_info(fs_info, "clearing %llu feature flag",
3575		- flag);
	3419	+ btrfs_info(fs_info,
	3420	+ "clearing incompat feature flag for %s (0x%llx)",
	3421	+ name, flag);
3576	3422	}
3577	3423	spin_unlock(&fs_info->super_lock);
3578	3424	}
..	..	@@ -3589,10 +3435,11 @@
3589	3435	}
3590	3436
3591	3437	#define btrfs_set_fs_compat_ro(__fs_info, opt) \
3592		- __btrfs_set_fs_compat_ro((__fs_info), BTRFS_FEATURE_COMPAT_RO_##opt)
	3438	+ __btrfs_set_fs_compat_ro((__fs_info), BTRFS_FEATURE_COMPAT_RO_##opt, \
	3439	+ #opt)
3593	3440
3594	3441	static inline void __btrfs_set_fs_compat_ro(struct btrfs_fs_info *fs_info,
3595		- u64 flag)
	3442	+ u64 flag, const char *name)
3596	3443	{
3597	3444	struct btrfs_super_block *disk_super;
3598	3445	u64 features;
..	..	@@ -3605,18 +3452,20 @@
3605	3452	if (!(features & flag)) {
3606	3453	features \|= flag;
3607	3454	btrfs_set_super_compat_ro_flags(disk_super, features);
3608		- btrfs_info(fs_info, "setting %llu ro feature flag",
3609		- flag);
	3455	+ btrfs_info(fs_info,
	3456	+ "setting compat-ro feature flag for %s (0x%llx)",
	3457	+ name, flag);
3610	3458	}
3611	3459	spin_unlock(&fs_info->super_lock);
3612	3460	}
3613	3461	}
3614	3462
3615	3463	#define btrfs_clear_fs_compat_ro(__fs_info, opt) \
3616		- __btrfs_clear_fs_compat_ro((__fs_info), BTRFS_FEATURE_COMPAT_RO_##opt)
	3464	+ __btrfs_clear_fs_compat_ro((__fs_info), BTRFS_FEATURE_COMPAT_RO_##opt, \
	3465	+ #opt)
3617	3466
3618	3467	static inline void __btrfs_clear_fs_compat_ro(struct btrfs_fs_info *fs_info,
3619		- u64 flag)
	3468	+ u64 flag, const char *name)
3620	3469	{
3621	3470	struct btrfs_super_block *disk_super;
3622	3471	u64 features;
..	..	@@ -3629,8 +3478,9 @@
3629	3478	if (features & flag) {
3630	3479	features &= ~flag;
3631	3480	btrfs_set_super_compat_ro_flags(disk_super, features);
3632		- btrfs_info(fs_info, "clearing %llu ro feature flag",
3633		- flag);
	3481	+ btrfs_info(fs_info,
	3482	+ "clearing compat-ro feature flag for %s (0x%llx)",
	3483	+ name, flag);
3634	3484	}
3635	3485	spin_unlock(&fs_info->super_lock);
3636	3486	}
..	..	@@ -3669,7 +3519,7 @@
3669	3519	int btrfs_update_reloc_root(struct btrfs_trans_handle *trans,
3670	3520	struct btrfs_root *root);
3671	3521	int btrfs_recover_relocation(struct btrfs_root *root);
3672		-int btrfs_reloc_clone_csums(struct inode *inode, u64 file_pos, u64 len);
	3522	+int btrfs_reloc_clone_csums(struct btrfs_inode *inode, u64 file_pos, u64 len);
3673	3523	int btrfs_reloc_cow_block(struct btrfs_trans_handle *trans,
3674	3524	struct btrfs_root root, struct extent_buffer buf,
3675	3525	struct extent_buffer *cow);
..	..	@@ -3677,6 +3527,10 @@
3677	3527	u64 *bytes_to_reserve);
3678	3528	int btrfs_reloc_post_snapshot(struct btrfs_trans_handle *trans,
3679	3529	struct btrfs_pending_snapshot *pending);
	3530	+int btrfs_should_cancel_balance(struct btrfs_fs_info *fs_info);
	3531	+struct btrfs_root find_reloc_root(struct btrfs_fs_info fs_info,
	3532	+ u64 bytenr);
	3533	+int btrfs_should_ignore_reloc_root(struct btrfs_root *root);
3680	3534
3681	3535	/* scrub.c */
3682	3536	int btrfs_scrub_dev(struct btrfs_fs_info *fs_info, u64 devid, u64 start,
..	..	@@ -3685,8 +3539,7 @@
3685	3539	void btrfs_scrub_pause(struct btrfs_fs_info *fs_info);
3686	3540	void btrfs_scrub_continue(struct btrfs_fs_info *fs_info);
3687	3541	int btrfs_scrub_cancel(struct btrfs_fs_info *info);
3688		-int btrfs_scrub_cancel_dev(struct btrfs_fs_info *info,
3689		- struct btrfs_device *dev);
	3542	+int btrfs_scrub_cancel_dev(struct btrfs_device *dev);
3690	3543	int btrfs_scrub_progress(struct btrfs_fs_info *fs_info, u64 devid,
3691	3544	struct btrfs_scrub_progress *progress);
3692	3545	static inline void btrfs_init_full_stripe_locks_tree(
..	..	@@ -3720,6 +3573,8 @@
3720	3573	int btrfs_reada_wait(void *handle);
3721	3574	void btrfs_reada_detach(void *handle);
3722	3575	int btree_readahead_hook(struct extent_buffer *eb, int err);
	3576	+void btrfs_reada_remove_dev(struct btrfs_device *dev);
	3577	+void btrfs_reada_undo_remove_dev(struct btrfs_device *dev);
3723	3578
3724	3579	static inline int is_fstree(u64 rootid)
3725	3580	{
..	..	@@ -3735,41 +3590,20 @@
3735	3590	return signal_pending(current);
3736	3591	}
3737	3592
	3593	+#define in_range(b, first, len) ((b) >= (first) && (b) < (first) + (len))
	3594	+
3738	3595	/* Sanity test specific functions */
3739	3596	#ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS
3740	3597	void btrfs_test_destroy_inode(struct inode *inode);
3741		-#endif
3742		-
3743	3598	static inline int btrfs_is_testing(struct btrfs_fs_info *fs_info)
3744	3599	{
3745		-#ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS
3746		- if (unlikely(test_bit(BTRFS_FS_STATE_DUMMY_FS_INFO,
3747		- &fs_info->fs_state)))
3748		- return 1;
3749		-#endif
	3600	+ return test_bit(BTRFS_FS_STATE_DUMMY_FS_INFO, &fs_info->fs_state);
	3601	+}
	3602	+#else
	3603	+static inline int btrfs_is_testing(struct btrfs_fs_info *fs_info)
	3604	+{
3750	3605	return 0;
3751	3606	}
3752		-
3753		-static inline void cond_wake_up(struct wait_queue_head *wq)
3754		-{
3755		- /*
3756		- * This implies a full smp_mb barrier, see comments for
3757		- * waitqueue_active why.
3758		- */
3759		- if (wq_has_sleeper(wq))
3760		- wake_up(wq);
3761		-}
3762		-
3763		-static inline void cond_wake_up_nomb(struct wait_queue_head *wq)
3764		-{
3765		- /*
3766		- * Special case for conditional wakeup where the barrier required for
3767		- * waitqueue_active is implied by some of the preceding code. Eg. one
3768		- * of such atomic operations (atomic_dec_and_return, ...), or a
3769		- * unlock/lock sequence, etc.
3770		- */
3771		- if (waitqueue_active(wq))
3772		- wake_up(wq);
3773		-}
	3607	+#endif
3774	3608
3775	3609	#endif