~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,85 @@
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	+bool btrfs_pinned_by_swapfile(struct btrfs_fs_info fs_info, void ptr);
	533	+
	534	+enum {
	535	+ BTRFS_FS_BARRIER,
	536	+ BTRFS_FS_CLOSING_START,
	537	+ BTRFS_FS_CLOSING_DONE,
	538	+ BTRFS_FS_LOG_RECOVERING,
	539	+ BTRFS_FS_OPEN,
	540	+ BTRFS_FS_QUOTA_ENABLED,
	541	+ BTRFS_FS_UPDATE_UUID_TREE_GEN,
	542	+ BTRFS_FS_CREATING_FREE_SPACE_TREE,
	543	+ BTRFS_FS_BTREE_ERR,
	544	+ BTRFS_FS_LOG1_ERR,
	545	+ BTRFS_FS_LOG2_ERR,
	546	+ BTRFS_FS_QUOTA_OVERRIDE,
	547	+ /* Used to record internally whether fs has been frozen */
	548	+ BTRFS_FS_FROZEN,
	549	+ /*
	550	+ * Indicate that balance has been set up from the ioctl and is in the
	551	+ * main phase. The fs_info::balance_ctl is initialized.
	552	+ * Set and cleared while holding fs_info::balance_mutex.
	553	+ */
	554	+ BTRFS_FS_BALANCE_RUNNING,
	555	+
	556	+ /* Indicate that the cleaner thread is awake and doing something. */
	557	+ BTRFS_FS_CLEANER_RUNNING,
	558	+
	559	+ /*
	560	+ * The checksumming has an optimized version and is considered fast,
	561	+ * so we don't need to offload checksums to workqueues.
	562	+ */
	563	+ BTRFS_FS_CSUM_IMPL_FAST,
	564	+
	565	+ /* Indicate that the discard workqueue can service discards. */
	566	+ BTRFS_FS_DISCARD_RUNNING,
	567	+
	568	+ /* Indicate that we can't trust the free space tree for caching yet */
	569	+ BTRFS_FS_FREE_SPACE_TREE_UNTRUSTED,
	570	+};
734	571
735	572	/*
736		- * Indicate that a whole-filesystem exclusive operation is running
737		- * (device replace, resize, device add/delete, balance)
	573	+ * Exclusive operations (device replace, resize, device add/remove, balance)
738	574	*/
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
	575	+enum btrfs_exclusive_operation {
	576	+ BTRFS_EXCLOP_NONE,
	577	+ BTRFS_EXCLOP_BALANCE,
	578	+ BTRFS_EXCLOP_DEV_ADD,
	579	+ BTRFS_EXCLOP_DEV_REMOVE,
	580	+ BTRFS_EXCLOP_DEV_REPLACE,
	581	+ BTRFS_EXCLOP_RESIZE,
	582	+ BTRFS_EXCLOP_SWAP_ACTIVATE,
	583	+};
752	584
753	585	struct btrfs_fs_info {
754		- u8 fsid[BTRFS_FSID_SIZE];
755	586	u8 chunk_tree_uuid[BTRFS_UUID_SIZE];
756	587	unsigned long flags;
757	588	struct btrfs_root *extent_root;
..	..	@@ -763,6 +594,7 @@
763	594	struct btrfs_root *quota_root;
764	595	struct btrfs_root *uuid_root;
765	596	struct btrfs_root *free_space_root;
	597	+ struct btrfs_root *data_reloc_root;
766	598
767	599	/* the log root tree is a directory of all the other log roots */
768	600	struct btrfs_root *log_root_tree;
..	..	@@ -778,11 +610,11 @@
778	610	/* keep track of unallocated space */
779	611	atomic64_t free_chunk_space;
780	612
781		- struct extent_io_tree freed_extents[2];
782		- struct extent_io_tree *pinned_extents;
	613	+ /* Track ranges which are used by log trees blocks/logged data extents */
	614	+ struct extent_io_tree excluded_extents;
783	615
784	616	/* logical->physical extent mapping */
785		- struct btrfs_mapping_tree mapping_tree;
	617	+ struct extent_map_tree mapping_tree;
786	618
787	619	/*
788	620	* block reservation for extent, checksum, root tree and
..	..	@@ -795,6 +627,8 @@
795	627	struct btrfs_block_rsv chunk_block_rsv;
796	628	/* block reservation for delayed operations */
797	629	struct btrfs_block_rsv delayed_block_rsv;
	630	+ /* block reservation for delayed refs */
	631	+ struct btrfs_block_rsv delayed_refs_rsv;
798	632
799	633	struct btrfs_block_rsv empty_block_rsv;
800	634
..	..	@@ -876,7 +710,6 @@
876	710	struct rw_semaphore cleanup_work_sem;
877	711
878	712	struct rw_semaphore subvol_sem;
879		- struct srcu_struct subvol_srcu;
880	713
881	714	spinlock_t trans_lock;
882	715	/*
..	..	@@ -891,7 +724,8 @@
891	724
892	725	spinlock_t delayed_iput_lock;
893	726	struct list_head delayed_iputs;
894		- struct mutex cleaner_delayed_iput_mutex;
	727	+ atomic_t nr_delayed_iputs;
	728	+ wait_queue_head_t delayed_iputs_wait;
895	729
896	730	atomic64_t tree_mod_seq;
897	731
..	..	@@ -937,12 +771,10 @@
937	771	struct btrfs_workqueue *endio_workers;
938	772	struct btrfs_workqueue *endio_meta_workers;
939	773	struct btrfs_workqueue *endio_raid56_workers;
940		- struct btrfs_workqueue *endio_repair_workers;
941	774	struct btrfs_workqueue *rmw_workers;
942	775	struct btrfs_workqueue *endio_meta_write_workers;
943	776	struct btrfs_workqueue *endio_write_workers;
944	777	struct btrfs_workqueue *endio_freespace_worker;
945		- struct btrfs_workqueue *submit_workers;
946	778	struct btrfs_workqueue *caching_workers;
947	779	struct btrfs_workqueue *readahead_workers;
948	780
..	..	@@ -954,21 +786,19 @@
954	786	struct btrfs_workqueue *fixup_workers;
955	787	struct btrfs_workqueue *delayed_workers;
956	788
957		- /* the extent workers do delayed refs on the extent allocation tree */
958		- struct btrfs_workqueue *extent_workers;
959	789	struct task_struct *transaction_kthread;
960	790	struct task_struct *cleaner_kthread;
961	791	u32 thread_pool_size;
962	792
963	793	struct kobject *space_info_kobj;
964		- struct list_head pending_raid_kobjs;
965		- spinlock_t pending_raid_kobjs_lock; /* uncontended */
	794	+ struct kobject *qgroups_kobj;
966	795
967	796	u64 total_pinned;
968	797
969	798	/* used to keep from writing metadata until there is a nice batch */
970	799	struct percpu_counter dirty_metadata_bytes;
971	800	struct percpu_counter delalloc_bytes;
	801	+ struct percpu_counter dio_bytes;
972	802	s32 dirty_metadata_batch;
973	803	s32 delalloc_batch;
974	804
..	..	@@ -1029,11 +859,16 @@
1029	859	atomic_t scrubs_paused;
1030	860	atomic_t scrub_cancel_req;
1031	861	wait_queue_head_t scrub_pause_wait;
1032		- int scrub_workers_refcnt;
	862	+ /*
	863	+ * The worker pointers are NULL iff the refcount is 0, ie. scrub is not
	864	+ * running.
	865	+ */
	866	+ refcount_t scrub_workers_refcnt;
1033	867	struct btrfs_workqueue *scrub_workers;
1034	868	struct btrfs_workqueue *scrub_wr_completion_workers;
1035		- struct btrfs_workqueue *scrub_nocow_workers;
1036	869	struct btrfs_workqueue *scrub_parity_workers;
	870	+
	871	+ struct btrfs_discard_ctl discard_ctl;
1037	872
1038	873	#ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
1039	874	u32 check_integrity_print_mask;
..	..	@@ -1043,10 +878,7 @@
1043	878
1044	879	/* holds configuration and tracking. Protected by qgroup_lock */
1045	880	struct rb_root qgroup_tree;
1046		- struct rb_root qgroup_op_tree;
1047	881	spinlock_t qgroup_lock;
1048		- spinlock_t qgroup_op_lock;
1049		- atomic_t qgroup_op_seq;
1050	882
1051	883	/*
1052	884	* used to avoid frequently calling ulist_alloc()/ulist_free()
..	..	@@ -1054,7 +886,10 @@
1054	886	*/
1055	887	struct ulist *qgroup_ulist;
1056	888
1057		- /* protect user change for quota operations */
	889	+ /*
	890	+ * Protect user change for quota operations. If a transaction is needed,
	891	+ * it must be started before locking this lock.
	892	+ */
1058	893	struct mutex qgroup_ioctl_lock;
1059	894
1060	895	/* list of dirty qgroups to be written at next commit */
..	..	@@ -1093,36 +928,49 @@
1093	928	/* device replace state */
1094	929	struct btrfs_dev_replace dev_replace;
1095	930
1096		- struct percpu_counter bio_counter;
1097		- wait_queue_head_t replace_wait;
1098		-
1099	931	struct semaphore uuid_tree_rescan_sem;
1100	932
1101	933	/* Used to reclaim the metadata space in the background. */
1102	934	struct work_struct async_reclaim_work;
	935	+ struct work_struct async_data_reclaim_work;
1103	936
1104	937	spinlock_t unused_bgs_lock;
1105	938	struct list_head unused_bgs;
1106	939	struct mutex unused_bg_unpin_mutex;
1107	940	struct mutex delete_unused_bgs_mutex;
1108	941
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	942	/* Cached block sizes */
1119	943	u32 nodesize;
1120	944	u32 sectorsize;
1121	945	u32 stripesize;
1122	946
	947	+ /* Block groups and devices containing active swapfiles. */
	948	+ spinlock_t swapfile_pins_lock;
	949	+ struct rb_root swapfile_pins;
	950	+
	951	+ struct crypto_shash *csum_shash;
	952	+
	953	+ /*
	954	+ * Number of send operations in progress.
	955	+ * Updated while holding fs_info::balance_mutex.
	956	+ */
	957	+ int send_in_progress;
	958	+
	959	+ /* Type of exclusive operation running */
	960	+ unsigned long exclusive_operation;
	961	+
1123	962	#ifdef CONFIG_BTRFS_FS_REF_VERIFY
1124	963	spinlock_t ref_verify_lock;
1125	964	struct rb_root block_tree;
	965	+#endif
	966	+
	967	+#ifdef CONFIG_BTRFS_DEBUG
	968	+ struct kobject *debug_kobj;
	969	+ struct kobject *discard_debug_kobj;
	970	+ struct list_head allocated_roots;
	971	+
	972	+ spinlock_t eb_leak_lock;
	973	+ struct list_head allocated_ebs;
1126	974	#endif
1127	975	};
1128	976
..	..	@@ -1131,30 +979,72 @@
1131	979	return sb->s_fs_info;
1132	980	}
1133	981
1134		-struct btrfs_subvolume_writers {
1135		- struct percpu_counter counter;
1136		- wait_queue_head_t wait;
1137		-};
1138		-
1139	982	/*
1140	983	* The state of btrfs root
1141	984	*/
	985	+enum {
	986	+ /*
	987	+ * btrfs_record_root_in_trans is a multi-step process, and it can race
	988	+ * with the balancing code. But the race is very small, and only the
	989	+ * first time the root is added to each transaction. So IN_TRANS_SETUP
	990	+ * is used to tell us when more checks are required
	991	+ */
	992	+ BTRFS_ROOT_IN_TRANS_SETUP,
	993	+
	994	+ /*
	995	+ * Set if tree blocks of this root can be shared by other roots.
	996	+ * Only subvolume trees and their reloc trees have this bit set.
	997	+ * Conflicts with TRACK_DIRTY bit.
	998	+ *
	999	+ * This affects two things:
	1000	+ *
	1001	+ * - How balance works
	1002	+ * For shareable roots, we need to use reloc tree and do path
	1003	+ * replacement for balance, and need various pre/post hooks for
	1004	+ * snapshot creation to handle them.
	1005	+ *
	1006	+ * While for non-shareable trees, we just simply do a tree search
	1007	+ * with COW.
	1008	+ *
	1009	+ * - How dirty roots are tracked
	1010	+ * For shareable roots, btrfs_record_root_in_trans() is needed to
	1011	+ * track them, while non-subvolume roots have TRACK_DIRTY bit, they
	1012	+ * don't need to set this manually.
	1013	+ */
	1014	+ BTRFS_ROOT_SHAREABLE,
	1015	+ BTRFS_ROOT_TRACK_DIRTY,
	1016	+ BTRFS_ROOT_IN_RADIX,
	1017	+ BTRFS_ROOT_ORPHAN_ITEM_INSERTED,
	1018	+ BTRFS_ROOT_DEFRAG_RUNNING,
	1019	+ BTRFS_ROOT_FORCE_COW,
	1020	+ BTRFS_ROOT_MULTI_LOG_TASKS,
	1021	+ BTRFS_ROOT_DIRTY,
	1022	+ BTRFS_ROOT_DELETING,
	1023	+
	1024	+ /*
	1025	+ * Reloc tree is orphan, only kept here for qgroup delayed subtree scan
	1026	+ *
	1027	+ * Set for the subvolume tree owning the reloc tree.
	1028	+ */
	1029	+ BTRFS_ROOT_DEAD_RELOC_TREE,
	1030	+ /* Mark dead root stored on device whose cleanup needs to be resumed */
	1031	+ BTRFS_ROOT_DEAD_TREE,
	1032	+ /* The root has a log tree. Used only for subvolume roots. */
	1033	+ BTRFS_ROOT_HAS_LOG_TREE,
	1034	+ /* Qgroup flushing is in progress */
	1035	+ BTRFS_ROOT_QGROUP_FLUSHING,
	1036	+};
	1037	+
