lael-labs/linux

.clang-format+1−0

@@ -80,6 +80,7 @@ ForEachMacros: · 79 unmodified lines
80	- 'ax25_uid_for_each'	80	- 'ax25_uid_for_each'
81	- '__bio_for_each_bvec'	81	- '__bio_for_each_bvec'
82	- 'bio_for_each_bvec'	82	- 'bio_for_each_bvec'
		83	- 'bio_for_each_bvec_all'
83	- 'bio_for_each_integrity_vec'	84	- 'bio_for_each_integrity_vec'
84	- '__bio_for_each_segment'	85	- '__bio_for_each_segment'
85	- 'bio_for_each_segment'	86	- 'bio_for_each_segment'

Documentation/block/biovecs.rst+2−0

 ::
 	bio_for_each_segment_all()
+	bio_for_each_bvec_all()
 	bio_first_bvec_all()
 	bio_first_page_all()
 	bio_last_bvec_all()
   bio_vec' will contain a multi-page IO vector during the iteration::
 	bio_for_each_bvec()
+	bio_for_each_bvec_all()
 	rq_for_each_bvec()

fs/btrfs/Kconfig+1−0

@@ -14,6 +14,7 @@ config BTRFS_FS · 13 unmodified lines
14	select LZO_DECOMPRESS	14	select LZO_DECOMPRESS
15	select ZSTD_COMPRESS	15	select ZSTD_COMPRESS
16	select ZSTD_DECOMPRESS	16	select ZSTD_DECOMPRESS
		17	select FS_IOMAP
17	select RAID6_PQ	18	select RAID6_PQ
18	select XOR_BLOCKS	19	select XOR_BLOCKS
19	select SRCU	20	select SRCU

fs/btrfs/backref.c+831−6

@@ -13,6 +13,7 @@ · 12 unmodified lines
13	#include "transaction.h"	13	#include "transaction.h"
14	#include "delayed-ref.h"	14	#include "delayed-ref.h"
15	#include "locking.h"	15	#include "locking.h"
		16	#include "misc.h"
16		17
17	/* Just an arbitrary number so we can be sure this happened */	18	/* Just an arbitrary number so we can be sure this happened */
18	#define BACKREF_FOUND_SHARED 6	19	#define BACKREF_FOUND_SHARED 6
@@ -537,18 +538,13 @@ static int resolve_indirect_ref(struct btrfs_fs_info *fs_info, · 518 unmodified lines
537	const u64 *extent_item_pos, bool ignore_offset)	538	const u64 *extent_item_pos, bool ignore_offset)
538	{	539	{
539	struct btrfs_root *root;	540	struct btrfs_root *root;
540	struct btrfs_key root_key;
541	struct extent_buffer *eb;	541	struct extent_buffer *eb;
542	int ret = 0;	542	int ret = 0;
543	int root_level;	543	int root_level;
544	int level = ref->level;	544	int level = ref->level;
545	struct btrfs_key search_key = ref->key_for_search;	545	struct btrfs_key search_key = ref->key_for_search;
546		546
547	root_key.objectid = ref->root_id;	547	root = btrfs_get_fs_root(fs_info, ref->root_id, false);
548	root_key.type = BTRFS_ROOT_ITEM_KEY;
549	root_key.offset = (u64)-1;
550
551	root = btrfs_get_fs_root(fs_info, &root_key, false);
552	if (IS_ERR(root)) {	548	if (IS_ERR(root)) {
553	ret = PTR_ERR(root);	549	ret = PTR_ERR(root);
554	goto out_free;	550	goto out_free;
@@ -2295,3 +2291,832 @@ void free_ipath(struct inode_fs_paths *ipath) · 1740 unmodified lines
2295	kvfree(ipath->fspath);	2291	kvfree(ipath->fspath);
2296	kfree(ipath);	2292	kfree(ipath);
2297	}	2293	}
		2294
		2295	struct btrfs_backref_iter *btrfs_backref_iter_alloc(
		2296	struct btrfs_fs_info *fs_info, gfp_t gfp_flag)
		2297	{
		2298	struct btrfs_backref_iter *ret;
		2299
		2300	ret = kzalloc(sizeof(*ret), gfp_flag);
		2301	if (!ret)
		2302	return NULL;
		2303
		2304	ret->path = btrfs_alloc_path();
		2305	if (!ret) {
		2306	kfree(ret);
		2307	return NULL;
		2308	}
		2309
		2310	/* Current backref iterator only supports iteration in commit root */
		2311	ret->path->search_commit_root = 1;
		2312	ret->path->skip_locking = 1;
		2313	ret->fs_info = fs_info;
		2314
		2315	return ret;
		2316	}
		2317
		2318	int btrfs_backref_iter_start(struct btrfs_backref_iter *iter, u64 bytenr)
		2319	{
		2320	struct btrfs_fs_info *fs_info = iter->fs_info;
		2321	struct btrfs_path *path = iter->path;
		2322	struct btrfs_extent_item *ei;
		2323	struct btrfs_key key;
		2324	int ret;
		2325
		2326	key.objectid = bytenr;
		2327	key.type = BTRFS_METADATA_ITEM_KEY;
		2328	key.offset = (u64)-1;
		2329	iter->bytenr = bytenr;
		2330
		2331	ret = btrfs_search_slot(NULL, fs_info->extent_root, &key, path, 0, 0);
		2332	if (ret < 0)
		2333	return ret;
		2334	if (ret == 0) {
		2335	ret = -EUCLEAN;
		2336	goto release;
		2337	}
		2338	if (path->slots[0] == 0) {
		2339	WARN_ON(IS_ENABLED(CONFIG_BTRFS_DEBUG));
		2340	ret = -EUCLEAN;
		2341	goto release;
		2342	}
		2343	path->slots[0]--;
		2344
		2345	btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]);
		2346	if ((key.type != BTRFS_EXTENT_ITEM_KEY &&
		2347	key.type != BTRFS_METADATA_ITEM_KEY) \|\| key.objectid != bytenr) {
		2348	ret = -ENOENT;
		2349	goto release;
		2350	}
		2351	memcpy(&iter->cur_key, &key, sizeof(key));
		2352	iter->item_ptr = (u32)btrfs_item_ptr_offset(path->nodes[0],
		2353	path->slots[0]);
		2354	iter->end_ptr = (u32)(iter->item_ptr +
		2355	btrfs_item_size_nr(path->nodes[0], path->slots[0]));
		2356	ei = btrfs_item_ptr(path->nodes[0], path->slots[0],
		2357	struct btrfs_extent_item);
		2358
		2359	/*
		2360	* Only support iteration on tree backref yet.
		2361	*
		2362	* This is an extra precaution for non skinny-metadata, where
		2363	* EXTENT_ITEM is also used for tree blocks, that we can only use
		2364	* extent flags to determine if it's a tree block.
		2365	*/
		2366	if (btrfs_extent_flags(path->nodes[0], ei) & BTRFS_EXTENT_FLAG_DATA) {
		2367	ret = -ENOTSUPP;
		2368	goto release;
		2369	}
		2370	iter->cur_ptr = (u32)(iter->item_ptr + sizeof(*ei));
		2371
		2372	/* If there is no inline backref, go search for keyed backref */
		2373	if (iter->cur_ptr >= iter->end_ptr) {
		2374	ret = btrfs_next_item(fs_info->extent_root, path);
		2375
		2376	/* No inline nor keyed ref */
		2377	if (ret > 0) {
		2378	ret = -ENOENT;
		2379	goto release;
		2380	}
		2381	if (ret < 0)
		2382	goto release;
		2383
		2384	btrfs_item_key_to_cpu(path->nodes[0], &iter->cur_key,
		2385	path->slots[0]);
		2386	if (iter->cur_key.objectid != bytenr \|\|
		2387	(iter->cur_key.type != BTRFS_SHARED_BLOCK_REF_KEY &&
		2388	iter->cur_key.type != BTRFS_TREE_BLOCK_REF_KEY)) {
		2389	ret = -ENOENT;
		2390	goto release;
		2391	}
		2392	iter->cur_ptr = (u32)btrfs_item_ptr_offset(path->nodes[0],
		2393	path->slots[0]);
		2394	iter->item_ptr = iter->cur_ptr;
		2395	iter->end_ptr = (u32)(iter->item_ptr + btrfs_item_size_nr(
		2396	path->nodes[0], path->slots[0]));
		2397	}
		2398
		2399	return 0;
		2400	release:
		2401	btrfs_backref_iter_release(iter);
		2402	return ret;
		2403	}
		2404
		2405	/*
		2406	* Go to the next backref item of current bytenr, can be either inlined or
		2407	* keyed.
		2408	*
		2409	* Caller needs to check whether it's inline ref or not by iter->cur_key.
		2410	*
		2411	* Return 0 if we get next backref without problem.
		2412	* Return >0 if there is no extra backref for this bytenr.
		2413	* Return <0 if there is something wrong happened.
		2414	*/
		2415	int btrfs_backref_iter_next(struct btrfs_backref_iter *iter)
		2416	{
		2417	struct extent_buffer *eb = btrfs_backref_get_eb(iter);
		2418	struct btrfs_path *path = iter->path;
		2419	struct btrfs_extent_inline_ref *iref;
		2420	int ret;
		2421	u32 size;
		2422
		2423	if (btrfs_backref_iter_is_inline_ref(iter)) {
		2424	/* We're still inside the inline refs */
		2425	ASSERT(iter->cur_ptr < iter->end_ptr);
		2426
		2427	if (btrfs_backref_has_tree_block_info(iter)) {
		2428	/* First tree block info */
		2429	size = sizeof(struct btrfs_tree_block_info);
		2430	} else {
		2431	/* Use inline ref type to determine the size */
		2432	int type;
		2433
		2434	iref = (struct btrfs_extent_inline_ref *)
		2435	((unsigned long)iter->cur_ptr);
		2436	type = btrfs_extent_inline_ref_type(eb, iref);
		2437
		2438	size = btrfs_extent_inline_ref_size(type);
		2439	}
		2440	iter->cur_ptr += size;
		2441	if (iter->cur_ptr < iter->end_ptr)
		2442	return 0;
		2443
		2444	/* All inline items iterated, fall through */
		2445	}
		2446
		2447	/* We're at keyed items, there is no inline item, go to the next one */
		2448	ret = btrfs_next_item(iter->fs_info->extent_root, iter->path);
		2449	if (ret)
		2450	return ret;
		2451
		2452	btrfs_item_key_to_cpu(path->nodes[0], &iter->cur_key, path->slots[0]);
		2453	if (iter->cur_key.objectid != iter->bytenr \|\|
		2454	(iter->cur_key.type != BTRFS_TREE_BLOCK_REF_KEY &&
		2455	iter->cur_key.type != BTRFS_SHARED_BLOCK_REF_KEY))
		2456	return 1;
		2457	iter->item_ptr = (u32)btrfs_item_ptr_offset(path->nodes[0],
		2458	path->slots[0]);
		2459	iter->cur_ptr = iter->item_ptr;
		2460	iter->end_ptr = iter->item_ptr + (u32)btrfs_item_size_nr(path->nodes[0],
		2461	path->slots[0]);
		2462	return 0;
		2463	}
		2464
		2465	void btrfs_backref_init_cache(struct btrfs_fs_info *fs_info,
		2466	struct btrfs_backref_cache *cache, int is_reloc)
		2467	{
		2468	int i;
		2469
		2470	cache->rb_root = RB_ROOT;
		2471	for (i = 0; i < BTRFS_MAX_LEVEL; i++)
		2472	INIT_LIST_HEAD(&cache->pending[i]);
		2473	INIT_LIST_HEAD(&cache->changed);
		2474	INIT_LIST_HEAD(&cache->detached);
		2475	INIT_LIST_HEAD(&cache->leaves);
		2476	INIT_LIST_HEAD(&cache->pending_edge);
		2477	INIT_LIST_HEAD(&cache->useless_node);
		2478	cache->fs_info = fs_info;
		2479	cache->is_reloc = is_reloc;
		2480	}
		2481
		2482	struct btrfs_backref_node *btrfs_backref_alloc_node(
		2483	struct btrfs_backref_cache *cache, u64 bytenr, int level)
		2484	{
		2485	struct btrfs_backref_node *node;
		2486
		2487	ASSERT(level >= 0 && level < BTRFS_MAX_LEVEL);
		2488	node = kzalloc(sizeof(*node), GFP_NOFS);
		2489	if (!node)
		2490	return node;
		2491
		2492	INIT_LIST_HEAD(&node->list);
		2493	INIT_LIST_HEAD(&node->upper);
		2494	INIT_LIST_HEAD(&node->lower);
		2495	RB_CLEAR_NODE(&node->rb_node);
		2496	cache->nr_nodes++;
		2497	node->level = level;
		2498	node->bytenr = bytenr;
		2499
		2500	return node;
		2501	}
		2502
		2503	struct btrfs_backref_edge *btrfs_backref_alloc_edge(
		2504	struct btrfs_backref_cache *cache)
		2505	{
		2506	struct btrfs_backref_edge *edge;
		2507
		2508	edge = kzalloc(sizeof(*edge), GFP_NOFS);
		2509	if (edge)
		2510	cache->nr_edges++;
		2511	return edge;
		2512	}
		2513
		2514	/*
		2515	* Drop the backref node from cache, also cleaning up all its
		2516	* upper edges and any uncached nodes in the path.
		2517	*
		2518	* This cleanup happens bottom up, thus the node should either
		2519	* be the lowest node in the cache or a detached node.
		2520	*/
		2521	void btrfs_backref_cleanup_node(struct btrfs_backref_cache *cache,
		2522	struct btrfs_backref_node *node)
		2523	{
		2524	struct btrfs_backref_node *upper;
		2525	struct btrfs_backref_edge *edge;
		2526
		2527	if (!node)
		2528	return;
		2529
		2530	BUG_ON(!node->lowest && !node->detached);
		2531	while (!list_empty(&node->upper)) {
		2532	edge = list_entry(node->upper.next, struct btrfs_backref_edge,
		2533	list[LOWER]);
		2534	upper = edge->node[UPPER];
		2535	list_del(&edge->list[LOWER]);
		2536	list_del(&edge->list[UPPER]);
		2537	btrfs_backref_free_edge(cache, edge);
		2538
		2539	if (RB_EMPTY_NODE(&upper->rb_node)) {
		2540	BUG_ON(!list_empty(&node->upper));
		2541	btrfs_backref_drop_node(cache, node);
		2542	node = upper;
		2543	node->lowest = 1;
		2544	continue;
		2545	}
		2546	/*
		2547	* Add the node to leaf node list if no other child block
		2548	* cached.
		2549	*/
		2550	if (list_empty(&upper->lower)) {
		2551	list_add_tail(&upper->lower, &cache->leaves);
		2552	upper->lowest = 1;
		2553	}
		2554	}
		2555
		2556	btrfs_backref_drop_node(cache, node);
		2557	}
		2558
		2559	/*
		2560	* Release all nodes/edges from current cache
		2561	*/
		2562	void btrfs_backref_release_cache(struct btrfs_backref_cache *cache)
		2563	{
		2564	struct btrfs_backref_node *node;
		2565	int i;
		2566
		2567	while (!list_empty(&cache->detached)) {
		2568	node = list_entry(cache->detached.next,
		2569	struct btrfs_backref_node, list);
		2570	btrfs_backref_cleanup_node(cache, node);
		2571	}
		2572
		2573	while (!list_empty(&cache->leaves)) {
		2574	node = list_entry(cache->leaves.next,
		2575	struct btrfs_backref_node, lower);
		2576	btrfs_backref_cleanup_node(cache, node);
		2577	}
		2578
		2579	cache->last_trans = 0;
		2580
		2581	for (i = 0; i < BTRFS_MAX_LEVEL; i++)
		2582	ASSERT(list_empty(&cache->pending[i]));
		2583	ASSERT(list_empty(&cache->pending_edge));
		2584	ASSERT(list_empty(&cache->useless_node));
		2585	ASSERT(list_empty(&cache->changed));
		2586	ASSERT(list_empty(&cache->detached));
		2587	ASSERT(RB_EMPTY_ROOT(&cache->rb_root));
		2588	ASSERT(!cache->nr_nodes);
		2589	ASSERT(!cache->nr_edges);
		2590	}
		2591
		2592	/*
		2593	* Handle direct tree backref
		2594	*
		2595	* Direct tree backref means, the backref item shows its parent bytenr
		2596	* directly. This is for SHARED_BLOCK_REF backref (keyed or inlined).
		2597	*
		2598	* @ref_key: The converted backref key.
		2599	* For keyed backref, it's the item key.
		2600	* For inlined backref, objectid is the bytenr,
		2601	* type is btrfs_inline_ref_type, offset is
		2602	* btrfs_inline_ref_offset.
		2603	*/
		2604	static int handle_direct_tree_backref(struct btrfs_backref_cache *cache,
		2605	struct btrfs_key *ref_key,
		2606	struct btrfs_backref_node *cur)
		2607	{
		2608	struct btrfs_backref_edge *edge;
		2609	struct btrfs_backref_node *upper;
		2610	struct rb_node *rb_node;
		2611
		2612	ASSERT(ref_key->type == BTRFS_SHARED_BLOCK_REF_KEY);
		2613
		2614	/* Only reloc root uses backref pointing to itself */
		2615	if (ref_key->objectid == ref_key->offset) {
		2616	struct btrfs_root *root;
		2617
		2618	cur->is_reloc_root = 1;
		2619	/* Only reloc backref cache cares about a specific root */
		2620	if (cache->is_reloc) {
		2621	root = find_reloc_root(cache->fs_info, cur->bytenr);
		2622	if (WARN_ON(!root))
		2623	return -ENOENT;
		2624	cur->root = root;
		2625	} else {
		2626	/*
		2627	* For generic purpose backref cache, reloc root node
		2628	* is useless.
		2629	*/
		2630	list_add(&cur->list, &cache->useless_node);
		2631	}
		2632	return 0;
		2633	}
		2634
		2635	edge = btrfs_backref_alloc_edge(cache);
		2636	if (!edge)
		2637	return -ENOMEM;
		2638
		2639	rb_node = rb_simple_search(&cache->rb_root, ref_key->offset);
		2640	if (!rb_node) {
		2641	/* Parent node not yet cached */
		2642	upper = btrfs_backref_alloc_node(cache, ref_key->offset,
		2643	cur->level + 1);
		2644	if (!upper) {
		2645	btrfs_backref_free_edge(cache, edge);
		2646	return -ENOMEM;
		2647	}
		2648
		2649	/*
		2650	* Backrefs for the upper level block isn't cached, add the
		2651	* block to pending list
		2652	*/
		2653	list_add_tail(&edge->list[UPPER], &cache->pending_edge);
		2654	} else {
		2655	/* Parent node already cached */
		2656	upper = rb_entry(rb_node, struct btrfs_backref_node, rb_node);
		2657	ASSERT(upper->checked);
		2658	INIT_LIST_HEAD(&edge->list[UPPER]);
		2659	}
		2660	btrfs_backref_link_edge(edge, cur, upper, LINK_LOWER);
		2661	return 0;
		2662	}
		2663
		2664	/*
		2665	* Handle indirect tree backref
		2666	*
		2667	* Indirect tree backref means, we only know which tree the node belongs to.
		2668	* We still need to do a tree search to find out the parents. This is for
		2669	* TREE_BLOCK_REF backref (keyed or inlined).
		2670	*
		2671	* @ref_key: The same as @ref_key in handle_direct_tree_backref()
		2672	* @tree_key: The first key of this tree block.
		2673	* @path: A clean (released) path, to avoid allocating path everytime
		2674	* the function get called.
		2675	*/
		2676	static int handle_indirect_tree_backref(struct btrfs_backref_cache *cache,
		2677	struct btrfs_path *path,
		2678	struct btrfs_key *ref_key,
		2679	struct btrfs_key *tree_key,
		2680	struct btrfs_backref_node *cur)
		2681	{
		2682	struct btrfs_fs_info *fs_info = cache->fs_info;
		2683	struct btrfs_backref_node *upper;
		2684	struct btrfs_backref_node *lower;
		2685	struct btrfs_backref_edge *edge;
		2686	struct extent_buffer *eb;
		2687	struct btrfs_root *root;
		2688	struct rb_node *rb_node;
		2689	int level;
		2690	bool need_check = true;
		2691	int ret;
		2692
		2693	root = btrfs_get_fs_root(fs_info, ref_key->offset, false);
		2694	if (IS_ERR(root))
		2695	return PTR_ERR(root);
		2696	if (!test_bit(BTRFS_ROOT_SHAREABLE, &root->state))
		2697	cur->cowonly = 1;
		2698
		2699	if (btrfs_root_level(&root->root_item) == cur->level) {
		2700	/* Tree root */
		2701	ASSERT(btrfs_root_bytenr(&root->root_item) == cur->bytenr);
		2702	/*
		2703	* For reloc backref cache, we may ignore reloc root. But for
		2704	* general purpose backref cache, we can't rely on
		2705	* btrfs_should_ignore_reloc_root() as it may conflict with
		2706	* current running relocation and lead to missing root.
		2707	*
		2708	* For general purpose backref cache, reloc root detection is
		2709	* completely relying on direct backref (key->offset is parent
		2710	* bytenr), thus only do such check for reloc cache.
		2711	*/
		2712	if (btrfs_should_ignore_reloc_root(root) && cache->is_reloc) {
		2713	btrfs_put_root(root);
		2714	list_add(&cur->list, &cache->useless_node);
		2715	} else {
		2716	cur->root = root;
		2717	}
		2718	return 0;
		2719	}
		2720
		2721	level = cur->level + 1;
		2722
		2723	/* Search the tree to find parent blocks referring to the block */
		2724	path->search_commit_root = 1;
		2725	path->skip_locking = 1;
		2726	path->lowest_level = level;
		2727	ret = btrfs_search_slot(NULL, root, tree_key, path, 0, 0);
		2728	path->lowest_level = 0;
		2729	if (ret < 0) {
		2730	btrfs_put_root(root);
		2731	return ret;
		2732	}
		2733	if (ret > 0 && path->slots[level] > 0)
		2734	path->slots[level]--;
		2735
		2736	eb = path->nodes[level];
		2737	if (btrfs_node_blockptr(eb, path->slots[level]) != cur->bytenr) {
		2738	btrfs_err(fs_info,
		2739	"couldn't find block (%llu) (level %d) in tree (%llu) with key (%llu %u %llu)",
		2740	cur->bytenr, level - 1, root->root_key.objectid,
		2741	tree_key->objectid, tree_key->type, tree_key->offset);
		2742	btrfs_put_root(root);
		2743	ret = -ENOENT;
		2744	goto out;
		2745	}
		2746	lower = cur;
		2747
		2748	/* Add all nodes and edges in the path */
		2749	for (; level < BTRFS_MAX_LEVEL; level++) {
		2750	if (!path->nodes[level]) {
		2751	ASSERT(btrfs_root_bytenr(&root->root_item) ==
		2752	lower->bytenr);
		2753	/* Same as previous should_ignore_reloc_root() call */
		2754	if (btrfs_should_ignore_reloc_root(root) &&
		2755	cache->is_reloc) {
		2756	btrfs_put_root(root);
		2757	list_add(&lower->list, &cache->useless_node);
		2758	} else {
		2759	lower->root = root;
		2760	}
		2761	break;
		2762	}
		2763
		2764	edge = btrfs_backref_alloc_edge(cache);
		2765	if (!edge) {
		2766	btrfs_put_root(root);
		2767	ret = -ENOMEM;
		2768	goto out;
		2769	}
		2770
		2771	eb = path->nodes[level];
		2772	rb_node = rb_simple_search(&cache->rb_root, eb->start);
		2773	if (!rb_node) {
		2774	upper = btrfs_backref_alloc_node(cache, eb->start,
		2775	lower->level + 1);
		2776	if (!upper) {
		2777	btrfs_put_root(root);
		2778	btrfs_backref_free_edge(cache, edge);
		2779	ret = -ENOMEM;
		2780	goto out;
		2781	}
		2782	upper->owner = btrfs_header_owner(eb);
		2783	if (!test_bit(BTRFS_ROOT_SHAREABLE, &root->state))
		2784	upper->cowonly = 1;
		2785
		2786	/*
		2787	* If we know the block isn't shared we can avoid
		2788	* checking its backrefs.
		2789	*/
		2790	if (btrfs_block_can_be_shared(root, eb))
		2791	upper->checked = 0;
		2792	else
		2793	upper->checked = 1;
		2794
		2795	/*
		2796	* Add the block to pending list if we need to check its
		2797	* backrefs, we only do this once while walking up a
		2798	* tree as we will catch anything else later on.
		2799	*/
		2800	if (!upper->checked && need_check) {
		2801	need_check = false;
		2802	list_add_tail(&edge->list[UPPER],
		2803	&cache->pending_edge);
		2804	} else {
		2805	if (upper->checked)
		2806	need_check = true;
		2807	INIT_LIST_HEAD(&edge->list[UPPER]);
		2808	}
		2809	} else {
		2810	upper = rb_entry(rb_node, struct btrfs_backref_node,
		2811	rb_node);
		2812	ASSERT(upper->checked);
		2813	INIT_LIST_HEAD(&edge->list[UPPER]);
		2814	if (!upper->owner)
		2815	upper->owner = btrfs_header_owner(eb);
		2816	}
		2817	btrfs_backref_link_edge(edge, lower, upper, LINK_LOWER);
		2818
		2819	if (rb_node) {
		2820	btrfs_put_root(root);
		2821	break;
		2822	}
		2823	lower = upper;
		2824	upper = NULL;
		2825	}
		2826	out:
		2827	btrfs_release_path(path);
		2828	return ret;
		2829	}
		2830
		2831	/*
		2832	* Add backref node @cur into @cache.
		2833	*
		2834	* NOTE: Even if the function returned 0, @cur is not yet cached as its upper
		2835	* links aren't yet bi-directional. Needs to finish such links.
		2836	* Use btrfs_backref_finish_upper_links() to finish such linkage.
		2837	*
		2838	* @path: Released path for indirect tree backref lookup
		2839	* @iter: Released backref iter for extent tree search
		2840	* @node_key: The first key of the tree block
		2841	*/
		2842	int btrfs_backref_add_tree_node(struct btrfs_backref_cache *cache,
		2843	struct btrfs_path *path,
		2844	struct btrfs_backref_iter *iter,
		2845	struct btrfs_key *node_key,
		2846	struct btrfs_backref_node *cur)
		2847	{
		2848	struct btrfs_fs_info *fs_info = cache->fs_info;
		2849	struct btrfs_backref_edge *edge;
		2850	struct btrfs_backref_node *exist;
		2851	int ret;
		2852
		2853	ret = btrfs_backref_iter_start(iter, cur->bytenr);
		2854	if (ret < 0)
		2855	return ret;
		2856	/*
		2857	* We skip the first btrfs_tree_block_info, as we don't use the key
		2858	* stored in it, but fetch it from the tree block
		2859	*/
		2860	if (btrfs_backref_has_tree_block_info(iter)) {
		2861	ret = btrfs_backref_iter_next(iter);
		2862	if (ret < 0)
		2863	goto out;
		2864	/* No extra backref? This means the tree block is corrupted */
		2865	if (ret > 0) {
		2866	ret = -EUCLEAN;
		2867	goto out;
		2868	}
		2869	}
		2870	WARN_ON(cur->checked);
		2871	if (!list_empty(&cur->upper)) {
		2872	/*
		2873	* The backref was added previously when processing backref of
		2874	* type BTRFS_TREE_BLOCK_REF_KEY
		2875	*/
		2876	ASSERT(list_is_singular(&cur->upper));
		2877	edge = list_entry(cur->upper.next, struct btrfs_backref_edge,
		2878	list[LOWER]);
		2879	ASSERT(list_empty(&edge->list[UPPER]));
		2880	exist = edge->node[UPPER];
		2881	/*
		2882	* Add the upper level block to pending list if we need check
		2883	* its backrefs
		2884	*/
		2885	if (!exist->checked)
		2886	list_add_tail(&edge->list[UPPER], &cache->pending_edge);
		2887	} else {
		2888	exist = NULL;
		2889	}
		2890
		2891	for (; ret == 0; ret = btrfs_backref_iter_next(iter)) {
		2892	struct extent_buffer *eb;
		2893	struct btrfs_key key;
		2894	int type;
		2895
		2896	cond_resched();
		2897	eb = btrfs_backref_get_eb(iter);
		2898
		2899	key.objectid = iter->bytenr;
		2900	if (btrfs_backref_iter_is_inline_ref(iter)) {
		2901	struct btrfs_extent_inline_ref *iref;
		2902
		2903	/* Update key for inline backref */
		2904	iref = (struct btrfs_extent_inline_ref *)
		2905	((unsigned long)iter->cur_ptr);
		2906	type = btrfs_get_extent_inline_ref_type(eb, iref,
		2907	BTRFS_REF_TYPE_BLOCK);
		2908	if (type == BTRFS_REF_TYPE_INVALID) {
		2909	ret = -EUCLEAN;
		2910	goto out;
		2911	}
		2912	key.type = type;
		2913	key.offset = btrfs_extent_inline_ref_offset(eb, iref);
		2914	} else {
		2915	key.type = iter->cur_key.type;
		2916	key.offset = iter->cur_key.offset;
		2917	}
		2918
		2919	/*
		2920	* Parent node found and matches current inline ref, no need to
		2921	* rebuild this node for this inline ref
		2922	*/
		2923	if (exist &&
		2924	((key.type == BTRFS_TREE_BLOCK_REF_KEY &&
		2925	exist->owner == key.offset) \|\|
		2926	(key.type == BTRFS_SHARED_BLOCK_REF_KEY &&
		2927	exist->bytenr == key.offset))) {
		2928	exist = NULL;
		2929	continue;
		2930	}
		2931
		2932	/* SHARED_BLOCK_REF means key.offset is the parent bytenr */
		2933	if (key.type == BTRFS_SHARED_BLOCK_REF_KEY) {
		2934	ret = handle_direct_tree_backref(cache, &key, cur);
		2935	if (ret < 0)
		2936	goto out;
		2937	continue;
		2938	} else if (unlikely(key.type == BTRFS_EXTENT_REF_V0_KEY)) {
		2939	ret = -EINVAL;
		2940	btrfs_print_v0_err(fs_info);
		2941	btrfs_handle_fs_error(fs_info, ret, NULL);
		2942	goto out;
		2943	} else if (key.type != BTRFS_TREE_BLOCK_REF_KEY) {
		2944	continue;
		2945	}
		2946
		2947	/*
		2948	* key.type == BTRFS_TREE_BLOCK_REF_KEY, inline ref offset
		2949	* means the root objectid. We need to search the tree to get
		2950	* its parent bytenr.
		2951	*/
		2952	ret = handle_indirect_tree_backref(cache, path, &key, node_key,
		2953	cur);
		2954	if (ret < 0)
		2955	goto out;
		2956	}
		2957	ret = 0;
		2958	cur->checked = 1;
		2959	WARN_ON(exist);
		2960	out:
		2961	btrfs_backref_iter_release(iter);
		2962	return ret;
		2963	}
		2964
		2965	/*
		2966	* Finish the upwards linkage created by btrfs_backref_add_tree_node()
		2967	*/
		2968	int btrfs_backref_finish_upper_links(struct btrfs_backref_cache *cache,
		2969	struct btrfs_backref_node *start)
		2970	{
		2971	struct list_head *useless_node = &cache->useless_node;
		2972	struct btrfs_backref_edge *edge;
		2973	struct rb_node *rb_node;
		2974	LIST_HEAD(pending_edge);
		2975
		2976	ASSERT(start->checked);
		2977
		2978	/* Insert this node to cache if it's not COW-only */
		2979	if (!start->cowonly) {
		2980	rb_node = rb_simple_insert(&cache->rb_root, start->bytenr,
		2981	&start->rb_node);
		2982	if (rb_node)
		2983	btrfs_backref_panic(cache->fs_info, start->bytenr,
		2984	-EEXIST);
		2985	list_add_tail(&start->lower, &cache->leaves);
		2986	}
		2987
		2988	/*
		2989	* Use breadth first search to iterate all related edges.
		2990	*
		2991	* The starting points are all the edges of this node
		2992	*/
		2993	list_for_each_entry(edge, &start->upper, list[LOWER])
		2994	list_add_tail(&edge->list[UPPER], &pending_edge);
		2995
		2996	while (!list_empty(&pending_edge)) {
		2997	struct btrfs_backref_node *upper;
		2998	struct btrfs_backref_node *lower;
		2999	struct rb_node *rb_node;
		3000
		3001	edge = list_first_entry(&pending_edge,
		3002	struct btrfs_backref_edge, list[UPPER]);
		3003	list_del_init(&edge->list[UPPER]);
		3004	upper = edge->node[UPPER];
		3005	lower = edge->node[LOWER];
		3006
		3007	/* Parent is detached, no need to keep any edges */
		3008	if (upper->detached) {
		3009	list_del(&edge->list[LOWER]);
		3010	btrfs_backref_free_edge(cache, edge);
		3011
		3012	/* Lower node is orphan, queue for cleanup */
		3013	if (list_empty(&lower->upper))
		3014	list_add(&lower->list, useless_node);
		3015	continue;
		3016	}
		3017
		3018	/*
		3019	* All new nodes added in current build_backref_tree() haven't
		3020	* been linked to the cache rb tree.
		3021	* So if we have upper->rb_node populated, this means a cache
		3022	* hit. We only need to link the edge, as @upper and all its
		3023	* parents have already been linked.
		3024	*/
		3025	if (!RB_EMPTY_NODE(&upper->rb_node)) {
		3026	if (upper->lowest) {
		3027	list_del_init(&upper->lower);
		3028	upper->lowest = 0;
		3029	}
		3030
		3031	list_add_tail(&edge->list[UPPER], &upper->lower);
		3032	continue;
		3033	}
		3034
		3035	/* Sanity check, we shouldn't have any unchecked nodes */
		3036	if (!upper->checked) {
		3037	ASSERT(0);
		3038	return -EUCLEAN;
		3039	}
		3040
		3041	/* Sanity check, COW-only node has non-COW-only parent */
		3042	if (start->cowonly != upper->cowonly) {
		3043	ASSERT(0);
		3044	return -EUCLEAN;
		3045	}
		3046
		3047	/* Only cache non-COW-only (subvolume trees) tree blocks */
		3048	if (!upper->cowonly) {
		3049	rb_node = rb_simple_insert(&cache->rb_root, upper->bytenr,
		3050	&upper->rb_node);
		3051	if (rb_node) {
		3052	btrfs_backref_panic(cache->fs_info,
		3053	upper->bytenr, -EEXIST);
		3054	return -EUCLEAN;
		3055	}
		3056	}
		3057
		3058	list_add_tail(&edge->list[UPPER], &upper->lower);
		3059
		3060	/*
		3061	* Also queue all the parent edges of this uncached node
		3062	* to finish the upper linkage
		3063	*/
		3064	list_for_each_entry(edge, &upper->upper, list[LOWER])
		3065	list_add_tail(&edge->list[UPPER], &pending_edge);
		3066	}
		3067	return 0;
		3068	}
		3069
		3070	void btrfs_backref_error_cleanup(struct btrfs_backref_cache *cache,
		3071	struct btrfs_backref_node *node)
		3072	{
		3073	struct btrfs_backref_node *lower;
		3074	struct btrfs_backref_node *upper;
		3075	struct btrfs_backref_edge *edge;
		3076
		3077	while (!list_empty(&cache->useless_node)) {
		3078	lower = list_first_entry(&cache->useless_node,
		3079	struct btrfs_backref_node, list);
		3080	list_del_init(&lower->list);
		3081	}
		3082	while (!list_empty(&cache->pending_edge)) {
		3083	edge = list_first_entry(&cache->pending_edge,
		3084	struct btrfs_backref_edge, list[UPPER]);
		3085	list_del(&edge->list[UPPER]);
		3086	list_del(&edge->list[LOWER]);
		3087	lower = edge->node[LOWER];
		3088	upper = edge->node[UPPER];
		3089	btrfs_backref_free_edge(cache, edge);
		3090
		3091	/*
		3092	* Lower is no longer linked to any upper backref nodes and
		3093	* isn't in the cache, we can free it ourselves.
		3094	*/
		3095	if (list_empty(&lower->upper) &&
		3096	RB_EMPTY_NODE(&lower->rb_node))
		3097	list_add(&lower->list, &cache->useless_node);
		3098
		3099	if (!RB_EMPTY_NODE(&upper->rb_node))
		3100	continue;
		3101
		3102	/* Add this guy's upper edges to the list to process */
		3103	list_for_each_entry(edge, &upper->upper, list[LOWER])
		3104	list_add_tail(&edge->list[UPPER],
		3105	&cache->pending_edge);
		3106	if (list_empty(&upper->upper))
		3107	list_add(&upper->list, &cache->useless_node);
		3108	}
		3109
		3110	while (!list_empty(&cache->useless_node)) {
		3111	lower = list_first_entry(&cache->useless_node,
		3112	struct btrfs_backref_node, list);
		3113	list_del_init(&lower->list);
		3114	if (lower == node)
		3115	node = NULL;
		3116	btrfs_backref_free_node(cache, lower);
		3117	}
		3118
		3119	btrfs_backref_cleanup_node(cache, node);
		3120	ASSERT(list_empty(&cache->useless_node) &&
		3121	list_empty(&cache->pending_edge));
		3122	}

fs/btrfs/backref.h+297−0

@@ -8,6 +8,7 @@ · 7 unmodified lines
8		8
9	#include <linux/btrfs.h>	9	#include <linux/btrfs.h>
10	#include "ulist.h"	10	#include "ulist.h"
		11	#include "disk-io.h"
11	#include "extent_io.h"	12	#include "extent_io.h"
12		13
13	struct inode_fs_paths {	14	struct inode_fs_paths {
@@ -78,4 +79,300 @@ struct prelim_ref { · 64 unmodified lines
78	u64 wanted_disk_byte;	79	u64 wanted_disk_byte;
79	};	80	};
80		81
		82	/*
		83	* Iterate backrefs of one extent.
		84	*
		85	* Now it only supports iteration of tree block in commit root.
		86	*/
		87	struct btrfs_backref_iter {
		88	u64 bytenr;
		89	struct btrfs_path *path;
		90	struct btrfs_fs_info *fs_info;
		91	struct btrfs_key cur_key;
		92	u32 item_ptr;
		93	u32 cur_ptr;
		94	u32 end_ptr;
		95	};
		96
		97	struct btrfs_backref_iter *btrfs_backref_iter_alloc(
		98	struct btrfs_fs_info *fs_info, gfp_t gfp_flag);
		99
		100	static inline void btrfs_backref_iter_free(struct btrfs_backref_iter *iter)
		101	{
		102	if (!iter)
		103	return;
		104	btrfs_free_path(iter->path);
		105	kfree(iter);
		106	}
		107
		108	static inline struct extent_buffer *btrfs_backref_get_eb(
		109	struct btrfs_backref_iter *iter)
		110	{
		111	if (!iter)
		112	return NULL;
		113	return iter->path->nodes[0];
		114	}
		115
		116	/*
		117	* For metadata with EXTENT_ITEM key (non-skinny) case, the first inline data
		118	* is btrfs_tree_block_info, without a btrfs_extent_inline_ref header.
		119	*
		120	* This helper determines if that's the case.
		121	*/
		122	static inline bool btrfs_backref_has_tree_block_info(
		123	struct btrfs_backref_iter *iter)
		124	{
		125	if (iter->cur_key.type == BTRFS_EXTENT_ITEM_KEY &&
		126	iter->cur_ptr - iter->item_ptr == sizeof(struct btrfs_extent_item))
		127	return true;
		128	return false;
		129	}
		130
		131	int btrfs_backref_iter_start(struct btrfs_backref_iter *iter, u64 bytenr);
		132
		133	int btrfs_backref_iter_next(struct btrfs_backref_iter *iter);
		134
		135	static inline bool btrfs_backref_iter_is_inline_ref(
		136	struct btrfs_backref_iter *iter)
		137	{
		138	if (iter->cur_key.type == BTRFS_EXTENT_ITEM_KEY \|\|
		139	iter->cur_key.type == BTRFS_METADATA_ITEM_KEY)
		140	return true;
		141	return false;
		142	}
		143
		144	static inline void btrfs_backref_iter_release(struct btrfs_backref_iter *iter)
		145	{
		146	iter->bytenr = 0;
		147	iter->item_ptr = 0;
		148	iter->cur_ptr = 0;
		149	iter->end_ptr = 0;
		150	btrfs_release_path(iter->path);
		151	memset(&iter->cur_key, 0, sizeof(iter->cur_key));
		152	}
		153
		154	/*
		155	* Backref cache related structures
		156	*
		157	* The whole objective of backref_cache is to build a bi-directional map
		158	* of tree blocks (represented by backref_node) and all their parents.
		159	*/
		160
		161	/*
		162	* Represent a tree block in the backref cache
		163	*/
		164	struct btrfs_backref_node {
		165	struct {
		166	struct rb_node rb_node;
		167	u64 bytenr;
		168	}; /* Use rb_simple_node for search/insert */
		169
		170	u64 new_bytenr;
		171	/* Objectid of tree block owner, can be not uptodate */
		172	u64 owner;
		173	/* Link to pending, changed or detached list */
		174	struct list_head list;
		175
		176	/* List of upper level edges, which link this node to its parents */
		177	struct list_head upper;
		178	/* List of lower level edges, which link this node to its children */
		179	struct list_head lower;
		180
		181	/* NULL if this node is not tree root */
		182	struct btrfs_root *root;
		183	/* Extent buffer got by COWing the block */
		184	struct extent_buffer *eb;
		185	/* Level of the tree block */
		186	unsigned int level:8;
		187	/* Is the block in a non-shareable tree */
		188	unsigned int cowonly:1;
		189	/* 1 if no child node is in the cache */
		190	unsigned int lowest:1;
		191	/* Is the extent buffer locked */
		192	unsigned int locked:1;
		193	/* Has the block been processed */
		194	unsigned int processed:1;
		195	/* Have backrefs of this block been checked */
		196	unsigned int checked:1;
		197	/*
		198	* 1 if corresponding block has been COWed but some upper level block
		199	* pointers may not point to the new location
		200	*/
		201	unsigned int pending:1;
		202	/* 1 if the backref node isn't connected to any other backref node */
		203	unsigned int detached:1;
		204
		205	/*
		206	* For generic purpose backref cache, where we only care if it's a reloc
		207	* root, doesn't care the source subvolid.
		208	*/
		209	unsigned int is_reloc_root:1;
		210	};
		211
		212	#define LOWER 0
		213	#define UPPER 1
		214
		215	/*
		216	* Represent an edge connecting upper and lower backref nodes.
		217	*/
		218	struct btrfs_backref_edge {
		219	/*
		220	* list[LOWER] is linked to btrfs_backref_node::upper of lower level
		221	* node, and list[UPPER] is linked to btrfs_backref_node::lower of
		222	* upper level node.
		223	*
		224	* Also, build_backref_tree() uses list[UPPER] for pending edges, before
		225	* linking list[UPPER] to its upper level nodes.
		226	*/
		227	struct list_head list[2];
		228
		229	/* Two related nodes */
		230	struct btrfs_backref_node *node[2];
		231	};
		232
		233	struct btrfs_backref_cache {
		234	/* Red black tree of all backref nodes in the cache */
		235	struct rb_root rb_root;
		236	/* For passing backref nodes to btrfs_reloc_cow_block */
		237	struct btrfs_backref_node *path[BTRFS_MAX_LEVEL];
		238	/*
		239	* List of blocks that have been COWed but some block pointers in upper
		240	* level blocks may not reflect the new location
		241	*/
		242	struct list_head pending[BTRFS_MAX_LEVEL];
		243	/* List of backref nodes with no child node */
		244	struct list_head leaves;
		245	/* List of blocks that have been COWed in current transaction */
		246	struct list_head changed;
		247	/* List of detached backref node. */
		248	struct list_head detached;
		249
		250	u64 last_trans;
		251
		252	int nr_nodes;
		253	int nr_edges;
		254
		255	/* List of unchecked backref edges during backref cache build */
		256	struct list_head pending_edge;
		257
		258	/* List of useless backref nodes during backref cache build */
		259	struct list_head useless_node;
		260
		261	struct btrfs_fs_info *fs_info;
		262
		263	/*
		264	* Whether this cache is for relocation
		265	*
		266	* Reloction backref cache require more info for reloc root compared
		267	* to generic backref cache.
		268	*/
		269	unsigned int is_reloc;
		270	};
		271
		272	void btrfs_backref_init_cache(struct btrfs_fs_info *fs_info,
		273	struct btrfs_backref_cache *cache, int is_reloc);
		274	struct btrfs_backref_node *btrfs_backref_alloc_node(
		275	struct btrfs_backref_cache *cache, u64 bytenr, int level);
		276	struct btrfs_backref_edge *btrfs_backref_alloc_edge(
		277	struct btrfs_backref_cache *cache);
		278
		279	#define LINK_LOWER (1 << 0)
		280	#define LINK_UPPER (1 << 1)
		281	static inline void btrfs_backref_link_edge(struct btrfs_backref_edge *edge,
		282	struct btrfs_backref_node *lower,
		283	struct btrfs_backref_node *upper,
		284	int link_which)
		285	{
		286	ASSERT(upper && lower && upper->level == lower->level + 1);
		287	edge->node[LOWER] = lower;
		288	edge->node[UPPER] = upper;
		289	if (link_which & LINK_LOWER)
		290	list_add_tail(&edge->list[LOWER], &lower->upper);
		291	if (link_which & LINK_UPPER)
		292	list_add_tail(&edge->list[UPPER], &upper->lower);
		293	}
		294
		295	static inline void btrfs_backref_free_node(struct btrfs_backref_cache *cache,
		296	struct btrfs_backref_node *node)
		297	{
		298	if (node) {
		299	cache->nr_nodes--;
		300	btrfs_put_root(node->root);
		301	kfree(node);
		302	}
		303	}
		304
		305	static inline void btrfs_backref_free_edge(struct btrfs_backref_cache *cache,
		306	struct btrfs_backref_edge *edge)
		307	{
		308	if (edge) {
		309	cache->nr_edges--;
		310	kfree(edge);
		311	}
		312	}
		313
		314	static inline void btrfs_backref_unlock_node_buffer(
		315	struct btrfs_backref_node *node)
		316	{
		317	if (node->locked) {
		318	btrfs_tree_unlock(node->eb);
		319	node->locked = 0;
		320	}
		321	}
		322
		323	static inline void btrfs_backref_drop_node_buffer(
		324	struct btrfs_backref_node *node)
		325	{
		326	if (node->eb) {
		327	btrfs_backref_unlock_node_buffer(node);
		328	free_extent_buffer(node->eb);
		329	node->eb = NULL;
		330	}
		331	}
		332
		333	/*
		334	* Drop the backref node from cache without cleaning up its children
		335	* edges.
		336	*
		337	* This can only be called on node without parent edges.
		338	* The children edges are still kept as is.
		339	*/
		340	static inline void btrfs_backref_drop_node(struct btrfs_backref_cache *tree,
		341	struct btrfs_backref_node *node)
		342	{
		343	BUG_ON(!list_empty(&node->upper));
		344
		345	btrfs_backref_drop_node_buffer(node);
		346	list_del(&node->list);
		347	list_del(&node->lower);
		348	if (!RB_EMPTY_NODE(&node->rb_node))
		349	rb_erase(&node->rb_node, &tree->rb_root);
		350	btrfs_backref_free_node(tree, node);
		351	}
		352
		353	void btrfs_backref_cleanup_node(struct btrfs_backref_cache *cache,
		354	struct btrfs_backref_node *node);
		355
		356	void btrfs_backref_release_cache(struct btrfs_backref_cache *cache);
		357
		358	static inline void btrfs_backref_panic(struct btrfs_fs_info *fs_info,
		359	u64 bytenr, int errno)
		360	{
		361	btrfs_panic(fs_info, errno,
		362	"Inconsistency in backref cache found at offset %llu",
		363	bytenr);
		364	}
		365
		366	int btrfs_backref_add_tree_node(struct btrfs_backref_cache *cache,
		367	struct btrfs_path *path,
		368	struct btrfs_backref_iter *iter,
		369	struct btrfs_key *node_key,
		370	struct btrfs_backref_node *cur);
		371
		372	int btrfs_backref_finish_upper_links(struct btrfs_backref_cache *cache,
		373	struct btrfs_backref_node *start);
		374
		375	void btrfs_backref_error_cleanup(struct btrfs_backref_cache *cache,
		376	struct btrfs_backref_node *node);
		377
81	#endif	378	#endif

fs/btrfs/block-group.c+154−79

 #include "disk-io.h"
 #include "free-space-cache.h"
 #include "free-space-tree.h"
-#include "disk-io.h"
 #include "volumes.h"
 #include "transaction.h"
 #include "ref-verify.h"
 	struct rb_node *parent = NULL;
 	struct btrfs_block_group *cache;
+	ASSERT(block_group->length != 0);
 	spin_lock(&info->block_group_cache_lock);
 	p = &info->block_group_cache_tree.rb_node;
 	}
 }
+static int remove_block_group_item(struct btrfs_trans_handle *trans,
+				   struct btrfs_path *path,
+				   struct btrfs_block_group *block_group)
+{
+	struct btrfs_fs_info *fs_info = trans->fs_info;
+	struct btrfs_root *root;
+	struct btrfs_key key;
+	int ret;
+	root = fs_info->extent_root;
+	key.objectid = block_group->start;
+	key.type = BTRFS_BLOCK_GROUP_ITEM_KEY;
+	key.offset = block_group->length;
+	ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
+	if (ret > 0)
+		ret = -ENOENT;
+	if (ret < 0)
+		return ret;
+	ret = btrfs_del_item(trans, root, path);
+	return ret;
+}
 int btrfs_remove_block_group(struct btrfs_trans_handle *trans,
 			     u64 group_start, struct extent_map *em)
 {
 	struct btrfs_fs_info *fs_info = trans->fs_info;
-	struct btrfs_root *root = fs_info->extent_root;
 	struct btrfs_path *path;
 	struct btrfs_block_group *block_group;
 	struct btrfs_free_cluster *cluster;
 	spin_unlock(&block_group->space_info->lock);
-	key.objectid = block_group->start;
-	key.type = BTRFS_BLOCK_GROUP_ITEM_KEY;
-	key.offset = block_group->length;
 	mutex_lock(&fs_info->chunk_mutex);
 	spin_lock(&block_group->lock);
 	block_group->removed = 1;
 	/*
-	 * At this point trimming can't start on this block group, because we
+	 * At this point trimming or scrub can't start on this block group,
-	 * removed the block group from the tree fs_info->block_group_cache_tree
+	 * because we removed the block group from the rbtree
-	 * so no one can't find it anymore and even if someone already got this
+	 * fs_info->block_group_cache_tree so no one can't find it anymore and
-	 * block group before we removed it from the rbtree, they have already
+	 * even if someone already got this block group before we removed it
-	 * incremented block_group->trimming - if they didn't, they won't find
+	 * from the rbtree, they have already incremented block_group->frozen -
-	 * any free space entries because we already removed them all when we
+	 * if they didn't, for the trimming case they won't find any free space
-	 * called btrfs_remove_free_space_cache().
+	 * entries because we already removed them all when we called
+	 * btrfs_remove_free_space_cache().
 	 *
 	 * And we must not remove the extent map from the fs_info->mapping_tree
 	 * to prevent the same logical address range and physical device space
-	 * ranges from being reused for a new block group. This is because our
+	 * ranges from being reused for a new block group. This is needed to
-	 * fs trim operation (btrfs_trim_fs() / btrfs_ioctl_fitrim()) is
+	 * avoid races with trimming and scrub.
+	 *
+	 * An fs trim operation (btrfs_trim_fs() / btrfs_ioctl_fitrim()) is
 	 * completely transactionless, so while it is trimming a range the
 	 * currently running transaction might finish and a new one start,
 	 * allowing for new block groups to be created that can reuse the same
 	 * in place until the extents have been discarded completely when
 	 * the transaction commit has completed.
 	 */
-	remove_em = (atomic_read(&block_group->trimming) == 0);
+	remove_em = (atomic_read(&block_group->frozen) == 0);
 	spin_unlock(&block_group->lock);
 	mutex_unlock(&fs_info->chunk_mutex);
 	/* Once for the block groups rbtree */
 	btrfs_put_block_group(block_group);
-	ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
+	ret = remove_block_group_item(trans, path, block_group);
-	if (ret > 0)
-		ret = -EIO;
 	if (ret < 0)
 		goto out;
-	ret = btrfs_del_item(trans, root, path);
-	if (ret)
-		goto out;
 	if (remove_em) {
 		struct extent_map_tree *em_tree;
 	free_extent_map(em);
 	return btrfs_start_transaction_fallback_global_rsv(fs_info->extent_root,
-							   num_items, 1);
+							   num_items);
 }
 /*
 		ret = clear_extent_bits(&prev_trans->pinned_extents, start, end,
 					EXTENT_DIRTY);
 		if (ret)
-			goto err;
+			goto out;
 	}
 	ret = clear_extent_bits(&trans->transaction->pinned_extents, start, end,
 				EXTENT_DIRTY);
-	if (ret)
+out:
-		goto err;
 	mutex_unlock(&fs_info->unused_bg_unpin_mutex);
 	if (prev_trans)
 		btrfs_put_transaction(prev_trans);
-	return true;
+	return ret == 0;
-err:
-	mutex_unlock(&fs_info->unused_bg_unpin_mutex);
-	if (prev_trans)
-		btrfs_put_transaction(prev_trans);
-	btrfs_dec_block_group_ro(bg);
-	return false;
 }
 /*
 		 * We could have pending pinned extents for this block group,
 		 * just delete them, we don't care about them anymore.
 		 */
-		if (!clean_pinned_extents(trans, block_group))
+		if (!clean_pinned_extents(trans, block_group)) {
+			btrfs_dec_block_group_ro(block_group);
 			goto end_trans;
+		}
 		/*
 		 * At this point, the block_group is read only and should fail
 		/* Implicit trim during transaction commit. */
 		if (trimming)
-			btrfs_get_block_group_trimming(block_group);
+			btrfs_freeze_block_group(block_group);
 		/*
 		 * Btrfs_remove_chunk will abort the transaction if things go
 		if (ret) {
 			if (trimming)
-				btrfs_put_block_group_trimming(block_group);
+				btrfs_unfreeze_block_group(block_group);
 			goto end_trans;
 		}
 }
 static struct btrfs_block_group *btrfs_create_block_group_cache(
-		struct btrfs_fs_info *fs_info, u64 start, u64 size)
+		struct btrfs_fs_info *fs_info, u64 start)
 {
 	struct btrfs_block_group *cache;
 	}
 	cache->start = start;
-	cache->length = size;
 	cache->fs_info = fs_info;
 	cache->full_stripe_len = btrfs_full_stripe_len(fs_info, start);
 	INIT_LIST_HEAD(&cache->dirty_list);
 	INIT_LIST_HEAD(&cache->io_list);
 	btrfs_init_free_space_ctl(cache);
-	atomic_set(&cache->trimming, 0);
+	atomic_set(&cache->frozen, 0);
 	mutex_init(&cache->free_space_lock);
 	btrfs_init_full_stripe_locks_tree(&cache->full_stripe_locks_root);
 	return ret;
 }
+static int read_block_group_item(struct btrfs_block_group *cache,
+				 struct btrfs_path *path,
+				 const struct btrfs_key *key)
+{
+	struct extent_buffer *leaf = path->nodes[0];
+	struct btrfs_block_group_item bgi;
+	int slot = path->slots[0];
+	cache->length = key->offset;
+	read_extent_buffer(leaf, &bgi, btrfs_item_ptr_offset(leaf, slot),
+			   sizeof(bgi));
+	cache->used = btrfs_stack_block_group_used(&bgi);
+	cache->flags = btrfs_stack_block_group_flags(&bgi);
+	return 0;
+}
 static int read_one_block_group(struct btrfs_fs_info *info,
 				struct btrfs_path *path,
 				const struct btrfs_key *key,
 				int need_clear)
 {
-	struct extent_buffer *leaf = path->nodes[0];
 	struct btrfs_block_group *cache;
 	struct btrfs_space_info *space_info;
-	struct btrfs_block_group_item bgi;
 	const bool mixed = btrfs_fs_incompat(info, MIXED_GROUPS);
-	int slot = path->slots[0];
 	int ret;
 	ASSERT(key->type == BTRFS_BLOCK_GROUP_ITEM_KEY);
-	cache = btrfs_create_block_group_cache(info, key->objectid, key->offset);
+	cache = btrfs_create_block_group_cache(info, key->objectid);
 	if (!cache)
 		return -ENOMEM;
+	ret = read_block_group_item(cache, path, key);
+	if (ret < 0)
+		goto error;
 	if (need_clear) {
 		/*
 		 * When we mount with old space cache, we need to
 		if (btrfs_test_opt(info, SPACE_CACHE))
 			cache->disk_cache_state = BTRFS_DC_CLEAR;
 	}
-	read_extent_buffer(leaf, &bgi, btrfs_item_ptr_offset(leaf, slot),
-			   sizeof(bgi));
-	cache->used = btrfs_stack_block_group_used(&bgi);
-	cache->flags = btrfs_stack_block_group_flags(&bgi);
 	if (!mixed && ((cache->flags & BTRFS_BLOCK_GROUP_METADATA) &&
 	    (cache->flags & BTRFS_BLOCK_GROUP_DATA))) {
 			btrfs_err(info,
 	 * are empty, and we can just add all the space in and be done with it.
 	 * This saves us _a_lot_ of time, particularly in the full case.
 	 */
-	if (key->offset == cache->used) {
+	if (cache->length == cache->used) {
 		cache->last_byte_to_unpin = (u64)-1;
 		cache->cached = BTRFS_CACHE_FINISHED;
 		btrfs_free_excluded_extents(cache);
 	} else if (cache->used == 0) {
 		cache->last_byte_to_unpin = (u64)-1;
 		cache->cached = BTRFS_CACHE_FINISHED;
-		add_new_free_space(cache, key->objectid,
+		add_new_free_space(cache, cache->start,
-				   key->objectid + key->offset);
+				   cache->start + cache->length);
 		btrfs_free_excluded_extents(cache);
 	}
 		goto error;
 	}
 	trace_btrfs_add_block_group(info, cache, 0);
-	btrfs_update_space_info(info, cache->flags, key->offset,
+	btrfs_update_space_info(info, cache->flags, cache->length,
 				cache->used, cache->bytes_super, &space_info);
 	cache->space_info = space_info;
 	path = btrfs_alloc_path();
 	if (!path)
 		return -ENOMEM;
-	path->reada = READA_FORWARD;
 	cache_gen = btrfs_super_cache_generation(info->super_copy);
 	if (btrfs_test_opt(info, SPACE_CACHE) &&
 	return ret;
 }
+static int insert_block_group_item(struct btrfs_trans_handle *trans,
+				   struct btrfs_block_group *block_group)
+{
+	struct btrfs_fs_info *fs_info = trans->fs_info;
+	struct btrfs_block_group_item bgi;
+	struct btrfs_root *root;
+	struct btrfs_key key;
+	spin_lock(&block_group->lock);
+	btrfs_set_stack_block_group_used(&bgi, block_group->used);
+	btrfs_set_stack_block_group_chunk_objectid(&bgi,
+				BTRFS_FIRST_CHUNK_TREE_OBJECTID);
+	btrfs_set_stack_block_group_flags(&bgi, block_group->flags);
+	key.objectid = block_group->start;
+	key.type = BTRFS_BLOCK_GROUP_ITEM_KEY;
+	key.offset = block_group->length;
+	spin_unlock(&block_group->lock);
+	root = fs_info->extent_root;
+	return btrfs_insert_item(trans, root, &key, &bgi, sizeof(bgi));
+}
 void btrfs_create_pending_block_groups(struct btrfs_trans_handle *trans)
 {
 	struct btrfs_fs_info *fs_info = trans->fs_info;
 	struct btrfs_block_group *block_group;
-	struct btrfs_root *extent_root = fs_info->extent_root;
-	struct btrfs_block_group_item item;
-	struct btrfs_key key;
 	int ret = 0;
 	if (!trans->can_flush_pending_bgs)
 		if (ret)
 			goto next;
-		spin_lock(&block_group->lock);
+		ret = insert_block_group_item(trans, block_group);
-		btrfs_set_stack_block_group_used(&item, block_group->used);
-		btrfs_set_stack_block_group_chunk_objectid(&item,
-				BTRFS_FIRST_CHUNK_TREE_OBJECTID);
-		btrfs_set_stack_block_group_flags(&item, block_group->flags);
-		key.objectid = block_group->start;
-		key.type = BTRFS_BLOCK_GROUP_ITEM_KEY;
-		key.offset = block_group->length;
-		spin_unlock(&block_group->lock);
-		ret = btrfs_insert_item(trans, extent_root, &key, &item,
-					sizeof(item));
 		if (ret)
 			btrfs_abort_transaction(trans, ret);
-		ret = btrfs_finish_chunk_alloc(trans, key.objectid, key.offset);
+		ret = btrfs_finish_chunk_alloc(trans, block_group->start,
+					block_group->length);
 		if (ret)
 			btrfs_abort_transaction(trans, ret);
 		add_block_group_free_space(trans, block_group);
 	btrfs_set_log_full_commit(trans);
-	cache = btrfs_create_block_group_cache(fs_info, chunk_offset, size);
+	cache = btrfs_create_block_group_cache(fs_info, chunk_offset);
 	if (!cache)
 		return -ENOMEM;
+	cache->length = size;
 	cache->used = bytes_used;
 	cache->flags = type;
 	cache->last_byte_to_unpin = (u64)-1;
 	spin_unlock(&sinfo->lock);
 }
-static int write_one_cache_group(struct btrfs_trans_handle *trans,
+static int update_block_group_item(struct btrfs_trans_handle *trans,
-				 struct btrfs_path *path,
+				   struct btrfs_path *path,
-				 struct btrfs_block_group *cache)
+				   struct btrfs_block_group *cache)
 {
 	struct btrfs_fs_info *fs_info = trans->fs_info;
 	int ret;
-	struct btrfs_root *extent_root = fs_info->extent_root;
+	struct btrfs_root *root = fs_info->extent_root;
 	unsigned long bi;
 	struct extent_buffer *leaf;
 	struct btrfs_block_group_item bgi;
 	key.type = BTRFS_BLOCK_GROUP_ITEM_KEY;
 	key.offset = cache->length;
-	ret = btrfs_search_slot(trans, extent_root, &key, path, 0, 1);
+	ret = btrfs_search_slot(trans, root, &key, path, 0, 1);
 	if (ret) {
 		if (ret > 0)
 			ret = -ENOENT;
 			}
 		}
 		if (!ret) {
-			ret = write_one_cache_group(trans, path, cache);
+			ret = update_block_group_item(trans, path, cache);
 			/*
 			 * Our block group might still be attached to the list
 			 * of new block groups in the transaction handle of some
 			}
 		}
 		if (!ret) {
-			ret = write_one_cache_group(trans, path, cache);
+			ret = update_block_group_item(trans, path, cache);
 			/*
 			 * One of the free space endio workers might have
 			 * created a new block group while updating a free space
 			if (ret == -ENOENT) {
 				wait_event(cur_trans->writer_wait,
 				   atomic_read(&cur_trans->num_writers) == 1);
-				ret = write_one_cache_group(trans, path, cache);
+				ret = update_block_group_item(trans, path, cache);
 			}
 			if (ret)
 				btrfs_abort_transaction(trans, ret);
 	}
 	return 0;
 }
+void btrfs_freeze_block_group(struct btrfs_block_group *cache)
+{
+	atomic_inc(&cache->frozen);
+}
+void btrfs_unfreeze_block_group(struct btrfs_block_group *block_group)
+{
+	struct btrfs_fs_info *fs_info = block_group->fs_info;
+	struct extent_map_tree *em_tree;
+	struct extent_map *em;
+	bool cleanup;
+	spin_lock(&block_group->lock);
+	cleanup = (atomic_dec_and_test(&block_group->frozen) &&
+		   block_group->removed);
+	spin_unlock(&block_group->lock);
+	if (cleanup) {
+		mutex_lock(&fs_info->chunk_mutex);
+		em_tree = &fs_info->mapping_tree;
+		write_lock(&em_tree->lock);
+		em = lookup_extent_mapping(em_tree, block_group->start,
+					   1);
+		BUG_ON(!em); /* logic error, can't happen */
+		remove_extent_mapping(em_tree, em);
+		write_unlock(&em_tree->lock);
+		mutex_unlock(&fs_info->chunk_mutex);
+		/* once for us and once for the tree */
+		free_extent_map(em);
+		free_extent_map(em);
+		/*
+		 * We may have left one free space entry and other possible
+		 * tasks trimming this block group have left 1 entry each one.
+		 * Free them if any.
+		 */
+		__btrfs_remove_free_space_cache(block_group->free_space_ctl);
+	}
+}

fs/btrfs/block-group.h+13−1

 	/* For read-only block groups */
 	struct list_head ro_list;
+	/*
+	 * When non-zero it means the block group's logical address and its
+	 * device extents can not be reused for future block group allocations
+	 * until the counter goes down to 0. This is to prevent them from being
+	 * reused while some task is still using the block group after it was
+	 * deleted - we want to make sure they can only be reused for new block
+	 * groups after that task is done with the deleted block group.
+	 */
+	atomic_t frozen;
 	/* For discard operations */
-	atomic_t trimming;
 	struct list_head discard_list;
 	int discard_index;
 	u64 discard_eligible_time;
 		cache->cached == BTRFS_CACHE_ERROR;
 }
+void btrfs_freeze_block_group(struct btrfs_block_group *cache);
+void btrfs_unfreeze_block_group(struct btrfs_block_group *cache);
 #ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS
 int btrfs_rmap_block(struct btrfs_fs_info *fs_info, u64 chunk_start,
 		     u64 physical, u64 **logical, int *naddrs, int *stripe_len);

fs/btrfs/block-rsv.c+4−1

 #include "block-rsv.h"
 #include "space-info.h"
 #include "transaction.h"
+#include "block-group.h"
 /*
  * HOW DO BLOCK RESERVES WORK
 	else
 		block_rsv->full = 0;
+	if (block_rsv->size >= sinfo->total_bytes)
+		sinfo->force_alloc = CHUNK_ALLOC_FORCE;
 	spin_unlock(&block_rsv->lock);
 	spin_unlock(&sinfo->lock);
 }
 	struct btrfs_fs_info *fs_info = root->fs_info;
 	struct btrfs_block_rsv *block_rsv = NULL;
-	if (test_bit(BTRFS_ROOT_REF_COWS, &root->state) ||
+	if (test_bit(BTRFS_ROOT_SHAREABLE, &root->state) ||
 	    (root == fs_info->csum_root && trans->adding_csums) ||
 	    (root == fs_info->uuid_root))
 		block_rsv = trans->block_rsv;

fs/btrfs/btrfs_inode.h+8−36

@@ -7,6 +7,7 @@ · 6 unmodified lines
7	#define BTRFS_INODE_H	7	#define BTRFS_INODE_H
8		8
9	#include <linux/hash.h>	9	#include <linux/hash.h>
		10	#include <linux/refcount.h>
10	#include "extent_map.h"	11	#include "extent_map.h"
11	#include "extent_io.h"	12	#include "extent_io.h"
12	#include "ordered-data.h"	13	#include "ordered-data.h"
@@ -27,7 +28,6 @@ enum { · 14 unmodified lines
27	BTRFS_INODE_NEEDS_FULL_SYNC,	28	BTRFS_INODE_NEEDS_FULL_SYNC,
28	BTRFS_INODE_COPY_EVERYTHING,	29	BTRFS_INODE_COPY_EVERYTHING,
29	BTRFS_INODE_IN_DELALLOC_LIST,	30	BTRFS_INODE_IN_DELALLOC_LIST,
30	BTRFS_INODE_READDIO_NEED_LOCK,
31	BTRFS_INODE_HAS_PROPS,	31	BTRFS_INODE_HAS_PROPS,
32	BTRFS_INODE_SNAPSHOT_FLUSH,	32	BTRFS_INODE_SNAPSHOT_FLUSH,
33	};	33	};
@@ -293,53 +293,25 @@ static inline int btrfs_inode_in_log(struct btrfs_inode *inode, u64 generation) · 259 unmodified lines
293	return ret;	293	return ret;
294	}	294	}
295		295
296	#define BTRFS_DIO_ORIG_BIO_SUBMITTED 0x1
297
298	struct btrfs_dio_private {	296	struct btrfs_dio_private {
299	struct inode *inode;	297	struct inode *inode;
300	unsigned long flags;
301	u64 logical_offset;	298	u64 logical_offset;
302	u64 disk_bytenr;	299	u64 disk_bytenr;
303	u64 bytes;	300	u64 bytes;
304	void *private;
305
306	/* number of bios pending for this dio */
307	atomic_t pending_bios;
308		301
309	/* IO errors */	302	/*
310	int errors;	303	* References to this structure. There is one reference per in-flight
311		304	* bio plus one while we're still setting up.
312	/* orig_bio is our btrfs_io_bio */	305	*/
313	struct bio *orig_bio;	306	refcount_t refs;
314		307
315	/* dio_bio came from fs/direct-io.c */	308	/* dio_bio came from fs/direct-io.c */
316	struct bio *dio_bio;	309	struct bio *dio_bio;
317		310
318	/*	311	/* Array of checksums */
319	* The original bio may be split to several sub-bios, this is	312	u8 csums[];
320	* done during endio of sub-bios
321	*/
322	blk_status_t (subio_endio)(struct inode , struct btrfs_io_bio *,
323	blk_status_t);
324	};	313	};
325		314
326	/*
327	* Disable DIO read nolock optimization, so new dio readers will be forced
328	* to grab i_mutex. It is used to avoid the endless truncate due to
329	* nonlocked dio read.
330	*/
331	static inline void btrfs_inode_block_unlocked_dio(struct btrfs_inode *inode)
332	{
333	set_bit(BTRFS_INODE_READDIO_NEED_LOCK, &inode->runtime_flags);
334	smp_mb();
335	}
336
337	static inline void btrfs_inode_resume_unlocked_dio(struct btrfs_inode *inode)
338	{
339	smp_mb__before_atomic();
340	clear_bit(BTRFS_INODE_READDIO_NEED_LOCK, &inode->runtime_flags);
341	}
342
343	/* Array of bytes with variable length, hexadecimal format 0x1234 */	315	/* Array of bytes with variable length, hexadecimal format 0x1234 */
344	#define CSUM_FMT "0x%*phN"	316	#define CSUM_FMT "0x%*phN"
345	#define CSUM_FMT_VALUE(size, bytes) size, bytes	317	#define CSUM_FMT_VALUE(size, bytes) size, bytes

fs/btrfs/compression.c+17−19

 	for (i = 0; i < cb->nr_pages; i++) {
 		page = cb->compressed_pages[i];
-		crypto_shash_init(shash);
 		kaddr = kmap_atomic(page);
-		crypto_shash_update(shash, kaddr, PAGE_SIZE);
+		crypto_shash_digest(shash, kaddr, PAGE_SIZE, csum);
 		kunmap_atomic(kaddr);
-		crypto_shash_final(shash, (u8 *)&csum);
 		if (memcmp(&csum, cb_sum, csum_size)) {
 			btrfs_print_data_csum_error(inode, disk_start,
 	}
 }
+/*
+ * Adjust @level according to the limits of the compression algorithm or
+ * fallback to default
+ */
+static unsigned int btrfs_compress_set_level(int type, unsigned level)
+{
+	const struct btrfs_compress_op *ops = btrfs_compress_op[type];
+	if (level == 0)
+		level = ops->default_level;
+	else
+		level = min(level, ops->max_level);
+	return level;
+}
 /*
  * Given an address space and start and length, compress the bytes into @pages
  * that are allocated on demand.
 	return level;
 }
-/*
- * Adjust @level according to the limits of the compression algorithm or
- * fallback to default
- */
-unsigned int btrfs_compress_set_level(int type, unsigned level)
-{
-	const struct btrfs_compress_op *ops = btrfs_compress_op[type];
-	if (level == 0)
-		level = ops->default_level;
-	else
-		level = min(level, ops->max_level);
-	return level;
-}

fs/btrfs/compression.h+0−2

@@ -140,8 +140,6 @@ extern const struct btrfs_compress_op btrfs_zstd_compress; · 139 unmodified lines
140	const char* btrfs_compress_type2str(enum btrfs_compression_type type);	140	const char* btrfs_compress_type2str(enum btrfs_compression_type type);
141	bool btrfs_compress_is_valid_type(const char *str, size_t len);	141	bool btrfs_compress_is_valid_type(const char *str, size_t len);
142		142
143	unsigned int btrfs_compress_set_level(int type, unsigned level);
144
145	int btrfs_compress_heuristic(struct inode *inode, u64 start, u64 end);	143	int btrfs_compress_heuristic(struct inode *inode, u64 start, u64 end);
146		144
147	#endif	145	#endif

fs/btrfs/ctree.c+76−104

 	return eb;
 }
-/* cowonly root (everything not a reference counted cow subvolume), just get
+/*
- * put onto a simple dirty list.  transaction.c walks this to make sure they
+ * Cowonly root (not-shareable trees, everything not subvolume or reloc roots),
- * get properly updated on disk.
+ * just get put onto a simple dirty list.  Transaction walks this list to make
+ * sure they get properly updated on disk.
  */
 static void add_root_to_dirty_list(struct btrfs_root *root)
 {
 	int level;
 	struct btrfs_disk_key disk_key;
-	WARN_ON(test_bit(BTRFS_ROOT_REF_COWS, &root->state) &&
+	WARN_ON(test_bit(BTRFS_ROOT_SHAREABLE, &root->state) &&
 		trans->transid != fs_info->running_transaction->transid);
-	WARN_ON(test_bit(BTRFS_ROOT_REF_COWS, &root->state) &&
+	WARN_ON(test_bit(BTRFS_ROOT_SHAREABLE, &root->state) &&
 		trans->transid != root->last_trans);
 	level = btrfs_header_level(buf);
 			      struct extent_buffer *buf)
 {
 	/*
-	 * Tree blocks not in reference counted trees and tree roots
+	 * Tree blocks not in shareable trees and tree roots are never shared.
-	 * are never shared. If a block was allocated after the last
+	 * If a block was allocated after the last snapshot and the block was
-	 * snapshot and the block was not allocated by tree relocation,
+	 * not allocated by tree relocation, we know the block is not shared.
-	 * we know the block is not shared.
 	 */
-	if (test_bit(BTRFS_ROOT_REF_COWS, &root->state) &&
+	if (test_bit(BTRFS_ROOT_SHAREABLE, &root->state) &&
 	    buf != root->node && buf != root->commit_root &&
 	    (btrfs_header_generation(buf) <=
 	     btrfs_root_last_snapshot(&root->root_item) ||
 	btrfs_assert_tree_locked(buf);
-	WARN_ON(test_bit(BTRFS_ROOT_REF_COWS, &root->state) &&
+	WARN_ON(test_bit(BTRFS_ROOT_SHAREABLE, &root->state) &&
 		trans->transid != fs_info->running_transaction->transid);
-	WARN_ON(test_bit(BTRFS_ROOT_REF_COWS, &root->state) &&
+	WARN_ON(test_bit(BTRFS_ROOT_SHAREABLE, &root->state) &&
 		trans->transid != root->last_trans);
 	level = btrfs_header_level(buf);
 		return ret;
 	}
-	if (test_bit(BTRFS_ROOT_REF_COWS, &root->state)) {
+	if (test_bit(BTRFS_ROOT_SHAREABLE, &root->state)) {
 		ret = btrfs_reloc_cow_block(trans, root, buf, cow);
 		if (ret) {
 			btrfs_abort_transaction(trans, ret);
 {
 	int low = 0;
 	int high = max;
-	int mid;
 	int ret;
-	struct btrfs_disk_key *tmp = NULL;
+	const int key_size = sizeof(struct btrfs_disk_key);
-	struct btrfs_disk_key unaligned;
-	unsigned long offset;
-	char *kaddr = NULL;
-	unsigned long map_start = 0;
-	unsigned long map_len = 0;
-	int err;
 	if (low > high) {
 		btrfs_err(eb->fs_info,
 	}
 	while (low < high) {
+		unsigned long oip;
+		unsigned long offset;
+		struct btrfs_disk_key *tmp;
+		struct btrfs_disk_key unaligned;
+		int mid;
 		mid = (low + high) / 2;
 		offset = p + mid * item_size;
+		oip = offset_in_page(offset);
-		if (!kaddr || offset < map_start ||
+		if (oip + key_size <= PAGE_SIZE) {
-		    (offset + sizeof(struct btrfs_disk_key)) >
+			const unsigned long idx = offset >> PAGE_SHIFT;
-		    map_start + map_len) {
+			char *kaddr = page_address(eb->pages[idx]);
-			err = map_private_extent_buffer(eb, offset,
-						sizeof(struct btrfs_disk_key),
-						&kaddr, &map_start, &map_len);
-			if (!err) {
-				tmp = (struct btrfs_disk_key *)(kaddr + offset -
-							map_start);
-			} else if (err == 1) {
-				read_extent_buffer(eb, &unaligned,
-						   offset, sizeof(unaligned));
-				tmp = &unaligned;
-			} else {
-				return err;
-			}
+			tmp = (struct btrfs_disk_key *)(kaddr + oip);
 		} else {
-			tmp = (struct btrfs_disk_key *)(kaddr + offset -
+			read_extent_buffer(eb, &unaligned, offset, key_size);
-							map_start);
+			tmp = &unaligned;
 		}
 		ret = comp_keys(tmp, key);
 		if (ret < 0)
  * leaves vs nodes
  */
 int btrfs_bin_search(struct extent_buffer *eb, const struct btrfs_key *key,
-		     int level, int *slot)
+		     int *slot)
 {
-	if (level == 0)
+	if (btrfs_header_level(eb) == 0)
 		return generic_bin_search(eb,
 					  offsetof(struct btrfs_leaf, items),
 					  sizeof(struct btrfs_item),
 	struct btrfs_fs_info *fs_info = root->fs_info;
 	u64 blocknr;
 	u64 gen;
-	struct extent_buffer *b = *eb_ret;
 	struct extent_buffer *tmp;
 	struct btrfs_key first_key;
 	int ret;
 	int parent_level;
-	blocknr = btrfs_node_blockptr(b, slot);
+	blocknr = btrfs_node_blockptr(*eb_ret, slot);
-	gen = btrfs_node_ptr_generation(b, slot);
+	gen = btrfs_node_ptr_generation(*eb_ret, slot);
-	parent_level = btrfs_header_level(b);
+	parent_level = btrfs_header_level(*eb_ret);
-	btrfs_node_key_to_cpu(b, &first_key, slot);
+	btrfs_node_key_to_cpu(*eb_ret, &first_key, slot);
 	tmp = find_extent_buffer(fs_info, blocknr);
 	if (tmp) {
 	return ret;
 }
-static int key_search(struct extent_buffer *b, const struct btrfs_key *key,
-		      int level, int *prev_cmp, int *slot)
-{
-	if (*prev_cmp != 0) {
-		*prev_cmp = btrfs_bin_search(b, key, level, slot);
-		return *prev_cmp;
-	}
-	*slot = 0;
-	return 0;
-}
 int btrfs_find_item(struct btrfs_root *fs_root, struct btrfs_path *path,
 		u64 iobjectid, u64 ioff, u8 key_type,
 		struct btrfs_key *found_key)
 			}
 		}
-		ret = key_search(b, key, level, &prev_cmp, &slot);
+		/*
-		if (ret < 0)
+		 * If btrfs_bin_search returns an exact match (prev_cmp == 0)
-			goto done;
+		 * we can safely assume the target key will always be in slot 0
+		 * on lower levels due to the invariants BTRFS' btree provides,
+		 * namely that a btrfs_key_ptr entry always points to the
+		 * lowest key in the child node, thus we can skip searching
+		 * lower levels
+		 */
+		if (prev_cmp == 0) {
+			slot = 0;
+			ret = 0;
+		} else {
+			ret = btrfs_bin_search(b, key, &slot);
+			prev_cmp = ret;
+			if (ret < 0)
+				goto done;
+		}
 		if (level == 0) {
 			p->slots[level] = slot;
 	int level;
 	int lowest_unlock = 1;
 	u8 lowest_level = 0;
-	int prev_cmp = -1;
 	lowest_level = p->lowest_level;
 	WARN_ON(p->nodes[0] != NULL);
 		 */
 		btrfs_unlock_up_safe(p, level + 1);
-		/*
+		ret = btrfs_bin_search(b, key, &slot);
-		 * Since we can unwind ebs we want to do a real search every
-		 * time.
-		 */
-		prev_cmp = -1;
-		ret = key_search(b, key, level, &prev_cmp, &slot);
 		if (ret < 0)
 			goto done;
 {
 	struct btrfs_item *start_item;
 	struct btrfs_item *end_item;
-	struct btrfs_map_token token;
 	int data_len;
 	int nritems = btrfs_header_nritems(l);
 	int end = min(nritems, start + nr) - 1;
 	if (!nr)
 		return 0;
-	btrfs_init_map_token(&token, l);
 	start_item = btrfs_item_nr(start);
 	end_item = btrfs_item_nr(end);
-	data_len = btrfs_token_item_offset(l, start_item, &token) +
+	data_len = btrfs_item_offset(l, start_item) +
-		btrfs_token_item_size(l, start_item, &token);
+		   btrfs_item_size(l, start_item);
-	data_len = data_len - btrfs_token_item_offset(l, end_item, &token);
+	data_len = data_len - btrfs_item_offset(l, end_item);
 	data_len += sizeof(struct btrfs_item) * nr;
 	WARN_ON(data_len < 0);
 	return data_len;
 	push_space = BTRFS_LEAF_DATA_SIZE(fs_info);
 	for (i = 0; i < right_nritems; i++) {
 		item = btrfs_item_nr(i);
-		push_space -= btrfs_token_item_size(right, item, &token);
+		push_space -= btrfs_token_item_size(&token, item);
-		btrfs_set_token_item_offset(right, item, push_space, &token);
+		btrfs_set_token_item_offset(&token, item, push_space);
 	}
 	left_nritems -= push_items;
 		item = btrfs_item_nr(i);
-		ioff = btrfs_token_item_offset(left, item, &token);
+		ioff = btrfs_token_item_offset(&token, item);
-		btrfs_set_token_item_offset(left, item,
+		btrfs_set_token_item_offset(&token, item,
-		      ioff - (BTRFS_LEAF_DATA_SIZE(fs_info) - old_left_item_size),
+		      ioff - (BTRFS_LEAF_DATA_SIZE(fs_info) - old_left_item_size));
-		      &token);
 	}
 	btrfs_set_header_nritems(left, old_left_nritems + push_items);
 	for (i = 0; i < right_nritems; i++) {
 		item = btrfs_item_nr(i);
-		push_space = push_space - btrfs_token_item_size(right,
+		push_space = push_space - btrfs_token_item_size(&token, item);
-								item, &token);
+		btrfs_set_token_item_offset(&token, item, push_space);
-		btrfs_set_token_item_offset(right, item, push_space, &token);
 	}
 	btrfs_mark_buffer_dirty(left);
 		struct btrfs_item *item = btrfs_item_nr(i);
 		u32 ioff;
-		ioff = btrfs_token_item_offset(right, item, &token);
+		ioff = btrfs_token_item_offset(&token, item);
-		btrfs_set_token_item_offset(right, item,
+		btrfs_set_token_item_offset(&token, item, ioff + rt_data_off);
-					    ioff + rt_data_off, &token);
 	}
 	btrfs_set_header_nritems(l, mid);
 		u32 ioff;
 		item = btrfs_item_nr(i);
-		ioff = btrfs_token_item_offset(leaf, item, &token);
+		ioff = btrfs_token_item_offset(&token, item);
-		btrfs_set_token_item_offset(leaf, item,
+		btrfs_set_token_item_offset(&token, item, ioff + size_diff);
-					    ioff + size_diff, &token);
 	}
 	/* shift the data */
 		u32 ioff;
 		item = btrfs_item_nr(i);
-		ioff = btrfs_token_item_offset(leaf, item, &token);
+		ioff = btrfs_token_item_offset(&token, item);
-		btrfs_set_token_item_offset(leaf, item,
+		btrfs_set_token_item_offset(&token, item, ioff - data_size);
-					    ioff - data_size, &token);
 	}
 	/* shift the data */
 			u32 ioff;
 			item = btrfs_item_nr(i);
-			ioff = btrfs_token_item_offset(leaf, item, &token);
+			ioff = btrfs_token_item_offset(&token, item);
-			btrfs_set_token_item_offset(leaf, item,
+			btrfs_set_token_item_offset(&token, item,
-						    ioff - total_data, &token);
+						    ioff - total_data);
 		}
 		/* shift the items */
 		memmove_extent_buffer(leaf, btrfs_item_nr_offset(slot + nr),
 		btrfs_cpu_key_to_disk(&disk_key, cpu_key + i);
 		btrfs_set_item_key(leaf, &disk_key, slot + i);
 		item = btrfs_item_nr(slot + i);
-		btrfs_set_token_item_offset(leaf, item,
+		btrfs_set_token_item_offset(&token, item, data_end - data_size[i]);
-					    data_end - data_size[i], &token);
 		data_end -= data_size[i];
-		btrfs_set_token_item_size(leaf, item, data_size[i], &token);
+		btrfs_set_token_item_size(&token, item, data_size[i]);
 	}
 	btrfs_set_header_nritems(leaf, nritems + nr);
 			u32 ioff;
 			item = btrfs_item_nr(i);
-			ioff = btrfs_token_item_offset(leaf, item, &token);
+			ioff = btrfs_token_item_offset(&token, item);
-			btrfs_set_token_item_offset(leaf, item,
+			btrfs_set_token_item_offset(&token, item, ioff + dsize);
-						    ioff + dsize, &token);
 		}
 		memmove_extent_buffer(leaf, btrfs_item_nr_offset(slot),
 	while (1) {
 		nritems = btrfs_header_nritems(cur);
 		level = btrfs_header_level(cur);
-		sret = btrfs_bin_search(cur, min_key, level, &slot);
+		sret = btrfs_bin_search(cur, min_key, &slot);
 		if (sret < 0) {
 			ret = sret;
 			goto out;

fs/btrfs/ctree.h+66−55

@@ -28,6 +28,7 @@ · 27 unmodified lines
28	#include <linux/dynamic_debug.h>	28	#include <linux/dynamic_debug.h>
29	#include <linux/refcount.h>	29	#include <linux/refcount.h>
30	#include <linux/crc32c.h>	30	#include <linux/crc32c.h>
		31	#include <linux/iomap.h>
31	#include "extent-io-tree.h"	32	#include "extent-io-tree.h"
32	#include "extent_io.h"	33	#include "extent_io.h"
33	#include "extent_map.h"	34	#include "extent_map.h"
@@ -582,6 +583,7 @@ struct btrfs_fs_info { · 548 unmodified lines
582	struct btrfs_root *quota_root;	583	struct btrfs_root *quota_root;
583	struct btrfs_root *uuid_root;	584	struct btrfs_root *uuid_root;
584	struct btrfs_root *free_space_root;	585	struct btrfs_root *free_space_root;
		586	struct btrfs_root *data_reloc_root;
585		587
586	/* the log root tree is a directory of all the other log roots */	588	/* the log root tree is a directory of all the other log roots */
587	struct btrfs_root *log_root_tree;	589	struct btrfs_root *log_root_tree;
@@ -758,7 +760,6 @@ struct btrfs_fs_info { · 170 unmodified lines
758	struct btrfs_workqueue *endio_workers;	760	struct btrfs_workqueue *endio_workers;
759	struct btrfs_workqueue *endio_meta_workers;	761	struct btrfs_workqueue *endio_meta_workers;
760	struct btrfs_workqueue *endio_raid56_workers;	762	struct btrfs_workqueue *endio_raid56_workers;
761	struct btrfs_workqueue *endio_repair_workers;
762	struct btrfs_workqueue *rmw_workers;	763	struct btrfs_workqueue *rmw_workers;
763	struct btrfs_workqueue *endio_meta_write_workers;	764	struct btrfs_workqueue *endio_meta_write_workers;
764	struct btrfs_workqueue *endio_write_workers;	765	struct btrfs_workqueue *endio_write_workers;
@@ -970,7 +971,28 @@ enum { · 205 unmodified lines
970	* is used to tell us when more checks are required	971	* is used to tell us when more checks are required
971	*/	972	*/
972	BTRFS_ROOT_IN_TRANS_SETUP,	973	BTRFS_ROOT_IN_TRANS_SETUP,
973	BTRFS_ROOT_REF_COWS,	974
		975	/*
		976	* Set if tree blocks of this root can be shared by other roots.
		977	* Only subvolume trees and their reloc trees have this bit set.
		978	* Conflicts with TRACK_DIRTY bit.
		979	*
		980	* This affects two things:
		981	*
		982	* - How balance works
		983	* For shareable roots, we need to use reloc tree and do path
		984	* replacement for balance, and need various pre/post hooks for
		985	* snapshot creation to handle them.
		986	*
		987	* While for non-shareable trees, we just simply do a tree search
		988	* with COW.
		989	*
		990	* - How dirty roots are tracked
		991	* For shareable roots, btrfs_record_root_in_trans() is needed to
		992	* track them, while non-subvolume roots have TRACK_DIRTY bit, they
		993	* don't need to set this manually.
		994	*/
		995	BTRFS_ROOT_SHAREABLE,
974	BTRFS_ROOT_TRACK_DIRTY,	996	BTRFS_ROOT_TRACK_DIRTY,
975	BTRFS_ROOT_IN_RADIX,	997	BTRFS_ROOT_IN_RADIX,
976	BTRFS_ROOT_ORPHAN_ITEM_INSERTED,	998	BTRFS_ROOT_ORPHAN_ITEM_INSERTED,
@@ -1056,7 +1078,7 @@ struct btrfs_root { · 79 unmodified lines
1056	struct btrfs_key defrag_progress;	1078	struct btrfs_key defrag_progress;
1057	struct btrfs_key defrag_max;	1079	struct btrfs_key defrag_max;
1058		1080
1059	/* the dirty list is only used by non-reference counted roots */	1081	/* The dirty list is only used by non-shareable roots */
1060	struct list_head dirty_list;	1082	struct list_head dirty_list;
1061		1083
1062	struct list_head root_list;	1084	struct list_head root_list;
@@ -1146,6 +1168,9 @@ struct btrfs_root { · 83 unmodified lines
1146	/* Record pairs of swapped blocks for qgroup */	1168	/* Record pairs of swapped blocks for qgroup */
1147	struct btrfs_qgroup_swapped_blocks swapped_blocks;	1169	struct btrfs_qgroup_swapped_blocks swapped_blocks;
1148		1170
		1171	/* Used only by log trees, when logging csum items */
		1172	struct extent_io_tree log_csum_range;
		1173
1149	#ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS	1174	#ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS
1150	u64 alloc_bytenr;	1175	u64 alloc_bytenr;
1151	#endif	1176	#endif
@@ -1341,7 +1366,7 @@ do { \ · 189 unmodified lines
1341	BTRFS_INODE_ROOT_ITEM_INIT)	1366	BTRFS_INODE_ROOT_ITEM_INIT)
1342		1367
1343	struct btrfs_map_token {	1368	struct btrfs_map_token {
1344	const struct extent_buffer *eb;	1369	struct extent_buffer *eb;
1345	char *kaddr;	1370	char *kaddr;
1346	unsigned long offset;	1371	unsigned long offset;
1347	};	1372	};
@@ -1353,7 +1378,8 @@ static inline void btrfs_init_map_token(struct btrfs_map_token *token, · 5 unmodified lines
1353	struct extent_buffer *eb)	1378	struct extent_buffer *eb)
1354	{	1379	{
1355	token->eb = eb;	1380	token->eb = eb;
1356	token->kaddr = NULL;	1381	token->kaddr = page_address(eb->pages[0]);
		1382	token->offset = 0;
1357	}	1383	}
1358		1384
1359	/* some macros to generate set/get functions for the struct fields. This	1385	/* some macros to generate set/get functions for the struct fields. This
@@ -1377,15 +1403,14 @@ static inline void btrfs_init_map_token(struct btrfs_map_token *token, · 17 unmodified lines
1377	sizeof(((type *)0)->member)))	1403	sizeof(((type *)0)->member)))
1378		1404
1379	#define DECLARE_BTRFS_SETGET_BITS(bits) \	1405	#define DECLARE_BTRFS_SETGET_BITS(bits) \
1380	u##bits btrfs_get_token_##bits(const struct extent_buffer *eb, \	1406	u##bits btrfs_get_token_##bits(struct btrfs_map_token *token, \
1381	const void *ptr, unsigned long off, \	1407	const void *ptr, unsigned long off); \
1382	struct btrfs_map_token *token); \	1408	void btrfs_set_token_##bits(struct btrfs_map_token *token, \
1383	void btrfs_set_token_##bits(struct extent_buffer eb, const void ptr, \	1409	const void *ptr, unsigned long off, \
1384	unsigned long off, u##bits val, \	1410	u##bits val); \
1385	struct btrfs_map_token *token); \
1386	u##bits btrfs_get_##bits(const struct extent_buffer *eb, \	1411	u##bits btrfs_get_##bits(const struct extent_buffer *eb, \
1387	const void *ptr, unsigned long off); \	1412	const void *ptr, unsigned long off); \
1388	void btrfs_set_##bits(struct extent_buffer eb, void ptr, \	1413	void btrfs_set_##bits(const struct extent_buffer eb, void ptr, \
1389	unsigned long off, u##bits val);	1414	unsigned long off, u##bits val);
1390		1415
1391	DECLARE_BTRFS_SETGET_BITS(8)	1416	DECLARE_BTRFS_SETGET_BITS(8)
@@ -1400,25 +1425,23 @@ static inline u##bits btrfs_##name(const struct extent_buffer *eb, \ · 8 unmodified lines
1400	BUILD_BUG_ON(sizeof(u##bits) != sizeof(((type *)0))->member); \	1425	BUILD_BUG_ON(sizeof(u##bits) != sizeof(((type *)0))->member); \
1401	return btrfs_get_##bits(eb, s, offsetof(type, member)); \	1426	return btrfs_get_##bits(eb, s, offsetof(type, member)); \
1402	} \	1427	} \
1403	static inline void btrfs_set_##name(struct extent_buffer eb, type s, \	1428	static inline void btrfs_set_##name(const struct extent_buffer eb, type s, \
1404	u##bits val) \	1429	u##bits val) \
1405	{ \	1430	{ \
1406	BUILD_BUG_ON(sizeof(u##bits) != sizeof(((type *)0))->member); \	1431	BUILD_BUG_ON(sizeof(u##bits) != sizeof(((type *)0))->member); \
1407	btrfs_set_##bits(eb, s, offsetof(type, member), val); \	1432	btrfs_set_##bits(eb, s, offsetof(type, member), val); \
1408	} \	1433	} \
1409	static inline u##bits btrfs_token_##name(const struct extent_buffer *eb,\	1434	static inline u##bits btrfs_token_##name(struct btrfs_map_token *token, \
1410	const type *s, \	1435	const type *s) \
1411	struct btrfs_map_token *token) \
1412	{ \	1436	{ \
1413	BUILD_BUG_ON(sizeof(u##bits) != sizeof(((type *)0))->member); \	1437	BUILD_BUG_ON(sizeof(u##bits) != sizeof(((type *)0))->member); \
1414	return btrfs_get_token_##bits(eb, s, offsetof(type, member), token); \	1438	return btrfs_get_token_##bits(token, s, offsetof(type, member));\
1415	} \	1439	} \
1416	static inline void btrfs_set_token_##name(struct extent_buffer *eb, \	1440	static inline void btrfs_set_token_##name(struct btrfs_map_token *token,\
1417	type *s, u##bits val, \	1441	type *s, u##bits val) \
1418	struct btrfs_map_token *token) \
1419	{ \	1442	{ \
1420	BUILD_BUG_ON(sizeof(u##bits) != sizeof(((type *)0))->member); \	1443	BUILD_BUG_ON(sizeof(u##bits) != sizeof(((type *)0))->member); \
1421	btrfs_set_token_##bits(eb, s, offsetof(type, member), val, token); \	1444	btrfs_set_token_##bits(token, s, offsetof(type, member), val); \
1422	}	1445	}
1423		1446
1424	#define BTRFS_SETGET_HEADER_FUNCS(name, type, member, bits) \	1447	#define BTRFS_SETGET_HEADER_FUNCS(name, type, member, bits) \
@@ -1428,7 +1451,7 @@ static inline u##bits btrfs_##name(const struct extent_buffer *eb) \ · 3 unmodified lines
1428	u##bits res = le##bits##_to_cpu(p->member); \	1451	u##bits res = le##bits##_to_cpu(p->member); \
1429	return res; \	1452	return res; \
1430	} \	1453	} \
1431	static inline void btrfs_set_##name(struct extent_buffer *eb, \	1454	static inline void btrfs_set_##name(const struct extent_buffer *eb, \
1432	u##bits val) \	1455	u##bits val) \
1433	{ \	1456	{ \
1434	type *p = page_address(eb->pages[0]); \	1457	type *p = page_address(eb->pages[0]); \
@@ -1446,7 +1469,7 @@ static inline void btrfs_set_##name(type *s, u##bits val) \ · 11 unmodified lines
1446	}	1469	}
1447		1470
1448		1471
1449	static inline u64 btrfs_device_total_bytes(struct extent_buffer *eb,	1472	static inline u64 btrfs_device_total_bytes(const struct extent_buffer *eb,
1450	struct btrfs_dev_item *s)	1473	struct btrfs_dev_item *s)
1451	{	1474	{
1452	BUILD_BUG_ON(sizeof(u64) !=	1475	BUILD_BUG_ON(sizeof(u64) !=
@@ -1454,7 +1477,7 @@ static inline u64 btrfs_device_total_bytes(struct extent_buffer *eb, · 1 unmodified line
1454	return btrfs_get_64(eb, s, offsetof(struct btrfs_dev_item,	1477	return btrfs_get_64(eb, s, offsetof(struct btrfs_dev_item,
1455	total_bytes));	1478	total_bytes));
1456	}	1479	}
1457	static inline void btrfs_set_device_total_bytes(struct extent_buffer *eb,	1480	static inline void btrfs_set_device_total_bytes(const struct extent_buffer *eb,
1458	struct btrfs_dev_item *s,	1481	struct btrfs_dev_item *s,
1459	u64 val)	1482	u64 val)
1460	{	1483	{
@@ -1558,13 +1581,13 @@ static inline char btrfs_stripe_dev_uuid_nr(struct btrfs_chunk c, int nr) · 97 unmodified lines
1558	return btrfs_stripe_dev_uuid(btrfs_stripe_nr(c, nr));	1581	return btrfs_stripe_dev_uuid(btrfs_stripe_nr(c, nr));
1559	}	1582	}
1560		1583
1561	static inline u64 btrfs_stripe_offset_nr(struct extent_buffer *eb,	1584	static inline u64 btrfs_stripe_offset_nr(const struct extent_buffer *eb,
1562	struct btrfs_chunk *c, int nr)	1585	struct btrfs_chunk *c, int nr)
1563	{	1586	{
1564	return btrfs_stripe_offset(eb, btrfs_stripe_nr(c, nr));	1587	return btrfs_stripe_offset(eb, btrfs_stripe_nr(c, nr));
1565	}	1588	}
1566		1589
1567	static inline u64 btrfs_stripe_devid_nr(struct extent_buffer *eb,	1590	static inline u64 btrfs_stripe_devid_nr(const struct extent_buffer *eb,
1568	struct btrfs_chunk *c, int nr)	1591	struct btrfs_chunk *c, int nr)
1569	{	1592	{
1570	return btrfs_stripe_devid(eb, btrfs_stripe_nr(c, nr));	1593	return btrfs_stripe_devid(eb, btrfs_stripe_nr(c, nr));
@@ -1644,31 +1667,21 @@ BTRFS_SETGET_FUNCS(dev_extent_chunk_objectid, struct btrfs_dev_extent, · 73 unmodified lines
1644	BTRFS_SETGET_FUNCS(dev_extent_chunk_offset, struct btrfs_dev_extent,	1667	BTRFS_SETGET_FUNCS(dev_extent_chunk_offset, struct btrfs_dev_extent,
1645	chunk_offset, 64);	1668	chunk_offset, 64);
1646	BTRFS_SETGET_FUNCS(dev_extent_length, struct btrfs_dev_extent, length, 64);	1669	BTRFS_SETGET_FUNCS(dev_extent_length, struct btrfs_dev_extent, length, 64);
1647
1648	static inline unsigned long btrfs_dev_extent_chunk_tree_uuid(struct btrfs_dev_extent *dev)
1649	{
1650	unsigned long ptr = offsetof(struct btrfs_dev_extent, chunk_tree_uuid);
1651	return (unsigned long)dev + ptr;
1652	}
1653
1654	BTRFS_SETGET_FUNCS(extent_refs, struct btrfs_extent_item, refs, 64);	1670	BTRFS_SETGET_FUNCS(extent_refs, struct btrfs_extent_item, refs, 64);
1655	BTRFS_SETGET_FUNCS(extent_generation, struct btrfs_extent_item,	1671	BTRFS_SETGET_FUNCS(extent_generation, struct btrfs_extent_item,
1656	generation, 64);	1672	generation, 64);
1657	BTRFS_SETGET_FUNCS(extent_flags, struct btrfs_extent_item, flags, 64);	1673	BTRFS_SETGET_FUNCS(extent_flags, struct btrfs_extent_item, flags, 64);
1658		1674
1659	BTRFS_SETGET_FUNCS(extent_refs_v0, struct btrfs_extent_item_v0, refs, 32);
1660
1661
1662	BTRFS_SETGET_FUNCS(tree_block_level, struct btrfs_tree_block_info, level, 8);	1675	BTRFS_SETGET_FUNCS(tree_block_level, struct btrfs_tree_block_info, level, 8);
1663		1676
1664	static inline void btrfs_tree_block_key(struct extent_buffer *eb,	1677	static inline void btrfs_tree_block_key(const struct extent_buffer *eb,
1665	struct btrfs_tree_block_info *item,	1678	struct btrfs_tree_block_info *item,
1666	struct btrfs_disk_key *key)	1679	struct btrfs_disk_key *key)
1667	{	1680	{
1668	read_eb_member(eb, item, struct btrfs_tree_block_info, key, key);	1681	read_eb_member(eb, item, struct btrfs_tree_block_info, key, key);
1669	}	1682	}
1670		1683
1671	static inline void btrfs_set_tree_block_key(struct extent_buffer *eb,	1684	static inline void btrfs_set_tree_block_key(const struct extent_buffer *eb,
1672	struct btrfs_tree_block_info *item,	1685	struct btrfs_tree_block_info *item,
1673	struct btrfs_disk_key *key)	1686	struct btrfs_disk_key *key)
1674	{	1687	{
@@ -1706,12 +1719,6 @@ static inline u32 btrfs_extent_inline_ref_size(int type) · 31 unmodified lines
1706	return 0;	1719	return 0;
1707	}	1720	}
1708		1721
1709	BTRFS_SETGET_FUNCS(ref_root_v0, struct btrfs_extent_ref_v0, root, 64);
1710	BTRFS_SETGET_FUNCS(ref_generation_v0, struct btrfs_extent_ref_v0,
1711	generation, 64);
1712	BTRFS_SETGET_FUNCS(ref_objectid_v0, struct btrfs_extent_ref_v0, objectid, 64);
1713	BTRFS_SETGET_FUNCS(ref_count_v0, struct btrfs_extent_ref_v0, count, 32);
1714
1715	/* struct btrfs_node */	1722	/* struct btrfs_node */
1716	BTRFS_SETGET_FUNCS(key_blockptr, struct btrfs_key_ptr, blockptr, 64);	1723	BTRFS_SETGET_FUNCS(key_blockptr, struct btrfs_key_ptr, blockptr, 64);
1717	BTRFS_SETGET_FUNCS(key_generation, struct btrfs_key_ptr, generation, 64);	1724	BTRFS_SETGET_FUNCS(key_generation, struct btrfs_key_ptr, generation, 64);
@@ -1720,7 +1727,7 @@ BTRFS_SETGET_STACK_FUNCS(stack_key_blockptr, struct btrfs_key_ptr, · 2 unmodified lines
1720	BTRFS_SETGET_STACK_FUNCS(stack_key_generation, struct btrfs_key_ptr,	1727	BTRFS_SETGET_STACK_FUNCS(stack_key_generation, struct btrfs_key_ptr,
1721	generation, 64);	1728	generation, 64);
1722		1729
1723	static inline u64 btrfs_node_blockptr(struct extent_buffer *eb, int nr)	1730	static inline u64 btrfs_node_blockptr(const struct extent_buffer *eb, int nr)
1724	{	1731	{
1725	unsigned long ptr;	1732	unsigned long ptr;
1726	ptr = offsetof(struct btrfs_node, ptrs) +	1733	ptr = offsetof(struct btrfs_node, ptrs) +
@@ -1728,7 +1735,7 @@ static inline u64 btrfs_node_blockptr(struct extent_buffer *eb, int nr) · 1 unmodified line
1728	return btrfs_key_blockptr(eb, (struct btrfs_key_ptr *)ptr);	1735	return btrfs_key_blockptr(eb, (struct btrfs_key_ptr *)ptr);
1729	}	1736	}
1730		1737
1731	static inline void btrfs_set_node_blockptr(struct extent_buffer *eb,	1738	static inline void btrfs_set_node_blockptr(const struct extent_buffer *eb,
1732	int nr, u64 val)	1739	int nr, u64 val)
1733	{	1740	{
1734	unsigned long ptr;	1741	unsigned long ptr;
@@ -1737,7 +1744,7 @@ static inline void btrfs_set_node_blockptr(struct extent_buffer *eb, · 2 unmodified lines
1737	btrfs_set_key_blockptr(eb, (struct btrfs_key_ptr *)ptr, val);	1744	btrfs_set_key_blockptr(eb, (struct btrfs_key_ptr *)ptr, val);
1738	}	1745	}
1739		1746
1740	static inline u64 btrfs_node_ptr_generation(struct extent_buffer *eb, int nr)	1747	static inline u64 btrfs_node_ptr_generation(const struct extent_buffer *eb, int nr)
1741	{	1748	{
1742	unsigned long ptr;	1749	unsigned long ptr;
1743	ptr = offsetof(struct btrfs_node, ptrs) +	1750	ptr = offsetof(struct btrfs_node, ptrs) +
@@ -1745,7 +1752,7 @@ static inline u64 btrfs_node_ptr_generation(struct extent_buffer *eb, int nr) · 1 unmodified line
1745	return btrfs_key_generation(eb, (struct btrfs_key_ptr *)ptr);	1752	return btrfs_key_generation(eb, (struct btrfs_key_ptr *)ptr);
1746	}	1753	}
1747		1754
1748	static inline void btrfs_set_node_ptr_generation(struct extent_buffer *eb,	1755	static inline void btrfs_set_node_ptr_generation(const struct extent_buffer *eb,
1749	int nr, u64 val)	1756	int nr, u64 val)
1750	{	1757	{
1751	unsigned long ptr;	1758	unsigned long ptr;
@@ -1763,7 +1770,7 @@ static inline unsigned long btrfs_node_key_ptr_offset(int nr) · 11 unmodified lines
1763	void btrfs_node_key(const struct extent_buffer *eb,	1770	void btrfs_node_key(const struct extent_buffer *eb,
1764	struct btrfs_disk_key *disk_key, int nr);	1771	struct btrfs_disk_key *disk_key, int nr);
1765		1772
1766	static inline void btrfs_set_node_key(struct extent_buffer *eb,	1773	static inline void btrfs_set_node_key(const struct extent_buffer *eb,
1767	struct btrfs_disk_key *disk_key, int nr)	1774	struct btrfs_disk_key *disk_key, int nr)
1768	{	1775	{
1769	unsigned long ptr;	1776	unsigned long ptr;
@@ -2498,8 +2505,6 @@ int btrfs_inc_extent_ref(struct btrfs_trans_handle *trans, · 728 unmodified lines
2498	struct btrfs_ref *generic_ref);	2505	struct btrfs_ref *generic_ref);
2499		2506
2500	int btrfs_extent_readonly(struct btrfs_fs_info *fs_info, u64 bytenr);	2507	int btrfs_extent_readonly(struct btrfs_fs_info *fs_info, u64 bytenr);
2501	void btrfs_get_block_group_trimming(struct btrfs_block_group *cache);
2502	void btrfs_put_block_group_trimming(struct btrfs_block_group *cache);
2503	void btrfs_clear_space_info_full(struct btrfs_fs_info *info);	2508	void btrfs_clear_space_info_full(struct btrfs_fs_info *info);
2504		2509
2505	enum btrfs_reserve_flush_enum {	2510	enum btrfs_reserve_flush_enum {
@@ -2512,6 +2517,7 @@ enum btrfs_reserve_flush_enum { · 6 unmodified lines
2512	BTRFS_RESERVE_FLUSH_LIMIT,	2517	BTRFS_RESERVE_FLUSH_LIMIT,
2513	BTRFS_RESERVE_FLUSH_EVICT,	2518	BTRFS_RESERVE_FLUSH_EVICT,
2514	BTRFS_RESERVE_FLUSH_ALL,	2519	BTRFS_RESERVE_FLUSH_ALL,
		2520	BTRFS_RESERVE_FLUSH_ALL_STEAL,
2515	};	2521	};
2516		2522
2517	enum btrfs_flush_state {	2523	enum btrfs_flush_state {
@@ -2551,7 +2557,7 @@ void btrfs_wait_for_snapshot_creation(struct btrfs_root *root); · 33 unmodified lines
2551		2557
2552	/* ctree.c */	2558	/* ctree.c */
2553	int btrfs_bin_search(struct extent_buffer eb, const struct btrfs_key key,	2559	int btrfs_bin_search(struct extent_buffer eb, const struct btrfs_key key,
2554	int level, int *slot);	2560	int *slot);
2555	int __pure btrfs_comp_cpu_keys(const struct btrfs_key k1, const struct btrfs_key k2);	2561	int __pure btrfs_comp_cpu_keys(const struct btrfs_key k1, const struct btrfs_key k2);
2556	int btrfs_previous_item(struct btrfs_root *root,	2562	int btrfs_previous_item(struct btrfs_root *root,
2557	struct btrfs_path *path, u64 min_objectid,	2563	struct btrfs_path *path, u64 min_objectid,
@@ -2896,10 +2902,9 @@ void btrfs_free_inode(struct inode *inode); · 338 unmodified lines
2896	int btrfs_drop_inode(struct inode *inode);	2902	int btrfs_drop_inode(struct inode *inode);
2897	int __init btrfs_init_cachep(void);	2903	int __init btrfs_init_cachep(void);
2898	void __cold btrfs_destroy_cachep(void);	2904	void __cold btrfs_destroy_cachep(void);
2899	struct inode btrfs_iget_path(struct super_block s, struct btrfs_key *location,	2905	struct inode btrfs_iget_path(struct super_block s, u64 ino,
2900	struct btrfs_root root, struct btrfs_path path);	2906	struct btrfs_root root, struct btrfs_path path);
2901	struct inode btrfs_iget(struct super_block s, struct btrfs_key *location,	2907	struct inode btrfs_iget(struct super_block s, u64 ino, struct btrfs_root *root);
2902	struct btrfs_root *root);
2903	struct extent_map btrfs_get_extent(struct btrfs_inode inode,	2908	struct extent_map btrfs_get_extent(struct btrfs_inode inode,
2904	struct page *page, size_t pg_offset,	2909	struct page *page, size_t pg_offset,
2905	u64 start, u64 end);	2910	u64 start, u64 end);
@@ -2929,6 +2934,9 @@ int btrfs_writepage_cow_fixup(struct page *page, u64 start, u64 end); · 23 unmodified lines
2929	void btrfs_writepage_endio_finish_ordered(struct page *page, u64 start,	2934	void btrfs_writepage_endio_finish_ordered(struct page *page, u64 start,
2930	u64 end, int uptodate);	2935	u64 end, int uptodate);
2931	extern const struct dentry_operations btrfs_dentry_operations;	2936	extern const struct dentry_operations btrfs_dentry_operations;
		2937	ssize_t btrfs_direct_IO(struct kiocb iocb, struct iov_iter iter);
		2938	extern const struct iomap_ops btrfs_dio_iomap_ops;
		2939	extern const struct iomap_dio_ops btrfs_dops;
2932		2940
2933	/* ioctl.c */	2941	/* ioctl.c */
2934	long btrfs_ioctl(struct file *file, unsigned int cmd, unsigned long arg);	2942	long btrfs_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
@@ -3381,6 +3389,9 @@ void btrfs_reloc_pre_snapshot(struct btrfs_pending_snapshot *pending, · 446 unmodified lines
3381	int btrfs_reloc_post_snapshot(struct btrfs_trans_handle *trans,	3389	int btrfs_reloc_post_snapshot(struct btrfs_trans_handle *trans,
3382	struct btrfs_pending_snapshot *pending);	3390	struct btrfs_pending_snapshot *pending);
3383	int btrfs_should_cancel_balance(struct btrfs_fs_info *fs_info);	3391	int btrfs_should_cancel_balance(struct btrfs_fs_info *fs_info);
		3392	struct btrfs_root find_reloc_root(struct btrfs_fs_info fs_info,
		3393	u64 bytenr);
		3394	int btrfs_should_ignore_reloc_root(struct btrfs_root *root);
3384		3395
3385	/* scrub.c */	3396	/* scrub.c */
3386	int btrfs_scrub_dev(struct btrfs_fs_info *fs_info, u64 devid, u64 start,	3397	int btrfs_scrub_dev(struct btrfs_fs_info *fs_info, u64 devid, u64 start,

fs/btrfs/disk-io.c+51−42

 	SHASH_DESC_ON_STACK(shash, fs_info->csum_shash);
 	shash->tfm = fs_info->csum_shash;
-	crypto_shash_init(shash);
 	/*
 	 * The super_block structure does not span the whole
 	 * BTRFS_SUPER_INFO_SIZE range, we expect that the unused space is
 	 * filled with zeros and is included in the checksum.
 	 */
-	crypto_shash_update(shash, raw_disk_sb + BTRFS_CSUM_SIZE,
+	crypto_shash_digest(shash, raw_disk_sb + BTRFS_CSUM_SIZE,
-			    BTRFS_SUPER_INFO_SIZE - BTRFS_CSUM_SIZE);
+			    BTRFS_SUPER_INFO_SIZE - BTRFS_CSUM_SIZE, result);
-	crypto_shash_final(shash, result);
 	if (memcmp(disk_sb->csum, result, btrfs_super_csum_size(disk_sb)))
 		return 1;
 		else
 			wq = fs_info->endio_write_workers;
 	} else {
-		if (unlikely(end_io_wq->metadata == BTRFS_WQ_ENDIO_DIO_REPAIR))
+		if (end_io_wq->metadata == BTRFS_WQ_ENDIO_RAID56)
-			wq = fs_info->endio_repair_workers;
-		else if (end_io_wq->metadata == BTRFS_WQ_ENDIO_RAID56)
 			wq = fs_info->endio_raid56_workers;
 		else if (end_io_wq->metadata)
 			wq = fs_info->endio_meta_workers;
 	root->log_transid = 0;
 	root->log_transid_committed = -1;
 	root->last_log_commit = 0;
-	if (!dummy)
+	if (!dummy) {
 		extent_io_tree_init(fs_info, &root->dirty_log_pages,
 				    IO_TREE_ROOT_DIRTY_LOG_PAGES, NULL);
+		extent_io_tree_init(fs_info, &root->log_csum_range,
+				    IO_TREE_LOG_CSUM_RANGE, NULL);
+	}
 	memset(&root->root_key, 0, sizeof(root->root_key));
 	memset(&root->root_item, 0, sizeof(root->root_item));
 	root->root_key.offset = BTRFS_TREE_LOG_OBJECTID;
 	/*
-	 * DON'T set REF_COWS for log trees
+	 * DON'T set SHAREABLE bit for log trees.
 	 *
-	 * log trees do not get reference counted because they go away
+	 * Log trees are not exposed to user space thus can't be snapshotted,
-	 * before a real commit is actually done.  They do store pointers
+	 * and they go away before a real commit is actually done.
-	 * to file data extents, and those reference counts still get
+	 *
-	 * updated (along with back refs to the log tree).
+	 * They do store pointers to file data extents, and those reference
+	 * counts still get updated (along with back refs to the log tree).
 	 */
 	leaf = btrfs_alloc_tree_block(trans, root, 0, BTRFS_TREE_LOG_OBJECTID,
 	if (ret)
 		goto fail;
-	if (root->root_key.objectid != BTRFS_TREE_LOG_OBJECTID) {
+	if (root->root_key.objectid != BTRFS_TREE_LOG_OBJECTID &&
-		set_bit(BTRFS_ROOT_REF_COWS, &root->state);
+	    root->root_key.objectid != BTRFS_DATA_RELOC_TREE_OBJECTID) {
+		set_bit(BTRFS_ROOT_SHAREABLE, &root->state);
 		btrfs_check_and_init_root_item(&root->root_item);
 	}
 	btrfs_put_root(fs_info->uuid_root);
 	btrfs_put_root(fs_info->free_space_root);
 	btrfs_put_root(fs_info->fs_root);
+	btrfs_put_root(fs_info->data_reloc_root);
 	btrfs_check_leaked_roots(fs_info);
 	btrfs_extent_buffer_leak_debug_check(fs_info);
 	kfree(fs_info->super_copy);
 struct btrfs_root *btrfs_get_fs_root(struct btrfs_fs_info *fs_info,
-				     struct btrfs_key *location,
+				     u64 objectid, bool check_ref)
-				     bool check_ref)
 {
 	struct btrfs_root *root;
 	struct btrfs_path *path;
 	struct btrfs_key key;
 	int ret;
-	if (location->objectid == BTRFS_ROOT_TREE_OBJECTID)
+	if (objectid == BTRFS_ROOT_TREE_OBJECTID)
 		return btrfs_grab_root(fs_info->tree_root);
-	if (location->objectid == BTRFS_EXTENT_TREE_OBJECTID)
+	if (objectid == BTRFS_EXTENT_TREE_OBJECTID)
 		return btrfs_grab_root(fs_info->extent_root);
-	if (location->objectid == BTRFS_CHUNK_TREE_OBJECTID)
+	if (objectid == BTRFS_CHUNK_TREE_OBJECTID)
 		return btrfs_grab_root(fs_info->chunk_root);
-	if (location->objectid == BTRFS_DEV_TREE_OBJECTID)
+	if (objectid == BTRFS_DEV_TREE_OBJECTID)
 		return btrfs_grab_root(fs_info->dev_root);
-	if (location->objectid == BTRFS_CSUM_TREE_OBJECTID)
+	if (objectid == BTRFS_CSUM_TREE_OBJECTID)
 		return btrfs_grab_root(fs_info->csum_root);
-	if (location->objectid == BTRFS_QUOTA_TREE_OBJECTID)
+	if (objectid == BTRFS_QUOTA_TREE_OBJECTID)
 		return btrfs_grab_root(fs_info->quota_root) ?
 			fs_info->quota_root : ERR_PTR(-ENOENT);
-	if (location->objectid == BTRFS_UUID_TREE_OBJECTID)
+	if (objectid == BTRFS_UUID_TREE_OBJECTID)
 		return btrfs_grab_root(fs_info->uuid_root) ?
 			fs_info->uuid_root : ERR_PTR(-ENOENT);
-	if (location->objectid == BTRFS_FREE_SPACE_TREE_OBJECTID)
+	if (objectid == BTRFS_FREE_SPACE_TREE_OBJECTID)
 		return btrfs_grab_root(fs_info->free_space_root) ?
 			fs_info->free_space_root : ERR_PTR(-ENOENT);
 again:
-	root = btrfs_lookup_fs_root(fs_info, location->objectid);
+	root = btrfs_lookup_fs_root(fs_info, objectid);
 	if (root) {
 		if (check_ref && btrfs_root_refs(&root->root_item) == 0) {
 			btrfs_put_root(root);
 		return root;
 	}
-	root = btrfs_read_tree_root(fs_info->tree_root, location);
+	key.objectid = objectid;
+	key.type = BTRFS_ROOT_ITEM_KEY;
+	key.offset = (u64)-1;
+	root = btrfs_read_tree_root(fs_info->tree_root, &key);
 	if (IS_ERR(root))
 		return root;
 	}
 	key.objectid = BTRFS_ORPHAN_OBJECTID;
 	key.type = BTRFS_ORPHAN_ITEM_KEY;
-	key.offset = location->objectid;
+	key.offset = objectid;
 	ret = btrfs_search_slot(NULL, fs_info->tree_root, &key, path, 0, 0);
 	btrfs_free_path(path);
 	btrfs_destroy_workqueue(fs_info->workers);
 	btrfs_destroy_workqueue(fs_info->endio_workers);
 	btrfs_destroy_workqueue(fs_info->endio_raid56_workers);
-	btrfs_destroy_workqueue(fs_info->endio_repair_workers);
 	btrfs_destroy_workqueue(fs_info->rmw_workers);
 	btrfs_destroy_workqueue(fs_info->endio_write_workers);
 	btrfs_destroy_workqueue(fs_info->endio_freespace_worker);
 	free_root_extent_buffers(info->quota_root);
 	free_root_extent_buffers(info->uuid_root);
 	free_root_extent_buffers(info->fs_root);
+	free_root_extent_buffers(info->data_reloc_root);
 	if (free_chunk_root)
 		free_root_extent_buffers(info->chunk_root);
 	free_root_extent_buffers(info->free_space_root);
 	if (refcount_dec_and_test(&root->refs)) {
 		WARN_ON(!RB_EMPTY_ROOT(&root->inode_tree));
+		WARN_ON(test_bit(BTRFS_ROOT_DEAD_RELOC_TREE, &root->state));
 		if (root->anon_dev)
 			free_anon_bdev(root->anon_dev);
 		btrfs_drew_lock_destroy(&root->snapshot_lock);
 	fs_info->endio_raid56_workers =
 		btrfs_alloc_workqueue(fs_info, "endio-raid56", flags,
 				      max_active, 4);
-	fs_info->endio_repair_workers =
-		btrfs_alloc_workqueue(fs_info, "endio-repair", flags, 1, 0);
 	fs_info->rmw_workers =
 		btrfs_alloc_workqueue(fs_info, "rmw", flags, max_active, 2);
 	fs_info->endio_write_workers =
 	      fs_info->flush_workers &&
 	      fs_info->endio_workers && fs_info->endio_meta_workers &&
 	      fs_info->endio_meta_write_workers &&
-	      fs_info->endio_repair_workers &&
 	      fs_info->endio_write_workers && fs_info->endio_raid56_workers &&
 	      fs_info->endio_freespace_worker && fs_info->rmw_workers &&
 	      fs_info->caching_workers && fs_info->readahead_workers &&
 	set_bit(BTRFS_ROOT_TRACK_DIRTY, &root->state);
 	fs_info->csum_root = root;
+	/*
+	 * This tree can share blocks with some other fs tree during relocation
+	 * and we need a proper setup by btrfs_get_fs_root
+	 */
+	root = btrfs_get_fs_root(tree_root->fs_info,
+				 BTRFS_DATA_RELOC_TREE_OBJECTID, true);
+	if (IS_ERR(root)) {
+		ret = PTR_ERR(root);
+		goto out;
+	}
+	set_bit(BTRFS_ROOT_TRACK_DIRTY, &root->state);
+	fs_info->data_reloc_root = root;
 	location.objectid = BTRFS_QUOTA_TREE_OBJECTID;
 	root = btrfs_read_tree_root(tree_root, &location);
 	if (!IS_ERR(root)) {
 	u64 generation;
 	u64 features;
 	u16 csum_type;
-	struct btrfs_key location;
 	struct btrfs_super_block *disk_super;
 	struct btrfs_fs_info *fs_info = btrfs_sb(sb);
 	struct btrfs_root *tree_root;
 		}
 	}
-	location.objectid = BTRFS_FS_TREE_OBJECTID;
+	fs_info->fs_root = btrfs_get_fs_root(fs_info, BTRFS_FS_TREE_OBJECTID, true);
-	location.type = BTRFS_ROOT_ITEM_KEY;
-	location.offset = 0;
-	fs_info->fs_root = btrfs_get_fs_root(fs_info, &location, true);
 	if (IS_ERR(fs_info->fs_root)) {
 		err = PTR_ERR(fs_info->fs_root);
 		btrfs_warn(fs_info, "failed to read fs tree: %d", err);
 		btrfs_set_super_bytenr(sb, bytenr);
-		crypto_shash_init(shash);
+		crypto_shash_digest(shash, (const char *)sb + BTRFS_CSUM_SIZE,
-		crypto_shash_update(shash, (const char *)sb + BTRFS_CSUM_SIZE,
+				    BTRFS_SUPER_INFO_SIZE - BTRFS_CSUM_SIZE,
-				    BTRFS_SUPER_INFO_SIZE - BTRFS_CSUM_SIZE);
+				    sb->csum);
-		crypto_shash_final(shash, sb->csum);
 		page = find_or_create_page(mapping, bytenr >> PAGE_SHIFT,
 					   GFP_NOFS);

fs/btrfs/disk-io.h+1−3

 	BTRFS_WQ_ENDIO_METADATA,
 	BTRFS_WQ_ENDIO_FREE_SPACE,
 	BTRFS_WQ_ENDIO_RAID56,
-	BTRFS_WQ_ENDIO_DIO_REPAIR,
 };
 static inline u64 btrfs_sb_offset(int mirror)
 void btrfs_free_fs_roots(struct btrfs_fs_info *fs_info);
 struct btrfs_root *btrfs_get_fs_root(struct btrfs_fs_info *fs_info,
-				     struct btrfs_key *key,
+				     u64 objectid, bool check_ref);
-				     bool check_ref);
 void btrfs_free_fs_info(struct btrfs_fs_info *fs_info);
 int btrfs_cleanup_fs_roots(struct btrfs_fs_info *fs_info);

fs/btrfs/export.c+3−14

 	struct btrfs_fs_info *fs_info = btrfs_sb(sb);
 	struct btrfs_root *root;
 	struct inode *inode;
-	struct btrfs_key key;
 	if (objectid < BTRFS_FIRST_FREE_OBJECTID)
 		return ERR_PTR(-ESTALE);
-	key.objectid = root_objectid;
+	root = btrfs_get_fs_root(fs_info, root_objectid, true);
-	key.type = BTRFS_ROOT_ITEM_KEY;
-	key.offset = (u64)-1;
-	root = btrfs_get_fs_root(fs_info, &key, true);
 	if (IS_ERR(root))
 		return ERR_CAST(root);
-	key.objectid = objectid;
+	inode = btrfs_iget(sb, objectid, root);
-	key.type = BTRFS_INODE_ITEM_KEY;
-	key.offset = 0;
-	inode = btrfs_iget(sb, &key, root);
 	btrfs_put_root(root);
 	if (IS_ERR(inode))
 		return ERR_CAST(inode);
 					found_key.offset, 0, 0);
 	}
-	key.type = BTRFS_INODE_ITEM_KEY;
+	return d_obtain_alias(btrfs_iget(fs_info->sb, key.objectid, root));
-	key.offset = 0;
-	return d_obtain_alias(btrfs_iget(fs_info->sb, &key, root));
 fail:
 	btrfs_free_path(path);
 	return ERR_PTR(ret);

fs/btrfs/extent-io-tree.h+1−0

@@ -44,6 +44,7 @@ enum { · 43 unmodified lines
44	IO_TREE_TRANS_DIRTY_PAGES,	44	IO_TREE_TRANS_DIRTY_PAGES,
45	IO_TREE_ROOT_DIRTY_LOG_PAGES,	45	IO_TREE_ROOT_DIRTY_LOG_PAGES,
46	IO_TREE_INODE_FILE_EXTENT,	46	IO_TREE_INODE_FILE_EXTENT,
		47	IO_TREE_LOG_CSUM_RANGE,
47	IO_TREE_SELFTEST,	48	IO_TREE_SELFTEST,
48	};	49	};
49		50

fs/btrfs/extent-tree.c+3−20

 }
 #endif
-static inline u64 heads_to_leaves(struct btrfs_fs_info *fs_info, u64 heads)
-{
-	u64 num_bytes;
-	num_bytes = heads * (sizeof(struct btrfs_extent_item) +
-			     sizeof(struct btrfs_extent_inline_ref));
-	if (!btrfs_fs_incompat(fs_info, SKINNY_METADATA))
-		num_bytes += heads * sizeof(struct btrfs_tree_block_info);
-	/*
-	 * We don't ever fill up leaves all the way so multiply by 2 just to be
-	 * closer to what we're really going to want to use.
-	 */
-	return div_u64(num_bytes, BTRFS_LEAF_DATA_SIZE(fs_info));
-}
 /*
  * Takes the number of bytes to be csumm'ed and figures out how many leaves it
  * would require to store the csums for that many bytes.
 	nritems = btrfs_header_nritems(buf);
 	level = btrfs_header_level(buf);
-	if (!test_bit(BTRFS_ROOT_REF_COWS, &root->state) && level == 0)
+	if (!test_bit(BTRFS_ROOT_SHAREABLE, &root->state) && level == 0)
 		return 0;
 	if (full_backref)
 						   &trimmed);
 		list_del_init(&block_group->bg_list);
-		btrfs_put_block_group_trimming(block_group);
+		btrfs_unfreeze_block_group(block_group);
 		btrfs_put_block_group(block_group);
 		if (ret) {
 		   struct btrfs_block_group *block_group,
 		   struct btrfs_free_cluster *cluster,
 		   int delalloc)
+	__acquires(&cluster->refill_lock)
 {
 	struct btrfs_block_group *used_bg = NULL;
 	 */
 	if (!for_reloc && !root_dropped)
 		btrfs_add_dead_root(root);
-	if (err && err != -EAGAIN)
-		btrfs_handle_fs_error(fs_info, err, NULL);
 	return err;
 }

fs/btrfs/extent_io.c+132−156

@@ -2333,7 +2333,7 @@ int repair_io_failure(struct btrfs_fs_info *fs_info, u64 ino, u64 start, · 2332 unmodified lines
2333	return 0;	2333	return 0;
2334	}	2334	}
2335		2335
2336	int btrfs_repair_eb_io_failure(struct extent_buffer *eb, int mirror_num)	2336	int btrfs_repair_eb_io_failure(const struct extent_buffer *eb, int mirror_num)
2337	{	2337	{
2338	struct btrfs_fs_info *fs_info = eb->fs_info;	2338	struct btrfs_fs_info *fs_info = eb->fs_info;
2339	u64 start = eb->start;	2339	u64 start = eb->start;
@@ -2537,8 +2537,9 @@ int btrfs_get_io_failure_record(struct inode *inode, u64 start, u64 end, · 197 unmodified lines
2537	return 0;	2537	return 0;
2538	}	2538	}
2539		2539
2540	bool btrfs_check_repairable(struct inode *inode, unsigned failed_bio_pages,	2540	static bool btrfs_check_repairable(struct inode *inode, bool needs_validation,
2541	struct io_failure_record *failrec, int failed_mirror)	2541	struct io_failure_record *failrec,
		2542	int failed_mirror)
2542	{	2543	{
2543	struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);	2544	struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
2544	int num_copies;	2545	int num_copies;
@@ -2561,7 +2562,7 @@ bool btrfs_check_repairable(struct inode *inode, unsigned failed_bio_pages, · 16 unmodified lines
2561	* a) deliver good data to the caller	2562	* a) deliver good data to the caller
2562	* b) correct the bad sectors on disk	2563	* b) correct the bad sectors on disk
2563	*/	2564	*/
2564	if (failed_bio_pages > 1) {	2565	if (needs_validation) {
2565	/*	2566	/*
2566	* to fulfill b), we need to know the exact failing sectors, as	2567	* to fulfill b), we need to know the exact failing sectors, as
2567	* we don't want to rewrite any more than the failed ones. thus,	2568	* we don't want to rewrite any more than the failed ones. thus,
@@ -2600,94 +2601,115 @@ bool btrfs_check_repairable(struct inode *inode, unsigned failed_bio_pages, · 32 unmodified lines
2600	return true;	2601	return true;
2601	}	2602	}
2602		2603
2603		2604	static bool btrfs_io_needs_validation(struct inode inode, struct bio bio)
2604	struct bio btrfs_create_repair_bio(struct inode inode, struct bio *failed_bio,
2605	struct io_failure_record *failrec,
2606	struct page *page, int pg_offset, int icsum,
2607	bio_end_io_t endio_func, void data)
2608	{	2605	{
2609	struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);	2606	u64 len = 0;
2610	struct bio *bio;	2607	const u32 blocksize = inode->i_sb->s_blocksize;
2611	struct btrfs_io_bio *btrfs_failed_bio;
2612	struct btrfs_io_bio *btrfs_bio;
2613		2608
2614	bio = btrfs_io_bio_alloc(1);	2609	/*
2615	bio->bi_end_io = endio_func;	2610	* If bi_status is BLK_STS_OK, then this was a checksum error, not an
2616	bio->bi_iter.bi_sector = failrec->logical >> 9;	2611	* I/O error. In this case, we already know exactly which sector was
2617	bio->bi_iter.bi_size = 0;	2612	* bad, so we don't need to validate.
2618	bio->bi_private = data;	2613	*/
		2614	if (bio->bi_status == BLK_STS_OK)
		2615	return false;
2619		2616
2620	btrfs_failed_bio = btrfs_io_bio(failed_bio);	2617	/*
2621	if (btrfs_failed_bio->csum) {	2618	* We need to validate each sector individually if the failed I/O was
2622	u16 csum_size = btrfs_super_csum_size(fs_info->super_copy);	2619	* for multiple sectors.
		2620	*
		2621	* There are a few possible bios that can end up here:
		2622	* 1. A buffered read bio, which is not cloned.
		2623	* 2. A direct I/O read bio, which is cloned.
		2624	* 3. A (buffered or direct) repair bio, which is not cloned.
		2625	*
		2626	* For cloned bios (case 2), we can get the size from
		2627	* btrfs_io_bio->iter; for non-cloned bios (cases 1 and 3), we can get
		2628	* it from the bvecs.
		2629	*/
		2630	if (bio_flagged(bio, BIO_CLONED)) {
		2631	if (btrfs_io_bio(bio)->iter.bi_size > blocksize)
		2632	return true;
		2633	} else {
		2634	struct bio_vec *bvec;
		2635	int i;
2623		2636
2624	btrfs_bio = btrfs_io_bio(bio);	2637	bio_for_each_bvec_all(bvec, bio, i) {
2625	btrfs_bio->csum = btrfs_bio->csum_inline;	2638	len += bvec->bv_len;
2626	icsum *= csum_size;	2639	if (len > blocksize)
2627	memcpy(btrfs_bio->csum, btrfs_failed_bio->csum + icsum,	2640	return true;
2628	csum_size);	2641	}
2629	}	2642	}
2630		2643	return false;
2631	bio_add_page(bio, page, failrec->len, pg_offset);
2632
2633	return bio;
2634	}	2644	}
2635		2645
2636	/*	2646	blk_status_t btrfs_submit_read_repair(struct inode *inode,
2637	* This is a generic handler for readpage errors. If other copies exist, read	2647	struct bio *failed_bio, u64 phy_offset,
2638	* those and write back good data to the failed position. Does not investigate	2648	struct page *page, unsigned int pgoff,
2639	* in remapping the failed extent elsewhere, hoping the device will be smart	2649	u64 start, u64 end, int failed_mirror,
2640	* enough to do this as needed	2650	submit_bio_hook_t *submit_bio_hook)
2641	*/
2642	static int bio_readpage_error(struct bio *failed_bio, u64 phy_offset,
2643	struct page *page, u64 start, u64 end,
2644	int failed_mirror)
2645	{	2651	{
2646	struct io_failure_record *failrec;	2652	struct io_failure_record *failrec;
2647	struct inode *inode = page->mapping->host;	2653	struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
2648	struct extent_io_tree *tree = &BTRFS_I(inode)->io_tree;	2654	struct extent_io_tree *tree = &BTRFS_I(inode)->io_tree;
2649	struct extent_io_tree *failure_tree = &BTRFS_I(inode)->io_failure_tree;	2655	struct extent_io_tree *failure_tree = &BTRFS_I(inode)->io_failure_tree;
2650	struct bio *bio;	2656	struct btrfs_io_bio *failed_io_bio = btrfs_io_bio(failed_bio);
2651	int read_mode = 0;	2657	const int icsum = phy_offset >> inode->i_sb->s_blocksize_bits;
		2658	bool need_validation;
		2659	struct bio *repair_bio;
		2660	struct btrfs_io_bio *repair_io_bio;
2652	blk_status_t status;	2661	blk_status_t status;
2653	int ret;	2662	int ret;
2654	unsigned failed_bio_pages = failed_bio->bi_iter.bi_size >> PAGE_SHIFT;	2663
		2664	btrfs_debug(fs_info,
		2665	"repair read error: read error at %llu", start);
2655		2666
2656	BUG_ON(bio_op(failed_bio) == REQ_OP_WRITE);	2667	BUG_ON(bio_op(failed_bio) == REQ_OP_WRITE);
2657		2668
2658	ret = btrfs_get_io_failure_record(inode, start, end, &failrec);	2669	ret = btrfs_get_io_failure_record(inode, start, end, &failrec);
2659	if (ret)	2670	if (ret)
2660	return ret;	2671	return errno_to_blk_status(ret);
		2672
		2673	need_validation = btrfs_io_needs_validation(inode, failed_bio);
2661		2674
2662	if (!btrfs_check_repairable(inode, failed_bio_pages, failrec,	2675	if (!btrfs_check_repairable(inode, need_validation, failrec,
2663	failed_mirror)) {	2676	failed_mirror)) {
2664	free_io_failure(failure_tree, tree, failrec);	2677	free_io_failure(failure_tree, tree, failrec);
2665	return -EIO;	2678	return BLK_STS_IOERR;
2666	}	2679	}
2667		2680
2668	if (failed_bio_pages > 1)	2681	repair_bio = btrfs_io_bio_alloc(1);
2669	read_mode \|= REQ_FAILFAST_DEV;	2682	repair_io_bio = btrfs_io_bio(repair_bio);
		2683	repair_bio->bi_opf = REQ_OP_READ;
		2684	if (need_validation)
		2685	repair_bio->bi_opf \|= REQ_FAILFAST_DEV;
		2686	repair_bio->bi_end_io = failed_bio->bi_end_io;
		2687	repair_bio->bi_iter.bi_sector = failrec->logical >> 9;
		2688	repair_bio->bi_private = failed_bio->bi_private;
2670		2689
2671	phy_offset >>= inode->i_sb->s_blocksize_bits;	2690	if (failed_io_bio->csum) {
2672	bio = btrfs_create_repair_bio(inode, failed_bio, failrec, page,	2691	const u16 csum_size = btrfs_super_csum_size(fs_info->super_copy);
2673	start - page_offset(page),	2692
2674	(int)phy_offset, failed_bio->bi_end_io,	2693	repair_io_bio->csum = repair_io_bio->csum_inline;
2675	NULL);	2694	memcpy(repair_io_bio->csum,
2676	bio->bi_opf = REQ_OP_READ \| read_mode;	2695	failed_io_bio->csum + csum_size * icsum, csum_size);
		2696	}
		2697
		2698	bio_add_page(repair_bio, page, failrec->len, pgoff);
		2699	repair_io_bio->logical = failrec->start;
		2700	repair_io_bio->iter = repair_bio->bi_iter;
2677		2701
2678	btrfs_debug(btrfs_sb(inode->i_sb),	2702	btrfs_debug(btrfs_sb(inode->i_sb),
2679	"Repair Read Error: submitting new read[%#x] to this_mirror=%d, in_validation=%d",	2703	"repair read error: submitting new read to mirror %d, in_validation=%d",
2680	read_mode, failrec->this_mirror, failrec->in_validation);	2704	failrec->this_mirror, failrec->in_validation);
2681		2705
2682	status = tree->ops->submit_bio_hook(tree->private_data, bio, failrec->this_mirror,	2706	status = submit_bio_hook(inode, repair_bio, failrec->this_mirror,
2683	failrec->bio_flags);	2707	failrec->bio_flags);
2684	if (status) {	2708	if (status) {
2685	free_io_failure(failure_tree, tree, failrec);	2709	free_io_failure(failure_tree, tree, failrec);
2686	bio_put(bio);	2710	bio_put(repair_bio);
2687	ret = blk_status_to_errno(status);
2688	}	2711	}
2689		2712	return status;
2690	return ret;
2691	}	2713	}
2692		2714
2693	/* lots and lots of room for performance fixes in the end_bio funcs */	2715	/* lots and lots of room for performance fixes in the end_bio funcs */
@@ -2859,9 +2881,10 @@ static void end_bio_extent_readpage(struct bio *bio) · 165 unmodified lines
2859	* If it can't handle the error it will return -EIO and	2881	* If it can't handle the error it will return -EIO and
2860	* we remain responsible for that page.	2882	* we remain responsible for that page.
2861	*/	2883	*/
2862	ret = bio_readpage_error(bio, offset, page, start, end,	2884	if (!btrfs_submit_read_repair(inode, bio, offset, page,
2863	mirror);	2885	start - page_offset(page),
2864	if (ret == 0) {	2886	start, end, mirror,
		2887	tree->ops->submit_bio_hook)) {
2865	uptodate = !bio->bi_status;	2888	uptodate = !bio->bi_status;
2866	offset += len;	2889	offset += len;
2867	continue;	2890	continue;
@@ -4862,7 +4885,7 @@ static void __free_extent_buffer(struct extent_buffer *eb) · 1994 unmodified lines
4862	kmem_cache_free(extent_buffer_cache, eb);	4885	kmem_cache_free(extent_buffer_cache, eb);
4863	}	4886	}
4864		4887
4865	int extent_buffer_under_io(struct extent_buffer *eb)	4888	int extent_buffer_under_io(const struct extent_buffer *eb)
4866	{	4889	{
4867	return (atomic_read(&eb->io_pages) \|\|	4890	return (atomic_read(&eb->io_pages) \|\|
4868	test_bit(EXTENT_BUFFER_WRITEBACK, &eb->bflags) \|\|	4891	test_bit(EXTENT_BUFFER_WRITEBACK, &eb->bflags) \|\|
@@ -4967,7 +4990,7 @@ __alloc_extent_buffer(struct btrfs_fs_info *fs_info, u64 start, · 98 unmodified lines
4967	return eb;	4990	return eb;
4968	}	4991	}
4969		4992
4970	struct extent_buffer btrfs_clone_extent_buffer(struct extent_buffer src)	4993	struct extent_buffer btrfs_clone_extent_buffer(const struct extent_buffer src)
4971	{	4994	{
4972	int i;	4995	int i;
4973	struct page *p;	4996	struct page *p;
@@ -5373,7 +5396,7 @@ void free_extent_buffer_stale(struct extent_buffer *eb) · 399 unmodified lines
5373	release_extent_buffer(eb);	5396	release_extent_buffer(eb);
5374	}	5397	}
5375		5398
5376	void clear_extent_buffer_dirty(struct extent_buffer *eb)	5399	void clear_extent_buffer_dirty(const struct extent_buffer *eb)
5377	{	5400	{
5378	int i;	5401	int i;
5379	int num_pages;	5402	int num_pages;
@@ -5571,8 +5594,7 @@ void read_extent_buffer(const struct extent_buffer eb, void dstv, · 191 unmodified lines
5571	struct page *page;	5594	struct page *page;
5572	char *kaddr;	5595	char *kaddr;
5573	char dst = (char )dstv;	5596	char dst = (char )dstv;
5574	size_t start_offset = offset_in_page(eb->start);	5597	unsigned long i = start >> PAGE_SHIFT;
5575	unsigned long i = (start_offset + start) >> PAGE_SHIFT;
5576		5598
5577	if (start + len > eb->len) {	5599	if (start + len > eb->len) {
5578	WARN(1, KERN_ERR "btrfs bad mapping eb start %llu len %lu, wanted %lu %lu\n",	5600	WARN(1, KERN_ERR "btrfs bad mapping eb start %llu len %lu, wanted %lu %lu\n",
@@ -5581,7 +5603,7 @@ void read_extent_buffer(const struct extent_buffer eb, void dstv, · 2 unmodified lines
5581	return;	5603	return;
5582	}	5604	}
5583		5605
5584	offset = offset_in_page(start_offset + start);	5606	offset = offset_in_page(start);
5585		5607
5586	while (len > 0) {	5608	while (len > 0) {
5587	page = eb->pages[i];	5609	page = eb->pages[i];
@@ -5606,14 +5628,13 @@ int read_extent_buffer_to_user(const struct extent_buffer *eb, · 18 unmodified lines
5606	struct page *page;	5628	struct page *page;
5607	char *kaddr;	5629	char *kaddr;
5608	char __user dst = (char __user )dstv;	5630	char __user dst = (char __user )dstv;
5609	size_t start_offset = offset_in_page(eb->start);	5631	unsigned long i = start >> PAGE_SHIFT;
5610	unsigned long i = (start_offset + start) >> PAGE_SHIFT;
5611	int ret = 0;	5632	int ret = 0;
5612		5633
5613	WARN_ON(start > eb->len);	5634	WARN_ON(start > eb->len);
5614	WARN_ON(start + len > eb->start + eb->len);	5635	WARN_ON(start + len > eb->start + eb->len);
5615		5636
5616	offset = offset_in_page(start_offset + start);	5637	offset = offset_in_page(start);
5617		5638
5618	while (len > 0) {	5639	while (len > 0) {
5619	page = eb->pages[i];	5640	page = eb->pages[i];
@@ -5634,48 +5655,6 @@ int read_extent_buffer_to_user(const struct extent_buffer *eb, · 14 unmodified lines
5634	return ret;	5655	return ret;
5635	}	5656	}
5636		5657
5637	/*
5638	* return 0 if the item is found within a page.
5639	* return 1 if the item spans two pages.
5640	* return -EINVAL otherwise.
5641	*/
5642	int map_private_extent_buffer(const struct extent_buffer *eb,
5643	unsigned long start, unsigned long min_len,
5644	char *map, unsigned long map_start,
5645	unsigned long *map_len)
5646	{
5647	size_t offset;
5648	char *kaddr;
5649	struct page *p;
5650	size_t start_offset = offset_in_page(eb->start);
5651	unsigned long i = (start_offset + start) >> PAGE_SHIFT;
5652	unsigned long end_i = (start_offset + start + min_len - 1) >>
5653	PAGE_SHIFT;
5654
5655	if (start + min_len > eb->len) {
5656	WARN(1, KERN_ERR "btrfs bad mapping eb start %llu len %lu, wanted %lu %lu\n",
5657	eb->start, eb->len, start, min_len);
5658	return -EINVAL;
5659	}
5660
5661	if (i != end_i)
5662	return 1;
5663
5664	if (i == 0) {
5665	offset = start_offset;
5666	*map_start = 0;
5667	} else {
5668	offset = 0;
5669	*map_start = ((u64)i << PAGE_SHIFT) - start_offset;
5670	}
5671
5672	p = eb->pages[i];
5673	kaddr = page_address(p);
5674	*map = kaddr + offset;
5675	*map_len = PAGE_SIZE - offset;
5676	return 0;
5677	}
5678
5679	int memcmp_extent_buffer(const struct extent_buffer eb, const void ptrv,	5658	int memcmp_extent_buffer(const struct extent_buffer eb, const void ptrv,
5680	unsigned long start, unsigned long len)	5659	unsigned long start, unsigned long len)
5681	{	5660	{
@@ -5684,14 +5663,13 @@ int memcmp_extent_buffer(const struct extent_buffer eb, const void ptrv, · 2 unmodified lines
5684	struct page *page;	5663	struct page *page;
5685	char *kaddr;	5664	char *kaddr;
5686	char ptr = (char )ptrv;	5665	char ptr = (char )ptrv;
5687	size_t start_offset = offset_in_page(eb->start);	5666	unsigned long i = start >> PAGE_SHIFT;
5688	unsigned long i = (start_offset + start) >> PAGE_SHIFT;
5689	int ret = 0;	5667	int ret = 0;
5690		5668
5691	WARN_ON(start > eb->len);	5669	WARN_ON(start > eb->len);
5692	WARN_ON(start + len > eb->start + eb->len);	5670	WARN_ON(start + len > eb->start + eb->len);
5693		5671
5694	offset = offset_in_page(start_offset + start);	5672	offset = offset_in_page(start);
5695		5673
5696	while (len > 0) {	5674	while (len > 0) {
5697	page = eb->pages[i];	5675	page = eb->pages[i];
@@ -5711,7 +5689,7 @@ int memcmp_extent_buffer(const struct extent_buffer eb, const void ptrv, · 13 unmodified lines
5711	return ret;	5689	return ret;
5712	}	5690	}
5713		5691
5714	void write_extent_buffer_chunk_tree_uuid(struct extent_buffer *eb,	5692	void write_extent_buffer_chunk_tree_uuid(const struct extent_buffer *eb,
5715	const void *srcv)	5693	const void *srcv)
5716	{	5694	{
5717	char *kaddr;	5695	char *kaddr;
@@ -5722,7 +5700,7 @@ void write_extent_buffer_chunk_tree_uuid(struct extent_buffer *eb, · 4 unmodified lines
5722	BTRFS_FSID_SIZE);	5700	BTRFS_FSID_SIZE);
5723	}	5701	}
5724		5702
5725	void write_extent_buffer_fsid(struct extent_buffer eb, const void srcv)	5703	void write_extent_buffer_fsid(const struct extent_buffer eb, const void srcv)
5726	{	5704	{
5727	char *kaddr;	5705	char *kaddr;
5728		5706
@@ -5732,7 +5710,7 @@ void write_extent_buffer_fsid(struct extent_buffer eb, const void srcv) · 3 unmodified lines
5732	BTRFS_FSID_SIZE);	5710	BTRFS_FSID_SIZE);
5733	}	5711	}
5734		5712
5735	void write_extent_buffer(struct extent_buffer eb, const void srcv,	5713	void write_extent_buffer(const struct extent_buffer eb, const void srcv,
5736	unsigned long start, unsigned long len)	5714	unsigned long start, unsigned long len)
5737	{	5715	{
5738	size_t cur;	5716	size_t cur;
@@ -5740,13 +5718,12 @@ void write_extent_buffer(struct extent_buffer eb, const void srcv, · 1 unmodified line
5740	struct page *page;	5718	struct page *page;
5741	char *kaddr;	5719	char *kaddr;
5742	char src = (char )srcv;	5720	char src = (char )srcv;
5743	size_t start_offset = offset_in_page(eb->start);	5721	unsigned long i = start >> PAGE_SHIFT;
5744	unsigned long i = (start_offset + start) >> PAGE_SHIFT;
5745		5722
5746	WARN_ON(start > eb->len);	5723	WARN_ON(start > eb->len);
5747	WARN_ON(start + len > eb->start + eb->len);	5724	WARN_ON(start + len > eb->start + eb->len);
5748		5725
5749	offset = offset_in_page(start_offset + start);	5726	offset = offset_in_page(start);
5750		5727
5751	while (len > 0) {	5728	while (len > 0) {
5752	page = eb->pages[i];	5729	page = eb->pages[i];
@@ -5763,20 +5740,19 @@ void write_extent_buffer(struct extent_buffer eb, const void srcv, · 10 unmodified lines
5763	}	5740	}
5764	}	5741	}
5765		5742
5766	void memzero_extent_buffer(struct extent_buffer *eb, unsigned long start,	5743	void memzero_extent_buffer(const struct extent_buffer *eb, unsigned long start,
5767	unsigned long len)	5744	unsigned long len)
5768	{	5745	{
5769	size_t cur;	5746	size_t cur;
5770	size_t offset;	5747	size_t offset;
5771	struct page *page;	5748	struct page *page;
5772	char *kaddr;	5749	char *kaddr;
5773	size_t start_offset = offset_in_page(eb->start);	5750	unsigned long i = start >> PAGE_SHIFT;
5774	unsigned long i = (start_offset + start) >> PAGE_SHIFT;
5775		5751
5776	WARN_ON(start > eb->len);	5752	WARN_ON(start > eb->len);
5777	WARN_ON(start + len > eb->start + eb->len);	5753	WARN_ON(start + len > eb->start + eb->len);
5778		5754
5779	offset = offset_in_page(start_offset + start);	5755	offset = offset_in_page(start);
5780		5756
5781	while (len > 0) {	5757	while (len > 0) {
5782	page = eb->pages[i];	5758	page = eb->pages[i];
@@ -5792,8 +5768,8 @@ void memzero_extent_buffer(struct extent_buffer *eb, unsigned long start, · 9 unmodified lines
5792	}	5768	}
5793	}	5769	}
5794		5770
5795	void copy_extent_buffer_full(struct extent_buffer *dst,	5771	void copy_extent_buffer_full(const struct extent_buffer *dst,
5796	struct extent_buffer *src)	5772	const struct extent_buffer *src)
5797	{	5773	{
5798	int i;	5774	int i;
5799	int num_pages;	5775	int num_pages;
@@ -5806,7 +5782,8 @@ void copy_extent_buffer_full(struct extent_buffer *dst, · 6 unmodified lines
5806	page_address(src->pages[i]));	5782	page_address(src->pages[i]));
5807	}	5783	}
5808		5784
5809	void copy_extent_buffer(struct extent_buffer dst, struct extent_buffer src,	5785	void copy_extent_buffer(const struct extent_buffer *dst,
		5786	const struct extent_buffer *src,
5810	unsigned long dst_offset, unsigned long src_offset,	5787	unsigned long dst_offset, unsigned long src_offset,
5811	unsigned long len)	5788	unsigned long len)
5812	{	5789	{
@@ -5815,12 +5792,11 @@ void copy_extent_buffer(struct extent_buffer dst, struct extent_buffer src, · 2 unmodified lines
5815	size_t offset;	5792	size_t offset;
5816	struct page *page;	5793	struct page *page;
5817	char *kaddr;	5794	char *kaddr;
5818	size_t start_offset = offset_in_page(dst->start);	5795	unsigned long i = dst_offset >> PAGE_SHIFT;
5819	unsigned long i = (start_offset + dst_offset) >> PAGE_SHIFT;
5820		5796
5821	WARN_ON(src->len != dst_len);	5797	WARN_ON(src->len != dst_len);
5822		5798
5823	offset = offset_in_page(start_offset + dst_offset);	5799	offset = offset_in_page(dst_offset);
5824		5800
5825	while (len > 0) {	5801	while (len > 0) {
5826	page = dst->pages[i];	5802	page = dst->pages[i];
@@ -5851,12 +5827,11 @@ void copy_extent_buffer(struct extent_buffer dst, struct extent_buffer src, · 24 unmodified lines
5851	* This helper hides the ugliness of finding the byte in an extent buffer which	5827	* This helper hides the ugliness of finding the byte in an extent buffer which
5852	* contains a given bit.	5828	* contains a given bit.
5853	*/	5829	*/
5854	static inline void eb_bitmap_offset(struct extent_buffer *eb,	5830	static inline void eb_bitmap_offset(const struct extent_buffer *eb,
5855	unsigned long start, unsigned long nr,	5831	unsigned long start, unsigned long nr,
5856	unsigned long *page_index,	5832	unsigned long *page_index,
5857	size_t *page_offset)	5833	size_t *page_offset)
5858	{	5834	{
5859	size_t start_offset = offset_in_page(eb->start);
5860	size_t byte_offset = BIT_BYTE(nr);	5835	size_t byte_offset = BIT_BYTE(nr);
5861	size_t offset;	5836	size_t offset;
5862		5837
@@ -5865,7 +5840,7 @@ static inline void eb_bitmap_offset(struct extent_buffer *eb, · 2 unmodified lines
5865	* the bitmap item in the extent buffer + the offset of the byte in the	5840	* the bitmap item in the extent buffer + the offset of the byte in the
5866	* bitmap item.	5841	* bitmap item.
5867	*/	5842	*/
5868	offset = start_offset + start + byte_offset;	5843	offset = start + byte_offset;
5869		5844
5870	*page_index = offset >> PAGE_SHIFT;	5845	*page_index = offset >> PAGE_SHIFT;
5871	*page_offset = offset_in_page(offset);	5846	*page_offset = offset_in_page(offset);
@@ -5877,7 +5852,7 @@ static inline void eb_bitmap_offset(struct extent_buffer *eb, · 5 unmodified lines
5877	* @start: offset of the bitmap item in the extent buffer	5852	* @start: offset of the bitmap item in the extent buffer
5878	* @nr: bit number to test	5853	* @nr: bit number to test
5879	*/	5854	*/
5880	int extent_buffer_test_bit(struct extent_buffer *eb, unsigned long start,	5855	int extent_buffer_test_bit(const struct extent_buffer *eb, unsigned long start,
5881	unsigned long nr)	5856	unsigned long nr)
5882	{	5857	{
5883	u8 *kaddr;	5858	u8 *kaddr;
@@ -5899,7 +5874,7 @@ int extent_buffer_test_bit(struct extent_buffer *eb, unsigned long start, · 15 unmodified lines
5899	* @pos: bit number of the first bit	5874	* @pos: bit number of the first bit
5900	* @len: number of bits to set	5875	* @len: number of bits to set
5901	*/	5876	*/
5902	void extent_buffer_bitmap_set(struct extent_buffer *eb, unsigned long start,	5877	void extent_buffer_bitmap_set(const struct extent_buffer *eb, unsigned long start,
5903	unsigned long pos, unsigned long len)	5878	unsigned long pos, unsigned long len)
5904	{	5879	{
5905	u8 *kaddr;	5880	u8 *kaddr;
@@ -5941,8 +5916,9 @@ void extent_buffer_bitmap_set(struct extent_buffer *eb, unsigned long start, · 35 unmodified lines
5941	* @pos: bit number of the first bit	5916	* @pos: bit number of the first bit
5942	* @len: number of bits to clear	5917	* @len: number of bits to clear
5943	*/	5918	*/
5944	void extent_buffer_bitmap_clear(struct extent_buffer *eb, unsigned long start,	5919	void extent_buffer_bitmap_clear(const struct extent_buffer *eb,
5945	unsigned long pos, unsigned long len)	5920	unsigned long start, unsigned long pos,
		5921	unsigned long len)
5946	{	5922	{
5947	u8 *kaddr;	5923	u8 *kaddr;
5948	struct page *page;	5924	struct page *page;
@@ -6003,14 +5979,14 @@ static void copy_pages(struct page dst_page, struct page src_page, · 54 unmodified lines
6003	memcpy(dst_kaddr + dst_off, src_kaddr + src_off, len);	5979	memcpy(dst_kaddr + dst_off, src_kaddr + src_off, len);
6004	}	5980	}
6005		5981
6006	void memcpy_extent_buffer(struct extent_buffer *dst, unsigned long dst_offset,	5982	void memcpy_extent_buffer(const struct extent_buffer *dst,
6007	unsigned long src_offset, unsigned long len)	5983	unsigned long dst_offset, unsigned long src_offset,
		5984	unsigned long len)
6008	{	5985	{
6009	struct btrfs_fs_info *fs_info = dst->fs_info;	5986	struct btrfs_fs_info *fs_info = dst->fs_info;
6010	size_t cur;	5987	size_t cur;
6011	size_t dst_off_in_page;	5988	size_t dst_off_in_page;
6012	size_t src_off_in_page;	5989	size_t src_off_in_page;
6013	size_t start_offset = offset_in_page(dst->start);
6014	unsigned long dst_i;	5990	unsigned long dst_i;
6015	unsigned long src_i;	5991	unsigned long src_i;
6016		5992
@@ -6028,11 +6004,11 @@ void memcpy_extent_buffer(struct extent_buffer *dst, unsigned long dst_offset, · 11 unmodified lines
6028	}	6004	}
6029		6005
6030	while (len > 0) {	6006	while (len > 0) {
6031	dst_off_in_page = offset_in_page(start_offset + dst_offset);	6007	dst_off_in_page = offset_in_page(dst_offset);
6032	src_off_in_page = offset_in_page(start_offset + src_offset);	6008	src_off_in_page = offset_in_page(src_offset);
6033		6009
6034	dst_i = (start_offset + dst_offset) >> PAGE_SHIFT;	6010	dst_i = dst_offset >> PAGE_SHIFT;
6035	src_i = (start_offset + src_offset) >> PAGE_SHIFT;	6011	src_i = src_offset >> PAGE_SHIFT;
6036		6012
6037	cur = min(len, (unsigned long)(PAGE_SIZE -	6013	cur = min(len, (unsigned long)(PAGE_SIZE -
6038	src_off_in_page));	6014	src_off_in_page));
@@ -6048,8 +6024,9 @@ void memcpy_extent_buffer(struct extent_buffer *dst, unsigned long dst_offset, · 9 unmodified lines
6048	}	6024	}
6049	}	6025	}
6050		6026
6051	void memmove_extent_buffer(struct extent_buffer *dst, unsigned long dst_offset,	6027	void memmove_extent_buffer(const struct extent_buffer *dst,
6052	unsigned long src_offset, unsigned long len)	6028	unsigned long dst_offset, unsigned long src_offset,
		6029	unsigned long len)
6053	{	6030	{
6054	struct btrfs_fs_info *fs_info = dst->fs_info;	6031	struct btrfs_fs_info *fs_info = dst->fs_info;
6055	size_t cur;	6032	size_t cur;
@@ -6057,7 +6034,6 @@ void memmove_extent_buffer(struct extent_buffer *dst, unsigned long dst_offset, · 1 unmodified line
6057	size_t src_off_in_page;	6034	size_t src_off_in_page;
6058	unsigned long dst_end = dst_offset + len - 1;	6035	unsigned long dst_end = dst_offset + len - 1;
6059	unsigned long src_end = src_offset + len - 1;	6036	unsigned long src_end = src_offset + len - 1;
6060	size_t start_offset = offset_in_page(dst->start);
6061	unsigned long dst_i;	6037	unsigned long dst_i;
6062	unsigned long src_i;	6038	unsigned long src_i;
6063		6039
@@ -6078,11 +6054,11 @@ void memmove_extent_buffer(struct extent_buffer *dst, unsigned long dst_offset, · 14 unmodified lines
6078	return;	6054	return;
6079	}	6055	}
6080	while (len > 0) {	6056	while (len > 0) {
6081	dst_i = (start_offset + dst_end) >> PAGE_SHIFT;	6057	dst_i = dst_end >> PAGE_SHIFT;
6082	src_i = (start_offset + src_end) >> PAGE_SHIFT;	6058	src_i = src_end >> PAGE_SHIFT;
6083		6059
6084	dst_off_in_page = offset_in_page(start_offset + dst_end);	6060	dst_off_in_page = offset_in_page(dst_end);
6085	src_off_in_page = offset_in_page(start_offset + src_end);	6061	src_off_in_page = offset_in_page(src_end);
6086		6062
6087	cur = min_t(unsigned long, len, src_off_in_page + 1);	6063	cur = min_t(unsigned long, len, src_off_in_page + 1);
6088	cur = min(cur, dst_off_in_page + 1);	6064	cur = min(cur, dst_off_in_page + 1);

fs/btrfs/extent_io.h+35−32

@@ -66,6 +66,10 @@ struct btrfs_io_bio; · 65 unmodified lines
66	struct io_failure_record;	66	struct io_failure_record;
67	struct extent_io_tree;	67	struct extent_io_tree;
68		68
		69	typedef blk_status_t (submit_bio_hook_t)(struct inode inode, struct bio bio,
		70	int mirror_num,
		71	unsigned long bio_flags);
		72
69	typedef blk_status_t (extent_submit_bio_start_t)(void *private_data,	73	typedef blk_status_t (extent_submit_bio_start_t)(void *private_data,
70	struct bio *bio, u64 bio_offset);	74	struct bio *bio, u64 bio_offset);
71		75
@@ -74,8 +78,7 @@ struct extent_io_ops { · 2 unmodified lines
74	* The following callbacks must be always defined, the function	78	* The following callbacks must be always defined, the function
75	* pointer will be called unconditionally.	79	* pointer will be called unconditionally.
76	*/	80	*/
77	blk_status_t (submit_bio_hook)(struct inode inode, struct bio *bio,	81	submit_bio_hook_t *submit_bio_hook;
78	int mirror_num, unsigned long bio_flags);
79	int (readpage_end_io_hook)(struct btrfs_io_bio io_bio, u64 phy_offset,	82	int (readpage_end_io_hook)(struct btrfs_io_bio io_bio, u64 phy_offset,
80	struct page *page, u64 start, u64 end,	83	struct page *page, u64 start, u64 end,
81	int mirror);	84	int mirror);
@@ -209,7 +212,7 @@ struct extent_buffer __alloc_dummy_extent_buffer(struct btrfs_fs_info fs_info, · 127 unmodified lines
209	u64 start, unsigned long len);	212	u64 start, unsigned long len);
210	struct extent_buffer alloc_dummy_extent_buffer(struct btrfs_fs_info fs_info,	213	struct extent_buffer alloc_dummy_extent_buffer(struct btrfs_fs_info fs_info,
211	u64 start);	214	u64 start);
212	struct extent_buffer btrfs_clone_extent_buffer(struct extent_buffer src);	215	struct extent_buffer btrfs_clone_extent_buffer(const struct extent_buffer src);
213	struct extent_buffer find_extent_buffer(struct btrfs_fs_info fs_info,	216	struct extent_buffer find_extent_buffer(struct btrfs_fs_info fs_info,
214	u64 start);	217	u64 start);
215	void free_extent_buffer(struct extent_buffer *eb);	218	void free_extent_buffer(struct extent_buffer *eb);
@@ -227,7 +230,7 @@ static inline int num_extent_pages(const struct extent_buffer *eb) · 11 unmodified lines
227	(eb->start >> PAGE_SHIFT);	230	(eb->start >> PAGE_SHIFT);
228	}	231	}
229		232
230	static inline int extent_buffer_uptodate(struct extent_buffer *eb)	233	static inline int extent_buffer_uptodate(const struct extent_buffer *eb)
231	{	234	{
232	return test_bit(EXTENT_BUFFER_UPTODATE, &eb->bflags);	235	return test_bit(EXTENT_BUFFER_UPTODATE, &eb->bflags);
233	}	236	}
@@ -240,37 +243,37 @@ void read_extent_buffer(const struct extent_buffer eb, void dst, · 6 unmodified lines
240	int read_extent_buffer_to_user(const struct extent_buffer *eb,	243	int read_extent_buffer_to_user(const struct extent_buffer *eb,
241	void __user *dst, unsigned long start,	244	void __user *dst, unsigned long start,
242	unsigned long len);	245	unsigned long len);
243	void write_extent_buffer_fsid(struct extent_buffer eb, const void src);	246	void write_extent_buffer_fsid(const struct extent_buffer eb, const void src);
244	void write_extent_buffer_chunk_tree_uuid(struct extent_buffer *eb,	247	void write_extent_buffer_chunk_tree_uuid(const struct extent_buffer *eb,
245	const void *src);	248	const void *src);
246	void write_extent_buffer(struct extent_buffer eb, const void src,	249	void write_extent_buffer(const struct extent_buffer eb, const void src,
247	unsigned long start, unsigned long len);	250	unsigned long start, unsigned long len);
248	void copy_extent_buffer_full(struct extent_buffer *dst,	251	void copy_extent_buffer_full(const struct extent_buffer *dst,
249	struct extent_buffer *src);	252	const struct extent_buffer *src);
250	void copy_extent_buffer(struct extent_buffer dst, struct extent_buffer src,	253	void copy_extent_buffer(const struct extent_buffer *dst,
		254	const struct extent_buffer *src,
251	unsigned long dst_offset, unsigned long src_offset,	255	unsigned long dst_offset, unsigned long src_offset,
252	unsigned long len);	256	unsigned long len);
253	void memcpy_extent_buffer(struct extent_buffer *dst, unsigned long dst_offset,	257	void memcpy_extent_buffer(const struct extent_buffer *dst,
254	unsigned long src_offset, unsigned long len);	258	unsigned long dst_offset, unsigned long src_offset,
255	void memmove_extent_buffer(struct extent_buffer *dst, unsigned long dst_offset,	259	unsigned long len);
256	unsigned long src_offset, unsigned long len);	260	void memmove_extent_buffer(const struct extent_buffer *dst,
257	void memzero_extent_buffer(struct extent_buffer *eb, unsigned long start,	261	unsigned long dst_offset, unsigned long src_offset,
		262	unsigned long len);
		263	void memzero_extent_buffer(const struct extent_buffer *eb, unsigned long start,
258	unsigned long len);	264	unsigned long len);
259	int extent_buffer_test_bit(struct extent_buffer *eb, unsigned long start,	265	int extent_buffer_test_bit(const struct extent_buffer *eb, unsigned long start,
260	unsigned long pos);	266	unsigned long pos);
261	void extent_buffer_bitmap_set(struct extent_buffer *eb, unsigned long start,	267	void extent_buffer_bitmap_set(const struct extent_buffer *eb, unsigned long start,
262	unsigned long pos, unsigned long len);	268	unsigned long pos, unsigned long len);
263	void extent_buffer_bitmap_clear(struct extent_buffer *eb, unsigned long start,	269	void extent_buffer_bitmap_clear(const struct extent_buffer *eb,
264	unsigned long pos, unsigned long len);	270	unsigned long start, unsigned long pos,
265	void clear_extent_buffer_dirty(struct extent_buffer *eb);	271	unsigned long len);
		272	void clear_extent_buffer_dirty(const struct extent_buffer *eb);
266	bool set_extent_buffer_dirty(struct extent_buffer *eb);	273	bool set_extent_buffer_dirty(struct extent_buffer *eb);
267	void set_extent_buffer_uptodate(struct extent_buffer *eb);	274	void set_extent_buffer_uptodate(struct extent_buffer *eb);
268	void clear_extent_buffer_uptodate(struct extent_buffer *eb);	275	void clear_extent_buffer_uptodate(struct extent_buffer *eb);
269	int extent_buffer_under_io(struct extent_buffer *eb);	276	int extent_buffer_under_io(const struct extent_buffer *eb);
270	int map_private_extent_buffer(const struct extent_buffer *eb,
271	unsigned long offset, unsigned long min_len,
272	char *map, unsigned long map_start,
273	unsigned long *map_len);
274	void extent_range_clear_dirty_for_io(struct inode *inode, u64 start, u64 end);	277	void extent_range_clear_dirty_for_io(struct inode *inode, u64 start, u64 end);
275	void extent_range_redirty_for_io(struct inode *inode, u64 start, u64 end);	278	void extent_range_redirty_for_io(struct inode *inode, u64 start, u64 end);
276	void extent_clear_unlock_delalloc(struct inode *inode, u64 start, u64 end,	279	void extent_clear_unlock_delalloc(struct inode *inode, u64 start, u64 end,
@@ -289,7 +292,7 @@ int repair_io_failure(struct btrfs_fs_info *fs_info, u64 ino, u64 start, · 12 unmodified lines
289	u64 length, u64 logical, struct page *page,	292	u64 length, u64 logical, struct page *page,
290	unsigned int pg_offset, int mirror_num);	293	unsigned int pg_offset, int mirror_num);
291	void end_extent_writepage(struct page *page, int err, u64 start, u64 end);	294	void end_extent_writepage(struct page *page, int err, u64 start, u64 end);
292	int btrfs_repair_eb_io_failure(struct extent_buffer *eb, int mirror_num);	295	int btrfs_repair_eb_io_failure(const struct extent_buffer *eb, int mirror_num);
293		296
294	/*	297	/*
295	* When IO fails, either with EIO or csum verification fails, we	298	* When IO fails, either with EIO or csum verification fails, we
@@ -311,12 +314,12 @@ struct io_failure_record { · 15 unmodified lines
311	};	314	};
312		315
313		316
314	bool btrfs_check_repairable(struct inode *inode, unsigned failed_bio_pages,	317	blk_status_t btrfs_submit_read_repair(struct inode *inode,
315	struct io_failure_record *failrec, int fail_mirror);	318	struct bio *failed_bio, u64 phy_offset,
316	struct bio btrfs_create_repair_bio(struct inode inode, struct bio *failed_bio,	319	struct page *page, unsigned int pgoff,
317	struct io_failure_record *failrec,	320	u64 start, u64 end, int failed_mirror,
318	struct page *page, int pg_offset, int icsum,	321	submit_bio_hook_t *submit_bio_hook);
319	bio_end_io_t endio_func, void data);	322
320	#ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS	323	#ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS
321	bool find_lock_delalloc_range(struct inode *inode,	324	bool find_lock_delalloc_range(struct inode *inode,
322	struct page locked_page, u64 start,	325	struct page locked_page, u64 start,

fs/btrfs/file-item.c+35−27

 /**
  * btrfs_lookup_bio_sums - Look up checksums for a bio.
  * @inode: inode that the bio is for.
- * @bio: bio embedded in btrfs_io_bio.
+ * @bio: bio to look up.
  * @offset: Unless (u64)-1, look up checksums for this offset in the file.
  *          If (u64)-1, use the page offsets from the bio instead.
- * @dst: Buffer of size btrfs_super_csum_size() used to return checksum. If
+ * @dst: Buffer of size nblocks * btrfs_super_csum_size() used to return
- *       NULL, the checksum is returned in btrfs_io_bio(bio)->csum instead.
+ *       checksum (nblocks = bio->bi_iter.bi_size / fs_info->sectorsize). If
+ *       NULL, the checksum buffer is allocated and returned in
+ *       btrfs_io_bio(bio)->csum instead.
  *
  * Return: BLK_STS_RESOURCE if allocating memory fails, BLK_STS_OK otherwise.
  */
 	struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
 	struct bio_vec bvec;
 	struct bvec_iter iter;
-	struct btrfs_io_bio *btrfs_bio = btrfs_io_bio(bio);
 	struct btrfs_csum_item *item = NULL;
 	struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
 	struct btrfs_path *path;
 	nblocks = bio->bi_iter.bi_size >> inode->i_sb->s_blocksize_bits;
 	if (!dst) {
+		struct btrfs_io_bio *btrfs_bio = btrfs_io_bio(bio);
 		if (nblocks * csum_size > BTRFS_BIO_INLINE_CSUM_SIZE) {
 			btrfs_bio->csum = kmalloc_array(nblocks, csum_size,
 							GFP_NOFS);
 				index = 0;
 			}
-			crypto_shash_init(shash);
 			data = kmap_atomic(bvec.bv_page);
-			crypto_shash_update(shash, data + bvec.bv_offset
+			crypto_shash_digest(shash, data + bvec.bv_offset
 					    + (i * fs_info->sectorsize),
-					    fs_info->sectorsize);
+					    fs_info->sectorsize,
+					    sums->sums + index);
 			kunmap_atomic(data);
-			crypto_shash_final(shash, (char *)(sums->sums + index));
 			index += csum_size;
 			offset += fs_info->sectorsize;
 			this_sum_bytes += fs_info->sectorsize;
 	}
 	ret = PTR_ERR(item);
 	if (ret != -EFBIG && ret != -ENOENT)
-		goto fail_unlock;
+		goto out;
 	if (ret == -EFBIG) {
 		u32 item_size;
 		nritems = btrfs_header_nritems(path->nodes[0]);
 		if (!nritems || (path->slots[0] >= nritems - 1)) {
 			ret = btrfs_next_leaf(root, path);
-			if (ret == 1)
+			if (ret < 0) {
+				goto out;
+			} else if (ret > 0) {
 				found_next = 1;
-			if (ret != 0)
 				goto insert;
+			}
 			slot = path->slots[0];
 		}
 		btrfs_item_key_to_cpu(path->nodes[0], &found_key, slot);
 	}
 	/*
-	 * at this point, we know the tree has an item, but it isn't big
+	 * At this point, we know the tree has a checksum item that ends at an
-	 * enough yet to put our csum in.  Grow it
+	 * offset matching the start of the checksum range we want to insert.
+	 * We try to extend that item as much as possible and then add as many
+	 * checksums to it as they fit.
+	 *
+	 * First check if the leaf has enough free space for at least one
+	 * checksum. If it has go directly to the item extension code, otherwise
+	 * release the path and do a search for insertion before the extension.
 	 */
+	if (btrfs_leaf_free_space(leaf) >= csum_size) {
+		btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
+		csum_offset = (bytenr - found_key.offset) >>
+			fs_info->sb->s_blocksize_bits;
+		goto extend_csum;
+	}
 	btrfs_release_path(path);
 	ret = btrfs_search_slot(trans, root, &file_key, path,
 				csum_size, 1);
 	if (ret < 0)
-		goto fail_unlock;
+		goto out;
 	if (ret > 0) {
 		if (path->slots[0] == 0)
 		goto insert;
 	}
+extend_csum:
 	if (csum_offset == btrfs_item_size_nr(leaf, path->slots[0]) /
 	    csum_size) {
 		int extend_nr;
 		u64 tmp;
 		u32 diff;
-		u32 free_space;
-		if (btrfs_leaf_free_space(leaf) <
-				 sizeof(struct btrfs_item) + csum_size * 2)
-			goto insert;
-		free_space = btrfs_leaf_free_space(leaf) -
-					 sizeof(struct btrfs_item) - csum_size;
 		tmp = sums->len - total_bytes;
 		tmp >>= fs_info->sb->s_blocksize_bits;
 		WARN_ON(tmp < 1);
 			   MAX_CSUM_ITEMS(fs_info, csum_size) * csum_size);
 		diff = diff - btrfs_item_size_nr(leaf, path->slots[0]);
-		diff = min(free_space, diff);
+		diff = min_t(u32, btrfs_leaf_free_space(leaf), diff);
 		diff /= csum_size;
 		diff *= csum_size;
 				      ins_size);
 	path->leave_spinning = 0;
 	if (ret < 0)
-		goto fail_unlock;
+		goto out;
 	if (WARN_ON(ret != 0))
-		goto fail_unlock;
+		goto out;
 	leaf = path->nodes[0];
 csum:
 	item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_csum_item);
 out:
 	btrfs_free_path(path);
 	return ret;
-fail_unlock:
-	goto out;
 }
 void btrfs_extent_item_to_extent_map(struct btrfs_inode *inode,

fs/btrfs/file.c+94−17

@@ -275,26 +275,18 @@ static int __btrfs_run_defrag_inode(struct btrfs_fs_info *fs_info, · 274 unmodified lines
275	{	275	{
276	struct btrfs_root *inode_root;	276	struct btrfs_root *inode_root;
277	struct inode *inode;	277	struct inode *inode;
278	struct btrfs_key key;
279	struct btrfs_ioctl_defrag_range_args range;	278	struct btrfs_ioctl_defrag_range_args range;
280	int num_defrag;	279	int num_defrag;
281	int ret;	280	int ret;
282		281
283	/* get the inode */	282	/* get the inode */
284	key.objectid = defrag->root;	283	inode_root = btrfs_get_fs_root(fs_info, defrag->root, true);
285	key.type = BTRFS_ROOT_ITEM_KEY;
286	key.offset = (u64)-1;
287
288	inode_root = btrfs_get_fs_root(fs_info, &key, true);
289	if (IS_ERR(inode_root)) {	284	if (IS_ERR(inode_root)) {
290	ret = PTR_ERR(inode_root);	285	ret = PTR_ERR(inode_root);
291	goto cleanup;	286	goto cleanup;
292	}	287	}
293		288
294	key.objectid = defrag->ino;	289	inode = btrfs_iget(fs_info->sb, defrag->ino, inode_root);
295	key.type = BTRFS_INODE_ITEM_KEY;
296	key.offset = 0;
297	inode = btrfs_iget(fs_info->sb, &key, inode_root);
298	btrfs_put_root(inode_root);	290	btrfs_put_root(inode_root);
299	if (IS_ERR(inode)) {	291	if (IS_ERR(inode)) {
300	ret = PTR_ERR(inode);	292	ret = PTR_ERR(inode);
@@ -775,7 +767,7 @@ int __btrfs_drop_extents(struct btrfs_trans_handle *trans, · 474 unmodified lines
775	if (start >= BTRFS_I(inode)->disk_i_size && !replace_extent)	767	if (start >= BTRFS_I(inode)->disk_i_size && !replace_extent)
776	modify_tree = 0;	768	modify_tree = 0;
777		769
778	update_refs = (test_bit(BTRFS_ROOT_REF_COWS, &root->state) \|\|	770	update_refs = (test_bit(BTRFS_ROOT_SHAREABLE, &root->state) \|\|
779	root == fs_info->tree_root);	771	root == fs_info->tree_root);
780	while (1) {	772	while (1) {
781	recow = 0;	773	recow = 0;
@@ -1817,21 +1809,61 @@ again: · 1035 unmodified lines
1817	return num_written ? num_written : ret;	1809	return num_written ? num_written : ret;
1818	}	1810	}
1819		1811
1820	static ssize_t __btrfs_direct_write(struct kiocb iocb, struct iov_iter from)	1812	static ssize_t check_direct_IO(struct btrfs_fs_info *fs_info,
		1813	const struct iov_iter *iter, loff_t offset)
		1814	{
		1815	const unsigned int blocksize_mask = fs_info->sectorsize - 1;
		1816
		1817	if (offset & blocksize_mask)
		1818	return -EINVAL;
		1819
		1820	if (iov_iter_alignment(iter) & blocksize_mask)
		1821	return -EINVAL;
		1822
		1823	return 0;
		1824	}
		1825
		1826	static ssize_t btrfs_direct_write(struct kiocb iocb, struct iov_iter from)
1821	{	1827	{
1822	struct file *file = iocb->ki_filp;	1828	struct file *file = iocb->ki_filp;
1823	struct inode *inode = file_inode(file);	1829	struct inode *inode = file_inode(file);
1824	loff_t pos;	1830	struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
1825	ssize_t written;	1831	loff_t pos = iocb->ki_pos;
		1832	ssize_t written = 0;
1826	ssize_t written_buffered;	1833	ssize_t written_buffered;
1827	loff_t endbyte;	1834	loff_t endbyte;
1828	int err;	1835	int err;
		1836	size_t count = 0;
		1837	bool relock = false;
1829		1838
1830	written = generic_file_direct_write(iocb, from);	1839	if (check_direct_IO(fs_info, from, pos))
		1840	goto buffered;
		1841
		1842	count = iov_iter_count(from);
		1843	/*
		1844	* If the write DIO is beyond the EOF, we need update the isize, but it
		1845	* is protected by i_mutex. So we can not unlock the i_mutex at this
		1846	* case.
		1847	*/
		1848	if (pos + count <= inode->i_size) {
		1849	inode_unlock(inode);
		1850	relock = true;
		1851	} else if (iocb->ki_flags & IOCB_NOWAIT) {
		1852	return -EAGAIN;
		1853	}
		1854
		1855	down_read(&BTRFS_I(inode)->dio_sem);
		1856	written = iomap_dio_rw(iocb, from, &btrfs_dio_iomap_ops, &btrfs_dops,
		1857	is_sync_kiocb(iocb));
		1858	up_read(&BTRFS_I(inode)->dio_sem);
		1859
		1860	if (relock)
		1861	inode_lock(inode);
1831		1862
1832	if (written < 0 \|\| !iov_iter_count(from))	1863	if (written < 0 \|\| !iov_iter_count(from))
1833	return written;	1864	return written;
1834		1865
		1866	buffered:
1835	pos = iocb->ki_pos;	1867	pos = iocb->ki_pos;
1836	written_buffered = btrfs_buffered_write(iocb, from);	1868	written_buffered = btrfs_buffered_write(iocb, from);
1837	if (written_buffered < 0) {	1869	if (written_buffered < 0) {
@@ -1970,7 +2002,7 @@ static ssize_t btrfs_file_write_iter(struct kiocb *iocb, · 132 unmodified lines
1970	atomic_inc(&BTRFS_I(inode)->sync_writers);	2002	atomic_inc(&BTRFS_I(inode)->sync_writers);
1971		2003
1972	if (iocb->ki_flags & IOCB_DIRECT) {	2004	if (iocb->ki_flags & IOCB_DIRECT) {
1973	num_written = __btrfs_direct_write(iocb, from);	2005	num_written = btrfs_direct_write(iocb, from);
1974	} else {	2006	} else {
1975	num_written = btrfs_buffered_write(iocb, from);	2007	num_written = btrfs_buffered_write(iocb, from);
1976	if (num_written > 0)	2008	if (num_written > 0)
@@ -3484,9 +3516,54 @@ static int btrfs_file_open(struct inode inode, struct file filp) · 1507 unmodified lines
3484	return generic_file_open(inode, filp);	3516	return generic_file_open(inode, filp);
3485	}	3517	}
3486		3518
		3519	static int check_direct_read(struct btrfs_fs_info *fs_info,
		3520	const struct iov_iter *iter, loff_t offset)
		3521	{
		3522	int ret;
		3523	int i, seg;
		3524
		3525	ret = check_direct_IO(fs_info, iter, offset);
		3526	if (ret < 0)
		3527	return ret;
		3528
		3529	for (seg = 0; seg < iter->nr_segs; seg++)
		3530	for (i = seg + 1; i < iter->nr_segs; i++)
		3531	if (iter->iov[seg].iov_base == iter->iov[i].iov_base)
		3532	return -EINVAL;
		3533	return 0;
		3534	}
		3535
		3536	static ssize_t btrfs_direct_read(struct kiocb iocb, struct iov_iter to)
		3537	{
		3538	struct inode *inode = file_inode(iocb->ki_filp);
		3539	ssize_t ret;
		3540
		3541	if (check_direct_read(btrfs_sb(inode->i_sb), to, iocb->ki_pos))
		3542	return 0;
		3543
		3544	inode_lock_shared(inode);
		3545	ret = iomap_dio_rw(iocb, to, &btrfs_dio_iomap_ops, &btrfs_dops,
		3546	is_sync_kiocb(iocb));
		3547	inode_unlock_shared(inode);
		3548	return ret;
		3549	}
		3550
		3551	static ssize_t btrfs_file_read_iter(struct kiocb iocb, struct iov_iter to)
		3552	{
		3553	ssize_t ret = 0;
		3554
		3555	if (iocb->ki_flags & IOCB_DIRECT) {
		3556	ret = btrfs_direct_read(iocb, to);
		3557	if (ret < 0)
		3558	return ret;
		3559	}
		3560
		3561	return generic_file_buffered_read(iocb, to, ret);
		3562	}
		3563
3487	const struct file_operations btrfs_file_operations = {	3564	const struct file_operations btrfs_file_operations = {
3488	.llseek = btrfs_file_llseek,	3565	.llseek = btrfs_file_llseek,
3489	.read_iter = generic_file_read_iter,	3566	.read_iter = btrfs_file_read_iter,
3490	.splice_read = generic_file_splice_read,	3567	.splice_read = generic_file_splice_read,
3491	.write_iter = btrfs_file_write_iter,	3568	.write_iter = btrfs_file_write_iter,
3492	.mmap = btrfs_file_mmap,	3569	.mmap = btrfs_file_mmap,

fs/btrfs/free-space-cache.c+17−64

 	 * sure NOFS is set to keep us from deadlocking.
 	 */
 	nofs_flag = memalloc_nofs_save();
-	inode = btrfs_iget_path(fs_info->sb, &location, root, path);
+	inode = btrfs_iget_path(fs_info->sb, location.objectid, root, path);
 	btrfs_release_path(path);
 	memalloc_nofs_restore(nofs_flag);
 	if (IS_ERR(inode))
 	if (ret) {
 		invalidate_inode_pages2(inode->i_mapping);
 		BTRFS_I(inode)->generation = 0;
-		if (block_group) {
+		if (block_group)
-#ifdef CONFIG_BTRFS_DEBUG
+			btrfs_debug(root->fs_info,
-			btrfs_err(root->fs_info,
+	  "failed to write free space cache for block group %llu error %d",
-				  "failed to write free space cache for block group %llu",
+				  block_group->start, ret);
-				  block_group->start);
-#endif
-		}
 	}
 	btrfs_update_inode(trans, root, inode);
 	ret = __btrfs_write_out_cache(fs_info->tree_root, inode, ctl,
 				block_group, &block_group->io_ctl, trans);
 	if (ret) {
-#ifdef CONFIG_BTRFS_DEBUG
+		btrfs_debug(fs_info,
-		btrfs_err(fs_info,
+	  "failed to write free space cache for block group %llu error %d",
-			  "failed to write free space cache for block group %llu",
+			  block_group->start, ret);
-			  block_group->start);
-#endif
 		spin_lock(&block_group->lock);
 		block_group->disk_cache_state = BTRFS_DC_ERROR;
 		spin_unlock(&block_group->lock);
 	return ret;
 }
-void btrfs_get_block_group_trimming(struct btrfs_block_group *cache)
-{
-	atomic_inc(&cache->trimming);
-}
-void btrfs_put_block_group_trimming(struct btrfs_block_group *block_group)
-{
-	struct btrfs_fs_info *fs_info = block_group->fs_info;
-	struct extent_map_tree *em_tree;
-	struct extent_map *em;
-	bool cleanup;
-	spin_lock(&block_group->lock);
-	cleanup = (atomic_dec_and_test(&block_group->trimming) &&
-		   block_group->removed);
-	spin_unlock(&block_group->lock);
-	if (cleanup) {
-		mutex_lock(&fs_info->chunk_mutex);
-		em_tree = &fs_info->mapping_tree;
-		write_lock(&em_tree->lock);
-		em = lookup_extent_mapping(em_tree, block_group->start,
-					   1);
-		BUG_ON(!em); /* logic error, can't happen */
-		remove_extent_mapping(em_tree, em);
-		write_unlock(&em_tree->lock);
-		mutex_unlock(&fs_info->chunk_mutex);
-		/* once for us and once for the tree */
-		free_extent_map(em);
-		free_extent_map(em);
-		/*
-		 * We've left one free space entry and other tasks trimming
-		 * this block group have left 1 entry each one. Free them.
-		 */
-		__btrfs_remove_free_space_cache(block_group->free_space_ctl);
-	}
-}
 int btrfs_trim_block_group(struct btrfs_block_group *block_group,
 			   u64 *trimmed, u64 start, u64 end, u64 minlen)
 {
 		spin_unlock(&block_group->lock);
 		return 0;
 	}
-	btrfs_get_block_group_trimming(block_group);
+	btrfs_freeze_block_group(block_group);
 	spin_unlock(&block_group->lock);
 	ret = trim_no_bitmap(block_group, trimmed, start, end, minlen, false);
 	if (rem)
 		reset_trimming_bitmap(ctl, offset_to_bitmap(ctl, end));
 out:
-	btrfs_put_block_group_trimming(block_group);
+	btrfs_unfreeze_block_group(block_group);
 	return ret;
 }
 		spin_unlock(&block_group->lock);
 		return 0;
 	}
-	btrfs_get_block_group_trimming(block_group);
+	btrfs_freeze_block_group(block_group);
 	spin_unlock(&block_group->lock);
 	ret = trim_no_bitmap(block_group, trimmed, start, end, minlen, async);
-	btrfs_put_block_group_trimming(block_group);
+	btrfs_unfreeze_block_group(block_group);
 	return ret;
 }
 		spin_unlock(&block_group->lock);
 		return 0;
 	}
-	btrfs_get_block_group_trimming(block_group);
+	btrfs_freeze_block_group(block_group);
 	spin_unlock(&block_group->lock);
 	ret = trim_bitmaps(block_group, trimmed, start, end, minlen, maxlen,
 			   async);
-	btrfs_put_block_group_trimming(block_group);
+	btrfs_unfreeze_block_group(block_group);
 	return ret;
 }
 		if (release_metadata)
 			btrfs_delalloc_release_metadata(BTRFS_I(inode),
 					inode->i_size, true);
-#ifdef CONFIG_BTRFS_DEBUG
+		btrfs_debug(fs_info,
-		btrfs_err(fs_info,
+			  "failed to write free ino cache for root %llu error %d",
-			  "failed to write free ino cache for root %llu",
+			  root->root_key.objectid, ret);
-			  root->root_key.objectid);
-#endif
 	}
 	return ret;

fs/btrfs/inode.c+452−867

@@ -5,7 +5,6 @@ · 4 unmodified lines
5		5
6	#include <linux/kernel.h>	6	#include <linux/kernel.h>
7	#include <linux/bio.h>	7	#include <linux/bio.h>
8	#include <linux/buffer_head.h>
9	#include <linux/file.h>	8	#include <linux/file.h>
10	#include <linux/fs.h>	9	#include <linux/fs.h>
11	#include <linux/pagemap.h>	10	#include <linux/pagemap.h>
@@ -49,17 +48,18 @@ · 37 unmodified lines
49	#include "qgroup.h"	48	#include "qgroup.h"
50	#include "delalloc-space.h"	49	#include "delalloc-space.h"
51	#include "block-group.h"	50	#include "block-group.h"
		51	#include "space-info.h"
52		52
53	struct btrfs_iget_args {	53	struct btrfs_iget_args {
54	struct btrfs_key *location;	54	u64 ino;
55	struct btrfs_root *root;	55	struct btrfs_root *root;
56	};	56	};
57		57
58	struct btrfs_dio_data {	58	struct btrfs_dio_data {
59	u64 reserve;	59	u64 reserve;
60	u64 unsubmitted_oe_range_start;	60	loff_t length;
61	u64 unsubmitted_oe_range_end;	61	ssize_t submitted;
62	int overwrite;	62	struct extent_changeset *data_reserved;
63	};	63	};
64		64
65	static const struct inode_operations btrfs_dir_inode_operations;	65	static const struct inode_operations btrfs_dir_inode_operations;
@@ -1142,7 +1142,7 @@ out_unlock: · 1076 unmodified lines
1142	*/	1142	*/
1143	if (extent_reserved) {	1143	if (extent_reserved) {
1144	extent_clear_unlock_delalloc(inode, start,	1144	extent_clear_unlock_delalloc(inode, start,
1145	start + cur_alloc_size,	1145	start + cur_alloc_size - 1,
1146	locked_page,	1146	locked_page,
1147	clear_bits,	1147	clear_bits,
1148	page_ops);	1148	page_ops);
@@ -1355,6 +1355,66 @@ static noinline int csum_exist_in_range(struct btrfs_fs_info *fs_info, · 206 unmodified lines
1355	return 1;	1355	return 1;
1356	}	1356	}
1357		1357
		1358	static int fallback_to_cow(struct inode inode, struct page locked_page,
		1359	const u64 start, const u64 end,
		1360	int page_started, unsigned long nr_written)
		1361	{
		1362	const bool is_space_ino = btrfs_is_free_space_inode(BTRFS_I(inode));
		1363	const u64 range_bytes = end + 1 - start;
		1364	struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
		1365	u64 range_start = start;
		1366	u64 count;
		1367
		1368	/*
		1369	* If EXTENT_NORESERVE is set it means that when the buffered write was
		1370	* made we had not enough available data space and therefore we did not
		1371	* reserve data space for it, since we though we could do NOCOW for the
		1372	* respective file range (either there is prealloc extent or the inode
		1373	* has the NOCOW bit set).
		1374	*
		1375	* However when we need to fallback to COW mode (because for example the
		1376	* block group for the corresponding extent was turned to RO mode by a
		1377	* scrub or relocation) we need to do the following:
		1378	*
		1379	* 1) We increment the bytes_may_use counter of the data space info.
		1380	* If COW succeeds, it allocates a new data extent and after doing
		1381	* that it decrements the space info's bytes_may_use counter and
		1382	* increments its bytes_reserved counter by the same amount (we do
		1383	* this at btrfs_add_reserved_bytes()). So we need to increment the
		1384	* bytes_may_use counter to compensate (when space is reserved at
		1385	* buffered write time, the bytes_may_use counter is incremented);
		1386	*
		1387	* 2) We clear the EXTENT_NORESERVE bit from the range. We do this so
		1388	* that if the COW path fails for any reason, it decrements (through
		1389	* extent_clear_unlock_delalloc()) the bytes_may_use counter of the
		1390	* data space info, which we incremented in the step above.
		1391	*
		1392	* If we need to fallback to cow and the inode corresponds to a free
		1393	* space cache inode, we must also increment bytes_may_use of the data
		1394	* space_info for the same reason. Space caches always get a prealloc
		1395	* extent for them, however scrub or balance may have set the block
		1396	* group that contains that extent to RO mode.
		1397	*/
		1398	count = count_range_bits(io_tree, &range_start, end, range_bytes,
		1399	EXTENT_NORESERVE, 0);
		1400	if (count > 0 \|\| is_space_ino) {
		1401	const u64 bytes = is_space_ino ? range_bytes : count;
		1402	struct btrfs_fs_info *fs_info = BTRFS_I(inode)->root->fs_info;
		1403	struct btrfs_space_info *sinfo = fs_info->data_sinfo;
		1404
		1405	spin_lock(&sinfo->lock);
		1406	btrfs_space_info_update_bytes_may_use(fs_info, sinfo, bytes);
		1407	spin_unlock(&sinfo->lock);
		1408
		1409	if (count > 0)
		1410	clear_extent_bit(io_tree, start, end, EXTENT_NORESERVE,
		1411	0, 0, NULL);
		1412	}
		1413
		1414	return cow_file_range(inode, locked_page, start, end, page_started,
		1415	nr_written, 1);
		1416	}
		1417
1358	/*	1418	/*
1359	* when nowcow writeback call back. This checks for snapshots or COW copies	1419	* when nowcow writeback call back. This checks for snapshots or COW copies
1360	* of the extents that exist in the file, and COWs the file as required.	1420	* of the extents that exist in the file, and COWs the file as required.
@@ -1602,9 +1662,9 @@ out_check: · 241 unmodified lines
1602	* NOCOW, following one which needs to be COW'ed	1662	* NOCOW, following one which needs to be COW'ed
1603	*/	1663	*/
1604	if (cow_start != (u64)-1) {	1664	if (cow_start != (u64)-1) {
1605	ret = cow_file_range(inode, locked_page,	1665	ret = fallback_to_cow(inode, locked_page, cow_start,
1606	cow_start, found_key.offset - 1,	1666	found_key.offset - 1,
1607	page_started, nr_written, 1);	1667	page_started, nr_written);
1608	if (ret) {	1668	if (ret) {
1609	if (nocow)	1669	if (nocow)
1610	btrfs_dec_nocow_writers(fs_info,	1670	btrfs_dec_nocow_writers(fs_info,
@@ -1693,8 +1753,8 @@ out_check: · 82 unmodified lines
1693		1753
1694	if (cow_start != (u64)-1) {	1754	if (cow_start != (u64)-1) {
1695	cur_offset = end;	1755	cur_offset = end;
1696	ret = cow_file_range(inode, locked_page, cow_start, end,	1756	ret = fallback_to_cow(inode, locked_page, cow_start, end,
1697	page_started, nr_written, 1);	1757	page_started, nr_written);
1698	if (ret)	1758	if (ret)
1699	goto error;	1759	goto error;
1700	}	1760	}
@@ -2726,10 +2786,9 @@ void btrfs_writepage_endio_finish_ordered(struct page *page, u64 start, · 1025 unmodified lines
2726	btrfs_queue_work(wq, &ordered_extent->work);	2786	btrfs_queue_work(wq, &ordered_extent->work);
2727	}	2787	}
2728		2788
2729	static int __readpage_endio_check(struct inode *inode,	2789	static int check_data_csum(struct inode inode, struct btrfs_io_bio io_bio,
2730	struct btrfs_io_bio *io_bio,	2790	int icsum, struct page *page, int pgoff, u64 start,
2731	int icsum, struct page *page,	2791	size_t len)
2732	int pgoff, u64 start, size_t len)
2733	{	2792	{
2734	struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);	2793	struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
2735	SHASH_DESC_ON_STACK(shash, fs_info->csum_shash);	2794	SHASH_DESC_ON_STACK(shash, fs_info->csum_shash);
@@ -2743,9 +2802,7 @@ static int __readpage_endio_check(struct inode *inode, · 7 unmodified lines
2743	kaddr = kmap_atomic(page);	2802	kaddr = kmap_atomic(page);
2744	shash->tfm = fs_info->csum_shash;	2803	shash->tfm = fs_info->csum_shash;
2745		2804
2746	crypto_shash_init(shash);	2805	crypto_shash_digest(shash, kaddr + pgoff, len, csum);
2747	crypto_shash_update(shash, kaddr + pgoff, len);
2748	crypto_shash_final(shash, csum);
2749		2806
2750	if (memcmp(csum, csum_expected, csum_size))	2807	if (memcmp(csum, csum_expected, csum_size))
2751	goto zeroit;	2808	goto zeroit;
@@ -2790,8 +2847,8 @@ static int btrfs_readpage_end_io_hook(struct btrfs_io_bio *io_bio, · 38 unmodified lines
2790	}	2847	}
2791		2848
2792	phy_offset >>= inode->i_sb->s_blocksize_bits;	2849	phy_offset >>= inode->i_sb->s_blocksize_bits;
2793	return __readpage_endio_check(inode, io_bio, phy_offset, page, offset,	2850	return check_data_csum(inode, io_bio, phy_offset, page, offset, start,
2794	start, (size_t)(end - start + 1));	2851	(size_t)(end - start + 1));
2795	}	2852	}
2796		2853
2797	/*	2854	/*
@@ -2981,7 +3038,7 @@ int btrfs_orphan_cleanup(struct btrfs_root *root) · 183 unmodified lines
2981	found_key.objectid = found_key.offset;	3038	found_key.objectid = found_key.offset;
2982	found_key.type = BTRFS_INODE_ITEM_KEY;	3039	found_key.type = BTRFS_INODE_ITEM_KEY;
2983	found_key.offset = 0;	3040	found_key.offset = 0;
2984	inode = btrfs_iget(fs_info->sb, &found_key, root);	3041	inode = btrfs_iget(fs_info->sb, last_objectid, root);
2985	ret = PTR_ERR_OR_ZERO(inode);	3042	ret = PTR_ERR_OR_ZERO(inode);
2986	if (ret && ret != -ENOENT)	3043	if (ret && ret != -ENOENT)
2987	goto out;	3044	goto out;
@@ -3000,18 +3057,16 @@ int btrfs_orphan_cleanup(struct btrfs_root *root) · 12 unmodified lines
3000	* orphan must not get deleted.	3057	* orphan must not get deleted.
3001	* find_dead_roots already ran before us, so if this	3058	* find_dead_roots already ran before us, so if this
3002	* is a snapshot deletion, we should find the root	3059	* is a snapshot deletion, we should find the root
3003	* in the dead_roots list	3060	* in the fs_roots radix tree.
3004	*/	3061	*/
3005	spin_lock(&fs_info->trans_lock);	3062
3006	list_for_each_entry(dead_root, &fs_info->dead_roots,	3063	spin_lock(&fs_info->fs_roots_radix_lock);
3007	root_list) {	3064	dead_root = radix_tree_lookup(&fs_info->fs_roots_radix,
3008	if (dead_root->root_key.objectid ==	3065	(unsigned long)found_key.objectid);
3009	found_key.objectid) {	3066	if (dead_root && btrfs_root_refs(&dead_root->root_item) == 0)
3010	is_dead_root = 1;	3067	is_dead_root = 1;
3011	break;	3068	spin_unlock(&fs_info->fs_roots_radix_lock);
3012	}	3069
3013	}
3014	spin_unlock(&fs_info->trans_lock);
3015	if (is_dead_root) {	3070	if (is_dead_root) {
3016	/* prevent this orphan from being found again */	3071	/* prevent this orphan from being found again */
3017	key.offset = found_key.objectid - 1;	3072	key.offset = found_key.objectid - 1;
@@ -3357,43 +3412,40 @@ static void fill_inode_item(struct btrfs_trans_handle *trans, · 339 unmodified lines
3357		3412
3358	btrfs_init_map_token(&token, leaf);	3413	btrfs_init_map_token(&token, leaf);
3359		3414
3360	btrfs_set_token_inode_uid(leaf, item, i_uid_read(inode), &token);	3415	btrfs_set_token_inode_uid(&token, item, i_uid_read(inode));
3361	btrfs_set_token_inode_gid(leaf, item, i_gid_read(inode), &token);	3416	btrfs_set_token_inode_gid(&token, item, i_gid_read(inode));
3362	btrfs_set_token_inode_size(leaf, item, BTRFS_I(inode)->disk_i_size,	3417	btrfs_set_token_inode_size(&token, item, BTRFS_I(inode)->disk_i_size);
3363	&token);	3418	btrfs_set_token_inode_mode(&token, item, inode->i_mode);
3364	btrfs_set_token_inode_mode(leaf, item, inode->i_mode, &token);	3419	btrfs_set_token_inode_nlink(&token, item, inode->i_nlink);
3365	btrfs_set_token_inode_nlink(leaf, item, inode->i_nlink, &token);	3420
3366		3421	btrfs_set_token_timespec_sec(&token, &item->atime,
3367	btrfs_set_token_timespec_sec(leaf, &item->atime,	3422	inode->i_atime.tv_sec);
3368	inode->i_atime.tv_sec, &token);	3423	btrfs_set_token_timespec_nsec(&token, &item->atime,
3369	btrfs_set_token_timespec_nsec(leaf, &item->atime,	3424	inode->i_atime.tv_nsec);
3370	inode->i_atime.tv_nsec, &token);	3425
3371		3426	btrfs_set_token_timespec_sec(&token, &item->mtime,
3372	btrfs_set_token_timespec_sec(leaf, &item->mtime,	3427	inode->i_mtime.tv_sec);
3373	inode->i_mtime.tv_sec, &token);	3428	btrfs_set_token_timespec_nsec(&token, &item->mtime,
3374	btrfs_set_token_timespec_nsec(leaf, &item->mtime,	3429	inode->i_mtime.tv_nsec);
3375	inode->i_mtime.tv_nsec, &token);	3430
3376		3431	btrfs_set_token_timespec_sec(&token, &item->ctime,
3377	btrfs_set_token_timespec_sec(leaf, &item->ctime,	3432	inode->i_ctime.tv_sec);
3378	inode->i_ctime.tv_sec, &token);	3433	btrfs_set_token_timespec_nsec(&token, &item->ctime,
3379	btrfs_set_token_timespec_nsec(leaf, &item->ctime,	3434	inode->i_ctime.tv_nsec);
3380	inode->i_ctime.tv_nsec, &token);	3435
3381		3436	btrfs_set_token_timespec_sec(&token, &item->otime,
3382	btrfs_set_token_timespec_sec(leaf, &item->otime,	3437	BTRFS_I(inode)->i_otime.tv_sec);
3383	BTRFS_I(inode)->i_otime.tv_sec, &token);	3438	btrfs_set_token_timespec_nsec(&token, &item->otime,
3384	btrfs_set_token_timespec_nsec(leaf, &item->otime,	3439	BTRFS_I(inode)->i_otime.tv_nsec);
3385	BTRFS_I(inode)->i_otime.tv_nsec, &token);	3440
3386		3441	btrfs_set_token_inode_nbytes(&token, item, inode_get_bytes(inode));
3387	btrfs_set_token_inode_nbytes(leaf, item, inode_get_bytes(inode),	3442	btrfs_set_token_inode_generation(&token, item,
3388	&token);	3443	BTRFS_I(inode)->generation);
3389	btrfs_set_token_inode_generation(leaf, item, BTRFS_I(inode)->generation,	3444	btrfs_set_token_inode_sequence(&token, item, inode_peek_iversion(inode));
3390	&token);	3445	btrfs_set_token_inode_transid(&token, item, trans->transid);
3391	btrfs_set_token_inode_sequence(leaf, item, inode_peek_iversion(inode),	3446	btrfs_set_token_inode_rdev(&token, item, inode->i_rdev);
3392	&token);	3447	btrfs_set_token_inode_flags(&token, item, BTRFS_I(inode)->flags);
3393	btrfs_set_token_inode_transid(leaf, item, trans->transid, &token);	3448	btrfs_set_token_inode_block_group(&token, item, 0);
3394	btrfs_set_token_inode_rdev(leaf, item, inode->i_rdev, &token);
3395	btrfs_set_token_inode_flags(leaf, item, BTRFS_I(inode)->flags, &token);
3396	btrfs_set_token_inode_block_group(leaf, item, 0, &token);
3397	}	3449	}
3398		3450
3399	/*	3451	/*
@@ -3618,7 +3670,7 @@ static struct btrfs_trans_handle __unlink_start_trans(struct inode dir) · 218 unmodified lines
3618	* 1 for the inode ref	3670	* 1 for the inode ref
3619	* 1 for the inode	3671	* 1 for the inode
3620	*/	3672	*/
3621	return btrfs_start_transaction_fallback_global_rsv(root, 5, 5);	3673	return btrfs_start_transaction_fallback_global_rsv(root, 5);
3622	}	3674	}
3623		3675
3624	static int btrfs_unlink(struct inode dir, struct dentry dentry)	3676	static int btrfs_unlink(struct inode dir, struct dentry dentry)
@@ -4108,11 +4160,12 @@ int btrfs_truncate_inode_items(struct btrfs_trans_handle *trans, · 483 unmodified lines
4108	BUG_ON(new_size > 0 && min_type != BTRFS_EXTENT_DATA_KEY);	4160	BUG_ON(new_size > 0 && min_type != BTRFS_EXTENT_DATA_KEY);
4109		4161
4110	/*	4162	/*
4111	* for non-free space inodes and ref cows, we want to back off from	4163	* For non-free space inodes and non-shareable roots, we want to back
4112	* time to time	4164	* off from time to time. This means all inodes in subvolume roots,
		4165	* reloc roots, and data reloc roots.
4113	*/	4166	*/
4114	if (!btrfs_is_free_space_inode(BTRFS_I(inode)) &&	4167	if (!btrfs_is_free_space_inode(BTRFS_I(inode)) &&
4115	test_bit(BTRFS_ROOT_REF_COWS, &root->state))	4168	test_bit(BTRFS_ROOT_SHAREABLE, &root->state))
4116	be_nice = true;	4169	be_nice = true;
4117		4170
4118	path = btrfs_alloc_path();	4171	path = btrfs_alloc_path();
@@ -4120,20 +4173,19 @@ int btrfs_truncate_inode_items(struct btrfs_trans_handle *trans, · 1 unmodified line
4120	return -ENOMEM;	4173	return -ENOMEM;
4121	path->reada = READA_BACK;	4174	path->reada = READA_BACK;
4122		4175
4123	if (root->root_key.objectid != BTRFS_TREE_LOG_OBJECTID)	4176	if (root->root_key.objectid != BTRFS_TREE_LOG_OBJECTID) {
4124	lock_extent_bits(&BTRFS_I(inode)->io_tree, lock_start, (u64)-1,	4177	lock_extent_bits(&BTRFS_I(inode)->io_tree, lock_start, (u64)-1,
4125	&cached_state);	4178	&cached_state);
4126		4179
4127	/*	4180	/*
4128	* We want to drop from the next block forward in case this new size is	4181	* We want to drop from the next block forward in case this
4129	* not block aligned since we will be keeping the last block of the	4182	* new size is not block aligned since we will be keeping the
4130	* extent just the way it is.	4183	* last block of the extent just the way it is.
4131	*/	4184	*/
4132	if (test_bit(BTRFS_ROOT_REF_COWS, &root->state) \|\|
4133	root == fs_info->tree_root)
4134	btrfs_drop_extent_cache(BTRFS_I(inode), ALIGN(new_size,	4185	btrfs_drop_extent_cache(BTRFS_I(inode), ALIGN(new_size,
4135	fs_info->sectorsize),	4186	fs_info->sectorsize),
4136	(u64)-1, 0);	4187	(u64)-1, 0);
		4188	}
4137		4189
4138	/*	4190	/*
4139	* This function is also used to drop the items in the log tree before	4191	* This function is also used to drop the items in the log tree before
@@ -4241,7 +4293,7 @@ search_again: · 101 unmodified lines
4241	extent_num_bytes);	4293	extent_num_bytes);
4242	num_dec = (orig_num_bytes -	4294	num_dec = (orig_num_bytes -
4243	extent_num_bytes);	4295	extent_num_bytes);
4244	if (test_bit(BTRFS_ROOT_REF_COWS,	4296	if (test_bit(BTRFS_ROOT_SHAREABLE,
4245	&root->state) &&	4297	&root->state) &&
4246	extent_start != 0)	4298	extent_start != 0)
4247	inode_sub_bytes(inode, num_dec);	4299	inode_sub_bytes(inode, num_dec);
@@ -4257,7 +4309,7 @@ search_again: · 9 unmodified lines
4257	num_dec = btrfs_file_extent_num_bytes(leaf, fi);	4309	num_dec = btrfs_file_extent_num_bytes(leaf, fi);
4258	if (extent_start != 0) {	4310	if (extent_start != 0) {
4259	found_extent = 1;	4311	found_extent = 1;
4260	if (test_bit(BTRFS_ROOT_REF_COWS,	4312	if (test_bit(BTRFS_ROOT_SHAREABLE,
4261	&root->state))	4313	&root->state))
4262	inode_sub_bytes(inode, num_dec);	4314	inode_sub_bytes(inode, num_dec);
4263	}	4315	}
@@ -4293,7 +4345,7 @@ search_again: · 29 unmodified lines
4293	clear_len = fs_info->sectorsize;	4345	clear_len = fs_info->sectorsize;
4294	}	4346	}
4295		4347
4296	if (test_bit(BTRFS_ROOT_REF_COWS, &root->state))	4348	if (test_bit(BTRFS_ROOT_SHAREABLE, &root->state))
4297	inode_sub_bytes(inode, item_end + 1 - new_size);	4349	inode_sub_bytes(inode, item_end + 1 - new_size);
4298	}	4350	}
4299	delete:	4351	delete:
@@ -4334,8 +4386,7 @@ delete: · 34 unmodified lines
4334	should_throttle = false;	4386	should_throttle = false;
4335		4387
4336	if (found_extent &&	4388	if (found_extent &&
4337	(test_bit(BTRFS_ROOT_REF_COWS, &root->state) \|\|	4389	root->root_key.objectid != BTRFS_TREE_LOG_OBJECTID) {
4338	root == fs_info->tree_root)) {
4339	struct btrfs_ref ref = { 0 };	4390	struct btrfs_ref ref = { 0 };
4340		4391
4341	bytes_deleted += extent_num_bytes;	4392	bytes_deleted += extent_num_bytes;
@@ -4759,10 +4810,7 @@ static int btrfs_setsize(struct inode inode, struct iattr attr) · 417 unmodified lines
4759		4810
4760	truncate_setsize(inode, newsize);	4811	truncate_setsize(inode, newsize);
4761		4812
4762	/* Disable nonlocked read DIO to avoid the endless truncate */
4763	btrfs_inode_block_unlocked_dio(BTRFS_I(inode));
4764	inode_dio_wait(inode);	4813	inode_dio_wait(inode);
4765	btrfs_inode_resume_unlocked_dio(BTRFS_I(inode));
4766		4814
4767	ret = btrfs_truncate(inode, newsize == oldsize);	4815	ret = btrfs_truncate(inode, newsize == oldsize);
4768	if (ret && inode->i_nlink) {	4816	if (ret && inode->i_nlink) {
@@ -5154,7 +5202,7 @@ static int fixup_tree_root_location(struct btrfs_fs_info *fs_info, · 385 unmodified lines
5154		5202
5155	btrfs_release_path(path);	5203	btrfs_release_path(path);
5156		5204
5157	new_root = btrfs_get_fs_root(fs_info, location, true);	5205	new_root = btrfs_get_fs_root(fs_info, location->objectid, true);
5158	if (IS_ERR(new_root)) {	5206	if (IS_ERR(new_root)) {
5159	err = PTR_ERR(new_root);	5207	err = PTR_ERR(new_root);
5160	goto out;	5208	goto out;
@@ -5232,9 +5280,11 @@ static void inode_tree_del(struct inode *inode) · 71 unmodified lines
5232	static int btrfs_init_locked_inode(struct inode inode, void p)	5280	static int btrfs_init_locked_inode(struct inode inode, void p)
5233	{	5281	{
5234	struct btrfs_iget_args *args = p;	5282	struct btrfs_iget_args *args = p;
5235	inode->i_ino = args->location->objectid;	5283
5236	memcpy(&BTRFS_I(inode)->location, args->location,	5284	inode->i_ino = args->ino;
5237	sizeof(*args->location));	5285	BTRFS_I(inode)->location.objectid = args->ino;
		5286	BTRFS_I(inode)->location.type = BTRFS_INODE_ITEM_KEY;
		5287	BTRFS_I(inode)->location.offset = 0;
5238	BTRFS_I(inode)->root = btrfs_grab_root(args->root);	5288	BTRFS_I(inode)->root = btrfs_grab_root(args->root);
5239	BUG_ON(args->root && !BTRFS_I(inode)->root);	5289	BUG_ON(args->root && !BTRFS_I(inode)->root);
5240	return 0;	5290	return 0;
@@ -5243,19 +5293,19 @@ static int btrfs_init_locked_inode(struct inode inode, void p) · 2 unmodified lines
5243	static int btrfs_find_actor(struct inode inode, void opaque)	5293	static int btrfs_find_actor(struct inode inode, void opaque)
5244	{	5294	{
5245	struct btrfs_iget_args *args = opaque;	5295	struct btrfs_iget_args *args = opaque;
5246	return args->location->objectid == BTRFS_I(inode)->location.objectid &&	5296
		5297	return args->ino == BTRFS_I(inode)->location.objectid &&
5247	args->root == BTRFS_I(inode)->root;	5298	args->root == BTRFS_I(inode)->root;
5248	}	5299	}
5249		5300
5250	static struct inode btrfs_iget_locked(struct super_block s,	5301	static struct inode btrfs_iget_locked(struct super_block s, u64 ino,
5251	struct btrfs_key *location,
5252	struct btrfs_root *root)	5302	struct btrfs_root *root)
5253	{	5303	{
5254	struct inode *inode;	5304	struct inode *inode;
5255	struct btrfs_iget_args args;	5305	struct btrfs_iget_args args;
5256	unsigned long hashval = btrfs_inode_hash(location->objectid, root);	5306	unsigned long hashval = btrfs_inode_hash(ino, root);
5257		5307
5258	args.location = location;	5308	args.ino = ino;
5259	args.root = root;	5309	args.root = root;
5260		5310
5261	inode = iget5_locked(s, hashval, btrfs_find_actor,	5311	inode = iget5_locked(s, hashval, btrfs_find_actor,
@@ -5265,17 +5315,17 @@ static struct inode btrfs_iget_locked(struct super_block s, · 3 unmodified lines
5265	}	5315	}
5266		5316
5267	/*	5317	/*
5268	* Get an inode object given its location and corresponding root.	5318	* Get an inode object given its inode number and corresponding root.
5269	* Path can be preallocated to prevent recursing back to iget through	5319	* Path can be preallocated to prevent recursing back to iget through
5270	* allocator. NULL is also valid but may require an additional allocation	5320	* allocator. NULL is also valid but may require an additional allocation
5271	* later.	5321	* later.
5272	*/	5322	*/
5273	struct inode btrfs_iget_path(struct super_block s, struct btrfs_key *location,	5323	struct inode btrfs_iget_path(struct super_block s, u64 ino,
5274	struct btrfs_root root, struct btrfs_path path)	5324	struct btrfs_root root, struct btrfs_path path)
5275	{	5325	{
5276	struct inode *inode;	5326	struct inode *inode;
5277		5327
5278	inode = btrfs_iget_locked(s, location, root);	5328	inode = btrfs_iget_locked(s, ino, root);
5279	if (!inode)	5329	if (!inode)
5280	return ERR_PTR(-ENOMEM);	5330	return ERR_PTR(-ENOMEM);
5281		5331
@@ -5302,10 +5352,9 @@ struct inode btrfs_iget_path(struct super_block s, struct btrfs_key *location, · 20 unmodified lines
5302	return inode;	5352	return inode;
5303	}	5353	}
5304		5354
5305	struct inode btrfs_iget(struct super_block s, struct btrfs_key *location,	5355	struct inode btrfs_iget(struct super_block s, u64 ino, struct btrfs_root *root)
5306	struct btrfs_root *root)
5307	{	5356	{
5308	return btrfs_iget_path(s, location, root, NULL);	5357	return btrfs_iget_path(s, ino, root, NULL);
5309	}	5358	}
5310		5359
5311	static struct inode new_simple_dir(struct super_block s,	5360	static struct inode new_simple_dir(struct super_block s,
@@ -5374,7 +5423,7 @@ struct inode btrfs_lookup_dentry(struct inode dir, struct dentry *dentry) · 62 unmodified lines
5374	return ERR_PTR(ret);	5423	return ERR_PTR(ret);
5375		5424
5376	if (location.type == BTRFS_INODE_ITEM_KEY) {	5425	if (location.type == BTRFS_INODE_ITEM_KEY) {
5377	inode = btrfs_iget(dir->i_sb, &location, root);	5426	inode = btrfs_iget(dir->i_sb, location.objectid, root);
5378	if (IS_ERR(inode))	5427	if (IS_ERR(inode))
5379	return inode;	5428	return inode;
5380		5429
@@ -5398,7 +5447,7 @@ struct inode btrfs_lookup_dentry(struct inode dir, struct dentry *dentry) · 17 unmodified lines
5398	else	5447	else
5399	inode = new_simple_dir(dir->i_sb, &location, sub_root);	5448	inode = new_simple_dir(dir->i_sb, &location, sub_root);
5400	} else {	5449	} else {
5401	inode = btrfs_iget(dir->i_sb, &location, sub_root);	5450	inode = btrfs_iget(dir->i_sb, location.objectid, sub_root);
5402	}	5451	}
5403	if (root != sub_root)	5452	if (root != sub_root)
5404	btrfs_put_root(sub_root);	5453	btrfs_put_root(sub_root);
@@ -5779,7 +5828,8 @@ int btrfs_set_inode_index(struct btrfs_inode dir, u64 index) · 374 unmodified lines
5779	static int btrfs_insert_inode_locked(struct inode *inode)	5828	static int btrfs_insert_inode_locked(struct inode *inode)
5780	{	5829	{
5781	struct btrfs_iget_args args;	5830	struct btrfs_iget_args args;
5782	args.location = &BTRFS_I(inode)->location;	5831
		5832	args.ino = BTRFS_I(inode)->location.objectid;
5783	args.root = BTRFS_I(inode)->root;	5833	args.root = BTRFS_I(inode)->root;
5784		5834
5785	return insert_inode_locked4(inode,	5835	return insert_inode_locked4(inode,
@@ -6991,7 +7041,7 @@ out: · 1205 unmodified lines
6991	}	7041	}
6992		7042
6993	static int lock_extent_direct(struct inode *inode, u64 lockstart, u64 lockend,	7043	static int lock_extent_direct(struct inode *inode, u64 lockstart, u64 lockend,
6994	struct extent_state **cached_state, int writing)	7044	struct extent_state **cached_state, bool writing)
6995	{	7045	{
6996	struct btrfs_ordered_extent *ordered;	7046	struct btrfs_ordered_extent *ordered;
6997	int ret = 0;	7047	int ret = 0;
@@ -7129,30 +7179,7 @@ static struct extent_map create_io_em(struct inode inode, u64 start, u64 len, · 131 unmodified lines
7129	}	7179	}
7130		7180
7131		7181
7132	static int btrfs_get_blocks_direct_read(struct extent_map *em,
7133	struct buffer_head *bh_result,
7134	struct inode *inode,
7135	u64 start, u64 len)
7136	{
7137	struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
7138
7139	if (em->block_start == EXTENT_MAP_HOLE \|\|
7140	test_bit(EXTENT_FLAG_PREALLOC, &em->flags))
7141	return -ENOENT;
7142
7143	len = min(len, em->len - (start - em->start));
7144
7145	bh_result->b_blocknr = (em->block_start + (start - em->start)) >>
7146	inode->i_blkbits;
7147	bh_result->b_size = len;
7148	bh_result->b_bdev = fs_info->fs_devices->latest_bdev;
7149	set_buffer_mapped(bh_result);
7150
7151	return 0;
7152	}
7153
7154	static int btrfs_get_blocks_direct_write(struct extent_map **map,	7182	static int btrfs_get_blocks_direct_write(struct extent_map **map,
7155	struct buffer_head *bh_result,
7156	struct inode *inode,	7183	struct inode *inode,
7157	struct btrfs_dio_data *dio_data,	7184	struct btrfs_dio_data *dio_data,
7158	u64 start, u64 len)	7185	u64 start, u64 len)
@@ -7214,7 +7241,6 @@ static int btrfs_get_blocks_direct_write(struct extent_map **map, · 55 unmodified lines
7214	}	7241	}
7215		7242
7216	/* this will cow the extent */	7243	/* this will cow the extent */
7217	len = bh_result->b_size;
7218	free_extent_map(em);	7244	free_extent_map(em);
7219	*map = em = btrfs_new_extent_direct(inode, start, len);	7245	*map = em = btrfs_new_extent_direct(inode, start, len);
7220	if (IS_ERR(em)) {	7246	if (IS_ERR(em)) {
@@ -7225,64 +7251,73 @@ static int btrfs_get_blocks_direct_write(struct extent_map **map, · 4 unmodified lines
7225	len = min(len, em->len - (start - em->start));	7251	len = min(len, em->len - (start - em->start));
7226		7252
7227	skip_cow:	7253	skip_cow:
7228	bh_result->b_blocknr = (em->block_start + (start - em->start)) >>
7229	inode->i_blkbits;
7230	bh_result->b_size = len;
7231	bh_result->b_bdev = fs_info->fs_devices->latest_bdev;
7232	set_buffer_mapped(bh_result);
7233
7234	if (!test_bit(EXTENT_FLAG_PREALLOC, &em->flags))
7235	set_buffer_new(bh_result);
7236
7237	/*	7254	/*
7238	* Need to update the i_size under the extent lock so buffered	7255	* Need to update the i_size under the extent lock so buffered
7239	* readers will get the updated i_size when we unlock.	7256	* readers will get the updated i_size when we unlock.
7240	*/	7257	*/
7241	if (!dio_data->overwrite && start + len > i_size_read(inode))	7258	if (start + len > i_size_read(inode))
7242	i_size_write(inode, start + len);	7259	i_size_write(inode, start + len);
7243		7260
7244	WARN_ON(dio_data->reserve < len);
7245	dio_data->reserve -= len;	7261	dio_data->reserve -= len;
7246	dio_data->unsubmitted_oe_range_end = start + len;
7247	current->journal_info = dio_data;
7248	out:	7262	out:
7249	return ret;	7263	return ret;
7250	}	7264	}
7251		7265
7252	static int btrfs_get_blocks_direct(struct inode *inode, sector_t iblock,	7266	static int btrfs_dio_iomap_begin(struct inode *inode, loff_t start,
7253	struct buffer_head *bh_result, int create)	7267	loff_t length, unsigned flags, struct iomap *iomap,
		7268	struct iomap *srcmap)
7254	{	7269	{
7255	struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);	7270	struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
7256	struct extent_map *em;	7271	struct extent_map *em;
7257	struct extent_state *cached_state = NULL;	7272	struct extent_state *cached_state = NULL;
7258	struct btrfs_dio_data *dio_data = NULL;	7273	struct btrfs_dio_data *dio_data = NULL;
7259	u64 start = iblock << inode->i_blkbits;
7260	u64 lockstart, lockend;	7274	u64 lockstart, lockend;
7261	u64 len = bh_result->b_size;	7275	const bool write = !!(flags & IOMAP_WRITE);
7262	int ret = 0;	7276	int ret = 0;
		7277	u64 len = length;
		7278	bool unlock_extents = false;
7263		7279
7264	if (!create)	7280	if (!write)
7265	len = min_t(u64, len, fs_info->sectorsize);	7281	len = min_t(u64, len, fs_info->sectorsize);
7266		7282
7267	lockstart = start;	7283	lockstart = start;
7268	lockend = start + len - 1;	7284	lockend = start + len - 1;
7269		7285
7270	if (current->journal_info) {	7286	/*
7271	/*	7287	* The generic stuff only does filemap_write_and_wait_range, which
7272	* Need to pull our outstanding extents and set journal_info to NULL so	7288	* isn't enough if we've written compressed pages to this area, so we
7273	* that anything that needs to check if there's a transaction doesn't get	7289	* need to flush the dirty pages again to make absolutely sure that any
7274	* confused.	7290	* outstanding dirty pages are on disk.
7275	*/	7291	*/
7276	dio_data = current->journal_info;	7292	if (test_bit(BTRFS_INODE_HAS_ASYNC_EXTENT,
7277	current->journal_info = NULL;	7293	&BTRFS_I(inode)->runtime_flags))
		7294	ret = filemap_fdatawrite_range(inode->i_mapping, start,
		7295	start + length - 1);
		7296
		7297	dio_data = kzalloc(sizeof(*dio_data), GFP_NOFS);
		7298	if (!dio_data)
		7299	return -ENOMEM;
		7300
		7301	dio_data->length = length;
		7302	if (write) {
		7303	dio_data->reserve = round_up(length, fs_info->sectorsize);
		7304	ret = btrfs_delalloc_reserve_space(inode,
		7305	&dio_data->data_reserved,
		7306	start, dio_data->reserve);
		7307	if (ret) {
		7308	extent_changeset_free(dio_data->data_reserved);
		7309	kfree(dio_data);
		7310	return ret;
		7311	}
7278	}	7312	}
		7313	iomap->private = dio_data;
		7314
7279		7315
7280	/*	7316	/*
7281	* If this errors out it's because we couldn't invalidate pagecache for	7317	* If this errors out it's because we couldn't invalidate pagecache for
7282	* this range and we need to fallback to buffered.	7318	* this range and we need to fallback to buffered.
7283	*/	7319	*/
7284	if (lock_extent_direct(inode, lockstart, lockend, &cached_state,	7320	if (lock_extent_direct(inode, lockstart, lockend, &cached_state, write)) {
7285	create)) {
7286	ret = -ENOTBLK;	7321	ret = -ENOTBLK;
7287	goto err;	7322	goto err;
7288	}	7323	}
@@ -7314,36 +7349,48 @@ static int btrfs_get_blocks_direct(struct inode *inode, sector_t iblock, · 25 unmodified lines
7314	goto unlock_err;	7349	goto unlock_err;
7315	}	7350	}
7316		7351
7317	if (create) {	7352	len = min(len, em->len - (start - em->start));
7318	ret = btrfs_get_blocks_direct_write(&em, bh_result, inode,	7353	if (write) {
7319	dio_data, start, len);	7354	ret = btrfs_get_blocks_direct_write(&em, inode, dio_data,
		7355	start, len);
7320	if (ret < 0)	7356	if (ret < 0)
7321	goto unlock_err;	7357	goto unlock_err;
7322		7358	unlock_extents = true;
7323	unlock_extent_cached(&BTRFS_I(inode)->io_tree, lockstart,	7359	/* Recalc len in case the new em is smaller than requested */
7324	lockend, &cached_state);	7360	len = min(len, em->len - (start - em->start));
7325	} else {	7361	} else {
7326	ret = btrfs_get_blocks_direct_read(em, bh_result, inode,
7327	start, len);
7328	/* Can be negative only if we read from a hole */
7329	if (ret < 0) {
7330	ret = 0;
7331	free_extent_map(em);
7332	goto unlock_err;
7333	}
7334	/*	7362	/*
7335	* We need to unlock only the end area that we aren't using.	7363	* We need to unlock only the end area that we aren't using.
7336	* The rest is going to be unlocked by the endio routine.	7364	* The rest is going to be unlocked by the endio routine.
7337	*/	7365	*/
7338	lockstart = start + bh_result->b_size;	7366	lockstart = start + len;
7339	if (lockstart < lockend) {	7367	if (lockstart < lockend)
7340	unlock_extent_cached(&BTRFS_I(inode)->io_tree,	7368	unlock_extents = true;
7341	lockstart, lockend, &cached_state);
7342	} else {
7343	free_extent_state(cached_state);
7344	}
7345	}	7369	}
7346		7370
		7371	if (unlock_extents)
		7372	unlock_extent_cached(&BTRFS_I(inode)->io_tree,
		7373	lockstart, lockend, &cached_state);
		7374	else
		7375	free_extent_state(cached_state);
		7376
		7377	/*
		7378	* Translate extent map information to iomap.
		7379	* We trim the extents (and move the addr) even though iomap code does
		7380	* that, since we have locked only the parts we are performing I/O in.
		7381	*/
		7382	if ((em->block_start == EXTENT_MAP_HOLE) \|\|
		7383	(test_bit(EXTENT_FLAG_PREALLOC, &em->flags) && !write)) {
		7384	iomap->addr = IOMAP_NULL_ADDR;
		7385	iomap->type = IOMAP_HOLE;
		7386	} else {
		7387	iomap->addr = em->block_start + (start - em->start);
		7388	iomap->type = IOMAP_MAPPED;
		7389	}
		7390	iomap->offset = start;
		7391	iomap->bdev = fs_info->fs_devices->latest_bdev;
		7392	iomap->length = len;
		7393
7347	free_extent_map(em);	7394	free_extent_map(em);
7348		7395
7349	return 0;	7396	return 0;
@@ -7352,370 +7399,152 @@ unlock_err: · 2 unmodified lines
7352	unlock_extent_cached(&BTRFS_I(inode)->io_tree, lockstart, lockend,	7399	unlock_extent_cached(&BTRFS_I(inode)->io_tree, lockstart, lockend,
7353	&cached_state);	7400	&cached_state);
7354	err:	7401	err:
7355	if (dio_data)	7402	if (dio_data) {
7356	current->journal_info = dio_data;	7403	btrfs_delalloc_release_space(inode, dio_data->data_reserved,
		7404	start, dio_data->reserve, true);
		7405	btrfs_delalloc_release_extents(BTRFS_I(inode), dio_data->reserve);
		7406	extent_changeset_free(dio_data->data_reserved);
		7407	kfree(dio_data);
		7408	}
7357	return ret;	7409	return ret;
7358	}	7410	}
7359		7411
7360	static inline blk_status_t submit_dio_repair_bio(struct inode *inode,	7412	static int btrfs_dio_iomap_end(struct inode *inode, loff_t pos, loff_t length,
7361	struct bio *bio,	7413	ssize_t written, unsigned flags, struct iomap *iomap)
7362	int mirror_num)
7363	{	7414	{
7364	struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);	7415	int ret = 0;
7365	blk_status_t ret;	7416	struct btrfs_dio_data *dio_data = iomap->private;
		7417	size_t submitted = dio_data->submitted;
		7418	const bool write = !!(flags & IOMAP_WRITE);
7366		7419
7367	BUG_ON(bio_op(bio) == REQ_OP_WRITE);	7420	if (!write && (iomap->type == IOMAP_HOLE)) {
		7421	/* If reading from a hole, unlock and return */
		7422	unlock_extent(&BTRFS_I(inode)->io_tree, pos, pos + length - 1);
		7423	goto out;
		7424	}
7368		7425
7369	ret = btrfs_bio_wq_end_io(fs_info, bio, BTRFS_WQ_ENDIO_DIO_REPAIR);	7426	if (submitted < length) {
7370	if (ret)	7427	pos += submitted;
7371	return ret;	7428	length -= submitted;
		7429	if (write)
		7430	__endio_write_update_ordered(inode, pos, length, false);
		7431	else
		7432	unlock_extent(&BTRFS_I(inode)->io_tree, pos,
		7433	pos + length - 1);
		7434	ret = -ENOTBLK;
		7435	}
7372		7436
7373	ret = btrfs_map_bio(fs_info, bio, mirror_num);	7437	if (write) {
		7438	if (dio_data->reserve)
		7439	btrfs_delalloc_release_space(inode,
		7440	dio_data->data_reserved, pos,
		7441	dio_data->reserve, true);
		7442	btrfs_delalloc_release_extents(BTRFS_I(inode), dio_data->length);
		7443	extent_changeset_free(dio_data->data_reserved);
		7444	}
		7445	out:
		7446	kfree(dio_data);
		7447	iomap->private = NULL;
7374		7448
7375	return ret;	7449	return ret;
7376	}	7450	}
7377		7451
7378	static int btrfs_check_dio_repairable(struct inode *inode,	7452	static void btrfs_dio_private_put(struct btrfs_dio_private *dip)
7379	struct bio *failed_bio,
7380	struct io_failure_record *failrec,
7381	int failed_mirror)
7382	{	7453	{
7383	struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);	7454	/*
7384	int num_copies;	7455	* This implies a barrier so that stores to dio_bio->bi_status before
7385		7456	* this and loads of dio_bio->bi_status after this are fully ordered.
7386	num_copies = btrfs_num_copies(fs_info, failrec->logical, failrec->len);	7457	*/
7387	if (num_copies == 1) {	7458	if (!refcount_dec_and_test(&dip->refs))
7388	/*	7459	return;
7389	* we only have a single copy of the data, so don't bother with
7390	* all the retry and error correction code that follows. no
7391	* matter what the error is, it is very likely to persist.
7392	*/
7393	btrfs_debug(fs_info,
7394	"Check DIO Repairable: cannot repair, num_copies=%d, next_mirror %d, failed_mirror %d",
7395	num_copies, failrec->this_mirror, failed_mirror);
7396	return 0;
7397	}
7398
7399	failrec->failed_mirror = failed_mirror;
7400	failrec->this_mirror++;
7401	if (failrec->this_mirror == failed_mirror)
7402	failrec->this_mirror++;
7403		7460
7404	if (failrec->this_mirror > num_copies) {	7461	if (bio_op(dip->dio_bio) == REQ_OP_WRITE) {
7405	btrfs_debug(fs_info,	7462	__endio_write_update_ordered(dip->inode, dip->logical_offset,
7406	"Check DIO Repairable: (fail) num_copies=%d, next_mirror %d, failed_mirror %d",	7463	dip->bytes,
7407	num_copies, failrec->this_mirror, failed_mirror);	7464	!dip->dio_bio->bi_status);
7408	return 0;	7465	} else {
		7466	unlock_extent(&BTRFS_I(dip->inode)->io_tree,
		7467	dip->logical_offset,
		7468	dip->logical_offset + dip->bytes - 1);
7409	}	7469	}
7410		7470
7411	return 1;	7471	bio_endio(dip->dio_bio);
		7472	kfree(dip);
7412	}	7473	}
7413		7474
7414	static blk_status_t dio_read_error(struct inode inode, struct bio failed_bio,	7475	static blk_status_t submit_dio_repair_bio(struct inode inode, struct bio bio,
7415	struct page *page, unsigned int pgoff,	7476	int mirror_num,
7416	u64 start, u64 end, int failed_mirror,	7477	unsigned long bio_flags)
7417	bio_end_io_t repair_endio, void repair_arg)
7418	{	7478	{
7419	struct io_failure_record *failrec;	7479	struct btrfs_dio_private *dip = bio->bi_private;
7420	struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;	7480	struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
7421	struct extent_io_tree *failure_tree = &BTRFS_I(inode)->io_failure_tree;	7481	blk_status_t ret;
7422	struct bio *bio;
7423	int isector;
7424	unsigned int read_mode = 0;
7425	int segs;
7426	int ret;
7427	blk_status_t status;
7428	struct bio_vec bvec;
7429		7482
7430	BUG_ON(bio_op(failed_bio) == REQ_OP_WRITE);	7483	BUG_ON(bio_op(bio) == REQ_OP_WRITE);
7431		7484
7432	ret = btrfs_get_io_failure_record(inode, start, end, &failrec);	7485	ret = btrfs_bio_wq_end_io(fs_info, bio, BTRFS_WQ_ENDIO_DATA);
7433	if (ret)	7486	if (ret)
7434	return errno_to_blk_status(ret);	7487	return ret;
7435
7436	ret = btrfs_check_dio_repairable(inode, failed_bio, failrec,
7437	failed_mirror);
7438	if (!ret) {
7439	free_io_failure(failure_tree, io_tree, failrec);
7440	return BLK_STS_IOERR;
7441	}
7442
7443	segs = bio_segments(failed_bio);
7444	bio_get_first_bvec(failed_bio, &bvec);
7445	if (segs > 1 \|\|
7446	(bvec.bv_len > btrfs_inode_sectorsize(inode)))
7447	read_mode \|= REQ_FAILFAST_DEV;
7448
7449	isector = start - btrfs_io_bio(failed_bio)->logical;
7450	isector >>= inode->i_sb->s_blocksize_bits;
7451	bio = btrfs_create_repair_bio(inode, failed_bio, failrec, page,
7452	pgoff, isector, repair_endio, repair_arg);
7453	bio->bi_opf = REQ_OP_READ \| read_mode;
7454
7455	btrfs_debug(BTRFS_I(inode)->root->fs_info,
7456	"repair DIO read error: submitting new dio read[%#x] to this_mirror=%d, in_validation=%d",
7457	read_mode, failrec->this_mirror, failrec->in_validation);
7458
7459	status = submit_dio_repair_bio(inode, bio, failrec->this_mirror);
7460	if (status) {
7461	free_io_failure(failure_tree, io_tree, failrec);
7462	bio_put(bio);
7463	}
7464
7465	return status;
7466	}
7467
7468	struct btrfs_retry_complete {
7469	struct completion done;
7470	struct inode *inode;
7471	u64 start;
7472	int uptodate;
7473	};
7474		7488
7475	static void btrfs_retry_endio_nocsum(struct bio *bio)	7489	refcount_inc(&dip->refs);
7476	{	7490	ret = btrfs_map_bio(fs_info, bio, mirror_num);
7477	struct btrfs_retry_complete *done = bio->bi_private;	7491	if (ret)
7478	struct inode *inode = done->inode;	7492	refcount_dec(&dip->refs);
7479	struct bio_vec *bvec;	7493	return ret;
7480	struct extent_io_tree io_tree, failure_tree;
7481	struct bvec_iter_all iter_all;
7482
7483	if (bio->bi_status)
7484	goto end;
7485
7486	ASSERT(bio->bi_vcnt == 1);
7487	io_tree = &BTRFS_I(inode)->io_tree;
7488	failure_tree = &BTRFS_I(inode)->io_failure_tree;
7489	ASSERT(bio_first_bvec_all(bio)->bv_len == btrfs_inode_sectorsize(inode));
7490
7491	done->uptodate = 1;
7492	ASSERT(!bio_flagged(bio, BIO_CLONED));
7493	bio_for_each_segment_all(bvec, bio, iter_all)
7494	clean_io_failure(BTRFS_I(inode)->root->fs_info, failure_tree,
7495	io_tree, done->start, bvec->bv_page,
7496	btrfs_ino(BTRFS_I(inode)), 0);
7497	end:
7498	complete(&done->done);
7499	bio_put(bio);
7500	}	7494	}
7501		7495
7502	static blk_status_t __btrfs_correct_data_nocsum(struct inode *inode,	7496	static blk_status_t btrfs_check_read_dio_bio(struct inode *inode,
7503	struct btrfs_io_bio *io_bio)	7497	struct btrfs_io_bio *io_bio,
		7498	const bool uptodate)
7504	{	7499	{
7505	struct btrfs_fs_info *fs_info;	7500	struct btrfs_fs_info *fs_info = BTRFS_I(inode)->root->fs_info;
		7501	const u32 sectorsize = fs_info->sectorsize;
		7502	struct extent_io_tree *failure_tree = &BTRFS_I(inode)->io_failure_tree;
		7503	struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
		7504	const bool csum = !(BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM);
7506	struct bio_vec bvec;	7505	struct bio_vec bvec;
7507	struct bvec_iter iter;	7506	struct bvec_iter iter;
7508	struct btrfs_retry_complete done;	7507	u64 start = io_bio->logical;
7509	u64 start;	7508	int icsum = 0;
7510	unsigned int pgoff;
7511	u32 sectorsize;
7512	int nr_sectors;
7513	blk_status_t ret;
7514	blk_status_t err = BLK_STS_OK;	7509	blk_status_t err = BLK_STS_OK;
7515		7510
7516	fs_info = BTRFS_I(inode)->root->fs_info;	7511	__bio_for_each_segment(bvec, &io_bio->bio, iter, io_bio->iter) {
7517	sectorsize = fs_info->sectorsize;	7512	unsigned int i, nr_sectors, pgoff;
7518
7519	start = io_bio->logical;
7520	done.inode = inode;
7521	io_bio->bio.bi_iter = io_bio->iter;
7522		7513
7523	bio_for_each_segment(bvec, &io_bio->bio, iter) {
7524	nr_sectors = BTRFS_BYTES_TO_BLKS(fs_info, bvec.bv_len);	7514	nr_sectors = BTRFS_BYTES_TO_BLKS(fs_info, bvec.bv_len);
7525	pgoff = bvec.bv_offset;	7515	pgoff = bvec.bv_offset;
7526		7516	for (i = 0; i < nr_sectors; i++) {
7527	next_block_or_try_again:
7528	done.uptodate = 0;
7529	done.start = start;
7530	init_completion(&done.done);
7531
7532	ret = dio_read_error(inode, &io_bio->bio, bvec.bv_page,
7533	pgoff, start, start + sectorsize - 1,
7534	io_bio->mirror_num,
7535	btrfs_retry_endio_nocsum, &done);
7536	if (ret) {
7537	err = ret;
7538	goto next;
7539	}
7540
7541	wait_for_completion_io(&done.done);
7542
7543	if (!done.uptodate) {
7544	/* We might have another mirror, so try again */
7545	goto next_block_or_try_again;
7546	}
7547
7548	next:
7549	start += sectorsize;
7550
7551	nr_sectors--;
7552	if (nr_sectors) {
7553	pgoff += sectorsize;
7554	ASSERT(pgoff < PAGE_SIZE);	7517	ASSERT(pgoff < PAGE_SIZE);
7555	goto next_block_or_try_again;	7518	if (uptodate &&
7556	}	7519	(!csum \|\| !check_data_csum(inode, io_bio, icsum,
7557	}	7520	bvec.bv_page, pgoff,
7558		7521	start, sectorsize))) {
7559	return err;	7522	clean_io_failure(fs_info, failure_tree, io_tree,
7560	}	7523	start, bvec.bv_page,
7561		7524	btrfs_ino(BTRFS_I(inode)),
7562	static void btrfs_retry_endio(struct bio *bio)	7525	pgoff);
7563	{	7526	} else {
7564	struct btrfs_retry_complete *done = bio->bi_private;	7527	blk_status_t status;
7565	struct btrfs_io_bio *io_bio = btrfs_io_bio(bio);	7528
7566	struct extent_io_tree io_tree, failure_tree;	7529	status = btrfs_submit_read_repair(inode,
7567	struct inode *inode = done->inode;	7530	&io_bio->bio,
7568	struct bio_vec *bvec;	7531	start - io_bio->logical,
7569	int uptodate;	7532	bvec.bv_page, pgoff,
7570	int ret;	7533	start,
7571	int i = 0;	7534	start + sectorsize - 1,
7572	struct bvec_iter_all iter_all;	7535	io_bio->mirror_num,
7573		7536	submit_dio_repair_bio);
7574	if (bio->bi_status)	7537	if (status)
7575	goto end;	7538	err = status;
7576		7539	}
7577	uptodate = 1;	7540	start += sectorsize;
7578		7541	icsum++;
7579	ASSERT(bio->bi_vcnt == 1);
7580	ASSERT(bio_first_bvec_all(bio)->bv_len == btrfs_inode_sectorsize(done->inode));
7581
7582	io_tree = &BTRFS_I(inode)->io_tree;
7583	failure_tree = &BTRFS_I(inode)->io_failure_tree;
7584
7585	ASSERT(!bio_flagged(bio, BIO_CLONED));
7586	bio_for_each_segment_all(bvec, bio, iter_all) {
7587	ret = __readpage_endio_check(inode, io_bio, i, bvec->bv_page,
7588	bvec->bv_offset, done->start,
7589	bvec->bv_len);
7590	if (!ret)
7591	clean_io_failure(BTRFS_I(inode)->root->fs_info,
7592	failure_tree, io_tree, done->start,
7593	bvec->bv_page,
7594	btrfs_ino(BTRFS_I(inode)),
7595	bvec->bv_offset);
7596	else
7597	uptodate = 0;
7598	i++;
7599	}
7600
7601	done->uptodate = uptodate;
7602	end:
7603	complete(&done->done);
7604	bio_put(bio);
7605	}
7606
7607	static blk_status_t __btrfs_subio_endio_read(struct inode *inode,
7608	struct btrfs_io_bio *io_bio, blk_status_t err)
7609	{
7610	struct btrfs_fs_info *fs_info;
7611	struct bio_vec bvec;
7612	struct bvec_iter iter;
7613	struct btrfs_retry_complete done;
7614	u64 start;
7615	u64 offset = 0;
7616	u32 sectorsize;
7617	int nr_sectors;
7618	unsigned int pgoff;
7619	int csum_pos;
7620	bool uptodate = (err == 0);
7621	int ret;
7622	blk_status_t status;
7623
7624	fs_info = BTRFS_I(inode)->root->fs_info;
7625	sectorsize = fs_info->sectorsize;
7626
7627	err = BLK_STS_OK;
7628	start = io_bio->logical;
7629	done.inode = inode;
7630	io_bio->bio.bi_iter = io_bio->iter;
7631
7632	bio_for_each_segment(bvec, &io_bio->bio, iter) {
7633	nr_sectors = BTRFS_BYTES_TO_BLKS(fs_info, bvec.bv_len);
7634
7635	pgoff = bvec.bv_offset;
7636	next_block:
7637	if (uptodate) {
7638	csum_pos = BTRFS_BYTES_TO_BLKS(fs_info, offset);
7639	ret = __readpage_endio_check(inode, io_bio, csum_pos,
7640	bvec.bv_page, pgoff, start, sectorsize);
7641	if (likely(!ret))
7642	goto next;
7643	}
7644	try_again:
7645	done.uptodate = 0;
7646	done.start = start;
7647	init_completion(&done.done);
7648
7649	status = dio_read_error(inode, &io_bio->bio, bvec.bv_page,
7650	pgoff, start, start + sectorsize - 1,
7651	io_bio->mirror_num, btrfs_retry_endio,
7652	&done);
7653	if (status) {
7654	err = status;
7655	goto next;
7656	}
7657
7658	wait_for_completion_io(&done.done);
7659
7660	if (!done.uptodate) {
7661	/* We might have another mirror, so try again */
7662	goto try_again;
7663	}
7664	next:
7665	offset += sectorsize;
7666	start += sectorsize;
7667
7668	ASSERT(nr_sectors);
7669
7670	nr_sectors--;
7671	if (nr_sectors) {
7672	pgoff += sectorsize;	7542	pgoff += sectorsize;
7673	ASSERT(pgoff < PAGE_SIZE);
7674	goto next_block;
7675	}	7543	}
7676	}	7544	}
7677
7678	return err;	7545	return err;
7679	}	7546	}
7680		7547
7681	static blk_status_t btrfs_subio_endio_read(struct inode *inode,
7682	struct btrfs_io_bio *io_bio, blk_status_t err)
7683	{
7684	bool skip_csum = BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM;
7685
7686	if (skip_csum) {
7687	if (unlikely(err))
7688	return __btrfs_correct_data_nocsum(inode, io_bio);
7689	else
7690	return BLK_STS_OK;
7691	} else {
7692	return __btrfs_subio_endio_read(inode, io_bio, err);
7693	}
7694	}
7695
7696	static void btrfs_endio_direct_read(struct bio *bio)
7697	{
7698	struct btrfs_dio_private *dip = bio->bi_private;
7699	struct inode *inode = dip->inode;
7700	struct bio *dio_bio;
7701	struct btrfs_io_bio *io_bio = btrfs_io_bio(bio);
7702	blk_status_t err = bio->bi_status;
7703
7704	if (dip->flags & BTRFS_DIO_ORIG_BIO_SUBMITTED)
7705	err = btrfs_subio_endio_read(inode, io_bio, err);
7706
7707	unlock_extent(&BTRFS_I(inode)->io_tree, dip->logical_offset,
7708	dip->logical_offset + dip->bytes - 1);
7709	dio_bio = dip->dio_bio;
7710
7711	kfree(dip);
7712
7713	dio_bio->bi_status = err;
7714	dio_end_io(dio_bio);
7715	btrfs_io_bio_free_csum(io_bio);
7716	bio_put(bio);
7717	}
7718
7719	static void __endio_write_update_ordered(struct inode *inode,	7548	static void __endio_write_update_ordered(struct inode *inode,
7720	const u64 offset, const u64 bytes,	7549	const u64 offset, const u64 bytes,
7721	const bool uptodate)	7550	const bool uptodate)
@@ -7759,21 +7588,6 @@ static void __endio_write_update_ordered(struct inode *inode, · 37 unmodified lines
7759	}	7588	}
7760	}	7589	}
7761		7590
7762	static void btrfs_endio_direct_write(struct bio *bio)
7763	{
7764	struct btrfs_dio_private *dip = bio->bi_private;
7765	struct bio *dio_bio = dip->dio_bio;
7766
7767	__endio_write_update_ordered(dip->inode, dip->logical_offset,
7768	dip->bytes, !bio->bi_status);
7769
7770	kfree(dip);
7771
7772	dio_bio->bi_status = bio->bi_status;
7773	dio_end_io(dio_bio);
7774	bio_put(bio);
7775	}
7776
7777	static blk_status_t btrfs_submit_bio_start_direct_io(void *private_data,	7591	static blk_status_t btrfs_submit_bio_start_direct_io(void *private_data,
7778	struct bio *bio, u64 offset)	7592	struct bio *bio, u64 offset)
7779	{	7593	{
@@ -7797,64 +7611,16 @@ static void btrfs_end_dio_bio(struct bio *bio) · 17 unmodified lines
7797	(unsigned long long)bio->bi_iter.bi_sector,	7611	(unsigned long long)bio->bi_iter.bi_sector,
7798	bio->bi_iter.bi_size, err);	7612	bio->bi_iter.bi_size, err);
7799		7613
7800	if (dip->subio_endio)	7614	if (bio_op(bio) == REQ_OP_READ) {
7801	err = dip->subio_endio(dip->inode, btrfs_io_bio(bio), err);	7615	err = btrfs_check_read_dio_bio(dip->inode, btrfs_io_bio(bio),
7802		7616	!err);
7803	if (err) {
7804	/*
7805	* We want to perceive the errors flag being set before
7806	* decrementing the reference count. We don't need a barrier
7807	* since atomic operations with a return value are fully
7808	* ordered as per atomic_t.txt
7809	*/
7810	dip->errors = 1;
7811	}	7617	}
7812		7618
7813	/* if there are more bios still pending for this dio, just exit */	7619	if (err)
7814	if (!atomic_dec_and_test(&dip->pending_bios))	7620	dip->dio_bio->bi_status = err;
7815	goto out;
7816		7621
7817	if (dip->errors) {
7818	bio_io_error(dip->orig_bio);
7819	} else {
7820	dip->dio_bio->bi_status = BLK_STS_OK;
7821	bio_endio(dip->orig_bio);
7822	}
7823	out:
7824	bio_put(bio);	7622	bio_put(bio);
7825	}	7623	btrfs_dio_private_put(dip);
7826
7827	static inline blk_status_t btrfs_lookup_and_bind_dio_csum(struct inode *inode,
7828	struct btrfs_dio_private *dip,
7829	struct bio *bio,
7830	u64 file_offset)
7831	{
7832	struct btrfs_io_bio *io_bio = btrfs_io_bio(bio);
7833	struct btrfs_io_bio *orig_io_bio = btrfs_io_bio(dip->orig_bio);
7834	u16 csum_size;
7835	blk_status_t ret;
7836
7837	/*
7838	* We load all the csum data we need when we submit
7839	* the first bio to reduce the csum tree search and
7840	* contention.
7841	*/
7842	if (dip->logical_offset == file_offset) {
7843	ret = btrfs_lookup_bio_sums(inode, dip->orig_bio, file_offset,
7844	NULL);
7845	if (ret)
7846	return ret;
7847	}
7848
7849	if (bio == dip->orig_bio)
7850	return 0;
7851
7852	file_offset -= dip->logical_offset;
7853	file_offset >>= inode->i_sb->s_blocksize_bits;
7854	csum_size = btrfs_super_csum_size(btrfs_sb(inode->i_sb)->super_copy);
7855	io_bio->csum = orig_io_bio->csum + csum_size * file_offset;
7856
7857	return 0;
7858	}	7624	}
7859		7625
7860	static inline blk_status_t btrfs_submit_dio_bio(struct bio *bio,	7626	static inline blk_status_t btrfs_submit_dio_bio(struct bio *bio,
@@ -7892,10 +7658,12 @@ static inline blk_status_t btrfs_submit_dio_bio(struct bio *bio, · 31 unmodified lines
7892	if (ret)	7658	if (ret)
7893	goto err;	7659	goto err;
7894	} else {	7660	} else {
7895	ret = btrfs_lookup_and_bind_dio_csum(inode, dip, bio,	7661	u64 csum_offset;
7896	file_offset);	7662
7897	if (ret)	7663	csum_offset = file_offset - dip->logical_offset;
7898	goto err;	7664	csum_offset >>= inode->i_sb->s_blocksize_bits;
		7665	csum_offset *= btrfs_super_csum_size(fs_info->super_copy);
		7666	btrfs_io_bio(bio)->csum = dip->csums + csum_offset;
7899	}	7667	}
7900	map:	7668	map:
7901	ret = btrfs_map_bio(fs_info, bio, 0);	7669	ret = btrfs_map_bio(fs_info, bio, 0);
@@ -7903,14 +7671,53 @@ err: · 1 unmodified line
7903	return ret;	7671	return ret;
7904	}	7672	}
7905		7673
7906	static int btrfs_submit_direct_hook(struct btrfs_dio_private *dip)	7674	/*
		7675	* If this succeeds, the btrfs_dio_private is responsible for cleaning up locked
		7676	* or ordered extents whether or not we submit any bios.
		7677	*/
		7678	static struct btrfs_dio_private btrfs_create_dio_private(struct bio dio_bio,
		7679	struct inode *inode,
		7680	loff_t file_offset)
7907	{	7681	{
7908	struct inode *inode = dip->inode;	7682	const bool write = (bio_op(dio_bio) == REQ_OP_WRITE);
		7683	const bool csum = !(BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM);
		7684	size_t dip_size;
		7685	struct btrfs_dio_private *dip;
		7686
		7687	dip_size = sizeof(*dip);
		7688	if (!write && csum) {
		7689	struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
		7690	const u16 csum_size = btrfs_super_csum_size(fs_info->super_copy);
		7691	size_t nblocks;
		7692
		7693	nblocks = dio_bio->bi_iter.bi_size >> inode->i_sb->s_blocksize_bits;
		7694	dip_size += csum_size * nblocks;
		7695	}
		7696
		7697	dip = kzalloc(dip_size, GFP_NOFS);
		7698	if (!dip)
		7699	return NULL;
		7700
		7701	dip->inode = inode;
		7702	dip->logical_offset = file_offset;
		7703	dip->bytes = dio_bio->bi_iter.bi_size;
		7704	dip->disk_bytenr = (u64)dio_bio->bi_iter.bi_sector << 9;
		7705	dip->dio_bio = dio_bio;
		7706	refcount_set(&dip->refs, 1);
		7707	return dip;
		7708	}
		7709
		7710	static blk_qc_t btrfs_submit_direct(struct inode inode, struct iomap iomap,
		7711	struct bio *dio_bio, loff_t file_offset)
		7712	{
		7713	const bool write = (bio_op(dio_bio) == REQ_OP_WRITE);
		7714	const bool csum = !(BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM);
7909	struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);	7715	struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
		7716	const bool raid56 = (btrfs_data_alloc_profile(fs_info) &
		7717	BTRFS_BLOCK_GROUP_RAID56_MASK);
		7718	struct btrfs_dio_private *dip;
7910	struct bio *bio;	7719	struct bio *bio;
7911	struct bio *orig_bio = dip->orig_bio;	7720	u64 start_sector;
7912	u64 start_sector = orig_bio->bi_iter.bi_sector;
7913	u64 file_offset = dip->logical_offset;
7914	int async_submit = 0;	7721	int async_submit = 0;
7915	u64 submit_len;	7722	u64 submit_len;
7916	int clone_offset = 0;	7723	int clone_offset = 0;
@@ -7918,330 +7725,108 @@ static int btrfs_submit_direct_hook(struct btrfs_dio_private *dip) · 1 unmodified line
7918	int ret;	7725	int ret;
7919	blk_status_t status;	7726	blk_status_t status;
7920	struct btrfs_io_geometry geom;	7727	struct btrfs_io_geometry geom;
		7728	struct btrfs_dio_data *dio_data = iomap->private;
7921		7729
7922	submit_len = orig_bio->bi_iter.bi_size;	7730	dip = btrfs_create_dio_private(dio_bio, inode, file_offset);
7923	ret = btrfs_get_io_geometry(fs_info, btrfs_op(orig_bio),	7731	if (!dip) {
7924	start_sector << 9, submit_len, &geom);	7732	if (!write) {
7925	if (ret)	7733	unlock_extent(&BTRFS_I(inode)->io_tree, file_offset,
7926	return -EIO;	7734	file_offset + dio_bio->bi_iter.bi_size - 1);
		7735	}
		7736	dio_bio->bi_status = BLK_STS_RESOURCE;
		7737	bio_endio(dio_bio);
		7738	return BLK_QC_T_NONE;
		7739	}
7927		7740
7928	if (geom.len >= submit_len) {	7741	if (!write && csum) {
7929	bio = orig_bio;	7742	/*
7930	dip->flags \|= BTRFS_DIO_ORIG_BIO_SUBMITTED;	7743	* Load the csums up front to reduce csum tree searches and
7931	goto submit;	7744	* contention when submitting bios.
		7745	*/
		7746	status = btrfs_lookup_bio_sums(inode, dio_bio, file_offset,
		7747	dip->csums);
		7748	if (status != BLK_STS_OK)
		7749	goto out_err;
7932	}	7750	}
7933		7751
7934	/* async crcs make it difficult to collect full stripe writes. */	7752	start_sector = dio_bio->bi_iter.bi_sector;
7935	if (btrfs_data_alloc_profile(fs_info) & BTRFS_BLOCK_GROUP_RAID56_MASK)	7753	submit_len = dio_bio->bi_iter.bi_size;
7936	async_submit = 0;
7937	else
7938	async_submit = 1;
7939		7754
7940	/* bio split */
7941	ASSERT(geom.len <= INT_MAX);
7942	atomic_inc(&dip->pending_bios);
7943	do {	7755	do {
		7756	ret = btrfs_get_io_geometry(fs_info, btrfs_op(dio_bio),
		7757	start_sector << 9, submit_len,
		7758	&geom);
		7759	if (ret) {
		7760	status = errno_to_blk_status(ret);
		7761	goto out_err;
		7762	}
		7763	ASSERT(geom.len <= INT_MAX);
		7764
7944	clone_len = min_t(int, submit_len, geom.len);	7765	clone_len = min_t(int, submit_len, geom.len);
7945		7766
7946	/*	7767	/*
7947	* This will never fail as it's passing GPF_NOFS and	7768	* This will never fail as it's passing GPF_NOFS and
7948	* the allocation is backed by btrfs_bioset.	7769	* the allocation is backed by btrfs_bioset.
7949	*/	7770	*/
7950	bio = btrfs_bio_clone_partial(orig_bio, clone_offset,	7771	bio = btrfs_bio_clone_partial(dio_bio, clone_offset, clone_len);
7951	clone_len);
7952	bio->bi_private = dip;	7772	bio->bi_private = dip;
7953	bio->bi_end_io = btrfs_end_dio_bio;	7773	bio->bi_end_io = btrfs_end_dio_bio;
7954	btrfs_io_bio(bio)->logical = file_offset;	7774	btrfs_io_bio(bio)->logical = file_offset;
7955		7775
7956	ASSERT(submit_len >= clone_len);	7776	ASSERT(submit_len >= clone_len);
7957	submit_len -= clone_len;	7777	submit_len -= clone_len;
7958	if (submit_len == 0)
7959	break;
7960		7778
7961	/*	7779	/*
7962	* Increase the count before we submit the bio so we know	7780	* Increase the count before we submit the bio so we know
7963	* the end IO handler won't happen before we increase the	7781	* the end IO handler won't happen before we increase the
7964	* count. Otherwise, the dip might get freed before we're	7782	* count. Otherwise, the dip might get freed before we're
7965	* done setting it up.	7783	* done setting it up.
		7784	*
		7785	* We transfer the initial reference to the last bio, so we
		7786	* don't need to increment the reference count for the last one.
7966	*/	7787	*/
7967	atomic_inc(&dip->pending_bios);	7788	if (submit_len > 0) {
		7789	refcount_inc(&dip->refs);
		7790	/*
		7791	* If we are submitting more than one bio, submit them
		7792	* all asynchronously. The exception is RAID 5 or 6, as
		7793	* asynchronous checksums make it difficult to collect
		7794	* full stripe writes.
		7795	*/
		7796	if (!raid56)
		7797	async_submit = 1;
		7798	}
7968		7799
7969	status = btrfs_submit_dio_bio(bio, inode, file_offset,	7800	status = btrfs_submit_dio_bio(bio, inode, file_offset,
7970	async_submit);	7801	async_submit);
7971	if (status) {	7802	if (status) {
7972	bio_put(bio);	7803	bio_put(bio);
7973	atomic_dec(&dip->pending_bios);	7804	if (submit_len > 0)
		7805	refcount_dec(&dip->refs);
7974	goto out_err;	7806	goto out_err;
7975	}	7807	}
7976		7808
		7809	dio_data->submitted += clone_len;
7977	clone_offset += clone_len;	7810	clone_offset += clone_len;
7978	start_sector += clone_len >> 9;	7811	start_sector += clone_len >> 9;
7979	file_offset += clone_len;	7812	file_offset += clone_len;
7980
7981	ret = btrfs_get_io_geometry(fs_info, btrfs_op(orig_bio),
7982	start_sector << 9, submit_len, &geom);
7983	if (ret)
7984	goto out_err;
7985	} while (submit_len > 0);	7813	} while (submit_len > 0);
		7814	return BLK_QC_T_NONE;
7986		7815
7987	submit:
7988	status = btrfs_submit_dio_bio(bio, inode, file_offset, async_submit);
7989	if (!status)
7990	return 0;
7991
7992	bio_put(bio);
7993	out_err:	7816	out_err:
7994	dip->errors = 1;	7817	dip->dio_bio->bi_status = status;
7995	/*	7818	btrfs_dio_private_put(dip);
7996	* Before atomic variable goto zero, we must make sure dip->errors is	7819	return BLK_QC_T_NONE;
7997	* perceived to be set. This ordering is ensured by the fact that an
7998	* atomic operations with a return value are fully ordered as per
7999	* atomic_t.txt
8000	*/
8001	if (atomic_dec_and_test(&dip->pending_bios))
8002	bio_io_error(dip->orig_bio);
8003
8004	/* bio_end_io() will handle error, so we needn't return it */
8005	return 0;
8006	}
8007
8008	static void btrfs_submit_direct(struct bio dio_bio, struct inode inode,
8009	loff_t file_offset)
8010	{
8011	struct btrfs_dio_private *dip = NULL;
8012	struct bio *bio = NULL;
8013	struct btrfs_io_bio *io_bio;
8014	bool write = (bio_op(dio_bio) == REQ_OP_WRITE);
8015	int ret = 0;
8016
8017	bio = btrfs_bio_clone(dio_bio);
8018
8019	dip = kzalloc(sizeof(*dip), GFP_NOFS);
8020	if (!dip) {
8021	ret = -ENOMEM;
8022	goto free_ordered;
8023	}
8024
8025	dip->private = dio_bio->bi_private;
8026	dip->inode = inode;
8027	dip->logical_offset = file_offset;
8028	dip->bytes = dio_bio->bi_iter.bi_size;
8029	dip->disk_bytenr = (u64)dio_bio->bi_iter.bi_sector << 9;
8030	bio->bi_private = dip;
8031	dip->orig_bio = bio;
8032	dip->dio_bio = dio_bio;
8033	atomic_set(&dip->pending_bios, 0);
8034	io_bio = btrfs_io_bio(bio);
8035	io_bio->logical = file_offset;
8036
8037	if (write) {
8038	bio->bi_end_io = btrfs_endio_direct_write;
8039	} else {
8040	bio->bi_end_io = btrfs_endio_direct_read;
8041	dip->subio_endio = btrfs_subio_endio_read;
8042	}
8043
8044	/*
8045	* Reset the range for unsubmitted ordered extents (to a 0 length range)
8046	* even if we fail to submit a bio, because in such case we do the
8047	* corresponding error handling below and it must not be done a second
8048	* time by btrfs_direct_IO().
8049	*/
8050	if (write) {
8051	struct btrfs_dio_data *dio_data = current->journal_info;
8052
8053	dio_data->unsubmitted_oe_range_end = dip->logical_offset +
8054	dip->bytes;
8055	dio_data->unsubmitted_oe_range_start =
8056	dio_data->unsubmitted_oe_range_end;
8057	}
8058
8059	ret = btrfs_submit_direct_hook(dip);
8060	if (!ret)
8061	return;
8062
8063	btrfs_io_bio_free_csum(io_bio);
8064
8065	free_ordered:
8066	/*
8067	* If we arrived here it means either we failed to submit the dip
8068	* or we either failed to clone the dio_bio or failed to allocate the
8069	* dip. If we cloned the dio_bio and allocated the dip, we can just
8070	* call bio_endio against our io_bio so that we get proper resource
8071	* cleanup if we fail to submit the dip, otherwise, we must do the
8072	* same as btrfs_endio_direct_[write\|read] because we can't call these
8073	* callbacks - they require an allocated dip and a clone of dio_bio.
8074	*/
8075	if (bio && dip) {
8076	bio_io_error(bio);
8077	/*
8078	* The end io callbacks free our dip, do the final put on bio
8079	* and all the cleanup and final put for dio_bio (through
8080	* dio_end_io()).
8081	*/
8082	dip = NULL;
8083	bio = NULL;
8084	} else {
8085	if (write)
8086	__endio_write_update_ordered(inode,
8087	file_offset,
8088	dio_bio->bi_iter.bi_size,
8089	false);
8090	else
8091	unlock_extent(&BTRFS_I(inode)->io_tree, file_offset,
8092	file_offset + dio_bio->bi_iter.bi_size - 1);
8093
8094	dio_bio->bi_status = BLK_STS_IOERR;
8095	/*
8096	* Releases and cleans up our dio_bio, no need to bio_put()
8097	* nor bio_endio()/bio_io_error() against dio_bio.
8098	*/
8099	dio_end_io(dio_bio);
8100	}
8101	if (bio)
8102	bio_put(bio);
8103	kfree(dip);
8104	}	7820	}
8105		7821
8106	static ssize_t check_direct_IO(struct btrfs_fs_info *fs_info,	7822	const struct iomap_ops btrfs_dio_iomap_ops = {
8107	const struct iov_iter *iter, loff_t offset)	7823	.iomap_begin = btrfs_dio_iomap_begin,
8108	{	7824	.iomap_end = btrfs_dio_iomap_end,
8109	int seg;	7825	};
8110	int i;
8111	unsigned int blocksize_mask = fs_info->sectorsize - 1;
8112	ssize_t retval = -EINVAL;
8113
8114	if (offset & blocksize_mask)
8115	goto out;
8116
8117	if (iov_iter_alignment(iter) & blocksize_mask)
8118	goto out;
8119
8120	/* If this is a write we don't need to check anymore */
8121	if (iov_iter_rw(iter) != READ \|\| !iter_is_iovec(iter))
8122	return 0;
8123	/*
8124	* Check to make sure we don't have duplicate iov_base's in this
8125	* iovec, if so return EINVAL, otherwise we'll get csum errors
8126	* when reading back.
8127	*/
8128	for (seg = 0; seg < iter->nr_segs; seg++) {
8129	for (i = seg + 1; i < iter->nr_segs; i++) {
8130	if (iter->iov[seg].iov_base == iter->iov[i].iov_base)
8131	goto out;
8132	}
8133	}
8134	retval = 0;
8135	out:
8136	return retval;
8137	}
8138
8139	static ssize_t btrfs_direct_IO(struct kiocb iocb, struct iov_iter iter)
8140	{
8141	struct file *file = iocb->ki_filp;
8142	struct inode *inode = file->f_mapping->host;
8143	struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
8144	struct btrfs_dio_data dio_data = { 0 };
8145	struct extent_changeset *data_reserved = NULL;
8146	loff_t offset = iocb->ki_pos;
8147	size_t count = 0;
8148	int flags = 0;
8149	bool wakeup = true;
8150	bool relock = false;
8151	ssize_t ret;
8152
8153	if (check_direct_IO(fs_info, iter, offset))
8154	return 0;
8155
8156	inode_dio_begin(inode);
8157
8158	/*
8159	* The generic stuff only does filemap_write_and_wait_range, which
8160	* isn't enough if we've written compressed pages to this area, so
8161	* we need to flush the dirty pages again to make absolutely sure
8162	* that any outstanding dirty pages are on disk.
8163	*/
8164	count = iov_iter_count(iter);
8165	if (test_bit(BTRFS_INODE_HAS_ASYNC_EXTENT,
8166	&BTRFS_I(inode)->runtime_flags))
8167	filemap_fdatawrite_range(inode->i_mapping, offset,
8168	offset + count - 1);
8169
8170	if (iov_iter_rw(iter) == WRITE) {
8171	/*
8172	* If the write DIO is beyond the EOF, we need update
8173	* the isize, but it is protected by i_mutex. So we can
8174	* not unlock the i_mutex at this case.
8175	*/
8176	if (offset + count <= inode->i_size) {
8177	dio_data.overwrite = 1;
8178	inode_unlock(inode);
8179	relock = true;
8180	} else if (iocb->ki_flags & IOCB_NOWAIT) {
8181	ret = -EAGAIN;
8182	goto out;
8183	}
8184	ret = btrfs_delalloc_reserve_space(inode, &data_reserved,
8185	offset, count);
8186	if (ret)
8187	goto out;
8188
8189	/*
8190	* We need to know how many extents we reserved so that we can
8191	* do the accounting properly if we go over the number we
8192	* originally calculated. Abuse current->journal_info for this.
8193	*/
8194	dio_data.reserve = round_up(count,
8195	fs_info->sectorsize);
8196	dio_data.unsubmitted_oe_range_start = (u64)offset;
8197	dio_data.unsubmitted_oe_range_end = (u64)offset;
8198	current->journal_info = &dio_data;
8199	down_read(&BTRFS_I(inode)->dio_sem);
8200	} else if (test_bit(BTRFS_INODE_READDIO_NEED_LOCK,
8201	&BTRFS_I(inode)->runtime_flags)) {
8202	inode_dio_end(inode);
8203	flags = DIO_LOCKING \| DIO_SKIP_HOLES;
8204	wakeup = false;
8205	}
8206
8207	ret = __blockdev_direct_IO(iocb, inode,
8208	fs_info->fs_devices->latest_bdev,
8209	iter, btrfs_get_blocks_direct, NULL,
8210	btrfs_submit_direct, flags);
8211	if (iov_iter_rw(iter) == WRITE) {
8212	up_read(&BTRFS_I(inode)->dio_sem);
8213	current->journal_info = NULL;
8214	if (ret < 0 && ret != -EIOCBQUEUED) {
8215	if (dio_data.reserve)
8216	btrfs_delalloc_release_space(inode, data_reserved,
8217	offset, dio_data.reserve, true);
8218	/*
8219	* On error we might have left some ordered extents
8220	* without submitting corresponding bios for them, so
8221	* cleanup them up to avoid other tasks getting them
8222	* and waiting for them to complete forever.
8223	*/
8224	if (dio_data.unsubmitted_oe_range_start <
8225	dio_data.unsubmitted_oe_range_end)
8226	__endio_write_update_ordered(inode,
8227	dio_data.unsubmitted_oe_range_start,
8228	dio_data.unsubmitted_oe_range_end -
8229	dio_data.unsubmitted_oe_range_start,
8230	false);
8231	} else if (ret >= 0 && (size_t)ret < count)
8232	btrfs_delalloc_release_space(inode, data_reserved,
8233	offset, count - (size_t)ret, true);
8234	btrfs_delalloc_release_extents(BTRFS_I(inode), count);
8235	}
8236	out:
8237	if (wakeup)
8238	inode_dio_end(inode);
8239	if (relock)
8240	inode_lock(inode);
8241		7826
8242	extent_changeset_free(data_reserved);	7827	const struct iomap_dio_ops btrfs_dops = {
8243	return ret;	7828	.submit_io = btrfs_submit_direct,
8244	}	7829	};
8245		7830
8246	#define BTRFS_FIEMAP_FLAGS (FIEMAP_FLAG_SYNC)	7831	#define BTRFS_FIEMAP_FLAGS (FIEMAP_FLAG_SYNC)
8247		7832
@@ -10539,7 +10124,7 @@ static const struct address_space_operations btrfs_aops = { · 2291 unmodified lines
10539	.writepage = btrfs_writepage,	10124	.writepage = btrfs_writepage,
10540	.writepages = btrfs_writepages,	10125	.writepages = btrfs_writepages,
10541	.readahead = btrfs_readahead,	10126	.readahead = btrfs_readahead,
10542	.direct_IO = btrfs_direct_IO,	10127	.direct_IO = noop_direct_IO,
10543	.invalidatepage = btrfs_invalidatepage,	10128	.invalidatepage = btrfs_invalidatepage,
10544	.releasepage = btrfs_releasepage,	10129	.releasepage = btrfs_releasepage,
10545	#ifdef CONFIG_MIGRATION	10130	#ifdef CONFIG_MIGRATION

fs/btrfs/ioctl.c+49−53

 		goto fail;
 	key.offset = (u64)-1;
-	new_root = btrfs_get_fs_root(fs_info, &key, true);
+	new_root = btrfs_get_fs_root(fs_info, objectid, true);
 	if (IS_ERR(new_root)) {
 		ret = PTR_ERR(new_root);
 		btrfs_abort_transaction(trans, ret);
 	struct btrfs_pending_snapshot *pending_snapshot;
 	struct btrfs_trans_handle *trans;
 	int ret;
-	bool snapshot_force_cow = false;
-	if (!test_bit(BTRFS_ROOT_REF_COWS, &root->state))
+	if (!test_bit(BTRFS_ROOT_SHAREABLE, &root->state))
 		return -EINVAL;
 	if (atomic_read(&root->nr_swapfiles)) {
 		goto free_pending;
 	}
-	/*
-	 * Force new buffered writes to reserve space even when NOCOW is
-	 * possible. This is to avoid later writeback (running dealloc) to
-	 * fallback to COW mode and unexpectedly fail with ENOSPC.
-	 */
-	btrfs_drew_read_lock(&root->snapshot_lock);
-	ret = btrfs_start_delalloc_snapshot(root);
-	if (ret)
-		goto dec_and_free;
-	/*
-	 * All previous writes have started writeback in NOCOW mode, so now
-	 * we force future writes to fallback to COW mode during snapshot
-	 * creation.
-	 */
-	atomic_inc(&root->snapshot_force_cow);
-	snapshot_force_cow = true;
-	btrfs_wait_ordered_extents(root, U64_MAX, 0, (u64)-1);
 	btrfs_init_block_rsv(&pending_snapshot->block_rsv,
 			     BTRFS_BLOCK_RSV_TEMP);
 	/*
 					&pending_snapshot->block_rsv, 8,
 					false);
 	if (ret)
-		goto dec_and_free;
+		goto free_pending;
 	pending_snapshot->dentry = dentry;
 	pending_snapshot->root = root;
 fail:
 	btrfs_put_root(pending_snapshot->snap);
 	btrfs_subvolume_release_metadata(fs_info, &pending_snapshot->block_rsv);
-dec_and_free:
-	if (snapshot_force_cow)
-		atomic_dec(&root->snapshot_force_cow);
-	btrfs_drew_read_unlock(&root->snapshot_lock);
 free_pending:
 	kfree(pending_snapshot->root_item);
 	btrfs_free_path(pending_snapshot->path);
 	return error;
 }
+static noinline int btrfs_mksnapshot(const struct path *parent,
+				   const char *name, int namelen,
+				   struct btrfs_root *root,
+				   bool readonly,
+				   struct btrfs_qgroup_inherit *inherit)
+{
+	int ret;
+	bool snapshot_force_cow = false;
+	/*
+	 * Force new buffered writes to reserve space even when NOCOW is
+	 * possible. This is to avoid later writeback (running dealloc) to
+	 * fallback to COW mode and unexpectedly fail with ENOSPC.
+	 */
+	btrfs_drew_read_lock(&root->snapshot_lock);
+	ret = btrfs_start_delalloc_snapshot(root);
+	if (ret)
+		goto out;
+	/*
+	 * All previous writes have started writeback in NOCOW mode, so now
+	 * we force future writes to fallback to COW mode during snapshot
+	 * creation.
+	 */
+	atomic_inc(&root->snapshot_force_cow);
+	snapshot_force_cow = true;
+	btrfs_wait_ordered_extents(root, U64_MAX, 0, (u64)-1);
+	ret = btrfs_mksubvol(parent, name, namelen,
+			     root, readonly, inherit);
+out:
+	if (snapshot_force_cow)
+		atomic_dec(&root->snapshot_force_cow);
+	btrfs_drew_read_unlock(&root->snapshot_lock);
+	return ret;
+}
 /*
  * When we're defragging a range, we don't want to kick it off again
  * if it is really just waiting for delalloc to send it down.
 			 */
 			ret = -EPERM;
 		} else {
-			ret = btrfs_mksubvol(&file->f_path, name, namelen,
+			ret = btrfs_mksnapshot(&file->f_path, name, namelen,
 					     BTRFS_I(src_inode)->root,
 					     readonly, inherit);
 		}
 		/* search the root of the inode that was passed */
 		root = btrfs_grab_root(BTRFS_I(inode)->root);
 	} else {
-		key.objectid = sk->tree_id;
+		root = btrfs_get_fs_root(info, sk->tree_id, true);
-		key.type = BTRFS_ROOT_ITEM_KEY;
-		key.offset = (u64)-1;
-		root = btrfs_get_fs_root(info, &key, true);
 		if (IS_ERR(root)) {
 			btrfs_free_path(path);
 			return PTR_ERR(root);
 	ptr = &name[BTRFS_INO_LOOKUP_PATH_MAX - 1];
-	key.objectid = tree_id;
+	root = btrfs_get_fs_root(info, tree_id, true);
-	key.type = BTRFS_ROOT_ITEM_KEY;
-	key.offset = (u64)-1;
-	root = btrfs_get_fs_root(info, &key, true);
 	if (IS_ERR(root)) {
 		ret = PTR_ERR(root);
 		root = NULL;
 	if (dirid != upper_limit.objectid) {
 		ptr = &args->path[BTRFS_INO_LOOKUP_USER_PATH_MAX - 1];
-		key.objectid = treeid;
+		root = btrfs_get_fs_root(fs_info, treeid, true);
-		key.type = BTRFS_ROOT_ITEM_KEY;
-		key.offset = (u64)-1;
-		root = btrfs_get_fs_root(fs_info, &key, true);
 		if (IS_ERR(root)) {
 			ret = PTR_ERR(root);
 			goto out;
 				goto out_put;
 			}
-			temp_inode = btrfs_iget(sb, &key2, root);
+			temp_inode = btrfs_iget(sb, key2.objectid, root);
 			if (IS_ERR(temp_inode)) {
 				ret = PTR_ERR(temp_inode);
 				goto out_put;
 	/* Get root_item of inode's subvolume */
 	key.objectid = BTRFS_I(inode)->root->root_key.objectid;
-	key.type = BTRFS_ROOT_ITEM_KEY;
+	root = btrfs_get_fs_root(fs_info, key.objectid, true);
-	key.offset = (u64)-1;
-	root = btrfs_get_fs_root(fs_info, &key, true);
 	if (IS_ERR(root)) {
 		ret = PTR_ERR(root);
 		goto out_free;
 	struct btrfs_dir_item *di;
 	struct btrfs_trans_handle *trans;
 	struct btrfs_path *path = NULL;
-	struct btrfs_key location;
 	struct btrfs_disk_key disk_key;
 	u64 objectid = 0;
 	u64 dir_id;
 	if (!objectid)
 		objectid = BTRFS_FS_TREE_OBJECTID;
-	location.objectid = objectid;
+	new_root = btrfs_get_fs_root(fs_info, objectid, true);
-	location.type = BTRFS_ROOT_ITEM_KEY;
-	location.offset = (u64)-1;
-	new_root = btrfs_get_fs_root(fs_info, &location, true);
 	if (IS_ERR(new_root)) {
 		ret = PTR_ERR(new_root);
 		goto out;

fs/btrfs/locking.c+1−0

@@ -410,6 +410,7 @@ void btrfs_tree_read_unlock_blocking(struct extent_buffer *eb) · 409 unmodified lines
410	* The rwlock is held for write upon exit.	410	* The rwlock is held for write upon exit.
411	*/	411	*/
412	void btrfs_tree_lock(struct extent_buffer *eb)	412	void btrfs_tree_lock(struct extent_buffer *eb)
		413	__acquires(&eb->lock)
413	{	414	{
414	u64 start_ns = 0;	415	u64 start_ns = 0;
415		416

fs/btrfs/misc.h+54−0

@@ -6,6 +6,7 @@ · 5 unmodified lines
6	#include <linux/sched.h>	6	#include <linux/sched.h>
7	#include <linux/wait.h>	7	#include <linux/wait.h>
8	#include <asm/div64.h>	8	#include <asm/div64.h>
		9	#include <linux/rbtree.h>
9		10
10	#define in_range(b, first, len) ((b) >= (first) && (b) < (first) + (len))	11	#define in_range(b, first, len) ((b) >= (first) && (b) < (first) + (len))
11		12
@@ -58,4 +59,57 @@ static inline bool has_single_bit_set(u64 n) · 46 unmodified lines
58	return is_power_of_two_u64(n);	59	return is_power_of_two_u64(n);
59	}	60	}
60		61
		62	/*
		63	* Simple bytenr based rb_tree relate structures
		64	*
		65	* Any structure wants to use bytenr as single search index should have their
		66	* structure start with these members.
		67	*/
		68	struct rb_simple_node {
		69	struct rb_node rb_node;
		70	u64 bytenr;
		71	};
		72
		73	static inline struct rb_node rb_simple_search(struct rb_root root, u64 bytenr)
		74	{
		75	struct rb_node *node = root->rb_node;
		76	struct rb_simple_node *entry;
		77
		78	while (node) {
		79	entry = rb_entry(node, struct rb_simple_node, rb_node);
		80
		81	if (bytenr < entry->bytenr)
		82	node = node->rb_left;
		83	else if (bytenr > entry->bytenr)
		84	node = node->rb_right;
		85	else
		86	return node;
		87	}
		88	return NULL;
		89	}
		90
		91	static inline struct rb_node rb_simple_insert(struct rb_root root, u64 bytenr,
		92	struct rb_node *node)
		93	{
		94	struct rb_node **p = &root->rb_node;
		95	struct rb_node *parent = NULL;
		96	struct rb_simple_node *entry;
		97
		98	while (*p) {
		99	parent = *p;
		100	entry = rb_entry(parent, struct rb_simple_node, rb_node);
		101
		102	if (bytenr < entry->bytenr)
		103	p = &(*p)->rb_left;
		104	else if (bytenr > entry->bytenr)
		105	p = &(*p)->rb_right;
		106	else
		107	return parent;
		108	}
		109
		110	rb_link_node(node, parent, p);
		111	rb_insert_color(node, root);
		112	return NULL;
		113	}
		114
61	#endif	115	#endif

fs/btrfs/props.c+2−7

 			       struct btrfs_root *parent_root)
 {
 	struct super_block *sb = root->fs_info->sb;
-	struct btrfs_key key;
 	struct inode *parent_inode, *child_inode;
 	int ret;
-	key.objectid = BTRFS_FIRST_FREE_OBJECTID;
+	parent_inode = btrfs_iget(sb, BTRFS_FIRST_FREE_OBJECTID, parent_root);
-	key.type = BTRFS_INODE_ITEM_KEY;
-	key.offset = 0;
-	parent_inode = btrfs_iget(sb, &key, parent_root);
 	if (IS_ERR(parent_inode))
 		return PTR_ERR(parent_inode);
-	child_inode = btrfs_iget(sb, &key, root);
+	child_inode = btrfs_iget(sb, BTRFS_FIRST_FREE_OBJECTID, root);
 	if (IS_ERR(child_inode)) {
 		iput(parent_inode);
 		return PTR_ERR(child_inode);

fs/btrfs/qgroup.c+14−0

 	struct btrfs_root *quota_root;
 	struct btrfs_qgroup *srcgroup;
 	struct btrfs_qgroup *dstgroup;
+	bool need_rescan = false;
 	u32 level_size = 0;
 	u64 nums;
 				goto unlock;
 		}
 		++i_qgroups;
+		/*
+		 * If we're doing a snapshot, and adding the snapshot to a new
+		 * qgroup, the numbers are guaranteed to be incorrect.
+		 */
+		if (srcid)
+			need_rescan = true;
 	}
 	for (i = 0; i <  inherit->num_ref_copies; ++i, i_qgroups += 2) {
 		dst->rfer = src->rfer - level_size;
 		dst->rfer_cmpr = src->rfer_cmpr - level_size;
+		/* Manually tweaking numbers certainly needs a rescan */
+		need_rescan = true;
 	}
 	for (i = 0; i <  inherit->num_excl_copies; ++i, i_qgroups += 2) {
 		struct btrfs_qgroup *src;
 		dst->excl = src->excl + level_size;
 		dst->excl_cmpr = src->excl_cmpr + level_size;
+		need_rescan = true;
 	}
 unlock:
 out:
 	if (!committing)
 		mutex_unlock(&fs_info->qgroup_ioctl_lock);
+	if (need_rescan)
+		fs_info->qgroup_flags |= BTRFS_QGROUP_STATUS_FLAG_INCONSISTENT;
 	return ret;
 }

fs/btrfs/relocation.c+288−1031

@@ -24,6 +24,7 @@ · 23 unmodified lines
24	#include "delalloc-space.h"	24	#include "delalloc-space.h"
25	#include "block-group.h"	25	#include "block-group.h"
26	#include "backref.h"	26	#include "backref.h"
		27	#include "misc.h"
27		28
28	/*	29	/*
29	* Relocation overview	30	* Relocation overview
@@ -72,100 +73,15 @@ · 42 unmodified lines
72	* The entry point of relocation is relocate_block_group() function.	73	* The entry point of relocation is relocate_block_group() function.
73	*/	74	*/
74		75
75	/*
76	* backref_node, mapping_node and tree_block start with this
77	*/
78	struct tree_entry {
79	struct rb_node rb_node;
80	u64 bytenr;
81	};
82
83	/*
84	* present a tree block in the backref cache
85	*/
86	struct backref_node {
87	struct rb_node rb_node;
88	u64 bytenr;
89
90	u64 new_bytenr;
91	/* objectid of tree block owner, can be not uptodate */
92	u64 owner;
93	/* link to pending, changed or detached list */
94	struct list_head list;
95	/* list of upper level blocks reference this block */
96	struct list_head upper;
97	/* list of child blocks in the cache */
98	struct list_head lower;
99	/* NULL if this node is not tree root */
100	struct btrfs_root *root;
101	/* extent buffer got by COW the block */
102	struct extent_buffer *eb;
103	/* level of tree block */
104	unsigned int level:8;
105	/* is the block in non-reference counted tree */
106	unsigned int cowonly:1;
107	/* 1 if no child node in the cache */
108	unsigned int lowest:1;
109	/* is the extent buffer locked */
110	unsigned int locked:1;
111	/* has the block been processed */
112	unsigned int processed:1;
113	/* have backrefs of this block been checked */
114	unsigned int checked:1;
115	/*
116	* 1 if corresponding block has been cowed but some upper
117	* level block pointers may not point to the new location
118	*/
119	unsigned int pending:1;
120	/*
121	* 1 if the backref node isn't connected to any other
122	* backref node.
123	*/
124	unsigned int detached:1;
125	};
126
127	/*
128	* present a block pointer in the backref cache
129	*/
130	struct backref_edge {
131	struct list_head list[2];
132	struct backref_node *node[2];
133	};
134
135	#define LOWER 0
136	#define UPPER 1
137	#define RELOCATION_RESERVED_NODES 256	76	#define RELOCATION_RESERVED_NODES 256
138
139	struct backref_cache {
140	/* red black tree of all backref nodes in the cache */
141	struct rb_root rb_root;
142	/* for passing backref nodes to btrfs_reloc_cow_block */
143	struct backref_node *path[BTRFS_MAX_LEVEL];
144	/*
145	* list of blocks that have been cowed but some block
146	* pointers in upper level blocks may not reflect the
147	* new location
148	*/
149	struct list_head pending[BTRFS_MAX_LEVEL];
150	/* list of backref nodes with no child node */
151	struct list_head leaves;
152	/* list of blocks that have been cowed in current transaction */
153	struct list_head changed;
154	/* list of detached backref node. */
155	struct list_head detached;
156
157	u64 last_trans;
158
159	int nr_nodes;
160	int nr_edges;
161	};
162
163	/*	77	/*
164	* map address of tree root to tree	78	* map address of tree root to tree
165	*/	79	*/
166	struct mapping_node {	80	struct mapping_node {
167	struct rb_node rb_node;	81	struct {
168	u64 bytenr;	82	struct rb_node rb_node;
		83	u64 bytenr;
		84	}; /* Use rb_simle_node for search/insert */
169	void *data;	85	void *data;
170	};	86	};
171		87
@@ -178,8 +94,10 @@ struct mapping_tree { · 6 unmodified lines
178	* present a tree block to process	94	* present a tree block to process
179	*/	95	*/
180	struct tree_block {	96	struct tree_block {
181	struct rb_node rb_node;	97	struct {
182	u64 bytenr;	98	struct rb_node rb_node;
		99	u64 bytenr;
		100	}; /* Use rb_simple_node for search/insert */
183	struct btrfs_key key;	101	struct btrfs_key key;
184	unsigned int level:8;	102	unsigned int level:8;
185	unsigned int key_ready:1;	103	unsigned int key_ready:1;
@@ -204,7 +122,7 @@ struct reloc_control { · 18 unmodified lines
204		122
205	struct btrfs_block_rsv *block_rsv;	123	struct btrfs_block_rsv *block_rsv;
206		124
207	struct backref_cache backref_cache;	125	struct btrfs_backref_cache backref_cache;
208		126
209	struct file_extent_cluster cluster;	127	struct file_extent_cluster cluster;
210	/* tree blocks have been processed */	128	/* tree blocks have been processed */
@@ -235,168 +153,41 @@ struct reloc_control { · 24 unmodified lines
235	#define MOVE_DATA_EXTENTS 0	153	#define MOVE_DATA_EXTENTS 0
236	#define UPDATE_DATA_PTRS 1	154	#define UPDATE_DATA_PTRS 1
237		155
238	static void remove_backref_node(struct backref_cache *cache,	156	static void mark_block_processed(struct reloc_control *rc,
239	struct backref_node *node);	157	struct btrfs_backref_node *node)
240	static void __mark_block_processed(struct reloc_control *rc,
241	struct backref_node *node);
242
243	static void mapping_tree_init(struct mapping_tree *tree)
244	{
245	tree->rb_root = RB_ROOT;
246	spin_lock_init(&tree->lock);
247	}
248
249	static void backref_cache_init(struct backref_cache *cache)
250	{
251	int i;
252	cache->rb_root = RB_ROOT;
253	for (i = 0; i < BTRFS_MAX_LEVEL; i++)
254	INIT_LIST_HEAD(&cache->pending[i]);
255	INIT_LIST_HEAD(&cache->changed);
256	INIT_LIST_HEAD(&cache->detached);
257	INIT_LIST_HEAD(&cache->leaves);
258	}
259
260	static void backref_cache_cleanup(struct backref_cache *cache)
261	{
262	struct backref_node *node;
263	int i;
264
265	while (!list_empty(&cache->detached)) {
266	node = list_entry(cache->detached.next,
267	struct backref_node, list);
268	remove_backref_node(cache, node);
269	}
270
271	while (!list_empty(&cache->leaves)) {
272	node = list_entry(cache->leaves.next,
273	struct backref_node, lower);
274	remove_backref_node(cache, node);
275	}
276
277	cache->last_trans = 0;
278
279	for (i = 0; i < BTRFS_MAX_LEVEL; i++)
280	ASSERT(list_empty(&cache->pending[i]));
281	ASSERT(list_empty(&cache->changed));
282	ASSERT(list_empty(&cache->detached));
283	ASSERT(RB_EMPTY_ROOT(&cache->rb_root));
284	ASSERT(!cache->nr_nodes);
285	ASSERT(!cache->nr_edges);
286	}
287
288	static struct backref_node alloc_backref_node(struct backref_cache cache)
289	{
290	struct backref_node *node;
291
292	node = kzalloc(sizeof(*node), GFP_NOFS);
293	if (node) {
294	INIT_LIST_HEAD(&node->list);
295	INIT_LIST_HEAD(&node->upper);
296	INIT_LIST_HEAD(&node->lower);
297	RB_CLEAR_NODE(&node->rb_node);
298	cache->nr_nodes++;
299	}
300	return node;
301	}
302
303	static void free_backref_node(struct backref_cache *cache,
304	struct backref_node *node)
305	{
306	if (node) {
307	cache->nr_nodes--;
308	btrfs_put_root(node->root);
309	kfree(node);
310	}
311	}
312
313	static struct backref_edge alloc_backref_edge(struct backref_cache cache)
314	{
315	struct backref_edge *edge;
316
317	edge = kzalloc(sizeof(*edge), GFP_NOFS);
318	if (edge)
319	cache->nr_edges++;
320	return edge;
321	}
322
323	static void free_backref_edge(struct backref_cache *cache,
324	struct backref_edge *edge)
325	{	158	{
326	if (edge) {	159	u32 blocksize;
327	cache->nr_edges--;
328	kfree(edge);
329	}
330	}
331		160
332	static struct rb_node tree_insert(struct rb_root root, u64 bytenr,	161	if (node->level == 0 \|\|
333	struct rb_node *node)	162	in_range(node->bytenr, rc->block_group->start,
334	{	163	rc->block_group->length)) {
335	struct rb_node **p = &root->rb_node;	164	blocksize = rc->extent_root->fs_info->nodesize;
336	struct rb_node *parent = NULL;	165	set_extent_bits(&rc->processed_blocks, node->bytenr,
337	struct tree_entry *entry;	166	node->bytenr + blocksize - 1, EXTENT_DIRTY);
338
339	while (*p) {
340	parent = *p;
341	entry = rb_entry(parent, struct tree_entry, rb_node);
342
343	if (bytenr < entry->bytenr)
344	p = &(*p)->rb_left;
345	else if (bytenr > entry->bytenr)
346	p = &(*p)->rb_right;
347	else
348	return parent;
349	}	167	}
350		168	node->processed = 1;
351	rb_link_node(node, parent, p);
352	rb_insert_color(node, root);
353	return NULL;
354	}	169	}
355		170
356	static struct rb_node tree_search(struct rb_root root, u64 bytenr)
357	{
358	struct rb_node *n = root->rb_node;
359	struct tree_entry *entry;
360
361	while (n) {
362	entry = rb_entry(n, struct tree_entry, rb_node);
363		171
364	if (bytenr < entry->bytenr)	172	static void mapping_tree_init(struct mapping_tree *tree)
365	n = n->rb_left;
366	else if (bytenr > entry->bytenr)
367	n = n->rb_right;
368	else
369	return n;
370	}
371	return NULL;
372	}
373
374	static void backref_tree_panic(struct rb_node *rb_node, int errno, u64 bytenr)
375	{	173	{
376		174	tree->rb_root = RB_ROOT;
377	struct btrfs_fs_info *fs_info = NULL;	175	spin_lock_init(&tree->lock);
378	struct backref_node *bnode = rb_entry(rb_node, struct backref_node,
379	rb_node);
380	if (bnode->root)
381	fs_info = bnode->root->fs_info;
382	btrfs_panic(fs_info, errno,
383	"Inconsistency in backref cache found at offset %llu",
384	bytenr);
385	}	176	}
386		177
387	/*	178	/*
388	* walk up backref nodes until reach node presents tree root	179	* walk up backref nodes until reach node presents tree root
389	*/	180	*/
390	static struct backref_node walk_up_backref(struct backref_node node,	181	static struct btrfs_backref_node *walk_up_backref(
391	struct backref_edge *edges[],	182	struct btrfs_backref_node *node,
392	int *index)	183	struct btrfs_backref_edge edges[], int index)
393	{	184	{
394	struct backref_edge *edge;	185	struct btrfs_backref_edge *edge;
395	int idx = *index;	186	int idx = *index;
396		187
397	while (!list_empty(&node->upper)) {	188	while (!list_empty(&node->upper)) {
398	edge = list_entry(node->upper.next,	189	edge = list_entry(node->upper.next,
399	struct backref_edge, list[LOWER]);	190	struct btrfs_backref_edge, list[LOWER]);
400	edges[idx++] = edge;	191	edges[idx++] = edge;
401	node = edge->node[UPPER];	192	node = edge->node[UPPER];
402	}	193	}
@@ -408,11 +199,11 @@ static struct backref_node walk_up_backref(struct backref_node node, · 5 unmodified lines
408	/*	199	/*
409	* walk down backref nodes to find start of next reference path	200	* walk down backref nodes to find start of next reference path
410	*/	201	*/
411	static struct backref_node walk_down_backref(struct backref_edge edges[],	202	static struct btrfs_backref_node *walk_down_backref(
412	int *index)	203	struct btrfs_backref_edge edges[], int index)
413	{	204	{
414	struct backref_edge *edge;	205	struct btrfs_backref_edge *edge;
415	struct backref_node *lower;	206	struct btrfs_backref_node *lower;
416	int idx = *index;	207	int idx = *index;
417		208
418	while (idx > 0) {	209	while (idx > 0) {
@@ -423,7 +214,7 @@ static struct backref_node walk_down_backref(struct backref_edge edges[], · 4 unmodified lines
423	continue;	214	continue;
424	}	215	}
425	edge = list_entry(edge->list[LOWER].next,	216	edge = list_entry(edge->list[LOWER].next,
426	struct backref_edge, list[LOWER]);	217	struct btrfs_backref_edge, list[LOWER]);
427	edges[idx - 1] = edge;	218	edges[idx - 1] = edge;
428	*index = idx;	219	*index = idx;
429	return edge->node[UPPER];	220	return edge->node[UPPER];
@@ -432,95 +223,24 @@ static struct backref_node walk_down_backref(struct backref_edge edges[], · 2 unmodified lines
432	return NULL;	223	return NULL;
433	}	224	}
434		225
435	static void unlock_node_buffer(struct backref_node *node)	226	static void update_backref_node(struct btrfs_backref_cache *cache,
436	{	227	struct btrfs_backref_node *node, u64 bytenr)
437	if (node->locked) {
438	btrfs_tree_unlock(node->eb);
439	node->locked = 0;
440	}
441	}
442
443	static void drop_node_buffer(struct backref_node *node)
444	{
445	if (node->eb) {
446	unlock_node_buffer(node);
447	free_extent_buffer(node->eb);
448	node->eb = NULL;
449	}
450	}
451
452	static void drop_backref_node(struct backref_cache *tree,
453	struct backref_node *node)
454	{
455	BUG_ON(!list_empty(&node->upper));
456
457	drop_node_buffer(node);
458	list_del(&node->list);
459	list_del(&node->lower);
460	if (!RB_EMPTY_NODE(&node->rb_node))
461	rb_erase(&node->rb_node, &tree->rb_root);
462	free_backref_node(tree, node);
463	}
464
465	/*
466	* remove a backref node from the backref cache
467	*/
468	static void remove_backref_node(struct backref_cache *cache,
469	struct backref_node *node)
470	{
471	struct backref_node *upper;
472	struct backref_edge *edge;
473
474	if (!node)
475	return;
476
477	BUG_ON(!node->lowest && !node->detached);
478	while (!list_empty(&node->upper)) {
479	edge = list_entry(node->upper.next, struct backref_edge,
480	list[LOWER]);
481	upper = edge->node[UPPER];
482	list_del(&edge->list[LOWER]);
483	list_del(&edge->list[UPPER]);
484	free_backref_edge(cache, edge);
485
486	if (RB_EMPTY_NODE(&upper->rb_node)) {
487	BUG_ON(!list_empty(&node->upper));
488	drop_backref_node(cache, node);
489	node = upper;
490	node->lowest = 1;
491	continue;
492	}
493	/*
494	* add the node to leaf node list if no other
495	* child block cached.
496	*/
497	if (list_empty(&upper->lower)) {
498	list_add_tail(&upper->lower, &cache->leaves);
499	upper->lowest = 1;
500	}
501	}
502
503	drop_backref_node(cache, node);
504	}
505
506	static void update_backref_node(struct backref_cache *cache,
507	struct backref_node *node, u64 bytenr)
508	{	228	{
509	struct rb_node *rb_node;	229	struct rb_node *rb_node;
510	rb_erase(&node->rb_node, &cache->rb_root);	230	rb_erase(&node->rb_node, &cache->rb_root);
511	node->bytenr = bytenr;	231	node->bytenr = bytenr;
512	rb_node = tree_insert(&cache->rb_root, node->bytenr, &node->rb_node);	232	rb_node = rb_simple_insert(&cache->rb_root, node->bytenr, &node->rb_node);
513	if (rb_node)	233	if (rb_node)
514	backref_tree_panic(rb_node, -EEXIST, bytenr);	234	btrfs_backref_panic(cache->fs_info, bytenr, -EEXIST);
515	}	235	}
516		236
517	/*	237	/*
518	* update backref cache after a transaction commit	238	* update backref cache after a transaction commit
519	*/	239	*/
520	static int update_backref_cache(struct btrfs_trans_handle *trans,	240	static int update_backref_cache(struct btrfs_trans_handle *trans,
521	struct backref_cache *cache)	241	struct btrfs_backref_cache *cache)
522	{	242	{
523	struct backref_node *node;	243	struct btrfs_backref_node *node;
524	int level = 0;	244	int level = 0;
525		245
526	if (cache->last_trans == 0) {	246	if (cache->last_trans == 0) {
@@ -538,13 +258,13 @@ static int update_backref_cache(struct btrfs_trans_handle *trans, · 11 unmodified lines
538	*/	258	*/
539	while (!list_empty(&cache->detached)) {	259	while (!list_empty(&cache->detached)) {
540	node = list_entry(cache->detached.next,	260	node = list_entry(cache->detached.next,
541	struct backref_node, list);	261	struct btrfs_backref_node, list);
542	remove_backref_node(cache, node);	262	btrfs_backref_cleanup_node(cache, node);
543	}	263	}
544		264
545	while (!list_empty(&cache->changed)) {	265	while (!list_empty(&cache->changed)) {
546	node = list_entry(cache->changed.next,	266	node = list_entry(cache->changed.next,
547	struct backref_node, list);	267	struct btrfs_backref_node, list);
548	list_del_init(&node->list);	268	list_del_init(&node->list);
549	BUG_ON(node->pending);	269	BUG_ON(node->pending);
550	update_backref_node(cache, node, node->new_bytenr);	270	update_backref_node(cache, node, node->new_bytenr);
@@ -585,7 +305,8 @@ static bool reloc_root_is_dead(struct btrfs_root *root) · 34 unmodified lines
585	*	305	*
586	* Reloc tree after swap is considered dead, thus not considered as valid.	306	* Reloc tree after swap is considered dead, thus not considered as valid.
587	* This is enough for most callers, as they don't distinguish dead reloc root	307	* This is enough for most callers, as they don't distinguish dead reloc root
588	* from no reloc root. But should_ignore_root() below is a special case.	308	* from no reloc root. But btrfs_should_ignore_reloc_root() below is a
		309	* special case.
589	*/	310	*/
590	static bool have_reloc_root(struct btrfs_root *root)	311	static bool have_reloc_root(struct btrfs_root *root)
591	{	312	{
@@ -596,11 +317,11 @@ static bool have_reloc_root(struct btrfs_root *root) · 4 unmodified lines
596	return true;	317	return true;
597	}	318	}
598		319
599	static int should_ignore_root(struct btrfs_root *root)	320	int btrfs_should_ignore_reloc_root(struct btrfs_root *root)
600	{	321	{
601	struct btrfs_root *reloc_root;	322	struct btrfs_root *reloc_root;
602		323
603	if (!test_bit(BTRFS_ROOT_REF_COWS, &root->state))	324	if (!test_bit(BTRFS_ROOT_SHAREABLE, &root->state))
604	return 0;	325	return 0;
605		326
606	/* This root has been merged with its reloc tree, we can ignore it */	327	/* This root has been merged with its reloc tree, we can ignore it */
@@ -622,18 +343,20 @@ static int should_ignore_root(struct btrfs_root *root) · 15 unmodified lines
622	*/	343	*/
623	return 1;	344	return 1;
624	}	345	}
		346
625	/*	347	/*
626	* find reloc tree by address of tree root	348	* find reloc tree by address of tree root
627	*/	349	*/
628	static struct btrfs_root find_reloc_root(struct reloc_control rc,	350	struct btrfs_root find_reloc_root(struct btrfs_fs_info fs_info, u64 bytenr)
629	u64 bytenr)
630	{	351	{
		352	struct reloc_control *rc = fs_info->reloc_ctl;
631	struct rb_node *rb_node;	353	struct rb_node *rb_node;
632	struct mapping_node *node;	354	struct mapping_node *node;
633	struct btrfs_root *root = NULL;	355	struct btrfs_root *root = NULL;
634		356
		357	ASSERT(rc);
635	spin_lock(&rc->reloc_root_tree.lock);	358	spin_lock(&rc->reloc_root_tree.lock);
636	rb_node = tree_search(&rc->reloc_root_tree.rb_root, bytenr);	359	rb_node = rb_simple_search(&rc->reloc_root_tree.rb_root, bytenr);
637	if (rb_node) {	360	if (rb_node) {
638	node = rb_entry(rb_node, struct mapping_node, rb_node);	361	node = rb_entry(rb_node, struct mapping_node, rb_node);
639	root = (struct btrfs_root *)node->data;	362	root = (struct btrfs_root *)node->data;
@@ -642,594 +365,165 @@ static struct btrfs_root find_reloc_root(struct reloc_control rc, · 2 unmodified lines
642	return btrfs_grab_root(root);	365	return btrfs_grab_root(root);
643	}	366	}
644		367
645	static struct btrfs_root read_fs_root(struct btrfs_fs_info fs_info,	368	/*
646	u64 root_objectid)	369	* For useless nodes, do two major clean ups:
		370	*
		371	* - Cleanup the children edges and nodes
		372	* If child node is also orphan (no parent) during cleanup, then the child
		373	* node will also be cleaned up.
		374	*
		375	* - Freeing up leaves (level 0), keeps nodes detached
		376	* For nodes, the node is still cached as "detached"
		377	*
		378	* Return false if @node is not in the @useless_nodes list.
		379	* Return true if @node is in the @useless_nodes list.
		380	*/
		381	static bool handle_useless_nodes(struct reloc_control *rc,
		382	struct btrfs_backref_node *node)
647	{	383	{
648	struct btrfs_key key;	384	struct btrfs_backref_cache *cache = &rc->backref_cache;
		385	struct list_head *useless_node = &cache->useless_node;
		386	bool ret = false;
649		387
650	key.objectid = root_objectid;	388	while (!list_empty(useless_node)) {
651	key.type = BTRFS_ROOT_ITEM_KEY;	389	struct btrfs_backref_node *cur;
652	key.offset = (u64)-1;
653		390
654	return btrfs_get_fs_root(fs_info, &key, false);	391	cur = list_first_entry(useless_node, struct btrfs_backref_node,
655	}	392	list);
		393	list_del_init(&cur->list);
656		394
657	static noinline_for_stack	395	/* Only tree root nodes can be added to @useless_nodes */
658	int find_inline_backref(struct extent_buffer *leaf, int slot,	396	ASSERT(list_empty(&cur->upper));
659	unsigned long ptr, unsigned long end)
660	{
661	struct btrfs_key key;
662	struct btrfs_extent_item *ei;
663	struct btrfs_tree_block_info *bi;
664	u32 item_size;
665		397
666	btrfs_item_key_to_cpu(leaf, &key, slot);	398	if (cur == node)
		399	ret = true;
667		400
668	item_size = btrfs_item_size_nr(leaf, slot);	401	/* The node is the lowest node */
669	if (item_size < sizeof(*ei)) {	402	if (cur->lowest) {
670	btrfs_print_v0_err(leaf->fs_info);	403	list_del_init(&cur->lower);
671	btrfs_handle_fs_error(leaf->fs_info, -EINVAL, NULL);	404	cur->lowest = 0;
672	return 1;	405	}
673	}
674	ei = btrfs_item_ptr(leaf, slot, struct btrfs_extent_item);
675	WARN_ON(!(btrfs_extent_flags(leaf, ei) &
676	BTRFS_EXTENT_FLAG_TREE_BLOCK));
677		406
678	if (key.type == BTRFS_EXTENT_ITEM_KEY &&	407	/* Cleanup the lower edges */
679	item_size <= sizeof(ei) + sizeof(bi)) {	408	while (!list_empty(&cur->lower)) {
680	WARN_ON(item_size < sizeof(ei) + sizeof(bi));	409	struct btrfs_backref_edge *edge;
681	return 1;	410	struct btrfs_backref_node *lower;
682	}
683	if (key.type == BTRFS_METADATA_ITEM_KEY &&
684	item_size <= sizeof(*ei)) {
685	WARN_ON(item_size < sizeof(*ei));
686	return 1;
687	}
688		411
689	if (key.type == BTRFS_EXTENT_ITEM_KEY) {	412	edge = list_entry(cur->lower.next,
690	bi = (struct btrfs_tree_block_info *)(ei + 1);	413	struct btrfs_backref_edge, list[UPPER]);
691	*ptr = (unsigned long)(bi + 1);	414	list_del(&edge->list[UPPER]);
692	} else {	415	list_del(&edge->list[LOWER]);
693	*ptr = (unsigned long)(ei + 1);	416	lower = edge->node[LOWER];
		417	btrfs_backref_free_edge(cache, edge);
		418
		419	/* Child node is also orphan, queue for cleanup */
		420	if (list_empty(&lower->upper))
		421	list_add(&lower->list, useless_node);
		422	}
		423	/* Mark this block processed for relocation */
		424	mark_block_processed(rc, cur);
		425
		426	/*
		427	* Backref nodes for tree leaves are deleted from the cache.
		428	* Backref nodes for upper level tree blocks are left in the
		429	* cache to avoid unnecessary backref lookup.
		430	*/
		431	if (cur->level > 0) {
		432	list_add(&cur->list, &cache->detached);
		433	cur->detached = 1;
		434	} else {
		435	rb_erase(&cur->rb_node, &cache->rb_root);
		436	btrfs_backref_free_node(cache, cur);
		437	}
694	}	438	}
695	*end = (unsigned long)ei + item_size;	439	return ret;
696	return 0;
697	}	440	}
698		441
699	/*	442	/*
700	* build backref tree for a given tree block. root of the backref tree	443	* Build backref tree for a given tree block. Root of the backref tree
701	* corresponds the tree block, leaves of the backref tree correspond	444	* corresponds the tree block, leaves of the backref tree correspond roots of
702	* roots of b-trees that reference the tree block.	445	* b-trees that reference the tree block.
703	*	446	*
704	* the basic idea of this function is check backrefs of a given block	447	* The basic idea of this function is check backrefs of a given block to find
705	* to find upper level blocks that reference the block, and then check	448	* upper level blocks that reference the block, and then check backrefs of
706	* backrefs of these upper level blocks recursively. the recursion stop	449	* these upper level blocks recursively. The recursion stops when tree root is
707	* when tree root is reached or backrefs for the block is cached.	450	* reached or backrefs for the block is cached.
708	*	451	*
709	* NOTE: if we find backrefs for a block are cached, we know backrefs	452	* NOTE: if we find that backrefs for a block are cached, we know backrefs for
710	* for all upper level blocks that directly/indirectly reference the	453	* all upper level blocks that directly/indirectly reference the block are also
711	* block are also cached.	454	* cached.
712	*/	455	*/
713	static noinline_for_stack	456	static noinline_for_stack struct btrfs_backref_node *build_backref_tree(
714	struct backref_node build_backref_tree(struct reloc_control rc,	457	struct reloc_control rc, struct btrfs_key node_key,
715	struct btrfs_key *node_key,	458	int level, u64 bytenr)
716	int level, u64 bytenr)
717	{	459	{
718	struct backref_cache *cache = &rc->backref_cache;	460	struct btrfs_backref_iter *iter;
719	struct btrfs_path path1; / For searching extent root */	461	struct btrfs_backref_cache *cache = &rc->backref_cache;
720	struct btrfs_path path2; / For searching parent of TREE_BLOCK_REF */	462	/* For searching parent of TREE_BLOCK_REF */
721	struct extent_buffer *eb;	463	struct btrfs_path *path;
722	struct btrfs_root *root;	464	struct btrfs_backref_node *cur;
723	struct backref_node *cur;	465	struct btrfs_backref_node *node = NULL;
724	struct backref_node *upper;	466	struct btrfs_backref_edge *edge;
725	struct backref_node *lower;
726	struct backref_node *node = NULL;
727	struct backref_node *exist = NULL;
728	struct backref_edge *edge;
729	struct rb_node *rb_node;
730	struct btrfs_key key;
731	unsigned long end;
732	unsigned long ptr;
733	LIST_HEAD(list); /* Pending edge list, upper node needs to be checked */
734	LIST_HEAD(useless);
735	int cowonly;
736	int ret;	467	int ret;
737	int err = 0;	468	int err = 0;
738	bool need_check = true;
739		469
740	path1 = btrfs_alloc_path();	470	iter = btrfs_backref_iter_alloc(rc->extent_root->fs_info, GFP_NOFS);
741	path2 = btrfs_alloc_path();	471	if (!iter)
742	if (!path1 \|\| !path2) {	472	return ERR_PTR(-ENOMEM);
		473	path = btrfs_alloc_path();
		474	if (!path) {
743	err = -ENOMEM;	475	err = -ENOMEM;
744	goto out;	476	goto out;
745	}	477	}
746		478
747	node = alloc_backref_node(cache);	479	node = btrfs_backref_alloc_node(cache, bytenr, level);
748	if (!node) {	480	if (!node) {
749	err = -ENOMEM;	481	err = -ENOMEM;
750	goto out;	482	goto out;
751	}	483	}
752		484
753	node->bytenr = bytenr;
754	node->level = level;
755	node->lowest = 1;	485	node->lowest = 1;
756	cur = node;	486	cur = node;
757	again:
758	end = 0;
759	ptr = 0;
760	key.objectid = cur->bytenr;
761	key.type = BTRFS_METADATA_ITEM_KEY;
762	key.offset = (u64)-1;
763
764	path1->search_commit_root = 1;
765	path1->skip_locking = 1;
766	ret = btrfs_search_slot(NULL, rc->extent_root, &key, path1,
767	0, 0);
768	if (ret < 0) {
769	err = ret;
770	goto out;
771	}
772	ASSERT(ret);
773	ASSERT(path1->slots[0]);
774
775	path1->slots[0]--;
776		487
777	WARN_ON(cur->checked);	488	/* Breadth-first search to build backref cache */
778	if (!list_empty(&cur->upper)) {	489	do {
779	/*	490	ret = btrfs_backref_add_tree_node(cache, path, iter, node_key,
780	* the backref was added previously when processing	491	cur);
781	* backref of type BTRFS_TREE_BLOCK_REF_KEY
782	*/
783	ASSERT(list_is_singular(&cur->upper));
784	edge = list_entry(cur->upper.next, struct backref_edge,
785	list[LOWER]);
786	ASSERT(list_empty(&edge->list[UPPER]));
787	exist = edge->node[UPPER];
788	/*
789	* add the upper level block to pending list if we need
790	* check its backrefs
791	*/
792	if (!exist->checked)
793	list_add_tail(&edge->list[UPPER], &list);
794	} else {
795	exist = NULL;
796	}
797
798	while (1) {
799	cond_resched();
800	eb = path1->nodes[0];
801
802	if (ptr >= end) {
803	if (path1->slots[0] >= btrfs_header_nritems(eb)) {
804	ret = btrfs_next_leaf(rc->extent_root, path1);
805	if (ret < 0) {
806	err = ret;
807	goto out;
808	}
809	if (ret > 0)
810	break;
811	eb = path1->nodes[0];
812	}
813
814	btrfs_item_key_to_cpu(eb, &key, path1->slots[0]);
815	if (key.objectid != cur->bytenr) {
816	WARN_ON(exist);
817	break;
818	}
819
820	if (key.type == BTRFS_EXTENT_ITEM_KEY \|\|
821	key.type == BTRFS_METADATA_ITEM_KEY) {
822	ret = find_inline_backref(eb, path1->slots[0],
823	&ptr, &end);
824	if (ret)
825	goto next;
826	}
827	}
828
829	if (ptr < end) {
830	/* update key for inline back ref */
831	struct btrfs_extent_inline_ref *iref;
832	int type;
833	iref = (struct btrfs_extent_inline_ref *)ptr;
834	type = btrfs_get_extent_inline_ref_type(eb, iref,
835	BTRFS_REF_TYPE_BLOCK);
836	if (type == BTRFS_REF_TYPE_INVALID) {
837	err = -EUCLEAN;
838	goto out;
839	}
840	key.type = type;
841	key.offset = btrfs_extent_inline_ref_offset(eb, iref);
842
843	WARN_ON(key.type != BTRFS_TREE_BLOCK_REF_KEY &&
844	key.type != BTRFS_SHARED_BLOCK_REF_KEY);
845	}
846
847	/*
848	* Parent node found and matches current inline ref, no need to
849	* rebuild this node for this inline ref.
850	*/
851	if (exist &&
852	((key.type == BTRFS_TREE_BLOCK_REF_KEY &&
853	exist->owner == key.offset) \|\|
854	(key.type == BTRFS_SHARED_BLOCK_REF_KEY &&
855	exist->bytenr == key.offset))) {
856	exist = NULL;
857	goto next;
858	}
859
860	/* SHARED_BLOCK_REF means key.offset is the parent bytenr */
861	if (key.type == BTRFS_SHARED_BLOCK_REF_KEY) {
862	if (key.objectid == key.offset) {
863	/*
864	* Only root blocks of reloc trees use backref
865	* pointing to itself.
866	*/
867	root = find_reloc_root(rc, cur->bytenr);
868	ASSERT(root);
869	cur->root = root;
870	break;
871	}
872
873	edge = alloc_backref_edge(cache);
874	if (!edge) {
875	err = -ENOMEM;
876	goto out;
877	}
878	rb_node = tree_search(&cache->rb_root, key.offset);
879	if (!rb_node) {
880	upper = alloc_backref_node(cache);
881	if (!upper) {
882	free_backref_edge(cache, edge);
883	err = -ENOMEM;
884	goto out;
885	}
886	upper->bytenr = key.offset;
887	upper->level = cur->level + 1;
888	/*
889	* backrefs for the upper level block isn't
890	* cached, add the block to pending list
891	*/
892	list_add_tail(&edge->list[UPPER], &list);
893	} else {
894	upper = rb_entry(rb_node, struct backref_node,
895	rb_node);
896	ASSERT(upper->checked);
897	INIT_LIST_HEAD(&edge->list[UPPER]);
898	}
899	list_add_tail(&edge->list[LOWER], &cur->upper);
900	edge->node[LOWER] = cur;
901	edge->node[UPPER] = upper;
902
903	goto next;
904	} else if (unlikely(key.type == BTRFS_EXTENT_REF_V0_KEY)) {
905	err = -EINVAL;
906	btrfs_print_v0_err(rc->extent_root->fs_info);
907	btrfs_handle_fs_error(rc->extent_root->fs_info, err,
908	NULL);
909	goto out;
910	} else if (key.type != BTRFS_TREE_BLOCK_REF_KEY) {
911	goto next;
912	}
913
914	/*
915	* key.type == BTRFS_TREE_BLOCK_REF_KEY, inline ref offset
916	* means the root objectid. We need to search the tree to get
917	* its parent bytenr.
918	*/
919	root = read_fs_root(rc->extent_root->fs_info, key.offset);
920	if (IS_ERR(root)) {
921	err = PTR_ERR(root);
922	goto out;
923	}
924
925	if (!test_bit(BTRFS_ROOT_REF_COWS, &root->state))
926	cur->cowonly = 1;
927
928	if (btrfs_root_level(&root->root_item) == cur->level) {
929	/* tree root */
930	ASSERT(btrfs_root_bytenr(&root->root_item) ==
931	cur->bytenr);
932	if (should_ignore_root(root)) {
933	btrfs_put_root(root);
934	list_add(&cur->list, &useless);
935	} else {
936	cur->root = root;
937	}
938	break;
939	}
940
941	level = cur->level + 1;
942
943	/* Search the tree to find parent blocks referring the block. */
944	path2->search_commit_root = 1;
945	path2->skip_locking = 1;
946	path2->lowest_level = level;
947	ret = btrfs_search_slot(NULL, root, node_key, path2, 0, 0);
948	path2->lowest_level = 0;
949	if (ret < 0) {	492	if (ret < 0) {
950	btrfs_put_root(root);
951	err = ret;	493	err = ret;
952	goto out;	494	goto out;
953	}	495	}
954	if (ret > 0 && path2->slots[level] > 0)	496	edge = list_first_entry_or_null(&cache->pending_edge,
955	path2->slots[level]--;	497	struct btrfs_backref_edge, list[UPPER]);
956		498	/*
957	eb = path2->nodes[level];	499	* The pending list isn't empty, take the first block to
958	if (btrfs_node_blockptr(eb, path2->slots[level]) !=	500	* process
959	cur->bytenr) {	501	*/
960	btrfs_err(root->fs_info,	502	if (edge) {
961	"couldn't find block (%llu) (level %d) in tree (%llu) with key (%llu %u %llu)",	503	list_del_init(&edge->list[UPPER]);
962	cur->bytenr, level - 1,	504	cur = edge->node[UPPER];
963	root->root_key.objectid,
964	node_key->objectid, node_key->type,
965	node_key->offset);
966	btrfs_put_root(root);
967	err = -ENOENT;
968	goto out;
969	}
970	lower = cur;
971	need_check = true;
972
973	/* Add all nodes and edges in the path */
974	for (; level < BTRFS_MAX_LEVEL; level++) {
975	if (!path2->nodes[level]) {
976	ASSERT(btrfs_root_bytenr(&root->root_item) ==
977	lower->bytenr);
978	if (should_ignore_root(root)) {
979	btrfs_put_root(root);
980	list_add(&lower->list, &useless);
981	} else {
982	lower->root = root;
983	}
984	break;
985	}
986
987	edge = alloc_backref_edge(cache);
988	if (!edge) {
989	btrfs_put_root(root);
990	err = -ENOMEM;
991	goto out;
992	}
993
994	eb = path2->nodes[level];
995	rb_node = tree_search(&cache->rb_root, eb->start);
996	if (!rb_node) {
997	upper = alloc_backref_node(cache);
998	if (!upper) {
999	btrfs_put_root(root);
1000	free_backref_edge(cache, edge);
1001	err = -ENOMEM;
1002	goto out;
1003	}
1004	upper->bytenr = eb->start;
1005	upper->owner = btrfs_header_owner(eb);
1006	upper->level = lower->level + 1;
1007	if (!test_bit(BTRFS_ROOT_REF_COWS,
1008	&root->state))
1009	upper->cowonly = 1;
1010
1011	/*
1012	* if we know the block isn't shared
1013	* we can void checking its backrefs.
1014	*/
1015	if (btrfs_block_can_be_shared(root, eb))
1016	upper->checked = 0;
1017	else
1018	upper->checked = 1;
1019
1020	/*
1021	* add the block to pending list if we
1022	* need check its backrefs, we only do this once
1023	* while walking up a tree as we will catch
1024	* anything else later on.
1025	*/
1026	if (!upper->checked && need_check) {
1027	need_check = false;
1028	list_add_tail(&edge->list[UPPER],
1029	&list);
1030	} else {
1031	if (upper->checked)
1032	need_check = true;
1033	INIT_LIST_HEAD(&edge->list[UPPER]);
1034	}
1035	} else {
1036	upper = rb_entry(rb_node, struct backref_node,
1037	rb_node);
1038	ASSERT(upper->checked);
1039	INIT_LIST_HEAD(&edge->list[UPPER]);
1040	if (!upper->owner)
1041	upper->owner = btrfs_header_owner(eb);
1042	}
1043	list_add_tail(&edge->list[LOWER], &lower->upper);
1044	edge->node[LOWER] = lower;
1045	edge->node[UPPER] = upper;
1046
1047	if (rb_node) {
1048	btrfs_put_root(root);
1049	break;
1050	}
1051	lower = upper;
1052	upper = NULL;
1053	}
1054	btrfs_release_path(path2);
1055	next:
1056	if (ptr < end) {
1057	ptr += btrfs_extent_inline_ref_size(key.type);
1058	if (ptr >= end) {
1059	WARN_ON(ptr > end);
1060	ptr = 0;
1061	end = 0;
1062	}
1063	}
1064	if (ptr >= end)
1065	path1->slots[0]++;
1066	}
1067	btrfs_release_path(path1);
1068
1069	cur->checked = 1;
1070	WARN_ON(exist);
1071
1072	/* the pending list isn't empty, take the first block to process */
1073	if (!list_empty(&list)) {
1074	edge = list_entry(list.next, struct backref_edge, list[UPPER]);
1075	list_del_init(&edge->list[UPPER]);
1076	cur = edge->node[UPPER];
1077	goto again;
1078	}
1079
1080	/*
1081	* everything goes well, connect backref nodes and insert backref nodes
1082	* into the cache.
1083	*/
1084	ASSERT(node->checked);
1085	cowonly = node->cowonly;
1086	if (!cowonly) {
1087	rb_node = tree_insert(&cache->rb_root, node->bytenr,
1088	&node->rb_node);
1089	if (rb_node)
1090	backref_tree_panic(rb_node, -EEXIST, node->bytenr);
1091	list_add_tail(&node->lower, &cache->leaves);
1092	}
1093
1094	list_for_each_entry(edge, &node->upper, list[LOWER])
1095	list_add_tail(&edge->list[UPPER], &list);
1096
1097	while (!list_empty(&list)) {
1098	edge = list_entry(list.next, struct backref_edge, list[UPPER]);
1099	list_del_init(&edge->list[UPPER]);
1100	upper = edge->node[UPPER];
1101	if (upper->detached) {
1102	list_del(&edge->list[LOWER]);
1103	lower = edge->node[LOWER];
1104	free_backref_edge(cache, edge);
1105	if (list_empty(&lower->upper))
1106	list_add(&lower->list, &useless);
1107	continue;
1108	}
1109
1110	if (!RB_EMPTY_NODE(&upper->rb_node)) {
1111	if (upper->lowest) {
1112	list_del_init(&upper->lower);
1113	upper->lowest = 0;
1114	}
1115
1116	list_add_tail(&edge->list[UPPER], &upper->lower);
1117	continue;
1118	}
1119
1120	if (!upper->checked) {
1121	/*
1122	* Still want to blow up for developers since this is a
1123	* logic bug.
1124	*/
1125	ASSERT(0);
1126	err = -EINVAL;
1127	goto out;
1128	}
1129	if (cowonly != upper->cowonly) {
1130	ASSERT(0);
1131	err = -EINVAL;
1132	goto out;
1133	}
1134
1135	if (!cowonly) {
1136	rb_node = tree_insert(&cache->rb_root, upper->bytenr,
1137	&upper->rb_node);
1138	if (rb_node)
1139	backref_tree_panic(rb_node, -EEXIST,
1140	upper->bytenr);
1141	}	505	}
		506	} while (edge);
1142		507
1143	list_add_tail(&edge->list[UPPER], &upper->lower);	508	/* Finish the upper linkage of newly added edges/nodes */
1144		509	ret = btrfs_backref_finish_upper_links(cache, node);
1145	list_for_each_entry(edge, &upper->upper, list[LOWER])	510	if (ret < 0) {
1146	list_add_tail(&edge->list[UPPER], &list);	511	err = ret;
		512	goto out;
1147	}	513	}
1148	/*
1149	* process useless backref nodes. backref nodes for tree leaves
1150	* are deleted from the cache. backref nodes for upper level
1151	* tree blocks are left in the cache to avoid unnecessary backref
1152	* lookup.
1153	*/
1154	while (!list_empty(&useless)) {
1155	upper = list_entry(useless.next, struct backref_node, list);
1156	list_del_init(&upper->list);
1157	ASSERT(list_empty(&upper->upper));
1158	if (upper == node)
1159	node = NULL;
1160	if (upper->lowest) {
1161	list_del_init(&upper->lower);
1162	upper->lowest = 0;
1163	}
1164	while (!list_empty(&upper->lower)) {
1165	edge = list_entry(upper->lower.next,
1166	struct backref_edge, list[UPPER]);
1167	list_del(&edge->list[UPPER]);
1168	list_del(&edge->list[LOWER]);
1169	lower = edge->node[LOWER];
1170	free_backref_edge(cache, edge);
1171		514
1172	if (list_empty(&lower->upper))	515	if (handle_useless_nodes(rc, node))
1173	list_add(&lower->list, &useless);	516	node = NULL;
1174	}
1175	__mark_block_processed(rc, upper);
1176	if (upper->level > 0) {
1177	list_add(&upper->list, &cache->detached);
1178	upper->detached = 1;
1179	} else {
1180	rb_erase(&upper->rb_node, &cache->rb_root);
1181	free_backref_node(cache, upper);
1182	}
1183	}
1184	out:	517	out:
1185	btrfs_free_path(path1);	518	btrfs_backref_iter_free(iter);
1186	btrfs_free_path(path2);	519	btrfs_free_path(path);
1187	if (err) {	520	if (err) {
1188	while (!list_empty(&useless)) {	521	btrfs_backref_error_cleanup(cache, node);
1189	lower = list_entry(useless.next,
1190	struct backref_node, list);
1191	list_del_init(&lower->list);
1192	}
1193	while (!list_empty(&list)) {
1194	edge = list_first_entry(&list, struct backref_edge,
1195	list[UPPER]);
1196	list_del(&edge->list[UPPER]);
1197	list_del(&edge->list[LOWER]);
1198	lower = edge->node[LOWER];
1199	upper = edge->node[UPPER];
1200	free_backref_edge(cache, edge);
1201
1202	/*
1203	* Lower is no longer linked to any upper backref nodes
1204	* and isn't in the cache, we can free it ourselves.
1205	*/
1206	if (list_empty(&lower->upper) &&
1207	RB_EMPTY_NODE(&lower->rb_node))
1208	list_add(&lower->list, &useless);
1209
1210	if (!RB_EMPTY_NODE(&upper->rb_node))
1211	continue;
1212
1213	/* Add this guy's upper edges to the list to process */
1214	list_for_each_entry(edge, &upper->upper, list[LOWER])
1215	list_add_tail(&edge->list[UPPER], &list);
1216	if (list_empty(&upper->upper))
1217	list_add(&upper->list, &useless);
1218	}
1219
1220	while (!list_empty(&useless)) {
1221	lower = list_entry(useless.next,
1222	struct backref_node, list);
1223	list_del_init(&lower->list);
1224	if (lower == node)
1225	node = NULL;
1226	free_backref_node(cache, lower);
1227	}
1228
1229	remove_backref_node(cache, node);
1230	return ERR_PTR(err);	522	return ERR_PTR(err);
1231	}	523	}
1232	ASSERT(!node \|\| !node->detached);	524	ASSERT(!node \|\| !node->detached);
		525	ASSERT(list_empty(&cache->useless_node) &&
		526	list_empty(&cache->pending_edge));
1233	return node;	527	return node;
1234	}	528	}
1235		529
@@ -1244,19 +538,19 @@ static int clone_backref_node(struct btrfs_trans_handle *trans, · 8 unmodified lines
1244	struct btrfs_root *dest)	538	struct btrfs_root *dest)
1245	{	539	{
1246	struct btrfs_root *reloc_root = src->reloc_root;	540	struct btrfs_root *reloc_root = src->reloc_root;
1247	struct backref_cache *cache = &rc->backref_cache;	541	struct btrfs_backref_cache *cache = &rc->backref_cache;
1248	struct backref_node *node = NULL;	542	struct btrfs_backref_node *node = NULL;
1249	struct backref_node *new_node;	543	struct btrfs_backref_node *new_node;
1250	struct backref_edge *edge;	544	struct btrfs_backref_edge *edge;
1251	struct backref_edge *new_edge;	545	struct btrfs_backref_edge *new_edge;
1252	struct rb_node *rb_node;	546	struct rb_node *rb_node;
1253		547
1254	if (cache->last_trans > 0)	548	if (cache->last_trans > 0)
1255	update_backref_cache(trans, cache);	549	update_backref_cache(trans, cache);
1256		550
1257	rb_node = tree_search(&cache->rb_root, src->commit_root->start);	551	rb_node = rb_simple_search(&cache->rb_root, src->commit_root->start);
1258	if (rb_node) {	552	if (rb_node) {
1259	node = rb_entry(rb_node, struct backref_node, rb_node);	553	node = rb_entry(rb_node, struct btrfs_backref_node, rb_node);
1260	if (node->detached)	554	if (node->detached)
1261	node = NULL;	555	node = NULL;
1262	else	556	else
@@ -1264,10 +558,10 @@ static int clone_backref_node(struct btrfs_trans_handle *trans, · 1 unmodified line
1264	}	558	}
1265		559
1266	if (!node) {	560	if (!node) {
1267	rb_node = tree_search(&cache->rb_root,	561	rb_node = rb_simple_search(&cache->rb_root,
1268	reloc_root->commit_root->start);	562	reloc_root->commit_root->start);
1269	if (rb_node) {	563	if (rb_node) {
1270	node = rb_entry(rb_node, struct backref_node,	564	node = rb_entry(rb_node, struct btrfs_backref_node,
1271	rb_node);	565	rb_node);
1272	BUG_ON(node->detached);	566	BUG_ON(node->detached);
1273	}	567	}
@@ -1276,12 +570,11 @@ static int clone_backref_node(struct btrfs_trans_handle *trans, · 2 unmodified lines
1276	if (!node)	570	if (!node)
1277	return 0;	571	return 0;
1278		572
1279	new_node = alloc_backref_node(cache);	573	new_node = btrfs_backref_alloc_node(cache, dest->node->start,
		574	node->level);
1280	if (!new_node)	575	if (!new_node)
1281	return -ENOMEM;	576	return -ENOMEM;
1282		577
1283	new_node->bytenr = dest->node->start;
1284	new_node->level = node->level;
1285	new_node->lowest = node->lowest;	578	new_node->lowest = node->lowest;
1286	new_node->checked = 1;	579	new_node->checked = 1;
1287	new_node->root = btrfs_grab_root(dest);	580	new_node->root = btrfs_grab_root(dest);
@@ -1289,23 +582,21 @@ static int clone_backref_node(struct btrfs_trans_handle *trans, · 1 unmodified line
1289		582
1290	if (!node->lowest) {	583	if (!node->lowest) {
1291	list_for_each_entry(edge, &node->lower, list[UPPER]) {	584	list_for_each_entry(edge, &node->lower, list[UPPER]) {
1292	new_edge = alloc_backref_edge(cache);	585	new_edge = btrfs_backref_alloc_edge(cache);
1293	if (!new_edge)	586	if (!new_edge)
1294	goto fail;	587	goto fail;
1295		588
1296	new_edge->node[UPPER] = new_node;	589	btrfs_backref_link_edge(new_edge, edge->node[LOWER],
1297	new_edge->node[LOWER] = edge->node[LOWER];	590	new_node, LINK_UPPER);
1298	list_add_tail(&new_edge->list[UPPER],
1299	&new_node->lower);
1300	}	591	}
1301	} else {	592	} else {
1302	list_add_tail(&new_node->lower, &cache->leaves);	593	list_add_tail(&new_node->lower, &cache->leaves);
1303	}	594	}
1304		595
1305	rb_node = tree_insert(&cache->rb_root, new_node->bytenr,	596	rb_node = rb_simple_insert(&cache->rb_root, new_node->bytenr,
1306	&new_node->rb_node);	597	&new_node->rb_node);
1307	if (rb_node)	598	if (rb_node)
1308	backref_tree_panic(rb_node, -EEXIST, new_node->bytenr);	599	btrfs_backref_panic(trans->fs_info, new_node->bytenr, -EEXIST);
1309		600
1310	if (!new_node->lowest) {	601	if (!new_node->lowest) {
1311	list_for_each_entry(new_edge, &new_node->lower, list[UPPER]) {	602	list_for_each_entry(new_edge, &new_node->lower, list[UPPER]) {
@@ -1317,11 +608,11 @@ static int clone_backref_node(struct btrfs_trans_handle *trans, · 5 unmodified lines
1317	fail:	608	fail:
1318	while (!list_empty(&new_node->lower)) {	609	while (!list_empty(&new_node->lower)) {
1319	new_edge = list_entry(new_node->lower.next,	610	new_edge = list_entry(new_node->lower.next,
1320	struct backref_edge, list[UPPER]);	611	struct btrfs_backref_edge, list[UPPER]);
1321	list_del(&new_edge->list[UPPER]);	612	list_del(&new_edge->list[UPPER]);
1322	free_backref_edge(cache, new_edge);	613	btrfs_backref_free_edge(cache, new_edge);
1323	}	614	}
1324	free_backref_node(cache, new_node);	615	btrfs_backref_free_node(cache, new_node);
1325	return -ENOMEM;	616	return -ENOMEM;
1326	}	617	}
1327		618
@@ -1343,8 +634,8 @@ static int __must_check __add_reloc_root(struct btrfs_root *root) · 15 unmodified lines
1343	node->data = root;	634	node->data = root;
1344		635
1345	spin_lock(&rc->reloc_root_tree.lock);	636	spin_lock(&rc->reloc_root_tree.lock);
1346	rb_node = tree_insert(&rc->reloc_root_tree.rb_root,	637	rb_node = rb_simple_insert(&rc->reloc_root_tree.rb_root,
1347	node->bytenr, &node->rb_node);	638	node->bytenr, &node->rb_node);
1348	spin_unlock(&rc->reloc_root_tree.lock);	639	spin_unlock(&rc->reloc_root_tree.lock);
1349	if (rb_node) {	640	if (rb_node) {
1350	btrfs_panic(fs_info, -EEXIST,	641	btrfs_panic(fs_info, -EEXIST,
@@ -1370,8 +661,8 @@ static void __del_reloc_root(struct btrfs_root *root) · 19 unmodified lines
1370		661
1371	if (rc && root->node) {	662	if (rc && root->node) {
1372	spin_lock(&rc->reloc_root_tree.lock);	663	spin_lock(&rc->reloc_root_tree.lock);
1373	rb_node = tree_search(&rc->reloc_root_tree.rb_root,	664	rb_node = rb_simple_search(&rc->reloc_root_tree.rb_root,
1374	root->commit_root->start);	665	root->commit_root->start);
1375	if (rb_node) {	666	if (rb_node) {
1376	node = rb_entry(rb_node, struct mapping_node, rb_node);	667	node = rb_entry(rb_node, struct mapping_node, rb_node);
1377	rb_erase(&node->rb_node, &rc->reloc_root_tree.rb_root);	668	rb_erase(&node->rb_node, &rc->reloc_root_tree.rb_root);
@@ -1414,8 +705,8 @@ static int __update_reloc_root(struct btrfs_root *root) · 36 unmodified lines
1414	struct reloc_control *rc = fs_info->reloc_ctl;	705	struct reloc_control *rc = fs_info->reloc_ctl;
1415		706
1416	spin_lock(&rc->reloc_root_tree.lock);	707	spin_lock(&rc->reloc_root_tree.lock);
1417	rb_node = tree_search(&rc->reloc_root_tree.rb_root,	708	rb_node = rb_simple_search(&rc->reloc_root_tree.rb_root,
1418	root->commit_root->start);	709	root->commit_root->start);
1419	if (rb_node) {	710	if (rb_node) {
1420	node = rb_entry(rb_node, struct mapping_node, rb_node);	711	node = rb_entry(rb_node, struct mapping_node, rb_node);
1421	rb_erase(&node->rb_node, &rc->reloc_root_tree.rb_root);	712	rb_erase(&node->rb_node, &rc->reloc_root_tree.rb_root);
@@ -1428,11 +719,11 @@ static int __update_reloc_root(struct btrfs_root *root) · 6 unmodified lines
1428		719
1429	spin_lock(&rc->reloc_root_tree.lock);	720	spin_lock(&rc->reloc_root_tree.lock);
1430	node->bytenr = root->node->start;	721	node->bytenr = root->node->start;
1431	rb_node = tree_insert(&rc->reloc_root_tree.rb_root,	722	rb_node = rb_simple_insert(&rc->reloc_root_tree.rb_root,
1432	node->bytenr, &node->rb_node);	723	node->bytenr, &node->rb_node);
1433	spin_unlock(&rc->reloc_root_tree.lock);	724	spin_unlock(&rc->reloc_root_tree.lock);
1434	if (rb_node)	725	if (rb_node)
1435	backref_tree_panic(rb_node, -EEXIST, node->bytenr);	726	btrfs_backref_panic(fs_info, node->bytenr, -EEXIST);
1436	return 0;	727	return 0;
1437	}	728	}
1438		729
@@ -1505,7 +796,7 @@ static struct btrfs_root create_reloc_root(struct btrfs_trans_handle trans, · 66 unmodified lines
1505		796
1506	reloc_root = btrfs_read_tree_root(fs_info->tree_root, &root_key);	797	reloc_root = btrfs_read_tree_root(fs_info->tree_root, &root_key);
1507	BUG_ON(IS_ERR(reloc_root));	798	BUG_ON(IS_ERR(reloc_root));
1508	set_bit(BTRFS_ROOT_REF_COWS, &reloc_root->state);	799	set_bit(BTRFS_ROOT_SHAREABLE, &reloc_root->state);
1509	reloc_root->last_trans = trans->transid;	800	reloc_root->last_trans = trans->transid;
1510	return reloc_root;	801	return reloc_root;
1511	}	802	}
@@ -1679,14 +970,6 @@ again: · 167 unmodified lines
1679	return NULL;	970	return NULL;
1680	}	971	}
1681		972
1682	static int in_block_group(u64 bytenr, struct btrfs_block_group *block_group)
1683	{
1684	if (bytenr >= block_group->start &&
1685	bytenr < block_group->start + block_group->length)
1686	return 1;
1687	return 0;
1688	}
1689
1690	/*	973	/*
1691	* get new location of data	974	* get new location of data
1692	*/	975	*/
@@ -1784,7 +1067,8 @@ int replace_file_extents(struct btrfs_trans_handle *trans, · 91 unmodified lines
1784	num_bytes = btrfs_file_extent_disk_num_bytes(leaf, fi);	1067	num_bytes = btrfs_file_extent_disk_num_bytes(leaf, fi);
1785	if (bytenr == 0)	1068	if (bytenr == 0)
1786	continue;	1069	continue;
1787	if (!in_block_group(bytenr, rc->block_group))	1070	if (!in_range(bytenr, rc->block_group->start,
		1071	rc->block_group->length))
1788	continue;	1072	continue;
1789		1073
1790	/*	1074	/*
@@ -1940,7 +1224,7 @@ again: · 149 unmodified lines
1940	level = btrfs_header_level(parent);	1224	level = btrfs_header_level(parent);
1941	BUG_ON(level < lowest_level);	1225	BUG_ON(level < lowest_level);
1942		1226
1943	ret = btrfs_bin_search(parent, &key, level, &slot);	1227	ret = btrfs_bin_search(parent, &key, &slot);
1944	if (ret < 0)	1228	if (ret < 0)
1945	break;	1229	break;
1946	if (ret && slot > 0)	1230	if (ret && slot > 0)
@@ -2560,7 +1844,8 @@ again: · 613 unmodified lines
2560	struct btrfs_root, root_list);	1844	struct btrfs_root, root_list);
2561	list_del_init(&reloc_root->root_list);	1845	list_del_init(&reloc_root->root_list);
2562		1846
2563	root = read_fs_root(fs_info, reloc_root->root_key.offset);	1847	root = btrfs_get_fs_root(fs_info, reloc_root->root_key.offset,
		1848	false);
2564	BUG_ON(IS_ERR(root));	1849	BUG_ON(IS_ERR(root));
2565	BUG_ON(root->reloc_root != reloc_root);	1850	BUG_ON(root->reloc_root != reloc_root);
2566		1851
@@ -2588,13 +1873,10 @@ again: · 21 unmodified lines
2588	static noinline_for_stack	1873	static noinline_for_stack
2589	void free_reloc_roots(struct list_head *list)	1874	void free_reloc_roots(struct list_head *list)
2590	{	1875	{
2591	struct btrfs_root *reloc_root;	1876	struct btrfs_root reloc_root, tmp;
2592		1877
2593	while (!list_empty(list)) {	1878	list_for_each_entry_safe(reloc_root, tmp, list, root_list)
2594	reloc_root = list_entry(list->next, struct btrfs_root,
2595	root_list);
2596	__del_reloc_root(reloc_root);	1879	__del_reloc_root(reloc_root);
2597	}
2598	}	1880	}
2599		1881
2600	static noinline_for_stack	1882	static noinline_for_stack
@@ -2624,12 +1906,11 @@ again: · 23 unmodified lines
2624	reloc_root = list_entry(reloc_roots.next,	1906	reloc_root = list_entry(reloc_roots.next,
2625	struct btrfs_root, root_list);	1907	struct btrfs_root, root_list);
2626		1908
		1909	root = btrfs_get_fs_root(fs_info, reloc_root->root_key.offset,
		1910	false);
2627	if (btrfs_root_refs(&reloc_root->root_item) > 0) {	1911	if (btrfs_root_refs(&reloc_root->root_item) > 0) {
2628	root = read_fs_root(fs_info,
2629	reloc_root->root_key.offset);
2630	BUG_ON(IS_ERR(root));	1912	BUG_ON(IS_ERR(root));
2631	BUG_ON(root->reloc_root != reloc_root);	1913	BUG_ON(root->reloc_root != reloc_root);
2632
2633	ret = merge_reloc_root(rc, root);	1914	ret = merge_reloc_root(rc, root);
2634	btrfs_put_root(root);	1915	btrfs_put_root(root);
2635	if (ret) {	1916	if (ret) {
@@ -2639,6 +1920,16 @@ again: · 3 unmodified lines
2639	goto out;	1920	goto out;
2640	}	1921	}
2641	} else {	1922	} else {
		1923	if (!IS_ERR(root)) {
		1924	if (root->reloc_root == reloc_root) {
		1925	root->reloc_root = NULL;
		1926	btrfs_put_root(reloc_root);
		1927	}
		1928	clear_bit(BTRFS_ROOT_DEAD_RELOC_TREE,
		1929	&root->state);
		1930	btrfs_put_root(root);
		1931	}
		1932
2642	list_del_init(&reloc_root->root_list);	1933	list_del_init(&reloc_root->root_list);
2643	/* Don't forget to queue this reloc root for cleanup */	1934	/* Don't forget to queue this reloc root for cleanup */
2644	list_add_tail(&reloc_root->reloc_dirty_list,	1935	list_add_tail(&reloc_root->reloc_dirty_list,
@@ -2653,15 +1944,13 @@ again: · 8 unmodified lines
2653	out:	1944	out:
2654	if (ret) {	1945	if (ret) {
2655	btrfs_handle_fs_error(fs_info, ret, NULL);	1946	btrfs_handle_fs_error(fs_info, ret, NULL);
2656	if (!list_empty(&reloc_roots))	1947	free_reloc_roots(&reloc_roots);
2657	free_reloc_roots(&reloc_roots);
2658		1948
2659	/* new reloc root may be added */	1949	/* new reloc root may be added */
2660	mutex_lock(&fs_info->reloc_mutex);	1950	mutex_lock(&fs_info->reloc_mutex);
2661	list_splice_init(&rc->reloc_roots, &reloc_roots);	1951	list_splice_init(&rc->reloc_roots, &reloc_roots);
2662	mutex_unlock(&fs_info->reloc_mutex);	1952	mutex_unlock(&fs_info->reloc_mutex);
2663	if (!list_empty(&reloc_roots))	1953	free_reloc_roots(&reloc_roots);
2664	free_reloc_roots(&reloc_roots);
2665	}	1954	}
2666		1955
2667	/*	1956	/*
@@ -2702,7 +1991,7 @@ static int record_reloc_root_in_trans(struct btrfs_trans_handle *trans, · 34 unmodified lines
2702	if (reloc_root->last_trans == trans->transid)	1991	if (reloc_root->last_trans == trans->transid)
2703	return 0;	1992	return 0;
2704		1993
2705	root = read_fs_root(fs_info, reloc_root->root_key.offset);	1994	root = btrfs_get_fs_root(fs_info, reloc_root->root_key.offset, false);
2706	BUG_ON(IS_ERR(root));	1995	BUG_ON(IS_ERR(root));
2707	BUG_ON(root->reloc_root != reloc_root);	1996	BUG_ON(root->reloc_root != reloc_root);
2708	ret = btrfs_record_root_in_trans(trans, root);	1997	ret = btrfs_record_root_in_trans(trans, root);
@@ -2714,10 +2003,10 @@ static int record_reloc_root_in_trans(struct btrfs_trans_handle *trans, · 5 unmodified lines
2714	static noinline_for_stack	2003	static noinline_for_stack
2715	struct btrfs_root select_reloc_root(struct btrfs_trans_handle trans,	2004	struct btrfs_root select_reloc_root(struct btrfs_trans_handle trans,
2716	struct reloc_control *rc,	2005	struct reloc_control *rc,
2717	struct backref_node *node,	2006	struct btrfs_backref_node *node,
2718	struct backref_edge *edges[])	2007	struct btrfs_backref_edge *edges[])
2719	{	2008	{
2720	struct backref_node *next;	2009	struct btrfs_backref_node *next;
2721	struct btrfs_root *root;	2010	struct btrfs_root *root;
2722	int index = 0;	2011	int index = 0;
2723		2012
@@ -2727,7 +2016,7 @@ struct btrfs_root select_reloc_root(struct btrfs_trans_handle trans, · 3 unmodified lines
2727	next = walk_up_backref(next, edges, &index);	2016	next = walk_up_backref(next, edges, &index);
2728	root = next->root;	2017	root = next->root;
2729	BUG_ON(!root);	2018	BUG_ON(!root);
2730	BUG_ON(!test_bit(BTRFS_ROOT_REF_COWS, &root->state));	2019	BUG_ON(!test_bit(BTRFS_ROOT_SHAREABLE, &root->state));
2731		2020
2732	if (root->root_key.objectid == BTRFS_TREE_RELOC_OBJECTID) {	2021	if (root->root_key.objectid == BTRFS_TREE_RELOC_OBJECTID) {
2733	record_reloc_root_in_trans(trans, root);	2022	record_reloc_root_in_trans(trans, root);
@@ -2746,7 +2035,7 @@ struct btrfs_root select_reloc_root(struct btrfs_trans_handle trans, · 12 unmodified lines
2746	ASSERT(next->root);	2035	ASSERT(next->root);
2747	list_add_tail(&next->list,	2036	list_add_tail(&next->list,
2748	&rc->backref_cache.changed);	2037	&rc->backref_cache.changed);
2749	__mark_block_processed(rc, next);	2038	mark_block_processed(rc, next);
2750	break;	2039	break;
2751	}	2040	}
2752		2041
@@ -2771,18 +2060,21 @@ struct btrfs_root select_reloc_root(struct btrfs_trans_handle trans, · 18 unmodified lines
2771	}	2060	}
2772		2061
2773	/*	2062	/*
2774	* select a tree root for relocation. return NULL if the block	2063	* Select a tree root for relocation.
2775	* is reference counted. we should use do_relocation() in this	2064	*
2776	* case. return a tree root pointer if the block isn't reference	2065	* Return NULL if the block is not shareable. We should use do_relocation() in
2777	* counted. return -ENOENT if the block is root of reloc tree.	2066	* this case.
		2067	*
		2068	* Return a tree root pointer if the block is shareable.
		2069	* Return -ENOENT if the block is root of reloc tree.
2778	*/	2070	*/
2779	static noinline_for_stack	2071	static noinline_for_stack
2780	struct btrfs_root select_one_root(struct backref_node node)	2072	struct btrfs_root select_one_root(struct btrfs_backref_node node)
2781	{	2073	{
2782	struct backref_node *next;	2074	struct btrfs_backref_node *next;
2783	struct btrfs_root *root;	2075	struct btrfs_root *root;
2784	struct btrfs_root *fs_root = NULL;	2076	struct btrfs_root *fs_root = NULL;
2785	struct backref_edge *edges[BTRFS_MAX_LEVEL - 1];	2077	struct btrfs_backref_edge *edges[BTRFS_MAX_LEVEL - 1];
2786	int index = 0;	2078	int index = 0;
2787		2079
2788	next = node;	2080	next = node;
@@ -2792,8 +2084,8 @@ struct btrfs_root select_one_root(struct backref_node node) · 3 unmodified lines
2792	root = next->root;	2084	root = next->root;
2793	BUG_ON(!root);	2085	BUG_ON(!root);
2794		2086
2795	/* no other choice for non-references counted tree */	2087	/* No other choice for non-shareable tree */
2796	if (!test_bit(BTRFS_ROOT_REF_COWS, &root->state))	2088	if (!test_bit(BTRFS_ROOT_SHAREABLE, &root->state))
2797	return root;	2089	return root;
2798		2090
2799	if (root->root_key.objectid != BTRFS_TREE_RELOC_OBJECTID)	2091	if (root->root_key.objectid != BTRFS_TREE_RELOC_OBJECTID)
@@ -2814,12 +2106,12 @@ struct btrfs_root select_one_root(struct backref_node node) · 14 unmodified lines
2814		2106
2815	static noinline_for_stack	2107	static noinline_for_stack
2816	u64 calcu_metadata_size(struct reloc_control *rc,	2108	u64 calcu_metadata_size(struct reloc_control *rc,
2817	struct backref_node *node, int reserve)	2109	struct btrfs_backref_node *node, int reserve)
2818	{	2110	{
2819	struct btrfs_fs_info *fs_info = rc->extent_root->fs_info;	2111	struct btrfs_fs_info *fs_info = rc->extent_root->fs_info;
2820	struct backref_node *next = node;	2112	struct btrfs_backref_node *next = node;
2821	struct backref_edge *edge;	2113	struct btrfs_backref_edge *edge;
2822	struct backref_edge *edges[BTRFS_MAX_LEVEL - 1];	2114	struct btrfs_backref_edge *edges[BTRFS_MAX_LEVEL - 1];
2823	u64 num_bytes = 0;	2115	u64 num_bytes = 0;
2824	int index = 0;	2116	int index = 0;
2825		2117
@@ -2837,7 +2129,7 @@ u64 calcu_metadata_size(struct reloc_control *rc, · 11 unmodified lines
2837	break;	2129	break;
2838		2130
2839	edge = list_entry(next->upper.next,	2131	edge = list_entry(next->upper.next,
2840	struct backref_edge, list[LOWER]);	2132	struct btrfs_backref_edge, list[LOWER]);
2841	edges[index++] = edge;	2133	edges[index++] = edge;
2842	next = edge->node[UPPER];	2134	next = edge->node[UPPER];
2843	}	2135	}
@@ -2848,7 +2140,7 @@ u64 calcu_metadata_size(struct reloc_control *rc, · 4 unmodified lines
2848		2140
2849	static int reserve_metadata_space(struct btrfs_trans_handle *trans,	2141	static int reserve_metadata_space(struct btrfs_trans_handle *trans,
2850	struct reloc_control *rc,	2142	struct reloc_control *rc,
2851	struct backref_node *node)	2143	struct btrfs_backref_node *node)
2852	{	2144	{
2853	struct btrfs_root *root = rc->extent_root;	2145	struct btrfs_root *root = rc->extent_root;
2854	struct btrfs_fs_info *fs_info = root->fs_info;	2146	struct btrfs_fs_info *fs_info = root->fs_info;
@@ -2896,14 +2188,14 @@ static int reserve_metadata_space(struct btrfs_trans_handle *trans, · 41 unmodified lines
2896	*/	2188	*/
2897	static int do_relocation(struct btrfs_trans_handle *trans,	2189	static int do_relocation(struct btrfs_trans_handle *trans,
2898	struct reloc_control *rc,	2190	struct reloc_control *rc,
2899	struct backref_node *node,	2191	struct btrfs_backref_node *node,
2900	struct btrfs_key *key,	2192	struct btrfs_key *key,
2901	struct btrfs_path *path, int lowest)	2193	struct btrfs_path *path, int lowest)
2902	{	2194	{
2903	struct btrfs_fs_info *fs_info = rc->extent_root->fs_info;	2195	struct btrfs_fs_info *fs_info = rc->extent_root->fs_info;
2904	struct backref_node *upper;	2196	struct btrfs_backref_node *upper;
2905	struct backref_edge *edge;	2197	struct btrfs_backref_edge *edge;
2906	struct backref_edge *edges[BTRFS_MAX_LEVEL - 1];	2198	struct btrfs_backref_edge *edges[BTRFS_MAX_LEVEL - 1];
2907	struct btrfs_root *root;	2199	struct btrfs_root *root;
2908	struct extent_buffer *eb;	2200	struct extent_buffer *eb;
2909	u32 blocksize;	2201	u32 blocksize;
@@ -2929,8 +2221,7 @@ static int do_relocation(struct btrfs_trans_handle *trans, · 19 unmodified lines
2929		2221
2930	if (upper->eb && !upper->locked) {	2222	if (upper->eb && !upper->locked) {
2931	if (!lowest) {	2223	if (!lowest) {
2932	ret = btrfs_bin_search(upper->eb, key,	2224	ret = btrfs_bin_search(upper->eb, key, &slot);
2933	upper->level, &slot);
2934	if (ret < 0) {	2225	if (ret < 0) {
2935	err = ret;	2226	err = ret;
2936	goto next;	2227	goto next;
@@ -2940,7 +2231,7 @@ static int do_relocation(struct btrfs_trans_handle *trans, · 3 unmodified lines
2940	if (node->eb->start == bytenr)	2231	if (node->eb->start == bytenr)
2941	goto next;	2232	goto next;
2942	}	2233	}
2943	drop_node_buffer(upper);	2234	btrfs_backref_drop_node_buffer(upper);
2944	}	2235	}
2945		2236
2946	if (!upper->eb) {	2237	if (!upper->eb) {
@@ -2968,8 +2259,7 @@ static int do_relocation(struct btrfs_trans_handle *trans, · 21 unmodified lines
2968	slot = path->slots[upper->level];	2259	slot = path->slots[upper->level];
2969	btrfs_release_path(path);	2260	btrfs_release_path(path);
2970	} else {	2261	} else {
2971	ret = btrfs_bin_search(upper->eb, key, upper->level,	2262	ret = btrfs_bin_search(upper->eb, key, &slot);
2972	&slot);
2973	if (ret < 0) {	2263	if (ret < 0) {
2974	err = ret;	2264	err = ret;
2975	goto next;	2265	goto next;
@@ -3039,15 +2329,15 @@ static int do_relocation(struct btrfs_trans_handle *trans, · 63 unmodified lines
3039	}	2329	}
3040	next:	2330	next:
3041	if (!upper->pending)	2331	if (!upper->pending)
3042	drop_node_buffer(upper);	2332	btrfs_backref_drop_node_buffer(upper);
3043	else	2333	else
3044	unlock_node_buffer(upper);	2334	btrfs_backref_unlock_node_buffer(upper);
3045	if (err)	2335	if (err)
3046	break;	2336	break;
3047	}	2337	}
3048		2338
3049	if (!err && node->pending) {	2339	if (!err && node->pending) {
3050	drop_node_buffer(node);	2340	btrfs_backref_drop_node_buffer(node);
3051	list_move_tail(&node->list, &rc->backref_cache.changed);	2341	list_move_tail(&node->list, &rc->backref_cache.changed);
3052	node->pending = 0;	2342	node->pending = 0;
3053	}	2343	}
@@ -3059,7 +2349,7 @@ next: · 5 unmodified lines
3059		2349
3060	static int link_to_upper(struct btrfs_trans_handle *trans,	2350	static int link_to_upper(struct btrfs_trans_handle *trans,
3061	struct reloc_control *rc,	2351	struct reloc_control *rc,
3062	struct backref_node *node,	2352	struct btrfs_backref_node *node,
3063	struct btrfs_path *path)	2353	struct btrfs_path *path)
3064	{	2354	{
3065	struct btrfs_key key;	2355	struct btrfs_key key;
@@ -3073,15 +2363,15 @@ static int finish_pending_nodes(struct btrfs_trans_handle *trans, · 7 unmodified lines
3073	struct btrfs_path *path, int err)	2363	struct btrfs_path *path, int err)
3074	{	2364	{
3075	LIST_HEAD(list);	2365	LIST_HEAD(list);
3076	struct backref_cache *cache = &rc->backref_cache;	2366	struct btrfs_backref_cache *cache = &rc->backref_cache;
3077	struct backref_node *node;	2367	struct btrfs_backref_node *node;
3078	int level;	2368	int level;
3079	int ret;	2369	int ret;
3080		2370
3081	for (level = 0; level < BTRFS_MAX_LEVEL; level++) {	2371	for (level = 0; level < BTRFS_MAX_LEVEL; level++) {
3082	while (!list_empty(&cache->pending[level])) {	2372	while (!list_empty(&cache->pending[level])) {
3083	node = list_entry(cache->pending[level].next,	2373	node = list_entry(cache->pending[level].next,
3084	struct backref_node, list);	2374	struct btrfs_backref_node, list);
3085	list_move_tail(&node->list, &list);	2375	list_move_tail(&node->list, &list);
3086	BUG_ON(!node->pending);	2376	BUG_ON(!node->pending);
3087		2377
@@ -3096,35 +2386,16 @@ static int finish_pending_nodes(struct btrfs_trans_handle *trans, · 8 unmodified lines
3096	return err;	2386	return err;
3097	}	2387	}
3098		2388
3099	static void mark_block_processed(struct reloc_control *rc,
3100	u64 bytenr, u32 blocksize)
3101	{
3102	set_extent_bits(&rc->processed_blocks, bytenr, bytenr + blocksize - 1,
3103	EXTENT_DIRTY);
3104	}
3105
3106	static void __mark_block_processed(struct reloc_control *rc,
3107	struct backref_node *node)
3108	{
3109	u32 blocksize;
3110	if (node->level == 0 \|\|
3111	in_block_group(node->bytenr, rc->block_group)) {
3112	blocksize = rc->extent_root->fs_info->nodesize;
3113	mark_block_processed(rc, node->bytenr, blocksize);
3114	}
3115	node->processed = 1;
3116	}
3117
3118	/*	2389	/*
3119	* mark a block and all blocks directly/indirectly reference the block	2390	* mark a block and all blocks directly/indirectly reference the block
3120	* as processed.	2391	* as processed.
3121	*/	2392	*/
3122	static void update_processed_blocks(struct reloc_control *rc,	2393	static void update_processed_blocks(struct reloc_control *rc,
3123	struct backref_node *node)	2394	struct btrfs_backref_node *node)
3124	{	2395	{
3125	struct backref_node *next = node;	2396	struct btrfs_backref_node *next = node;
3126	struct backref_edge *edge;	2397	struct btrfs_backref_edge *edge;
3127	struct backref_edge *edges[BTRFS_MAX_LEVEL - 1];	2398	struct btrfs_backref_edge *edges[BTRFS_MAX_LEVEL - 1];
3128	int index = 0;	2399	int index = 0;
3129		2400
3130	while (next) {	2401	while (next) {
@@ -3133,13 +2404,13 @@ static void update_processed_blocks(struct reloc_control *rc, · 2 unmodified lines
3133	if (next->processed)	2404	if (next->processed)
3134	break;	2405	break;
3135		2406
3136	__mark_block_processed(rc, next);	2407	mark_block_processed(rc, next);
3137		2408
3138	if (list_empty(&next->upper))	2409	if (list_empty(&next->upper))
3139	break;	2410	break;
3140		2411
3141	edge = list_entry(next->upper.next,	2412	edge = list_entry(next->upper.next,
3142	struct backref_edge, list[LOWER]);	2413	struct btrfs_backref_edge, list[LOWER]);
3143	edges[index++] = edge;	2414	edges[index++] = edge;
3144	next = edge->node[UPPER];	2415	next = edge->node[UPPER];
3145	}	2416	}
@@ -3184,7 +2455,7 @@ static int get_tree_block_key(struct btrfs_fs_info *fs_info, · 38 unmodified lines
3184	*/	2455	*/
3185	static int relocate_tree_block(struct btrfs_trans_handle *trans,	2456	static int relocate_tree_block(struct btrfs_trans_handle *trans,
3186	struct reloc_control *rc,	2457	struct reloc_control *rc,
3187	struct backref_node *node,	2458	struct btrfs_backref_node *node,
3188	struct btrfs_key *key,	2459	struct btrfs_key *key,
3189	struct btrfs_path *path)	2460	struct btrfs_path *path)
3190	{	2461	{
@@ -3210,7 +2481,7 @@ static int relocate_tree_block(struct btrfs_trans_handle *trans, · 19 unmodified lines
3210	}	2481	}
3211		2482
3212	if (root) {	2483	if (root) {
3213	if (test_bit(BTRFS_ROOT_REF_COWS, &root->state)) {	2484	if (test_bit(BTRFS_ROOT_SHAREABLE, &root->state)) {
3214	BUG_ON(node->new_bytenr);	2485	BUG_ON(node->new_bytenr);
3215	BUG_ON(!list_empty(&node->list));	2486	BUG_ON(!list_empty(&node->list));
3216	btrfs_record_root_in_trans(trans, root);	2487	btrfs_record_root_in_trans(trans, root);
@@ -3234,7 +2505,7 @@ static int relocate_tree_block(struct btrfs_trans_handle *trans, · 17 unmodified lines
3234	}	2505	}
3235	out:	2506	out:
3236	if (ret \|\| node->level == 0 \|\| node->cowonly)	2507	if (ret \|\| node->level == 0 \|\| node->cowonly)
3237	remove_backref_node(&rc->backref_cache, node);	2508	btrfs_backref_cleanup_node(&rc->backref_cache, node);
3238	return ret;	2509	return ret;
3239	}	2510	}
3240		2511
@@ -3246,7 +2517,7 @@ int relocate_tree_blocks(struct btrfs_trans_handle *trans, · 5 unmodified lines
3246	struct reloc_control rc, struct rb_root blocks)	2517	struct reloc_control rc, struct rb_root blocks)
3247	{	2518	{
3248	struct btrfs_fs_info *fs_info = rc->extent_root->fs_info;	2519	struct btrfs_fs_info *fs_info = rc->extent_root->fs_info;
3249	struct backref_node *node;	2520	struct btrfs_backref_node *node;
3250	struct btrfs_path *path;	2521	struct btrfs_path *path;
3251	struct tree_block *block;	2522	struct tree_block *block;
3252	struct tree_block *next;	2523	struct tree_block *next;
@@ -3613,9 +2884,10 @@ static int add_tree_block(struct reloc_control *rc, · 360 unmodified lines
3613	block->level = level;	2884	block->level = level;
3614	block->key_ready = 0;	2885	block->key_ready = 0;
3615		2886
3616	rb_node = tree_insert(blocks, block->bytenr, &block->rb_node);	2887	rb_node = rb_simple_insert(blocks, block->bytenr, &block->rb_node);
3617	if (rb_node)	2888	if (rb_node)
3618	backref_tree_panic(rb_node, -EEXIST, block->bytenr);	2889	btrfs_backref_panic(rc->extent_root->fs_info, block->bytenr,
		2890	-EEXIST);
3619		2891
3620	return 0;	2892	return 0;
3621	}	2893	}
@@ -3636,7 +2908,7 @@ static int __add_tree_block(struct reloc_control *rc, · 14 unmodified lines
3636	if (tree_block_processed(bytenr, rc))	2908	if (tree_block_processed(bytenr, rc))
3637	return 0;	2909	return 0;
3638		2910
3639	if (tree_search(blocks, bytenr))	2911	if (rb_simple_search(blocks, bytenr))
3640	return 0;	2912	return 0;
3641		2913
3642	path = btrfs_alloc_path();	2914	path = btrfs_alloc_path();
@@ -3698,7 +2970,6 @@ static int delete_block_group_cache(struct btrfs_fs_info *fs_info, · 55 unmodified lines
3698	struct inode *inode,	2970	struct inode *inode,
3699	u64 ino)	2971	u64 ino)
3700	{	2972	{
3701	struct btrfs_key key;
3702	struct btrfs_root *root = fs_info->tree_root;	2973	struct btrfs_root *root = fs_info->tree_root;
3703	struct btrfs_trans_handle *trans;	2974	struct btrfs_trans_handle *trans;
3704	int ret = 0;	2975	int ret = 0;
@@ -3706,11 +2977,7 @@ static int delete_block_group_cache(struct btrfs_fs_info *fs_info, · 1 unmodified line
3706	if (inode)	2977	if (inode)
3707	goto truncate;	2978	goto truncate;
3708		2979
3709	key.objectid = ino;	2980	inode = btrfs_iget(fs_info->sb, ino, root);
3710	key.type = BTRFS_INODE_ITEM_KEY;
3711	key.offset = 0;
3712
3713	inode = btrfs_iget(fs_info->sb, &key, root);
3714	if (IS_ERR(inode))	2981	if (IS_ERR(inode))
3715	return -ENOENT;	2982	return -ENOENT;
3716		2983
@@ -4122,7 +3389,7 @@ restart: · 405 unmodified lines
4122	rc->create_reloc_tree = 0;	3389	rc->create_reloc_tree = 0;
4123	set_reloc_control(rc);	3390	set_reloc_control(rc);
4124		3391
4125	backref_cache_cleanup(&rc->backref_cache);	3392	btrfs_backref_release_cache(&rc->backref_cache);
4126	btrfs_block_rsv_release(fs_info, rc->block_rsv, (u64)-1, NULL);	3393	btrfs_block_rsv_release(fs_info, rc->block_rsv, (u64)-1, NULL);
4127		3394
4128	/*	3395	/*
@@ -4198,14 +3465,10 @@ struct inode create_reloc_inode(struct btrfs_fs_info fs_info, · 69 unmodified lines
4198	struct inode *inode = NULL;	3465	struct inode *inode = NULL;
4199	struct btrfs_trans_handle *trans;	3466	struct btrfs_trans_handle *trans;
4200	struct btrfs_root *root;	3467	struct btrfs_root *root;
4201	struct btrfs_key key;
4202	u64 objectid;	3468	u64 objectid;
4203	int err = 0;	3469	int err = 0;
4204		3470
4205	root = read_fs_root(fs_info, BTRFS_DATA_RELOC_TREE_OBJECTID);	3471	root = btrfs_grab_root(fs_info->data_reloc_root);
4206	if (IS_ERR(root))
4207	return ERR_CAST(root);
4208
4209	trans = btrfs_start_transaction(root, 6);	3472	trans = btrfs_start_transaction(root, 6);
4210	if (IS_ERR(trans)) {	3473	if (IS_ERR(trans)) {
4211	btrfs_put_root(root);	3474	btrfs_put_root(root);
@@ -4219,10 +3482,7 @@ struct inode create_reloc_inode(struct btrfs_fs_info fs_info, · 7 unmodified lines
4219	err = __insert_orphan_inode(trans, root, objectid);	3482	err = __insert_orphan_inode(trans, root, objectid);
4220	BUG_ON(err);	3483	BUG_ON(err);
4221		3484
4222	key.objectid = objectid;	3485	inode = btrfs_iget(fs_info->sb, objectid, root);
4223	key.type = BTRFS_INODE_ITEM_KEY;
4224	key.offset = 0;
4225	inode = btrfs_iget(fs_info->sb, &key, root);
4226	BUG_ON(IS_ERR(inode));	3486	BUG_ON(IS_ERR(inode));
4227	BTRFS_I(inode)->index_cnt = group->start;	3487	BTRFS_I(inode)->index_cnt = group->start;
4228		3488
@@ -4249,7 +3509,7 @@ static struct reloc_control alloc_reloc_control(struct btrfs_fs_info fs_info) · 20 unmodified lines
4249		3509
4250	INIT_LIST_HEAD(&rc->reloc_roots);	3510	INIT_LIST_HEAD(&rc->reloc_roots);
4251	INIT_LIST_HEAD(&rc->dirty_subvol_roots);	3511	INIT_LIST_HEAD(&rc->dirty_subvol_roots);
4252	backref_cache_init(&rc->backref_cache);	3512	btrfs_backref_init_cache(fs_info, &rc->backref_cache, 1);
4253	mapping_tree_init(&rc->reloc_root_tree);	3513	mapping_tree_init(&rc->reloc_root_tree);
4254	extent_io_tree_init(fs_info, &rc->processed_blocks,	3514	extent_io_tree_init(fs_info, &rc->processed_blocks,
4255	IO_TREE_RELOC_BLOCKS, NULL);	3515	IO_TREE_RELOC_BLOCKS, NULL);
@@ -4494,12 +3754,12 @@ int btrfs_recover_relocation(struct btrfs_root *root) · 238 unmodified lines
4494	goto out;	3754	goto out;
4495	}	3755	}
4496		3756
4497	set_bit(BTRFS_ROOT_REF_COWS, &reloc_root->state);	3757	set_bit(BTRFS_ROOT_SHAREABLE, &reloc_root->state);
4498	list_add(&reloc_root->root_list, &reloc_roots);	3758	list_add(&reloc_root->root_list, &reloc_roots);
4499		3759
4500	if (btrfs_root_refs(&reloc_root->root_item) > 0) {	3760	if (btrfs_root_refs(&reloc_root->root_item) > 0) {
4501	fs_root = read_fs_root(fs_info,	3761	fs_root = btrfs_get_fs_root(fs_info,
4502	reloc_root->root_key.offset);	3762	reloc_root->root_key.offset, false);
4503	if (IS_ERR(fs_root)) {	3763	if (IS_ERR(fs_root)) {
4504	ret = PTR_ERR(fs_root);	3764	ret = PTR_ERR(fs_root);
4505	if (ret != -ENOENT) {	3765	if (ret != -ENOENT) {
@@ -4555,7 +3815,8 @@ int btrfs_recover_relocation(struct btrfs_root *root) · 49 unmodified lines
4555	continue;	3815	continue;
4556	}	3816	}
4557		3817
4558	fs_root = read_fs_root(fs_info, reloc_root->root_key.offset);	3818	fs_root = btrfs_get_fs_root(fs_info, reloc_root->root_key.offset,
		3819	false);
4559	if (IS_ERR(fs_root)) {	3820	if (IS_ERR(fs_root)) {
4560	err = PTR_ERR(fs_root);	3821	err = PTR_ERR(fs_root);
4561	list_add_tail(&reloc_root->root_list, &reloc_roots);	3822	list_add_tail(&reloc_root->root_list, &reloc_roots);
@@ -4591,20 +3852,16 @@ out_unset: · 29 unmodified lines
4591	unset_reloc_control(rc);	3852	unset_reloc_control(rc);
4592	free_reloc_control(rc);	3853	free_reloc_control(rc);
4593	out:	3854	out:
4594	if (!list_empty(&reloc_roots))	3855	free_reloc_roots(&reloc_roots);
4595	free_reloc_roots(&reloc_roots);
4596		3856
4597	btrfs_free_path(path);	3857	btrfs_free_path(path);
4598		3858
4599	if (err == 0) {	3859	if (err == 0) {
4600	/* cleanup orphan inode in data relocation tree */	3860	/* cleanup orphan inode in data relocation tree */
4601	fs_root = read_fs_root(fs_info, BTRFS_DATA_RELOC_TREE_OBJECTID);	3861	fs_root = btrfs_grab_root(fs_info->data_reloc_root);
4602	if (IS_ERR(fs_root)) {	3862	ASSERT(fs_root);
4603	err = PTR_ERR(fs_root);	3863	err = btrfs_orphan_cleanup(fs_root);
4604	} else {	3864	btrfs_put_root(fs_root);
4605	err = btrfs_orphan_cleanup(fs_root);
4606	btrfs_put_root(fs_root);
4607	}
4608	}	3865	}
4609	return err;	3866	return err;
4610	}	3867	}
@@ -4666,7 +3923,7 @@ int btrfs_reloc_cow_block(struct btrfs_trans_handle *trans, · 55 unmodified lines
4666	{	3923	{
4667	struct btrfs_fs_info *fs_info = root->fs_info;	3924	struct btrfs_fs_info *fs_info = root->fs_info;
4668	struct reloc_control *rc;	3925	struct reloc_control *rc;
4669	struct backref_node *node;	3926	struct btrfs_backref_node *node;
4670	int first_cow = 0;	3927	int first_cow = 0;
4671	int level;	3928	int level;
4672	int ret = 0;	3929	int ret = 0;
@@ -4691,7 +3948,7 @@ int btrfs_reloc_cow_block(struct btrfs_trans_handle *trans, · 18 unmodified lines
4691	BUG_ON(node->bytenr != buf->start &&	3948	BUG_ON(node->bytenr != buf->start &&
4692	node->new_bytenr != buf->start);	3949	node->new_bytenr != buf->start);
4693		3950
4694	drop_node_buffer(node);	3951	btrfs_backref_drop_node_buffer(node);
4695	atomic_inc(&cow->refs);	3952	atomic_inc(&cow->refs);
4696	node->eb = cow;	3953	node->eb = cow;
4697	node->new_bytenr = cow->start;	3954	node->new_bytenr = cow->start;
@@ -4703,7 +3960,7 @@ int btrfs_reloc_cow_block(struct btrfs_trans_handle *trans, · 5 unmodified lines
4703	}	3960	}
4704		3961
4705	if (first_cow)	3962	if (first_cow)
4706	__mark_block_processed(rc, node);	3963	mark_block_processed(rc, node);
4707		3964
4708	if (first_cow && level > 0)	3965	if (first_cow && level > 0)
4709	rc->nodes_relocated += buf->len;	3966	rc->nodes_relocated += buf->len;

fs/btrfs/root-tree.c+5−7

 	struct extent_buffer *leaf;
 	struct btrfs_path *path;
 	struct btrfs_key key;
-	struct btrfs_key root_key;
 	struct btrfs_root *root;
 	int err = 0;
 	int ret;
 	key.type = BTRFS_ORPHAN_ITEM_KEY;
 	key.offset = 0;
-	root_key.type = BTRFS_ROOT_ITEM_KEY;
-	root_key.offset = (u64)-1;
 	while (1) {
+		u64 root_objectid;
 		ret = btrfs_search_slot(NULL, tree_root, &key, path, 0, 0);
 		if (ret < 0) {
 			err = ret;
 		    key.type != BTRFS_ORPHAN_ITEM_KEY)
 			break;
-		root_key.objectid = key.offset;
+		root_objectid = key.offset;
 		key.offset++;
-		root = btrfs_get_fs_root(fs_info, &root_key, false);
+		root = btrfs_get_fs_root(fs_info, root_objectid, false);
 		err = PTR_ERR_OR_ZERO(root);
 		if (err && err != -ENOENT) {
 			break;
 				break;
 			}
 			err = btrfs_del_orphan_item(trans, tree_root,
-						    root_key.objectid);
+						    root_objectid);
 			btrfs_end_transaction(trans);
 			if (err) {
 				btrfs_handle_fs_error(fs_info, err,

fs/btrfs/scrub.c+45−14

 	struct btrfs_fs_info *fs_info = swarn->dev->fs_info;
 	struct inode_fs_paths *ipath = NULL;
 	struct btrfs_root *local_root;
-	struct btrfs_key root_key;
 	struct btrfs_key key;
-	root_key.objectid = root;
+	local_root = btrfs_get_fs_root(fs_info, root, true);
-	root_key.type = BTRFS_ROOT_ITEM_KEY;
-	root_key.offset = (u64)-1;
-	local_root = btrfs_get_fs_root(fs_info, &root_key, true);
 	if (IS_ERR(local_root)) {
 		ret = PTR_ERR(local_root);
 		goto err;
 static noinline_for_stack int scrub_stripe(struct scrub_ctx *sctx,
 					   struct map_lookup *map,
 					   struct btrfs_device *scrub_dev,
-					   int num, u64 base, u64 length)
+					   int num, u64 base, u64 length,
+					   struct btrfs_block_group *cache)
 {
 	struct btrfs_path *path, *ppath;
 	struct btrfs_fs_info *fs_info = sctx->fs_info;
 				break;
 			}
+			/*
+			 * If our block group was removed in the meanwhile, just
+			 * stop scrubbing since there is no point in continuing.
+			 * Continuing would prevent reusing its device extents
+			 * for new block groups for a long time.
+			 */
+			spin_lock(&cache->lock);
+			if (cache->removed) {
+				spin_unlock(&cache->lock);
+				ret = 0;
+				goto out;
+			}
+			spin_unlock(&cache->lock);
 			extent = btrfs_item_ptr(l, slot,
 						struct btrfs_extent_item);
 			flags = btrfs_extent_flags(l, extent);
 						   &extent_dev,
 						   &extent_mirror_num);
-			ret = btrfs_lookup_csums_range(csum_root,
+			if (flags & BTRFS_EXTENT_FLAG_DATA) {
-						       extent_logical,
+				ret = btrfs_lookup_csums_range(csum_root,
-						       extent_logical +
+						extent_logical,
-						       extent_len - 1,
+						extent_logical + extent_len - 1,
-						       &sctx->csum_list, 1);
+						&sctx->csum_list, 1);
-			if (ret)
+				if (ret)
-				goto out;
+					goto out;
+			}
 			ret = scrub_extent(sctx, map, extent_logical, extent_len,
 					   extent_physical, extent_dev, flags,
 		if (map->stripes[i].dev->bdev == scrub_dev->bdev &&
 		    map->stripes[i].physical == dev_offset) {
 			ret = scrub_stripe(sctx, map, scrub_dev, i,
-					   chunk_offset, length);
+					   chunk_offset, length, cache);
 			if (ret)
 				goto out;
 		}
 		if (!cache)
 			goto skip;
+		/*
+		 * Make sure that while we are scrubbing the corresponding block
+		 * group doesn't get its logical address and its device extents
+		 * reused for another block group, which can possibly be of a
+		 * different type and different profile. We do this to prevent
+		 * false error detections and crashes due to bogus attempts to
+		 * repair extents.
+		 */
+		spin_lock(&cache->lock);
+		if (cache->removed) {
+			spin_unlock(&cache->lock);
+			btrfs_put_block_group(cache);
+			goto skip;
+		}
+		btrfs_freeze_block_group(cache);
+		spin_unlock(&cache->lock);
 		/*
 		 * we need call btrfs_inc_block_group_ro() with scrubs_paused,
 		 * to avoid deadlock caused by:
 		} else {
 			btrfs_warn(fs_info,
 				   "failed setting block group ro: %d", ret);
+			btrfs_unfreeze_block_group(cache);
 			btrfs_put_block_group(cache);
 			scrub_pause_off(fs_info);
 			break;
 			spin_unlock(&cache->lock);
 		}
+		btrfs_unfreeze_block_group(cache);
 		btrfs_put_block_group(cache);
 		if (ret)
 			break;

fs/btrfs/send.c+72−17

 #include "btrfs_inode.h"
 #include "transaction.h"
 #include "compression.h"
+#include "xattr.h"
 /*
  * Maximum number of references an extent can have in order for us to attempt to
 	struct fs_path *p;
 	struct posix_acl_xattr_header dummy_acl;
+	/* Capabilities are emitted by finish_inode_if_needed */
+	if (!strncmp(name, XATTR_NAME_CAPS, name_len))
+		return 0;
 	p = fs_path_alloc();
 	if (!p)
 		return -ENOMEM;
 	struct inode *inode;
 	struct page *page;
 	char *addr;
-	struct btrfs_key key;
 	pgoff_t index = offset >> PAGE_SHIFT;
 	pgoff_t last_index;
 	unsigned pg_offset = offset_in_page(offset);
 	ssize_t ret = 0;
-	key.objectid = sctx->cur_ino;
+	inode = btrfs_iget(fs_info->sb, sctx->cur_ino, root);
-	key.type = BTRFS_INODE_ITEM_KEY;
-	key.offset = 0;
-	inode = btrfs_iget(fs_info->sb, &key, root);
 	if (IS_ERR(inode))
 		return PTR_ERR(inode);
 	return 0;
 }
+/*
+ * Search for a capability xattr related to sctx->cur_ino. If the capability is
+ * found, call send_set_xattr function to emit it.
+ *
+ * Return 0 if there isn't a capability, or when the capability was emitted
+ * successfully, or < 0 if an error occurred.
+ */
+static int send_capabilities(struct send_ctx *sctx)
+{
+	struct fs_path *fspath = NULL;
+	struct btrfs_path *path;
+	struct btrfs_dir_item *di;
+	struct extent_buffer *leaf;
+	unsigned long data_ptr;
+	char *buf = NULL;
+	int buf_len;
+	int ret = 0;
+	path = alloc_path_for_send();
+	if (!path)
+		return -ENOMEM;
+	di = btrfs_lookup_xattr(NULL, sctx->send_root, path, sctx->cur_ino,
+				XATTR_NAME_CAPS, strlen(XATTR_NAME_CAPS), 0);
+	if (!di) {
+		/* There is no xattr for this inode */
+		goto out;
+	} else if (IS_ERR(di)) {
+		ret = PTR_ERR(di);
+		goto out;
+	}
+	leaf = path->nodes[0];
+	buf_len = btrfs_dir_data_len(leaf, di);
+	fspath = fs_path_alloc();
+	buf = kmalloc(buf_len, GFP_KERNEL);
+	if (!fspath || !buf) {
+		ret = -ENOMEM;
+		goto out;
+	}
+	ret = get_cur_path(sctx, sctx->cur_ino, sctx->cur_inode_gen, fspath);
+	if (ret < 0)
+		goto out;
+	data_ptr = (unsigned long)(di + 1) + btrfs_dir_name_len(leaf, di);
+	read_extent_buffer(leaf, buf, data_ptr, buf_len);
+	ret = send_set_xattr(sctx, fspath, XATTR_NAME_CAPS,
+			strlen(XATTR_NAME_CAPS), buf, buf_len);
+out:
+	kfree(buf);
+	fs_path_free(fspath);
+	btrfs_free_path(path);
+	return ret;
+}
 static int clone_range(struct send_ctx *sctx,
 		       struct clone_root *clone_root,
 		       const u64 disk_byte,
 			goto out;
 	}
+	ret = send_capabilities(sctx);
+	if (ret < 0)
+		goto out;
 	/*
 	 * If other directory inodes depended on our current directory
 	 * inode's move/rename, now do their move/rename operations.
 	struct btrfs_root *send_root = BTRFS_I(file_inode(mnt_file))->root;
 	struct btrfs_fs_info *fs_info = send_root->fs_info;
 	struct btrfs_root *clone_root;
-	struct btrfs_key key;
 	struct send_ctx *sctx = NULL;
 	u32 i;
 	u64 *clone_sources_tmp = NULL;
 		}
 		for (i = 0; i < arg->clone_sources_count; i++) {
-			key.objectid = clone_sources_tmp[i];
+			clone_root = btrfs_get_fs_root(fs_info,
-			key.type = BTRFS_ROOT_ITEM_KEY;
+						clone_sources_tmp[i], true);
-			key.offset = (u64)-1;
-			clone_root = btrfs_get_fs_root(fs_info, &key, true);
 			if (IS_ERR(clone_root)) {
 				ret = PTR_ERR(clone_root);
 				goto out;
 	}
 	if (arg->parent_root) {
-		key.objectid = arg->parent_root;
+		sctx->parent_root = btrfs_get_fs_root(fs_info, arg->parent_root,
-		key.type = BTRFS_ROOT_ITEM_KEY;
+						      true);
-		key.offset = (u64)-1;
-		sctx->parent_root = btrfs_get_fs_root(fs_info, &key, true);
 		if (IS_ERR(sctx->parent_root)) {
 			ret = PTR_ERR(sctx->parent_root);
 			goto out;

fs/btrfs/space-info.c+73−8

@@ -626,6 +626,7 @@ static int may_commit_transaction(struct btrfs_fs_info *fs_info, · 625 unmodified lines
626	struct reserve_ticket *ticket = NULL;	626	struct reserve_ticket *ticket = NULL;
627	struct btrfs_block_rsv *delayed_rsv = &fs_info->delayed_block_rsv;	627	struct btrfs_block_rsv *delayed_rsv = &fs_info->delayed_block_rsv;
628	struct btrfs_block_rsv *delayed_refs_rsv = &fs_info->delayed_refs_rsv;	628	struct btrfs_block_rsv *delayed_refs_rsv = &fs_info->delayed_refs_rsv;
		629	struct btrfs_block_rsv *trans_rsv = &fs_info->trans_block_rsv;
629	struct btrfs_trans_handle *trans;	630	struct btrfs_trans_handle *trans;
630	u64 bytes_needed;	631	u64 bytes_needed;
631	u64 reclaim_bytes = 0;	632	u64 reclaim_bytes = 0;
@@ -688,6 +689,11 @@ static int may_commit_transaction(struct btrfs_fs_info *fs_info, · 56 unmodified lines
688	spin_lock(&delayed_refs_rsv->lock);	689	spin_lock(&delayed_refs_rsv->lock);
689	reclaim_bytes += delayed_refs_rsv->reserved;	690	reclaim_bytes += delayed_refs_rsv->reserved;
690	spin_unlock(&delayed_refs_rsv->lock);	691	spin_unlock(&delayed_refs_rsv->lock);
		692
		693	spin_lock(&trans_rsv->lock);
		694	reclaim_bytes += trans_rsv->reserved;
		695	spin_unlock(&trans_rsv->lock);
		696
691	if (reclaim_bytes >= bytes_needed)	697	if (reclaim_bytes >= bytes_needed)
692	goto commit;	698	goto commit;
693	bytes_needed -= reclaim_bytes;	699	bytes_needed -= reclaim_bytes;
@@ -856,6 +862,34 @@ static inline int need_do_async_reclaim(struct btrfs_fs_info *fs_info, · 162 unmodified lines
856	!test_bit(BTRFS_FS_STATE_REMOUNTING, &fs_info->fs_state));	862	!test_bit(BTRFS_FS_STATE_REMOUNTING, &fs_info->fs_state));
857	}	863	}
858		864
		865	static bool steal_from_global_rsv(struct btrfs_fs_info *fs_info,
		866	struct btrfs_space_info *space_info,
		867	struct reserve_ticket *ticket)
		868	{
		869	struct btrfs_block_rsv *global_rsv = &fs_info->global_block_rsv;
		870	u64 min_bytes;
		871
		872	if (global_rsv->space_info != space_info)
		873	return false;
		874
		875	spin_lock(&global_rsv->lock);
		876	min_bytes = div_factor(global_rsv->size, 1);
		877	if (global_rsv->reserved < min_bytes + ticket->bytes) {
		878	spin_unlock(&global_rsv->lock);
		879	return false;
		880	}
		881	global_rsv->reserved -= ticket->bytes;
		882	ticket->bytes = 0;
		883	list_del_init(&ticket->list);
		884	wake_up(&ticket->wait);
		885	space_info->tickets_id++;
		886	if (global_rsv->reserved < global_rsv->size)
		887	global_rsv->full = 0;
		888	spin_unlock(&global_rsv->lock);
		889
		890	return true;
		891	}
		892
859	/*	893	/*
860	* maybe_fail_all_tickets - we've exhausted our flushing, start failing tickets	894	* maybe_fail_all_tickets - we've exhausted our flushing, start failing tickets
861	* @fs_info - fs_info for this fs	895	* @fs_info - fs_info for this fs
@@ -888,6 +922,10 @@ static bool maybe_fail_all_tickets(struct btrfs_fs_info *fs_info, · 26 unmodified lines
888	ticket = list_first_entry(&space_info->tickets,	922	ticket = list_first_entry(&space_info->tickets,
889	struct reserve_ticket, list);	923	struct reserve_ticket, list);
890		924
		925	if (ticket->steal &&
		926	steal_from_global_rsv(fs_info, space_info, ticket))
		927	return true;
		928
891	/*	929	/*
892	* may_commit_transaction will avoid committing the transaction	930	* may_commit_transaction will avoid committing the transaction
893	* if it doesn't feel like the space reclaimed by the commit	931	* if it doesn't feel like the space reclaimed by the commit
@@ -1104,6 +1142,7 @@ static int handle_reserve_ticket(struct btrfs_fs_info *fs_info, · 210 unmodified lines
1104		1142
1105	switch (flush) {	1143	switch (flush) {
1106	case BTRFS_RESERVE_FLUSH_ALL:	1144	case BTRFS_RESERVE_FLUSH_ALL:
		1145	case BTRFS_RESERVE_FLUSH_ALL_STEAL:
1107	wait_reserve_ticket(fs_info, space_info, ticket);	1146	wait_reserve_ticket(fs_info, space_info, ticket);
1108	break;	1147	break;
1109	case BTRFS_RESERVE_FLUSH_LIMIT:	1148	case BTRFS_RESERVE_FLUSH_LIMIT:
@@ -1125,11 +1164,17 @@ static int handle_reserve_ticket(struct btrfs_fs_info *fs_info, · 15 unmodified lines
1125	ret = ticket->error;	1164	ret = ticket->error;
1126	if (ticket->bytes \|\| ticket->error) {	1165	if (ticket->bytes \|\| ticket->error) {
1127	/*	1166	/*
1128	* Need to delete here for priority tickets. For regular tickets	1167	* We were a priority ticket, so we need to delete ourselves
1129	* either the async reclaim job deletes the ticket from the list	1168	* from the list. Because we could have other priority tickets
1130	* or we delete it ourselves at wait_reserve_ticket().	1169	* behind us that require less space, run
		1170	* btrfs_try_granting_tickets() to see if their reservations can
		1171	* now be made.
1131	*/	1172	*/
1132	remove_ticket(space_info, ticket);	1173	if (!list_empty(&ticket->list)) {
		1174	remove_ticket(space_info, ticket);
		1175	btrfs_try_granting_tickets(fs_info, space_info);
		1176	}
		1177
1133	if (!ret)	1178	if (!ret)
1134	ret = -ENOSPC;	1179	ret = -ENOSPC;
1135	}	1180	}
@@ -1145,6 +1190,16 @@ static int handle_reserve_ticket(struct btrfs_fs_info *fs_info, · 9 unmodified lines
1145	return ret;	1190	return ret;
1146	}	1191	}
1147		1192
		1193	/*
		1194	* This returns true if this flush state will go through the ordinary flushing
		1195	* code.
		1196	*/
		1197	static inline bool is_normal_flushing(enum btrfs_reserve_flush_enum flush)
		1198	{
		1199	return (flush == BTRFS_RESERVE_FLUSH_ALL) \|\|
		1200	(flush == BTRFS_RESERVE_FLUSH_ALL_STEAL);
		1201	}
		1202
1148	/**	1203	/**
1149	* reserve_metadata_bytes - try to reserve bytes from the block_rsv's space	1204	* reserve_metadata_bytes - try to reserve bytes from the block_rsv's space
1150	* @root - the root we're allocating for	1205	* @root - the root we're allocating for
@@ -1175,8 +1230,17 @@ static int __reserve_metadata_bytes(struct btrfs_fs_info *fs_info, · 24 unmodified lines
1175	spin_lock(&space_info->lock);	1230	spin_lock(&space_info->lock);
1176	ret = -ENOSPC;	1231	ret = -ENOSPC;
1177	used = btrfs_space_info_used(space_info, true);	1232	used = btrfs_space_info_used(space_info, true);
1178	pending_tickets = !list_empty(&space_info->tickets) \|\|	1233
1179	!list_empty(&space_info->priority_tickets);	1234	/*
		1235	* We don't want NO_FLUSH allocations to jump everybody, they can
		1236	* generally handle ENOSPC in a different way, so treat them the same as
		1237	* normal flushers when it comes to skipping pending tickets.
		1238	*/
		1239	if (is_normal_flushing(flush) \|\| (flush == BTRFS_RESERVE_NO_FLUSH))
		1240	pending_tickets = !list_empty(&space_info->tickets) \|\|
		1241	!list_empty(&space_info->priority_tickets);
		1242	else
		1243	pending_tickets = !list_empty(&space_info->priority_tickets);
1180		1244
1181	/*	1245	/*
1182	* Carry on if we have enough space (short-circuit) OR call	1246	* Carry on if we have enough space (short-circuit) OR call
@@ -1198,12 +1262,13 @@ static int __reserve_metadata_bytes(struct btrfs_fs_info *fs_info, · 15 unmodified lines
1198	* the list and we will do our own flushing further down.	1262	* the list and we will do our own flushing further down.
1199	*/	1263	*/
1200	if (ret && flush != BTRFS_RESERVE_NO_FLUSH) {	1264	if (ret && flush != BTRFS_RESERVE_NO_FLUSH) {
1201	ASSERT(space_info->reclaim_size >= 0);
1202	ticket.bytes = orig_bytes;	1265	ticket.bytes = orig_bytes;
1203	ticket.error = 0;	1266	ticket.error = 0;
1204	space_info->reclaim_size += ticket.bytes;	1267	space_info->reclaim_size += ticket.bytes;
1205	init_waitqueue_head(&ticket.wait);	1268	init_waitqueue_head(&ticket.wait);
1206	if (flush == BTRFS_RESERVE_FLUSH_ALL) {	1269	ticket.steal = (flush == BTRFS_RESERVE_FLUSH_ALL_STEAL);
		1270	if (flush == BTRFS_RESERVE_FLUSH_ALL \|\|
		1271	flush == BTRFS_RESERVE_FLUSH_ALL_STEAL) {
1207	list_add_tail(&ticket.list, &space_info->tickets);	1272	list_add_tail(&ticket.list, &space_info->tickets);
1208	if (!space_info->flush) {	1273	if (!space_info->flush) {
1209	space_info->flush = 1;	1274	space_info->flush = 1;

fs/btrfs/space-info.h+1−0

@@ -78,6 +78,7 @@ struct btrfs_space_info { · 77 unmodified lines
78	struct reserve_ticket {	78	struct reserve_ticket {
79	u64 bytes;	79	u64 bytes;
80	int error;	80	int error;
		81	bool steal;
81	struct list_head list;	82	struct list_head list;
82	wait_queue_head_t wait;	83	wait_queue_head_t wait;
83	};	84	};

fs/btrfs/struct-funcs.c+112−111

@@ -17,151 +17,152 @@ static inline void put_unaligned_le8(u8 val, void *p) · 16 unmodified lines
17	(u8 )p = val;	17	(u8 )p = val;
18	}	18	}
19		19
		20	static bool check_setget_bounds(const struct extent_buffer *eb,
		21	const void *ptr, unsigned off, int size)
		22	{
		23	const unsigned long member_offset = (unsigned long)ptr + off;
		24
		25	if (member_offset > eb->len) {
		26	btrfs_warn(eb->fs_info,
		27	"bad eb member start: ptr 0x%lx start %llu member offset %lu size %d",
		28	(unsigned long)ptr, eb->start, member_offset, size);
		29	return false;
		30	}
		31	if (member_offset + size > eb->len) {
		32	btrfs_warn(eb->fs_info,
		33	"bad eb member end: ptr 0x%lx start %llu member offset %lu size %d",
		34	(unsigned long)ptr, eb->start, member_offset, size);
		35	return false;
		36	}
		37
		38	return true;
		39	}
		40
20	/*	41	/*
21	* this is some deeply nasty code.	42	* Macro templates that define helpers to read/write extent buffer data of a
		43	* given size, that are also used via ctree.h for access to item members by
		44	* specialized helpers.
22	*	45	*
23	* The end result is that anyone who #includes ctree.h gets a	46	* Generic helpers:
24	* declaration for the btrfs_set_foo functions and btrfs_foo functions,	47	* - btrfs_set_8 (for 8/16/32/64)
25	* which are wrappers of btrfs_set_token_#bits functions and	48	* - btrfs_get_8 (for 8/16/32/64)
26	* btrfs_get_token_#bits functions, which are defined in this file.
27	*	49	*
28	* These setget functions do all the extent_buffer related mapping	50	* Generic helpers with a token (cached address of the most recently accessed
29	* required to efficiently read and write specific fields in the extent	51	* page):
30	* buffers. Every pointer to metadata items in btrfs is really just	52	* - btrfs_set_token_8 (for 8/16/32/64)
31	* an unsigned long offset into the extent buffer which has been	53	* - btrfs_get_token_8 (for 8/16/32/64)
32	* cast to a specific type. This gives us all the gcc type checking.
33	*	54	*
34	* The extent buffer api is used to do the page spanning work required to	55	* The set/get functions handle data spanning two pages transparently, in case
35	* have a metadata blocksize different from the page size.	56	* metadata block size is larger than page. Every pointer to metadata items is
		57	* an offset into the extent buffer page array, cast to a specific type. This
		58	* gives us all the type checking.
36	*	59	*
37	* There are 2 variants defined, one with a token pointer and one without.	60	* The extent buffer pages stored in the array pages do not form a contiguous
		61	* phyusical range, but the API functions assume the linear offset to the range
		62	* from 0 to metadata node size.
38	*/	63	*/
39		64
40	#define DEFINE_BTRFS_SETGET_BITS(bits) \	65	#define DEFINE_BTRFS_SETGET_BITS(bits) \
41	u##bits btrfs_get_token_##bits(const struct extent_buffer *eb, \	66	u##bits btrfs_get_token_##bits(struct btrfs_map_token *token, \
42	const void *ptr, unsigned long off, \	67	const void *ptr, unsigned long off) \
43	struct btrfs_map_token *token) \
44	{ \	68	{ \
45	unsigned long part_offset = (unsigned long)ptr; \	69	const unsigned long member_offset = (unsigned long)ptr + off; \
46	unsigned long offset = part_offset + off; \	70	const unsigned long idx = member_offset >> PAGE_SHIFT; \
47	void *p; \	71	const unsigned long oip = offset_in_page(member_offset); \
48	int err; \	72	const int size = sizeof(u##bits); \
49	char *kaddr; \	73	u8 lebytes[sizeof(u##bits)]; \
50	unsigned long map_start; \	74	const int part = PAGE_SIZE - oip; \
51	unsigned long map_len; \
52	int size = sizeof(u##bits); \
53	u##bits res; \
54	\	75	\
55	ASSERT(token); \	76	ASSERT(token); \
56	ASSERT(token->eb == eb); \	77	ASSERT(token->kaddr); \
57	\	78	ASSERT(check_setget_bounds(token->eb, ptr, off, size)); \
58	if (token->kaddr && token->offset <= offset && \	79	if (token->offset <= member_offset && \
59	(token->offset + PAGE_SIZE >= offset + size)) { \	80	member_offset + size <= token->offset + PAGE_SIZE) { \
60	kaddr = token->kaddr; \	81	return get_unaligned_le##bits(token->kaddr + oip); \
61	p = kaddr + part_offset - token->offset; \
62	res = get_unaligned_le##bits(p + off); \
63	return res; \
64	} \	82	} \
65	err = map_private_extent_buffer(eb, offset, size, \	83	token->kaddr = page_address(token->eb->pages[idx]); \
66	&kaddr, &map_start, &map_len); \	84	token->offset = idx << PAGE_SHIFT; \
67	if (err) { \	85	if (oip + size <= PAGE_SIZE) \
68	__le##bits leres; \	86	return get_unaligned_le##bits(token->kaddr + oip); \
69	\	87	\
70	read_extent_buffer(eb, &leres, offset, size); \	88	memcpy(lebytes, token->kaddr + oip, part); \
71	return le##bits##_to_cpu(leres); \	89	token->kaddr = page_address(token->eb->pages[idx + 1]); \
72	} \	90	token->offset = (idx + 1) << PAGE_SHIFT; \
73	p = kaddr + part_offset - map_start; \	91	memcpy(lebytes + part, token->kaddr, size - part); \
74	res = get_unaligned_le##bits(p + off); \	92	return get_unaligned_le##bits(lebytes); \
75	token->kaddr = kaddr; \
76	token->offset = map_start; \
77	return res; \
78	} \	93	} \
79	u##bits btrfs_get_##bits(const struct extent_buffer *eb, \	94	u##bits btrfs_get_##bits(const struct extent_buffer *eb, \
80	const void *ptr, unsigned long off) \	95	const void *ptr, unsigned long off) \
81	{ \	96	{ \
82	unsigned long part_offset = (unsigned long)ptr; \	97	const unsigned long member_offset = (unsigned long)ptr + off; \
83	unsigned long offset = part_offset + off; \	98	const unsigned long oip = offset_in_page(member_offset); \
84	void *p; \	99	const unsigned long idx = member_offset >> PAGE_SHIFT; \
85	int err; \	100	char *kaddr = page_address(eb->pages[idx]); \
86	char *kaddr; \	101	const int size = sizeof(u##bits); \
87	unsigned long map_start; \	102	const int part = PAGE_SIZE - oip; \
88	unsigned long map_len; \	103	u8 lebytes[sizeof(u##bits)]; \
89	int size = sizeof(u##bits); \
90	u##bits res; \
91	\	104	\
92	err = map_private_extent_buffer(eb, offset, size, \	105	ASSERT(check_setget_bounds(eb, ptr, off, size)); \
93	&kaddr, &map_start, &map_len); \	106	if (oip + size <= PAGE_SIZE) \
94	if (err) { \	107	return get_unaligned_le##bits(kaddr + oip); \
95	__le##bits leres; \
96	\	108	\
97	read_extent_buffer(eb, &leres, offset, size); \	109	memcpy(lebytes, kaddr + oip, part); \
98	return le##bits##_to_cpu(leres); \	110	kaddr = page_address(eb->pages[idx + 1]); \
99	} \	111	memcpy(lebytes + part, kaddr, size - part); \
100	p = kaddr + part_offset - map_start; \	112	return get_unaligned_le##bits(lebytes); \
101	res = get_unaligned_le##bits(p + off); \
102	return res; \
103	} \	113	} \
104	void btrfs_set_token_##bits(struct extent_buffer *eb, \	114	void btrfs_set_token_##bits(struct btrfs_map_token *token, \
105	const void *ptr, unsigned long off, \	115	const void *ptr, unsigned long off, \
106	u##bits val, \	116	u##bits val) \
107	struct btrfs_map_token *token) \
108	{ \	117	{ \
109	unsigned long part_offset = (unsigned long)ptr; \	118	const unsigned long member_offset = (unsigned long)ptr + off; \
110	unsigned long offset = part_offset + off; \	119	const unsigned long idx = member_offset >> PAGE_SHIFT; \
111	void *p; \	120	const unsigned long oip = offset_in_page(member_offset); \
112	int err; \	121	const int size = sizeof(u##bits); \
113	char *kaddr; \	122	u8 lebytes[sizeof(u##bits)]; \
114	unsigned long map_start; \	123	const int part = PAGE_SIZE - oip; \
115	unsigned long map_len; \
116	int size = sizeof(u##bits); \
117	\	124	\
118	ASSERT(token); \	125	ASSERT(token); \
119	ASSERT(token->eb == eb); \	126	ASSERT(token->kaddr); \
120	\	127	ASSERT(check_setget_bounds(token->eb, ptr, off, size)); \
121	if (token->kaddr && token->offset <= offset && \	128	if (token->offset <= member_offset && \
122	(token->offset + PAGE_SIZE >= offset + size)) { \	129	member_offset + size <= token->offset + PAGE_SIZE) { \
123	kaddr = token->kaddr; \	130	put_unaligned_le##bits(val, token->kaddr + oip); \
124	p = kaddr + part_offset - token->offset; \
125	put_unaligned_le##bits(val, p + off); \
126	return; \	131	return; \
127	} \	132	} \
128	err = map_private_extent_buffer(eb, offset, size, \	133	token->kaddr = page_address(token->eb->pages[idx]); \
129	&kaddr, &map_start, &map_len); \	134	token->offset = idx << PAGE_SHIFT; \
130	if (err) { \	135	if (oip + size <= PAGE_SIZE) { \
131	__le##bits val2; \	136	put_unaligned_le##bits(val, token->kaddr + oip); \
132	\
133	val2 = cpu_to_le##bits(val); \
134	write_extent_buffer(eb, &val2, offset, size); \
135	return; \	137	return; \
136	} \	138	} \
137	p = kaddr + part_offset - map_start; \	139	put_unaligned_le##bits(val, lebytes); \
138	put_unaligned_le##bits(val, p + off); \	140	memcpy(token->kaddr + oip, lebytes, part); \
139	token->kaddr = kaddr; \	141	token->kaddr = page_address(token->eb->pages[idx + 1]); \
140	token->offset = map_start; \	142	token->offset = (idx + 1) << PAGE_SHIFT; \
		143	memcpy(token->kaddr, lebytes + part, size - part); \
141	} \	144	} \
142	void btrfs_set_##bits(struct extent_buffer eb, void ptr, \	145	void btrfs_set_##bits(const struct extent_buffer eb, void ptr, \
143	unsigned long off, u##bits val) \	146	unsigned long off, u##bits val) \
144	{ \	147	{ \
145	unsigned long part_offset = (unsigned long)ptr; \	148	const unsigned long member_offset = (unsigned long)ptr + off; \
146	unsigned long offset = part_offset + off; \	149	const unsigned long oip = offset_in_page(member_offset); \
147	void *p; \	150	const unsigned long idx = member_offset >> PAGE_SHIFT; \
148	int err; \	151	char *kaddr = page_address(eb->pages[idx]); \
149	char *kaddr; \	152	const int size = sizeof(u##bits); \
150	unsigned long map_start; \	153	const int part = PAGE_SIZE - oip; \
151	unsigned long map_len; \	154	u8 lebytes[sizeof(u##bits)]; \
152	int size = sizeof(u##bits); \
153	\
154	err = map_private_extent_buffer(eb, offset, size, \
155	&kaddr, &map_start, &map_len); \
156	if (err) { \
157	__le##bits val2; \
158	\	155	\
159	val2 = cpu_to_le##bits(val); \	156	ASSERT(check_setget_bounds(eb, ptr, off, size)); \
160	write_extent_buffer(eb, &val2, offset, size); \	157	if (oip + size <= PAGE_SIZE) { \
		158	put_unaligned_le##bits(val, kaddr + oip); \
161	return; \	159	return; \
162	} \	160	} \
163	p = kaddr + part_offset - map_start; \	161	\
164	put_unaligned_le##bits(val, p + off); \	162	put_unaligned_le##bits(val, lebytes); \
		163	memcpy(kaddr + oip, lebytes, part); \
		164	kaddr = page_address(eb->pages[idx + 1]); \
		165	memcpy(kaddr, lebytes + part, size - part); \
165	}	166	}
166		167
167	DEFINE_BTRFS_SETGET_BITS(8)	168	DEFINE_BTRFS_SETGET_BITS(8)

fs/btrfs/super.c+20−18

 	char *errstr = "unknown";
 	switch (errno) {
-	case -EIO:
+	case -ENOENT:		/* -2 */
+		errstr = "No such entry";
+		break;
+	case -EIO:		/* -5 */
 		errstr = "IO failure";
 		break;
-	case -ENOMEM:
+	case -ENOMEM:		/* -12*/
 		errstr = "Out of memory";
 		break;
-	case -EROFS:
+	case -EEXIST:		/* -17 */
-		errstr = "Readonly filesystem";
-		break;
-	case -EEXIST:
 		errstr = "Object already exists";
 		break;
-	case -ENOSPC:
+	case -ENOSPC:		/* -28 */
 		errstr = "No space left";
 		break;
-	case -ENOENT:
+	case -EROFS:		/* -30 */
-		errstr = "No such entry";
+		errstr = "Readonly filesystem";
+		break;
+	case -EOPNOTSUPP:	/* -95 */
+		errstr = "Operation not supported";
+		break;
+	case -EUCLEAN:		/* -117 */
+		errstr = "Filesystem corrupted";
+		break;
+	case -EDQUOT:		/* -122 */
+		errstr = "Quota exceeded";
 		break;
 	}
 		dirid = btrfs_root_ref_dirid(path->nodes[0], root_ref);
 		btrfs_release_path(path);
-		key.objectid = subvol_objectid;
+		fs_root = btrfs_get_fs_root(fs_info, subvol_objectid, true);
-		key.type = BTRFS_ROOT_ITEM_KEY;
-		key.offset = (u64)-1;
-		fs_root = btrfs_get_fs_root(fs_info, &key, true);
 		if (IS_ERR(fs_root)) {
 			ret = PTR_ERR(fs_root);
 			fs_root = NULL;
 {
 	struct inode *inode;
 	struct btrfs_fs_info *fs_info = btrfs_sb(sb);
-	struct btrfs_key key;
 	int err;
 	sb->s_maxbytes = MAX_LFS_FILESIZE;
 		return err;
 	}
-	key.objectid = BTRFS_FIRST_FREE_OBJECTID;
+	inode = btrfs_iget(sb, BTRFS_FIRST_FREE_OBJECTID, fs_info->fs_root);
-	key.type = BTRFS_INODE_ITEM_KEY;
-	key.offset = 0;
-	inode = btrfs_iget(sb, &key, fs_info->fs_root);
 	if (IS_ERR(inode)) {
 		err = PTR_ERR(inode);
 		goto fail_close;

fs/btrfs/transaction.c+32−46

 #include "dev-replace.h"
 #include "qgroup.h"
 #include "block-group.h"
+#include "space-info.h"
 #define BTRFS_ROOT_TRANS_TAG 0
 						 struct btrfs_block_group,
 						 bg_list);
 			list_del_init(&cache->bg_list);
-			btrfs_put_block_group_trimming(cache);
+			btrfs_unfreeze_block_group(cache);
 			btrfs_put_block_group(cache);
 		}
 		WARN_ON(!list_empty(&transaction->dev_update_list));
 }
 /*
- * this does all the record keeping required to make sure that a reference
+ * This does all the record keeping required to make sure that a shareable root
- * counted root is properly recorded in a given transaction.  This is required
+ * is properly recorded in a given transaction.  This is required to make sure
- * to make sure the old root from before we joined the transaction is deleted
+ * the old root from before we joined the transaction is deleted when the
- * when the transaction commits
+ * transaction commits.
  */
 static int record_root_in_trans(struct btrfs_trans_handle *trans,
 			       struct btrfs_root *root,
 {
 	struct btrfs_fs_info *fs_info = root->fs_info;
-	if ((test_bit(BTRFS_ROOT_REF_COWS, &root->state) &&
+	if ((test_bit(BTRFS_ROOT_SHAREABLE, &root->state) &&
 	    root->last_trans < trans->transid) || force) {
 		WARN_ON(root == fs_info->extent_root);
 		WARN_ON(!force && root->commit_root != root->node);
 {
 	struct btrfs_fs_info *fs_info = root->fs_info;
-	if (!test_bit(BTRFS_ROOT_REF_COWS, &root->state))
+	if (!test_bit(BTRFS_ROOT_SHAREABLE, &root->state))
 		return 0;
 	/*
 	struct btrfs_fs_info *fs_info = root->fs_info;
 	if (!fs_info->reloc_ctl ||
-	    !test_bit(BTRFS_ROOT_REF_COWS, &root->state) ||
+	    !test_bit(BTRFS_ROOT_SHAREABLE, &root->state) ||
 	    root->root_key.objectid == BTRFS_TREE_RELOC_OBJECTID ||
 	    root->reloc_root)
 		return false;
 	u64 num_bytes = 0;
 	u64 qgroup_reserved = 0;
 	bool reloc_reserved = false;
+	bool do_chunk_alloc = false;
 	int ret;
 	/* Send isn't supposed to start transactions. */
 		 * refill that amount for whatever is missing in the reserve.
 		 */
 		num_bytes = btrfs_calc_insert_metadata_size(fs_info, num_items);
-		if (delayed_refs_rsv->full == 0) {
+		if (flush == BTRFS_RESERVE_FLUSH_ALL &&
+		    delayed_refs_rsv->full == 0) {
 			delayed_refs_bytes = num_bytes;
 			num_bytes <<= 1;
 		}
 							  delayed_refs_bytes);
 			num_bytes -= delayed_refs_bytes;
 		}
+		if (rsv->space_info->force_alloc)
+			do_chunk_alloc = true;
 	} else if (num_items == 0 && flush == BTRFS_RESERVE_FLUSH_ALL &&
 		   !delayed_refs_rsv->full) {
 		/*
 	if (!current->journal_info)
 		current->journal_info = h;
+	/*
+	 * If the space_info is marked ALLOC_FORCE then we'll get upgraded to
+	 * ALLOC_FORCE the first run through, and then we won't allocate for
+	 * anybody else who races in later.  We don't care about the return
+	 * value here.
+	 */
+	if (do_chunk_alloc && num_bytes) {
+		u64 flags = h->block_rsv->space_info->flags;
+		btrfs_chunk_alloc(h, btrfs_get_alloc_profile(fs_info, flags),
+				  CHUNK_ALLOC_NO_FORCE);
+	}
 	/*
 	 * btrfs_record_root_in_trans() needs to alloc new extents, and may
 	 * call btrfs_join_transaction() while we're also starting a
 struct btrfs_trans_handle *btrfs_start_transaction_fallback_global_rsv(
 					struct btrfs_root *root,
-					unsigned int num_items,
+					unsigned int num_items)
-					int min_factor)
 {
-	struct btrfs_fs_info *fs_info = root->fs_info;
+	return start_transaction(root, num_items, TRANS_START,
-	struct btrfs_trans_handle *trans;
+				 BTRFS_RESERVE_FLUSH_ALL_STEAL, false);
-	u64 num_bytes;
-	int ret;
-	/*
-	 * We have two callers: unlink and block group removal.  The
-	 * former should succeed even if we will temporarily exceed
-	 * quota and the latter operates on the extent root so
-	 * qgroup enforcement is ignored anyway.
-	 */
-	trans = start_transaction(root, num_items, TRANS_START,
-				  BTRFS_RESERVE_FLUSH_ALL, false);
-	if (!IS_ERR(trans) || PTR_ERR(trans) != -ENOSPC)
-		return trans;
-	trans = btrfs_start_transaction(root, 0);
-	if (IS_ERR(trans))
-		return trans;
-	num_bytes = btrfs_calc_insert_metadata_size(fs_info, num_items);
-	ret = btrfs_cond_migrate_bytes(fs_info, &fs_info->trans_block_rsv,
-				       num_bytes, min_factor);
-	if (ret) {
-		btrfs_end_transaction(trans);
-		return ERR_PTR(ret);
-	}
-	trans->block_rsv = &fs_info->trans_block_rsv;
-	trans->bytes_reserved = num_bytes;
-	trace_btrfs_space_reservation(fs_info, "transaction",
-				      trans->transid, num_bytes, 1);
-	return trans;
 }
 struct btrfs_trans_handle *btrfs_join_transaction(struct btrfs_root *root)
 	}
 	key.offset = (u64)-1;
-	pending->snap = btrfs_get_fs_root(fs_info, &key, true);
+	pending->snap = btrfs_get_fs_root(fs_info, objectid, true);
 	if (IS_ERR(pending->snap)) {
 		ret = PTR_ERR(pending->snap);
 		btrfs_abort_transaction(trans, ret);

fs/btrfs/transaction.h+1−2

 						   unsigned int num_items);
 struct btrfs_trans_handle *btrfs_start_transaction_fallback_global_rsv(
 					struct btrfs_root *root,
-					unsigned int num_items,
+					unsigned int num_items);
-					int min_factor);
 struct btrfs_trans_handle *btrfs_join_transaction(struct btrfs_root *root);
 struct btrfs_trans_handle *btrfs_join_transaction_spacecache(struct btrfs_root *root);
 struct btrfs_trans_handle *btrfs_join_transaction_nostart(struct btrfs_root *root);

fs/btrfs/tree-checker.c+0−4

 	return 0;
 }
-/* Inode item error output has the same format as dir_item_err() */
-#define inode_item_err(eb, slot, fmt, ...)			\
-	dir_item_err(eb, slot, fmt, __VA_ARGS__)
 static int check_inode_item(struct extent_buffer *leaf,
 			    struct btrfs_key *key, int slot)
 {

fs/btrfs/tree-defrag.c+1−1

@@ -35,7 +35,7 @@ int btrfs_defrag_leaves(struct btrfs_trans_handle *trans, · 34 unmodified lines
35	goto out;	35	goto out;
36	}	36	}
37		37
38	if (!test_bit(BTRFS_ROOT_REF_COWS, &root->state))	38	if (!test_bit(BTRFS_ROOT_SHAREABLE, &root->state))
39	goto out;	39	goto out;
40		40
41	path = btrfs_alloc_path();	41	path = btrfs_alloc_path();

fs/btrfs/tree-log.c+90−102

@@ -505,13 +505,8 @@ insert: · 504 unmodified lines
505	*/	505	*/
506	if (S_ISREG(btrfs_inode_mode(eb, src_item)) &&	506	if (S_ISREG(btrfs_inode_mode(eb, src_item)) &&
507	S_ISREG(btrfs_inode_mode(dst_eb, dst_item)) &&	507	S_ISREG(btrfs_inode_mode(dst_eb, dst_item)) &&
508	ino_size != 0) {	508	ino_size != 0)
509	struct btrfs_map_token token;	509	btrfs_set_inode_size(dst_eb, dst_item, ino_size);
510
511	btrfs_init_map_token(&token, dst_eb);
512	btrfs_set_token_inode_size(dst_eb, dst_item,
513	ino_size, &token);
514	}
515	goto no_copy;	510	goto no_copy;
516	}	511	}
517		512
@@ -555,13 +550,9 @@ no_copy: · 37 unmodified lines
555	static noinline struct inode read_one_inode(struct btrfs_root root,	550	static noinline struct inode read_one_inode(struct btrfs_root root,
556	u64 objectid)	551	u64 objectid)
557	{	552	{
558	struct btrfs_key key;
559	struct inode *inode;	553	struct inode *inode;
560		554
561	key.objectid = objectid;	555	inode = btrfs_iget(root->fs_info->sb, objectid, root);
562	key.type = BTRFS_INODE_ITEM_KEY;
563	key.offset = 0;
564	inode = btrfs_iget(root->fs_info->sb, &key, root);
565	if (IS_ERR(inode))	556	if (IS_ERR(inode))
566	inode = NULL;	557	inode = NULL;
567	return inode;	558	return inode;
@@ -3299,6 +3290,7 @@ static void free_log_tree(struct btrfs_trans_handle *trans, · 2731 unmodified lines
3299		3290
3300	clear_extent_bits(&log->dirty_log_pages, 0, (u64)-1,	3291	clear_extent_bits(&log->dirty_log_pages, 0, (u64)-1,
3301	EXTENT_DIRTY \| EXTENT_NEW \| EXTENT_NEED_WAIT);	3292	EXTENT_DIRTY \| EXTENT_NEW \| EXTENT_NEED_WAIT);
		3293	extent_io_tree_release(&log->log_csum_range);
3302	btrfs_put_root(log);	3294	btrfs_put_root(log);
3303	}	3295	}
3304		3296
@@ -3816,8 +3808,7 @@ static int drop_objectid_items(struct btrfs_trans_handle *trans, · 511 unmodified lines
3816		3808
3817	found_key.offset = 0;	3809	found_key.offset = 0;
3818	found_key.type = 0;	3810	found_key.type = 0;
3819	ret = btrfs_bin_search(path->nodes[0], &found_key, 0,	3811	ret = btrfs_bin_search(path->nodes[0], &found_key, &start_slot);
3820	&start_slot);
3821	if (ret < 0)	3812	if (ret < 0)
3822	break;	3813	break;
3823		3814
@@ -3853,44 +3844,41 @@ static void fill_inode_item(struct btrfs_trans_handle *trans, · 29 unmodified lines
3853	* just to say 'this inode exists' and a logging	3844	* just to say 'this inode exists' and a logging
3854	* to say 'update this inode with these values'	3845	* to say 'update this inode with these values'
3855	*/	3846	*/
3856	btrfs_set_token_inode_generation(leaf, item, 0, &token);	3847	btrfs_set_token_inode_generation(&token, item, 0);
3857	btrfs_set_token_inode_size(leaf, item, logged_isize, &token);	3848	btrfs_set_token_inode_size(&token, item, logged_isize);
3858	} else {	3849	} else {
3859	btrfs_set_token_inode_generation(leaf, item,	3850	btrfs_set_token_inode_generation(&token, item,
3860	BTRFS_I(inode)->generation,	3851	BTRFS_I(inode)->generation);
3861	&token);	3852	btrfs_set_token_inode_size(&token, item, inode->i_size);
3862	btrfs_set_token_inode_size(leaf, item, inode->i_size, &token);	3853	}
3863	}	3854
3864		3855	btrfs_set_token_inode_uid(&token, item, i_uid_read(inode));
3865	btrfs_set_token_inode_uid(leaf, item, i_uid_read(inode), &token);	3856	btrfs_set_token_inode_gid(&token, item, i_gid_read(inode));
3866	btrfs_set_token_inode_gid(leaf, item, i_gid_read(inode), &token);	3857	btrfs_set_token_inode_mode(&token, item, inode->i_mode);
3867	btrfs_set_token_inode_mode(leaf, item, inode->i_mode, &token);	3858	btrfs_set_token_inode_nlink(&token, item, inode->i_nlink);
3868	btrfs_set_token_inode_nlink(leaf, item, inode->i_nlink, &token);	3859
3869		3860	btrfs_set_token_timespec_sec(&token, &item->atime,
3870	btrfs_set_token_timespec_sec(leaf, &item->atime,	3861	inode->i_atime.tv_sec);
3871	inode->i_atime.tv_sec, &token);	3862	btrfs_set_token_timespec_nsec(&token, &item->atime,
3872	btrfs_set_token_timespec_nsec(leaf, &item->atime,	3863	inode->i_atime.tv_nsec);
3873	inode->i_atime.tv_nsec, &token);	3864
3874		3865	btrfs_set_token_timespec_sec(&token, &item->mtime,
3875	btrfs_set_token_timespec_sec(leaf, &item->mtime,	3866	inode->i_mtime.tv_sec);
3876	inode->i_mtime.tv_sec, &token);	3867	btrfs_set_token_timespec_nsec(&token, &item->mtime,
3877	btrfs_set_token_timespec_nsec(leaf, &item->mtime,	3868	inode->i_mtime.tv_nsec);
3878	inode->i_mtime.tv_nsec, &token);	3869
3879		3870	btrfs_set_token_timespec_sec(&token, &item->ctime,
3880	btrfs_set_token_timespec_sec(leaf, &item->ctime,	3871	inode->i_ctime.tv_sec);
3881	inode->i_ctime.tv_sec, &token);	3872	btrfs_set_token_timespec_nsec(&token, &item->ctime,
3882	btrfs_set_token_timespec_nsec(leaf, &item->ctime,	3873	inode->i_ctime.tv_nsec);
3883	inode->i_ctime.tv_nsec, &token);	3874
3884		3875	btrfs_set_token_inode_nbytes(&token, item, inode_get_bytes(inode));
3885	btrfs_set_token_inode_nbytes(leaf, item, inode_get_bytes(inode),	3876
3886	&token);	3877	btrfs_set_token_inode_sequence(&token, item, inode_peek_iversion(inode));
3887		3878	btrfs_set_token_inode_transid(&token, item, trans->transid);
3888	btrfs_set_token_inode_sequence(leaf, item,	3879	btrfs_set_token_inode_rdev(&token, item, inode->i_rdev);
3889	inode_peek_iversion(inode), &token);	3880	btrfs_set_token_inode_flags(&token, item, BTRFS_I(inode)->flags);
3890	btrfs_set_token_inode_transid(leaf, item, trans->transid, &token);	3881	btrfs_set_token_inode_block_group(&token, item, 0);
3891	btrfs_set_token_inode_rdev(leaf, item, inode->i_rdev, &token);
3892	btrfs_set_token_inode_flags(leaf, item, BTRFS_I(inode)->flags, &token);
3893	btrfs_set_token_inode_block_group(leaf, item, 0, &token);
3894	}	3882	}
3895		3883
3896	static int log_inode_item(struct btrfs_trans_handle *trans,	3884	static int log_inode_item(struct btrfs_trans_handle *trans,
@@ -3916,8 +3904,20 @@ static int log_csums(struct btrfs_trans_handle *trans, · 19 unmodified lines
3916	struct btrfs_root *log_root,	3904	struct btrfs_root *log_root,
3917	struct btrfs_ordered_sum *sums)	3905	struct btrfs_ordered_sum *sums)
3918	{	3906	{
		3907	const u64 lock_end = sums->bytenr + sums->len - 1;
		3908	struct extent_state *cached_state = NULL;
3919	int ret;	3909	int ret;
3920		3910
		3911	/*
		3912	* Serialize logging for checksums. This is to avoid racing with the
		3913	* same checksum being logged by another task that is logging another
		3914	* file which happens to refer to the same extent as well. Such races
		3915	* can leave checksum items in the log with overlapping ranges.
		3916	*/
		3917	ret = lock_extent_bits(&log_root->log_csum_range, sums->bytenr,
		3918	lock_end, &cached_state);
		3919	if (ret)
		3920	return ret;
3921	/*	3921	/*
3922	* Due to extent cloning, we might have logged a csum item that covers a	3922	* Due to extent cloning, we might have logged a csum item that covers a
3923	* subrange of a cloned extent, and later we can end up logging a csum	3923	* subrange of a cloned extent, and later we can end up logging a csum
@@ -3928,10 +3928,13 @@ static int log_csums(struct btrfs_trans_handle *trans, · 4 unmodified lines
3928	* trim and adjust) any existing csum items in the log for this range.	3928	* trim and adjust) any existing csum items in the log for this range.
3929	*/	3929	*/
3930	ret = btrfs_del_csums(trans, log_root, sums->bytenr, sums->len);	3930	ret = btrfs_del_csums(trans, log_root, sums->bytenr, sums->len);
3931	if (ret)	3931	if (!ret)
3932	return ret;	3932	ret = btrfs_csum_file_blocks(trans, log_root, sums);
3933		3933
3934	return btrfs_csum_file_blocks(trans, log_root, sums);	3934	unlock_extent_cached(&log_root->log_csum_range, sums->bytenr, lock_end,
		3935	&cached_state);
		3936
		3937	return ret;
3935	}	3938	}
3936		3939
3937	static noinline int copy_items(struct btrfs_trans_handle *trans,	3940	static noinline int copy_items(struct btrfs_trans_handle *trans,
@@ -4164,43 +4167,35 @@ static int log_one_extent(struct btrfs_trans_handle *trans, · 226 unmodified lines
4164	fi = btrfs_item_ptr(leaf, path->slots[0],	4167	fi = btrfs_item_ptr(leaf, path->slots[0],
4165	struct btrfs_file_extent_item);	4168	struct btrfs_file_extent_item);
4166		4169
4167	btrfs_set_token_file_extent_generation(leaf, fi, trans->transid,	4170	btrfs_set_token_file_extent_generation(&token, fi, trans->transid);
4168	&token);
4169	if (test_bit(EXTENT_FLAG_PREALLOC, &em->flags))	4171	if (test_bit(EXTENT_FLAG_PREALLOC, &em->flags))
4170	btrfs_set_token_file_extent_type(leaf, fi,	4172	btrfs_set_token_file_extent_type(&token, fi,
4171	BTRFS_FILE_EXTENT_PREALLOC,	4173	BTRFS_FILE_EXTENT_PREALLOC);
4172	&token);
4173	else	4174	else
4174	btrfs_set_token_file_extent_type(leaf, fi,	4175	btrfs_set_token_file_extent_type(&token, fi,
4175	BTRFS_FILE_EXTENT_REG,	4176	BTRFS_FILE_EXTENT_REG);
4176	&token);
4177		4177
4178	block_len = max(em->block_len, em->orig_block_len);	4178	block_len = max(em->block_len, em->orig_block_len);
4179	if (em->compress_type != BTRFS_COMPRESS_NONE) {	4179	if (em->compress_type != BTRFS_COMPRESS_NONE) {
4180	btrfs_set_token_file_extent_disk_bytenr(leaf, fi,	4180	btrfs_set_token_file_extent_disk_bytenr(&token, fi,
4181	em->block_start,	4181	em->block_start);
4182	&token);	4182	btrfs_set_token_file_extent_disk_num_bytes(&token, fi, block_len);
4183	btrfs_set_token_file_extent_disk_num_bytes(leaf, fi, block_len,
4184	&token);
4185	} else if (em->block_start < EXTENT_MAP_LAST_BYTE) {	4183	} else if (em->block_start < EXTENT_MAP_LAST_BYTE) {
4186	btrfs_set_token_file_extent_disk_bytenr(leaf, fi,	4184	btrfs_set_token_file_extent_disk_bytenr(&token, fi,
4187	em->block_start -	4185	em->block_start -
4188	extent_offset, &token);	4186	extent_offset);
4189	btrfs_set_token_file_extent_disk_num_bytes(leaf, fi, block_len,	4187	btrfs_set_token_file_extent_disk_num_bytes(&token, fi, block_len);
4190	&token);
4191	} else {	4188	} else {
4192	btrfs_set_token_file_extent_disk_bytenr(leaf, fi, 0, &token);	4189	btrfs_set_token_file_extent_disk_bytenr(&token, fi, 0);
4193	btrfs_set_token_file_extent_disk_num_bytes(leaf, fi, 0,	4190	btrfs_set_token_file_extent_disk_num_bytes(&token, fi, 0);
4194	&token);	4191	}
4195	}	4192
4196		4193	btrfs_set_token_file_extent_offset(&token, fi, extent_offset);
4197	btrfs_set_token_file_extent_offset(leaf, fi, extent_offset, &token);	4194	btrfs_set_token_file_extent_num_bytes(&token, fi, em->len);
4198	btrfs_set_token_file_extent_num_bytes(leaf, fi, em->len, &token);	4195	btrfs_set_token_file_extent_ram_bytes(&token, fi, em->ram_bytes);
4199	btrfs_set_token_file_extent_ram_bytes(leaf, fi, em->ram_bytes, &token);	4196	btrfs_set_token_file_extent_compression(&token, fi, em->compress_type);
4200	btrfs_set_token_file_extent_compression(leaf, fi, em->compress_type,	4197	btrfs_set_token_file_extent_encryption(&token, fi, 0);
4201	&token);	4198	btrfs_set_token_file_extent_other_encoding(&token, fi, 0);
4202	btrfs_set_token_file_extent_encryption(leaf, fi, 0, &token);
4203	btrfs_set_token_file_extent_other_encoding(leaf, fi, 0, &token);
4204	btrfs_mark_buffer_dirty(leaf);	4199	btrfs_mark_buffer_dirty(leaf);
4205		4200
4206	btrfs_release_path(path);	4201	btrfs_release_path(path);
@@ -4336,12 +4331,9 @@ static int btrfs_log_prealloc_extents(struct btrfs_trans_handle *trans, · 129 unmodified lines
4336	}	4331	}
4337	}	4332	}
4338	}	4333	}
4339	if (ins_nr > 0) {	4334	if (ins_nr > 0)
4340	ret = copy_items(trans, inode, dst_path, path,	4335	ret = copy_items(trans, inode, dst_path, path,
4341	start_slot, ins_nr, 1, 0);	4336	start_slot, ins_nr, 1, 0);
4342	if (ret > 0)
4343	ret = 0;
4344	}
4345	out:	4337	out:
4346	btrfs_release_path(path);	4338	btrfs_release_path(path);
4347	btrfs_free_path(dst_path);	4339	btrfs_free_path(dst_path);
@@ -4835,10 +4827,7 @@ static int log_conflicting_inodes(struct btrfs_trans_handle *trans, · 487 unmodified lines
4835		4827
4836	btrfs_release_path(path);	4828	btrfs_release_path(path);
4837		4829
4838	key.objectid = ino;	4830	inode = btrfs_iget(fs_info->sb, ino, root);
4839	key.type = BTRFS_INODE_ITEM_KEY;
4840	key.offset = 0;
4841	inode = btrfs_iget(fs_info->sb, &key, root);
4842	/*	4831	/*
4843	* If the other inode that had a conflicting dir entry was	4832	* If the other inode that had a conflicting dir entry was
4844	* deleted in the current transaction, we need to log its parent	4833	* deleted in the current transaction, we need to log its parent
@@ -4847,8 +4836,7 @@ static int log_conflicting_inodes(struct btrfs_trans_handle *trans, · 2 unmodified lines
4847	if (IS_ERR(inode)) {	4836	if (IS_ERR(inode)) {
4848	ret = PTR_ERR(inode);	4837	ret = PTR_ERR(inode);
4849	if (ret == -ENOENT) {	4838	if (ret == -ENOENT) {
4850	key.objectid = parent;	4839	inode = btrfs_iget(fs_info->sb, parent, root);
4851	inode = btrfs_iget(fs_info->sb, &key, root);
4852	if (IS_ERR(inode)) {	4840	if (IS_ERR(inode)) {
4853	ret = PTR_ERR(inode);	4841	ret = PTR_ERR(inode);
4854	} else {	4842	} else {
@@ -5587,7 +5575,7 @@ process_leaf: · 732 unmodified lines
5587	continue;	5575	continue;
5588		5576
5589	btrfs_release_path(path);	5577	btrfs_release_path(path);
5590	di_inode = btrfs_iget(fs_info->sb, &di_key, root);	5578	di_inode = btrfs_iget(fs_info->sb, di_key.objectid, root);
5591	if (IS_ERR(di_inode)) {	5579	if (IS_ERR(di_inode)) {
5592	ret = PTR_ERR(di_inode);	5580	ret = PTR_ERR(di_inode);
5593	goto next_dir_inode;	5581	goto next_dir_inode;
@@ -5713,7 +5701,8 @@ static int btrfs_log_all_parents(struct btrfs_trans_handle *trans, · 119 unmodified lines
5713	cur_offset = item_size;	5701	cur_offset = item_size;
5714	}	5702	}
5715		5703
5716	dir_inode = btrfs_iget(fs_info->sb, &inode_key, root);	5704	dir_inode = btrfs_iget(fs_info->sb, inode_key.objectid,
		5705	root);
5717	/*	5706	/*
5718	* If the parent inode was deleted, return an error to	5707	* If the parent inode was deleted, return an error to
5719	* fallback to a transaction commit. This is to prevent	5708	* fallback to a transaction commit. This is to prevent
@@ -5780,14 +5769,17 @@ static int log_new_ancestors(struct btrfs_trans_handle *trans, · 60 unmodified lines
5780	int slot = path->slots[0];	5769	int slot = path->slots[0];
5781	struct btrfs_key search_key;	5770	struct btrfs_key search_key;
5782	struct inode *inode;	5771	struct inode *inode;
		5772	u64 ino;
5783	int ret = 0;	5773	int ret = 0;
5784		5774
5785	btrfs_release_path(path);	5775	btrfs_release_path(path);
5786		5776
		5777	ino = found_key.offset;
		5778
5787	search_key.objectid = found_key.offset;	5779	search_key.objectid = found_key.offset;
5788	search_key.type = BTRFS_INODE_ITEM_KEY;	5780	search_key.type = BTRFS_INODE_ITEM_KEY;
5789	search_key.offset = 0;	5781	search_key.offset = 0;
5790	inode = btrfs_iget(fs_info->sb, &search_key, root);	5782	inode = btrfs_iget(fs_info->sb, ino, root);
5791	if (IS_ERR(inode))	5783	if (IS_ERR(inode))
5792	return PTR_ERR(inode);	5784	return PTR_ERR(inode);
5793		5785
@@ -6132,7 +6124,6 @@ int btrfs_recover_log_trees(struct btrfs_root *log_root_tree) · 338 unmodified lines
6132	struct btrfs_trans_handle *trans;	6124	struct btrfs_trans_handle *trans;
6133	struct btrfs_key key;	6125	struct btrfs_key key;
6134	struct btrfs_key found_key;	6126	struct btrfs_key found_key;
6135	struct btrfs_key tmp_key;
6136	struct btrfs_root *log;	6127	struct btrfs_root *log;
6137	struct btrfs_fs_info *fs_info = log_root_tree->fs_info;	6128	struct btrfs_fs_info *fs_info = log_root_tree->fs_info;
6138	struct walk_control wc = {	6129	struct walk_control wc = {
@@ -6194,11 +6185,8 @@ again: · 55 unmodified lines
6194	goto error;	6185	goto error;
6195	}	6186	}
6196		6187
6197	tmp_key.objectid = found_key.offset;	6188	wc.replay_dest = btrfs_get_fs_root(fs_info, found_key.offset,
6198	tmp_key.type = BTRFS_ROOT_ITEM_KEY;	6189	true);
6199	tmp_key.offset = (u64)-1;
6200
6201	wc.replay_dest = btrfs_get_fs_root(fs_info, &tmp_key, true);
6202	if (IS_ERR(wc.replay_dest)) {	6190	if (IS_ERR(wc.replay_dest)) {
6203	ret = PTR_ERR(wc.replay_dest);	6191	ret = PTR_ERR(wc.replay_dest);
6204		6192

fs/btrfs/uuid-tree.c+1−5

 static int btrfs_check_uuid_tree_entry(struct btrfs_fs_info *fs_info,
 				       u8 *uuid, u8 type, u64 subvolid)
 {
-	struct btrfs_key key;
 	int ret = 0;
 	struct btrfs_root *subvol_root;
 	    type != BTRFS_UUID_KEY_RECEIVED_SUBVOL)
 		goto out;
-	key.objectid = subvolid;
+	subvol_root = btrfs_get_fs_root(fs_info, subvolid, true);
-	key.type = BTRFS_ROOT_ITEM_KEY;
-	key.offset = (u64)-1;
-	subvol_root = btrfs_get_fs_root(fs_info, &key, true);
 	if (IS_ERR(subvol_root)) {
 		ret = PTR_ERR(subvol_root);
 		if (ret == -ENOENT)

fs/btrfs/volumes.c+44−36

@@ -280,10 +280,9 @@ static int __btrfs_map_block(struct btrfs_fs_info *fs_info, · 279 unmodified lines
280	* ============	280	* ============
281	*	281	*
282	* uuid_mutex	282	* uuid_mutex
283	* volume_mutex	283	* device_list_mutex
284	* device_list_mutex	284	* chunk_mutex
285	* chunk_mutex	285	* balance_mutex
286	* balance_mutex
287	*	286	*
288	*	287	*
289	* Exclusive operations, BTRFS_FS_EXCL_OP	288	* Exclusive operations, BTRFS_FS_EXCL_OP
@@ -1042,6 +1041,8 @@ again: · 752 unmodified lines
1042	&device->dev_state)) {	1041	&device->dev_state)) {
1043	if (!test_bit(BTRFS_DEV_STATE_REPLACE_TGT,	1042	if (!test_bit(BTRFS_DEV_STATE_REPLACE_TGT,
1044	&device->dev_state) &&	1043	&device->dev_state) &&
		1044	!test_bit(BTRFS_DEV_STATE_MISSING,
		1045	&device->dev_state) &&
1045	(!latest_dev \|\|	1046	(!latest_dev \|\|
1046	device->generation > latest_dev->generation)) {	1047	device->generation > latest_dev->generation)) {
1047	latest_dev = device;	1048	latest_dev = device;
@@ -1185,7 +1186,6 @@ static int open_fs_devices(struct btrfs_fs_devices *fs_devices, · 137 unmodified lines
1185	{	1186	{
1186	struct btrfs_device *device;	1187	struct btrfs_device *device;
1187	struct btrfs_device *latest_dev = NULL;	1188	struct btrfs_device *latest_dev = NULL;
1188	int ret = 0;
1189		1189
1190	flags \|= FMODE_EXCL;	1190	flags \|= FMODE_EXCL;
1191		1191
@@ -1198,16 +1198,15 @@ static int open_fs_devices(struct btrfs_fs_devices *fs_devices, · 6 unmodified lines
1198	device->generation > latest_dev->generation)	1198	device->generation > latest_dev->generation)
1199	latest_dev = device;	1199	latest_dev = device;
1200	}	1200	}
1201	if (fs_devices->open_devices == 0) {	1201	if (fs_devices->open_devices == 0)
1202	ret = -EINVAL;	1202	return -EINVAL;
1203	goto out;	1203
1204	}
1205	fs_devices->opened = 1;	1204	fs_devices->opened = 1;
1206	fs_devices->latest_bdev = latest_dev->bdev;	1205	fs_devices->latest_bdev = latest_dev->bdev;
1207	fs_devices->total_rw_bytes = 0;	1206	fs_devices->total_rw_bytes = 0;
1208	fs_devices->chunk_alloc_policy = BTRFS_CHUNK_ALLOC_REGULAR;	1207	fs_devices->chunk_alloc_policy = BTRFS_CHUNK_ALLOC_REGULAR;
1209	out:	1208
1210	return ret;	1209	return 0;
1211	}	1210	}
1212		1211
1213	static int devid_cmp(void priv, struct list_head a, struct list_head *b)	1212	static int devid_cmp(void priv, struct list_head a, struct list_head *b)
@@ -1251,49 +1250,48 @@ void btrfs_release_disk_super(struct btrfs_super_block *super) · 37 unmodified lines
1251	put_page(page);	1250	put_page(page);
1252	}	1251	}
1253		1252
1254	static int btrfs_read_disk_super(struct block_device *bdev, u64 bytenr,	1253	static struct btrfs_super_block btrfs_read_disk_super(struct block_device bdev,
1255	struct page **page,	1254	u64 bytenr)
1256	struct btrfs_super_block **disk_super)
1257	{	1255	{
		1256	struct btrfs_super_block *disk_super;
		1257	struct page *page;
1258	void *p;	1258	void *p;
1259	pgoff_t index;	1259	pgoff_t index;
1260		1260
1261	/* make sure our super fits in the device */	1261	/* make sure our super fits in the device */
1262	if (bytenr + PAGE_SIZE >= i_size_read(bdev->bd_inode))	1262	if (bytenr + PAGE_SIZE >= i_size_read(bdev->bd_inode))
1263	return 1;	1263	return ERR_PTR(-EINVAL);
1264		1264
1265	/* make sure our super fits in the page */	1265	/* make sure our super fits in the page */
1266	if (sizeof(**disk_super) > PAGE_SIZE)	1266	if (sizeof(*disk_super) > PAGE_SIZE)
1267	return 1;	1267	return ERR_PTR(-EINVAL);
1268		1268
1269	/* make sure our super doesn't straddle pages on disk */	1269	/* make sure our super doesn't straddle pages on disk */
1270	index = bytenr >> PAGE_SHIFT;	1270	index = bytenr >> PAGE_SHIFT;
1271	if ((bytenr + sizeof(**disk_super) - 1) >> PAGE_SHIFT != index)	1271	if ((bytenr + sizeof(*disk_super) - 1) >> PAGE_SHIFT != index)
1272	return 1;	1272	return ERR_PTR(-EINVAL);
1273		1273
1274	/* pull in the page with our super */	1274	/* pull in the page with our super */
1275	*page = read_cache_page_gfp(bdev->bd_inode->i_mapping,	1275	page = read_cache_page_gfp(bdev->bd_inode->i_mapping, index, GFP_KERNEL);
1276	index, GFP_KERNEL);
1277		1276
1278	if (IS_ERR(*page))	1277	if (IS_ERR(page))
1279	return 1;	1278	return ERR_CAST(page);
1280		1279
1281	p = page_address(*page);	1280	p = page_address(page);
1282		1281
1283	/* align our pointer to the offset of the super block */	1282	/* align our pointer to the offset of the super block */
1284	*disk_super = p + offset_in_page(bytenr);	1283	disk_super = p + offset_in_page(bytenr);
1285		1284
1286	if (btrfs_super_bytenr(*disk_super) != bytenr \|\|	1285	if (btrfs_super_bytenr(disk_super) != bytenr \|\|
1287	btrfs_super_magic(*disk_super) != BTRFS_MAGIC) {	1286	btrfs_super_magic(disk_super) != BTRFS_MAGIC) {
1288	btrfs_release_disk_super(p);	1287	btrfs_release_disk_super(p);
1289	return 1;	1288	return ERR_PTR(-EINVAL);
1290	}	1289	}
1291		1290
1292	if ((*disk_super)->label[0] &&	1291	if (disk_super->label[0] && disk_super->label[BTRFS_LABEL_SIZE - 1])
1293	(*disk_super)->label[BTRFS_LABEL_SIZE - 1])	1292	disk_super->label[BTRFS_LABEL_SIZE - 1] = 0;
1294	(*disk_super)->label[BTRFS_LABEL_SIZE - 1] = '\0';
1295		1293
1296	return 0;	1294	return disk_super;
1297	}	1295	}
1298		1296
1299	int btrfs_forget_devices(const char *path)	1297	int btrfs_forget_devices(const char *path)
@@ -1319,7 +1317,6 @@ struct btrfs_device btrfs_scan_one_device(const char path, fmode_t flags, · 19 unmodified lines
1319	bool new_device_added = false;	1317	bool new_device_added = false;
1320	struct btrfs_device *device = NULL;	1318	struct btrfs_device *device = NULL;
1321	struct block_device *bdev;	1319	struct block_device *bdev;
1322	struct page *page;
1323	u64 bytenr;	1320	u64 bytenr;
1324		1321
1325	lockdep_assert_held(&uuid_mutex);	1322	lockdep_assert_held(&uuid_mutex);
@@ -1337,8 +1334,9 @@ struct btrfs_device btrfs_scan_one_device(const char path, fmode_t flags, · 11 unmodified lines
1337	if (IS_ERR(bdev))	1334	if (IS_ERR(bdev))
1338	return ERR_CAST(bdev);	1335	return ERR_CAST(bdev);
1339		1336
1340	if (btrfs_read_disk_super(bdev, bytenr, &page, &disk_super)) {	1337	disk_super = btrfs_read_disk_super(bdev, bytenr);
1341	device = ERR_PTR(-EINVAL);	1338	if (IS_ERR(disk_super)) {
		1339	device = ERR_CAST(disk_super);
1342	goto error_bdev_put;	1340	goto error_bdev_put;
1343	}	1341	}
1344		1342
@@ -2663,8 +2661,18 @@ int btrfs_init_new_device(struct btrfs_fs_info fs_info, const char device_path · 1318 unmodified lines
2663	ret = btrfs_commit_transaction(trans);	2661	ret = btrfs_commit_transaction(trans);
2664	}	2662	}
2665		2663
2666	/* Update ctime/mtime for libblkid */	2664	/*
		2665	* Now that we have written a new super block to this device, check all
		2666	* other fs_devices list if device_path alienates any other scanned
		2667	* device.
		2668	* We can ignore the return value as it typically returns -EINVAL and
		2669	* only succeeds if the device was an alien.
		2670	*/
		2671	btrfs_forget_devices(device_path);
		2672
		2673	/* Update ctime/mtime for blkid or udev */
2667	update_dev_time(device_path);	2674	update_dev_time(device_path);
		2675
2668	return ret;	2676	return ret;
2669		2677
2670	error_sysfs:	2678	error_sysfs:

fs/direct-io.c+0−19

@@ -386,25 +386,6 @@ static void dio_bio_end_io(struct bio *bio) · 385 unmodified lines
386	spin_unlock_irqrestore(&dio->bio_lock, flags);	386	spin_unlock_irqrestore(&dio->bio_lock, flags);
387	}	387	}
388		388
389	/**
390	* dio_end_io - handle the end io action for the given bio
391	* @bio: The direct io bio thats being completed
392	*
393	* This is meant to be called by any filesystem that uses their own dio_submit_t
394	* so that the DIO specific endio actions are dealt with after the filesystem
395	* has done it's completion work.
396	*/
397	void dio_end_io(struct bio *bio)
398	{
399	struct dio *dio = bio->bi_private;
400
401	if (dio->is_async)
402	dio_bio_end_aio(bio);
403	else
404	dio_bio_end_io(bio);
405	}
406	EXPORT_SYMBOL_GPL(dio_end_io);
407
408	static inline void	389	static inline void
409	dio_bio_alloc(struct dio dio, struct dio_submit sdio,	390	dio_bio_alloc(struct dio dio, struct dio_submit sdio,
410	struct block_device *bdev,	391	struct block_device *bdev,

fs/iomap/direct-io.c+10−7

 EXPORT_SYMBOL_GPL(iomap_dio_iopoll);
 static void iomap_dio_submit_bio(struct iomap_dio *dio, struct iomap *iomap,
-		struct bio *bio)
+		struct bio *bio, loff_t pos)
 {
 	atomic_inc(&dio->ref);
 		bio_set_polled(bio, dio->iocb);
 	dio->submit.last_queue = bdev_get_queue(iomap->bdev);
-	dio->submit.cookie = submit_bio(bio);
+	if (dio->dops && dio->dops->submit_io)
+		dio->submit.cookie = dio->dops->submit_io(
+				file_inode(dio->iocb->ki_filp),
+				iomap, bio, pos);
+	else
+		dio->submit.cookie = submit_bio(bio);
 }
 static ssize_t iomap_dio_complete(struct iomap_dio *dio)
 	get_page(page);
 	__bio_add_page(bio, page, len, 0);
 	bio_set_op_attrs(bio, REQ_OP_WRITE, flags);
-	iomap_dio_submit_bio(dio, iomap, bio);
+	iomap_dio_submit_bio(dio, iomap, bio, pos);
 }
 static loff_t
 		}
 		dio->size += n;
-		pos += n;
 		copied += n;
 		nr_pages = iov_iter_npages(dio->submit.iter, BIO_MAX_PAGES);
-		iomap_dio_submit_bio(dio, iomap, bio);
+		iomap_dio_submit_bio(dio, iomap, bio, pos);
+		pos += n;
 	} while (nr_pages);
 	/*
 	struct blk_plug plug;
 	struct iomap_dio *dio;
-	lockdep_assert_held(&inode->i_rwsem);
 	if (!count)
 		return 0;

include/linux/bio.h+8−0

@@ -169,6 +169,14 @@ static inline void bio_advance_iter(const struct bio *bio, · 168 unmodified lines
169	#define bio_for_each_bvec(bvl, bio, iter) \	169	#define bio_for_each_bvec(bvl, bio, iter) \
170	__bio_for_each_bvec(bvl, bio, iter, (bio)->bi_iter)	170	__bio_for_each_bvec(bvl, bio, iter, (bio)->bi_iter)
171		171
		172	/*
		173	* Iterate over all multi-page bvecs. Drivers shouldn't use this version for the
		174	* same reasons as bio_for_each_segment_all().
		175	*/
		176	#define bio_for_each_bvec_all(bvl, bio, i) \
		177	for (i = 0, bvl = bio_first_bvec_all(bio); \
		178	i < (bio)->bi_vcnt; i++, bvl++) \
		179
172	#define bio_iter_last(bvec, iter) ((iter).bi_size == (bvec).bv_len)	180	#define bio_iter_last(bvec, iter) ((iter).bi_size == (bvec).bv_len)
173		181
174	static inline unsigned bio_segments(struct bio *bio)	182	static inline unsigned bio_segments(struct bio *bio)

include/linux/fs.h+2−2

 extern int generic_copy_file_checks(struct file *file_in, loff_t pos_in,
 				    struct file *file_out, loff_t pos_out,
 				    size_t *count, unsigned int flags);
+extern ssize_t generic_file_buffered_read(struct kiocb *iocb,
+		struct iov_iter *to, ssize_t already_read);
 extern ssize_t generic_file_read_iter(struct kiocb *, struct iov_iter *);
 extern ssize_t __generic_file_write_iter(struct kiocb *, struct iov_iter *);
 extern ssize_t generic_file_write_iter(struct kiocb *, struct iov_iter *);
 	DIO_SKIP_HOLES	= 0x02,
 };
-void dio_end_io(struct bio *bio);
 ssize_t __blockdev_direct_IO(struct kiocb *iocb, struct inode *inode,
 			     struct block_device *bdev, struct iov_iter *iter,
 			     get_block_t get_block,

include/linux/iomap.h+2−0

@@ -251,6 +251,8 @@ int iomap_writepages(struct address_space *mapping, · 250 unmodified lines
251	struct iomap_dio_ops {	251	struct iomap_dio_ops {
252	int (end_io)(struct kiocb iocb, ssize_t size, int error,	252	int (end_io)(struct kiocb iocb, ssize_t size, int error,
253	unsigned flags);	253	unsigned flags);
		254	blk_qc_t (submit_io)(struct inode inode, struct iomap *iomap,
		255	struct bio *bio, loff_t file_offset);
254	};	256	};
255		257
256	ssize_t iomap_dio_rw(struct kiocb iocb, struct iov_iter iter,	258	ssize_t iomap_dio_rw(struct kiocb iocb, struct iov_iter iter,

include/trace/events/btrfs.h+1−0

@@ -89,6 +89,7 @@ TRACE_DEFINE_ENUM(COMMIT_TRANS); · 88 unmodified lines
89	{ IO_TREE_TRANS_DIRTY_PAGES, "TRANS_DIRTY_PAGES" }, \	89	{ IO_TREE_TRANS_DIRTY_PAGES, "TRANS_DIRTY_PAGES" }, \
90	{ IO_TREE_ROOT_DIRTY_LOG_PAGES, "ROOT_DIRTY_LOG_PAGES" }, \	90	{ IO_TREE_ROOT_DIRTY_LOG_PAGES, "ROOT_DIRTY_LOG_PAGES" }, \
91	{ IO_TREE_INODE_FILE_EXTENT, "INODE_FILE_EXTENT" }, \	91	{ IO_TREE_INODE_FILE_EXTENT, "INODE_FILE_EXTENT" }, \
		92	{ IO_TREE_LOG_CSUM_RANGE, "LOG_CSUM_RANGE" }, \
92	{ IO_TREE_SELFTEST, "SELFTEST" })	93	{ IO_TREE_SELFTEST, "SELFTEST" })
93		94
94	#define BTRFS_GROUP_FLAGS \	95	#define BTRFS_GROUP_FLAGS \

include/uapi/linux/btrfs_tree.h+0−9

@@ -519,15 +519,6 @@ struct btrfs_extent_inline_ref { · 518 unmodified lines
519	__le64 offset;	519	__le64 offset;
520	} __attribute__ ((__packed__));	520	} __attribute__ ((__packed__));
521		521
522	/* old style backrefs item */
523	struct btrfs_extent_ref_v0 {
524	__le64 root;
525	__le64 generation;
526	__le64 objectid;
527	__le32 count;
528	} __attribute__ ((__packed__));
529
530
531	/* dev extents record free space on individual devices. The owner	522	/* dev extents record free space on individual devices. The owner
532	* field points back to the chunk allocation mapping tree that allocated	523	* field points back to the chunk allocation mapping tree that allocated
533	* the extent. The chunk tree uuid field is a way to double check the owner	524	* the extent. The chunk tree uuid field is a way to double check the owner

mm/filemap.c+2−1

  * * total number of bytes copied, including those the were already @written
  * * negative error code if nothing was copied
  */
-static ssize_t generic_file_buffered_read(struct kiocb *iocb,
+ssize_t generic_file_buffered_read(struct kiocb *iocb,
 		struct iov_iter *iter, ssize_t written)
 {
 	struct file *filp = iocb->ki_filp;
 	file_accessed(filp);
 	return written ? written : error;
 }
+EXPORT_SYMBOL_GPL(generic_file_buffered_read);
 /**
  * generic_file_read_iter - generic filesystem read routine