1 // SPDX-License-Identifier: GPL-2.0
9 #include <linux/blk-cgroup.h>
17 #include <linux/backing-dev.h>
39 #include "disk-io.h"
42 #include "ordered-data.h"
44 #include "tree-log.h"
50 #include "delalloc-space.h"
51 #include "block-group.h"
52 #include "space-info.h"
55 #include "inode-item.h"
58 #include "extent-tree.h"
59 #include "root-tree.h"
61 #include "dir-item.h"
62 #include "file-item.h"
63 #include "uuid-tree.h"
72 #include "raid-stripe-tree.h"
130 	struct btrfs_fs_info *fs_info = warn->fs_info;  in data_reloc_print_warning_inode()
151 	ret = btrfs_search_slot(NULL, local_root, &key, &warn->path, 0, 0);  in data_reloc_print_warning_inode()
154 		btrfs_release_path(&warn->path);  in data_reloc_print_warning_inode()
158 	eb = warn->path.nodes[0];  in data_reloc_print_warning_inode()
159 	inode_item = btrfs_item_ptr(eb, warn->path.slots[0], struct btrfs_inode_item);  in data_reloc_print_warning_inode()
161 	btrfs_release_path(&warn->path);  in data_reloc_print_warning_inode()
164 	ipath = init_ipath(4096, local_root, &warn->path);  in data_reloc_print_warning_inode()
171 		 * -ENOMEM, not a critical error, just output an generic error  in data_reloc_print_warning_inode()
176 			   warn->logical, warn->mirror_num, root, inum, offset);  in data_reloc_print_warning_inode()
187 	for (int i = 0; i < ipath->fspath->elem_cnt; i++) {  in data_reloc_print_warning_inode()
190 			   warn->logical, warn->mirror_num, root, inum, offset,  in data_reloc_print_warning_inode()
191 			   fs_info->sectorsize, nlink,  in data_reloc_print_warning_inode()
192 			   (char *)(unsigned long)ipath->fspath->val[i]);  in data_reloc_print_warning_inode()
202 		   warn->logical, warn->mirror_num, root, inum, offset, ret);  in data_reloc_print_warning_inode()
209  * Do extra user-friendly error output (e.g. lookup all the affected files).
218 	struct btrfs_fs_info *fs_info = inode->root->fs_info;  in print_data_reloc_error()
223 	const u32 csum_size = fs_info->csum_size;  in print_data_reloc_error()
229 	mutex_lock(&fs_info->reloc_mutex);  in print_data_reloc_error()
231 	mutex_unlock(&fs_info->reloc_mutex);  in print_data_reloc_error()
237 			btrfs_root_id(inode->root), btrfs_ino(inode), file_off,  in print_data_reloc_error()
247 			btrfs_root_id(inode->root),  in print_data_reloc_error()
294 		ctx.extent_item_pos = logical - found_key.objectid;  in print_data_reloc_error()
310 	struct btrfs_root *root = inode->root;  in btrfs_print_data_csum_error()
311 	const u32 csum_size = root->fs_info->csum_size;  in btrfs_print_data_csum_error()
320 		btrfs_warn_rl(root->fs_info,  in btrfs_print_data_csum_error()
328 		btrfs_warn_rl(root->fs_info,  in btrfs_print_data_csum_error()
343  * BTRFS_ILOCK_SHARED - acquire a shared lock on the inode
344  * BTRFS_ILOCK_TRY - try to acquire the lock, if fails on first attempt
345  *		     return -EAGAIN
346  * BTRFS_ILOCK_MMAP - acquire a write lock on the i_mmap_lock
352 			if (!inode_trylock_shared(&inode->vfs_inode))  in btrfs_inode_lock()
353 				return -EAGAIN;  in btrfs_inode_lock()
357 		inode_lock_shared(&inode->vfs_inode);  in btrfs_inode_lock()
360 			if (!inode_trylock(&inode->vfs_inode))  in btrfs_inode_lock()
361 				return -EAGAIN;  in btrfs_inode_lock()
365 		inode_lock(&inode->vfs_inode);  in btrfs_inode_lock()
368 		down_write(&inode->i_mmap_lock);  in btrfs_inode_lock()
381 		up_write(&inode->i_mmap_lock);  in btrfs_inode_unlock()
383 		inode_unlock_shared(&inode->vfs_inode);  in btrfs_inode_unlock()
385 		inode_unlock(&inode->vfs_inode);  in btrfs_inode_unlock()
402 	const pgoff_t end_index = (offset + bytes - 1) >> PAGE_SHIFT;  in btrfs_cleanup_ordered_extents()
406 		folio = filemap_get_folio(inode->vfs_inode.i_mapping, index);  in btrfs_cleanup_ordered_extents()
418 		btrfs_folio_clamp_clear_ordered(inode->root->fs_info, folio,  in btrfs_cleanup_ordered_extents()
433 	if (args->default_acl) {  in btrfs_init_inode_security()
434 		ret = __btrfs_set_acl(trans, args->inode, args->default_acl,  in btrfs_init_inode_security()
439 	if (args->acl) {  in btrfs_init_inode_security()
440 		ret = __btrfs_set_acl(trans, args->inode, args->acl, ACL_TYPE_ACCESS);  in btrfs_init_inode_security()
444 	if (!args->default_acl && !args->acl)  in btrfs_init_inode_security()
445 		cache_no_acl(args->inode);  in btrfs_init_inode_security()
446 	return btrfs_xattr_security_init(trans, args->inode, args->dir,  in btrfs_init_inode_security()
447 					 &args->dentry->d_name);  in btrfs_init_inode_security()
463 	struct btrfs_root *root = inode->root;  in insert_inline_extent()
465 	const u32 sectorsize = trans->fs_info->sectorsize;  in insert_inline_extent()
506 	leaf = path->nodes[0];  in insert_inline_extent()
507 	ei = btrfs_item_ptr(leaf, path->slots[0],  in insert_inline_extent()
509 	btrfs_set_file_extent_generation(leaf, ei, trans->transid);  in insert_inline_extent()
526 		folio = filemap_get_folio(inode->vfs_inode.i_mapping, 0);  in insert_inline_extent()
541 					ALIGN(size, root->fs_info->sectorsize));  in insert_inline_extent()
552 	i_size = i_size_read(&inode->vfs_inode);  in insert_inline_extent()
554 		i_size_write(&inode->vfs_inode, size);  in insert_inline_extent()
557 	inode->disk_i_size = i_size;  in insert_inline_extent()
567 	struct btrfs_fs_info *fs_info = inode->root->fs_info;  in can_cow_file_range_inline()
575 	if (size > fs_info->sectorsize)  in can_cow_file_range_inline()
578 	/* We do not allow a non-compressed extent to be as large as block size. */  in can_cow_file_range_inline()
579 	if (data_len >= fs_info->sectorsize)  in can_cow_file_range_inline()
587 	if (data_len > fs_info->max_inline)  in can_cow_file_range_inline()
591 	if (size < i_size_read(&inode->vfs_inode))  in can_cow_file_range_inline()
612 	struct btrfs_root *root = inode->root;  in __cow_file_range_inline()
613 	struct btrfs_fs_info *fs_info = root->fs_info;  in __cow_file_range_inline()
621 		return -ENOMEM;  in __cow_file_range_inline()
628 	trans->block_rsv = &inode->block_rsv;  in __cow_file_range_inline()
632 	drop_args.end = fs_info->sectorsize;  in __cow_file_range_inline()
645 	if (unlikely(ret && ret != -ENOSPC)) {  in __cow_file_range_inline()
648 	} else if (ret == -ENOSPC) {  in __cow_file_range_inline()
655 	if (unlikely(ret && ret != -ENOSPC)) {  in __cow_file_range_inline()
658 	} else if (ret == -ENOSPC) {  in __cow_file_range_inline()
671 	btrfs_qgroup_free_data(inode, NULL, 0, fs_info->sectorsize, NULL);  in __cow_file_range_inline()
688 	u64 size = min_t(u64, i_size_read(&inode->vfs_inode), end + 1);  in cow_file_range_inline()
694 	btrfs_lock_extent(&inode->io_tree, offset, end, &cached);  in cow_file_range_inline()
699 		btrfs_unlock_extent(&inode->io_tree, offset, end, &cached);  in cow_file_range_inline()
764 		return -ENOMEM;  in add_async_extent()
765 	async_extent->start = start;  in add_async_extent()
766 	async_extent->ram_size = ram_size;  in add_async_extent()
767 	async_extent->compressed_size = compressed_size;  in add_async_extent()
768 	async_extent->folios = folios;  in add_async_extent()
769 	async_extent->nr_folios = nr_folios;  in add_async_extent()
770 	async_extent->compress_type = compress_type;  in add_async_extent()
771 	list_add_tail(&async_extent->list, &cow->extents);  in add_async_extent()
782 	struct btrfs_fs_info *fs_info = inode->root->fs_info;  in inode_need_compress()
790 	if (inode->defrag_compress == BTRFS_DEFRAG_DONT_COMPRESS)  in inode_need_compress()
792 	if (BTRFS_COMPRESS_NONE < inode->defrag_compress &&  in inode_need_compress()
793 	    inode->defrag_compress < BTRFS_NR_COMPRESS_TYPES)  in inode_need_compress()
799 	if (inode->flags & BTRFS_INODE_NOCOMPRESS)  in inode_need_compress()
802 	    inode->flags & BTRFS_INODE_COMPRESS ||  in inode_need_compress()
803 	    inode->prop_compress)  in inode_need_compress()
813 	    (start > 0 || end + 1 < inode->disk_i_size))  in inode_should_defrag()
824 		folio = filemap_get_folio(inode->vfs_inode.i_mapping, index);  in extent_range_clear_dirty_for_io()
830 		btrfs_folio_clamp_clear_dirty(inode->root->fs_info, folio, start,  in extent_range_clear_dirty_for_io()
831 					      end + 1 - start);  in extent_range_clear_dirty_for_io()
854 	struct btrfs_inode *inode = async_chunk->inode;  in compress_file_range()
855 	struct btrfs_fs_info *fs_info = inode->root->fs_info;  in compress_file_range()
856 	struct address_space *mapping = inode->vfs_inode.i_mapping;  in compress_file_range()
857 	const u32 min_folio_shift = PAGE_SHIFT + fs_info->block_min_order;  in compress_file_range()
859 	u64 blocksize = fs_info->sectorsize;  in compress_file_range()
860 	u64 start = async_chunk->start;  in compress_file_range()
861 	u64 end = async_chunk->end;  in compress_file_range()
871 	int compress_type = fs_info->compress_type;  in compress_file_range()
872 	int compress_level = fs_info->compress_level;  in compress_file_range()
874 	inode_should_defrag(inode, start, end, end - start + 1, SZ_16K);  in compress_file_range()
902 	i_size = i_size_read(&inode->vfs_inode);  in compress_file_range()
907 	nr_folios = (end >> min_folio_shift) - (start >> min_folio_shift) + 1;  in compress_file_range()
923 	total_compressed = actual_end - start;  in compress_file_range()
930 	   (start > 0 || end + 1 < inode->disk_i_size))  in compress_file_range()
939 	 * We do compression for mount -o compress and when the inode has not  in compress_file_range()
955 	if (0 < inode->defrag_compress && inode->defrag_compress < BTRFS_NR_COMPRESS_TYPES) {  in compress_file_range()
956 		compress_type = inode->defrag_compress;  in compress_file_range()
957 		compress_level = inode->defrag_compress_level;  in compress_file_range()
958 	} else if (inode->prop_compress) {  in compress_file_range()
959 		compress_type = inode->prop_compress;  in compress_file_range()
973 	loff = (total_compressed & (min_folio_size - 1));  in compress_file_range()
975 		folio_zero_range(folios[nr_folios - 1], loff, min_folio_size - loff);  in compress_file_range()
994 			mapping_set_error(mapping, -EIO);  in compress_file_range()
1009 	total_in = round_up(total_in, fs_info->sectorsize);  in compress_file_range()
1028 	if (!btrfs_test_opt(fs_info, FORCE_COMPRESS) && !inode->prop_compress)  in compress_file_range()
1029 		inode->flags |= BTRFS_INODE_NOCOMPRESS;  in compress_file_range()
1031 	ret = add_async_extent(async_chunk, start, end - start + 1, 0, NULL, 0,  in compress_file_range()
1037 			WARN_ON(folios[i]->mapping);  in compress_file_range()
1048 	if (!async_extent->folios)  in free_async_extent_pages()
1051 	for (i = 0; i < async_extent->nr_folios; i++) {  in free_async_extent_pages()
1052 		WARN_ON(async_extent->folios[i]->mapping);  in free_async_extent_pages()
1053 		btrfs_free_compr_folio(async_extent->folios[i]);  in free_async_extent_pages()
1055 	kfree(async_extent->folios);  in free_async_extent_pages()
1056 	async_extent->nr_folios = 0;  in free_async_extent_pages()
1057 	async_extent->folios = NULL;  in free_async_extent_pages()
1064 	u64 start = async_extent->start;  in submit_uncompressed_range()
1065 	u64 end = async_extent->start + async_extent->ram_size - 1;  in submit_uncompressed_range()
1074 	wbc_attach_fdatawrite_inode(&wbc, &inode->vfs_inode);  in submit_uncompressed_range()
1080 			btrfs_folio_end_lock(inode->root->fs_info, locked_folio,  in submit_uncompressed_range()
1081 					     start, async_extent->ram_size);  in submit_uncompressed_range()
1082 		btrfs_err_rl(inode->root->fs_info,  in submit_uncompressed_range()
1084 			     __func__, btrfs_root_id(inode->root),  in submit_uncompressed_range()
1085 			     btrfs_ino(inode), start, async_extent->ram_size, ret);  in submit_uncompressed_range()
1093 	struct btrfs_inode *inode = async_chunk->inode;  in submit_one_async_extent()
1094 	struct extent_io_tree *io_tree = &inode->io_tree;  in submit_one_async_extent()
1095 	struct btrfs_root *root = inode->root;  in submit_one_async_extent()
1096 	struct btrfs_fs_info *fs_info = root->fs_info;  in submit_one_async_extent()
1105 	u64 start = async_extent->start;  in submit_one_async_extent()
1106 	u64 end = async_extent->start + async_extent->ram_size - 1;  in submit_one_async_extent()
1108 	if (async_chunk->blkcg_css)  in submit_one_async_extent()
1109 		kthread_associate_blkcg(async_chunk->blkcg_css);  in submit_one_async_extent()
1112 	 * If async_chunk->locked_folio is in the async_extent range, we need to  in submit_one_async_extent()
1115 	if (async_chunk->locked_folio) {  in submit_one_async_extent()
1116 		u64 locked_folio_start = folio_pos(async_chunk->locked_folio);  in submit_one_async_extent()
1118 			folio_size(async_chunk->locked_folio) - 1;  in submit_one_async_extent()
1121 			locked_folio = async_chunk->locked_folio;  in submit_one_async_extent()
1124 	if (async_extent->compress_type == BTRFS_COMPRESS_NONE) {  in submit_one_async_extent()
1125 		ASSERT(!async_extent->folios);  in submit_one_async_extent()
1126 		ASSERT(async_extent->nr_folios == 0);  in submit_one_async_extent()
1132 	ret = btrfs_reserve_extent(root, async_extent->ram_size,  in submit_one_async_extent()
1133 				   async_extent->compressed_size,  in submit_one_async_extent()
1134 				   async_extent->compressed_size,  in submit_one_async_extent()
1140 		 * non-contiguous space for the uncompressed size instead.  So  in submit_one_async_extent()
1153 	file_extent.ram_bytes = async_extent->ram_size;  in submit_one_async_extent()
1154 	file_extent.num_bytes = async_extent->ram_size;  in submit_one_async_extent()
1156 	file_extent.compression = async_extent->compress_type;  in submit_one_async_extent()
1179 			    async_extent->folios,	/* compressed_folios */  in submit_one_async_extent()
1180 			    async_extent->nr_folios,  in submit_one_async_extent()
1181 			    async_chunk->write_flags, true);  in submit_one_async_extent()
1184 	if (async_chunk->blkcg_css)  in submit_one_async_extent()
1194 	mapping_set_error(inode->vfs_inode.i_mapping, -EIO);  in submit_one_async_extent()
1203 	if (async_chunk->blkcg_css)  in submit_one_async_extent()
1208 		    async_extent->ram_size, ret);  in submit_one_async_extent()
1215 	struct extent_map_tree *em_tree = &inode->extent_tree;  in btrfs_get_extent_allocation_hint()
1219 	read_lock(&em_tree->lock);  in btrfs_get_extent_allocation_hint()
1227 		if (em->disk_bytenr >= EXTENT_MAP_LAST_BYTE) {  in btrfs_get_extent_allocation_hint()
1230 			if (em && em->disk_bytenr < EXTENT_MAP_LAST_BYTE)  in btrfs_get_extent_allocation_hint()
1239 	read_unlock(&em_tree->lock);  in btrfs_get_extent_allocation_hint()
1251  * it to make sure we don't do extra locks or unlocks.
1263  * - If COW_FILE_RANGE_KEEP_LOCKED flag is set, all folios are kept locked.
1264  * - Else all folios except for @locked_folio are unlocked.
1267  * while-loop, the ordered extents created in previous iterations are cleaned up.
1274 	struct btrfs_root *root = inode->root;  in cow_file_range()
1275 	struct btrfs_fs_info *fs_info = root->fs_info;  in cow_file_range()
1282 	u64 blocksize = fs_info->sectorsize;  in cow_file_range()
1290 		ret = -EINVAL;  in cow_file_range()
1294 	num_bytes = ALIGN(end - start + 1, blocksize);  in cow_file_range()
1296 	ASSERT(num_bytes <= btrfs_super_total_bytes(fs_info->super_copy));  in cow_file_range()
1345 		min_alloc_size = fs_info->sectorsize;  in cow_file_range()
1354 		if (ret == -EAGAIN) {  in cow_file_range()
1356 			 * btrfs_reserve_extent only returns -EAGAIN for zoned  in cow_file_range()
1364 			 * us, or return -ENOSPC if it can't handle retries.  in cow_file_range()
1368 				wait_on_bit_io(&inode->root->fs_info->flags,  in cow_file_range()
1378 				end = start - 1;  in cow_file_range()
1382 			ret = -ENOSPC;  in cow_file_range()
1399 		btrfs_lock_extent(&inode->io_tree, start, start + cur_alloc_size - 1,  in cow_file_range()
1405 			btrfs_unlock_extent(&inode->io_tree, start,  in cow_file_range()
1406 					    start + cur_alloc_size - 1, &cached);  in cow_file_range()
1415 			btrfs_unlock_extent(&inode->io_tree, start,  in cow_file_range()
1416 					    start + cur_alloc_size - 1, &cached);  in cow_file_range()
1437 							    start + cur_alloc_size - 1,  in cow_file_range()
1447 			num_bytes -= cur_alloc_size;  in cow_file_range()
1468 	btrfs_drop_extent_map_range(inode, start, start + cur_alloc_size - 1, false);  in cow_file_range()
1476 	 * |-------(1)----|---(2)---|-------------(3)----------|  in cow_file_range()
1477 	 * `- orig_start  `- start  `- start + cur_alloc_size  `- end  in cow_file_range()
1496 			mapping_set_error(inode->vfs_inode.i_mapping, ret);  in cow_file_range()
1498 		btrfs_cleanup_ordered_extents(inode, orig_start, start - orig_start);  in cow_file_range()
1499 		extent_clear_unlock_delalloc(inode, orig_start, start - 1,  in cow_file_range()
1519 					     start + cur_alloc_size - 1,  in cow_file_range()
1537 				       end - start - cur_alloc_size + 1, NULL);  in cow_file_range()
1541 		  __func__, btrfs_root_id(inode->root),  in cow_file_range()
1542 		  btrfs_ino(inode), orig_start, end + 1 - orig_start,  in cow_file_range()
1567 		btrfs_add_delayed_iput(async_chunk->inode);  in submit_compressed_extents()
1568 		if (async_chunk->blkcg_css)  in submit_compressed_extents()
1569 			css_put(async_chunk->blkcg_css);  in submit_compressed_extents()
1571 		async_cow = async_chunk->async_cow;  in submit_compressed_extents()
1572 		if (atomic_dec_and_test(&async_cow->num_chunks))  in submit_compressed_extents()
1577 	nr_pages = (async_chunk->end - async_chunk->start + PAGE_SIZE) >>  in submit_compressed_extents()
1580 	while (!list_empty(&async_chunk->extents)) {  in submit_compressed_extents()
1581 		async_extent = list_first_entry(&async_chunk->extents,  in submit_compressed_extents()
1583 		list_del(&async_extent->list);  in submit_compressed_extents()
1588 	if (atomic_sub_return(nr_pages, &fs_info->async_delalloc_pages) <  in submit_compressed_extents()
1590 		cond_wake_up_nomb(&fs_info->async_submit_wait);  in submit_compressed_extents()
1597 	struct btrfs_fs_info *fs_info = inode->root->fs_info;  in run_delalloc_compressed()
1602 	u64 num_chunks = DIV_ROUND_UP(end - start, SZ_512K);  in run_delalloc_compressed()
1613 	set_bit(BTRFS_INODE_HAS_ASYNC_EXTENT, &inode->runtime_flags);  in run_delalloc_compressed()
1615 	async_chunk = ctx->chunks;  in run_delalloc_compressed()
1616 	atomic_set(&ctx->num_chunks, num_chunks);  in run_delalloc_compressed()
1619 		u64 cur_end = min(end, start + SZ_512K - 1);  in run_delalloc_compressed()
1625 		ihold(&inode->vfs_inode);  in run_delalloc_compressed()
1654 						 cur_end - start);  in run_delalloc_compressed()
1672 		nr_pages = DIV_ROUND_UP(cur_end - start, PAGE_SIZE);  in run_delalloc_compressed()
1673 		atomic_add(nr_pages, &fs_info->async_delalloc_pages);  in run_delalloc_compressed()
1675 		btrfs_queue_work(fs_info->delalloc_workers, &async_chunk[i].work);  in run_delalloc_compressed()
1699 		extent_write_locked_range(&inode->vfs_inode, locked_folio,  in run_delalloc_cow()
1712 	const bool is_reloc_ino = btrfs_is_data_reloc_root(inode->root);  in fallback_to_cow()
1713 	const u64 range_bytes = end + 1 - start;  in fallback_to_cow()
1714 	struct extent_io_tree *io_tree = &inode->io_tree;  in fallback_to_cow()
1757 		struct btrfs_fs_info *fs_info = inode->root->fs_info;  in fallback_to_cow()
1758 		struct btrfs_space_info *sinfo = fs_info->data_sinfo;  in fallback_to_cow()
1763 		spin_lock(&sinfo->lock);  in fallback_to_cow()
1765 		spin_unlock(&sinfo->lock);  in fallback_to_cow()
1814  * if path->nodes[0] is NULL or not if it needs to use the path afterwards.
1826 	struct extent_buffer *leaf = path->nodes[0];  in can_nocow_file_extent()
1827 	struct btrfs_root *root = inode->root;  in can_nocow_file_extent()
1835 	bool nowait = path->nowait;  in can_nocow_file_extent()
1837 	fi = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_file_extent_item);  in can_nocow_file_extent()
1843 	if (!(inode->flags & BTRFS_INODE_NODATACOW) &&  in can_nocow_file_extent()
1853 	    btrfs_root_last_snapshot(&root->root_item))  in can_nocow_file_extent()
1868 	args->file_extent.disk_bytenr = btrfs_file_extent_disk_bytenr(leaf, fi);  in can_nocow_file_extent()
1869 	args->file_extent.disk_num_bytes = btrfs_file_extent_disk_num_bytes(leaf, fi);  in can_nocow_file_extent()
1870 	args->file_extent.ram_bytes = btrfs_file_extent_ram_bytes(leaf, fi);  in can_nocow_file_extent()
1871 	args->file_extent.offset = btrfs_file_extent_offset(leaf, fi);  in can_nocow_file_extent()
1872 	args->file_extent.compression = btrfs_file_extent_compression(leaf, fi);  in can_nocow_file_extent()
1881 	ret = btrfs_cross_ref_exist(inode, key->offset - args->file_extent.offset,  in can_nocow_file_extent()
1882 				    args->file_extent.disk_bytenr, path);  in can_nocow_file_extent()
1887 	if (args->free_path) {  in can_nocow_file_extent()
1891 		 * another path. So free the path to avoid unnecessary extra  in can_nocow_file_extent()
1899 	if (args->writeback_path && !is_freespace_inode &&  in can_nocow_file_extent()
1900 	    atomic_read(&root->snapshot_force_cow))  in can_nocow_file_extent()
1903 	args->file_extent.num_bytes = min(args->end + 1, extent_end) - args->start;  in can_nocow_file_extent()
1904 	args->file_extent.offset += args->start - key->offset;  in can_nocow_file_extent()
1905 	io_start = args->file_extent.disk_bytenr + args->file_extent.offset;  in can_nocow_file_extent()
1912 	csum_root = btrfs_csum_root(root->fs_info, io_start);  in can_nocow_file_extent()
1914 				      io_start + args->file_extent.num_bytes - 1,  in can_nocow_file_extent()
1922 	if (args->free_path && path)  in can_nocow_file_extent()
1934 	const u64 len = nocow_args->file_extent.num_bytes;  in nocow_one_range()
1935 	const u64 end = file_pos + len - 1;  in nocow_one_range()
1938 	btrfs_lock_extent(&inode->io_tree, file_pos, end, cached);  in nocow_one_range()
1943 		em = btrfs_create_io_em(inode, file_pos, &nocow_args->file_extent,  in nocow_one_range()
1952 	ordered = btrfs_alloc_ordered_extent(inode, file_pos, &nocow_args->file_extent,  in nocow_one_range()
1963 	if (btrfs_is_data_reloc_root(inode->root))  in nocow_one_range()
1987 	btrfs_err(inode->root->fs_info,  in nocow_one_range()
1989 		  __func__, btrfs_root_id(inode->root), btrfs_ino(inode),  in nocow_one_range()
2005 	struct btrfs_fs_info *fs_info = inode->root->fs_info;  in run_delalloc_nocow()
2006 	struct btrfs_root *root = inode->root;  in run_delalloc_nocow()
2008 	u64 cow_start = (u64)-1;  in run_delalloc_nocow()
2039 		ret = -ENOMEM;  in run_delalloc_nocow()
2065 		if (ret > 0 && path->slots[0] > 0 && check_prev) {  in run_delalloc_nocow()
2066 			leaf = path->nodes[0];  in run_delalloc_nocow()
2068 					      path->slots[0] - 1);  in run_delalloc_nocow()
2071 				path->slots[0]--;  in run_delalloc_nocow()
2076 		leaf = path->nodes[0];  in run_delalloc_nocow()
2077 		if (path->slots[0] >= btrfs_header_nritems(leaf)) {  in run_delalloc_nocow()
2083 			leaf = path->nodes[0];  in run_delalloc_nocow()
2086 		btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);  in run_delalloc_nocow()
2097 			path->slots[0]++;  in run_delalloc_nocow()
2111 			if (cow_start == (u64)-1)  in run_delalloc_nocow()
2121 		fi = btrfs_item_ptr(leaf, path->slots[0],  in run_delalloc_nocow()
2127 			ret = -EUCLEAN;  in run_delalloc_nocow()
2137 			path->slots[0]++;  in run_delalloc_nocow()
2161 			if (cow_start == (u64)-1)  in run_delalloc_nocow()
2166 			if (!path->nodes[0])  in run_delalloc_nocow()
2168 			path->slots[0]++;  in run_delalloc_nocow()
2173 		 * COW range from cow_start to found_key.offset - 1. As the key  in run_delalloc_nocow()
2177 		if (cow_start != (u64)-1) {  in run_delalloc_nocow()
2179 					      found_key.offset - 1);  in run_delalloc_nocow()
2181 				cow_end = found_key.offset - 1;  in run_delalloc_nocow()
2185 			cow_start = (u64)-1;  in run_delalloc_nocow()
2193 			nocow_end = cur_offset + nocow_args.file_extent.num_bytes - 1;  in run_delalloc_nocow()
2200 	if (cur_offset <= end && cow_start == (u64)-1)  in run_delalloc_nocow()
2203 	if (cow_start != (u64)-1) {  in run_delalloc_nocow()
2209 		cow_start = (u64)-1;  in run_delalloc_nocow()
2224 	if (cow_start == (u64)-1) {  in run_delalloc_nocow()
2228 		 *    |   OE cleanup  |       Untouched        |  in run_delalloc_nocow()
2235 		 *    |   OE cleanup  |   Skip     | Untouched |  in run_delalloc_nocow()
2241 		oe_cleanup_len = cur_offset - start;  in run_delalloc_nocow()
2246 		untouched_len = end + 1 - untouched_start;  in run_delalloc_nocow()
2247 	} else if (cow_start != (u64)-1 && cow_end == 0) {  in run_delalloc_nocow()
2251 		 *    | OE cleanup |        Untouched        |  in run_delalloc_nocow()
2254 		 * thus [cow_start, cur_offset) doesn't yet have any OE.  in run_delalloc_nocow()
2257 		oe_cleanup_len = cow_start - start;  in run_delalloc_nocow()
2259 		untouched_len = end + 1 - untouched_start;  in run_delalloc_nocow()
2264 		 *    | OE cleanup |   Skip     |  Untouched |  in run_delalloc_nocow()
2270 		ASSERT(cow_start != (u64)-1 && cow_end != 0);  in run_delalloc_nocow()
2272 		oe_cleanup_len = cow_start - start;  in run_delalloc_nocow()
2274 		untouched_len = end + 1 - untouched_start;  in run_delalloc_nocow()
2278 		const u64 oe_cleanup_end = oe_cleanup_start + oe_cleanup_len - 1;  in run_delalloc_nocow()
2289 		const u64 untouched_end = untouched_start + untouched_len - 1;  in run_delalloc_nocow()
2295 		btrfs_lock_extent(&inode->io_tree, untouched_start, untouched_end, &cached);  in run_delalloc_nocow()
2308 		  __func__, btrfs_root_id(inode->root), btrfs_ino(inode),  in run_delalloc_nocow()
2309 		  start, end + 1 - start, cur_offset, oe_cleanup_start, oe_cleanup_len,  in run_delalloc_nocow()
2316 	if (inode->flags & (BTRFS_INODE_NODATACOW | BTRFS_INODE_PREALLOC)) {  in should_nocow()
2317 		if (inode->defrag_bytes &&  in should_nocow()
2318 		    btrfs_test_range_bit_exists(&inode->io_tree, start, end, EXTENT_DEFRAG))  in should_nocow()
2332 	const bool zoned = btrfs_is_zoned(inode->root->fs_info);  in btrfs_run_delalloc_range()
2362 	struct btrfs_fs_info *fs_info = inode->root->fs_info;  in btrfs_split_delalloc_extent()
2365 	lockdep_assert_held(&inode->io_tree.lock);  in btrfs_split_delalloc_extent()
2368 	if (!(orig->state & EXTENT_DELALLOC))  in btrfs_split_delalloc_extent()
2371 	size = orig->end - orig->start + 1;  in btrfs_split_delalloc_extent()
2372 	if (size > fs_info->max_extent_size) {  in btrfs_split_delalloc_extent()
2380 		new_size = orig->end - split + 1;  in btrfs_split_delalloc_extent()
2382 		new_size = split - orig->start;  in btrfs_split_delalloc_extent()
2388 	spin_lock(&inode->lock);  in btrfs_split_delalloc_extent()
2390 	spin_unlock(&inode->lock);  in btrfs_split_delalloc_extent()
2401 	struct btrfs_fs_info *fs_info = inode->root->fs_info;  in btrfs_merge_delalloc_extent()
2405 	lockdep_assert_held(&inode->io_tree.lock);  in btrfs_merge_delalloc_extent()
2408 	if (!(other->state & EXTENT_DELALLOC))  in btrfs_merge_delalloc_extent()
2411 	if (new->start > other->start)  in btrfs_merge_delalloc_extent()
2412 		new_size = new->end - other->start + 1;  in btrfs_merge_delalloc_extent()
2414 		new_size = other->end - new->start + 1;  in btrfs_merge_delalloc_extent()
2417 	if (new_size <= fs_info->max_extent_size) {  in btrfs_merge_delalloc_extent()
2418 		spin_lock(&inode->lock);  in btrfs_merge_delalloc_extent()
2419 		btrfs_mod_outstanding_extents(inode, -1);  in btrfs_merge_delalloc_extent()
2420 		spin_unlock(&inode->lock);  in btrfs_merge_delalloc_extent()
2442 	old_size = other->end - other->start + 1;  in btrfs_merge_delalloc_extent()
2444 	old_size = new->end - new->start + 1;  in btrfs_merge_delalloc_extent()
2449 	spin_lock(&inode->lock);  in btrfs_merge_delalloc_extent()
2450 	btrfs_mod_outstanding_extents(inode, -1);  in btrfs_merge_delalloc_extent()
2451 	spin_unlock(&inode->lock);  in btrfs_merge_delalloc_extent()
2456 	struct btrfs_root *root = inode->root;  in btrfs_add_delalloc_inode()
2457 	struct btrfs_fs_info *fs_info = root->fs_info;  in btrfs_add_delalloc_inode()
2459 	spin_lock(&root->delalloc_lock);  in btrfs_add_delalloc_inode()
2460 	ASSERT(list_empty(&inode->delalloc_inodes));  in btrfs_add_delalloc_inode()
2461 	list_add_tail(&inode->delalloc_inodes, &root->delalloc_inodes);  in btrfs_add_delalloc_inode()
2462 	root->nr_delalloc_inodes++;  in btrfs_add_delalloc_inode()
2463 	if (root->nr_delalloc_inodes == 1) {  in btrfs_add_delalloc_inode()
2464 		spin_lock(&fs_info->delalloc_root_lock);  in btrfs_add_delalloc_inode()
2465 		ASSERT(list_empty(&root->delalloc_root));  in btrfs_add_delalloc_inode()
2466 		list_add_tail(&root->delalloc_root, &fs_info->delalloc_roots);  in btrfs_add_delalloc_inode()
2467 		spin_unlock(&fs_info->delalloc_root_lock);  in btrfs_add_delalloc_inode()
2469 	spin_unlock(&root->delalloc_lock);  in btrfs_add_delalloc_inode()
2474 	struct btrfs_root *root = inode->root;  in btrfs_del_delalloc_inode()
2475 	struct btrfs_fs_info *fs_info = root->fs_info;  in btrfs_del_delalloc_inode()
2477 	lockdep_assert_held(&root->delalloc_lock);  in btrfs_del_delalloc_inode()
2483 	 * still has ->delalloc_bytes > 0.  in btrfs_del_delalloc_inode()
2485 	if (!list_empty(&inode->delalloc_inodes)) {  in btrfs_del_delalloc_inode()
2486 		list_del_init(&inode->delalloc_inodes);  in btrfs_del_delalloc_inode()
2487 		root->nr_delalloc_inodes--;  in btrfs_del_delalloc_inode()
2488 		if (!root->nr_delalloc_inodes) {  in btrfs_del_delalloc_inode()
2489 			ASSERT(list_empty(&root->delalloc_inodes));  in btrfs_del_delalloc_inode()
2490 			spin_lock(&fs_info->delalloc_root_lock);  in btrfs_del_delalloc_inode()
2491 			ASSERT(!list_empty(&root->delalloc_root));  in btrfs_del_delalloc_inode()
2492 			list_del_init(&root->delalloc_root);  in btrfs_del_delalloc_inode()
2493 			spin_unlock(&fs_info->delalloc_root_lock);  in btrfs_del_delalloc_inode()
2505 	struct btrfs_fs_info *fs_info = inode->root->fs_info;  in btrfs_set_delalloc_extent()
2507 	lockdep_assert_held(&inode->io_tree.lock);  in btrfs_set_delalloc_extent()
2516 	if (!(state->state & EXTENT_DELALLOC) && (bits & EXTENT_DELALLOC)) {  in btrfs_set_delalloc_extent()
2517 		u64 len = state->end + 1 - state->start;  in btrfs_set_delalloc_extent()
2521 		spin_lock(&inode->lock);  in btrfs_set_delalloc_extent()
2523 		spin_unlock(&inode->lock);  in btrfs_set_delalloc_extent()
2529 		percpu_counter_add_batch(&fs_info->delalloc_bytes, len,  in btrfs_set_delalloc_extent()
2530 					 fs_info->delalloc_batch);  in btrfs_set_delalloc_extent()
2531 		spin_lock(&inode->lock);  in btrfs_set_delalloc_extent()
2532 		prev_delalloc_bytes = inode->delalloc_bytes;  in btrfs_set_delalloc_extent()
2533 		inode->delalloc_bytes += len;  in btrfs_set_delalloc_extent()
2535 			inode->defrag_bytes += len;  in btrfs_set_delalloc_extent()
2536 		spin_unlock(&inode->lock);  in btrfs_set_delalloc_extent()
2548 	if (!(state->state & EXTENT_DELALLOC_NEW) &&  in btrfs_set_delalloc_extent()
2550 		spin_lock(&inode->lock);  in btrfs_set_delalloc_extent()
2551 		inode->new_delalloc_bytes += state->end + 1 - state->start;  in btrfs_set_delalloc_extent()
2552 		spin_unlock(&inode->lock);  in btrfs_set_delalloc_extent()
2563 	struct btrfs_fs_info *fs_info = inode->root->fs_info;  in btrfs_clear_delalloc_extent()
2564 	u64 len = state->end + 1 - state->start;  in btrfs_clear_delalloc_extent()
2567 	lockdep_assert_held(&inode->io_tree.lock);  in btrfs_clear_delalloc_extent()
2569 	if ((state->state & EXTENT_DEFRAG) && (bits & EXTENT_DEFRAG)) {  in btrfs_clear_delalloc_extent()
2570 		spin_lock(&inode->lock);  in btrfs_clear_delalloc_extent()
2571 		inode->defrag_bytes -= len;  in btrfs_clear_delalloc_extent()
2572 		spin_unlock(&inode->lock);  in btrfs_clear_delalloc_extent()
2580 	if ((state->state & EXTENT_DELALLOC) && (bits & EXTENT_DELALLOC)) {  in btrfs_clear_delalloc_extent()
2581 		struct btrfs_root *root = inode->root;  in btrfs_clear_delalloc_extent()
2584 		spin_lock(&inode->lock);  in btrfs_clear_delalloc_extent()
2585 		btrfs_mod_outstanding_extents(inode, -num_extents);  in btrfs_clear_delalloc_extent()
2586 		spin_unlock(&inode->lock);  in btrfs_clear_delalloc_extent()
2594 		    root != fs_info->tree_root)  in btrfs_clear_delalloc_extent()
2603 		    !(state->state & EXTENT_NORESERVE) &&  in btrfs_clear_delalloc_extent()
2607 		percpu_counter_add_batch(&fs_info->delalloc_bytes, -len,  in btrfs_clear_delalloc_extent()
2608 					 fs_info->delalloc_batch);  in btrfs_clear_delalloc_extent()
2609 		spin_lock(&inode->lock);  in btrfs_clear_delalloc_extent()
2610 		inode->delalloc_bytes -= len;  in btrfs_clear_delalloc_extent()
2611 		new_delalloc_bytes = inode->delalloc_bytes;  in btrfs_clear_delalloc_extent()
2612 		spin_unlock(&inode->lock);  in btrfs_clear_delalloc_extent()
2621 			spin_lock(&root->delalloc_lock);  in btrfs_clear_delalloc_extent()
2623 			spin_unlock(&root->delalloc_lock);  in btrfs_clear_delalloc_extent()
2627 	if ((state->state & EXTENT_DELALLOC_NEW) &&  in btrfs_clear_delalloc_extent()
2629 		spin_lock(&inode->lock);  in btrfs_clear_delalloc_extent()
2630 		ASSERT(inode->new_delalloc_bytes >= len);  in btrfs_clear_delalloc_extent()
2631 		inode->new_delalloc_bytes -= len;  in btrfs_clear_delalloc_extent()
2633 			inode_add_bytes(&inode->vfs_inode, len);  in btrfs_clear_delalloc_extent()
2634 		spin_unlock(&inode->lock);  in btrfs_clear_delalloc_extent()
2650 		trans->adding_csums = true;  in add_pending_csums()
2652 			csum_root = btrfs_csum_root(trans->fs_info,  in add_pending_csums()
2653 						    sum->logical);  in add_pending_csums()
2655 		trans->adding_csums = false;  in add_pending_csums()
2668 	const u64 end = start + len - 1;  in btrfs_find_new_delalloc_bytes()
2671 		const u64 search_len = end - search_start + 1;  in btrfs_find_new_delalloc_bytes()
2680 		if (em->disk_bytenr != EXTENT_MAP_HOLE)  in btrfs_find_new_delalloc_bytes()
2683 		em_len = em->len;  in btrfs_find_new_delalloc_bytes()
2684 		if (em->start < search_start)  in btrfs_find_new_delalloc_bytes()
2685 			em_len -= search_start - em->start;  in btrfs_find_new_delalloc_bytes()
2689 		ret = btrfs_set_extent_bit(&inode->io_tree, search_start,  in btrfs_find_new_delalloc_bytes()
2690 					   search_start + em_len - 1,  in btrfs_find_new_delalloc_bytes()
2707 	if (start >= i_size_read(&inode->vfs_inode) &&  in btrfs_set_extent_delalloc()
2708 	    !(inode->flags & BTRFS_INODE_PREALLOC)) {  in btrfs_set_extent_delalloc()
2718 						    end + 1 - start,  in btrfs_set_extent_delalloc()
2724 	return btrfs_set_extent_bit(&inode->io_tree, start, end,  in btrfs_set_extent_delalloc()
2742 	struct folio *folio = fixup->folio;  in btrfs_writepage_fixup_worker()
2743 	struct btrfs_inode *inode = fixup->inode;  in btrfs_writepage_fixup_worker()
2744 	struct btrfs_fs_info *fs_info = inode->root->fs_info;  in btrfs_writepage_fixup_worker()
2746 	u64 page_end = folio_end(folio) - 1;  in btrfs_writepage_fixup_worker()
2761 	 * folio->mapping may go NULL, but it shouldn't be moved to a different  in btrfs_writepage_fixup_worker()
2764 	if (!folio->mapping || !folio_test_dirty(folio) ||  in btrfs_writepage_fixup_worker()
2800 	btrfs_lock_extent(&inode->io_tree, page_start, page_end, &cached_state);  in btrfs_writepage_fixup_worker()
2808 		btrfs_unlock_extent(&inode->io_tree, page_start, page_end,  in btrfs_writepage_fixup_worker()
2835 	btrfs_unlock_extent(&inode->io_tree, page_start, page_end, &cached_state);  in btrfs_writepage_fixup_worker()
2842 		mapping_set_error(folio->mapping, ret);  in btrfs_writepage_fixup_worker()
2873 	struct inode *inode = folio->mapping->host;  in btrfs_writepage_cow_fixup()
2884 	 * We should not hit such out-of-band dirty folios anymore.  in btrfs_writepage_cow_fixup()
2890 			     btrfs_root_id(BTRFS_I(inode)->root),  in btrfs_writepage_cow_fixup()
2893 		return -EUCLEAN;  in btrfs_writepage_cow_fixup()
2905 		return -EAGAIN;  in btrfs_writepage_cow_fixup()
2909 		return -EAGAIN;  in btrfs_writepage_cow_fixup()
2915 	 * folio->mapping outside of the folio lock.  in btrfs_writepage_cow_fixup()
2920 	btrfs_init_work(&fixup->work, btrfs_writepage_fixup_worker, NULL);  in btrfs_writepage_cow_fixup()
2921 	fixup->folio = folio;  in btrfs_writepage_cow_fixup()
2922 	fixup->inode = BTRFS_I(inode);  in btrfs_writepage_cow_fixup()
2923 	btrfs_queue_work(fs_info->fixup_workers, &fixup->work);  in btrfs_writepage_cow_fixup()
2925 	return -EAGAIN;  in btrfs_writepage_cow_fixup()
2934 	struct btrfs_root *root = inode->root;  in insert_reserved_file_extent()
2935 	const u64 sectorsize = root->fs_info->sectorsize;  in insert_reserved_file_extent()
2949 		return -ENOMEM;  in insert_reserved_file_extent()
2979 	leaf = path->nodes[0];  in insert_reserved_file_extent()
2980 	btrfs_set_stack_file_extent_generation(stack_fi, trans->transid);  in insert_reserved_file_extent()
2982 			btrfs_item_ptr_offset(leaf, path->slots[0]),  in insert_reserved_file_extent()
2997 		inline_size = drop_args.bytes_found - inline_size;  in insert_reserved_file_extent()
2999 		drop_args.bytes_found -= inline_size;  in insert_reserved_file_extent()
3000 		num_bytes -= sectorsize;  in insert_reserved_file_extent()
3015 					       file_pos - offset,  in insert_reserved_file_extent()
3029 	spin_lock(&cache->lock);  in btrfs_release_delalloc_bytes()
3030 	cache->delalloc_bytes -= len;  in btrfs_release_delalloc_bytes()
3031 	spin_unlock(&cache->lock);  in btrfs_release_delalloc_bytes()
3037 					     struct btrfs_ordered_extent *oe)  in insert_ordered_extent_file_extent()  argument
3041 	u64 num_bytes = oe->num_bytes;  in insert_ordered_extent_file_extent()
3042 	u64 ram_bytes = oe->ram_bytes;  in insert_ordered_extent_file_extent()
3046 	btrfs_set_stack_file_extent_disk_bytenr(&stack_fi, oe->disk_bytenr);  in insert_ordered_extent_file_extent()
3048 						   oe->disk_num_bytes);  in insert_ordered_extent_file_extent()
3049 	btrfs_set_stack_file_extent_offset(&stack_fi, oe->offset);  in insert_ordered_extent_file_extent()
3050 	if (test_bit(BTRFS_ORDERED_TRUNCATED, &oe->flags))  in insert_ordered_extent_file_extent()
3051 		num_bytes = oe->truncated_len;  in insert_ordered_extent_file_extent()
3054 	btrfs_set_stack_file_extent_compression(&stack_fi, oe->compress_type);  in insert_ordered_extent_file_extent()
3063 	update_inode_bytes = test_bit(BTRFS_ORDERED_DIRECT, &oe->flags) ||  in insert_ordered_extent_file_extent()
3064 			     test_bit(BTRFS_ORDERED_ENCODED, &oe->flags) ||  in insert_ordered_extent_file_extent()
3065 			     test_bit(BTRFS_ORDERED_TRUNCATED, &oe->flags);  in insert_ordered_extent_file_extent()
3067 	return insert_reserved_file_extent(trans, oe->inode,  in insert_ordered_extent_file_extent()
3068 					   oe->file_offset, &stack_fi,  in insert_ordered_extent_file_extent()
3069 					   update_inode_bytes, oe->qgroup_rsv);  in insert_ordered_extent_file_extent()
3079 	struct btrfs_inode *inode = ordered_extent->inode;  in btrfs_finish_one_ordered()
3080 	struct btrfs_root *root = inode->root;  in btrfs_finish_one_ordered()
3081 	struct btrfs_fs_info *fs_info = root->fs_info;  in btrfs_finish_one_ordered()
3083 	struct extent_io_tree *io_tree = &inode->io_tree;  in btrfs_finish_one_ordered()
3088 	u64 logical_len = ordered_extent->num_bytes;  in btrfs_finish_one_ordered()
3094 	start = ordered_extent->file_offset;  in btrfs_finish_one_ordered()
3095 	end = start + ordered_extent->num_bytes - 1;  in btrfs_finish_one_ordered()
3097 	if (!test_bit(BTRFS_ORDERED_NOCOW, &ordered_extent->flags) &&  in btrfs_finish_one_ordered()
3098 	    !test_bit(BTRFS_ORDERED_PREALLOC, &ordered_extent->flags) &&  in btrfs_finish_one_ordered()
3099 	    !test_bit(BTRFS_ORDERED_DIRECT, &ordered_extent->flags) &&  in btrfs_finish_one_ordered()
3100 	    !test_bit(BTRFS_ORDERED_ENCODED, &ordered_extent->flags))  in btrfs_finish_one_ordered()
3107 	if (unlikely(test_bit(BTRFS_ORDERED_IOERR, &ordered_extent->flags))) {  in btrfs_finish_one_ordered()
3108 		ret = -EIO;  in btrfs_finish_one_ordered()
3112 	ret = btrfs_zone_finish_endio(fs_info, ordered_extent->disk_bytenr,  in btrfs_finish_one_ordered()
3113 				      ordered_extent->disk_num_bytes);  in btrfs_finish_one_ordered()
3117 	if (test_bit(BTRFS_ORDERED_TRUNCATED, &ordered_extent->flags)) {  in btrfs_finish_one_ordered()
3119 		logical_len = ordered_extent->truncated_len;  in btrfs_finish_one_ordered()
3133 	if (!test_bit(BTRFS_ORDERED_NOCOW, &ordered_extent->flags)) {  in btrfs_finish_one_ordered()
3150 	trans->block_rsv = &inode->block_rsv;  in btrfs_finish_one_ordered()
3158 	if (test_bit(BTRFS_ORDERED_NOCOW, &ordered_extent->flags)) {  in btrfs_finish_one_ordered()
3160 		ASSERT(list_empty(&ordered_extent->list));  in btrfs_finish_one_ordered()
3161 		if (unlikely(!list_empty(&ordered_extent->list))) {  in btrfs_finish_one_ordered()
3162 			ret = -EINVAL;  in btrfs_finish_one_ordered()
3170 			/* -ENOMEM or corruption */  in btrfs_finish_one_ordered()
3176 	if (test_bit(BTRFS_ORDERED_COMPRESSED, &ordered_extent->flags))  in btrfs_finish_one_ordered()
3177 		compress_type = ordered_extent->compress_type;  in btrfs_finish_one_ordered()
3178 	if (test_bit(BTRFS_ORDERED_PREALLOC, &ordered_extent->flags)) {  in btrfs_finish_one_ordered()
3181 						ordered_extent->file_offset,  in btrfs_finish_one_ordered()
3182 						ordered_extent->file_offset +  in btrfs_finish_one_ordered()
3184 		btrfs_zoned_release_data_reloc_bg(fs_info, ordered_extent->disk_bytenr,  in btrfs_finish_one_ordered()
3185 						  ordered_extent->disk_num_bytes);  in btrfs_finish_one_ordered()
3187 		BUG_ON(root == fs_info->tree_root);  in btrfs_finish_one_ordered()
3192 						ordered_extent->disk_bytenr,  in btrfs_finish_one_ordered()
3193 						ordered_extent->disk_num_bytes);  in btrfs_finish_one_ordered()
3201 	ret = btrfs_unpin_extent_cache(inode, ordered_extent->file_offset,  in btrfs_finish_one_ordered()
3202 				       ordered_extent->num_bytes, trans->transid);  in btrfs_finish_one_ordered()
3208 	ret = add_pending_csums(trans, &ordered_extent->list);  in btrfs_finish_one_ordered()
3220 	    !test_bit(BTRFS_ORDERED_TRUNCATED, &ordered_extent->flags))  in btrfs_finish_one_ordered()
3221 		btrfs_clear_extent_bit(&inode->io_tree, start, end,  in btrfs_finish_one_ordered()
3227 	if (unlikely(ret)) { /* -ENOMEM or corruption */  in btrfs_finish_one_ordered()
3232 	btrfs_clear_extent_bit(&inode->io_tree, start, end, clear_bits,  in btrfs_finish_one_ordered()
3257 		 * writepage where we do ASSERT(em->block_start !=  in btrfs_finish_one_ordered()
3286 		    !test_bit(BTRFS_ORDERED_NOCOW, &ordered_extent->flags) &&  in btrfs_finish_one_ordered()
3287 		    !test_bit(BTRFS_ORDERED_PREALLOC, &ordered_extent->flags)) {  in btrfs_finish_one_ordered()
3294 						ordered_extent->disk_bytenr,  in btrfs_finish_one_ordered()
3295 						ordered_extent->disk_num_bytes,  in btrfs_finish_one_ordered()
3298 					ordered_extent->disk_bytenr,  in btrfs_finish_one_ordered()
3299 					ordered_extent->disk_num_bytes, true);  in btrfs_finish_one_ordered()
3304 			btrfs_qgroup_free_refroot(fs_info, btrfs_root_id(inode->root),  in btrfs_finish_one_ordered()
3305 						  ordered_extent->qgroup_rsv,  in btrfs_finish_one_ordered()
3326 	if (btrfs_is_zoned(ordered->inode->root->fs_info) &&  in btrfs_finish_ordered_io()
3327 	    !test_bit(BTRFS_ORDERED_IOERR, &ordered->flags) &&  in btrfs_finish_ordered_io()
3328 	    list_empty(&ordered->bioc_list))  in btrfs_finish_ordered_io()
3337 	const u32 blocksize = fs_info->sectorsize;  in btrfs_calculate_block_csum()
3338 	SHASH_DESC_ON_STACK(shash, fs_info->csum_shash);  in btrfs_calculate_block_csum()
3340 	shash->tfm = fs_info->csum_shash;  in btrfs_calculate_block_csum()
3350 			size_t len = min(paddr + blocksize - cur,  in btrfs_calculate_block_csum()
3351 					 PAGE_SIZE - offset_in_page(cur));  in btrfs_calculate_block_csum()
3364  * Verify the checksum for a single sector without any extra action that depend
3373 	if (unlikely(memcmp(csum, csum_expected, fs_info->csum_size) != 0))  in btrfs_check_block_csum()
3374 		return -EIO;  in btrfs_check_block_csum()
3394 	struct btrfs_inode *inode = bbio->inode;  in btrfs_data_csum_ok()
3395 	struct btrfs_fs_info *fs_info = inode->root->fs_info;  in btrfs_data_csum_ok()
3396 	const u32 blocksize = fs_info->sectorsize;  in btrfs_data_csum_ok()
3398 	u64 file_offset = bbio->file_offset + bio_offset;  in btrfs_data_csum_ok()
3399 	u64 end = file_offset + blocksize - 1;  in btrfs_data_csum_ok()
3403 	if (!bbio->csum)  in btrfs_data_csum_ok()
3406 	if (btrfs_is_data_reloc_root(inode->root) &&  in btrfs_data_csum_ok()
3407 	    btrfs_test_range_bit(&inode->io_tree, file_offset, end, EXTENT_NODATASUM,  in btrfs_data_csum_ok()
3410 		btrfs_clear_extent_bit(&inode->io_tree, file_offset, end,  in btrfs_data_csum_ok()
3415 	csum_expected = bbio->csum + (bio_offset >> fs_info->sectorsize_bits) *  in btrfs_data_csum_ok()
3416 				fs_info->csum_size;  in btrfs_data_csum_ok()
3423 				    bbio->mirror_num);  in btrfs_data_csum_ok()
3444 	struct btrfs_fs_info *fs_info = inode->root->fs_info;  in btrfs_add_delayed_iput()
3447 	if (atomic_add_unless(&inode->vfs_inode.i_count, -1, 1))  in btrfs_add_delayed_iput()
3450 	WARN_ON_ONCE(test_bit(BTRFS_FS_STATE_NO_DELAYED_IPUT, &fs_info->fs_state));  in btrfs_add_delayed_iput()
3451 	atomic_inc(&fs_info->nr_delayed_iputs);  in btrfs_add_delayed_iput()
3454 	 * context (see bio.c and btrfs_put_ordered_extent()) or a non-irq  in btrfs_add_delayed_iput()
3457 	spin_lock_irqsave(&fs_info->delayed_iput_lock, flags);  in btrfs_add_delayed_iput()
3458 	ASSERT(list_empty(&inode->delayed_iput));  in btrfs_add_delayed_iput()
3459 	list_add_tail(&inode->delayed_iput, &fs_info->delayed_iputs);  in btrfs_add_delayed_iput()
3460 	spin_unlock_irqrestore(&fs_info->delayed_iput_lock, flags);  in btrfs_add_delayed_iput()
3461 	if (!test_bit(BTRFS_FS_CLEANER_RUNNING, &fs_info->flags))  in btrfs_add_delayed_iput()
3462 		wake_up_process(fs_info->cleaner_kthread);  in btrfs_add_delayed_iput()
3468 	list_del_init(&inode->delayed_iput);  in run_delayed_iput_locked()
3469 	spin_unlock_irq(&fs_info->delayed_iput_lock);  in run_delayed_iput_locked()
3470 	iput(&inode->vfs_inode);  in run_delayed_iput_locked()
3471 	if (atomic_dec_and_test(&fs_info->nr_delayed_iputs))  in run_delayed_iput_locked()
3472 		wake_up(&fs_info->delayed_iputs_wait);  in run_delayed_iput_locked()
3473 	spin_lock_irq(&fs_info->delayed_iput_lock);  in run_delayed_iput_locked()
3479 	if (!list_empty(&inode->delayed_iput)) {  in btrfs_run_delayed_iput()
3480 		spin_lock_irq(&fs_info->delayed_iput_lock);  in btrfs_run_delayed_iput()
3481 		if (!list_empty(&inode->delayed_iput))  in btrfs_run_delayed_iput()
3483 		spin_unlock_irq(&fs_info->delayed_iput_lock);  in btrfs_run_delayed_iput()
3492 	 * fs_info->delayed_iput_lock. So we need to disable irqs here to  in btrfs_run_delayed_iputs()
3495 	spin_lock_irq(&fs_info->delayed_iput_lock);  in btrfs_run_delayed_iputs()
3496 	while (!list_empty(&fs_info->delayed_iputs)) {  in btrfs_run_delayed_iputs()
3499 		inode = list_first_entry(&fs_info->delayed_iputs,  in btrfs_run_delayed_iputs()
3503 			spin_unlock_irq(&fs_info->delayed_iput_lock);  in btrfs_run_delayed_iputs()
3505 			spin_lock_irq(&fs_info->delayed_iput_lock);  in btrfs_run_delayed_iputs()
3508 	spin_unlock_irq(&fs_info->delayed_iput_lock);  in btrfs_run_delayed_iputs()
3525 	int ret = wait_event_killable(fs_info->delayed_iputs_wait,  in btrfs_wait_on_delayed_iputs()
3526 			atomic_read(&fs_info->nr_delayed_iputs) == 0);  in btrfs_wait_on_delayed_iputs()
3528 		return -EINTR;  in btrfs_wait_on_delayed_iputs()
3541 	ret = btrfs_insert_orphan_item(trans, inode->root, btrfs_ino(inode));  in btrfs_orphan_add()
3542 	if (unlikely(ret && ret != -EEXIST)) {  in btrfs_orphan_add()
3557 	return btrfs_del_orphan_item(trans, inode->root, btrfs_ino(inode));  in btrfs_orphan_del()
3566 	struct btrfs_fs_info *fs_info = root->fs_info;  in btrfs_orphan_cleanup()
3574 	if (test_and_set_bit(BTRFS_ROOT_ORPHAN_CLEANUP, &root->state))  in btrfs_orphan_cleanup()
3579 		ret = -ENOMEM;  in btrfs_orphan_cleanup()
3582 	path->reada = READA_BACK;  in btrfs_orphan_cleanup()
3586 	key.offset = (u64)-1;  in btrfs_orphan_cleanup()
3602 			if (path->slots[0] == 0)  in btrfs_orphan_cleanup()
3604 			path->slots[0]--;  in btrfs_orphan_cleanup()
3608 		leaf = path->nodes[0];  in btrfs_orphan_cleanup()
3609 		btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);  in btrfs_orphan_cleanup()
3631 			 * due to -ENOSPC for example, so try to grab the error  in btrfs_orphan_cleanup()
3636 			ret = BTRFS_FS_ERROR(fs_info) ?: -EINVAL;  in btrfs_orphan_cleanup()
3649 			if (ret != -ENOENT)  in btrfs_orphan_cleanup()
3653 		if (!inode && root == fs_info->tree_root) {  in btrfs_orphan_cleanup()
3668 			 * fs_info->fs_roots_radix. So here we can find if an  in btrfs_orphan_cleanup()
3673 			spin_lock(&fs_info->fs_roots_radix_lock);  in btrfs_orphan_cleanup()
3674 			dead_root = radix_tree_lookup(&fs_info->fs_roots_radix,  in btrfs_orphan_cleanup()
3676 			if (dead_root && btrfs_root_refs(&dead_root->root_item) == 0)  in btrfs_orphan_cleanup()
3678 			spin_unlock(&fs_info->fs_roots_radix_lock);  in btrfs_orphan_cleanup()
3682 				key.offset = found_key.objectid - 1;  in btrfs_orphan_cleanup()
3705 		 * only if this filesystem was last used on a pre-v3.12 kernel  in btrfs_orphan_cleanup()
3714 		if (!inode || inode->vfs_inode.i_nlink) {  in btrfs_orphan_cleanup()
3717 				iput(&inode->vfs_inode);  in btrfs_orphan_cleanup()
3740 		iput(&inode->vfs_inode);  in btrfs_orphan_cleanup()
3745 	if (test_bit(BTRFS_ROOT_ORPHAN_ITEM_INSERTED, &root->state)) {  in btrfs_orphan_cleanup()
3788 	*first_xattr_slot = -1;  in acls_after_inode_item()
3798 			if (*first_xattr_slot == -1)  in acls_after_inode_item()
3817 		 * - inode  in acls_after_inode_item()
3818 		 * - inode backrefs  in acls_after_inode_item()
3819 		 * - xattrs  in acls_after_inode_item()
3820 		 * - extents,  in acls_after_inode_item()
3833 	if (*first_xattr_slot == -1)  in acls_after_inode_item()
3840 	struct btrfs_fs_info *fs_info = inode->root->fs_info;  in btrfs_init_file_extent_tree()
3842 	if (WARN_ON_ONCE(inode->file_extent_tree))  in btrfs_init_file_extent_tree()
3846 	if (!S_ISREG(inode->vfs_inode.i_mode))  in btrfs_init_file_extent_tree()
3851 	inode->file_extent_tree = kmalloc(sizeof(struct extent_io_tree), GFP_KERNEL);  in btrfs_init_file_extent_tree()
3852 	if (!inode->file_extent_tree)  in btrfs_init_file_extent_tree()
3853 		return -ENOMEM;  in btrfs_init_file_extent_tree()
3855 	btrfs_extent_io_tree_init(fs_info, inode->file_extent_tree,  in btrfs_init_file_extent_tree()
3858 	lockdep_set_class(&inode->file_extent_tree->lock, &file_extent_tree_class);  in btrfs_init_file_extent_tree()
3865 	struct btrfs_root *root = inode->root;  in btrfs_add_inode_to_root()
3870 	if (inode_unhashed(&inode->vfs_inode))  in btrfs_add_inode_to_root()
3874 		ret = xa_reserve(&root->inodes, ino, GFP_NOFS);  in btrfs_add_inode_to_root()
3879 	existing = xa_store(&root->inodes, ino, inode, GFP_ATOMIC);  in btrfs_add_inode_to_root()
3883 		ASSERT(ret != -EINVAL);  in btrfs_add_inode_to_root()
3884 		ASSERT(ret != -ENOMEM);  in btrfs_add_inode_to_root()
3887 		WARN_ON(!(existing->vfs_inode.i_state & (I_WILL_FREE | I_FREEING)));  in btrfs_add_inode_to_root()
3894  * Read a locked inode from the btree into the in-memory inode and add it to
3901 	struct btrfs_root *root = inode->root;  in btrfs_read_locked_inode()
3902 	struct btrfs_fs_info *fs_info = root->fs_info;  in btrfs_read_locked_inode()
3905 	struct inode *vfs_inode = &inode->vfs_inode;  in btrfs_read_locked_inode()
3929 			ret = -ENOENT;  in btrfs_read_locked_inode()
3933 	leaf = path->nodes[0];  in btrfs_read_locked_inode()
3938 	inode_item = btrfs_item_ptr(leaf, path->slots[0],  in btrfs_read_locked_inode()
3940 	vfs_inode->i_mode = btrfs_inode_mode(leaf, inode_item);  in btrfs_read_locked_inode()
3946 	inode_set_atime(vfs_inode, btrfs_timespec_sec(leaf, &inode_item->atime),  in btrfs_read_locked_inode()
3947 			btrfs_timespec_nsec(leaf, &inode_item->atime));  in btrfs_read_locked_inode()
3949 	inode_set_mtime(vfs_inode, btrfs_timespec_sec(leaf, &inode_item->mtime),  in btrfs_read_locked_inode()
3950 			btrfs_timespec_nsec(leaf, &inode_item->mtime));  in btrfs_read_locked_inode()
3952 	inode_set_ctime(vfs_inode, btrfs_timespec_sec(leaf, &inode_item->ctime),  in btrfs_read_locked_inode()
3953 			btrfs_timespec_nsec(leaf, &inode_item->ctime));  in btrfs_read_locked_inode()
3955 	inode->i_otime_sec = btrfs_timespec_sec(leaf, &inode_item->otime);  in btrfs_read_locked_inode()
3956 	inode->i_otime_nsec = btrfs_timespec_nsec(leaf, &inode_item->otime);  in btrfs_read_locked_inode()
3959 	inode->generation = btrfs_inode_generation(leaf, inode_item);  in btrfs_read_locked_inode()
3960 	inode->last_trans = btrfs_inode_transid(leaf, inode_item);  in btrfs_read_locked_inode()
3963 	vfs_inode->i_generation = inode->generation;  in btrfs_read_locked_inode()
3964 	vfs_inode->i_rdev = 0;  in btrfs_read_locked_inode()
3967 	if (S_ISDIR(vfs_inode->i_mode))  in btrfs_read_locked_inode()
3968 		inode->index_cnt = (u64)-1;  in btrfs_read_locked_inode()
3971 				&inode->flags, &inode->ro_flags);  in btrfs_read_locked_inode()
3980 			round_up(i_size_read(vfs_inode), fs_info->sectorsize));  in btrfs_read_locked_inode()
3983 	 * and then re-read we need to do a full sync since we don't have any  in btrfs_read_locked_inode()
3987 	 * This is required for both inode re-read from disk and delayed inode  in btrfs_read_locked_inode()
3990 	if (inode->last_trans == btrfs_get_fs_generation(fs_info))  in btrfs_read_locked_inode()
3991 		set_bit(BTRFS_INODE_NEEDS_FULL_SYNC, &inode->runtime_flags);  in btrfs_read_locked_inode()
4006 	 * xfs_io -c fsync mydir/foo  in btrfs_read_locked_inode()
4020 	inode->last_unlink_trans = inode->last_trans;  in btrfs_read_locked_inode()
4028 	inode->last_reflink_trans = inode->last_trans;  in btrfs_read_locked_inode()
4030 	path->slots[0]++;  in btrfs_read_locked_inode()
4031 	if (vfs_inode->i_nlink != 1 ||  in btrfs_read_locked_inode()
4032 	    path->slots[0] >= btrfs_header_nritems(leaf))  in btrfs_read_locked_inode()
4035 	btrfs_item_key_to_cpu(leaf, &location, path->slots[0]);  in btrfs_read_locked_inode()
4039 	ptr = btrfs_item_ptr_offset(leaf, path->slots[0]);  in btrfs_read_locked_inode()
4044 		inode->dir_index = btrfs_inode_ref_index(leaf, ref);  in btrfs_read_locked_inode()
4049 		inode->dir_index = btrfs_inode_extref_index(leaf, extref);  in btrfs_read_locked_inode()
4056 	maybe_acls = acls_after_inode_item(leaf, path->slots[0],  in btrfs_read_locked_inode()
4058 	if (first_xattr_slot != -1) {  in btrfs_read_locked_inode()
4059 		path->slots[0] = first_xattr_slot;  in btrfs_read_locked_inode()
4070 	switch (vfs_inode->i_mode & S_IFMT) {  in btrfs_read_locked_inode()
4072 		vfs_inode->i_mapping->a_ops = &btrfs_aops;  in btrfs_read_locked_inode()
4073 		vfs_inode->i_fop = &btrfs_file_operations;  in btrfs_read_locked_inode()
4074 		vfs_inode->i_op = &btrfs_file_inode_operations;  in btrfs_read_locked_inode()
4077 		vfs_inode->i_fop = &btrfs_dir_file_operations;  in btrfs_read_locked_inode()
4078 		vfs_inode->i_op = &btrfs_dir_inode_operations;  in btrfs_read_locked_inode()
4081 		vfs_inode->i_op = &btrfs_symlink_inode_operations;  in btrfs_read_locked_inode()
4083 		vfs_inode->i_mapping->a_ops = &btrfs_aops;  in btrfs_read_locked_inode()
4086 		vfs_inode->i_op = &btrfs_special_inode_operations;  in btrfs_read_locked_inode()
4087 		init_special_inode(vfs_inode, vfs_inode->i_mode, rdev);  in btrfs_read_locked_inode()
4115 	btrfs_set_inode_size(leaf, item, BTRFS_I(inode)->disk_i_size);  in fill_inode_item()
4116 	btrfs_set_inode_mode(leaf, item, inode->i_mode);  in fill_inode_item()
4117 	btrfs_set_inode_nlink(leaf, item, inode->i_nlink);  in fill_inode_item()
4119 	btrfs_set_timespec_sec(leaf, &item->atime, inode_get_atime_sec(inode));  in fill_inode_item()
4120 	btrfs_set_timespec_nsec(leaf, &item->atime, inode_get_atime_nsec(inode));  in fill_inode_item()
4122 	btrfs_set_timespec_sec(leaf, &item->mtime, inode_get_mtime_sec(inode));  in fill_inode_item()
4123 	btrfs_set_timespec_nsec(leaf, &item->mtime, inode_get_mtime_nsec(inode));  in fill_inode_item()
4125 	btrfs_set_timespec_sec(leaf, &item->ctime, inode_get_ctime_sec(inode));  in fill_inode_item()
4126 	btrfs_set_timespec_nsec(leaf, &item->ctime, inode_get_ctime_nsec(inode));  in fill_inode_item()
4128 	btrfs_set_timespec_sec(leaf, &item->otime, BTRFS_I(inode)->i_otime_sec);  in fill_inode_item()
4129 	btrfs_set_timespec_nsec(leaf, &item->otime, BTRFS_I(inode)->i_otime_nsec);  in fill_inode_item()
4132 	btrfs_set_inode_generation(leaf, item, BTRFS_I(inode)->generation);  in fill_inode_item()
4134 	btrfs_set_inode_transid(leaf, item, trans->transid);  in fill_inode_item()
4135 	btrfs_set_inode_rdev(leaf, item, inode->i_rdev);  in fill_inode_item()
4136 	flags = btrfs_inode_combine_flags(BTRFS_I(inode)->flags,  in fill_inode_item()
4137 					  BTRFS_I(inode)->ro_flags);  in fill_inode_item()
4143  * copy everything in the in-memory inode into the btree.
4156 		return -ENOMEM;  in btrfs_update_inode_item()
4159 	ret = btrfs_lookup_inode(trans, inode->root, path, &key, 1);  in btrfs_update_inode_item()
4162 			ret = -ENOENT;  in btrfs_update_inode_item()
4166 	leaf = path->nodes[0];  in btrfs_update_inode_item()
4167 	inode_item = btrfs_item_ptr(leaf, path->slots[0],  in btrfs_update_inode_item()
4170 	fill_inode_item(trans, leaf, inode_item, &inode->vfs_inode);  in btrfs_update_inode_item()
4176  * copy everything in the in-memory inode into the btree.
4181 	struct btrfs_root *root = inode->root;  in btrfs_update_inode()
4182 	struct btrfs_fs_info *fs_info = root->fs_info;  in btrfs_update_inode()
4190 	 * without delay  in btrfs_update_inode()
4194 	    && !test_bit(BTRFS_FS_LOG_RECOVERING, &fs_info->flags)) {  in btrfs_update_inode()
4212 	if (ret == -ENOSPC)  in btrfs_update_inode_fallback()
4227 	if (test_bit(BTRFS_FS_LOG_RECOVERING, &dir->root->fs_info->flags))  in update_time_after_link_or_unlink()
4230 	now = inode_set_ctime_current(&dir->vfs_inode);  in update_time_after_link_or_unlink()
4231 	inode_set_mtime_to_ts(&dir->vfs_inode, now);  in update_time_after_link_or_unlink()
4245 	struct btrfs_root *root = dir->root;  in __btrfs_unlink_inode()
4246 	struct btrfs_fs_info *fs_info = root->fs_info;  in __btrfs_unlink_inode()
4256 		return -ENOMEM;  in __btrfs_unlink_inode()
4258 	di = btrfs_lookup_dir_item(trans, root, path, dir_ino, name, -1);  in __btrfs_unlink_inode()
4261 		return di ? PTR_ERR(di) : -ENOENT;  in __btrfs_unlink_inode()
4279 	 * that we delay to delete it, and just do this deletion when  in __btrfs_unlink_inode()
4282 	if (inode->dir_index) {  in __btrfs_unlink_inode()
4285 			index = inode->dir_index;  in __btrfs_unlink_inode()
4294 			   name->len, name->name, btrfs_root_id(root), ino, dir_ino);  in __btrfs_unlink_inode()
4300 		rename_ctx->index = index;  in __btrfs_unlink_inode()
4311 	 * Besides that, doing it here would only cause extra unnecessary btree  in __btrfs_unlink_inode()
4321 	 * being run in btrfs-cleaner context.  If we have enough of these built  in __btrfs_unlink_inode()
4322 	 * up we can end up burning a lot of time in btrfs-cleaner without any  in __btrfs_unlink_inode()
4330 	btrfs_i_size_write(dir, dir->vfs_inode.i_size - name->len * 2);  in __btrfs_unlink_inode()
4331 	inode_inc_iversion(&inode->vfs_inode);  in __btrfs_unlink_inode()
4332 	inode_set_ctime_current(&inode->vfs_inode);  in __btrfs_unlink_inode()
4333 	inode_inc_iversion(&dir->vfs_inode);  in __btrfs_unlink_inode()
4347 		drop_nlink(&inode->vfs_inode);  in btrfs_unlink_inode()
4363 	struct btrfs_root *root = dir->root;  in __unlink_start_trans()
4376 	ret = fscrypt_setup_filename(dir, &dentry->d_name, 1, &fname);  in btrfs_unlink()
4380 	/* This needs to handle no-key deletions later on */  in btrfs_unlink()
4396 	if (inode->i_nlink == 0) {  in btrfs_unlink()
4404 	btrfs_btree_balance_dirty(BTRFS_I(dir)->root->fs_info);  in btrfs_unlink()
4413 	struct btrfs_root *root = dir->root;  in btrfs_unlink_subvol()
4425 	ret = fscrypt_setup_filename(&dir->vfs_inode, &dentry->d_name, 1, &fname);  in btrfs_unlink_subvol()
4429 	/* This needs to handle no-key deletions later on */  in btrfs_unlink_subvol()
4432 		objectid = btrfs_root_id(inode->root);  in btrfs_unlink_subvol()
4434 		objectid = inode->ref_root_id;  in btrfs_unlink_subvol()
4438 		return -EINVAL;  in btrfs_unlink_subvol()
4443 		ret = -ENOMEM;  in btrfs_unlink_subvol()
4448 				   &fname.disk_name, -1);  in btrfs_unlink_subvol()
4450 		ret = di ? PTR_ERR(di) : -ENOENT;  in btrfs_unlink_subvol()
4454 	leaf = path->nodes[0];  in btrfs_unlink_subvol()
4468 	 * depending on btrfs_del_root_ref to return -ENOENT here is incorrect.  in btrfs_unlink_subvol()
4481 		leaf = path->nodes[0];  in btrfs_unlink_subvol()
4482 		btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);  in btrfs_unlink_subvol()
4501 	btrfs_i_size_write(dir, dir->vfs_inode.i_size - fname.disk_name.len * 2);  in btrfs_unlink_subvol()
4502 	inode_inc_iversion(&dir->vfs_inode);  in btrfs_unlink_subvol()
4503 	inode_set_mtime_to_ts(&dir->vfs_inode, inode_set_ctime_current(&dir->vfs_inode));  in btrfs_unlink_subvol()
4519 	struct btrfs_fs_info *fs_info = root->fs_info;  in may_destroy_subvol()
4529 		return -ENOMEM;  in may_destroy_subvol()
4532 	dir_id = btrfs_super_root_dir(fs_info->super_copy);  in may_destroy_subvol()
4533 	di = btrfs_lookup_dir_item(NULL, fs_info->tree_root, path,  in may_destroy_subvol()
4536 		btrfs_dir_item_key_to_cpu(path->nodes[0], di, &key);  in may_destroy_subvol()
4538 			ret = -EPERM;  in may_destroy_subvol()
4549 	key.offset = (u64)-1;  in may_destroy_subvol()
4551 	ret = btrfs_search_slot(NULL, fs_info->tree_root, &key, path, 0, 0);  in may_destroy_subvol()
4556 		 * Key with offset -1 found, there would have to exist a root  in may_destroy_subvol()
4559 		return -EUCLEAN;  in may_destroy_subvol()
4563 	if (path->slots[0] > 0) {  in may_destroy_subvol()
4564 		path->slots[0]--;  in may_destroy_subvol()
4565 		btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]);  in may_destroy_subvol()
4567 			ret = -ENOTEMPTY;  in may_destroy_subvol()
4576 	struct btrfs_fs_info *fs_info = root->fs_info;  in btrfs_prune_dentries()
4581 		WARN_ON(btrfs_root_refs(&root->root_item) != 0);  in btrfs_prune_dentries()
4585 		if (icount_read(&inode->vfs_inode) > 1)  in btrfs_prune_dentries()
4586 			d_prune_aliases(&inode->vfs_inode);  in btrfs_prune_dentries()
4593 		iput(&inode->vfs_inode);  in btrfs_prune_dentries()
4601 	struct btrfs_root *root = dir->root;  in btrfs_delete_subvolume()
4602 	struct btrfs_fs_info *fs_info = root->fs_info;  in btrfs_delete_subvolume()
4604 	struct btrfs_root *dest = BTRFS_I(inode)->root;  in btrfs_delete_subvolume()
4611 	down_write(&fs_info->subvol_sem);  in btrfs_delete_subvolume()
4618 	spin_lock(&dest->root_item_lock);  in btrfs_delete_subvolume()
4619 	if (dest->send_in_progress) {  in btrfs_delete_subvolume()
4620 		spin_unlock(&dest->root_item_lock);  in btrfs_delete_subvolume()
4624 		ret = -EPERM;  in btrfs_delete_subvolume()
4627 	if (atomic_read(&dest->nr_swapfiles)) {  in btrfs_delete_subvolume()
4628 		spin_unlock(&dest->root_item_lock);  in btrfs_delete_subvolume()
4632 		ret = -EPERM;  in btrfs_delete_subvolume()
4635 	root_flags = btrfs_root_flags(&dest->root_item);  in btrfs_delete_subvolume()
4636 	btrfs_set_root_flags(&dest->root_item,  in btrfs_delete_subvolume()
4638 	spin_unlock(&dest->root_item_lock);  in btrfs_delete_subvolume()
4662 	trans->block_rsv = &block_rsv;  in btrfs_delete_subvolume()
4663 	trans->bytes_reserved = block_rsv.size;  in btrfs_delete_subvolume()
4679 	memset(&dest->root_item.drop_progress, 0,  in btrfs_delete_subvolume()
4680 		sizeof(dest->root_item.drop_progress));  in btrfs_delete_subvolume()
4681 	btrfs_set_root_drop_level(&dest->root_item, 0);  in btrfs_delete_subvolume()
4682 	btrfs_set_root_refs(&dest->root_item, 0);  in btrfs_delete_subvolume()
4684 	if (!test_and_set_bit(BTRFS_ROOT_ORPHAN_ITEM_INSERTED, &dest->state)) {  in btrfs_delete_subvolume()
4686 					fs_info->tree_root,  in btrfs_delete_subvolume()
4694 	ret = btrfs_uuid_tree_remove(trans, dest->root_item.uuid,  in btrfs_delete_subvolume()
4696 	if (unlikely(ret && ret != -ENOENT)) {  in btrfs_delete_subvolume()
4700 	if (!btrfs_is_empty_uuid(dest->root_item.received_uuid)) {  in btrfs_delete_subvolume()
4702 					  dest->root_item.received_uuid,  in btrfs_delete_subvolume()
4705 		if (unlikely(ret && ret != -ENOENT)) {  in btrfs_delete_subvolume()
4711 	free_anon_bdev(dest->anon_dev);  in btrfs_delete_subvolume()
4712 	dest->anon_dev = 0;  in btrfs_delete_subvolume()
4714 	trans->block_rsv = NULL;  in btrfs_delete_subvolume()
4715 	trans->bytes_reserved = 0;  in btrfs_delete_subvolume()
4717 	inode->i_flags |= S_DEAD;  in btrfs_delete_subvolume()
4719 	btrfs_block_rsv_release(fs_info, &block_rsv, (u64)-1, NULL);  in btrfs_delete_subvolume()
4724 		spin_lock(&dest->root_item_lock);  in btrfs_delete_subvolume()
4725 		root_flags = btrfs_root_flags(&dest->root_item);  in btrfs_delete_subvolume()
4726 		btrfs_set_root_flags(&dest->root_item,  in btrfs_delete_subvolume()
4728 		spin_unlock(&dest->root_item_lock);  in btrfs_delete_subvolume()
4731 	up_write(&fs_info->subvol_sem);  in btrfs_delete_subvolume()
4735 		ASSERT(dest->send_in_progress == 0);  in btrfs_delete_subvolume()
4745 	struct btrfs_fs_info *fs_info = inode->root->fs_info;  in btrfs_rmdir()
4750 	if (inode->vfs_inode.i_size > BTRFS_EMPTY_DIR_SIZE)  in btrfs_rmdir()
4751 		return -ENOTEMPTY;  in btrfs_rmdir()
4756 			return -EOPNOTSUPP;  in btrfs_rmdir()
4761 	ret = fscrypt_setup_filename(vfs_dir, &dentry->d_name, 1, &fname);  in btrfs_rmdir()
4765 	/* This needs to handle no-key deletions later on */  in btrfs_rmdir()
4787 	if (inode->last_unlink_trans >= trans->transid)  in btrfs_rmdir()
4817 	if (blockstart <= bytenr && bytenr <= blockstart + blocksize - 1)  in is_inside_block()
4825 	struct address_space *mapping = inode->vfs_inode.i_mapping;  in truncate_block_zero_beyond_eof()
4840 		if (folio->mapping != mapping) {  in truncate_block_zero_beyond_eof()
4846 			ret = -EIO;  in truncate_block_zero_beyond_eof()
4853 	 * We do not need to lock extents nor wait for OE, as it's already  in truncate_block_zero_beyond_eof()
4859 	folio_zero_range(folio, zero_start - folio_pos(folio),  in truncate_block_zero_beyond_eof()
4860 			 zero_end - zero_start);  in truncate_block_zero_beyond_eof()
4871  * @inode  - inode that we're zeroing
4872  * @offset - the file offset of the block to truncate
4874  *           extra checks if the block that covers @offset needs to be zeroed.
4875  * @start  - the start file offset of the range we want to zero
4876  * @end    - the end (inclusive) file offset of the range we want to zero.
4887 	struct btrfs_fs_info *fs_info = inode->root->fs_info;  in btrfs_truncate_block()
4888 	struct address_space *mapping = inode->vfs_inode.i_mapping;  in btrfs_truncate_block()
4889 	struct extent_io_tree *io_tree = &inode->io_tree;  in btrfs_truncate_block()
4894 	u32 blocksize = fs_info->sectorsize;  in btrfs_truncate_block()
4920 		if (end == (u64)-1 && blocksize < PAGE_SIZE)  in btrfs_truncate_block()
4944 	block_end = block_start + blocksize - 1;  in btrfs_truncate_block()
4984 		if (folio->mapping != mapping) {  in btrfs_truncate_block()
4990 			ret = -EIO;  in btrfs_truncate_block()
4996 	 * We unlock the page after the io is completed and then re-lock it  in btrfs_truncate_block()
5019 	btrfs_clear_extent_bit(&inode->io_tree, block_start, block_end,  in btrfs_truncate_block()
5030 	if (end == (u64)-1) {  in btrfs_truncate_block()
5041 		zero_end = min_t(u64, folio_end(folio) - 1, end);  in btrfs_truncate_block()
5046 	folio_zero_range(folio, zero_start - folio_pos(folio),  in btrfs_truncate_block()
5047 			 zero_end - zero_start + 1);  in btrfs_truncate_block()
5050 				  block_end + 1 - block_start);  in btrfs_truncate_block()
5052 			      block_end + 1 - block_start);  in btrfs_truncate_block()
5055 		btrfs_set_extent_bit(&inode->io_tree, block_start, block_end,  in btrfs_truncate_block()
5080 	struct btrfs_root *root = inode->root;  in maybe_insert_hole()
5081 	struct btrfs_fs_info *fs_info = root->fs_info;  in maybe_insert_hole()
5096 	 * 1 - for the one we're dropping  in maybe_insert_hole()
5097 	 * 1 - for the one we're adding  in maybe_insert_hole()
5098 	 * 1 - for updating the inode.  in maybe_insert_hole()
5134 	struct btrfs_root *root = inode->root;  in btrfs_cont_expand()
5135 	struct btrfs_fs_info *fs_info = root->fs_info;  in btrfs_cont_expand()
5136 	struct extent_io_tree *io_tree = &inode->io_tree;  in btrfs_cont_expand()
5139 	u64 hole_start = ALIGN(oldsize, fs_info->sectorsize);  in btrfs_cont_expand()
5140 	u64 block_end = ALIGN(size, fs_info->sectorsize);  in btrfs_cont_expand()
5151 	ret = btrfs_truncate_block(inode, oldsize, oldsize, -1);  in btrfs_cont_expand()
5158 	btrfs_lock_and_flush_ordered_range(inode, hole_start, block_end - 1,  in btrfs_cont_expand()
5162 		em = btrfs_get_extent(inode, NULL, cur_offset, block_end - cur_offset);  in btrfs_cont_expand()
5169 		last_byte = ALIGN(last_byte, fs_info->sectorsize);  in btrfs_cont_expand()
5170 		hole_size = last_byte - cur_offset;  in btrfs_cont_expand()
5172 		if (!(em->flags & EXTENT_FLAG_PREALLOC)) {  in btrfs_cont_expand()
5187 						    cur_offset + hole_size - 1,  in btrfs_cont_expand()
5192 			hole_em->start = cur_offset;  in btrfs_cont_expand()
5193 			hole_em->len = hole_size;  in btrfs_cont_expand()
5195 			hole_em->disk_bytenr = EXTENT_MAP_HOLE;  in btrfs_cont_expand()
5196 			hole_em->disk_num_bytes = 0;  in btrfs_cont_expand()
5197 			hole_em->ram_bytes = hole_size;  in btrfs_cont_expand()
5198 			hole_em->generation = btrfs_get_fs_generation(fs_info);  in btrfs_cont_expand()
5216 	btrfs_unlock_extent(io_tree, hole_start, block_end - 1, &cached_state);  in btrfs_cont_expand()
5222 	struct btrfs_root *root = BTRFS_I(inode)->root;  in btrfs_setsize()
5225 	loff_t newsize = attr->ia_size;  in btrfs_setsize()
5226 	int mask = attr->ia_valid;  in btrfs_setsize()
5247 		 * state of this file - if the snapshot captures this expanding  in btrfs_setsize()
5251 		btrfs_drew_write_lock(&root->snapshot_lock);  in btrfs_setsize()
5254 			btrfs_drew_write_unlock(&root->snapshot_lock);  in btrfs_setsize()
5260 			btrfs_drew_write_unlock(&root->snapshot_lock);  in btrfs_setsize()
5268 		btrfs_drew_write_unlock(&root->snapshot_lock);  in btrfs_setsize()
5275 					ALIGN(newsize, fs_info->sectorsize),  in btrfs_setsize()
5276 					(u64)-1);  in btrfs_setsize()
5288 				&BTRFS_I(inode)->runtime_flags);  in btrfs_setsize()
5295 		if (ret && inode->i_nlink) {  in btrfs_setsize()
5299 			 * Truncate failed, so fix up the in-memory size. We  in btrfs_setsize()
5302 			 * in-memory size to match.  in btrfs_setsize()
5304 			ret2 = btrfs_wait_ordered_range(BTRFS_I(inode), 0, (u64)-1);  in btrfs_setsize()
5307 			i_size_write(inode, BTRFS_I(inode)->disk_i_size);  in btrfs_setsize()
5318 	struct btrfs_root *root = BTRFS_I(inode)->root;  in btrfs_setattr()
5322 		return -EROFS;  in btrfs_setattr()
5328 	if (S_ISREG(inode->i_mode) && (attr->ia_valid & ATTR_SIZE)) {  in btrfs_setattr()
5334 	if (attr->ia_valid) {  in btrfs_setattr()
5339 		if (!ret && attr->ia_valid & ATTR_MODE)  in btrfs_setattr()
5340 			ret = posix_acl_chmod(idmap, dentry, inode->i_mode);  in btrfs_setattr()
5361 	struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;  in evict_inode_truncate_pages()
5364 	ASSERT(inode->i_state & I_FREEING);  in evict_inode_truncate_pages()
5365 	truncate_inode_pages_final(&inode->i_data);  in evict_inode_truncate_pages()
5367 	btrfs_drop_extent_map_range(BTRFS_I(inode), 0, (u64)-1, false);  in evict_inode_truncate_pages()
5377 	 * queue kthread), inode references (inode->i_count) were not taken  in evict_inode_truncate_pages()
5381 	 * reference count - if we don't do it, when they access the inode's  in evict_inode_truncate_pages()
5383 	 * use-after-free issue.  in evict_inode_truncate_pages()
5385 	spin_lock(&io_tree->lock);  in evict_inode_truncate_pages()
5386 	while (!RB_EMPTY_ROOT(&io_tree->state)) {  in evict_inode_truncate_pages()
5393 		node = rb_first(&io_tree->state);  in evict_inode_truncate_pages()
5395 		start = state->start;  in evict_inode_truncate_pages()
5396 		end = state->end;  in evict_inode_truncate_pages()
5397 		state_flags = state->state;  in evict_inode_truncate_pages()
5398 		spin_unlock(&io_tree->lock);  in evict_inode_truncate_pages()
5412 					       end - start + 1, NULL);  in evict_inode_truncate_pages()
5419 		spin_lock(&io_tree->lock);  in evict_inode_truncate_pages()
5421 	spin_unlock(&io_tree->lock);  in evict_inode_truncate_pages()
5427 	struct btrfs_fs_info *fs_info = root->fs_info;  in evict_refill_and_join()
5439 	 * above.  We reserve our extra bit here because we generate a ton of  in evict_refill_and_join()
5443 	 * if we fail to make this reservation we can re-try without the  in evict_refill_and_join()
5446 	ret = btrfs_block_rsv_refill(fs_info, rsv, rsv->size + delayed_refs_extra,  in evict_refill_and_join()
5449 		ret = btrfs_block_rsv_refill(fs_info, rsv, rsv->size,  in evict_refill_and_join()
5454 			return ERR_PTR(-ENOSPC);  in evict_refill_and_join()
5464 		trans->block_rsv = &fs_info->trans_block_rsv;  in evict_refill_and_join()
5465 		trans->bytes_reserved = delayed_refs_extra;  in evict_refill_and_join()
5466 		btrfs_block_rsv_migrate(rsv, trans->block_rsv,  in evict_refill_and_join()
5476 	struct btrfs_root *root = BTRFS_I(inode)->root;  in btrfs_evict_inode()
5491 	if (inode->i_nlink &&  in btrfs_evict_inode()
5492 	    ((btrfs_root_refs(&root->root_item) != 0 &&  in btrfs_evict_inode()
5500 	if (test_bit(BTRFS_FS_LOG_RECOVERING, &fs_info->flags))  in btrfs_evict_inode()
5503 	if (inode->i_nlink > 0) {  in btrfs_evict_inode()
5504 		BUG_ON(btrfs_root_refs(&root->root_item) != 0 &&  in btrfs_evict_inode()
5543 		trans->block_rsv = &rsv;  in btrfs_evict_inode()
5546 		trans->block_rsv = &fs_info->trans_block_rsv;  in btrfs_evict_inode()
5554 		if (ret && ret != -ENOSPC && ret != -EAGAIN)  in btrfs_evict_inode()
5571 		trans->block_rsv = &rsv;  in btrfs_evict_inode()
5573 		trans->block_rsv = &fs_info->trans_block_rsv;  in btrfs_evict_inode()
5578 	btrfs_block_rsv_release(fs_info, &rsv, (u64)-1, NULL);  in btrfs_evict_inode()
5594  * If no dir entries were found, returns -ENOENT.
5595  * If found a corrupted location in dir entry, returns -EUCLEAN.
5602 	struct btrfs_root *root = dir->root;  in btrfs_inode_by_name()
5608 		return -ENOMEM;  in btrfs_inode_by_name()
5610 	ret = fscrypt_setup_filename(&dir->vfs_inode, &dentry->d_name, 1, &fname);  in btrfs_inode_by_name()
5619 	/* This needs to handle no-key deletions later on */  in btrfs_inode_by_name()
5624 		ret = di ? PTR_ERR(di) : -ENOENT;  in btrfs_inode_by_name()
5628 	btrfs_dir_item_key_to_cpu(path->nodes[0], di, location);  in btrfs_inode_by_name()
5629 	if (unlikely(location->type != BTRFS_INODE_ITEM_KEY &&  in btrfs_inode_by_name()
5630 		     location->type != BTRFS_ROOT_ITEM_KEY)) {  in btrfs_inode_by_name()
5631 		ret = -EUCLEAN;  in btrfs_inode_by_name()
5632 		btrfs_warn(root->fs_info,  in btrfs_inode_by_name()
5635 			   location->objectid, location->type, location->offset);  in btrfs_inode_by_name()
5638 		*type = btrfs_dir_ftype(path->nodes[0], di);  in btrfs_inode_by_name()
5664 	ret = fscrypt_setup_filename(&dir->vfs_inode, &dentry->d_name, 0, &fname);  in fixup_tree_root_location()
5670 		err = -ENOMEM;  in fixup_tree_root_location()
5674 	err = -ENOENT;  in fixup_tree_root_location()
5675 	key.objectid = btrfs_root_id(dir->root);  in fixup_tree_root_location()
5677 	key.offset = location->objectid;  in fixup_tree_root_location()
5679 	ret = btrfs_search_slot(NULL, fs_info->tree_root, &key, path, 0, 0);  in fixup_tree_root_location()
5686 	leaf = path->nodes[0];  in fixup_tree_root_location()
5687 	ref = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_root_ref);  in fixup_tree_root_location()
5699 	new_root = btrfs_get_fs_root(fs_info, location->objectid, true);  in fixup_tree_root_location()
5706 	location->objectid = btrfs_root_dirid(&new_root->root_item);  in fixup_tree_root_location()
5707 	location->type = BTRFS_INODE_ITEM_KEY;  in fixup_tree_root_location()
5708 	location->offset = 0;  in fixup_tree_root_location()
5719 	struct btrfs_root *root = inode->root;  in btrfs_del_inode_from_root()
5723 	xa_lock(&root->inodes);  in btrfs_del_inode_from_root()
5733 	entry = __xa_cmpxchg(&root->inodes, btrfs_ino(inode), inode, NULL,  in btrfs_del_inode_from_root()
5736 		empty = xa_empty(&root->inodes);  in btrfs_del_inode_from_root()
5737 	xa_unlock(&root->inodes);  in btrfs_del_inode_from_root()
5739 	if (empty && btrfs_root_refs(&root->root_item) == 0) {  in btrfs_del_inode_from_root()
5740 		xa_lock(&root->inodes);  in btrfs_del_inode_from_root()
5741 		empty = xa_empty(&root->inodes);  in btrfs_del_inode_from_root()
5742 		xa_unlock(&root->inodes);  in btrfs_del_inode_from_root()
5753 	btrfs_set_inode_number(BTRFS_I(inode), args->ino);  in btrfs_init_locked_inode()
5754 	BTRFS_I(inode)->root = btrfs_grab_root(args->root);  in btrfs_init_locked_inode()
5756 	if (args->root && args->root == args->root->fs_info->tree_root &&  in btrfs_init_locked_inode()
5757 	    args->ino != BTRFS_BTREE_INODE_OBJECTID)  in btrfs_init_locked_inode()
5759 			&BTRFS_I(inode)->runtime_flags);  in btrfs_init_locked_inode()
5767 	return args->ino == btrfs_ino(BTRFS_I(inode)) &&  in btrfs_find_actor()
5768 		args->root == BTRFS_I(inode)->root;  in btrfs_find_actor()
5780 	inode = iget5_locked_rcu(root->fs_info->sb, hashval, btrfs_find_actor,  in btrfs_iget_locked()
5800 		return ERR_PTR(-ENOMEM);  in btrfs_iget_path()
5802 	if (!(inode->vfs_inode.i_state & I_NEW))  in btrfs_iget_path()
5809 	unlock_new_inode(&inode->vfs_inode);  in btrfs_iget_path()
5824 		return ERR_PTR(-ENOMEM);  in btrfs_iget()
5826 	if (!(inode->vfs_inode.i_state & I_NEW))  in btrfs_iget()
5831 		iget_failed(&inode->vfs_inode);  in btrfs_iget()
5832 		return ERR_PTR(-ENOMEM);  in btrfs_iget()
5840 	unlock_new_inode(&inode->vfs_inode);  in btrfs_iget()
5852 	vfs_inode = new_inode(dir->i_sb);  in new_simple_dir()
5854 		return ERR_PTR(-ENOMEM);  in new_simple_dir()
5857 	inode->root = btrfs_grab_root(root);  in new_simple_dir()
5858 	inode->ref_root_id = key->objectid;  in new_simple_dir()
5859 	set_bit(BTRFS_INODE_ROOT_STUB, &inode->runtime_flags);  in new_simple_dir()
5860 	set_bit(BTRFS_INODE_DUMMY, &inode->runtime_flags);  in new_simple_dir()
5864 	 * We only need lookup, the rest is read-only and there's no inode  in new_simple_dir()
5867 	vfs_inode->i_op = &simple_dir_inode_operations;  in new_simple_dir()
5868 	vfs_inode->i_opflags &= ~IOP_XATTR;  in new_simple_dir()
5869 	vfs_inode->i_fop = &simple_dir_operations;  in new_simple_dir()
5870 	vfs_inode->i_mode = S_IFDIR | S_IRUGO | S_IWUSR | S_IXUGO;  in new_simple_dir()
5875 	inode->i_otime_sec = ts.tv_sec;  in new_simple_dir()
5876 	inode->i_otime_nsec = ts.tv_nsec;  in new_simple_dir()
5878 	vfs_inode->i_uid = dir->i_uid;  in new_simple_dir()
5879 	vfs_inode->i_gid = dir->i_gid;  in new_simple_dir()
5895 	return fs_umode_to_ftype(inode->vfs_inode.i_mode);  in btrfs_inode_type()
5902 	struct btrfs_root *root = BTRFS_I(dir)->root;  in btrfs_lookup_dentry()
5908 	if (dentry->d_name.len > BTRFS_NAME_LEN)  in btrfs_lookup_dentry()
5909 		return ERR_PTR(-ENAMETOOLONG);  in btrfs_lookup_dentry()
5920 		/* Do extra check against inode mode with di_type */  in btrfs_lookup_dentry()
5924 				  inode->vfs_inode.i_mode, btrfs_inode_type(inode),  in btrfs_lookup_dentry()
5926 			iput(&inode->vfs_inode);  in btrfs_lookup_dentry()
5927 			return ERR_PTR(-EUCLEAN);  in btrfs_lookup_dentry()
5929 		return &inode->vfs_inode;  in btrfs_lookup_dentry()
5935 		if (ret != -ENOENT)  in btrfs_lookup_dentry()
5946 		down_read(&fs_info->cleanup_work_sem);  in btrfs_lookup_dentry()
5947 		if (!sb_rdonly(inode->vfs_inode.i_sb))  in btrfs_lookup_dentry()
5949 		up_read(&fs_info->cleanup_work_sem);  in btrfs_lookup_dentry()
5951 			iput(&inode->vfs_inode);  in btrfs_lookup_dentry()
5959 	return &inode->vfs_inode;  in btrfs_lookup_dentry()
5968 		inode = d_inode(dentry->d_parent);  in btrfs_dentry_delete()
5971 		root = BTRFS_I(inode)->root;  in btrfs_dentry_delete()
5972 		if (btrfs_root_refs(&root->root_item) == 0)  in btrfs_dentry_delete()
5986 	if (inode == ERR_PTR(-ENOENT))  in btrfs_lookup()
5993  * in-memory index_cnt variable to the first free sequence number.
5997 	struct btrfs_root *root = inode->root;  in btrfs_set_inode_index_count()
6005 	key.offset = (u64)-1;  in btrfs_set_inode_index_count()
6009 		return -ENOMEM;  in btrfs_set_inode_index_count()
6018 	if (path->slots[0] == 0) {  in btrfs_set_inode_index_count()
6019 		inode->index_cnt = BTRFS_DIR_START_INDEX;  in btrfs_set_inode_index_count()
6023 	path->slots[0]--;  in btrfs_set_inode_index_count()
6025 	leaf = path->nodes[0];  in btrfs_set_inode_index_count()
6026 	btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);  in btrfs_set_inode_index_count()
6030 		inode->index_cnt = BTRFS_DIR_START_INDEX;  in btrfs_set_inode_index_count()
6034 	inode->index_cnt = found_key.offset + 1;  in btrfs_set_inode_index_count()
6044 	if (dir->index_cnt == (u64)-1) {  in btrfs_get_dir_last_index()
6054 	*index = dir->index_cnt - 1;  in btrfs_get_dir_last_index()
6082 		return -ENOMEM;  in btrfs_opendir()
6083 	private->last_index = last_index;  in btrfs_opendir()
6084 	private->filldir_buf = kzalloc(PAGE_SIZE, GFP_KERNEL);  in btrfs_opendir()
6085 	if (!private->filldir_buf) {  in btrfs_opendir()
6087 		return -ENOMEM;  in btrfs_opendir()
6089 	file->private_data = private;  in btrfs_opendir()
6095 	struct btrfs_file_private *private = file->private_data;  in btrfs_dir_llseek()
6099 				       &private->last_index);  in btrfs_dir_llseek()
6115 	while (entries--) {  in btrfs_filldir()
6119 		ctx->pos = get_unaligned(&entry->offset);  in btrfs_filldir()
6120 		if (!dir_emit(ctx, name, get_unaligned(&entry->name_len),  in btrfs_filldir()
6121 					 get_unaligned(&entry->ino),  in btrfs_filldir()
6122 					 get_unaligned(&entry->type)))  in btrfs_filldir()
6125 			get_unaligned(&entry->name_len);  in btrfs_filldir()
6126 		ctx->pos++;  in btrfs_filldir()
6134 	struct btrfs_root *root = BTRFS_I(inode)->root;  in btrfs_real_readdir()
6135 	struct btrfs_file_private *private = file->private_data;  in btrfs_real_readdir()
6156 		return -ENOMEM;  in btrfs_real_readdir()
6158 	addr = private->filldir_buf;  in btrfs_real_readdir()
6159 	path->reada = READA_FORWARD;  in btrfs_real_readdir()
6161 	put = btrfs_readdir_get_delayed_items(BTRFS_I(inode), private->last_index,  in btrfs_real_readdir()
6166 	key.offset = ctx->pos;  in btrfs_real_readdir()
6171 		struct extent_buffer *leaf = path->nodes[0];  in btrfs_real_readdir()
6178 		if (found_key.offset < ctx->pos)  in btrfs_real_readdir()
6180 		if (found_key.offset > private->last_index)  in btrfs_real_readdir()
6184 		di = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_dir_item);  in btrfs_real_readdir()
6189 			ret = btrfs_filldir(private->filldir_buf, entries, ctx);  in btrfs_real_readdir()
6192 			addr = private->filldir_buf;  in btrfs_real_readdir()
6203 		put_unaligned(name_len, &entry->name_len);  in btrfs_real_readdir()
6204 		put_unaligned(fs_ftype_to_dtype(ftype), &entry->type);  in btrfs_real_readdir()
6206 		put_unaligned(location.objectid, &entry->ino);  in btrfs_real_readdir()
6207 		put_unaligned(found_key.offset, &entry->offset);  in btrfs_real_readdir()
6218 	ret = btrfs_filldir(private->filldir_buf, entries, ctx);  in btrfs_real_readdir()
6242 	if (ctx->pos >= INT_MAX)  in btrfs_real_readdir()
6243 		ctx->pos = LLONG_MAX;  in btrfs_real_readdir()
6245 		ctx->pos = INT_MAX;  in btrfs_real_readdir()
6262 	struct btrfs_root *root = inode->root;  in btrfs_dirty_inode()
6263 	struct btrfs_fs_info *fs_info = root->fs_info;  in btrfs_dirty_inode()
6267 	if (test_bit(BTRFS_INODE_DUMMY, &inode->runtime_flags))  in btrfs_dirty_inode()
6275 	if (ret == -ENOSPC || ret == -EDQUOT) {  in btrfs_dirty_inode()
6285 	if (inode->delayed_node)  in btrfs_dirty_inode()
6297 	struct btrfs_root *root = BTRFS_I(inode)->root;  in btrfs_update_time()
6301 		return -EROFS;  in btrfs_update_time()
6315 	if (dir->index_cnt == (u64)-1) {  in btrfs_set_inode_index()
6324 	*index = dir->index_cnt;  in btrfs_set_inode_index()
6325 	dir->index_cnt++;  in btrfs_set_inode_index()
6335 	args.root = BTRFS_I(inode)->root;  in btrfs_insert_inode_locked()
6338 		   btrfs_inode_hash(inode->i_ino, BTRFS_I(inode)->root),  in btrfs_insert_inode_locked()
6345 	struct inode *dir = args->dir;  in btrfs_new_inode_prepare()
6346 	struct inode *inode = args->inode;  in btrfs_new_inode_prepare()
6349 	if (!args->orphan) {  in btrfs_new_inode_prepare()
6350 		ret = fscrypt_setup_filename(dir, &args->dentry->d_name, 0,  in btrfs_new_inode_prepare()
6351 					     &args->fname);  in btrfs_new_inode_prepare()
6356 	ret = posix_acl_create(dir, &inode->i_mode, &args->default_acl, &args->acl);  in btrfs_new_inode_prepare()
6358 		fscrypt_free_filename(&args->fname);  in btrfs_new_inode_prepare()
6365 	if (BTRFS_I(dir)->prop_compress)  in btrfs_new_inode_prepare()
6368 	if (args->default_acl)  in btrfs_new_inode_prepare()
6371 	if (args->acl)  in btrfs_new_inode_prepare()
6375 	if (dir->i_security)  in btrfs_new_inode_prepare()
6378 	if (args->orphan) {  in btrfs_new_inode_prepare()
6398 	posix_acl_release(args->acl);  in btrfs_new_inode_args_destroy()
6399 	posix_acl_release(args->default_acl);  in btrfs_new_inode_args_destroy()
6400 	fscrypt_free_filename(&args->fname);  in btrfs_new_inode_args_destroy()
6412 	flags = dir->flags;  in btrfs_inherit_iflags()
6415 		inode->flags &= ~BTRFS_INODE_COMPRESS;  in btrfs_inherit_iflags()
6416 		inode->flags |= BTRFS_INODE_NOCOMPRESS;  in btrfs_inherit_iflags()
6418 		inode->flags &= ~BTRFS_INODE_NOCOMPRESS;  in btrfs_inherit_iflags()
6419 		inode->flags |= BTRFS_INODE_COMPRESS;  in btrfs_inherit_iflags()
6423 		inode->flags |= BTRFS_INODE_NODATACOW;  in btrfs_inherit_iflags()
6424 		if (S_ISREG(inode->vfs_inode.i_mode))  in btrfs_inherit_iflags()
6425 			inode->flags |= BTRFS_INODE_NODATASUM;  in btrfs_inherit_iflags()
6435 	struct inode *dir = args->dir;  in btrfs_create_new_inode()
6436 	struct inode *inode = args->inode;  in btrfs_create_new_inode()
6437 	const struct fscrypt_str *name = args->orphan ? NULL : &args->fname.disk_name;  in btrfs_create_new_inode()
6453 		return -ENOMEM;  in btrfs_create_new_inode()
6455 	if (!args->subvol)  in btrfs_create_new_inode()
6456 		BTRFS_I(inode)->root = btrfs_grab_root(BTRFS_I(dir)->root);  in btrfs_create_new_inode()
6457 	root = BTRFS_I(inode)->root;  in btrfs_create_new_inode()
6468 	ret = xa_reserve(&root->inodes, objectid, GFP_NOFS);  in btrfs_create_new_inode()
6473 	if (args->orphan) {  in btrfs_create_new_inode()
6482 		ret = btrfs_set_inode_index(BTRFS_I(dir), &BTRFS_I(inode)->dir_index);  in btrfs_create_new_inode()
6487 	if (S_ISDIR(inode->i_mode))  in btrfs_create_new_inode()
6488 		BTRFS_I(inode)->index_cnt = BTRFS_DIR_START_INDEX;  in btrfs_create_new_inode()
6490 	BTRFS_I(inode)->generation = trans->transid;  in btrfs_create_new_inode()
6491 	inode->i_generation = BTRFS_I(inode)->generation;  in btrfs_create_new_inode()
6498 	set_bit(BTRFS_INODE_NO_CAP_XATTR, &BTRFS_I(inode)->runtime_flags);  in btrfs_create_new_inode()
6505 	if (!args->subvol)  in btrfs_create_new_inode()
6509 	if (S_ISREG(inode->i_mode)) {  in btrfs_create_new_inode()
6511 			BTRFS_I(inode)->flags |= BTRFS_INODE_NODATASUM;  in btrfs_create_new_inode()
6513 			BTRFS_I(inode)->flags |= BTRFS_INODE_NODATACOW |  in btrfs_create_new_inode()
6520 		if (!args->orphan)  in btrfs_create_new_inode()
6521 			BTRFS_I(dir)->index_cnt--;  in btrfs_create_new_inode()
6539 	if (!args->orphan) {  in btrfs_create_new_inode()
6548 		if (args->subvol) {  in btrfs_create_new_inode()
6553 			sizes[1] = name->len + sizeof(*ref);  in btrfs_create_new_inode()
6559 	batch.total_data_size = sizes[0] + (args->orphan ? 0 : sizes[1]);  in btrfs_create_new_inode()
6560 	batch.nr = args->orphan ? 1 : 2;  in btrfs_create_new_inode()
6568 	BTRFS_I(inode)->i_otime_sec = ts.tv_sec;  in btrfs_create_new_inode()
6569 	BTRFS_I(inode)->i_otime_nsec = ts.tv_nsec;  in btrfs_create_new_inode()
6576 	inode_item = btrfs_item_ptr(path->nodes[0], path->slots[0],  in btrfs_create_new_inode()
6578 	memzero_extent_buffer(path->nodes[0], (unsigned long)inode_item,  in btrfs_create_new_inode()
6580 	fill_inode_item(trans, path->nodes[0], inode_item, inode);  in btrfs_create_new_inode()
6582 	if (!args->orphan) {  in btrfs_create_new_inode()
6583 		ref = btrfs_item_ptr(path->nodes[0], path->slots[0] + 1,  in btrfs_create_new_inode()
6586 		if (args->subvol) {  in btrfs_create_new_inode()
6587 			btrfs_set_inode_ref_name_len(path->nodes[0], ref, 2);  in btrfs_create_new_inode()
6588 			btrfs_set_inode_ref_index(path->nodes[0], ref, 0);  in btrfs_create_new_inode()
6589 			write_extent_buffer(path->nodes[0], "..", ptr, 2);  in btrfs_create_new_inode()
6591 			btrfs_set_inode_ref_name_len(path->nodes[0], ref,  in btrfs_create_new_inode()
6592 						     name->len);  in btrfs_create_new_inode()
6593 			btrfs_set_inode_ref_index(path->nodes[0], ref,  in btrfs_create_new_inode()
6594 						  BTRFS_I(inode)->dir_index);  in btrfs_create_new_inode()
6595 			write_extent_buffer(path->nodes[0], name->name, ptr,  in btrfs_create_new_inode()
6596 					    name->len);  in btrfs_create_new_inode()
6608 	if (args->subvol) {  in btrfs_create_new_inode()
6615 		parent = btrfs_iget(BTRFS_FIRST_FREE_OBJECTID, BTRFS_I(dir)->root);  in btrfs_create_new_inode()
6621 			iput(&parent->vfs_inode);  in btrfs_create_new_inode()
6637 	if (!args->subvol) {  in btrfs_create_new_inode()
6657 	if (args->orphan) {  in btrfs_create_new_inode()
6665 				     0, BTRFS_I(inode)->dir_index);  in btrfs_create_new_inode()
6683 		xa_release(&root->inodes, objectid);  in btrfs_create_new_inode()
6701 	struct btrfs_root *root = parent_inode->root;  in btrfs_add_link()
6706 		memcpy(&key, &inode->root->root_key, sizeof(key));  in btrfs_add_link()
6728 	if (ret == -EEXIST || ret == -EOVERFLOW)  in btrfs_add_link()
6735 	btrfs_i_size_write(parent_inode, parent_inode->vfs_inode.i_size +  in btrfs_add_link()
6736 			   name->len * 2);  in btrfs_add_link()
6737 	inode_inc_iversion(&parent_inode->vfs_inode);  in btrfs_add_link()
6770 	struct btrfs_root *root = BTRFS_I(dir)->root;  in btrfs_create_common()
6809 	inode = new_inode(dir->i_sb);  in btrfs_mknod()
6811 		return -ENOMEM;  in btrfs_mknod()
6813 	inode->i_op = &btrfs_special_inode_operations;  in btrfs_mknod()
6814 	init_special_inode(inode, inode->i_mode, rdev);  in btrfs_mknod()
6823 	inode = new_inode(dir->i_sb);  in btrfs_create()
6825 		return -ENOMEM;  in btrfs_create()
6827 	inode->i_fop = &btrfs_file_operations;  in btrfs_create()
6828 	inode->i_op = &btrfs_file_inode_operations;  in btrfs_create()
6829 	inode->i_mapping->a_ops = &btrfs_aops;  in btrfs_create()
6837 	struct btrfs_root *root = BTRFS_I(dir)->root;  in btrfs_link()
6845 	if (btrfs_root_id(root) != btrfs_root_id(BTRFS_I(inode)->root))  in btrfs_link()
6846 		return -EXDEV;  in btrfs_link()
6848 	if (inode->i_nlink >= BTRFS_LINK_MAX)  in btrfs_link()
6849 		return -EMLINK;  in btrfs_link()
6851 	ret = fscrypt_setup_filename(dir, &dentry->d_name, 0, &fname);  in btrfs_link()
6865 	trans = btrfs_start_transaction(root, inode->i_nlink ? 5 : 6);  in btrfs_link()
6873 	BTRFS_I(inode)->dir_index = 0ULL;  in btrfs_link()
6890 	if (inode->i_nlink == 1) {  in btrfs_link()
6905 	btrfs_log_new_name(trans, old_dentry, NULL, 0, dentry->d_parent);  in btrfs_link()
6920 	inode = new_inode(dir->i_sb);  in btrfs_mkdir()
6922 		return ERR_PTR(-ENOMEM);  in btrfs_mkdir()
6924 	inode->i_op = &btrfs_dir_inode_operations;  in btrfs_mkdir()
6925 	inode->i_fop = &btrfs_dir_file_operations;  in btrfs_mkdir()
6934 	struct extent_buffer *leaf = path->nodes[0];  in uncompress_inline()
6935 	const u32 blocksize = leaf->fs_info->sectorsize;  in uncompress_inline()
6944 	inline_size = btrfs_file_extent_inline_item_len(leaf, path->slots[0]);  in uncompress_inline()
6947 		return -ENOMEM;  in uncompress_inline()
6965 		folio_zero_range(folio, max_size, blocksize - max_size);  in uncompress_inline()
6972 	const u32 blocksize = path->nodes[0]->fs_info->sectorsize;  in read_inline_extent()
6982 	fi = btrfs_item_ptr(path->nodes[0], path->slots[0],  in read_inline_extent()
6984 	if (btrfs_file_extent_compression(path->nodes[0], fi) != BTRFS_COMPRESS_NONE)  in read_inline_extent()
6988 			  btrfs_file_extent_ram_bytes(path->nodes[0], fi));  in read_inline_extent()
6990 	read_extent_buffer(path->nodes[0], kaddr,  in read_inline_extent()
6994 		folio_zero_range(folio, copy_size, blocksize - copy_size);  in read_inline_extent()
7007  * it from the B-tree and caching it if necessary. Note that there may be more
7013  * Return: ERR_PTR on error, non-NULL extent_map on success.
7018 	struct btrfs_fs_info *fs_info = inode->root->fs_info;  in btrfs_get_extent()
7023 	int extent_type = -1;  in btrfs_get_extent()
7025 	struct btrfs_root *root = inode->root;  in btrfs_get_extent()
7030 	struct extent_map_tree *em_tree = &inode->extent_tree;  in btrfs_get_extent()
7032 	read_lock(&em_tree->lock);  in btrfs_get_extent()
7034 	read_unlock(&em_tree->lock);  in btrfs_get_extent()
7037 		if (em->start > start || em->start + em->len <= start)  in btrfs_get_extent()
7039 		else if (em->disk_bytenr == EXTENT_MAP_INLINE && folio)  in btrfs_get_extent()
7046 		ret = -ENOMEM;  in btrfs_get_extent()
7049 	em->start = EXTENT_MAP_HOLE;  in btrfs_get_extent()
7050 	em->disk_bytenr = EXTENT_MAP_HOLE;  in btrfs_get_extent()
7051 	em->len = (u64)-1;  in btrfs_get_extent()
7055 		ret = -ENOMEM;  in btrfs_get_extent()
7060 	path->reada = READA_FORWARD;  in btrfs_get_extent()
7068 		path->search_commit_root = 1;  in btrfs_get_extent()
7069 		path->skip_locking = 1;  in btrfs_get_extent()
7076 		if (path->slots[0] == 0)  in btrfs_get_extent()
7078 		path->slots[0]--;  in btrfs_get_extent()
7082 	leaf = path->nodes[0];  in btrfs_get_extent()
7083 	item = btrfs_item_ptr(leaf, path->slots[0],  in btrfs_get_extent()
7085 	btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);  in btrfs_get_extent()
7104 		if (unlikely(!S_ISREG(inode->vfs_inode.i_mode))) {  in btrfs_get_extent()
7105 			ret = -EUCLEAN;  in btrfs_get_extent()
7107 		"regular/prealloc extent found for non-regular inode %llu",  in btrfs_get_extent()
7115 						      path->slots[0],  in btrfs_get_extent()
7120 		path->slots[0]++;  in btrfs_get_extent()
7121 		if (path->slots[0] >= btrfs_header_nritems(leaf)) {  in btrfs_get_extent()
7128 			leaf = path->nodes[0];  in btrfs_get_extent()
7130 		btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);  in btrfs_get_extent()
7140 		em->start = start;  in btrfs_get_extent()
7141 		em->len = found_key.offset - start;  in btrfs_get_extent()
7142 		em->disk_bytenr = EXTENT_MAP_HOLE;  in btrfs_get_extent()
7154 		 * ensured by tree-checker and inline extent creation path.  in btrfs_get_extent()
7158 		ASSERT(em->start == 0);  in btrfs_get_extent()
7166 		ASSERT(em->disk_bytenr == EXTENT_MAP_INLINE);  in btrfs_get_extent()
7167 		ASSERT(em->len == fs_info->sectorsize);  in btrfs_get_extent()
7175 	em->start = start;  in btrfs_get_extent()
7176 	em->len = len;  in btrfs_get_extent()
7177 	em->disk_bytenr = EXTENT_MAP_HOLE;  in btrfs_get_extent()
7181 	if (unlikely(em->start > start || btrfs_extent_map_end(em) <= start)) {  in btrfs_get_extent()
7184 			  em->start, em->len, start, len);  in btrfs_get_extent()
7185 		ret = -EIO;  in btrfs_get_extent()
7189 	write_lock(&em_tree->lock);  in btrfs_get_extent()
7191 	write_unlock(&em_tree->lock);  in btrfs_get_extent()
7210 	if (!block_group || block_group->ro)  in btrfs_extent_readonly()
7224  * @orig_len:	(optional) Return the original on-disk length of the file extent
7239 	struct btrfs_root *root = inode->root;  in can_nocow_extent()
7240 	struct btrfs_fs_info *fs_info = root->fs_info;  in can_nocow_extent()
7245 	struct extent_io_tree *io_tree = &inode->io_tree;  in can_nocow_extent()
7252 		return -ENOMEM;  in can_nocow_extent()
7253 	path->nowait = nowait;  in can_nocow_extent()
7261 		if (path->slots[0] == 0) {  in can_nocow_extent()
7265 		path->slots[0]--;  in can_nocow_extent()
7268 	leaf = path->nodes[0];  in can_nocow_extent()
7269 	btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);  in can_nocow_extent()
7284 	fi = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_file_extent_item);  in can_nocow_extent()
7288 	nocow_args.end = offset + *len - 1;  in can_nocow_extent()
7305 	if (!(inode->flags & BTRFS_INODE_NODATACOW) &&  in can_nocow_extent()
7310 				     root->fs_info->sectorsize) - 1;  in can_nocow_extent()
7314 			return -EAGAIN;  in can_nocow_extent()
7348 		ASSERT(file_extent->num_bytes <= file_extent->ram_bytes);  in btrfs_create_io_em()
7352 		ASSERT(file_extent->disk_num_bytes == file_extent->num_bytes);  in btrfs_create_io_em()
7353 		ASSERT(file_extent->ram_bytes == file_extent->num_bytes);  in btrfs_create_io_em()
7356 		ASSERT(file_extent->offset == 0);  in btrfs_create_io_em()
7360 		ASSERT(file_extent->compression != BTRFS_COMPRESS_NONE);  in btrfs_create_io_em()
7366 		ASSERT(file_extent->num_bytes <= file_extent->ram_bytes);  in btrfs_create_io_em()
7372 		return ERR_PTR(-ENOMEM);  in btrfs_create_io_em()
7374 	em->start = start;  in btrfs_create_io_em()
7375 	em->len = file_extent->num_bytes;  in btrfs_create_io_em()
7376 	em->disk_bytenr = file_extent->disk_bytenr;  in btrfs_create_io_em()
7377 	em->disk_num_bytes = file_extent->disk_num_bytes;  in btrfs_create_io_em()
7378 	em->ram_bytes = file_extent->ram_bytes;  in btrfs_create_io_em()
7379 	em->generation = -1;  in btrfs_create_io_em()
7380 	em->offset = file_extent->offset;  in btrfs_create_io_em()
7381 	em->flags |= EXTENT_FLAG_PINNED;  in btrfs_create_io_em()
7383 		btrfs_extent_map_set_compression(em, file_extent->compression);  in btrfs_create_io_em()
7398  * If we continue to release/invalidate the page, we could cause use-after-free
7424 	spin_lock_irq(&bfs->lock);  in wait_subpage_spinlock()
7425 	spin_unlock_irq(&bfs->lock);  in wait_subpage_spinlock()
7476 	struct btrfs_fs_info *fs_info = inode->root->fs_info;  in btrfs_invalidate_folio()
7477 	struct extent_io_tree *tree = &inode->io_tree;  in btrfs_invalidate_folio()
7480 	u64 page_end = page_start + folio_size(folio) - 1;  in btrfs_invalidate_folio()
7482 	int inode_evicting = inode->vfs_inode.i_state & I_FREEING;  in btrfs_invalidate_folio()
7505 	 * shouldn't clear page extent mapped, as folio->private can still  in btrfs_invalidate_folio()
7528 							   page_end + 1 - cur);  in btrfs_invalidate_folio()
7538 		if (ordered->file_offset > cur) {  in btrfs_invalidate_folio()
7540 			 * There is a range between [cur, oe->file_offset) not  in btrfs_invalidate_folio()
7545 			range_end = ordered->file_offset - 1;  in btrfs_invalidate_folio()
7550 		range_end = min(ordered->file_offset + ordered->num_bytes - 1,  in btrfs_invalidate_folio()
7552 		ASSERT(range_end + 1 - cur < U32_MAX);  in btrfs_invalidate_folio()
7553 		range_len = range_end + 1 - cur;  in btrfs_invalidate_folio()
7579 		spin_lock_irq(&inode->ordered_tree_lock);  in btrfs_invalidate_folio()
7580 		set_bit(BTRFS_ORDERED_TRUNCATED, &ordered->flags);  in btrfs_invalidate_folio()
7581 		ordered->truncated_len = min(ordered->truncated_len,  in btrfs_invalidate_folio()
7582 					     cur - ordered->file_offset);  in btrfs_invalidate_folio()
7583 		spin_unlock_irq(&inode->ordered_tree_lock);  in btrfs_invalidate_folio()
7592 						   cur, range_end + 1 - cur)) {  in btrfs_invalidate_folio()
7618 		btrfs_qgroup_free_data(inode, NULL, cur, range_end + 1 - cur, NULL);  in btrfs_invalidate_folio()
7646 	struct btrfs_root *root = inode->root;  in btrfs_truncate()
7647 	struct btrfs_fs_info *fs_info = root->fs_info;  in btrfs_truncate()
7651 	u64 mask = fs_info->sectorsize - 1;  in btrfs_truncate()
7656 					       inode->vfs_inode.i_size & (~mask),  in btrfs_truncate()
7657 					       (u64)-1);  in btrfs_truncate()
7685 	 * 1) rsv - for the truncate reservation, which we will steal from the  in btrfs_truncate()
7687 	 * 2) fs_info->trans_block_rsv - this will have 1 items worth left for  in btrfs_truncate()
7705 	ret = btrfs_block_rsv_migrate(&fs_info->trans_block_rsv, &rsv,  in btrfs_truncate()
7717 	trans->block_rsv = &rsv;  in btrfs_truncate()
7721 		const u64 new_size = inode->vfs_inode.i_size;  in btrfs_truncate()
7722 		const u64 lock_start = ALIGN_DOWN(new_size, fs_info->sectorsize);  in btrfs_truncate()
7725 		btrfs_lock_extent(&inode->io_tree, lock_start, (u64)-1, &cached_state);  in btrfs_truncate()
7732 					    ALIGN(new_size, fs_info->sectorsize),  in btrfs_truncate()
7733 					    (u64)-1, false);  in btrfs_truncate()
7737 		inode_sub_bytes(&inode->vfs_inode, control.sub_bytes);  in btrfs_truncate()
7740 		btrfs_unlock_extent(&inode->io_tree, lock_start, (u64)-1, &cached_state);  in btrfs_truncate()
7742 		trans->block_rsv = &fs_info->trans_block_rsv;  in btrfs_truncate()
7743 		if (ret != -ENOSPC && ret != -EAGAIN)  in btrfs_truncate()
7760 		btrfs_block_rsv_release(fs_info, &rsv, -1, NULL);  in btrfs_truncate()
7761 		ret = btrfs_block_rsv_migrate(&fs_info->trans_block_rsv,  in btrfs_truncate()
7771 		trans->block_rsv = &rsv;  in btrfs_truncate()
7784 		ret = btrfs_truncate_block(inode, inode->vfs_inode.i_size,  in btrfs_truncate()
7785 					   inode->vfs_inode.i_size, (u64)-1);  in btrfs_truncate()
7799 		trans->block_rsv = &fs_info->trans_block_rsv;  in btrfs_truncate()
7810 	btrfs_block_rsv_release(fs_info, &rsv, (u64)-1, NULL);  in btrfs_truncate()
7819 	 * fsync to truncate all the inode's items from the log and re-log them  in btrfs_truncate()
7836 	inode = new_inode(dir->i_sb);  in btrfs_new_subvol_inode()
7844 		inode->i_op = &btrfs_dir_inode_operations;  in btrfs_new_subvol_inode()
7845 		inode->i_fop = &btrfs_dir_file_operations;  in btrfs_new_subvol_inode()
7860 	ei->root = NULL;  in btrfs_alloc_inode()
7861 	ei->generation = 0;  in btrfs_alloc_inode()
7862 	ei->last_trans = 0;  in btrfs_alloc_inode()
7863 	ei->last_sub_trans = 0;  in btrfs_alloc_inode()
7864 	ei->logged_trans = 0;  in btrfs_alloc_inode()
7865 	ei->delalloc_bytes = 0;  in btrfs_alloc_inode()
7867 	ei->new_delalloc_bytes = 0;  in btrfs_alloc_inode()
7868 	ei->defrag_bytes = 0;  in btrfs_alloc_inode()
7869 	ei->disk_i_size = 0;  in btrfs_alloc_inode()
7870 	ei->flags = 0;  in btrfs_alloc_inode()
7871 	ei->ro_flags = 0;  in btrfs_alloc_inode()
7873 	 * ->index_cnt will be properly initialized later when creating a new  in btrfs_alloc_inode()
7877 	ei->csum_bytes = 0;  in btrfs_alloc_inode()
7878 	ei->dir_index = 0;  in btrfs_alloc_inode()
7879 	ei->last_unlink_trans = 0;  in btrfs_alloc_inode()
7880 	ei->last_reflink_trans = 0;  in btrfs_alloc_inode()
7881 	ei->last_log_commit = 0;  in btrfs_alloc_inode()
7883 	spin_lock_init(&ei->lock);  in btrfs_alloc_inode()
7884 	ei->outstanding_extents = 0;  in btrfs_alloc_inode()
7885 	if (sb->s_magic != BTRFS_TEST_MAGIC)  in btrfs_alloc_inode()
7886 		btrfs_init_metadata_block_rsv(fs_info, &ei->block_rsv,  in btrfs_alloc_inode()
7888 	ei->runtime_flags = 0;  in btrfs_alloc_inode()
7889 	ei->prop_compress = BTRFS_COMPRESS_NONE;  in btrfs_alloc_inode()
7890 	ei->defrag_compress = BTRFS_COMPRESS_NONE;  in btrfs_alloc_inode()
7892 	ei->delayed_node = NULL;  in btrfs_alloc_inode()
7894 	ei->i_otime_sec = 0;  in btrfs_alloc_inode()
7895 	ei->i_otime_nsec = 0;  in btrfs_alloc_inode()
7897 	inode = &ei->vfs_inode;  in btrfs_alloc_inode()
7898 	btrfs_extent_map_tree_init(&ei->extent_tree);  in btrfs_alloc_inode()
7901 	btrfs_extent_io_tree_init(fs_info, &ei->io_tree, IO_TREE_INODE_IO);  in btrfs_alloc_inode()
7902 	ei->io_tree.inode = ei;  in btrfs_alloc_inode()
7904 	ei->file_extent_tree = NULL;  in btrfs_alloc_inode()
7906 	mutex_init(&ei->log_mutex);  in btrfs_alloc_inode()
7907 	spin_lock_init(&ei->ordered_tree_lock);  in btrfs_alloc_inode()
7908 	ei->ordered_tree = RB_ROOT;  in btrfs_alloc_inode()
7909 	ei->ordered_tree_last = NULL;  in btrfs_alloc_inode()
7910 	INIT_LIST_HEAD(&ei->delalloc_inodes);  in btrfs_alloc_inode()
7911 	INIT_LIST_HEAD(&ei->delayed_iput);  in btrfs_alloc_inode()
7912 	init_rwsem(&ei->i_mmap_lock);  in btrfs_alloc_inode()
7920 	btrfs_drop_extent_map_range(BTRFS_I(inode), 0, (u64)-1, false);  in btrfs_test_destroy_inode()
7921 	kfree(BTRFS_I(inode)->file_extent_tree);  in btrfs_test_destroy_inode()
7928 	kfree(BTRFS_I(inode)->file_extent_tree);  in btrfs_free_inode()
7936 	struct btrfs_root *root = inode->root;  in btrfs_destroy_inode()
7939 	WARN_ON(!hlist_empty(&vfs_inode->i_dentry));  in btrfs_destroy_inode()
7940 	WARN_ON(vfs_inode->i_data.nrpages);  in btrfs_destroy_inode()
7941 	WARN_ON(inode->block_rsv.reserved);  in btrfs_destroy_inode()
7942 	WARN_ON(inode->block_rsv.size);  in btrfs_destroy_inode()
7943 	WARN_ON(inode->outstanding_extents);  in btrfs_destroy_inode()
7944 	if (!S_ISDIR(vfs_inode->i_mode)) {  in btrfs_destroy_inode()
7945 		WARN_ON(inode->delalloc_bytes);  in btrfs_destroy_inode()
7946 		WARN_ON(inode->new_delalloc_bytes);  in btrfs_destroy_inode()
7947 		WARN_ON(inode->csum_bytes);  in btrfs_destroy_inode()
7950 		WARN_ON(inode->defrag_bytes);  in btrfs_destroy_inode()
7967 		ordered = btrfs_lookup_first_ordered_extent(inode, (u64)-1);  in btrfs_destroy_inode()
7971 			btrfs_err(root->fs_info,  in btrfs_destroy_inode()
7973 				  ordered->file_offset, ordered->num_bytes);  in btrfs_destroy_inode()
7976 				btrfs_lockdep_acquire(root->fs_info, btrfs_ordered_extent);  in btrfs_destroy_inode()
7985 	btrfs_drop_extent_map_range(inode, 0, (u64)-1, false);  in btrfs_destroy_inode()
7986 	btrfs_inode_clear_file_extent_range(inode, 0, (u64)-1);  in btrfs_destroy_inode()
7987 	btrfs_put_root(inode->root);  in btrfs_destroy_inode()
7992 	struct btrfs_root *root = BTRFS_I(inode)->root;  in btrfs_drop_inode()
7998 	if (btrfs_root_refs(&root->root_item) == 0)  in btrfs_drop_inode()
8008 	inode_init_once(&ei->vfs_inode);  in init_once()
8010 	ei->i_verity_info = NULL;  in init_once()
8031 		return -ENOMEM;  in btrfs_init_cachep()
8042 	struct inode *inode = d_inode(path->dentry);  in btrfs_getattr()
8043 	u32 blocksize = btrfs_sb(inode->i_sb)->sectorsize;  in btrfs_getattr()
8044 	u32 bi_flags = BTRFS_I(inode)->flags;  in btrfs_getattr()
8045 	u32 bi_ro_flags = BTRFS_I(inode)->ro_flags;  in btrfs_getattr()
8047 	stat->result_mask |= STATX_BTIME;  in btrfs_getattr()
8048 	stat->btime.tv_sec = BTRFS_I(inode)->i_otime_sec;  in btrfs_getattr()
8049 	stat->btime.tv_nsec = BTRFS_I(inode)->i_otime_nsec;  in btrfs_getattr()
8051 		stat->attributes |= STATX_ATTR_APPEND;  in btrfs_getattr()
8053 		stat->attributes |= STATX_ATTR_COMPRESSED;  in btrfs_getattr()
8055 		stat->attributes |= STATX_ATTR_IMMUTABLE;  in btrfs_getattr()
8057 		stat->attributes |= STATX_ATTR_NODUMP;  in btrfs_getattr()
8059 		stat->attributes |= STATX_ATTR_VERITY;  in btrfs_getattr()
8061 	stat->attributes_mask |= (STATX_ATTR_APPEND |  in btrfs_getattr()
8067 	stat->dev = BTRFS_I(inode)->root->anon_dev;  in btrfs_getattr()
8069 	stat->subvol = btrfs_root_id(BTRFS_I(inode)->root);  in btrfs_getattr()
8070 	stat->result_mask |= STATX_SUBVOL;  in btrfs_getattr()
8072 	spin_lock(&BTRFS_I(inode)->lock);  in btrfs_getattr()
8073 	delalloc_bytes = BTRFS_I(inode)->new_delalloc_bytes;  in btrfs_getattr()
8075 	spin_unlock(&BTRFS_I(inode)->lock);  in btrfs_getattr()
8076 	stat->blocks = (ALIGN(inode_bytes, blocksize) +  in btrfs_getattr()
8089 	struct btrfs_root *root = BTRFS_I(old_dir)->root;  in btrfs_rename_exchange()
8090 	struct btrfs_root *dest = BTRFS_I(new_dir)->root;  in btrfs_rename_exchange()
8091 	struct inode *new_inode = new_dentry->d_inode;  in btrfs_rename_exchange()
8092 	struct inode *old_inode = old_dentry->d_inode;  in btrfs_rename_exchange()
8107 	 * For non-subvolumes allow exchange only within one subvolume, in the  in btrfs_rename_exchange()
8114 		return -EXDEV;  in btrfs_rename_exchange()
8116 	ret = fscrypt_setup_filename(old_dir, &old_dentry->d_name, 0, &old_fname);  in btrfs_rename_exchange()
8120 	ret = fscrypt_setup_filename(new_dir, &new_dentry->d_name, 0, &new_fname);  in btrfs_rename_exchange()
8132 		down_read(&fs_info->subvol_sem);  in btrfs_rename_exchange()
8188 	BTRFS_I(old_inode)->dir_index = 0ULL;  in btrfs_rename_exchange()
8189 	BTRFS_I(new_inode)->dir_index = 0ULL;  in btrfs_rename_exchange()
8251 	if (old_dentry->d_parent != new_dentry->d_parent) {  in btrfs_rename_exchange()
8267 					   BTRFS_I(old_dentry->d_inode),  in btrfs_rename_exchange()
8289 					   BTRFS_I(new_dentry->d_inode),  in btrfs_rename_exchange()
8316 	if (old_inode->i_nlink == 1)  in btrfs_rename_exchange()
8317 		BTRFS_I(old_inode)->dir_index = old_idx;  in btrfs_rename_exchange()
8318 	if (new_inode->i_nlink == 1)  in btrfs_rename_exchange()
8319 		BTRFS_I(new_inode)->dir_index = new_idx;  in btrfs_rename_exchange()
8329 				   old_rename_ctx.index, new_dentry->d_parent);  in btrfs_rename_exchange()
8331 				   new_rename_ctx.index, old_dentry->d_parent);  in btrfs_rename_exchange()
8344 		up_read(&fs_info->subvol_sem);  in btrfs_rename_exchange()
8356 	inode = new_inode(dir->i_sb);  in new_whiteout_inode()
8360 		inode->i_op = &btrfs_special_inode_operations;  in new_whiteout_inode()
8361 		init_special_inode(inode, inode->i_mode, WHITEOUT_DEV);  in new_whiteout_inode()
8378 	struct btrfs_root *root = BTRFS_I(old_dir)->root;  in btrfs_rename()
8379 	struct btrfs_root *dest = BTRFS_I(new_dir)->root;  in btrfs_rename()
8391 		return -EPERM;  in btrfs_rename()
8395 		return -EXDEV;  in btrfs_rename()
8399 		return -ENOTEMPTY;  in btrfs_rename()
8401 	if (S_ISDIR(old_inode->i_mode) && new_inode &&  in btrfs_rename()
8402 	    new_inode->i_size > BTRFS_EMPTY_DIR_SIZE)  in btrfs_rename()
8403 		return -ENOTEMPTY;  in btrfs_rename()
8405 	ret = fscrypt_setup_filename(old_dir, &old_dentry->d_name, 0, &old_fname);  in btrfs_rename()
8409 	ret = fscrypt_setup_filename(new_dir, &new_dentry->d_name, 0, &new_fname);  in btrfs_rename()
8416 	ret = btrfs_check_dir_item_collision(dest, new_dir->i_ino, &new_fname.disk_name);  in btrfs_rename()
8418 		if (ret == -EEXIST) {  in btrfs_rename()
8425 			/* maybe -EOVERFLOW */  in btrfs_rename()
8435 	if (new_inode && S_ISREG(old_inode->i_mode) && new_inode->i_size)  in btrfs_rename()
8436 		filemap_flush(old_inode->i_mapping);  in btrfs_rename()
8441 			ret = -ENOMEM;  in btrfs_rename()
8454 		down_read(&fs_info->subvol_sem);  in btrfs_rename()
8506 	BTRFS_I(old_inode)->dir_index = 0ULL;  in btrfs_rename()
8546 	if (old_dentry->d_parent != new_dentry->d_parent)  in btrfs_rename()
8580 			BUG_ON(new_inode->i_nlink == 0);  in btrfs_rename()
8590 		if (new_inode->i_nlink == 0) {  in btrfs_rename()
8607 	if (old_inode->i_nlink == 1)  in btrfs_rename()
8608 		BTRFS_I(old_inode)->dir_index = index;  in btrfs_rename()
8612 				   rename_ctx.index, new_dentry->d_parent);  in btrfs_rename()
8634 		up_read(&fs_info->subvol_sem);  in btrfs_rename()
8653 		return -EINVAL;  in btrfs_rename2()
8662 	btrfs_btree_balance_dirty(BTRFS_I(new_dir)->root->fs_info);  in btrfs_rename2()
8681 	inode = delalloc_work->inode;  in btrfs_run_delalloc_work()
8682 	filemap_flush(inode->i_mapping);  in btrfs_run_delalloc_work()
8684 				&BTRFS_I(inode)->runtime_flags))  in btrfs_run_delalloc_work()
8685 		filemap_flush(inode->i_mapping);  in btrfs_run_delalloc_work()
8688 	complete(&delalloc_work->completion);  in btrfs_run_delalloc_work()
8699 	init_completion(&work->completion);  in btrfs_alloc_delalloc_work()
8700 	INIT_LIST_HEAD(&work->list);  in btrfs_alloc_delalloc_work()
8701 	work->inode = inode;  in btrfs_alloc_delalloc_work()
8702 	btrfs_init_work(&work->work, btrfs_run_delalloc_work, NULL);  in btrfs_alloc_delalloc_work()
8719 	bool full_flush = wbc->nr_to_write == LONG_MAX;  in start_delalloc_inodes()
8721 	mutex_lock(&root->delalloc_mutex);  in start_delalloc_inodes()
8722 	spin_lock(&root->delalloc_lock);  in start_delalloc_inodes()
8723 	list_splice_init(&root->delalloc_inodes, &splice);  in start_delalloc_inodes()
8730 		list_move_tail(&inode->delalloc_inodes, &root->delalloc_inodes);  in start_delalloc_inodes()
8733 		    test_bit(BTRFS_INODE_NO_DELALLOC_FLUSH, &inode->runtime_flags))  in start_delalloc_inodes()
8736 		tmp_inode = igrab(&inode->vfs_inode);  in start_delalloc_inodes()
8738 			cond_resched_lock(&root->delalloc_lock);  in start_delalloc_inodes()
8741 		spin_unlock(&root->delalloc_lock);  in start_delalloc_inodes()
8744 			set_bit(BTRFS_INODE_SNAPSHOT_FLUSH, &inode->runtime_flags);  in start_delalloc_inodes()
8746 			work = btrfs_alloc_delalloc_work(&inode->vfs_inode);  in start_delalloc_inodes()
8748 				iput(&inode->vfs_inode);  in start_delalloc_inodes()
8749 				ret = -ENOMEM;  in start_delalloc_inodes()
8752 			list_add_tail(&work->list, &works);  in start_delalloc_inodes()
8753 			btrfs_queue_work(root->fs_info->flush_workers,  in start_delalloc_inodes()
8754 					 &work->work);  in start_delalloc_inodes()
8756 			ret = filemap_fdatawrite_wbc(inode->vfs_inode.i_mapping, wbc);  in start_delalloc_inodes()
8758 			if (ret || wbc->nr_to_write <= 0)  in start_delalloc_inodes()
8762 		spin_lock(&root->delalloc_lock);  in start_delalloc_inodes()
8764 	spin_unlock(&root->delalloc_lock);  in start_delalloc_inodes()
8768 		list_del_init(&work->list);  in start_delalloc_inodes()
8769 		wait_for_completion(&work->completion);  in start_delalloc_inodes()
8774 		spin_lock(&root->delalloc_lock);  in start_delalloc_inodes()
8775 		list_splice_tail(&splice, &root->delalloc_inodes);  in start_delalloc_inodes()
8776 		spin_unlock(&root->delalloc_lock);  in start_delalloc_inodes()
8778 	mutex_unlock(&root->delalloc_mutex);  in start_delalloc_inodes()
8790 	struct btrfs_fs_info *fs_info = root->fs_info;  in btrfs_start_delalloc_snapshot()
8793 		return -EROFS;  in btrfs_start_delalloc_snapshot()
8812 		return -EROFS;  in btrfs_start_delalloc_roots()
8814 	mutex_lock(&fs_info->delalloc_root_mutex);  in btrfs_start_delalloc_roots()
8815 	spin_lock(&fs_info->delalloc_root_lock);  in btrfs_start_delalloc_roots()
8816 	list_splice_init(&fs_info->delalloc_roots, &splice);  in btrfs_start_delalloc_roots()
8829 		list_move_tail(&root->delalloc_root,  in btrfs_start_delalloc_roots()
8830 			       &fs_info->delalloc_roots);  in btrfs_start_delalloc_roots()
8831 		spin_unlock(&fs_info->delalloc_root_lock);  in btrfs_start_delalloc_roots()
8837 		spin_lock(&fs_info->delalloc_root_lock);  in btrfs_start_delalloc_roots()
8839 	spin_unlock(&fs_info->delalloc_root_lock);  in btrfs_start_delalloc_roots()
8844 		spin_lock(&fs_info->delalloc_root_lock);  in btrfs_start_delalloc_roots()
8845 		list_splice_tail(&splice, &fs_info->delalloc_roots);  in btrfs_start_delalloc_roots()
8846 		spin_unlock(&fs_info->delalloc_root_lock);  in btrfs_start_delalloc_roots()
8848 	mutex_unlock(&fs_info->delalloc_root_mutex);  in btrfs_start_delalloc_roots()
8857 	struct btrfs_root *root = BTRFS_I(dir)->root;  in btrfs_symlink()
8879 	    name_len >= fs_info->sectorsize)  in btrfs_symlink()
8880 		return -ENAMETOOLONG;  in btrfs_symlink()
8882 	inode = new_inode(dir->i_sb);  in btrfs_symlink()
8884 		return -ENOMEM;  in btrfs_symlink()
8886 	inode->i_op = &btrfs_symlink_inode_operations;  in btrfs_symlink()
8888 	inode->i_mapping->a_ops = &btrfs_aops;  in btrfs_symlink()
8911 		ret = -ENOMEM;  in btrfs_symlink()
8929 	leaf = path->nodes[0];  in btrfs_symlink()
8930 	ei = btrfs_item_ptr(leaf, path->slots[0],  in btrfs_symlink()
8932 	btrfs_set_file_extent_generation(leaf, ei, trans->transid);  in btrfs_symlink()
8967 	u64 start = ins->objectid;  in insert_prealloc_file_extent()
8968 	u64 len = ins->offset;  in insert_prealloc_file_extent()
9008 		ret = -ENOMEM;  in insert_prealloc_file_extent()
9013 				     file_offset + len - 1, &extent_info,  in insert_prealloc_file_extent()
9028 	btrfs_qgroup_free_refroot(inode->root->fs_info,  in insert_prealloc_file_extent()
9029 			btrfs_root_id(inode->root), qgroup_released,  in insert_prealloc_file_extent()
9041 	struct btrfs_root *root = BTRFS_I(inode)->root;  in __btrfs_prealloc_file_range()
9047 	u64 last_alloc = (u64)-1;  in __btrfs_prealloc_file_range()
9050 	u64 end = start + num_bytes - 1;  in __btrfs_prealloc_file_range()
9071 		 * ->bytes_may_use to ->bytes_reserved.  Any error that happens  in __btrfs_prealloc_file_range()
9098 					    cur_offset + ins.offset - 1, false);  in __btrfs_prealloc_file_range()
9103 		em->start = cur_offset;  in __btrfs_prealloc_file_range()
9104 		em->len = ins.offset;  in __btrfs_prealloc_file_range()
9105 		em->disk_bytenr = ins.objectid;  in __btrfs_prealloc_file_range()
9106 		em->offset = 0;  in __btrfs_prealloc_file_range()
9107 		em->disk_num_bytes = ins.offset;  in __btrfs_prealloc_file_range()
9108 		em->ram_bytes = ins.offset;  in __btrfs_prealloc_file_range()
9109 		em->flags |= EXTENT_FLAG_PREALLOC;  in __btrfs_prealloc_file_range()
9110 		em->generation = trans->transid;  in __btrfs_prealloc_file_range()
9115 		num_bytes -= ins.offset;  in __btrfs_prealloc_file_range()
9121 		BTRFS_I(inode)->flags |= BTRFS_INODE_PREALLOC;  in __btrfs_prealloc_file_range()
9123 		    (actual_len > inode->i_size) &&  in __btrfs_prealloc_file_range()
9124 		    (cur_offset > inode->i_size)) {  in __btrfs_prealloc_file_range()
9149 			end - clear_offset + 1);  in __btrfs_prealloc_file_range()
9174 	struct btrfs_root *root = BTRFS_I(inode)->root;  in btrfs_permission()
9175 	umode_t mode = inode->i_mode;  in btrfs_permission()
9180 			return -EROFS;  in btrfs_permission()
9181 		if (BTRFS_I(inode)->flags & BTRFS_INODE_READONLY)  in btrfs_permission()
9182 			return -EACCES;  in btrfs_permission()
9192 	struct btrfs_root *root = BTRFS_I(dir)->root;  in btrfs_tmpfile()
9196 		.dentry = file->f_path.dentry,  in btrfs_tmpfile()
9202 	inode = new_inode(dir->i_sb);  in btrfs_tmpfile()
9204 		return -ENOMEM;  in btrfs_tmpfile()
9206 	inode->i_fop = &btrfs_file_operations;  in btrfs_tmpfile()
9207 	inode->i_op = &btrfs_file_inode_operations;  in btrfs_tmpfile()
9208 	inode->i_mapping->a_ops = &btrfs_aops;  in btrfs_tmpfile()
9228 	 *    d_tmpfile() -> inode_dec_link_count() -> drop_nlink()  in btrfs_tmpfile()
9261 		if (fs_info->sectorsize < SZ_4K || fs_info->sectorsize > SZ_64K)  in btrfs_encoded_io_compression_from_extent()
9262 			return -EINVAL;  in btrfs_encoded_io_compression_from_extent()
9264 		       (fs_info->sectorsize_bits - 12);  in btrfs_encoded_io_compression_from_extent()
9268 		return -EUCLEAN;  in btrfs_encoded_io_compression_from_extent()
9281 	struct btrfs_inode *inode = BTRFS_I(file_inode(iocb->ki_filp));  in btrfs_encoded_read_inline()
9282 	struct btrfs_root *root = inode->root;  in btrfs_encoded_read_inline()
9283 	struct btrfs_fs_info *fs_info = root->fs_info;  in btrfs_encoded_read_inline()
9284 	struct extent_io_tree *io_tree = &inode->io_tree;  in btrfs_encoded_read_inline()
9292 	const bool nowait = (iocb->ki_flags & IOCB_NOWAIT);  in btrfs_encoded_read_inline()
9296 		return -ENOMEM;  in btrfs_encoded_read_inline()
9298 	path->nowait = nowait;  in btrfs_encoded_read_inline()
9305 			return -EIO;  in btrfs_encoded_read_inline()
9309 	leaf = path->nodes[0];  in btrfs_encoded_read_inline()
9310 	item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_file_extent_item);  in btrfs_encoded_read_inline()
9315 	encoded->len = min_t(u64, extent_start + ram_bytes,  in btrfs_encoded_read_inline()
9316 			     inode->vfs_inode.i_size) - iocb->ki_pos;  in btrfs_encoded_read_inline()
9321 	encoded->compression = ret;  in btrfs_encoded_read_inline()
9322 	if (encoded->compression) {  in btrfs_encoded_read_inline()
9326 								path->slots[0]);  in btrfs_encoded_read_inline()
9328 			return -ENOBUFS;  in btrfs_encoded_read_inline()
9331 		encoded->unencoded_len = ram_bytes;  in btrfs_encoded_read_inline()
9332 		encoded->unencoded_offset = iocb->ki_pos - extent_start;  in btrfs_encoded_read_inline()
9334 		count = min_t(u64, count, encoded->len);  in btrfs_encoded_read_inline()
9335 		encoded->len = count;  in btrfs_encoded_read_inline()
9336 		encoded->unencoded_len = count;  in btrfs_encoded_read_inline()
9337 		ptr += iocb->ki_pos - extent_start;  in btrfs_encoded_read_inline()
9342 		return -ENOMEM;  in btrfs_encoded_read_inline()
9352 		ret = -EFAULT;  in btrfs_encoded_read_inline()
9367 	struct btrfs_encoded_read_private *priv = bbio->private;  in btrfs_encoded_read_endio()
9369 	if (bbio->bio.bi_status) {  in btrfs_encoded_read_endio()
9377 		WRITE_ONCE(priv->status, bbio->bio.bi_status);  in btrfs_encoded_read_endio()
9379 	if (refcount_dec_and_test(&priv->pending_refs)) {  in btrfs_encoded_read_endio()
9380 		int err = blk_status_to_errno(READ_ONCE(priv->status));  in btrfs_encoded_read_endio()
9382 		if (priv->uring_ctx) {  in btrfs_encoded_read_endio()
9383 			btrfs_uring_read_extent_endio(priv->uring_ctx, err);  in btrfs_encoded_read_endio()
9386 			complete(priv->sync_reads);  in btrfs_encoded_read_endio()
9389 	bio_put(&bbio->bio);  in btrfs_encoded_read_endio()
9396 	struct btrfs_fs_info *fs_info = inode->root->fs_info;  in btrfs_encoded_read_regular_fill_pages()
9410 			return -ENOMEM;  in btrfs_encoded_read_regular_fill_pages()
9414 		priv->sync_reads = &sync_reads;  in btrfs_encoded_read_regular_fill_pages()
9417 	refcount_set(&priv->pending_refs, 1);  in btrfs_encoded_read_regular_fill_pages()
9418 	priv->status = 0;  in btrfs_encoded_read_regular_fill_pages()
9419 	priv->uring_ctx = uring_ctx;  in btrfs_encoded_read_regular_fill_pages()
9423 	bbio->bio.bi_iter.bi_sector = disk_bytenr >> SECTOR_SHIFT;  in btrfs_encoded_read_regular_fill_pages()
9424 	bbio->inode = inode;  in btrfs_encoded_read_regular_fill_pages()
9429 		if (bio_add_page(&bbio->bio, pages[i], bytes, 0) < bytes) {  in btrfs_encoded_read_regular_fill_pages()
9430 			refcount_inc(&priv->pending_refs);  in btrfs_encoded_read_regular_fill_pages()
9435 			bbio->bio.bi_iter.bi_sector = disk_bytenr >> SECTOR_SHIFT;  in btrfs_encoded_read_regular_fill_pages()
9436 			bbio->inode = inode;  in btrfs_encoded_read_regular_fill_pages()
9442 		disk_io_size -= bytes;  in btrfs_encoded_read_regular_fill_pages()
9445 	refcount_inc(&priv->pending_refs);  in btrfs_encoded_read_regular_fill_pages()
9449 		if (refcount_dec_and_test(&priv->pending_refs)) {  in btrfs_encoded_read_regular_fill_pages()
9450 			ret = blk_status_to_errno(READ_ONCE(priv->status));  in btrfs_encoded_read_regular_fill_pages()
9456 		return -EIOCBQUEUED;  in btrfs_encoded_read_regular_fill_pages()
9458 		if (!refcount_dec_and_test(&priv->pending_refs))  in btrfs_encoded_read_regular_fill_pages()
9461 		return blk_status_to_errno(READ_ONCE(priv->status));  in btrfs_encoded_read_regular_fill_pages()
9471 	struct btrfs_inode *inode = BTRFS_I(file_inode(iocb->ki_filp));  in btrfs_encoded_read_regular()
9472 	struct extent_io_tree *io_tree = &inode->io_tree;  in btrfs_encoded_read_regular()
9482 		return -ENOMEM;  in btrfs_encoded_read_regular()
9485 		ret = -ENOMEM;  in btrfs_encoded_read_regular()
9502 		i = (iocb->ki_pos - start) >> PAGE_SHIFT;  in btrfs_encoded_read_regular()
9503 		page_offset = (iocb->ki_pos - start) & (PAGE_SIZE - 1);  in btrfs_encoded_read_regular()
9507 		size_t bytes = min_t(size_t, count - cur,  in btrfs_encoded_read_regular()
9508 				     PAGE_SIZE - page_offset);  in btrfs_encoded_read_regular()
9512 			ret = -EFAULT;  in btrfs_encoded_read_regular()
9534 	struct btrfs_inode *inode = BTRFS_I(file_inode(iocb->ki_filp));  in btrfs_encoded_read()
9535 	struct btrfs_fs_info *fs_info = inode->root->fs_info;  in btrfs_encoded_read()
9536 	struct extent_io_tree *io_tree = &inode->io_tree;  in btrfs_encoded_read()
9541 	const bool nowait = (iocb->ki_flags & IOCB_NOWAIT);  in btrfs_encoded_read()
9544 	file_accessed(iocb->ki_filp);  in btrfs_encoded_read()
9551 	if (iocb->ki_pos >= inode->vfs_inode.i_size) {  in btrfs_encoded_read()
9555 	start = ALIGN_DOWN(iocb->ki_pos, fs_info->sectorsize);  in btrfs_encoded_read()
9557 	 * We don't know how long the extent containing iocb->ki_pos is, but if  in btrfs_encoded_read()
9560 	lockend = start + BTRFS_MAX_UNCOMPRESSED - 1;  in btrfs_encoded_read()
9565 		if (filemap_range_needs_writeback(inode->vfs_inode.i_mapping,  in btrfs_encoded_read()
9567 			ret = -EAGAIN;  in btrfs_encoded_read()
9572 			ret = -EAGAIN;  in btrfs_encoded_read()
9577 						     lockend - start + 1);  in btrfs_encoded_read()
9581 			ret = -EAGAIN;  in btrfs_encoded_read()
9589 						       lockend - start + 1);  in btrfs_encoded_read()
9595 							     lockend - start + 1);  in btrfs_encoded_read()
9604 	em = btrfs_get_extent(inode, NULL, start, lockend - start + 1);  in btrfs_encoded_read()
9610 	if (em->disk_bytenr == EXTENT_MAP_INLINE) {  in btrfs_encoded_read()
9611 		u64 extent_start = em->start;  in btrfs_encoded_read()
9629 	encoded->len = min_t(u64, btrfs_extent_map_end(em),  in btrfs_encoded_read()
9630 			     inode->vfs_inode.i_size) - iocb->ki_pos;  in btrfs_encoded_read()
9631 	if (em->disk_bytenr == EXTENT_MAP_HOLE ||  in btrfs_encoded_read()
9632 	    (em->flags & EXTENT_FLAG_PREALLOC)) {  in btrfs_encoded_read()
9634 		count = min_t(u64, count, encoded->len);  in btrfs_encoded_read()
9635 		encoded->len = count;  in btrfs_encoded_read()
9636 		encoded->unencoded_len = count;  in btrfs_encoded_read()
9638 		*disk_bytenr = em->disk_bytenr;  in btrfs_encoded_read()
9643 		if (em->disk_num_bytes > count) {  in btrfs_encoded_read()
9644 			ret = -ENOBUFS;  in btrfs_encoded_read()
9647 		*disk_io_size = em->disk_num_bytes;  in btrfs_encoded_read()
9648 		count = em->disk_num_bytes;  in btrfs_encoded_read()
9649 		encoded->unencoded_len = em->ram_bytes;  in btrfs_encoded_read()
9650 		encoded->unencoded_offset = iocb->ki_pos - (em->start - em->offset);  in btrfs_encoded_read()
9655 		encoded->compression = ret;  in btrfs_encoded_read()
9657 		*disk_bytenr = btrfs_extent_map_block_start(em) + (start - em->start);  in btrfs_encoded_read()
9658 		if (encoded->len > count)  in btrfs_encoded_read()
9659 			encoded->len = count;  in btrfs_encoded_read()
9664 		*disk_io_size = min(lockend + 1, iocb->ki_pos + encoded->len) - start;  in btrfs_encoded_read()
9665 		count = start + *disk_io_size - iocb->ki_pos;  in btrfs_encoded_read()
9666 		encoded->len = count;  in btrfs_encoded_read()
9667 		encoded->unencoded_len = count;  in btrfs_encoded_read()
9668 		*disk_io_size = ALIGN(*disk_io_size, fs_info->sectorsize);  in btrfs_encoded_read()
9679 			ret = -EFAULT;  in btrfs_encoded_read()
9681 		ret = -EIOCBQUEUED;  in btrfs_encoded_read()
9689 	if (!unlocked && ret != -EIOCBQUEUED)  in btrfs_encoded_read()
9692 	if (!unlocked && ret != -EIOCBQUEUED)  in btrfs_encoded_read()
9700 	struct btrfs_inode *inode = BTRFS_I(file_inode(iocb->ki_filp));  in btrfs_do_encoded_write()
9701 	struct btrfs_root *root = inode->root;  in btrfs_do_encoded_write()
9702 	struct btrfs_fs_info *fs_info = root->fs_info;  in btrfs_do_encoded_write()
9703 	struct extent_io_tree *io_tree = &inode->io_tree;  in btrfs_do_encoded_write()
9719 	switch (encoded->compression) {  in btrfs_do_encoded_write()
9732 		if (encoded->compression -  in btrfs_do_encoded_write()
9734 		    fs_info->sectorsize_bits)  in btrfs_do_encoded_write()
9735 			return -EINVAL;  in btrfs_do_encoded_write()
9739 		return -EINVAL;  in btrfs_do_encoded_write()
9741 	if (encoded->encryption != BTRFS_ENCODED_IO_ENCRYPTION_NONE)  in btrfs_do_encoded_write()
9742 		return -EINVAL;  in btrfs_do_encoded_write()
9748 	if (inode->flags & BTRFS_INODE_NODATASUM)  in btrfs_do_encoded_write()
9749 		return -EINVAL;  in btrfs_do_encoded_write()
9754 	if (encoded->unencoded_len > BTRFS_MAX_UNCOMPRESSED ||  in btrfs_do_encoded_write()
9756 		return -EINVAL;  in btrfs_do_encoded_write()
9771 	if (orig_count >= encoded->unencoded_len)  in btrfs_do_encoded_write()
9772 		return -EINVAL;  in btrfs_do_encoded_write()
9775 	start = iocb->ki_pos;  in btrfs_do_encoded_write()
9776 	if (!IS_ALIGNED(start, fs_info->sectorsize))  in btrfs_do_encoded_write()
9777 		return -EINVAL;  in btrfs_do_encoded_write()
9784 	if (start + encoded->len < inode->vfs_inode.i_size &&  in btrfs_do_encoded_write()
9785 	    !IS_ALIGNED(start + encoded->len, fs_info->sectorsize))  in btrfs_do_encoded_write()
9786 		return -EINVAL;  in btrfs_do_encoded_write()
9788 	/* Finally, the offset in the unencoded data must be sector-aligned. */  in btrfs_do_encoded_write()
9789 	if (!IS_ALIGNED(encoded->unencoded_offset, fs_info->sectorsize))  in btrfs_do_encoded_write()
9790 		return -EINVAL;  in btrfs_do_encoded_write()
9792 	num_bytes = ALIGN(encoded->len, fs_info->sectorsize);  in btrfs_do_encoded_write()
9793 	ram_bytes = ALIGN(encoded->unencoded_len, fs_info->sectorsize);  in btrfs_do_encoded_write()
9794 	end = start + num_bytes - 1;  in btrfs_do_encoded_write()
9798 	 * sector-aligned. For convenience, we extend it with zeroes if it  in btrfs_do_encoded_write()
9801 	disk_num_bytes = ALIGN(orig_count, fs_info->sectorsize);  in btrfs_do_encoded_write()
9805 		return -ENOMEM;  in btrfs_do_encoded_write()
9812 			ret = -ENOMEM;  in btrfs_do_encoded_write()
9818 			ret = -EFAULT;  in btrfs_do_encoded_write()
9822 			memset(kaddr + bytes, 0, PAGE_SIZE - bytes);  in btrfs_do_encoded_write()
9832 		ret = invalidate_inode_pages2_range(inode->vfs_inode.i_mapping,  in btrfs_do_encoded_write()
9840 		    !filemap_range_has_page(inode->vfs_inode.i_mapping, start, end))  in btrfs_do_encoded_write()
9849 	 * We don't use the higher-level delalloc space functions because our  in btrfs_do_encoded_write()
9864 	if (encoded->unencoded_len == encoded->len &&  in btrfs_do_encoded_write()
9865 	    encoded->unencoded_offset == 0 &&  in btrfs_do_encoded_write()
9866 	    can_cow_file_range_inline(inode, start, encoded->len, orig_count)) {  in btrfs_do_encoded_write()
9867 		ret = __cow_file_range_inline(inode, encoded->len,  in btrfs_do_encoded_write()
9887 	file_extent.offset = encoded->unencoded_offset;  in btrfs_do_encoded_write()
9906 	if (start + encoded->len > inode->vfs_inode.i_size)  in btrfs_do_encoded_write()
9907 		i_size_write(&inode->vfs_inode, start + encoded->len);  in btrfs_do_encoded_write()
9943 		iocb->ki_pos += encoded->len;  in btrfs_do_encoded_write()
9956 	struct btrfs_fs_info *fs_info = BTRFS_I(inode)->root->fs_info;  in btrfs_add_swapfile_pin()
9963 		return -ENOMEM;  in btrfs_add_swapfile_pin()
9964 	sp->ptr = ptr;  in btrfs_add_swapfile_pin()
9965 	sp->inode = inode;  in btrfs_add_swapfile_pin()
9966 	sp->is_block_group = is_block_group;  in btrfs_add_swapfile_pin()
9967 	sp->bg_extent_count = 1;  in btrfs_add_swapfile_pin()
9969 	spin_lock(&fs_info->swapfile_pins_lock);  in btrfs_add_swapfile_pin()
9970 	p = &fs_info->swapfile_pins.rb_node;  in btrfs_add_swapfile_pin()
9974 		if (sp->ptr < entry->ptr ||  in btrfs_add_swapfile_pin()
9975 		    (sp->ptr == entry->ptr && sp->inode < entry->inode)) {  in btrfs_add_swapfile_pin()
9976 			p = &(*p)->rb_left;  in btrfs_add_swapfile_pin()
9977 		} else if (sp->ptr > entry->ptr ||  in btrfs_add_swapfile_pin()
9978 			   (sp->ptr == entry->ptr && sp->inode > entry->inode)) {  in btrfs_add_swapfile_pin()
9979 			p = &(*p)->rb_right;  in btrfs_add_swapfile_pin()
9982 				entry->bg_extent_count++;  in btrfs_add_swapfile_pin()
9983 			spin_unlock(&fs_info->swapfile_pins_lock);  in btrfs_add_swapfile_pin()
9988 	rb_link_node(&sp->node, parent, p);  in btrfs_add_swapfile_pin()
9989 	rb_insert_color(&sp->node, &fs_info->swapfile_pins);  in btrfs_add_swapfile_pin()
9990 	spin_unlock(&fs_info->swapfile_pins_lock);  in btrfs_add_swapfile_pin()
9997 	struct btrfs_fs_info *fs_info = BTRFS_I(inode)->root->fs_info;  in btrfs_free_swapfile_pins()
10001 	spin_lock(&fs_info->swapfile_pins_lock);  in btrfs_free_swapfile_pins()
10002 	node = rb_first(&fs_info->swapfile_pins);  in btrfs_free_swapfile_pins()
10006 		if (sp->inode == inode) {  in btrfs_free_swapfile_pins()
10007 			rb_erase(&sp->node, &fs_info->swapfile_pins);  in btrfs_free_swapfile_pins()
10008 			if (sp->is_block_group) {  in btrfs_free_swapfile_pins()
10009 				btrfs_dec_block_group_swap_extents(sp->ptr,  in btrfs_free_swapfile_pins()
10010 							   sp->bg_extent_count);  in btrfs_free_swapfile_pins()
10011 				btrfs_put_block_group(sp->ptr);  in btrfs_free_swapfile_pins()
10017 	spin_unlock(&fs_info->swapfile_pins_lock);  in btrfs_free_swapfile_pins()
10043 	if (bsi->nr_pages >= sis->max)  in btrfs_add_swap_extent()
10046 	max_pages = sis->max - bsi->nr_pages;  in btrfs_add_swap_extent()
10047 	first_ppage = PAGE_ALIGN(bsi->block_start) >> PAGE_SHIFT;  in btrfs_add_swap_extent()
10048 	next_ppage = PAGE_ALIGN_DOWN(bsi->block_start + bsi->block_len) >> PAGE_SHIFT;  in btrfs_add_swap_extent()
10052 	nr_pages = next_ppage - first_ppage;  in btrfs_add_swap_extent()
10056 	if (bsi->start == 0)  in btrfs_add_swap_extent()
10058 	if (bsi->lowest_ppage > first_ppage_reported)  in btrfs_add_swap_extent()
10059 		bsi->lowest_ppage = first_ppage_reported;  in btrfs_add_swap_extent()
10060 	if (bsi->highest_ppage < (next_ppage - 1))  in btrfs_add_swap_extent()
10061 		bsi->highest_ppage = next_ppage - 1;  in btrfs_add_swap_extent()
10063 	ret = add_swap_extent(sis, bsi->nr_pages, nr_pages, first_ppage);  in btrfs_add_swap_extent()
10066 	bsi->nr_extents += ret;  in btrfs_add_swap_extent()
10067 	bsi->nr_pages += nr_pages;  in btrfs_add_swap_extent()
10076 	atomic_dec(&BTRFS_I(inode)->root->nr_swapfiles);  in btrfs_swap_deactivate()
10083 	struct btrfs_root *root = BTRFS_I(inode)->root;  in btrfs_swap_activate()
10084 	struct btrfs_fs_info *fs_info = root->fs_info;  in btrfs_swap_activate()
10085 	struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;  in btrfs_swap_activate()
10090 		.lowest_ppage = (sector_t)-1ULL,  in btrfs_swap_activate()
10105 	down_write(&BTRFS_I(inode)->i_mmap_lock);  in btrfs_swap_activate()
10112 	ret = btrfs_wait_ordered_range(BTRFS_I(inode), 0, (u64)-1);  in btrfs_swap_activate()
10119 	if (BTRFS_I(inode)->flags & BTRFS_INODE_COMPRESS) {  in btrfs_swap_activate()
10121 		ret = -EINVAL;  in btrfs_swap_activate()
10124 	if (!(BTRFS_I(inode)->flags & BTRFS_INODE_NODATACOW)) {  in btrfs_swap_activate()
10125 		btrfs_warn(fs_info, "swapfile must not be copy-on-write");  in btrfs_swap_activate()
10126 		ret = -EINVAL;  in btrfs_swap_activate()
10129 	if (!(BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM)) {  in btrfs_swap_activate()
10131 		ret = -EINVAL;  in btrfs_swap_activate()
10138 		ret = -ENOMEM;  in btrfs_swap_activate()
10146 	 * fs_info->swapfile_pins prevents them from running while the swap  in btrfs_swap_activate()
10154 		ret = -EBUSY;  in btrfs_swap_activate()
10165 	if (!btrfs_drew_try_write_lock(&root->snapshot_lock)) {  in btrfs_swap_activate()
10169 		ret = -EINVAL;  in btrfs_swap_activate()
10182 	spin_lock(&root->root_item_lock);  in btrfs_swap_activate()
10184 		spin_unlock(&root->root_item_lock);  in btrfs_swap_activate()
10186 		btrfs_drew_write_unlock(&root->snapshot_lock);  in btrfs_swap_activate()
10191 		ret = -EPERM;  in btrfs_swap_activate()
10194 	atomic_inc(&root->nr_swapfiles);  in btrfs_swap_activate()
10195 	spin_unlock(&root->root_item_lock);  in btrfs_swap_activate()
10197 	isize = ALIGN_DOWN(inode->i_size, fs_info->sectorsize);  in btrfs_swap_activate()
10199 	btrfs_lock_extent(io_tree, 0, isize - 1, &cached_state);  in btrfs_swap_activate()
10225 			ret = -EINVAL;  in btrfs_swap_activate()
10229 		leaf = path->nodes[0];  in btrfs_swap_activate()
10230 		ei = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_file_extent_item);  in btrfs_swap_activate()
10241 			ret = -EINVAL;  in btrfs_swap_activate()
10247 			ret = -EINVAL;  in btrfs_swap_activate()
10254 			ret = -EINVAL;  in btrfs_swap_activate()
10263 			len = isize - key.offset;  in btrfs_swap_activate()
10267 		backref_ctx->curr_leaf_bytenr = leaf->start;  in btrfs_swap_activate()
10284 				   "swapfile must not be copy-on-write");  in btrfs_swap_activate()
10285 			ret = -EINVAL;  in btrfs_swap_activate()
10295 		if (map->type & BTRFS_BLOCK_GROUP_PROFILE_MASK) {  in btrfs_swap_activate()
10298 			ret = -EINVAL;  in btrfs_swap_activate()
10303 			device = map->stripes[0].dev;  in btrfs_swap_activate()
10309 		} else if (device != map->stripes[0].dev) {  in btrfs_swap_activate()
10311 			ret = -EINVAL;  in btrfs_swap_activate()
10315 		physical_block_start = (map->stripes[0].physical +  in btrfs_swap_activate()
10316 					(logical_block_start - map->start));  in btrfs_swap_activate()
10324 			ret = -EINVAL;  in btrfs_swap_activate()
10330 			   "block group for swapfile at %llu is read-only%s",  in btrfs_swap_activate()
10331 			   bg->start,  in btrfs_swap_activate()
10332 			   atomic_read(&fs_info->scrubs_running) ?  in btrfs_swap_activate()
10335 			ret = -EINVAL;  in btrfs_swap_activate()
10363 			ret = -EINTR;  in btrfs_swap_activate()
10377 	btrfs_unlock_extent(io_tree, 0, isize - 1, &cached_state);  in btrfs_swap_activate()
10382 	btrfs_drew_write_unlock(&root->snapshot_lock);  in btrfs_swap_activate()
10387 	up_write(&BTRFS_I(inode)->i_mmap_lock);  in btrfs_swap_activate()
10394 		sis->bdev = device->bdev;  in btrfs_swap_activate()
10395 	*span = bsi.highest_ppage - bsi.lowest_ppage + 1;  in btrfs_swap_activate()
10396 	sis->max = bsi.nr_pages;  in btrfs_swap_activate()
10397 	sis->pages = bsi.nr_pages - 1;  in btrfs_swap_activate()
10408 	return -EOPNOTSUPP;  in btrfs_swap_activate()
10425 	spin_lock(&inode->lock);  in btrfs_update_inode_bytes()
10427 		inode_sub_bytes(&inode->vfs_inode, del_bytes);  in btrfs_update_inode_bytes()
10429 		inode_add_bytes(&inode->vfs_inode, add_bytes);  in btrfs_update_inode_bytes()
10430 	spin_unlock(&inode->lock);  in btrfs_update_inode_bytes()
10449 	struct btrfs_root *root = inode->root;  in btrfs_assert_inode_range_clean()
10455 	ordered = btrfs_lookup_first_ordered_range(inode, start, end + 1 - start);  in btrfs_assert_inode_range_clean()
10457 		btrfs_err(root->fs_info,  in btrfs_assert_inode_range_clean()
10460 			  ordered->file_offset,  in btrfs_assert_inode_range_clean()
10461 			  ordered->file_offset + ordered->num_bytes - 1);  in btrfs_assert_inode_range_clean()
10482 	xa_lock(&root->inodes);  in btrfs_find_first_inode()
10484 		inode = xa_find(&root->inodes, &from, ULONG_MAX, XA_PRESENT);  in btrfs_find_first_inode()
10487 		if (igrab(&inode->vfs_inode))  in btrfs_find_first_inode()
10491 		cond_resched_lock(&root->inodes.xa_lock);  in btrfs_find_first_inode()
10493 	xa_unlock(&root->inodes);  in btrfs_find_first_inode()