1142	1038	/*
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
	1039	+ * Record swapped tree blocks of a subvolume tree for delayed subtree trace
	1040	+ * code. For detail check comment in fs/btrfs/qgroup.c.
1148	1041	*/
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
	1042	+struct btrfs_qgroup_swapped_blocks {
	1043	+ spinlock_t lock;
	1044	+ /* RM_EMPTY_ROOT() of above blocks[] */
	1045	+ bool swapped;
	1046	+ struct rb_root blocks[BTRFS_MAX_LEVEL];
	1047	+};
1158	1048
1159	1049	/*
1160	1050	* in ram representation of the tree. extent_root is used for all allocations
..	..	@@ -1191,8 +1081,10 @@
1191	1081	wait_queue_head_t log_writer_wait;
1192	1082	wait_queue_head_t log_commit_wait[2];
1193	1083	struct list_head log_ctxs[2];
	1084	+ /* Used only for log trees of subvolumes, not for the log root tree */
1194	1085	atomic_t log_writers;
1195	1086	atomic_t log_commit[2];
	1087	+ /* Used only for log trees of subvolumes, not for the log root tree */
1196	1088	atomic_t log_batch;
1197	1089	int log_transid;
1198	1090	/* No matter the commit succeeds or not*/
..	..	@@ -1201,23 +1093,16 @@
1201	1093	int last_log_commit;
1202	1094	pid_t log_start_pid;
1203	1095
1204		- u64 objectid;
1205	1096	u64 last_trans;
1206	1097
1207	1098	u32 type;
1208	1099
1209	1100	u64 highest_objectid;
1210	1101
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	1102	struct btrfs_key defrag_progress;
1218	1103	struct btrfs_key defrag_max;
1219	1104
1220		- /* the dirty list is only used by non-reference counted roots */
	1105	+ /* The dirty list is only used by non-shareable roots */
1221	1106	struct list_head dirty_list;
1222	1107
1223	1108	struct list_head root_list;
..	..	@@ -1273,28 +1158,87 @@
1273	1158	u64 nr_ordered_extents;
1274	1159
1275	1160	/*
	1161	+ * Not empty if this subvolume root has gone through tree block swap
	1162	+ * (relocation)
	1163	+ *
	1164	+ * Will be used by reloc_control::dirty_subvol_roots.
	1165	+ */
	1166	+ struct list_head reloc_dirty_list;
	1167	+
	1168	+ /*
1276	1169	* Number of currently running SEND ioctls to prevent
1277	1170	* manipulation with the read-only status via SUBVOL_SETFLAGS
1278	1171	*/
1279	1172	int send_in_progress;
1280		- struct btrfs_subvolume_writers *subv_writers;
1281		- atomic_t will_be_snapshotted;
	1173	+ /*
	1174	+ * Number of currently running deduplication operations that have a
	1175	+ * destination inode belonging to this root. Protected by the lock
	1176	+ * root_item_lock.
	1177	+ */
	1178	+ int dedupe_in_progress;
	1179	+ /* For exclusion of snapshot creation and nocow writes */
	1180	+ struct btrfs_drew_lock snapshot_lock;
	1181	+
