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()
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()
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()
971  * it to make sure we don't do extra locks or unlocks.
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()
998 		ret = -EINVAL;  in cow_file_range()
1002 	num_bytes = ALIGN(end - start + 1, blocksize);  in cow_file_range()
1004 	ASSERT(num_bytes <= btrfs_super_total_bytes(fs_info->super_copy));  in cow_file_range()
1026 			     (end - start + PAGE_SIZE) / PAGE_SIZE;  in cow_file_range()
1035 	btrfs_drop_extent_cache(inode, start, start + num_bytes - 1, 0);  in cow_file_range()
1048 	if (root->root_key.objectid == BTRFS_DATA_RELOC_TREE_OBJECTID)  in cow_file_range()
1051 		min_alloc_size = fs_info->sectorsize;  in cow_file_range()
1083 		if (root->root_key.objectid ==  in cow_file_range()
1100 						start + ram_size - 1, 0);  in cow_file_range()
1115 		extent_clear_unlock_delalloc(inode, start, start + ram_size - 1,  in cow_file_range()
1122 			num_bytes -= cur_alloc_size;  in cow_file_range()
1139 	btrfs_drop_extent_cache(inode, start, start + ram_size - 1, 0);  in cow_file_range()
1160 					     start + cur_alloc_size - 1,  in cow_file_range()
1186 		btrfs_add_delayed_iput(async_chunk->inode);  in async_cow_start()
1187 		async_chunk->inode = NULL;  in async_cow_start()
1201 	nr_pages = (async_chunk->end - async_chunk->start + PAGE_SIZE) >>  in async_cow_submit()
1205 	 * ->inode could be NULL if async_chunk_start has failed to compress,  in async_cow_submit()
1207 	 * always adjust ->async_delalloc_pages as its paired with the init  in async_cow_submit()
1210 	if (async_chunk->inode)  in async_cow_submit()
1214 	if (atomic_sub_return(nr_pages, &fs_info->async_delalloc_pages) <  in async_cow_submit()
1216 		cond_wake_up_nomb(&fs_info->async_submit_wait);  in async_cow_submit()
1224 	if (async_chunk->inode)  in async_cow_free()
1225 		btrfs_add_delayed_iput(async_chunk->inode);  in async_cow_free()
1226 	if (async_chunk->blkcg_css)  in async_cow_free()
1227 		css_put(async_chunk->blkcg_css);  in async_cow_free()
1232 	if (atomic_dec_and_test(async_chunk->pending))  in async_cow_free()
1233 		kvfree(async_chunk->pending);  in async_cow_free()
1242 	struct btrfs_fs_info *fs_info = inode->root->fs_info;  in cow_file_range_async()
1248 	u64 num_chunks = DIV_ROUND_UP(end - start, SZ_512K);  in cow_file_range_async()
1254 	unlock_extent(&inode->io_tree, start, end);  in cow_file_range_async()
1256 	if (inode->flags & BTRFS_INODE_NOCOMPRESS &&  in cow_file_range_async()
1278 		return -ENOMEM;  in cow_file_range_async()
1281 	async_chunk = ctx->chunks;  in cow_file_range_async()
1282 	atomic_set(&ctx->num_chunks, num_chunks);  in cow_file_range_async()
1286 			cur_end = min(end, start + SZ_512K - 1);  in cow_file_range_async()
1294 		ihold(&inode->vfs_inode);  in cow_file_range_async()
1295 		async_chunk[i].pending = &ctx->num_chunks;  in cow_file_range_async()
1296 		async_chunk[i].inode = &inode->vfs_inode;  in cow_file_range_async()
1322 						 cur_end - start);  in cow_file_range_async()
1339 		nr_pages = DIV_ROUND_UP(cur_end - start, PAGE_SIZE);  in cow_file_range_async()
1340 		atomic_add(nr_pages, &fs_info->async_delalloc_pages);  in cow_file_range_async()
1342 		btrfs_queue_work(fs_info->delalloc_workers, &async_chunk[i].work);  in cow_file_range_async()
1358 	ret = btrfs_lookup_csums_range(fs_info->csum_root, bytenr,  in csum_exist_in_range()
1359 				       bytenr + num_bytes - 1, &list, 0);  in csum_exist_in_range()
1365 		list_del(&sums->list);  in csum_exist_in_range()
1378 	const bool is_reloc_ino = (inode->root->root_key.objectid ==  in fallback_to_cow()
1380 	const u64 range_bytes = end + 1 - start;  in fallback_to_cow()
1381 	struct extent_io_tree *io_tree = &inode->io_tree;  in fallback_to_cow()
1421 		struct btrfs_fs_info *fs_info = inode->root->fs_info;  in fallback_to_cow()
1422 		struct btrfs_space_info *sinfo = fs_info->data_sinfo;  in fallback_to_cow()
1427 		spin_lock(&sinfo->lock);  in fallback_to_cow()
1429 		spin_unlock(&sinfo->lock);  in fallback_to_cow()
1453 	struct btrfs_fs_info *fs_info = inode->root->fs_info;  in run_delalloc_nocow()
1454 	struct btrfs_root *root = inode->root;  in run_delalloc_nocow()
1456 	u64 cow_start = (u64)-1;  in run_delalloc_nocow()
1474 		return -ENOMEM;  in run_delalloc_nocow()
1500 		if (ret > 0 && path->slots[0] > 0 && check_prev) {  in run_delalloc_nocow()
1501 			leaf = path->nodes[0];  in run_delalloc_nocow()
1503 					      path->slots[0] - 1);  in run_delalloc_nocow()
1506 				path->slots[0]--;  in run_delalloc_nocow()
1511 		leaf = path->nodes[0];  in run_delalloc_nocow()
1512 		if (path->slots[0] >= btrfs_header_nritems(leaf)) {  in run_delalloc_nocow()
1515 				if (cow_start != (u64)-1)  in run_delalloc_nocow()
1521 			leaf = path->nodes[0];  in run_delalloc_nocow()
1524 		btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);  in run_delalloc_nocow()
1535 			path->slots[0]++;  in run_delalloc_nocow()
1558 		fi = btrfs_item_ptr(leaf, path->slots[0],  in run_delalloc_nocow()
1576 				path->slots[0]++;  in run_delalloc_nocow()
1596 			    btrfs_root_last_snapshot(&root->root_item))  in run_delalloc_nocow()
1604 						    found_key.offset -  in run_delalloc_nocow()
1608 				 * ret could be -EIO if the above fails to read  in run_delalloc_nocow()
1612 					if (cow_start != (u64)-1)  in run_delalloc_nocow()
1621 			disk_bytenr += cur_offset - found_key.offset;  in run_delalloc_nocow()
1622 			num_bytes = min(end + 1, extent_end) - cur_offset;  in run_delalloc_nocow()
1627 			if (!freespace_inode && atomic_read(&root->snapshot_force_cow))  in run_delalloc_nocow()
1638 				 * ret could be -EIO if the above fails to read  in run_delalloc_nocow()
1642 					if (cow_start != (u64)-1)  in run_delalloc_nocow()
1654 			extent_end = ALIGN(extent_end, fs_info->sectorsize);  in run_delalloc_nocow()
1657 				path->slots[0]++;  in run_delalloc_nocow()
1670 			if (cow_start == (u64)-1)  in run_delalloc_nocow()
1675 			path->slots[0]++;  in run_delalloc_nocow()
1682 		 * COW range from cow_start to found_key.offset - 1. As the key  in run_delalloc_nocow()
1686 		if (cow_start != (u64)-1) {  in run_delalloc_nocow()
1688 					      cow_start, found_key.offset - 1,  in run_delalloc_nocow()
1692 			cow_start = (u64)-1;  in run_delalloc_nocow()
1696 			u64 orig_start = found_key.offset - extent_offset;  in run_delalloc_nocow()
1717 							cur_offset + num_bytes - 1,  in run_delalloc_nocow()
1734 		if (root->root_key.objectid ==  in run_delalloc_nocow()
1745 					     cur_offset + num_bytes - 1,  in run_delalloc_nocow()
1765 	if (cur_offset <= end && cow_start == (u64)-1)  in run_delalloc_nocow()
1768 	if (cow_start != (u64)-1) {  in run_delalloc_nocow()
1795 	if (!(inode->flags & BTRFS_INODE_NODATACOW) &&  in need_force_cow()
1796 	    !(inode->flags & BTRFS_INODE_PREALLOC))  in need_force_cow()
1804 	if (inode->defrag_bytes &&  in need_force_cow()
1805 	    test_range_bit(&inode->io_tree, start, end, EXTENT_DEFRAG, 0, NULL))  in need_force_cow()
1822 	if (inode->flags & BTRFS_INODE_NODATACOW && !force_cow) {  in btrfs_run_delalloc_range()
1825 	} else if (inode->flags & BTRFS_INODE_PREALLOC && !force_cow) {  in btrfs_run_delalloc_range()
1833 		set_bit(BTRFS_INODE_HAS_ASYNC_EXTENT, &inode->runtime_flags);  in btrfs_run_delalloc_range()
1839 					      end - start + 1);  in btrfs_run_delalloc_range()
1849 	if (!(orig->state & EXTENT_DELALLOC))  in btrfs_split_delalloc_extent()
1852 	size = orig->end - orig->start + 1;  in btrfs_split_delalloc_extent()
1861 		new_size = orig->end - split + 1;  in btrfs_split_delalloc_extent()
1863 		new_size = split - orig->start;  in btrfs_split_delalloc_extent()
1869 	spin_lock(&BTRFS_I(inode)->lock);  in btrfs_split_delalloc_extent()
1871 	spin_unlock(&BTRFS_I(inode)->lock);  in btrfs_split_delalloc_extent()
1886 	if (!(other->state & EXTENT_DELALLOC))  in btrfs_merge_delalloc_extent()
1889 	if (new->start > other->start)  in btrfs_merge_delalloc_extent()
1890 		new_size = new->end - other->start + 1;  in btrfs_merge_delalloc_extent()
1892 		new_size = other->end - new->start + 1;  in btrfs_merge_delalloc_extent()
1896 		spin_lock(&BTRFS_I(inode)->lock);  in btrfs_merge_delalloc_extent()
1897 		btrfs_mod_outstanding_extents(BTRFS_I(inode), -1);  in btrfs_merge_delalloc_extent()
1898 		spin_unlock(&BTRFS_I(inode)->lock);  in btrfs_merge_delalloc_extent()
1920 	old_size = other->end - other->start + 1;  in btrfs_merge_delalloc_extent()
1922 	old_size = new->end - new->start + 1;  in btrfs_merge_delalloc_extent()
1927 	spin_lock(&BTRFS_I(inode)->lock);  in btrfs_merge_delalloc_extent()
1928 	btrfs_mod_outstanding_extents(BTRFS_I(inode), -1);  in btrfs_merge_delalloc_extent()
1929 	spin_unlock(&BTRFS_I(inode)->lock);  in btrfs_merge_delalloc_extent()
1935 	struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);  in btrfs_add_delalloc_inodes()
1937 	spin_lock(&root->delalloc_lock);  in btrfs_add_delalloc_inodes()
1938 	if (list_empty(&BTRFS_I(inode)->delalloc_inodes)) {  in btrfs_add_delalloc_inodes()
1939 		list_add_tail(&BTRFS_I(inode)->delalloc_inodes,  in btrfs_add_delalloc_inodes()
1940 			      &root->delalloc_inodes);  in btrfs_add_delalloc_inodes()
1942 			&BTRFS_I(inode)->runtime_flags);  in btrfs_add_delalloc_inodes()
1943 		root->nr_delalloc_inodes++;  in btrfs_add_delalloc_inodes()
1944 		if (root->nr_delalloc_inodes == 1) {  in btrfs_add_delalloc_inodes()
1945 			spin_lock(&fs_info->delalloc_root_lock);  in btrfs_add_delalloc_inodes()
1946 			BUG_ON(!list_empty(&root->delalloc_root));  in btrfs_add_delalloc_inodes()
1947 			list_add_tail(&root->delalloc_root,  in btrfs_add_delalloc_inodes()
1948 				      &fs_info->delalloc_roots);  in btrfs_add_delalloc_inodes()
1949 			spin_unlock(&fs_info->delalloc_root_lock);  in btrfs_add_delalloc_inodes()
1952 	spin_unlock(&root->delalloc_lock);  in btrfs_add_delalloc_inodes()
1959 	struct btrfs_fs_info *fs_info = root->fs_info;  in __btrfs_del_delalloc_inode()
1961 	if (!list_empty(&inode->delalloc_inodes)) {  in __btrfs_del_delalloc_inode()
1962 		list_del_init(&inode->delalloc_inodes);  in __btrfs_del_delalloc_inode()
1964 			  &inode->runtime_flags);  in __btrfs_del_delalloc_inode()
1965 		root->nr_delalloc_inodes--;  in __btrfs_del_delalloc_inode()
1966 		if (!root->nr_delalloc_inodes) {  in __btrfs_del_delalloc_inode()
1967 			ASSERT(list_empty(&root->delalloc_inodes));  in __btrfs_del_delalloc_inode()
1968 			spin_lock(&fs_info->delalloc_root_lock);  in __btrfs_del_delalloc_inode()
1969 			BUG_ON(list_empty(&root->delalloc_root));  in __btrfs_del_delalloc_inode()
1970 			list_del_init(&root->delalloc_root);  in __btrfs_del_delalloc_inode()
1971 			spin_unlock(&fs_info->delalloc_root_lock);  in __btrfs_del_delalloc_inode()
1979 	spin_lock(&root->delalloc_lock);  in btrfs_del_delalloc_inode()
1981 	spin_unlock(&root->delalloc_lock);  in btrfs_del_delalloc_inode()
1991 	struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);  in btrfs_set_delalloc_extent()
2000 	if (!(state->state & EXTENT_DELALLOC) && (*bits & EXTENT_DELALLOC)) {  in btrfs_set_delalloc_extent()
2001 		struct btrfs_root *root = BTRFS_I(inode)->root;  in btrfs_set_delalloc_extent()
2002 		u64 len = state->end + 1 - state->start;  in btrfs_set_delalloc_extent()
2006 		spin_lock(&BTRFS_I(inode)->lock);  in btrfs_set_delalloc_extent()
2008 		spin_unlock(&BTRFS_I(inode)->lock);  in btrfs_set_delalloc_extent()
2014 		percpu_counter_add_batch(&fs_info->delalloc_bytes, len,  in btrfs_set_delalloc_extent()
2015 					 fs_info->delalloc_batch);  in btrfs_set_delalloc_extent()
2016 		spin_lock(&BTRFS_I(inode)->lock);  in btrfs_set_delalloc_extent()
2017 		BTRFS_I(inode)->delalloc_bytes += len;  in btrfs_set_delalloc_extent()
2019 			BTRFS_I(inode)->defrag_bytes += len;  in btrfs_set_delalloc_extent()
2021 					 &BTRFS_I(inode)->runtime_flags))  in btrfs_set_delalloc_extent()
2023 		spin_unlock(&BTRFS_I(inode)->lock);  in btrfs_set_delalloc_extent()
2026 	if (!(state->state & EXTENT_DELALLOC_NEW) &&  in btrfs_set_delalloc_extent()
2028 		spin_lock(&BTRFS_I(inode)->lock);  in btrfs_set_delalloc_extent()
2029 		BTRFS_I(inode)->new_delalloc_bytes += state->end + 1 -  in btrfs_set_delalloc_extent()
2030 			state->start;  in btrfs_set_delalloc_extent()
2031 		spin_unlock(&BTRFS_I(inode)->lock);  in btrfs_set_delalloc_extent()
2043 	struct btrfs_fs_info *fs_info = btrfs_sb(vfs_inode->i_sb);  in btrfs_clear_delalloc_extent()
2044 	u64 len = state->end + 1 - state->start;  in btrfs_clear_delalloc_extent()
2047 	if ((state->state & EXTENT_DEFRAG) && (*bits & EXTENT_DEFRAG)) {  in btrfs_clear_delalloc_extent()
2048 		spin_lock(&inode->lock);  in btrfs_clear_delalloc_extent()
2049 		inode->defrag_bytes -= len;  in btrfs_clear_delalloc_extent()
2050 		spin_unlock(&inode->lock);  in btrfs_clear_delalloc_extent()
2058 	if ((state->state & EXTENT_DELALLOC) && (*bits & EXTENT_DELALLOC)) {  in btrfs_clear_delalloc_extent()
2059 		struct btrfs_root *root = inode->root;  in btrfs_clear_delalloc_extent()
2062 		spin_lock(&inode->lock);  in btrfs_clear_delalloc_extent()
2063 		btrfs_mod_outstanding_extents(inode, -num_extents);  in btrfs_clear_delalloc_extent()
2064 		spin_unlock(&inode->lock);  in btrfs_clear_delalloc_extent()
2072 		    root != fs_info->tree_root)  in btrfs_clear_delalloc_extent()
2079 		if (root->root_key.objectid != BTRFS_DATA_RELOC_TREE_OBJECTID &&  in btrfs_clear_delalloc_extent()
2080 		    do_list && !(state->state & EXTENT_NORESERVE) &&  in btrfs_clear_delalloc_extent()
2084 		percpu_counter_add_batch(&fs_info->delalloc_bytes, -len,  in btrfs_clear_delalloc_extent()
2085 					 fs_info->delalloc_batch);  in btrfs_clear_delalloc_extent()
2086 		spin_lock(&inode->lock);  in btrfs_clear_delalloc_extent()
2087 		inode->delalloc_bytes -= len;  in btrfs_clear_delalloc_extent()
2088 		if (do_list && inode->delalloc_bytes == 0 &&  in btrfs_clear_delalloc_extent()
2090 					&inode->runtime_flags))  in btrfs_clear_delalloc_extent()
2092 		spin_unlock(&inode->lock);  in btrfs_clear_delalloc_extent()
2095 	if ((state->state & EXTENT_DELALLOC_NEW) &&  in btrfs_clear_delalloc_extent()
2097 		spin_lock(&inode->lock);  in btrfs_clear_delalloc_extent()
2098 		ASSERT(inode->new_delalloc_bytes >= len);  in btrfs_clear_delalloc_extent()
2099 		inode->new_delalloc_bytes -= len;  in btrfs_clear_delalloc_extent()
2100 		spin_unlock(&inode->lock);  in btrfs_clear_delalloc_extent()
2105  * btrfs_bio_fits_in_stripe - Checks whether the size of the given bio will fit
2109  * @page - The page we are about to add to the bio
2110  * @size - size we want to add to the bio
2111  * @bio - bio we want to ensure is smaller than a stripe
2112  * @bio_flags - flags of the bio
2121 	struct inode *inode = page->mapping->host;  in btrfs_bio_fits_in_stripe()
2122 	struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);  in btrfs_bio_fits_in_stripe()
2123 	u64 logical = (u64)bio->bi_iter.bi_sector << 9;  in btrfs_bio_fits_in_stripe()
2132 	length = bio->bi_iter.bi_size;  in btrfs_bio_fits_in_stripe()
2170  *    c-1) if bio is issued by fsync:	sync submit
2173  *    c-2) if root is reloc root:	sync submit
2176  *    c-3) otherwise:			async submit
2182 	struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);  in btrfs_submit_data_bio()
2183 	struct btrfs_root *root = BTRFS_I(inode)->root;  in btrfs_submit_data_bio()
2187 	int async = !atomic_read(&BTRFS_I(inode)->sync_writers);  in btrfs_submit_data_bio()
2189 	skip_sum = BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM;  in btrfs_submit_data_bio()
2205 			ret = btrfs_lookup_bio_sums(inode, bio, (u64)-1, NULL);  in btrfs_submit_data_bio()
2212 		if (root->root_key.objectid == BTRFS_DATA_RELOC_TREE_OBJECTID)  in btrfs_submit_data_bio()
2229 		bio->bi_status = ret;  in btrfs_submit_data_bio()
2246 		trans->adding_csums = true;  in add_pending_csums()
2247 		ret = btrfs_csum_file_blocks(trans, trans->fs_info->csum_root, sum);  in add_pending_csums()
2248 		trans->adding_csums = false;  in add_pending_csums()
2261 	const u64 end = start + len - 1;  in btrfs_find_new_delalloc_bytes()
2264 		const u64 search_len = end - search_start + 1;  in btrfs_find_new_delalloc_bytes()
2273 		if (em->block_start != EXTENT_MAP_HOLE)  in btrfs_find_new_delalloc_bytes()
2276 		em_len = em->len;  in btrfs_find_new_delalloc_bytes()
2277 		if (em->start < search_start)  in btrfs_find_new_delalloc_bytes()
2278 			em_len -= search_start - em->start;  in btrfs_find_new_delalloc_bytes()
2282 		ret = set_extent_bit(&inode->io_tree, search_start,  in btrfs_find_new_delalloc_bytes()
2283 				     search_start + em_len - 1,  in btrfs_find_new_delalloc_bytes()
2301 	if (start >= i_size_read(&inode->vfs_inode) &&  in btrfs_set_extent_delalloc()
2302 	    !(inode->flags & BTRFS_INODE_PREALLOC)) {  in btrfs_set_extent_delalloc()
2312 						    end + 1 - start,  in btrfs_set_extent_delalloc()
2318 	return set_extent_delalloc(&inode->io_tree, start, end, extra_bits,  in btrfs_set_extent_delalloc()
2343 	page = fixup->page;  in btrfs_writepage_fixup_worker()
2344 	inode = BTRFS_I(fixup->inode);  in btrfs_writepage_fixup_worker()
2346 	page_end = page_offset(page) + PAGE_SIZE - 1;  in btrfs_writepage_fixup_worker()
2359 	 * page->mapping may go NULL, but it shouldn't be moved to a different  in btrfs_writepage_fixup_worker()
2362 	if (!page->mapping || !PageDirty(page) || !PageChecked(page)) {  in btrfs_writepage_fixup_worker()
2397 	lock_extent_bits(&inode->io_tree, page_start, page_end, &cached_state);  in btrfs_writepage_fixup_worker()
2405 		unlock_extent_cached(&inode->io_tree, page_start, page_end,  in btrfs_writepage_fixup_worker()
2432 	unlock_extent_cached(&inode->io_tree, page_start, page_end,  in btrfs_writepage_fixup_worker()
2440 		mapping_set_error(page->mapping, ret);  in btrfs_writepage_fixup_worker()
2455 	btrfs_add_delayed_iput(&inode->vfs_inode);  in btrfs_writepage_fixup_worker()
2471 	struct inode *inode = page->mapping->host;  in btrfs_writepage_cow_fixup()
2472 	struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);  in btrfs_writepage_cow_fixup()
2487 		return -EAGAIN;  in btrfs_writepage_cow_fixup()
2491 		return -EAGAIN;  in btrfs_writepage_cow_fixup()
2497 	 * page->mapping outside of the page lock.  in btrfs_writepage_cow_fixup()
2502 	btrfs_init_work(&fixup->work, btrfs_writepage_fixup_worker, NULL, NULL);  in btrfs_writepage_cow_fixup()
2503 	fixup->page = page;  in btrfs_writepage_cow_fixup()
2504 	fixup->inode = inode;  in btrfs_writepage_cow_fixup()
2505 	btrfs_queue_work(fs_info->fixup_workers, &fixup->work);  in btrfs_writepage_cow_fixup()
2507 	return -EAGAIN;  in btrfs_writepage_cow_fixup()
2515 	struct btrfs_root *root = inode->root;  in insert_reserved_file_extent()
2528 		return -ENOMEM;  in insert_reserved_file_extent()
2550 		path->leave_spinning = 1;  in insert_reserved_file_extent()
2556 	leaf = path->nodes[0];  in insert_reserved_file_extent()
2557 	btrfs_set_stack_file_extent_generation(stack_fi, trans->transid);  in insert_reserved_file_extent()
2559 			btrfs_item_ptr_offset(leaf, path->slots[0]),  in insert_reserved_file_extent()
2565 	inode_add_bytes(&inode->vfs_inode, num_bytes);  in insert_reserved_file_extent()
2591 	spin_lock(&cache->lock);  in btrfs_release_delalloc_bytes()
2592 	cache->delalloc_bytes -= len;  in btrfs_release_delalloc_bytes()
2593 	spin_unlock(&cache->lock);  in btrfs_release_delalloc_bytes()
2599 					     struct btrfs_ordered_extent *oe)  in insert_ordered_extent_file_extent()  argument
2606 	btrfs_set_stack_file_extent_disk_bytenr(&stack_fi, oe->disk_bytenr);  in insert_ordered_extent_file_extent()
2608 						   oe->disk_num_bytes);  in insert_ordered_extent_file_extent()
2609 	if (test_bit(BTRFS_ORDERED_TRUNCATED, &oe->flags))  in insert_ordered_extent_file_extent()
2610 		logical_len = oe->truncated_len;  in insert_ordered_extent_file_extent()
2612 		logical_len = oe->num_bytes;  in insert_ordered_extent_file_extent()
2615 	btrfs_set_stack_file_extent_compression(&stack_fi, oe->compress_type);  in insert_ordered_extent_file_extent()
2618 	return insert_reserved_file_extent(trans, BTRFS_I(oe->inode),  in insert_ordered_extent_file_extent()
2619 					   oe->file_offset, &stack_fi,  in insert_ordered_extent_file_extent()
2620 					   oe->qgroup_rsv);  in insert_ordered_extent_file_extent()
2630 	struct inode *inode = ordered_extent->inode;  in btrfs_finish_ordered_io()
2631 	struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);  in btrfs_finish_ordered_io()
2632 	struct btrfs_root *root = BTRFS_I(inode)->root;  in btrfs_finish_ordered_io()
2634 	struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;  in btrfs_finish_ordered_io()
2639 	u64 logical_len = ordered_extent->num_bytes;  in btrfs_finish_ordered_io()
2647 	start = ordered_extent->file_offset;  in btrfs_finish_ordered_io()
2648 	end = start + ordered_extent->num_bytes - 1;  in btrfs_finish_ordered_io()
2650 	if (!test_bit(BTRFS_ORDERED_NOCOW, &ordered_extent->flags) &&  in btrfs_finish_ordered_io()
2651 	    !test_bit(BTRFS_ORDERED_PREALLOC, &ordered_extent->flags) &&  in btrfs_finish_ordered_io()
2652 	    !test_bit(BTRFS_ORDERED_DIRECT, &ordered_extent->flags))  in btrfs_finish_ordered_io()
2657 	if (test_bit(BTRFS_ORDERED_IOERR, &ordered_extent->flags)) {  in btrfs_finish_ordered_io()
2658 		ret = -EIO;  in btrfs_finish_ordered_io()
2664 	if (test_bit(BTRFS_ORDERED_TRUNCATED, &ordered_extent->flags)) {  in btrfs_finish_ordered_io()
2666 		logical_len = ordered_extent->truncated_len;  in btrfs_finish_ordered_io()
2672 	if (test_bit(BTRFS_ORDERED_NOCOW, &ordered_extent->flags)) {  in btrfs_finish_ordered_io()
2673 		BUG_ON(!list_empty(&ordered_extent->list)); /* Logic error */  in btrfs_finish_ordered_io()
2685 		trans->block_rsv = &BTRFS_I(inode)->block_rsv;  in btrfs_finish_ordered_io()
2687 		if (ret) /* -ENOMEM or corruption */  in btrfs_finish_ordered_io()
2705 	trans->block_rsv = &BTRFS_I(inode)->block_rsv;  in btrfs_finish_ordered_io()
2707 	if (test_bit(BTRFS_ORDERED_COMPRESSED, &ordered_extent->flags))  in btrfs_finish_ordered_io()
2708 		compress_type = ordered_extent->compress_type;  in btrfs_finish_ordered_io()
2709 	if (test_bit(BTRFS_ORDERED_PREALLOC, &ordered_extent->flags)) {  in btrfs_finish_ordered_io()
2712 						ordered_extent->file_offset,  in btrfs_finish_ordered_io()
2713 						ordered_extent->file_offset +  in btrfs_finish_ordered_io()
2716 		BUG_ON(root == fs_info->tree_root);  in btrfs_finish_ordered_io()
2721 						ordered_extent->disk_bytenr,  in btrfs_finish_ordered_io()
2722 						ordered_extent->disk_num_bytes);  in btrfs_finish_ordered_io()
2725 	unpin_extent_cache(&BTRFS_I(inode)->extent_tree,  in btrfs_finish_ordered_io()
2726 			   ordered_extent->file_offset,  in btrfs_finish_ordered_io()
2727 			   ordered_extent->num_bytes, trans->transid);  in btrfs_finish_ordered_io()
2733 	ret = add_pending_csums(trans, &ordered_extent->list);  in btrfs_finish_ordered_io()
2741 	if (ret) { /* -ENOMEM or corruption */  in btrfs_finish_ordered_io()
2752 	clear_extent_bit(&BTRFS_I(inode)->io_tree, start, end, clear_bits,  in btrfs_finish_ordered_io()
2771 					     &ordered_extent->flags))  in btrfs_finish_ordered_io()
2772 			mapping_set_error(ordered_extent->inode->i_mapping, -EIO);  in btrfs_finish_ordered_io()
2793 		    !test_bit(BTRFS_ORDERED_NOCOW, &ordered_extent->flags) &&  in btrfs_finish_ordered_io()
2794 		    !test_bit(BTRFS_ORDERED_PREALLOC, &ordered_extent->flags)) {  in btrfs_finish_ordered_io()
2801 						ordered_extent->disk_bytenr,  in btrfs_finish_ordered_io()
2802 						ordered_extent->disk_num_bytes,  in btrfs_finish_ordered_io()
2805 					ordered_extent->disk_bytenr,  in btrfs_finish_ordered_io()
2806 					ordered_extent->disk_num_bytes, 1);  in btrfs_finish_ordered_io()
2834 	struct btrfs_inode *inode = BTRFS_I(page->mapping->host);  in btrfs_writepage_endio_finish_ordered()
2835 	struct btrfs_fs_info *fs_info = inode->root->fs_info;  in btrfs_writepage_endio_finish_ordered()
2843 					    end - start + 1, uptodate))  in btrfs_writepage_endio_finish_ordered()
2847 		wq = fs_info->endio_freespace_worker;  in btrfs_writepage_endio_finish_ordered()
2849 		wq = fs_info->endio_write_workers;  in btrfs_writepage_endio_finish_ordered()
2851 	btrfs_init_work(&ordered_extent->work, finish_ordered_fn, NULL, NULL);  in btrfs_writepage_endio_finish_ordered()
2852 	btrfs_queue_work(wq, &ordered_extent->work);  in btrfs_writepage_endio_finish_ordered()
2859 	struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);  in check_data_csum()
2860 	SHASH_DESC_ON_STACK(shash, fs_info->csum_shash);  in check_data_csum()
2862 	u16 csum_size = btrfs_super_csum_size(fs_info->super_copy);  in check_data_csum()
2866 	csum_expected = ((u8 *)io_bio->csum) + icsum * csum_size;  in check_data_csum()
2869 	shash->tfm = fs_info->csum_shash;  in check_data_csum()
2880 				    io_bio->mirror_num);  in check_data_csum()
2881 	if (io_bio->device)  in check_data_csum()
2882 		btrfs_dev_stat_inc_and_print(io_bio->device,  in check_data_csum()
2887 	return -EIO;  in check_data_csum()
2898 	size_t offset = start - page_offset(page);  in btrfs_verify_data_csum()
2899 	struct inode *inode = page->mapping->host;  in btrfs_verify_data_csum()
2900 	struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;  in btrfs_verify_data_csum()
2901 	struct btrfs_root *root = BTRFS_I(inode)->root;  in btrfs_verify_data_csum()
2908 	if (BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM)  in btrfs_verify_data_csum()
2911 	if (root->root_key.objectid == BTRFS_DATA_RELOC_TREE_OBJECTID &&  in btrfs_verify_data_csum()
2917 	phy_offset >>= inode->i_sb->s_blocksize_bits;  in btrfs_verify_data_csum()
2919 			       (size_t)(end - start + 1));  in btrfs_verify_data_csum()
2923  * btrfs_add_delayed_iput - perform a delayed iput on @inode
2934 	struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);  in btrfs_add_delayed_iput()
2937 	if (atomic_add_unless(&inode->i_count, -1, 1))  in btrfs_add_delayed_iput()
2940 	atomic_inc(&fs_info->nr_delayed_iputs);  in btrfs_add_delayed_iput()
2941 	spin_lock(&fs_info->delayed_iput_lock);  in btrfs_add_delayed_iput()
2942 	ASSERT(list_empty(&binode->delayed_iput));  in btrfs_add_delayed_iput()
2943 	list_add_tail(&binode->delayed_iput, &fs_info->delayed_iputs);  in btrfs_add_delayed_iput()
2944 	spin_unlock(&fs_info->delayed_iput_lock);  in btrfs_add_delayed_iput()
2945 	if (!test_bit(BTRFS_FS_CLEANER_RUNNING, &fs_info->flags))  in btrfs_add_delayed_iput()
2946 		wake_up_process(fs_info->cleaner_kthread);  in btrfs_add_delayed_iput()
2952 	list_del_init(&inode->delayed_iput);  in run_delayed_iput_locked()
2953 	spin_unlock(&fs_info->delayed_iput_lock);  in run_delayed_iput_locked()
2954 	iput(&inode->vfs_inode);  in run_delayed_iput_locked()
2955 	if (atomic_dec_and_test(&fs_info->nr_delayed_iputs))  in run_delayed_iput_locked()
2956 		wake_up(&fs_info->delayed_iputs_wait);  in run_delayed_iput_locked()
2957 	spin_lock(&fs_info->delayed_iput_lock);  in run_delayed_iput_locked()
2963 	if (!list_empty(&inode->delayed_iput)) {  in btrfs_run_delayed_iput()
2964 		spin_lock(&fs_info->delayed_iput_lock);  in btrfs_run_delayed_iput()
2965 		if (!list_empty(&inode->delayed_iput))  in btrfs_run_delayed_iput()
2967 		spin_unlock(&fs_info->delayed_iput_lock);  in btrfs_run_delayed_iput()
2974 	spin_lock(&fs_info->delayed_iput_lock);  in btrfs_run_delayed_iputs()
2975 	while (!list_empty(&fs_info->delayed_iputs)) {  in btrfs_run_delayed_iputs()
2978 		inode = list_first_entry(&fs_info->delayed_iputs,  in btrfs_run_delayed_iputs()
2981 		cond_resched_lock(&fs_info->delayed_iput_lock);  in btrfs_run_delayed_iputs()
2983 	spin_unlock(&fs_info->delayed_iput_lock);  in btrfs_run_delayed_iputs()
2987  * btrfs_wait_on_delayed_iputs - wait on the delayed iputs to be done running
2988  * @fs_info - the fs_info for this fs
2989  * @return - EINTR if we were killed, 0 if nothing's pending
2998 	int ret = wait_event_killable(fs_info->delayed_iputs_wait,  in btrfs_wait_on_delayed_iputs()
2999 			atomic_read(&fs_info->nr_delayed_iputs) == 0);  in btrfs_wait_on_delayed_iputs()
3001 		return -EINTR;  in btrfs_wait_on_delayed_iputs()
3014 	ret = btrfs_insert_orphan_item(trans, inode->root, btrfs_ino(inode));  in btrfs_orphan_add()
3015 	if (ret && ret != -EEXIST) {  in btrfs_orphan_add()
3030 	return btrfs_del_orphan_item(trans, inode->root, btrfs_ino(inode));  in btrfs_orphan_del()
3039 	struct btrfs_fs_info *fs_info = root->fs_info;  in btrfs_orphan_cleanup()
3048 	if (cmpxchg(&root->orphan_cleanup_state, 0, ORPHAN_CLEANUP_STARTED))  in btrfs_orphan_cleanup()
3053 		ret = -ENOMEM;  in btrfs_orphan_cleanup()
3056 	path->reada = READA_BACK;  in btrfs_orphan_cleanup()
3060 	key.offset = (u64)-1;  in btrfs_orphan_cleanup()
3074 			if (path->slots[0] == 0)  in btrfs_orphan_cleanup()
3076 			path->slots[0]--;  in btrfs_orphan_cleanup()
3080 		leaf = path->nodes[0];  in btrfs_orphan_cleanup()
3081 		btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);  in btrfs_orphan_cleanup()
3101 			ret = -EINVAL;  in btrfs_orphan_cleanup()
3110 		inode = btrfs_iget(fs_info->sb, last_objectid, root);  in btrfs_orphan_cleanup()
3112 		if (ret && ret != -ENOENT)  in btrfs_orphan_cleanup()
3115 		if (ret == -ENOENT && root == fs_info->tree_root) {  in btrfs_orphan_cleanup()
3131 			spin_lock(&fs_info->fs_roots_radix_lock);  in btrfs_orphan_cleanup()
3132 			dead_root = radix_tree_lookup(&fs_info->fs_roots_radix,  in btrfs_orphan_cleanup()
3134 			if (dead_root && btrfs_root_refs(&dead_root->root_item) == 0)  in btrfs_orphan_cleanup()
3136 			spin_unlock(&fs_info->fs_roots_radix_lock);  in btrfs_orphan_cleanup()
3140 				key.offset = found_key.objectid - 1;  in btrfs_orphan_cleanup()
3156 		 * only if this filesystem was last used on a pre-v3.12 kernel  in btrfs_orphan_cleanup()
3165 		if (ret == -ENOENT || inode->i_nlink) {  in btrfs_orphan_cleanup()
3191 	root->orphan_cleanup_state = ORPHAN_CLEANUP_DONE;  in btrfs_orphan_cleanup()
3193 	if (test_bit(BTRFS_ROOT_ORPHAN_ITEM_INSERTED, &root->state)) {  in btrfs_orphan_cleanup()
3233 	*first_xattr_slot = -1;  in acls_after_inode_item()
3243 			if (*first_xattr_slot == -1)  in acls_after_inode_item()
3273 	if (*first_xattr_slot == -1)  in acls_after_inode_item()
3279  * read an inode from the btree into the in-memory inode
3284 	struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);  in btrfs_read_locked_inode()
3288 	struct btrfs_root *root = BTRFS_I(inode)->root;  in btrfs_read_locked_inode()
3304 			return -ENOMEM;  in btrfs_read_locked_inode()
3307 	memcpy(&location, &BTRFS_I(inode)->location, sizeof(location));  in btrfs_read_locked_inode()
3316 	leaf = path->nodes[0];  in btrfs_read_locked_inode()
3321 	inode_item = btrfs_item_ptr(leaf, path->slots[0],  in btrfs_read_locked_inode()
3323 	inode->i_mode = btrfs_inode_mode(leaf, inode_item);  in btrfs_read_locked_inode()
3329 			round_up(i_size_read(inode), fs_info->sectorsize));  in btrfs_read_locked_inode()
3331 	inode->i_atime.tv_sec = btrfs_timespec_sec(leaf, &inode_item->atime);  in btrfs_read_locked_inode()
3332 	inode->i_atime.tv_nsec = btrfs_timespec_nsec(leaf, &inode_item->atime);  in btrfs_read_locked_inode()
3334 	inode->i_mtime.tv_sec = btrfs_timespec_sec(leaf, &inode_item->mtime);  in btrfs_read_locked_inode()
3335 	inode->i_mtime.tv_nsec = btrfs_timespec_nsec(leaf, &inode_item->mtime);  in btrfs_read_locked_inode()
3337 	inode->i_ctime.tv_sec = btrfs_timespec_sec(leaf, &inode_item->ctime);  in btrfs_read_locked_inode()
3338 	inode->i_ctime.tv_nsec = btrfs_timespec_nsec(leaf, &inode_item->ctime);  in btrfs_read_locked_inode()
3340 	BTRFS_I(inode)->i_otime.tv_sec =  in btrfs_read_locked_inode()
3341 		btrfs_timespec_sec(leaf, &inode_item->otime);  in btrfs_read_locked_inode()
3342 	BTRFS_I(inode)->i_otime.tv_nsec =  in btrfs_read_locked_inode()
3343 		btrfs_timespec_nsec(leaf, &inode_item->otime);  in btrfs_read_locked_inode()
3346 	BTRFS_I(inode)->generation = btrfs_inode_generation(leaf, inode_item);  in btrfs_read_locked_inode()
3347 	BTRFS_I(inode)->last_trans = btrfs_inode_transid(leaf, inode_item);  in btrfs_read_locked_inode()
3351 	inode->i_generation = BTRFS_I(inode)->generation;  in btrfs_read_locked_inode()
3352 	inode->i_rdev = 0;  in btrfs_read_locked_inode()
3355 	BTRFS_I(inode)->index_cnt = (u64)-1;  in btrfs_read_locked_inode()
3356 	BTRFS_I(inode)->flags = btrfs_inode_flags(leaf, inode_item);  in btrfs_read_locked_inode()
3361 	 * and then re-read we need to do a full sync since we don't have any  in btrfs_read_locked_inode()
3365 	 * This is required for both inode re-read from disk and delayed inode  in btrfs_read_locked_inode()
3368 	if (BTRFS_I(inode)->last_trans == fs_info->generation)  in btrfs_read_locked_inode()
3370 			&BTRFS_I(inode)->runtime_flags);  in btrfs_read_locked_inode()
3385 	 * xfs_io -c fsync mydir/foo  in btrfs_read_locked_inode()
3399 	BTRFS_I(inode)->last_unlink_trans = BTRFS_I(inode)->last_trans;  in btrfs_read_locked_inode()
3407 	BTRFS_I(inode)->last_reflink_trans = BTRFS_I(inode)->last_trans;  in btrfs_read_locked_inode()
3409 	path->slots[0]++;  in btrfs_read_locked_inode()
3410 	if (inode->i_nlink != 1 ||  in btrfs_read_locked_inode()
3411 	    path->slots[0] >= btrfs_header_nritems(leaf))  in btrfs_read_locked_inode()
3414 	btrfs_item_key_to_cpu(leaf, &location, path->slots[0]);  in btrfs_read_locked_inode()
3418 	ptr = btrfs_item_ptr_offset(leaf, path->slots[0]);  in btrfs_read_locked_inode()
3423 		BTRFS_I(inode)->dir_index = btrfs_inode_ref_index(leaf, ref);  in btrfs_read_locked_inode()
3428 		BTRFS_I(inode)->dir_index = btrfs_inode_extref_index(leaf,  in btrfs_read_locked_inode()
3436 	maybe_acls = acls_after_inode_item(leaf, path->slots[0],  in btrfs_read_locked_inode()
3438 	if (first_xattr_slot != -1) {  in btrfs_read_locked_inode()
3439 		path->slots[0] = first_xattr_slot;  in btrfs_read_locked_inode()
3445 				  root->root_key.objectid, ret);  in btrfs_read_locked_inode()
3453 	switch (inode->i_mode & S_IFMT) {  in btrfs_read_locked_inode()
3455 		inode->i_mapping->a_ops = &btrfs_aops;  in btrfs_read_locked_inode()
3456 		inode->i_fop = &btrfs_file_operations;  in btrfs_read_locked_inode()
3457 		inode->i_op = &btrfs_file_inode_operations;  in btrfs_read_locked_inode()
3460 		inode->i_fop = &btrfs_dir_file_operations;  in btrfs_read_locked_inode()
3461 		inode->i_op = &btrfs_dir_inode_operations;  in btrfs_read_locked_inode()
3464 		inode->i_op = &btrfs_symlink_inode_operations;  in btrfs_read_locked_inode()
3466 		inode->i_mapping->a_ops = &btrfs_aops;  in btrfs_read_locked_inode()
3469 		inode->i_op = &btrfs_special_inode_operations;  in btrfs_read_locked_inode()
3470 		init_special_inode(inode, inode->i_mode, rdev);  in btrfs_read_locked_inode()
3492 	btrfs_set_token_inode_size(&token, item, BTRFS_I(inode)->disk_i_size);  in fill_inode_item()
3493 	btrfs_set_token_inode_mode(&token, item, inode->i_mode);  in fill_inode_item()
3494 	btrfs_set_token_inode_nlink(&token, item, inode->i_nlink);  in fill_inode_item()
3496 	btrfs_set_token_timespec_sec(&token, &item->atime,  in fill_inode_item()
3497 				     inode->i_atime.tv_sec);  in fill_inode_item()
3498 	btrfs_set_token_timespec_nsec(&token, &item->atime,  in fill_inode_item()
3499 				      inode->i_atime.tv_nsec);  in fill_inode_item()
3501 	btrfs_set_token_timespec_sec(&token, &item->mtime,  in fill_inode_item()
3502 				     inode->i_mtime.tv_sec);  in fill_inode_item()
3503 	btrfs_set_token_timespec_nsec(&token, &item->mtime,  in fill_inode_item()
3504 				      inode->i_mtime.tv_nsec);  in fill_inode_item()
3506 	btrfs_set_token_timespec_sec(&token, &item->ctime,  in fill_inode_item()
3507 				     inode->i_ctime.tv_sec);  in fill_inode_item()
3508 	btrfs_set_token_timespec_nsec(&token, &item->ctime,  in fill_inode_item()
3509 				      inode->i_ctime.tv_nsec);  in fill_inode_item()
3511 	btrfs_set_token_timespec_sec(&token, &item->otime,  in fill_inode_item()
3512 				     BTRFS_I(inode)->i_otime.tv_sec);  in fill_inode_item()
3513 	btrfs_set_token_timespec_nsec(&token, &item->otime,  in fill_inode_item()
3514 				      BTRFS_I(inode)->i_otime.tv_nsec);  in fill_inode_item()
3518 					 BTRFS_I(inode)->generation);  in fill_inode_item()
3520 	btrfs_set_token_inode_transid(&token, item, trans->transid);  in fill_inode_item()
3521 	btrfs_set_token_inode_rdev(&token, item, inode->i_rdev);  in fill_inode_item()
3522 	btrfs_set_token_inode_flags(&token, item, BTRFS_I(inode)->flags);  in fill_inode_item()
3527  * copy everything in the in-memory inode into the btree.
3539 		return -ENOMEM;  in btrfs_update_inode_item()
3541 	path->leave_spinning = 1;  in btrfs_update_inode_item()
3542 	ret = btrfs_lookup_inode(trans, root, path, &BTRFS_I(inode)->location,  in btrfs_update_inode_item()
3546 			ret = -ENOENT;  in btrfs_update_inode_item()
3550 	leaf = path->nodes[0];  in btrfs_update_inode_item()
3551 	inode_item = btrfs_item_ptr(leaf, path->slots[0],  in btrfs_update_inode_item()
3564  * copy everything in the in-memory inode into the btree.
3569 	struct btrfs_fs_info *fs_info = root->fs_info;  in btrfs_update_inode()
3577 	 * without delay  in btrfs_update_inode()
3580 	    && root->root_key.objectid != BTRFS_DATA_RELOC_TREE_OBJECTID  in btrfs_update_inode()
3581 	    && !test_bit(BTRFS_FS_LOG_RECOVERING, &fs_info->flags)) {  in btrfs_update_inode()
3600 	if (ret == -ENOSPC)  in btrfs_update_inode_fallback()
3616 	struct btrfs_fs_info *fs_info = root->fs_info;  in __btrfs_unlink_inode()
3626 		ret = -ENOMEM;  in __btrfs_unlink_inode()
3630 	path->leave_spinning = 1;  in __btrfs_unlink_inode()
3632 				    name, name_len, -1);  in __btrfs_unlink_inode()
3634 		ret = di ? PTR_ERR(di) : -ENOENT;  in __btrfs_unlink_inode()
3649 	 * that we delay to delete it, and just do this deletion when  in __btrfs_unlink_inode()
3652 	if (inode->dir_index) {  in __btrfs_unlink_inode()
3655 			index = inode->dir_index;  in __btrfs_unlink_inode()
3678 	if (ret != 0 && ret != -ENOENT) {  in __btrfs_unlink_inode()
3685 	if (ret == -ENOENT)  in __btrfs_unlink_inode()
3692 	 * being run in btrfs-cleaner context.  If we have enough of these built  in __btrfs_unlink_inode()
3693 	 * up we can end up burning a lot of time in btrfs-cleaner without any  in __btrfs_unlink_inode()
3705 	btrfs_i_size_write(dir, dir->vfs_inode.i_size - name_len * 2);  in __btrfs_unlink_inode()
3706 	inode_inc_iversion(&inode->vfs_inode);  in __btrfs_unlink_inode()
3707 	inode_inc_iversion(&dir->vfs_inode);  in __btrfs_unlink_inode()
3708 	inode->vfs_inode.i_ctime = dir->vfs_inode.i_mtime =  in __btrfs_unlink_inode()
3709 		dir->vfs_inode.i_ctime = current_time(&inode->vfs_inode);  in __btrfs_unlink_inode()
3710 	ret = btrfs_update_inode(trans, root, &dir->vfs_inode);  in __btrfs_unlink_inode()
3723 		drop_nlink(&inode->vfs_inode);  in btrfs_unlink_inode()
3724 		ret = btrfs_update_inode(trans, root, &inode->vfs_inode);  in btrfs_unlink_inode()
3739 	struct btrfs_root *root = BTRFS_I(dir)->root;  in __unlink_start_trans()
3753 	struct btrfs_root *root = BTRFS_I(dir)->root;  in btrfs_unlink()
3766 			BTRFS_I(d_inode(dentry)), dentry->d_name.name,  in btrfs_unlink()
3767 			dentry->d_name.len);  in btrfs_unlink()
3771 	if (inode->i_nlink == 0) {  in btrfs_unlink()
3779 	btrfs_btree_balance_dirty(root->fs_info);  in btrfs_unlink()
3786 	struct btrfs_root *root = BTRFS_I(dir)->root;  in btrfs_unlink_subvol()
3792 	const char *name = dentry->d_name.name;  in btrfs_unlink_subvol()
3793 	int name_len = dentry->d_name.len;  in btrfs_unlink_subvol()
3800 		objectid = inode->root->root_key.objectid;  in btrfs_unlink_subvol()
3802 		objectid = inode->location.objectid;  in btrfs_unlink_subvol()
3805 		return -EINVAL;  in btrfs_unlink_subvol()
3810 		return -ENOMEM;  in btrfs_unlink_subvol()
3813 				   name, name_len, -1);  in btrfs_unlink_subvol()
3815 		ret = di ? PTR_ERR(di) : -ENOENT;  in btrfs_unlink_subvol()
3819 	leaf = path->nodes[0];  in btrfs_unlink_subvol()
3833 	 * depending on btrfs_del_root_ref to return -ENOENT here is incorret.  in btrfs_unlink_subvol()
3843 				ret = -ENOENT;  in btrfs_unlink_subvol()
3850 		leaf = path->nodes[0];  in btrfs_unlink_subvol()
3851 		btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);  in btrfs_unlink_subvol()
3856 					 root->root_key.objectid, dir_ino,  in btrfs_unlink_subvol()
3870 	btrfs_i_size_write(BTRFS_I(dir), dir->i_size - name_len * 2);  in btrfs_unlink_subvol()
3872 	dir->i_mtime = dir->i_ctime = current_time(dir);  in btrfs_unlink_subvol()
3887 	struct btrfs_fs_info *fs_info = root->fs_info;  in may_destroy_subvol()
3896 		return -ENOMEM;  in may_destroy_subvol()
3899 	dir_id = btrfs_super_root_dir(fs_info->super_copy);  in may_destroy_subvol()
3900 	di = btrfs_lookup_dir_item(NULL, fs_info->tree_root, path,  in may_destroy_subvol()
3903 		btrfs_dir_item_key_to_cpu(path->nodes[0], di, &key);  in may_destroy_subvol()
3904 		if (key.objectid == root->root_key.objectid) {  in may_destroy_subvol()
3905 			ret = -EPERM;  in may_destroy_subvol()
3914 	key.objectid = root->root_key.objectid;  in may_destroy_subvol()
3916 	key.offset = (u64)-1;  in may_destroy_subvol()
3918 	ret = btrfs_search_slot(NULL, fs_info->tree_root, &key, path, 0, 0);  in may_destroy_subvol()
3924 	if (path->slots[0] > 0) {  in may_destroy_subvol()
3925 		path->slots[0]--;  in may_destroy_subvol()
3926 		btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]);  in may_destroy_subvol()
3927 		if (key.objectid == root->root_key.objectid &&  in may_destroy_subvol()
3929 			ret = -ENOTEMPTY;  in may_destroy_subvol()
3939 	struct btrfs_fs_info *fs_info = root->fs_info;  in btrfs_prune_dentries()
3946 	if (!test_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state))  in btrfs_prune_dentries()
3947 		WARN_ON(btrfs_root_refs(&root->root_item) != 0);  in btrfs_prune_dentries()
3949 	spin_lock(&root->inode_lock);  in btrfs_prune_dentries()
3951 	node = root->inode_tree.rb_node;  in btrfs_prune_dentries()
3958 			node = node->rb_left;  in btrfs_prune_dentries()
3960 			node = node->rb_right;  in btrfs_prune_dentries()
3977 		inode = igrab(&entry->vfs_inode);  in btrfs_prune_dentries()
3979 			spin_unlock(&root->inode_lock);  in btrfs_prune_dentries()
3980 			if (atomic_read(&inode->i_count) > 1)  in btrfs_prune_dentries()
3988 			spin_lock(&root->inode_lock);  in btrfs_prune_dentries()
3992 		if (cond_resched_lock(&root->inode_lock))  in btrfs_prune_dentries()
3997 	spin_unlock(&root->inode_lock);  in btrfs_prune_dentries()
4002 	struct btrfs_fs_info *fs_info = btrfs_sb(dentry->d_sb);  in btrfs_delete_subvolume()
4003 	struct btrfs_root *root = BTRFS_I(dir)->root;  in btrfs_delete_subvolume()
4005 	struct btrfs_root *dest = BTRFS_I(inode)->root;  in btrfs_delete_subvolume()
4017 	spin_lock(&dest->root_item_lock);  in btrfs_delete_subvolume()
4018 	if (dest->send_in_progress) {  in btrfs_delete_subvolume()
4019 		spin_unlock(&dest->root_item_lock);  in btrfs_delete_subvolume()
4022 			   dest->root_key.objectid);  in btrfs_delete_subvolume()
4023 		return -EPERM;  in btrfs_delete_subvolume()
4025 	if (atomic_read(&dest->nr_swapfiles)) {  in btrfs_delete_subvolume()
4026 		spin_unlock(&dest->root_item_lock);  in btrfs_delete_subvolume()
4029 			   root->root_key.objectid);  in btrfs_delete_subvolume()
4030 		return -EPERM;  in btrfs_delete_subvolume()
4032 	root_flags = btrfs_root_flags(&dest->root_item);  in btrfs_delete_subvolume()
4033 	btrfs_set_root_flags(&dest->root_item,  in btrfs_delete_subvolume()
4035 	spin_unlock(&dest->root_item_lock);  in btrfs_delete_subvolume()
4037 	down_write(&fs_info->subvol_sem);  in btrfs_delete_subvolume()
4058 	trans->block_rsv = &block_rsv;  in btrfs_delete_subvolume()
4059 	trans->bytes_reserved = block_rsv.size;  in btrfs_delete_subvolume()
4072 	memset(&dest->root_item.drop_progress, 0,  in btrfs_delete_subvolume()
4073 		sizeof(dest->root_item.drop_progress));  in btrfs_delete_subvolume()
4074 	dest->root_item.drop_level = 0;  in btrfs_delete_subvolume()
4075 	btrfs_set_root_refs(&dest->root_item, 0);  in btrfs_delete_subvolume()
4077 	if (!test_and_set_bit(BTRFS_ROOT_ORPHAN_ITEM_INSERTED, &dest->state)) {  in btrfs_delete_subvolume()
4079 					fs_info->tree_root,  in btrfs_delete_subvolume()
4080 					dest->root_key.objectid);  in btrfs_delete_subvolume()
4088 	ret = btrfs_uuid_tree_remove(trans, dest->root_item.uuid,  in btrfs_delete_subvolume()
4090 				  dest->root_key.objectid);  in btrfs_delete_subvolume()
4091 	if (ret && ret != -ENOENT) {  in btrfs_delete_subvolume()
4096 	if (!btrfs_is_empty_uuid(dest->root_item.received_uuid)) {  in btrfs_delete_subvolume()
4098 					  dest->root_item.received_uuid,  in btrfs_delete_subvolume()
4100 					  dest->root_key.objectid);  in btrfs_delete_subvolume()
4101 		if (ret && ret != -ENOENT) {  in btrfs_delete_subvolume()
4108 	free_anon_bdev(dest->anon_dev);  in btrfs_delete_subvolume()
4109 	dest->anon_dev = 0;  in btrfs_delete_subvolume()
4111 	trans->block_rsv = NULL;  in btrfs_delete_subvolume()
4112 	trans->bytes_reserved = 0;  in btrfs_delete_subvolume()
4116 	inode->i_flags |= S_DEAD;  in btrfs_delete_subvolume()
4120 	up_write(&fs_info->subvol_sem);  in btrfs_delete_subvolume()
4122 		spin_lock(&dest->root_item_lock);  in btrfs_delete_subvolume()
4123 		root_flags = btrfs_root_flags(&dest->root_item);  in btrfs_delete_subvolume()
4124 		btrfs_set_root_flags(&dest->root_item,  in btrfs_delete_subvolume()
4126 		spin_unlock(&dest->root_item_lock);  in btrfs_delete_subvolume()
4130 		ASSERT(dest->send_in_progress == 0);  in btrfs_delete_subvolume()
4133 		if (dest->ino_cache_inode) {  in btrfs_delete_subvolume()
4134 			iput(dest->ino_cache_inode);  in btrfs_delete_subvolume()
4135 			dest->ino_cache_inode = NULL;  in btrfs_delete_subvolume()
4146 	struct btrfs_root *root = BTRFS_I(dir)->root;  in btrfs_rmdir()
4150 	if (inode->i_size > BTRFS_EMPTY_DIR_SIZE)  in btrfs_rmdir()
4151 		return -ENOTEMPTY;  in btrfs_rmdir()
4168 	last_unlink_trans = BTRFS_I(inode)->last_unlink_trans;  in btrfs_rmdir()
4172 			BTRFS_I(d_inode(dentry)), dentry->d_name.name,  in btrfs_rmdir()
4173 			dentry->d_name.len);  in btrfs_rmdir()
4187 		if (last_unlink_trans >= trans->transid)  in btrfs_rmdir()
4188 			BTRFS_I(dir)->last_unlink_trans = last_unlink_trans;  in btrfs_rmdir()
4192 	btrfs_btree_balance_dirty(root->fs_info);  in btrfs_rmdir()
4219 	struct btrfs_fs_info *fs_info = root->fs_info;  in btrfs_truncate_inode_items()
4230 	u32 found_type = (u8)-1;  in btrfs_truncate_inode_items()
4235 	int extent_type = -1;  in btrfs_truncate_inode_items()
4241 	const u64 lock_start = ALIGN_DOWN(new_size, fs_info->sectorsize);  in btrfs_truncate_inode_items()
4247 	 * For non-free space inodes and non-shareable roots, we want to back  in btrfs_truncate_inode_items()
4252 	    test_bit(BTRFS_ROOT_SHAREABLE, &root->state))  in btrfs_truncate_inode_items()
4257 		return -ENOMEM;  in btrfs_truncate_inode_items()
4258 	path->reada = READA_BACK;  in btrfs_truncate_inode_items()
4260 	if (root->root_key.objectid != BTRFS_TREE_LOG_OBJECTID) {  in btrfs_truncate_inode_items()
4261 		lock_extent_bits(&BTRFS_I(inode)->io_tree, lock_start, (u64)-1,  in btrfs_truncate_inode_items()
4270 					fs_info->sectorsize),  in btrfs_truncate_inode_items()
4271 					(u64)-1, 0);  in btrfs_truncate_inode_items()
4276 	 * we relog the inode, so if root != BTRFS_I(inode)->root, it means  in btrfs_truncate_inode_items()
4280 	if (min_type == 0 && root == BTRFS_I(inode)->root)  in btrfs_truncate_inode_items()
4284 	key.offset = (u64)-1;  in btrfs_truncate_inode_items()
4285 	key.type = (u8)-1;  in btrfs_truncate_inode_items()
4295 		ret = -EAGAIN;  in btrfs_truncate_inode_items()
4299 	ret = btrfs_search_slot(trans, root, &key, path, -1, 1);  in btrfs_truncate_inode_items()
4308 		if (path->slots[0] == 0)  in btrfs_truncate_inode_items()
4310 		path->slots[0]--;  in btrfs_truncate_inode_items()
4317 		leaf = path->nodes[0];  in btrfs_truncate_inode_items()
4318 		btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);  in btrfs_truncate_inode_items()
4329 			fi = btrfs_item_ptr(leaf, path->slots[0],  in btrfs_truncate_inode_items()
4344 					BTRFS_I(inode), leaf, fi, path->slots[0],  in btrfs_truncate_inode_items()
4347 			item_end--;  in btrfs_truncate_inode_items()
4372 				extent_num_bytes = ALIGN(new_size -  in btrfs_truncate_inode_items()
4374 						fs_info->sectorsize);  in btrfs_truncate_inode_items()
4375 				clear_start = ALIGN(new_size, fs_info->sectorsize);  in btrfs_truncate_inode_items()
4378 				num_dec = (orig_num_bytes -  in btrfs_truncate_inode_items()
4381 					     &root->state) &&  in btrfs_truncate_inode_items()
4389 				extent_offset = found_key.offset -  in btrfs_truncate_inode_items()
4397 						     &root->state))  in btrfs_truncate_inode_items()
4411 				u32 size = (u32)(new_size - found_key.offset);  in btrfs_truncate_inode_items()
4429 				clear_len = fs_info->sectorsize;  in btrfs_truncate_inode_items()
4432 			if (test_bit(BTRFS_ROOT_SHAREABLE, &root->state))  in btrfs_truncate_inode_items()
4433 				inode_sub_bytes(inode, item_end + 1 - new_size);  in btrfs_truncate_inode_items()
4441 		if (root == BTRFS_I(inode)->root) {  in btrfs_truncate_inode_items()
4457 				pending_del_slot = path->slots[0];  in btrfs_truncate_inode_items()
4460 				   path->slots[0] + 1 == pending_del_slot) {  in btrfs_truncate_inode_items()
4463 				pending_del_slot = path->slots[0];  in btrfs_truncate_inode_items()
4473 		    root->root_key.objectid != BTRFS_TREE_LOG_OBJECTID) {  in btrfs_truncate_inode_items()
4480 			ref.real_root = root->root_key.objectid;  in btrfs_truncate_inode_items()
4497 		if (path->slots[0] == 0 ||  in btrfs_truncate_inode_items()
4498 		    path->slots[0] != pending_del_slot ||  in btrfs_truncate_inode_items()
4526 					ret = -EAGAIN;  in btrfs_truncate_inode_items()
4532 			path->slots[0]--;  in btrfs_truncate_inode_items()
4546 	if (root->root_key.objectid != BTRFS_TREE_LOG_OBJECTID) {  in btrfs_truncate_inode_items()
4551 		unlock_extent_cached(&BTRFS_I(inode)->io_tree, lock_start,  in btrfs_truncate_inode_items()
4552 				     (u64)-1, &cached_state);  in btrfs_truncate_inode_items()
4560  * btrfs_truncate_block - read, zero a chunk and write a block
4561  * @inode - inode that we're zeroing
4562  * @from - the offset to start zeroing
4563  * @len - the length to zero, 0 to zero the entire range respective to the
4565  * @front - zero up to the offset instead of from the offset on
4573 	struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);  in btrfs_truncate_block()
4574 	struct address_space *mapping = inode->i_mapping;  in btrfs_truncate_block()
4575 	struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;  in btrfs_truncate_block()
4581 	u32 blocksize = fs_info->sectorsize;  in btrfs_truncate_block()
4583 	unsigned offset = from & (blocksize - 1);  in btrfs_truncate_block()
4596 	block_end = block_start + blocksize - 1;  in btrfs_truncate_block()
4622 		ret = -ENOMEM;  in btrfs_truncate_block()
4629 		if (page->mapping != mapping) {  in btrfs_truncate_block()
4635 			ret = -EIO;  in btrfs_truncate_block()
4655 	clear_extent_bit(&BTRFS_I(inode)->io_tree, block_start, block_end,  in btrfs_truncate_block()
4669 			len = blocksize - offset;  in btrfs_truncate_block()
4672 			memset(kaddr + (block_start - page_offset(page)),  in btrfs_truncate_block()
4675 			memset(kaddr + (block_start - page_offset(page)) +  offset,  in btrfs_truncate_block()
4685 		set_extent_bit(&BTRFS_I(inode)->io_tree, block_start,  in btrfs_truncate_block()
4711 	struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);  in maybe_insert_hole()
4720 		BTRFS_I(inode)->last_trans = fs_info->generation;  in maybe_insert_hole()
4721 		BTRFS_I(inode)->last_sub_trans = root->log_transid;  in maybe_insert_hole()
4722 		BTRFS_I(inode)->last_log_commit = root->last_log_commit;  in maybe_insert_hole()
4727 	 * 1 - for the one we're dropping  in maybe_insert_hole()
4728 	 * 1 - for the one we're adding  in maybe_insert_hole()
4729 	 * 1 - for updating the inode.  in maybe_insert_hole()
4760 	struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);  in btrfs_cont_expand()
4761 	struct btrfs_root *root = BTRFS_I(inode)->root;  in btrfs_cont_expand()
4762 	struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;  in btrfs_cont_expand()
4765 	struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;  in btrfs_cont_expand()
4766 	u64 hole_start = ALIGN(oldsize, fs_info->sectorsize);  in btrfs_cont_expand()
4767 	u64 block_end = ALIGN(size, fs_info->sectorsize);  in btrfs_cont_expand()
4786 					   block_end - 1, &cached_state);  in btrfs_cont_expand()
4790 				      block_end - cur_offset);  in btrfs_cont_expand()
4797 		last_byte = ALIGN(last_byte, fs_info->sectorsize);  in btrfs_cont_expand()
4798 		hole_size = last_byte - cur_offset;  in btrfs_cont_expand()
4800 		if (!test_bit(EXTENT_FLAG_PREALLOC, &em->flags)) {  in btrfs_cont_expand()
4814 						cur_offset + hole_size - 1, 0);  in btrfs_cont_expand()
4818 					&BTRFS_I(inode)->runtime_flags);  in btrfs_cont_expand()
4821 			hole_em->start = cur_offset;  in btrfs_cont_expand()
4822 			hole_em->len = hole_size;  in btrfs_cont_expand()
4823 			hole_em->orig_start = cur_offset;  in btrfs_cont_expand()
4825 			hole_em->block_start = EXTENT_MAP_HOLE;  in btrfs_cont_expand()
4826 			hole_em->block_len = 0;  in btrfs_cont_expand()
4827 			hole_em->orig_block_len = 0;  in btrfs_cont_expand()
4828 			hole_em->ram_bytes = hole_size;  in btrfs_cont_expand()
4829 			hole_em->compress_type = BTRFS_COMPRESS_NONE;  in btrfs_cont_expand()
4830 			hole_em->generation = fs_info->generation;  in btrfs_cont_expand()
4833 				write_lock(&em_tree->lock);  in btrfs_cont_expand()
4835 				write_unlock(&em_tree->lock);  in btrfs_cont_expand()
4836 				if (err != -EEXIST)  in btrfs_cont_expand()
4841 							hole_size - 1, 0);  in btrfs_cont_expand()
4858 	unlock_extent_cached(io_tree, hole_start, block_end - 1, &cached_state);  in btrfs_cont_expand()
4864 	struct btrfs_root *root = BTRFS_I(inode)->root;  in btrfs_setsize()
4867 	loff_t newsize = attr->ia_size;  in btrfs_setsize()
4868 	int mask = attr->ia_valid;  in btrfs_setsize()
4880 			inode->i_ctime = inode->i_mtime =  in btrfs_setsize()
4888 		 * state of this file - if the snapshot captures this expanding  in btrfs_setsize()
4892 		btrfs_drew_write_lock(&root->snapshot_lock);  in btrfs_setsize()
4895 			btrfs_drew_write_unlock(&root->snapshot_lock);  in btrfs_setsize()
4901 			btrfs_drew_write_unlock(&root->snapshot_lock);  in btrfs_setsize()
4909 		btrfs_drew_write_unlock(&root->snapshot_lock);  in btrfs_setsize()
4920 				&BTRFS_I(inode)->runtime_flags);  in btrfs_setsize()
4927 		if (ret && inode->i_nlink) {  in btrfs_setsize()
4931 			 * Truncate failed, so fix up the in-memory size. We  in btrfs_setsize()
4934 			 * in-memory size to match.  in btrfs_setsize()
4936 			err = btrfs_wait_ordered_range(inode, 0, (u64)-1);  in btrfs_setsize()
4939 			i_size_write(inode, BTRFS_I(inode)->disk_i_size);  in btrfs_setsize()
4949 	struct btrfs_root *root = BTRFS_I(inode)->root;  in btrfs_setattr()
4953 		return -EROFS;  in btrfs_setattr()
4959 	if (S_ISREG(inode->i_mode) && (attr->ia_valid & ATTR_SIZE)) {  in btrfs_setattr()
4965 	if (attr->ia_valid) {  in btrfs_setattr()
4970 		if (!err && attr->ia_valid & ATTR_MODE)  in btrfs_setattr()
4971 			err = posix_acl_chmod(inode, inode->i_mode);  in btrfs_setattr()
4991 	struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;  in evict_inode_truncate_pages()
4992 	struct extent_map_tree *map_tree = &BTRFS_I(inode)->extent_tree;  in evict_inode_truncate_pages()
4995 	ASSERT(inode->i_state & I_FREEING);  in evict_inode_truncate_pages()
4996 	truncate_inode_pages_final(&inode->i_data);  in evict_inode_truncate_pages()
4998 	write_lock(&map_tree->lock);  in evict_inode_truncate_pages()
4999 	while (!RB_EMPTY_ROOT(&map_tree->map.rb_root)) {  in evict_inode_truncate_pages()
5002 		node = rb_first_cached(&map_tree->map);  in evict_inode_truncate_pages()
5004 		clear_bit(EXTENT_FLAG_PINNED, &em->flags);  in evict_inode_truncate_pages()
5005 		clear_bit(EXTENT_FLAG_LOGGING, &em->flags);  in evict_inode_truncate_pages()
5009 			write_unlock(&map_tree->lock);  in evict_inode_truncate_pages()
5011 			write_lock(&map_tree->lock);  in evict_inode_truncate_pages()
5014 	write_unlock(&map_tree->lock);  in evict_inode_truncate_pages()
5024 	 * queue kthread), inode references (inode->i_count) were not taken  in evict_inode_truncate_pages()
5028 	 * reference count - if we don't do it, when they access the inode's  in evict_inode_truncate_pages()
5030 	 * use-after-free issue.  in evict_inode_truncate_pages()
5032 	spin_lock(&io_tree->lock);  in evict_inode_truncate_pages()
5033 	while (!RB_EMPTY_ROOT(&io_tree->state)) {  in evict_inode_truncate_pages()
5040 		node = rb_first(&io_tree->state);  in evict_inode_truncate_pages()
5042 		start = state->start;  in evict_inode_truncate_pages()
5043 		end = state->end;  in evict_inode_truncate_pages()
5044 		state_flags = state->state;  in evict_inode_truncate_pages()
5045 		spin_unlock(&io_tree->lock);  in evict_inode_truncate_pages()
5059 					       end - start + 1);  in evict_inode_truncate_pages()
5067 		spin_lock(&io_tree->lock);  in evict_inode_truncate_pages()
5069 	spin_unlock(&io_tree->lock);  in evict_inode_truncate_pages()
5075 	struct btrfs_fs_info *fs_info = root->fs_info;  in evict_refill_and_join()
5076 	struct btrfs_block_rsv *global_rsv = &fs_info->global_block_rsv;  in evict_refill_and_join()
5088 	 * above.  We reserve our extra bit here because we generate a ton of  in evict_refill_and_join()
5094 	ret = btrfs_block_rsv_refill(root, rsv, rsv->size + delayed_refs_extra,  in evict_refill_and_join()
5102 		    btrfs_block_rsv_migrate(global_rsv, rsv, rsv->size, 0)) {  in evict_refill_and_join()
5105 			return ERR_PTR(-ENOSPC);  in evict_refill_and_join()
5115 		trans->block_rsv = &fs_info->trans_block_rsv;  in evict_refill_and_join()
5116 		trans->bytes_reserved = delayed_refs_extra;  in evict_refill_and_join()
5117 		btrfs_block_rsv_migrate(rsv, trans->block_rsv,  in evict_refill_and_join()
5125 	struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);  in btrfs_evict_inode()
5127 	struct btrfs_root *root = BTRFS_I(inode)->root;  in btrfs_evict_inode()
5140 	if (inode->i_nlink &&  in btrfs_evict_inode()
5141 	    ((btrfs_root_refs(&root->root_item) != 0 &&  in btrfs_evict_inode()
5142 	      root->root_key.objectid != BTRFS_ROOT_TREE_OBJECTID) ||  in btrfs_evict_inode()
5149 	btrfs_free_io_failure_record(BTRFS_I(inode), 0, (u64)-1);  in btrfs_evict_inode()
5151 	if (test_bit(BTRFS_FS_LOG_RECOVERING, &fs_info->flags))  in btrfs_evict_inode()
5154 	if (inode->i_nlink > 0) {  in btrfs_evict_inode()
5155 		BUG_ON(btrfs_root_refs(&root->root_item) != 0 &&  in btrfs_evict_inode()
5156 		       root->root_key.objectid != BTRFS_ROOT_TREE_OBJECTID);  in btrfs_evict_inode()
5167 	rsv->size = btrfs_calc_metadata_size(fs_info, 1);  in btrfs_evict_inode()
5168 	rsv->failfast = 1;  in btrfs_evict_inode()
5177 		trans->block_rsv = rsv;  in btrfs_evict_inode()
5180 		trans->block_rsv = &fs_info->trans_block_rsv;  in btrfs_evict_inode()
5183 		if (ret && ret != -ENOSPC && ret != -EAGAIN)  in btrfs_evict_inode()
5200 		trans->block_rsv = rsv;  in btrfs_evict_inode()
5202 		trans->block_rsv = &fs_info->trans_block_rsv;  in btrfs_evict_inode()
5206 	if (!(root == fs_info->tree_root ||  in btrfs_evict_inode()
5207 	      root->root_key.objectid == BTRFS_TREE_RELOC_OBJECTID))  in btrfs_evict_inode()
5226  * If no dir entries were found, returns -ENOENT.
5227  * If found a corrupted location in dir entry, returns -EUCLEAN.
5232 	const char *name = dentry->d_name.name;  in btrfs_inode_by_name()
5233 	int namelen = dentry->d_name.len;  in btrfs_inode_by_name()
5236 	struct btrfs_root *root = BTRFS_I(dir)->root;  in btrfs_inode_by_name()
5241 		return -ENOMEM;  in btrfs_inode_by_name()
5246 		ret = di ? PTR_ERR(di) : -ENOENT;  in btrfs_inode_by_name()
5250 	btrfs_dir_item_key_to_cpu(path->nodes[0], di, location);  in btrfs_inode_by_name()
5251 	if (location->type != BTRFS_INODE_ITEM_KEY &&  in btrfs_inode_by_name()
5252 	    location->type != BTRFS_ROOT_ITEM_KEY) {  in btrfs_inode_by_name()
5253 		ret = -EUCLEAN;  in btrfs_inode_by_name()
5254 		btrfs_warn(root->fs_info,  in btrfs_inode_by_name()
5257 			   location->objectid, location->type, location->offset);  in btrfs_inode_by_name()
5260 		*type = btrfs_dir_type(path->nodes[0], di);  in btrfs_inode_by_name()
5287 		err = -ENOMEM;  in fixup_tree_root_location()
5291 	err = -ENOENT;  in fixup_tree_root_location()
5292 	key.objectid = BTRFS_I(dir)->root->root_key.objectid;  in fixup_tree_root_location()
5294 	key.offset = location->objectid;  in fixup_tree_root_location()
5296 	ret = btrfs_search_slot(NULL, fs_info->tree_root, &key, path, 0, 0);  in fixup_tree_root_location()
5303 	leaf = path->nodes[0];  in fixup_tree_root_location()
5304 	ref = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_root_ref);  in fixup_tree_root_location()
5306 	    btrfs_root_ref_name_len(leaf, ref) != dentry->d_name.len)  in fixup_tree_root_location()
5309 	ret = memcmp_extent_buffer(leaf, dentry->d_name.name,  in fixup_tree_root_location()
5311 				   dentry->d_name.len);  in fixup_tree_root_location()
5317 	new_root = btrfs_get_fs_root(fs_info, location->objectid, true);  in fixup_tree_root_location()
5324 	location->objectid = btrfs_root_dirid(&new_root->root_item);  in fixup_tree_root_location()
5325 	location->type = BTRFS_INODE_ITEM_KEY;  in fixup_tree_root_location()
5326 	location->offset = 0;  in fixup_tree_root_location()
5335 	struct btrfs_root *root = BTRFS_I(inode)->root;  in inode_tree_add()
5339 	struct rb_node *new = &BTRFS_I(inode)->rb_node;  in inode_tree_add()
5345 	spin_lock(&root->inode_lock);  in inode_tree_add()
5346 	p = &root->inode_tree.rb_node;  in inode_tree_add()
5352 			p = &parent->rb_left;  in inode_tree_add()
5354 			p = &parent->rb_right;  in inode_tree_add()
5356 			WARN_ON(!(entry->vfs_inode.i_state &  in inode_tree_add()
5358 			rb_replace_node(parent, new, &root->inode_tree);  in inode_tree_add()
5360 			spin_unlock(&root->inode_lock);  in inode_tree_add()
5365 	rb_insert_color(new, &root->inode_tree);  in inode_tree_add()
5366 	spin_unlock(&root->inode_lock);  in inode_tree_add()
5371 	struct btrfs_root *root = inode->root;  in inode_tree_del()
5374 	spin_lock(&root->inode_lock);  in inode_tree_del()
5375 	if (!RB_EMPTY_NODE(&inode->rb_node)) {  in inode_tree_del()
5376 		rb_erase(&inode->rb_node, &root->inode_tree);  in inode_tree_del()
5377 		RB_CLEAR_NODE(&inode->rb_node);  in inode_tree_del()
5378 		empty = RB_EMPTY_ROOT(&root->inode_tree);  in inode_tree_del()
5380 	spin_unlock(&root->inode_lock);  in inode_tree_del()
5382 	if (empty && btrfs_root_refs(&root->root_item) == 0) {  in inode_tree_del()
5383 		spin_lock(&root->inode_lock);  in inode_tree_del()
5384 		empty = RB_EMPTY_ROOT(&root->inode_tree);  in inode_tree_del()
5385 		spin_unlock(&root->inode_lock);  in inode_tree_del()
5396 	inode->i_ino = args->ino;  in btrfs_init_locked_inode()
5397 	BTRFS_I(inode)->location.objectid = args->ino;  in btrfs_init_locked_inode()
5398 	BTRFS_I(inode)->location.type = BTRFS_INODE_ITEM_KEY;  in btrfs_init_locked_inode()
5399 	BTRFS_I(inode)->location.offset = 0;  in btrfs_init_locked_inode()
5400 	BTRFS_I(inode)->root = btrfs_grab_root(args->root);  in btrfs_init_locked_inode()
5401 	BUG_ON(args->root && !BTRFS_I(inode)->root);  in btrfs_init_locked_inode()
5409 	return args->ino == BTRFS_I(inode)->location.objectid &&  in btrfs_find_actor()
5410 		args->root == BTRFS_I(inode)->root;  in btrfs_find_actor()
5442 		return ERR_PTR(-ENOMEM);  in btrfs_iget_path()
5444 	if (inode->i_state & I_NEW) {  in btrfs_iget_path()
5459 				ret = -ENOENT;  in btrfs_iget_path()
5479 		return ERR_PTR(-ENOMEM);  in new_simple_dir()
5481 	BTRFS_I(inode)->root = btrfs_grab_root(root);  in new_simple_dir()
5482 	memcpy(&BTRFS_I(inode)->location, key, sizeof(*key));  in new_simple_dir()
5483 	set_bit(BTRFS_INODE_DUMMY, &BTRFS_I(inode)->runtime_flags);  in new_simple_dir()
5485 	inode->i_ino = BTRFS_EMPTY_SUBVOL_DIR_OBJECTID;  in new_simple_dir()
5487 	 * We only need lookup, the rest is read-only and there's no inode  in new_simple_dir()
5490 	inode->i_op = &simple_dir_inode_operations;  in new_simple_dir()
5491 	inode->i_opflags &= ~IOP_XATTR;  in new_simple_dir()
5492 	inode->i_fop = &simple_dir_operations;  in new_simple_dir()
5493 	inode->i_mode = S_IFDIR | S_IRUGO | S_IWUSR | S_IXUGO;  in new_simple_dir()
5494 	inode->i_mtime = current_time(inode);  in new_simple_dir()
5495 	inode->i_atime = inode->i_mtime;  in new_simple_dir()
5496 	inode->i_ctime = inode->i_mtime;  in new_simple_dir()
5497 	BTRFS_I(inode)->i_otime = inode->i_mtime;  in new_simple_dir()
5505 	 * Compile-time asserts that generic FT_* types still match  in btrfs_inode_type()
5517 	return fs_umode_to_ftype(inode->i_mode);  in btrfs_inode_type()
5522 	struct btrfs_fs_info *fs_info = btrfs_sb(dir->i_sb);  in btrfs_lookup_dentry()
5524 	struct btrfs_root *root = BTRFS_I(dir)->root;  in btrfs_lookup_dentry()
5530 	if (dentry->d_name.len > BTRFS_NAME_LEN)  in btrfs_lookup_dentry()
5531 		return ERR_PTR(-ENAMETOOLONG);  in btrfs_lookup_dentry()
5538 		inode = btrfs_iget(dir->i_sb, location.objectid, root);  in btrfs_lookup_dentry()
5542 		/* Do extra check against inode mode with di_type */  in btrfs_lookup_dentry()
5546 				  inode->i_mode, btrfs_inode_type(inode),  in btrfs_lookup_dentry()
5549 			return ERR_PTR(-EUCLEAN);  in btrfs_lookup_dentry()
5557 		if (ret != -ENOENT)  in btrfs_lookup_dentry()
5560 			inode = new_simple_dir(dir->i_sb, &location, sub_root);  in btrfs_lookup_dentry()
5562 		inode = btrfs_iget(dir->i_sb, location.objectid, sub_root);  in btrfs_lookup_dentry()
5568 		down_read(&fs_info->cleanup_work_sem);  in btrfs_lookup_dentry()
5569 		if (!sb_rdonly(inode->i_sb))  in btrfs_lookup_dentry()
5571 		up_read(&fs_info->cleanup_work_sem);  in btrfs_lookup_dentry()
5587 		inode = d_inode(dentry->d_parent);  in btrfs_dentry_delete()
5590 		root = BTRFS_I(inode)->root;  in btrfs_dentry_delete()
5591 		if (btrfs_root_refs(&root->root_item) == 0)  in btrfs_dentry_delete()
5605 	if (inode == ERR_PTR(-ENOENT))  in btrfs_lookup()
5625 		return -ENOMEM;  in btrfs_opendir()
5626 	private->filldir_buf = kzalloc(PAGE_SIZE, GFP_KERNEL);  in btrfs_opendir()
5627 	if (!private->filldir_buf) {  in btrfs_opendir()
5629 		return -ENOMEM;  in btrfs_opendir()
5631 	file->private_data = private;  in btrfs_opendir()
5644 	while (entries--) {  in btrfs_filldir()
5648 		ctx->pos = get_unaligned(&entry->offset);  in btrfs_filldir()
5649 		if (!dir_emit(ctx, name, get_unaligned(&entry->name_len),  in btrfs_filldir()
5650 					 get_unaligned(&entry->ino),  in btrfs_filldir()
5651 					 get_unaligned(&entry->type)))  in btrfs_filldir()
5654 			get_unaligned(&entry->name_len);  in btrfs_filldir()
5655 		ctx->pos++;  in btrfs_filldir()
5663 	struct btrfs_root *root = BTRFS_I(inode)->root;  in btrfs_real_readdir()
5664 	struct btrfs_file_private *private = file->private_data;  in btrfs_real_readdir()
5687 		return -ENOMEM;  in btrfs_real_readdir()
5689 	addr = private->filldir_buf;  in btrfs_real_readdir()
5690 	path->reada = READA_FORWARD;  in btrfs_real_readdir()
5698 	key.offset = ctx->pos;  in btrfs_real_readdir()
5708 		leaf = path->nodes[0];  in btrfs_real_readdir()
5709 		slot = path->slots[0];  in btrfs_real_readdir()
5725 		if (found_key.offset < ctx->pos)  in btrfs_real_readdir()
5734 			ret = btrfs_filldir(private->filldir_buf, entries, ctx);  in btrfs_real_readdir()
5737 			addr = private->filldir_buf;  in btrfs_real_readdir()
5744 		put_unaligned(name_len, &entry->name_len);  in btrfs_real_readdir()
5749 				&entry->type);  in btrfs_real_readdir()
5751 		put_unaligned(location.objectid, &entry->ino);  in btrfs_real_readdir()
5752 		put_unaligned(found_key.offset, &entry->offset);  in btrfs_real_readdir()
5757 		path->slots[0]++;  in btrfs_real_readdir()
5761 	ret = btrfs_filldir(private->filldir_buf, entries, ctx);  in btrfs_real_readdir()
5777 	 * they're returned by readdir.  Until we re-use freed offsets  in btrfs_real_readdir()
5786 	if (ctx->pos >= INT_MAX)  in btrfs_real_readdir()
5787 		ctx->pos = LLONG_MAX;  in btrfs_real_readdir()
5789 		ctx->pos = INT_MAX;  in btrfs_real_readdir()
5807 	struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);  in btrfs_dirty_inode()
5808 	struct btrfs_root *root = BTRFS_I(inode)->root;  in btrfs_dirty_inode()
5812 	if (test_bit(BTRFS_INODE_DUMMY, &BTRFS_I(inode)->runtime_flags))  in btrfs_dirty_inode()
5820 	if (ret && (ret == -ENOSPC || ret == -EDQUOT)) {  in btrfs_dirty_inode()
5830 	if (BTRFS_I(inode)->delayed_node)  in btrfs_dirty_inode()
5843 	struct btrfs_root *root = BTRFS_I(inode)->root;  in btrfs_update_time()
5847 		return -EROFS;  in btrfs_update_time()
5852 		inode->i_ctime = *now;  in btrfs_update_time()
5854 		inode->i_mtime = *now;  in btrfs_update_time()
5856 		inode->i_atime = *now;  in btrfs_update_time()
5862  * and then set the in-memory index_cnt variable to reflect
5867 	struct btrfs_root *root = inode->root;  in btrfs_set_inode_index_count()
5875 	key.offset = (u64)-1;  in btrfs_set_inode_index_count()
5879 		return -ENOMEM;  in btrfs_set_inode_index_count()
5895 	if (path->slots[0] == 0) {  in btrfs_set_inode_index_count()
5896 		inode->index_cnt = 2;  in btrfs_set_inode_index_count()
5900 	path->slots[0]--;  in btrfs_set_inode_index_count()
5902 	leaf = path->nodes[0];  in btrfs_set_inode_index_count()
5903 	btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);  in btrfs_set_inode_index_count()
5907 		inode->index_cnt = 2;  in btrfs_set_inode_index_count()
5911 	inode->index_cnt = found_key.offset + 1;  in btrfs_set_inode_index_count()
5925 	if (dir->index_cnt == (u64)-1) {  in btrfs_set_inode_index()
5934 	*index = dir->index_cnt;  in btrfs_set_inode_index()
5935 	dir->index_cnt++;  in btrfs_set_inode_index()
5944 	args.ino = BTRFS_I(inode)->location.objectid;  in btrfs_insert_inode_locked()
5945 	args.root = BTRFS_I(inode)->root;  in btrfs_insert_inode_locked()
5948 		   btrfs_inode_hash(inode->i_ino, BTRFS_I(inode)->root),  in btrfs_insert_inode_locked()
5964 	flags = BTRFS_I(dir)->flags;  in btrfs_inherit_iflags()
5967 		BTRFS_I(inode)->flags &= ~BTRFS_INODE_COMPRESS;  in btrfs_inherit_iflags()
5968 		BTRFS_I(inode)->flags |= BTRFS_INODE_NOCOMPRESS;  in btrfs_inherit_iflags()
5970 		BTRFS_I(inode)->flags &= ~BTRFS_INODE_NOCOMPRESS;  in btrfs_inherit_iflags()
5971 		BTRFS_I(inode)->flags |= BTRFS_INODE_COMPRESS;  in btrfs_inherit_iflags()
5975 		BTRFS_I(inode)->flags |= BTRFS_INODE_NODATACOW;  in btrfs_inherit_iflags()
5976 		if (S_ISREG(inode->i_mode))  in btrfs_inherit_iflags()
5977 			BTRFS_I(inode)->flags |= BTRFS_INODE_NODATASUM;  in btrfs_inherit_iflags()
5990 	struct btrfs_fs_info *fs_info = root->fs_info;  in btrfs_new_inode()
6005 		return ERR_PTR(-ENOMEM);  in btrfs_new_inode()
6008 	inode = new_inode(fs_info->sb);  in btrfs_new_inode()
6012 		return ERR_PTR(-ENOMEM);  in btrfs_new_inode()
6026 	inode->i_ino = objectid;  in btrfs_new_inode()
6045 	BTRFS_I(inode)->index_cnt = 2;  in btrfs_new_inode()
6046 	BTRFS_I(inode)->dir_index = *index;  in btrfs_new_inode()
6047 	BTRFS_I(inode)->root = btrfs_grab_root(root);  in btrfs_new_inode()
6048 	BTRFS_I(inode)->generation = trans->transid;  in btrfs_new_inode()
6049 	inode->i_generation = BTRFS_I(inode)->generation;  in btrfs_new_inode()
6057 	set_bit(BTRFS_INODE_NEEDS_FULL_SYNC, &BTRFS_I(inode)->runtime_flags);  in btrfs_new_inode()
6079 	location = &BTRFS_I(inode)->location;  in btrfs_new_inode()
6080 	location->objectid = objectid;  in btrfs_new_inode()
6081 	location->offset = 0;  in btrfs_new_inode()
6082 	location->type = BTRFS_INODE_ITEM_KEY;  in btrfs_new_inode()
6090 	path->leave_spinning = 1;  in btrfs_new_inode()
6098 	inode->i_mtime = current_time(inode);  in btrfs_new_inode()
6099 	inode->i_atime = inode->i_mtime;  in btrfs_new_inode()
6100 	inode->i_ctime = inode->i_mtime;  in btrfs_new_inode()
6101 	BTRFS_I(inode)->i_otime = inode->i_mtime;  in btrfs_new_inode()
6103 	inode_item = btrfs_item_ptr(path->nodes[0], path->slots[0],  in btrfs_new_inode()
6105 	memzero_extent_buffer(path->nodes[0], (unsigned long)inode_item,  in btrfs_new_inode()
6107 	fill_inode_item(trans, path->nodes[0], inode_item, inode);  in btrfs_new_inode()
6110 		ref = btrfs_item_ptr(path->nodes[0], path->slots[0] + 1,  in btrfs_new_inode()
6112 		btrfs_set_inode_ref_name_len(path->nodes[0], ref, name_len);  in btrfs_new_inode()
6113 		btrfs_set_inode_ref_index(path->nodes[0], ref, *index);  in btrfs_new_inode()
6115 		write_extent_buffer(path->nodes[0], name, ptr, name_len);  in btrfs_new_inode()
6118 	btrfs_mark_buffer_dirty(path->nodes[0]);  in btrfs_new_inode()
6125 			BTRFS_I(inode)->flags |= BTRFS_INODE_NODATASUM;  in btrfs_new_inode()
6127 			BTRFS_I(inode)->flags |= BTRFS_INODE_NODATACOW |  in btrfs_new_inode()
6142 			btrfs_ino(BTRFS_I(inode)), root->root_key.objectid, ret);  in btrfs_new_inode()
6150 		BTRFS_I(dir)->index_cnt--;  in btrfs_new_inode()
6167 	struct btrfs_root *root = parent_inode->root;  in btrfs_add_link()
6172 		memcpy(&key, &inode->root->root_key, sizeof(key));  in btrfs_add_link()
6181 					 root->root_key.objectid, parent_ino,  in btrfs_add_link()
6193 				    btrfs_inode_type(&inode->vfs_inode), index);  in btrfs_add_link()
6194 	if (ret == -EEXIST || ret == -EOVERFLOW)  in btrfs_add_link()
6201 	btrfs_i_size_write(parent_inode, parent_inode->vfs_inode.i_size +  in btrfs_add_link()
6203 	inode_inc_iversion(&parent_inode->vfs_inode);  in btrfs_add_link()
6210 	if (!test_bit(BTRFS_FS_LOG_RECOVERING, &root->fs_info->flags)) {  in btrfs_add_link()
6211 		struct timespec64 now = current_time(&parent_inode->vfs_inode);  in btrfs_add_link()
6213 		parent_inode->vfs_inode.i_mtime = now;  in btrfs_add_link()
6214 		parent_inode->vfs_inode.i_ctime = now;  in btrfs_add_link()
6216 	ret = btrfs_update_inode(trans, root, &parent_inode->vfs_inode);  in btrfs_add_link()
6226 					 root->root_key.objectid, parent_ino,  in btrfs_add_link()
6249 				 dentry->d_name.name, dentry->d_name.len,  in btrfs_add_nondir()
6252 		err = -EEXIST;  in btrfs_add_nondir()
6259 	struct btrfs_fs_info *fs_info = btrfs_sb(dir->i_sb);  in btrfs_mknod()
6261 	struct btrfs_root *root = BTRFS_I(dir)->root;  in btrfs_mknod()
6280 	inode = btrfs_new_inode(trans, root, dir, dentry->d_name.name,  in btrfs_mknod()
6281 			dentry->d_name.len, btrfs_ino(BTRFS_I(dir)), objectid,  in btrfs_mknod()
6295 	inode->i_op = &btrfs_special_inode_operations;  in btrfs_mknod()
6296 	init_special_inode(inode, inode->i_mode, rdev);  in btrfs_mknod()
6298 	err = btrfs_init_inode_security(trans, inode, dir, &dentry->d_name);  in btrfs_mknod()
6323 	struct btrfs_fs_info *fs_info = btrfs_sb(dir->i_sb);  in btrfs_create()
6325 	struct btrfs_root *root = BTRFS_I(dir)->root;  in btrfs_create()
6344 	inode = btrfs_new_inode(trans, root, dir, dentry->d_name.name,  in btrfs_create()
6345 			dentry->d_name.len, btrfs_ino(BTRFS_I(dir)), objectid,  in btrfs_create()
6358 	inode->i_fop = &btrfs_file_operations;  in btrfs_create()
6359 	inode->i_op = &btrfs_file_inode_operations;  in btrfs_create()
6360 	inode->i_mapping->a_ops = &btrfs_aops;  in btrfs_create()
6362 	err = btrfs_init_inode_security(trans, inode, dir, &dentry->d_name);  in btrfs_create()
6391 	struct btrfs_root *root = BTRFS_I(dir)->root;  in btrfs_link()
6393 	struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);  in btrfs_link()
6399 	if (root->root_key.objectid != BTRFS_I(inode)->root->root_key.objectid)  in btrfs_link()
6400 		return -EXDEV;  in btrfs_link()
6402 	if (inode->i_nlink >= BTRFS_LINK_MAX)  in btrfs_link()
6403 		return -EMLINK;  in btrfs_link()
6415 	trans = btrfs_start_transaction(root, inode->i_nlink ? 5 : 6);  in btrfs_link()
6423 	BTRFS_I(inode)->dir_index = 0ULL;  in btrfs_link()
6426 	inode->i_ctime = current_time(inode);  in btrfs_link()
6428 	set_bit(BTRFS_INODE_COPY_EVERYTHING, &BTRFS_I(inode)->runtime_flags);  in btrfs_link()
6436 		struct dentry *parent = dentry->d_parent;  in btrfs_link()
6441 		if (inode->i_nlink == 1) {  in btrfs_link()
6467 	struct btrfs_fs_info *fs_info = btrfs_sb(dir->i_sb);  in btrfs_mkdir()
6470 	struct btrfs_root *root = BTRFS_I(dir)->root;  in btrfs_mkdir()
6488 	inode = btrfs_new_inode(trans, root, dir, dentry->d_name.name,  in btrfs_mkdir()
6489 			dentry->d_name.len, btrfs_ino(BTRFS_I(dir)), objectid,  in btrfs_mkdir()
6498 	inode->i_op = &btrfs_dir_inode_operations;  in btrfs_mkdir()
6499 	inode->i_fop = &btrfs_dir_file_operations;  in btrfs_mkdir()
6501 	err = btrfs_init_inode_security(trans, inode, dir, &dentry->d_name);  in btrfs_mkdir()
6511 			dentry->d_name.name,  in btrfs_mkdir()
6512 			dentry->d_name.len, 0, index);  in btrfs_mkdir()
6534 	struct extent_buffer *leaf = path->nodes[0];  in uncompress_inline()
6545 					btrfs_item_nr(path->slots[0]));  in uncompress_inline()
6548 		return -ENOMEM;  in uncompress_inline()
6567 		memset(map + pg_offset + max_size, 0, PAGE_SIZE - max_size - pg_offset);  in uncompress_inline()
6575  * btrfs_get_extent - Lookup the first extent overlapping a range in a file.
6583  * range, reading it from the B-tree and caching it if necessary. Note that
6590  * Return: ERR_PTR on error, non-NULL extent_map on success.
6596 	struct btrfs_fs_info *fs_info = inode->root->fs_info;  in btrfs_get_extent()
6601 	int extent_type = -1;  in btrfs_get_extent()
6603 	struct btrfs_root *root = inode->root;  in btrfs_get_extent()
6608 	struct extent_map_tree *em_tree = &inode->extent_tree;  in btrfs_get_extent()
6609 	struct extent_io_tree *io_tree = &inode->io_tree;  in btrfs_get_extent()
6611 	read_lock(&em_tree->lock);  in btrfs_get_extent()
6613 	read_unlock(&em_tree->lock);  in btrfs_get_extent()
6616 		if (em->start > start || em->start + em->len <= start)  in btrfs_get_extent()
6618 		else if (em->block_start == EXTENT_MAP_INLINE && page)  in btrfs_get_extent()
6625 		ret = -ENOMEM;  in btrfs_get_extent()
6628 	em->start = EXTENT_MAP_HOLE;  in btrfs_get_extent()
6629 	em->orig_start = EXTENT_MAP_HOLE;  in btrfs_get_extent()
6630 	em->len = (u64)-1;  in btrfs_get_extent()
6631 	em->block_len = (u64)-1;  in btrfs_get_extent()
6635 		ret = -ENOMEM;  in btrfs_get_extent()
6640 	path->reada = READA_FORWARD;  in btrfs_get_extent()
6646 	path->leave_spinning = 1;  in btrfs_get_extent()
6648 	path->recurse = btrfs_is_free_space_inode(inode);  in btrfs_get_extent()
6654 		if (path->slots[0] == 0)  in btrfs_get_extent()
6656 		path->slots[0]--;  in btrfs_get_extent()
6660 	leaf = path->nodes[0];  in btrfs_get_extent()
6661 	item = btrfs_item_ptr(leaf, path->slots[0],  in btrfs_get_extent()
6663 	btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);  in btrfs_get_extent()
6682 		if (!S_ISREG(inode->vfs_inode.i_mode)) {  in btrfs_get_extent()
6683 			ret = -EUCLEAN;  in btrfs_get_extent()
6685 		"regular/prealloc extent found for non-regular inode %llu",  in btrfs_get_extent()
6693 						      path->slots[0],  in btrfs_get_extent()
6698 		path->slots[0]++;  in btrfs_get_extent()
6699 		if (path->slots[0] >= btrfs_header_nritems(leaf)) {  in btrfs_get_extent()
6706 			leaf = path->nodes[0];  in btrfs_get_extent()
6708 		btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);  in btrfs_get_extent()
6718 		em->start = start;  in btrfs_get_extent()
6719 		em->orig_start = start;  in btrfs_get_extent()
6720 		em->len = found_key.offset - start;  in btrfs_get_extent()
6721 		em->block_start = EXTENT_MAP_HOLE;  in btrfs_get_extent()
6741 		extent_offset = page_offset(page) + pg_offset - extent_start;  in btrfs_get_extent()
6742 		copy_size = min_t(u64, PAGE_SIZE - pg_offset,  in btrfs_get_extent()
6743 				  size - extent_offset);  in btrfs_get_extent()
6744 		em->start = extent_start + extent_offset;  in btrfs_get_extent()
6745 		em->len = ALIGN(copy_size, fs_info->sectorsize);  in btrfs_get_extent()
6746 		em->orig_block_len = em->len;  in btrfs_get_extent()
6747 		em->orig_start = em->start;  in btrfs_get_extent()
6764 					       PAGE_SIZE - pg_offset -  in btrfs_get_extent()
6771 		set_extent_uptodate(io_tree, em->start,  in btrfs_get_extent()
6772 				    extent_map_end(em) - 1, NULL, GFP_NOFS);  in btrfs_get_extent()
6776 	em->start = start;  in btrfs_get_extent()
6777 	em->orig_start = start;  in btrfs_get_extent()
6778 	em->len = len;  in btrfs_get_extent()
6779 	em->block_start = EXTENT_MAP_HOLE;  in btrfs_get_extent()
6783 	if (em->start > start || extent_map_end(em) <= start) {  in btrfs_get_extent()
6786 			  em->start, em->len, start, len);  in btrfs_get_extent()
6787 		ret = -EIO;  in btrfs_get_extent()
6791 	write_lock(&em_tree->lock);  in btrfs_get_extent()
6793 	write_unlock(&em_tree->lock);  in btrfs_get_extent()
6822 	 * - a hole or  in btrfs_get_extent_fiemap()
6823 	 * - a pre-alloc extent,  in btrfs_get_extent_fiemap()
6826 	if (em->block_start != EXTENT_MAP_HOLE &&  in btrfs_get_extent_fiemap()
6827 	    !test_bit(EXTENT_FLAG_PREALLOC, &em->flags))  in btrfs_get_extent_fiemap()
6832 	/* check to see if we've wrapped (len == -1 or similar) */  in btrfs_get_extent_fiemap()
6835 		end = (u64)-1;  in btrfs_get_extent_fiemap()
6837 		end -= 1;  in btrfs_get_extent_fiemap()
6842 	delalloc_len = count_range_bits(&inode->io_tree, &delalloc_start,  in btrfs_get_extent_fiemap()
6846 		delalloc_end = (u64)-1;  in btrfs_get_extent_fiemap()
6863 	delalloc_len = delalloc_end - delalloc_start;  in btrfs_get_extent_fiemap()
6872 			err = -ENOMEM;  in btrfs_get_extent_fiemap()
6884 		if (hole_end <= start || hole_em->start > end) {  in btrfs_get_extent_fiemap()
6888 		       hole_start = max(hole_em->start, start);  in btrfs_get_extent_fiemap()
6889 		       hole_len = hole_end - hole_start;  in btrfs_get_extent_fiemap()
6898 			em->len = min(hole_len, delalloc_start - hole_start);  in btrfs_get_extent_fiemap()
6899 			em->start = hole_start;  in btrfs_get_extent_fiemap()
6900 			em->orig_start = hole_start;  in btrfs_get_extent_fiemap()
6905 			em->block_start = hole_em->block_start;  in btrfs_get_extent_fiemap()
6906 			em->block_len = hole_len;  in btrfs_get_extent_fiemap()
6907 			if (test_bit(EXTENT_FLAG_PREALLOC, &hole_em->flags))  in btrfs_get_extent_fiemap()
6908 				set_bit(EXTENT_FLAG_PREALLOC, &em->flags);  in btrfs_get_extent_fiemap()
6914 			em->start = delalloc_start;  in btrfs_get_extent_fiemap()
6915 			em->len = delalloc_len;  in btrfs_get_extent_fiemap()
6916 			em->orig_start = delalloc_start;  in btrfs_get_extent_fiemap()
6917 			em->block_start = EXTENT_MAP_DELALLOC;  in btrfs_get_extent_fiemap()
6918 			em->block_len = delalloc_len;  in btrfs_get_extent_fiemap()
6959 			btrfs_drop_extent_cache(inode, start, start + len - 1, 0);  in btrfs_create_dio_extent()
6971 	struct btrfs_root *root = inode->root;  in btrfs_new_extent_direct()
6972 	struct btrfs_fs_info *fs_info = root->fs_info;  in btrfs_new_extent_direct()
6979 	ret = btrfs_reserve_extent(root, len, len, fs_info->sectorsize,  in btrfs_new_extent_direct()
7002  * @orig_len:	(optional) Return the original on-disk length of the file extent
7022 	struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);  in can_nocow_extent()
7026 	struct btrfs_root *root = BTRFS_I(inode)->root;  in can_nocow_extent()
7027 	struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;  in can_nocow_extent()
7036 	bool nocow = (BTRFS_I(inode)->flags & BTRFS_INODE_NODATACOW);  in can_nocow_extent()
7040 		return -ENOMEM;  in can_nocow_extent()
7047 	slot = path->slots[0];  in can_nocow_extent()
7054 		slot--;  in can_nocow_extent()
7057 	leaf = path->nodes[0];  in can_nocow_extent()
7100 	     btrfs_root_last_snapshot(&root->root_item)))  in can_nocow_extent()
7106 		*orig_start = key.offset - backref_offset;  in can_nocow_extent()
7114 	num_bytes = min(offset + *len, extent_end) - offset;  in can_nocow_extent()
7119 				     root->fs_info->sectorsize) - 1;  in can_nocow_extent()
7123 			ret = -EAGAIN;  in can_nocow_extent()
7136 				    key.offset - backref_offset, disk_bytenr,  in can_nocow_extent()
7150 	disk_bytenr += offset - key.offset;  in can_nocow_extent()
7171 		lock_extent_bits(&BTRFS_I(inode)->io_tree, lockstart, lockend,  in lock_extent_direct()
7179 						     lockend - lockstart + 1);  in lock_extent_direct()
7189 		    (!writing || !filemap_range_has_page(inode->i_mapping,  in lock_extent_direct()
7193 		unlock_extent_cached(&BTRFS_I(inode)->io_tree, lockstart, lockend,  in lock_extent_direct()
7213 			    test_bit(BTRFS_ORDERED_DIRECT, &ordered->flags))  in lock_extent_direct()
7216 				ret = -ENOTBLK;  in lock_extent_direct()
7232 			ret = -ENOTBLK;  in lock_extent_direct()
7260 	em_tree = &inode->extent_tree;  in create_io_em()
7263 		return ERR_PTR(-ENOMEM);  in create_io_em()
7265 	em->start = start;  in create_io_em()
7266 	em->orig_start = orig_start;  in create_io_em()
7267 	em->len = len;  in create_io_em()
7268 	em->block_len = block_len;  in create_io_em()
7269 	em->block_start = block_start;  in create_io_em()
7270 	em->orig_block_len = orig_block_len;  in create_io_em()
7271 	em->ram_bytes = ram_bytes;  in create_io_em()
7272 	em->generation = -1;  in create_io_em()
7273 	set_bit(EXTENT_FLAG_PINNED, &em->flags);  in create_io_em()
7275 		set_bit(EXTENT_FLAG_FILLING, &em->flags);  in create_io_em()
7277 		set_bit(EXTENT_FLAG_COMPRESSED, &em->flags);  in create_io_em()
7278 		em->compress_type = compress_type;  in create_io_em()
7282 		btrfs_drop_extent_cache(inode, em->start,  in create_io_em()
7283 					em->start + em->len - 1, 0);  in create_io_em()
7284 		write_lock(&em_tree->lock);  in create_io_em()
7286 		write_unlock(&em_tree->lock);  in create_io_em()
7291 	} while (ret == -EEXIST);  in create_io_em()
7308 	struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);  in btrfs_get_blocks_direct_write()
7321 	if (test_bit(EXTENT_FLAG_PREALLOC, &em->flags) ||  in btrfs_get_blocks_direct_write()
7322 	    ((BTRFS_I(inode)->flags & BTRFS_INODE_NODATACOW) &&  in btrfs_get_blocks_direct_write()
7323 	     em->block_start != EXTENT_MAP_HOLE)) {  in btrfs_get_blocks_direct_write()
7327 		if (test_bit(EXTENT_FLAG_PREALLOC, &em->flags))  in btrfs_get_blocks_direct_write()
7331 		len = min(len, em->len - (start - em->start));  in btrfs_get_blocks_direct_write()
7332 		block_start = em->block_start + (start - em->start);  in btrfs_get_blocks_direct_write()
7371 	len = min(len, em->len - (start - em->start));  in btrfs_get_blocks_direct_write()
7381 	dio_data->reserve -= len;  in btrfs_get_blocks_direct_write()
7390 	struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);  in btrfs_dio_iomap_begin()
7399 	bool sync = (current->journal_info == BTRFS_DIO_SYNC_STUB);  in btrfs_dio_iomap_begin()
7402 	 * We used current->journal_info here to see if we were sync, but  in btrfs_dio_iomap_begin()
7404 	 * we have a journal_info set, so we need to clear this out and re-set  in btrfs_dio_iomap_begin()
7407 	ASSERT(current->journal_info == NULL ||  in btrfs_dio_iomap_begin()
7408 	       current->journal_info == BTRFS_DIO_SYNC_STUB);  in btrfs_dio_iomap_begin()
7409 	current->journal_info = NULL;  in btrfs_dio_iomap_begin()
7412 		len = min_t(u64, len, fs_info->sectorsize);  in btrfs_dio_iomap_begin()
7415 	lockend = start + len - 1;  in btrfs_dio_iomap_begin()
7424 		     &BTRFS_I(inode)->runtime_flags)) {  in btrfs_dio_iomap_begin()
7425 		ret = filemap_fdatawrite_range(inode->i_mapping, start,  in btrfs_dio_iomap_begin()
7426 					       start + length - 1);  in btrfs_dio_iomap_begin()
7433 		return -ENOMEM;  in btrfs_dio_iomap_begin()
7435 	dio_data->sync = sync;  in btrfs_dio_iomap_begin()
7436 	dio_data->length = length;  in btrfs_dio_iomap_begin()
7438 		dio_data->reserve = round_up(length, fs_info->sectorsize);  in btrfs_dio_iomap_begin()
7440 				&dio_data->data_reserved,  in btrfs_dio_iomap_begin()
7441 				start, dio_data->reserve);  in btrfs_dio_iomap_begin()
7443 			extent_changeset_free(dio_data->data_reserved);  in btrfs_dio_iomap_begin()
7448 	iomap->private = dio_data;  in btrfs_dio_iomap_begin()
7456 		ret = -ENOTBLK;  in btrfs_dio_iomap_begin()
7476 	 * We return -ENOTBLK because that's what makes DIO go ahead and go back  in btrfs_dio_iomap_begin()
7480 	if (test_bit(EXTENT_FLAG_COMPRESSED, &em->flags) ||  in btrfs_dio_iomap_begin()
7481 	    em->block_start == EXTENT_MAP_INLINE) {  in btrfs_dio_iomap_begin()
7484 		 * If we are in a NOWAIT context, return -EAGAIN in order to  in btrfs_dio_iomap_begin()
7488 		 * space - this happens if we were able to read some data from  in btrfs_dio_iomap_begin()
7489 		 * previous non-compressed extents and then when we fallback to  in btrfs_dio_iomap_begin()
7493 		 * of bytes previously read is > 0, so it does not return -EFAULT).  in btrfs_dio_iomap_begin()
7495 		ret = (flags & IOMAP_NOWAIT) ? -EAGAIN : -ENOTBLK;  in btrfs_dio_iomap_begin()
7499 	len = min(len, em->len - (start - em->start));  in btrfs_dio_iomap_begin()
7507 		len = min(len, em->len - (start - em->start));  in btrfs_dio_iomap_begin()
7519 		unlock_extent_cached(&BTRFS_I(inode)->io_tree,  in btrfs_dio_iomap_begin()
7529 	if ((em->block_start == EXTENT_MAP_HOLE) ||  in btrfs_dio_iomap_begin()
7530 	    (test_bit(EXTENT_FLAG_PREALLOC, &em->flags) && !write)) {  in btrfs_dio_iomap_begin()
7531 		iomap->addr = IOMAP_NULL_ADDR;  in btrfs_dio_iomap_begin()
7532 		iomap->type = IOMAP_HOLE;  in btrfs_dio_iomap_begin()
7534 		iomap->addr = em->block_start + (start - em->start);  in btrfs_dio_iomap_begin()
7535 		iomap->type = IOMAP_MAPPED;  in btrfs_dio_iomap_begin()
7537 	iomap->offset = start;  in btrfs_dio_iomap_begin()
7538 	iomap->bdev = fs_info->fs_devices->latest_bdev;  in btrfs_dio_iomap_begin()
7539 	iomap->length = len;  in btrfs_dio_iomap_begin()
7546 	unlock_extent_cached(&BTRFS_I(inode)->io_tree, lockstart, lockend,  in btrfs_dio_iomap_begin()
7551 				dio_data->data_reserved, start,  in btrfs_dio_iomap_begin()
7552 				dio_data->reserve, true);  in btrfs_dio_iomap_begin()
7553 		btrfs_delalloc_release_extents(BTRFS_I(inode), dio_data->reserve);  in btrfs_dio_iomap_begin()
7554 		extent_changeset_free(dio_data->data_reserved);  in btrfs_dio_iomap_begin()
7564 	struct btrfs_dio_data *dio_data = iomap->private;  in btrfs_dio_iomap_end()
7565 	size_t submitted = dio_data->submitted;  in btrfs_dio_iomap_end()
7568 	if (!write && (iomap->type == IOMAP_HOLE)) {  in btrfs_dio_iomap_end()
7570 		unlock_extent(&BTRFS_I(inode)->io_tree, pos, pos + length - 1);  in btrfs_dio_iomap_end()
7576 		length -= submitted;  in btrfs_dio_iomap_end()
7581 			unlock_extent(&BTRFS_I(inode)->io_tree, pos,  in btrfs_dio_iomap_end()
7582 				      pos + length - 1);  in btrfs_dio_iomap_end()
7583 		ret = -ENOTBLK;  in btrfs_dio_iomap_end()
7587 		if (dio_data->reserve)  in btrfs_dio_iomap_end()
7589 					dio_data->data_reserved, pos,  in btrfs_dio_iomap_end()
7590 					dio_data->reserve, true);  in btrfs_dio_iomap_end()
7591 		btrfs_delalloc_release_extents(BTRFS_I(inode), dio_data->length);  in btrfs_dio_iomap_end()
7592 		extent_changeset_free(dio_data->data_reserved);  in btrfs_dio_iomap_end()
7596 	 * We're all done, we can re-set the current->journal_info now safely  in btrfs_dio_iomap_end()
7599 	if (dio_data->sync) {  in btrfs_dio_iomap_end()
7600 		ASSERT(current->journal_info == NULL);  in btrfs_dio_iomap_end()
7601 		current->journal_info = BTRFS_DIO_SYNC_STUB;  in btrfs_dio_iomap_end()
7604 	iomap->private = NULL;  in btrfs_dio_iomap_end()
7612 	 * This implies a barrier so that stores to dio_bio->bi_status before  in btrfs_dio_private_put()
7613 	 * this and loads of dio_bio->bi_status after this are fully ordered.  in btrfs_dio_private_put()
7615 	if (!refcount_dec_and_test(&dip->refs))  in btrfs_dio_private_put()
7618 	if (bio_op(dip->dio_bio) == REQ_OP_WRITE) {  in btrfs_dio_private_put()
7619 		__endio_write_update_ordered(BTRFS_I(dip->inode),  in btrfs_dio_private_put()
7620 					     dip->logical_offset,  in btrfs_dio_private_put()
7621 					     dip->bytes,  in btrfs_dio_private_put()
7622 					     !dip->dio_bio->bi_status);  in btrfs_dio_private_put()
7624 		unlock_extent(&BTRFS_I(dip->inode)->io_tree,  in btrfs_dio_private_put()
7625 			      dip->logical_offset,  in btrfs_dio_private_put()
7626 			      dip->logical_offset + dip->bytes - 1);  in btrfs_dio_private_put()
7629 	bio_endio(dip->dio_bio);  in btrfs_dio_private_put()
7637 	struct btrfs_dio_private *dip = bio->bi_private;  in submit_dio_repair_bio()
7638 	struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);  in submit_dio_repair_bio()
7647 	refcount_inc(&dip->refs);  in submit_dio_repair_bio()
7650 		refcount_dec(&dip->refs);  in submit_dio_repair_bio()
7658 	struct btrfs_fs_info *fs_info = BTRFS_I(inode)->root->fs_info;  in btrfs_check_read_dio_bio()
7659 	const u32 sectorsize = fs_info->sectorsize;  in btrfs_check_read_dio_bio()
7660 	struct extent_io_tree *failure_tree = &BTRFS_I(inode)->io_failure_tree;  in btrfs_check_read_dio_bio()
7661 	struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;  in btrfs_check_read_dio_bio()
7662 	const bool csum = !(BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM);  in btrfs_check_read_dio_bio()
7665 	u64 start = io_bio->logical;  in btrfs_check_read_dio_bio()
7669 	__bio_for_each_segment(bvec, &io_bio->bio, iter, io_bio->iter) {  in btrfs_check_read_dio_bio()
7688 							&io_bio->bio,  in btrfs_check_read_dio_bio()
7689 							start - io_bio->logical,  in btrfs_check_read_dio_bio()
7692 							start + sectorsize - 1,  in btrfs_check_read_dio_bio()
7693 							io_bio->mirror_num,  in btrfs_check_read_dio_bio()
7710 	struct btrfs_fs_info *fs_info = inode->root->fs_info;  in __endio_write_update_ordered()
7718 		wq = fs_info->endio_freespace_worker;  in __endio_write_update_ordered()
7720 		wq = fs_info->endio_write_workers;  in __endio_write_update_ordered()
7728 			btrfs_init_work(&ordered->work, finish_ordered_fn, NULL,  in __endio_write_update_ordered()
7730 			btrfs_queue_work(wq, &ordered->work);  in __endio_write_update_ordered()
7743 			ordered_bytes = offset + bytes - ordered_offset;  in __endio_write_update_ordered()
7759 	struct btrfs_dio_private *dip = bio->bi_private;  in btrfs_end_dio_bio()
7760 	blk_status_t err = bio->bi_status;  in btrfs_end_dio_bio()
7763 		btrfs_warn(BTRFS_I(dip->inode)->root->fs_info,  in btrfs_end_dio_bio()
7765 			   btrfs_ino(BTRFS_I(dip->inode)), bio_op(bio),  in btrfs_end_dio_bio()
7766 			   bio->bi_opf,  in btrfs_end_dio_bio()
7767 			   (unsigned long long)bio->bi_iter.bi_sector,  in btrfs_end_dio_bio()
7768 			   bio->bi_iter.bi_size, err);  in btrfs_end_dio_bio()
7771 		err = btrfs_check_read_dio_bio(dip->inode, btrfs_io_bio(bio),  in btrfs_end_dio_bio()
7776 		dip->dio_bio->bi_status = err;  in btrfs_end_dio_bio()
7785 	struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);  in btrfs_submit_dio_bio()
7786 	struct btrfs_dio_private *dip = bio->bi_private;  in btrfs_submit_dio_bio()
7792 		async_submit = !atomic_read(&BTRFS_I(inode)->sync_writers);  in btrfs_submit_dio_bio()
7800 	if (BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM)  in btrfs_submit_dio_bio()
7819 		csum_offset = file_offset - dip->logical_offset;  in btrfs_submit_dio_bio()
7820 		csum_offset >>= inode->i_sb->s_blocksize_bits;  in btrfs_submit_dio_bio()
7821 		csum_offset *= btrfs_super_csum_size(fs_info->super_copy);  in btrfs_submit_dio_bio()
7822 		btrfs_io_bio(bio)->csum = dip->csums + csum_offset;  in btrfs_submit_dio_bio()
7839 	const bool csum = !(BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM);  in btrfs_create_dio_private()
7845 		struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);  in btrfs_create_dio_private()
7846 		const u16 csum_size = btrfs_super_csum_size(fs_info->super_copy);  in btrfs_create_dio_private()
7849 		nblocks = dio_bio->bi_iter.bi_size >> inode->i_sb->s_blocksize_bits;  in btrfs_create_dio_private()
7857 	dip->inode = inode;  in btrfs_create_dio_private()
7858 	dip->logical_offset = file_offset;  in btrfs_create_dio_private()
7859 	dip->bytes = dio_bio->bi_iter.bi_size;  in btrfs_create_dio_private()
7860 	dip->disk_bytenr = (u64)dio_bio->bi_iter.bi_sector << 9;  in btrfs_create_dio_private()
7861 	dip->dio_bio = dio_bio;  in btrfs_create_dio_private()
7862 	refcount_set(&dip->refs, 1);  in btrfs_create_dio_private()
7870 	const bool csum = !(BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM);  in btrfs_submit_direct()
7871 	struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);  in btrfs_submit_direct()
7884 	struct btrfs_dio_data *dio_data = iomap->private;  in btrfs_submit_direct()
7889 			unlock_extent(&BTRFS_I(inode)->io_tree, file_offset,  in btrfs_submit_direct()
7890 				file_offset + dio_bio->bi_iter.bi_size - 1);  in btrfs_submit_direct()
7892 		dio_bio->bi_status = BLK_STS_RESOURCE;  in btrfs_submit_direct()
7903 					       dip->csums);  in btrfs_submit_direct()
7908 	start_sector = dio_bio->bi_iter.bi_sector;  in btrfs_submit_direct()
7909 	submit_len = dio_bio->bi_iter.bi_size;  in btrfs_submit_direct()
7928 		bio->bi_private = dip;  in btrfs_submit_direct()
7929 		bio->bi_end_io = btrfs_end_dio_bio;  in btrfs_submit_direct()
7930 		btrfs_io_bio(bio)->logical = file_offset;  in btrfs_submit_direct()
7933 		submit_len -= clone_len;  in btrfs_submit_direct()
7945 			refcount_inc(&dip->refs);  in btrfs_submit_direct()
7961 				refcount_dec(&dip->refs);  in btrfs_submit_direct()
7965 		dio_data->submitted += clone_len;  in btrfs_submit_direct()
7973 	dip->dio_bio->bi_status = status;  in btrfs_submit_direct()
7983 	unsigned int blocksize_mask = fs_info->sectorsize - 1;  in check_direct_IO()
7984 	ssize_t retval = -EINVAL;  in check_direct_IO()
8000 	for (seg = 0; seg < iter->nr_segs; seg++) {  in check_direct_IO()
8001 		for (i = seg + 1; i < iter->nr_segs; i++) {  in check_direct_IO()
8002 			if (iter->iov[seg].iov_base == iter->iov[i].iov_base)  in check_direct_IO()
8019 	if (current->journal_info == BTRFS_DIO_SYNC_STUB) {  in btrfs_maybe_fsync_end_io()
8020 		current->journal_info = NULL;  in btrfs_maybe_fsync_end_io()
8028 		iocb->ki_flags |= IOCB_DSYNC;  in btrfs_maybe_fsync_end_io()
8051 	struct file *file = iocb->ki_filp;  in btrfs_direct_IO()
8052 	struct inode *inode = file->f_mapping->host;  in btrfs_direct_IO()
8053 	struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);  in btrfs_direct_IO()
8055 	loff_t offset = iocb->ki_pos;  in btrfs_direct_IO()
8061 		ASSERT(current->journal_info == NULL ||  in btrfs_direct_IO()
8062 		       current->journal_info == BTRFS_DIO_SYNC_STUB);  in btrfs_direct_IO()
8063 		current->journal_info = NULL;  in btrfs_direct_IO()
8074 		if (offset + count <= inode->i_size) {  in btrfs_direct_IO()
8078 		down_read(&BTRFS_I(inode)->dio_sem);  in btrfs_direct_IO()
8085 	if (current->journal_info)  in btrfs_direct_IO()
8092 	if (ret == -ENOTBLK)  in btrfs_direct_IO()
8096 		up_read(&BTRFS_I(inode)->dio_sem);  in btrfs_direct_IO()
8119 	struct btrfs_inode *inode = BTRFS_I(page->mapping->host);  in btrfs_readpage()
8121 	u64 end = start + PAGE_SIZE - 1;  in btrfs_readpage()
8136 	struct inode *inode = page->mapping->host;  in btrfs_writepage()
8139 	if (current->flags & PF_MEMALLOC) {  in btrfs_writepage()
8215 	struct btrfs_inode *inode = BTRFS_I(page->mapping->host);  in btrfs_invalidatepage()
8216 	struct extent_io_tree *tree = &inode->io_tree;  in btrfs_invalidatepage()
8220 	u64 page_end = page_start + PAGE_SIZE - 1;  in btrfs_invalidatepage()
8223 	int inode_evicting = inode->vfs_inode.i_state & I_FREEING;  in btrfs_invalidatepage()
8239 	 * shouldn't clear page extent mapped, as page->private can still  in btrfs_invalidatepage()
8256 	ordered = btrfs_lookup_ordered_range(inode, start, page_end - start + 1);  in btrfs_invalidatepage()
8259 			  ordered->file_offset + ordered->num_bytes - 1);  in btrfs_invalidatepage()
8277 			tree = &inode->ordered_tree;  in btrfs_invalidatepage()
8279 			spin_lock_irq(&tree->lock);  in btrfs_invalidatepage()
8280 			set_bit(BTRFS_ORDERED_TRUNCATED, &ordered->flags);  in btrfs_invalidatepage()
8281 			new_len = start - ordered->file_offset;  in btrfs_invalidatepage()
8282 			if (new_len < ordered->truncated_len)  in btrfs_invalidatepage()
8283 				ordered->truncated_len = new_len;  in btrfs_invalidatepage()
8284 			spin_unlock_irq(&tree->lock);  in btrfs_invalidatepage()
8288 							   end - start + 1, 1))  in btrfs_invalidatepage()
8347 	struct page *page = vmf->page;  in btrfs_page_mkwrite()
8348 	struct inode *inode = file_inode(vmf->vma->vm_file);  in btrfs_page_mkwrite()
8349 	struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);  in btrfs_page_mkwrite()
8350 	struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;  in btrfs_page_mkwrite()
8367 	sb_start_pagefault(inode->i_sb);  in btrfs_page_mkwrite()
8369 	page_end = page_start + PAGE_SIZE - 1;  in btrfs_page_mkwrite()
8383 		ret2 = file_update_time(vmf->vma->vm_file);  in btrfs_page_mkwrite()
8398 	if ((page->mapping != inode->i_mapping) ||  in btrfs_page_mkwrite()
8423 	if (page->index == ((size - 1) >> PAGE_SHIFT)) {  in btrfs_page_mkwrite()
8424 		reserved_space = round_up(size - page_start,  in btrfs_page_mkwrite()
8425 					  fs_info->sectorsize);  in btrfs_page_mkwrite()
8427 			end = page_start + reserved_space - 1;  in btrfs_page_mkwrite()
8430 					PAGE_SIZE - reserved_space, true);  in btrfs_page_mkwrite()
8441 	clear_extent_bit(&BTRFS_I(inode)->io_tree, page_start, end,  in btrfs_page_mkwrite()
8462 		memset(kaddr + zero_start, 0, PAGE_SIZE - zero_start);  in btrfs_page_mkwrite()
8475 	sb_end_pagefault(inode->i_sb);  in btrfs_page_mkwrite()
8486 	sb_end_pagefault(inode->i_sb);  in btrfs_page_mkwrite()
8493 	struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);  in btrfs_truncate()
8494 	struct btrfs_root *root = BTRFS_I(inode)->root;  in btrfs_truncate()
8498 	u64 mask = fs_info->sectorsize - 1;  in btrfs_truncate()
8502 		ret = btrfs_wait_ordered_range(inode, inode->i_size & (~mask),  in btrfs_truncate()
8503 					       (u64)-1);  in btrfs_truncate()
8531 	 * 1) rsv - for the truncate reservation, which we will steal from the  in btrfs_truncate()
8533 	 * 2) fs_info->trans_block_rsv - this will have 1 items worth left for  in btrfs_truncate()
8538 		return -ENOMEM;  in btrfs_truncate()
8539 	rsv->size = min_size;  in btrfs_truncate()
8540 	rsv->failfast = 1;  in btrfs_truncate()
8553 	ret = btrfs_block_rsv_migrate(&fs_info->trans_block_rsv, rsv,  in btrfs_truncate()
8564 	set_bit(BTRFS_INODE_NEEDS_FULL_SYNC, &BTRFS_I(inode)->runtime_flags);  in btrfs_truncate()
8565 	trans->block_rsv = rsv;  in btrfs_truncate()
8569 						 inode->i_size,  in btrfs_truncate()
8571 		trans->block_rsv = &fs_info->trans_block_rsv;  in btrfs_truncate()
8572 		if (ret != -ENOSPC && ret != -EAGAIN)  in btrfs_truncate()
8589 		btrfs_block_rsv_release(fs_info, rsv, -1, NULL);  in btrfs_truncate()
8590 		ret = btrfs_block_rsv_migrate(&fs_info->trans_block_rsv,  in btrfs_truncate()
8593 		trans->block_rsv = rsv;  in btrfs_truncate()
8606 		ret = btrfs_truncate_block(inode, inode->i_size, 0, 0);  in btrfs_truncate()
8620 		trans->block_rsv = &fs_info->trans_block_rsv;  in btrfs_truncate()
8654 	inode->i_op = &btrfs_dir_inode_operations;  in btrfs_create_subvol_root()
8655 	inode->i_fop = &btrfs_dir_file_operations;  in btrfs_create_subvol_root()
8663 		btrfs_err(new_root->fs_info,  in btrfs_create_subvol_root()
8665 			  new_root->root_key.objectid, err);  in btrfs_create_subvol_root()
8683 	ei->root = NULL;  in btrfs_alloc_inode()
8684 	ei->generation = 0;  in btrfs_alloc_inode()
8685 	ei->last_trans = 0;  in btrfs_alloc_inode()
8686 	ei->last_sub_trans = 0;  in btrfs_alloc_inode()
8687 	ei->logged_trans = 0;  in btrfs_alloc_inode()
8688 	ei->delalloc_bytes = 0;  in btrfs_alloc_inode()
8689 	ei->new_delalloc_bytes = 0;  in btrfs_alloc_inode()
8690 	ei->defrag_bytes = 0;  in btrfs_alloc_inode()
8691 	ei->disk_i_size = 0;  in btrfs_alloc_inode()
8692 	ei->flags = 0;  in btrfs_alloc_inode()
8693 	ei->csum_bytes = 0;  in btrfs_alloc_inode()
8694 	ei->index_cnt = (u64)-1;  in btrfs_alloc_inode()
8695 	ei->dir_index = 0;  in btrfs_alloc_inode()
8696 	ei->last_unlink_trans = 0;  in btrfs_alloc_inode()
8697 	ei->last_reflink_trans = 0;  in btrfs_alloc_inode()
8698 	ei->last_log_commit = 0;  in btrfs_alloc_inode()
8700 	spin_lock_init(&ei->lock);  in btrfs_alloc_inode()
8701 	ei->outstanding_extents = 0;  in btrfs_alloc_inode()
8702 	if (sb->s_magic != BTRFS_TEST_MAGIC)  in btrfs_alloc_inode()
8703 		btrfs_init_metadata_block_rsv(fs_info, &ei->block_rsv,  in btrfs_alloc_inode()
8705 	ei->runtime_flags = 0;  in btrfs_alloc_inode()
8706 	ei->prop_compress = BTRFS_COMPRESS_NONE;  in btrfs_alloc_inode()
8707 	ei->defrag_compress = BTRFS_COMPRESS_NONE;  in btrfs_alloc_inode()
8709 	ei->delayed_node = NULL;  in btrfs_alloc_inode()
8711 	ei->i_otime.tv_sec = 0;  in btrfs_alloc_inode()
8712 	ei->i_otime.tv_nsec = 0;  in btrfs_alloc_inode()
8714 	inode = &ei->vfs_inode;  in btrfs_alloc_inode()
8715 	extent_map_tree_init(&ei->extent_tree);  in btrfs_alloc_inode()
8716 	extent_io_tree_init(fs_info, &ei->io_tree, IO_TREE_INODE_IO, inode);  in btrfs_alloc_inode()
8717 	extent_io_tree_init(fs_info, &ei->io_failure_tree,  in btrfs_alloc_inode()
8719 	extent_io_tree_init(fs_info, &ei->file_extent_tree,  in btrfs_alloc_inode()
8721 	ei->io_tree.track_uptodate = true;  in btrfs_alloc_inode()
8722 	ei->io_failure_tree.track_uptodate = true;  in btrfs_alloc_inode()
8723 	atomic_set(&ei->sync_writers, 0);  in btrfs_alloc_inode()
8724 	mutex_init(&ei->log_mutex);  in btrfs_alloc_inode()
8725 	btrfs_ordered_inode_tree_init(&ei->ordered_tree);  in btrfs_alloc_inode()
8726 	INIT_LIST_HEAD(&ei->delalloc_inodes);  in btrfs_alloc_inode()
8727 	INIT_LIST_HEAD(&ei->delayed_iput);  in btrfs_alloc_inode()
8728 	RB_CLEAR_NODE(&ei->rb_node);  in btrfs_alloc_inode()
8729 	init_rwsem(&ei->dio_sem);  in btrfs_alloc_inode()
8737 	btrfs_drop_extent_cache(BTRFS_I(inode), 0, (u64)-1, 0);  in btrfs_test_destroy_inode()
8751 	struct btrfs_root *root = inode->root;  in btrfs_destroy_inode()
8753 	WARN_ON(!hlist_empty(&vfs_inode->i_dentry));  in btrfs_destroy_inode()
8754 	WARN_ON(vfs_inode->i_data.nrpages);  in btrfs_destroy_inode()
8755 	WARN_ON(inode->block_rsv.reserved);  in btrfs_destroy_inode()
8756 	WARN_ON(inode->block_rsv.size);  in btrfs_destroy_inode()
8757 	WARN_ON(inode->outstanding_extents);  in btrfs_destroy_inode()
8758 	WARN_ON(inode->delalloc_bytes);  in btrfs_destroy_inode()
8759 	WARN_ON(inode->new_delalloc_bytes);  in btrfs_destroy_inode()
8760 	WARN_ON(inode->csum_bytes);  in btrfs_destroy_inode()
8761 	WARN_ON(inode->defrag_bytes);  in btrfs_destroy_inode()
8772 		ordered = btrfs_lookup_first_ordered_extent(inode, (u64)-1);  in btrfs_destroy_inode()
8776 			btrfs_err(root->fs_info,  in btrfs_destroy_inode()
8778 				  ordered->file_offset, ordered->num_bytes);  in btrfs_destroy_inode()
8786 	btrfs_drop_extent_cache(inode, 0, (u64)-1, 0);  in btrfs_destroy_inode()
8787 	btrfs_inode_clear_file_extent_range(inode, 0, (u64)-1);  in btrfs_destroy_inode()
8788 	btrfs_put_root(inode->root);  in btrfs_destroy_inode()
8793 	struct btrfs_root *root = BTRFS_I(inode)->root;  in btrfs_drop_inode()
8799 	if (btrfs_root_refs(&root->root_item) == 0)  in btrfs_drop_inode()
8809 	inode_init_once(&ei->vfs_inode);  in init_once()
8862 	return -ENOMEM;  in btrfs_init_cachep()
8869 	struct inode *inode = d_inode(path->dentry);  in btrfs_getattr()
8870 	u32 blocksize = inode->i_sb->s_blocksize;  in btrfs_getattr()
8871 	u32 bi_flags = BTRFS_I(inode)->flags;  in btrfs_getattr()
8873 	stat->result_mask |= STATX_BTIME;  in btrfs_getattr()
8874 	stat->btime.tv_sec = BTRFS_I(inode)->i_otime.tv_sec;  in btrfs_getattr()
8875 	stat->btime.tv_nsec = BTRFS_I(inode)->i_otime.tv_nsec;  in btrfs_getattr()
8877 		stat->attributes |= STATX_ATTR_APPEND;  in btrfs_getattr()
8879 		stat->attributes |= STATX_ATTR_COMPRESSED;  in btrfs_getattr()
8881 		stat->attributes |= STATX_ATTR_IMMUTABLE;  in btrfs_getattr()
8883 		stat->attributes |= STATX_ATTR_NODUMP;  in btrfs_getattr()
8885 	stat->attributes_mask |= (STATX_ATTR_APPEND |  in btrfs_getattr()
8891 	stat->dev = BTRFS_I(inode)->root->anon_dev;  in btrfs_getattr()
8893 	spin_lock(&BTRFS_I(inode)->lock);  in btrfs_getattr()
8894 	delalloc_bytes = BTRFS_I(inode)->new_delalloc_bytes;  in btrfs_getattr()
8895 	spin_unlock(&BTRFS_I(inode)->lock);  in btrfs_getattr()
8896 	stat->blocks = (ALIGN(inode_get_bytes(inode), blocksize) +  in btrfs_getattr()
8906 	struct btrfs_fs_info *fs_info = btrfs_sb(old_dir->i_sb);  in btrfs_rename_exchange()
8908 	struct btrfs_root *root = BTRFS_I(old_dir)->root;  in btrfs_rename_exchange()
8909 	struct btrfs_root *dest = BTRFS_I(new_dir)->root;  in btrfs_rename_exchange()
8910 	struct inode *new_inode = new_dentry->d_inode;  in btrfs_rename_exchange()
8911 	struct inode *old_inode = old_dentry->d_inode;  in btrfs_rename_exchange()
8924 	 * For non-subvolumes allow exchange only within one subvolume, in the  in btrfs_rename_exchange()
8931 		return -EXDEV;  in btrfs_rename_exchange()
8936 		down_read(&fs_info->subvol_sem);  in btrfs_rename_exchange()
8966 	BTRFS_I(old_inode)->dir_index = 0ULL;  in btrfs_rename_exchange()
8967 	BTRFS_I(new_inode)->dir_index = 0ULL;  in btrfs_rename_exchange()
8977 					     new_dentry->d_name.name,  in btrfs_rename_exchange()
8978 					     new_dentry->d_name.len,  in btrfs_rename_exchange()
8995 					     old_dentry->d_name.name,  in btrfs_rename_exchange()
8996 					     old_dentry->d_name.len,  in btrfs_rename_exchange()
9012 	old_dir->i_ctime = old_dir->i_mtime = ctime;  in btrfs_rename_exchange()
9013 	new_dir->i_ctime = new_dir->i_mtime = ctime;  in btrfs_rename_exchange()
9014 	old_inode->i_ctime = ctime;  in btrfs_rename_exchange()
9015 	new_inode->i_ctime = ctime;  in btrfs_rename_exchange()
9017 	if (old_dentry->d_parent != new_dentry->d_parent) {  in btrfs_rename_exchange()
9029 					   BTRFS_I(old_dentry->d_inode),  in btrfs_rename_exchange()
9030 					   old_dentry->d_name.name,  in btrfs_rename_exchange()
9031 					   old_dentry->d_name.len);  in btrfs_rename_exchange()
9045 					   BTRFS_I(new_dentry->d_inode),  in btrfs_rename_exchange()
9046 					   new_dentry->d_name.name,  in btrfs_rename_exchange()
9047 					   new_dentry->d_name.len);  in btrfs_rename_exchange()
9057 			     new_dentry->d_name.name,  in btrfs_rename_exchange()
9058 			     new_dentry->d_name.len, 0, old_idx);  in btrfs_rename_exchange()
9065 			     old_dentry->d_name.name,  in btrfs_rename_exchange()
9066 			     old_dentry->d_name.len, 0, new_idx);  in btrfs_rename_exchange()
9072 	if (old_inode->i_nlink == 1)  in btrfs_rename_exchange()
9073 		BTRFS_I(old_inode)->dir_index = old_idx;  in btrfs_rename_exchange()
9074 	if (new_inode->i_nlink == 1)  in btrfs_rename_exchange()
9075 		BTRFS_I(new_inode)->dir_index = new_idx;  in btrfs_rename_exchange()
9079 				   new_dentry->d_parent);  in btrfs_rename_exchange()
9085 				   old_dentry->d_parent);  in btrfs_rename_exchange()
9102 		if (btrfs_inode_in_log(BTRFS_I(old_dir), fs_info->generation) ||  in btrfs_rename_exchange()
9103 		    btrfs_inode_in_log(BTRFS_I(new_dir), fs_info->generation) ||  in btrfs_rename_exchange()
9104 		    btrfs_inode_in_log(BTRFS_I(old_inode), fs_info->generation) ||  in btrfs_rename_exchange()
9106 		     btrfs_inode_in_log(BTRFS_I(new_inode), fs_info->generation)))  in btrfs_rename_exchange()
9123 		up_read(&fs_info->subvol_sem);  in btrfs_rename_exchange()
9143 				dentry->d_name.name,  in btrfs_whiteout_for_rename()
9144 				dentry->d_name.len,  in btrfs_whiteout_for_rename()
9155 	inode->i_op = &btrfs_special_inode_operations;  in btrfs_whiteout_for_rename()
9156 	init_special_inode(inode, inode->i_mode,  in btrfs_whiteout_for_rename()
9160 				&dentry->d_name);  in btrfs_whiteout_for_rename()
9183 	struct btrfs_fs_info *fs_info = btrfs_sb(old_dir->i_sb);  in btrfs_rename()
9186 	struct btrfs_root *root = BTRFS_I(old_dir)->root;  in btrfs_rename()
9187 	struct btrfs_root *dest = BTRFS_I(new_dir)->root;  in btrfs_rename()
9197 		return -EPERM;  in btrfs_rename()
9201 		return -EXDEV;  in btrfs_rename()
9205 		return -ENOTEMPTY;  in btrfs_rename()
9207 	if (S_ISDIR(old_inode->i_mode) && new_inode &&  in btrfs_rename()
9208 	    new_inode->i_size > BTRFS_EMPTY_DIR_SIZE)  in btrfs_rename()
9209 		return -ENOTEMPTY;  in btrfs_rename()
9213 	ret = btrfs_check_dir_item_collision(dest, new_dir->i_ino,  in btrfs_rename()
9214 			     new_dentry->d_name.name,  in btrfs_rename()
9215 			     new_dentry->d_name.len);  in btrfs_rename()
9218 		if (ret == -EEXIST) {  in btrfs_rename()
9225 			/* maybe -EOVERFLOW */  in btrfs_rename()
9235 	if (new_inode && S_ISREG(old_inode->i_mode) && new_inode->i_size)  in btrfs_rename()
9236 		filemap_flush(old_inode->i_mapping);  in btrfs_rename()
9240 		down_read(&fs_info->subvol_sem);  in btrfs_rename()
9268 	BTRFS_I(old_inode)->dir_index = 0ULL;  in btrfs_rename()
9276 					     new_dentry->d_name.name,  in btrfs_rename()
9277 					     new_dentry->d_name.len,  in btrfs_rename()
9287 	old_dir->i_ctime = old_dir->i_mtime =  in btrfs_rename()
9288 	new_dir->i_ctime = new_dir->i_mtime =  in btrfs_rename()
9289 	old_inode->i_ctime = current_time(old_dir);  in btrfs_rename()
9291 	if (old_dentry->d_parent != new_dentry->d_parent)  in btrfs_rename()
9300 					old_dentry->d_name.name,  in btrfs_rename()
9301 					old_dentry->d_name.len);  in btrfs_rename()
9312 		new_inode->i_ctime = current_time(new_inode);  in btrfs_rename()
9316 			BUG_ON(new_inode->i_nlink == 0);  in btrfs_rename()
9320 						 new_dentry->d_name.name,  in btrfs_rename()
9321 						 new_dentry->d_name.len);  in btrfs_rename()
9323 		if (!ret && new_inode->i_nlink == 0)  in btrfs_rename()
9333 			     new_dentry->d_name.name,  in btrfs_rename()
9334 			     new_dentry->d_name.len, 0, index);  in btrfs_rename()
9340 	if (old_inode->i_nlink == 1)  in btrfs_rename()
9341 		BTRFS_I(old_inode)->dir_index = index;  in btrfs_rename()
9345 				   new_dentry->d_parent);  in btrfs_rename()
9372 		if (btrfs_inode_in_log(BTRFS_I(old_dir), fs_info->generation) ||  in btrfs_rename()
9373 		    btrfs_inode_in_log(BTRFS_I(new_dir), fs_info->generation) ||  in btrfs_rename()
9374 		    btrfs_inode_in_log(BTRFS_I(old_inode), fs_info->generation) ||  in btrfs_rename()
9376 		     btrfs_inode_in_log(BTRFS_I(new_inode), fs_info->generation)))  in btrfs_rename()
9386 		up_read(&fs_info->subvol_sem);  in btrfs_rename()
9396 		return -EINVAL;  in btrfs_rename2()
9419 	inode = delalloc_work->inode;  in btrfs_run_delalloc_work()
9420 	filemap_flush(inode->i_mapping);  in btrfs_run_delalloc_work()
9422 				&BTRFS_I(inode)->runtime_flags))  in btrfs_run_delalloc_work()
9423 		filemap_flush(inode->i_mapping);  in btrfs_run_delalloc_work()
9426 	complete(&delalloc_work->completion);  in btrfs_run_delalloc_work()
9437 	init_completion(&work->completion);  in btrfs_alloc_delalloc_work()
9438 	INIT_LIST_HEAD(&work->list);  in btrfs_alloc_delalloc_work()
9439 	work->inode = inode;  in btrfs_alloc_delalloc_work()
9440 	btrfs_init_work(&work->work, btrfs_run_delalloc_work, NULL, NULL);  in btrfs_alloc_delalloc_work()
9459 	bool full_flush = wbc->nr_to_write == LONG_MAX;  in start_delalloc_inodes()
9464 	mutex_lock(&root->delalloc_mutex);  in start_delalloc_inodes()
9465 	spin_lock(&root->delalloc_lock);  in start_delalloc_inodes()
9466 	list_splice_init(&root->delalloc_inodes, &splice);  in start_delalloc_inodes()
9471 		list_move_tail(&binode->delalloc_inodes,  in start_delalloc_inodes()
9472 			       &root->delalloc_inodes);  in start_delalloc_inodes()
9475 		    test_bit(BTRFS_INODE_NO_DELALLOC_FLUSH, &binode->runtime_flags))  in start_delalloc_inodes()
9478 		inode = igrab(&binode->vfs_inode);  in start_delalloc_inodes()
9480 			cond_resched_lock(&root->delalloc_lock);  in start_delalloc_inodes()
9483 		spin_unlock(&root->delalloc_lock);  in start_delalloc_inodes()
9487 				&binode->runtime_flags);  in start_delalloc_inodes()
9492 				ret = -ENOMEM;  in start_delalloc_inodes()
9495 			list_add_tail(&work->list, &works);  in start_delalloc_inodes()
9496 			btrfs_queue_work(root->fs_info->flush_workers,  in start_delalloc_inodes()
9497 					 &work->work);  in start_delalloc_inodes()
9502 				     &BTRFS_I(inode)->runtime_flags))  in start_delalloc_inodes()
9505 			if (ret || wbc->nr_to_write <= 0)  in start_delalloc_inodes()
9509 		spin_lock(&root->delalloc_lock);  in start_delalloc_inodes()
9511 	spin_unlock(&root->delalloc_lock);  in start_delalloc_inodes()
9515 		list_del_init(&work->list);  in start_delalloc_inodes()
9516 		wait_for_completion(&work->completion);  in start_delalloc_inodes()
9521 		spin_lock(&root->delalloc_lock);  in start_delalloc_inodes()
9522 		list_splice_tail(&splice, &root->delalloc_inodes);  in start_delalloc_inodes()
9523 		spin_unlock(&root->delalloc_lock);  in start_delalloc_inodes()
9525 	mutex_unlock(&root->delalloc_mutex);  in start_delalloc_inodes()
9537 	struct btrfs_fs_info *fs_info = root->fs_info;  in btrfs_start_delalloc_snapshot()
9539 	if (test_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state))  in btrfs_start_delalloc_snapshot()
9540 		return -EROFS;  in btrfs_start_delalloc_snapshot()
9558 	if (test_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state))  in btrfs_start_delalloc_roots()
9559 		return -EROFS;  in btrfs_start_delalloc_roots()
9563 	mutex_lock(&fs_info->delalloc_root_mutex);  in btrfs_start_delalloc_roots()
9564 	spin_lock(&fs_info->delalloc_root_lock);  in btrfs_start_delalloc_roots()
9565 	list_splice_init(&fs_info->delalloc_roots, &splice);  in btrfs_start_delalloc_roots()
9578 		list_move_tail(&root->delalloc_root,  in btrfs_start_delalloc_roots()
9579 			       &fs_info->delalloc_roots);  in btrfs_start_delalloc_roots()
9580 		spin_unlock(&fs_info->delalloc_root_lock);  in btrfs_start_delalloc_roots()
9586 		spin_lock(&fs_info->delalloc_root_lock);  in btrfs_start_delalloc_roots()
9588 	spin_unlock(&fs_info->delalloc_root_lock);  in btrfs_start_delalloc_roots()
9593 		spin_lock(&fs_info->delalloc_root_lock);  in btrfs_start_delalloc_roots()
9594 		list_splice_tail(&splice, &fs_info->delalloc_roots);  in btrfs_start_delalloc_roots()
9595 		spin_unlock(&fs_info->delalloc_root_lock);  in btrfs_start_delalloc_roots()
9597 	mutex_unlock(&fs_info->delalloc_root_mutex);  in btrfs_start_delalloc_roots()
9604 	struct btrfs_fs_info *fs_info = btrfs_sb(dir->i_sb);  in btrfs_symlink()
9606 	struct btrfs_root *root = BTRFS_I(dir)->root;  in btrfs_symlink()
9621 		return -ENAMETOOLONG;  in btrfs_symlink()
9638 	inode = btrfs_new_inode(trans, root, dir, dentry->d_name.name,  in btrfs_symlink()
9639 				dentry->d_name.len, btrfs_ino(BTRFS_I(dir)),  in btrfs_symlink()
9653 	inode->i_fop = &btrfs_file_operations;  in btrfs_symlink()
9654 	inode->i_op = &btrfs_file_inode_operations;  in btrfs_symlink()
9655 	inode->i_mapping->a_ops = &btrfs_aops;  in btrfs_symlink()
9657 	err = btrfs_init_inode_security(trans, inode, dir, &dentry->d_name);  in btrfs_symlink()
9663 		err = -ENOMEM;  in btrfs_symlink()
9676 	leaf = path->nodes[0];  in btrfs_symlink()
9677 	ei = btrfs_item_ptr(leaf, path->slots[0],  in btrfs_symlink()
9679 	btrfs_set_file_extent_generation(leaf, ei, trans->transid);  in btrfs_symlink()
9692 	inode->i_op = &btrfs_symlink_inode_operations;  in btrfs_symlink()
9699 	 * last step to avoid extra cleanup of these indexes if an error happens  in btrfs_symlink()
9729 	u64 start = ins->objectid;  in insert_prealloc_file_extent()
9730 	u64 len = ins->offset;  in insert_prealloc_file_extent()
9767 		return ERR_PTR(-ENOMEM);  in insert_prealloc_file_extent()
9770 				     file_offset + len - 1, &extent_info,  in insert_prealloc_file_extent()
9784 	struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);  in __btrfs_prealloc_file_range()
9785 	struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;  in __btrfs_prealloc_file_range()
9787 	struct btrfs_root *root = BTRFS_I(inode)->root;  in __btrfs_prealloc_file_range()
9793 	u64 last_alloc = (u64)-1;  in __btrfs_prealloc_file_range()
9796 	u64 end = start + num_bytes - 1;  in __btrfs_prealloc_file_range()
9817 		 * ->bytes_may_use to ->bytes_reserved.  Any error that happens  in __btrfs_prealloc_file_range()
9841 					cur_offset + ins.offset -1, 0);  in __btrfs_prealloc_file_range()
9846 				&BTRFS_I(inode)->runtime_flags);  in __btrfs_prealloc_file_range()
9850 		em->start = cur_offset;  in __btrfs_prealloc_file_range()
9851 		em->orig_start = cur_offset;  in __btrfs_prealloc_file_range()
9852 		em->len = ins.offset;  in __btrfs_prealloc_file_range()
9853 		em->block_start = ins.objectid;  in __btrfs_prealloc_file_range()
9854 		em->block_len = ins.offset;  in __btrfs_prealloc_file_range()
9855 		em->orig_block_len = ins.offset;  in __btrfs_prealloc_file_range()
9856 		em->ram_bytes = ins.offset;  in __btrfs_prealloc_file_range()
9857 		set_bit(EXTENT_FLAG_PREALLOC, &em->flags);  in __btrfs_prealloc_file_range()
9858 		em->generation = trans->transid;  in __btrfs_prealloc_file_range()
9861 			write_lock(&em_tree->lock);  in __btrfs_prealloc_file_range()
9863 			write_unlock(&em_tree->lock);  in __btrfs_prealloc_file_range()
9864 			if (ret != -EEXIST)  in __btrfs_prealloc_file_range()
9867 						cur_offset + ins.offset - 1,  in __btrfs_prealloc_file_range()
9872 		num_bytes -= ins.offset;  in __btrfs_prealloc_file_range()
9877 		inode->i_ctime = current_time(inode);  in __btrfs_prealloc_file_range()
9878 		BTRFS_I(inode)->flags |= BTRFS_INODE_PREALLOC;  in __btrfs_prealloc_file_range()
9880 		    (actual_len > inode->i_size) &&  in __btrfs_prealloc_file_range()
9881 		    (cur_offset > inode->i_size)) {  in __btrfs_prealloc_file_range()
9906 			end - clear_offset + 1);  in __btrfs_prealloc_file_range()
9935 	struct btrfs_root *root = BTRFS_I(inode)->root;  in btrfs_permission()
9936 	umode_t mode = inode->i_mode;  in btrfs_permission()
9941 			return -EROFS;  in btrfs_permission()
9942 		if (BTRFS_I(inode)->flags & BTRFS_INODE_READONLY)  in btrfs_permission()
9943 			return -EACCES;  in btrfs_permission()
9950 	struct btrfs_fs_info *fs_info = btrfs_sb(dir->i_sb);  in btrfs_tmpfile()
9952 	struct btrfs_root *root = BTRFS_I(dir)->root;  in btrfs_tmpfile()
9977 	inode->i_fop = &btrfs_file_operations;  in btrfs_tmpfile()
9978 	inode->i_op = &btrfs_file_inode_operations;  in btrfs_tmpfile()
9980 	inode->i_mapping->a_ops = &btrfs_aops;  in btrfs_tmpfile()
9998 	 *    d_tmpfile() -> inode_dec_link_count() -> drop_nlink()  in btrfs_tmpfile()
10014 	struct inode *inode = tree->private_data;  in btrfs_set_range_writeback()
10020 		page = find_get_page(inode->i_mapping, index);  in btrfs_set_range_writeback()
10037 	struct btrfs_fs_info *fs_info = BTRFS_I(inode)->root->fs_info;  in btrfs_add_swapfile_pin()
10044 		return -ENOMEM;  in btrfs_add_swapfile_pin()
10045 	sp->ptr = ptr;  in btrfs_add_swapfile_pin()
10046 	sp->inode = inode;  in btrfs_add_swapfile_pin()
10047 	sp->is_block_group = is_block_group;  in btrfs_add_swapfile_pin()
10048 	sp->bg_extent_count = 1;  in btrfs_add_swapfile_pin()
10050 	spin_lock(&fs_info->swapfile_pins_lock);  in btrfs_add_swapfile_pin()
10051 	p = &fs_info->swapfile_pins.rb_node;  in btrfs_add_swapfile_pin()
10055 		if (sp->ptr < entry->ptr ||  in btrfs_add_swapfile_pin()
10056 		    (sp->ptr == entry->ptr && sp->inode < entry->inode)) {  in btrfs_add_swapfile_pin()
10057 			p = &(*p)->rb_left;  in btrfs_add_swapfile_pin()
10058 		} else if (sp->ptr > entry->ptr ||  in btrfs_add_swapfile_pin()
10059 			   (sp->ptr == entry->ptr && sp->inode > entry->inode)) {  in btrfs_add_swapfile_pin()
10060 			p = &(*p)->rb_right;  in btrfs_add_swapfile_pin()
10063 				entry->bg_extent_count++;  in btrfs_add_swapfile_pin()
10064 			spin_unlock(&fs_info->swapfile_pins_lock);  in btrfs_add_swapfile_pin()
10069 	rb_link_node(&sp->node, parent, p);  in btrfs_add_swapfile_pin()
10070 	rb_insert_color(&sp->node, &fs_info->swapfile_pins);  in btrfs_add_swapfile_pin()
10071 	spin_unlock(&fs_info->swapfile_pins_lock);  in btrfs_add_swapfile_pin()
10078 	struct btrfs_fs_info *fs_info = BTRFS_I(inode)->root->fs_info;  in btrfs_free_swapfile_pins()
10082 	spin_lock(&fs_info->swapfile_pins_lock);  in btrfs_free_swapfile_pins()
10083 	node = rb_first(&fs_info->swapfile_pins);  in btrfs_free_swapfile_pins()
10087 		if (sp->inode == inode) {  in btrfs_free_swapfile_pins()
10088 			rb_erase(&sp->node, &fs_info->swapfile_pins);  in btrfs_free_swapfile_pins()
10089 			if (sp->is_block_group) {  in btrfs_free_swapfile_pins()
10090 				btrfs_dec_block_group_swap_extents(sp->ptr,  in btrfs_free_swapfile_pins()
10091 							   sp->bg_extent_count);  in btrfs_free_swapfile_pins()
10092 				btrfs_put_block_group(sp->ptr);  in btrfs_free_swapfile_pins()
10098 	spin_unlock(&fs_info->swapfile_pins_lock);  in btrfs_free_swapfile_pins()
10124 	if (bsi->nr_pages >= sis->max)  in btrfs_add_swap_extent()
10127 	max_pages = sis->max - bsi->nr_pages;  in btrfs_add_swap_extent()
10128 	first_ppage = ALIGN(bsi->block_start, PAGE_SIZE) >> PAGE_SHIFT;  in btrfs_add_swap_extent()
10129 	next_ppage = ALIGN_DOWN(bsi->block_start + bsi->block_len,  in btrfs_add_swap_extent()
10134 	nr_pages = next_ppage - first_ppage;  in btrfs_add_swap_extent()
10138 	if (bsi->start == 0)  in btrfs_add_swap_extent()
10140 	if (bsi->lowest_ppage > first_ppage_reported)  in btrfs_add_swap_extent()
10141 		bsi->lowest_ppage = first_ppage_reported;  in btrfs_add_swap_extent()
10142 	if (bsi->highest_ppage < (next_ppage - 1))  in btrfs_add_swap_extent()
10143 		bsi->highest_ppage = next_ppage - 1;  in btrfs_add_swap_extent()
10145 	ret = add_swap_extent(sis, bsi->nr_pages, nr_pages, first_ppage);  in btrfs_add_swap_extent()
10148 	bsi->nr_extents += ret;  in btrfs_add_swap_extent()
10149 	bsi->nr_pages += nr_pages;  in btrfs_add_swap_extent()
10158 	atomic_dec(&BTRFS_I(inode)->root->nr_swapfiles);  in btrfs_swap_deactivate()
10165 	struct btrfs_root *root = BTRFS_I(inode)->root;  in btrfs_swap_activate()
10166 	struct btrfs_fs_info *fs_info = root->fs_info;  in btrfs_swap_activate()
10167 	struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;  in btrfs_swap_activate()
10172 		.lowest_ppage = (sector_t)-1ULL,  in btrfs_swap_activate()
10183 	ret = btrfs_wait_ordered_range(inode, 0, (u64)-1);  in btrfs_swap_activate()
10190 	if (BTRFS_I(inode)->flags & BTRFS_INODE_COMPRESS) {  in btrfs_swap_activate()
10192 		return -EINVAL;  in btrfs_swap_activate()
10194 	if (!(BTRFS_I(inode)->flags & BTRFS_INODE_NODATACOW)) {  in btrfs_swap_activate()
10195 		btrfs_warn(fs_info, "swapfile must not be copy-on-write");  in btrfs_swap_activate()
10196 		return -EINVAL;  in btrfs_swap_activate()
10198 	if (!(BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM)) {  in btrfs_swap_activate()
10200 		return -EINVAL;  in btrfs_swap_activate()
10207 	 * fs_info->swapfile_pins prevents them from running while the swap  in btrfs_swap_activate()
10215 		return -EBUSY;  in btrfs_swap_activate()
10225 	if (!btrfs_drew_try_write_lock(&root->snapshot_lock)) {  in btrfs_swap_activate()
10229 		return -EINVAL;  in btrfs_swap_activate()
10241 	spin_lock(&root->root_item_lock);  in btrfs_swap_activate()
10243 		spin_unlock(&root->root_item_lock);  in btrfs_swap_activate()
10248 			root->root_key.objectid);  in btrfs_swap_activate()
10249 		return -EPERM;  in btrfs_swap_activate()
10251 	atomic_inc(&root->nr_swapfiles);  in btrfs_swap_activate()
10252 	spin_unlock(&root->root_item_lock);  in btrfs_swap_activate()
10254 	isize = ALIGN_DOWN(inode->i_size, fs_info->sectorsize);  in btrfs_swap_activate()
10256 	lock_extent_bits(io_tree, 0, isize - 1, &cached_state);  in btrfs_swap_activate()
10261 		u64 len = isize - start;  in btrfs_swap_activate()
10269 		if (em->block_start == EXTENT_MAP_HOLE) {  in btrfs_swap_activate()
10271 			ret = -EINVAL;  in btrfs_swap_activate()
10274 		if (em->block_start == EXTENT_MAP_INLINE) {  in btrfs_swap_activate()
10283 			ret = -EINVAL;  in btrfs_swap_activate()
10286 		if (test_bit(EXTENT_FLAG_COMPRESSED, &em->flags)) {  in btrfs_swap_activate()
10288 			ret = -EINVAL;  in btrfs_swap_activate()
10292 		logical_block_start = em->block_start + (start - em->start);  in btrfs_swap_activate()
10293 		len = min(len, em->len - (start - em->start));  in btrfs_swap_activate()
10304 				   "swapfile must not be copy-on-write");  in btrfs_swap_activate()
10305 			ret = -EINVAL;  in btrfs_swap_activate()
10315 		if (em->map_lookup->type & BTRFS_BLOCK_GROUP_PROFILE_MASK) {  in btrfs_swap_activate()
10318 			ret = -EINVAL;  in btrfs_swap_activate()
10323 			device = em->map_lookup->stripes[0].dev;  in btrfs_swap_activate()
10329 		} else if (device != em->map_lookup->stripes[0].dev) {  in btrfs_swap_activate()
10331 			ret = -EINVAL;  in btrfs_swap_activate()
10335 		physical_block_start = (em->map_lookup->stripes[0].physical +  in btrfs_swap_activate()
10336 					(logical_block_start - em->start));  in btrfs_swap_activate()
10337 		len = min(len, em->len - (logical_block_start - em->start));  in btrfs_swap_activate()
10345 			ret = -EINVAL;  in btrfs_swap_activate()
10351 			   "block group for swapfile at %llu is read-only%s",  in btrfs_swap_activate()
10352 			   bg->start,  in btrfs_swap_activate()
10353 			   atomic_read(&fs_info->scrubs_running) ?  in btrfs_swap_activate()
10356 			ret = -EINVAL;  in btrfs_swap_activate()
10393 	unlock_extent_cached(io_tree, 0, isize - 1, &cached_state);  in btrfs_swap_activate()
10398 	btrfs_drew_write_unlock(&root->snapshot_lock);  in btrfs_swap_activate()
10406 		sis->bdev = device->bdev;  in btrfs_swap_activate()
10407 	*span = bsi.highest_ppage - bsi.lowest_ppage + 1;  in btrfs_swap_activate()
10408 	sis->max = bsi.nr_pages;  in btrfs_swap_activate()
10409 	sis->pages = bsi.nr_pages - 1;  in btrfs_swap_activate()
10410 	sis->highest_bit = bsi.nr_pages - 1;  in btrfs_swap_activate()
10421 	return -EOPNOTSUPP;  in btrfs_swap_activate()