Lines Matching +full:oe +full:- +full:extra +full:- +full:delay
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 "print-tree.h"
43 #include "ordered-data.h"
45 #include "tree-log.h"
49 #include "free-space-cache.h"
52 #include "delalloc-space.h"
53 #include "block-group.h"
54 #include "space-info.h"
57 #include "inode-item.h"
60 #include "extent-tree.h"
61 #include "root-tree.h"
63 #include "dir-item.h"
64 #include "file-item.h"
65 #include "uuid-tree.h"
74 #include "raid-stripe-tree.h"
152 struct btrfs_fs_info *fs_info = warn->fs_info; in data_reloc_print_warning_inode()
173 ret = btrfs_search_slot(NULL, local_root, &key, &warn->path, 0, 0); in data_reloc_print_warning_inode()
176 btrfs_release_path(&warn->path); in data_reloc_print_warning_inode()
180 eb = warn->path.nodes[0]; in data_reloc_print_warning_inode()
181 inode_item = btrfs_item_ptr(eb, warn->path.slots[0], struct btrfs_inode_item); in data_reloc_print_warning_inode()
183 btrfs_release_path(&warn->path); in data_reloc_print_warning_inode()
186 ipath = init_ipath(4096, local_root, &warn->path); in data_reloc_print_warning_inode()
193 * -ENOMEM, not a critical error, just output an generic error in data_reloc_print_warning_inode()
198 warn->logical, warn->mirror_num, root, inum, offset); in data_reloc_print_warning_inode()
209 for (int i = 0; i < ipath->fspath->elem_cnt; i++) { in data_reloc_print_warning_inode()
212 warn->logical, warn->mirror_num, root, inum, offset, in data_reloc_print_warning_inode()
213 fs_info->sectorsize, nlink, in data_reloc_print_warning_inode()
214 (char *)(unsigned long)ipath->fspath->val[i]); in data_reloc_print_warning_inode()
224 warn->logical, warn->mirror_num, root, inum, offset, ret); in data_reloc_print_warning_inode()
231 * Do extra user-friendly error output (e.g. lookup all the affected files).
240 struct btrfs_fs_info *fs_info = inode->root->fs_info; in print_data_reloc_error()
245 const u32 csum_size = fs_info->csum_size; in print_data_reloc_error()
251 mutex_lock(&fs_info->reloc_mutex); in print_data_reloc_error()
253 mutex_unlock(&fs_info->reloc_mutex); in print_data_reloc_error()
259 inode->root->root_key.objectid, btrfs_ino(inode), file_off, in print_data_reloc_error()
269 inode->root->root_key.objectid, in print_data_reloc_error()
316 ctx.extent_item_pos = logical - found_key.objectid; in print_data_reloc_error()
332 struct btrfs_root *root = inode->root; in btrfs_print_data_csum_error()
333 const u32 csum_size = root->fs_info->csum_size; in btrfs_print_data_csum_error()
336 if (root->root_key.objectid == BTRFS_DATA_RELOC_TREE_OBJECTID) in btrfs_print_data_csum_error()
341 if (root->root_key.objectid >= BTRFS_LAST_FREE_OBJECTID) { in btrfs_print_data_csum_error()
342 btrfs_warn_rl(root->fs_info, in btrfs_print_data_csum_error()
344 root->root_key.objectid, btrfs_ino(inode), in btrfs_print_data_csum_error()
350 btrfs_warn_rl(root->fs_info, in btrfs_print_data_csum_error()
352 root->root_key.objectid, btrfs_ino(inode), in btrfs_print_data_csum_error()
365 * BTRFS_ILOCK_SHARED - acquire a shared lock on the inode
366 * BTRFS_ILOCK_TRY - try to acquire the lock, if fails on first attempt
367 * return -EAGAIN
368 * BTRFS_ILOCK_MMAP - acquire a write lock on the i_mmap_lock
374 if (!inode_trylock_shared(&inode->vfs_inode)) in btrfs_inode_lock()
375 return -EAGAIN; in btrfs_inode_lock()
379 inode_lock_shared(&inode->vfs_inode); in btrfs_inode_lock()
382 if (!inode_trylock(&inode->vfs_inode)) in btrfs_inode_lock()
383 return -EAGAIN; in btrfs_inode_lock()
387 inode_lock(&inode->vfs_inode); in btrfs_inode_lock()
390 down_write(&inode->i_mmap_lock); in btrfs_inode_lock()
403 up_write(&inode->i_mmap_lock); in btrfs_inode_unlock()
405 inode_unlock_shared(&inode->vfs_inode); in btrfs_inode_unlock()
407 inode_unlock(&inode->vfs_inode); in btrfs_inode_unlock()
425 unsigned long end_index = (offset + bytes - 1) >> PAGE_SHIFT; in btrfs_cleanup_ordered_extents()
431 page_end = page_start + PAGE_SIZE - 1; in btrfs_cleanup_ordered_extents()
449 page = find_get_page(inode->vfs_inode.i_mapping, index); in btrfs_cleanup_ordered_extents()
459 btrfs_folio_clamp_clear_ordered(inode->root->fs_info, in btrfs_cleanup_ordered_extents()
474 if (page_start >= offset && page_end <= (offset + bytes - 1)) { in btrfs_cleanup_ordered_extents()
475 bytes = offset + bytes - page_offset(locked_page) - PAGE_SIZE; in btrfs_cleanup_ordered_extents()
490 if (args->default_acl) { in btrfs_init_inode_security()
491 err = __btrfs_set_acl(trans, args->inode, args->default_acl, in btrfs_init_inode_security()
496 if (args->acl) { in btrfs_init_inode_security()
497 err = __btrfs_set_acl(trans, args->inode, args->acl, ACL_TYPE_ACCESS); in btrfs_init_inode_security()
501 if (!args->default_acl && !args->acl) in btrfs_init_inode_security()
502 cache_no_acl(args->inode); in btrfs_init_inode_security()
503 return btrfs_xattr_security_init(trans, args->inode, args->dir, in btrfs_init_inode_security()
504 &args->dentry->d_name); in btrfs_init_inode_security()
520 struct btrfs_root *root = inode->root; in insert_inline_extent()
550 leaf = path->nodes[0]; in insert_inline_extent()
551 ei = btrfs_item_ptr(leaf, path->slots[0], in insert_inline_extent()
553 btrfs_set_file_extent_generation(leaf, ei, trans->transid); in insert_inline_extent()
574 compressed_size -= cur_size; in insert_inline_extent()
579 page = find_get_page(inode->vfs_inode.i_mapping, 0); in insert_inline_extent()
594 ALIGN(size, root->fs_info->sectorsize)); in insert_inline_extent()
605 i_size = i_size_read(&inode->vfs_inode); in insert_inline_extent()
607 i_size_write(&inode->vfs_inode, size); in insert_inline_extent()
610 inode->disk_i_size = i_size; in insert_inline_extent()
629 struct btrfs_root *root = inode->root; in cow_file_range_inline()
630 struct btrfs_fs_info *fs_info = root->fs_info; in cow_file_range_inline()
642 if (size < i_size_read(&inode->vfs_inode) || in cow_file_range_inline()
643 size > fs_info->sectorsize || in cow_file_range_inline()
645 data_len > fs_info->max_inline) in cow_file_range_inline()
650 return -ENOMEM; in cow_file_range_inline()
657 trans->block_rsv = &inode->block_rsv; in cow_file_range_inline()
661 drop_args.end = fs_info->sectorsize; in cow_file_range_inline()
674 if (ret && ret != -ENOSPC) { in cow_file_range_inline()
677 } else if (ret == -ENOSPC) { in cow_file_range_inline()
684 if (ret && ret != -ENOSPC) { in cow_file_range_inline()
687 } else if (ret == -ENOSPC) { in cow_file_range_inline()
743 BUG_ON(!async_extent); /* -ENOMEM */ in add_async_extent()
744 async_extent->start = start; in add_async_extent()
745 async_extent->ram_size = ram_size; in add_async_extent()
746 async_extent->compressed_size = compressed_size; in add_async_extent()
747 async_extent->pages = pages; in add_async_extent()
748 async_extent->nr_pages = nr_pages; in add_async_extent()
749 async_extent->compress_type = compress_type; in add_async_extent()
750 list_add_tail(&async_extent->list, &cow->extents); in add_async_extent()
761 struct btrfs_fs_info *fs_info = inode->root->fs_info; in inode_need_compress()
777 * \- A \- B in inode_need_compress()
795 if (fs_info->sectorsize < PAGE_SIZE) { in inode_need_compress()
805 if (inode->defrag_compress) in inode_need_compress()
808 if (inode->flags & BTRFS_INODE_NOCOMPRESS) in inode_need_compress()
811 inode->flags & BTRFS_INODE_COMPRESS || in inode_need_compress()
812 inode->prop_compress) in inode_need_compress()
813 return btrfs_compress_heuristic(&inode->vfs_inode, start, end); in inode_need_compress()
822 (start > 0 || end + 1 < inode->disk_i_size)) in inode_should_defrag()
843 struct btrfs_inode *inode = async_chunk->inode; in compress_file_range()
844 struct btrfs_fs_info *fs_info = inode->root->fs_info; in compress_file_range()
845 struct address_space *mapping = inode->vfs_inode.i_mapping; in compress_file_range()
846 u64 blocksize = fs_info->sectorsize; in compress_file_range()
847 u64 start = async_chunk->start; in compress_file_range()
848 u64 end = async_chunk->end; in compress_file_range()
858 int compress_type = fs_info->compress_type; in compress_file_range()
860 inode_should_defrag(inode, start, end, end - start + 1, SZ_16K); in compress_file_range()
867 extent_range_clear_dirty_for_io(&inode->vfs_inode, start, end); in compress_file_range()
879 i_size = i_size_read(&inode->vfs_inode); in compress_file_range()
884 nr_pages = (end >> PAGE_SHIFT) - (start >> PAGE_SHIFT) + 1; in compress_file_range()
900 total_compressed = actual_end - start; in compress_file_range()
907 (start > 0 || end + 1 < inode->disk_i_size)) in compress_file_range()
927 * We do compression for mount -o compress and when the inode has not in compress_file_range()
943 if (inode->defrag_compress) in compress_file_range()
944 compress_type = inode->defrag_compress; in compress_file_range()
945 else if (inode->prop_compress) in compress_file_range()
946 compress_type = inode->prop_compress; in compress_file_range()
949 ret = btrfs_compress_pages(compress_type | (fs_info->compress_level << 4), in compress_file_range()
961 memzero_page(pages[nr_pages - 1], poff, PAGE_SIZE - poff); in compress_file_range()
972 if (start == 0 && fs_info->sectorsize == PAGE_SIZE) { in compress_file_range()
989 mapping_set_error(mapping, -EIO); in compress_file_range()
1022 total_in = round_up(total_in, fs_info->sectorsize); in compress_file_range()
1040 if (!btrfs_test_opt(fs_info, FORCE_COMPRESS) && !inode->prop_compress) in compress_file_range()
1041 inode->flags |= BTRFS_INODE_NOCOMPRESS; in compress_file_range()
1043 add_async_extent(async_chunk, start, end - start + 1, 0, NULL, 0, in compress_file_range()
1048 WARN_ON(pages[i]->mapping); in compress_file_range()
1059 if (!async_extent->pages) in free_async_extent_pages()
1062 for (i = 0; i < async_extent->nr_pages; i++) { in free_async_extent_pages()
1063 WARN_ON(async_extent->pages[i]->mapping); in free_async_extent_pages()
1064 btrfs_free_compr_page(async_extent->pages[i]); in free_async_extent_pages()
1066 kfree(async_extent->pages); in free_async_extent_pages()
1067 async_extent->nr_pages = 0; in free_async_extent_pages()
1068 async_extent->pages = NULL; in free_async_extent_pages()
1075 u64 start = async_extent->start; in submit_uncompressed_range()
1076 u64 end = async_extent->start + async_extent->ram_size - 1; in submit_uncompressed_range()
1085 wbc_attach_fdatawrite_inode(&wbc, &inode->vfs_inode); in submit_uncompressed_range()
1089 btrfs_cleanup_ordered_extents(inode, locked_page, start, end - start + 1); in submit_uncompressed_range()
1098 mapping_set_error(locked_page->mapping, ret); in submit_uncompressed_range()
1108 struct btrfs_inode *inode = async_chunk->inode; in submit_one_async_extent()
1109 struct extent_io_tree *io_tree = &inode->io_tree; in submit_one_async_extent()
1110 struct btrfs_root *root = inode->root; in submit_one_async_extent()
1111 struct btrfs_fs_info *fs_info = root->fs_info; in submit_one_async_extent()
1117 u64 start = async_extent->start; in submit_one_async_extent()
1118 u64 end = async_extent->start + async_extent->ram_size - 1; in submit_one_async_extent()
1120 if (async_chunk->blkcg_css) in submit_one_async_extent()
1121 kthread_associate_blkcg(async_chunk->blkcg_css); in submit_one_async_extent()
1124 * If async_chunk->locked_page is in the async_extent range, we need to in submit_one_async_extent()
1127 if (async_chunk->locked_page) { in submit_one_async_extent()
1128 u64 locked_page_start = page_offset(async_chunk->locked_page); in submit_one_async_extent()
1129 u64 locked_page_end = locked_page_start + PAGE_SIZE - 1; in submit_one_async_extent()
1132 locked_page = async_chunk->locked_page; in submit_one_async_extent()
1136 if (async_extent->compress_type == BTRFS_COMPRESS_NONE) { in submit_one_async_extent()
1141 ret = btrfs_reserve_extent(root, async_extent->ram_size, in submit_one_async_extent()
1142 async_extent->compressed_size, in submit_one_async_extent()
1143 async_extent->compressed_size, in submit_one_async_extent()
1147 * Here we used to try again by going back to non-compressed in submit_one_async_extent()
1158 async_extent->ram_size, /* len */ in submit_one_async_extent()
1163 async_extent->ram_size, /* ram_bytes */ in submit_one_async_extent()
1164 async_extent->compress_type, in submit_one_async_extent()
1173 async_extent->ram_size, /* num_bytes */ in submit_one_async_extent()
1174 async_extent->ram_size, /* ram_bytes */ in submit_one_async_extent()
1179 async_extent->compress_type); in submit_one_async_extent()
1192 async_extent->pages, /* compressed_pages */ in submit_one_async_extent()
1193 async_extent->nr_pages, in submit_one_async_extent()
1194 async_chunk->write_flags, true); in submit_one_async_extent()
1197 if (async_chunk->blkcg_css) in submit_one_async_extent()
1206 mapping_set_error(inode->vfs_inode.i_mapping, -EIO); in submit_one_async_extent()
1214 if (async_chunk->blkcg_css) in submit_one_async_extent()
1218 root->root_key.objectid, btrfs_ino(inode), start, in submit_one_async_extent()
1219 async_extent->ram_size, ret); in submit_one_async_extent()
1226 struct extent_map_tree *em_tree = &inode->extent_tree; in get_extent_allocation_hint()
1230 read_lock(&em_tree->lock); in get_extent_allocation_hint()
1238 if (em->block_start >= EXTENT_MAP_LAST_BYTE) { in get_extent_allocation_hint()
1241 if (em && em->block_start < EXTENT_MAP_LAST_BYTE) in get_extent_allocation_hint()
1242 alloc_hint = em->block_start; in get_extent_allocation_hint()
1246 alloc_hint = em->block_start; in get_extent_allocation_hint()
1250 read_unlock(&em_tree->lock); in get_extent_allocation_hint()
1262 * it to make sure we don't do extra locks or unlocks.
1274 * - If @keep_locked is set, all pages are kept locked.
1275 * - Else all pages except for @locked_page are unlocked.
1278 * while-loop, the ordered extents created in previous iterations are kept
1288 struct btrfs_root *root = inode->root; in cow_file_range()
1289 struct btrfs_fs_info *fs_info = root->fs_info; in cow_file_range()
1296 u64 blocksize = fs_info->sectorsize; in cow_file_range()
1305 ret = -EINVAL; in cow_file_range()
1309 num_bytes = ALIGN(end - start + 1, blocksize); in cow_file_range()
1311 ASSERT(num_bytes <= btrfs_super_total_bytes(fs_info->super_copy)); in cow_file_range()
1325 if (start == 0 && fs_info->sectorsize == PAGE_SIZE && !no_inline) { in cow_file_range()
1326 u64 actual_end = min_t(u64, i_size_read(&inode->vfs_inode), in cow_file_range()
1381 min_alloc_size = fs_info->sectorsize; in cow_file_range()
1390 if (ret == -EAGAIN) { in cow_file_range()
1392 * btrfs_reserve_extent only returns -EAGAIN for zoned in cow_file_range()
1400 * us, or return -ENOSPC if it can't handle retries. in cow_file_range()
1404 wait_on_bit_io(&inode->root->fs_info->flags, in cow_file_range()
1410 *done_offset = start - 1; in cow_file_range()
1413 ret = -ENOSPC; in cow_file_range()
1460 start + ram_size - 1, in cow_file_range()
1478 extent_clear_unlock_delalloc(inode, start, start + ram_size - 1, in cow_file_range()
1485 num_bytes -= cur_alloc_size; in cow_file_range()
1504 btrfs_drop_extent_map_range(inode, start, start + ram_size - 1, false); in cow_file_range()
1512 * |-------(1)----|---(2)---|-------------(3)----------| in cow_file_range()
1513 * `- orig_start `- start `- start + cur_alloc_size `- end in cow_file_range()
1536 mapping_set_error(inode->vfs_inode.i_mapping, ret); in cow_file_range()
1537 extent_clear_unlock_delalloc(inode, orig_start, start - 1, in cow_file_range()
1553 start + cur_alloc_size - 1, in cow_file_range()
1596 btrfs_add_delayed_iput(async_chunk->inode); in submit_compressed_extents()
1597 if (async_chunk->blkcg_css) in submit_compressed_extents()
1598 css_put(async_chunk->blkcg_css); in submit_compressed_extents()
1600 async_cow = async_chunk->async_cow; in submit_compressed_extents()
1601 if (atomic_dec_and_test(&async_cow->num_chunks)) in submit_compressed_extents()
1606 nr_pages = (async_chunk->end - async_chunk->start + PAGE_SIZE) >> in submit_compressed_extents()
1609 while (!list_empty(&async_chunk->extents)) { in submit_compressed_extents()
1610 async_extent = list_entry(async_chunk->extents.next, in submit_compressed_extents()
1612 list_del(&async_extent->list); in submit_compressed_extents()
1617 if (atomic_sub_return(nr_pages, &fs_info->async_delalloc_pages) < in submit_compressed_extents()
1619 cond_wake_up_nomb(&fs_info->async_submit_wait); in submit_compressed_extents()
1626 struct btrfs_fs_info *fs_info = inode->root->fs_info; in run_delalloc_compressed()
1631 u64 num_chunks = DIV_ROUND_UP(end - start, SZ_512K); in run_delalloc_compressed()
1642 unlock_extent(&inode->io_tree, start, end, NULL); in run_delalloc_compressed()
1643 set_bit(BTRFS_INODE_HAS_ASYNC_EXTENT, &inode->runtime_flags); in run_delalloc_compressed()
1645 async_chunk = ctx->chunks; in run_delalloc_compressed()
1646 atomic_set(&ctx->num_chunks, num_chunks); in run_delalloc_compressed()
1649 u64 cur_end = min(end, start + SZ_512K - 1); in run_delalloc_compressed()
1655 ihold(&inode->vfs_inode); in run_delalloc_compressed()
1683 cur_end - start); in run_delalloc_compressed()
1701 nr_pages = DIV_ROUND_UP(cur_end - start, PAGE_SIZE); in run_delalloc_compressed()
1702 atomic_add(nr_pages, &fs_info->async_delalloc_pages); in run_delalloc_compressed()
1704 btrfs_queue_work(fs_info->delalloc_workers, &async_chunk[i].work); in run_delalloc_compressed()
1728 extent_write_locked_range(&inode->vfs_inode, locked_page, start, in run_delalloc_cow()
1744 ret = btrfs_lookup_csums_list(csum_root, bytenr, bytenr + num_bytes - 1, in csum_exist_in_range()
1751 list_del(&sums->list); in csum_exist_in_range()
1763 const bool is_reloc_ino = btrfs_is_data_reloc_root(inode->root); in fallback_to_cow()
1764 const u64 range_bytes = end + 1 - start; in fallback_to_cow()
1765 struct extent_io_tree *io_tree = &inode->io_tree; in fallback_to_cow()
1806 struct btrfs_fs_info *fs_info = inode->root->fs_info; in fallback_to_cow()
1807 struct btrfs_space_info *sinfo = fs_info->data_sinfo; in fallback_to_cow()
1812 spin_lock(&sinfo->lock); in fallback_to_cow()
1814 spin_unlock(&sinfo->lock); in fallback_to_cow()
1858 * if path->nodes[0] is NULL or not if it needs to use the path afterwards.
1870 struct extent_buffer *leaf = path->nodes[0]; in can_nocow_file_extent()
1871 struct btrfs_root *root = inode->root; in can_nocow_file_extent()
1877 bool nowait = path->nowait; in can_nocow_file_extent()
1879 fi = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_file_extent_item); in can_nocow_file_extent()
1886 args->disk_bytenr = btrfs_file_extent_disk_bytenr(leaf, fi); in can_nocow_file_extent()
1887 args->disk_num_bytes = btrfs_file_extent_disk_num_bytes(leaf, fi); in can_nocow_file_extent()
1888 args->extent_offset = btrfs_file_extent_offset(leaf, fi); in can_nocow_file_extent()
1890 if (!(inode->flags & BTRFS_INODE_NODATACOW) && in can_nocow_file_extent()
1899 if (!args->strict && in can_nocow_file_extent()
1901 btrfs_root_last_snapshot(&root->root_item)) in can_nocow_file_extent()
1905 if (args->disk_bytenr == 0) in can_nocow_file_extent()
1924 key->offset - args->extent_offset, in can_nocow_file_extent()
1925 args->disk_bytenr, args->strict, path); in can_nocow_file_extent()
1930 if (args->free_path) { in can_nocow_file_extent()
1934 * another path. So free the path to avoid unnecessary extra in can_nocow_file_extent()
1942 if (args->writeback_path && !is_freespace_inode && in can_nocow_file_extent()
1943 atomic_read(&root->snapshot_force_cow)) in can_nocow_file_extent()
1946 args->disk_bytenr += args->extent_offset; in can_nocow_file_extent()
1947 args->disk_bytenr += args->start - key->offset; in can_nocow_file_extent()
1948 args->num_bytes = min(args->end + 1, extent_end) - args->start; in can_nocow_file_extent()
1954 ret = csum_exist_in_range(root->fs_info, args->disk_bytenr, args->num_bytes, in can_nocow_file_extent()
1962 if (args->free_path && path) in can_nocow_file_extent()
1979 struct btrfs_fs_info *fs_info = inode->root->fs_info; in run_delalloc_nocow()
1980 struct btrfs_root *root = inode->root; in run_delalloc_nocow()
1982 u64 cow_start = (u64)-1; in run_delalloc_nocow()
1998 ret = -ENOMEM; in run_delalloc_nocow()
2027 if (ret > 0 && path->slots[0] > 0 && check_prev) { in run_delalloc_nocow()
2028 leaf = path->nodes[0]; in run_delalloc_nocow()
2030 path->slots[0] - 1); in run_delalloc_nocow()
2033 path->slots[0]--; in run_delalloc_nocow()
2038 leaf = path->nodes[0]; in run_delalloc_nocow()
2039 if (path->slots[0] >= btrfs_header_nritems(leaf)) { in run_delalloc_nocow()
2045 leaf = path->nodes[0]; in run_delalloc_nocow()
2048 btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]); in run_delalloc_nocow()
2059 path->slots[0]++; in run_delalloc_nocow()
2082 fi = btrfs_item_ptr(leaf, path->slots[0], in run_delalloc_nocow()
2088 ret = -EUCLEAN; in run_delalloc_nocow()
2099 path->slots[0]++; in run_delalloc_nocow()
2121 if (cow_start == (u64)-1) in run_delalloc_nocow()
2126 if (!path->nodes[0]) in run_delalloc_nocow()
2128 path->slots[0]++; in run_delalloc_nocow()
2133 * COW range from cow_start to found_key.offset - 1. As the key in run_delalloc_nocow()
2137 if (cow_start != (u64)-1) { in run_delalloc_nocow()
2139 cow_start, found_key.offset - 1); in run_delalloc_nocow()
2140 cow_start = (u64)-1; in run_delalloc_nocow()
2147 nocow_end = cur_offset + nocow_args.num_bytes - 1; in run_delalloc_nocow()
2150 u64 orig_start = found_key.offset - nocow_args.extent_offset; in run_delalloc_nocow()
2214 if (cur_offset <= end && cow_start == (u64)-1) in run_delalloc_nocow()
2217 if (cow_start != (u64)-1) { in run_delalloc_nocow()
2220 cow_start = (u64)-1; in run_delalloc_nocow()
2234 if (cow_start != (u64)-1) in run_delalloc_nocow()
2249 if (inode->flags & (BTRFS_INODE_NODATACOW | BTRFS_INODE_PREALLOC)) { in should_nocow()
2250 if (inode->defrag_bytes && in should_nocow()
2251 test_range_bit_exists(&inode->io_tree, start, end, EXTENT_DEFRAG)) in should_nocow()
2265 const bool zoned = btrfs_is_zoned(inode->root->fs_info); in btrfs_run_delalloc_range()
2295 end - start + 1); in btrfs_run_delalloc_range()
2302 struct btrfs_fs_info *fs_info = inode->root->fs_info; in btrfs_split_delalloc_extent()
2306 if (!(orig->state & EXTENT_DELALLOC)) in btrfs_split_delalloc_extent()
2309 size = orig->end - orig->start + 1; in btrfs_split_delalloc_extent()
2310 if (size > fs_info->max_extent_size) { in btrfs_split_delalloc_extent()
2318 new_size = orig->end - split + 1; in btrfs_split_delalloc_extent()
2320 new_size = split - orig->start; in btrfs_split_delalloc_extent()
2326 spin_lock(&inode->lock); in btrfs_split_delalloc_extent()
2328 spin_unlock(&inode->lock); in btrfs_split_delalloc_extent()
2339 struct btrfs_fs_info *fs_info = inode->root->fs_info; in btrfs_merge_delalloc_extent()
2344 if (!(other->state & EXTENT_DELALLOC)) in btrfs_merge_delalloc_extent()
2347 if (new->start > other->start) in btrfs_merge_delalloc_extent()
2348 new_size = new->end - other->start + 1; in btrfs_merge_delalloc_extent()
2350 new_size = other->end - new->start + 1; in btrfs_merge_delalloc_extent()
2353 if (new_size <= fs_info->max_extent_size) { in btrfs_merge_delalloc_extent()
2354 spin_lock(&inode->lock); in btrfs_merge_delalloc_extent()
2355 btrfs_mod_outstanding_extents(inode, -1); in btrfs_merge_delalloc_extent()
2356 spin_unlock(&inode->lock); in btrfs_merge_delalloc_extent()
2378 old_size = other->end - other->start + 1; in btrfs_merge_delalloc_extent()
2380 old_size = new->end - new->start + 1; in btrfs_merge_delalloc_extent()
2385 spin_lock(&inode->lock); in btrfs_merge_delalloc_extent()
2386 btrfs_mod_outstanding_extents(inode, -1); in btrfs_merge_delalloc_extent()
2387 spin_unlock(&inode->lock); in btrfs_merge_delalloc_extent()
2393 struct btrfs_fs_info *fs_info = inode->root->fs_info; in btrfs_add_delalloc_inodes()
2395 spin_lock(&root->delalloc_lock); in btrfs_add_delalloc_inodes()
2396 if (list_empty(&inode->delalloc_inodes)) { in btrfs_add_delalloc_inodes()
2397 list_add_tail(&inode->delalloc_inodes, &root->delalloc_inodes); in btrfs_add_delalloc_inodes()
2398 set_bit(BTRFS_INODE_IN_DELALLOC_LIST, &inode->runtime_flags); in btrfs_add_delalloc_inodes()
2399 root->nr_delalloc_inodes++; in btrfs_add_delalloc_inodes()
2400 if (root->nr_delalloc_inodes == 1) { in btrfs_add_delalloc_inodes()
2401 spin_lock(&fs_info->delalloc_root_lock); in btrfs_add_delalloc_inodes()
2402 BUG_ON(!list_empty(&root->delalloc_root)); in btrfs_add_delalloc_inodes()
2403 list_add_tail(&root->delalloc_root, in btrfs_add_delalloc_inodes()
2404 &fs_info->delalloc_roots); in btrfs_add_delalloc_inodes()
2405 spin_unlock(&fs_info->delalloc_root_lock); in btrfs_add_delalloc_inodes()
2408 spin_unlock(&root->delalloc_lock); in btrfs_add_delalloc_inodes()
2414 struct btrfs_fs_info *fs_info = root->fs_info; in __btrfs_del_delalloc_inode()
2416 if (!list_empty(&inode->delalloc_inodes)) { in __btrfs_del_delalloc_inode()
2417 list_del_init(&inode->delalloc_inodes); in __btrfs_del_delalloc_inode()
2419 &inode->runtime_flags); in __btrfs_del_delalloc_inode()
2420 root->nr_delalloc_inodes--; in __btrfs_del_delalloc_inode()
2421 if (!root->nr_delalloc_inodes) { in __btrfs_del_delalloc_inode()
2422 ASSERT(list_empty(&root->delalloc_inodes)); in __btrfs_del_delalloc_inode()
2423 spin_lock(&fs_info->delalloc_root_lock); in __btrfs_del_delalloc_inode()
2424 BUG_ON(list_empty(&root->delalloc_root)); in __btrfs_del_delalloc_inode()
2425 list_del_init(&root->delalloc_root); in __btrfs_del_delalloc_inode()
2426 spin_unlock(&fs_info->delalloc_root_lock); in __btrfs_del_delalloc_inode()
2434 spin_lock(&root->delalloc_lock); in btrfs_del_delalloc_inode()
2436 spin_unlock(&root->delalloc_lock); in btrfs_del_delalloc_inode()
2446 struct btrfs_fs_info *fs_info = inode->root->fs_info; in btrfs_set_delalloc_extent()
2455 if (!(state->state & EXTENT_DELALLOC) && (bits & EXTENT_DELALLOC)) { in btrfs_set_delalloc_extent()
2456 struct btrfs_root *root = inode->root; in btrfs_set_delalloc_extent()
2457 u64 len = state->end + 1 - state->start; in btrfs_set_delalloc_extent()
2461 spin_lock(&inode->lock); in btrfs_set_delalloc_extent()
2463 spin_unlock(&inode->lock); in btrfs_set_delalloc_extent()
2469 percpu_counter_add_batch(&fs_info->delalloc_bytes, len, in btrfs_set_delalloc_extent()
2470 fs_info->delalloc_batch); in btrfs_set_delalloc_extent()
2471 spin_lock(&inode->lock); in btrfs_set_delalloc_extent()
2472 inode->delalloc_bytes += len; in btrfs_set_delalloc_extent()
2474 inode->defrag_bytes += len; in btrfs_set_delalloc_extent()
2476 &inode->runtime_flags)) in btrfs_set_delalloc_extent()
2478 spin_unlock(&inode->lock); in btrfs_set_delalloc_extent()
2481 if (!(state->state & EXTENT_DELALLOC_NEW) && in btrfs_set_delalloc_extent()
2483 spin_lock(&inode->lock); in btrfs_set_delalloc_extent()
2484 inode->new_delalloc_bytes += state->end + 1 - state->start; in btrfs_set_delalloc_extent()
2485 spin_unlock(&inode->lock); in btrfs_set_delalloc_extent()
2496 struct btrfs_fs_info *fs_info = inode->root->fs_info; in btrfs_clear_delalloc_extent()
2497 u64 len = state->end + 1 - state->start; in btrfs_clear_delalloc_extent()
2500 if ((state->state & EXTENT_DEFRAG) && (bits & EXTENT_DEFRAG)) { in btrfs_clear_delalloc_extent()
2501 spin_lock(&inode->lock); in btrfs_clear_delalloc_extent()
2502 inode->defrag_bytes -= len; in btrfs_clear_delalloc_extent()
2503 spin_unlock(&inode->lock); in btrfs_clear_delalloc_extent()
2511 if ((state->state & EXTENT_DELALLOC) && (bits & EXTENT_DELALLOC)) { in btrfs_clear_delalloc_extent()
2512 struct btrfs_root *root = inode->root; in btrfs_clear_delalloc_extent()
2515 spin_lock(&inode->lock); in btrfs_clear_delalloc_extent()
2516 btrfs_mod_outstanding_extents(inode, -num_extents); in btrfs_clear_delalloc_extent()
2517 spin_unlock(&inode->lock); in btrfs_clear_delalloc_extent()
2525 root != fs_info->tree_root) in btrfs_clear_delalloc_extent()
2533 do_list && !(state->state & EXTENT_NORESERVE) && in btrfs_clear_delalloc_extent()
2537 percpu_counter_add_batch(&fs_info->delalloc_bytes, -len, in btrfs_clear_delalloc_extent()
2538 fs_info->delalloc_batch); in btrfs_clear_delalloc_extent()
2539 spin_lock(&inode->lock); in btrfs_clear_delalloc_extent()
2540 inode->delalloc_bytes -= len; in btrfs_clear_delalloc_extent()
2541 if (do_list && inode->delalloc_bytes == 0 && in btrfs_clear_delalloc_extent()
2543 &inode->runtime_flags)) in btrfs_clear_delalloc_extent()
2545 spin_unlock(&inode->lock); in btrfs_clear_delalloc_extent()
2548 if ((state->state & EXTENT_DELALLOC_NEW) && in btrfs_clear_delalloc_extent()
2550 spin_lock(&inode->lock); in btrfs_clear_delalloc_extent()
2551 ASSERT(inode->new_delalloc_bytes >= len); in btrfs_clear_delalloc_extent()
2552 inode->new_delalloc_bytes -= len; in btrfs_clear_delalloc_extent()
2554 inode_add_bytes(&inode->vfs_inode, len); in btrfs_clear_delalloc_extent()
2555 spin_unlock(&inode->lock); in btrfs_clear_delalloc_extent()
2562 u64 start = (u64)bbio->bio.bi_iter.bi_sector << SECTOR_SHIFT; in btrfs_extract_ordered_extent()
2563 u64 len = bbio->bio.bi_iter.bi_size; in btrfs_extract_ordered_extent()
2568 if (WARN_ON_ONCE(start != ordered->disk_bytenr)) in btrfs_extract_ordered_extent()
2569 return -EINVAL; in btrfs_extract_ordered_extent()
2572 if (ordered->disk_num_bytes == len) { in btrfs_extract_ordered_extent()
2573 refcount_inc(&ordered->refs); in btrfs_extract_ordered_extent()
2574 bbio->ordered = ordered; in btrfs_extract_ordered_extent()
2580 * a pre-existing one. in btrfs_extract_ordered_extent()
2582 if (!test_bit(BTRFS_ORDERED_NOCOW, &ordered->flags)) { in btrfs_extract_ordered_extent()
2583 ret = split_extent_map(bbio->inode, bbio->file_offset, in btrfs_extract_ordered_extent()
2584 ordered->num_bytes, len, in btrfs_extract_ordered_extent()
2585 ordered->disk_bytenr); in btrfs_extract_ordered_extent()
2593 bbio->ordered = new; in btrfs_extract_ordered_extent()
2609 trans->adding_csums = true; in add_pending_csums()
2611 csum_root = btrfs_csum_root(trans->fs_info, in add_pending_csums()
2612 sum->logical); in add_pending_csums()
2614 trans->adding_csums = false; in add_pending_csums()
2627 const u64 end = start + len - 1; in btrfs_find_new_delalloc_bytes()
2630 const u64 search_len = end - search_start + 1; in btrfs_find_new_delalloc_bytes()
2639 if (em->block_start != EXTENT_MAP_HOLE) in btrfs_find_new_delalloc_bytes()
2642 em_len = em->len; in btrfs_find_new_delalloc_bytes()
2643 if (em->start < search_start) in btrfs_find_new_delalloc_bytes()
2644 em_len -= search_start - em->start; in btrfs_find_new_delalloc_bytes()
2648 ret = set_extent_bit(&inode->io_tree, search_start, in btrfs_find_new_delalloc_bytes()
2649 search_start + em_len - 1, in btrfs_find_new_delalloc_bytes()
2666 if (start >= i_size_read(&inode->vfs_inode) && in btrfs_set_extent_delalloc()
2667 !(inode->flags & BTRFS_INODE_PREALLOC)) { in btrfs_set_extent_delalloc()
2677 end + 1 - start, in btrfs_set_extent_delalloc()
2683 return set_extent_bit(&inode->io_tree, start, end, in btrfs_set_extent_delalloc()
2701 struct page *page = fixup->page; in btrfs_writepage_fixup_worker()
2702 struct btrfs_inode *inode = fixup->inode; in btrfs_writepage_fixup_worker()
2703 struct btrfs_fs_info *fs_info = inode->root->fs_info; in btrfs_writepage_fixup_worker()
2705 u64 page_end = page_offset(page) + PAGE_SIZE - 1; in btrfs_writepage_fixup_worker()
2720 * page->mapping may go NULL, but it shouldn't be moved to a different in btrfs_writepage_fixup_worker()
2723 if (!page->mapping || !PageDirty(page) || !PageChecked(page)) { in btrfs_writepage_fixup_worker()
2758 lock_extent(&inode->io_tree, page_start, page_end, &cached_state); in btrfs_writepage_fixup_worker()
2766 unlock_extent(&inode->io_tree, page_start, page_end, in btrfs_writepage_fixup_worker()
2793 unlock_extent(&inode->io_tree, page_start, page_end, &cached_state); in btrfs_writepage_fixup_worker()
2800 mapping_set_error(page->mapping, ret); in btrfs_writepage_fixup_worker()
2831 struct inode *inode = page->mapping->host; in btrfs_writepage_cow_fixup()
2832 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); in btrfs_writepage_cow_fixup()
2847 return -EAGAIN; in btrfs_writepage_cow_fixup()
2851 return -EAGAIN; in btrfs_writepage_cow_fixup()
2857 * page->mapping outside of the page lock. in btrfs_writepage_cow_fixup()
2862 btrfs_init_work(&fixup->work, btrfs_writepage_fixup_worker, NULL); in btrfs_writepage_cow_fixup()
2863 fixup->page = page; in btrfs_writepage_cow_fixup()
2864 fixup->inode = BTRFS_I(inode); in btrfs_writepage_cow_fixup()
2865 btrfs_queue_work(fs_info->fixup_workers, &fixup->work); in btrfs_writepage_cow_fixup()
2867 return -EAGAIN; in btrfs_writepage_cow_fixup()
2876 struct btrfs_root *root = inode->root; in insert_reserved_file_extent()
2877 const u64 sectorsize = root->fs_info->sectorsize; in insert_reserved_file_extent()
2891 return -ENOMEM; in insert_reserved_file_extent()
2921 leaf = path->nodes[0]; in insert_reserved_file_extent()
2922 btrfs_set_stack_file_extent_generation(stack_fi, trans->transid); in insert_reserved_file_extent()
2924 btrfs_item_ptr_offset(leaf, path->slots[0]), in insert_reserved_file_extent()
2940 inline_size = drop_args.bytes_found - inline_size; in insert_reserved_file_extent()
2942 drop_args.bytes_found -= inline_size; in insert_reserved_file_extent()
2943 num_bytes -= sectorsize; in insert_reserved_file_extent()
2958 file_pos - offset, in insert_reserved_file_extent()
2974 spin_lock(&cache->lock); in btrfs_release_delalloc_bytes()
2975 cache->delalloc_bytes -= len; in btrfs_release_delalloc_bytes()
2976 spin_unlock(&cache->lock); in btrfs_release_delalloc_bytes()
2982 struct btrfs_ordered_extent *oe) in insert_ordered_extent_file_extent() argument
2986 u64 num_bytes = oe->num_bytes; in insert_ordered_extent_file_extent()
2987 u64 ram_bytes = oe->ram_bytes; in insert_ordered_extent_file_extent()
2991 btrfs_set_stack_file_extent_disk_bytenr(&stack_fi, oe->disk_bytenr); in insert_ordered_extent_file_extent()
2993 oe->disk_num_bytes); in insert_ordered_extent_file_extent()
2994 btrfs_set_stack_file_extent_offset(&stack_fi, oe->offset); in insert_ordered_extent_file_extent()
2995 if (test_bit(BTRFS_ORDERED_TRUNCATED, &oe->flags)) { in insert_ordered_extent_file_extent()
2996 num_bytes = oe->truncated_len; in insert_ordered_extent_file_extent()
3001 btrfs_set_stack_file_extent_compression(&stack_fi, oe->compress_type); in insert_ordered_extent_file_extent()
3010 update_inode_bytes = test_bit(BTRFS_ORDERED_DIRECT, &oe->flags) || in insert_ordered_extent_file_extent()
3011 test_bit(BTRFS_ORDERED_ENCODED, &oe->flags) || in insert_ordered_extent_file_extent()
3012 test_bit(BTRFS_ORDERED_TRUNCATED, &oe->flags); in insert_ordered_extent_file_extent()
3014 return insert_reserved_file_extent(trans, BTRFS_I(oe->inode), in insert_ordered_extent_file_extent()
3015 oe->file_offset, &stack_fi, in insert_ordered_extent_file_extent()
3016 update_inode_bytes, oe->qgroup_rsv); in insert_ordered_extent_file_extent()
3026 struct btrfs_inode *inode = BTRFS_I(ordered_extent->inode); in btrfs_finish_one_ordered()
3027 struct btrfs_root *root = inode->root; in btrfs_finish_one_ordered()
3028 struct btrfs_fs_info *fs_info = root->fs_info; in btrfs_finish_one_ordered()
3030 struct extent_io_tree *io_tree = &inode->io_tree; in btrfs_finish_one_ordered()
3035 u64 logical_len = ordered_extent->num_bytes; in btrfs_finish_one_ordered()
3041 start = ordered_extent->file_offset; in btrfs_finish_one_ordered()
3042 end = start + ordered_extent->num_bytes - 1; in btrfs_finish_one_ordered()
3044 if (!test_bit(BTRFS_ORDERED_NOCOW, &ordered_extent->flags) && in btrfs_finish_one_ordered()
3045 !test_bit(BTRFS_ORDERED_PREALLOC, &ordered_extent->flags) && in btrfs_finish_one_ordered()
3046 !test_bit(BTRFS_ORDERED_DIRECT, &ordered_extent->flags) && in btrfs_finish_one_ordered()
3047 !test_bit(BTRFS_ORDERED_ENCODED, &ordered_extent->flags)) in btrfs_finish_one_ordered()
3054 if (test_bit(BTRFS_ORDERED_IOERR, &ordered_extent->flags)) { in btrfs_finish_one_ordered()
3055 ret = -EIO; in btrfs_finish_one_ordered()
3060 btrfs_zone_finish_endio(fs_info, ordered_extent->disk_bytenr, in btrfs_finish_one_ordered()
3061 ordered_extent->disk_num_bytes); in btrfs_finish_one_ordered()
3063 if (test_bit(BTRFS_ORDERED_TRUNCATED, &ordered_extent->flags)) { in btrfs_finish_one_ordered()
3065 logical_len = ordered_extent->truncated_len; in btrfs_finish_one_ordered()
3071 if (test_bit(BTRFS_ORDERED_NOCOW, &ordered_extent->flags)) { in btrfs_finish_one_ordered()
3072 BUG_ON(!list_empty(&ordered_extent->list)); /* Logic error */ in btrfs_finish_one_ordered()
3084 trans->block_rsv = &inode->block_rsv; in btrfs_finish_one_ordered()
3086 if (ret) /* -ENOMEM or corruption */ in btrfs_finish_one_ordered()
3104 trans->block_rsv = &inode->block_rsv; in btrfs_finish_one_ordered()
3110 if (test_bit(BTRFS_ORDERED_COMPRESSED, &ordered_extent->flags)) in btrfs_finish_one_ordered()
3111 compress_type = ordered_extent->compress_type; in btrfs_finish_one_ordered()
3112 if (test_bit(BTRFS_ORDERED_PREALLOC, &ordered_extent->flags)) { in btrfs_finish_one_ordered()
3115 ordered_extent->file_offset, in btrfs_finish_one_ordered()
3116 ordered_extent->file_offset + in btrfs_finish_one_ordered()
3118 btrfs_zoned_release_data_reloc_bg(fs_info, ordered_extent->disk_bytenr, in btrfs_finish_one_ordered()
3119 ordered_extent->disk_num_bytes); in btrfs_finish_one_ordered()
3121 BUG_ON(root == fs_info->tree_root); in btrfs_finish_one_ordered()
3126 ordered_extent->disk_bytenr, in btrfs_finish_one_ordered()
3127 ordered_extent->disk_num_bytes); in btrfs_finish_one_ordered()
3130 unpin_extent_cache(inode, ordered_extent->file_offset, in btrfs_finish_one_ordered()
3131 ordered_extent->num_bytes, trans->transid); in btrfs_finish_one_ordered()
3137 ret = add_pending_csums(trans, &ordered_extent->list); in btrfs_finish_one_ordered()
3149 !test_bit(BTRFS_ORDERED_TRUNCATED, &ordered_extent->flags)) in btrfs_finish_one_ordered()
3150 clear_extent_bit(&inode->io_tree, start, end, in btrfs_finish_one_ordered()
3156 if (ret) { /* -ENOMEM or corruption */ in btrfs_finish_one_ordered()
3162 clear_extent_bit(&inode->io_tree, start, end, clear_bits, in btrfs_finish_one_ordered()
3180 &ordered_extent->flags)) in btrfs_finish_one_ordered()
3181 mapping_set_error(ordered_extent->inode->i_mapping, -EIO); in btrfs_finish_one_ordered()
3194 * writepage where we do ASSERT(em->block_start != in btrfs_finish_one_ordered()
3217 !test_bit(BTRFS_ORDERED_NOCOW, &ordered_extent->flags) && in btrfs_finish_one_ordered()
3218 !test_bit(BTRFS_ORDERED_PREALLOC, &ordered_extent->flags)) { in btrfs_finish_one_ordered()
3225 ordered_extent->disk_bytenr, in btrfs_finish_one_ordered()
3226 ordered_extent->disk_num_bytes, in btrfs_finish_one_ordered()
3229 ordered_extent->disk_bytenr, in btrfs_finish_one_ordered()
3230 ordered_extent->disk_num_bytes, 1); in btrfs_finish_one_ordered()
3235 btrfs_qgroup_free_refroot(fs_info, inode->root->root_key.objectid, in btrfs_finish_one_ordered()
3236 ordered_extent->qgroup_rsv, in btrfs_finish_one_ordered()
3257 if (btrfs_is_zoned(btrfs_sb(ordered->inode->i_sb)) && in btrfs_finish_ordered_io()
3258 !test_bit(BTRFS_ORDERED_IOERR, &ordered->flags) && in btrfs_finish_ordered_io()
3259 list_empty(&ordered->bioc_list)) in btrfs_finish_ordered_io()
3265 * Verify the checksum for a single sector without any extra action that depend
3271 SHASH_DESC_ON_STACK(shash, fs_info->csum_shash); in btrfs_check_sector_csum()
3274 ASSERT(pgoff + fs_info->sectorsize <= PAGE_SIZE); in btrfs_check_sector_csum()
3276 shash->tfm = fs_info->csum_shash; in btrfs_check_sector_csum()
3279 crypto_shash_digest(shash, kaddr, fs_info->sectorsize, csum); in btrfs_check_sector_csum()
3282 if (memcmp(csum, csum_expected, fs_info->csum_size)) in btrfs_check_sector_csum()
3283 return -EIO; in btrfs_check_sector_csum()
3303 struct btrfs_inode *inode = bbio->inode; in btrfs_data_csum_ok()
3304 struct btrfs_fs_info *fs_info = inode->root->fs_info; in btrfs_data_csum_ok()
3305 u64 file_offset = bbio->file_offset + bio_offset; in btrfs_data_csum_ok()
3306 u64 end = file_offset + bv->bv_len - 1; in btrfs_data_csum_ok()
3310 ASSERT(bv->bv_len == fs_info->sectorsize); in btrfs_data_csum_ok()
3312 if (!bbio->csum) in btrfs_data_csum_ok()
3315 if (btrfs_is_data_reloc_root(inode->root) && in btrfs_data_csum_ok()
3316 test_range_bit(&inode->io_tree, file_offset, end, EXTENT_NODATASUM, in btrfs_data_csum_ok()
3319 clear_extent_bits(&inode->io_tree, file_offset, end, in btrfs_data_csum_ok()
3324 csum_expected = bbio->csum + (bio_offset >> fs_info->sectorsize_bits) * in btrfs_data_csum_ok()
3325 fs_info->csum_size; in btrfs_data_csum_ok()
3326 if (btrfs_check_sector_csum(fs_info, bv->bv_page, bv->bv_offset, csum, in btrfs_data_csum_ok()
3333 bbio->mirror_num); in btrfs_data_csum_ok()
3352 struct btrfs_fs_info *fs_info = inode->root->fs_info; in btrfs_add_delayed_iput()
3355 if (atomic_add_unless(&inode->vfs_inode.i_count, -1, 1)) in btrfs_add_delayed_iput()
3358 atomic_inc(&fs_info->nr_delayed_iputs); in btrfs_add_delayed_iput()
3361 * context (see bio.c and btrfs_put_ordered_extent()) or a non-irq in btrfs_add_delayed_iput()
3364 spin_lock_irqsave(&fs_info->delayed_iput_lock, flags); in btrfs_add_delayed_iput()
3365 ASSERT(list_empty(&inode->delayed_iput)); in btrfs_add_delayed_iput()
3366 list_add_tail(&inode->delayed_iput, &fs_info->delayed_iputs); in btrfs_add_delayed_iput()
3367 spin_unlock_irqrestore(&fs_info->delayed_iput_lock, flags); in btrfs_add_delayed_iput()
3368 if (!test_bit(BTRFS_FS_CLEANER_RUNNING, &fs_info->flags)) in btrfs_add_delayed_iput()
3369 wake_up_process(fs_info->cleaner_kthread); in btrfs_add_delayed_iput()
3375 list_del_init(&inode->delayed_iput); in run_delayed_iput_locked()
3376 spin_unlock_irq(&fs_info->delayed_iput_lock); in run_delayed_iput_locked()
3377 iput(&inode->vfs_inode); in run_delayed_iput_locked()
3378 if (atomic_dec_and_test(&fs_info->nr_delayed_iputs)) in run_delayed_iput_locked()
3379 wake_up(&fs_info->delayed_iputs_wait); in run_delayed_iput_locked()
3380 spin_lock_irq(&fs_info->delayed_iput_lock); in run_delayed_iput_locked()
3386 if (!list_empty(&inode->delayed_iput)) { in btrfs_run_delayed_iput()
3387 spin_lock_irq(&fs_info->delayed_iput_lock); in btrfs_run_delayed_iput()
3388 if (!list_empty(&inode->delayed_iput)) in btrfs_run_delayed_iput()
3390 spin_unlock_irq(&fs_info->delayed_iput_lock); in btrfs_run_delayed_iput()
3399 * fs_info->delayed_iput_lock. So we need to disable irqs here to in btrfs_run_delayed_iputs()
3402 spin_lock_irq(&fs_info->delayed_iput_lock); in btrfs_run_delayed_iputs()
3403 while (!list_empty(&fs_info->delayed_iputs)) { in btrfs_run_delayed_iputs()
3406 inode = list_first_entry(&fs_info->delayed_iputs, in btrfs_run_delayed_iputs()
3410 spin_unlock_irq(&fs_info->delayed_iput_lock); in btrfs_run_delayed_iputs()
3412 spin_lock_irq(&fs_info->delayed_iput_lock); in btrfs_run_delayed_iputs()
3415 spin_unlock_irq(&fs_info->delayed_iput_lock); in btrfs_run_delayed_iputs()
3432 int ret = wait_event_killable(fs_info->delayed_iputs_wait, in btrfs_wait_on_delayed_iputs()
3433 atomic_read(&fs_info->nr_delayed_iputs) == 0); in btrfs_wait_on_delayed_iputs()
3435 return -EINTR; in btrfs_wait_on_delayed_iputs()
3448 ret = btrfs_insert_orphan_item(trans, inode->root, btrfs_ino(inode)); in btrfs_orphan_add()
3449 if (ret && ret != -EEXIST) { in btrfs_orphan_add()
3464 return btrfs_del_orphan_item(trans, inode->root, btrfs_ino(inode)); in btrfs_orphan_del()
3473 struct btrfs_fs_info *fs_info = root->fs_info; in btrfs_orphan_cleanup()
3482 if (test_and_set_bit(BTRFS_ROOT_ORPHAN_CLEANUP, &root->state)) in btrfs_orphan_cleanup()
3487 ret = -ENOMEM; in btrfs_orphan_cleanup()
3490 path->reada = READA_BACK; in btrfs_orphan_cleanup()
3494 key.offset = (u64)-1; in btrfs_orphan_cleanup()
3508 if (path->slots[0] == 0) in btrfs_orphan_cleanup()
3510 path->slots[0]--; in btrfs_orphan_cleanup()
3514 leaf = path->nodes[0]; in btrfs_orphan_cleanup()
3515 btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]); in btrfs_orphan_cleanup()
3537 * due to -ENOSPC for example, so try to grab the error in btrfs_orphan_cleanup()
3542 ret = BTRFS_FS_ERROR(fs_info) ?: -EINVAL; in btrfs_orphan_cleanup()
3551 inode = btrfs_iget(fs_info->sb, last_objectid, root); in btrfs_orphan_cleanup()
3555 if (ret != -ENOENT) in btrfs_orphan_cleanup()
3559 if (!inode && root == fs_info->tree_root) { in btrfs_orphan_cleanup()
3574 * fs_info->fs_roots_radix. So here we can find if an in btrfs_orphan_cleanup()
3579 spin_lock(&fs_info->fs_roots_radix_lock); in btrfs_orphan_cleanup()
3580 dead_root = radix_tree_lookup(&fs_info->fs_roots_radix, in btrfs_orphan_cleanup()
3582 if (dead_root && btrfs_root_refs(&dead_root->root_item) == 0) in btrfs_orphan_cleanup()
3584 spin_unlock(&fs_info->fs_roots_radix_lock); in btrfs_orphan_cleanup()
3588 key.offset = found_key.objectid - 1; in btrfs_orphan_cleanup()
3611 * only if this filesystem was last used on a pre-v3.12 kernel in btrfs_orphan_cleanup()
3620 if (!inode || inode->i_nlink) { in btrfs_orphan_cleanup()
3651 if (test_bit(BTRFS_ROOT_ORPHAN_ITEM_INSERTED, &root->state)) { in btrfs_orphan_cleanup()
3691 *first_xattr_slot = -1; in acls_after_inode_item()
3701 if (*first_xattr_slot == -1) in acls_after_inode_item()
3731 if (*first_xattr_slot == -1) in acls_after_inode_item()
3737 * read an inode from the btree into the in-memory inode
3742 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); in btrfs_read_locked_inode()
3746 struct btrfs_root *root = BTRFS_I(inode)->root; in btrfs_read_locked_inode()
3762 return -ENOMEM; in btrfs_read_locked_inode()
3765 memcpy(&location, &BTRFS_I(inode)->location, sizeof(location)); in btrfs_read_locked_inode()
3774 leaf = path->nodes[0]; in btrfs_read_locked_inode()
3779 inode_item = btrfs_item_ptr(leaf, path->slots[0], in btrfs_read_locked_inode()
3781 inode->i_mode = btrfs_inode_mode(leaf, inode_item); in btrfs_read_locked_inode()
3787 round_up(i_size_read(inode), fs_info->sectorsize)); in btrfs_read_locked_inode()
3789 inode_set_atime(inode, btrfs_timespec_sec(leaf, &inode_item->atime), in btrfs_read_locked_inode()
3790 btrfs_timespec_nsec(leaf, &inode_item->atime)); in btrfs_read_locked_inode()
3792 inode_set_mtime(inode, btrfs_timespec_sec(leaf, &inode_item->mtime), in btrfs_read_locked_inode()
3793 btrfs_timespec_nsec(leaf, &inode_item->mtime)); in btrfs_read_locked_inode()
3795 inode_set_ctime(inode, btrfs_timespec_sec(leaf, &inode_item->ctime), in btrfs_read_locked_inode()
3796 btrfs_timespec_nsec(leaf, &inode_item->ctime)); in btrfs_read_locked_inode()
3798 BTRFS_I(inode)->i_otime_sec = btrfs_timespec_sec(leaf, &inode_item->otime); in btrfs_read_locked_inode()
3799 BTRFS_I(inode)->i_otime_nsec = btrfs_timespec_nsec(leaf, &inode_item->otime); in btrfs_read_locked_inode()
3802 BTRFS_I(inode)->generation = btrfs_inode_generation(leaf, inode_item); in btrfs_read_locked_inode()
3803 BTRFS_I(inode)->last_trans = btrfs_inode_transid(leaf, inode_item); in btrfs_read_locked_inode()
3807 inode->i_generation = BTRFS_I(inode)->generation; in btrfs_read_locked_inode()
3808 inode->i_rdev = 0; in btrfs_read_locked_inode()
3811 BTRFS_I(inode)->index_cnt = (u64)-1; in btrfs_read_locked_inode()
3813 &BTRFS_I(inode)->flags, &BTRFS_I(inode)->ro_flags); in btrfs_read_locked_inode()
3818 * and then re-read we need to do a full sync since we don't have any in btrfs_read_locked_inode()
3822 * This is required for both inode re-read from disk and delayed inode in btrfs_read_locked_inode()
3825 if (BTRFS_I(inode)->last_trans == btrfs_get_fs_generation(fs_info)) in btrfs_read_locked_inode()
3827 &BTRFS_I(inode)->runtime_flags); in btrfs_read_locked_inode()
3842 * xfs_io -c fsync mydir/foo in btrfs_read_locked_inode()
3856 BTRFS_I(inode)->last_unlink_trans = BTRFS_I(inode)->last_trans; in btrfs_read_locked_inode()
3864 BTRFS_I(inode)->last_reflink_trans = BTRFS_I(inode)->last_trans; in btrfs_read_locked_inode()
3866 path->slots[0]++; in btrfs_read_locked_inode()
3867 if (inode->i_nlink != 1 || in btrfs_read_locked_inode()
3868 path->slots[0] >= btrfs_header_nritems(leaf)) in btrfs_read_locked_inode()
3871 btrfs_item_key_to_cpu(leaf, &location, path->slots[0]); in btrfs_read_locked_inode()
3875 ptr = btrfs_item_ptr_offset(leaf, path->slots[0]); in btrfs_read_locked_inode()
3880 BTRFS_I(inode)->dir_index = btrfs_inode_ref_index(leaf, ref); in btrfs_read_locked_inode()
3885 BTRFS_I(inode)->dir_index = btrfs_inode_extref_index(leaf, in btrfs_read_locked_inode()
3893 maybe_acls = acls_after_inode_item(leaf, path->slots[0], in btrfs_read_locked_inode()
3895 if (first_xattr_slot != -1) { in btrfs_read_locked_inode()
3896 path->slots[0] = first_xattr_slot; in btrfs_read_locked_inode()
3902 root->root_key.objectid, ret); in btrfs_read_locked_inode()
3910 switch (inode->i_mode & S_IFMT) { in btrfs_read_locked_inode()
3912 inode->i_mapping->a_ops = &btrfs_aops; in btrfs_read_locked_inode()
3913 inode->i_fop = &btrfs_file_operations; in btrfs_read_locked_inode()
3914 inode->i_op = &btrfs_file_inode_operations; in btrfs_read_locked_inode()
3917 inode->i_fop = &btrfs_dir_file_operations; in btrfs_read_locked_inode()
3918 inode->i_op = &btrfs_dir_inode_operations; in btrfs_read_locked_inode()
3921 inode->i_op = &btrfs_symlink_inode_operations; in btrfs_read_locked_inode()
3923 inode->i_mapping->a_ops = &btrfs_aops; in btrfs_read_locked_inode()
3926 inode->i_op = &btrfs_special_inode_operations; in btrfs_read_locked_inode()
3927 init_special_inode(inode, inode->i_mode, rdev); in btrfs_read_locked_inode()
3950 btrfs_set_token_inode_size(&token, item, BTRFS_I(inode)->disk_i_size); in fill_inode_item()
3951 btrfs_set_token_inode_mode(&token, item, inode->i_mode); in fill_inode_item()
3952 btrfs_set_token_inode_nlink(&token, item, inode->i_nlink); in fill_inode_item()
3954 btrfs_set_token_timespec_sec(&token, &item->atime, in fill_inode_item()
3956 btrfs_set_token_timespec_nsec(&token, &item->atime, in fill_inode_item()
3959 btrfs_set_token_timespec_sec(&token, &item->mtime, in fill_inode_item()
3961 btrfs_set_token_timespec_nsec(&token, &item->mtime, in fill_inode_item()
3964 btrfs_set_token_timespec_sec(&token, &item->ctime, in fill_inode_item()
3966 btrfs_set_token_timespec_nsec(&token, &item->ctime, in fill_inode_item()
3969 btrfs_set_token_timespec_sec(&token, &item->otime, BTRFS_I(inode)->i_otime_sec); in fill_inode_item()
3970 btrfs_set_token_timespec_nsec(&token, &item->otime, BTRFS_I(inode)->i_otime_nsec); in fill_inode_item()
3974 BTRFS_I(inode)->generation); in fill_inode_item()
3976 btrfs_set_token_inode_transid(&token, item, trans->transid); in fill_inode_item()
3977 btrfs_set_token_inode_rdev(&token, item, inode->i_rdev); in fill_inode_item()
3978 flags = btrfs_inode_combine_flags(BTRFS_I(inode)->flags, in fill_inode_item()
3979 BTRFS_I(inode)->ro_flags); in fill_inode_item()
3985 * copy everything in the in-memory inode into the btree.
3997 return -ENOMEM; in btrfs_update_inode_item()
3999 ret = btrfs_lookup_inode(trans, inode->root, path, &inode->location, 1); in btrfs_update_inode_item()
4002 ret = -ENOENT; in btrfs_update_inode_item()
4006 leaf = path->nodes[0]; in btrfs_update_inode_item()
4007 inode_item = btrfs_item_ptr(leaf, path->slots[0], in btrfs_update_inode_item()
4010 fill_inode_item(trans, leaf, inode_item, &inode->vfs_inode); in btrfs_update_inode_item()
4020 * copy everything in the in-memory inode into the btree.
4025 struct btrfs_root *root = inode->root; in btrfs_update_inode()
4026 struct btrfs_fs_info *fs_info = root->fs_info; in btrfs_update_inode()
4034 * without delay in btrfs_update_inode()
4038 && !test_bit(BTRFS_FS_LOG_RECOVERING, &fs_info->flags)) { in btrfs_update_inode()
4056 if (ret == -ENOSPC) in btrfs_update_inode_fallback()
4072 struct btrfs_root *root = dir->root; in __btrfs_unlink_inode()
4073 struct btrfs_fs_info *fs_info = root->fs_info; in __btrfs_unlink_inode()
4083 ret = -ENOMEM; in __btrfs_unlink_inode()
4087 di = btrfs_lookup_dir_item(trans, root, path, dir_ino, name, -1); in __btrfs_unlink_inode()
4089 ret = di ? PTR_ERR(di) : -ENOENT; in __btrfs_unlink_inode()
4104 * that we delay to delete it, and just do this deletion when in __btrfs_unlink_inode()
4107 if (inode->dir_index) { in __btrfs_unlink_inode()
4110 index = inode->dir_index; in __btrfs_unlink_inode()
4119 name->len, name->name, ino, dir_ino); in __btrfs_unlink_inode()
4125 rename_ctx->index = index; in __btrfs_unlink_inode()
4136 * Besides that, doing it here would only cause extra unnecessary btree in __btrfs_unlink_inode()
4146 * being run in btrfs-cleaner context. If we have enough of these built in __btrfs_unlink_inode()
4147 * up we can end up burning a lot of time in btrfs-cleaner without any in __btrfs_unlink_inode()
4159 btrfs_i_size_write(dir, dir->vfs_inode.i_size - name->len * 2); in __btrfs_unlink_inode()
4160 inode_inc_iversion(&inode->vfs_inode); in __btrfs_unlink_inode()
4161 inode_inc_iversion(&dir->vfs_inode); in __btrfs_unlink_inode()
4162 inode_set_mtime_to_ts(&dir->vfs_inode, inode_set_ctime_current(&dir->vfs_inode)); in __btrfs_unlink_inode()
4176 drop_nlink(&inode->vfs_inode); in btrfs_unlink_inode()
4192 struct btrfs_root *root = dir->root; in __unlink_start_trans()
4205 ret = fscrypt_setup_filename(dir, &dentry->d_name, 1, &fname); in btrfs_unlink()
4209 /* This needs to handle no-key deletions later on */ in btrfs_unlink()
4225 if (inode->i_nlink == 0) { in btrfs_unlink()
4233 btrfs_btree_balance_dirty(BTRFS_I(dir)->root->fs_info); in btrfs_unlink()
4242 struct btrfs_root *root = dir->root; in btrfs_unlink_subvol()
4254 ret = fscrypt_setup_filename(&dir->vfs_inode, &dentry->d_name, 1, &fname); in btrfs_unlink_subvol()
4258 /* This needs to handle no-key deletions later on */ in btrfs_unlink_subvol()
4261 objectid = inode->root->root_key.objectid; in btrfs_unlink_subvol()
4263 objectid = inode->location.objectid; in btrfs_unlink_subvol()
4267 return -EINVAL; in btrfs_unlink_subvol()
4272 ret = -ENOMEM; in btrfs_unlink_subvol()
4277 &fname.disk_name, -1); in btrfs_unlink_subvol()
4279 ret = di ? PTR_ERR(di) : -ENOENT; in btrfs_unlink_subvol()
4283 leaf = path->nodes[0]; in btrfs_unlink_subvol()
4297 * depending on btrfs_del_root_ref to return -ENOENT here is incorrect. in btrfs_unlink_subvol()
4306 ret = -ENOENT; in btrfs_unlink_subvol()
4313 leaf = path->nodes[0]; in btrfs_unlink_subvol()
4314 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]); in btrfs_unlink_subvol()
4319 root->root_key.objectid, dir_ino, in btrfs_unlink_subvol()
4333 btrfs_i_size_write(dir, dir->vfs_inode.i_size - fname.disk_name.len * 2); in btrfs_unlink_subvol()
4334 inode_inc_iversion(&dir->vfs_inode); in btrfs_unlink_subvol()
4335 inode_set_mtime_to_ts(&dir->vfs_inode, inode_set_ctime_current(&dir->vfs_inode)); in btrfs_unlink_subvol()
4351 struct btrfs_fs_info *fs_info = root->fs_info; in may_destroy_subvol()
4361 return -ENOMEM; in may_destroy_subvol()
4364 dir_id = btrfs_super_root_dir(fs_info->super_copy); in may_destroy_subvol()
4365 di = btrfs_lookup_dir_item(NULL, fs_info->tree_root, path, in may_destroy_subvol()
4368 btrfs_dir_item_key_to_cpu(path->nodes[0], di, &key); in may_destroy_subvol()
4369 if (key.objectid == root->root_key.objectid) { in may_destroy_subvol()
4370 ret = -EPERM; in may_destroy_subvol()
4379 key.objectid = root->root_key.objectid; in may_destroy_subvol()
4381 key.offset = (u64)-1; in may_destroy_subvol()
4383 ret = btrfs_search_slot(NULL, fs_info->tree_root, &key, path, 0, 0); in may_destroy_subvol()
4389 if (path->slots[0] > 0) { in may_destroy_subvol()
4390 path->slots[0]--; in may_destroy_subvol()
4391 btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]); in may_destroy_subvol()
4392 if (key.objectid == root->root_key.objectid && in may_destroy_subvol()
4394 ret = -ENOTEMPTY; in may_destroy_subvol()
4404 struct btrfs_fs_info *fs_info = root->fs_info; in btrfs_prune_dentries()
4412 WARN_ON(btrfs_root_refs(&root->root_item) != 0); in btrfs_prune_dentries()
4414 spin_lock(&root->inode_lock); in btrfs_prune_dentries()
4416 node = root->inode_tree.rb_node; in btrfs_prune_dentries()
4423 node = node->rb_left; in btrfs_prune_dentries()
4425 node = node->rb_right; in btrfs_prune_dentries()
4442 inode = igrab(&entry->vfs_inode); in btrfs_prune_dentries()
4444 spin_unlock(&root->inode_lock); in btrfs_prune_dentries()
4445 if (atomic_read(&inode->i_count) > 1) in btrfs_prune_dentries()
4453 spin_lock(&root->inode_lock); in btrfs_prune_dentries()
4457 if (cond_resched_lock(&root->inode_lock)) in btrfs_prune_dentries()
4462 spin_unlock(&root->inode_lock); in btrfs_prune_dentries()
4467 struct btrfs_fs_info *fs_info = btrfs_sb(dentry->d_sb); in btrfs_delete_subvolume()
4468 struct btrfs_root *root = dir->root; in btrfs_delete_subvolume()
4470 struct btrfs_root *dest = BTRFS_I(inode)->root; in btrfs_delete_subvolume()
4476 down_write(&fs_info->subvol_sem); in btrfs_delete_subvolume()
4483 spin_lock(&dest->root_item_lock); in btrfs_delete_subvolume()
4484 if (dest->send_in_progress) { in btrfs_delete_subvolume()
4485 spin_unlock(&dest->root_item_lock); in btrfs_delete_subvolume()
4488 dest->root_key.objectid); in btrfs_delete_subvolume()
4489 ret = -EPERM; in btrfs_delete_subvolume()
4492 if (atomic_read(&dest->nr_swapfiles)) { in btrfs_delete_subvolume()
4493 spin_unlock(&dest->root_item_lock); in btrfs_delete_subvolume()
4496 root->root_key.objectid); in btrfs_delete_subvolume()
4497 ret = -EPERM; in btrfs_delete_subvolume()
4500 root_flags = btrfs_root_flags(&dest->root_item); in btrfs_delete_subvolume()
4501 btrfs_set_root_flags(&dest->root_item, in btrfs_delete_subvolume()
4503 spin_unlock(&dest->root_item_lock); in btrfs_delete_subvolume()
4524 trans->block_rsv = &block_rsv; in btrfs_delete_subvolume()
4525 trans->bytes_reserved = block_rsv.size; in btrfs_delete_subvolume()
4541 memset(&dest->root_item.drop_progress, 0, in btrfs_delete_subvolume()
4542 sizeof(dest->root_item.drop_progress)); in btrfs_delete_subvolume()
4543 btrfs_set_root_drop_level(&dest->root_item, 0); in btrfs_delete_subvolume()
4544 btrfs_set_root_refs(&dest->root_item, 0); in btrfs_delete_subvolume()
4546 if (!test_and_set_bit(BTRFS_ROOT_ORPHAN_ITEM_INSERTED, &dest->state)) { in btrfs_delete_subvolume()
4548 fs_info->tree_root, in btrfs_delete_subvolume()
4549 dest->root_key.objectid); in btrfs_delete_subvolume()
4556 ret = btrfs_uuid_tree_remove(trans, dest->root_item.uuid, in btrfs_delete_subvolume()
4558 dest->root_key.objectid); in btrfs_delete_subvolume()
4559 if (ret && ret != -ENOENT) { in btrfs_delete_subvolume()
4563 if (!btrfs_is_empty_uuid(dest->root_item.received_uuid)) { in btrfs_delete_subvolume()
4565 dest->root_item.received_uuid, in btrfs_delete_subvolume()
4567 dest->root_key.objectid); in btrfs_delete_subvolume()
4568 if (ret && ret != -ENOENT) { in btrfs_delete_subvolume()
4574 free_anon_bdev(dest->anon_dev); in btrfs_delete_subvolume()
4575 dest->anon_dev = 0; in btrfs_delete_subvolume()
4577 trans->block_rsv = NULL; in btrfs_delete_subvolume()
4578 trans->bytes_reserved = 0; in btrfs_delete_subvolume()
4580 inode->i_flags |= S_DEAD; in btrfs_delete_subvolume()
4585 spin_lock(&dest->root_item_lock); in btrfs_delete_subvolume()
4586 root_flags = btrfs_root_flags(&dest->root_item); in btrfs_delete_subvolume()
4587 btrfs_set_root_flags(&dest->root_item, in btrfs_delete_subvolume()
4589 spin_unlock(&dest->root_item_lock); in btrfs_delete_subvolume()
4592 up_write(&fs_info->subvol_sem); in btrfs_delete_subvolume()
4596 ASSERT(dest->send_in_progress == 0); in btrfs_delete_subvolume()
4605 struct btrfs_fs_info *fs_info = BTRFS_I(inode)->root->fs_info; in btrfs_rmdir()
4611 if (inode->i_size > BTRFS_EMPTY_DIR_SIZE) in btrfs_rmdir()
4612 return -ENOTEMPTY; in btrfs_rmdir()
4617 return -EOPNOTSUPP; in btrfs_rmdir()
4622 err = fscrypt_setup_filename(dir, &dentry->d_name, 1, &fname); in btrfs_rmdir()
4626 /* This needs to handle no-key deletions later on */ in btrfs_rmdir()
4643 last_unlink_trans = BTRFS_I(inode)->last_unlink_trans; in btrfs_rmdir()
4661 if (last_unlink_trans >= trans->transid) in btrfs_rmdir()
4662 BTRFS_I(dir)->last_unlink_trans = last_unlink_trans; in btrfs_rmdir()
4676 * @inode - inode that we're zeroing
4677 * @from - the offset to start zeroing
4678 * @len - the length to zero, 0 to zero the entire range respective to the
4680 * @front - zero up to the offset instead of from the offset on
4688 struct btrfs_fs_info *fs_info = inode->root->fs_info; in btrfs_truncate_block()
4689 struct address_space *mapping = inode->vfs_inode.i_mapping; in btrfs_truncate_block()
4690 struct extent_io_tree *io_tree = &inode->io_tree; in btrfs_truncate_block()
4695 u32 blocksize = fs_info->sectorsize; in btrfs_truncate_block()
4697 unsigned offset = from & (blocksize - 1); in btrfs_truncate_block()
4710 block_end = block_start + blocksize - 1; in btrfs_truncate_block()
4735 ret = -ENOMEM; in btrfs_truncate_block()
4742 if (page->mapping != mapping) { in btrfs_truncate_block()
4748 ret = -EIO; in btrfs_truncate_block()
4754 * We unlock the page after the io is completed and then re-lock it in btrfs_truncate_block()
4777 clear_extent_bit(&inode->io_tree, block_start, block_end, in btrfs_truncate_block()
4790 len = blocksize - offset; in btrfs_truncate_block()
4792 memzero_page(page, (block_start - page_offset(page)), in btrfs_truncate_block()
4795 memzero_page(page, (block_start - page_offset(page)) + offset, in btrfs_truncate_block()
4799 block_end + 1 - block_start); in btrfs_truncate_block()
4801 block_end + 1 - block_start); in btrfs_truncate_block()
4805 set_extent_bit(&inode->io_tree, block_start, block_end, in btrfs_truncate_block()
4828 struct btrfs_root *root = inode->root; in maybe_insert_hole()
4829 struct btrfs_fs_info *fs_info = root->fs_info; in maybe_insert_hole()
4844 * 1 - for the one we're dropping in maybe_insert_hole()
4845 * 1 - for the one we're adding in maybe_insert_hole()
4846 * 1 - for updating the inode. in maybe_insert_hole()
4882 struct btrfs_root *root = inode->root; in btrfs_cont_expand()
4883 struct btrfs_fs_info *fs_info = root->fs_info; in btrfs_cont_expand()
4884 struct extent_io_tree *io_tree = &inode->io_tree; in btrfs_cont_expand()
4887 u64 hole_start = ALIGN(oldsize, fs_info->sectorsize); in btrfs_cont_expand()
4888 u64 block_end = ALIGN(size, fs_info->sectorsize); in btrfs_cont_expand()
4906 btrfs_lock_and_flush_ordered_range(inode, hole_start, block_end - 1, in btrfs_cont_expand()
4911 block_end - cur_offset); in btrfs_cont_expand()
4918 last_byte = ALIGN(last_byte, fs_info->sectorsize); in btrfs_cont_expand()
4919 hole_size = last_byte - cur_offset; in btrfs_cont_expand()
4921 if (!(em->flags & EXTENT_FLAG_PREALLOC)) { in btrfs_cont_expand()
4936 cur_offset + hole_size - 1, in btrfs_cont_expand()
4941 hole_em->start = cur_offset; in btrfs_cont_expand()
4942 hole_em->len = hole_size; in btrfs_cont_expand()
4943 hole_em->orig_start = cur_offset; in btrfs_cont_expand()
4945 hole_em->block_start = EXTENT_MAP_HOLE; in btrfs_cont_expand()
4946 hole_em->block_len = 0; in btrfs_cont_expand()
4947 hole_em->orig_block_len = 0; in btrfs_cont_expand()
4948 hole_em->ram_bytes = hole_size; in btrfs_cont_expand()
4949 hole_em->generation = btrfs_get_fs_generation(fs_info); in btrfs_cont_expand()
4967 unlock_extent(io_tree, hole_start, block_end - 1, &cached_state); in btrfs_cont_expand()
4973 struct btrfs_root *root = BTRFS_I(inode)->root; in btrfs_setsize()
4976 loff_t newsize = attr->ia_size; in btrfs_setsize()
4977 int mask = attr->ia_valid; in btrfs_setsize()
4998 * state of this file - if the snapshot captures this expanding in btrfs_setsize()
5002 btrfs_drew_write_lock(&root->snapshot_lock); in btrfs_setsize()
5005 btrfs_drew_write_unlock(&root->snapshot_lock); in btrfs_setsize()
5011 btrfs_drew_write_unlock(&root->snapshot_lock); in btrfs_setsize()
5019 btrfs_drew_write_unlock(&root->snapshot_lock); in btrfs_setsize()
5022 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); in btrfs_setsize()
5026 ALIGN(newsize, fs_info->sectorsize), in btrfs_setsize()
5027 (u64)-1); in btrfs_setsize()
5039 &BTRFS_I(inode)->runtime_flags); in btrfs_setsize()
5046 if (ret && inode->i_nlink) { in btrfs_setsize()
5050 * Truncate failed, so fix up the in-memory size. We in btrfs_setsize()
5053 * in-memory size to match. in btrfs_setsize()
5055 err = btrfs_wait_ordered_range(inode, 0, (u64)-1); in btrfs_setsize()
5058 i_size_write(inode, BTRFS_I(inode)->disk_i_size); in btrfs_setsize()
5069 struct btrfs_root *root = BTRFS_I(inode)->root; in btrfs_setattr()
5073 return -EROFS; in btrfs_setattr()
5079 if (S_ISREG(inode->i_mode) && (attr->ia_valid & ATTR_SIZE)) { in btrfs_setattr()
5085 if (attr->ia_valid) { in btrfs_setattr()
5090 if (!err && attr->ia_valid & ATTR_MODE) in btrfs_setattr()
5091 err = posix_acl_chmod(idmap, dentry, inode->i_mode); in btrfs_setattr()
5112 struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree; in evict_inode_truncate_pages()
5115 ASSERT(inode->i_state & I_FREEING); in evict_inode_truncate_pages()
5116 truncate_inode_pages_final(&inode->i_data); in evict_inode_truncate_pages()
5118 btrfs_drop_extent_map_range(BTRFS_I(inode), 0, (u64)-1, false); in evict_inode_truncate_pages()
5128 * queue kthread), inode references (inode->i_count) were not taken in evict_inode_truncate_pages()
5132 * reference count - if we don't do it, when they access the inode's in evict_inode_truncate_pages()
5134 * use-after-free issue. in evict_inode_truncate_pages()
5136 spin_lock(&io_tree->lock); in evict_inode_truncate_pages()
5137 while (!RB_EMPTY_ROOT(&io_tree->state)) { in evict_inode_truncate_pages()
5144 node = rb_first(&io_tree->state); in evict_inode_truncate_pages()
5146 start = state->start; in evict_inode_truncate_pages()
5147 end = state->end; in evict_inode_truncate_pages()
5148 state_flags = state->state; in evict_inode_truncate_pages()
5149 spin_unlock(&io_tree->lock); in evict_inode_truncate_pages()
5163 end - start + 1, NULL); in evict_inode_truncate_pages()
5170 spin_lock(&io_tree->lock); in evict_inode_truncate_pages()
5172 spin_unlock(&io_tree->lock); in evict_inode_truncate_pages()
5178 struct btrfs_fs_info *fs_info = root->fs_info; in evict_refill_and_join()
5190 * above. We reserve our extra bit here because we generate a ton of in evict_refill_and_join()
5194 * if we fail to make this reservation we can re-try without the in evict_refill_and_join()
5197 ret = btrfs_block_rsv_refill(fs_info, rsv, rsv->size + delayed_refs_extra, in evict_refill_and_join()
5200 ret = btrfs_block_rsv_refill(fs_info, rsv, rsv->size, in evict_refill_and_join()
5205 return ERR_PTR(-ENOSPC); in evict_refill_and_join()
5215 trans->block_rsv = &fs_info->trans_block_rsv; in evict_refill_and_join()
5216 trans->bytes_reserved = delayed_refs_extra; in evict_refill_and_join()
5217 btrfs_block_rsv_migrate(rsv, trans->block_rsv, in evict_refill_and_join()
5225 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); in btrfs_evict_inode()
5227 struct btrfs_root *root = BTRFS_I(inode)->root; in btrfs_evict_inode()
5241 if (inode->i_nlink && in btrfs_evict_inode()
5242 ((btrfs_root_refs(&root->root_item) != 0 && in btrfs_evict_inode()
5243 root->root_key.objectid != BTRFS_ROOT_TREE_OBJECTID) || in btrfs_evict_inode()
5250 if (test_bit(BTRFS_FS_LOG_RECOVERING, &fs_info->flags)) in btrfs_evict_inode()
5253 if (inode->i_nlink > 0) { in btrfs_evict_inode()
5254 BUG_ON(btrfs_root_refs(&root->root_item) != 0 && in btrfs_evict_inode()
5255 root->root_key.objectid != BTRFS_ROOT_TREE_OBJECTID); in btrfs_evict_inode()
5278 rsv->size = btrfs_calc_metadata_size(fs_info, 1); in btrfs_evict_inode()
5279 rsv->failfast = true; in btrfs_evict_inode()
5295 trans->block_rsv = rsv; in btrfs_evict_inode()
5298 trans->block_rsv = &fs_info->trans_block_rsv; in btrfs_evict_inode()
5306 if (ret && ret != -ENOSPC && ret != -EAGAIN) in btrfs_evict_inode()
5323 trans->block_rsv = rsv; in btrfs_evict_inode()
5325 trans->block_rsv = &fs_info->trans_block_rsv; in btrfs_evict_inode()
5345 * If no dir entries were found, returns -ENOENT.
5346 * If found a corrupted location in dir entry, returns -EUCLEAN.
5353 struct btrfs_root *root = dir->root; in btrfs_inode_by_name()
5359 return -ENOMEM; in btrfs_inode_by_name()
5361 ret = fscrypt_setup_filename(&dir->vfs_inode, &dentry->d_name, 1, &fname); in btrfs_inode_by_name()
5370 /* This needs to handle no-key deletions later on */ in btrfs_inode_by_name()
5375 ret = di ? PTR_ERR(di) : -ENOENT; in btrfs_inode_by_name()
5379 btrfs_dir_item_key_to_cpu(path->nodes[0], di, location); in btrfs_inode_by_name()
5380 if (location->type != BTRFS_INODE_ITEM_KEY && in btrfs_inode_by_name()
5381 location->type != BTRFS_ROOT_ITEM_KEY) { in btrfs_inode_by_name()
5382 ret = -EUCLEAN; in btrfs_inode_by_name()
5383 btrfs_warn(root->fs_info, in btrfs_inode_by_name()
5386 location->objectid, location->type, location->offset); in btrfs_inode_by_name()
5389 *type = btrfs_dir_ftype(path->nodes[0], di); in btrfs_inode_by_name()
5416 ret = fscrypt_setup_filename(&dir->vfs_inode, &dentry->d_name, 0, &fname); in fixup_tree_root_location()
5422 err = -ENOMEM; in fixup_tree_root_location()
5426 err = -ENOENT; in fixup_tree_root_location()
5427 key.objectid = dir->root->root_key.objectid; in fixup_tree_root_location()
5429 key.offset = location->objectid; in fixup_tree_root_location()
5431 ret = btrfs_search_slot(NULL, fs_info->tree_root, &key, path, 0, 0); in fixup_tree_root_location()
5438 leaf = path->nodes[0]; in fixup_tree_root_location()
5439 ref = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_root_ref); in fixup_tree_root_location()
5451 new_root = btrfs_get_fs_root(fs_info, location->objectid, true); in fixup_tree_root_location()
5458 location->objectid = btrfs_root_dirid(&new_root->root_item); in fixup_tree_root_location()
5459 location->type = BTRFS_INODE_ITEM_KEY; in fixup_tree_root_location()
5460 location->offset = 0; in fixup_tree_root_location()
5470 struct btrfs_root *root = inode->root; in inode_tree_add()
5474 struct rb_node *new = &inode->rb_node; in inode_tree_add()
5477 if (inode_unhashed(&inode->vfs_inode)) in inode_tree_add()
5480 spin_lock(&root->inode_lock); in inode_tree_add()
5481 p = &root->inode_tree.rb_node; in inode_tree_add()
5487 p = &parent->rb_left; in inode_tree_add()
5489 p = &parent->rb_right; in inode_tree_add()
5491 WARN_ON(!(entry->vfs_inode.i_state & in inode_tree_add()
5493 rb_replace_node(parent, new, &root->inode_tree); in inode_tree_add()
5495 spin_unlock(&root->inode_lock); in inode_tree_add()
5500 rb_insert_color(new, &root->inode_tree); in inode_tree_add()
5501 spin_unlock(&root->inode_lock); in inode_tree_add()
5506 struct btrfs_root *root = inode->root; in inode_tree_del()
5509 spin_lock(&root->inode_lock); in inode_tree_del()
5510 if (!RB_EMPTY_NODE(&inode->rb_node)) { in inode_tree_del()
5511 rb_erase(&inode->rb_node, &root->inode_tree); in inode_tree_del()
5512 RB_CLEAR_NODE(&inode->rb_node); in inode_tree_del()
5513 empty = RB_EMPTY_ROOT(&root->inode_tree); in inode_tree_del()
5515 spin_unlock(&root->inode_lock); in inode_tree_del()
5517 if (empty && btrfs_root_refs(&root->root_item) == 0) { in inode_tree_del()
5518 spin_lock(&root->inode_lock); in inode_tree_del()
5519 empty = RB_EMPTY_ROOT(&root->inode_tree); in inode_tree_del()
5520 spin_unlock(&root->inode_lock); in inode_tree_del()
5531 inode->i_ino = args->ino; in btrfs_init_locked_inode()
5532 BTRFS_I(inode)->location.objectid = args->ino; in btrfs_init_locked_inode()
5533 BTRFS_I(inode)->location.type = BTRFS_INODE_ITEM_KEY; in btrfs_init_locked_inode()
5534 BTRFS_I(inode)->location.offset = 0; in btrfs_init_locked_inode()
5535 BTRFS_I(inode)->root = btrfs_grab_root(args->root); in btrfs_init_locked_inode()
5536 BUG_ON(args->root && !BTRFS_I(inode)->root); in btrfs_init_locked_inode()
5538 if (args->root && args->root == args->root->fs_info->tree_root && in btrfs_init_locked_inode()
5539 args->ino != BTRFS_BTREE_INODE_OBJECTID) in btrfs_init_locked_inode()
5541 &BTRFS_I(inode)->runtime_flags); in btrfs_init_locked_inode()
5549 return args->ino == BTRFS_I(inode)->location.objectid && in btrfs_find_actor()
5550 args->root == BTRFS_I(inode)->root; in btrfs_find_actor()
5582 return ERR_PTR(-ENOMEM); in btrfs_iget_path()
5584 if (inode->i_state & I_NEW) { in btrfs_iget_path()
5599 ret = -ENOENT; in btrfs_iget_path()
5617 struct inode *inode = new_inode(dir->i_sb); in new_simple_dir()
5620 return ERR_PTR(-ENOMEM); in new_simple_dir()
5622 BTRFS_I(inode)->root = btrfs_grab_root(root); in new_simple_dir()
5623 memcpy(&BTRFS_I(inode)->location, key, sizeof(*key)); in new_simple_dir()
5624 set_bit(BTRFS_INODE_DUMMY, &BTRFS_I(inode)->runtime_flags); in new_simple_dir()
5626 inode->i_ino = BTRFS_EMPTY_SUBVOL_DIR_OBJECTID; in new_simple_dir()
5628 * We only need lookup, the rest is read-only and there's no inode in new_simple_dir()
5631 inode->i_op = &simple_dir_inode_operations; in new_simple_dir()
5632 inode->i_opflags &= ~IOP_XATTR; in new_simple_dir()
5633 inode->i_fop = &simple_dir_operations; in new_simple_dir()
5634 inode->i_mode = S_IFDIR | S_IRUGO | S_IWUSR | S_IXUGO; in new_simple_dir()
5639 BTRFS_I(inode)->i_otime_sec = ts.tv_sec; in new_simple_dir()
5640 BTRFS_I(inode)->i_otime_nsec = ts.tv_nsec; in new_simple_dir()
5642 inode->i_uid = dir->i_uid; in new_simple_dir()
5643 inode->i_gid = dir->i_gid; in new_simple_dir()
5659 return fs_umode_to_ftype(inode->i_mode); in btrfs_inode_type()
5664 struct btrfs_fs_info *fs_info = btrfs_sb(dir->i_sb); in btrfs_lookup_dentry()
5666 struct btrfs_root *root = BTRFS_I(dir)->root; in btrfs_lookup_dentry()
5672 if (dentry->d_name.len > BTRFS_NAME_LEN) in btrfs_lookup_dentry()
5673 return ERR_PTR(-ENAMETOOLONG); in btrfs_lookup_dentry()
5680 inode = btrfs_iget(dir->i_sb, location.objectid, root); in btrfs_lookup_dentry()
5684 /* Do extra check against inode mode with di_type */ in btrfs_lookup_dentry()
5688 inode->i_mode, btrfs_inode_type(inode), in btrfs_lookup_dentry()
5691 return ERR_PTR(-EUCLEAN); in btrfs_lookup_dentry()
5699 if (ret != -ENOENT) in btrfs_lookup_dentry()
5704 inode = btrfs_iget(dir->i_sb, location.objectid, sub_root); in btrfs_lookup_dentry()
5710 down_read(&fs_info->cleanup_work_sem); in btrfs_lookup_dentry()
5711 if (!sb_rdonly(inode->i_sb)) in btrfs_lookup_dentry()
5713 up_read(&fs_info->cleanup_work_sem); in btrfs_lookup_dentry()
5729 inode = d_inode(dentry->d_parent); in btrfs_dentry_delete()
5732 root = BTRFS_I(inode)->root; in btrfs_dentry_delete()
5733 if (btrfs_root_refs(&root->root_item) == 0) in btrfs_dentry_delete()
5747 if (inode == ERR_PTR(-ENOENT)) in btrfs_lookup()
5754 * in-memory index_cnt variable to the first free sequence number.
5758 struct btrfs_root *root = inode->root; in btrfs_set_inode_index_count()
5766 key.offset = (u64)-1; in btrfs_set_inode_index_count()
5770 return -ENOMEM; in btrfs_set_inode_index_count()
5780 if (path->slots[0] == 0) { in btrfs_set_inode_index_count()
5781 inode->index_cnt = BTRFS_DIR_START_INDEX; in btrfs_set_inode_index_count()
5785 path->slots[0]--; in btrfs_set_inode_index_count()
5787 leaf = path->nodes[0]; in btrfs_set_inode_index_count()
5788 btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]); in btrfs_set_inode_index_count()
5792 inode->index_cnt = BTRFS_DIR_START_INDEX; in btrfs_set_inode_index_count()
5796 inode->index_cnt = found_key.offset + 1; in btrfs_set_inode_index_count()
5807 if (dir->index_cnt == (u64)-1) { in btrfs_get_dir_last_index()
5817 *index = dir->index_cnt - 1; in btrfs_get_dir_last_index()
5845 return -ENOMEM; in btrfs_opendir()
5846 private->last_index = last_index; in btrfs_opendir()
5847 private->filldir_buf = kzalloc(PAGE_SIZE, GFP_KERNEL); in btrfs_opendir()
5848 if (!private->filldir_buf) { in btrfs_opendir()
5850 return -ENOMEM; in btrfs_opendir()
5852 file->private_data = private; in btrfs_opendir()
5858 struct btrfs_file_private *private = file->private_data; in btrfs_dir_llseek()
5862 &private->last_index); in btrfs_dir_llseek()
5878 while (entries--) { in btrfs_filldir()
5882 ctx->pos = get_unaligned(&entry->offset); in btrfs_filldir()
5883 if (!dir_emit(ctx, name, get_unaligned(&entry->name_len), in btrfs_filldir()
5884 get_unaligned(&entry->ino), in btrfs_filldir()
5885 get_unaligned(&entry->type))) in btrfs_filldir()
5888 get_unaligned(&entry->name_len); in btrfs_filldir()
5889 ctx->pos++; in btrfs_filldir()
5897 struct btrfs_root *root = BTRFS_I(inode)->root; in btrfs_real_readdir()
5898 struct btrfs_file_private *private = file->private_data; in btrfs_real_readdir()
5919 return -ENOMEM; in btrfs_real_readdir()
5921 addr = private->filldir_buf; in btrfs_real_readdir()
5922 path->reada = READA_FORWARD; in btrfs_real_readdir()
5924 put = btrfs_readdir_get_delayed_items(inode, private->last_index, in btrfs_real_readdir()
5929 key.offset = ctx->pos; in btrfs_real_readdir()
5934 struct extent_buffer *leaf = path->nodes[0]; in btrfs_real_readdir()
5941 if (found_key.offset < ctx->pos) in btrfs_real_readdir()
5943 if (found_key.offset > private->last_index) in btrfs_real_readdir()
5947 di = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_dir_item); in btrfs_real_readdir()
5952 ret = btrfs_filldir(private->filldir_buf, entries, ctx); in btrfs_real_readdir()
5955 addr = private->filldir_buf; in btrfs_real_readdir()
5966 put_unaligned(name_len, &entry->name_len); in btrfs_real_readdir()
5967 put_unaligned(fs_ftype_to_dtype(ftype), &entry->type); in btrfs_real_readdir()
5969 put_unaligned(location.objectid, &entry->ino); in btrfs_real_readdir()
5970 put_unaligned(found_key.offset, &entry->offset); in btrfs_real_readdir()
5981 ret = btrfs_filldir(private->filldir_buf, entries, ctx); in btrfs_real_readdir()
5997 * they're returned by readdir. Until we re-use freed offsets in btrfs_real_readdir()
6006 if (ctx->pos >= INT_MAX) in btrfs_real_readdir()
6007 ctx->pos = LLONG_MAX; in btrfs_real_readdir()
6009 ctx->pos = INT_MAX; in btrfs_real_readdir()
6027 struct btrfs_root *root = inode->root; in btrfs_dirty_inode()
6028 struct btrfs_fs_info *fs_info = root->fs_info; in btrfs_dirty_inode()
6032 if (test_bit(BTRFS_INODE_DUMMY, &inode->runtime_flags)) in btrfs_dirty_inode()
6040 if (ret == -ENOSPC || ret == -EDQUOT) { in btrfs_dirty_inode()
6050 if (inode->delayed_node) in btrfs_dirty_inode()
6062 struct btrfs_root *root = BTRFS_I(inode)->root; in btrfs_update_time()
6066 return -EROFS; in btrfs_update_time()
6080 if (dir->index_cnt == (u64)-1) { in btrfs_set_inode_index()
6089 *index = dir->index_cnt; in btrfs_set_inode_index()
6090 dir->index_cnt++; in btrfs_set_inode_index()
6099 args.ino = BTRFS_I(inode)->location.objectid; in btrfs_insert_inode_locked()
6100 args.root = BTRFS_I(inode)->root; in btrfs_insert_inode_locked()
6103 btrfs_inode_hash(inode->i_ino, BTRFS_I(inode)->root), in btrfs_insert_inode_locked()
6110 struct inode *dir = args->dir; in btrfs_new_inode_prepare()
6111 struct inode *inode = args->inode; in btrfs_new_inode_prepare()
6114 if (!args->orphan) { in btrfs_new_inode_prepare()
6115 ret = fscrypt_setup_filename(dir, &args->dentry->d_name, 0, in btrfs_new_inode_prepare()
6116 &args->fname); in btrfs_new_inode_prepare()
6121 ret = posix_acl_create(dir, &inode->i_mode, &args->default_acl, &args->acl); in btrfs_new_inode_prepare()
6123 fscrypt_free_filename(&args->fname); in btrfs_new_inode_prepare()
6130 if (BTRFS_I(dir)->prop_compress) in btrfs_new_inode_prepare()
6133 if (args->default_acl) in btrfs_new_inode_prepare()
6136 if (args->acl) in btrfs_new_inode_prepare()
6140 if (dir->i_security) in btrfs_new_inode_prepare()
6143 if (args->orphan) { in btrfs_new_inode_prepare()
6163 posix_acl_release(args->acl); in btrfs_new_inode_args_destroy()
6164 posix_acl_release(args->default_acl); in btrfs_new_inode_args_destroy()
6165 fscrypt_free_filename(&args->fname); in btrfs_new_inode_args_destroy()
6177 flags = dir->flags; in btrfs_inherit_iflags()
6180 inode->flags &= ~BTRFS_INODE_COMPRESS; in btrfs_inherit_iflags()
6181 inode->flags |= BTRFS_INODE_NOCOMPRESS; in btrfs_inherit_iflags()
6183 inode->flags &= ~BTRFS_INODE_NOCOMPRESS; in btrfs_inherit_iflags()
6184 inode->flags |= BTRFS_INODE_COMPRESS; in btrfs_inherit_iflags()
6188 inode->flags |= BTRFS_INODE_NODATACOW; in btrfs_inherit_iflags()
6189 if (S_ISREG(inode->vfs_inode.i_mode)) in btrfs_inherit_iflags()
6190 inode->flags |= BTRFS_INODE_NODATASUM; in btrfs_inherit_iflags()
6193 btrfs_sync_inode_flags_to_i_flags(&inode->vfs_inode); in btrfs_inherit_iflags()
6200 struct inode *dir = args->dir; in btrfs_create_new_inode()
6201 struct inode *inode = args->inode; in btrfs_create_new_inode()
6202 const struct fscrypt_str *name = args->orphan ? NULL : &args->fname.disk_name; in btrfs_create_new_inode()
6203 struct btrfs_fs_info *fs_info = btrfs_sb(dir->i_sb); in btrfs_create_new_inode()
6218 return -ENOMEM; in btrfs_create_new_inode()
6220 if (!args->subvol) in btrfs_create_new_inode()
6221 BTRFS_I(inode)->root = btrfs_grab_root(BTRFS_I(dir)->root); in btrfs_create_new_inode()
6222 root = BTRFS_I(inode)->root; in btrfs_create_new_inode()
6227 inode->i_ino = objectid; in btrfs_create_new_inode()
6229 if (args->orphan) { in btrfs_create_new_inode()
6238 ret = btrfs_set_inode_index(BTRFS_I(dir), &BTRFS_I(inode)->dir_index); in btrfs_create_new_inode()
6243 BTRFS_I(inode)->index_cnt = BTRFS_DIR_START_INDEX; in btrfs_create_new_inode()
6244 BTRFS_I(inode)->generation = trans->transid; in btrfs_create_new_inode()
6245 inode->i_generation = BTRFS_I(inode)->generation; in btrfs_create_new_inode()
6252 set_bit(BTRFS_INODE_NO_CAP_XATTR, &BTRFS_I(inode)->runtime_flags); in btrfs_create_new_inode()
6259 if (!args->subvol) in btrfs_create_new_inode()
6262 if (S_ISREG(inode->i_mode)) { in btrfs_create_new_inode()
6264 BTRFS_I(inode)->flags |= BTRFS_INODE_NODATASUM; in btrfs_create_new_inode()
6266 BTRFS_I(inode)->flags |= BTRFS_INODE_NODATACOW | in btrfs_create_new_inode()
6270 location = &BTRFS_I(inode)->location; in btrfs_create_new_inode()
6271 location->objectid = objectid; in btrfs_create_new_inode()
6272 location->offset = 0; in btrfs_create_new_inode()
6273 location->type = BTRFS_INODE_ITEM_KEY; in btrfs_create_new_inode()
6277 if (!args->orphan) in btrfs_create_new_inode()
6278 BTRFS_I(dir)->index_cnt--; in btrfs_create_new_inode()
6296 if (!args->orphan) { in btrfs_create_new_inode()
6305 if (args->subvol) { in btrfs_create_new_inode()
6310 sizes[1] = name->len + sizeof(*ref); in btrfs_create_new_inode()
6316 batch.total_data_size = sizes[0] + (args->orphan ? 0 : sizes[1]); in btrfs_create_new_inode()
6317 batch.nr = args->orphan ? 1 : 2; in btrfs_create_new_inode()
6325 BTRFS_I(inode)->i_otime_sec = ts.tv_sec; in btrfs_create_new_inode()
6326 BTRFS_I(inode)->i_otime_nsec = ts.tv_nsec; in btrfs_create_new_inode()
6333 inode_item = btrfs_item_ptr(path->nodes[0], path->slots[0], in btrfs_create_new_inode()
6335 memzero_extent_buffer(path->nodes[0], (unsigned long)inode_item, in btrfs_create_new_inode()
6337 fill_inode_item(trans, path->nodes[0], inode_item, inode); in btrfs_create_new_inode()
6339 if (!args->orphan) { in btrfs_create_new_inode()
6340 ref = btrfs_item_ptr(path->nodes[0], path->slots[0] + 1, in btrfs_create_new_inode()
6343 if (args->subvol) { in btrfs_create_new_inode()
6344 btrfs_set_inode_ref_name_len(path->nodes[0], ref, 2); in btrfs_create_new_inode()
6345 btrfs_set_inode_ref_index(path->nodes[0], ref, 0); in btrfs_create_new_inode()
6346 write_extent_buffer(path->nodes[0], "..", ptr, 2); in btrfs_create_new_inode()
6348 btrfs_set_inode_ref_name_len(path->nodes[0], ref, in btrfs_create_new_inode()
6349 name->len); in btrfs_create_new_inode()
6350 btrfs_set_inode_ref_index(path->nodes[0], ref, in btrfs_create_new_inode()
6351 BTRFS_I(inode)->dir_index); in btrfs_create_new_inode()
6352 write_extent_buffer(path->nodes[0], name->name, ptr, in btrfs_create_new_inode()
6353 name->len); in btrfs_create_new_inode()
6357 btrfs_mark_buffer_dirty(trans, path->nodes[0]); in btrfs_create_new_inode()
6366 if (args->subvol) { in btrfs_create_new_inode()
6373 parent = btrfs_iget(fs_info->sb, BTRFS_FIRST_FREE_OBJECTID, in btrfs_create_new_inode()
6374 BTRFS_I(dir)->root); in btrfs_create_new_inode()
6387 btrfs_ino(BTRFS_I(inode)), root->root_key.objectid, in btrfs_create_new_inode()
6395 if (!args->subvol) { in btrfs_create_new_inode()
6410 if (args->orphan) { in btrfs_create_new_inode()
6414 0, BTRFS_I(inode)->dir_index); in btrfs_create_new_inode()
6447 struct btrfs_root *root = parent_inode->root; in btrfs_add_link()
6452 memcpy(&key, &inode->root->root_key, sizeof(key)); in btrfs_add_link()
6461 root->root_key.objectid, parent_ino, in btrfs_add_link()
6473 btrfs_inode_type(&inode->vfs_inode), index); in btrfs_add_link()
6474 if (ret == -EEXIST || ret == -EOVERFLOW) in btrfs_add_link()
6481 btrfs_i_size_write(parent_inode, parent_inode->vfs_inode.i_size + in btrfs_add_link()
6482 name->len * 2); in btrfs_add_link()
6483 inode_inc_iversion(&parent_inode->vfs_inode); in btrfs_add_link()
6490 if (!test_bit(BTRFS_FS_LOG_RECOVERING, &root->fs_info->flags)) in btrfs_add_link()
6491 inode_set_mtime_to_ts(&parent_inode->vfs_inode, in btrfs_add_link()
6492 inode_set_ctime_current(&parent_inode->vfs_inode)); in btrfs_add_link()
6504 root->root_key.objectid, parent_ino, in btrfs_add_link()
6525 struct btrfs_fs_info *fs_info = btrfs_sb(dir->i_sb); in btrfs_create_common()
6526 struct btrfs_root *root = BTRFS_I(dir)->root; in btrfs_create_common()
6565 inode = new_inode(dir->i_sb); in btrfs_mknod()
6567 return -ENOMEM; in btrfs_mknod()
6569 inode->i_op = &btrfs_special_inode_operations; in btrfs_mknod()
6570 init_special_inode(inode, inode->i_mode, rdev); in btrfs_mknod()
6579 inode = new_inode(dir->i_sb); in btrfs_create()
6581 return -ENOMEM; in btrfs_create()
6583 inode->i_fop = &btrfs_file_operations; in btrfs_create()
6584 inode->i_op = &btrfs_file_inode_operations; in btrfs_create()
6585 inode->i_mapping->a_ops = &btrfs_aops; in btrfs_create()
6593 struct btrfs_root *root = BTRFS_I(dir)->root; in btrfs_link()
6595 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); in btrfs_link()
6602 if (root->root_key.objectid != BTRFS_I(inode)->root->root_key.objectid) in btrfs_link()
6603 return -EXDEV; in btrfs_link()
6605 if (inode->i_nlink >= BTRFS_LINK_MAX) in btrfs_link()
6606 return -EMLINK; in btrfs_link()
6608 err = fscrypt_setup_filename(dir, &dentry->d_name, 0, &fname); in btrfs_link()
6622 trans = btrfs_start_transaction(root, inode->i_nlink ? 5 : 6); in btrfs_link()
6630 BTRFS_I(inode)->dir_index = 0ULL; in btrfs_link()
6635 set_bit(BTRFS_INODE_COPY_EVERYTHING, &BTRFS_I(inode)->runtime_flags); in btrfs_link()
6643 struct dentry *parent = dentry->d_parent; in btrfs_link()
6648 if (inode->i_nlink == 1) { in btrfs_link()
6678 inode = new_inode(dir->i_sb); in btrfs_mkdir()
6680 return -ENOMEM; in btrfs_mkdir()
6682 inode->i_op = &btrfs_dir_inode_operations; in btrfs_mkdir()
6683 inode->i_fop = &btrfs_dir_file_operations; in btrfs_mkdir()
6692 struct extent_buffer *leaf = path->nodes[0]; in uncompress_inline()
6701 inline_size = btrfs_file_extent_inline_item_len(leaf, path->slots[0]); in uncompress_inline()
6704 return -ENOMEM; in uncompress_inline()
6721 memzero_page(page, max_size, PAGE_SIZE - max_size); in uncompress_inline()
6738 fi = btrfs_item_ptr(path->nodes[0], path->slots[0], in read_inline_extent()
6740 if (btrfs_file_extent_compression(path->nodes[0], fi) != BTRFS_COMPRESS_NONE) in read_inline_extent()
6744 btrfs_file_extent_ram_bytes(path->nodes[0], fi)); in read_inline_extent()
6746 read_extent_buffer(path->nodes[0], kaddr, in read_inline_extent()
6750 memzero_page(page, copy_size, PAGE_SIZE - copy_size); in read_inline_extent()
6764 * it from the B-tree and caching it if necessary. Note that there may be more
6770 * Return: ERR_PTR on error, non-NULL extent_map on success.
6776 struct btrfs_fs_info *fs_info = inode->root->fs_info; in btrfs_get_extent()
6781 int extent_type = -1; in btrfs_get_extent()
6783 struct btrfs_root *root = inode->root; in btrfs_get_extent()
6788 struct extent_map_tree *em_tree = &inode->extent_tree; in btrfs_get_extent()
6790 read_lock(&em_tree->lock); in btrfs_get_extent()
6792 read_unlock(&em_tree->lock); in btrfs_get_extent()
6795 if (em->start > start || em->start + em->len <= start) in btrfs_get_extent()
6797 else if (em->block_start == EXTENT_MAP_INLINE && page) in btrfs_get_extent()
6804 ret = -ENOMEM; in btrfs_get_extent()
6807 em->start = EXTENT_MAP_HOLE; in btrfs_get_extent()
6808 em->orig_start = EXTENT_MAP_HOLE; in btrfs_get_extent()
6809 em->len = (u64)-1; in btrfs_get_extent()
6810 em->block_len = (u64)-1; in btrfs_get_extent()
6814 ret = -ENOMEM; in btrfs_get_extent()
6819 path->reada = READA_FORWARD; in btrfs_get_extent()
6827 path->search_commit_root = 1; in btrfs_get_extent()
6828 path->skip_locking = 1; in btrfs_get_extent()
6835 if (path->slots[0] == 0) in btrfs_get_extent()
6837 path->slots[0]--; in btrfs_get_extent()
6841 leaf = path->nodes[0]; in btrfs_get_extent()
6842 item = btrfs_item_ptr(leaf, path->slots[0], in btrfs_get_extent()
6844 btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]); in btrfs_get_extent()
6863 if (!S_ISREG(inode->vfs_inode.i_mode)) { in btrfs_get_extent()
6864 ret = -EUCLEAN; in btrfs_get_extent()
6866 "regular/prealloc extent found for non-regular inode %llu", in btrfs_get_extent()
6874 path->slots[0], in btrfs_get_extent()
6879 path->slots[0]++; in btrfs_get_extent()
6880 if (path->slots[0] >= btrfs_header_nritems(leaf)) { in btrfs_get_extent()
6887 leaf = path->nodes[0]; in btrfs_get_extent()
6889 btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]); in btrfs_get_extent()
6899 em->start = start; in btrfs_get_extent()
6900 em->orig_start = start; in btrfs_get_extent()
6901 em->len = found_key.offset - start; in btrfs_get_extent()
6902 em->block_start = EXTENT_MAP_HOLE; in btrfs_get_extent()
6914 * ensured by tree-checker and inline extent creation path. in btrfs_get_extent()
6919 ASSERT(em->start == 0); in btrfs_get_extent()
6927 ASSERT(em->block_start == EXTENT_MAP_INLINE); in btrfs_get_extent()
6928 ASSERT(em->len == fs_info->sectorsize); in btrfs_get_extent()
6936 em->start = start; in btrfs_get_extent()
6937 em->orig_start = start; in btrfs_get_extent()
6938 em->len = len; in btrfs_get_extent()
6939 em->block_start = EXTENT_MAP_HOLE; in btrfs_get_extent()
6943 if (em->start > start || extent_map_end(em) <= start) { in btrfs_get_extent()
6946 em->start, em->len, start, len); in btrfs_get_extent()
6947 ret = -EIO; in btrfs_get_extent()
6951 write_lock(&em_tree->lock); in btrfs_get_extent()
6953 write_unlock(&em_tree->lock); in btrfs_get_extent()
6997 start + len - 1, false); in btrfs_create_dio_extent()
7001 ASSERT(!dio_data->ordered); in btrfs_create_dio_extent()
7002 dio_data->ordered = ordered; in btrfs_create_dio_extent()
7013 struct btrfs_root *root = inode->root; in btrfs_new_extent_direct()
7014 struct btrfs_fs_info *fs_info = root->fs_info; in btrfs_new_extent_direct()
7022 ret = btrfs_reserve_extent(root, len, len, fs_info->sectorsize, in btrfs_new_extent_direct()
7024 if (ret == -EAGAIN) { in btrfs_new_extent_direct()
7026 wait_on_bit_io(&inode->root->fs_info->flags, BTRFS_FS_NEED_ZONE_FINISH, in btrfs_new_extent_direct()
7050 if (!block_group || block_group->ro) in btrfs_extent_readonly()
7064 * @orig_len: (optional) Return the original on-disk length of the file extent
7081 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); in can_nocow_extent()
7086 struct btrfs_root *root = BTRFS_I(inode)->root; in can_nocow_extent()
7087 struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree; in can_nocow_extent()
7094 return -ENOMEM; in can_nocow_extent()
7095 path->nowait = nowait; in can_nocow_extent()
7103 if (path->slots[0] == 0) { in can_nocow_extent()
7108 path->slots[0]--; in can_nocow_extent()
7111 leaf = path->nodes[0]; in can_nocow_extent()
7112 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]); in can_nocow_extent()
7127 fi = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_file_extent_item); in can_nocow_extent()
7133 nocow_args.end = offset + *len - 1; in can_nocow_extent()
7151 if (!(BTRFS_I(inode)->flags & BTRFS_INODE_NODATACOW) && in can_nocow_extent()
7156 root->fs_info->sectorsize) - 1; in can_nocow_extent()
7159 ret = -EAGAIN; in can_nocow_extent()
7165 *orig_start = key.offset - nocow_args.extent_offset; in can_nocow_extent()
7182 struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree; in lock_extent_direct()
7190 return -EAGAIN; in lock_extent_direct()
7200 lockend - lockstart + 1); in lock_extent_direct()
7210 (!writing || !filemap_range_has_page(inode->i_mapping, in lock_extent_direct()
7219 ret = -EAGAIN; in lock_extent_direct()
7238 test_bit(BTRFS_ORDERED_DIRECT, &ordered->flags)) in lock_extent_direct()
7241 ret = nowait ? -EAGAIN : -ENOTBLK; in lock_extent_direct()
7257 ret = nowait ? -EAGAIN : -ENOTBLK; in lock_extent_direct()
7286 return ERR_PTR(-ENOMEM); in create_io_em()
7288 em->start = start; in create_io_em()
7289 em->orig_start = orig_start; in create_io_em()
7290 em->len = len; in create_io_em()
7291 em->block_len = block_len; in create_io_em()
7292 em->block_start = block_start; in create_io_em()
7293 em->orig_block_len = orig_block_len; in create_io_em()
7294 em->ram_bytes = ram_bytes; in create_io_em()
7295 em->generation = -1; in create_io_em()
7296 em->flags |= EXTENT_FLAG_PINNED; in create_io_em()
7298 em->flags |= EXTENT_FLAG_FILLING; in create_io_em()
7320 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); in btrfs_get_blocks_direct_write()
7340 if ((em->flags & EXTENT_FLAG_PREALLOC) || in btrfs_get_blocks_direct_write()
7341 ((BTRFS_I(inode)->flags & BTRFS_INODE_NODATACOW) && in btrfs_get_blocks_direct_write()
7342 em->block_start != EXTENT_MAP_HOLE)) { in btrfs_get_blocks_direct_write()
7343 if (em->flags & EXTENT_FLAG_PREALLOC) in btrfs_get_blocks_direct_write()
7347 len = min(len, em->len - (start - em->start)); in btrfs_get_blocks_direct_write()
7348 block_start = em->block_start + (start - em->start); in btrfs_get_blocks_direct_write()
7370 if (nowait && (ret == -ENOSPC || ret == -EDQUOT)) in btrfs_get_blocks_direct_write()
7371 ret = -EAGAIN; in btrfs_get_blocks_direct_write()
7392 dio_data->nocow_done = true; in btrfs_get_blocks_direct_write()
7399 ret = -EAGAIN; in btrfs_get_blocks_direct_write()
7407 if (!dio_data->data_space_reserved) { in btrfs_get_blocks_direct_write()
7408 ret = -ENOSPC; in btrfs_get_blocks_direct_write()
7428 len = min(len, em->len - (start - em->start)); in btrfs_get_blocks_direct_write()
7431 prev_len - len, true); in btrfs_get_blocks_direct_write()
7460 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); in btrfs_dio_iomap_begin()
7463 struct btrfs_dio_data *dio_data = iter->private; in btrfs_dio_iomap_begin()
7480 * -EAGAIN at this point so that the normal path is used. in btrfs_dio_iomap_begin()
7483 return -EAGAIN; in btrfs_dio_iomap_begin()
7490 len = min_t(u64, len, fs_info->sectorsize * BTRFS_MAX_BIO_SECTORS); in btrfs_dio_iomap_begin()
7493 lockend = start + len - 1; in btrfs_dio_iomap_begin()
7499 * outstanding dirty pages are on disk - the first flush only starts in btrfs_dio_iomap_begin()
7507 * dirty or under writeback (same as for the non-compression case). in btrfs_dio_iomap_begin()
7514 &BTRFS_I(inode)->runtime_flags)) { in btrfs_dio_iomap_begin()
7516 if (filemap_range_needs_writeback(inode->i_mapping, in btrfs_dio_iomap_begin()
7518 return -EAGAIN; in btrfs_dio_iomap_begin()
7520 ret = filemap_fdatawrite_range(inode->i_mapping, start, in btrfs_dio_iomap_begin()
7521 start + length - 1); in btrfs_dio_iomap_begin()
7540 &dio_data->data_reserved, in btrfs_dio_iomap_begin()
7543 dio_data->data_space_reserved = true; in btrfs_dio_iomap_begin()
7544 else if (ret && !(BTRFS_I(inode)->flags & in btrfs_dio_iomap_begin()
7574 * We return -ENOTBLK because that's what makes DIO go ahead and go back in btrfs_dio_iomap_begin()
7579 em->block_start == EXTENT_MAP_INLINE) { in btrfs_dio_iomap_begin()
7582 * If we are in a NOWAIT context, return -EAGAIN in order to in btrfs_dio_iomap_begin()
7586 * space - this happens if we were able to read some data from in btrfs_dio_iomap_begin()
7587 * previous non-compressed extents and then when we fallback to in btrfs_dio_iomap_begin()
7591 * of bytes previously read is > 0, so it does not return -EFAULT). in btrfs_dio_iomap_begin()
7593 ret = (flags & IOMAP_NOWAIT) ? -EAGAIN : -ENOTBLK; in btrfs_dio_iomap_begin()
7597 len = min(len, em->len - (start - em->start)); in btrfs_dio_iomap_begin()
7601 * (or a mix of extents and holes), then we return -EAGAIN to make the in btrfs_dio_iomap_begin()
7617 * which we return back to our caller - we should only return EIOCBQUEUED in btrfs_dio_iomap_begin()
7622 ret = -EAGAIN; in btrfs_dio_iomap_begin()
7633 len = min(len, em->len - (start - em->start)); in btrfs_dio_iomap_begin()
7634 if (dio_data->data_space_reserved) { in btrfs_dio_iomap_begin()
7638 if (dio_data->nocow_done) { in btrfs_dio_iomap_begin()
7643 release_len = data_alloc_len - len; in btrfs_dio_iomap_begin()
7648 dio_data->data_reserved, in btrfs_dio_iomap_begin()
7663 unlock_extent(&BTRFS_I(inode)->io_tree, lockstart, lockend, in btrfs_dio_iomap_begin()
7673 if ((em->block_start == EXTENT_MAP_HOLE) || in btrfs_dio_iomap_begin()
7674 ((em->flags & EXTENT_FLAG_PREALLOC) && !write)) { in btrfs_dio_iomap_begin()
7675 iomap->addr = IOMAP_NULL_ADDR; in btrfs_dio_iomap_begin()
7676 iomap->type = IOMAP_HOLE; in btrfs_dio_iomap_begin()
7678 iomap->addr = em->block_start + (start - em->start); in btrfs_dio_iomap_begin()
7679 iomap->type = IOMAP_MAPPED; in btrfs_dio_iomap_begin()
7681 iomap->offset = start; in btrfs_dio_iomap_begin()
7682 iomap->bdev = fs_info->fs_devices->latest_dev->bdev; in btrfs_dio_iomap_begin()
7683 iomap->length = len; in btrfs_dio_iomap_begin()
7689 unlock_extent(&BTRFS_I(inode)->io_tree, lockstart, lockend, in btrfs_dio_iomap_begin()
7692 if (dio_data->data_space_reserved) { in btrfs_dio_iomap_begin()
7694 dio_data->data_reserved, in btrfs_dio_iomap_begin()
7696 extent_changeset_free(dio_data->data_reserved); in btrfs_dio_iomap_begin()
7706 struct btrfs_dio_data *dio_data = iter->private; in btrfs_dio_iomap_end()
7707 size_t submitted = dio_data->submitted; in btrfs_dio_iomap_end()
7711 if (!write && (iomap->type == IOMAP_HOLE)) { in btrfs_dio_iomap_end()
7713 unlock_extent(&BTRFS_I(inode)->io_tree, pos, pos + length - 1, in btrfs_dio_iomap_end()
7720 length -= submitted; in btrfs_dio_iomap_end()
7722 btrfs_finish_ordered_extent(dio_data->ordered, NULL, in btrfs_dio_iomap_end()
7725 unlock_extent(&BTRFS_I(inode)->io_tree, pos, in btrfs_dio_iomap_end()
7726 pos + length - 1, NULL); in btrfs_dio_iomap_end()
7727 ret = -ENOTBLK; in btrfs_dio_iomap_end()
7730 btrfs_put_ordered_extent(dio_data->ordered); in btrfs_dio_iomap_end()
7731 dio_data->ordered = NULL; in btrfs_dio_iomap_end()
7735 extent_changeset_free(dio_data->data_reserved); in btrfs_dio_iomap_end()
7743 struct btrfs_inode *inode = bbio->inode; in btrfs_dio_end_io()
7744 struct bio *bio = &bbio->bio; in btrfs_dio_end_io()
7746 if (bio->bi_status) { in btrfs_dio_end_io()
7747 btrfs_warn(inode->root->fs_info, in btrfs_dio_end_io()
7749 btrfs_ino(inode), bio->bi_opf, in btrfs_dio_end_io()
7750 dip->file_offset, dip->bytes, bio->bi_status); in btrfs_dio_end_io()
7754 btrfs_finish_ordered_extent(bbio->ordered, NULL, in btrfs_dio_end_io()
7755 dip->file_offset, dip->bytes, in btrfs_dio_end_io()
7756 !bio->bi_status); in btrfs_dio_end_io()
7758 unlock_extent(&inode->io_tree, dip->file_offset, in btrfs_dio_end_io()
7759 dip->file_offset + dip->bytes - 1, NULL); in btrfs_dio_end_io()
7762 bbio->bio.bi_private = bbio->private; in btrfs_dio_end_io()
7772 struct btrfs_dio_data *dio_data = iter->private; in btrfs_dio_submit_io()
7774 btrfs_bio_init(bbio, BTRFS_I(iter->inode)->root->fs_info, in btrfs_dio_submit_io()
7775 btrfs_dio_end_io, bio->bi_private); in btrfs_dio_submit_io()
7776 bbio->inode = BTRFS_I(iter->inode); in btrfs_dio_submit_io()
7777 bbio->file_offset = file_offset; in btrfs_dio_submit_io()
7779 dip->file_offset = file_offset; in btrfs_dio_submit_io()
7780 dip->bytes = bio->bi_iter.bi_size; in btrfs_dio_submit_io()
7782 dio_data->submitted += bio->bi_iter.bi_size; in btrfs_dio_submit_io()
7791 if (iter->flags & IOMAP_WRITE) { in btrfs_dio_submit_io()
7794 ret = btrfs_extract_ordered_extent(bbio, dio_data->ordered); in btrfs_dio_submit_io()
7796 btrfs_finish_ordered_extent(dio_data->ordered, NULL, in btrfs_dio_submit_io()
7797 file_offset, dip->bytes, in btrfs_dio_submit_io()
7799 bio->bi_status = errno_to_blk_status(ret); in btrfs_dio_submit_io()
7858 if (fieinfo->fi_flags & FIEMAP_FLAG_SYNC) { in btrfs_fiemap()
7872 if (fieinfo->fi_flags & FIEMAP_FLAG_SYNC) { in btrfs_fiemap()
7900 * If we continue to release/invalidate the page, we could cause use-after-free
7906 struct btrfs_fs_info *fs_info = btrfs_sb(page->mapping->host->i_sb); in wait_subpage_spinlock()
7910 if (!btrfs_is_subpage(fs_info, page->mapping)) in wait_subpage_spinlock()
7927 spin_lock_irq(&subpage->lock); in wait_subpage_spinlock()
7928 spin_unlock_irq(&subpage->lock); in wait_subpage_spinlock()
7933 int ret = try_release_extent_mapping(&folio->page, gfp_flags); in __btrfs_release_folio()
7936 wait_subpage_spinlock(&folio->page); in __btrfs_release_folio()
7937 clear_page_extent_mapped(&folio->page); in __btrfs_release_folio()
7973 struct btrfs_inode *inode = BTRFS_I(folio->mapping->host); in btrfs_invalidate_folio()
7974 struct btrfs_fs_info *fs_info = inode->root->fs_info; in btrfs_invalidate_folio()
7975 struct extent_io_tree *tree = &inode->io_tree; in btrfs_invalidate_folio()
7978 u64 page_end = page_start + folio_size(folio) - 1; in btrfs_invalidate_folio()
7980 int inode_evicting = inode->vfs_inode.i_state & I_FREEING; in btrfs_invalidate_folio()
7996 wait_subpage_spinlock(&folio->page); in btrfs_invalidate_folio()
8003 * shouldn't clear page extent mapped, as folio->private can still in btrfs_invalidate_folio()
8026 page_end + 1 - cur); in btrfs_invalidate_folio()
8036 if (ordered->file_offset > cur) { in btrfs_invalidate_folio()
8038 * There is a range between [cur, oe->file_offset) not in btrfs_invalidate_folio()
8043 range_end = ordered->file_offset - 1; in btrfs_invalidate_folio()
8048 range_end = min(ordered->file_offset + ordered->num_bytes - 1, in btrfs_invalidate_folio()
8050 ASSERT(range_end + 1 - cur < U32_MAX); in btrfs_invalidate_folio()
8051 range_len = range_end + 1 - cur; in btrfs_invalidate_folio()
8077 spin_lock_irq(&inode->ordered_tree_lock); in btrfs_invalidate_folio()
8078 set_bit(BTRFS_ORDERED_TRUNCATED, &ordered->flags); in btrfs_invalidate_folio()
8079 ordered->truncated_len = min(ordered->truncated_len, in btrfs_invalidate_folio()
8080 cur - ordered->file_offset); in btrfs_invalidate_folio()
8081 spin_unlock_irq(&inode->ordered_tree_lock); in btrfs_invalidate_folio()
8090 cur, range_end + 1 - cur)) { in btrfs_invalidate_folio()
8116 btrfs_qgroup_free_data(inode, NULL, cur, range_end + 1 - cur, NULL); in btrfs_invalidate_folio()
8134 clear_page_extent_mapped(&folio->page); in btrfs_invalidate_folio()
8154 struct page *page = vmf->page; in btrfs_page_mkwrite()
8156 struct inode *inode = file_inode(vmf->vma->vm_file); in btrfs_page_mkwrite()
8157 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); in btrfs_page_mkwrite()
8158 struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree; in btrfs_page_mkwrite()
8176 sb_start_pagefault(inode->i_sb); in btrfs_page_mkwrite()
8178 page_end = page_start + PAGE_SIZE - 1; in btrfs_page_mkwrite()
8192 ret2 = file_update_time(vmf->vma->vm_file); in btrfs_page_mkwrite()
8204 down_read(&BTRFS_I(inode)->i_mmap_lock); in btrfs_page_mkwrite()
8208 if ((page->mapping != inode->i_mapping) || in btrfs_page_mkwrite()
8232 up_read(&BTRFS_I(inode)->i_mmap_lock); in btrfs_page_mkwrite()
8238 if (page->index == ((size - 1) >> PAGE_SHIFT)) { in btrfs_page_mkwrite()
8239 reserved_space = round_up(size - page_start, in btrfs_page_mkwrite()
8240 fs_info->sectorsize); in btrfs_page_mkwrite()
8242 end = page_start + reserved_space - 1; in btrfs_page_mkwrite()
8245 PAGE_SIZE - reserved_space, true); in btrfs_page_mkwrite()
8256 clear_extent_bit(&BTRFS_I(inode)->io_tree, page_start, end, in btrfs_page_mkwrite()
8275 memzero_page(page, zero_start, PAGE_SIZE - zero_start); in btrfs_page_mkwrite()
8278 btrfs_folio_set_dirty(fs_info, folio, page_start, end + 1 - page_start); in btrfs_page_mkwrite()
8279 btrfs_folio_set_uptodate(fs_info, folio, page_start, end + 1 - page_start); in btrfs_page_mkwrite()
8284 up_read(&BTRFS_I(inode)->i_mmap_lock); in btrfs_page_mkwrite()
8287 sb_end_pagefault(inode->i_sb); in btrfs_page_mkwrite()
8293 up_read(&BTRFS_I(inode)->i_mmap_lock); in btrfs_page_mkwrite()
8299 sb_end_pagefault(inode->i_sb); in btrfs_page_mkwrite()
8312 struct btrfs_root *root = inode->root; in btrfs_truncate()
8313 struct btrfs_fs_info *fs_info = root->fs_info; in btrfs_truncate()
8317 u64 mask = fs_info->sectorsize - 1; in btrfs_truncate()
8321 ret = btrfs_wait_ordered_range(&inode->vfs_inode, in btrfs_truncate()
8322 inode->vfs_inode.i_size & (~mask), in btrfs_truncate()
8323 (u64)-1); in btrfs_truncate()
8351 * 1) rsv - for the truncate reservation, which we will steal from the in btrfs_truncate()
8353 * 2) fs_info->trans_block_rsv - this will have 1 items worth left for in btrfs_truncate()
8358 return -ENOMEM; in btrfs_truncate()
8359 rsv->size = min_size; in btrfs_truncate()
8360 rsv->failfast = true; in btrfs_truncate()
8373 ret = btrfs_block_rsv_migrate(&fs_info->trans_block_rsv, rsv, in btrfs_truncate()
8385 trans->block_rsv = rsv; in btrfs_truncate()
8389 const u64 new_size = inode->vfs_inode.i_size; in btrfs_truncate()
8390 const u64 lock_start = ALIGN_DOWN(new_size, fs_info->sectorsize); in btrfs_truncate()
8393 lock_extent(&inode->io_tree, lock_start, (u64)-1, &cached_state); in btrfs_truncate()
8400 ALIGN(new_size, fs_info->sectorsize), in btrfs_truncate()
8401 (u64)-1, false); in btrfs_truncate()
8405 inode_sub_bytes(&inode->vfs_inode, control.sub_bytes); in btrfs_truncate()
8408 unlock_extent(&inode->io_tree, lock_start, (u64)-1, &cached_state); in btrfs_truncate()
8410 trans->block_rsv = &fs_info->trans_block_rsv; in btrfs_truncate()
8411 if (ret != -ENOSPC && ret != -EAGAIN) in btrfs_truncate()
8428 btrfs_block_rsv_release(fs_info, rsv, -1, NULL); in btrfs_truncate()
8429 ret = btrfs_block_rsv_migrate(&fs_info->trans_block_rsv, in btrfs_truncate()
8439 trans->block_rsv = rsv; in btrfs_truncate()
8452 ret = btrfs_truncate_block(inode, inode->vfs_inode.i_size, 0, 0); in btrfs_truncate()
8466 trans->block_rsv = &fs_info->trans_block_rsv; in btrfs_truncate()
8486 * fsync to truncate all the inode's items from the log and re-log them in btrfs_truncate()
8503 inode = new_inode(dir->i_sb); in btrfs_new_subvol_inode()
8511 inode->i_op = &btrfs_dir_inode_operations; in btrfs_new_subvol_inode()
8512 inode->i_fop = &btrfs_dir_file_operations; in btrfs_new_subvol_inode()
8537 ei->root = NULL; in btrfs_alloc_inode()
8538 ei->generation = 0; in btrfs_alloc_inode()
8539 ei->last_trans = 0; in btrfs_alloc_inode()
8540 ei->last_sub_trans = 0; in btrfs_alloc_inode()
8541 ei->logged_trans = 0; in btrfs_alloc_inode()
8542 ei->delalloc_bytes = 0; in btrfs_alloc_inode()
8543 ei->new_delalloc_bytes = 0; in btrfs_alloc_inode()
8544 ei->defrag_bytes = 0; in btrfs_alloc_inode()
8545 ei->disk_i_size = 0; in btrfs_alloc_inode()
8546 ei->flags = 0; in btrfs_alloc_inode()
8547 ei->ro_flags = 0; in btrfs_alloc_inode()
8548 ei->csum_bytes = 0; in btrfs_alloc_inode()
8549 ei->index_cnt = (u64)-1; in btrfs_alloc_inode()
8550 ei->dir_index = 0; in btrfs_alloc_inode()
8551 ei->last_unlink_trans = 0; in btrfs_alloc_inode()
8552 ei->last_reflink_trans = 0; in btrfs_alloc_inode()
8553 ei->last_log_commit = 0; in btrfs_alloc_inode()
8555 spin_lock_init(&ei->lock); in btrfs_alloc_inode()
8556 ei->outstanding_extents = 0; in btrfs_alloc_inode()
8557 if (sb->s_magic != BTRFS_TEST_MAGIC) in btrfs_alloc_inode()
8558 btrfs_init_metadata_block_rsv(fs_info, &ei->block_rsv, in btrfs_alloc_inode()
8560 ei->runtime_flags = 0; in btrfs_alloc_inode()
8561 ei->prop_compress = BTRFS_COMPRESS_NONE; in btrfs_alloc_inode()
8562 ei->defrag_compress = BTRFS_COMPRESS_NONE; in btrfs_alloc_inode()
8564 ei->delayed_node = NULL; in btrfs_alloc_inode()
8566 ei->i_otime_sec = 0; in btrfs_alloc_inode()
8567 ei->i_otime_nsec = 0; in btrfs_alloc_inode()
8569 inode = &ei->vfs_inode; in btrfs_alloc_inode()
8570 extent_map_tree_init(&ei->extent_tree); in btrfs_alloc_inode()
8573 extent_io_tree_init(fs_info, &ei->io_tree, IO_TREE_INODE_IO); in btrfs_alloc_inode()
8574 ei->io_tree.inode = ei; in btrfs_alloc_inode()
8576 ei->file_extent_tree = file_extent_tree; in btrfs_alloc_inode()
8578 extent_io_tree_init(fs_info, ei->file_extent_tree, in btrfs_alloc_inode()
8581 lockdep_set_class(&ei->file_extent_tree->lock, &file_extent_tree_class); in btrfs_alloc_inode()
8583 mutex_init(&ei->log_mutex); in btrfs_alloc_inode()
8584 spin_lock_init(&ei->ordered_tree_lock); in btrfs_alloc_inode()
8585 ei->ordered_tree = RB_ROOT; in btrfs_alloc_inode()
8586 ei->ordered_tree_last = NULL; in btrfs_alloc_inode()
8587 INIT_LIST_HEAD(&ei->delalloc_inodes); in btrfs_alloc_inode()
8588 INIT_LIST_HEAD(&ei->delayed_iput); in btrfs_alloc_inode()
8589 RB_CLEAR_NODE(&ei->rb_node); in btrfs_alloc_inode()
8590 init_rwsem(&ei->i_mmap_lock); in btrfs_alloc_inode()
8598 btrfs_drop_extent_map_range(BTRFS_I(inode), 0, (u64)-1, false); in btrfs_test_destroy_inode()
8599 kfree(BTRFS_I(inode)->file_extent_tree); in btrfs_test_destroy_inode()
8606 kfree(BTRFS_I(inode)->file_extent_tree); in btrfs_free_inode()
8614 struct btrfs_root *root = inode->root; in btrfs_destroy_inode()
8617 WARN_ON(!hlist_empty(&vfs_inode->i_dentry)); in btrfs_destroy_inode()
8618 WARN_ON(vfs_inode->i_data.nrpages); in btrfs_destroy_inode()
8619 WARN_ON(inode->block_rsv.reserved); in btrfs_destroy_inode()
8620 WARN_ON(inode->block_rsv.size); in btrfs_destroy_inode()
8621 WARN_ON(inode->outstanding_extents); in btrfs_destroy_inode()
8622 if (!S_ISDIR(vfs_inode->i_mode)) { in btrfs_destroy_inode()
8623 WARN_ON(inode->delalloc_bytes); in btrfs_destroy_inode()
8624 WARN_ON(inode->new_delalloc_bytes); in btrfs_destroy_inode()
8626 WARN_ON(inode->csum_bytes); in btrfs_destroy_inode()
8627 WARN_ON(inode->defrag_bytes); in btrfs_destroy_inode()
8644 ordered = btrfs_lookup_first_ordered_extent(inode, (u64)-1); in btrfs_destroy_inode()
8648 btrfs_err(root->fs_info, in btrfs_destroy_inode()
8650 ordered->file_offset, ordered->num_bytes); in btrfs_destroy_inode()
8653 btrfs_lockdep_acquire(root->fs_info, btrfs_ordered_extent); in btrfs_destroy_inode()
8662 btrfs_drop_extent_map_range(inode, 0, (u64)-1, false); in btrfs_destroy_inode()
8663 btrfs_inode_clear_file_extent_range(inode, 0, (u64)-1); in btrfs_destroy_inode()
8664 btrfs_put_root(inode->root); in btrfs_destroy_inode()
8669 struct btrfs_root *root = BTRFS_I(inode)->root; in btrfs_drop_inode()
8675 if (btrfs_root_refs(&root->root_item) == 0) in btrfs_drop_inode()
8685 inode_init_once(&ei->vfs_inode); in init_once()
8716 return -ENOMEM; in btrfs_init_cachep()
8725 struct inode *inode = d_inode(path->dentry); in btrfs_getattr()
8726 u32 blocksize = inode->i_sb->s_blocksize; in btrfs_getattr()
8727 u32 bi_flags = BTRFS_I(inode)->flags; in btrfs_getattr()
8728 u32 bi_ro_flags = BTRFS_I(inode)->ro_flags; in btrfs_getattr()
8730 stat->result_mask |= STATX_BTIME; in btrfs_getattr()
8731 stat->btime.tv_sec = BTRFS_I(inode)->i_otime_sec; in btrfs_getattr()
8732 stat->btime.tv_nsec = BTRFS_I(inode)->i_otime_nsec; in btrfs_getattr()
8734 stat->attributes |= STATX_ATTR_APPEND; in btrfs_getattr()
8736 stat->attributes |= STATX_ATTR_COMPRESSED; in btrfs_getattr()
8738 stat->attributes |= STATX_ATTR_IMMUTABLE; in btrfs_getattr()
8740 stat->attributes |= STATX_ATTR_NODUMP; in btrfs_getattr()
8742 stat->attributes |= STATX_ATTR_VERITY; in btrfs_getattr()
8744 stat->attributes_mask |= (STATX_ATTR_APPEND | in btrfs_getattr()
8750 stat->dev = BTRFS_I(inode)->root->anon_dev; in btrfs_getattr()
8752 spin_lock(&BTRFS_I(inode)->lock); in btrfs_getattr()
8753 delalloc_bytes = BTRFS_I(inode)->new_delalloc_bytes; in btrfs_getattr()
8755 spin_unlock(&BTRFS_I(inode)->lock); in btrfs_getattr()
8756 stat->blocks = (ALIGN(inode_bytes, blocksize) + in btrfs_getattr()
8766 struct btrfs_fs_info *fs_info = btrfs_sb(old_dir->i_sb); in btrfs_rename_exchange()
8769 struct btrfs_root *root = BTRFS_I(old_dir)->root; in btrfs_rename_exchange()
8770 struct btrfs_root *dest = BTRFS_I(new_dir)->root; in btrfs_rename_exchange()
8771 struct inode *new_inode = new_dentry->d_inode; in btrfs_rename_exchange()
8772 struct inode *old_inode = old_dentry->d_inode; in btrfs_rename_exchange()
8786 * For non-subvolumes allow exchange only within one subvolume, in the in btrfs_rename_exchange()
8793 return -EXDEV; in btrfs_rename_exchange()
8795 ret = fscrypt_setup_filename(old_dir, &old_dentry->d_name, 0, &old_fname); in btrfs_rename_exchange()
8799 ret = fscrypt_setup_filename(new_dir, &new_dentry->d_name, 0, &new_fname); in btrfs_rename_exchange()
8811 down_read(&fs_info->subvol_sem); in btrfs_rename_exchange()
8867 BTRFS_I(old_inode)->dir_index = 0ULL; in btrfs_rename_exchange()
8868 BTRFS_I(new_inode)->dir_index = 0ULL; in btrfs_rename_exchange()
8905 if (old_dentry->d_parent != new_dentry->d_parent) { in btrfs_rename_exchange()
8917 BTRFS_I(old_dentry->d_inode), in btrfs_rename_exchange()
8932 BTRFS_I(new_dentry->d_inode), in btrfs_rename_exchange()
8956 if (old_inode->i_nlink == 1) in btrfs_rename_exchange()
8957 BTRFS_I(old_inode)->dir_index = old_idx; in btrfs_rename_exchange()
8958 if (new_inode->i_nlink == 1) in btrfs_rename_exchange()
8959 BTRFS_I(new_inode)->dir_index = new_idx; in btrfs_rename_exchange()
8975 old_rename_ctx.index, new_dentry->d_parent); in btrfs_rename_exchange()
8978 new_rename_ctx.index, old_dentry->d_parent); in btrfs_rename_exchange()
8991 up_read(&fs_info->subvol_sem); in btrfs_rename_exchange()
9003 inode = new_inode(dir->i_sb); in new_whiteout_inode()
9007 inode->i_op = &btrfs_special_inode_operations; in new_whiteout_inode()
9008 init_special_inode(inode, inode->i_mode, WHITEOUT_DEV); in new_whiteout_inode()
9018 struct btrfs_fs_info *fs_info = btrfs_sb(old_dir->i_sb); in btrfs_rename()
9025 struct btrfs_root *root = BTRFS_I(old_dir)->root; in btrfs_rename()
9026 struct btrfs_root *dest = BTRFS_I(new_dir)->root; in btrfs_rename()
9037 return -EPERM; in btrfs_rename()
9041 return -EXDEV; in btrfs_rename()
9045 return -ENOTEMPTY; in btrfs_rename()
9047 if (S_ISDIR(old_inode->i_mode) && new_inode && in btrfs_rename()
9048 new_inode->i_size > BTRFS_EMPTY_DIR_SIZE) in btrfs_rename()
9049 return -ENOTEMPTY; in btrfs_rename()
9051 ret = fscrypt_setup_filename(old_dir, &old_dentry->d_name, 0, &old_fname); in btrfs_rename()
9055 ret = fscrypt_setup_filename(new_dir, &new_dentry->d_name, 0, &new_fname); in btrfs_rename()
9062 ret = btrfs_check_dir_item_collision(dest, new_dir->i_ino, &new_fname.disk_name); in btrfs_rename()
9064 if (ret == -EEXIST) { in btrfs_rename()
9071 /* maybe -EOVERFLOW */ in btrfs_rename()
9081 if (new_inode && S_ISREG(old_inode->i_mode) && new_inode->i_size) in btrfs_rename()
9082 filemap_flush(old_inode->i_mapping); in btrfs_rename()
9087 ret = -ENOMEM; in btrfs_rename()
9100 down_read(&fs_info->subvol_sem); in btrfs_rename()
9152 BTRFS_I(old_inode)->dir_index = 0ULL; in btrfs_rename()
9169 if (old_dentry->d_parent != new_dentry->d_parent) in btrfs_rename()
9192 BUG_ON(new_inode->i_nlink == 0); in btrfs_rename()
9198 if (!ret && new_inode->i_nlink == 0) in btrfs_rename()
9214 if (old_inode->i_nlink == 1) in btrfs_rename()
9215 BTRFS_I(old_inode)->dir_index = index; in btrfs_rename()
9219 rename_ctx.index, new_dentry->d_parent); in btrfs_rename()
9237 up_read(&fs_info->subvol_sem); in btrfs_rename()
9256 return -EINVAL; in btrfs_rename2()
9265 btrfs_btree_balance_dirty(BTRFS_I(new_dir)->root->fs_info); in btrfs_rename2()
9284 inode = delalloc_work->inode; in btrfs_run_delalloc_work()
9285 filemap_flush(inode->i_mapping); in btrfs_run_delalloc_work()
9287 &BTRFS_I(inode)->runtime_flags)) in btrfs_run_delalloc_work()
9288 filemap_flush(inode->i_mapping); in btrfs_run_delalloc_work()
9291 complete(&delalloc_work->completion); in btrfs_run_delalloc_work()
9302 init_completion(&work->completion); in btrfs_alloc_delalloc_work()
9303 INIT_LIST_HEAD(&work->list); in btrfs_alloc_delalloc_work()
9304 work->inode = inode; in btrfs_alloc_delalloc_work()
9305 btrfs_init_work(&work->work, btrfs_run_delalloc_work, NULL); in btrfs_alloc_delalloc_work()
9324 bool full_flush = wbc->nr_to_write == LONG_MAX; in start_delalloc_inodes()
9326 mutex_lock(&root->delalloc_mutex); in start_delalloc_inodes()
9327 spin_lock(&root->delalloc_lock); in start_delalloc_inodes()
9328 list_splice_init(&root->delalloc_inodes, &splice); in start_delalloc_inodes()
9333 list_move_tail(&binode->delalloc_inodes, in start_delalloc_inodes()
9334 &root->delalloc_inodes); in start_delalloc_inodes()
9337 test_bit(BTRFS_INODE_NO_DELALLOC_FLUSH, &binode->runtime_flags)) in start_delalloc_inodes()
9340 inode = igrab(&binode->vfs_inode); in start_delalloc_inodes()
9342 cond_resched_lock(&root->delalloc_lock); in start_delalloc_inodes()
9345 spin_unlock(&root->delalloc_lock); in start_delalloc_inodes()
9349 &binode->runtime_flags); in start_delalloc_inodes()
9354 ret = -ENOMEM; in start_delalloc_inodes()
9357 list_add_tail(&work->list, &works); in start_delalloc_inodes()
9358 btrfs_queue_work(root->fs_info->flush_workers, in start_delalloc_inodes()
9359 &work->work); in start_delalloc_inodes()
9361 ret = filemap_fdatawrite_wbc(inode->i_mapping, wbc); in start_delalloc_inodes()
9363 if (ret || wbc->nr_to_write <= 0) in start_delalloc_inodes()
9367 spin_lock(&root->delalloc_lock); in start_delalloc_inodes()
9369 spin_unlock(&root->delalloc_lock); in start_delalloc_inodes()
9373 list_del_init(&work->list); in start_delalloc_inodes()
9374 wait_for_completion(&work->completion); in start_delalloc_inodes()
9379 spin_lock(&root->delalloc_lock); in start_delalloc_inodes()
9380 list_splice_tail(&splice, &root->delalloc_inodes); in start_delalloc_inodes()
9381 spin_unlock(&root->delalloc_lock); in start_delalloc_inodes()
9383 mutex_unlock(&root->delalloc_mutex); in start_delalloc_inodes()
9395 struct btrfs_fs_info *fs_info = root->fs_info; in btrfs_start_delalloc_snapshot()
9398 return -EROFS; in btrfs_start_delalloc_snapshot()
9417 return -EROFS; in btrfs_start_delalloc_roots()
9419 mutex_lock(&fs_info->delalloc_root_mutex); in btrfs_start_delalloc_roots()
9420 spin_lock(&fs_info->delalloc_root_lock); in btrfs_start_delalloc_roots()
9421 list_splice_init(&fs_info->delalloc_roots, &splice); in btrfs_start_delalloc_roots()
9434 list_move_tail(&root->delalloc_root, in btrfs_start_delalloc_roots()
9435 &fs_info->delalloc_roots); in btrfs_start_delalloc_roots()
9436 spin_unlock(&fs_info->delalloc_root_lock); in btrfs_start_delalloc_roots()
9442 spin_lock(&fs_info->delalloc_root_lock); in btrfs_start_delalloc_roots()
9444 spin_unlock(&fs_info->delalloc_root_lock); in btrfs_start_delalloc_roots()
9449 spin_lock(&fs_info->delalloc_root_lock); in btrfs_start_delalloc_roots()
9450 list_splice_tail(&splice, &fs_info->delalloc_roots); in btrfs_start_delalloc_roots()
9451 spin_unlock(&fs_info->delalloc_root_lock); in btrfs_start_delalloc_roots()
9453 mutex_unlock(&fs_info->delalloc_root_mutex); in btrfs_start_delalloc_roots()
9460 struct btrfs_fs_info *fs_info = btrfs_sb(dir->i_sb); in btrfs_symlink()
9462 struct btrfs_root *root = BTRFS_I(dir)->root; in btrfs_symlink()
9480 return -ENAMETOOLONG; in btrfs_symlink()
9482 inode = new_inode(dir->i_sb); in btrfs_symlink()
9484 return -ENOMEM; in btrfs_symlink()
9486 inode->i_op = &btrfs_symlink_inode_operations; in btrfs_symlink()
9488 inode->i_mapping->a_ops = &btrfs_aops; in btrfs_symlink()
9511 err = -ENOMEM; in btrfs_symlink()
9530 leaf = path->nodes[0]; in btrfs_symlink()
9531 ei = btrfs_item_ptr(leaf, path->slots[0], in btrfs_symlink()
9533 btrfs_set_file_extent_generation(leaf, ei, trans->transid); in btrfs_symlink()
9569 u64 start = ins->objectid; in insert_prealloc_file_extent()
9570 u64 len = ins->offset; in insert_prealloc_file_extent()
9610 ret = -ENOMEM; in insert_prealloc_file_extent()
9615 file_offset + len - 1, &extent_info, in insert_prealloc_file_extent()
9630 btrfs_qgroup_free_refroot(inode->root->fs_info, in insert_prealloc_file_extent()
9631 inode->root->root_key.objectid, qgroup_released, in insert_prealloc_file_extent()
9641 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); in __btrfs_prealloc_file_range()
9643 struct btrfs_root *root = BTRFS_I(inode)->root; in __btrfs_prealloc_file_range()
9649 u64 last_alloc = (u64)-1; in __btrfs_prealloc_file_range()
9652 u64 end = start + num_bytes - 1; in __btrfs_prealloc_file_range()
9673 * ->bytes_may_use to ->bytes_reserved. Any error that happens in __btrfs_prealloc_file_range()
9700 cur_offset + ins.offset - 1, false); in __btrfs_prealloc_file_range()
9705 em->start = cur_offset; in __btrfs_prealloc_file_range()
9706 em->orig_start = cur_offset; in __btrfs_prealloc_file_range()
9707 em->len = ins.offset; in __btrfs_prealloc_file_range()
9708 em->block_start = ins.objectid; in __btrfs_prealloc_file_range()
9709 em->block_len = ins.offset; in __btrfs_prealloc_file_range()
9710 em->orig_block_len = ins.offset; in __btrfs_prealloc_file_range()
9711 em->ram_bytes = ins.offset; in __btrfs_prealloc_file_range()
9712 em->flags |= EXTENT_FLAG_PREALLOC; in __btrfs_prealloc_file_range()
9713 em->generation = trans->transid; in __btrfs_prealloc_file_range()
9718 num_bytes -= ins.offset; in __btrfs_prealloc_file_range()
9724 BTRFS_I(inode)->flags |= BTRFS_INODE_PREALLOC; in __btrfs_prealloc_file_range()
9726 (actual_len > inode->i_size) && in __btrfs_prealloc_file_range()
9727 (cur_offset > inode->i_size)) { in __btrfs_prealloc_file_range()
9752 end - clear_offset + 1); in __btrfs_prealloc_file_range()
9777 struct btrfs_root *root = BTRFS_I(inode)->root; in btrfs_permission()
9778 umode_t mode = inode->i_mode; in btrfs_permission()
9783 return -EROFS; in btrfs_permission()
9784 if (BTRFS_I(inode)->flags & BTRFS_INODE_READONLY) in btrfs_permission()
9785 return -EACCES; in btrfs_permission()
9793 struct btrfs_fs_info *fs_info = btrfs_sb(dir->i_sb); in btrfs_tmpfile()
9795 struct btrfs_root *root = BTRFS_I(dir)->root; in btrfs_tmpfile()
9799 .dentry = file->f_path.dentry, in btrfs_tmpfile()
9805 inode = new_inode(dir->i_sb); in btrfs_tmpfile()
9807 return -ENOMEM; in btrfs_tmpfile()
9809 inode->i_fop = &btrfs_file_operations; in btrfs_tmpfile()
9810 inode->i_op = &btrfs_file_inode_operations; in btrfs_tmpfile()
9811 inode->i_mapping->a_ops = &btrfs_aops; in btrfs_tmpfile()
9831 * d_tmpfile() -> inode_dec_link_count() -> drop_nlink() in btrfs_tmpfile()
9853 struct btrfs_fs_info *fs_info = inode->root->fs_info; in btrfs_set_range_writeback()
9859 ASSERT(end + 1 - start <= U32_MAX); in btrfs_set_range_writeback()
9860 len = end + 1 - start; in btrfs_set_range_writeback()
9862 page = find_get_page(inode->vfs_inode.i_mapping, index); in btrfs_set_range_writeback()
9886 if (fs_info->sectorsize < SZ_4K || fs_info->sectorsize > SZ_64K) in btrfs_encoded_io_compression_from_extent()
9887 return -EINVAL; in btrfs_encoded_io_compression_from_extent()
9889 (fs_info->sectorsize_bits - 12); in btrfs_encoded_io_compression_from_extent()
9893 return -EUCLEAN; in btrfs_encoded_io_compression_from_extent()
9906 struct btrfs_inode *inode = BTRFS_I(file_inode(iocb->ki_filp)); in btrfs_encoded_read_inline()
9907 struct btrfs_root *root = inode->root; in btrfs_encoded_read_inline()
9908 struct btrfs_fs_info *fs_info = root->fs_info; in btrfs_encoded_read_inline()
9909 struct extent_io_tree *io_tree = &inode->io_tree; in btrfs_encoded_read_inline()
9920 ret = -ENOMEM; in btrfs_encoded_read_inline()
9928 ret = -EIO; in btrfs_encoded_read_inline()
9932 leaf = path->nodes[0]; in btrfs_encoded_read_inline()
9933 item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_file_extent_item); in btrfs_encoded_read_inline()
9938 encoded->len = min_t(u64, extent_start + ram_bytes, in btrfs_encoded_read_inline()
9939 inode->vfs_inode.i_size) - iocb->ki_pos; in btrfs_encoded_read_inline()
9944 encoded->compression = ret; in btrfs_encoded_read_inline()
9945 if (encoded->compression) { in btrfs_encoded_read_inline()
9949 path->slots[0]); in btrfs_encoded_read_inline()
9951 ret = -ENOBUFS; in btrfs_encoded_read_inline()
9955 encoded->unencoded_len = ram_bytes; in btrfs_encoded_read_inline()
9956 encoded->unencoded_offset = iocb->ki_pos - extent_start; in btrfs_encoded_read_inline()
9958 count = min_t(u64, count, encoded->len); in btrfs_encoded_read_inline()
9959 encoded->len = count; in btrfs_encoded_read_inline()
9960 encoded->unencoded_len = count; in btrfs_encoded_read_inline()
9961 ptr += iocb->ki_pos - extent_start; in btrfs_encoded_read_inline()
9966 ret = -ENOMEM; in btrfs_encoded_read_inline()
9977 ret = -EFAULT; in btrfs_encoded_read_inline()
9992 struct btrfs_encoded_read_private *priv = bbio->private; in btrfs_encoded_read_endio()
9994 if (bbio->bio.bi_status) { in btrfs_encoded_read_endio()
10003 WRITE_ONCE(priv->status, bbio->bio.bi_status); in btrfs_encoded_read_endio()
10005 if (!atomic_dec_return(&priv->pending)) in btrfs_encoded_read_endio()
10006 wake_up(&priv->wait); in btrfs_encoded_read_endio()
10007 bio_put(&bbio->bio); in btrfs_encoded_read_endio()
10014 struct btrfs_fs_info *fs_info = inode->root->fs_info; in btrfs_encoded_read_regular_fill_pages()
10025 bbio->bio.bi_iter.bi_sector = disk_bytenr >> SECTOR_SHIFT; in btrfs_encoded_read_regular_fill_pages()
10026 bbio->inode = inode; in btrfs_encoded_read_regular_fill_pages()
10031 if (bio_add_page(&bbio->bio, pages[i], bytes, 0) < bytes) { in btrfs_encoded_read_regular_fill_pages()
10037 bbio->bio.bi_iter.bi_sector = disk_bytenr >> SECTOR_SHIFT; in btrfs_encoded_read_regular_fill_pages()
10038 bbio->inode = inode; in btrfs_encoded_read_regular_fill_pages()
10044 disk_io_size -= bytes; in btrfs_encoded_read_regular_fill_pages()
10064 struct btrfs_inode *inode = BTRFS_I(file_inode(iocb->ki_filp)); in btrfs_encoded_read_regular()
10065 struct extent_io_tree *io_tree = &inode->io_tree; in btrfs_encoded_read_regular()
10075 return -ENOMEM; in btrfs_encoded_read_regular()
10078 ret = -ENOMEM; in btrfs_encoded_read_regular()
10095 i = (iocb->ki_pos - start) >> PAGE_SHIFT; in btrfs_encoded_read_regular()
10096 page_offset = (iocb->ki_pos - start) & (PAGE_SIZE - 1); in btrfs_encoded_read_regular()
10100 size_t bytes = min_t(size_t, count - cur, in btrfs_encoded_read_regular()
10101 PAGE_SIZE - page_offset); in btrfs_encoded_read_regular()
10105 ret = -EFAULT; in btrfs_encoded_read_regular()
10125 struct btrfs_inode *inode = BTRFS_I(file_inode(iocb->ki_filp)); in btrfs_encoded_read()
10126 struct btrfs_fs_info *fs_info = inode->root->fs_info; in btrfs_encoded_read()
10127 struct extent_io_tree *io_tree = &inode->io_tree; in btrfs_encoded_read()
10135 file_accessed(iocb->ki_filp); in btrfs_encoded_read()
10139 if (iocb->ki_pos >= inode->vfs_inode.i_size) { in btrfs_encoded_read()
10143 start = ALIGN_DOWN(iocb->ki_pos, fs_info->sectorsize); in btrfs_encoded_read()
10145 * We don't know how long the extent containing iocb->ki_pos is, but if in btrfs_encoded_read()
10148 lockend = start + BTRFS_MAX_UNCOMPRESSED - 1; in btrfs_encoded_read()
10153 ret = btrfs_wait_ordered_range(&inode->vfs_inode, start, in btrfs_encoded_read()
10154 lockend - start + 1); in btrfs_encoded_read()
10159 lockend - start + 1); in btrfs_encoded_read()
10167 em = btrfs_get_extent(inode, NULL, 0, start, lockend - start + 1); in btrfs_encoded_read()
10173 if (em->block_start == EXTENT_MAP_INLINE) { in btrfs_encoded_read()
10174 u64 extent_start = em->start; in btrfs_encoded_read()
10192 encoded->len = min_t(u64, extent_map_end(em), in btrfs_encoded_read()
10193 inode->vfs_inode.i_size) - iocb->ki_pos; in btrfs_encoded_read()
10194 if (em->block_start == EXTENT_MAP_HOLE || in btrfs_encoded_read()
10195 (em->flags & EXTENT_FLAG_PREALLOC)) { in btrfs_encoded_read()
10197 count = min_t(u64, count, encoded->len); in btrfs_encoded_read()
10198 encoded->len = count; in btrfs_encoded_read()
10199 encoded->unencoded_len = count; in btrfs_encoded_read()
10201 disk_bytenr = em->block_start; in btrfs_encoded_read()
10206 if (em->block_len > count) { in btrfs_encoded_read()
10207 ret = -ENOBUFS; in btrfs_encoded_read()
10210 disk_io_size = em->block_len; in btrfs_encoded_read()
10211 count = em->block_len; in btrfs_encoded_read()
10212 encoded->unencoded_len = em->ram_bytes; in btrfs_encoded_read()
10213 encoded->unencoded_offset = iocb->ki_pos - em->orig_start; in btrfs_encoded_read()
10218 encoded->compression = ret; in btrfs_encoded_read()
10220 disk_bytenr = em->block_start + (start - em->start); in btrfs_encoded_read()
10221 if (encoded->len > count) in btrfs_encoded_read()
10222 encoded->len = count; in btrfs_encoded_read()
10227 disk_io_size = min(lockend + 1, iocb->ki_pos + encoded->len) - start; in btrfs_encoded_read()
10228 count = start + disk_io_size - iocb->ki_pos; in btrfs_encoded_read()
10229 encoded->len = count; in btrfs_encoded_read()
10230 encoded->unencoded_len = count; in btrfs_encoded_read()
10231 disk_io_size = ALIGN(disk_io_size, fs_info->sectorsize); in btrfs_encoded_read()
10242 ret = -EFAULT; in btrfs_encoded_read()
10247 encoded->compression, in btrfs_encoded_read()
10253 iocb->ki_pos += encoded->len; in btrfs_encoded_read()
10268 struct btrfs_inode *inode = BTRFS_I(file_inode(iocb->ki_filp)); in btrfs_do_encoded_write()
10269 struct btrfs_root *root = inode->root; in btrfs_do_encoded_write()
10270 struct btrfs_fs_info *fs_info = root->fs_info; in btrfs_do_encoded_write()
10271 struct extent_io_tree *io_tree = &inode->io_tree; in btrfs_do_encoded_write()
10286 switch (encoded->compression) { in btrfs_do_encoded_write()
10299 if (encoded->compression - in btrfs_do_encoded_write()
10301 fs_info->sectorsize_bits) in btrfs_do_encoded_write()
10302 return -EINVAL; in btrfs_do_encoded_write()
10306 return -EINVAL; in btrfs_do_encoded_write()
10308 if (encoded->encryption != BTRFS_ENCODED_IO_ENCRYPTION_NONE) in btrfs_do_encoded_write()
10309 return -EINVAL; in btrfs_do_encoded_write()
10315 if (inode->flags & BTRFS_INODE_NODATASUM) in btrfs_do_encoded_write()
10316 return -EINVAL; in btrfs_do_encoded_write()
10321 if (encoded->unencoded_len > BTRFS_MAX_UNCOMPRESSED || in btrfs_do_encoded_write()
10323 return -EINVAL; in btrfs_do_encoded_write()
10338 if (orig_count >= encoded->unencoded_len) in btrfs_do_encoded_write()
10339 return -EINVAL; in btrfs_do_encoded_write()
10342 start = iocb->ki_pos; in btrfs_do_encoded_write()
10343 if (!IS_ALIGNED(start, fs_info->sectorsize)) in btrfs_do_encoded_write()
10344 return -EINVAL; in btrfs_do_encoded_write()
10351 if (start + encoded->len < inode->vfs_inode.i_size && in btrfs_do_encoded_write()
10352 !IS_ALIGNED(start + encoded->len, fs_info->sectorsize)) in btrfs_do_encoded_write()
10353 return -EINVAL; in btrfs_do_encoded_write()
10355 /* Finally, the offset in the unencoded data must be sector-aligned. */ in btrfs_do_encoded_write()
10356 if (!IS_ALIGNED(encoded->unencoded_offset, fs_info->sectorsize)) in btrfs_do_encoded_write()
10357 return -EINVAL; in btrfs_do_encoded_write()
10359 num_bytes = ALIGN(encoded->len, fs_info->sectorsize); in btrfs_do_encoded_write()
10360 ram_bytes = ALIGN(encoded->unencoded_len, fs_info->sectorsize); in btrfs_do_encoded_write()
10361 end = start + num_bytes - 1; in btrfs_do_encoded_write()
10365 * sector-aligned. For convenience, we extend it with zeroes if it in btrfs_do_encoded_write()
10368 disk_num_bytes = ALIGN(orig_count, fs_info->sectorsize); in btrfs_do_encoded_write()
10372 return -ENOMEM; in btrfs_do_encoded_write()
10379 ret = -ENOMEM; in btrfs_do_encoded_write()
10385 ret = -EFAULT; in btrfs_do_encoded_write()
10389 memset(kaddr + bytes, 0, PAGE_SIZE - bytes); in btrfs_do_encoded_write()
10396 ret = btrfs_wait_ordered_range(&inode->vfs_inode, start, num_bytes); in btrfs_do_encoded_write()
10399 ret = invalidate_inode_pages2_range(inode->vfs_inode.i_mapping, in btrfs_do_encoded_write()
10407 !filemap_range_has_page(inode->vfs_inode.i_mapping, start, end)) in btrfs_do_encoded_write()
10416 * We don't use the higher-level delalloc space functions because our in btrfs_do_encoded_write()
10431 if (start == 0 && encoded->unencoded_len == encoded->len && in btrfs_do_encoded_write()
10432 encoded->unencoded_offset == 0) { in btrfs_do_encoded_write()
10433 ret = cow_file_range_inline(inode, encoded->len, orig_count, in btrfs_do_encoded_write()
10449 start - encoded->unencoded_offset, ins.objectid, in btrfs_do_encoded_write()
10460 encoded->unencoded_offset, in btrfs_do_encoded_write()
10471 if (start + encoded->len > inode->vfs_inode.i_size) in btrfs_do_encoded_write()
10472 i_size_write(&inode->vfs_inode, start + encoded->len); in btrfs_do_encoded_write()
10508 iocb->ki_pos += encoded->len; in btrfs_do_encoded_write()
10521 struct btrfs_fs_info *fs_info = BTRFS_I(inode)->root->fs_info; in btrfs_add_swapfile_pin()
10528 return -ENOMEM; in btrfs_add_swapfile_pin()
10529 sp->ptr = ptr; in btrfs_add_swapfile_pin()
10530 sp->inode = inode; in btrfs_add_swapfile_pin()
10531 sp->is_block_group = is_block_group; in btrfs_add_swapfile_pin()
10532 sp->bg_extent_count = 1; in btrfs_add_swapfile_pin()
10534 spin_lock(&fs_info->swapfile_pins_lock); in btrfs_add_swapfile_pin()
10535 p = &fs_info->swapfile_pins.rb_node; in btrfs_add_swapfile_pin()
10539 if (sp->ptr < entry->ptr || in btrfs_add_swapfile_pin()
10540 (sp->ptr == entry->ptr && sp->inode < entry->inode)) { in btrfs_add_swapfile_pin()
10541 p = &(*p)->rb_left; in btrfs_add_swapfile_pin()
10542 } else if (sp->ptr > entry->ptr || in btrfs_add_swapfile_pin()
10543 (sp->ptr == entry->ptr && sp->inode > entry->inode)) { in btrfs_add_swapfile_pin()
10544 p = &(*p)->rb_right; in btrfs_add_swapfile_pin()
10547 entry->bg_extent_count++; in btrfs_add_swapfile_pin()
10548 spin_unlock(&fs_info->swapfile_pins_lock); in btrfs_add_swapfile_pin()
10553 rb_link_node(&sp->node, parent, p); in btrfs_add_swapfile_pin()
10554 rb_insert_color(&sp->node, &fs_info->swapfile_pins); in btrfs_add_swapfile_pin()
10555 spin_unlock(&fs_info->swapfile_pins_lock); in btrfs_add_swapfile_pin()
10562 struct btrfs_fs_info *fs_info = BTRFS_I(inode)->root->fs_info; in btrfs_free_swapfile_pins()
10566 spin_lock(&fs_info->swapfile_pins_lock); in btrfs_free_swapfile_pins()
10567 node = rb_first(&fs_info->swapfile_pins); in btrfs_free_swapfile_pins()
10571 if (sp->inode == inode) { in btrfs_free_swapfile_pins()
10572 rb_erase(&sp->node, &fs_info->swapfile_pins); in btrfs_free_swapfile_pins()
10573 if (sp->is_block_group) { in btrfs_free_swapfile_pins()
10574 btrfs_dec_block_group_swap_extents(sp->ptr, in btrfs_free_swapfile_pins()
10575 sp->bg_extent_count); in btrfs_free_swapfile_pins()
10576 btrfs_put_block_group(sp->ptr); in btrfs_free_swapfile_pins()
10582 spin_unlock(&fs_info->swapfile_pins_lock); in btrfs_free_swapfile_pins()
10608 if (bsi->nr_pages >= sis->max) in btrfs_add_swap_extent()
10611 max_pages = sis->max - bsi->nr_pages; in btrfs_add_swap_extent()
10612 first_ppage = PAGE_ALIGN(bsi->block_start) >> PAGE_SHIFT; in btrfs_add_swap_extent()
10613 next_ppage = PAGE_ALIGN_DOWN(bsi->block_start + bsi->block_len) >> PAGE_SHIFT; in btrfs_add_swap_extent()
10617 nr_pages = next_ppage - first_ppage; in btrfs_add_swap_extent()
10621 if (bsi->start == 0) in btrfs_add_swap_extent()
10623 if (bsi->lowest_ppage > first_ppage_reported) in btrfs_add_swap_extent()
10624 bsi->lowest_ppage = first_ppage_reported; in btrfs_add_swap_extent()
10625 if (bsi->highest_ppage < (next_ppage - 1)) in btrfs_add_swap_extent()
10626 bsi->highest_ppage = next_ppage - 1; in btrfs_add_swap_extent()
10628 ret = add_swap_extent(sis, bsi->nr_pages, nr_pages, first_ppage); in btrfs_add_swap_extent()
10631 bsi->nr_extents += ret; in btrfs_add_swap_extent()
10632 bsi->nr_pages += nr_pages; in btrfs_add_swap_extent()
10641 atomic_dec(&BTRFS_I(inode)->root->nr_swapfiles); in btrfs_swap_deactivate()
10648 struct btrfs_root *root = BTRFS_I(inode)->root; in btrfs_swap_activate()
10649 struct btrfs_fs_info *fs_info = root->fs_info; in btrfs_swap_activate()
10650 struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree; in btrfs_swap_activate()
10656 .lowest_ppage = (sector_t)-1ULL, in btrfs_swap_activate()
10667 ret = btrfs_wait_ordered_range(inode, 0, (u64)-1); in btrfs_swap_activate()
10674 if (BTRFS_I(inode)->flags & BTRFS_INODE_COMPRESS) { in btrfs_swap_activate()
10676 return -EINVAL; in btrfs_swap_activate()
10678 if (!(BTRFS_I(inode)->flags & BTRFS_INODE_NODATACOW)) { in btrfs_swap_activate()
10679 btrfs_warn(fs_info, "swapfile must not be copy-on-write"); in btrfs_swap_activate()
10680 return -EINVAL; in btrfs_swap_activate()
10682 if (!(BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM)) { in btrfs_swap_activate()
10684 return -EINVAL; in btrfs_swap_activate()
10691 * fs_info->swapfile_pins prevents them from running while the swap in btrfs_swap_activate()
10699 return -EBUSY; in btrfs_swap_activate()
10709 if (!btrfs_drew_try_write_lock(&root->snapshot_lock)) { in btrfs_swap_activate()
10713 return -EINVAL; in btrfs_swap_activate()
10725 spin_lock(&root->root_item_lock); in btrfs_swap_activate()
10727 spin_unlock(&root->root_item_lock); in btrfs_swap_activate()
10732 root->root_key.objectid); in btrfs_swap_activate()
10733 return -EPERM; in btrfs_swap_activate()
10735 atomic_inc(&root->nr_swapfiles); in btrfs_swap_activate()
10736 spin_unlock(&root->root_item_lock); in btrfs_swap_activate()
10738 isize = ALIGN_DOWN(inode->i_size, fs_info->sectorsize); in btrfs_swap_activate()
10740 lock_extent(io_tree, 0, isize - 1, &cached_state); in btrfs_swap_activate()
10745 u64 len = isize - start; in btrfs_swap_activate()
10753 if (em->block_start == EXTENT_MAP_HOLE) { in btrfs_swap_activate()
10755 ret = -EINVAL; in btrfs_swap_activate()
10758 if (em->block_start == EXTENT_MAP_INLINE) { in btrfs_swap_activate()
10767 ret = -EINVAL; in btrfs_swap_activate()
10772 ret = -EINVAL; in btrfs_swap_activate()
10776 logical_block_start = em->block_start + (start - em->start); in btrfs_swap_activate()
10777 len = min(len, em->len - (start - em->start)); in btrfs_swap_activate()
10788 "swapfile must not be copy-on-write"); in btrfs_swap_activate()
10789 ret = -EINVAL; in btrfs_swap_activate()
10799 if (map->type & BTRFS_BLOCK_GROUP_PROFILE_MASK) { in btrfs_swap_activate()
10802 ret = -EINVAL; in btrfs_swap_activate()
10807 device = map->stripes[0].dev; in btrfs_swap_activate()
10813 } else if (device != map->stripes[0].dev) { in btrfs_swap_activate()
10815 ret = -EINVAL; in btrfs_swap_activate()
10819 physical_block_start = (map->stripes[0].physical + in btrfs_swap_activate()
10820 (logical_block_start - map->start)); in btrfs_swap_activate()
10821 len = min(len, map->chunk_len - (logical_block_start - map->start)); in btrfs_swap_activate()
10829 ret = -EINVAL; in btrfs_swap_activate()
10835 "block group for swapfile at %llu is read-only%s", in btrfs_swap_activate()
10836 bg->start, in btrfs_swap_activate()
10837 atomic_read(&fs_info->scrubs_running) ? in btrfs_swap_activate()
10840 ret = -EINVAL; in btrfs_swap_activate()
10879 unlock_extent(io_tree, 0, isize - 1, &cached_state); in btrfs_swap_activate()
10884 btrfs_drew_write_unlock(&root->snapshot_lock); in btrfs_swap_activate()
10892 sis->bdev = device->bdev; in btrfs_swap_activate()
10893 *span = bsi.highest_ppage - bsi.lowest_ppage + 1; in btrfs_swap_activate()
10894 sis->max = bsi.nr_pages; in btrfs_swap_activate()
10895 sis->pages = bsi.nr_pages - 1; in btrfs_swap_activate()
10896 sis->highest_bit = bsi.nr_pages - 1; in btrfs_swap_activate()
10907 return -EOPNOTSUPP; in btrfs_swap_activate()
10924 spin_lock(&inode->lock); in btrfs_update_inode_bytes()
10926 inode_sub_bytes(&inode->vfs_inode, del_bytes); in btrfs_update_inode_bytes()
10928 inode_add_bytes(&inode->vfs_inode, add_bytes); in btrfs_update_inode_bytes()
10929 spin_unlock(&inode->lock); in btrfs_update_inode_bytes()
10948 struct btrfs_root *root = inode->root; in btrfs_assert_inode_range_clean()
10954 ordered = btrfs_lookup_first_ordered_range(inode, start, end + 1 - start); in btrfs_assert_inode_range_clean()
10956 btrfs_err(root->fs_info, in btrfs_assert_inode_range_clean()
10958 start, end, btrfs_ino(inode), root->root_key.objectid, in btrfs_assert_inode_range_clean()
10959 ordered->file_offset, in btrfs_assert_inode_range_clean()
10960 ordered->file_offset + ordered->num_bytes - 1); in btrfs_assert_inode_range_clean()