1282	1182	atomic_t snapshot_force_cow;
1283	1183
1284	1184	/* For qgroup metadata reserved space */
1285	1185	spinlock_t qgroup_meta_rsv_lock;
1286	1186	u64 qgroup_meta_rsv_pertrans;
1287	1187	u64 qgroup_meta_rsv_prealloc;
	1188	+ wait_queue_head_t qgroup_flush_wait;
	1189	+
	1190	+ /* Number of active swapfiles */
	1191	+ atomic_t nr_swapfiles;
	1192	+
	1193	+ /* Record pairs of swapped blocks for qgroup */
	1194	+ struct btrfs_qgroup_swapped_blocks swapped_blocks;
	1195	+
	1196	+ /* Used only by log trees, when logging csum items */
	1197	+ struct extent_io_tree log_csum_range;
	1198	+
	1199	+#ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS
	1200	+ u64 alloc_bytenr;
	1201	+#endif
	1202	+
	1203	+#ifdef CONFIG_BTRFS_DEBUG
	1204	+ struct list_head leak_list;
	1205	+#endif
	1206	+};
	1207	+
	1208	+/*
	1209	+ * Structure that conveys information about an extent that is going to replace
	1210	+ * all the extents in a file range.
	1211	+ */
	1212	+struct btrfs_replace_extent_info {
	1213	+ u64 disk_offset;
	1214	+ u64 disk_len;
	1215	+ u64 data_offset;
	1216	+ u64 data_len;
	1217	+ u64 file_offset;
	1218	+ /* Pointer to a file extent item of type regular or prealloc. */
	1219	+ char *extent_buf;
	1220	+ /*
	1221	+ * Set to true when attempting to replace a file range with a new extent
	1222	+ * described by this structure, set to false when attempting to clone an
	1223	+ * existing extent into a file range.
	1224	+ */
	1225	+ bool is_new_extent;
	1226	+ /* Meaningful only if is_new_extent is true. */
	1227	+ int qgroup_reserved;
	1228	+ /*
	1229	+ * Meaningful only if is_new_extent is true.
	1230	+ * Used to track how many extent items we have already inserted in a
	1231	+ * subvolume tree that refer to the extent described by this structure,
	1232	+ * so that we know when to create a new delayed ref or update an existing
	1233	+ * one.
	1234	+ */
	1235	+ int insertions;
1288	1236	};
1289	1237
1290	1238	struct btrfs_file_private {
1291	1239	void *filldir_buf;
1292	1240	};
1293	1241
1294		-static inline u32 btrfs_inode_sectorsize(const struct inode *inode)
1295		-{
1296		- return btrfs_sb(inode->i_sb)->sectorsize;
1297		-}
1298	1242
1299	1243	static inline u32 BTRFS_LEAF_DATA_SIZE(const struct btrfs_fs_info *info)
1300	1244	{
..	..	@@ -1342,7 +1286,7 @@
1342	1286	#define BTRFS_MOUNT_FLUSHONCOMMIT (1 << 7)
1343	1287	#define BTRFS_MOUNT_SSD_SPREAD (1 << 8)
1344	1288	#define BTRFS_MOUNT_NOSSD (1 << 9)
1345		-#define BTRFS_MOUNT_DISCARD (1 << 10)
	1289	+#define BTRFS_MOUNT_DISCARD_SYNC (1 << 10)
1346	1290	#define BTRFS_MOUNT_FORCE_COMPRESS (1 << 11)
1347	1291	#define BTRFS_MOUNT_SPACE_CACHE (1 << 12)
1348	1292	#define BTRFS_MOUNT_CLEAR_CACHE (1 << 13)
..	..	@@ -1361,6 +1305,7 @@
1361	1305	#define BTRFS_MOUNT_FREE_SPACE_TREE (1 << 26)
1362	1306	#define BTRFS_MOUNT_NOLOGREPLAY (1 << 27)
1363	1307	#define BTRFS_MOUNT_REF_VERIFY (1 << 28)
	1308	+#define BTRFS_MOUNT_DISCARD_ASYNC (1 << 29)
1364	1309
1365	1310	#define BTRFS_DEFAULT_COMMIT_INTERVAL (30)
1366	1311	#define BTRFS_DEFAULT_MAX_INLINE (2048)
..	..	@@ -1372,31 +1317,18 @@
1372	1317	BTRFS_MOUNT_##opt)
1373	1318
1374	1319	#define btrfs_set_and_info(fs_info, opt, fmt, args...) \
1375		-{ \
	1320	+do { \
1376	1321	if (!btrfs_test_opt(fs_info, opt)) \
1377	1322	btrfs_info(fs_info, fmt, ##args); \
1378	1323	btrfs_set_opt(fs_info->mount_opt, opt); \
1379		-}
	1324	+} while (0)
1380	1325
1381	1326	#define btrfs_clear_and_info(fs_info, opt, fmt, args...) \
1382		-{ \
	1327	+do { \
1383	1328	if (btrfs_test_opt(fs_info, opt)) \
1384	1329	btrfs_info(fs_info, fmt, ##args); \
1385	1330	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
	1331	+} while (0)
1400	1332
1401	1333	/*
1402	1334	* Requests for changes that need to be done during transaction commit.
..	..	@@ -1475,7 +1407,7 @@
1475	1407	BTRFS_INODE_ROOT_ITEM_INIT)
1476	1408
1477	1409	struct btrfs_map_token {
1478		- const struct extent_buffer *eb;
	1410	+ struct extent_buffer *eb;
1479	1411	char *kaddr;
1480	1412	unsigned long offset;
1481	1413	};
..	..	@@ -1483,9 +1415,12 @@
1483	1415	#define BTRFS_BYTES_TO_BLKS(fs_info, bytes) \
1484	1416	((bytes) >> (fs_info)->sb->s_blocksize_bits)
1485	1417
1486		-static inline void btrfs_init_map_token (struct btrfs_map_token *token)
	1418	+static inline void btrfs_init_map_token(struct btrfs_map_token *token,
	1419	+ struct extent_buffer *eb)
1487	1420	{
1488		- token->kaddr = NULL;
	1421	+ token->eb = eb;
	1422	+ token->kaddr = page_address(eb->pages[0]);
	1423	+ token->offset = 0;
1489	1424	}
1490	1425
1491	1426	/* some macros to generate set/get functions for the struct fields. This
..	..	@@ -1495,6 +1430,16 @@
1495	1430	#define le8_to_cpu(v) (v)
1496	1431	#define cpu_to_le8(v) (v)
1497	1432	#define __le8 u8
	1433	+
	1434	+static inline u8 get_unaligned_le8(const void *p)
	1435	+{
	1436	+ return (u8 )p;
	1437	+}
	1438	+
	1439	+static inline void put_unaligned_le8(u8 val, void *p)
	1440	+{
	1441	+ (u8 )p = val;
	1442	+}
1498	1443
1499	1444	#define read_eb_member(eb, ptr, type, member, result) (\
1500	1445	read_extent_buffer(eb, (char *)(result), \
..	..	@@ -1509,23 +1454,15 @@
1509	1454	sizeof(((type *)0)->member)))
1510	1455
1511	1456	#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		-}
	1457	+u##bits btrfs_get_token_##bits(struct btrfs_map_token *token, \
	1458	+ const void *ptr, unsigned long off); \
	1459	+void btrfs_set_token_##bits(struct btrfs_map_token *token, \
	1460	+ const void *ptr, unsigned long off, \
	1461	+ u##bits val); \
	1462	+u##bits btrfs_get_##bits(const struct extent_buffer *eb, \
	1463	+ const void *ptr, unsigned long off); \
	1464	+void btrfs_set_##bits(const struct extent_buffer eb, void ptr, \
	1465	+ unsigned long off, u##bits val);
1529	1466
1530	1467	DECLARE_BTRFS_SETGET_BITS(8)
1531	1468	DECLARE_BTRFS_SETGET_BITS(16)
..	..	@@ -1539,53 +1476,49 @@
1539	1476	BUILD_BUG_ON(sizeof(u##bits) != sizeof(((type *)0))->member); \
1540	1477	return btrfs_get_##bits(eb, s, offsetof(type, member)); \
1541	1478	} \
1542		-static inline void btrfs_set_##name(struct extent_buffer eb, type s, \
	1479	+static inline void btrfs_set_##name(const struct extent_buffer eb, type s, \
1543	1480	u##bits val) \
1544	1481	{ \
1545	1482	BUILD_BUG_ON(sizeof(u##bits) != sizeof(((type *)0))->member); \
1546	1483	btrfs_set_##bits(eb, s, offsetof(type, member), val); \
1547	1484	} \
1548		-static inline u##bits btrfs_token_##name(const struct extent_buffer *eb,\
1549		- const type *s, \
1550		- struct btrfs_map_token *token) \
	1485	+static inline u##bits btrfs_token_##name(struct btrfs_map_token *token, \
	1486	+ const type *s) \
1551	1487	{ \
1552	1488	BUILD_BUG_ON(sizeof(u##bits) != sizeof(((type *)0))->member); \
1553		- return btrfs_get_token_##bits(eb, s, offsetof(type, member), token); \
	1489	+ return btrfs_get_token_##bits(token, s, offsetof(type, member));\
1554	1490	} \
1555		-static inline void btrfs_set_token_##name(struct extent_buffer *eb, \
1556		- type *s, u##bits val, \
1557		- struct btrfs_map_token *token) \
	1491	+static inline void btrfs_set_token_##name(struct btrfs_map_token *token,\
	1492	+ type *s, u##bits val) \
1558	1493	{ \
1559	1494	BUILD_BUG_ON(sizeof(u##bits) != sizeof(((type *)0))->member); \
1560		- btrfs_set_token_##bits(eb, s, offsetof(type, member), val, token); \
	1495	+ btrfs_set_token_##bits(token, s, offsetof(type, member), val); \
1561	1496	}
1562	1497
1563	1498	#define BTRFS_SETGET_HEADER_FUNCS(name, type, member, bits) \
1564	1499	static inline u##bits btrfs_##name(const struct extent_buffer *eb) \
1565	1500	{ \
1566	1501	const type *p = page_address(eb->pages[0]); \
1567		- u##bits res = le##bits##_to_cpu(p->member); \
1568		- return res; \
	1502	+ return get_unaligned_le##bits(&p->member); \
1569	1503	} \
1570		-static inline void btrfs_set_##name(struct extent_buffer *eb, \
	1504	+static inline void btrfs_set_##name(const struct extent_buffer *eb, \
1571	1505	u##bits val) \
1572	1506	{ \
1573	1507	type *p = page_address(eb->pages[0]); \
1574		- p->member = cpu_to_le##bits(val); \
	1508	+ put_unaligned_le##bits(val, &p->member); \
1575	1509	}
1576	1510
1577	1511	#define BTRFS_SETGET_STACK_FUNCS(name, type, member, bits) \
1578	1512	static inline u##bits btrfs_##name(const type *s) \
1579	1513	{ \
1580		- return le##bits##_to_cpu(s->member); \
	1514	+ return get_unaligned_le##bits(&s->member); \
1581	1515	} \
1582	1516	static inline void btrfs_set_##name(type *s, u##bits val) \
1583	1517	{ \
1584		- s->member = cpu_to_le##bits(val); \
	1518	+ put_unaligned_le##bits(val, &s->member); \
1585	1519	}
1586	1520
1587		-
1588		-static inline u64 btrfs_device_total_bytes(struct extent_buffer *eb,
	1521	+static inline u64 btrfs_device_total_bytes(const struct extent_buffer *eb,
1589	1522	struct btrfs_dev_item *s)
1590	1523	{
1591	1524	BUILD_BUG_ON(sizeof(u64) !=
..	..	@@ -1593,7 +1526,7 @@
1593	1526	return btrfs_get_64(eb, s, offsetof(struct btrfs_dev_item,
1594	1527	total_bytes));
1595	1528	}
1596		-static inline void btrfs_set_device_total_bytes(struct extent_buffer *eb,
	1529	+static inline void btrfs_set_device_total_bytes(const struct extent_buffer *eb,
1597	1530	struct btrfs_dev_item *s,
1598	1531	u64 val)
1599	1532	{
..	..	@@ -1697,31 +1630,31 @@
1697	1630	return btrfs_stripe_dev_uuid(btrfs_stripe_nr(c, nr));
1698	1631	}
1699	1632
1700		-static inline u64 btrfs_stripe_offset_nr(struct extent_buffer *eb,
	1633	+static inline u64 btrfs_stripe_offset_nr(const struct extent_buffer *eb,
1701	1634	struct btrfs_chunk *c, int nr)
1702	1635	{
1703	1636	return btrfs_stripe_offset(eb, btrfs_stripe_nr(c, nr));
1704	1637	}
1705	1638
1706		-static inline u64 btrfs_stripe_devid_nr(struct extent_buffer *eb,
	1639	+static inline u64 btrfs_stripe_devid_nr(const struct extent_buffer *eb,
1707	1640	struct btrfs_chunk *c, int nr)
1708	1641	{
1709	1642	return btrfs_stripe_devid(eb, btrfs_stripe_nr(c, nr));
1710	1643	}
1711	1644
1712	1645	/* struct btrfs_block_group_item */
1713		-BTRFS_SETGET_STACK_FUNCS(block_group_used, struct btrfs_block_group_item,
	1646	+BTRFS_SETGET_STACK_FUNCS(stack_block_group_used, struct btrfs_block_group_item,
1714	1647	used, 64);
1715		-BTRFS_SETGET_FUNCS(disk_block_group_used, struct btrfs_block_group_item,
	1648	+BTRFS_SETGET_FUNCS(block_group_used, struct btrfs_block_group_item,
1716	1649	used, 64);
1717		-BTRFS_SETGET_STACK_FUNCS(block_group_chunk_objectid,
	1650	+BTRFS_SETGET_STACK_FUNCS(stack_block_group_chunk_objectid,
1718	1651	struct btrfs_block_group_item, chunk_objectid, 64);
1719	1652
1720		-BTRFS_SETGET_FUNCS(disk_block_group_chunk_objectid,
	1653	+BTRFS_SETGET_FUNCS(block_group_chunk_objectid,
1721	1654	struct btrfs_block_group_item, chunk_objectid, 64);
1722		-BTRFS_SETGET_FUNCS(disk_block_group_flags,
	1655	+BTRFS_SETGET_FUNCS(block_group_flags,
1723	1656	struct btrfs_block_group_item, flags, 64);
1724		-BTRFS_SETGET_STACK_FUNCS(block_group_flags,
	1657	+BTRFS_SETGET_STACK_FUNCS(stack_block_group_flags,
1725	1658	struct btrfs_block_group_item, flags, 64);
1726	1659
1727	1660	/* struct btrfs_free_space_info */
..	..	@@ -1783,31 +1716,21 @@
1783	1716	BTRFS_SETGET_FUNCS(dev_extent_chunk_offset, struct btrfs_dev_extent,
1784	1717	chunk_offset, 64);
1785	1718	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	1719	BTRFS_SETGET_FUNCS(extent_refs, struct btrfs_extent_item, refs, 64);
1794	1720	BTRFS_SETGET_FUNCS(extent_generation, struct btrfs_extent_item,
1795	1721	generation, 64);
1796	1722	BTRFS_SETGET_FUNCS(extent_flags, struct btrfs_extent_item, flags, 64);
1797	1723
1798		-BTRFS_SETGET_FUNCS(extent_refs_v0, struct btrfs_extent_item_v0, refs, 32);
1799		-
1800		-
1801	1724	BTRFS_SETGET_FUNCS(tree_block_level, struct btrfs_tree_block_info, level, 8);
1802	1725
1803		-static inline void btrfs_tree_block_key(struct extent_buffer *eb,
	1726	+static inline void btrfs_tree_block_key(const struct extent_buffer *eb,
1804	1727	struct btrfs_tree_block_info *item,
1805	1728	struct btrfs_disk_key *key)
1806	1729	{
1807	1730	read_eb_member(eb, item, struct btrfs_tree_block_info, key, key);
1808	1731	}
1809	1732
1810		-static inline void btrfs_set_tree_block_key(struct extent_buffer *eb,
	1733	+static inline void btrfs_set_tree_block_key(const struct extent_buffer *eb,
1811	1734	struct btrfs_tree_block_info *item,
1812	1735	struct btrfs_disk_key *key)
1813	1736	{
..	..	@@ -1845,12 +1768,6 @@
1845	1768	return 0;
1846	1769	}
1847	1770
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	1771	/* struct btrfs_node */
1855	1772	BTRFS_SETGET_FUNCS(key_blockptr, struct btrfs_key_ptr, blockptr, 64);
1856	1773	BTRFS_SETGET_FUNCS(key_generation, struct btrfs_key_ptr, generation, 64);
..	..	@@ -1859,7 +1776,7 @@
1859	1776	BTRFS_SETGET_STACK_FUNCS(stack_key_generation, struct btrfs_key_ptr,
1860	1777	generation, 64);
1861	1778
1862		-static inline u64 btrfs_node_blockptr(struct extent_buffer *eb, int nr)
	1779	+static inline u64 btrfs_node_blockptr(const struct extent_buffer *eb, int nr)
1863	1780	{
1864	1781	unsigned long ptr;
1865	1782	ptr = offsetof(struct btrfs_node, ptrs) +
..	..	@@ -1867,7 +1784,7 @@
1867	1784	return btrfs_key_blockptr(eb, (struct btrfs_key_ptr *)ptr);
1868	1785	}
1869	1786
1870		-static inline void btrfs_set_node_blockptr(struct extent_buffer *eb,
	1787	+static inline void btrfs_set_node_blockptr(const struct extent_buffer *eb,
1871	1788	int nr, u64 val)
1872	1789	{
1873	1790	unsigned long ptr;
..	..	@@ -1876,7 +1793,7 @@
1876	1793	btrfs_set_key_blockptr(eb, (struct btrfs_key_ptr *)ptr, val);
1877	1794	}
1878	1795
1879		-static inline u64 btrfs_node_ptr_generation(struct extent_buffer *eb, int nr)
	1796	+static inline u64 btrfs_node_ptr_generation(const struct extent_buffer *eb, int nr)
1880	1797	{
1881	1798	unsigned long ptr;
1882	1799	ptr = offsetof(struct btrfs_node, ptrs) +
..	..	@@ -1884,7 +1801,7 @@
1884	1801	return btrfs_key_generation(eb, (struct btrfs_key_ptr *)ptr);
1885	1802	}
1886	1803
1887		-static inline void btrfs_set_node_ptr_generation(struct extent_buffer *eb,
	1804	+static inline void btrfs_set_node_ptr_generation(const struct extent_buffer *eb,
1888	1805	int nr, u64 val)
1889	1806	{
1890	1807	unsigned long ptr;
..	..	@@ -1902,7 +1819,7 @@
1902	1819	void btrfs_node_key(const struct extent_buffer *eb,
1903	1820	struct btrfs_disk_key *disk_key, int nr);
1904	1821
1905		-static inline void btrfs_set_node_key(struct extent_buffer *eb,
	1822	+static inline void btrfs_set_node_key(const struct extent_buffer *eb,
1906	1823	struct btrfs_disk_key *disk_key, int nr)
1907	1824	{
1908	1825	unsigned long ptr;
..	..	@@ -2026,6 +1943,52 @@
2026	1943	BTRFS_SETGET_STACK_FUNCS(disk_key_offset, struct btrfs_disk_key, offset, 64);
2027	1944	BTRFS_SETGET_STACK_FUNCS(disk_key_type, struct btrfs_disk_key, type, 8);
2028	1945
	1946	+#ifdef __LITTLE_ENDIAN
	1947	+
	1948	+/*
	1949	+ * Optimized helpers for little-endian architectures where CPU and on-disk
	1950	+ * structures have the same endianness and we can skip conversions.
	1951	+ */
	1952	+
	1953	+static inline void btrfs_disk_key_to_cpu(struct btrfs_key *cpu_key,
	1954	+ const struct btrfs_disk_key *disk_key)
	1955	+{
	1956	+ memcpy(cpu_key, disk_key, sizeof(struct btrfs_key));
	1957	+}
	1958	+
	1959	+static inline void btrfs_cpu_key_to_disk(struct btrfs_disk_key *disk_key,
	1960	+ const struct btrfs_key *cpu_key)
	1961	+{
	1962	+ memcpy(disk_key, cpu_key, sizeof(struct btrfs_key));
	1963	+}
	1964	+
	1965	+static inline void btrfs_node_key_to_cpu(const struct extent_buffer *eb,
	1966	+ struct btrfs_key *cpu_key, int nr)
	1967	+{
	1968	+ struct btrfs_disk_key disk_key = (struct btrfs_disk_key )cpu_key;
	1969	+
	1970	+ btrfs_node_key(eb, disk_key, nr);
	1971	+}
	1972	+
	1973	+static inline void btrfs_item_key_to_cpu(const struct extent_buffer *eb,
	1974	+ struct btrfs_key *cpu_key, int nr)
	1975	+{
	1976	+ struct btrfs_disk_key disk_key = (struct btrfs_disk_key )cpu_key;
	1977	+
	1978	+ btrfs_item_key(eb, disk_key, nr);
	1979	+}
	1980	+
	1981	+static inline void btrfs_dir_item_key_to_cpu(const struct extent_buffer *eb,
	1982	+ const struct btrfs_dir_item *item,
	1983	+ struct btrfs_key *cpu_key)
	1984	+{
	1985	+ struct btrfs_disk_key disk_key = (struct btrfs_disk_key )cpu_key;
	1986	+
	1987	+ btrfs_dir_item_key(eb, item, disk_key);
	1988	+}
	1989	+
	1990	+#else
	1991	+
2029	1992	static inline void btrfs_disk_key_to_cpu(struct btrfs_key *cpu,
2030	1993	const struct btrfs_disk_key *disk)
2031	1994	{
..	..	@@ -2067,15 +2030,7 @@
2067	2030	btrfs_disk_key_to_cpu(key, &disk_key);
2068	2031	}
2069	2032
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		-}
	2033	+#endif
2079	2034
2080	2035	/* struct btrfs_header */
2081	2036	BTRFS_SETGET_HEADER_FUNCS(header_bytenr, struct btrfs_header, bytenr, 64);
..	..	@@ -2097,18 +2052,16 @@
2097	2052	return (btrfs_header_flags(eb) & flag) == flag;
2098	2053	}
2099	2054
2100		-static inline int btrfs_set_header_flag(struct extent_buffer *eb, u64 flag)
	2055	+static inline void btrfs_set_header_flag(struct extent_buffer *eb, u64 flag)
2101	2056	{
2102	2057	u64 flags = btrfs_header_flags(eb);
2103	2058	btrfs_set_header_flags(eb, flags \| flag);
2104		- return (flags & flag) == flag;
2105	2059	}
2106	2060
2107		-static inline int btrfs_clear_header_flag(struct extent_buffer *eb, u64 flag)
	2061	+static inline void btrfs_clear_header_flag(struct extent_buffer *eb, u64 flag)
2108	2062	{
2109	2063	u64 flags = btrfs_header_flags(eb);
2110	2064	btrfs_set_header_flags(eb, flags & ~flag);
2111		- return (flags & flag) == flag;
2112	2065	}
2113	2066
2114	2067	static inline int btrfs_header_backref_rev(const struct extent_buffer *eb)
..	..	@@ -2124,16 +2077,6 @@
2124	2077	flags &= ~BTRFS_BACKREF_REV_MASK;
2125	2078	flags \|= (u64)rev << BTRFS_BACKREF_REV_SHIFT;
2126	2079	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	2080	}
2138	2081
2139	2082	static inline int btrfs_is_leaf(const struct extent_buffer *eb)
..	..	@@ -2364,14 +2307,10 @@
2364	2307	BTRFS_SETGET_STACK_FUNCS(super_uuid_tree_generation, struct btrfs_super_block,
2365	2308	uuid_tree_generation, 64);
2366	2309
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		-}
	2310	+int btrfs_super_csum_size(const struct btrfs_super_block *s);
	2311	+const char *btrfs_super_csum_name(u16 csum_type);
	2312	+const char *btrfs_super_csum_driver(u16 csum_type);
	2313	+size_t __attribute_const__ btrfs_get_num_csums(void);
2375	2314
2376	2315
2377	2316	/*
..	..	@@ -2379,18 +2318,18 @@
2379	2318	* this returns the address of the start of the last item,
2380	2319	* which is the stop of the leaf data stack
2381	2320	*/
2382		-static inline unsigned int leaf_data_end(const struct btrfs_fs_info *fs_info,
2383		- const struct extent_buffer *leaf)
	2321	+static inline unsigned int leaf_data_end(const struct extent_buffer *leaf)
2384	2322	{
2385	2323	u32 nr = btrfs_header_nritems(leaf);
2386	2324
2387	2325	if (nr == 0)
2388		- return BTRFS_LEAF_DATA_SIZE(fs_info);
	2326	+ return BTRFS_LEAF_DATA_SIZE(leaf->fs_info);
2389	2327	return btrfs_item_offset_nr(leaf, nr - 1);
2390	2328	}
2391	2329
2392	2330	/* struct btrfs_file_extent_item */
2393		-BTRFS_SETGET_FUNCS(file_extent_type, struct btrfs_file_extent_item, type, 8);
	2331	+BTRFS_SETGET_STACK_FUNCS(stack_file_extent_type, struct btrfs_file_extent_item,
	2332	+ type, 8);
2394	2333	BTRFS_SETGET_STACK_FUNCS(stack_file_extent_disk_bytenr,
2395	2334	struct btrfs_file_extent_item, disk_bytenr, 64);
2396	2335	BTRFS_SETGET_STACK_FUNCS(stack_file_extent_offset,
..	..	@@ -2399,6 +2338,8 @@
2399	2338	struct btrfs_file_extent_item, generation, 64);
2400	2339	BTRFS_SETGET_STACK_FUNCS(stack_file_extent_num_bytes,
2401	2340	struct btrfs_file_extent_item, num_bytes, 64);
	2341	+BTRFS_SETGET_STACK_FUNCS(stack_file_extent_ram_bytes,
	2342	+ struct btrfs_file_extent_item, ram_bytes, 64);
2402	2343	BTRFS_SETGET_STACK_FUNCS(stack_file_extent_disk_num_bytes,
2403	2344	struct btrfs_file_extent_item, disk_num_bytes, 64);
2404	2345	BTRFS_SETGET_STACK_FUNCS(stack_file_extent_compression,
..	..	@@ -2415,6 +2356,7 @@
2415	2356	return BTRFS_FILE_EXTENT_INLINE_DATA_START + datasize;
2416	2357	}
2417	2358
	2359	+BTRFS_SETGET_FUNCS(file_extent_type, struct btrfs_file_extent_item, type, 8);
2418	2360	BTRFS_SETGET_FUNCS(file_extent_disk_bytenr, struct btrfs_file_extent_item,
2419	2361	disk_bytenr, 64);
2420	2362	BTRFS_SETGET_FUNCS(file_extent_generation, struct btrfs_file_extent_item,
..	..	@@ -2444,30 +2386,6 @@
2444	2386	struct btrfs_item *e)
2445	2387	{
2446	2388	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	2389	}
2472	2390
2473	2391	/* btrfs_qgroup_status_item */
..	..	@@ -2565,6 +2483,16 @@
2565	2483	((unsigned long)(BTRFS_LEAF_DATA_OFFSET + \
2566	2484	btrfs_item_offset_nr(leaf, slot)))
2567	2485
	2486	+static inline u32 btrfs_crc32c(u32 crc, const void *address, unsigned length)
	2487	+{
	2488	+ return crc32c(crc, address, length);
	2489	+}
	2490	+
	2491	+static inline void btrfs_crc32c_final(u32 crc, u8 *result)
	2492	+{
	2493	+ put_unaligned_le32(~crc, result);
	2494	+}
	2495	+
2568	2496	static inline u64 btrfs_name_hash(const char *name, int len)
2569	2497	{
2570	2498	return crc32c((u32)~1, name, len);
..	..	@@ -2579,12 +2507,6 @@
2579	2507	return (u64) crc32c(parent_objectid, name, len);
2580	2508	}
2581	2509
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	2510	static inline gfp_t btrfs_alloc_write_mask(struct address_space *mapping)
2589	2511	{
2590	2512	return mapping_gfp_constraint(mapping, ~__GFP_FS);
..	..	@@ -2593,72 +2515,65 @@
2593	2515	/* extent-tree.c */
2594	2516
2595	2517	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,
	2518	+ BTRFS_REF_TYPE_INVALID,
	2519	+ BTRFS_REF_TYPE_BLOCK,
	2520	+ BTRFS_REF_TYPE_DATA,
	2521	+ BTRFS_REF_TYPE_ANY,
2600	2522	};
2601	2523
2602	2524	int btrfs_get_extent_inline_ref_type(const struct extent_buffer *eb,
2603	2525	struct btrfs_extent_inline_ref *iref,
2604	2526	enum btrfs_inline_ref_type is_data);
	2527	+u64 hash_extent_data_ref(u64 root_objectid, u64 owner, u64 offset);
2605	2528
2606	2529	u64 btrfs_csum_bytes_to_leaves(struct btrfs_fs_info *fs_info, u64 csum_bytes);
2607	2530
2608		-static inline u64 btrfs_calc_trans_metadata_size(struct btrfs_fs_info *fs_info,
2609		- unsigned num_items)
	2531	+/*
	2532	+ * Use this if we would be adding new items, as we could split nodes as we cow
	2533	+ * down the tree.
	2534	+ */
	2535	+static inline u64 btrfs_calc_insert_metadata_size(struct btrfs_fs_info *fs_info,
	2536	+ unsigned num_items)
2610	2537	{
2611	2538	return (u64)fs_info->nodesize * BTRFS_MAX_LEVEL * 2 * num_items;
2612	2539	}
2613	2540
2614	2541	/*
2615		- * Doing a truncate won't result in new nodes or leaves, just what we need for
2616		- * COW.
	2542	+ * Doing a truncate or a modification won't result in new nodes or leaves, just
	2543	+ * what we need for COW.
2617	2544	*/
2618		-static inline u64 btrfs_calc_trunc_metadata_size(struct btrfs_fs_info *fs_info,
	2545	+static inline u64 btrfs_calc_metadata_size(struct btrfs_fs_info *fs_info,
2619	2546	unsigned num_items)
2620	2547	{
2621	2548	return (u64)fs_info->nodesize * BTRFS_MAX_LEVEL * num_items;
2622	2549	}
2623	2550
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);
	2551	+int btrfs_add_excluded_extent(struct btrfs_fs_info *fs_info,
	2552	+ u64 start, u64 num_bytes);
	2553	+void btrfs_free_excluded_extents(struct btrfs_block_group *cache);
2635	2554	int btrfs_run_delayed_refs(struct btrfs_trans_handle *trans,
2636	2555	unsigned long count);
2637		-int btrfs_async_run_delayed_refs(struct btrfs_fs_info *fs_info,
2638		- unsigned long count, u64 transid, int wait);
	2556	+void btrfs_cleanup_ref_head_accounting(struct btrfs_fs_info *fs_info,
	2557	+ struct btrfs_delayed_ref_root *delayed_refs,
	2558	+ struct btrfs_delayed_ref_head *head);
2639	2559	int btrfs_lookup_data_extent(struct btrfs_fs_info *fs_info, u64 start, u64 len);
2640	2560	int btrfs_lookup_extent_info(struct btrfs_trans_handle *trans,
2641	2561	struct btrfs_fs_info *fs_info, u64 bytenr,
2642	2562	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,
	2563	+int btrfs_pin_extent(struct btrfs_trans_handle *trans, u64 bytenr, u64 num,
	2564	+ int reserved);
	2565	+int btrfs_pin_extent_for_log_replay(struct btrfs_trans_handle *trans,
2646	2566	u64 bytenr, u64 num_bytes);
2647		-int btrfs_exclude_logged_extents(struct btrfs_fs_info *fs_info,
2648		- struct extent_buffer *eb);
	2567	+int btrfs_exclude_logged_extents(struct extent_buffer *eb);
2649	2568	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);
	2569	+ u64 objectid, u64 offset, u64 bytenr, bool strict);
2656	2570	struct extent_buffer btrfs_alloc_tree_block(struct btrfs_trans_handle trans,
2657	2571	struct btrfs_root *root,
2658	2572	u64 parent, u64 root_objectid,
2659	2573	const struct btrfs_disk_key *key,
2660	2574	int level, u64 hint,
2661		- u64 empty_size);
	2575	+ u64 empty_size,
	2576	+ enum btrfs_lock_nesting nest);
2662	2577	void btrfs_free_tree_block(struct btrfs_trans_handle *trans,
2663	2578	struct btrfs_root *root,
2664	2579	struct extent_buffer *buf,
..	..	@@ -2678,128 +2593,92 @@
2678	2593	int btrfs_dec_ref(struct btrfs_trans_handle trans, struct btrfs_root root,
2679	2594	struct extent_buffer *buf, int full_backref);
2680	2595	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,
	2596	+ struct extent_buffer *eb, u64 flags,
2683	2597	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);
	2598	+int btrfs_free_extent(struct btrfs_trans_handle trans, struct btrfs_ref ref);
2688	2599
2689	2600	int btrfs_free_reserved_extent(struct btrfs_fs_info *fs_info,
2690	2601	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);
	2602	+int btrfs_pin_reserved_extent(struct btrfs_trans_handle *trans, u64 start,
	2603	+ u64 len);
2694	2604	int btrfs_finish_extent_commit(struct btrfs_trans_handle *trans);
2695	2605	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);
	2606	+ struct btrfs_ref *generic_ref);
2699	2607
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	2608	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	2609	void btrfs_clear_space_info_full(struct btrfs_fs_info *info);
2726	2610
	2611	+/*
	2612	+ * Different levels for to flush space when doing space reservations.
	2613	+ *
	2614	+ * The higher the level, the more methods we try to reclaim space.
	2615	+ */
2727	2616	enum btrfs_reserve_flush_enum {
2728	2617	/* If we are in the transaction, we can't flush anything.*/
2729	2618	BTRFS_RESERVE_NO_FLUSH,
	2619	+
2730	2620	/*
2731		- * Flushing delalloc may cause deadlock somewhere, in this
2732		- * case, use FLUSH LIMIT
	2621	+ * Flush space by:
	2622	+ * - Running delayed inode items
	2623	+ * - Allocating a new chunk
2733	2624	*/
2734	2625	BTRFS_RESERVE_FLUSH_LIMIT,
	2626	+
	2627	+ /*
	2628	+ * Flush space by:
	2629	+ * - Running delayed inode items
	2630	+ * - Running delayed refs
	2631	+ * - Running delalloc and waiting for ordered extents
	2632	+ * - Allocating a new chunk
	2633	+ */
	2634	+ BTRFS_RESERVE_FLUSH_EVICT,
	2635	+
	2636	+ /*
	2637	+ * Flush space by above mentioned methods and by:
	2638	+ * - Running delayed iputs
	2639	+ * - Commiting transaction
	2640	+ *
	2641	+ * Can be interruped by fatal signal.
	2642	+ */
	2643	+ BTRFS_RESERVE_FLUSH_DATA,
	2644	+ BTRFS_RESERVE_FLUSH_FREE_SPACE_INODE,
2735	2645	BTRFS_RESERVE_FLUSH_ALL,
	2646	+
	2647	+ /*
	2648	+ * Pretty much the same as FLUSH_ALL, but can also steal space from
	2649	+ * global rsv.
	2650	+ *
	2651	+ * Can be interruped by fatal signal.
	2652	+ */
	2653	+ BTRFS_RESERVE_FLUSH_ALL_STEAL,
2736	2654	};
2737	2655
2738	2656	enum btrfs_flush_state {
2739	2657	FLUSH_DELAYED_ITEMS_NR = 1,
2740	2658	FLUSH_DELAYED_ITEMS = 2,
2741		- FLUSH_DELALLOC = 3,
2742		- FLUSH_DELALLOC_WAIT = 4,
2743		- ALLOC_CHUNK = 5,
2744		- COMMIT_TRANS = 6,
	2659	+ FLUSH_DELAYED_REFS_NR = 3,
	2660	+ FLUSH_DELAYED_REFS = 4,
	2661	+ FLUSH_DELALLOC = 5,
	2662	+ FLUSH_DELALLOC_WAIT = 6,
	2663	+ ALLOC_CHUNK = 7,
	2664	+ ALLOC_CHUNK_FORCE = 8,
	2665	+ RUN_DELAYED_IPUTS = 9,
	2666	+ COMMIT_TRANS = 10,
2745	2667	};
2746	2668
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	2669	int btrfs_subvolume_reserve_metadata(struct btrfs_root *root,
2759	2670	struct btrfs_block_rsv *rsv,
2760	2671	int nitems, bool use_global_rsv);
2761		-void btrfs_subvolume_release_metadata(struct btrfs_fs_info *fs_info,
	2672	+void btrfs_subvolume_release_metadata(struct btrfs_root *root,
2762	2673	struct btrfs_block_rsv *rsv);
2763	2674	void btrfs_delalloc_release_extents(struct btrfs_inode *inode, u64 num_bytes);
2764	2675
2765	2676	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	2677	u64 btrfs_account_ro_block_groups_free_space(struct btrfs_space_info *sinfo);
2798	2678	int btrfs_error_unpin_extent_range(struct btrfs_fs_info *fs_info,
2799	2679	u64 start, u64 end);
2800	2680	int btrfs_discard_extent(struct btrfs_fs_info *fs_info, u64 bytenr,
2801	2681	u64 num_bytes, u64 *actual_bytes);
2802		-int btrfs_force_chunk_alloc(struct btrfs_trans_handle *trans, u64 type);
2803	2682	int btrfs_trim_fs(struct btrfs_fs_info fs_info, struct fstrim_range range);
2804	2683
2805	2684	int btrfs_init_space_info(struct btrfs_fs_info *fs_info);
..	..	@@ -2808,15 +2687,11 @@
2808	2687	int btrfs_start_write_no_snapshotting(struct btrfs_root *root);
2809	2688	void btrfs_end_write_no_snapshotting(struct btrfs_root *root);
2810	2689	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	2690
2816	2691	/* ctree.c */
2817	2692	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);
	2693	+ int *slot);
	2694	+int __pure btrfs_comp_cpu_keys(const struct btrfs_key k1, const struct btrfs_key k2);
2820	2695	int btrfs_previous_item(struct btrfs_root *root,
2821	2696	struct btrfs_path *path, u64 min_objectid,
2822	2697	int type);
..	..	@@ -2826,42 +2701,28 @@
2826	2701	struct btrfs_path *path,
2827	2702	const struct btrfs_key *new_key);
2828	2703	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	2704	int btrfs_find_next_key(struct btrfs_root root, struct btrfs_path path,
2832	2705	struct btrfs_key *key, int lowest_level,
2833	2706	u64 min_trans);
2834	2707	int btrfs_search_forward(struct btrfs_root root, struct btrfs_key min_key,
2835	2708	struct btrfs_path *path,
2836	2709	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);
	2710	+struct extent_buffer btrfs_read_node_slot(struct extent_buffer parent,
	2711	+ int slot);
	2712	+
2851	2713	int btrfs_cow_block(struct btrfs_trans_handle *trans,
2852	2714	struct btrfs_root root, struct extent_buffer buf,
2853	2715	struct extent_buffer *parent, int parent_slot,
2854		- struct extent_buffer **cow_ret);
	2716	+ struct extent_buffer **cow_ret,
	2717	+ enum btrfs_lock_nesting nest);
2855	2718	int btrfs_copy_root(struct btrfs_trans_handle *trans,
2856	2719	struct btrfs_root *root,
2857	2720	struct extent_buffer *buf,
2858	2721	struct extent_buffer **cow_ret, u64 new_root_objectid);
2859	2722	int btrfs_block_can_be_shared(struct btrfs_root *root,
2860	2723	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);
	2724	+void btrfs_extend_item(struct btrfs_path *path, u32 data_size);
	2725	+void btrfs_truncate_item(struct btrfs_path *path, u32 new_size, int from_end);
2865	2726	int btrfs_split_item(struct btrfs_trans_handle *trans,
2866	2727	struct btrfs_root *root,
2867	2728	struct btrfs_path *path,
..	..	@@ -2889,10 +2750,6 @@
2889	2750	void btrfs_release_path(struct btrfs_path *p);
2890	2751	struct btrfs_path *btrfs_alloc_path(void);
2891	2752	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	2753
2897	2754	int btrfs_del_items(struct btrfs_trans_handle trans, struct btrfs_root root,
2898	2755	struct btrfs_path *path, int slot, int nr);
..	..	@@ -2905,7 +2762,7 @@
2905	2762
2906	2763	void setup_items_for_insert(struct btrfs_root root, struct btrfs_path path,
2907	2764	const struct btrfs_key cpu_key, u32 data_size,
2908		- u32 total_data, u32 total_size, int nr);
	2765	+ int nr);
2909	2766	int btrfs_insert_item(struct btrfs_trans_handle trans, struct btrfs_root root,
2910	2767	const struct btrfs_key key, void data, u32 data_size);
2911	2768	int btrfs_insert_empty_items(struct btrfs_trans_handle *trans,
..	..	@@ -2939,11 +2796,9 @@
2939	2796	{
2940	2797	return btrfs_next_old_item(root, p, 0);
2941	2798	}
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);
	2799	+int btrfs_leaf_free_space(struct extent_buffer *leaf);
	2800	+int __must_check btrfs_drop_snapshot(struct btrfs_root *root, int update_ref,
	2801	+ int for_reloc);
2947	2802	int btrfs_drop_subtree(struct btrfs_trans_handle *trans,
2948	2803	struct btrfs_root *root,
2949	2804	struct extent_buffer *node,
..	..	@@ -2969,24 +2824,6 @@
2969	2824	static inline int btrfs_need_cleaner_sleep(struct btrfs_fs_info *fs_info)
2970	2825	{
2971	2826	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	2827	}
2991	2828
2992	2829	/* tree mod log functions from ctree.c */
..	..	@@ -3027,15 +2864,12 @@
3027	2864	u64 subid);
3028	2865	int btrfs_uuid_tree_remove(struct btrfs_trans_handle trans, u8 uuid, u8 type,
3029	2866	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));
	2867	+int btrfs_uuid_tree_iterate(struct btrfs_fs_info *fs_info);
3033	2868
3034	2869	/* dir-item.c */
3035	2870	int btrfs_check_dir_item_collision(struct btrfs_root *root, u64 dir,
3036	2871	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,
	2872	+int btrfs_insert_dir_item(struct btrfs_trans_handle trans, const char name,
3039	2873	int name_len, struct btrfs_inode *dir,
3040	2874	struct btrfs_key *location, u8 type, u64 index);
3041	2875	struct btrfs_dir_item btrfs_lookup_dir_item(struct btrfs_trans_handle trans,
..	..	@@ -3103,21 +2937,18 @@
3103	2937	u64 inode_objectid, u64 ref_objectid, int ins_len,
3104	2938	int cow);
3105	2939
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		-
	2940	+struct btrfs_inode_ref btrfs_find_name_in_backref(struct extent_buffer leaf,
	2941	+ int slot, const char *name,
	2942	+ int name_len);
	2943	+struct btrfs_inode_extref *btrfs_find_name_in_ext_backref(
	2944	+ struct extent_buffer *leaf, int slot, u64 ref_objectid,
	2945	+ const char *name, int name_len);
3114	2946	/* file-item.c */
3115	2947	struct btrfs_dio_private;
3116	2948	int btrfs_del_csums(struct btrfs_trans_handle *trans,
3117	2949	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);
	2950	+blk_status_t btrfs_lookup_bio_sums(struct inode inode, struct bio bio,
	2951	+ u64 offset, u8 *dst);
3121	2952	int btrfs_insert_file_extent(struct btrfs_trans_handle *trans,
3122	2953	struct btrfs_root *root,
3123	2954	u64 objectid, u64 pos,
..	..	@@ -3131,8 +2962,8 @@
3131	2962	int btrfs_csum_file_blocks(struct btrfs_trans_handle *trans,
3132	2963	struct btrfs_root *root,
3133	2964	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);
	2965	+blk_status_t btrfs_csum_one_bio(struct btrfs_inode inode, struct bio bio,
	2966	+ u64 file_start, int contig);
3136	2967	int btrfs_lookup_csums_range(struct btrfs_root *root, u64 start, u64 end,
3137	2968	struct list_head *list, int search_commit);
3138	2969	void btrfs_extent_item_to_extent_map(struct btrfs_inode *inode,
..	..	@@ -3140,14 +2971,23 @@
3140	2971	struct btrfs_file_extent_item *fi,
3141	2972	const bool new_inline,
3142	2973	struct extent_map *em);
	2974	+int btrfs_inode_clear_file_extent_range(struct btrfs_inode *inode, u64 start,
	2975	+ u64 len);
	2976	+int btrfs_inode_set_file_extent_range(struct btrfs_inode *inode, u64 start,
	2977	+ u64 len);
	2978	+void btrfs_inode_safe_disk_i_size_write(struct inode *inode, u64 new_i_size);
	2979	+u64 btrfs_file_extent_end(const struct btrfs_path *path);
3143	2980
3144	2981	/* inode.c */
	2982	+blk_status_t btrfs_submit_data_bio(struct inode inode, struct bio bio,
	2983	+ int mirror_num, unsigned long bio_flags);
	2984	+int btrfs_verify_data_csum(struct btrfs_io_bio *io_bio, u64 phy_offset,
	2985	+ struct page *page, u64 start, u64 end, int mirror);
3145	2986	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);
	2987	+ u64 start, u64 len);
3148	2988	noinline int can_nocow_extent(struct inode inode, u64 offset, u64 len,
3149	2989	u64 orig_start, u64 orig_block_len,
3150		- u64 *ram_bytes);
	2990	+ u64 *ram_bytes, bool strict);
3151	2991
3152	2992	void __btrfs_del_delalloc_inode(struct btrfs_root *root,
3153	2993	struct btrfs_inode *inode);
..	..	@@ -3169,17 +3009,25 @@
3169	3009	u32 min_type);
3170	3010
3171	3011	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,
	3012	+int btrfs_start_delalloc_roots(struct btrfs_fs_info *fs_info, u64 nr,
	3013	+ bool in_reclaim_context);
	3014	+int btrfs_set_extent_delalloc(struct btrfs_inode *inode, u64 start, u64 end,
3174	3015	unsigned int extra_bits,
3175		- struct extent_state **cached_state, int dedupe);
	3016	+ struct extent_state **cached_state);
3176	3017	int btrfs_create_subvol_root(struct btrfs_trans_handle *trans,
3177	3018	struct btrfs_root *new_root,
3178	3019	struct btrfs_root *parent_root,
3179	3020	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);
	3021	+ void btrfs_set_delalloc_extent(struct inode inode, struct extent_state state,
	3022	+ unsigned *bits);
	3023	+void btrfs_clear_delalloc_extent(struct inode *inode,
	3024	+ struct extent_state state, unsigned bits);
	3025	+void btrfs_merge_delalloc_extent(struct inode inode, struct extent_state new,
	3026	+ struct extent_state *other);
	3027	+void btrfs_split_delalloc_extent(struct inode *inode,
	3028	+ struct extent_state *orig, u64 split);
	3029	+int btrfs_bio_fits_in_stripe(struct page page, size_t size, struct bio bio,
	3030	+ unsigned long bio_flags);
3183	3031	void btrfs_set_range_writeback(struct extent_io_tree *tree, u64 start, u64 end);
3184	3032	vm_fault_t btrfs_page_mkwrite(struct vm_fault *vmf);
3185	3033	int btrfs_readpage(struct file file, struct page page);
..	..	@@ -3187,17 +3035,16 @@
3187	3035	int btrfs_write_inode(struct inode inode, struct writeback_control wbc);
3188	3036	struct inode btrfs_alloc_inode(struct super_block sb);
3189	3037	void btrfs_destroy_inode(struct inode *inode);
	3038	+void btrfs_free_inode(struct inode *inode);
3190	3039	int btrfs_drop_inode(struct inode *inode);
3191	3040	int __init btrfs_init_cachep(void);
3192	3041	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);
	3042	+struct inode btrfs_iget_path(struct super_block s, u64 ino,
	3043	+ struct btrfs_root root, struct btrfs_path path);
	3044	+struct inode btrfs_iget(struct super_block s, u64 ino, struct btrfs_root *root);
3198	3045	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);
	3046	+ struct page *page, size_t pg_offset,
	3047	+ u64 start, u64 end);
