Lines Matching +full:foo +full:- +full:queue
1 // SPDX-License-Identifier: GPL-2.0
16 #include <linux/backing-dev.h>
38 #include "disk-io.h"
41 #include "print-tree.h"
42 #include "ordered-data.h"
44 #include "tree-log.h"
48 #include "free-space-cache.h"
51 #include "delalloc-space.h"
52 #include "block-group.h"
53 #include "space-info.h"
100 * btrfs_inode_lock - lock inode i_rwsem based on arguments passed
104 * BTRFS_ILOCK_SHARED - acquire a shared lock on the inode
105 * BTRFS_ILOCK_TRY - try to acquire the lock, if fails on first attempt
106 * return -EAGAIN
107 * BTRFS_ILOCK_MMAP - acquire a write lock on the i_mmap_lock
114 return -EAGAIN; in btrfs_inode_lock()
122 return -EAGAIN; in btrfs_inode_lock()
129 down_write(&BTRFS_I(inode)->i_mmap_lock); in btrfs_inode_lock()
134 * btrfs_inode_unlock - unock inode i_rwsem
142 up_write(&BTRFS_I(inode)->i_mmap_lock); in btrfs_inode_unlock()
164 unsigned long end_index = (offset + bytes - 1) >> PAGE_SHIFT; in btrfs_cleanup_ordered_extents()
166 u64 page_end = page_start + PAGE_SIZE - 1; in btrfs_cleanup_ordered_extents()
186 page = find_get_page(inode->vfs_inode.i_mapping, index); in btrfs_cleanup_ordered_extents()
196 btrfs_page_clamp_clear_ordered(inode->root->fs_info, page, in btrfs_cleanup_ordered_extents()
209 if (page_start >= offset && page_end <= (offset + bytes - 1)) { in btrfs_cleanup_ordered_extents()
210 bytes = offset + bytes - page_offset(locked_page) - PAGE_SIZE; in btrfs_cleanup_ordered_extents()
272 leaf = path->nodes[0]; in insert_inline_extent()
273 ei = btrfs_item_ptr(leaf, path->slots[0], in insert_inline_extent()
275 btrfs_set_file_extent_generation(leaf, ei, trans->transid); in insert_inline_extent()
296 compressed_size -= cur_size; in insert_inline_extent()
301 page = find_get_page(inode->i_mapping, in insert_inline_extent()
317 size = ALIGN(size, root->fs_info->sectorsize); in insert_inline_extent()
331 BTRFS_I(inode)->disk_i_size = inode->i_size; in insert_inline_extent()
348 struct btrfs_root *root = inode->root; in cow_file_range_inline()
349 struct btrfs_fs_info *fs_info = root->fs_info; in cow_file_range_inline()
351 u64 isize = i_size_read(&inode->vfs_inode); in cow_file_range_inline()
353 u64 inline_len = actual_end - start; in cow_file_range_inline()
354 u64 aligned_end = ALIGN(end, fs_info->sectorsize); in cow_file_range_inline()
363 actual_end > fs_info->sectorsize || in cow_file_range_inline()
366 (actual_end & (fs_info->sectorsize - 1)) == 0) || in cow_file_range_inline()
368 data_len > fs_info->max_inline) { in cow_file_range_inline()
374 return -ENOMEM; in cow_file_range_inline()
381 trans->block_rsv = &inode->block_rsv; in cow_file_range_inline()
405 root, &inode->vfs_inode, start, in cow_file_range_inline()
408 if (ret && ret != -ENOSPC) { in cow_file_range_inline()
411 } else if (ret == -ENOSPC) { in cow_file_range_inline()
418 if (ret && ret != -ENOSPC) { in cow_file_range_inline()
421 } else if (ret == -ENOSPC) { in cow_file_range_inline()
426 set_bit(BTRFS_INODE_NEEDS_FULL_SYNC, &inode->runtime_flags); in cow_file_range_inline()
478 BUG_ON(!async_extent); /* -ENOMEM */ in add_async_extent()
479 async_extent->start = start; in add_async_extent()
480 async_extent->ram_size = ram_size; in add_async_extent()
481 async_extent->compressed_size = compressed_size; in add_async_extent()
482 async_extent->pages = pages; in add_async_extent()
483 async_extent->nr_pages = nr_pages; in add_async_extent()
484 async_extent->compress_type = compress_type; in add_async_extent()
485 list_add_tail(&async_extent->list, &cow->extents); in add_async_extent()
495 if (inode->root->fs_info->sectorsize < PAGE_SIZE) in inode_can_compress()
497 if (inode->flags & BTRFS_INODE_NODATACOW || in inode_can_compress()
498 inode->flags & BTRFS_INODE_NODATASUM) in inode_can_compress()
510 struct btrfs_fs_info *fs_info = inode->root->fs_info; in inode_need_compress()
522 if (inode->defrag_compress) in inode_need_compress()
525 if (inode->flags & BTRFS_INODE_NOCOMPRESS) in inode_need_compress()
528 inode->flags & BTRFS_INODE_COMPRESS || in inode_need_compress()
529 inode->prop_compress) in inode_need_compress()
530 return btrfs_compress_heuristic(&inode->vfs_inode, start, end); in inode_need_compress()
539 (start > 0 || end + 1 < inode->disk_i_size)) in inode_should_defrag()
548 * This is done inside an ordered work queue, and the compression
550 * two, and the ordered work queue takes care of making sure that
551 * happens in the same order things were put onto the queue by
555 * entry onto the work queue to write the uncompressed bytes. This
562 struct inode *inode = async_chunk->inode; in compress_file_range()
563 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); in compress_file_range()
564 u64 blocksize = fs_info->sectorsize; in compress_file_range()
565 u64 start = async_chunk->start; in compress_file_range()
566 u64 end = async_chunk->end; in compress_file_range()
576 int compress_type = fs_info->compress_type; in compress_file_range()
580 inode_should_defrag(BTRFS_I(inode), start, end, end - start + 1, in compress_file_range()
598 nr_pages = (end >> PAGE_SHIFT) - (start >> PAGE_SHIFT) + 1; in compress_file_range()
616 total_compressed = actual_end - start; in compress_file_range()
623 (start > 0 || end + 1 < BTRFS_I(inode)->disk_i_size)) in compress_file_range()
632 * we do compression for mount -o compress and when the in compress_file_range()
645 if (BTRFS_I(inode)->defrag_compress) in compress_file_range()
646 compress_type = BTRFS_I(inode)->defrag_compress; in compress_file_range()
647 else if (BTRFS_I(inode)->prop_compress) in compress_file_range()
648 compress_type = BTRFS_I(inode)->prop_compress; in compress_file_range()
669 compress_type | (fs_info->compress_level << 4), in compress_file_range()
670 inode->i_mapping, start, in compress_file_range()
678 struct page *page = pages[nr_pages - 1]; in compress_file_range()
684 memzero_page(page, offset, PAGE_SIZE - offset); in compress_file_range()
693 if (start == 0 && fs_info->sectorsize == PAGE_SIZE) { in compress_file_range()
741 WARN_ON(pages[i]->mapping); in compress_file_range()
791 WARN_ON(pages[i]->mapping); in compress_file_range()
801 !(BTRFS_I(inode)->prop_compress)) { in compress_file_range()
802 BTRFS_I(inode)->flags |= BTRFS_INODE_NOCOMPRESS; in compress_file_range()
809 * to our extent and set things up for the async work queue to run in compress_file_range()
812 if (async_chunk->locked_page && in compress_file_range()
813 (page_offset(async_chunk->locked_page) >= start && in compress_file_range()
814 page_offset(async_chunk->locked_page)) <= end) { in compress_file_range()
815 __set_page_dirty_nobuffers(async_chunk->locked_page); in compress_file_range()
821 add_async_extent(async_chunk, start, end - start + 1, 0, NULL, 0, in compress_file_range()
832 if (!async_extent->pages) in free_async_extent_pages()
835 for (i = 0; i < async_extent->nr_pages; i++) { in free_async_extent_pages()
836 WARN_ON(async_extent->pages[i]->mapping); in free_async_extent_pages()
837 put_page(async_extent->pages[i]); in free_async_extent_pages()
839 kfree(async_extent->pages); in free_async_extent_pages()
840 async_extent->nr_pages = 0; in free_async_extent_pages()
841 async_extent->pages = NULL; in free_async_extent_pages()
852 struct btrfs_inode *inode = BTRFS_I(async_chunk->inode); in submit_compressed_extents()
853 struct btrfs_fs_info *fs_info = inode->root->fs_info; in submit_compressed_extents()
858 struct btrfs_root *root = inode->root; in submit_compressed_extents()
859 struct extent_io_tree *io_tree = &inode->io_tree; in submit_compressed_extents()
863 while (!list_empty(&async_chunk->extents)) { in submit_compressed_extents()
864 async_extent = list_entry(async_chunk->extents.next, in submit_compressed_extents()
866 list_del(&async_extent->list); in submit_compressed_extents()
869 lock_extent(io_tree, async_extent->start, in submit_compressed_extents()
870 async_extent->start + async_extent->ram_size - 1); in submit_compressed_extents()
872 if (!async_extent->pages) { in submit_compressed_extents()
877 ret = cow_file_range(inode, async_chunk->locked_page, in submit_compressed_extents()
878 async_extent->start, in submit_compressed_extents()
879 async_extent->start + in submit_compressed_extents()
880 async_extent->ram_size - 1, in submit_compressed_extents()
892 extent_write_locked_range(&inode->vfs_inode, in submit_compressed_extents()
893 async_extent->start, in submit_compressed_extents()
894 async_extent->start + in submit_compressed_extents()
895 async_extent->ram_size - 1, in submit_compressed_extents()
897 else if (ret && async_chunk->locked_page) in submit_compressed_extents()
898 unlock_page(async_chunk->locked_page); in submit_compressed_extents()
904 ret = btrfs_reserve_extent(root, async_extent->ram_size, in submit_compressed_extents()
905 async_extent->compressed_size, in submit_compressed_extents()
906 async_extent->compressed_size, in submit_compressed_extents()
911 if (ret == -ENOSPC) { in submit_compressed_extents()
912 unlock_extent(io_tree, async_extent->start, in submit_compressed_extents()
913 async_extent->start + in submit_compressed_extents()
914 async_extent->ram_size - 1); in submit_compressed_extents()
922 extent_range_redirty_for_io(&inode->vfs_inode, in submit_compressed_extents()
923 async_extent->start, in submit_compressed_extents()
924 async_extent->start + in submit_compressed_extents()
925 async_extent->ram_size - 1); in submit_compressed_extents()
935 em = create_io_em(inode, async_extent->start, in submit_compressed_extents()
936 async_extent->ram_size, /* len */ in submit_compressed_extents()
937 async_extent->start, /* orig_start */ in submit_compressed_extents()
941 async_extent->ram_size, /* ram_bytes */ in submit_compressed_extents()
942 async_extent->compress_type, in submit_compressed_extents()
950 async_extent->start, in submit_compressed_extents()
952 async_extent->ram_size, in submit_compressed_extents()
954 async_extent->compress_type); in submit_compressed_extents()
956 btrfs_drop_extent_cache(inode, async_extent->start, in submit_compressed_extents()
957 async_extent->start + in submit_compressed_extents()
958 async_extent->ram_size - 1, 0); in submit_compressed_extents()
966 extent_clear_unlock_delalloc(inode, async_extent->start, in submit_compressed_extents()
967 async_extent->start + in submit_compressed_extents()
968 async_extent->ram_size - 1, in submit_compressed_extents()
971 if (btrfs_submit_compressed_write(inode, async_extent->start, in submit_compressed_extents()
972 async_extent->ram_size, in submit_compressed_extents()
974 ins.offset, async_extent->pages, in submit_compressed_extents()
975 async_extent->nr_pages, in submit_compressed_extents()
976 async_chunk->write_flags, in submit_compressed_extents()
977 async_chunk->blkcg_css)) { in submit_compressed_extents()
978 struct page *p = async_extent->pages[0]; in submit_compressed_extents()
979 const u64 start = async_extent->start; in submit_compressed_extents()
980 const u64 end = start + async_extent->ram_size - 1; in submit_compressed_extents()
982 p->mapping = inode->vfs_inode.i_mapping; in submit_compressed_extents()
986 p->mapping = NULL; in submit_compressed_extents()
1001 extent_clear_unlock_delalloc(inode, async_extent->start, in submit_compressed_extents()
1002 async_extent->start + in submit_compressed_extents()
1003 async_extent->ram_size - 1, in submit_compressed_extents()
1017 struct extent_map_tree *em_tree = &inode->extent_tree; in get_extent_allocation_hint()
1021 read_lock(&em_tree->lock); in get_extent_allocation_hint()
1029 if (em->block_start >= EXTENT_MAP_LAST_BYTE) { in get_extent_allocation_hint()
1032 if (em && em->block_start < EXTENT_MAP_LAST_BYTE) in get_extent_allocation_hint()
1033 alloc_hint = em->block_start; in get_extent_allocation_hint()
1037 alloc_hint = em->block_start; in get_extent_allocation_hint()
1041 read_unlock(&em_tree->lock); in get_extent_allocation_hint()
1064 struct btrfs_root *root = inode->root; in cow_file_range()
1065 struct btrfs_fs_info *fs_info = root->fs_info; in cow_file_range()
1071 u64 blocksize = fs_info->sectorsize; in cow_file_range()
1081 ret = -EINVAL; in cow_file_range()
1085 num_bytes = ALIGN(end - start + 1, blocksize); in cow_file_range()
1087 ASSERT(num_bytes <= btrfs_super_total_bytes(fs_info->super_copy)); in cow_file_range()
1101 if (start == 0 && fs_info->sectorsize == PAGE_SIZE) { in cow_file_range()
1119 (end - start + PAGE_SIZE) / PAGE_SIZE; in cow_file_range()
1141 btrfs_drop_extent_cache(inode, start, start + num_bytes - 1, 0); in cow_file_range()
1154 if (root->root_key.objectid == BTRFS_DATA_RELOC_TREE_OBJECTID) in cow_file_range()
1157 min_alloc_size = fs_info->sectorsize; in cow_file_range()
1190 if (root->root_key.objectid == in cow_file_range()
1207 start + ram_size - 1, 0); in cow_file_range()
1223 extent_clear_unlock_delalloc(inode, start, start + ram_size - 1, in cow_file_range()
1230 num_bytes -= cur_alloc_size; in cow_file_range()
1247 btrfs_drop_extent_cache(inode, start, start + ram_size - 1, 0); in cow_file_range()
1267 start + cur_alloc_size - 1, in cow_file_range()
1282 * work queue call back to started compression on a file and pages
1293 btrfs_add_delayed_iput(async_chunk->inode); in async_cow_start()
1294 async_chunk->inode = NULL; in async_cow_start()
1299 * work queue call back to submit previously compressed pages
1308 nr_pages = (async_chunk->end - async_chunk->start + PAGE_SIZE) >> in async_cow_submit()
1312 * ->inode could be NULL if async_chunk_start has failed to compress, in async_cow_submit()
1314 * always adjust ->async_delalloc_pages as its paired with the init in async_cow_submit()
1317 if (async_chunk->inode) in async_cow_submit()
1321 if (atomic_sub_return(nr_pages, &fs_info->async_delalloc_pages) < in async_cow_submit()
1323 cond_wake_up_nomb(&fs_info->async_submit_wait); in async_cow_submit()
1331 if (async_chunk->inode) in async_cow_free()
1332 btrfs_add_delayed_iput(async_chunk->inode); in async_cow_free()
1333 if (async_chunk->blkcg_css) in async_cow_free()
1334 css_put(async_chunk->blkcg_css); in async_cow_free()
1339 if (atomic_dec_and_test(async_chunk->pending)) in async_cow_free()
1340 kvfree(async_chunk->pending); in async_cow_free()
1349 struct btrfs_fs_info *fs_info = inode->root->fs_info; in cow_file_range_async()
1355 u64 num_chunks = DIV_ROUND_UP(end - start, SZ_512K); in cow_file_range_async()
1361 unlock_extent(&inode->io_tree, start, end); in cow_file_range_async()
1363 if (inode->flags & BTRFS_INODE_NOCOMPRESS && in cow_file_range_async()
1384 return -ENOMEM; in cow_file_range_async()
1387 async_chunk = ctx->chunks; in cow_file_range_async()
1388 atomic_set(&ctx->num_chunks, num_chunks); in cow_file_range_async()
1392 cur_end = min(end, start + SZ_512K - 1); in cow_file_range_async()
1400 ihold(&inode->vfs_inode); in cow_file_range_async()
1401 async_chunk[i].pending = &ctx->num_chunks; in cow_file_range_async()
1402 async_chunk[i].inode = &inode->vfs_inode; in cow_file_range_async()
1428 cur_end - start); in cow_file_range_async()
1445 nr_pages = DIV_ROUND_UP(cur_end - start, PAGE_SIZE); in cow_file_range_async()
1446 atomic_add(nr_pages, &fs_info->async_delalloc_pages); in cow_file_range_async()
1448 btrfs_queue_work(fs_info->delalloc_workers, &async_chunk[i].work); in cow_file_range_async()
1474 extent_write_locked_range(&inode->vfs_inode, start, end, WB_SYNC_ALL); in run_delalloc_zoned()
1487 ret = btrfs_lookup_csums_range(fs_info->csum_root, bytenr, in csum_exist_in_range()
1488 bytenr + num_bytes - 1, &list, 0); in csum_exist_in_range()
1494 list_del(&sums->list); in csum_exist_in_range()
1507 const bool is_reloc_ino = (inode->root->root_key.objectid == in fallback_to_cow()
1509 const u64 range_bytes = end + 1 - start; in fallback_to_cow()
1510 struct extent_io_tree *io_tree = &inode->io_tree; in fallback_to_cow()
1550 struct btrfs_fs_info *fs_info = inode->root->fs_info; in fallback_to_cow()
1551 struct btrfs_space_info *sinfo = fs_info->data_sinfo; in fallback_to_cow()
1556 spin_lock(&sinfo->lock); in fallback_to_cow()
1558 spin_unlock(&sinfo->lock); in fallback_to_cow()
1582 struct btrfs_fs_info *fs_info = inode->root->fs_info; in run_delalloc_nocow()
1583 struct btrfs_root *root = inode->root; in run_delalloc_nocow()
1585 u64 cow_start = (u64)-1; in run_delalloc_nocow()
1593 const bool force = inode->flags & BTRFS_INODE_NODATACOW; in run_delalloc_nocow()
1603 return -ENOMEM; in run_delalloc_nocow()
1629 if (ret > 0 && path->slots[0] > 0 && check_prev) { in run_delalloc_nocow()
1630 leaf = path->nodes[0]; in run_delalloc_nocow()
1632 path->slots[0] - 1); in run_delalloc_nocow()
1635 path->slots[0]--; in run_delalloc_nocow()
1640 leaf = path->nodes[0]; in run_delalloc_nocow()
1641 if (path->slots[0] >= btrfs_header_nritems(leaf)) { in run_delalloc_nocow()
1644 if (cow_start != (u64)-1) in run_delalloc_nocow()
1650 leaf = path->nodes[0]; in run_delalloc_nocow()
1653 btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]); in run_delalloc_nocow()
1664 path->slots[0]++; in run_delalloc_nocow()
1687 fi = btrfs_item_ptr(leaf, path->slots[0], in run_delalloc_nocow()
1705 path->slots[0]++; in run_delalloc_nocow()
1725 btrfs_root_last_snapshot(&root->root_item)) in run_delalloc_nocow()
1739 found_key.offset - in run_delalloc_nocow()
1743 * ret could be -EIO if the above fails to read in run_delalloc_nocow()
1747 if (cow_start != (u64)-1) in run_delalloc_nocow()
1756 disk_bytenr += cur_offset - found_key.offset; in run_delalloc_nocow()
1757 num_bytes = min(end + 1, extent_end) - cur_offset; in run_delalloc_nocow()
1762 if (!freespace_inode && atomic_read(&root->snapshot_force_cow)) in run_delalloc_nocow()
1773 * ret could be -EIO if the above fails to read in run_delalloc_nocow()
1777 if (cow_start != (u64)-1) in run_delalloc_nocow()
1790 extent_end = ALIGN(extent_end, fs_info->sectorsize); in run_delalloc_nocow()
1793 path->slots[0]++; in run_delalloc_nocow()
1806 if (cow_start == (u64)-1) in run_delalloc_nocow()
1811 if (!path->nodes[0]) in run_delalloc_nocow()
1813 path->slots[0]++; in run_delalloc_nocow()
1818 * COW range from cow_start to found_key.offset - 1. As the key in run_delalloc_nocow()
1822 if (cow_start != (u64)-1) { in run_delalloc_nocow()
1824 cow_start, found_key.offset - 1, in run_delalloc_nocow()
1828 cow_start = (u64)-1; in run_delalloc_nocow()
1832 u64 orig_start = found_key.offset - extent_offset; in run_delalloc_nocow()
1853 cur_offset + num_bytes - 1, in run_delalloc_nocow()
1870 if (root->root_key.objectid == in run_delalloc_nocow()
1881 cur_offset + num_bytes - 1, in run_delalloc_nocow()
1901 if (cur_offset <= end && cow_start == (u64)-1) in run_delalloc_nocow()
1904 if (cow_start != (u64)-1) { in run_delalloc_nocow()
1929 if (inode->flags & (BTRFS_INODE_NODATACOW | BTRFS_INODE_PREALLOC)) { in should_nocow()
1930 if (inode->defrag_bytes && in should_nocow()
1931 test_range_bit(&inode->io_tree, start, end, EXTENT_DEFRAG, in should_nocow()
1948 const bool zoned = btrfs_is_zoned(inode->root->fs_info); in btrfs_run_delalloc_range()
1963 set_bit(BTRFS_INODE_HAS_ASYNC_EXTENT, &inode->runtime_flags); in btrfs_run_delalloc_range()
1970 end - start + 1); in btrfs_run_delalloc_range()
1980 if (!(orig->state & EXTENT_DELALLOC)) in btrfs_split_delalloc_extent()
1983 size = orig->end - orig->start + 1; in btrfs_split_delalloc_extent()
1992 new_size = orig->end - split + 1; in btrfs_split_delalloc_extent()
1994 new_size = split - orig->start; in btrfs_split_delalloc_extent()
2000 spin_lock(&BTRFS_I(inode)->lock); in btrfs_split_delalloc_extent()
2002 spin_unlock(&BTRFS_I(inode)->lock); in btrfs_split_delalloc_extent()
2017 if (!(other->state & EXTENT_DELALLOC)) in btrfs_merge_delalloc_extent()
2020 if (new->start > other->start) in btrfs_merge_delalloc_extent()
2021 new_size = new->end - other->start + 1; in btrfs_merge_delalloc_extent()
2023 new_size = other->end - new->start + 1; in btrfs_merge_delalloc_extent()
2027 spin_lock(&BTRFS_I(inode)->lock); in btrfs_merge_delalloc_extent()
2028 btrfs_mod_outstanding_extents(BTRFS_I(inode), -1); in btrfs_merge_delalloc_extent()
2029 spin_unlock(&BTRFS_I(inode)->lock); in btrfs_merge_delalloc_extent()
2051 old_size = other->end - other->start + 1; in btrfs_merge_delalloc_extent()
2053 old_size = new->end - new->start + 1; in btrfs_merge_delalloc_extent()
2058 spin_lock(&BTRFS_I(inode)->lock); in btrfs_merge_delalloc_extent()
2059 btrfs_mod_outstanding_extents(BTRFS_I(inode), -1); in btrfs_merge_delalloc_extent()
2060 spin_unlock(&BTRFS_I(inode)->lock); in btrfs_merge_delalloc_extent()
2066 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); in btrfs_add_delalloc_inodes()
2068 spin_lock(&root->delalloc_lock); in btrfs_add_delalloc_inodes()
2069 if (list_empty(&BTRFS_I(inode)->delalloc_inodes)) { in btrfs_add_delalloc_inodes()
2070 list_add_tail(&BTRFS_I(inode)->delalloc_inodes, in btrfs_add_delalloc_inodes()
2071 &root->delalloc_inodes); in btrfs_add_delalloc_inodes()
2073 &BTRFS_I(inode)->runtime_flags); in btrfs_add_delalloc_inodes()
2074 root->nr_delalloc_inodes++; in btrfs_add_delalloc_inodes()
2075 if (root->nr_delalloc_inodes == 1) { in btrfs_add_delalloc_inodes()
2076 spin_lock(&fs_info->delalloc_root_lock); in btrfs_add_delalloc_inodes()
2077 BUG_ON(!list_empty(&root->delalloc_root)); in btrfs_add_delalloc_inodes()
2078 list_add_tail(&root->delalloc_root, in btrfs_add_delalloc_inodes()
2079 &fs_info->delalloc_roots); in btrfs_add_delalloc_inodes()
2080 spin_unlock(&fs_info->delalloc_root_lock); in btrfs_add_delalloc_inodes()
2083 spin_unlock(&root->delalloc_lock); in btrfs_add_delalloc_inodes()
2090 struct btrfs_fs_info *fs_info = root->fs_info; in __btrfs_del_delalloc_inode()
2092 if (!list_empty(&inode->delalloc_inodes)) { in __btrfs_del_delalloc_inode()
2093 list_del_init(&inode->delalloc_inodes); in __btrfs_del_delalloc_inode()
2095 &inode->runtime_flags); in __btrfs_del_delalloc_inode()
2096 root->nr_delalloc_inodes--; in __btrfs_del_delalloc_inode()
2097 if (!root->nr_delalloc_inodes) { in __btrfs_del_delalloc_inode()
2098 ASSERT(list_empty(&root->delalloc_inodes)); in __btrfs_del_delalloc_inode()
2099 spin_lock(&fs_info->delalloc_root_lock); in __btrfs_del_delalloc_inode()
2100 BUG_ON(list_empty(&root->delalloc_root)); in __btrfs_del_delalloc_inode()
2101 list_del_init(&root->delalloc_root); in __btrfs_del_delalloc_inode()
2102 spin_unlock(&fs_info->delalloc_root_lock); in __btrfs_del_delalloc_inode()
2110 spin_lock(&root->delalloc_lock); in btrfs_del_delalloc_inode()
2112 spin_unlock(&root->delalloc_lock); in btrfs_del_delalloc_inode()
2122 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); in btrfs_set_delalloc_extent()
2131 if (!(state->state & EXTENT_DELALLOC) && (*bits & EXTENT_DELALLOC)) { in btrfs_set_delalloc_extent()
2132 struct btrfs_root *root = BTRFS_I(inode)->root; in btrfs_set_delalloc_extent()
2133 u64 len = state->end + 1 - state->start; in btrfs_set_delalloc_extent()
2137 spin_lock(&BTRFS_I(inode)->lock); in btrfs_set_delalloc_extent()
2139 spin_unlock(&BTRFS_I(inode)->lock); in btrfs_set_delalloc_extent()
2145 percpu_counter_add_batch(&fs_info->delalloc_bytes, len, in btrfs_set_delalloc_extent()
2146 fs_info->delalloc_batch); in btrfs_set_delalloc_extent()
2147 spin_lock(&BTRFS_I(inode)->lock); in btrfs_set_delalloc_extent()
2148 BTRFS_I(inode)->delalloc_bytes += len; in btrfs_set_delalloc_extent()
2150 BTRFS_I(inode)->defrag_bytes += len; in btrfs_set_delalloc_extent()
2152 &BTRFS_I(inode)->runtime_flags)) in btrfs_set_delalloc_extent()
2154 spin_unlock(&BTRFS_I(inode)->lock); in btrfs_set_delalloc_extent()
2157 if (!(state->state & EXTENT_DELALLOC_NEW) && in btrfs_set_delalloc_extent()
2159 spin_lock(&BTRFS_I(inode)->lock); in btrfs_set_delalloc_extent()
2160 BTRFS_I(inode)->new_delalloc_bytes += state->end + 1 - in btrfs_set_delalloc_extent()
2161 state->start; in btrfs_set_delalloc_extent()
2162 spin_unlock(&BTRFS_I(inode)->lock); in btrfs_set_delalloc_extent()
2174 struct btrfs_fs_info *fs_info = btrfs_sb(vfs_inode->i_sb); in btrfs_clear_delalloc_extent()
2175 u64 len = state->end + 1 - state->start; in btrfs_clear_delalloc_extent()
2178 if ((state->state & EXTENT_DEFRAG) && (*bits & EXTENT_DEFRAG)) { in btrfs_clear_delalloc_extent()
2179 spin_lock(&inode->lock); in btrfs_clear_delalloc_extent()
2180 inode->defrag_bytes -= len; in btrfs_clear_delalloc_extent()
2181 spin_unlock(&inode->lock); in btrfs_clear_delalloc_extent()
2189 if ((state->state & EXTENT_DELALLOC) && (*bits & EXTENT_DELALLOC)) { in btrfs_clear_delalloc_extent()
2190 struct btrfs_root *root = inode->root; in btrfs_clear_delalloc_extent()
2193 spin_lock(&inode->lock); in btrfs_clear_delalloc_extent()
2194 btrfs_mod_outstanding_extents(inode, -num_extents); in btrfs_clear_delalloc_extent()
2195 spin_unlock(&inode->lock); in btrfs_clear_delalloc_extent()
2203 root != fs_info->tree_root) in btrfs_clear_delalloc_extent()
2210 if (root->root_key.objectid != BTRFS_DATA_RELOC_TREE_OBJECTID && in btrfs_clear_delalloc_extent()
2211 do_list && !(state->state & EXTENT_NORESERVE) && in btrfs_clear_delalloc_extent()
2215 percpu_counter_add_batch(&fs_info->delalloc_bytes, -len, in btrfs_clear_delalloc_extent()
2216 fs_info->delalloc_batch); in btrfs_clear_delalloc_extent()
2217 spin_lock(&inode->lock); in btrfs_clear_delalloc_extent()
2218 inode->delalloc_bytes -= len; in btrfs_clear_delalloc_extent()
2219 if (do_list && inode->delalloc_bytes == 0 && in btrfs_clear_delalloc_extent()
2221 &inode->runtime_flags)) in btrfs_clear_delalloc_extent()
2223 spin_unlock(&inode->lock); in btrfs_clear_delalloc_extent()
2226 if ((state->state & EXTENT_DELALLOC_NEW) && in btrfs_clear_delalloc_extent()
2228 spin_lock(&inode->lock); in btrfs_clear_delalloc_extent()
2229 ASSERT(inode->new_delalloc_bytes >= len); in btrfs_clear_delalloc_extent()
2230 inode->new_delalloc_bytes -= len; in btrfs_clear_delalloc_extent()
2232 inode_add_bytes(&inode->vfs_inode, len); in btrfs_clear_delalloc_extent()
2233 spin_unlock(&inode->lock); in btrfs_clear_delalloc_extent()
2238 * btrfs_bio_fits_in_stripe - Checks whether the size of the given bio will fit
2242 * @page - The page we are about to add to the bio
2243 * @size - size we want to add to the bio
2244 * @bio - bio we want to ensure is smaller than a stripe
2245 * @bio_flags - flags of the bio
2254 struct inode *inode = page->mapping->host; in btrfs_bio_fits_in_stripe()
2255 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); in btrfs_bio_fits_in_stripe()
2256 u64 logical = bio->bi_iter.bi_sector << 9; in btrfs_bio_fits_in_stripe()
2257 u32 bio_len = bio->bi_iter.bi_size; in btrfs_bio_fits_in_stripe()
2265 em = btrfs_get_chunk_map(fs_info, logical, fs_info->sectorsize); in btrfs_bio_fits_in_stripe()
2301 struct extent_map_tree *em_tree = &inode->extent_tree; in split_zoned_em()
2319 ret = -ENOMEM; in split_zoned_em()
2325 lock_extent(&inode->io_tree, start, start + len - 1); in split_zoned_em()
2326 write_lock(&em_tree->lock); in split_zoned_em()
2329 ret = -EIO; in split_zoned_em()
2333 ASSERT(em->len == len); in split_zoned_em()
2334 ASSERT(!test_bit(EXTENT_FLAG_COMPRESSED, &em->flags)); in split_zoned_em()
2335 ASSERT(em->block_start < EXTENT_MAP_LAST_BYTE); in split_zoned_em()
2336 ASSERT(test_bit(EXTENT_FLAG_PINNED, &em->flags)); in split_zoned_em()
2337 ASSERT(!test_bit(EXTENT_FLAG_LOGGING, &em->flags)); in split_zoned_em()
2338 ASSERT(!list_empty(&em->list)); in split_zoned_em()
2340 flags = em->flags; in split_zoned_em()
2341 clear_bit(EXTENT_FLAG_PINNED, &em->flags); in split_zoned_em()
2343 /* First, replace the em with a new extent_map starting from * em->start */ in split_zoned_em()
2344 split_pre->start = em->start; in split_zoned_em()
2345 split_pre->len = (pre ? pre : em->len - post); in split_zoned_em()
2346 split_pre->orig_start = split_pre->start; in split_zoned_em()
2347 split_pre->block_start = em->block_start; in split_zoned_em()
2348 split_pre->block_len = split_pre->len; in split_zoned_em()
2349 split_pre->orig_block_len = split_pre->block_len; in split_zoned_em()
2350 split_pre->ram_bytes = split_pre->len; in split_zoned_em()
2351 split_pre->flags = flags; in split_zoned_em()
2352 split_pre->compress_type = em->compress_type; in split_zoned_em()
2353 split_pre->generation = em->generation; in split_zoned_em()
2359 * [em->start, em->start + pre] if pre != 0 in split_zoned_em()
2360 * [em->start, em->start + em->len - post] if pre == 0 in split_zoned_em()
2365 split_mid->start = em->start + pre; in split_zoned_em()
2366 split_mid->len = em->len - pre - post; in split_zoned_em()
2367 split_mid->orig_start = split_mid->start; in split_zoned_em()
2368 split_mid->block_start = em->block_start + pre; in split_zoned_em()
2369 split_mid->block_len = split_mid->len; in split_zoned_em()
2370 split_mid->orig_block_len = split_mid->block_len; in split_zoned_em()
2371 split_mid->ram_bytes = split_mid->len; in split_zoned_em()
2372 split_mid->flags = flags; in split_zoned_em()
2373 split_mid->compress_type = em->compress_type; in split_zoned_em()
2374 split_mid->generation = em->generation; in split_zoned_em()
2379 split_post->start = em->start + em->len - post; in split_zoned_em()
2380 split_post->len = post; in split_zoned_em()
2381 split_post->orig_start = split_post->start; in split_zoned_em()
2382 split_post->block_start = em->block_start + em->len - post; in split_zoned_em()
2383 split_post->block_len = split_post->len; in split_zoned_em()
2384 split_post->orig_block_len = split_post->block_len; in split_zoned_em()
2385 split_post->ram_bytes = split_post->len; in split_zoned_em()
2386 split_post->flags = flags; in split_zoned_em()
2387 split_post->compress_type = em->compress_type; in split_zoned_em()
2388 split_post->generation = em->generation; in split_zoned_em()
2398 write_unlock(&em_tree->lock); in split_zoned_em()
2399 unlock_extent(&inode->io_tree, start, start + len - 1); in split_zoned_em()
2412 u64 start = (u64)bio->bi_iter.bi_sector << SECTOR_SHIFT; in extract_ordered_extent()
2414 u64 len = bio->bi_iter.bi_size; in extract_ordered_extent()
2425 if (ordered->disk_num_bytes == len) in extract_ordered_extent()
2429 if (WARN_ON_ONCE(ordered->bytes_left != ordered->disk_num_bytes)) { in extract_ordered_extent()
2430 ret = -EINVAL; in extract_ordered_extent()
2435 if (WARN_ON_ONCE(ordered->disk_num_bytes != ordered->num_bytes)) { in extract_ordered_extent()
2436 ret = -EINVAL; in extract_ordered_extent()
2440 ordered_end = ordered->disk_bytenr + ordered->disk_num_bytes; in extract_ordered_extent()
2442 if (WARN_ON_ONCE(start < ordered->disk_bytenr || end > ordered_end)) { in extract_ordered_extent()
2443 ret = -EINVAL; in extract_ordered_extent()
2448 if (WARN_ON_ONCE(!list_empty(&ordered->list))) { in extract_ordered_extent()
2449 ret = -EINVAL; in extract_ordered_extent()
2453 file_len = ordered->num_bytes; in extract_ordered_extent()
2454 pre = start - ordered->disk_bytenr; in extract_ordered_extent()
2455 post = ordered_end - end; in extract_ordered_extent()
2478 * c-1) if bio is issued by fsync: sync submit
2481 * c-2) if root is reloc root: sync submit
2484 * c-3) otherwise: async submit
2490 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); in btrfs_submit_data_bio()
2491 struct btrfs_root *root = BTRFS_I(inode)->root; in btrfs_submit_data_bio()
2495 int async = !atomic_read(&BTRFS_I(inode)->sync_writers); in btrfs_submit_data_bio()
2497 skip_sum = (BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM) || in btrfs_submit_data_bio()
2498 !fs_info->csum_root; in btrfs_submit_data_bio()
2504 struct page *page = bio_first_bvec_all(bio)->bv_page; in btrfs_submit_data_bio()
2535 if (root->root_key.objectid == BTRFS_DATA_RELOC_TREE_OBJECTID) in btrfs_submit_data_bio()
2552 bio->bi_status = ret; in btrfs_submit_data_bio()
2569 trans->adding_csums = true; in add_pending_csums()
2570 ret = btrfs_csum_file_blocks(trans, trans->fs_info->csum_root, sum); in add_pending_csums()
2571 trans->adding_csums = false; in add_pending_csums()
2584 const u64 end = start + len - 1; in btrfs_find_new_delalloc_bytes()
2587 const u64 search_len = end - search_start + 1; in btrfs_find_new_delalloc_bytes()
2596 if (em->block_start != EXTENT_MAP_HOLE) in btrfs_find_new_delalloc_bytes()
2599 em_len = em->len; in btrfs_find_new_delalloc_bytes()
2600 if (em->start < search_start) in btrfs_find_new_delalloc_bytes()
2601 em_len -= search_start - em->start; in btrfs_find_new_delalloc_bytes()
2605 ret = set_extent_bit(&inode->io_tree, search_start, in btrfs_find_new_delalloc_bytes()
2606 search_start + em_len - 1, in btrfs_find_new_delalloc_bytes()
2624 if (start >= i_size_read(&inode->vfs_inode) && in btrfs_set_extent_delalloc()
2625 !(inode->flags & BTRFS_INODE_PREALLOC)) { in btrfs_set_extent_delalloc()
2635 end + 1 - start, in btrfs_set_extent_delalloc()
2641 return set_extent_delalloc(&inode->io_tree, start, end, extra_bits, in btrfs_set_extent_delalloc()
2666 page = fixup->page; in btrfs_writepage_fixup_worker()
2667 inode = BTRFS_I(fixup->inode); in btrfs_writepage_fixup_worker()
2669 page_end = page_offset(page) + PAGE_SIZE - 1; in btrfs_writepage_fixup_worker()
2682 * page->mapping may go NULL, but it shouldn't be moved to a different in btrfs_writepage_fixup_worker()
2685 if (!page->mapping || !PageDirty(page) || !PageChecked(page)) { in btrfs_writepage_fixup_worker()
2720 lock_extent_bits(&inode->io_tree, page_start, page_end, &cached_state); in btrfs_writepage_fixup_worker()
2728 unlock_extent_cached(&inode->io_tree, page_start, page_end, in btrfs_writepage_fixup_worker()
2755 unlock_extent_cached(&inode->io_tree, page_start, page_end, in btrfs_writepage_fixup_worker()
2763 mapping_set_error(page->mapping, ret); in btrfs_writepage_fixup_worker()
2778 btrfs_add_delayed_iput(&inode->vfs_inode); in btrfs_writepage_fixup_worker()
2794 struct inode *inode = page->mapping->host; in btrfs_writepage_cow_fixup()
2795 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); in btrfs_writepage_cow_fixup()
2810 return -EAGAIN; in btrfs_writepage_cow_fixup()
2814 return -EAGAIN; in btrfs_writepage_cow_fixup()
2820 * page->mapping outside of the page lock. in btrfs_writepage_cow_fixup()
2825 btrfs_init_work(&fixup->work, btrfs_writepage_fixup_worker, NULL, NULL); in btrfs_writepage_cow_fixup()
2826 fixup->page = page; in btrfs_writepage_cow_fixup()
2827 fixup->inode = inode; in btrfs_writepage_cow_fixup()
2828 btrfs_queue_work(fs_info->fixup_workers, &fixup->work); in btrfs_writepage_cow_fixup()
2830 return -EAGAIN; in btrfs_writepage_cow_fixup()
2839 struct btrfs_root *root = inode->root; in insert_reserved_file_extent()
2840 const u64 sectorsize = root->fs_info->sectorsize; in insert_reserved_file_extent()
2853 return -ENOMEM; in insert_reserved_file_extent()
2883 leaf = path->nodes[0]; in insert_reserved_file_extent()
2884 btrfs_set_stack_file_extent_generation(stack_fi, trans->transid); in insert_reserved_file_extent()
2886 btrfs_item_ptr_offset(leaf, path->slots[0]), in insert_reserved_file_extent()
2902 inline_size = drop_args.bytes_found - inline_size; in insert_reserved_file_extent()
2904 drop_args.bytes_found -= inline_size; in insert_reserved_file_extent()
2905 num_bytes -= sectorsize; in insert_reserved_file_extent()
2935 spin_lock(&cache->lock); in btrfs_release_delalloc_bytes()
2936 cache->delalloc_bytes -= len; in btrfs_release_delalloc_bytes()
2937 spin_unlock(&cache->lock); in btrfs_release_delalloc_bytes()
2951 btrfs_set_stack_file_extent_disk_bytenr(&stack_fi, oe->disk_bytenr); in insert_ordered_extent_file_extent()
2953 oe->disk_num_bytes); in insert_ordered_extent_file_extent()
2954 if (test_bit(BTRFS_ORDERED_TRUNCATED, &oe->flags)) in insert_ordered_extent_file_extent()
2955 logical_len = oe->truncated_len; in insert_ordered_extent_file_extent()
2957 logical_len = oe->num_bytes; in insert_ordered_extent_file_extent()
2960 btrfs_set_stack_file_extent_compression(&stack_fi, oe->compress_type); in insert_ordered_extent_file_extent()
2969 update_inode_bytes = test_bit(BTRFS_ORDERED_DIRECT, &oe->flags) || in insert_ordered_extent_file_extent()
2970 test_bit(BTRFS_ORDERED_TRUNCATED, &oe->flags); in insert_ordered_extent_file_extent()
2972 return insert_reserved_file_extent(trans, BTRFS_I(oe->inode), in insert_ordered_extent_file_extent()
2973 oe->file_offset, &stack_fi, in insert_ordered_extent_file_extent()
2974 update_inode_bytes, oe->qgroup_rsv); in insert_ordered_extent_file_extent()
2984 struct btrfs_inode *inode = BTRFS_I(ordered_extent->inode); in btrfs_finish_ordered_io()
2985 struct btrfs_root *root = inode->root; in btrfs_finish_ordered_io()
2986 struct btrfs_fs_info *fs_info = root->fs_info; in btrfs_finish_ordered_io()
2988 struct extent_io_tree *io_tree = &inode->io_tree; in btrfs_finish_ordered_io()
2993 u64 logical_len = ordered_extent->num_bytes; in btrfs_finish_ordered_io()
2999 start = ordered_extent->file_offset; in btrfs_finish_ordered_io()
3000 end = start + ordered_extent->num_bytes - 1; in btrfs_finish_ordered_io()
3002 if (!test_bit(BTRFS_ORDERED_NOCOW, &ordered_extent->flags) && in btrfs_finish_ordered_io()
3003 !test_bit(BTRFS_ORDERED_PREALLOC, &ordered_extent->flags) && in btrfs_finish_ordered_io()
3004 !test_bit(BTRFS_ORDERED_DIRECT, &ordered_extent->flags)) in btrfs_finish_ordered_io()
3009 if (test_bit(BTRFS_ORDERED_IOERR, &ordered_extent->flags)) { in btrfs_finish_ordered_io()
3010 ret = -EIO; in btrfs_finish_ordered_io()
3014 if (ordered_extent->bdev) in btrfs_finish_ordered_io()
3019 if (test_bit(BTRFS_ORDERED_TRUNCATED, &ordered_extent->flags)) { in btrfs_finish_ordered_io()
3021 logical_len = ordered_extent->truncated_len; in btrfs_finish_ordered_io()
3027 if (test_bit(BTRFS_ORDERED_NOCOW, &ordered_extent->flags)) { in btrfs_finish_ordered_io()
3028 BUG_ON(!list_empty(&ordered_extent->list)); /* Logic error */ in btrfs_finish_ordered_io()
3040 trans->block_rsv = &inode->block_rsv; in btrfs_finish_ordered_io()
3042 if (ret) /* -ENOMEM or corruption */ in btrfs_finish_ordered_io()
3060 trans->block_rsv = &inode->block_rsv; in btrfs_finish_ordered_io()
3062 if (test_bit(BTRFS_ORDERED_COMPRESSED, &ordered_extent->flags)) in btrfs_finish_ordered_io()
3063 compress_type = ordered_extent->compress_type; in btrfs_finish_ordered_io()
3064 if (test_bit(BTRFS_ORDERED_PREALLOC, &ordered_extent->flags)) { in btrfs_finish_ordered_io()
3067 ordered_extent->file_offset, in btrfs_finish_ordered_io()
3068 ordered_extent->file_offset + in btrfs_finish_ordered_io()
3071 BUG_ON(root == fs_info->tree_root); in btrfs_finish_ordered_io()
3076 ordered_extent->disk_bytenr, in btrfs_finish_ordered_io()
3077 ordered_extent->disk_num_bytes); in btrfs_finish_ordered_io()
3080 unpin_extent_cache(&inode->extent_tree, ordered_extent->file_offset, in btrfs_finish_ordered_io()
3081 ordered_extent->num_bytes, trans->transid); in btrfs_finish_ordered_io()
3087 ret = add_pending_csums(trans, &ordered_extent->list); in btrfs_finish_ordered_io()
3099 !test_bit(BTRFS_ORDERED_TRUNCATED, &ordered_extent->flags)) in btrfs_finish_ordered_io()
3100 clear_extent_bit(&inode->io_tree, start, end, in btrfs_finish_ordered_io()
3106 if (ret) { /* -ENOMEM or corruption */ in btrfs_finish_ordered_io()
3112 clear_extent_bit(&inode->io_tree, start, end, clear_bits, in btrfs_finish_ordered_io()
3131 &ordered_extent->flags)) in btrfs_finish_ordered_io()
3132 mapping_set_error(ordered_extent->inode->i_mapping, -EIO); in btrfs_finish_ordered_io()
3153 !test_bit(BTRFS_ORDERED_NOCOW, &ordered_extent->flags) && in btrfs_finish_ordered_io()
3154 !test_bit(BTRFS_ORDERED_PREALLOC, &ordered_extent->flags)) { in btrfs_finish_ordered_io()
3161 ordered_extent->disk_bytenr, in btrfs_finish_ordered_io()
3162 ordered_extent->disk_num_bytes, in btrfs_finish_ordered_io()
3165 ordered_extent->disk_bytenr, in btrfs_finish_ordered_io()
3166 ordered_extent->disk_num_bytes, 1); in btrfs_finish_ordered_io()
3197 btrfs_mark_ordered_io_finished(inode, page, start, end + 1 - start, in btrfs_writepage_endio_finish_ordered()
3202 * check_data_csum - verify checksum of one sector of uncompressed data
3216 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); in check_data_csum()
3217 SHASH_DESC_ON_STACK(shash, fs_info->csum_shash); in check_data_csum()
3219 u32 len = fs_info->sectorsize; in check_data_csum()
3220 const u32 csum_size = fs_info->csum_size; in check_data_csum()
3227 offset_sectors = bio_offset >> fs_info->sectorsize_bits; in check_data_csum()
3228 csum_expected = ((u8 *)io_bio->csum) + offset_sectors * csum_size; in check_data_csum()
3231 shash->tfm = fs_info->csum_shash; in check_data_csum()
3242 io_bio->mirror_num); in check_data_csum()
3243 if (io_bio->device) in check_data_csum()
3244 btrfs_dev_stat_inc_and_print(io_bio->device, in check_data_csum()
3249 return -EIO; in check_data_csum()
3267 struct inode *inode = page->mapping->host; in btrfs_verify_data_csum()
3268 struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree; in btrfs_verify_data_csum()
3269 struct btrfs_root *root = BTRFS_I(inode)->root; in btrfs_verify_data_csum()
3270 const u32 sectorsize = root->fs_info->sectorsize; in btrfs_verify_data_csum()
3283 * flag, while in this context we can easily use io_bio->csum to in btrfs_verify_data_csum()
3286 * So for now, just exit if io_bio->csum is NULL, as it means it's in btrfs_verify_data_csum()
3290 if (io_bio->csum == NULL) in btrfs_verify_data_csum()
3293 if (BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM) in btrfs_verify_data_csum()
3296 if (!root->fs_info->csum_root) in btrfs_verify_data_csum()
3300 end <= page_offset(page) + PAGE_SIZE - 1); in btrfs_verify_data_csum()
3307 if (root->root_key.objectid == BTRFS_DATA_RELOC_TREE_OBJECTID && in btrfs_verify_data_csum()
3309 file_offset + sectorsize - 1, in btrfs_verify_data_csum()
3313 file_offset + sectorsize - 1, in btrfs_verify_data_csum()
3320 const int nr_bit = (pg_off - offset_in_page(start)) >> in btrfs_verify_data_csum()
3321 root->fs_info->sectorsize_bits; in btrfs_verify_data_csum()
3330 * btrfs_add_delayed_iput - perform a delayed iput on @inode
3341 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); in btrfs_add_delayed_iput()
3344 if (atomic_add_unless(&inode->i_count, -1, 1)) in btrfs_add_delayed_iput()
3347 atomic_inc(&fs_info->nr_delayed_iputs); in btrfs_add_delayed_iput()
3348 spin_lock(&fs_info->delayed_iput_lock); in btrfs_add_delayed_iput()
3349 ASSERT(list_empty(&binode->delayed_iput)); in btrfs_add_delayed_iput()
3350 list_add_tail(&binode->delayed_iput, &fs_info->delayed_iputs); in btrfs_add_delayed_iput()
3351 spin_unlock(&fs_info->delayed_iput_lock); in btrfs_add_delayed_iput()
3352 if (!test_bit(BTRFS_FS_CLEANER_RUNNING, &fs_info->flags)) in btrfs_add_delayed_iput()
3353 wake_up_process(fs_info->cleaner_kthread); in btrfs_add_delayed_iput()
3359 list_del_init(&inode->delayed_iput); in run_delayed_iput_locked()
3360 spin_unlock(&fs_info->delayed_iput_lock); in run_delayed_iput_locked()
3361 iput(&inode->vfs_inode); in run_delayed_iput_locked()
3362 if (atomic_dec_and_test(&fs_info->nr_delayed_iputs)) in run_delayed_iput_locked()
3363 wake_up(&fs_info->delayed_iputs_wait); in run_delayed_iput_locked()
3364 spin_lock(&fs_info->delayed_iput_lock); in run_delayed_iput_locked()
3370 if (!list_empty(&inode->delayed_iput)) { in btrfs_run_delayed_iput()
3371 spin_lock(&fs_info->delayed_iput_lock); in btrfs_run_delayed_iput()
3372 if (!list_empty(&inode->delayed_iput)) in btrfs_run_delayed_iput()
3374 spin_unlock(&fs_info->delayed_iput_lock); in btrfs_run_delayed_iput()
3381 spin_lock(&fs_info->delayed_iput_lock); in btrfs_run_delayed_iputs()
3382 while (!list_empty(&fs_info->delayed_iputs)) { in btrfs_run_delayed_iputs()
3385 inode = list_first_entry(&fs_info->delayed_iputs, in btrfs_run_delayed_iputs()
3388 cond_resched_lock(&fs_info->delayed_iput_lock); in btrfs_run_delayed_iputs()
3390 spin_unlock(&fs_info->delayed_iput_lock); in btrfs_run_delayed_iputs()
3407 int ret = wait_event_killable(fs_info->delayed_iputs_wait, in btrfs_wait_on_delayed_iputs()
3408 atomic_read(&fs_info->nr_delayed_iputs) == 0); in btrfs_wait_on_delayed_iputs()
3410 return -EINTR; in btrfs_wait_on_delayed_iputs()
3423 ret = btrfs_insert_orphan_item(trans, inode->root, btrfs_ino(inode)); in btrfs_orphan_add()
3424 if (ret && ret != -EEXIST) { in btrfs_orphan_add()
3439 return btrfs_del_orphan_item(trans, inode->root, btrfs_ino(inode)); in btrfs_orphan_del()
3448 struct btrfs_fs_info *fs_info = root->fs_info; in btrfs_orphan_cleanup()
3457 if (cmpxchg(&root->orphan_cleanup_state, 0, ORPHAN_CLEANUP_STARTED)) in btrfs_orphan_cleanup()
3462 ret = -ENOMEM; in btrfs_orphan_cleanup()
3465 path->reada = READA_BACK; in btrfs_orphan_cleanup()
3469 key.offset = (u64)-1; in btrfs_orphan_cleanup()
3483 if (path->slots[0] == 0) in btrfs_orphan_cleanup()
3485 path->slots[0]--; in btrfs_orphan_cleanup()
3489 leaf = path->nodes[0]; in btrfs_orphan_cleanup()
3490 btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]); in btrfs_orphan_cleanup()
3510 ret = -EINVAL; in btrfs_orphan_cleanup()
3519 inode = btrfs_iget(fs_info->sb, last_objectid, root); in btrfs_orphan_cleanup()
3521 if (ret && ret != -ENOENT) in btrfs_orphan_cleanup()
3524 if (ret == -ENOENT && root == fs_info->tree_root) { in btrfs_orphan_cleanup()
3539 * fs_info->fs_roots_radix. So here we can find if an in btrfs_orphan_cleanup()
3544 spin_lock(&fs_info->fs_roots_radix_lock); in btrfs_orphan_cleanup()
3545 dead_root = radix_tree_lookup(&fs_info->fs_roots_radix, in btrfs_orphan_cleanup()
3547 if (dead_root && btrfs_root_refs(&dead_root->root_item) == 0) in btrfs_orphan_cleanup()
3549 spin_unlock(&fs_info->fs_roots_radix_lock); in btrfs_orphan_cleanup()
3553 key.offset = found_key.objectid - 1; in btrfs_orphan_cleanup()
3576 * only if this filesystem was last used on a pre-v3.12 kernel in btrfs_orphan_cleanup()
3585 if (ret == -ENOENT || inode->i_nlink) { in btrfs_orphan_cleanup()
3615 root->orphan_cleanup_state = ORPHAN_CLEANUP_DONE; in btrfs_orphan_cleanup()
3617 if (test_bit(BTRFS_ROOT_ORPHAN_ITEM_INSERTED, &root->state)) { in btrfs_orphan_cleanup()
3657 *first_xattr_slot = -1; in acls_after_inode_item()
3667 if (*first_xattr_slot == -1) in acls_after_inode_item()
3697 if (*first_xattr_slot == -1) in acls_after_inode_item()
3703 * read an inode from the btree into the in-memory inode
3708 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); in btrfs_read_locked_inode()
3712 struct btrfs_root *root = BTRFS_I(inode)->root; in btrfs_read_locked_inode()
3728 return -ENOMEM; in btrfs_read_locked_inode()
3731 memcpy(&location, &BTRFS_I(inode)->location, sizeof(location)); in btrfs_read_locked_inode()
3740 leaf = path->nodes[0]; in btrfs_read_locked_inode()
3745 inode_item = btrfs_item_ptr(leaf, path->slots[0], in btrfs_read_locked_inode()
3747 inode->i_mode = btrfs_inode_mode(leaf, inode_item); in btrfs_read_locked_inode()
3753 round_up(i_size_read(inode), fs_info->sectorsize)); in btrfs_read_locked_inode()
3755 inode->i_atime.tv_sec = btrfs_timespec_sec(leaf, &inode_item->atime); in btrfs_read_locked_inode()
3756 inode->i_atime.tv_nsec = btrfs_timespec_nsec(leaf, &inode_item->atime); in btrfs_read_locked_inode()
3758 inode->i_mtime.tv_sec = btrfs_timespec_sec(leaf, &inode_item->mtime); in btrfs_read_locked_inode()
3759 inode->i_mtime.tv_nsec = btrfs_timespec_nsec(leaf, &inode_item->mtime); in btrfs_read_locked_inode()
3761 inode->i_ctime.tv_sec = btrfs_timespec_sec(leaf, &inode_item->ctime); in btrfs_read_locked_inode()
3762 inode->i_ctime.tv_nsec = btrfs_timespec_nsec(leaf, &inode_item->ctime); in btrfs_read_locked_inode()
3764 BTRFS_I(inode)->i_otime.tv_sec = in btrfs_read_locked_inode()
3765 btrfs_timespec_sec(leaf, &inode_item->otime); in btrfs_read_locked_inode()
3766 BTRFS_I(inode)->i_otime.tv_nsec = in btrfs_read_locked_inode()
3767 btrfs_timespec_nsec(leaf, &inode_item->otime); in btrfs_read_locked_inode()
3770 BTRFS_I(inode)->generation = btrfs_inode_generation(leaf, inode_item); in btrfs_read_locked_inode()
3771 BTRFS_I(inode)->last_trans = btrfs_inode_transid(leaf, inode_item); in btrfs_read_locked_inode()
3775 inode->i_generation = BTRFS_I(inode)->generation; in btrfs_read_locked_inode()
3776 inode->i_rdev = 0; in btrfs_read_locked_inode()
3779 BTRFS_I(inode)->index_cnt = (u64)-1; in btrfs_read_locked_inode()
3781 &BTRFS_I(inode)->flags, &BTRFS_I(inode)->ro_flags); in btrfs_read_locked_inode()
3786 * and then re-read we need to do a full sync since we don't have any in btrfs_read_locked_inode()
3790 * This is required for both inode re-read from disk and delayed inode in btrfs_read_locked_inode()
3793 if (BTRFS_I(inode)->last_trans == fs_info->generation) in btrfs_read_locked_inode()
3795 &BTRFS_I(inode)->runtime_flags); in btrfs_read_locked_inode()
3805 * touch mydir/foo in btrfs_read_locked_inode()
3806 * ln mydir/foo mydir/bar in btrfs_read_locked_inode()
3810 * xfs_io -c fsync mydir/foo in btrfs_read_locked_inode()
3814 * We must make sure that when we fsync our inode foo we also log its in btrfs_read_locked_inode()
3816 * dentry with the "bar" name but our inode foo has a link count of 1 in btrfs_read_locked_inode()
3824 BTRFS_I(inode)->last_unlink_trans = BTRFS_I(inode)->last_trans; in btrfs_read_locked_inode()
3832 BTRFS_I(inode)->last_reflink_trans = BTRFS_I(inode)->last_trans; in btrfs_read_locked_inode()
3834 path->slots[0]++; in btrfs_read_locked_inode()
3835 if (inode->i_nlink != 1 || in btrfs_read_locked_inode()
3836 path->slots[0] >= btrfs_header_nritems(leaf)) in btrfs_read_locked_inode()
3839 btrfs_item_key_to_cpu(leaf, &location, path->slots[0]); in btrfs_read_locked_inode()
3843 ptr = btrfs_item_ptr_offset(leaf, path->slots[0]); in btrfs_read_locked_inode()
3848 BTRFS_I(inode)->dir_index = btrfs_inode_ref_index(leaf, ref); in btrfs_read_locked_inode()
3853 BTRFS_I(inode)->dir_index = btrfs_inode_extref_index(leaf, in btrfs_read_locked_inode()
3861 maybe_acls = acls_after_inode_item(leaf, path->slots[0], in btrfs_read_locked_inode()
3863 if (first_xattr_slot != -1) { in btrfs_read_locked_inode()
3864 path->slots[0] = first_xattr_slot; in btrfs_read_locked_inode()
3870 root->root_key.objectid, ret); in btrfs_read_locked_inode()
3878 switch (inode->i_mode & S_IFMT) { in btrfs_read_locked_inode()
3880 inode->i_mapping->a_ops = &btrfs_aops; in btrfs_read_locked_inode()
3881 inode->i_fop = &btrfs_file_operations; in btrfs_read_locked_inode()
3882 inode->i_op = &btrfs_file_inode_operations; in btrfs_read_locked_inode()
3885 inode->i_fop = &btrfs_dir_file_operations; in btrfs_read_locked_inode()
3886 inode->i_op = &btrfs_dir_inode_operations; in btrfs_read_locked_inode()
3889 inode->i_op = &btrfs_symlink_inode_operations; in btrfs_read_locked_inode()
3891 inode->i_mapping->a_ops = &btrfs_aops; in btrfs_read_locked_inode()
3894 inode->i_op = &btrfs_special_inode_operations; in btrfs_read_locked_inode()
3895 init_special_inode(inode, inode->i_mode, rdev); in btrfs_read_locked_inode()
3918 btrfs_set_token_inode_size(&token, item, BTRFS_I(inode)->disk_i_size); in fill_inode_item()
3919 btrfs_set_token_inode_mode(&token, item, inode->i_mode); in fill_inode_item()
3920 btrfs_set_token_inode_nlink(&token, item, inode->i_nlink); in fill_inode_item()
3922 btrfs_set_token_timespec_sec(&token, &item->atime, in fill_inode_item()
3923 inode->i_atime.tv_sec); in fill_inode_item()
3924 btrfs_set_token_timespec_nsec(&token, &item->atime, in fill_inode_item()
3925 inode->i_atime.tv_nsec); in fill_inode_item()
3927 btrfs_set_token_timespec_sec(&token, &item->mtime, in fill_inode_item()
3928 inode->i_mtime.tv_sec); in fill_inode_item()
3929 btrfs_set_token_timespec_nsec(&token, &item->mtime, in fill_inode_item()
3930 inode->i_mtime.tv_nsec); in fill_inode_item()
3932 btrfs_set_token_timespec_sec(&token, &item->ctime, in fill_inode_item()
3933 inode->i_ctime.tv_sec); in fill_inode_item()
3934 btrfs_set_token_timespec_nsec(&token, &item->ctime, in fill_inode_item()
3935 inode->i_ctime.tv_nsec); in fill_inode_item()
3937 btrfs_set_token_timespec_sec(&token, &item->otime, in fill_inode_item()
3938 BTRFS_I(inode)->i_otime.tv_sec); in fill_inode_item()
3939 btrfs_set_token_timespec_nsec(&token, &item->otime, in fill_inode_item()
3940 BTRFS_I(inode)->i_otime.tv_nsec); in fill_inode_item()
3944 BTRFS_I(inode)->generation); in fill_inode_item()
3946 btrfs_set_token_inode_transid(&token, item, trans->transid); in fill_inode_item()
3947 btrfs_set_token_inode_rdev(&token, item, inode->i_rdev); in fill_inode_item()
3948 flags = btrfs_inode_combine_flags(BTRFS_I(inode)->flags, in fill_inode_item()
3949 BTRFS_I(inode)->ro_flags); in fill_inode_item()
3955 * copy everything in the in-memory inode into the btree.
3968 return -ENOMEM; in btrfs_update_inode_item()
3970 ret = btrfs_lookup_inode(trans, root, path, &inode->location, 1); in btrfs_update_inode_item()
3973 ret = -ENOENT; in btrfs_update_inode_item()
3977 leaf = path->nodes[0]; in btrfs_update_inode_item()
3978 inode_item = btrfs_item_ptr(leaf, path->slots[0], in btrfs_update_inode_item()
3981 fill_inode_item(trans, leaf, inode_item, &inode->vfs_inode); in btrfs_update_inode_item()
3991 * copy everything in the in-memory inode into the btree.
3997 struct btrfs_fs_info *fs_info = root->fs_info; in btrfs_update_inode()
4008 && root->root_key.objectid != BTRFS_DATA_RELOC_TREE_OBJECTID in btrfs_update_inode()
4009 && !test_bit(BTRFS_FS_LOG_RECOVERING, &fs_info->flags)) { in btrfs_update_inode()
4027 if (ret == -ENOSPC) in btrfs_update_inode_fallback()
4043 struct btrfs_fs_info *fs_info = root->fs_info; in __btrfs_unlink_inode()
4053 ret = -ENOMEM; in __btrfs_unlink_inode()
4058 name, name_len, -1); in __btrfs_unlink_inode()
4060 ret = di ? PTR_ERR(di) : -ENOENT; in __btrfs_unlink_inode()
4078 if (inode->dir_index) { in __btrfs_unlink_inode()
4081 index = inode->dir_index; in __btrfs_unlink_inode()
4104 if (ret != 0 && ret != -ENOENT) { in __btrfs_unlink_inode()
4111 if (ret == -ENOENT) in __btrfs_unlink_inode()
4118 * being run in btrfs-cleaner context. If we have enough of these built in __btrfs_unlink_inode()
4119 * up we can end up burning a lot of time in btrfs-cleaner without any in __btrfs_unlink_inode()
4131 btrfs_i_size_write(dir, dir->vfs_inode.i_size - name_len * 2); in __btrfs_unlink_inode()
4132 inode_inc_iversion(&inode->vfs_inode); in __btrfs_unlink_inode()
4133 inode_inc_iversion(&dir->vfs_inode); in __btrfs_unlink_inode()
4134 inode->vfs_inode.i_ctime = dir->vfs_inode.i_mtime = in __btrfs_unlink_inode()
4135 dir->vfs_inode.i_ctime = current_time(&inode->vfs_inode); in __btrfs_unlink_inode()
4149 drop_nlink(&inode->vfs_inode); in btrfs_unlink_inode()
4165 struct btrfs_root *root = BTRFS_I(dir)->root; in __unlink_start_trans()
4179 struct btrfs_root *root = BTRFS_I(dir)->root; in btrfs_unlink()
4192 BTRFS_I(d_inode(dentry)), dentry->d_name.name, in btrfs_unlink()
4193 dentry->d_name.len); in btrfs_unlink()
4197 if (inode->i_nlink == 0) { in btrfs_unlink()
4205 btrfs_btree_balance_dirty(root->fs_info); in btrfs_unlink()
4212 struct btrfs_root *root = BTRFS_I(dir)->root; in btrfs_unlink_subvol()
4218 const char *name = dentry->d_name.name; in btrfs_unlink_subvol()
4219 int name_len = dentry->d_name.len; in btrfs_unlink_subvol()
4226 objectid = inode->root->root_key.objectid; in btrfs_unlink_subvol()
4228 objectid = inode->location.objectid; in btrfs_unlink_subvol()
4231 return -EINVAL; in btrfs_unlink_subvol()
4236 return -ENOMEM; in btrfs_unlink_subvol()
4239 name, name_len, -1); in btrfs_unlink_subvol()
4241 ret = di ? PTR_ERR(di) : -ENOENT; in btrfs_unlink_subvol()
4245 leaf = path->nodes[0]; in btrfs_unlink_subvol()
4259 * depending on btrfs_del_root_ref to return -ENOENT here is incorrect. in btrfs_unlink_subvol()
4269 ret = -ENOENT; in btrfs_unlink_subvol()
4276 leaf = path->nodes[0]; in btrfs_unlink_subvol()
4277 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]); in btrfs_unlink_subvol()
4282 root->root_key.objectid, dir_ino, in btrfs_unlink_subvol()
4296 btrfs_i_size_write(BTRFS_I(dir), dir->i_size - name_len * 2); in btrfs_unlink_subvol()
4298 dir->i_mtime = dir->i_ctime = current_time(dir); in btrfs_unlink_subvol()
4313 struct btrfs_fs_info *fs_info = root->fs_info; in may_destroy_subvol()
4322 return -ENOMEM; in may_destroy_subvol()
4325 dir_id = btrfs_super_root_dir(fs_info->super_copy); in may_destroy_subvol()
4326 di = btrfs_lookup_dir_item(NULL, fs_info->tree_root, path, in may_destroy_subvol()
4329 btrfs_dir_item_key_to_cpu(path->nodes[0], di, &key); in may_destroy_subvol()
4330 if (key.objectid == root->root_key.objectid) { in may_destroy_subvol()
4331 ret = -EPERM; in may_destroy_subvol()
4340 key.objectid = root->root_key.objectid; in may_destroy_subvol()
4342 key.offset = (u64)-1; in may_destroy_subvol()
4344 ret = btrfs_search_slot(NULL, fs_info->tree_root, &key, path, 0, 0); in may_destroy_subvol()
4350 if (path->slots[0] > 0) { in may_destroy_subvol()
4351 path->slots[0]--; in may_destroy_subvol()
4352 btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]); in may_destroy_subvol()
4353 if (key.objectid == root->root_key.objectid && in may_destroy_subvol()
4355 ret = -ENOTEMPTY; in may_destroy_subvol()
4365 struct btrfs_fs_info *fs_info = root->fs_info; in btrfs_prune_dentries()
4372 if (!test_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state)) in btrfs_prune_dentries()
4373 WARN_ON(btrfs_root_refs(&root->root_item) != 0); in btrfs_prune_dentries()
4375 spin_lock(&root->inode_lock); in btrfs_prune_dentries()
4377 node = root->inode_tree.rb_node; in btrfs_prune_dentries()
4384 node = node->rb_left; in btrfs_prune_dentries()
4386 node = node->rb_right; in btrfs_prune_dentries()
4403 inode = igrab(&entry->vfs_inode); in btrfs_prune_dentries()
4405 spin_unlock(&root->inode_lock); in btrfs_prune_dentries()
4406 if (atomic_read(&inode->i_count) > 1) in btrfs_prune_dentries()
4414 spin_lock(&root->inode_lock); in btrfs_prune_dentries()
4418 if (cond_resched_lock(&root->inode_lock)) in btrfs_prune_dentries()
4423 spin_unlock(&root->inode_lock); in btrfs_prune_dentries()
4428 struct btrfs_fs_info *fs_info = btrfs_sb(dentry->d_sb); in btrfs_delete_subvolume()
4429 struct btrfs_root *root = BTRFS_I(dir)->root; in btrfs_delete_subvolume()
4431 struct btrfs_root *dest = BTRFS_I(inode)->root; in btrfs_delete_subvolume()
4442 spin_lock(&dest->root_item_lock); in btrfs_delete_subvolume()
4443 if (dest->send_in_progress) { in btrfs_delete_subvolume()
4444 spin_unlock(&dest->root_item_lock); in btrfs_delete_subvolume()
4447 dest->root_key.objectid); in btrfs_delete_subvolume()
4448 return -EPERM; in btrfs_delete_subvolume()
4450 root_flags = btrfs_root_flags(&dest->root_item); in btrfs_delete_subvolume()
4451 btrfs_set_root_flags(&dest->root_item, in btrfs_delete_subvolume()
4453 spin_unlock(&dest->root_item_lock); in btrfs_delete_subvolume()
4455 down_write(&fs_info->subvol_sem); in btrfs_delete_subvolume()
4476 trans->block_rsv = &block_rsv; in btrfs_delete_subvolume()
4477 trans->bytes_reserved = block_rsv.size; in btrfs_delete_subvolume()
4493 memset(&dest->root_item.drop_progress, 0, in btrfs_delete_subvolume()
4494 sizeof(dest->root_item.drop_progress)); in btrfs_delete_subvolume()
4495 btrfs_set_root_drop_level(&dest->root_item, 0); in btrfs_delete_subvolume()
4496 btrfs_set_root_refs(&dest->root_item, 0); in btrfs_delete_subvolume()
4498 if (!test_and_set_bit(BTRFS_ROOT_ORPHAN_ITEM_INSERTED, &dest->state)) { in btrfs_delete_subvolume()
4500 fs_info->tree_root, in btrfs_delete_subvolume()
4501 dest->root_key.objectid); in btrfs_delete_subvolume()
4508 ret = btrfs_uuid_tree_remove(trans, dest->root_item.uuid, in btrfs_delete_subvolume()
4510 dest->root_key.objectid); in btrfs_delete_subvolume()
4511 if (ret && ret != -ENOENT) { in btrfs_delete_subvolume()
4515 if (!btrfs_is_empty_uuid(dest->root_item.received_uuid)) { in btrfs_delete_subvolume()
4517 dest->root_item.received_uuid, in btrfs_delete_subvolume()
4519 dest->root_key.objectid); in btrfs_delete_subvolume()
4520 if (ret && ret != -ENOENT) { in btrfs_delete_subvolume()
4526 free_anon_bdev(dest->anon_dev); in btrfs_delete_subvolume()
4527 dest->anon_dev = 0; in btrfs_delete_subvolume()
4529 trans->block_rsv = NULL; in btrfs_delete_subvolume()
4530 trans->bytes_reserved = 0; in btrfs_delete_subvolume()
4532 inode->i_flags |= S_DEAD; in btrfs_delete_subvolume()
4536 up_write(&fs_info->subvol_sem); in btrfs_delete_subvolume()
4538 spin_lock(&dest->root_item_lock); in btrfs_delete_subvolume()
4539 root_flags = btrfs_root_flags(&dest->root_item); in btrfs_delete_subvolume()
4540 btrfs_set_root_flags(&dest->root_item, in btrfs_delete_subvolume()
4542 spin_unlock(&dest->root_item_lock); in btrfs_delete_subvolume()
4546 ASSERT(dest->send_in_progress == 0); in btrfs_delete_subvolume()
4556 struct btrfs_root *root = BTRFS_I(dir)->root; in btrfs_rmdir()
4560 if (inode->i_size > BTRFS_EMPTY_DIR_SIZE) in btrfs_rmdir()
4561 return -ENOTEMPTY; in btrfs_rmdir()
4578 last_unlink_trans = BTRFS_I(inode)->last_unlink_trans; in btrfs_rmdir()
4582 BTRFS_I(d_inode(dentry)), dentry->d_name.name, in btrfs_rmdir()
4583 dentry->d_name.len); in btrfs_rmdir()
4590 * 1) create dir foo in btrfs_rmdir()
4591 * 2) create snapshot under dir foo in btrfs_rmdir()
4593 * 4) rmdir foo in btrfs_rmdir()
4594 * 5) mkdir foo in btrfs_rmdir()
4595 * 6) fsync foo or some file inside foo in btrfs_rmdir()
4597 if (last_unlink_trans >= trans->transid) in btrfs_rmdir()
4598 BTRFS_I(dir)->last_unlink_trans = last_unlink_trans; in btrfs_rmdir()
4602 btrfs_btree_balance_dirty(root->fs_info); in btrfs_rmdir()
4645 struct btrfs_fs_info *fs_info = root->fs_info; in btrfs_truncate_inode_items()
4656 u32 found_type = (u8)-1; in btrfs_truncate_inode_items()
4661 int extent_type = -1; in btrfs_truncate_inode_items()
4667 const u64 lock_start = ALIGN_DOWN(new_size, fs_info->sectorsize); in btrfs_truncate_inode_items()
4673 * For non-free space inodes and non-shareable roots, we want to back in btrfs_truncate_inode_items()
4678 test_bit(BTRFS_ROOT_SHAREABLE, &root->state)) in btrfs_truncate_inode_items()
4683 return -ENOMEM; in btrfs_truncate_inode_items()
4684 path->reada = READA_BACK; in btrfs_truncate_inode_items()
4686 if (root->root_key.objectid != BTRFS_TREE_LOG_OBJECTID) { in btrfs_truncate_inode_items()
4687 lock_extent_bits(&inode->io_tree, lock_start, (u64)-1, in btrfs_truncate_inode_items()
4696 fs_info->sectorsize), in btrfs_truncate_inode_items()
4697 (u64)-1, 0); in btrfs_truncate_inode_items()
4702 * we relog the inode, so if root != BTRFS_I(inode)->root, it means in btrfs_truncate_inode_items()
4706 if (min_type == 0 && root == inode->root) in btrfs_truncate_inode_items()
4710 key.offset = (u64)-1; in btrfs_truncate_inode_items()
4711 key.type = (u8)-1; in btrfs_truncate_inode_items()
4715 * with a 16K leaf size and 128MB extents, you can actually queue in btrfs_truncate_inode_items()
4721 ret = -EAGAIN; in btrfs_truncate_inode_items()
4725 ret = btrfs_search_slot(trans, root, &key, path, -1, 1); in btrfs_truncate_inode_items()
4734 if (path->slots[0] == 0) in btrfs_truncate_inode_items()
4736 path->slots[0]--; in btrfs_truncate_inode_items()
4743 leaf = path->nodes[0]; in btrfs_truncate_inode_items()
4744 btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]); in btrfs_truncate_inode_items()
4755 fi = btrfs_item_ptr(leaf, path->slots[0], in btrfs_truncate_inode_items()
4769 inode, leaf, fi, path->slots[0], in btrfs_truncate_inode_items()
4772 item_end--; in btrfs_truncate_inode_items()
4800 extent_num_bytes = ALIGN(new_size - in btrfs_truncate_inode_items()
4802 fs_info->sectorsize); in btrfs_truncate_inode_items()
4803 clear_start = ALIGN(new_size, fs_info->sectorsize); in btrfs_truncate_inode_items()
4806 num_dec = (orig_num_bytes - in btrfs_truncate_inode_items()
4809 &root->state) && in btrfs_truncate_inode_items()
4811 inode_sub_bytes(&inode->vfs_inode, in btrfs_truncate_inode_items()
4818 extent_offset = found_key.offset - in btrfs_truncate_inode_items()
4826 &root->state)) in btrfs_truncate_inode_items()
4827 inode_sub_bytes(&inode->vfs_inode, in btrfs_truncate_inode_items()
4841 u32 size = (u32)(new_size - found_key.offset); in btrfs_truncate_inode_items()
4859 clear_len = fs_info->sectorsize; in btrfs_truncate_inode_items()
4862 if (test_bit(BTRFS_ROOT_SHAREABLE, &root->state)) in btrfs_truncate_inode_items()
4863 inode_sub_bytes(&inode->vfs_inode, in btrfs_truncate_inode_items()
4864 item_end + 1 - new_size); in btrfs_truncate_inode_items()
4872 if (root == inode->root) { in btrfs_truncate_inode_items()
4888 pending_del_slot = path->slots[0]; in btrfs_truncate_inode_items()
4891 path->slots[0] + 1 == pending_del_slot) { in btrfs_truncate_inode_items()
4894 pending_del_slot = path->slots[0]; in btrfs_truncate_inode_items()
4904 root->root_key.objectid != BTRFS_TREE_LOG_OBJECTID) { in btrfs_truncate_inode_items()
4911 ref.real_root = root->root_key.objectid; in btrfs_truncate_inode_items()
4928 if (path->slots[0] == 0 || in btrfs_truncate_inode_items()
4929 path->slots[0] != pending_del_slot || in btrfs_truncate_inode_items()
4957 ret = -EAGAIN; in btrfs_truncate_inode_items()
4963 path->slots[0]--; in btrfs_truncate_inode_items()
4977 if (root->root_key.objectid != BTRFS_TREE_LOG_OBJECTID) { in btrfs_truncate_inode_items()
4982 unlock_extent_cached(&inode->io_tree, lock_start, (u64)-1, in btrfs_truncate_inode_items()
4991 * btrfs_truncate_block - read, zero a chunk and write a block
4992 * @inode - inode that we're zeroing
4993 * @from - the offset to start zeroing
4994 * @len - the length to zero, 0 to zero the entire range respective to the
4996 * @front - zero up to the offset instead of from the offset on
5004 struct btrfs_fs_info *fs_info = inode->root->fs_info; in btrfs_truncate_block()
5005 struct address_space *mapping = inode->vfs_inode.i_mapping; in btrfs_truncate_block()
5006 struct extent_io_tree *io_tree = &inode->io_tree; in btrfs_truncate_block()
5011 u32 blocksize = fs_info->sectorsize; in btrfs_truncate_block()
5013 unsigned offset = from & (blocksize - 1); in btrfs_truncate_block()
5026 block_end = block_start + blocksize - 1; in btrfs_truncate_block()
5051 ret = -ENOMEM; in btrfs_truncate_block()
5061 if (page->mapping != mapping) { in btrfs_truncate_block()
5067 ret = -EIO; in btrfs_truncate_block()
5086 clear_extent_bit(&inode->io_tree, block_start, block_end, in btrfs_truncate_block()
5100 len = blocksize - offset; in btrfs_truncate_block()
5102 memzero_page(page, (block_start - page_offset(page)), in btrfs_truncate_block()
5105 memzero_page(page, (block_start - page_offset(page)) + offset, in btrfs_truncate_block()
5110 btrfs_page_set_dirty(fs_info, page, block_start, block_end + 1 - block_start); in btrfs_truncate_block()
5114 set_extent_bit(&inode->io_tree, block_start, block_end, in btrfs_truncate_block()
5138 struct btrfs_fs_info *fs_info = root->fs_info; in maybe_insert_hole()
5153 * 1 - for the one we're dropping in maybe_insert_hole()
5154 * 1 - for the one we're adding in maybe_insert_hole()
5155 * 1 - for updating the inode. in maybe_insert_hole()
5192 struct btrfs_root *root = inode->root; in btrfs_cont_expand()
5193 struct btrfs_fs_info *fs_info = root->fs_info; in btrfs_cont_expand()
5194 struct extent_io_tree *io_tree = &inode->io_tree; in btrfs_cont_expand()
5197 struct extent_map_tree *em_tree = &inode->extent_tree; in btrfs_cont_expand()
5198 u64 hole_start = ALIGN(oldsize, fs_info->sectorsize); in btrfs_cont_expand()
5199 u64 block_end = ALIGN(size, fs_info->sectorsize); in btrfs_cont_expand()
5217 btrfs_lock_and_flush_ordered_range(inode, hole_start, block_end - 1, in btrfs_cont_expand()
5222 block_end - cur_offset); in btrfs_cont_expand()
5229 last_byte = ALIGN(last_byte, fs_info->sectorsize); in btrfs_cont_expand()
5230 hole_size = last_byte - cur_offset; in btrfs_cont_expand()
5232 if (!test_bit(EXTENT_FLAG_PREALLOC, &em->flags)) { in btrfs_cont_expand()
5246 cur_offset + hole_size - 1, 0); in btrfs_cont_expand()
5250 &inode->runtime_flags); in btrfs_cont_expand()
5253 hole_em->start = cur_offset; in btrfs_cont_expand()
5254 hole_em->len = hole_size; in btrfs_cont_expand()
5255 hole_em->orig_start = cur_offset; in btrfs_cont_expand()
5257 hole_em->block_start = EXTENT_MAP_HOLE; in btrfs_cont_expand()
5258 hole_em->block_len = 0; in btrfs_cont_expand()
5259 hole_em->orig_block_len = 0; in btrfs_cont_expand()
5260 hole_em->ram_bytes = hole_size; in btrfs_cont_expand()
5261 hole_em->compress_type = BTRFS_COMPRESS_NONE; in btrfs_cont_expand()
5262 hole_em->generation = fs_info->generation; in btrfs_cont_expand()
5265 write_lock(&em_tree->lock); in btrfs_cont_expand()
5267 write_unlock(&em_tree->lock); in btrfs_cont_expand()
5268 if (err != -EEXIST) in btrfs_cont_expand()
5272 hole_size - 1, 0); in btrfs_cont_expand()
5289 unlock_extent_cached(io_tree, hole_start, block_end - 1, &cached_state); in btrfs_cont_expand()
5295 struct btrfs_root *root = BTRFS_I(inode)->root; in btrfs_setsize()
5298 loff_t newsize = attr->ia_size; in btrfs_setsize()
5299 int mask = attr->ia_valid; in btrfs_setsize()
5311 inode->i_ctime = inode->i_mtime = in btrfs_setsize()
5319 * state of this file - if the snapshot captures this expanding in btrfs_setsize()
5323 btrfs_drew_write_lock(&root->snapshot_lock); in btrfs_setsize()
5326 btrfs_drew_write_unlock(&root->snapshot_lock); in btrfs_setsize()
5332 btrfs_drew_write_unlock(&root->snapshot_lock); in btrfs_setsize()
5340 btrfs_drew_write_unlock(&root->snapshot_lock); in btrfs_setsize()
5343 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); in btrfs_setsize()
5347 ALIGN(newsize, fs_info->sectorsize), in btrfs_setsize()
5348 (u64)-1); in btrfs_setsize()
5360 &BTRFS_I(inode)->runtime_flags); in btrfs_setsize()
5367 if (ret && inode->i_nlink) { in btrfs_setsize()
5371 * Truncate failed, so fix up the in-memory size. We in btrfs_setsize()
5374 * in-memory size to match. in btrfs_setsize()
5376 err = btrfs_wait_ordered_range(inode, 0, (u64)-1); in btrfs_setsize()
5379 i_size_write(inode, BTRFS_I(inode)->disk_i_size); in btrfs_setsize()
5390 struct btrfs_root *root = BTRFS_I(inode)->root; in btrfs_setattr()
5394 return -EROFS; in btrfs_setattr()
5400 if (S_ISREG(inode->i_mode) && (attr->ia_valid & ATTR_SIZE)) { in btrfs_setattr()
5406 if (attr->ia_valid) { in btrfs_setattr()
5411 if (!err && attr->ia_valid & ATTR_MODE) in btrfs_setattr()
5412 err = posix_acl_chmod(mnt_userns, inode, inode->i_mode); in btrfs_setattr()
5432 struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree; in evict_inode_truncate_pages()
5433 struct extent_map_tree *map_tree = &BTRFS_I(inode)->extent_tree; in evict_inode_truncate_pages()
5436 ASSERT(inode->i_state & I_FREEING); in evict_inode_truncate_pages()
5437 truncate_inode_pages_final(&inode->i_data); in evict_inode_truncate_pages()
5439 write_lock(&map_tree->lock); in evict_inode_truncate_pages()
5440 while (!RB_EMPTY_ROOT(&map_tree->map.rb_root)) { in evict_inode_truncate_pages()
5443 node = rb_first_cached(&map_tree->map); in evict_inode_truncate_pages()
5445 clear_bit(EXTENT_FLAG_PINNED, &em->flags); in evict_inode_truncate_pages()
5446 clear_bit(EXTENT_FLAG_LOGGING, &em->flags); in evict_inode_truncate_pages()
5450 write_unlock(&map_tree->lock); in evict_inode_truncate_pages()
5452 write_lock(&map_tree->lock); in evict_inode_truncate_pages()
5455 write_unlock(&map_tree->lock); in evict_inode_truncate_pages()
5465 * queue kthread), inode references (inode->i_count) were not taken in evict_inode_truncate_pages()
5469 * reference count - if we don't do it, when they access the inode's in evict_inode_truncate_pages()
5471 * use-after-free issue. in evict_inode_truncate_pages()
5473 spin_lock(&io_tree->lock); in evict_inode_truncate_pages()
5474 while (!RB_EMPTY_ROOT(&io_tree->state)) { in evict_inode_truncate_pages()
5481 node = rb_first(&io_tree->state); in evict_inode_truncate_pages()
5483 start = state->start; in evict_inode_truncate_pages()
5484 end = state->end; in evict_inode_truncate_pages()
5485 state_flags = state->state; in evict_inode_truncate_pages()
5486 spin_unlock(&io_tree->lock); in evict_inode_truncate_pages()
5500 end - start + 1); in evict_inode_truncate_pages()
5508 spin_lock(&io_tree->lock); in evict_inode_truncate_pages()
5510 spin_unlock(&io_tree->lock); in evict_inode_truncate_pages()
5516 struct btrfs_fs_info *fs_info = root->fs_info; in evict_refill_and_join()
5517 struct btrfs_block_rsv *global_rsv = &fs_info->global_block_rsv; in evict_refill_and_join()
5535 ret = btrfs_block_rsv_refill(root, rsv, rsv->size + delayed_refs_extra, in evict_refill_and_join()
5543 btrfs_block_rsv_migrate(global_rsv, rsv, rsv->size, 0)) { in evict_refill_and_join()
5546 return ERR_PTR(-ENOSPC); in evict_refill_and_join()
5556 trans->block_rsv = &fs_info->trans_block_rsv; in evict_refill_and_join()
5557 trans->bytes_reserved = delayed_refs_extra; in evict_refill_and_join()
5558 btrfs_block_rsv_migrate(rsv, trans->block_rsv, in evict_refill_and_join()
5566 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); in btrfs_evict_inode()
5568 struct btrfs_root *root = BTRFS_I(inode)->root; in btrfs_evict_inode()
5582 if (inode->i_nlink && in btrfs_evict_inode()
5583 ((btrfs_root_refs(&root->root_item) != 0 && in btrfs_evict_inode()
5584 root->root_key.objectid != BTRFS_ROOT_TREE_OBJECTID) || in btrfs_evict_inode()
5591 btrfs_free_io_failure_record(BTRFS_I(inode), 0, (u64)-1); in btrfs_evict_inode()
5593 if (test_bit(BTRFS_FS_LOG_RECOVERING, &fs_info->flags)) in btrfs_evict_inode()
5596 if (inode->i_nlink > 0) { in btrfs_evict_inode()
5597 BUG_ON(btrfs_root_refs(&root->root_item) != 0 && in btrfs_evict_inode()
5598 root->root_key.objectid != BTRFS_ROOT_TREE_OBJECTID); in btrfs_evict_inode()
5609 rsv->size = btrfs_calc_metadata_size(fs_info, 1); in btrfs_evict_inode()
5610 rsv->failfast = 1; in btrfs_evict_inode()
5619 trans->block_rsv = rsv; in btrfs_evict_inode()
5623 trans->block_rsv = &fs_info->trans_block_rsv; in btrfs_evict_inode()
5626 if (ret && ret != -ENOSPC && ret != -EAGAIN) in btrfs_evict_inode()
5643 trans->block_rsv = rsv; in btrfs_evict_inode()
5645 trans->block_rsv = &fs_info->trans_block_rsv; in btrfs_evict_inode()
5666 * If no dir entries were found, returns -ENOENT.
5667 * If found a corrupted location in dir entry, returns -EUCLEAN.
5672 const char *name = dentry->d_name.name; in btrfs_inode_by_name()
5673 int namelen = dentry->d_name.len; in btrfs_inode_by_name()
5676 struct btrfs_root *root = BTRFS_I(dir)->root; in btrfs_inode_by_name()
5681 return -ENOMEM; in btrfs_inode_by_name()
5686 ret = di ? PTR_ERR(di) : -ENOENT; in btrfs_inode_by_name()
5690 btrfs_dir_item_key_to_cpu(path->nodes[0], di, location); in btrfs_inode_by_name()
5691 if (location->type != BTRFS_INODE_ITEM_KEY && in btrfs_inode_by_name()
5692 location->type != BTRFS_ROOT_ITEM_KEY) { in btrfs_inode_by_name()
5693 ret = -EUCLEAN; in btrfs_inode_by_name()
5694 btrfs_warn(root->fs_info, in btrfs_inode_by_name()
5697 location->objectid, location->type, location->offset); in btrfs_inode_by_name()
5700 *type = btrfs_dir_type(path->nodes[0], di); in btrfs_inode_by_name()
5727 err = -ENOMEM; in fixup_tree_root_location()
5731 err = -ENOENT; in fixup_tree_root_location()
5732 key.objectid = BTRFS_I(dir)->root->root_key.objectid; in fixup_tree_root_location()
5734 key.offset = location->objectid; in fixup_tree_root_location()
5736 ret = btrfs_search_slot(NULL, fs_info->tree_root, &key, path, 0, 0); in fixup_tree_root_location()
5743 leaf = path->nodes[0]; in fixup_tree_root_location()
5744 ref = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_root_ref); in fixup_tree_root_location()
5746 btrfs_root_ref_name_len(leaf, ref) != dentry->d_name.len) in fixup_tree_root_location()
5749 ret = memcmp_extent_buffer(leaf, dentry->d_name.name, in fixup_tree_root_location()
5751 dentry->d_name.len); in fixup_tree_root_location()
5757 new_root = btrfs_get_fs_root(fs_info, location->objectid, true); in fixup_tree_root_location()
5764 location->objectid = btrfs_root_dirid(&new_root->root_item); in fixup_tree_root_location()
5765 location->type = BTRFS_INODE_ITEM_KEY; in fixup_tree_root_location()
5766 location->offset = 0; in fixup_tree_root_location()
5775 struct btrfs_root *root = BTRFS_I(inode)->root; in inode_tree_add()
5779 struct rb_node *new = &BTRFS_I(inode)->rb_node; in inode_tree_add()
5785 spin_lock(&root->inode_lock); in inode_tree_add()
5786 p = &root->inode_tree.rb_node; in inode_tree_add()
5792 p = &parent->rb_left; in inode_tree_add()
5794 p = &parent->rb_right; in inode_tree_add()
5796 WARN_ON(!(entry->vfs_inode.i_state & in inode_tree_add()
5798 rb_replace_node(parent, new, &root->inode_tree); in inode_tree_add()
5800 spin_unlock(&root->inode_lock); in inode_tree_add()
5805 rb_insert_color(new, &root->inode_tree); in inode_tree_add()
5806 spin_unlock(&root->inode_lock); in inode_tree_add()
5811 struct btrfs_root *root = inode->root; in inode_tree_del()
5814 spin_lock(&root->inode_lock); in inode_tree_del()
5815 if (!RB_EMPTY_NODE(&inode->rb_node)) { in inode_tree_del()
5816 rb_erase(&inode->rb_node, &root->inode_tree); in inode_tree_del()
5817 RB_CLEAR_NODE(&inode->rb_node); in inode_tree_del()
5818 empty = RB_EMPTY_ROOT(&root->inode_tree); in inode_tree_del()
5820 spin_unlock(&root->inode_lock); in inode_tree_del()
5822 if (empty && btrfs_root_refs(&root->root_item) == 0) { in inode_tree_del()
5823 spin_lock(&root->inode_lock); in inode_tree_del()
5824 empty = RB_EMPTY_ROOT(&root->inode_tree); in inode_tree_del()
5825 spin_unlock(&root->inode_lock); in inode_tree_del()
5836 inode->i_ino = args->ino; in btrfs_init_locked_inode()
5837 BTRFS_I(inode)->location.objectid = args->ino; in btrfs_init_locked_inode()
5838 BTRFS_I(inode)->location.type = BTRFS_INODE_ITEM_KEY; in btrfs_init_locked_inode()
5839 BTRFS_I(inode)->location.offset = 0; in btrfs_init_locked_inode()
5840 BTRFS_I(inode)->root = btrfs_grab_root(args->root); in btrfs_init_locked_inode()
5841 BUG_ON(args->root && !BTRFS_I(inode)->root); in btrfs_init_locked_inode()
5849 return args->ino == BTRFS_I(inode)->location.objectid && in btrfs_find_actor()
5850 args->root == BTRFS_I(inode)->root; in btrfs_find_actor()
5882 return ERR_PTR(-ENOMEM); in btrfs_iget_path()
5884 if (inode->i_state & I_NEW) { in btrfs_iget_path()
5899 ret = -ENOENT; in btrfs_iget_path()
5919 return ERR_PTR(-ENOMEM); in new_simple_dir()
5921 BTRFS_I(inode)->root = btrfs_grab_root(root); in new_simple_dir()
5922 memcpy(&BTRFS_I(inode)->location, key, sizeof(*key)); in new_simple_dir()
5923 set_bit(BTRFS_INODE_DUMMY, &BTRFS_I(inode)->runtime_flags); in new_simple_dir()
5925 inode->i_ino = BTRFS_EMPTY_SUBVOL_DIR_OBJECTID; in new_simple_dir()
5927 * We only need lookup, the rest is read-only and there's no inode in new_simple_dir()
5930 inode->i_op = &simple_dir_inode_operations; in new_simple_dir()
5931 inode->i_opflags &= ~IOP_XATTR; in new_simple_dir()
5932 inode->i_fop = &simple_dir_operations; in new_simple_dir()
5933 inode->i_mode = S_IFDIR | S_IRUGO | S_IWUSR | S_IXUGO; in new_simple_dir()
5934 inode->i_mtime = current_time(inode); in new_simple_dir()
5935 inode->i_atime = inode->i_mtime; in new_simple_dir()
5936 inode->i_ctime = inode->i_mtime; in new_simple_dir()
5937 BTRFS_I(inode)->i_otime = inode->i_mtime; in new_simple_dir()
5945 * Compile-time asserts that generic FT_* types still match in btrfs_inode_type()
5957 return fs_umode_to_ftype(inode->i_mode); in btrfs_inode_type()
5962 struct btrfs_fs_info *fs_info = btrfs_sb(dir->i_sb); in btrfs_lookup_dentry()
5964 struct btrfs_root *root = BTRFS_I(dir)->root; in btrfs_lookup_dentry()
5970 if (dentry->d_name.len > BTRFS_NAME_LEN) in btrfs_lookup_dentry()
5971 return ERR_PTR(-ENAMETOOLONG); in btrfs_lookup_dentry()
5978 inode = btrfs_iget(dir->i_sb, location.objectid, root); in btrfs_lookup_dentry()
5986 inode->i_mode, btrfs_inode_type(inode), in btrfs_lookup_dentry()
5989 return ERR_PTR(-EUCLEAN); in btrfs_lookup_dentry()
5997 if (ret != -ENOENT) in btrfs_lookup_dentry()
6000 inode = new_simple_dir(dir->i_sb, &location, sub_root); in btrfs_lookup_dentry()
6002 inode = btrfs_iget(dir->i_sb, location.objectid, sub_root); in btrfs_lookup_dentry()
6008 down_read(&fs_info->cleanup_work_sem); in btrfs_lookup_dentry()
6009 if (!sb_rdonly(inode->i_sb)) in btrfs_lookup_dentry()
6011 up_read(&fs_info->cleanup_work_sem); in btrfs_lookup_dentry()
6027 inode = d_inode(dentry->d_parent); in btrfs_dentry_delete()
6030 root = BTRFS_I(inode)->root; in btrfs_dentry_delete()
6031 if (btrfs_root_refs(&root->root_item) == 0) in btrfs_dentry_delete()
6045 if (inode == ERR_PTR(-ENOENT)) in btrfs_lookup()
6065 return -ENOMEM; in btrfs_opendir()
6066 private->filldir_buf = kzalloc(PAGE_SIZE, GFP_KERNEL); in btrfs_opendir()
6067 if (!private->filldir_buf) { in btrfs_opendir()
6069 return -ENOMEM; in btrfs_opendir()
6071 file->private_data = private; in btrfs_opendir()
6084 while (entries--) { in btrfs_filldir()
6088 ctx->pos = get_unaligned(&entry->offset); in btrfs_filldir()
6089 if (!dir_emit(ctx, name, get_unaligned(&entry->name_len), in btrfs_filldir()
6090 get_unaligned(&entry->ino), in btrfs_filldir()
6091 get_unaligned(&entry->type))) in btrfs_filldir()
6094 get_unaligned(&entry->name_len); in btrfs_filldir()
6095 ctx->pos++; in btrfs_filldir()
6103 struct btrfs_root *root = BTRFS_I(inode)->root; in btrfs_real_readdir()
6104 struct btrfs_file_private *private = file->private_data; in btrfs_real_readdir()
6127 return -ENOMEM; in btrfs_real_readdir()
6129 addr = private->filldir_buf; in btrfs_real_readdir()
6130 path->reada = READA_FORWARD; in btrfs_real_readdir()
6138 key.offset = ctx->pos; in btrfs_real_readdir()
6148 leaf = path->nodes[0]; in btrfs_real_readdir()
6149 slot = path->slots[0]; in btrfs_real_readdir()
6165 if (found_key.offset < ctx->pos) in btrfs_real_readdir()
6174 ret = btrfs_filldir(private->filldir_buf, entries, ctx); in btrfs_real_readdir()
6177 addr = private->filldir_buf; in btrfs_real_readdir()
6184 put_unaligned(name_len, &entry->name_len); in btrfs_real_readdir()
6189 &entry->type); in btrfs_real_readdir()
6191 put_unaligned(location.objectid, &entry->ino); in btrfs_real_readdir()
6192 put_unaligned(found_key.offset, &entry->offset); in btrfs_real_readdir()
6197 path->slots[0]++; in btrfs_real_readdir()
6201 ret = btrfs_filldir(private->filldir_buf, entries, ctx); in btrfs_real_readdir()
6217 * they're returned by readdir. Until we re-use freed offsets in btrfs_real_readdir()
6226 if (ctx->pos >= INT_MAX) in btrfs_real_readdir()
6227 ctx->pos = LLONG_MAX; in btrfs_real_readdir()
6229 ctx->pos = INT_MAX; in btrfs_real_readdir()
6247 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); in btrfs_dirty_inode()
6248 struct btrfs_root *root = BTRFS_I(inode)->root; in btrfs_dirty_inode()
6252 if (test_bit(BTRFS_INODE_DUMMY, &BTRFS_I(inode)->runtime_flags)) in btrfs_dirty_inode()
6260 if (ret && (ret == -ENOSPC || ret == -EDQUOT)) { in btrfs_dirty_inode()
6270 if (BTRFS_I(inode)->delayed_node) in btrfs_dirty_inode()
6283 struct btrfs_root *root = BTRFS_I(inode)->root; in btrfs_update_time()
6287 return -EROFS; in btrfs_update_time()
6292 inode->i_ctime = *now; in btrfs_update_time()
6294 inode->i_mtime = *now; in btrfs_update_time()
6296 inode->i_atime = *now; in btrfs_update_time()
6302 * and then set the in-memory index_cnt variable to reflect
6307 struct btrfs_root *root = inode->root; in btrfs_set_inode_index_count()
6315 key.offset = (u64)-1; in btrfs_set_inode_index_count()
6319 return -ENOMEM; in btrfs_set_inode_index_count()
6335 if (path->slots[0] == 0) { in btrfs_set_inode_index_count()
6336 inode->index_cnt = 2; in btrfs_set_inode_index_count()
6340 path->slots[0]--; in btrfs_set_inode_index_count()
6342 leaf = path->nodes[0]; in btrfs_set_inode_index_count()
6343 btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]); in btrfs_set_inode_index_count()
6347 inode->index_cnt = 2; in btrfs_set_inode_index_count()
6351 inode->index_cnt = found_key.offset + 1; in btrfs_set_inode_index_count()
6365 if (dir->index_cnt == (u64)-1) { in btrfs_set_inode_index()
6374 *index = dir->index_cnt; in btrfs_set_inode_index()
6375 dir->index_cnt++; in btrfs_set_inode_index()
6384 args.ino = BTRFS_I(inode)->location.objectid; in btrfs_insert_inode_locked()
6385 args.root = BTRFS_I(inode)->root; in btrfs_insert_inode_locked()
6388 btrfs_inode_hash(inode->i_ino, BTRFS_I(inode)->root), in btrfs_insert_inode_locked()
6404 flags = BTRFS_I(dir)->flags; in btrfs_inherit_iflags()
6407 BTRFS_I(inode)->flags &= ~BTRFS_INODE_COMPRESS; in btrfs_inherit_iflags()
6408 BTRFS_I(inode)->flags |= BTRFS_INODE_NOCOMPRESS; in btrfs_inherit_iflags()
6410 BTRFS_I(inode)->flags &= ~BTRFS_INODE_NOCOMPRESS; in btrfs_inherit_iflags()
6411 BTRFS_I(inode)->flags |= BTRFS_INODE_COMPRESS; in btrfs_inherit_iflags()
6415 BTRFS_I(inode)->flags |= BTRFS_INODE_NODATACOW; in btrfs_inherit_iflags()
6416 if (S_ISREG(inode->i_mode)) in btrfs_inherit_iflags()
6417 BTRFS_I(inode)->flags |= BTRFS_INODE_NODATASUM; in btrfs_inherit_iflags()
6431 struct btrfs_fs_info *fs_info = root->fs_info; in btrfs_new_inode()
6446 return ERR_PTR(-ENOMEM); in btrfs_new_inode()
6449 inode = new_inode(fs_info->sb); in btrfs_new_inode()
6453 return ERR_PTR(-ENOMEM); in btrfs_new_inode()
6467 inode->i_ino = objectid; in btrfs_new_inode()
6486 BTRFS_I(inode)->index_cnt = 2; in btrfs_new_inode()
6487 BTRFS_I(inode)->dir_index = *index; in btrfs_new_inode()
6488 BTRFS_I(inode)->root = btrfs_grab_root(root); in btrfs_new_inode()
6489 BTRFS_I(inode)->generation = trans->transid; in btrfs_new_inode()
6490 inode->i_generation = BTRFS_I(inode)->generation; in btrfs_new_inode()
6498 set_bit(BTRFS_INODE_NEEDS_FULL_SYNC, &BTRFS_I(inode)->runtime_flags); in btrfs_new_inode()
6520 location = &BTRFS_I(inode)->location; in btrfs_new_inode()
6521 location->objectid = objectid; in btrfs_new_inode()
6522 location->offset = 0; in btrfs_new_inode()
6523 location->type = BTRFS_INODE_ITEM_KEY; in btrfs_new_inode()
6538 inode->i_mtime = current_time(inode); in btrfs_new_inode()
6539 inode->i_atime = inode->i_mtime; in btrfs_new_inode()
6540 inode->i_ctime = inode->i_mtime; in btrfs_new_inode()
6541 BTRFS_I(inode)->i_otime = inode->i_mtime; in btrfs_new_inode()
6543 inode_item = btrfs_item_ptr(path->nodes[0], path->slots[0], in btrfs_new_inode()
6545 memzero_extent_buffer(path->nodes[0], (unsigned long)inode_item, in btrfs_new_inode()
6547 fill_inode_item(trans, path->nodes[0], inode_item, inode); in btrfs_new_inode()
6550 ref = btrfs_item_ptr(path->nodes[0], path->slots[0] + 1, in btrfs_new_inode()
6552 btrfs_set_inode_ref_name_len(path->nodes[0], ref, name_len); in btrfs_new_inode()
6553 btrfs_set_inode_ref_index(path->nodes[0], ref, *index); in btrfs_new_inode()
6555 write_extent_buffer(path->nodes[0], name, ptr, name_len); in btrfs_new_inode()
6558 btrfs_mark_buffer_dirty(path->nodes[0]); in btrfs_new_inode()
6565 BTRFS_I(inode)->flags |= BTRFS_INODE_NODATASUM; in btrfs_new_inode()
6567 BTRFS_I(inode)->flags |= BTRFS_INODE_NODATACOW | in btrfs_new_inode()
6582 btrfs_ino(BTRFS_I(inode)), root->root_key.objectid, ret); in btrfs_new_inode()
6590 BTRFS_I(dir)->index_cnt--; in btrfs_new_inode()
6607 struct btrfs_root *root = parent_inode->root; in btrfs_add_link()
6612 memcpy(&key, &inode->root->root_key, sizeof(key)); in btrfs_add_link()
6621 root->root_key.objectid, parent_ino, in btrfs_add_link()
6633 btrfs_inode_type(&inode->vfs_inode), index); in btrfs_add_link()
6634 if (ret == -EEXIST || ret == -EOVERFLOW) in btrfs_add_link()
6641 btrfs_i_size_write(parent_inode, parent_inode->vfs_inode.i_size + in btrfs_add_link()
6643 inode_inc_iversion(&parent_inode->vfs_inode); in btrfs_add_link()
6650 if (!test_bit(BTRFS_FS_LOG_RECOVERING, &root->fs_info->flags)) { in btrfs_add_link()
6651 struct timespec64 now = current_time(&parent_inode->vfs_inode); in btrfs_add_link()
6653 parent_inode->vfs_inode.i_mtime = now; in btrfs_add_link()
6654 parent_inode->vfs_inode.i_ctime = now; in btrfs_add_link()
6666 root->root_key.objectid, parent_ino, in btrfs_add_link()
6689 dentry->d_name.name, dentry->d_name.len, in btrfs_add_nondir()
6692 err = -EEXIST; in btrfs_add_nondir()
6699 struct btrfs_fs_info *fs_info = btrfs_sb(dir->i_sb); in btrfs_mknod()
6701 struct btrfs_root *root = BTRFS_I(dir)->root; in btrfs_mknod()
6721 dentry->d_name.name, dentry->d_name.len, in btrfs_mknod()
6735 inode->i_op = &btrfs_special_inode_operations; in btrfs_mknod()
6736 init_special_inode(inode, inode->i_mode, rdev); in btrfs_mknod()
6738 err = btrfs_init_inode_security(trans, inode, dir, &dentry->d_name); in btrfs_mknod()
6763 struct btrfs_fs_info *fs_info = btrfs_sb(dir->i_sb); in btrfs_create()
6765 struct btrfs_root *root = BTRFS_I(dir)->root; in btrfs_create()
6785 dentry->d_name.name, dentry->d_name.len, in btrfs_create()
6798 inode->i_fop = &btrfs_file_operations; in btrfs_create()
6799 inode->i_op = &btrfs_file_inode_operations; in btrfs_create()
6800 inode->i_mapping->a_ops = &btrfs_aops; in btrfs_create()
6802 err = btrfs_init_inode_security(trans, inode, dir, &dentry->d_name); in btrfs_create()
6831 struct btrfs_root *root = BTRFS_I(dir)->root; in btrfs_link()
6833 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); in btrfs_link()
6839 if (root->root_key.objectid != BTRFS_I(inode)->root->root_key.objectid) in btrfs_link()
6840 return -EXDEV; in btrfs_link()
6842 if (inode->i_nlink >= BTRFS_LINK_MAX) in btrfs_link()
6843 return -EMLINK; in btrfs_link()
6855 trans = btrfs_start_transaction(root, inode->i_nlink ? 5 : 6); in btrfs_link()
6863 BTRFS_I(inode)->dir_index = 0ULL; in btrfs_link()
6866 inode->i_ctime = current_time(inode); in btrfs_link()
6868 set_bit(BTRFS_INODE_COPY_EVERYTHING, &BTRFS_I(inode)->runtime_flags); in btrfs_link()
6876 struct dentry *parent = dentry->d_parent; in btrfs_link()
6881 if (inode->i_nlink == 1) { in btrfs_link()
6908 struct btrfs_fs_info *fs_info = btrfs_sb(dir->i_sb); in btrfs_mkdir()
6911 struct btrfs_root *root = BTRFS_I(dir)->root; in btrfs_mkdir()
6930 dentry->d_name.name, dentry->d_name.len, in btrfs_mkdir()
6940 inode->i_op = &btrfs_dir_inode_operations; in btrfs_mkdir()
6941 inode->i_fop = &btrfs_dir_file_operations; in btrfs_mkdir()
6943 err = btrfs_init_inode_security(trans, inode, dir, &dentry->d_name); in btrfs_mkdir()
6953 dentry->d_name.name, in btrfs_mkdir()
6954 dentry->d_name.len, 0, index); in btrfs_mkdir()
6976 struct extent_buffer *leaf = path->nodes[0]; in uncompress_inline()
6987 btrfs_item_nr(path->slots[0])); in uncompress_inline()
6990 return -ENOMEM; in uncompress_inline()
7009 PAGE_SIZE - max_size - pg_offset); in uncompress_inline()
7015 * btrfs_get_extent - Lookup the first extent overlapping a range in a file.
7023 * range, reading it from the B-tree and caching it if necessary. Note that
7030 * Return: ERR_PTR on error, non-NULL extent_map on success.
7036 struct btrfs_fs_info *fs_info = inode->root->fs_info; in btrfs_get_extent()
7041 int extent_type = -1; in btrfs_get_extent()
7043 struct btrfs_root *root = inode->root; in btrfs_get_extent()
7048 struct extent_map_tree *em_tree = &inode->extent_tree; in btrfs_get_extent()
7049 struct extent_io_tree *io_tree = &inode->io_tree; in btrfs_get_extent()
7051 read_lock(&em_tree->lock); in btrfs_get_extent()
7053 read_unlock(&em_tree->lock); in btrfs_get_extent()
7056 if (em->start > start || em->start + em->len <= start) in btrfs_get_extent()
7058 else if (em->block_start == EXTENT_MAP_INLINE && page) in btrfs_get_extent()
7065 ret = -ENOMEM; in btrfs_get_extent()
7068 em->start = EXTENT_MAP_HOLE; in btrfs_get_extent()
7069 em->orig_start = EXTENT_MAP_HOLE; in btrfs_get_extent()
7070 em->len = (u64)-1; in btrfs_get_extent()
7071 em->block_len = (u64)-1; in btrfs_get_extent()
7075 ret = -ENOMEM; in btrfs_get_extent()
7080 path->reada = READA_FORWARD; in btrfs_get_extent()
7088 path->search_commit_root = 1; in btrfs_get_extent()
7089 path->skip_locking = 1; in btrfs_get_extent()
7096 if (path->slots[0] == 0) in btrfs_get_extent()
7098 path->slots[0]--; in btrfs_get_extent()
7102 leaf = path->nodes[0]; in btrfs_get_extent()
7103 item = btrfs_item_ptr(leaf, path->slots[0], in btrfs_get_extent()
7105 btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]); in btrfs_get_extent()
7124 if (!S_ISREG(inode->vfs_inode.i_mode)) { in btrfs_get_extent()
7125 ret = -EUCLEAN; in btrfs_get_extent()
7127 "regular/prealloc extent found for non-regular inode %llu", in btrfs_get_extent()
7135 path->slots[0], in btrfs_get_extent()
7140 path->slots[0]++; in btrfs_get_extent()
7141 if (path->slots[0] >= btrfs_header_nritems(leaf)) { in btrfs_get_extent()
7148 leaf = path->nodes[0]; in btrfs_get_extent()
7150 btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]); in btrfs_get_extent()
7160 em->start = start; in btrfs_get_extent()
7161 em->orig_start = start; in btrfs_get_extent()
7162 em->len = found_key.offset - start; in btrfs_get_extent()
7163 em->block_start = EXTENT_MAP_HOLE; in btrfs_get_extent()
7183 extent_offset = page_offset(page) + pg_offset - extent_start; in btrfs_get_extent()
7184 copy_size = min_t(u64, PAGE_SIZE - pg_offset, in btrfs_get_extent()
7185 size - extent_offset); in btrfs_get_extent()
7186 em->start = extent_start + extent_offset; in btrfs_get_extent()
7187 em->len = ALIGN(copy_size, fs_info->sectorsize); in btrfs_get_extent()
7188 em->orig_block_len = em->len; in btrfs_get_extent()
7189 em->orig_start = em->start; in btrfs_get_extent()
7205 PAGE_SIZE - pg_offset - in btrfs_get_extent()
7212 set_extent_uptodate(io_tree, em->start, in btrfs_get_extent()
7213 extent_map_end(em) - 1, NULL, GFP_NOFS); in btrfs_get_extent()
7217 em->start = start; in btrfs_get_extent()
7218 em->orig_start = start; in btrfs_get_extent()
7219 em->len = len; in btrfs_get_extent()
7220 em->block_start = EXTENT_MAP_HOLE; in btrfs_get_extent()
7224 if (em->start > start || extent_map_end(em) <= start) { in btrfs_get_extent()
7227 em->start, em->len, start, len); in btrfs_get_extent()
7228 ret = -EIO; in btrfs_get_extent()
7232 write_lock(&em_tree->lock); in btrfs_get_extent()
7234 write_unlock(&em_tree->lock); in btrfs_get_extent()
7263 * - a hole or in btrfs_get_extent_fiemap()
7264 * - a pre-alloc extent, in btrfs_get_extent_fiemap()
7267 if (em->block_start != EXTENT_MAP_HOLE && in btrfs_get_extent_fiemap()
7268 !test_bit(EXTENT_FLAG_PREALLOC, &em->flags)) in btrfs_get_extent_fiemap()
7273 /* check to see if we've wrapped (len == -1 or similar) */ in btrfs_get_extent_fiemap()
7276 end = (u64)-1; in btrfs_get_extent_fiemap()
7278 end -= 1; in btrfs_get_extent_fiemap()
7283 delalloc_len = count_range_bits(&inode->io_tree, &delalloc_start, in btrfs_get_extent_fiemap()
7287 delalloc_end = (u64)-1; in btrfs_get_extent_fiemap()
7304 delalloc_len = delalloc_end - delalloc_start; in btrfs_get_extent_fiemap()
7313 err = -ENOMEM; in btrfs_get_extent_fiemap()
7325 if (hole_end <= start || hole_em->start > end) { in btrfs_get_extent_fiemap()
7329 hole_start = max(hole_em->start, start); in btrfs_get_extent_fiemap()
7330 hole_len = hole_end - hole_start; in btrfs_get_extent_fiemap()
7339 em->len = min(hole_len, delalloc_start - hole_start); in btrfs_get_extent_fiemap()
7340 em->start = hole_start; in btrfs_get_extent_fiemap()
7341 em->orig_start = hole_start; in btrfs_get_extent_fiemap()
7346 em->block_start = hole_em->block_start; in btrfs_get_extent_fiemap()
7347 em->block_len = hole_len; in btrfs_get_extent_fiemap()
7348 if (test_bit(EXTENT_FLAG_PREALLOC, &hole_em->flags)) in btrfs_get_extent_fiemap()
7349 set_bit(EXTENT_FLAG_PREALLOC, &em->flags); in btrfs_get_extent_fiemap()
7355 em->start = delalloc_start; in btrfs_get_extent_fiemap()
7356 em->len = delalloc_len; in btrfs_get_extent_fiemap()
7357 em->orig_start = delalloc_start; in btrfs_get_extent_fiemap()
7358 em->block_start = EXTENT_MAP_DELALLOC; in btrfs_get_extent_fiemap()
7359 em->block_len = delalloc_len; in btrfs_get_extent_fiemap()
7400 btrfs_drop_extent_cache(inode, start, start + len - 1, 0); in btrfs_create_dio_extent()
7412 struct btrfs_root *root = inode->root; in btrfs_new_extent_direct()
7413 struct btrfs_fs_info *fs_info = root->fs_info; in btrfs_new_extent_direct()
7420 ret = btrfs_reserve_extent(root, len, len, fs_info->sectorsize, in btrfs_new_extent_direct()
7442 if (!block_group || block_group->ro) in btrfs_extent_readonly()
7456 * @orig_len: (optional) Return the original on-disk length of the file extent
7473 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); in can_nocow_extent()
7477 struct btrfs_root *root = BTRFS_I(inode)->root; in can_nocow_extent()
7478 struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree; in can_nocow_extent()
7487 bool nocow = (BTRFS_I(inode)->flags & BTRFS_INODE_NODATACOW); in can_nocow_extent()
7491 return -ENOMEM; in can_nocow_extent()
7498 slot = path->slots[0]; in can_nocow_extent()
7505 slot--; in can_nocow_extent()
7508 leaf = path->nodes[0]; in can_nocow_extent()
7551 btrfs_root_last_snapshot(&root->root_item))) in can_nocow_extent()
7557 *orig_start = key.offset - backref_offset; in can_nocow_extent()
7565 num_bytes = min(offset + *len, extent_end) - offset; in can_nocow_extent()
7570 root->fs_info->sectorsize) - 1; in can_nocow_extent()
7574 ret = -EAGAIN; in can_nocow_extent()
7587 key.offset - backref_offset, disk_bytenr, in can_nocow_extent()
7601 disk_bytenr += offset - key.offset; in can_nocow_extent()
7622 lock_extent_bits(&BTRFS_I(inode)->io_tree, lockstart, lockend, in lock_extent_direct()
7630 lockend - lockstart + 1); in lock_extent_direct()
7640 (!writing || !filemap_range_has_page(inode->i_mapping, in lock_extent_direct()
7644 unlock_extent_cached(&BTRFS_I(inode)->io_tree, lockstart, lockend, in lock_extent_direct()
7664 test_bit(BTRFS_ORDERED_DIRECT, &ordered->flags)) in lock_extent_direct()
7667 ret = -ENOTBLK; in lock_extent_direct()
7683 ret = -ENOTBLK; in lock_extent_direct()
7711 em_tree = &inode->extent_tree; in create_io_em()
7714 return ERR_PTR(-ENOMEM); in create_io_em()
7716 em->start = start; in create_io_em()
7717 em->orig_start = orig_start; in create_io_em()
7718 em->len = len; in create_io_em()
7719 em->block_len = block_len; in create_io_em()
7720 em->block_start = block_start; in create_io_em()
7721 em->orig_block_len = orig_block_len; in create_io_em()
7722 em->ram_bytes = ram_bytes; in create_io_em()
7723 em->generation = -1; in create_io_em()
7724 set_bit(EXTENT_FLAG_PINNED, &em->flags); in create_io_em()
7726 set_bit(EXTENT_FLAG_FILLING, &em->flags); in create_io_em()
7728 set_bit(EXTENT_FLAG_COMPRESSED, &em->flags); in create_io_em()
7729 em->compress_type = compress_type; in create_io_em()
7733 btrfs_drop_extent_cache(inode, em->start, in create_io_em()
7734 em->start + em->len - 1, 0); in create_io_em()
7735 write_lock(&em_tree->lock); in create_io_em()
7737 write_unlock(&em_tree->lock); in create_io_em()
7742 } while (ret == -EEXIST); in create_io_em()
7759 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); in btrfs_get_blocks_direct_write()
7772 if (test_bit(EXTENT_FLAG_PREALLOC, &em->flags) || in btrfs_get_blocks_direct_write()
7773 ((BTRFS_I(inode)->flags & BTRFS_INODE_NODATACOW) && in btrfs_get_blocks_direct_write()
7774 em->block_start != EXTENT_MAP_HOLE)) { in btrfs_get_blocks_direct_write()
7778 if (test_bit(EXTENT_FLAG_PREALLOC, &em->flags)) in btrfs_get_blocks_direct_write()
7782 len = min(len, em->len - (start - em->start)); in btrfs_get_blocks_direct_write()
7783 block_start = em->block_start + (start - em->start); in btrfs_get_blocks_direct_write()
7822 len = min(len, em->len - (start - em->start)); in btrfs_get_blocks_direct_write()
7832 dio_data->reserve -= len; in btrfs_get_blocks_direct_write()
7841 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); in btrfs_dio_iomap_begin()
7852 len = min_t(u64, len, fs_info->sectorsize); in btrfs_dio_iomap_begin()
7855 lockend = start + len - 1; in btrfs_dio_iomap_begin()
7864 &BTRFS_I(inode)->runtime_flags)) { in btrfs_dio_iomap_begin()
7865 ret = filemap_fdatawrite_range(inode->i_mapping, start, in btrfs_dio_iomap_begin()
7866 start + length - 1); in btrfs_dio_iomap_begin()
7873 return -ENOMEM; in btrfs_dio_iomap_begin()
7875 dio_data->length = length; in btrfs_dio_iomap_begin()
7877 dio_data->reserve = round_up(length, fs_info->sectorsize); in btrfs_dio_iomap_begin()
7879 &dio_data->data_reserved, in btrfs_dio_iomap_begin()
7880 start, dio_data->reserve); in btrfs_dio_iomap_begin()
7882 extent_changeset_free(dio_data->data_reserved); in btrfs_dio_iomap_begin()
7887 iomap->private = dio_data; in btrfs_dio_iomap_begin()
7895 ret = -ENOTBLK; in btrfs_dio_iomap_begin()
7915 * We return -ENOTBLK because that's what makes DIO go ahead and go back in btrfs_dio_iomap_begin()
7919 if (test_bit(EXTENT_FLAG_COMPRESSED, &em->flags) || in btrfs_dio_iomap_begin()
7920 em->block_start == EXTENT_MAP_INLINE) { in btrfs_dio_iomap_begin()
7922 ret = -ENOTBLK; in btrfs_dio_iomap_begin()
7926 len = min(len, em->len - (start - em->start)); in btrfs_dio_iomap_begin()
7934 len = min(len, em->len - (start - em->start)); in btrfs_dio_iomap_begin()
7946 unlock_extent_cached(&BTRFS_I(inode)->io_tree, in btrfs_dio_iomap_begin()
7956 if ((em->block_start == EXTENT_MAP_HOLE) || in btrfs_dio_iomap_begin()
7957 (test_bit(EXTENT_FLAG_PREALLOC, &em->flags) && !write)) { in btrfs_dio_iomap_begin()
7958 iomap->addr = IOMAP_NULL_ADDR; in btrfs_dio_iomap_begin()
7959 iomap->type = IOMAP_HOLE; in btrfs_dio_iomap_begin()
7961 iomap->addr = em->block_start + (start - em->start); in btrfs_dio_iomap_begin()
7962 iomap->type = IOMAP_MAPPED; in btrfs_dio_iomap_begin()
7964 iomap->offset = start; in btrfs_dio_iomap_begin()
7965 iomap->bdev = fs_info->fs_devices->latest_bdev; in btrfs_dio_iomap_begin()
7966 iomap->length = len; in btrfs_dio_iomap_begin()
7968 if (write && btrfs_use_zone_append(BTRFS_I(inode), em->block_start)) in btrfs_dio_iomap_begin()
7969 iomap->flags |= IOMAP_F_ZONE_APPEND; in btrfs_dio_iomap_begin()
7976 unlock_extent_cached(&BTRFS_I(inode)->io_tree, lockstart, lockend, in btrfs_dio_iomap_begin()
7981 dio_data->data_reserved, start, in btrfs_dio_iomap_begin()
7982 dio_data->reserve, true); in btrfs_dio_iomap_begin()
7983 btrfs_delalloc_release_extents(BTRFS_I(inode), dio_data->reserve); in btrfs_dio_iomap_begin()
7984 extent_changeset_free(dio_data->data_reserved); in btrfs_dio_iomap_begin()
7994 struct btrfs_dio_data *dio_data = iomap->private; in btrfs_dio_iomap_end()
7995 size_t submitted = dio_data->submitted; in btrfs_dio_iomap_end()
7998 if (!write && (iomap->type == IOMAP_HOLE)) { in btrfs_dio_iomap_end()
8000 unlock_extent(&BTRFS_I(inode)->io_tree, pos, pos + length - 1); in btrfs_dio_iomap_end()
8006 length -= submitted; in btrfs_dio_iomap_end()
8011 unlock_extent(&BTRFS_I(inode)->io_tree, pos, in btrfs_dio_iomap_end()
8012 pos + length - 1); in btrfs_dio_iomap_end()
8013 ret = -ENOTBLK; in btrfs_dio_iomap_end()
8017 if (dio_data->reserve) in btrfs_dio_iomap_end()
8019 dio_data->data_reserved, pos, in btrfs_dio_iomap_end()
8020 dio_data->reserve, true); in btrfs_dio_iomap_end()
8021 btrfs_delalloc_release_extents(BTRFS_I(inode), dio_data->length); in btrfs_dio_iomap_end()
8022 extent_changeset_free(dio_data->data_reserved); in btrfs_dio_iomap_end()
8026 iomap->private = NULL; in btrfs_dio_iomap_end()
8034 * This implies a barrier so that stores to dio_bio->bi_status before in btrfs_dio_private_put()
8035 * this and loads of dio_bio->bi_status after this are fully ordered. in btrfs_dio_private_put()
8037 if (!refcount_dec_and_test(&dip->refs)) in btrfs_dio_private_put()
8040 if (btrfs_op(dip->dio_bio) == BTRFS_MAP_WRITE) { in btrfs_dio_private_put()
8041 __endio_write_update_ordered(BTRFS_I(dip->inode), in btrfs_dio_private_put()
8042 dip->logical_offset, in btrfs_dio_private_put()
8043 dip->bytes, in btrfs_dio_private_put()
8044 !dip->dio_bio->bi_status); in btrfs_dio_private_put()
8046 unlock_extent(&BTRFS_I(dip->inode)->io_tree, in btrfs_dio_private_put()
8047 dip->logical_offset, in btrfs_dio_private_put()
8048 dip->logical_offset + dip->bytes - 1); in btrfs_dio_private_put()
8051 bio_endio(dip->dio_bio); in btrfs_dio_private_put()
8059 struct btrfs_dio_private *dip = bio->bi_private; in submit_dio_repair_bio()
8060 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); in submit_dio_repair_bio()
8069 refcount_inc(&dip->refs); in submit_dio_repair_bio()
8072 refcount_dec(&dip->refs); in submit_dio_repair_bio()
8080 struct btrfs_fs_info *fs_info = BTRFS_I(inode)->root->fs_info; in btrfs_check_read_dio_bio()
8081 const u32 sectorsize = fs_info->sectorsize; in btrfs_check_read_dio_bio()
8082 struct extent_io_tree *failure_tree = &BTRFS_I(inode)->io_failure_tree; in btrfs_check_read_dio_bio()
8083 struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree; in btrfs_check_read_dio_bio()
8084 const bool csum = !(BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM); in btrfs_check_read_dio_bio()
8087 u64 start = io_bio->logical; in btrfs_check_read_dio_bio()
8091 __bio_for_each_segment(bvec, &io_bio->bio, iter, io_bio->iter) { in btrfs_check_read_dio_bio()
8109 ASSERT((start - io_bio->logical) < UINT_MAX); in btrfs_check_read_dio_bio()
8111 &io_bio->bio, in btrfs_check_read_dio_bio()
8112 start - io_bio->logical, in btrfs_check_read_dio_bio()
8114 start, io_bio->mirror_num, in btrfs_check_read_dio_bio()
8145 struct btrfs_dio_private *dip = bio->bi_private; in btrfs_end_dio_bio()
8146 blk_status_t err = bio->bi_status; in btrfs_end_dio_bio()
8149 btrfs_warn(BTRFS_I(dip->inode)->root->fs_info, in btrfs_end_dio_bio()
8151 btrfs_ino(BTRFS_I(dip->inode)), bio_op(bio), in btrfs_end_dio_bio()
8152 bio->bi_opf, bio->bi_iter.bi_sector, in btrfs_end_dio_bio()
8153 bio->bi_iter.bi_size, err); in btrfs_end_dio_bio()
8156 err = btrfs_check_read_dio_bio(dip->inode, btrfs_io_bio(bio), in btrfs_end_dio_bio()
8161 dip->dio_bio->bi_status = err; in btrfs_end_dio_bio()
8163 btrfs_record_physical_zoned(dip->inode, dip->logical_offset, bio); in btrfs_end_dio_bio()
8172 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); in btrfs_submit_dio_bio()
8173 struct btrfs_dio_private *dip = bio->bi_private; in btrfs_submit_dio_bio()
8179 async_submit = !atomic_read(&BTRFS_I(inode)->sync_writers); in btrfs_submit_dio_bio()
8187 if (BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM) in btrfs_submit_dio_bio()
8205 csum_offset = file_offset - dip->logical_offset; in btrfs_submit_dio_bio()
8206 csum_offset >>= fs_info->sectorsize_bits; in btrfs_submit_dio_bio()
8207 csum_offset *= fs_info->csum_size; in btrfs_submit_dio_bio()
8208 btrfs_io_bio(bio)->csum = dip->csums + csum_offset; in btrfs_submit_dio_bio()
8225 const bool csum = !(BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM); in btrfs_create_dio_private()
8231 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); in btrfs_create_dio_private()
8234 nblocks = dio_bio->bi_iter.bi_size >> fs_info->sectorsize_bits; in btrfs_create_dio_private()
8235 dip_size += fs_info->csum_size * nblocks; in btrfs_create_dio_private()
8242 dip->inode = inode; in btrfs_create_dio_private()
8243 dip->logical_offset = file_offset; in btrfs_create_dio_private()
8244 dip->bytes = dio_bio->bi_iter.bi_size; in btrfs_create_dio_private()
8245 dip->disk_bytenr = dio_bio->bi_iter.bi_sector << 9; in btrfs_create_dio_private()
8246 dip->dio_bio = dio_bio; in btrfs_create_dio_private()
8247 refcount_set(&dip->refs, 1); in btrfs_create_dio_private()
8254 struct inode *inode = iter->inode; in btrfs_submit_direct()
8256 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); in btrfs_submit_direct()
8270 struct btrfs_dio_data *dio_data = iter->iomap.private; in btrfs_submit_direct()
8276 unlock_extent(&BTRFS_I(inode)->io_tree, file_offset, in btrfs_submit_direct()
8277 file_offset + dio_bio->bi_iter.bi_size - 1); in btrfs_submit_direct()
8279 dio_bio->bi_status = BLK_STS_RESOURCE; in btrfs_submit_direct()
8291 status = btrfs_lookup_bio_sums(inode, dio_bio, dip->csums); in btrfs_submit_direct()
8296 start_sector = dio_bio->bi_iter.bi_sector; in btrfs_submit_direct()
8297 submit_len = dio_bio->bi_iter.bi_size; in btrfs_submit_direct()
8322 bio->bi_private = dip; in btrfs_submit_direct()
8323 bio->bi_end_io = btrfs_end_dio_bio; in btrfs_submit_direct()
8324 btrfs_io_bio(bio)->logical = file_offset; in btrfs_submit_direct()
8336 submit_len -= clone_len; in btrfs_submit_direct()
8348 refcount_inc(&dip->refs); in btrfs_submit_direct()
8364 refcount_dec(&dip->refs); in btrfs_submit_direct()
8368 dio_data->submitted += clone_len; in btrfs_submit_direct()
8380 dip->dio_bio->bi_status = status; in btrfs_submit_direct()
8409 struct btrfs_inode *inode = BTRFS_I(page->mapping->host); in btrfs_readpage()
8411 u64 end = start + PAGE_SIZE - 1; in btrfs_readpage()
8425 struct inode *inode = page->mapping->host; in btrfs_writepage()
8428 if (current->flags & PF_MEMALLOC) { in btrfs_writepage()
8462 * If we continue to release/invalidate the page, we could cause use-after-free
8468 struct btrfs_fs_info *fs_info = btrfs_sb(page->mapping->host->i_sb); in wait_subpage_spinlock()
8471 if (fs_info->sectorsize == PAGE_SIZE) in wait_subpage_spinlock()
8474 ASSERT(PagePrivate(page) && page->private); in wait_subpage_spinlock()
8475 subpage = (struct btrfs_subpage *)page->private; in wait_subpage_spinlock()
8488 spin_lock_irq(&subpage->lock); in wait_subpage_spinlock()
8489 spin_unlock_irq(&subpage->lock); in wait_subpage_spinlock()
8540 struct btrfs_inode *inode = BTRFS_I(page->mapping->host); in btrfs_invalidatepage()
8541 struct btrfs_fs_info *fs_info = inode->root->fs_info; in btrfs_invalidatepage()
8542 struct extent_io_tree *tree = &inode->io_tree; in btrfs_invalidatepage()
8545 u64 page_end = page_start + PAGE_SIZE - 1; in btrfs_invalidatepage()
8547 int inode_evicting = inode->vfs_inode.i_state & I_FREEING; in btrfs_invalidatepage()
8570 * shouldn't clear page extent mapped, as page->private can still in btrfs_invalidatepage()
8593 page_end + 1 - cur); in btrfs_invalidatepage()
8603 if (ordered->file_offset > cur) { in btrfs_invalidatepage()
8605 * There is a range between [cur, oe->file_offset) not in btrfs_invalidatepage()
8610 range_end = ordered->file_offset - 1; in btrfs_invalidatepage()
8615 range_end = min(ordered->file_offset + ordered->num_bytes - 1, in btrfs_invalidatepage()
8617 ASSERT(range_end + 1 - cur < U32_MAX); in btrfs_invalidatepage()
8618 range_len = range_end + 1 - cur; in btrfs_invalidatepage()
8645 spin_lock_irq(&inode->ordered_tree.lock); in btrfs_invalidatepage()
8646 set_bit(BTRFS_ORDERED_TRUNCATED, &ordered->flags); in btrfs_invalidatepage()
8647 ordered->truncated_len = min(ordered->truncated_len, in btrfs_invalidatepage()
8648 cur - ordered->file_offset); in btrfs_invalidatepage()
8649 spin_unlock_irq(&inode->ordered_tree.lock); in btrfs_invalidatepage()
8652 cur, range_end + 1 - cur)) { in btrfs_invalidatepage()
8685 btrfs_qgroup_free_data(inode, NULL, cur, range_end + 1 - cur); in btrfs_invalidatepage()
8723 struct page *page = vmf->page; in btrfs_page_mkwrite()
8724 struct inode *inode = file_inode(vmf->vma->vm_file); in btrfs_page_mkwrite()
8725 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); in btrfs_page_mkwrite()
8726 struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree; in btrfs_page_mkwrite()
8742 sb_start_pagefault(inode->i_sb); in btrfs_page_mkwrite()
8744 page_end = page_start + PAGE_SIZE - 1; in btrfs_page_mkwrite()
8758 ret2 = file_update_time(vmf->vma->vm_file); in btrfs_page_mkwrite()
8770 down_read(&BTRFS_I(inode)->i_mmap_lock); in btrfs_page_mkwrite()
8774 if ((page->mapping != inode->i_mapping) || in btrfs_page_mkwrite()
8799 up_read(&BTRFS_I(inode)->i_mmap_lock); in btrfs_page_mkwrite()
8805 if (page->index == ((size - 1) >> PAGE_SHIFT)) { in btrfs_page_mkwrite()
8806 reserved_space = round_up(size - page_start, in btrfs_page_mkwrite()
8807 fs_info->sectorsize); in btrfs_page_mkwrite()
8809 end = page_start + reserved_space - 1; in btrfs_page_mkwrite()
8812 PAGE_SIZE - reserved_space, true); in btrfs_page_mkwrite()
8823 clear_extent_bit(&BTRFS_I(inode)->io_tree, page_start, end, in btrfs_page_mkwrite()
8843 memzero_page(page, zero_start, PAGE_SIZE - zero_start); in btrfs_page_mkwrite()
8847 btrfs_page_set_dirty(fs_info, page, page_start, end + 1 - page_start); in btrfs_page_mkwrite()
8848 btrfs_page_set_uptodate(fs_info, page, page_start, end + 1 - page_start); in btrfs_page_mkwrite()
8853 up_read(&BTRFS_I(inode)->i_mmap_lock); in btrfs_page_mkwrite()
8856 sb_end_pagefault(inode->i_sb); in btrfs_page_mkwrite()
8862 up_read(&BTRFS_I(inode)->i_mmap_lock); in btrfs_page_mkwrite()
8868 sb_end_pagefault(inode->i_sb); in btrfs_page_mkwrite()
8875 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); in btrfs_truncate()
8876 struct btrfs_root *root = BTRFS_I(inode)->root; in btrfs_truncate()
8880 u64 mask = fs_info->sectorsize - 1; in btrfs_truncate()
8885 ret = btrfs_wait_ordered_range(inode, inode->i_size & (~mask), in btrfs_truncate()
8886 (u64)-1); in btrfs_truncate()
8914 * 1) rsv - for the truncate reservation, which we will steal from the in btrfs_truncate()
8916 * 2) fs_info->trans_block_rsv - this will have 1 items worth left for in btrfs_truncate()
8921 return -ENOMEM; in btrfs_truncate()
8922 rsv->size = min_size; in btrfs_truncate()
8923 rsv->failfast = 1; in btrfs_truncate()
8936 ret = btrfs_block_rsv_migrate(&fs_info->trans_block_rsv, rsv, in btrfs_truncate()
8940 trans->block_rsv = rsv; in btrfs_truncate()
8944 inode->i_size, in btrfs_truncate()
8947 trans->block_rsv = &fs_info->trans_block_rsv; in btrfs_truncate()
8948 if (ret != -ENOSPC && ret != -EAGAIN) in btrfs_truncate()
8965 btrfs_block_rsv_release(fs_info, rsv, -1, NULL); in btrfs_truncate()
8966 ret = btrfs_block_rsv_migrate(&fs_info->trans_block_rsv, in btrfs_truncate()
8969 trans->block_rsv = rsv; in btrfs_truncate()
8982 ret = btrfs_truncate_block(BTRFS_I(inode), inode->i_size, 0, 0); in btrfs_truncate()
8996 trans->block_rsv = &fs_info->trans_block_rsv; in btrfs_truncate()
9016 * fsync to truncate all the inode's items from the log and re-log them in btrfs_truncate()
9023 set_bit(BTRFS_INODE_NEEDS_FULL_SYNC, &BTRFS_I(inode)->runtime_flags); in btrfs_truncate()
9051 inode->i_op = &btrfs_dir_inode_operations; in btrfs_create_subvol_root()
9052 inode->i_fop = &btrfs_dir_file_operations; in btrfs_create_subvol_root()
9060 btrfs_err(new_root->fs_info, in btrfs_create_subvol_root()
9062 new_root->root_key.objectid, err); in btrfs_create_subvol_root()
9080 ei->root = NULL; in btrfs_alloc_inode()
9081 ei->generation = 0; in btrfs_alloc_inode()
9082 ei->last_trans = 0; in btrfs_alloc_inode()
9083 ei->last_sub_trans = 0; in btrfs_alloc_inode()
9084 ei->logged_trans = 0; in btrfs_alloc_inode()
9085 ei->delalloc_bytes = 0; in btrfs_alloc_inode()
9086 ei->new_delalloc_bytes = 0; in btrfs_alloc_inode()
9087 ei->defrag_bytes = 0; in btrfs_alloc_inode()
9088 ei->disk_i_size = 0; in btrfs_alloc_inode()
9089 ei->flags = 0; in btrfs_alloc_inode()
9090 ei->ro_flags = 0; in btrfs_alloc_inode()
9091 ei->csum_bytes = 0; in btrfs_alloc_inode()
9092 ei->index_cnt = (u64)-1; in btrfs_alloc_inode()
9093 ei->dir_index = 0; in btrfs_alloc_inode()
9094 ei->last_unlink_trans = 0; in btrfs_alloc_inode()
9095 ei->last_reflink_trans = 0; in btrfs_alloc_inode()
9096 ei->last_log_commit = 0; in btrfs_alloc_inode()
9098 spin_lock_init(&ei->lock); in btrfs_alloc_inode()
9099 ei->outstanding_extents = 0; in btrfs_alloc_inode()
9100 if (sb->s_magic != BTRFS_TEST_MAGIC) in btrfs_alloc_inode()
9101 btrfs_init_metadata_block_rsv(fs_info, &ei->block_rsv, in btrfs_alloc_inode()
9103 ei->runtime_flags = 0; in btrfs_alloc_inode()
9104 ei->prop_compress = BTRFS_COMPRESS_NONE; in btrfs_alloc_inode()
9105 ei->defrag_compress = BTRFS_COMPRESS_NONE; in btrfs_alloc_inode()
9107 ei->delayed_node = NULL; in btrfs_alloc_inode()
9109 ei->i_otime.tv_sec = 0; in btrfs_alloc_inode()
9110 ei->i_otime.tv_nsec = 0; in btrfs_alloc_inode()
9112 inode = &ei->vfs_inode; in btrfs_alloc_inode()
9113 extent_map_tree_init(&ei->extent_tree); in btrfs_alloc_inode()
9114 extent_io_tree_init(fs_info, &ei->io_tree, IO_TREE_INODE_IO, inode); in btrfs_alloc_inode()
9115 extent_io_tree_init(fs_info, &ei->io_failure_tree, in btrfs_alloc_inode()
9117 extent_io_tree_init(fs_info, &ei->file_extent_tree, in btrfs_alloc_inode()
9119 ei->io_tree.track_uptodate = true; in btrfs_alloc_inode()
9120 ei->io_failure_tree.track_uptodate = true; in btrfs_alloc_inode()
9121 atomic_set(&ei->sync_writers, 0); in btrfs_alloc_inode()
9122 mutex_init(&ei->log_mutex); in btrfs_alloc_inode()
9123 btrfs_ordered_inode_tree_init(&ei->ordered_tree); in btrfs_alloc_inode()
9124 INIT_LIST_HEAD(&ei->delalloc_inodes); in btrfs_alloc_inode()
9125 INIT_LIST_HEAD(&ei->delayed_iput); in btrfs_alloc_inode()
9126 RB_CLEAR_NODE(&ei->rb_node); in btrfs_alloc_inode()
9127 init_rwsem(&ei->i_mmap_lock); in btrfs_alloc_inode()
9135 btrfs_drop_extent_cache(BTRFS_I(inode), 0, (u64)-1, 0); in btrfs_test_destroy_inode()
9149 struct btrfs_root *root = inode->root; in btrfs_destroy_inode()
9151 WARN_ON(!hlist_empty(&vfs_inode->i_dentry)); in btrfs_destroy_inode()
9152 WARN_ON(vfs_inode->i_data.nrpages); in btrfs_destroy_inode()
9153 WARN_ON(inode->block_rsv.reserved); in btrfs_destroy_inode()
9154 WARN_ON(inode->block_rsv.size); in btrfs_destroy_inode()
9155 WARN_ON(inode->outstanding_extents); in btrfs_destroy_inode()
9156 WARN_ON(inode->delalloc_bytes); in btrfs_destroy_inode()
9157 WARN_ON(inode->new_delalloc_bytes); in btrfs_destroy_inode()
9158 WARN_ON(inode->csum_bytes); in btrfs_destroy_inode()
9159 WARN_ON(inode->defrag_bytes); in btrfs_destroy_inode()
9170 ordered = btrfs_lookup_first_ordered_extent(inode, (u64)-1); in btrfs_destroy_inode()
9174 btrfs_err(root->fs_info, in btrfs_destroy_inode()
9176 ordered->file_offset, ordered->num_bytes); in btrfs_destroy_inode()
9184 btrfs_drop_extent_cache(inode, 0, (u64)-1, 0); in btrfs_destroy_inode()
9185 btrfs_inode_clear_file_extent_range(inode, 0, (u64)-1); in btrfs_destroy_inode()
9186 btrfs_put_root(inode->root); in btrfs_destroy_inode()
9191 struct btrfs_root *root = BTRFS_I(inode)->root; in btrfs_drop_inode()
9197 if (btrfs_root_refs(&root->root_item) == 0) in btrfs_drop_inode()
9203 static void init_once(void *foo) in init_once() argument
9205 struct btrfs_inode *ei = (struct btrfs_inode *) foo; in init_once()
9207 inode_init_once(&ei->vfs_inode); in init_once()
9260 return -ENOMEM; in btrfs_init_cachep()
9269 struct inode *inode = d_inode(path->dentry); in btrfs_getattr()
9270 u32 blocksize = inode->i_sb->s_blocksize; in btrfs_getattr()
9271 u32 bi_flags = BTRFS_I(inode)->flags; in btrfs_getattr()
9272 u32 bi_ro_flags = BTRFS_I(inode)->ro_flags; in btrfs_getattr()
9274 stat->result_mask |= STATX_BTIME; in btrfs_getattr()
9275 stat->btime.tv_sec = BTRFS_I(inode)->i_otime.tv_sec; in btrfs_getattr()
9276 stat->btime.tv_nsec = BTRFS_I(inode)->i_otime.tv_nsec; in btrfs_getattr()
9278 stat->attributes |= STATX_ATTR_APPEND; in btrfs_getattr()
9280 stat->attributes |= STATX_ATTR_COMPRESSED; in btrfs_getattr()
9282 stat->attributes |= STATX_ATTR_IMMUTABLE; in btrfs_getattr()
9284 stat->attributes |= STATX_ATTR_NODUMP; in btrfs_getattr()
9286 stat->attributes |= STATX_ATTR_VERITY; in btrfs_getattr()
9288 stat->attributes_mask |= (STATX_ATTR_APPEND | in btrfs_getattr()
9294 stat->dev = BTRFS_I(inode)->root->anon_dev; in btrfs_getattr()
9296 spin_lock(&BTRFS_I(inode)->lock); in btrfs_getattr()
9297 delalloc_bytes = BTRFS_I(inode)->new_delalloc_bytes; in btrfs_getattr()
9299 spin_unlock(&BTRFS_I(inode)->lock); in btrfs_getattr()
9300 stat->blocks = (ALIGN(inode_bytes, blocksize) + in btrfs_getattr()
9310 struct btrfs_fs_info *fs_info = btrfs_sb(old_dir->i_sb); in btrfs_rename_exchange()
9312 struct btrfs_root *root = BTRFS_I(old_dir)->root; in btrfs_rename_exchange()
9313 struct btrfs_root *dest = BTRFS_I(new_dir)->root; in btrfs_rename_exchange()
9314 struct inode *new_inode = new_dentry->d_inode; in btrfs_rename_exchange()
9315 struct inode *old_inode = old_dentry->d_inode; in btrfs_rename_exchange()
9328 * For non-subvolumes allow exchange only within one subvolume, in the in btrfs_rename_exchange()
9335 return -EXDEV; in btrfs_rename_exchange()
9340 down_read(&fs_info->subvol_sem); in btrfs_rename_exchange()
9373 BTRFS_I(old_inode)->dir_index = 0ULL; in btrfs_rename_exchange()
9374 BTRFS_I(new_inode)->dir_index = 0ULL; in btrfs_rename_exchange()
9382 new_dentry->d_name.name, in btrfs_rename_exchange()
9383 new_dentry->d_name.len, in btrfs_rename_exchange()
9398 old_dentry->d_name.name, in btrfs_rename_exchange()
9399 old_dentry->d_name.len, in btrfs_rename_exchange()
9415 old_dir->i_ctime = old_dir->i_mtime = ctime; in btrfs_rename_exchange()
9416 new_dir->i_ctime = new_dir->i_mtime = ctime; in btrfs_rename_exchange()
9417 old_inode->i_ctime = ctime; in btrfs_rename_exchange()
9418 new_inode->i_ctime = ctime; in btrfs_rename_exchange()
9420 if (old_dentry->d_parent != new_dentry->d_parent) { in btrfs_rename_exchange()
9455 BTRFS_I(old_dentry->d_inode), in btrfs_rename_exchange()
9456 old_dentry->d_name.name, in btrfs_rename_exchange()
9457 old_dentry->d_name.len); in btrfs_rename_exchange()
9471 BTRFS_I(new_dentry->d_inode), in btrfs_rename_exchange()
9472 new_dentry->d_name.name, in btrfs_rename_exchange()
9473 new_dentry->d_name.len); in btrfs_rename_exchange()
9483 new_dentry->d_name.name, in btrfs_rename_exchange()
9484 new_dentry->d_name.len, 0, old_idx); in btrfs_rename_exchange()
9491 old_dentry->d_name.name, in btrfs_rename_exchange()
9492 old_dentry->d_name.len, 0, new_idx); in btrfs_rename_exchange()
9498 if (old_inode->i_nlink == 1) in btrfs_rename_exchange()
9499 BTRFS_I(old_inode)->dir_index = old_idx; in btrfs_rename_exchange()
9500 if (new_inode->i_nlink == 1) in btrfs_rename_exchange()
9501 BTRFS_I(new_inode)->dir_index = new_idx; in btrfs_rename_exchange()
9505 new_dentry->d_parent); in btrfs_rename_exchange()
9511 old_dentry->d_parent); in btrfs_rename_exchange()
9528 if (btrfs_inode_in_log(BTRFS_I(old_dir), fs_info->generation) || in btrfs_rename_exchange()
9529 btrfs_inode_in_log(BTRFS_I(new_dir), fs_info->generation) || in btrfs_rename_exchange()
9530 btrfs_inode_in_log(BTRFS_I(old_inode), fs_info->generation) || in btrfs_rename_exchange()
9531 btrfs_inode_in_log(BTRFS_I(new_inode), fs_info->generation)) in btrfs_rename_exchange()
9548 up_read(&fs_info->subvol_sem); in btrfs_rename_exchange()
9569 dentry->d_name.name, in btrfs_whiteout_for_rename()
9570 dentry->d_name.len, in btrfs_whiteout_for_rename()
9581 inode->i_op = &btrfs_special_inode_operations; in btrfs_whiteout_for_rename()
9582 init_special_inode(inode, inode->i_mode, in btrfs_whiteout_for_rename()
9586 &dentry->d_name); in btrfs_whiteout_for_rename()
9610 struct btrfs_fs_info *fs_info = btrfs_sb(old_dir->i_sb); in btrfs_rename()
9613 struct btrfs_root *root = BTRFS_I(old_dir)->root; in btrfs_rename()
9614 struct btrfs_root *dest = BTRFS_I(new_dir)->root; in btrfs_rename()
9624 return -EPERM; in btrfs_rename()
9628 return -EXDEV; in btrfs_rename()
9632 return -ENOTEMPTY; in btrfs_rename()
9634 if (S_ISDIR(old_inode->i_mode) && new_inode && in btrfs_rename()
9635 new_inode->i_size > BTRFS_EMPTY_DIR_SIZE) in btrfs_rename()
9636 return -ENOTEMPTY; in btrfs_rename()
9640 ret = btrfs_check_dir_item_collision(dest, new_dir->i_ino, in btrfs_rename()
9641 new_dentry->d_name.name, in btrfs_rename()
9642 new_dentry->d_name.len); in btrfs_rename()
9645 if (ret == -EEXIST) { in btrfs_rename()
9652 /* maybe -EOVERFLOW */ in btrfs_rename()
9662 if (new_inode && S_ISREG(old_inode->i_mode) && new_inode->i_size) in btrfs_rename()
9663 filemap_flush(old_inode->i_mapping); in btrfs_rename()
9667 down_read(&fs_info->subvol_sem); in btrfs_rename()
9698 BTRFS_I(old_inode)->dir_index = 0ULL; in btrfs_rename()
9704 new_dentry->d_name.name, in btrfs_rename()
9705 new_dentry->d_name.len, in btrfs_rename()
9715 old_dir->i_ctime = old_dir->i_mtime = in btrfs_rename()
9716 new_dir->i_ctime = new_dir->i_mtime = in btrfs_rename()
9717 old_inode->i_ctime = current_time(old_dir); in btrfs_rename()
9719 if (old_dentry->d_parent != new_dentry->d_parent) in btrfs_rename()
9747 old_dentry->d_name.name, in btrfs_rename()
9748 old_dentry->d_name.len); in btrfs_rename()
9759 new_inode->i_ctime = current_time(new_inode); in btrfs_rename()
9763 BUG_ON(new_inode->i_nlink == 0); in btrfs_rename()
9767 new_dentry->d_name.name, in btrfs_rename()
9768 new_dentry->d_name.len); in btrfs_rename()
9770 if (!ret && new_inode->i_nlink == 0) in btrfs_rename()
9780 new_dentry->d_name.name, in btrfs_rename()
9781 new_dentry->d_name.len, 0, index); in btrfs_rename()
9787 if (old_inode->i_nlink == 1) in btrfs_rename()
9788 BTRFS_I(old_inode)->dir_index = index; in btrfs_rename()
9792 new_dentry->d_parent); in btrfs_rename()
9819 if (btrfs_inode_in_log(BTRFS_I(old_dir), fs_info->generation) || in btrfs_rename()
9820 btrfs_inode_in_log(BTRFS_I(new_dir), fs_info->generation) || in btrfs_rename()
9821 btrfs_inode_in_log(BTRFS_I(old_inode), fs_info->generation) || in btrfs_rename()
9823 btrfs_inode_in_log(BTRFS_I(new_inode), fs_info->generation))) in btrfs_rename()
9833 up_read(&fs_info->subvol_sem); in btrfs_rename()
9843 return -EINVAL; in btrfs_rename2()
9867 inode = delalloc_work->inode; in btrfs_run_delalloc_work()
9868 filemap_flush(inode->i_mapping); in btrfs_run_delalloc_work()
9870 &BTRFS_I(inode)->runtime_flags)) in btrfs_run_delalloc_work()
9871 filemap_flush(inode->i_mapping); in btrfs_run_delalloc_work()
9874 complete(&delalloc_work->completion); in btrfs_run_delalloc_work()
9885 init_completion(&work->completion); in btrfs_alloc_delalloc_work()
9886 INIT_LIST_HEAD(&work->list); in btrfs_alloc_delalloc_work()
9887 work->inode = inode; in btrfs_alloc_delalloc_work()
9888 btrfs_init_work(&work->work, btrfs_run_delalloc_work, NULL, NULL); in btrfs_alloc_delalloc_work()
9907 bool full_flush = wbc->nr_to_write == LONG_MAX; in start_delalloc_inodes()
9912 mutex_lock(&root->delalloc_mutex); in start_delalloc_inodes()
9913 spin_lock(&root->delalloc_lock); in start_delalloc_inodes()
9914 list_splice_init(&root->delalloc_inodes, &splice); in start_delalloc_inodes()
9919 list_move_tail(&binode->delalloc_inodes, in start_delalloc_inodes()
9920 &root->delalloc_inodes); in start_delalloc_inodes()
9923 test_bit(BTRFS_INODE_NO_DELALLOC_FLUSH, &binode->runtime_flags)) in start_delalloc_inodes()
9926 inode = igrab(&binode->vfs_inode); in start_delalloc_inodes()
9928 cond_resched_lock(&root->delalloc_lock); in start_delalloc_inodes()
9931 spin_unlock(&root->delalloc_lock); in start_delalloc_inodes()
9935 &binode->runtime_flags); in start_delalloc_inodes()
9940 ret = -ENOMEM; in start_delalloc_inodes()
9943 list_add_tail(&work->list, &works); in start_delalloc_inodes()
9944 btrfs_queue_work(root->fs_info->flush_workers, in start_delalloc_inodes()
9945 &work->work); in start_delalloc_inodes()
9947 ret = filemap_fdatawrite_wbc(inode->i_mapping, wbc); in start_delalloc_inodes()
9949 if (ret || wbc->nr_to_write <= 0) in start_delalloc_inodes()
9953 spin_lock(&root->delalloc_lock); in start_delalloc_inodes()
9955 spin_unlock(&root->delalloc_lock); in start_delalloc_inodes()
9959 list_del_init(&work->list); in start_delalloc_inodes()
9960 wait_for_completion(&work->completion); in start_delalloc_inodes()
9965 spin_lock(&root->delalloc_lock); in start_delalloc_inodes()
9966 list_splice_tail(&splice, &root->delalloc_inodes); in start_delalloc_inodes()
9967 spin_unlock(&root->delalloc_lock); in start_delalloc_inodes()
9969 mutex_unlock(&root->delalloc_mutex); in start_delalloc_inodes()
9981 struct btrfs_fs_info *fs_info = root->fs_info; in btrfs_start_delalloc_snapshot()
9983 if (test_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state)) in btrfs_start_delalloc_snapshot()
9984 return -EROFS; in btrfs_start_delalloc_snapshot()
10002 if (test_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state)) in btrfs_start_delalloc_roots()
10003 return -EROFS; in btrfs_start_delalloc_roots()
10007 mutex_lock(&fs_info->delalloc_root_mutex); in btrfs_start_delalloc_roots()
10008 spin_lock(&fs_info->delalloc_root_lock); in btrfs_start_delalloc_roots()
10009 list_splice_init(&fs_info->delalloc_roots, &splice); in btrfs_start_delalloc_roots()
10022 list_move_tail(&root->delalloc_root, in btrfs_start_delalloc_roots()
10023 &fs_info->delalloc_roots); in btrfs_start_delalloc_roots()
10024 spin_unlock(&fs_info->delalloc_root_lock); in btrfs_start_delalloc_roots()
10030 spin_lock(&fs_info->delalloc_root_lock); in btrfs_start_delalloc_roots()
10032 spin_unlock(&fs_info->delalloc_root_lock); in btrfs_start_delalloc_roots()
10037 spin_lock(&fs_info->delalloc_root_lock); in btrfs_start_delalloc_roots()
10038 list_splice_tail(&splice, &fs_info->delalloc_roots); in btrfs_start_delalloc_roots()
10039 spin_unlock(&fs_info->delalloc_root_lock); in btrfs_start_delalloc_roots()
10041 mutex_unlock(&fs_info->delalloc_root_mutex); in btrfs_start_delalloc_roots()
10048 struct btrfs_fs_info *fs_info = btrfs_sb(dir->i_sb); in btrfs_symlink()
10050 struct btrfs_root *root = BTRFS_I(dir)->root; in btrfs_symlink()
10065 return -ENAMETOOLONG; in btrfs_symlink()
10083 dentry->d_name.name, dentry->d_name.len, in btrfs_symlink()
10098 inode->i_fop = &btrfs_file_operations; in btrfs_symlink()
10099 inode->i_op = &btrfs_file_inode_operations; in btrfs_symlink()
10100 inode->i_mapping->a_ops = &btrfs_aops; in btrfs_symlink()
10102 err = btrfs_init_inode_security(trans, inode, dir, &dentry->d_name); in btrfs_symlink()
10108 err = -ENOMEM; in btrfs_symlink()
10121 leaf = path->nodes[0]; in btrfs_symlink()
10122 ei = btrfs_item_ptr(leaf, path->slots[0], in btrfs_symlink()
10124 btrfs_set_file_extent_generation(leaf, ei, trans->transid); in btrfs_symlink()
10137 inode->i_op = &btrfs_symlink_inode_operations; in btrfs_symlink()
10175 u64 start = ins->objectid; in insert_prealloc_file_extent()
10176 u64 len = ins->offset; in insert_prealloc_file_extent()
10215 ret = -ENOMEM; in insert_prealloc_file_extent()
10220 file_offset + len - 1, &extent_info, in insert_prealloc_file_extent()
10235 btrfs_qgroup_free_refroot(inode->root->fs_info, in insert_prealloc_file_extent()
10236 inode->root->root_key.objectid, qgroup_released, in insert_prealloc_file_extent()
10246 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); in __btrfs_prealloc_file_range()
10247 struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree; in __btrfs_prealloc_file_range()
10249 struct btrfs_root *root = BTRFS_I(inode)->root; in __btrfs_prealloc_file_range()
10255 u64 last_alloc = (u64)-1; in __btrfs_prealloc_file_range()
10258 u64 end = start + num_bytes - 1; in __btrfs_prealloc_file_range()
10279 * ->bytes_may_use to ->bytes_reserved. Any error that happens in __btrfs_prealloc_file_range()
10304 cur_offset + ins.offset -1, 0); in __btrfs_prealloc_file_range()
10309 &BTRFS_I(inode)->runtime_flags); in __btrfs_prealloc_file_range()
10313 em->start = cur_offset; in __btrfs_prealloc_file_range()
10314 em->orig_start = cur_offset; in __btrfs_prealloc_file_range()
10315 em->len = ins.offset; in __btrfs_prealloc_file_range()
10316 em->block_start = ins.objectid; in __btrfs_prealloc_file_range()
10317 em->block_len = ins.offset; in __btrfs_prealloc_file_range()
10318 em->orig_block_len = ins.offset; in __btrfs_prealloc_file_range()
10319 em->ram_bytes = ins.offset; in __btrfs_prealloc_file_range()
10320 set_bit(EXTENT_FLAG_PREALLOC, &em->flags); in __btrfs_prealloc_file_range()
10321 em->generation = trans->transid; in __btrfs_prealloc_file_range()
10324 write_lock(&em_tree->lock); in __btrfs_prealloc_file_range()
10326 write_unlock(&em_tree->lock); in __btrfs_prealloc_file_range()
10327 if (ret != -EEXIST) in __btrfs_prealloc_file_range()
10330 cur_offset + ins.offset - 1, in __btrfs_prealloc_file_range()
10335 num_bytes -= ins.offset; in __btrfs_prealloc_file_range()
10340 inode->i_ctime = current_time(inode); in __btrfs_prealloc_file_range()
10341 BTRFS_I(inode)->flags |= BTRFS_INODE_PREALLOC; in __btrfs_prealloc_file_range()
10343 (actual_len > inode->i_size) && in __btrfs_prealloc_file_range()
10344 (cur_offset > inode->i_size)) { in __btrfs_prealloc_file_range()
10369 end - clear_offset + 1); in __btrfs_prealloc_file_range()
10399 struct btrfs_root *root = BTRFS_I(inode)->root; in btrfs_permission()
10400 umode_t mode = inode->i_mode; in btrfs_permission()
10405 return -EROFS; in btrfs_permission()
10406 if (BTRFS_I(inode)->flags & BTRFS_INODE_READONLY) in btrfs_permission()
10407 return -EACCES; in btrfs_permission()
10415 struct btrfs_fs_info *fs_info = btrfs_sb(dir->i_sb); in btrfs_tmpfile()
10417 struct btrfs_root *root = BTRFS_I(dir)->root; in btrfs_tmpfile()
10442 inode->i_fop = &btrfs_file_operations; in btrfs_tmpfile()
10443 inode->i_op = &btrfs_file_inode_operations; in btrfs_tmpfile()
10445 inode->i_mapping->a_ops = &btrfs_aops; in btrfs_tmpfile()
10463 * d_tmpfile() -> inode_dec_link_count() -> drop_nlink() in btrfs_tmpfile()
10479 struct btrfs_fs_info *fs_info = inode->root->fs_info; in btrfs_set_range_writeback()
10485 ASSERT(end + 1 - start <= U32_MAX); in btrfs_set_range_writeback()
10486 len = end + 1 - start; in btrfs_set_range_writeback()
10488 page = find_get_page(inode->vfs_inode.i_mapping, index); in btrfs_set_range_writeback()
10506 struct btrfs_fs_info *fs_info = BTRFS_I(inode)->root->fs_info; in btrfs_add_swapfile_pin()
10513 return -ENOMEM; in btrfs_add_swapfile_pin()
10514 sp->ptr = ptr; in btrfs_add_swapfile_pin()
10515 sp->inode = inode; in btrfs_add_swapfile_pin()
10516 sp->is_block_group = is_block_group; in btrfs_add_swapfile_pin()
10517 sp->bg_extent_count = 1; in btrfs_add_swapfile_pin()
10519 spin_lock(&fs_info->swapfile_pins_lock); in btrfs_add_swapfile_pin()
10520 p = &fs_info->swapfile_pins.rb_node; in btrfs_add_swapfile_pin()
10524 if (sp->ptr < entry->ptr || in btrfs_add_swapfile_pin()
10525 (sp->ptr == entry->ptr && sp->inode < entry->inode)) { in btrfs_add_swapfile_pin()
10526 p = &(*p)->rb_left; in btrfs_add_swapfile_pin()
10527 } else if (sp->ptr > entry->ptr || in btrfs_add_swapfile_pin()
10528 (sp->ptr == entry->ptr && sp->inode > entry->inode)) { in btrfs_add_swapfile_pin()
10529 p = &(*p)->rb_right; in btrfs_add_swapfile_pin()
10532 entry->bg_extent_count++; in btrfs_add_swapfile_pin()
10533 spin_unlock(&fs_info->swapfile_pins_lock); in btrfs_add_swapfile_pin()
10538 rb_link_node(&sp->node, parent, p); in btrfs_add_swapfile_pin()
10539 rb_insert_color(&sp->node, &fs_info->swapfile_pins); in btrfs_add_swapfile_pin()
10540 spin_unlock(&fs_info->swapfile_pins_lock); in btrfs_add_swapfile_pin()
10547 struct btrfs_fs_info *fs_info = BTRFS_I(inode)->root->fs_info; in btrfs_free_swapfile_pins()
10551 spin_lock(&fs_info->swapfile_pins_lock); in btrfs_free_swapfile_pins()
10552 node = rb_first(&fs_info->swapfile_pins); in btrfs_free_swapfile_pins()
10556 if (sp->inode == inode) { in btrfs_free_swapfile_pins()
10557 rb_erase(&sp->node, &fs_info->swapfile_pins); in btrfs_free_swapfile_pins()
10558 if (sp->is_block_group) { in btrfs_free_swapfile_pins()
10559 btrfs_dec_block_group_swap_extents(sp->ptr, in btrfs_free_swapfile_pins()
10560 sp->bg_extent_count); in btrfs_free_swapfile_pins()
10561 btrfs_put_block_group(sp->ptr); in btrfs_free_swapfile_pins()
10567 spin_unlock(&fs_info->swapfile_pins_lock); in btrfs_free_swapfile_pins()
10587 first_ppage = ALIGN(bsi->block_start, PAGE_SIZE) >> PAGE_SHIFT; in btrfs_add_swap_extent()
10588 next_ppage = ALIGN_DOWN(bsi->block_start + bsi->block_len, in btrfs_add_swap_extent()
10593 nr_pages = next_ppage - first_ppage; in btrfs_add_swap_extent()
10596 if (bsi->start == 0) in btrfs_add_swap_extent()
10598 if (bsi->lowest_ppage > first_ppage_reported) in btrfs_add_swap_extent()
10599 bsi->lowest_ppage = first_ppage_reported; in btrfs_add_swap_extent()
10600 if (bsi->highest_ppage < (next_ppage - 1)) in btrfs_add_swap_extent()
10601 bsi->highest_ppage = next_ppage - 1; in btrfs_add_swap_extent()
10603 ret = add_swap_extent(sis, bsi->nr_pages, nr_pages, first_ppage); in btrfs_add_swap_extent()
10606 bsi->nr_extents += ret; in btrfs_add_swap_extent()
10607 bsi->nr_pages += nr_pages; in btrfs_add_swap_extent()
10616 atomic_dec(&BTRFS_I(inode)->root->nr_swapfiles); in btrfs_swap_deactivate()
10623 struct btrfs_root *root = BTRFS_I(inode)->root; in btrfs_swap_activate()
10624 struct btrfs_fs_info *fs_info = root->fs_info; in btrfs_swap_activate()
10625 struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree; in btrfs_swap_activate()
10630 .lowest_ppage = (sector_t)-1ULL, in btrfs_swap_activate()
10641 ret = btrfs_wait_ordered_range(inode, 0, (u64)-1); in btrfs_swap_activate()
10648 if (BTRFS_I(inode)->flags & BTRFS_INODE_COMPRESS) { in btrfs_swap_activate()
10650 return -EINVAL; in btrfs_swap_activate()
10652 if (!(BTRFS_I(inode)->flags & BTRFS_INODE_NODATACOW)) { in btrfs_swap_activate()
10653 btrfs_warn(fs_info, "swapfile must not be copy-on-write"); in btrfs_swap_activate()
10654 return -EINVAL; in btrfs_swap_activate()
10656 if (!(BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM)) { in btrfs_swap_activate()
10658 return -EINVAL; in btrfs_swap_activate()
10665 * fs_info->swapfile_pins prevents them from running while the swap in btrfs_swap_activate()
10673 return -EBUSY; in btrfs_swap_activate()
10683 if (!btrfs_drew_try_write_lock(&root->snapshot_lock)) { in btrfs_swap_activate()
10687 return -EINVAL; in btrfs_swap_activate()
10695 atomic_inc(&root->nr_swapfiles); in btrfs_swap_activate()
10697 isize = ALIGN_DOWN(inode->i_size, fs_info->sectorsize); in btrfs_swap_activate()
10699 lock_extent_bits(io_tree, 0, isize - 1, &cached_state); in btrfs_swap_activate()
10704 u64 len = isize - start; in btrfs_swap_activate()
10712 if (em->block_start == EXTENT_MAP_HOLE) { in btrfs_swap_activate()
10714 ret = -EINVAL; in btrfs_swap_activate()
10717 if (em->block_start == EXTENT_MAP_INLINE) { in btrfs_swap_activate()
10726 ret = -EINVAL; in btrfs_swap_activate()
10729 if (test_bit(EXTENT_FLAG_COMPRESSED, &em->flags)) { in btrfs_swap_activate()
10731 ret = -EINVAL; in btrfs_swap_activate()
10735 logical_block_start = em->block_start + (start - em->start); in btrfs_swap_activate()
10736 len = min(len, em->len - (start - em->start)); in btrfs_swap_activate()
10747 "swapfile must not be copy-on-write"); in btrfs_swap_activate()
10748 ret = -EINVAL; in btrfs_swap_activate()
10758 if (em->map_lookup->type & BTRFS_BLOCK_GROUP_PROFILE_MASK) { in btrfs_swap_activate()
10761 ret = -EINVAL; in btrfs_swap_activate()
10766 device = em->map_lookup->stripes[0].dev; in btrfs_swap_activate()
10772 } else if (device != em->map_lookup->stripes[0].dev) { in btrfs_swap_activate()
10774 ret = -EINVAL; in btrfs_swap_activate()
10778 physical_block_start = (em->map_lookup->stripes[0].physical + in btrfs_swap_activate()
10779 (logical_block_start - em->start)); in btrfs_swap_activate()
10780 len = min(len, em->len - (logical_block_start - em->start)); in btrfs_swap_activate()
10788 ret = -EINVAL; in btrfs_swap_activate()
10794 "block group for swapfile at %llu is read-only%s", in btrfs_swap_activate()
10795 bg->start, in btrfs_swap_activate()
10796 atomic_read(&fs_info->scrubs_running) ? in btrfs_swap_activate()
10799 ret = -EINVAL; in btrfs_swap_activate()
10836 unlock_extent_cached(io_tree, 0, isize - 1, &cached_state); in btrfs_swap_activate()
10841 btrfs_drew_write_unlock(&root->snapshot_lock); in btrfs_swap_activate()
10849 sis->bdev = device->bdev; in btrfs_swap_activate()
10850 *span = bsi.highest_ppage - bsi.lowest_ppage + 1; in btrfs_swap_activate()
10851 sis->max = bsi.nr_pages; in btrfs_swap_activate()
10852 sis->pages = bsi.nr_pages - 1; in btrfs_swap_activate()
10853 sis->highest_bit = bsi.nr_pages - 1; in btrfs_swap_activate()
10864 return -EOPNOTSUPP; in btrfs_swap_activate()
10881 spin_lock(&inode->lock); in btrfs_update_inode_bytes()
10883 inode_sub_bytes(&inode->vfs_inode, del_bytes); in btrfs_update_inode_bytes()
10885 inode_add_bytes(&inode->vfs_inode, add_bytes); in btrfs_update_inode_bytes()
10886 spin_unlock(&inode->lock); in btrfs_update_inode_bytes()