1 // SPDX-License-Identifier: GPL-2.0
16 #include <linux/backing-dev.h>
37 #include "disk-io.h"
40 #include "print-tree.h"
41 #include "ordered-data.h"
43 #include "tree-log.h"
47 #include "free-space-cache.h"
48 #include "inode-map.h"
51 #include "delalloc-space.h"
52 #include "block-group.h"
53 #include "space-info.h"
113 	unsigned long end_index = (offset + bytes - 1) >> PAGE_SHIFT;  in btrfs_cleanup_ordered_extents()
115 	u64 page_end = page_start + PAGE_SIZE - 1;  in btrfs_cleanup_ordered_extents()
120 		page = find_get_page(inode->vfs_inode.i_mapping, index);  in btrfs_cleanup_ordered_extents()
133 	if (page_start >= offset && page_end <= (offset + bytes - 1)) {  in btrfs_cleanup_ordered_extents()
135 		bytes -= PAGE_SIZE;  in btrfs_cleanup_ordered_extents()
193 		path->leave_spinning = 1;  in insert_inline_extent()
199 	leaf = path->nodes[0];  in insert_inline_extent()
200 	ei = btrfs_item_ptr(leaf, path->slots[0],  in insert_inline_extent()
202 	btrfs_set_file_extent_generation(leaf, ei, trans->transid);  in insert_inline_extent()
223 			compressed_size -= cur_size;  in insert_inline_extent()
228 		page = find_get_page(inode->i_mapping,  in insert_inline_extent()
244 	size = ALIGN(size, root->fs_info->sectorsize);  in insert_inline_extent()
258 	BTRFS_I(inode)->disk_i_size = inode->i_size;  in insert_inline_extent()
276 	struct btrfs_root *root = inode->root;  in cow_file_range_inline()
277 	struct btrfs_fs_info *fs_info = root->fs_info;  in cow_file_range_inline()
279 	u64 isize = i_size_read(&inode->vfs_inode);  in cow_file_range_inline()
281 	u64 inline_len = actual_end - start;  in cow_file_range_inline()
282 	u64 aligned_end = ALIGN(end, fs_info->sectorsize);  in cow_file_range_inline()
293 	    actual_end > fs_info->sectorsize ||  in cow_file_range_inline()
296 	    (actual_end & (fs_info->sectorsize - 1)) == 0) ||  in cow_file_range_inline()
298 	    data_len > fs_info->max_inline) {  in cow_file_range_inline()
304 		return -ENOMEM;  in cow_file_range_inline()
311 	trans->block_rsv = &inode->block_rsv;  in cow_file_range_inline()
331 				   root, &inode->vfs_inode, start,  in cow_file_range_inline()
334 	if (ret && ret != -ENOSPC) {  in cow_file_range_inline()
337 	} else if (ret == -ENOSPC) {  in cow_file_range_inline()
342 	set_bit(BTRFS_INODE_NEEDS_FULL_SYNC, &inode->runtime_flags);  in cow_file_range_inline()
343 	btrfs_drop_extent_cache(inode, start, aligned_end - 1, 0);  in cow_file_range_inline()
395 	BUG_ON(!async_extent); /* -ENOMEM */  in add_async_extent()
396 	async_extent->start = start;  in add_async_extent()
397 	async_extent->ram_size = ram_size;  in add_async_extent()
398 	async_extent->compressed_size = compressed_size;  in add_async_extent()
399 	async_extent->pages = pages;  in add_async_extent()
400 	async_extent->nr_pages = nr_pages;  in add_async_extent()
401 	async_extent->compress_type = compress_type;  in add_async_extent()
402 	list_add_tail(&async_extent->list, &cow->extents);  in add_async_extent()
411 	if (inode->flags & BTRFS_INODE_NODATACOW ||  in inode_can_compress()
412 	    inode->flags & BTRFS_INODE_NODATASUM)  in inode_can_compress()
424 	struct btrfs_fs_info *fs_info = inode->root->fs_info;  in inode_need_compress()
436 	if (inode->defrag_compress)  in inode_need_compress()
439 	if (inode->flags & BTRFS_INODE_NOCOMPRESS)  in inode_need_compress()
442 	    inode->flags & BTRFS_INODE_COMPRESS ||  in inode_need_compress()
443 	    inode->prop_compress)  in inode_need_compress()
444 		return btrfs_compress_heuristic(&inode->vfs_inode, start, end);  in inode_need_compress()
453 	    (start > 0 || end + 1 < inode->disk_i_size))  in inode_should_defrag()
462  * This is done inside an ordered work queue, and the compression
464  * two, and the ordered work queue takes care of making sure that
465  * happens in the same order things were put onto the queue by
469  * entry onto the work queue to write the uncompressed bytes.  This
476 	struct inode *inode = async_chunk->inode;  in compress_file_range()
477 	struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);  in compress_file_range()
478 	u64 blocksize = fs_info->sectorsize;  in compress_file_range()
479 	u64 start = async_chunk->start;  in compress_file_range()
480 	u64 end = async_chunk->end;  in compress_file_range()
490 	int compress_type = fs_info->compress_type;  in compress_file_range()
494 	inode_should_defrag(BTRFS_I(inode), start, end, end - start + 1,  in compress_file_range()
512 	nr_pages = (end >> PAGE_SHIFT) - (start >> PAGE_SHIFT) + 1;  in compress_file_range()
530 	total_compressed = actual_end - start;  in compress_file_range()
537 	   (start > 0 || end + 1 < BTRFS_I(inode)->disk_i_size))  in compress_file_range()
546 	 * we do compression for mount -o compress and when the  in compress_file_range()
559 		if (BTRFS_I(inode)->defrag_compress)  in compress_file_range()
560 			compress_type = BTRFS_I(inode)->defrag_compress;  in compress_file_range()
561 		else if (BTRFS_I(inode)->prop_compress)  in compress_file_range()
562 			compress_type = BTRFS_I(inode)->prop_compress;  in compress_file_range()
583 			compress_type | (fs_info->compress_level << 4),  in compress_file_range()
584 					   inode->i_mapping, start,  in compress_file_range()
592 			struct page *page = pages[nr_pages - 1];  in compress_file_range()
601 				       PAGE_SIZE - offset);  in compress_file_range()
657 					WARN_ON(pages[i]->mapping);  in compress_file_range()
707 			WARN_ON(pages[i]->mapping);  in compress_file_range()
717 		    !(BTRFS_I(inode)->prop_compress)) {  in compress_file_range()
718 			BTRFS_I(inode)->flags |= BTRFS_INODE_NOCOMPRESS;  in compress_file_range()
725 	 * to our extent and set things up for the async work queue to run  in compress_file_range()
728 	if (async_chunk->locked_page &&  in compress_file_range()
729 	    (page_offset(async_chunk->locked_page) >= start &&  in compress_file_range()
730 	     page_offset(async_chunk->locked_page)) <= end) {  in compress_file_range()
731 		__set_page_dirty_nobuffers(async_chunk->locked_page);  in compress_file_range()
737 	add_async_extent(async_chunk, start, end - start + 1, 0, NULL, 0,  in compress_file_range()
748 	if (!async_extent->pages)  in free_async_extent_pages()
751 	for (i = 0; i < async_extent->nr_pages; i++) {  in free_async_extent_pages()
752 		WARN_ON(async_extent->pages[i]->mapping);  in free_async_extent_pages()
753 		put_page(async_extent->pages[i]);  in free_async_extent_pages()
755 	kfree(async_extent->pages);  in free_async_extent_pages()
756 	async_extent->nr_pages = 0;  in free_async_extent_pages()
757 	async_extent->pages = NULL;  in free_async_extent_pages()
768 	struct btrfs_inode *inode = BTRFS_I(async_chunk->inode);  in submit_compressed_extents()
769 	struct btrfs_fs_info *fs_info = inode->root->fs_info;  in submit_compressed_extents()
774 	struct btrfs_root *root = inode->root;  in submit_compressed_extents()
775 	struct extent_io_tree *io_tree = &inode->io_tree;  in submit_compressed_extents()
779 	while (!list_empty(&async_chunk->extents)) {  in submit_compressed_extents()
780 		async_extent = list_entry(async_chunk->extents.next,  in submit_compressed_extents()
782 		list_del(&async_extent->list);  in submit_compressed_extents()
785 		lock_extent(io_tree, async_extent->start,  in submit_compressed_extents()
786 			    async_extent->start + async_extent->ram_size - 1);  in submit_compressed_extents()
788 		if (!async_extent->pages) {  in submit_compressed_extents()
793 			ret = cow_file_range(inode, async_chunk->locked_page,  in submit_compressed_extents()
794 					     async_extent->start,  in submit_compressed_extents()
795 					     async_extent->start +  in submit_compressed_extents()
796 					     async_extent->ram_size - 1,  in submit_compressed_extents()
808 				extent_write_locked_range(&inode->vfs_inode,  in submit_compressed_extents()
809 						  async_extent->start,  in submit_compressed_extents()
810 						  async_extent->start +  in submit_compressed_extents()
811 						  async_extent->ram_size - 1,  in submit_compressed_extents()
813 			else if (ret && async_chunk->locked_page)  in submit_compressed_extents()
814 				unlock_page(async_chunk->locked_page);  in submit_compressed_extents()
820 		ret = btrfs_reserve_extent(root, async_extent->ram_size,  in submit_compressed_extents()
821 					   async_extent->compressed_size,  in submit_compressed_extents()
822 					   async_extent->compressed_size,  in submit_compressed_extents()
827 			if (ret == -ENOSPC) {  in submit_compressed_extents()
828 				unlock_extent(io_tree, async_extent->start,  in submit_compressed_extents()
829 					      async_extent->start +  in submit_compressed_extents()
830 					      async_extent->ram_size - 1);  in submit_compressed_extents()
838 				extent_range_redirty_for_io(&inode->vfs_inode,  in submit_compressed_extents()
839 						async_extent->start,  in submit_compressed_extents()
840 						async_extent->start +  in submit_compressed_extents()
841 						async_extent->ram_size - 1);  in submit_compressed_extents()
851 		em = create_io_em(inode, async_extent->start,  in submit_compressed_extents()
852 				  async_extent->ram_size, /* len */  in submit_compressed_extents()
853 				  async_extent->start, /* orig_start */  in submit_compressed_extents()
857 				  async_extent->ram_size, /* ram_bytes */  in submit_compressed_extents()
858 				  async_extent->compress_type,  in submit_compressed_extents()
866 						async_extent->start,  in submit_compressed_extents()
868 						async_extent->ram_size,  in submit_compressed_extents()
871 						async_extent->compress_type);  in submit_compressed_extents()
873 			btrfs_drop_extent_cache(inode, async_extent->start,  in submit_compressed_extents()
874 						async_extent->start +  in submit_compressed_extents()
875 						async_extent->ram_size - 1, 0);  in submit_compressed_extents()
883 		extent_clear_unlock_delalloc(inode, async_extent->start,  in submit_compressed_extents()
884 				async_extent->start +  in submit_compressed_extents()
885 				async_extent->ram_size - 1,  in submit_compressed_extents()
889 		if (btrfs_submit_compressed_write(inode, async_extent->start,  in submit_compressed_extents()
890 				    async_extent->ram_size,  in submit_compressed_extents()
892 				    ins.offset, async_extent->pages,  in submit_compressed_extents()
893 				    async_extent->nr_pages,  in submit_compressed_extents()
894 				    async_chunk->write_flags,  in submit_compressed_extents()
895 				    async_chunk->blkcg_css)) {  in submit_compressed_extents()
896 			struct page *p = async_extent->pages[0];  in submit_compressed_extents()
897 			const u64 start = async_extent->start;  in submit_compressed_extents()
898 			const u64 end = start + async_extent->ram_size - 1;  in submit_compressed_extents()
900 			p->mapping = inode->vfs_inode.i_mapping;  in submit_compressed_extents()
903 			p->mapping = NULL;  in submit_compressed_extents()
918 	extent_clear_unlock_delalloc(inode, async_extent->start,  in submit_compressed_extents()
919 				     async_extent->start +  in submit_compressed_extents()
920 				     async_extent->ram_size - 1,  in submit_compressed_extents()
935 	struct extent_map_tree *em_tree = &inode->extent_tree;  in get_extent_allocation_hint()
939 	read_lock(&em_tree->lock);  in get_extent_allocation_hint()
947 		if (em->block_start >= EXTENT_MAP_LAST_BYTE) {  in get_extent_allocation_hint()
950 			if (em && em->block_start < EXTENT_MAP_LAST_BYTE)  in get_extent_allocation_hint()
951 				alloc_hint = em->block_start;  in get_extent_allocation_hint()
955 			alloc_hint = em->block_start;  in get_extent_allocation_hint()
959 	read_unlock(&em_tree->lock);  in get_extent_allocation_hint()
982 	struct btrfs_root *root = inode->root;  in cow_file_range()
983 	struct btrfs_fs_info *fs_info = root->fs_info;  in cow_file_range()
989 	u64 blocksize = fs_info->sectorsize;  in cow_file_range()
999 		ret = -EINVAL;  in cow_file_range()
1003 	num_bytes = ALIGN(end - start + 1, blocksize);  in cow_file_range()
1005 	ASSERT(num_bytes <= btrfs_super_total_bytes(fs_info->super_copy));  in cow_file_range()
1027 			     (end - start + PAGE_SIZE) / PAGE_SIZE;  in cow_file_range()
1036 	btrfs_drop_extent_cache(inode, start, start + num_bytes - 1, 0);  in cow_file_range()
1049 	if (root->root_key.objectid == BTRFS_DATA_RELOC_TREE_OBJECTID)  in cow_file_range()
1052 		min_alloc_size = fs_info->sectorsize;  in cow_file_range()
1084 		if (root->root_key.objectid ==  in cow_file_range()
1101 						start + ram_size - 1, 0);  in cow_file_range()
1116 		extent_clear_unlock_delalloc(inode, start, start + ram_size - 1,  in cow_file_range()
1123 			num_bytes -= cur_alloc_size;  in cow_file_range()
1140 	btrfs_drop_extent_cache(inode, start, start + ram_size - 1, 0);  in cow_file_range()
1161 					     start + cur_alloc_size - 1,  in cow_file_range()
1176  * work queue call back to started compression on a file and pages
1187 		btrfs_add_delayed_iput(async_chunk->inode);  in async_cow_start()
1188 		async_chunk->inode = NULL;  in async_cow_start()
1193  * work queue call back to submit previously compressed pages
1202 	nr_pages = (async_chunk->end - async_chunk->start + PAGE_SIZE) >>  in async_cow_submit()
1206 	 * ->inode could be NULL if async_chunk_start has failed to compress,  in async_cow_submit()
1208 	 * always adjust ->async_delalloc_pages as its paired with the init  in async_cow_submit()
1211 	if (async_chunk->inode)  in async_cow_submit()
1215 	if (atomic_sub_return(nr_pages, &fs_info->async_delalloc_pages) <  in async_cow_submit()
1217 		cond_wake_up_nomb(&fs_info->async_submit_wait);  in async_cow_submit()
1225 	if (async_chunk->inode)  in async_cow_free()
1226 		btrfs_add_delayed_iput(async_chunk->inode);  in async_cow_free()
1227 	if (async_chunk->blkcg_css)  in async_cow_free()
1228 		css_put(async_chunk->blkcg_css);  in async_cow_free()
1233 	if (atomic_dec_and_test(async_chunk->pending))  in async_cow_free()
1234 		kvfree(async_chunk->pending);  in async_cow_free()
1243 	struct btrfs_fs_info *fs_info = inode->root->fs_info;  in cow_file_range_async()
1249 	u64 num_chunks = DIV_ROUND_UP(end - start, SZ_512K);  in cow_file_range_async()
1255 	unlock_extent(&inode->io_tree, start, end);  in cow_file_range_async()
1257 	if (inode->flags & BTRFS_INODE_NOCOMPRESS &&  in cow_file_range_async()
1279 		return -ENOMEM;  in cow_file_range_async()
1282 	async_chunk = ctx->chunks;  in cow_file_range_async()
1283 	atomic_set(&ctx->num_chunks, num_chunks);  in cow_file_range_async()
1287 			cur_end = min(end, start + SZ_512K - 1);  in cow_file_range_async()
1295 		ihold(&inode->vfs_inode);  in cow_file_range_async()
1296 		async_chunk[i].pending = &ctx->num_chunks;  in cow_file_range_async()
1297 		async_chunk[i].inode = &inode->vfs_inode;  in cow_file_range_async()
1323 						 cur_end - start);  in cow_file_range_async()
1340 		nr_pages = DIV_ROUND_UP(cur_end - start, PAGE_SIZE);  in cow_file_range_async()
1341 		atomic_add(nr_pages, &fs_info->async_delalloc_pages);  in cow_file_range_async()
1343 		btrfs_queue_work(fs_info->delalloc_workers, &async_chunk[i].work);  in cow_file_range_async()
1359 	ret = btrfs_lookup_csums_range(fs_info->csum_root, bytenr,  in csum_exist_in_range()
1360 				       bytenr + num_bytes - 1, &list, 0);  in csum_exist_in_range()
1366 		list_del(&sums->list);  in csum_exist_in_range()
1379 	const bool is_reloc_ino = (inode->root->root_key.objectid ==  in fallback_to_cow()
1381 	const u64 range_bytes = end + 1 - start;  in fallback_to_cow()
1382 	struct extent_io_tree *io_tree = &inode->io_tree;  in fallback_to_cow()
1422 		struct btrfs_fs_info *fs_info = inode->root->fs_info;  in fallback_to_cow()
1423 		struct btrfs_space_info *sinfo = fs_info->data_sinfo;  in fallback_to_cow()
1428 		spin_lock(&sinfo->lock);  in fallback_to_cow()
1430 		spin_unlock(&sinfo->lock);  in fallback_to_cow()
1454 	struct btrfs_fs_info *fs_info = inode->root->fs_info;  in run_delalloc_nocow()
1455 	struct btrfs_root *root = inode->root;  in run_delalloc_nocow()
1457 	u64 cow_start = (u64)-1;  in run_delalloc_nocow()
1475 		return -ENOMEM;  in run_delalloc_nocow()
1501 		if (ret > 0 && path->slots[0] > 0 && check_prev) {  in run_delalloc_nocow()
1502 			leaf = path->nodes[0];  in run_delalloc_nocow()
1504 					      path->slots[0] - 1);  in run_delalloc_nocow()
1507 				path->slots[0]--;  in run_delalloc_nocow()
1512 		leaf = path->nodes[0];  in run_delalloc_nocow()
1513 		if (path->slots[0] >= btrfs_header_nritems(leaf)) {  in run_delalloc_nocow()
1516 				if (cow_start != (u64)-1)  in run_delalloc_nocow()
1522 			leaf = path->nodes[0];  in run_delalloc_nocow()
1525 		btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);  in run_delalloc_nocow()
1536 			path->slots[0]++;  in run_delalloc_nocow()
1559 		fi = btrfs_item_ptr(leaf, path->slots[0],  in run_delalloc_nocow()
1577 				path->slots[0]++;  in run_delalloc_nocow()
1597 			    btrfs_root_last_snapshot(&root->root_item))  in run_delalloc_nocow()
1605 						    found_key.offset -  in run_delalloc_nocow()
1609 				 * ret could be -EIO if the above fails to read  in run_delalloc_nocow()
1613 					if (cow_start != (u64)-1)  in run_delalloc_nocow()
1622 			disk_bytenr += cur_offset - found_key.offset;  in run_delalloc_nocow()
1623 			num_bytes = min(end + 1, extent_end) - cur_offset;  in run_delalloc_nocow()
1628 			if (!freespace_inode && atomic_read(&root->snapshot_force_cow))  in run_delalloc_nocow()
1639 				 * ret could be -EIO if the above fails to read  in run_delalloc_nocow()
1643 					if (cow_start != (u64)-1)  in run_delalloc_nocow()
1655 			extent_end = ALIGN(extent_end, fs_info->sectorsize);  in run_delalloc_nocow()
1658 				path->slots[0]++;  in run_delalloc_nocow()
1671 			if (cow_start == (u64)-1)  in run_delalloc_nocow()
1676 			path->slots[0]++;  in run_delalloc_nocow()
1683 		 * COW range from cow_start to found_key.offset - 1. As the key  in run_delalloc_nocow()
1687 		if (cow_start != (u64)-1) {  in run_delalloc_nocow()
1689 					      cow_start, found_key.offset - 1,  in run_delalloc_nocow()
1693 			cow_start = (u64)-1;  in run_delalloc_nocow()
1697 			u64 orig_start = found_key.offset - extent_offset;  in run_delalloc_nocow()
1718 							cur_offset + num_bytes - 1,  in run_delalloc_nocow()
1735 		if (root->root_key.objectid ==  in run_delalloc_nocow()
1746 					     cur_offset + num_bytes - 1,  in run_delalloc_nocow()
1766 	if (cur_offset <= end && cow_start == (u64)-1)  in run_delalloc_nocow()
1769 	if (cow_start != (u64)-1) {  in run_delalloc_nocow()
1796 	if (!(inode->flags & BTRFS_INODE_NODATACOW) &&  in need_force_cow()
1797 	    !(inode->flags & BTRFS_INODE_PREALLOC))  in need_force_cow()
1805 	if (inode->defrag_bytes &&  in need_force_cow()
1806 	    test_range_bit(&inode->io_tree, start, end, EXTENT_DEFRAG, 0, NULL))  in need_force_cow()
1823 	if (inode->flags & BTRFS_INODE_NODATACOW && !force_cow) {  in btrfs_run_delalloc_range()
1826 	} else if (inode->flags & BTRFS_INODE_PREALLOC && !force_cow) {  in btrfs_run_delalloc_range()
1834 		set_bit(BTRFS_INODE_HAS_ASYNC_EXTENT, &inode->runtime_flags);  in btrfs_run_delalloc_range()
1840 					      end - start + 1);  in btrfs_run_delalloc_range()
1850 	if (!(orig->state & EXTENT_DELALLOC))  in btrfs_split_delalloc_extent()
1853 	size = orig->end - orig->start + 1;  in btrfs_split_delalloc_extent()
1862 		new_size = orig->end - split + 1;  in btrfs_split_delalloc_extent()
1864 		new_size = split - orig->start;  in btrfs_split_delalloc_extent()
1870 	spin_lock(&BTRFS_I(inode)->lock);  in btrfs_split_delalloc_extent()
1872 	spin_unlock(&BTRFS_I(inode)->lock);  in btrfs_split_delalloc_extent()
1887 	if (!(other->state & EXTENT_DELALLOC))  in btrfs_merge_delalloc_extent()
1890 	if (new->start > other->start)  in btrfs_merge_delalloc_extent()
1891 		new_size = new->end - other->start + 1;  in btrfs_merge_delalloc_extent()
1893 		new_size = other->end - new->start + 1;  in btrfs_merge_delalloc_extent()
1897 		spin_lock(&BTRFS_I(inode)->lock);  in btrfs_merge_delalloc_extent()
1898 		btrfs_mod_outstanding_extents(BTRFS_I(inode), -1);  in btrfs_merge_delalloc_extent()
1899 		spin_unlock(&BTRFS_I(inode)->lock);  in btrfs_merge_delalloc_extent()
1921 	old_size = other->end - other->start + 1;  in btrfs_merge_delalloc_extent()
1923 	old_size = new->end - new->start + 1;  in btrfs_merge_delalloc_extent()
1928 	spin_lock(&BTRFS_I(inode)->lock);  in btrfs_merge_delalloc_extent()
1929 	btrfs_mod_outstanding_extents(BTRFS_I(inode), -1);  in btrfs_merge_delalloc_extent()
1930 	spin_unlock(&BTRFS_I(inode)->lock);  in btrfs_merge_delalloc_extent()
1936 	struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);  in btrfs_add_delalloc_inodes()
1938 	spin_lock(&root->delalloc_lock);  in btrfs_add_delalloc_inodes()
1939 	if (list_empty(&BTRFS_I(inode)->delalloc_inodes)) {  in btrfs_add_delalloc_inodes()
1940 		list_add_tail(&BTRFS_I(inode)->delalloc_inodes,  in btrfs_add_delalloc_inodes()
1941 			      &root->delalloc_inodes);  in btrfs_add_delalloc_inodes()
1943 			&BTRFS_I(inode)->runtime_flags);  in btrfs_add_delalloc_inodes()
1944 		root->nr_delalloc_inodes++;  in btrfs_add_delalloc_inodes()
1945 		if (root->nr_delalloc_inodes == 1) {  in btrfs_add_delalloc_inodes()
1946 			spin_lock(&fs_info->delalloc_root_lock);  in btrfs_add_delalloc_inodes()
1947 			BUG_ON(!list_empty(&root->delalloc_root));  in btrfs_add_delalloc_inodes()
1948 			list_add_tail(&root->delalloc_root,  in btrfs_add_delalloc_inodes()
1949 				      &fs_info->delalloc_roots);  in btrfs_add_delalloc_inodes()
1950 			spin_unlock(&fs_info->delalloc_root_lock);  in btrfs_add_delalloc_inodes()
1953 	spin_unlock(&root->delalloc_lock);  in btrfs_add_delalloc_inodes()
1960 	struct btrfs_fs_info *fs_info = root->fs_info;  in __btrfs_del_delalloc_inode()
1962 	if (!list_empty(&inode->delalloc_inodes)) {  in __btrfs_del_delalloc_inode()
1963 		list_del_init(&inode->delalloc_inodes);  in __btrfs_del_delalloc_inode()
1965 			  &inode->runtime_flags);  in __btrfs_del_delalloc_inode()
1966 		root->nr_delalloc_inodes--;  in __btrfs_del_delalloc_inode()
1967 		if (!root->nr_delalloc_inodes) {  in __btrfs_del_delalloc_inode()
1968 			ASSERT(list_empty(&root->delalloc_inodes));  in __btrfs_del_delalloc_inode()
1969 			spin_lock(&fs_info->delalloc_root_lock);  in __btrfs_del_delalloc_inode()
1970 			BUG_ON(list_empty(&root->delalloc_root));  in __btrfs_del_delalloc_inode()
1971 			list_del_init(&root->delalloc_root);  in __btrfs_del_delalloc_inode()
1972 			spin_unlock(&fs_info->delalloc_root_lock);  in __btrfs_del_delalloc_inode()
1980 	spin_lock(&root->delalloc_lock);  in btrfs_del_delalloc_inode()
1982 	spin_unlock(&root->delalloc_lock);  in btrfs_del_delalloc_inode()
1992 	struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);  in btrfs_set_delalloc_extent()
2001 	if (!(state->state & EXTENT_DELALLOC) && (*bits & EXTENT_DELALLOC)) {  in btrfs_set_delalloc_extent()
2002 		struct btrfs_root *root = BTRFS_I(inode)->root;  in btrfs_set_delalloc_extent()
2003 		u64 len = state->end + 1 - state->start;  in btrfs_set_delalloc_extent()
2007 		spin_lock(&BTRFS_I(inode)->lock);  in btrfs_set_delalloc_extent()
2009 		spin_unlock(&BTRFS_I(inode)->lock);  in btrfs_set_delalloc_extent()
2015 		percpu_counter_add_batch(&fs_info->delalloc_bytes, len,  in btrfs_set_delalloc_extent()
2016 					 fs_info->delalloc_batch);  in btrfs_set_delalloc_extent()
2017 		spin_lock(&BTRFS_I(inode)->lock);  in btrfs_set_delalloc_extent()
2018 		BTRFS_I(inode)->delalloc_bytes += len;  in btrfs_set_delalloc_extent()
2020 			BTRFS_I(inode)->defrag_bytes += len;  in btrfs_set_delalloc_extent()
2022 					 &BTRFS_I(inode)->runtime_flags))  in btrfs_set_delalloc_extent()
2024 		spin_unlock(&BTRFS_I(inode)->lock);  in btrfs_set_delalloc_extent()
2027 	if (!(state->state & EXTENT_DELALLOC_NEW) &&  in btrfs_set_delalloc_extent()
2029 		spin_lock(&BTRFS_I(inode)->lock);  in btrfs_set_delalloc_extent()
2030 		BTRFS_I(inode)->new_delalloc_bytes += state->end + 1 -  in btrfs_set_delalloc_extent()
2031 			state->start;  in btrfs_set_delalloc_extent()
2032 		spin_unlock(&BTRFS_I(inode)->lock);  in btrfs_set_delalloc_extent()
2044 	struct btrfs_fs_info *fs_info = btrfs_sb(vfs_inode->i_sb);  in btrfs_clear_delalloc_extent()
2045 	u64 len = state->end + 1 - state->start;  in btrfs_clear_delalloc_extent()
2048 	if ((state->state & EXTENT_DEFRAG) && (*bits & EXTENT_DEFRAG)) {  in btrfs_clear_delalloc_extent()
2049 		spin_lock(&inode->lock);  in btrfs_clear_delalloc_extent()
2050 		inode->defrag_bytes -= len;  in btrfs_clear_delalloc_extent()
2051 		spin_unlock(&inode->lock);  in btrfs_clear_delalloc_extent()
2059 	if ((state->state & EXTENT_DELALLOC) && (*bits & EXTENT_DELALLOC)) {  in btrfs_clear_delalloc_extent()
2060 		struct btrfs_root *root = inode->root;  in btrfs_clear_delalloc_extent()
2063 		spin_lock(&inode->lock);  in btrfs_clear_delalloc_extent()
2064 		btrfs_mod_outstanding_extents(inode, -num_extents);  in btrfs_clear_delalloc_extent()
2065 		spin_unlock(&inode->lock);  in btrfs_clear_delalloc_extent()
2073 		    root != fs_info->tree_root)  in btrfs_clear_delalloc_extent()
2080 		if (root->root_key.objectid != BTRFS_DATA_RELOC_TREE_OBJECTID &&  in btrfs_clear_delalloc_extent()
2081 		    do_list && !(state->state & EXTENT_NORESERVE) &&  in btrfs_clear_delalloc_extent()
2085 		percpu_counter_add_batch(&fs_info->delalloc_bytes, -len,  in btrfs_clear_delalloc_extent()
2086 					 fs_info->delalloc_batch);  in btrfs_clear_delalloc_extent()
2087 		spin_lock(&inode->lock);  in btrfs_clear_delalloc_extent()
2088 		inode->delalloc_bytes -= len;  in btrfs_clear_delalloc_extent()
2089 		if (do_list && inode->delalloc_bytes == 0 &&  in btrfs_clear_delalloc_extent()
2091 					&inode->runtime_flags))  in btrfs_clear_delalloc_extent()
2093 		spin_unlock(&inode->lock);  in btrfs_clear_delalloc_extent()
2096 	if ((state->state & EXTENT_DELALLOC_NEW) &&  in btrfs_clear_delalloc_extent()
2098 		spin_lock(&inode->lock);  in btrfs_clear_delalloc_extent()
2099 		ASSERT(inode->new_delalloc_bytes >= len);  in btrfs_clear_delalloc_extent()
2100 		inode->new_delalloc_bytes -= len;  in btrfs_clear_delalloc_extent()
2101 		spin_unlock(&inode->lock);  in btrfs_clear_delalloc_extent()
2106  * btrfs_bio_fits_in_stripe - Checks whether the size of the given bio will fit
2110  * @page - The page we are about to add to the bio
2111  * @size - size we want to add to the bio
2112  * @bio - bio we want to ensure is smaller than a stripe
2113  * @bio_flags - flags of the bio
2122 	struct inode *inode = page->mapping->host;  in btrfs_bio_fits_in_stripe()
2123 	struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);  in btrfs_bio_fits_in_stripe()
2124 	u64 logical = (u64)bio->bi_iter.bi_sector << 9;  in btrfs_bio_fits_in_stripe()
2133 	length = bio->bi_iter.bi_size;  in btrfs_bio_fits_in_stripe()
2171  *    c-1) if bio is issued by fsync:	sync submit
2174  *    c-2) if root is reloc root:	sync submit
2177  *    c-3) otherwise:			async submit
2183 	struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);  in btrfs_submit_data_bio()
2184 	struct btrfs_root *root = BTRFS_I(inode)->root;  in btrfs_submit_data_bio()
2188 	int async = !atomic_read(&BTRFS_I(inode)->sync_writers);  in btrfs_submit_data_bio()
2190 	skip_sum = BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM;  in btrfs_submit_data_bio()
2206 			ret = btrfs_lookup_bio_sums(inode, bio, (u64)-1, NULL);  in btrfs_submit_data_bio()
2213 		if (root->root_key.objectid == BTRFS_DATA_RELOC_TREE_OBJECTID)  in btrfs_submit_data_bio()
2230 		bio->bi_status = ret;  in btrfs_submit_data_bio()
2247 		trans->adding_csums = true;  in add_pending_csums()
2248 		ret = btrfs_csum_file_blocks(trans, trans->fs_info->csum_root, sum);  in add_pending_csums()
2249 		trans->adding_csums = false;  in add_pending_csums()
2262 	const u64 end = start + len - 1;  in btrfs_find_new_delalloc_bytes()
2265 		const u64 search_len = end - search_start + 1;  in btrfs_find_new_delalloc_bytes()
2274 		if (em->block_start != EXTENT_MAP_HOLE)  in btrfs_find_new_delalloc_bytes()
2277 		em_len = em->len;  in btrfs_find_new_delalloc_bytes()
2278 		if (em->start < search_start)  in btrfs_find_new_delalloc_bytes()
2279 			em_len -= search_start - em->start;  in btrfs_find_new_delalloc_bytes()
2283 		ret = set_extent_bit(&inode->io_tree, search_start,  in btrfs_find_new_delalloc_bytes()
2284 				     search_start + em_len - 1,  in btrfs_find_new_delalloc_bytes()
2302 	if (start >= i_size_read(&inode->vfs_inode) &&  in btrfs_set_extent_delalloc()
2303 	    !(inode->flags & BTRFS_INODE_PREALLOC)) {  in btrfs_set_extent_delalloc()
2313 						    end + 1 - start,  in btrfs_set_extent_delalloc()
2319 	return set_extent_delalloc(&inode->io_tree, start, end, extra_bits,  in btrfs_set_extent_delalloc()
2344 	page = fixup->page;  in btrfs_writepage_fixup_worker()
2345 	inode = BTRFS_I(fixup->inode);  in btrfs_writepage_fixup_worker()
2347 	page_end = page_offset(page) + PAGE_SIZE - 1;  in btrfs_writepage_fixup_worker()
2360 	 * page->mapping may go NULL, but it shouldn't be moved to a different  in btrfs_writepage_fixup_worker()
2363 	if (!page->mapping || !PageDirty(page) || !PageChecked(page)) {  in btrfs_writepage_fixup_worker()
2398 	lock_extent_bits(&inode->io_tree, page_start, page_end, &cached_state);  in btrfs_writepage_fixup_worker()
2406 		unlock_extent_cached(&inode->io_tree, page_start, page_end,  in btrfs_writepage_fixup_worker()
2433 	unlock_extent_cached(&inode->io_tree, page_start, page_end,  in btrfs_writepage_fixup_worker()
2441 		mapping_set_error(page->mapping, ret);  in btrfs_writepage_fixup_worker()
2456 	btrfs_add_delayed_iput(&inode->vfs_inode);  in btrfs_writepage_fixup_worker()
2472 	struct inode *inode = page->mapping->host;  in btrfs_writepage_cow_fixup()
2473 	struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);  in btrfs_writepage_cow_fixup()
2488 		return -EAGAIN;  in btrfs_writepage_cow_fixup()
2492 		return -EAGAIN;  in btrfs_writepage_cow_fixup()
2498 	 * page->mapping outside of the page lock.  in btrfs_writepage_cow_fixup()
2503 	btrfs_init_work(&fixup->work, btrfs_writepage_fixup_worker, NULL, NULL);  in btrfs_writepage_cow_fixup()
2504 	fixup->page = page;  in btrfs_writepage_cow_fixup()
2505 	fixup->inode = inode;  in btrfs_writepage_cow_fixup()
2506 	btrfs_queue_work(fs_info->fixup_workers, &fixup->work);  in btrfs_writepage_cow_fixup()
2508 	return -EAGAIN;  in btrfs_writepage_cow_fixup()
2516 	struct btrfs_root *root = inode->root;  in insert_reserved_file_extent()
2529 		return -ENOMEM;  in insert_reserved_file_extent()
2551 		path->leave_spinning = 1;  in insert_reserved_file_extent()
2557 	leaf = path->nodes[0];  in insert_reserved_file_extent()
2558 	btrfs_set_stack_file_extent_generation(stack_fi, trans->transid);  in insert_reserved_file_extent()
2560 			btrfs_item_ptr_offset(leaf, path->slots[0]),  in insert_reserved_file_extent()
2566 	inode_add_bytes(&inode->vfs_inode, num_bytes);  in insert_reserved_file_extent()
2592 	spin_lock(&cache->lock);  in btrfs_release_delalloc_bytes()
2593 	cache->delalloc_bytes -= len;  in btrfs_release_delalloc_bytes()
2594 	spin_unlock(&cache->lock);  in btrfs_release_delalloc_bytes()
2607 	btrfs_set_stack_file_extent_disk_bytenr(&stack_fi, oe->disk_bytenr);  in insert_ordered_extent_file_extent()
2609 						   oe->disk_num_bytes);  in insert_ordered_extent_file_extent()
2610 	if (test_bit(BTRFS_ORDERED_TRUNCATED, &oe->flags))  in insert_ordered_extent_file_extent()
2611 		logical_len = oe->truncated_len;  in insert_ordered_extent_file_extent()
2613 		logical_len = oe->num_bytes;  in insert_ordered_extent_file_extent()
2616 	btrfs_set_stack_file_extent_compression(&stack_fi, oe->compress_type);  in insert_ordered_extent_file_extent()
2619 	return insert_reserved_file_extent(trans, BTRFS_I(oe->inode),  in insert_ordered_extent_file_extent()
2620 					   oe->file_offset, &stack_fi,  in insert_ordered_extent_file_extent()
2621 					   oe->qgroup_rsv);  in insert_ordered_extent_file_extent()
2631 	struct inode *inode = ordered_extent->inode;  in btrfs_finish_ordered_io()
2632 	struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);  in btrfs_finish_ordered_io()
2633 	struct btrfs_root *root = BTRFS_I(inode)->root;  in btrfs_finish_ordered_io()
2635 	struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;  in btrfs_finish_ordered_io()
2640 	u64 logical_len = ordered_extent->num_bytes;  in btrfs_finish_ordered_io()
2648 	start = ordered_extent->file_offset;  in btrfs_finish_ordered_io()
2649 	end = start + ordered_extent->num_bytes - 1;  in btrfs_finish_ordered_io()
2651 	if (!test_bit(BTRFS_ORDERED_NOCOW, &ordered_extent->flags) &&  in btrfs_finish_ordered_io()
2652 	    !test_bit(BTRFS_ORDERED_PREALLOC, &ordered_extent->flags) &&  in btrfs_finish_ordered_io()
2653 	    !test_bit(BTRFS_ORDERED_DIRECT, &ordered_extent->flags))  in btrfs_finish_ordered_io()
2658 	if (test_bit(BTRFS_ORDERED_IOERR, &ordered_extent->flags)) {  in btrfs_finish_ordered_io()
2659 		ret = -EIO;  in btrfs_finish_ordered_io()
2665 	if (test_bit(BTRFS_ORDERED_TRUNCATED, &ordered_extent->flags)) {  in btrfs_finish_ordered_io()
2667 		logical_len = ordered_extent->truncated_len;  in btrfs_finish_ordered_io()
2673 	if (test_bit(BTRFS_ORDERED_NOCOW, &ordered_extent->flags)) {  in btrfs_finish_ordered_io()
2674 		BUG_ON(!list_empty(&ordered_extent->list)); /* Logic error */  in btrfs_finish_ordered_io()
2686 		trans->block_rsv = &BTRFS_I(inode)->block_rsv;  in btrfs_finish_ordered_io()
2688 		if (ret) /* -ENOMEM or corruption */  in btrfs_finish_ordered_io()
2706 	trans->block_rsv = &BTRFS_I(inode)->block_rsv;  in btrfs_finish_ordered_io()
2708 	if (test_bit(BTRFS_ORDERED_COMPRESSED, &ordered_extent->flags))  in btrfs_finish_ordered_io()
2709 		compress_type = ordered_extent->compress_type;  in btrfs_finish_ordered_io()
2710 	if (test_bit(BTRFS_ORDERED_PREALLOC, &ordered_extent->flags)) {  in btrfs_finish_ordered_io()
2713 						ordered_extent->file_offset,  in btrfs_finish_ordered_io()
2714 						ordered_extent->file_offset +  in btrfs_finish_ordered_io()
2717 		BUG_ON(root == fs_info->tree_root);  in btrfs_finish_ordered_io()
2722 						ordered_extent->disk_bytenr,  in btrfs_finish_ordered_io()
2723 						ordered_extent->disk_num_bytes);  in btrfs_finish_ordered_io()
2726 	unpin_extent_cache(&BTRFS_I(inode)->extent_tree,  in btrfs_finish_ordered_io()
2727 			   ordered_extent->file_offset,  in btrfs_finish_ordered_io()
2728 			   ordered_extent->num_bytes, trans->transid);  in btrfs_finish_ordered_io()
2734 	ret = add_pending_csums(trans, &ordered_extent->list);  in btrfs_finish_ordered_io()
2742 	if (ret) { /* -ENOMEM or corruption */  in btrfs_finish_ordered_io()
2753 	clear_extent_bit(&BTRFS_I(inode)->io_tree, start, end, clear_bits,  in btrfs_finish_ordered_io()
2772 					     &ordered_extent->flags))  in btrfs_finish_ordered_io()
2773 			mapping_set_error(ordered_extent->inode->i_mapping, -EIO);  in btrfs_finish_ordered_io()
2794 		    !test_bit(BTRFS_ORDERED_NOCOW, &ordered_extent->flags) &&  in btrfs_finish_ordered_io()
2795 		    !test_bit(BTRFS_ORDERED_PREALLOC, &ordered_extent->flags)) {  in btrfs_finish_ordered_io()
2802 						ordered_extent->disk_bytenr,  in btrfs_finish_ordered_io()
2803 						ordered_extent->disk_num_bytes,  in btrfs_finish_ordered_io()
2806 					ordered_extent->disk_bytenr,  in btrfs_finish_ordered_io()
2807 					ordered_extent->disk_num_bytes, 1);  in btrfs_finish_ordered_io()
2835 	struct btrfs_inode *inode = BTRFS_I(page->mapping->host);  in btrfs_writepage_endio_finish_ordered()
2836 	struct btrfs_fs_info *fs_info = inode->root->fs_info;  in btrfs_writepage_endio_finish_ordered()
2844 					    end - start + 1, uptodate))  in btrfs_writepage_endio_finish_ordered()
2848 		wq = fs_info->endio_freespace_worker;  in btrfs_writepage_endio_finish_ordered()
2850 		wq = fs_info->endio_write_workers;  in btrfs_writepage_endio_finish_ordered()
2852 	btrfs_init_work(&ordered_extent->work, finish_ordered_fn, NULL, NULL);  in btrfs_writepage_endio_finish_ordered()
2853 	btrfs_queue_work(wq, &ordered_extent->work);  in btrfs_writepage_endio_finish_ordered()
2860 	struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);  in check_data_csum()
2861 	SHASH_DESC_ON_STACK(shash, fs_info->csum_shash);  in check_data_csum()
2863 	u16 csum_size = btrfs_super_csum_size(fs_info->super_copy);  in check_data_csum()
2867 	csum_expected = ((u8 *)io_bio->csum) + icsum * csum_size;  in check_data_csum()
2870 	shash->tfm = fs_info->csum_shash;  in check_data_csum()
2881 				    io_bio->mirror_num);  in check_data_csum()
2882 	if (io_bio->device)  in check_data_csum()
2883 		btrfs_dev_stat_inc_and_print(io_bio->device,  in check_data_csum()
2888 	return -EIO;  in check_data_csum()
2899 	size_t offset = start - page_offset(page);  in btrfs_verify_data_csum()
2900 	struct inode *inode = page->mapping->host;  in btrfs_verify_data_csum()
2901 	struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;  in btrfs_verify_data_csum()
2902 	struct btrfs_root *root = BTRFS_I(inode)->root;  in btrfs_verify_data_csum()
2909 	if (BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM)  in btrfs_verify_data_csum()
2912 	if (root->root_key.objectid == BTRFS_DATA_RELOC_TREE_OBJECTID &&  in btrfs_verify_data_csum()
2918 	phy_offset >>= inode->i_sb->s_blocksize_bits;  in btrfs_verify_data_csum()
2920 			       (size_t)(end - start + 1));  in btrfs_verify_data_csum()
2924  * btrfs_add_delayed_iput - perform a delayed iput on @inode
2935 	struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);  in btrfs_add_delayed_iput()
2938 	if (atomic_add_unless(&inode->i_count, -1, 1))  in btrfs_add_delayed_iput()
2941 	atomic_inc(&fs_info->nr_delayed_iputs);  in btrfs_add_delayed_iput()
2942 	spin_lock(&fs_info->delayed_iput_lock);  in btrfs_add_delayed_iput()
2943 	ASSERT(list_empty(&binode->delayed_iput));  in btrfs_add_delayed_iput()
2944 	list_add_tail(&binode->delayed_iput, &fs_info->delayed_iputs);  in btrfs_add_delayed_iput()
2945 	spin_unlock(&fs_info->delayed_iput_lock);  in btrfs_add_delayed_iput()
2946 	if (!test_bit(BTRFS_FS_CLEANER_RUNNING, &fs_info->flags))  in btrfs_add_delayed_iput()
2947 		wake_up_process(fs_info->cleaner_kthread);  in btrfs_add_delayed_iput()
2953 	list_del_init(&inode->delayed_iput);  in run_delayed_iput_locked()
2954 	spin_unlock(&fs_info->delayed_iput_lock);  in run_delayed_iput_locked()
2955 	iput(&inode->vfs_inode);  in run_delayed_iput_locked()
2956 	if (atomic_dec_and_test(&fs_info->nr_delayed_iputs))  in run_delayed_iput_locked()
2957 		wake_up(&fs_info->delayed_iputs_wait);  in run_delayed_iput_locked()
2958 	spin_lock(&fs_info->delayed_iput_lock);  in run_delayed_iput_locked()
2964 	if (!list_empty(&inode->delayed_iput)) {  in btrfs_run_delayed_iput()
2965 		spin_lock(&fs_info->delayed_iput_lock);  in btrfs_run_delayed_iput()
2966 		if (!list_empty(&inode->delayed_iput))  in btrfs_run_delayed_iput()
2968 		spin_unlock(&fs_info->delayed_iput_lock);  in btrfs_run_delayed_iput()
2975 	spin_lock(&fs_info->delayed_iput_lock);  in btrfs_run_delayed_iputs()
2976 	while (!list_empty(&fs_info->delayed_iputs)) {  in btrfs_run_delayed_iputs()
2979 		inode = list_first_entry(&fs_info->delayed_iputs,  in btrfs_run_delayed_iputs()
2982 		cond_resched_lock(&fs_info->delayed_iput_lock);  in btrfs_run_delayed_iputs()
2984 	spin_unlock(&fs_info->delayed_iput_lock);  in btrfs_run_delayed_iputs()
2988  * btrfs_wait_on_delayed_iputs - wait on the delayed iputs to be done running
2989  * @fs_info - the fs_info for this fs
2990  * @return - EINTR if we were killed, 0 if nothing's pending
2999 	int ret = wait_event_killable(fs_info->delayed_iputs_wait,  in btrfs_wait_on_delayed_iputs()
3000 			atomic_read(&fs_info->nr_delayed_iputs) == 0);  in btrfs_wait_on_delayed_iputs()
3002 		return -EINTR;  in btrfs_wait_on_delayed_iputs()
3015 	ret = btrfs_insert_orphan_item(trans, inode->root, btrfs_ino(inode));  in btrfs_orphan_add()
3016 	if (ret && ret != -EEXIST) {  in btrfs_orphan_add()
3031 	return btrfs_del_orphan_item(trans, inode->root, btrfs_ino(inode));  in btrfs_orphan_del()
3040 	struct btrfs_fs_info *fs_info = root->fs_info;  in btrfs_orphan_cleanup()
3049 	if (cmpxchg(&root->orphan_cleanup_state, 0, ORPHAN_CLEANUP_STARTED))  in btrfs_orphan_cleanup()
3054 		ret = -ENOMEM;  in btrfs_orphan_cleanup()
3057 	path->reada = READA_BACK;  in btrfs_orphan_cleanup()
3061 	key.offset = (u64)-1;  in btrfs_orphan_cleanup()
3075 			if (path->slots[0] == 0)  in btrfs_orphan_cleanup()
3077 			path->slots[0]--;  in btrfs_orphan_cleanup()
3081 		leaf = path->nodes[0];  in btrfs_orphan_cleanup()
3082 		btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);  in btrfs_orphan_cleanup()
3102 			ret = -EINVAL;  in btrfs_orphan_cleanup()
3111 		inode = btrfs_iget(fs_info->sb, last_objectid, root);  in btrfs_orphan_cleanup()
3113 		if (ret && ret != -ENOENT)  in btrfs_orphan_cleanup()
3116 		if (ret == -ENOENT && root == fs_info->tree_root) {  in btrfs_orphan_cleanup()
3132 			spin_lock(&fs_info->fs_roots_radix_lock);  in btrfs_orphan_cleanup()
3133 			dead_root = radix_tree_lookup(&fs_info->fs_roots_radix,  in btrfs_orphan_cleanup()
3135 			if (dead_root && btrfs_root_refs(&dead_root->root_item) == 0)  in btrfs_orphan_cleanup()
3137 			spin_unlock(&fs_info->fs_roots_radix_lock);  in btrfs_orphan_cleanup()
3141 				key.offset = found_key.objectid - 1;  in btrfs_orphan_cleanup()
3157 		 * only if this filesystem was last used on a pre-v3.12 kernel  in btrfs_orphan_cleanup()
3166 		if (ret == -ENOENT || inode->i_nlink) {  in btrfs_orphan_cleanup()
3192 	root->orphan_cleanup_state = ORPHAN_CLEANUP_DONE;  in btrfs_orphan_cleanup()
3194 	if (test_bit(BTRFS_ROOT_ORPHAN_ITEM_INSERTED, &root->state)) {  in btrfs_orphan_cleanup()
3234 	*first_xattr_slot = -1;  in acls_after_inode_item()
3244 			if (*first_xattr_slot == -1)  in acls_after_inode_item()
3274 	if (*first_xattr_slot == -1)  in acls_after_inode_item()
3280  * read an inode from the btree into the in-memory inode
3285 	struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);  in btrfs_read_locked_inode()
3289 	struct btrfs_root *root = BTRFS_I(inode)->root;  in btrfs_read_locked_inode()
3305 			return -ENOMEM;  in btrfs_read_locked_inode()
3308 	memcpy(&location, &BTRFS_I(inode)->location, sizeof(location));  in btrfs_read_locked_inode()
3317 	leaf = path->nodes[0];  in btrfs_read_locked_inode()
3322 	inode_item = btrfs_item_ptr(leaf, path->slots[0],  in btrfs_read_locked_inode()
3324 	inode->i_mode = btrfs_inode_mode(leaf, inode_item);  in btrfs_read_locked_inode()
3330 			round_up(i_size_read(inode), fs_info->sectorsize));  in btrfs_read_locked_inode()
3332 	inode->i_atime.tv_sec = btrfs_timespec_sec(leaf, &inode_item->atime);  in btrfs_read_locked_inode()
3333 	inode->i_atime.tv_nsec = btrfs_timespec_nsec(leaf, &inode_item->atime);  in btrfs_read_locked_inode()
3335 	inode->i_mtime.tv_sec = btrfs_timespec_sec(leaf, &inode_item->mtime);  in btrfs_read_locked_inode()
3336 	inode->i_mtime.tv_nsec = btrfs_timespec_nsec(leaf, &inode_item->mtime);  in btrfs_read_locked_inode()
3338 	inode->i_ctime.tv_sec = btrfs_timespec_sec(leaf, &inode_item->ctime);  in btrfs_read_locked_inode()
3339 	inode->i_ctime.tv_nsec = btrfs_timespec_nsec(leaf, &inode_item->ctime);  in btrfs_read_locked_inode()
3341 	BTRFS_I(inode)->i_otime.tv_sec =  in btrfs_read_locked_inode()
3342 		btrfs_timespec_sec(leaf, &inode_item->otime);  in btrfs_read_locked_inode()
3343 	BTRFS_I(inode)->i_otime.tv_nsec =  in btrfs_read_locked_inode()
3344 		btrfs_timespec_nsec(leaf, &inode_item->otime);  in btrfs_read_locked_inode()
3347 	BTRFS_I(inode)->generation = btrfs_inode_generation(leaf, inode_item);  in btrfs_read_locked_inode()
3348 	BTRFS_I(inode)->last_trans = btrfs_inode_transid(leaf, inode_item);  in btrfs_read_locked_inode()
3352 	inode->i_generation = BTRFS_I(inode)->generation;  in btrfs_read_locked_inode()
3353 	inode->i_rdev = 0;  in btrfs_read_locked_inode()
3356 	BTRFS_I(inode)->index_cnt = (u64)-1;  in btrfs_read_locked_inode()
3357 	BTRFS_I(inode)->flags = btrfs_inode_flags(leaf, inode_item);  in btrfs_read_locked_inode()
3362 	 * and then re-read we need to do a full sync since we don't have any  in btrfs_read_locked_inode()
3366 	 * This is required for both inode re-read from disk and delayed inode  in btrfs_read_locked_inode()
3369 	if (BTRFS_I(inode)->last_trans == fs_info->generation)  in btrfs_read_locked_inode()
3371 			&BTRFS_I(inode)->runtime_flags);  in btrfs_read_locked_inode()
3381 	 * touch mydir/foo  in btrfs_read_locked_inode()
3382 	 * ln mydir/foo mydir/bar  in btrfs_read_locked_inode()
3386 	 * xfs_io -c fsync mydir/foo  in btrfs_read_locked_inode()
3390 	 * We must make sure that when we fsync our inode foo we also log its  in btrfs_read_locked_inode()
3392 	 * dentry with the "bar" name but our inode foo has a link count of 1  in btrfs_read_locked_inode()
3400 	BTRFS_I(inode)->last_unlink_trans = BTRFS_I(inode)->last_trans;  in btrfs_read_locked_inode()
3408 	BTRFS_I(inode)->last_reflink_trans = BTRFS_I(inode)->last_trans;  in btrfs_read_locked_inode()
3410 	path->slots[0]++;  in btrfs_read_locked_inode()
3411 	if (inode->i_nlink != 1 ||  in btrfs_read_locked_inode()
3412 	    path->slots[0] >= btrfs_header_nritems(leaf))  in btrfs_read_locked_inode()
3415 	btrfs_item_key_to_cpu(leaf, &location, path->slots[0]);  in btrfs_read_locked_inode()
3419 	ptr = btrfs_item_ptr_offset(leaf, path->slots[0]);  in btrfs_read_locked_inode()
3424 		BTRFS_I(inode)->dir_index = btrfs_inode_ref_index(leaf, ref);  in btrfs_read_locked_inode()
3429 		BTRFS_I(inode)->dir_index = btrfs_inode_extref_index(leaf,  in btrfs_read_locked_inode()
3437 	maybe_acls = acls_after_inode_item(leaf, path->slots[0],  in btrfs_read_locked_inode()
3439 	if (first_xattr_slot != -1) {  in btrfs_read_locked_inode()
3440 		path->slots[0] = first_xattr_slot;  in btrfs_read_locked_inode()
3446 				  root->root_key.objectid, ret);  in btrfs_read_locked_inode()
3454 	switch (inode->i_mode & S_IFMT) {  in btrfs_read_locked_inode()
3456 		inode->i_mapping->a_ops = &btrfs_aops;  in btrfs_read_locked_inode()
3457 		inode->i_fop = &btrfs_file_operations;  in btrfs_read_locked_inode()
3458 		inode->i_op = &btrfs_file_inode_operations;  in btrfs_read_locked_inode()
3461 		inode->i_fop = &btrfs_dir_file_operations;  in btrfs_read_locked_inode()
3462 		inode->i_op = &btrfs_dir_inode_operations;  in btrfs_read_locked_inode()
3465 		inode->i_op = &btrfs_symlink_inode_operations;  in btrfs_read_locked_inode()
3467 		inode->i_mapping->a_ops = &btrfs_aops;  in btrfs_read_locked_inode()
3470 		inode->i_op = &btrfs_special_inode_operations;  in btrfs_read_locked_inode()
3471 		init_special_inode(inode, inode->i_mode, rdev);  in btrfs_read_locked_inode()
3493 	btrfs_set_token_inode_size(&token, item, BTRFS_I(inode)->disk_i_size);  in fill_inode_item()
3494 	btrfs_set_token_inode_mode(&token, item, inode->i_mode);  in fill_inode_item()
3495 	btrfs_set_token_inode_nlink(&token, item, inode->i_nlink);  in fill_inode_item()
3497 	btrfs_set_token_timespec_sec(&token, &item->atime,  in fill_inode_item()
3498 				     inode->i_atime.tv_sec);  in fill_inode_item()
3499 	btrfs_set_token_timespec_nsec(&token, &item->atime,  in fill_inode_item()
3500 				      inode->i_atime.tv_nsec);  in fill_inode_item()
3502 	btrfs_set_token_timespec_sec(&token, &item->mtime,  in fill_inode_item()
3503 				     inode->i_mtime.tv_sec);  in fill_inode_item()
3504 	btrfs_set_token_timespec_nsec(&token, &item->mtime,  in fill_inode_item()
3505 				      inode->i_mtime.tv_nsec);  in fill_inode_item()
3507 	btrfs_set_token_timespec_sec(&token, &item->ctime,  in fill_inode_item()
3508 				     inode->i_ctime.tv_sec);  in fill_inode_item()
3509 	btrfs_set_token_timespec_nsec(&token, &item->ctime,  in fill_inode_item()
3510 				      inode->i_ctime.tv_nsec);  in fill_inode_item()
3512 	btrfs_set_token_timespec_sec(&token, &item->otime,  in fill_inode_item()
3513 				     BTRFS_I(inode)->i_otime.tv_sec);  in fill_inode_item()
3514 	btrfs_set_token_timespec_nsec(&token, &item->otime,  in fill_inode_item()
3515 				      BTRFS_I(inode)->i_otime.tv_nsec);  in fill_inode_item()
3519 					 BTRFS_I(inode)->generation);  in fill_inode_item()
3521 	btrfs_set_token_inode_transid(&token, item, trans->transid);  in fill_inode_item()
3522 	btrfs_set_token_inode_rdev(&token, item, inode->i_rdev);  in fill_inode_item()
3523 	btrfs_set_token_inode_flags(&token, item, BTRFS_I(inode)->flags);  in fill_inode_item()
3528  * copy everything in the in-memory inode into the btree.
3540 		return -ENOMEM;  in btrfs_update_inode_item()
3542 	path->leave_spinning = 1;  in btrfs_update_inode_item()
3543 	ret = btrfs_lookup_inode(trans, root, path, &BTRFS_I(inode)->location,  in btrfs_update_inode_item()
3547 			ret = -ENOENT;  in btrfs_update_inode_item()
3551 	leaf = path->nodes[0];  in btrfs_update_inode_item()
3552 	inode_item = btrfs_item_ptr(leaf, path->slots[0],  in btrfs_update_inode_item()
3565  * copy everything in the in-memory inode into the btree.
3570 	struct btrfs_fs_info *fs_info = root->fs_info;  in btrfs_update_inode()
3581 	    && root->root_key.objectid != BTRFS_DATA_RELOC_TREE_OBJECTID  in btrfs_update_inode()
3582 	    && !test_bit(BTRFS_FS_LOG_RECOVERING, &fs_info->flags)) {  in btrfs_update_inode()
3601 	if (ret == -ENOSPC)  in btrfs_update_inode_fallback()
3617 	struct btrfs_fs_info *fs_info = root->fs_info;  in __btrfs_unlink_inode()
3627 		ret = -ENOMEM;  in __btrfs_unlink_inode()
3631 	path->leave_spinning = 1;  in __btrfs_unlink_inode()
3633 				    name, name_len, -1);  in __btrfs_unlink_inode()
3635 		ret = di ? PTR_ERR(di) : -ENOENT;  in __btrfs_unlink_inode()
3653 	if (inode->dir_index) {  in __btrfs_unlink_inode()
3656 			index = inode->dir_index;  in __btrfs_unlink_inode()
3679 	if (ret != 0 && ret != -ENOENT) {  in __btrfs_unlink_inode()
3686 	if (ret == -ENOENT)  in __btrfs_unlink_inode()
3693 	 * being run in btrfs-cleaner context.  If we have enough of these built  in __btrfs_unlink_inode()
3694 	 * up we can end up burning a lot of time in btrfs-cleaner without any  in __btrfs_unlink_inode()
3706 	btrfs_i_size_write(dir, dir->vfs_inode.i_size - name_len * 2);  in __btrfs_unlink_inode()
3707 	inode_inc_iversion(&inode->vfs_inode);  in __btrfs_unlink_inode()
3708 	inode_inc_iversion(&dir->vfs_inode);  in __btrfs_unlink_inode()
3709 	inode->vfs_inode.i_ctime = dir->vfs_inode.i_mtime =  in __btrfs_unlink_inode()
3710 		dir->vfs_inode.i_ctime = current_time(&inode->vfs_inode);  in __btrfs_unlink_inode()
3711 	ret = btrfs_update_inode(trans, root, &dir->vfs_inode);  in __btrfs_unlink_inode()
3724 		drop_nlink(&inode->vfs_inode);  in btrfs_unlink_inode()
3725 		ret = btrfs_update_inode(trans, root, &inode->vfs_inode);  in btrfs_unlink_inode()
3740 	struct btrfs_root *root = BTRFS_I(dir)->root;  in __unlink_start_trans()
3754 	struct btrfs_root *root = BTRFS_I(dir)->root;  in btrfs_unlink()
3767 			BTRFS_I(d_inode(dentry)), dentry->d_name.name,  in btrfs_unlink()
3768 			dentry->d_name.len);  in btrfs_unlink()
3772 	if (inode->i_nlink == 0) {  in btrfs_unlink()
3780 	btrfs_btree_balance_dirty(root->fs_info);  in btrfs_unlink()
3787 	struct btrfs_root *root = BTRFS_I(dir)->root;  in btrfs_unlink_subvol()
3793 	const char *name = dentry->d_name.name;  in btrfs_unlink_subvol()
3794 	int name_len = dentry->d_name.len;  in btrfs_unlink_subvol()
3801 		objectid = inode->root->root_key.objectid;  in btrfs_unlink_subvol()
3803 		objectid = inode->location.objectid;  in btrfs_unlink_subvol()
3806 		return -EINVAL;  in btrfs_unlink_subvol()
3811 		return -ENOMEM;  in btrfs_unlink_subvol()
3814 				   name, name_len, -1);  in btrfs_unlink_subvol()
3816 		ret = di ? PTR_ERR(di) : -ENOENT;  in btrfs_unlink_subvol()
3820 	leaf = path->nodes[0];  in btrfs_unlink_subvol()
3834 	 * depending on btrfs_del_root_ref to return -ENOENT here is incorret.  in btrfs_unlink_subvol()
3844 				ret = -ENOENT;  in btrfs_unlink_subvol()
3851 		leaf = path->nodes[0];  in btrfs_unlink_subvol()
3852 		btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);  in btrfs_unlink_subvol()
3857 					 root->root_key.objectid, dir_ino,  in btrfs_unlink_subvol()
3871 	btrfs_i_size_write(BTRFS_I(dir), dir->i_size - name_len * 2);  in btrfs_unlink_subvol()
3873 	dir->i_mtime = dir->i_ctime = current_time(dir);  in btrfs_unlink_subvol()
3888 	struct btrfs_fs_info *fs_info = root->fs_info;  in may_destroy_subvol()
3897 		return -ENOMEM;  in may_destroy_subvol()
3900 	dir_id = btrfs_super_root_dir(fs_info->super_copy);  in may_destroy_subvol()
3901 	di = btrfs_lookup_dir_item(NULL, fs_info->tree_root, path,  in may_destroy_subvol()
3904 		btrfs_dir_item_key_to_cpu(path->nodes[0], di, &key);  in may_destroy_subvol()
3905 		if (key.objectid == root->root_key.objectid) {  in may_destroy_subvol()
3906 			ret = -EPERM;  in may_destroy_subvol()
3915 	key.objectid = root->root_key.objectid;  in may_destroy_subvol()
3917 	key.offset = (u64)-1;  in may_destroy_subvol()
3919 	ret = btrfs_search_slot(NULL, fs_info->tree_root, &key, path, 0, 0);  in may_destroy_subvol()
3925 	if (path->slots[0] > 0) {  in may_destroy_subvol()
3926 		path->slots[0]--;  in may_destroy_subvol()
3927 		btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]);  in may_destroy_subvol()
3928 		if (key.objectid == root->root_key.objectid &&  in may_destroy_subvol()
3930 			ret = -ENOTEMPTY;  in may_destroy_subvol()
3940 	struct btrfs_fs_info *fs_info = root->fs_info;  in btrfs_prune_dentries()
3947 	if (!test_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state))  in btrfs_prune_dentries()
3948 		WARN_ON(btrfs_root_refs(&root->root_item) != 0);  in btrfs_prune_dentries()
3950 	spin_lock(&root->inode_lock);  in btrfs_prune_dentries()
3952 	node = root->inode_tree.rb_node;  in btrfs_prune_dentries()
3959 			node = node->rb_left;  in btrfs_prune_dentries()
3961 			node = node->rb_right;  in btrfs_prune_dentries()
3978 		inode = igrab(&entry->vfs_inode);  in btrfs_prune_dentries()
3980 			spin_unlock(&root->inode_lock);  in btrfs_prune_dentries()
3981 			if (atomic_read(&inode->i_count) > 1)  in btrfs_prune_dentries()
3989 			spin_lock(&root->inode_lock);  in btrfs_prune_dentries()
3993 		if (cond_resched_lock(&root->inode_lock))  in btrfs_prune_dentries()
3998 	spin_unlock(&root->inode_lock);  in btrfs_prune_dentries()
4003 	struct btrfs_fs_info *fs_info = btrfs_sb(dentry->d_sb);  in btrfs_delete_subvolume()
4004 	struct btrfs_root *root = BTRFS_I(dir)->root;  in btrfs_delete_subvolume()
4006 	struct btrfs_root *dest = BTRFS_I(inode)->root;  in btrfs_delete_subvolume()
4018 	spin_lock(&dest->root_item_lock);  in btrfs_delete_subvolume()
4019 	if (dest->send_in_progress) {  in btrfs_delete_subvolume()
4020 		spin_unlock(&dest->root_item_lock);  in btrfs_delete_subvolume()
4023 			   dest->root_key.objectid);  in btrfs_delete_subvolume()
4024 		return -EPERM;  in btrfs_delete_subvolume()
4026 	root_flags = btrfs_root_flags(&dest->root_item);  in btrfs_delete_subvolume()
4027 	btrfs_set_root_flags(&dest->root_item,  in btrfs_delete_subvolume()
4029 	spin_unlock(&dest->root_item_lock);  in btrfs_delete_subvolume()
4031 	down_write(&fs_info->subvol_sem);  in btrfs_delete_subvolume()
4052 	trans->block_rsv = &block_rsv;  in btrfs_delete_subvolume()
4053 	trans->bytes_reserved = block_rsv.size;  in btrfs_delete_subvolume()
4066 	memset(&dest->root_item.drop_progress, 0,  in btrfs_delete_subvolume()
4067 		sizeof(dest->root_item.drop_progress));  in btrfs_delete_subvolume()
4068 	dest->root_item.drop_level = 0;  in btrfs_delete_subvolume()
4069 	btrfs_set_root_refs(&dest->root_item, 0);  in btrfs_delete_subvolume()
4071 	if (!test_and_set_bit(BTRFS_ROOT_ORPHAN_ITEM_INSERTED, &dest->state)) {  in btrfs_delete_subvolume()
4073 					fs_info->tree_root,  in btrfs_delete_subvolume()
4074 					dest->root_key.objectid);  in btrfs_delete_subvolume()
4082 	ret = btrfs_uuid_tree_remove(trans, dest->root_item.uuid,  in btrfs_delete_subvolume()
4084 				  dest->root_key.objectid);  in btrfs_delete_subvolume()
4085 	if (ret && ret != -ENOENT) {  in btrfs_delete_subvolume()
4090 	if (!btrfs_is_empty_uuid(dest->root_item.received_uuid)) {  in btrfs_delete_subvolume()
4092 					  dest->root_item.received_uuid,  in btrfs_delete_subvolume()
4094 					  dest->root_key.objectid);  in btrfs_delete_subvolume()
4095 		if (ret && ret != -ENOENT) {  in btrfs_delete_subvolume()
4102 	free_anon_bdev(dest->anon_dev);  in btrfs_delete_subvolume()
4103 	dest->anon_dev = 0;  in btrfs_delete_subvolume()
4105 	trans->block_rsv = NULL;  in btrfs_delete_subvolume()
4106 	trans->bytes_reserved = 0;  in btrfs_delete_subvolume()
4110 	inode->i_flags |= S_DEAD;  in btrfs_delete_subvolume()
4114 	up_write(&fs_info->subvol_sem);  in btrfs_delete_subvolume()
4116 		spin_lock(&dest->root_item_lock);  in btrfs_delete_subvolume()
4117 		root_flags = btrfs_root_flags(&dest->root_item);  in btrfs_delete_subvolume()
4118 		btrfs_set_root_flags(&dest->root_item,  in btrfs_delete_subvolume()
4120 		spin_unlock(&dest->root_item_lock);  in btrfs_delete_subvolume()
4124 		ASSERT(dest->send_in_progress == 0);  in btrfs_delete_subvolume()
4127 		if (dest->ino_cache_inode) {  in btrfs_delete_subvolume()
4128 			iput(dest->ino_cache_inode);  in btrfs_delete_subvolume()
4129 			dest->ino_cache_inode = NULL;  in btrfs_delete_subvolume()
4140 	struct btrfs_root *root = BTRFS_I(dir)->root;  in btrfs_rmdir()
4144 	if (inode->i_size > BTRFS_EMPTY_DIR_SIZE)  in btrfs_rmdir()
4145 		return -ENOTEMPTY;  in btrfs_rmdir()
4162 	last_unlink_trans = BTRFS_I(inode)->last_unlink_trans;  in btrfs_rmdir()
4166 			BTRFS_I(d_inode(dentry)), dentry->d_name.name,  in btrfs_rmdir()
4167 			dentry->d_name.len);  in btrfs_rmdir()
4174 		 * 1) create dir foo  in btrfs_rmdir()
4175 		 * 2) create snapshot under dir foo  in btrfs_rmdir()
4177 		 * 4) rmdir foo  in btrfs_rmdir()
4178 		 * 5) mkdir foo  in btrfs_rmdir()
4179 		 * 6) fsync foo or some file inside foo  in btrfs_rmdir()
4181 		if (last_unlink_trans >= trans->transid)  in btrfs_rmdir()
4182 			BTRFS_I(dir)->last_unlink_trans = last_unlink_trans;  in btrfs_rmdir()
4186 	btrfs_btree_balance_dirty(root->fs_info);  in btrfs_rmdir()
4213 	struct btrfs_fs_info *fs_info = root->fs_info;  in btrfs_truncate_inode_items()
4224 	u32 found_type = (u8)-1;  in btrfs_truncate_inode_items()
4229 	int extent_type = -1;  in btrfs_truncate_inode_items()
4235 	const u64 lock_start = ALIGN_DOWN(new_size, fs_info->sectorsize);  in btrfs_truncate_inode_items()
4241 	 * For non-free space inodes and non-shareable roots, we want to back  in btrfs_truncate_inode_items()
4246 	    test_bit(BTRFS_ROOT_SHAREABLE, &root->state))  in btrfs_truncate_inode_items()
4251 		return -ENOMEM;  in btrfs_truncate_inode_items()
4252 	path->reada = READA_BACK;  in btrfs_truncate_inode_items()
4254 	if (root->root_key.objectid != BTRFS_TREE_LOG_OBJECTID) {  in btrfs_truncate_inode_items()
4255 		lock_extent_bits(&BTRFS_I(inode)->io_tree, lock_start, (u64)-1,  in btrfs_truncate_inode_items()
4264 					fs_info->sectorsize),  in btrfs_truncate_inode_items()
4265 					(u64)-1, 0);  in btrfs_truncate_inode_items()
4270 	 * we relog the inode, so if root != BTRFS_I(inode)->root, it means  in btrfs_truncate_inode_items()
4274 	if (min_type == 0 && root == BTRFS_I(inode)->root)  in btrfs_truncate_inode_items()
4278 	key.offset = (u64)-1;  in btrfs_truncate_inode_items()
4279 	key.type = (u8)-1;  in btrfs_truncate_inode_items()
4283 	 * with a 16K leaf size and 128MB extents, you can actually queue  in btrfs_truncate_inode_items()
4289 		ret = -EAGAIN;  in btrfs_truncate_inode_items()
4293 	ret = btrfs_search_slot(trans, root, &key, path, -1, 1);  in btrfs_truncate_inode_items()
4302 		if (path->slots[0] == 0)  in btrfs_truncate_inode_items()
4304 		path->slots[0]--;  in btrfs_truncate_inode_items()
4311 		leaf = path->nodes[0];  in btrfs_truncate_inode_items()
4312 		btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);  in btrfs_truncate_inode_items()
4323 			fi = btrfs_item_ptr(leaf, path->slots[0],  in btrfs_truncate_inode_items()
4338 					BTRFS_I(inode), leaf, fi, path->slots[0],  in btrfs_truncate_inode_items()
4341 			item_end--;  in btrfs_truncate_inode_items()
4366 				extent_num_bytes = ALIGN(new_size -  in btrfs_truncate_inode_items()
4368 						fs_info->sectorsize);  in btrfs_truncate_inode_items()
4369 				clear_start = ALIGN(new_size, fs_info->sectorsize);  in btrfs_truncate_inode_items()
4372 				num_dec = (orig_num_bytes -  in btrfs_truncate_inode_items()
4375 					     &root->state) &&  in btrfs_truncate_inode_items()
4383 				extent_offset = found_key.offset -  in btrfs_truncate_inode_items()
4391 						     &root->state))  in btrfs_truncate_inode_items()
4405 				u32 size = (u32)(new_size - found_key.offset);  in btrfs_truncate_inode_items()
4423 				clear_len = fs_info->sectorsize;  in btrfs_truncate_inode_items()
4426 			if (test_bit(BTRFS_ROOT_SHAREABLE, &root->state))  in btrfs_truncate_inode_items()
4427 				inode_sub_bytes(inode, item_end + 1 - new_size);  in btrfs_truncate_inode_items()
4435 		if (root == BTRFS_I(inode)->root) {  in btrfs_truncate_inode_items()
4451 				pending_del_slot = path->slots[0];  in btrfs_truncate_inode_items()
4454 				   path->slots[0] + 1 == pending_del_slot) {  in btrfs_truncate_inode_items()
4457 				pending_del_slot = path->slots[0];  in btrfs_truncate_inode_items()
4467 		    root->root_key.objectid != BTRFS_TREE_LOG_OBJECTID) {  in btrfs_truncate_inode_items()
4474 			ref.real_root = root->root_key.objectid;  in btrfs_truncate_inode_items()
4491 		if (path->slots[0] == 0 ||  in btrfs_truncate_inode_items()
4492 		    path->slots[0] != pending_del_slot ||  in btrfs_truncate_inode_items()
4520 					ret = -EAGAIN;  in btrfs_truncate_inode_items()
4526 			path->slots[0]--;  in btrfs_truncate_inode_items()
4540 	if (root->root_key.objectid != BTRFS_TREE_LOG_OBJECTID) {  in btrfs_truncate_inode_items()
4545 		unlock_extent_cached(&BTRFS_I(inode)->io_tree, lock_start,  in btrfs_truncate_inode_items()
4546 				     (u64)-1, &cached_state);  in btrfs_truncate_inode_items()
4554  * btrfs_truncate_block - read, zero a chunk and write a block
4555  * @inode - inode that we're zeroing
4556  * @from - the offset to start zeroing
4557  * @len - the length to zero, 0 to zero the entire range respective to the
4559  * @front - zero up to the offset instead of from the offset on
4567 	struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);  in btrfs_truncate_block()
4568 	struct address_space *mapping = inode->i_mapping;  in btrfs_truncate_block()
4569 	struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;  in btrfs_truncate_block()
4575 	u32 blocksize = fs_info->sectorsize;  in btrfs_truncate_block()
4577 	unsigned offset = from & (blocksize - 1);  in btrfs_truncate_block()
4590 	block_end = block_start + blocksize - 1;  in btrfs_truncate_block()
4616 		ret = -ENOMEM;  in btrfs_truncate_block()
4623 		if (page->mapping != mapping) {  in btrfs_truncate_block()
4629 			ret = -EIO;  in btrfs_truncate_block()
4649 	clear_extent_bit(&BTRFS_I(inode)->io_tree, block_start, block_end,  in btrfs_truncate_block()
4663 			len = blocksize - offset;  in btrfs_truncate_block()
4666 			memset(kaddr + (block_start - page_offset(page)),  in btrfs_truncate_block()
4669 			memset(kaddr + (block_start - page_offset(page)) +  offset,  in btrfs_truncate_block()
4679 		set_extent_bit(&BTRFS_I(inode)->io_tree, block_start,  in btrfs_truncate_block()
4705 	struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);  in maybe_insert_hole()
4714 		BTRFS_I(inode)->last_trans = fs_info->generation;  in maybe_insert_hole()
4715 		BTRFS_I(inode)->last_sub_trans = root->log_transid;  in maybe_insert_hole()
4716 		BTRFS_I(inode)->last_log_commit = root->last_log_commit;  in maybe_insert_hole()
4721 	 * 1 - for the one we're dropping  in maybe_insert_hole()
4722 	 * 1 - for the one we're adding  in maybe_insert_hole()
4723 	 * 1 - for updating the inode.  in maybe_insert_hole()
4754 	struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);  in btrfs_cont_expand()
4755 	struct btrfs_root *root = BTRFS_I(inode)->root;  in btrfs_cont_expand()
4756 	struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;  in btrfs_cont_expand()
4759 	struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;  in btrfs_cont_expand()
4760 	u64 hole_start = ALIGN(oldsize, fs_info->sectorsize);  in btrfs_cont_expand()
4761 	u64 block_end = ALIGN(size, fs_info->sectorsize);  in btrfs_cont_expand()
4780 					   block_end - 1, &cached_state);  in btrfs_cont_expand()
4784 				      block_end - cur_offset);  in btrfs_cont_expand()
4791 		last_byte = ALIGN(last_byte, fs_info->sectorsize);  in btrfs_cont_expand()
4792 		hole_size = last_byte - cur_offset;  in btrfs_cont_expand()
4794 		if (!test_bit(EXTENT_FLAG_PREALLOC, &em->flags)) {  in btrfs_cont_expand()
4808 						cur_offset + hole_size - 1, 0);  in btrfs_cont_expand()
4812 					&BTRFS_I(inode)->runtime_flags);  in btrfs_cont_expand()
4815 			hole_em->start = cur_offset;  in btrfs_cont_expand()
4816 			hole_em->len = hole_size;  in btrfs_cont_expand()
4817 			hole_em->orig_start = cur_offset;  in btrfs_cont_expand()
4819 			hole_em->block_start = EXTENT_MAP_HOLE;  in btrfs_cont_expand()
4820 			hole_em->block_len = 0;  in btrfs_cont_expand()
4821 			hole_em->orig_block_len = 0;  in btrfs_cont_expand()
4822 			hole_em->ram_bytes = hole_size;  in btrfs_cont_expand()
4823 			hole_em->compress_type = BTRFS_COMPRESS_NONE;  in btrfs_cont_expand()
4824 			hole_em->generation = fs_info->generation;  in btrfs_cont_expand()
4827 				write_lock(&em_tree->lock);  in btrfs_cont_expand()
4829 				write_unlock(&em_tree->lock);  in btrfs_cont_expand()
4830 				if (err != -EEXIST)  in btrfs_cont_expand()
4835 							hole_size - 1, 0);  in btrfs_cont_expand()
4852 	unlock_extent_cached(io_tree, hole_start, block_end - 1, &cached_state);  in btrfs_cont_expand()
4858 	struct btrfs_root *root = BTRFS_I(inode)->root;  in btrfs_setsize()
4861 	loff_t newsize = attr->ia_size;  in btrfs_setsize()
4862 	int mask = attr->ia_valid;  in btrfs_setsize()
4874 			inode->i_ctime = inode->i_mtime =  in btrfs_setsize()
4882 		 * state of this file - if the snapshot captures this expanding  in btrfs_setsize()
4886 		btrfs_drew_write_lock(&root->snapshot_lock);  in btrfs_setsize()
4889 			btrfs_drew_write_unlock(&root->snapshot_lock);  in btrfs_setsize()
4895 			btrfs_drew_write_unlock(&root->snapshot_lock);  in btrfs_setsize()
4903 		btrfs_drew_write_unlock(&root->snapshot_lock);  in btrfs_setsize()
4914 				&BTRFS_I(inode)->runtime_flags);  in btrfs_setsize()
4921 		if (ret && inode->i_nlink) {  in btrfs_setsize()
4925 			 * Truncate failed, so fix up the in-memory size. We  in btrfs_setsize()
4928 			 * in-memory size to match.  in btrfs_setsize()
4930 			err = btrfs_wait_ordered_range(inode, 0, (u64)-1);  in btrfs_setsize()
4933 			i_size_write(inode, BTRFS_I(inode)->disk_i_size);  in btrfs_setsize()
4943 	struct btrfs_root *root = BTRFS_I(inode)->root;  in btrfs_setattr()
4947 		return -EROFS;  in btrfs_setattr()
4953 	if (S_ISREG(inode->i_mode) && (attr->ia_valid & ATTR_SIZE)) {  in btrfs_setattr()
4959 	if (attr->ia_valid) {  in btrfs_setattr()
4964 		if (!err && attr->ia_valid & ATTR_MODE)  in btrfs_setattr()
4965 			err = posix_acl_chmod(inode, inode->i_mode);  in btrfs_setattr()
4985 	struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;  in evict_inode_truncate_pages()
4986 	struct extent_map_tree *map_tree = &BTRFS_I(inode)->extent_tree;  in evict_inode_truncate_pages()
4989 	ASSERT(inode->i_state & I_FREEING);  in evict_inode_truncate_pages()
4990 	truncate_inode_pages_final(&inode->i_data);  in evict_inode_truncate_pages()
4992 	write_lock(&map_tree->lock);  in evict_inode_truncate_pages()
4993 	while (!RB_EMPTY_ROOT(&map_tree->map.rb_root)) {  in evict_inode_truncate_pages()
4996 		node = rb_first_cached(&map_tree->map);  in evict_inode_truncate_pages()
4998 		clear_bit(EXTENT_FLAG_PINNED, &em->flags);  in evict_inode_truncate_pages()
4999 		clear_bit(EXTENT_FLAG_LOGGING, &em->flags);  in evict_inode_truncate_pages()
5003 			write_unlock(&map_tree->lock);  in evict_inode_truncate_pages()
5005 			write_lock(&map_tree->lock);  in evict_inode_truncate_pages()
5008 	write_unlock(&map_tree->lock);  in evict_inode_truncate_pages()
5018 	 * queue kthread), inode references (inode->i_count) were not taken  in evict_inode_truncate_pages()
5022 	 * reference count - if we don't do it, when they access the inode's  in evict_inode_truncate_pages()
5024 	 * use-after-free issue.  in evict_inode_truncate_pages()
5026 	spin_lock(&io_tree->lock);  in evict_inode_truncate_pages()
5027 	while (!RB_EMPTY_ROOT(&io_tree->state)) {  in evict_inode_truncate_pages()
5034 		node = rb_first(&io_tree->state);  in evict_inode_truncate_pages()
5036 		start = state->start;  in evict_inode_truncate_pages()
5037 		end = state->end;  in evict_inode_truncate_pages()
5038 		state_flags = state->state;  in evict_inode_truncate_pages()
5039 		spin_unlock(&io_tree->lock);  in evict_inode_truncate_pages()
5053 					       end - start + 1);  in evict_inode_truncate_pages()
5061 		spin_lock(&io_tree->lock);  in evict_inode_truncate_pages()
5063 	spin_unlock(&io_tree->lock);  in evict_inode_truncate_pages()
5069 	struct btrfs_fs_info *fs_info = root->fs_info;  in evict_refill_and_join()
5070 	struct btrfs_block_rsv *global_rsv = &fs_info->global_block_rsv;  in evict_refill_and_join()
5088 	ret = btrfs_block_rsv_refill(root, rsv, rsv->size + delayed_refs_extra,  in evict_refill_and_join()
5096 		    btrfs_block_rsv_migrate(global_rsv, rsv, rsv->size, 0)) {  in evict_refill_and_join()
5099 			return ERR_PTR(-ENOSPC);  in evict_refill_and_join()
5109 		trans->block_rsv = &fs_info->trans_block_rsv;  in evict_refill_and_join()
5110 		trans->bytes_reserved = delayed_refs_extra;  in evict_refill_and_join()
5111 		btrfs_block_rsv_migrate(rsv, trans->block_rsv,  in evict_refill_and_join()
5119 	struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);  in btrfs_evict_inode()
5121 	struct btrfs_root *root = BTRFS_I(inode)->root;  in btrfs_evict_inode()
5134 	if (inode->i_nlink &&  in btrfs_evict_inode()
5135 	    ((btrfs_root_refs(&root->root_item) != 0 &&  in btrfs_evict_inode()
5136 	      root->root_key.objectid != BTRFS_ROOT_TREE_OBJECTID) ||  in btrfs_evict_inode()
5143 	btrfs_free_io_failure_record(BTRFS_I(inode), 0, (u64)-1);  in btrfs_evict_inode()
5145 	if (test_bit(BTRFS_FS_LOG_RECOVERING, &fs_info->flags))  in btrfs_evict_inode()
5148 	if (inode->i_nlink > 0) {  in btrfs_evict_inode()
5149 		BUG_ON(btrfs_root_refs(&root->root_item) != 0 &&  in btrfs_evict_inode()
5150 		       root->root_key.objectid != BTRFS_ROOT_TREE_OBJECTID);  in btrfs_evict_inode()
5161 	rsv->size = btrfs_calc_metadata_size(fs_info, 1);  in btrfs_evict_inode()
5162 	rsv->failfast = 1;  in btrfs_evict_inode()
5171 		trans->block_rsv = rsv;  in btrfs_evict_inode()
5174 		trans->block_rsv = &fs_info->trans_block_rsv;  in btrfs_evict_inode()
5177 		if (ret && ret != -ENOSPC && ret != -EAGAIN)  in btrfs_evict_inode()
5194 		trans->block_rsv = rsv;  in btrfs_evict_inode()
5196 		trans->block_rsv = &fs_info->trans_block_rsv;  in btrfs_evict_inode()
5200 	if (!(root == fs_info->tree_root ||  in btrfs_evict_inode()
5201 	      root->root_key.objectid == BTRFS_TREE_RELOC_OBJECTID))  in btrfs_evict_inode()
5220  * If no dir entries were found, returns -ENOENT.
5221  * If found a corrupted location in dir entry, returns -EUCLEAN.
5226 	const char *name = dentry->d_name.name;  in btrfs_inode_by_name()
5227 	int namelen = dentry->d_name.len;  in btrfs_inode_by_name()
5230 	struct btrfs_root *root = BTRFS_I(dir)->root;  in btrfs_inode_by_name()
5235 		return -ENOMEM;  in btrfs_inode_by_name()
5240 		ret = di ? PTR_ERR(di) : -ENOENT;  in btrfs_inode_by_name()
5244 	btrfs_dir_item_key_to_cpu(path->nodes[0], di, location);  in btrfs_inode_by_name()
5245 	if (location->type != BTRFS_INODE_ITEM_KEY &&  in btrfs_inode_by_name()
5246 	    location->type != BTRFS_ROOT_ITEM_KEY) {  in btrfs_inode_by_name()
5247 		ret = -EUCLEAN;  in btrfs_inode_by_name()
5248 		btrfs_warn(root->fs_info,  in btrfs_inode_by_name()
5251 			   location->objectid, location->type, location->offset);  in btrfs_inode_by_name()
5254 		*type = btrfs_dir_type(path->nodes[0], di);  in btrfs_inode_by_name()
5281 		err = -ENOMEM;  in fixup_tree_root_location()
5285 	err = -ENOENT;  in fixup_tree_root_location()
5286 	key.objectid = BTRFS_I(dir)->root->root_key.objectid;  in fixup_tree_root_location()
5288 	key.offset = location->objectid;  in fixup_tree_root_location()
5290 	ret = btrfs_search_slot(NULL, fs_info->tree_root, &key, path, 0, 0);  in fixup_tree_root_location()
5297 	leaf = path->nodes[0];  in fixup_tree_root_location()
5298 	ref = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_root_ref);  in fixup_tree_root_location()
5300 	    btrfs_root_ref_name_len(leaf, ref) != dentry->d_name.len)  in fixup_tree_root_location()
5303 	ret = memcmp_extent_buffer(leaf, dentry->d_name.name,  in fixup_tree_root_location()
5305 				   dentry->d_name.len);  in fixup_tree_root_location()
5311 	new_root = btrfs_get_fs_root(fs_info, location->objectid, true);  in fixup_tree_root_location()
5318 	location->objectid = btrfs_root_dirid(&new_root->root_item);  in fixup_tree_root_location()
5319 	location->type = BTRFS_INODE_ITEM_KEY;  in fixup_tree_root_location()
5320 	location->offset = 0;  in fixup_tree_root_location()
5329 	struct btrfs_root *root = BTRFS_I(inode)->root;  in inode_tree_add()
5333 	struct rb_node *new = &BTRFS_I(inode)->rb_node;  in inode_tree_add()
5339 	spin_lock(&root->inode_lock);  in inode_tree_add()
5340 	p = &root->inode_tree.rb_node;  in inode_tree_add()
5346 			p = &parent->rb_left;  in inode_tree_add()
5348 			p = &parent->rb_right;  in inode_tree_add()
5350 			WARN_ON(!(entry->vfs_inode.i_state &  in inode_tree_add()
5352 			rb_replace_node(parent, new, &root->inode_tree);  in inode_tree_add()
5354 			spin_unlock(&root->inode_lock);  in inode_tree_add()
5359 	rb_insert_color(new, &root->inode_tree);  in inode_tree_add()
5360 	spin_unlock(&root->inode_lock);  in inode_tree_add()
5365 	struct btrfs_root *root = inode->root;  in inode_tree_del()
5368 	spin_lock(&root->inode_lock);  in inode_tree_del()
5369 	if (!RB_EMPTY_NODE(&inode->rb_node)) {  in inode_tree_del()
5370 		rb_erase(&inode->rb_node, &root->inode_tree);  in inode_tree_del()
5371 		RB_CLEAR_NODE(&inode->rb_node);  in inode_tree_del()
5372 		empty = RB_EMPTY_ROOT(&root->inode_tree);  in inode_tree_del()
5374 	spin_unlock(&root->inode_lock);  in inode_tree_del()
5376 	if (empty && btrfs_root_refs(&root->root_item) == 0) {  in inode_tree_del()
5377 		spin_lock(&root->inode_lock);  in inode_tree_del()
5378 		empty = RB_EMPTY_ROOT(&root->inode_tree);  in inode_tree_del()
5379 		spin_unlock(&root->inode_lock);  in inode_tree_del()
5390 	inode->i_ino = args->ino;  in btrfs_init_locked_inode()
5391 	BTRFS_I(inode)->location.objectid = args->ino;  in btrfs_init_locked_inode()
5392 	BTRFS_I(inode)->location.type = BTRFS_INODE_ITEM_KEY;  in btrfs_init_locked_inode()
5393 	BTRFS_I(inode)->location.offset = 0;  in btrfs_init_locked_inode()
5394 	BTRFS_I(inode)->root = btrfs_grab_root(args->root);  in btrfs_init_locked_inode()
5395 	BUG_ON(args->root && !BTRFS_I(inode)->root);  in btrfs_init_locked_inode()
5403 	return args->ino == BTRFS_I(inode)->location.objectid &&  in btrfs_find_actor()
5404 		args->root == BTRFS_I(inode)->root;  in btrfs_find_actor()
5436 		return ERR_PTR(-ENOMEM);  in btrfs_iget_path()
5438 	if (inode->i_state & I_NEW) {  in btrfs_iget_path()
5453 				ret = -ENOENT;  in btrfs_iget_path()
5473 		return ERR_PTR(-ENOMEM);  in new_simple_dir()
5475 	BTRFS_I(inode)->root = btrfs_grab_root(root);  in new_simple_dir()
5476 	memcpy(&BTRFS_I(inode)->location, key, sizeof(*key));  in new_simple_dir()
5477 	set_bit(BTRFS_INODE_DUMMY, &BTRFS_I(inode)->runtime_flags);  in new_simple_dir()
5479 	inode->i_ino = BTRFS_EMPTY_SUBVOL_DIR_OBJECTID;  in new_simple_dir()
5481 	 * We only need lookup, the rest is read-only and there's no inode  in new_simple_dir()
5484 	inode->i_op = &simple_dir_inode_operations;  in new_simple_dir()
5485 	inode->i_opflags &= ~IOP_XATTR;  in new_simple_dir()
5486 	inode->i_fop = &simple_dir_operations;  in new_simple_dir()
5487 	inode->i_mode = S_IFDIR | S_IRUGO | S_IWUSR | S_IXUGO;  in new_simple_dir()
5488 	inode->i_mtime = current_time(inode);  in new_simple_dir()
5489 	inode->i_atime = inode->i_mtime;  in new_simple_dir()
5490 	inode->i_ctime = inode->i_mtime;  in new_simple_dir()
5491 	BTRFS_I(inode)->i_otime = inode->i_mtime;  in new_simple_dir()
5499 	 * Compile-time asserts that generic FT_* types still match  in btrfs_inode_type()
5511 	return fs_umode_to_ftype(inode->i_mode);  in btrfs_inode_type()
5516 	struct btrfs_fs_info *fs_info = btrfs_sb(dir->i_sb);  in btrfs_lookup_dentry()
5518 	struct btrfs_root *root = BTRFS_I(dir)->root;  in btrfs_lookup_dentry()
5524 	if (dentry->d_name.len > BTRFS_NAME_LEN)  in btrfs_lookup_dentry()
5525 		return ERR_PTR(-ENAMETOOLONG);  in btrfs_lookup_dentry()
5532 		inode = btrfs_iget(dir->i_sb, location.objectid, root);  in btrfs_lookup_dentry()
5540 				  inode->i_mode, btrfs_inode_type(inode),  in btrfs_lookup_dentry()
5543 			return ERR_PTR(-EUCLEAN);  in btrfs_lookup_dentry()
5551 		if (ret != -ENOENT)  in btrfs_lookup_dentry()
5554 			inode = new_simple_dir(dir->i_sb, &location, sub_root);  in btrfs_lookup_dentry()
5556 		inode = btrfs_iget(dir->i_sb, location.objectid, sub_root);  in btrfs_lookup_dentry()
5562 		down_read(&fs_info->cleanup_work_sem);  in btrfs_lookup_dentry()
5563 		if (!sb_rdonly(inode->i_sb))  in btrfs_lookup_dentry()
5565 		up_read(&fs_info->cleanup_work_sem);  in btrfs_lookup_dentry()
5581 		inode = d_inode(dentry->d_parent);  in btrfs_dentry_delete()
5584 		root = BTRFS_I(inode)->root;  in btrfs_dentry_delete()
5585 		if (btrfs_root_refs(&root->root_item) == 0)  in btrfs_dentry_delete()
5599 	if (inode == ERR_PTR(-ENOENT))  in btrfs_lookup()
5619 		return -ENOMEM;  in btrfs_opendir()
5620 	private->filldir_buf = kzalloc(PAGE_SIZE, GFP_KERNEL);  in btrfs_opendir()
5621 	if (!private->filldir_buf) {  in btrfs_opendir()
5623 		return -ENOMEM;  in btrfs_opendir()
5625 	file->private_data = private;  in btrfs_opendir()
5638 	while (entries--) {  in btrfs_filldir()
5642 		ctx->pos = get_unaligned(&entry->offset);  in btrfs_filldir()
5643 		if (!dir_emit(ctx, name, get_unaligned(&entry->name_len),  in btrfs_filldir()
5644 					 get_unaligned(&entry->ino),  in btrfs_filldir()
5645 					 get_unaligned(&entry->type)))  in btrfs_filldir()
5648 			get_unaligned(&entry->name_len);  in btrfs_filldir()
5649 		ctx->pos++;  in btrfs_filldir()
5657 	struct btrfs_root *root = BTRFS_I(inode)->root;  in btrfs_real_readdir()
5658 	struct btrfs_file_private *private = file->private_data;  in btrfs_real_readdir()
5681 		return -ENOMEM;  in btrfs_real_readdir()
5683 	addr = private->filldir_buf;  in btrfs_real_readdir()
5684 	path->reada = READA_FORWARD;  in btrfs_real_readdir()
5692 	key.offset = ctx->pos;  in btrfs_real_readdir()
5702 		leaf = path->nodes[0];  in btrfs_real_readdir()
5703 		slot = path->slots[0];  in btrfs_real_readdir()
5719 		if (found_key.offset < ctx->pos)  in btrfs_real_readdir()
5728 			ret = btrfs_filldir(private->filldir_buf, entries, ctx);  in btrfs_real_readdir()
5731 			addr = private->filldir_buf;  in btrfs_real_readdir()
5738 		put_unaligned(name_len, &entry->name_len);  in btrfs_real_readdir()
5743 				&entry->type);  in btrfs_real_readdir()
5745 		put_unaligned(location.objectid, &entry->ino);  in btrfs_real_readdir()
5746 		put_unaligned(found_key.offset, &entry->offset);  in btrfs_real_readdir()
5751 		path->slots[0]++;  in btrfs_real_readdir()
5755 	ret = btrfs_filldir(private->filldir_buf, entries, ctx);  in btrfs_real_readdir()
5771 	 * they're returned by readdir.  Until we re-use freed offsets  in btrfs_real_readdir()
5780 	if (ctx->pos >= INT_MAX)  in btrfs_real_readdir()
5781 		ctx->pos = LLONG_MAX;  in btrfs_real_readdir()
5783 		ctx->pos = INT_MAX;  in btrfs_real_readdir()
5801 	struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);  in btrfs_dirty_inode()
5802 	struct btrfs_root *root = BTRFS_I(inode)->root;  in btrfs_dirty_inode()
5806 	if (test_bit(BTRFS_INODE_DUMMY, &BTRFS_I(inode)->runtime_flags))  in btrfs_dirty_inode()
5814 	if (ret && (ret == -ENOSPC || ret == -EDQUOT)) {  in btrfs_dirty_inode()
5824 	if (BTRFS_I(inode)->delayed_node)  in btrfs_dirty_inode()
5837 	struct btrfs_root *root = BTRFS_I(inode)->root;  in btrfs_update_time()
5841 		return -EROFS;  in btrfs_update_time()
5846 		inode->i_ctime = *now;  in btrfs_update_time()
5848 		inode->i_mtime = *now;  in btrfs_update_time()
5850 		inode->i_atime = *now;  in btrfs_update_time()
5856  * and then set the in-memory index_cnt variable to reflect
5861 	struct btrfs_root *root = inode->root;  in btrfs_set_inode_index_count()
5869 	key.offset = (u64)-1;  in btrfs_set_inode_index_count()
5873 		return -ENOMEM;  in btrfs_set_inode_index_count()
5889 	if (path->slots[0] == 0) {  in btrfs_set_inode_index_count()
5890 		inode->index_cnt = 2;  in btrfs_set_inode_index_count()
5894 	path->slots[0]--;  in btrfs_set_inode_index_count()
5896 	leaf = path->nodes[0];  in btrfs_set_inode_index_count()
5897 	btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);  in btrfs_set_inode_index_count()
5901 		inode->index_cnt = 2;  in btrfs_set_inode_index_count()
5905 	inode->index_cnt = found_key.offset + 1;  in btrfs_set_inode_index_count()
5919 	if (dir->index_cnt == (u64)-1) {  in btrfs_set_inode_index()
5928 	*index = dir->index_cnt;  in btrfs_set_inode_index()
5929 	dir->index_cnt++;  in btrfs_set_inode_index()
5938 	args.ino = BTRFS_I(inode)->location.objectid;  in btrfs_insert_inode_locked()
5939 	args.root = BTRFS_I(inode)->root;  in btrfs_insert_inode_locked()
5942 		   btrfs_inode_hash(inode->i_ino, BTRFS_I(inode)->root),  in btrfs_insert_inode_locked()
5958 	flags = BTRFS_I(dir)->flags;  in btrfs_inherit_iflags()
5961 		BTRFS_I(inode)->flags &= ~BTRFS_INODE_COMPRESS;  in btrfs_inherit_iflags()
5962 		BTRFS_I(inode)->flags |= BTRFS_INODE_NOCOMPRESS;  in btrfs_inherit_iflags()
5964 		BTRFS_I(inode)->flags &= ~BTRFS_INODE_NOCOMPRESS;  in btrfs_inherit_iflags()
5965 		BTRFS_I(inode)->flags |= BTRFS_INODE_COMPRESS;  in btrfs_inherit_iflags()
5969 		BTRFS_I(inode)->flags |= BTRFS_INODE_NODATACOW;  in btrfs_inherit_iflags()
5970 		if (S_ISREG(inode->i_mode))  in btrfs_inherit_iflags()
5971 			BTRFS_I(inode)->flags |= BTRFS_INODE_NODATASUM;  in btrfs_inherit_iflags()
5984 	struct btrfs_fs_info *fs_info = root->fs_info;  in btrfs_new_inode()
5999 		return ERR_PTR(-ENOMEM);  in btrfs_new_inode()
6002 	inode = new_inode(fs_info->sb);  in btrfs_new_inode()
6006 		return ERR_PTR(-ENOMEM);  in btrfs_new_inode()
6020 	inode->i_ino = objectid;  in btrfs_new_inode()
6039 	BTRFS_I(inode)->index_cnt = 2;  in btrfs_new_inode()
6040 	BTRFS_I(inode)->dir_index = *index;  in btrfs_new_inode()
6041 	BTRFS_I(inode)->root = btrfs_grab_root(root);  in btrfs_new_inode()
6042 	BTRFS_I(inode)->generation = trans->transid;  in btrfs_new_inode()
6043 	inode->i_generation = BTRFS_I(inode)->generation;  in btrfs_new_inode()
6051 	set_bit(BTRFS_INODE_NEEDS_FULL_SYNC, &BTRFS_I(inode)->runtime_flags);  in btrfs_new_inode()
6073 	location = &BTRFS_I(inode)->location;  in btrfs_new_inode()
6074 	location->objectid = objectid;  in btrfs_new_inode()
6075 	location->offset = 0;  in btrfs_new_inode()
6076 	location->type = BTRFS_INODE_ITEM_KEY;  in btrfs_new_inode()
6084 	path->leave_spinning = 1;  in btrfs_new_inode()
6092 	inode->i_mtime = current_time(inode);  in btrfs_new_inode()
6093 	inode->i_atime = inode->i_mtime;  in btrfs_new_inode()
6094 	inode->i_ctime = inode->i_mtime;  in btrfs_new_inode()
6095 	BTRFS_I(inode)->i_otime = inode->i_mtime;  in btrfs_new_inode()
6097 	inode_item = btrfs_item_ptr(path->nodes[0], path->slots[0],  in btrfs_new_inode()
6099 	memzero_extent_buffer(path->nodes[0], (unsigned long)inode_item,  in btrfs_new_inode()
6101 	fill_inode_item(trans, path->nodes[0], inode_item, inode);  in btrfs_new_inode()
6104 		ref = btrfs_item_ptr(path->nodes[0], path->slots[0] + 1,  in btrfs_new_inode()
6106 		btrfs_set_inode_ref_name_len(path->nodes[0], ref, name_len);  in btrfs_new_inode()
6107 		btrfs_set_inode_ref_index(path->nodes[0], ref, *index);  in btrfs_new_inode()
6109 		write_extent_buffer(path->nodes[0], name, ptr, name_len);  in btrfs_new_inode()
6112 	btrfs_mark_buffer_dirty(path->nodes[0]);  in btrfs_new_inode()
6119 			BTRFS_I(inode)->flags |= BTRFS_INODE_NODATASUM;  in btrfs_new_inode()
6121 			BTRFS_I(inode)->flags |= BTRFS_INODE_NODATACOW |  in btrfs_new_inode()
6136 			btrfs_ino(BTRFS_I(inode)), root->root_key.objectid, ret);  in btrfs_new_inode()
6144 		BTRFS_I(dir)->index_cnt--;  in btrfs_new_inode()
6161 	struct btrfs_root *root = parent_inode->root;  in btrfs_add_link()
6166 		memcpy(&key, &inode->root->root_key, sizeof(key));  in btrfs_add_link()
6175 					 root->root_key.objectid, parent_ino,  in btrfs_add_link()
6187 				    btrfs_inode_type(&inode->vfs_inode), index);  in btrfs_add_link()
6188 	if (ret == -EEXIST || ret == -EOVERFLOW)  in btrfs_add_link()
6195 	btrfs_i_size_write(parent_inode, parent_inode->vfs_inode.i_size +  in btrfs_add_link()
6197 	inode_inc_iversion(&parent_inode->vfs_inode);  in btrfs_add_link()
6204 	if (!test_bit(BTRFS_FS_LOG_RECOVERING, &root->fs_info->flags)) {  in btrfs_add_link()
6205 		struct timespec64 now = current_time(&parent_inode->vfs_inode);  in btrfs_add_link()
6207 		parent_inode->vfs_inode.i_mtime = now;  in btrfs_add_link()
6208 		parent_inode->vfs_inode.i_ctime = now;  in btrfs_add_link()
6210 	ret = btrfs_update_inode(trans, root, &parent_inode->vfs_inode);  in btrfs_add_link()
6220 					 root->root_key.objectid, parent_ino,  in btrfs_add_link()
6243 				 dentry->d_name.name, dentry->d_name.len,  in btrfs_add_nondir()
6246 		err = -EEXIST;  in btrfs_add_nondir()
6253 	struct btrfs_fs_info *fs_info = btrfs_sb(dir->i_sb);  in btrfs_mknod()
6255 	struct btrfs_root *root = BTRFS_I(dir)->root;  in btrfs_mknod()
6274 	inode = btrfs_new_inode(trans, root, dir, dentry->d_name.name,  in btrfs_mknod()
6275 			dentry->d_name.len, btrfs_ino(BTRFS_I(dir)), objectid,  in btrfs_mknod()
6289 	inode->i_op = &btrfs_special_inode_operations;  in btrfs_mknod()
6290 	init_special_inode(inode, inode->i_mode, rdev);  in btrfs_mknod()
6292 	err = btrfs_init_inode_security(trans, inode, dir, &dentry->d_name);  in btrfs_mknod()
6317 	struct btrfs_fs_info *fs_info = btrfs_sb(dir->i_sb);  in btrfs_create()
6319 	struct btrfs_root *root = BTRFS_I(dir)->root;  in btrfs_create()
6338 	inode = btrfs_new_inode(trans, root, dir, dentry->d_name.name,  in btrfs_create()
6339 			dentry->d_name.len, btrfs_ino(BTRFS_I(dir)), objectid,  in btrfs_create()
6352 	inode->i_fop = &btrfs_file_operations;  in btrfs_create()
6353 	inode->i_op = &btrfs_file_inode_operations;  in btrfs_create()
6354 	inode->i_mapping->a_ops = &btrfs_aops;  in btrfs_create()
6356 	err = btrfs_init_inode_security(trans, inode, dir, &dentry->d_name);  in btrfs_create()
6385 	struct btrfs_root *root = BTRFS_I(dir)->root;  in btrfs_link()
6387 	struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);  in btrfs_link()
6393 	if (root->root_key.objectid != BTRFS_I(inode)->root->root_key.objectid)  in btrfs_link()
6394 		return -EXDEV;  in btrfs_link()
6396 	if (inode->i_nlink >= BTRFS_LINK_MAX)  in btrfs_link()
6397 		return -EMLINK;  in btrfs_link()
6409 	trans = btrfs_start_transaction(root, inode->i_nlink ? 5 : 6);  in btrfs_link()
6417 	BTRFS_I(inode)->dir_index = 0ULL;  in btrfs_link()
6420 	inode->i_ctime = current_time(inode);  in btrfs_link()
6422 	set_bit(BTRFS_INODE_COPY_EVERYTHING, &BTRFS_I(inode)->runtime_flags);  in btrfs_link()
6430 		struct dentry *parent = dentry->d_parent;  in btrfs_link()
6435 		if (inode->i_nlink == 1) {  in btrfs_link()
6461 	struct btrfs_fs_info *fs_info = btrfs_sb(dir->i_sb);  in btrfs_mkdir()
6464 	struct btrfs_root *root = BTRFS_I(dir)->root;  in btrfs_mkdir()
6482 	inode = btrfs_new_inode(trans, root, dir, dentry->d_name.name,  in btrfs_mkdir()
6483 			dentry->d_name.len, btrfs_ino(BTRFS_I(dir)), objectid,  in btrfs_mkdir()
6492 	inode->i_op = &btrfs_dir_inode_operations;  in btrfs_mkdir()
6493 	inode->i_fop = &btrfs_dir_file_operations;  in btrfs_mkdir()
6495 	err = btrfs_init_inode_security(trans, inode, dir, &dentry->d_name);  in btrfs_mkdir()
6505 			dentry->d_name.name,  in btrfs_mkdir()
6506 			dentry->d_name.len, 0, index);  in btrfs_mkdir()
6528 	struct extent_buffer *leaf = path->nodes[0];  in uncompress_inline()
6539 					btrfs_item_nr(path->slots[0]));  in uncompress_inline()
6542 		return -ENOMEM;  in uncompress_inline()
6561 		memset(map + pg_offset + max_size, 0, PAGE_SIZE - max_size - pg_offset);  in uncompress_inline()
6569  * btrfs_get_extent - Lookup the first extent overlapping a range in a file.
6577  * range, reading it from the B-tree and caching it if necessary. Note that
6584  * Return: ERR_PTR on error, non-NULL extent_map on success.
6590 	struct btrfs_fs_info *fs_info = inode->root->fs_info;  in btrfs_get_extent()
6595 	int extent_type = -1;  in btrfs_get_extent()
6597 	struct btrfs_root *root = inode->root;  in btrfs_get_extent()
6602 	struct extent_map_tree *em_tree = &inode->extent_tree;  in btrfs_get_extent()
6603 	struct extent_io_tree *io_tree = &inode->io_tree;  in btrfs_get_extent()
6605 	read_lock(&em_tree->lock);  in btrfs_get_extent()
6607 	read_unlock(&em_tree->lock);  in btrfs_get_extent()
6610 		if (em->start > start || em->start + em->len <= start)  in btrfs_get_extent()
6612 		else if (em->block_start == EXTENT_MAP_INLINE && page)  in btrfs_get_extent()
6619 		ret = -ENOMEM;  in btrfs_get_extent()
6622 	em->start = EXTENT_MAP_HOLE;  in btrfs_get_extent()
6623 	em->orig_start = EXTENT_MAP_HOLE;  in btrfs_get_extent()
6624 	em->len = (u64)-1;  in btrfs_get_extent()
6625 	em->block_len = (u64)-1;  in btrfs_get_extent()
6629 		ret = -ENOMEM;  in btrfs_get_extent()
6634 	path->reada = READA_FORWARD;  in btrfs_get_extent()
6640 	path->leave_spinning = 1;  in btrfs_get_extent()
6642 	path->recurse = btrfs_is_free_space_inode(inode);  in btrfs_get_extent()
6648 		if (path->slots[0] == 0)  in btrfs_get_extent()
6650 		path->slots[0]--;  in btrfs_get_extent()
6654 	leaf = path->nodes[0];  in btrfs_get_extent()
6655 	item = btrfs_item_ptr(leaf, path->slots[0],  in btrfs_get_extent()
6657 	btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);  in btrfs_get_extent()
6676 		if (!S_ISREG(inode->vfs_inode.i_mode)) {  in btrfs_get_extent()
6677 			ret = -EUCLEAN;  in btrfs_get_extent()
6679 		"regular/prealloc extent found for non-regular inode %llu",  in btrfs_get_extent()
6687 						      path->slots[0],  in btrfs_get_extent()
6692 		path->slots[0]++;  in btrfs_get_extent()
6693 		if (path->slots[0] >= btrfs_header_nritems(leaf)) {  in btrfs_get_extent()
6700 			leaf = path->nodes[0];  in btrfs_get_extent()
6702 		btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);  in btrfs_get_extent()
6712 		em->start = start;  in btrfs_get_extent()
6713 		em->orig_start = start;  in btrfs_get_extent()
6714 		em->len = found_key.offset - start;  in btrfs_get_extent()
6715 		em->block_start = EXTENT_MAP_HOLE;  in btrfs_get_extent()
6735 		extent_offset = page_offset(page) + pg_offset - extent_start;  in btrfs_get_extent()
6736 		copy_size = min_t(u64, PAGE_SIZE - pg_offset,  in btrfs_get_extent()
6737 				  size - extent_offset);  in btrfs_get_extent()
6738 		em->start = extent_start + extent_offset;  in btrfs_get_extent()
6739 		em->len = ALIGN(copy_size, fs_info->sectorsize);  in btrfs_get_extent()
6740 		em->orig_block_len = em->len;  in btrfs_get_extent()
6741 		em->orig_start = em->start;  in btrfs_get_extent()
6758 					       PAGE_SIZE - pg_offset -  in btrfs_get_extent()
6765 		set_extent_uptodate(io_tree, em->start,  in btrfs_get_extent()
6766 				    extent_map_end(em) - 1, NULL, GFP_NOFS);  in btrfs_get_extent()
6770 	em->start = start;  in btrfs_get_extent()
6771 	em->orig_start = start;  in btrfs_get_extent()
6772 	em->len = len;  in btrfs_get_extent()
6773 	em->block_start = EXTENT_MAP_HOLE;  in btrfs_get_extent()
6777 	if (em->start > start || extent_map_end(em) <= start) {  in btrfs_get_extent()
6780 			  em->start, em->len, start, len);  in btrfs_get_extent()
6781 		ret = -EIO;  in btrfs_get_extent()
6785 	write_lock(&em_tree->lock);  in btrfs_get_extent()
6787 	write_unlock(&em_tree->lock);  in btrfs_get_extent()
6816 	 * - a hole or  in btrfs_get_extent_fiemap()
6817 	 * - a pre-alloc extent,  in btrfs_get_extent_fiemap()
6820 	if (em->block_start != EXTENT_MAP_HOLE &&  in btrfs_get_extent_fiemap()
6821 	    !test_bit(EXTENT_FLAG_PREALLOC, &em->flags))  in btrfs_get_extent_fiemap()
6826 	/* check to see if we've wrapped (len == -1 or similar) */  in btrfs_get_extent_fiemap()
6829 		end = (u64)-1;  in btrfs_get_extent_fiemap()
6831 		end -= 1;  in btrfs_get_extent_fiemap()
6836 	delalloc_len = count_range_bits(&inode->io_tree, &delalloc_start,  in btrfs_get_extent_fiemap()
6840 		delalloc_end = (u64)-1;  in btrfs_get_extent_fiemap()
6857 	delalloc_len = delalloc_end - delalloc_start;  in btrfs_get_extent_fiemap()
6866 			err = -ENOMEM;  in btrfs_get_extent_fiemap()
6878 		if (hole_end <= start || hole_em->start > end) {  in btrfs_get_extent_fiemap()
6882 		       hole_start = max(hole_em->start, start);  in btrfs_get_extent_fiemap()
6883 		       hole_len = hole_end - hole_start;  in btrfs_get_extent_fiemap()
6892 			em->len = min(hole_len, delalloc_start - hole_start);  in btrfs_get_extent_fiemap()
6893 			em->start = hole_start;  in btrfs_get_extent_fiemap()
6894 			em->orig_start = hole_start;  in btrfs_get_extent_fiemap()
6899 			em->block_start = hole_em->block_start;  in btrfs_get_extent_fiemap()
6900 			em->block_len = hole_len;  in btrfs_get_extent_fiemap()
6901 			if (test_bit(EXTENT_FLAG_PREALLOC, &hole_em->flags))  in btrfs_get_extent_fiemap()
6902 				set_bit(EXTENT_FLAG_PREALLOC, &em->flags);  in btrfs_get_extent_fiemap()
6908 			em->start = delalloc_start;  in btrfs_get_extent_fiemap()
6909 			em->len = delalloc_len;  in btrfs_get_extent_fiemap()
6910 			em->orig_start = delalloc_start;  in btrfs_get_extent_fiemap()
6911 			em->block_start = EXTENT_MAP_DELALLOC;  in btrfs_get_extent_fiemap()
6912 			em->block_len = delalloc_len;  in btrfs_get_extent_fiemap()
6953 			btrfs_drop_extent_cache(inode, start, start + len - 1, 0);  in btrfs_create_dio_extent()
6965 	struct btrfs_root *root = inode->root;  in btrfs_new_extent_direct()
6966 	struct btrfs_fs_info *fs_info = root->fs_info;  in btrfs_new_extent_direct()
6973 	ret = btrfs_reserve_extent(root, len, len, fs_info->sectorsize,  in btrfs_new_extent_direct()
6996  * @orig_len:	(optional) Return the original on-disk length of the file extent
7016 	struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);  in can_nocow_extent()
7020 	struct btrfs_root *root = BTRFS_I(inode)->root;  in can_nocow_extent()
7021 	struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;  in can_nocow_extent()
7030 	bool nocow = (BTRFS_I(inode)->flags & BTRFS_INODE_NODATACOW);  in can_nocow_extent()
7034 		return -ENOMEM;  in can_nocow_extent()
7041 	slot = path->slots[0];  in can_nocow_extent()
7048 		slot--;  in can_nocow_extent()
7051 	leaf = path->nodes[0];  in can_nocow_extent()
7094 	     btrfs_root_last_snapshot(&root->root_item)))  in can_nocow_extent()
7100 		*orig_start = key.offset - backref_offset;  in can_nocow_extent()
7108 	num_bytes = min(offset + *len, extent_end) - offset;  in can_nocow_extent()
7113 				     root->fs_info->sectorsize) - 1;  in can_nocow_extent()
7117 			ret = -EAGAIN;  in can_nocow_extent()
7130 				    key.offset - backref_offset, disk_bytenr,  in can_nocow_extent()
7144 	disk_bytenr += offset - key.offset;  in can_nocow_extent()
7165 		lock_extent_bits(&BTRFS_I(inode)->io_tree, lockstart, lockend,  in lock_extent_direct()
7173 						     lockend - lockstart + 1);  in lock_extent_direct()
7183 		    (!writing || !filemap_range_has_page(inode->i_mapping,  in lock_extent_direct()
7187 		unlock_extent_cached(&BTRFS_I(inode)->io_tree, lockstart, lockend,  in lock_extent_direct()
7207 			    test_bit(BTRFS_ORDERED_DIRECT, &ordered->flags))  in lock_extent_direct()
7210 				ret = -ENOTBLK;  in lock_extent_direct()
7226 			ret = -ENOTBLK;  in lock_extent_direct()
7254 	em_tree = &inode->extent_tree;  in create_io_em()
7257 		return ERR_PTR(-ENOMEM);  in create_io_em()
7259 	em->start = start;  in create_io_em()
7260 	em->orig_start = orig_start;  in create_io_em()
7261 	em->len = len;  in create_io_em()
7262 	em->block_len = block_len;  in create_io_em()
7263 	em->block_start = block_start;  in create_io_em()
7264 	em->orig_block_len = orig_block_len;  in create_io_em()
7265 	em->ram_bytes = ram_bytes;  in create_io_em()
7266 	em->generation = -1;  in create_io_em()
7267 	set_bit(EXTENT_FLAG_PINNED, &em->flags);  in create_io_em()
7269 		set_bit(EXTENT_FLAG_FILLING, &em->flags);  in create_io_em()
7271 		set_bit(EXTENT_FLAG_COMPRESSED, &em->flags);  in create_io_em()
7272 		em->compress_type = compress_type;  in create_io_em()
7276 		btrfs_drop_extent_cache(inode, em->start,  in create_io_em()
7277 					em->start + em->len - 1, 0);  in create_io_em()
7278 		write_lock(&em_tree->lock);  in create_io_em()
7280 		write_unlock(&em_tree->lock);  in create_io_em()
7285 	} while (ret == -EEXIST);  in create_io_em()
7302 	struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);  in btrfs_get_blocks_direct_write()
7315 	if (test_bit(EXTENT_FLAG_PREALLOC, &em->flags) ||  in btrfs_get_blocks_direct_write()
7316 	    ((BTRFS_I(inode)->flags & BTRFS_INODE_NODATACOW) &&  in btrfs_get_blocks_direct_write()
7317 	     em->block_start != EXTENT_MAP_HOLE)) {  in btrfs_get_blocks_direct_write()
7321 		if (test_bit(EXTENT_FLAG_PREALLOC, &em->flags))  in btrfs_get_blocks_direct_write()
7325 		len = min(len, em->len - (start - em->start));  in btrfs_get_blocks_direct_write()
7326 		block_start = em->block_start + (start - em->start);  in btrfs_get_blocks_direct_write()
7365 	len = min(len, em->len - (start - em->start));  in btrfs_get_blocks_direct_write()
7375 	dio_data->reserve -= len;  in btrfs_get_blocks_direct_write()
7384 	struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);  in btrfs_dio_iomap_begin()
7393 	bool sync = (current->journal_info == BTRFS_DIO_SYNC_STUB);  in btrfs_dio_iomap_begin()
7396 	 * We used current->journal_info here to see if we were sync, but  in btrfs_dio_iomap_begin()
7398 	 * we have a journal_info set, so we need to clear this out and re-set  in btrfs_dio_iomap_begin()
7401 	ASSERT(current->journal_info == NULL ||  in btrfs_dio_iomap_begin()
7402 	       current->journal_info == BTRFS_DIO_SYNC_STUB);  in btrfs_dio_iomap_begin()
7403 	current->journal_info = NULL;  in btrfs_dio_iomap_begin()
7406 		len = min_t(u64, len, fs_info->sectorsize);  in btrfs_dio_iomap_begin()
7409 	lockend = start + len - 1;  in btrfs_dio_iomap_begin()
7418 		     &BTRFS_I(inode)->runtime_flags)) {  in btrfs_dio_iomap_begin()
7419 		ret = filemap_fdatawrite_range(inode->i_mapping, start,  in btrfs_dio_iomap_begin()
7420 					       start + length - 1);  in btrfs_dio_iomap_begin()
7427 		return -ENOMEM;  in btrfs_dio_iomap_begin()
7429 	dio_data->sync = sync;  in btrfs_dio_iomap_begin()
7430 	dio_data->length = length;  in btrfs_dio_iomap_begin()
7432 		dio_data->reserve = round_up(length, fs_info->sectorsize);  in btrfs_dio_iomap_begin()
7434 				&dio_data->data_reserved,  in btrfs_dio_iomap_begin()
7435 				start, dio_data->reserve);  in btrfs_dio_iomap_begin()
7437 			extent_changeset_free(dio_data->data_reserved);  in btrfs_dio_iomap_begin()
7442 	iomap->private = dio_data;  in btrfs_dio_iomap_begin()
7450 		ret = -ENOTBLK;  in btrfs_dio_iomap_begin()
7470 	 * We return -ENOTBLK because that's what makes DIO go ahead and go back  in btrfs_dio_iomap_begin()
7474 	if (test_bit(EXTENT_FLAG_COMPRESSED, &em->flags) ||  in btrfs_dio_iomap_begin()
7475 	    em->block_start == EXTENT_MAP_INLINE) {  in btrfs_dio_iomap_begin()
7477 		ret = -ENOTBLK;  in btrfs_dio_iomap_begin()
7481 	len = min(len, em->len - (start - em->start));  in btrfs_dio_iomap_begin()
7489 		len = min(len, em->len - (start - em->start));  in btrfs_dio_iomap_begin()
7501 		unlock_extent_cached(&BTRFS_I(inode)->io_tree,  in btrfs_dio_iomap_begin()
7511 	if ((em->block_start == EXTENT_MAP_HOLE) ||  in btrfs_dio_iomap_begin()
7512 	    (test_bit(EXTENT_FLAG_PREALLOC, &em->flags) && !write)) {  in btrfs_dio_iomap_begin()
7513 		iomap->addr = IOMAP_NULL_ADDR;  in btrfs_dio_iomap_begin()
7514 		iomap->type = IOMAP_HOLE;  in btrfs_dio_iomap_begin()
7516 		iomap->addr = em->block_start + (start - em->start);  in btrfs_dio_iomap_begin()
7517 		iomap->type = IOMAP_MAPPED;  in btrfs_dio_iomap_begin()
7519 	iomap->offset = start;  in btrfs_dio_iomap_begin()
7520 	iomap->bdev = fs_info->fs_devices->latest_bdev;  in btrfs_dio_iomap_begin()
7521 	iomap->length = len;  in btrfs_dio_iomap_begin()
7528 	unlock_extent_cached(&BTRFS_I(inode)->io_tree, lockstart, lockend,  in btrfs_dio_iomap_begin()
7533 				dio_data->data_reserved, start,  in btrfs_dio_iomap_begin()
7534 				dio_data->reserve, true);  in btrfs_dio_iomap_begin()
7535 		btrfs_delalloc_release_extents(BTRFS_I(inode), dio_data->reserve);  in btrfs_dio_iomap_begin()
7536 		extent_changeset_free(dio_data->data_reserved);  in btrfs_dio_iomap_begin()
7546 	struct btrfs_dio_data *dio_data = iomap->private;  in btrfs_dio_iomap_end()
7547 	size_t submitted = dio_data->submitted;  in btrfs_dio_iomap_end()
7550 	if (!write && (iomap->type == IOMAP_HOLE)) {  in btrfs_dio_iomap_end()
7552 		unlock_extent(&BTRFS_I(inode)->io_tree, pos, pos + length - 1);  in btrfs_dio_iomap_end()
7558 		length -= submitted;  in btrfs_dio_iomap_end()
7563 			unlock_extent(&BTRFS_I(inode)->io_tree, pos,  in btrfs_dio_iomap_end()
7564 				      pos + length - 1);  in btrfs_dio_iomap_end()
7565 		ret = -ENOTBLK;  in btrfs_dio_iomap_end()
7569 		if (dio_data->reserve)  in btrfs_dio_iomap_end()
7571 					dio_data->data_reserved, pos,  in btrfs_dio_iomap_end()
7572 					dio_data->reserve, true);  in btrfs_dio_iomap_end()
7573 		btrfs_delalloc_release_extents(BTRFS_I(inode), dio_data->length);  in btrfs_dio_iomap_end()
7574 		extent_changeset_free(dio_data->data_reserved);  in btrfs_dio_iomap_end()
7578 	 * We're all done, we can re-set the current->journal_info now safely  in btrfs_dio_iomap_end()
7581 	if (dio_data->sync) {  in btrfs_dio_iomap_end()
7582 		ASSERT(current->journal_info == NULL);  in btrfs_dio_iomap_end()
7583 		current->journal_info = BTRFS_DIO_SYNC_STUB;  in btrfs_dio_iomap_end()
7586 	iomap->private = NULL;  in btrfs_dio_iomap_end()
7594 	 * This implies a barrier so that stores to dio_bio->bi_status before  in btrfs_dio_private_put()
7595 	 * this and loads of dio_bio->bi_status after this are fully ordered.  in btrfs_dio_private_put()
7597 	if (!refcount_dec_and_test(&dip->refs))  in btrfs_dio_private_put()
7600 	if (bio_op(dip->dio_bio) == REQ_OP_WRITE) {  in btrfs_dio_private_put()
7601 		__endio_write_update_ordered(BTRFS_I(dip->inode),  in btrfs_dio_private_put()
7602 					     dip->logical_offset,  in btrfs_dio_private_put()
7603 					     dip->bytes,  in btrfs_dio_private_put()
7604 					     !dip->dio_bio->bi_status);  in btrfs_dio_private_put()
7606 		unlock_extent(&BTRFS_I(dip->inode)->io_tree,  in btrfs_dio_private_put()
7607 			      dip->logical_offset,  in btrfs_dio_private_put()
7608 			      dip->logical_offset + dip->bytes - 1);  in btrfs_dio_private_put()
7611 	bio_endio(dip->dio_bio);  in btrfs_dio_private_put()
7619 	struct btrfs_dio_private *dip = bio->bi_private;  in submit_dio_repair_bio()
7620 	struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);  in submit_dio_repair_bio()
7629 	refcount_inc(&dip->refs);  in submit_dio_repair_bio()
7632 		refcount_dec(&dip->refs);  in submit_dio_repair_bio()
7640 	struct btrfs_fs_info *fs_info = BTRFS_I(inode)->root->fs_info;  in btrfs_check_read_dio_bio()
7641 	const u32 sectorsize = fs_info->sectorsize;  in btrfs_check_read_dio_bio()
7642 	struct extent_io_tree *failure_tree = &BTRFS_I(inode)->io_failure_tree;  in btrfs_check_read_dio_bio()
7643 	struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;  in btrfs_check_read_dio_bio()
7644 	const bool csum = !(BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM);  in btrfs_check_read_dio_bio()
7647 	u64 start = io_bio->logical;  in btrfs_check_read_dio_bio()
7651 	__bio_for_each_segment(bvec, &io_bio->bio, iter, io_bio->iter) {  in btrfs_check_read_dio_bio()
7670 							&io_bio->bio,  in btrfs_check_read_dio_bio()
7671 							start - io_bio->logical,  in btrfs_check_read_dio_bio()
7674 							start + sectorsize - 1,  in btrfs_check_read_dio_bio()
7675 							io_bio->mirror_num,  in btrfs_check_read_dio_bio()
7692 	struct btrfs_fs_info *fs_info = inode->root->fs_info;  in __endio_write_update_ordered()
7700 		wq = fs_info->endio_freespace_worker;  in __endio_write_update_ordered()
7702 		wq = fs_info->endio_write_workers;  in __endio_write_update_ordered()
7710 			btrfs_init_work(&ordered->work, finish_ordered_fn, NULL,  in __endio_write_update_ordered()
7712 			btrfs_queue_work(wq, &ordered->work);  in __endio_write_update_ordered()
7725 			ordered_bytes = offset + bytes - ordered_offset;  in __endio_write_update_ordered()
7741 	struct btrfs_dio_private *dip = bio->bi_private;  in btrfs_end_dio_bio()
7742 	blk_status_t err = bio->bi_status;  in btrfs_end_dio_bio()
7745 		btrfs_warn(BTRFS_I(dip->inode)->root->fs_info,  in btrfs_end_dio_bio()
7747 			   btrfs_ino(BTRFS_I(dip->inode)), bio_op(bio),  in btrfs_end_dio_bio()
7748 			   bio->bi_opf,  in btrfs_end_dio_bio()
7749 			   (unsigned long long)bio->bi_iter.bi_sector,  in btrfs_end_dio_bio()
7750 			   bio->bi_iter.bi_size, err);  in btrfs_end_dio_bio()
7753 		err = btrfs_check_read_dio_bio(dip->inode, btrfs_io_bio(bio),  in btrfs_end_dio_bio()
7758 		dip->dio_bio->bi_status = err;  in btrfs_end_dio_bio()
7767 	struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);  in btrfs_submit_dio_bio()
7768 	struct btrfs_dio_private *dip = bio->bi_private;  in btrfs_submit_dio_bio()
7774 		async_submit = !atomic_read(&BTRFS_I(inode)->sync_writers);  in btrfs_submit_dio_bio()
7782 	if (BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM)  in btrfs_submit_dio_bio()
7801 		csum_offset = file_offset - dip->logical_offset;  in btrfs_submit_dio_bio()
7802 		csum_offset >>= inode->i_sb->s_blocksize_bits;  in btrfs_submit_dio_bio()
7803 		csum_offset *= btrfs_super_csum_size(fs_info->super_copy);  in btrfs_submit_dio_bio()
7804 		btrfs_io_bio(bio)->csum = dip->csums + csum_offset;  in btrfs_submit_dio_bio()
7821 	const bool csum = !(BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM);  in btrfs_create_dio_private()
7827 		struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);  in btrfs_create_dio_private()
7828 		const u16 csum_size = btrfs_super_csum_size(fs_info->super_copy);  in btrfs_create_dio_private()
7831 		nblocks = dio_bio->bi_iter.bi_size >> inode->i_sb->s_blocksize_bits;  in btrfs_create_dio_private()
7839 	dip->inode = inode;  in btrfs_create_dio_private()
7840 	dip->logical_offset = file_offset;  in btrfs_create_dio_private()
7841 	dip->bytes = dio_bio->bi_iter.bi_size;  in btrfs_create_dio_private()
7842 	dip->disk_bytenr = (u64)dio_bio->bi_iter.bi_sector << 9;  in btrfs_create_dio_private()
7843 	dip->dio_bio = dio_bio;  in btrfs_create_dio_private()
7844 	refcount_set(&dip->refs, 1);  in btrfs_create_dio_private()
7852 	const bool csum = !(BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM);  in btrfs_submit_direct()
7853 	struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);  in btrfs_submit_direct()
7866 	struct btrfs_dio_data *dio_data = iomap->private;  in btrfs_submit_direct()
7871 			unlock_extent(&BTRFS_I(inode)->io_tree, file_offset,  in btrfs_submit_direct()
7872 				file_offset + dio_bio->bi_iter.bi_size - 1);  in btrfs_submit_direct()
7874 		dio_bio->bi_status = BLK_STS_RESOURCE;  in btrfs_submit_direct()
7885 					       dip->csums);  in btrfs_submit_direct()
7890 	start_sector = dio_bio->bi_iter.bi_sector;  in btrfs_submit_direct()
7891 	submit_len = dio_bio->bi_iter.bi_size;  in btrfs_submit_direct()
7910 		bio->bi_private = dip;  in btrfs_submit_direct()
7911 		bio->bi_end_io = btrfs_end_dio_bio;  in btrfs_submit_direct()
7912 		btrfs_io_bio(bio)->logical = file_offset;  in btrfs_submit_direct()
7915 		submit_len -= clone_len;  in btrfs_submit_direct()
7927 			refcount_inc(&dip->refs);  in btrfs_submit_direct()
7943 				refcount_dec(&dip->refs);  in btrfs_submit_direct()
7947 		dio_data->submitted += clone_len;  in btrfs_submit_direct()
7955 	dip->dio_bio->bi_status = status;  in btrfs_submit_direct()
7965 	unsigned int blocksize_mask = fs_info->sectorsize - 1;  in check_direct_IO()
7966 	ssize_t retval = -EINVAL;  in check_direct_IO()
7982 	for (seg = 0; seg < iter->nr_segs; seg++) {  in check_direct_IO()
7983 		for (i = seg + 1; i < iter->nr_segs; i++) {  in check_direct_IO()
7984 			if (iter->iov[seg].iov_base == iter->iov[i].iov_base)  in check_direct_IO()
8001 	if (current->journal_info == BTRFS_DIO_SYNC_STUB) {  in btrfs_maybe_fsync_end_io()
8002 		current->journal_info = NULL;  in btrfs_maybe_fsync_end_io()
8010 		iocb->ki_flags |= IOCB_DSYNC;  in btrfs_maybe_fsync_end_io()
8033 	struct file *file = iocb->ki_filp;  in btrfs_direct_IO()
8034 	struct inode *inode = file->f_mapping->host;  in btrfs_direct_IO()
8035 	struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);  in btrfs_direct_IO()
8037 	loff_t offset = iocb->ki_pos;  in btrfs_direct_IO()
8043 		ASSERT(current->journal_info == NULL ||  in btrfs_direct_IO()
8044 		       current->journal_info == BTRFS_DIO_SYNC_STUB);  in btrfs_direct_IO()
8045 		current->journal_info = NULL;  in btrfs_direct_IO()
8056 		if (offset + count <= inode->i_size) {  in btrfs_direct_IO()
8060 		down_read(&BTRFS_I(inode)->dio_sem);  in btrfs_direct_IO()
8067 	if (current->journal_info)  in btrfs_direct_IO()
8074 	if (ret == -ENOTBLK)  in btrfs_direct_IO()
8078 		up_read(&BTRFS_I(inode)->dio_sem);  in btrfs_direct_IO()
8101 	struct btrfs_inode *inode = BTRFS_I(page->mapping->host);  in btrfs_readpage()
8103 	u64 end = start + PAGE_SIZE - 1;  in btrfs_readpage()
8118 	struct inode *inode = page->mapping->host;  in btrfs_writepage()
8121 	if (current->flags & PF_MEMALLOC) {  in btrfs_writepage()
8197 	struct btrfs_inode *inode = BTRFS_I(page->mapping->host);  in btrfs_invalidatepage()
8198 	struct extent_io_tree *tree = &inode->io_tree;  in btrfs_invalidatepage()
8202 	u64 page_end = page_start + PAGE_SIZE - 1;  in btrfs_invalidatepage()
8205 	int inode_evicting = inode->vfs_inode.i_state & I_FREEING;  in btrfs_invalidatepage()
8221 	 * shouldn't clear page extent mapped, as page->private can still  in btrfs_invalidatepage()
8238 	ordered = btrfs_lookup_ordered_range(inode, start, page_end - start + 1);  in btrfs_invalidatepage()
8241 			  ordered->file_offset + ordered->num_bytes - 1);  in btrfs_invalidatepage()
8259 			tree = &inode->ordered_tree;  in btrfs_invalidatepage()
8261 			spin_lock_irq(&tree->lock);  in btrfs_invalidatepage()
8262 			set_bit(BTRFS_ORDERED_TRUNCATED, &ordered->flags);  in btrfs_invalidatepage()
8263 			new_len = start - ordered->file_offset;  in btrfs_invalidatepage()
8264 			if (new_len < ordered->truncated_len)  in btrfs_invalidatepage()
8265 				ordered->truncated_len = new_len;  in btrfs_invalidatepage()
8266 			spin_unlock_irq(&tree->lock);  in btrfs_invalidatepage()
8270 							   end - start + 1, 1))  in btrfs_invalidatepage()
8329 	struct page *page = vmf->page;  in btrfs_page_mkwrite()
8330 	struct inode *inode = file_inode(vmf->vma->vm_file);  in btrfs_page_mkwrite()
8331 	struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);  in btrfs_page_mkwrite()
8332 	struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;  in btrfs_page_mkwrite()
8349 	sb_start_pagefault(inode->i_sb);  in btrfs_page_mkwrite()
8351 	page_end = page_start + PAGE_SIZE - 1;  in btrfs_page_mkwrite()
8365 		ret2 = file_update_time(vmf->vma->vm_file);  in btrfs_page_mkwrite()
8380 	if ((page->mapping != inode->i_mapping) ||  in btrfs_page_mkwrite()
8405 	if (page->index == ((size - 1) >> PAGE_SHIFT)) {  in btrfs_page_mkwrite()
8406 		reserved_space = round_up(size - page_start,  in btrfs_page_mkwrite()
8407 					  fs_info->sectorsize);  in btrfs_page_mkwrite()
8409 			end = page_start + reserved_space - 1;  in btrfs_page_mkwrite()
8412 					PAGE_SIZE - reserved_space, true);  in btrfs_page_mkwrite()
8423 	clear_extent_bit(&BTRFS_I(inode)->io_tree, page_start, end,  in btrfs_page_mkwrite()
8444 		memset(kaddr + zero_start, 0, PAGE_SIZE - zero_start);  in btrfs_page_mkwrite()
8457 	sb_end_pagefault(inode->i_sb);  in btrfs_page_mkwrite()
8468 	sb_end_pagefault(inode->i_sb);  in btrfs_page_mkwrite()
8475 	struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);  in btrfs_truncate()
8476 	struct btrfs_root *root = BTRFS_I(inode)->root;  in btrfs_truncate()
8480 	u64 mask = fs_info->sectorsize - 1;  in btrfs_truncate()
8484 		ret = btrfs_wait_ordered_range(inode, inode->i_size & (~mask),  in btrfs_truncate()
8485 					       (u64)-1);  in btrfs_truncate()
8513 	 * 1) rsv - for the truncate reservation, which we will steal from the  in btrfs_truncate()
8515 	 * 2) fs_info->trans_block_rsv - this will have 1 items worth left for  in btrfs_truncate()
8520 		return -ENOMEM;  in btrfs_truncate()
8521 	rsv->size = min_size;  in btrfs_truncate()
8522 	rsv->failfast = 1;  in btrfs_truncate()
8535 	ret = btrfs_block_rsv_migrate(&fs_info->trans_block_rsv, rsv,  in btrfs_truncate()
8546 	set_bit(BTRFS_INODE_NEEDS_FULL_SYNC, &BTRFS_I(inode)->runtime_flags);  in btrfs_truncate()
8547 	trans->block_rsv = rsv;  in btrfs_truncate()
8551 						 inode->i_size,  in btrfs_truncate()
8553 		trans->block_rsv = &fs_info->trans_block_rsv;  in btrfs_truncate()
8554 		if (ret != -ENOSPC && ret != -EAGAIN)  in btrfs_truncate()
8571 		btrfs_block_rsv_release(fs_info, rsv, -1, NULL);  in btrfs_truncate()
8572 		ret = btrfs_block_rsv_migrate(&fs_info->trans_block_rsv,  in btrfs_truncate()
8575 		trans->block_rsv = rsv;  in btrfs_truncate()
8588 		ret = btrfs_truncate_block(inode, inode->i_size, 0, 0);  in btrfs_truncate()
8602 		trans->block_rsv = &fs_info->trans_block_rsv;  in btrfs_truncate()
8636 	inode->i_op = &btrfs_dir_inode_operations;  in btrfs_create_subvol_root()
8637 	inode->i_fop = &btrfs_dir_file_operations;  in btrfs_create_subvol_root()
8645 		btrfs_err(new_root->fs_info,  in btrfs_create_subvol_root()
8647 			  new_root->root_key.objectid, err);  in btrfs_create_subvol_root()
8665 	ei->root = NULL;  in btrfs_alloc_inode()
8666 	ei->generation = 0;  in btrfs_alloc_inode()
8667 	ei->last_trans = 0;  in btrfs_alloc_inode()
8668 	ei->last_sub_trans = 0;  in btrfs_alloc_inode()
8669 	ei->logged_trans = 0;  in btrfs_alloc_inode()
8670 	ei->delalloc_bytes = 0;  in btrfs_alloc_inode()
8671 	ei->new_delalloc_bytes = 0;  in btrfs_alloc_inode()
8672 	ei->defrag_bytes = 0;  in btrfs_alloc_inode()
8673 	ei->disk_i_size = 0;  in btrfs_alloc_inode()
8674 	ei->flags = 0;  in btrfs_alloc_inode()
8675 	ei->csum_bytes = 0;  in btrfs_alloc_inode()
8676 	ei->index_cnt = (u64)-1;  in btrfs_alloc_inode()
8677 	ei->dir_index = 0;  in btrfs_alloc_inode()
8678 	ei->last_unlink_trans = 0;  in btrfs_alloc_inode()
8679 	ei->last_reflink_trans = 0;  in btrfs_alloc_inode()
8680 	ei->last_log_commit = 0;  in btrfs_alloc_inode()
8682 	spin_lock_init(&ei->lock);  in btrfs_alloc_inode()
8683 	ei->outstanding_extents = 0;  in btrfs_alloc_inode()
8684 	if (sb->s_magic != BTRFS_TEST_MAGIC)  in btrfs_alloc_inode()
8685 		btrfs_init_metadata_block_rsv(fs_info, &ei->block_rsv,  in btrfs_alloc_inode()
8687 	ei->runtime_flags = 0;  in btrfs_alloc_inode()
8688 	ei->prop_compress = BTRFS_COMPRESS_NONE;  in btrfs_alloc_inode()
8689 	ei->defrag_compress = BTRFS_COMPRESS_NONE;  in btrfs_alloc_inode()
8691 	ei->delayed_node = NULL;  in btrfs_alloc_inode()
8693 	ei->i_otime.tv_sec = 0;  in btrfs_alloc_inode()
8694 	ei->i_otime.tv_nsec = 0;  in btrfs_alloc_inode()
8696 	inode = &ei->vfs_inode;  in btrfs_alloc_inode()
8697 	extent_map_tree_init(&ei->extent_tree);  in btrfs_alloc_inode()
8698 	extent_io_tree_init(fs_info, &ei->io_tree, IO_TREE_INODE_IO, inode);  in btrfs_alloc_inode()
8699 	extent_io_tree_init(fs_info, &ei->io_failure_tree,  in btrfs_alloc_inode()
8701 	extent_io_tree_init(fs_info, &ei->file_extent_tree,  in btrfs_alloc_inode()
8703 	ei->io_tree.track_uptodate = true;  in btrfs_alloc_inode()
8704 	ei->io_failure_tree.track_uptodate = true;  in btrfs_alloc_inode()
8705 	atomic_set(&ei->sync_writers, 0);  in btrfs_alloc_inode()
8706 	mutex_init(&ei->log_mutex);  in btrfs_alloc_inode()
8707 	btrfs_ordered_inode_tree_init(&ei->ordered_tree);  in btrfs_alloc_inode()
8708 	INIT_LIST_HEAD(&ei->delalloc_inodes);  in btrfs_alloc_inode()
8709 	INIT_LIST_HEAD(&ei->delayed_iput);  in btrfs_alloc_inode()
8710 	RB_CLEAR_NODE(&ei->rb_node);  in btrfs_alloc_inode()
8711 	init_rwsem(&ei->dio_sem);  in btrfs_alloc_inode()
8719 	btrfs_drop_extent_cache(BTRFS_I(inode), 0, (u64)-1, 0);  in btrfs_test_destroy_inode()
8733 	struct btrfs_root *root = inode->root;  in btrfs_destroy_inode()
8735 	WARN_ON(!hlist_empty(&vfs_inode->i_dentry));  in btrfs_destroy_inode()
8736 	WARN_ON(vfs_inode->i_data.nrpages);  in btrfs_destroy_inode()
8737 	WARN_ON(inode->block_rsv.reserved);  in btrfs_destroy_inode()
8738 	WARN_ON(inode->block_rsv.size);  in btrfs_destroy_inode()
8739 	WARN_ON(inode->outstanding_extents);  in btrfs_destroy_inode()
8740 	WARN_ON(inode->delalloc_bytes);  in btrfs_destroy_inode()
8741 	WARN_ON(inode->new_delalloc_bytes);  in btrfs_destroy_inode()
8742 	WARN_ON(inode->csum_bytes);  in btrfs_destroy_inode()
8743 	WARN_ON(inode->defrag_bytes);  in btrfs_destroy_inode()
8754 		ordered = btrfs_lookup_first_ordered_extent(inode, (u64)-1);  in btrfs_destroy_inode()
8758 			btrfs_err(root->fs_info,  in btrfs_destroy_inode()
8760 				  ordered->file_offset, ordered->num_bytes);  in btrfs_destroy_inode()
8768 	btrfs_drop_extent_cache(inode, 0, (u64)-1, 0);  in btrfs_destroy_inode()
8769 	btrfs_inode_clear_file_extent_range(inode, 0, (u64)-1);  in btrfs_destroy_inode()
8770 	btrfs_put_root(inode->root);  in btrfs_destroy_inode()
8775 	struct btrfs_root *root = BTRFS_I(inode)->root;  in btrfs_drop_inode()
8781 	if (btrfs_root_refs(&root->root_item) == 0)  in btrfs_drop_inode()
8787 static void init_once(void *foo)  in init_once()  argument
8789 	struct btrfs_inode *ei = (struct btrfs_inode *) foo;  in init_once()
8791 	inode_init_once(&ei->vfs_inode);  in init_once()
8844 	return -ENOMEM;  in btrfs_init_cachep()
8851 	struct inode *inode = d_inode(path->dentry);  in btrfs_getattr()
8852 	u32 blocksize = inode->i_sb->s_blocksize;  in btrfs_getattr()
8853 	u32 bi_flags = BTRFS_I(inode)->flags;  in btrfs_getattr()
8855 	stat->result_mask |= STATX_BTIME;  in btrfs_getattr()
8856 	stat->btime.tv_sec = BTRFS_I(inode)->i_otime.tv_sec;  in btrfs_getattr()
8857 	stat->btime.tv_nsec = BTRFS_I(inode)->i_otime.tv_nsec;  in btrfs_getattr()
8859 		stat->attributes |= STATX_ATTR_APPEND;  in btrfs_getattr()
8861 		stat->attributes |= STATX_ATTR_COMPRESSED;  in btrfs_getattr()
8863 		stat->attributes |= STATX_ATTR_IMMUTABLE;  in btrfs_getattr()
8865 		stat->attributes |= STATX_ATTR_NODUMP;  in btrfs_getattr()
8867 	stat->attributes_mask |= (STATX_ATTR_APPEND |  in btrfs_getattr()
8873 	stat->dev = BTRFS_I(inode)->root->anon_dev;  in btrfs_getattr()
8875 	spin_lock(&BTRFS_I(inode)->lock);  in btrfs_getattr()
8876 	delalloc_bytes = BTRFS_I(inode)->new_delalloc_bytes;  in btrfs_getattr()
8877 	spin_unlock(&BTRFS_I(inode)->lock);  in btrfs_getattr()
8878 	stat->blocks = (ALIGN(inode_get_bytes(inode), blocksize) +  in btrfs_getattr()
8888 	struct btrfs_fs_info *fs_info = btrfs_sb(old_dir->i_sb);  in btrfs_rename_exchange()
8890 	struct btrfs_root *root = BTRFS_I(old_dir)->root;  in btrfs_rename_exchange()
8891 	struct btrfs_root *dest = BTRFS_I(new_dir)->root;  in btrfs_rename_exchange()
8892 	struct inode *new_inode = new_dentry->d_inode;  in btrfs_rename_exchange()
8893 	struct inode *old_inode = old_dentry->d_inode;  in btrfs_rename_exchange()
8906 	 * For non-subvolumes allow exchange only within one subvolume, in the  in btrfs_rename_exchange()
8913 		return -EXDEV;  in btrfs_rename_exchange()
8918 		down_read(&fs_info->subvol_sem);  in btrfs_rename_exchange()
8948 	BTRFS_I(old_inode)->dir_index = 0ULL;  in btrfs_rename_exchange()
8949 	BTRFS_I(new_inode)->dir_index = 0ULL;  in btrfs_rename_exchange()
8959 					     new_dentry->d_name.name,  in btrfs_rename_exchange()
8960 					     new_dentry->d_name.len,  in btrfs_rename_exchange()
8977 					     old_dentry->d_name.name,  in btrfs_rename_exchange()
8978 					     old_dentry->d_name.len,  in btrfs_rename_exchange()
8994 	old_dir->i_ctime = old_dir->i_mtime = ctime;  in btrfs_rename_exchange()
8995 	new_dir->i_ctime = new_dir->i_mtime = ctime;  in btrfs_rename_exchange()
8996 	old_inode->i_ctime = ctime;  in btrfs_rename_exchange()
8997 	new_inode->i_ctime = ctime;  in btrfs_rename_exchange()
8999 	if (old_dentry->d_parent != new_dentry->d_parent) {  in btrfs_rename_exchange()
9011 					   BTRFS_I(old_dentry->d_inode),  in btrfs_rename_exchange()
9012 					   old_dentry->d_name.name,  in btrfs_rename_exchange()
9013 					   old_dentry->d_name.len);  in btrfs_rename_exchange()
9027 					   BTRFS_I(new_dentry->d_inode),  in btrfs_rename_exchange()
9028 					   new_dentry->d_name.name,  in btrfs_rename_exchange()
9029 					   new_dentry->d_name.len);  in btrfs_rename_exchange()
9039 			     new_dentry->d_name.name,  in btrfs_rename_exchange()
9040 			     new_dentry->d_name.len, 0, old_idx);  in btrfs_rename_exchange()
9047 			     old_dentry->d_name.name,  in btrfs_rename_exchange()
9048 			     old_dentry->d_name.len, 0, new_idx);  in btrfs_rename_exchange()
9054 	if (old_inode->i_nlink == 1)  in btrfs_rename_exchange()
9055 		BTRFS_I(old_inode)->dir_index = old_idx;  in btrfs_rename_exchange()
9056 	if (new_inode->i_nlink == 1)  in btrfs_rename_exchange()
9057 		BTRFS_I(new_inode)->dir_index = new_idx;  in btrfs_rename_exchange()
9061 				   new_dentry->d_parent);  in btrfs_rename_exchange()
9067 				   old_dentry->d_parent);  in btrfs_rename_exchange()
9084 		if (btrfs_inode_in_log(BTRFS_I(old_dir), fs_info->generation) ||  in btrfs_rename_exchange()
9085 		    btrfs_inode_in_log(BTRFS_I(new_dir), fs_info->generation) ||  in btrfs_rename_exchange()
9086 		    btrfs_inode_in_log(BTRFS_I(old_inode), fs_info->generation) ||  in btrfs_rename_exchange()
9088 		     btrfs_inode_in_log(BTRFS_I(new_inode), fs_info->generation)))  in btrfs_rename_exchange()
9105 		up_read(&fs_info->subvol_sem);  in btrfs_rename_exchange()
9125 				dentry->d_name.name,  in btrfs_whiteout_for_rename()
9126 				dentry->d_name.len,  in btrfs_whiteout_for_rename()
9137 	inode->i_op = &btrfs_special_inode_operations;  in btrfs_whiteout_for_rename()
9138 	init_special_inode(inode, inode->i_mode,  in btrfs_whiteout_for_rename()
9142 				&dentry->d_name);  in btrfs_whiteout_for_rename()
9165 	struct btrfs_fs_info *fs_info = btrfs_sb(old_dir->i_sb);  in btrfs_rename()
9168 	struct btrfs_root *root = BTRFS_I(old_dir)->root;  in btrfs_rename()
9169 	struct btrfs_root *dest = BTRFS_I(new_dir)->root;  in btrfs_rename()
9179 		return -EPERM;  in btrfs_rename()
9183 		return -EXDEV;  in btrfs_rename()
9187 		return -ENOTEMPTY;  in btrfs_rename()
9189 	if (S_ISDIR(old_inode->i_mode) && new_inode &&  in btrfs_rename()
9190 	    new_inode->i_size > BTRFS_EMPTY_DIR_SIZE)  in btrfs_rename()
9191 		return -ENOTEMPTY;  in btrfs_rename()
9195 	ret = btrfs_check_dir_item_collision(dest, new_dir->i_ino,  in btrfs_rename()
9196 			     new_dentry->d_name.name,  in btrfs_rename()
9197 			     new_dentry->d_name.len);  in btrfs_rename()
9200 		if (ret == -EEXIST) {  in btrfs_rename()
9207 			/* maybe -EOVERFLOW */  in btrfs_rename()
9217 	if (new_inode && S_ISREG(old_inode->i_mode) && new_inode->i_size)  in btrfs_rename()
9218 		filemap_flush(old_inode->i_mapping);  in btrfs_rename()
9222 		down_read(&fs_info->subvol_sem);  in btrfs_rename()
9250 	BTRFS_I(old_inode)->dir_index = 0ULL;  in btrfs_rename()
9258 					     new_dentry->d_name.name,  in btrfs_rename()
9259 					     new_dentry->d_name.len,  in btrfs_rename()
9269 	old_dir->i_ctime = old_dir->i_mtime =  in btrfs_rename()
9270 	new_dir->i_ctime = new_dir->i_mtime =  in btrfs_rename()
9271 	old_inode->i_ctime = current_time(old_dir);  in btrfs_rename()
9273 	if (old_dentry->d_parent != new_dentry->d_parent)  in btrfs_rename()
9282 					old_dentry->d_name.name,  in btrfs_rename()
9283 					old_dentry->d_name.len);  in btrfs_rename()
9294 		new_inode->i_ctime = current_time(new_inode);  in btrfs_rename()
9298 			BUG_ON(new_inode->i_nlink == 0);  in btrfs_rename()
9302 						 new_dentry->d_name.name,  in btrfs_rename()
9303 						 new_dentry->d_name.len);  in btrfs_rename()
9305 		if (!ret && new_inode->i_nlink == 0)  in btrfs_rename()
9315 			     new_dentry->d_name.name,  in btrfs_rename()
9316 			     new_dentry->d_name.len, 0, index);  in btrfs_rename()
9322 	if (old_inode->i_nlink == 1)  in btrfs_rename()
9323 		BTRFS_I(old_inode)->dir_index = index;  in btrfs_rename()
9327 				   new_dentry->d_parent);  in btrfs_rename()
9354 		if (btrfs_inode_in_log(BTRFS_I(old_dir), fs_info->generation) ||  in btrfs_rename()
9355 		    btrfs_inode_in_log(BTRFS_I(new_dir), fs_info->generation) ||  in btrfs_rename()
9356 		    btrfs_inode_in_log(BTRFS_I(old_inode), fs_info->generation) ||  in btrfs_rename()
9358 		     btrfs_inode_in_log(BTRFS_I(new_inode), fs_info->generation)))  in btrfs_rename()
9368 		up_read(&fs_info->subvol_sem);  in btrfs_rename()
9378 		return -EINVAL;  in btrfs_rename2()
9401 	inode = delalloc_work->inode;  in btrfs_run_delalloc_work()
9402 	filemap_flush(inode->i_mapping);  in btrfs_run_delalloc_work()
9404 				&BTRFS_I(inode)->runtime_flags))  in btrfs_run_delalloc_work()
9405 		filemap_flush(inode->i_mapping);  in btrfs_run_delalloc_work()
9408 	complete(&delalloc_work->completion);  in btrfs_run_delalloc_work()
9419 	init_completion(&work->completion);  in btrfs_alloc_delalloc_work()
9420 	INIT_LIST_HEAD(&work->list);  in btrfs_alloc_delalloc_work()
9421 	work->inode = inode;  in btrfs_alloc_delalloc_work()
9422 	btrfs_init_work(&work->work, btrfs_run_delalloc_work, NULL, NULL);  in btrfs_alloc_delalloc_work()
9441 	bool full_flush = wbc->nr_to_write == LONG_MAX;  in start_delalloc_inodes()
9446 	mutex_lock(&root->delalloc_mutex);  in start_delalloc_inodes()
9447 	spin_lock(&root->delalloc_lock);  in start_delalloc_inodes()
9448 	list_splice_init(&root->delalloc_inodes, &splice);  in start_delalloc_inodes()
9453 		list_move_tail(&binode->delalloc_inodes,  in start_delalloc_inodes()
9454 			       &root->delalloc_inodes);  in start_delalloc_inodes()
9457 		    test_bit(BTRFS_INODE_NO_DELALLOC_FLUSH, &binode->runtime_flags))  in start_delalloc_inodes()
9460 		inode = igrab(&binode->vfs_inode);  in start_delalloc_inodes()
9462 			cond_resched_lock(&root->delalloc_lock);  in start_delalloc_inodes()
9465 		spin_unlock(&root->delalloc_lock);  in start_delalloc_inodes()
9469 				&binode->runtime_flags);  in start_delalloc_inodes()
9474 				ret = -ENOMEM;  in start_delalloc_inodes()
9477 			list_add_tail(&work->list, &works);  in start_delalloc_inodes()
9478 			btrfs_queue_work(root->fs_info->flush_workers,  in start_delalloc_inodes()
9479 					 &work->work);  in start_delalloc_inodes()
9484 				     &BTRFS_I(inode)->runtime_flags))  in start_delalloc_inodes()
9487 			if (ret || wbc->nr_to_write <= 0)  in start_delalloc_inodes()
9491 		spin_lock(&root->delalloc_lock);  in start_delalloc_inodes()
9493 	spin_unlock(&root->delalloc_lock);  in start_delalloc_inodes()
9497 		list_del_init(&work->list);  in start_delalloc_inodes()
9498 		wait_for_completion(&work->completion);  in start_delalloc_inodes()
9503 		spin_lock(&root->delalloc_lock);  in start_delalloc_inodes()
9504 		list_splice_tail(&splice, &root->delalloc_inodes);  in start_delalloc_inodes()
9505 		spin_unlock(&root->delalloc_lock);  in start_delalloc_inodes()
9507 	mutex_unlock(&root->delalloc_mutex);  in start_delalloc_inodes()
9519 	struct btrfs_fs_info *fs_info = root->fs_info;  in btrfs_start_delalloc_snapshot()
9521 	if (test_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state))  in btrfs_start_delalloc_snapshot()
9522 		return -EROFS;  in btrfs_start_delalloc_snapshot()
9540 	if (test_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state))  in btrfs_start_delalloc_roots()
9541 		return -EROFS;  in btrfs_start_delalloc_roots()
9545 	mutex_lock(&fs_info->delalloc_root_mutex);  in btrfs_start_delalloc_roots()
9546 	spin_lock(&fs_info->delalloc_root_lock);  in btrfs_start_delalloc_roots()
9547 	list_splice_init(&fs_info->delalloc_roots, &splice);  in btrfs_start_delalloc_roots()
9560 		list_move_tail(&root->delalloc_root,  in btrfs_start_delalloc_roots()
9561 			       &fs_info->delalloc_roots);  in btrfs_start_delalloc_roots()
9562 		spin_unlock(&fs_info->delalloc_root_lock);  in btrfs_start_delalloc_roots()
9568 		spin_lock(&fs_info->delalloc_root_lock);  in btrfs_start_delalloc_roots()
9570 	spin_unlock(&fs_info->delalloc_root_lock);  in btrfs_start_delalloc_roots()
9575 		spin_lock(&fs_info->delalloc_root_lock);  in btrfs_start_delalloc_roots()
9576 		list_splice_tail(&splice, &fs_info->delalloc_roots);  in btrfs_start_delalloc_roots()
9577 		spin_unlock(&fs_info->delalloc_root_lock);  in btrfs_start_delalloc_roots()
9579 	mutex_unlock(&fs_info->delalloc_root_mutex);  in btrfs_start_delalloc_roots()
9586 	struct btrfs_fs_info *fs_info = btrfs_sb(dir->i_sb);  in btrfs_symlink()
9588 	struct btrfs_root *root = BTRFS_I(dir)->root;  in btrfs_symlink()
9603 		return -ENAMETOOLONG;  in btrfs_symlink()
9620 	inode = btrfs_new_inode(trans, root, dir, dentry->d_name.name,  in btrfs_symlink()
9621 				dentry->d_name.len, btrfs_ino(BTRFS_I(dir)),  in btrfs_symlink()
9635 	inode->i_fop = &btrfs_file_operations;  in btrfs_symlink()
9636 	inode->i_op = &btrfs_file_inode_operations;  in btrfs_symlink()
9637 	inode->i_mapping->a_ops = &btrfs_aops;  in btrfs_symlink()
9639 	err = btrfs_init_inode_security(trans, inode, dir, &dentry->d_name);  in btrfs_symlink()
9645 		err = -ENOMEM;  in btrfs_symlink()
9658 	leaf = path->nodes[0];  in btrfs_symlink()
9659 	ei = btrfs_item_ptr(leaf, path->slots[0],  in btrfs_symlink()
9661 	btrfs_set_file_extent_generation(leaf, ei, trans->transid);  in btrfs_symlink()
9674 	inode->i_op = &btrfs_symlink_inode_operations;  in btrfs_symlink()
9711 	u64 start = ins->objectid;  in insert_prealloc_file_extent()
9712 	u64 len = ins->offset;  in insert_prealloc_file_extent()
9749 		return ERR_PTR(-ENOMEM);  in insert_prealloc_file_extent()
9752 				     file_offset + len - 1, &extent_info,  in insert_prealloc_file_extent()
9766 	struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);  in __btrfs_prealloc_file_range()
9767 	struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;  in __btrfs_prealloc_file_range()
9769 	struct btrfs_root *root = BTRFS_I(inode)->root;  in __btrfs_prealloc_file_range()
9775 	u64 last_alloc = (u64)-1;  in __btrfs_prealloc_file_range()
9778 	u64 end = start + num_bytes - 1;  in __btrfs_prealloc_file_range()
9799 		 * ->bytes_may_use to ->bytes_reserved.  Any error that happens  in __btrfs_prealloc_file_range()
9823 					cur_offset + ins.offset -1, 0);  in __btrfs_prealloc_file_range()
9828 				&BTRFS_I(inode)->runtime_flags);  in __btrfs_prealloc_file_range()
9832 		em->start = cur_offset;  in __btrfs_prealloc_file_range()
9833 		em->orig_start = cur_offset;  in __btrfs_prealloc_file_range()
9834 		em->len = ins.offset;  in __btrfs_prealloc_file_range()
9835 		em->block_start = ins.objectid;  in __btrfs_prealloc_file_range()
9836 		em->block_len = ins.offset;  in __btrfs_prealloc_file_range()
9837 		em->orig_block_len = ins.offset;  in __btrfs_prealloc_file_range()
9838 		em->ram_bytes = ins.offset;  in __btrfs_prealloc_file_range()
9839 		set_bit(EXTENT_FLAG_PREALLOC, &em->flags);  in __btrfs_prealloc_file_range()
9840 		em->generation = trans->transid;  in __btrfs_prealloc_file_range()
9843 			write_lock(&em_tree->lock);  in __btrfs_prealloc_file_range()
9845 			write_unlock(&em_tree->lock);  in __btrfs_prealloc_file_range()
9846 			if (ret != -EEXIST)  in __btrfs_prealloc_file_range()
9849 						cur_offset + ins.offset - 1,  in __btrfs_prealloc_file_range()
9854 		num_bytes -= ins.offset;  in __btrfs_prealloc_file_range()
9859 		inode->i_ctime = current_time(inode);  in __btrfs_prealloc_file_range()
9860 		BTRFS_I(inode)->flags |= BTRFS_INODE_PREALLOC;  in __btrfs_prealloc_file_range()
9862 		    (actual_len > inode->i_size) &&  in __btrfs_prealloc_file_range()
9863 		    (cur_offset > inode->i_size)) {  in __btrfs_prealloc_file_range()
9888 			end - clear_offset + 1);  in __btrfs_prealloc_file_range()
9917 	struct btrfs_root *root = BTRFS_I(inode)->root;  in btrfs_permission()
9918 	umode_t mode = inode->i_mode;  in btrfs_permission()
9923 			return -EROFS;  in btrfs_permission()
9924 		if (BTRFS_I(inode)->flags & BTRFS_INODE_READONLY)  in btrfs_permission()
9925 			return -EACCES;  in btrfs_permission()
9932 	struct btrfs_fs_info *fs_info = btrfs_sb(dir->i_sb);  in btrfs_tmpfile()
9934 	struct btrfs_root *root = BTRFS_I(dir)->root;  in btrfs_tmpfile()
9959 	inode->i_fop = &btrfs_file_operations;  in btrfs_tmpfile()
9960 	inode->i_op = &btrfs_file_inode_operations;  in btrfs_tmpfile()
9962 	inode->i_mapping->a_ops = &btrfs_aops;  in btrfs_tmpfile()
9980 	 *    d_tmpfile() -> inode_dec_link_count() -> drop_nlink()  in btrfs_tmpfile()
9996 	struct inode *inode = tree->private_data;  in btrfs_set_range_writeback()
10002 		page = find_get_page(inode->i_mapping, index);  in btrfs_set_range_writeback()
10019 	struct btrfs_fs_info *fs_info = BTRFS_I(inode)->root->fs_info;  in btrfs_add_swapfile_pin()
10026 		return -ENOMEM;  in btrfs_add_swapfile_pin()
10027 	sp->ptr = ptr;  in btrfs_add_swapfile_pin()
10028 	sp->inode = inode;  in btrfs_add_swapfile_pin()
10029 	sp->is_block_group = is_block_group;  in btrfs_add_swapfile_pin()
10030 	sp->bg_extent_count = 1;  in btrfs_add_swapfile_pin()
10032 	spin_lock(&fs_info->swapfile_pins_lock);  in btrfs_add_swapfile_pin()
10033 	p = &fs_info->swapfile_pins.rb_node;  in btrfs_add_swapfile_pin()
10037 		if (sp->ptr < entry->ptr ||  in btrfs_add_swapfile_pin()
10038 		    (sp->ptr == entry->ptr && sp->inode < entry->inode)) {  in btrfs_add_swapfile_pin()
10039 			p = &(*p)->rb_left;  in btrfs_add_swapfile_pin()
10040 		} else if (sp->ptr > entry->ptr ||  in btrfs_add_swapfile_pin()
10041 			   (sp->ptr == entry->ptr && sp->inode > entry->inode)) {  in btrfs_add_swapfile_pin()
10042 			p = &(*p)->rb_right;  in btrfs_add_swapfile_pin()
10045 				entry->bg_extent_count++;  in btrfs_add_swapfile_pin()
10046 			spin_unlock(&fs_info->swapfile_pins_lock);  in btrfs_add_swapfile_pin()
10051 	rb_link_node(&sp->node, parent, p);  in btrfs_add_swapfile_pin()
10052 	rb_insert_color(&sp->node, &fs_info->swapfile_pins);  in btrfs_add_swapfile_pin()
10053 	spin_unlock(&fs_info->swapfile_pins_lock);  in btrfs_add_swapfile_pin()
10060 	struct btrfs_fs_info *fs_info = BTRFS_I(inode)->root->fs_info;  in btrfs_free_swapfile_pins()
10064 	spin_lock(&fs_info->swapfile_pins_lock);  in btrfs_free_swapfile_pins()
10065 	node = rb_first(&fs_info->swapfile_pins);  in btrfs_free_swapfile_pins()
10069 		if (sp->inode == inode) {  in btrfs_free_swapfile_pins()
10070 			rb_erase(&sp->node, &fs_info->swapfile_pins);  in btrfs_free_swapfile_pins()
10071 			if (sp->is_block_group) {  in btrfs_free_swapfile_pins()
10072 				btrfs_dec_block_group_swap_extents(sp->ptr,  in btrfs_free_swapfile_pins()
10073 							   sp->bg_extent_count);  in btrfs_free_swapfile_pins()
10074 				btrfs_put_block_group(sp->ptr);  in btrfs_free_swapfile_pins()
10080 	spin_unlock(&fs_info->swapfile_pins_lock);  in btrfs_free_swapfile_pins()
10106 	if (bsi->nr_pages >= sis->max)  in btrfs_add_swap_extent()
10109 	max_pages = sis->max - bsi->nr_pages;  in btrfs_add_swap_extent()
10110 	first_ppage = ALIGN(bsi->block_start, PAGE_SIZE) >> PAGE_SHIFT;  in btrfs_add_swap_extent()
10111 	next_ppage = ALIGN_DOWN(bsi->block_start + bsi->block_len,  in btrfs_add_swap_extent()
10116 	nr_pages = next_ppage - first_ppage;  in btrfs_add_swap_extent()
10120 	if (bsi->start == 0)  in btrfs_add_swap_extent()
10122 	if (bsi->lowest_ppage > first_ppage_reported)  in btrfs_add_swap_extent()
10123 		bsi->lowest_ppage = first_ppage_reported;  in btrfs_add_swap_extent()
10124 	if (bsi->highest_ppage < (next_ppage - 1))  in btrfs_add_swap_extent()
10125 		bsi->highest_ppage = next_ppage - 1;  in btrfs_add_swap_extent()
10127 	ret = add_swap_extent(sis, bsi->nr_pages, nr_pages, first_ppage);  in btrfs_add_swap_extent()
10130 	bsi->nr_extents += ret;  in btrfs_add_swap_extent()
10131 	bsi->nr_pages += nr_pages;  in btrfs_add_swap_extent()
10140 	atomic_dec(&BTRFS_I(inode)->root->nr_swapfiles);  in btrfs_swap_deactivate()
10147 	struct btrfs_root *root = BTRFS_I(inode)->root;  in btrfs_swap_activate()
10148 	struct btrfs_fs_info *fs_info = root->fs_info;  in btrfs_swap_activate()
10149 	struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;  in btrfs_swap_activate()
10154 		.lowest_ppage = (sector_t)-1ULL,  in btrfs_swap_activate()
10165 	ret = btrfs_wait_ordered_range(inode, 0, (u64)-1);  in btrfs_swap_activate()
10172 	if (BTRFS_I(inode)->flags & BTRFS_INODE_COMPRESS) {  in btrfs_swap_activate()
10174 		return -EINVAL;  in btrfs_swap_activate()
10176 	if (!(BTRFS_I(inode)->flags & BTRFS_INODE_NODATACOW)) {  in btrfs_swap_activate()
10177 		btrfs_warn(fs_info, "swapfile must not be copy-on-write");  in btrfs_swap_activate()
10178 		return -EINVAL;  in btrfs_swap_activate()
10180 	if (!(BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM)) {  in btrfs_swap_activate()
10182 		return -EINVAL;  in btrfs_swap_activate()
10189 	 * fs_info->swapfile_pins prevents them from running while the swap  in btrfs_swap_activate()
10197 		return -EBUSY;  in btrfs_swap_activate()
10207 	if (!btrfs_drew_try_write_lock(&root->snapshot_lock)) {  in btrfs_swap_activate()
10211 		return -EINVAL;  in btrfs_swap_activate()
10219 	atomic_inc(&root->nr_swapfiles);  in btrfs_swap_activate()
10221 	isize = ALIGN_DOWN(inode->i_size, fs_info->sectorsize);  in btrfs_swap_activate()
10223 	lock_extent_bits(io_tree, 0, isize - 1, &cached_state);  in btrfs_swap_activate()
10228 		u64 len = isize - start;  in btrfs_swap_activate()
10236 		if (em->block_start == EXTENT_MAP_HOLE) {  in btrfs_swap_activate()
10238 			ret = -EINVAL;  in btrfs_swap_activate()
10241 		if (em->block_start == EXTENT_MAP_INLINE) {  in btrfs_swap_activate()
10250 			ret = -EINVAL;  in btrfs_swap_activate()
10253 		if (test_bit(EXTENT_FLAG_COMPRESSED, &em->flags)) {  in btrfs_swap_activate()
10255 			ret = -EINVAL;  in btrfs_swap_activate()
10259 		logical_block_start = em->block_start + (start - em->start);  in btrfs_swap_activate()
10260 		len = min(len, em->len - (start - em->start));  in btrfs_swap_activate()
10271 				   "swapfile must not be copy-on-write");  in btrfs_swap_activate()
10272 			ret = -EINVAL;  in btrfs_swap_activate()
10282 		if (em->map_lookup->type & BTRFS_BLOCK_GROUP_PROFILE_MASK) {  in btrfs_swap_activate()
10285 			ret = -EINVAL;  in btrfs_swap_activate()
10290 			device = em->map_lookup->stripes[0].dev;  in btrfs_swap_activate()
10296 		} else if (device != em->map_lookup->stripes[0].dev) {  in btrfs_swap_activate()
10298 			ret = -EINVAL;  in btrfs_swap_activate()
10302 		physical_block_start = (em->map_lookup->stripes[0].physical +  in btrfs_swap_activate()
10303 					(logical_block_start - em->start));  in btrfs_swap_activate()
10304 		len = min(len, em->len - (logical_block_start - em->start));  in btrfs_swap_activate()
10312 			ret = -EINVAL;  in btrfs_swap_activate()
10318 			   "block group for swapfile at %llu is read-only%s",  in btrfs_swap_activate()
10319 			   bg->start,  in btrfs_swap_activate()
10320 			   atomic_read(&fs_info->scrubs_running) ?  in btrfs_swap_activate()
10323 			ret = -EINVAL;  in btrfs_swap_activate()
10360 	unlock_extent_cached(io_tree, 0, isize - 1, &cached_state);  in btrfs_swap_activate()
10365 	btrfs_drew_write_unlock(&root->snapshot_lock);  in btrfs_swap_activate()
10373 		sis->bdev = device->bdev;  in btrfs_swap_activate()
10374 	*span = bsi.highest_ppage - bsi.lowest_ppage + 1;  in btrfs_swap_activate()
10375 	sis->max = bsi.nr_pages;  in btrfs_swap_activate()
10376 	sis->pages = bsi.nr_pages - 1;  in btrfs_swap_activate()
10377 	sis->highest_bit = bsi.nr_pages - 1;  in btrfs_swap_activate()
10388 	return -EOPNOTSUPP;  in btrfs_swap_activate()