3201	3048	int btrfs_update_inode(struct btrfs_trans_handle *trans,
3202	3049	struct btrfs_root *root,
3203	3050	struct inode *inode);
..	..	@@ -3209,6 +3056,7 @@
3209	3056	int btrfs_cont_expand(struct inode *inode, loff_t oldsize, loff_t size);
3210	3057	void btrfs_add_delayed_iput(struct inode *inode);
3211	3058	void btrfs_run_delayed_iputs(struct btrfs_fs_info *fs_info);
	3059	+int btrfs_wait_on_delayed_iputs(struct btrfs_fs_info *fs_info);
3212	3060	int btrfs_prealloc_file_range(struct inode *inode, int mode,
3213	3061	u64 start, u64 num_bytes, u64 min_size,
3214	3062	loff_t actual_len, u64 *alloc_hint);
..	..	@@ -3216,20 +3064,21 @@
3216	3064	struct btrfs_trans_handle *trans, int mode,
3217	3065	u64 start, u64 num_bytes, u64 min_size,
3218	3066	loff_t actual_len, u64 *alloc_hint);
3219		-int btrfs_run_delalloc_range(void private_data, struct page locked_page,
	3067	+int btrfs_run_delalloc_range(struct btrfs_inode inode, struct page locked_page,
3220	3068	u64 start, u64 end, int page_started, unsigned long nr_written,
3221	3069	struct writeback_control *wbc);
	3070	+int btrfs_writepage_cow_fixup(struct page *page, u64 start, u64 end);
	3071	+void btrfs_writepage_endio_finish_ordered(struct page *page, u64 start,
	3072	+ u64 end, int uptodate);
3222	3073	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
	3074	+ssize_t btrfs_direct_IO(struct kiocb iocb, struct iov_iter iter);
3226	3075
3227	3076	/* ioctl.c */
3228	3077	long btrfs_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
3229	3078	long btrfs_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
3230	3079	int btrfs_ioctl_get_supported_features(void __user *arg);
3231	3080	void btrfs_sync_inode_flags_to_i_flags(struct inode *inode);
3232		-int btrfs_is_empty_uuid(u8 *uuid);
	3081	+int __pure btrfs_is_empty_uuid(u8 *uuid);
3233	3082	int btrfs_defrag_file(struct inode inode, struct file file,
3234	3083	struct btrfs_ioctl_defrag_range_args *range,
3235	3084	u64 newer_than, unsigned long max_pages);
..	..	@@ -3237,9 +3086,9 @@
3237	3086	struct btrfs_ioctl_space_info *space);
3238	3087	void btrfs_update_ioctl_balance_args(struct btrfs_fs_info *fs_info,
3239	3088	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);
	3089	+bool btrfs_exclop_start(struct btrfs_fs_info *fs_info,
	3090	+ enum btrfs_exclusive_operation type);
	3091	+void btrfs_exclop_finish(struct btrfs_fs_info *fs_info);
3243	3092
3244	3093	/* file.c */
3245	3094	int __init btrfs_auto_defrag_init(void);
..	..	@@ -3253,7 +3102,7 @@
3253	3102	int skip_pinned);
3254	3103	extern const struct file_operations btrfs_file_operations;
3255	3104	int __btrfs_drop_extents(struct btrfs_trans_handle *trans,
3256		- struct btrfs_root root, struct inode inode,
	3105	+ struct btrfs_root root, struct btrfs_inode inode,
3257	3106	struct btrfs_path *path, u64 start, u64 end,
3258	3107	u64 *drop_end, int drop_cache,
3259	3108	int replace_extent,
..	..	@@ -3262,25 +3111,24 @@
3262	3111	int btrfs_drop_extents(struct btrfs_trans_handle *trans,
3263	3112	struct btrfs_root root, struct inode inode, u64 start,
3264	3113	u64 end, int drop_cache);
	3114	+int btrfs_replace_file_extents(struct inode inode, struct btrfs_path path,
	3115	+ const u64 start, const u64 end,
	3116	+ struct btrfs_replace_extent_info *extent_info,
	3117	+ struct btrfs_trans_handle **trans_out);
3265	3118	int btrfs_mark_extent_written(struct btrfs_trans_handle *trans,
3266	3119	struct btrfs_inode *inode, u64 start, u64 end);
3267	3120	int btrfs_release_file(struct inode inode, struct file file);
3268		-int btrfs_dirty_pages(struct inode inode, struct page *pages,
	3121	+int btrfs_dirty_pages(struct btrfs_inode inode, struct page *pages,
3269	3122	size_t num_pages, loff_t pos, size_t write_bytes,
3270	3123	struct extent_state **cached);
3271	3124	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);
	3125	+int btrfs_check_nocow_lock(struct btrfs_inode *inode, loff_t pos,
	3126	+ size_t *write_bytes);
	3127	+void btrfs_check_nocow_unlock(struct btrfs_inode *inode);
3274	3128
3275	3129	/* tree-defrag.c */
3276	3130	int btrfs_defrag_leaves(struct btrfs_trans_handle *trans,
3277	3131	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	3132
3285	3133	/* super.c */
3286	3134	int btrfs_parse_options(struct btrfs_fs_info info, char options,
..	..	@@ -3374,31 +3222,17 @@
3374	3222
3375	3223	#if defined(CONFIG_DYNAMIC_DEBUG)
3376	3224	#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)
	3225	+ _dynamic_func_call_no_desc(fmt, btrfs_printk, \
	3226	+ fs_info, KERN_DEBUG fmt, ##args)
	3227	+#define btrfs_debug_in_rcu(fs_info, fmt, args...) \
	3228	+ _dynamic_func_call_no_desc(fmt, btrfs_printk_in_rcu, \
	3229	+ fs_info, KERN_DEBUG fmt, ##args)
3388	3230	#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)
	3231	+ _dynamic_func_call_no_desc(fmt, btrfs_printk_rl_in_rcu, \
	3232	+ fs_info, KERN_DEBUG fmt, ##args)
	3233	+#define btrfs_debug_rl(fs_info, fmt, args...) \
	3234	+ _dynamic_func_call_no_desc(fmt, btrfs_printk_ratelimited, \
	3235	+ fs_info, KERN_DEBUG fmt, ##args)
3402	3236	#elif defined(DEBUG)
3403	3237	#define btrfs_debug(fs_info, fmt, args...) \
3404	3238	btrfs_printk(fs_info, KERN_DEBUG fmt, ##args)
..	..	@@ -3450,19 +3284,29 @@
3450	3284	} while (0)
3451	3285
3452	3286	#ifdef CONFIG_BTRFS_ASSERT
3453		-
3454		-__cold
3455		-static inline void assfail(const char expr, const char file, int line)
	3287	+__cold __noreturn
	3288	+static inline void assertfail(const char expr, const char file, int line)
3456	3289	{
3457		- pr_err("assertion failed: %s, file: %s, line: %d\n",
3458		- expr, file, line);
	3290	+ pr_err("assertion failed: %s, in %s:%d\n", expr, file, line);
3459	3291	BUG();
3460	3292	}
3461	3293
3462		-#define ASSERT(expr) \
3463		- (likely(expr) ? (void)0 : assfail(#expr, __FILE__, __LINE__))
	3294	+#define ASSERT(expr) \
	3295	+ (likely(expr) ? (void)0 : assertfail(#expr, __FILE__, __LINE__))
	3296	+
3464	3297	#else
3465		-#define ASSERT(expr) ((void)0)
	3298	+static inline void assertfail(const char expr, const char file, int line) { }
	3299	+#define ASSERT(expr) (void)(expr)
	3300	+#endif
	3301	+
	3302	+/*
	3303	+ * Use that for functions that are conditionally exported for sanity tests but
	3304	+ * otherwise static
	3305	+ */
	3306	+#ifndef CONFIG_BTRFS_FS_RUN_SANITY_TESTS
	3307	+#define EXPORT_FOR_TESTS static
	3308	+#else
	3309	+#define EXPORT_FOR_TESTS
3466	3310	#endif
3467	3311
3468	3312	__cold
..	..	@@ -3477,7 +3321,7 @@
3477	3321	void __btrfs_handle_fs_error(struct btrfs_fs_info fs_info, const char function,
3478	3322	unsigned int line, int errno, const char *fmt, ...);
3479	3323
3480		-const char *btrfs_decode_error(int errno);
	3324	+const char * __attribute_const__ btrfs_decode_error(int errno);
3481	3325
3482	3326	__cold
3483	3327	void __btrfs_abort_transaction(struct btrfs_trans_handle *trans,
..	..	@@ -3493,7 +3337,7 @@
3493	3337	/* Report first abort since mount */ \
3494	3338	if (!test_and_set_bit(BTRFS_FS_STATE_TRANS_ABORTED, \
3495	3339	&((trans)->fs_info->fs_state))) { \
3496		- if ((errno) != -EIO) { \
	3340	+ if ((errno) != -EIO && (errno) != -EROFS) { \
3497	3341	WARN(1, KERN_DEBUG \
3498	3342	"BTRFS: Transaction aborted (error %d)\n", \
3499	3343	(errno)); \
..	..	@@ -3531,10 +3375,11 @@
3531	3375	/* compatibility and incompatibility defines */
3532	3376
3533	3377	#define btrfs_set_fs_incompat(__fs_info, opt) \
3534		- __btrfs_set_fs_incompat((__fs_info), BTRFS_FEATURE_INCOMPAT_##opt)
	3378	+ __btrfs_set_fs_incompat((__fs_info), BTRFS_FEATURE_INCOMPAT_##opt, \
	3379	+ #opt)
3535	3380
3536	3381	static inline void __btrfs_set_fs_incompat(struct btrfs_fs_info *fs_info,
3537		- u64 flag)
	3382	+ u64 flag, const char* name)
3538	3383	{
3539	3384	struct btrfs_super_block *disk_super;
3540	3385	u64 features;
..	..	@@ -3547,18 +3392,20 @@
3547	3392	if (!(features & flag)) {
3548	3393	features \|= flag;
3549	3394	btrfs_set_super_incompat_flags(disk_super, features);
3550		- btrfs_info(fs_info, "setting %llu feature flag",
3551		- flag);
	3395	+ btrfs_info(fs_info,
	3396	+ "setting incompat feature flag for %s (0x%llx)",
	3397	+ name, flag);
3552	3398	}
3553	3399	spin_unlock(&fs_info->super_lock);
3554	3400	}
3555	3401	}
3556	3402
3557	3403	#define btrfs_clear_fs_incompat(__fs_info, opt) \
3558		- __btrfs_clear_fs_incompat((__fs_info), BTRFS_FEATURE_INCOMPAT_##opt)
	3404	+ __btrfs_clear_fs_incompat((__fs_info), BTRFS_FEATURE_INCOMPAT_##opt, \
	3405	+ #opt)
3559	3406
3560	3407	static inline void __btrfs_clear_fs_incompat(struct btrfs_fs_info *fs_info,
3561		- u64 flag)
	3408	+ u64 flag, const char* name)
3562	3409	{
3563	3410	struct btrfs_super_block *disk_super;
3564	3411	u64 features;
..	..	@@ -3571,8 +3418,9 @@
3571	3418	if (features & flag) {
3572	3419	features &= ~flag;
3573	3420	btrfs_set_super_incompat_flags(disk_super, features);
3574		- btrfs_info(fs_info, "clearing %llu feature flag",
3575		- flag);
	3421	+ btrfs_info(fs_info,
	3422	+ "clearing incompat feature flag for %s (0x%llx)",
	3423	+ name, flag);
3576	3424	}
3577	3425	spin_unlock(&fs_info->super_lock);
3578	3426	}
..	..	@@ -3589,10 +3437,11 @@
3589	3437	}
3590	3438
3591	3439	#define btrfs_set_fs_compat_ro(__fs_info, opt) \
3592		- __btrfs_set_fs_compat_ro((__fs_info), BTRFS_FEATURE_COMPAT_RO_##opt)
	3440	+ __btrfs_set_fs_compat_ro((__fs_info), BTRFS_FEATURE_COMPAT_RO_##opt, \
	3441	+ #opt)
3593	3442
3594	3443	static inline void __btrfs_set_fs_compat_ro(struct btrfs_fs_info *fs_info,
3595		- u64 flag)
	3444	+ u64 flag, const char *name)
3596	3445	{
3597	3446	struct btrfs_super_block *disk_super;
3598	3447	u64 features;
..	..	@@ -3605,18 +3454,20 @@
3605	3454	if (!(features & flag)) {
3606	3455	features \|= flag;
3607	3456	btrfs_set_super_compat_ro_flags(disk_super, features);
3608		- btrfs_info(fs_info, "setting %llu ro feature flag",
3609		- flag);
	3457	+ btrfs_info(fs_info,
	3458	+ "setting compat-ro feature flag for %s (0x%llx)",
	3459	+ name, flag);
3610	3460	}
3611	3461	spin_unlock(&fs_info->super_lock);
3612	3462	}
3613	3463	}
3614	3464
3615	3465	#define btrfs_clear_fs_compat_ro(__fs_info, opt) \
3616		- __btrfs_clear_fs_compat_ro((__fs_info), BTRFS_FEATURE_COMPAT_RO_##opt)
	3466	+ __btrfs_clear_fs_compat_ro((__fs_info), BTRFS_FEATURE_COMPAT_RO_##opt, \
	3467	+ #opt)
3617	3468
3618	3469	static inline void __btrfs_clear_fs_compat_ro(struct btrfs_fs_info *fs_info,
3619		- u64 flag)
	3470	+ u64 flag, const char *name)
3620	3471	{
3621	3472	struct btrfs_super_block *disk_super;
3622	3473	u64 features;
..	..	@@ -3629,8 +3480,9 @@
3629	3480	if (features & flag) {
3630	3481	features &= ~flag;
3631	3482	btrfs_set_super_compat_ro_flags(disk_super, features);
3632		- btrfs_info(fs_info, "clearing %llu ro feature flag",
3633		- flag);
	3483	+ btrfs_info(fs_info,
	3484	+ "clearing compat-ro feature flag for %s (0x%llx)",
	3485	+ name, flag);
3634	3486	}
3635	3487	spin_unlock(&fs_info->super_lock);
3636	3488	}
..	..	@@ -3669,7 +3521,7 @@
3669	3521	int btrfs_update_reloc_root(struct btrfs_trans_handle *trans,
3670	3522	struct btrfs_root *root);
3671	3523	int btrfs_recover_relocation(struct btrfs_root *root);
3672		-int btrfs_reloc_clone_csums(struct inode *inode, u64 file_pos, u64 len);
	3524	+int btrfs_reloc_clone_csums(struct btrfs_inode *inode, u64 file_pos, u64 len);
3673	3525	int btrfs_reloc_cow_block(struct btrfs_trans_handle *trans,
3674	3526	struct btrfs_root root, struct extent_buffer buf,
3675	3527	struct extent_buffer *cow);
..	..	@@ -3677,6 +3529,10 @@
3677	3529	u64 *bytes_to_reserve);
3678	3530	int btrfs_reloc_post_snapshot(struct btrfs_trans_handle *trans,
3679	3531	struct btrfs_pending_snapshot *pending);
	3532	+int btrfs_should_cancel_balance(struct btrfs_fs_info *fs_info);
	3533	+struct btrfs_root find_reloc_root(struct btrfs_fs_info fs_info,
	3534	+ u64 bytenr);
	3535	+int btrfs_should_ignore_reloc_root(struct btrfs_root *root);
3680	3536
3681	3537	/* scrub.c */
3682	3538	int btrfs_scrub_dev(struct btrfs_fs_info *fs_info, u64 devid, u64 start,
..	..	@@ -3685,8 +3541,7 @@
3685	3541	void btrfs_scrub_pause(struct btrfs_fs_info *fs_info);
3686	3542	void btrfs_scrub_continue(struct btrfs_fs_info *fs_info);
3687	3543	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);
	3544	+int btrfs_scrub_cancel_dev(struct btrfs_device *dev);
3690	3545	int btrfs_scrub_progress(struct btrfs_fs_info *fs_info, u64 devid,
3691	3546	struct btrfs_scrub_progress *progress);
3692	3547	static inline void btrfs_init_full_stripe_locks_tree(
..	..	@@ -3720,6 +3575,8 @@
3720	3575	int btrfs_reada_wait(void *handle);
3721	3576	void btrfs_reada_detach(void *handle);
3722	3577	int btree_readahead_hook(struct extent_buffer *eb, int err);
	3578	+void btrfs_reada_remove_dev(struct btrfs_device *dev);
	3579	+void btrfs_reada_undo_remove_dev(struct btrfs_device *dev);
3723	3580
3724	3581	static inline int is_fstree(u64 rootid)
3725	3582	{
..	..	@@ -3735,41 +3592,20 @@
3735	3592	return signal_pending(current);
3736	3593	}
3737	3594
	3595	+#define in_range(b, first, len) ((b) >= (first) && (b) < (first) + (len))
	3596	+
3738	3597	/* Sanity test specific functions */
3739	3598	#ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS
3740	3599	void btrfs_test_destroy_inode(struct inode *inode);
3741		-#endif
3742		-
3743	3600	static inline int btrfs_is_testing(struct btrfs_fs_info *fs_info)
3744	3601	{
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
	3602	+ return test_bit(BTRFS_FS_STATE_DUMMY_FS_INFO, &fs_info->fs_state);
	3603	+}
	3604	+#else
	3605	+static inline int btrfs_is_testing(struct btrfs_fs_info *fs_info)
	3606	+{
3750	3607	return 0;
3751	3608	}
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		-}
	3609	+#endif
3774	3610
3775	3611	#endif