Lines Matching +full:foo +full:- +full:queue
1 // SPDX-License-Identifier: GPL-2.0
9 #include <linux/blk-cgroup.h>
17 #include <linux/backing-dev.h>
39 #include "disk-io.h"
42 #include "print-tree.h"
43 #include "ordered-data.h"
45 #include "tree-log.h"
49 #include "free-space-cache.h"
52 #include "delalloc-space.h"
53 #include "block-group.h"
54 #include "space-info.h"
57 #include "inode-item.h"
83 * References to this structure. There is one reference per in-flight
129 * btrfs_inode_lock - lock inode i_rwsem based on arguments passed
133 * BTRFS_ILOCK_SHARED - acquire a shared lock on the inode
134 * BTRFS_ILOCK_TRY - try to acquire the lock, if fails on first attempt
135 * return -EAGAIN
136 * BTRFS_ILOCK_MMAP - acquire a write lock on the i_mmap_lock
143 return -EAGAIN; in btrfs_inode_lock()
151 return -EAGAIN; in btrfs_inode_lock()
158 down_write(&BTRFS_I(inode)->i_mmap_lock); in btrfs_inode_lock()
163 * btrfs_inode_unlock - unock inode i_rwsem
171 up_write(&BTRFS_I(inode)->i_mmap_lock); in btrfs_inode_unlock()
193 unsigned long end_index = (offset + bytes - 1) >> PAGE_SHIFT; in btrfs_cleanup_ordered_extents()
199 page_end = page_start + PAGE_SIZE - 1; in btrfs_cleanup_ordered_extents()
218 page = find_get_page(inode->vfs_inode.i_mapping, index); in btrfs_cleanup_ordered_extents()
228 btrfs_page_clamp_clear_ordered(inode->root->fs_info, page, in btrfs_cleanup_ordered_extents()
243 if (page_start >= offset && page_end <= (offset + bytes - 1)) { in btrfs_cleanup_ordered_extents()
244 bytes = offset + bytes - page_offset(locked_page) - PAGE_SIZE; in btrfs_cleanup_ordered_extents()
259 if (args->default_acl) { in btrfs_init_inode_security()
260 err = __btrfs_set_acl(trans, args->inode, args->default_acl, in btrfs_init_inode_security()
265 if (args->acl) { in btrfs_init_inode_security()
266 err = __btrfs_set_acl(trans, args->inode, args->acl, ACL_TYPE_ACCESS); in btrfs_init_inode_security()
270 if (!args->default_acl && !args->acl) in btrfs_init_inode_security()
271 cache_no_acl(args->inode); in btrfs_init_inode_security()
272 return btrfs_xattr_security_init(trans, args->inode, args->dir, in btrfs_init_inode_security()
273 &args->dentry->d_name); in btrfs_init_inode_security()
289 struct btrfs_root *root = inode->root; in insert_inline_extent()
319 leaf = path->nodes[0]; in insert_inline_extent()
320 ei = btrfs_item_ptr(leaf, path->slots[0], in insert_inline_extent()
322 btrfs_set_file_extent_generation(leaf, ei, trans->transid); in insert_inline_extent()
343 compressed_size -= cur_size; in insert_inline_extent()
348 page = find_get_page(inode->vfs_inode.i_mapping, 0); in insert_inline_extent()
363 ALIGN(size, root->fs_info->sectorsize)); in insert_inline_extent()
374 i_size = i_size_read(&inode->vfs_inode); in insert_inline_extent()
376 i_size_write(&inode->vfs_inode, size); in insert_inline_extent()
379 inode->disk_i_size = i_size; in insert_inline_extent()
398 struct btrfs_root *root = inode->root; in cow_file_range_inline()
399 struct btrfs_fs_info *fs_info = root->fs_info; in cow_file_range_inline()
411 if (size < i_size_read(&inode->vfs_inode) || in cow_file_range_inline()
412 size > fs_info->sectorsize || in cow_file_range_inline()
414 data_len > fs_info->max_inline) in cow_file_range_inline()
419 return -ENOMEM; in cow_file_range_inline()
426 trans->block_rsv = &inode->block_rsv; in cow_file_range_inline()
430 drop_args.end = fs_info->sectorsize; in cow_file_range_inline()
443 if (ret && ret != -ENOSPC) { in cow_file_range_inline()
446 } else if (ret == -ENOSPC) { in cow_file_range_inline()
453 if (ret && ret != -ENOSPC) { in cow_file_range_inline()
456 } else if (ret == -ENOSPC) { in cow_file_range_inline()
512 BUG_ON(!async_extent); /* -ENOMEM */ in add_async_extent()
513 async_extent->start = start; in add_async_extent()
514 async_extent->ram_size = ram_size; in add_async_extent()
515 async_extent->compressed_size = compressed_size; in add_async_extent()
516 async_extent->pages = pages; in add_async_extent()
517 async_extent->nr_pages = nr_pages; in add_async_extent()
518 async_extent->compress_type = compress_type; in add_async_extent()
519 list_add_tail(&async_extent->list, &cow->extents); in add_async_extent()
530 struct btrfs_fs_info *fs_info = inode->root->fs_info; in inode_need_compress()
546 * \- A \- B in inode_need_compress()
564 if (fs_info->sectorsize < PAGE_SIZE) { in inode_need_compress()
574 if (inode->defrag_compress) in inode_need_compress()
577 if (inode->flags & BTRFS_INODE_NOCOMPRESS) in inode_need_compress()
580 inode->flags & BTRFS_INODE_COMPRESS || in inode_need_compress()
581 inode->prop_compress) in inode_need_compress()
582 return btrfs_compress_heuristic(&inode->vfs_inode, start, end); in inode_need_compress()
591 (start > 0 || end + 1 < inode->disk_i_size)) in inode_should_defrag()
600 * This is done inside an ordered work queue, and the compression
602 * two, and the ordered work queue takes care of making sure that
603 * happens in the same order things were put onto the queue by
607 * entry onto the work queue to write the uncompressed bytes. This
614 struct inode *inode = async_chunk->inode; in compress_file_range()
615 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); in compress_file_range()
616 u64 blocksize = fs_info->sectorsize; in compress_file_range()
617 u64 start = async_chunk->start; in compress_file_range()
618 u64 end = async_chunk->end; in compress_file_range()
628 int compress_type = fs_info->compress_type; in compress_file_range()
632 inode_should_defrag(BTRFS_I(inode), start, end, end - start + 1, in compress_file_range()
650 nr_pages = (end >> PAGE_SHIFT) - (start >> PAGE_SHIFT) + 1; in compress_file_range()
667 total_compressed = actual_end - start; in compress_file_range()
674 (start > 0 || end + 1 < BTRFS_I(inode)->disk_i_size)) in compress_file_range()
694 * we do compression for mount -o compress and when the in compress_file_range()
707 if (BTRFS_I(inode)->defrag_compress) in compress_file_range()
708 compress_type = BTRFS_I(inode)->defrag_compress; in compress_file_range()
709 else if (BTRFS_I(inode)->prop_compress) in compress_file_range()
710 compress_type = BTRFS_I(inode)->prop_compress; in compress_file_range()
731 compress_type | (fs_info->compress_level << 4), in compress_file_range()
732 inode->i_mapping, start, in compress_file_range()
740 struct page *page = pages[nr_pages - 1]; in compress_file_range()
746 memzero_page(page, offset, PAGE_SIZE - offset); in compress_file_range()
755 if (start == 0 && fs_info->sectorsize == PAGE_SIZE) { in compress_file_range()
804 WARN_ON(pages[i]->mapping); in compress_file_range()
826 total_in = round_up(total_in, fs_info->sectorsize); in compress_file_range()
854 WARN_ON(pages[i]->mapping); in compress_file_range()
864 !(BTRFS_I(inode)->prop_compress)) { in compress_file_range()
865 BTRFS_I(inode)->flags |= BTRFS_INODE_NOCOMPRESS; in compress_file_range()
872 * to our extent and set things up for the async work queue to run in compress_file_range()
875 if (async_chunk->locked_page && in compress_file_range()
876 (page_offset(async_chunk->locked_page) >= start && in compress_file_range()
877 page_offset(async_chunk->locked_page)) <= end) { in compress_file_range()
878 __set_page_dirty_nobuffers(async_chunk->locked_page); in compress_file_range()
884 add_async_extent(async_chunk, start, end - start + 1, 0, NULL, 0, in compress_file_range()
895 if (!async_extent->pages) in free_async_extent_pages()
898 for (i = 0; i < async_extent->nr_pages; i++) { in free_async_extent_pages()
899 WARN_ON(async_extent->pages[i]->mapping); in free_async_extent_pages()
900 put_page(async_extent->pages[i]); in free_async_extent_pages()
902 kfree(async_extent->pages); in free_async_extent_pages()
903 async_extent->nr_pages = 0; in free_async_extent_pages()
904 async_extent->pages = NULL; in free_async_extent_pages()
911 u64 start = async_extent->start; in submit_uncompressed_range()
912 u64 end = async_extent->start + async_extent->ram_size - 1; in submit_uncompressed_range()
932 btrfs_cleanup_ordered_extents(inode, locked_page, start, end - start + 1); in submit_uncompressed_range()
935 const u64 page_end = page_start + PAGE_SIZE - 1; in submit_uncompressed_range()
937 btrfs_page_set_error(inode->root->fs_info, locked_page, in submit_uncompressed_range()
947 ret = extent_write_locked_range(&inode->vfs_inode, start, end); in submit_uncompressed_range()
959 struct extent_io_tree *io_tree = &inode->io_tree; in submit_one_async_extent()
960 struct btrfs_root *root = inode->root; in submit_one_async_extent()
961 struct btrfs_fs_info *fs_info = root->fs_info; in submit_one_async_extent()
966 u64 start = async_extent->start; in submit_one_async_extent()
967 u64 end = async_extent->start + async_extent->ram_size - 1; in submit_one_async_extent()
970 * If async_chunk->locked_page is in the async_extent range, we need to in submit_one_async_extent()
973 if (async_chunk->locked_page) { in submit_one_async_extent()
974 u64 locked_page_start = page_offset(async_chunk->locked_page); in submit_one_async_extent()
975 u64 locked_page_end = locked_page_start + PAGE_SIZE - 1; in submit_one_async_extent()
978 locked_page = async_chunk->locked_page; in submit_one_async_extent()
983 if (!async_extent->pages) in submit_one_async_extent()
986 ret = btrfs_reserve_extent(root, async_extent->ram_size, in submit_one_async_extent()
987 async_extent->compressed_size, in submit_one_async_extent()
988 async_extent->compressed_size, in submit_one_async_extent()
993 * Here we used to try again by going back to non-compressed in submit_one_async_extent()
1004 async_extent->ram_size, /* len */ in submit_one_async_extent()
1009 async_extent->ram_size, /* ram_bytes */ in submit_one_async_extent()
1010 async_extent->compress_type, in submit_one_async_extent()
1019 async_extent->ram_size, /* num_bytes */ in submit_one_async_extent()
1020 async_extent->ram_size, /* ram_bytes */ in submit_one_async_extent()
1025 async_extent->compress_type); in submit_one_async_extent()
1037 async_extent->ram_size, /* num_bytes */ in submit_one_async_extent()
1040 async_extent->pages, /* compressed_pages */ in submit_one_async_extent()
1041 async_extent->nr_pages, in submit_one_async_extent()
1042 async_chunk->write_flags, in submit_one_async_extent()
1043 async_chunk->blkcg_css, true)) { in submit_one_async_extent()
1044 const u64 start = async_extent->start; in submit_one_async_extent()
1045 const u64 end = start + async_extent->ram_size - 1; in submit_one_async_extent()
1079 struct btrfs_inode *inode = BTRFS_I(async_chunk->inode); in submit_compressed_extents()
1080 struct btrfs_fs_info *fs_info = inode->root->fs_info; in submit_compressed_extents()
1085 while (!list_empty(&async_chunk->extents)) { in submit_compressed_extents()
1089 async_extent = list_entry(async_chunk->extents.next, in submit_compressed_extents()
1091 list_del(&async_extent->list); in submit_compressed_extents()
1092 extent_start = async_extent->start; in submit_compressed_extents()
1093 ram_size = async_extent->ram_size; in submit_compressed_extents()
1099 inode->root->root_key.objectid, in submit_compressed_extents()
1107 struct extent_map_tree *em_tree = &inode->extent_tree; in get_extent_allocation_hint()
1111 read_lock(&em_tree->lock); in get_extent_allocation_hint()
1119 if (em->block_start >= EXTENT_MAP_LAST_BYTE) { in get_extent_allocation_hint()
1122 if (em && em->block_start < EXTENT_MAP_LAST_BYTE) in get_extent_allocation_hint()
1123 alloc_hint = em->block_start; in get_extent_allocation_hint()
1127 alloc_hint = em->block_start; in get_extent_allocation_hint()
1131 read_unlock(&em_tree->lock); in get_extent_allocation_hint()
1156 * - page_started == 1 (return value)
1157 * - All the pages are unlocked. IO is started.
1158 * - Note that this can happen only on success
1159 * - unlock == 1
1160 * - All the pages except @locked_page are unlocked in any case
1161 * - unlock == 0
1162 * - On success, all the pages are locked for writing out them
1163 * - On failure, all the pages except @locked_page are unlocked
1166 * while-loop, the ordered extents created in previous iterations are kept
1177 struct btrfs_root *root = inode->root; in cow_file_range()
1178 struct btrfs_fs_info *fs_info = root->fs_info; in cow_file_range()
1185 u64 blocksize = fs_info->sectorsize; in cow_file_range()
1194 ret = -EINVAL; in cow_file_range()
1198 num_bytes = ALIGN(end - start + 1, blocksize); in cow_file_range()
1200 ASSERT(num_bytes <= btrfs_super_total_bytes(fs_info->super_copy)); in cow_file_range()
1214 if (start == 0 && fs_info->sectorsize == PAGE_SIZE) { in cow_file_range()
1215 u64 actual_end = min_t(u64, i_size_read(&inode->vfs_inode), in cow_file_range()
1235 (end - start + PAGE_SIZE) / PAGE_SIZE; in cow_file_range()
1272 min_alloc_size = fs_info->sectorsize; in cow_file_range()
1322 start + ram_size - 1, in cow_file_range()
1339 extent_clear_unlock_delalloc(inode, start, start + ram_size - 1, in cow_file_range()
1346 num_bytes -= cur_alloc_size; in cow_file_range()
1363 btrfs_drop_extent_map_range(inode, start, start + ram_size - 1, false); in cow_file_range()
1369 * If done_offset is non-NULL and ret == -EAGAIN, we expect the in cow_file_range()
1372 if (done_offset && ret == -EAGAIN) { in cow_file_range()
1374 *done_offset = start - 1; in cow_file_range()
1378 } else if (ret == -EAGAIN) { in cow_file_range()
1379 /* Convert to -ENOSPC since the caller cannot retry. */ in cow_file_range()
1380 ret = -ENOSPC; in cow_file_range()
1386 * |-------(1)----|---(2)---|-------------(3)----------| in cow_file_range()
1387 * `- orig_start `- start `- start + cur_alloc_size `- end in cow_file_range()
1410 mapping_set_error(inode->vfs_inode.i_mapping, ret); in cow_file_range()
1411 extent_clear_unlock_delalloc(inode, orig_start, start - 1, in cow_file_range()
1427 start + cur_alloc_size - 1, in cow_file_range()
1449 * work queue call back to started compression on a file and pages
1460 btrfs_add_delayed_iput(async_chunk->inode); in async_cow_start()
1461 async_chunk->inode = NULL; in async_cow_start()
1466 * work queue call back to submit previously compressed pages
1475 nr_pages = (async_chunk->end - async_chunk->start + PAGE_SIZE) >> in async_cow_submit()
1479 * ->inode could be NULL if async_chunk_start has failed to compress, in async_cow_submit()
1481 * always adjust ->async_delalloc_pages as its paired with the init in async_cow_submit()
1484 if (async_chunk->inode) in async_cow_submit()
1488 if (atomic_sub_return(nr_pages, &fs_info->async_delalloc_pages) < in async_cow_submit()
1490 cond_wake_up_nomb(&fs_info->async_submit_wait); in async_cow_submit()
1499 if (async_chunk->inode) in async_cow_free()
1500 btrfs_add_delayed_iput(async_chunk->inode); in async_cow_free()
1501 if (async_chunk->blkcg_css) in async_cow_free()
1502 css_put(async_chunk->blkcg_css); in async_cow_free()
1504 async_cow = async_chunk->async_cow; in async_cow_free()
1505 if (atomic_dec_and_test(&async_cow->num_chunks)) in async_cow_free()
1515 struct btrfs_fs_info *fs_info = inode->root->fs_info; in cow_file_range_async()
1521 u64 num_chunks = DIV_ROUND_UP(end - start, SZ_512K); in cow_file_range_async()
1527 unlock_extent(&inode->io_tree, start, end, NULL); in cow_file_range_async()
1529 if (inode->flags & BTRFS_INODE_NOCOMPRESS && in cow_file_range_async()
1550 return -ENOMEM; in cow_file_range_async()
1553 async_chunk = ctx->chunks; in cow_file_range_async()
1554 atomic_set(&ctx->num_chunks, num_chunks); in cow_file_range_async()
1558 cur_end = min(end, start + SZ_512K - 1); in cow_file_range_async()
1566 ihold(&inode->vfs_inode); in cow_file_range_async()
1568 async_chunk[i].inode = &inode->vfs_inode; in cow_file_range_async()
1594 cur_end - start); in cow_file_range_async()
1611 nr_pages = DIV_ROUND_UP(cur_end - start, PAGE_SIZE); in cow_file_range_async()
1612 atomic_add(nr_pages, &fs_info->async_delalloc_pages); in cow_file_range_async()
1614 btrfs_queue_work(fs_info->delalloc_workers, &async_chunk[i].work); in cow_file_range_async()
1635 if (ret && ret != -EAGAIN) in run_delalloc_zoned()
1647 wait_on_bit_io(&inode->root->fs_info->flags, in run_delalloc_zoned()
1658 extent_write_locked_range(&inode->vfs_inode, start, done_offset); in run_delalloc_zoned()
1677 bytenr + num_bytes - 1, &list, 0, in csum_exist_in_range()
1684 list_del(&sums->list); in csum_exist_in_range()
1697 const bool is_reloc_ino = btrfs_is_data_reloc_root(inode->root); in fallback_to_cow()
1698 const u64 range_bytes = end + 1 - start; in fallback_to_cow()
1699 struct extent_io_tree *io_tree = &inode->io_tree; in fallback_to_cow()
1739 struct btrfs_fs_info *fs_info = inode->root->fs_info; in fallback_to_cow()
1740 struct btrfs_space_info *sinfo = fs_info->data_sinfo; in fallback_to_cow()
1745 spin_lock(&sinfo->lock); in fallback_to_cow()
1747 spin_unlock(&sinfo->lock); in fallback_to_cow()
1785 * if path->nodes[0] is NULL or not if it needs to use the path afterwards.
1797 struct extent_buffer *leaf = path->nodes[0]; in can_nocow_file_extent()
1798 struct btrfs_root *root = inode->root; in can_nocow_file_extent()
1804 bool nowait = path->nowait; in can_nocow_file_extent()
1806 fi = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_file_extent_item); in can_nocow_file_extent()
1813 args->disk_bytenr = btrfs_file_extent_disk_bytenr(leaf, fi); in can_nocow_file_extent()
1814 args->disk_num_bytes = btrfs_file_extent_disk_num_bytes(leaf, fi); in can_nocow_file_extent()
1815 args->extent_offset = btrfs_file_extent_offset(leaf, fi); in can_nocow_file_extent()
1817 if (!(inode->flags & BTRFS_INODE_NODATACOW) && in can_nocow_file_extent()
1826 if (!args->strict && in can_nocow_file_extent()
1828 btrfs_root_last_snapshot(&root->root_item)) in can_nocow_file_extent()
1832 if (args->disk_bytenr == 0) in can_nocow_file_extent()
1851 key->offset - args->extent_offset, in can_nocow_file_extent()
1852 args->disk_bytenr, false, path); in can_nocow_file_extent()
1857 if (args->free_path) { in can_nocow_file_extent()
1869 if (args->writeback_path && !is_freespace_inode && in can_nocow_file_extent()
1870 atomic_read(&root->snapshot_force_cow)) in can_nocow_file_extent()
1873 args->disk_bytenr += args->extent_offset; in can_nocow_file_extent()
1874 args->disk_bytenr += args->start - key->offset; in can_nocow_file_extent()
1875 args->num_bytes = min(args->end + 1, extent_end) - args->start; in can_nocow_file_extent()
1881 ret = csum_exist_in_range(root->fs_info, args->disk_bytenr, args->num_bytes, in can_nocow_file_extent()
1889 if (args->free_path && path) in can_nocow_file_extent()
1908 struct btrfs_fs_info *fs_info = inode->root->fs_info; in run_delalloc_nocow()
1909 struct btrfs_root *root = inode->root; in run_delalloc_nocow()
1911 u64 cow_start = (u64)-1; in run_delalloc_nocow()
1928 return -ENOMEM; in run_delalloc_nocow()
1955 if (ret > 0 && path->slots[0] > 0 && check_prev) { in run_delalloc_nocow()
1956 leaf = path->nodes[0]; in run_delalloc_nocow()
1958 path->slots[0] - 1); in run_delalloc_nocow()
1961 path->slots[0]--; in run_delalloc_nocow()
1966 leaf = path->nodes[0]; in run_delalloc_nocow()
1967 if (path->slots[0] >= btrfs_header_nritems(leaf)) { in run_delalloc_nocow()
1970 if (cow_start != (u64)-1) in run_delalloc_nocow()
1976 leaf = path->nodes[0]; in run_delalloc_nocow()
1979 btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]); in run_delalloc_nocow()
1990 path->slots[0]++; in run_delalloc_nocow()
2013 fi = btrfs_item_ptr(leaf, path->slots[0], in run_delalloc_nocow()
2019 ret = -EUCLEAN; in run_delalloc_nocow()
2030 path->slots[0]++; in run_delalloc_nocow()
2037 if (cow_start != (u64)-1) in run_delalloc_nocow()
2054 if (cow_start == (u64)-1) in run_delalloc_nocow()
2059 if (!path->nodes[0]) in run_delalloc_nocow()
2061 path->slots[0]++; in run_delalloc_nocow()
2066 * COW range from cow_start to found_key.offset - 1. As the key in run_delalloc_nocow()
2070 if (cow_start != (u64)-1) { in run_delalloc_nocow()
2072 cow_start, found_key.offset - 1, in run_delalloc_nocow()
2076 cow_start = (u64)-1; in run_delalloc_nocow()
2079 nocow_end = cur_offset + nocow_args.num_bytes - 1; in run_delalloc_nocow()
2082 u64 orig_start = found_key.offset - nocow_args.extent_offset; in run_delalloc_nocow()
2156 if (cur_offset <= end && cow_start == (u64)-1) in run_delalloc_nocow()
2159 if (cow_start != (u64)-1) { in run_delalloc_nocow()
2184 if (inode->flags & (BTRFS_INODE_NODATACOW | BTRFS_INODE_PREALLOC)) { in should_nocow()
2185 if (inode->defrag_bytes && in should_nocow()
2186 test_range_bit(&inode->io_tree, start, end, EXTENT_DEFRAG, in should_nocow()
2203 const bool zoned = btrfs_is_zoned(inode->root->fs_info); in btrfs_run_delalloc_range()
2220 ASSERT(!zoned || btrfs_is_data_reloc_root(inode->root)); in btrfs_run_delalloc_range()
2232 set_bit(BTRFS_INODE_HAS_ASYNC_EXTENT, &inode->runtime_flags); in btrfs_run_delalloc_range()
2239 end - start + 1); in btrfs_run_delalloc_range()
2246 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); in btrfs_split_delalloc_extent()
2250 if (!(orig->state & EXTENT_DELALLOC)) in btrfs_split_delalloc_extent()
2253 size = orig->end - orig->start + 1; in btrfs_split_delalloc_extent()
2254 if (size > fs_info->max_extent_size) { in btrfs_split_delalloc_extent()
2262 new_size = orig->end - split + 1; in btrfs_split_delalloc_extent()
2264 new_size = split - orig->start; in btrfs_split_delalloc_extent()
2270 spin_lock(&BTRFS_I(inode)->lock); in btrfs_split_delalloc_extent()
2272 spin_unlock(&BTRFS_I(inode)->lock); in btrfs_split_delalloc_extent()
2283 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); in btrfs_merge_delalloc_extent()
2288 if (!(other->state & EXTENT_DELALLOC)) in btrfs_merge_delalloc_extent()
2291 if (new->start > other->start) in btrfs_merge_delalloc_extent()
2292 new_size = new->end - other->start + 1; in btrfs_merge_delalloc_extent()
2294 new_size = other->end - new->start + 1; in btrfs_merge_delalloc_extent()
2297 if (new_size <= fs_info->max_extent_size) { in btrfs_merge_delalloc_extent()
2298 spin_lock(&BTRFS_I(inode)->lock); in btrfs_merge_delalloc_extent()
2299 btrfs_mod_outstanding_extents(BTRFS_I(inode), -1); in btrfs_merge_delalloc_extent()
2300 spin_unlock(&BTRFS_I(inode)->lock); in btrfs_merge_delalloc_extent()
2322 old_size = other->end - other->start + 1; in btrfs_merge_delalloc_extent()
2324 old_size = new->end - new->start + 1; in btrfs_merge_delalloc_extent()
2329 spin_lock(&BTRFS_I(inode)->lock); in btrfs_merge_delalloc_extent()
2330 btrfs_mod_outstanding_extents(BTRFS_I(inode), -1); in btrfs_merge_delalloc_extent()
2331 spin_unlock(&BTRFS_I(inode)->lock); in btrfs_merge_delalloc_extent()
2337 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); in btrfs_add_delalloc_inodes()
2339 spin_lock(&root->delalloc_lock); in btrfs_add_delalloc_inodes()
2340 if (list_empty(&BTRFS_I(inode)->delalloc_inodes)) { in btrfs_add_delalloc_inodes()
2341 list_add_tail(&BTRFS_I(inode)->delalloc_inodes, in btrfs_add_delalloc_inodes()
2342 &root->delalloc_inodes); in btrfs_add_delalloc_inodes()
2344 &BTRFS_I(inode)->runtime_flags); in btrfs_add_delalloc_inodes()
2345 root->nr_delalloc_inodes++; in btrfs_add_delalloc_inodes()
2346 if (root->nr_delalloc_inodes == 1) { in btrfs_add_delalloc_inodes()
2347 spin_lock(&fs_info->delalloc_root_lock); in btrfs_add_delalloc_inodes()
2348 BUG_ON(!list_empty(&root->delalloc_root)); in btrfs_add_delalloc_inodes()
2349 list_add_tail(&root->delalloc_root, in btrfs_add_delalloc_inodes()
2350 &fs_info->delalloc_roots); in btrfs_add_delalloc_inodes()
2351 spin_unlock(&fs_info->delalloc_root_lock); in btrfs_add_delalloc_inodes()
2354 spin_unlock(&root->delalloc_lock); in btrfs_add_delalloc_inodes()
2361 struct btrfs_fs_info *fs_info = root->fs_info; in __btrfs_del_delalloc_inode()
2363 if (!list_empty(&inode->delalloc_inodes)) { in __btrfs_del_delalloc_inode()
2364 list_del_init(&inode->delalloc_inodes); in __btrfs_del_delalloc_inode()
2366 &inode->runtime_flags); in __btrfs_del_delalloc_inode()
2367 root->nr_delalloc_inodes--; in __btrfs_del_delalloc_inode()
2368 if (!root->nr_delalloc_inodes) { in __btrfs_del_delalloc_inode()
2369 ASSERT(list_empty(&root->delalloc_inodes)); in __btrfs_del_delalloc_inode()
2370 spin_lock(&fs_info->delalloc_root_lock); in __btrfs_del_delalloc_inode()
2371 BUG_ON(list_empty(&root->delalloc_root)); in __btrfs_del_delalloc_inode()
2372 list_del_init(&root->delalloc_root); in __btrfs_del_delalloc_inode()
2373 spin_unlock(&fs_info->delalloc_root_lock); in __btrfs_del_delalloc_inode()
2381 spin_lock(&root->delalloc_lock); in btrfs_del_delalloc_inode()
2383 spin_unlock(&root->delalloc_lock); in btrfs_del_delalloc_inode()
2393 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); in btrfs_set_delalloc_extent()
2402 if (!(state->state & EXTENT_DELALLOC) && (bits & EXTENT_DELALLOC)) { in btrfs_set_delalloc_extent()
2403 struct btrfs_root *root = BTRFS_I(inode)->root; in btrfs_set_delalloc_extent()
2404 u64 len = state->end + 1 - state->start; in btrfs_set_delalloc_extent()
2408 spin_lock(&BTRFS_I(inode)->lock); in btrfs_set_delalloc_extent()
2410 spin_unlock(&BTRFS_I(inode)->lock); in btrfs_set_delalloc_extent()
2416 percpu_counter_add_batch(&fs_info->delalloc_bytes, len, in btrfs_set_delalloc_extent()
2417 fs_info->delalloc_batch); in btrfs_set_delalloc_extent()
2418 spin_lock(&BTRFS_I(inode)->lock); in btrfs_set_delalloc_extent()
2419 BTRFS_I(inode)->delalloc_bytes += len; in btrfs_set_delalloc_extent()
2421 BTRFS_I(inode)->defrag_bytes += len; in btrfs_set_delalloc_extent()
2423 &BTRFS_I(inode)->runtime_flags)) in btrfs_set_delalloc_extent()
2425 spin_unlock(&BTRFS_I(inode)->lock); in btrfs_set_delalloc_extent()
2428 if (!(state->state & EXTENT_DELALLOC_NEW) && in btrfs_set_delalloc_extent()
2430 spin_lock(&BTRFS_I(inode)->lock); in btrfs_set_delalloc_extent()
2431 BTRFS_I(inode)->new_delalloc_bytes += state->end + 1 - in btrfs_set_delalloc_extent()
2432 state->start; in btrfs_set_delalloc_extent()
2433 spin_unlock(&BTRFS_I(inode)->lock); in btrfs_set_delalloc_extent()
2445 struct btrfs_fs_info *fs_info = btrfs_sb(vfs_inode->i_sb); in btrfs_clear_delalloc_extent()
2446 u64 len = state->end + 1 - state->start; in btrfs_clear_delalloc_extent()
2449 if ((state->state & EXTENT_DEFRAG) && (bits & EXTENT_DEFRAG)) { in btrfs_clear_delalloc_extent()
2450 spin_lock(&inode->lock); in btrfs_clear_delalloc_extent()
2451 inode->defrag_bytes -= len; in btrfs_clear_delalloc_extent()
2452 spin_unlock(&inode->lock); in btrfs_clear_delalloc_extent()
2460 if ((state->state & EXTENT_DELALLOC) && (bits & EXTENT_DELALLOC)) { in btrfs_clear_delalloc_extent()
2461 struct btrfs_root *root = inode->root; in btrfs_clear_delalloc_extent()
2464 spin_lock(&inode->lock); in btrfs_clear_delalloc_extent()
2465 btrfs_mod_outstanding_extents(inode, -num_extents); in btrfs_clear_delalloc_extent()
2466 spin_unlock(&inode->lock); in btrfs_clear_delalloc_extent()
2474 root != fs_info->tree_root) in btrfs_clear_delalloc_extent()
2482 do_list && !(state->state & EXTENT_NORESERVE) && in btrfs_clear_delalloc_extent()
2486 percpu_counter_add_batch(&fs_info->delalloc_bytes, -len, in btrfs_clear_delalloc_extent()
2487 fs_info->delalloc_batch); in btrfs_clear_delalloc_extent()
2488 spin_lock(&inode->lock); in btrfs_clear_delalloc_extent()
2489 inode->delalloc_bytes -= len; in btrfs_clear_delalloc_extent()
2490 if (do_list && inode->delalloc_bytes == 0 && in btrfs_clear_delalloc_extent()
2492 &inode->runtime_flags)) in btrfs_clear_delalloc_extent()
2494 spin_unlock(&inode->lock); in btrfs_clear_delalloc_extent()
2497 if ((state->state & EXTENT_DELALLOC_NEW) && in btrfs_clear_delalloc_extent()
2499 spin_lock(&inode->lock); in btrfs_clear_delalloc_extent()
2500 ASSERT(inode->new_delalloc_bytes >= len); in btrfs_clear_delalloc_extent()
2501 inode->new_delalloc_bytes -= len; in btrfs_clear_delalloc_extent()
2503 inode_add_bytes(&inode->vfs_inode, len); in btrfs_clear_delalloc_extent()
2504 spin_unlock(&inode->lock); in btrfs_clear_delalloc_extent()
2519 return btrfs_csum_one_bio(BTRFS_I(inode), bio, (u64)-1, false); in btrfs_submit_bio_start()
2530 struct extent_map_tree *em_tree = &inode->extent_tree; in split_zoned_em()
2548 ret = -ENOMEM; in split_zoned_em()
2554 lock_extent(&inode->io_tree, start, start + len - 1, NULL); in split_zoned_em()
2555 write_lock(&em_tree->lock); in split_zoned_em()
2558 ret = -EIO; in split_zoned_em()
2562 ASSERT(em->len == len); in split_zoned_em()
2563 ASSERT(!test_bit(EXTENT_FLAG_COMPRESSED, &em->flags)); in split_zoned_em()
2564 ASSERT(em->block_start < EXTENT_MAP_LAST_BYTE); in split_zoned_em()
2565 ASSERT(test_bit(EXTENT_FLAG_PINNED, &em->flags)); in split_zoned_em()
2566 ASSERT(!test_bit(EXTENT_FLAG_LOGGING, &em->flags)); in split_zoned_em()
2567 ASSERT(!list_empty(&em->list)); in split_zoned_em()
2569 flags = em->flags; in split_zoned_em()
2570 clear_bit(EXTENT_FLAG_PINNED, &em->flags); in split_zoned_em()
2572 /* First, replace the em with a new extent_map starting from * em->start */ in split_zoned_em()
2573 split_pre->start = em->start; in split_zoned_em()
2574 split_pre->len = (pre ? pre : em->len - post); in split_zoned_em()
2575 split_pre->orig_start = split_pre->start; in split_zoned_em()
2576 split_pre->block_start = em->block_start; in split_zoned_em()
2577 split_pre->block_len = split_pre->len; in split_zoned_em()
2578 split_pre->orig_block_len = split_pre->block_len; in split_zoned_em()
2579 split_pre->ram_bytes = split_pre->len; in split_zoned_em()
2580 split_pre->flags = flags; in split_zoned_em()
2581 split_pre->compress_type = em->compress_type; in split_zoned_em()
2582 split_pre->generation = em->generation; in split_zoned_em()
2588 * [em->start, em->start + pre] if pre != 0 in split_zoned_em()
2589 * [em->start, em->start + em->len - post] if pre == 0 in split_zoned_em()
2594 split_mid->start = em->start + pre; in split_zoned_em()
2595 split_mid->len = em->len - pre - post; in split_zoned_em()
2596 split_mid->orig_start = split_mid->start; in split_zoned_em()
2597 split_mid->block_start = em->block_start + pre; in split_zoned_em()
2598 split_mid->block_len = split_mid->len; in split_zoned_em()
2599 split_mid->orig_block_len = split_mid->block_len; in split_zoned_em()
2600 split_mid->ram_bytes = split_mid->len; in split_zoned_em()
2601 split_mid->flags = flags; in split_zoned_em()
2602 split_mid->compress_type = em->compress_type; in split_zoned_em()
2603 split_mid->generation = em->generation; in split_zoned_em()
2608 split_post->start = em->start + em->len - post; in split_zoned_em()
2609 split_post->len = post; in split_zoned_em()
2610 split_post->orig_start = split_post->start; in split_zoned_em()
2611 split_post->block_start = em->block_start + em->len - post; in split_zoned_em()
2612 split_post->block_len = split_post->len; in split_zoned_em()
2613 split_post->orig_block_len = split_post->block_len; in split_zoned_em()
2614 split_post->ram_bytes = split_post->len; in split_zoned_em()
2615 split_post->flags = flags; in split_zoned_em()
2616 split_post->compress_type = em->compress_type; in split_zoned_em()
2617 split_post->generation = em->generation; in split_zoned_em()
2627 write_unlock(&em_tree->lock); in split_zoned_em()
2628 unlock_extent(&inode->io_tree, start, start + len - 1, NULL); in split_zoned_em()
2641 u64 start = (u64)bio->bi_iter.bi_sector << SECTOR_SHIFT; in extract_ordered_extent()
2643 u64 len = bio->bi_iter.bi_size; in extract_ordered_extent()
2654 if (ordered->disk_num_bytes == len) in extract_ordered_extent()
2658 if (WARN_ON_ONCE(ordered->bytes_left != ordered->disk_num_bytes)) { in extract_ordered_extent()
2659 ret = -EINVAL; in extract_ordered_extent()
2664 if (WARN_ON_ONCE(ordered->disk_num_bytes != ordered->num_bytes)) { in extract_ordered_extent()
2665 ret = -EINVAL; in extract_ordered_extent()
2669 ordered_end = ordered->disk_bytenr + ordered->disk_num_bytes; in extract_ordered_extent()
2671 if (WARN_ON_ONCE(start < ordered->disk_bytenr || end > ordered_end)) { in extract_ordered_extent()
2672 ret = -EINVAL; in extract_ordered_extent()
2677 if (WARN_ON_ONCE(!list_empty(&ordered->list))) { in extract_ordered_extent()
2678 ret = -EINVAL; in extract_ordered_extent()
2682 file_len = ordered->num_bytes; in extract_ordered_extent()
2683 pre = start - ordered->disk_bytenr; in extract_ordered_extent()
2684 post = ordered_end - end; in extract_ordered_extent()
2699 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); in btrfs_submit_data_write_bio()
2705 page_offset(bio_first_bvec_all(bio)->bv_page)); in btrfs_submit_data_write_bio()
2714 * friends, that is ->sync_writers != 0, defer the submission to a in btrfs_submit_data_write_bio()
2718 * so they are handled as part of the no-checksum case. in btrfs_submit_data_write_bio()
2720 if (!(bi->flags & BTRFS_INODE_NODATASUM) && in btrfs_submit_data_write_bio()
2721 !test_bit(BTRFS_FS_STATE_NO_CSUMS, &fs_info->fs_state) && in btrfs_submit_data_write_bio()
2722 !btrfs_is_data_reloc_root(bi->root)) { in btrfs_submit_data_write_bio()
2723 if (!atomic_read(&bi->sync_writers) && in btrfs_submit_data_write_bio()
2728 ret = btrfs_csum_one_bio(bi, bio, (u64)-1, false); in btrfs_submit_data_write_bio()
2740 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); in btrfs_submit_data_read_bio()
2753 btrfs_bio(bio)->iter = bio->bi_iter; in btrfs_submit_data_read_bio()
2780 trans->adding_csums = true; in add_pending_csums()
2782 csum_root = btrfs_csum_root(trans->fs_info, in add_pending_csums()
2783 sum->bytenr); in add_pending_csums()
2785 trans->adding_csums = false; in add_pending_csums()
2798 const u64 end = start + len - 1; in btrfs_find_new_delalloc_bytes()
2801 const u64 search_len = end - search_start + 1; in btrfs_find_new_delalloc_bytes()
2810 if (em->block_start != EXTENT_MAP_HOLE) in btrfs_find_new_delalloc_bytes()
2813 em_len = em->len; in btrfs_find_new_delalloc_bytes()
2814 if (em->start < search_start) in btrfs_find_new_delalloc_bytes()
2815 em_len -= search_start - em->start; in btrfs_find_new_delalloc_bytes()
2819 ret = set_extent_bit(&inode->io_tree, search_start, in btrfs_find_new_delalloc_bytes()
2820 search_start + em_len - 1, in btrfs_find_new_delalloc_bytes()
2838 if (start >= i_size_read(&inode->vfs_inode) && in btrfs_set_extent_delalloc()
2839 !(inode->flags & BTRFS_INODE_PREALLOC)) { in btrfs_set_extent_delalloc()
2849 end + 1 - start, in btrfs_set_extent_delalloc()
2855 return set_extent_delalloc(&inode->io_tree, start, end, extra_bits, in btrfs_set_extent_delalloc()
2880 page = fixup->page; in btrfs_writepage_fixup_worker()
2881 inode = BTRFS_I(fixup->inode); in btrfs_writepage_fixup_worker()
2883 page_end = page_offset(page) + PAGE_SIZE - 1; in btrfs_writepage_fixup_worker()
2896 * page->mapping may go NULL, but it shouldn't be moved to a different in btrfs_writepage_fixup_worker()
2899 if (!page->mapping || !PageDirty(page) || !PageChecked(page)) { in btrfs_writepage_fixup_worker()
2934 lock_extent(&inode->io_tree, page_start, page_end, &cached_state); in btrfs_writepage_fixup_worker()
2942 unlock_extent(&inode->io_tree, page_start, page_end, in btrfs_writepage_fixup_worker()
2969 unlock_extent(&inode->io_tree, page_start, page_end, &cached_state); in btrfs_writepage_fixup_worker()
2976 mapping_set_error(page->mapping, ret); in btrfs_writepage_fixup_worker()
2981 btrfs_page_clear_checked(inode->root->fs_info, page, page_start, PAGE_SIZE); in btrfs_writepage_fixup_worker()
2991 btrfs_add_delayed_iput(&inode->vfs_inode); in btrfs_writepage_fixup_worker()
3007 struct inode *inode = page->mapping->host; in btrfs_writepage_cow_fixup()
3008 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); in btrfs_writepage_cow_fixup()
3023 return -EAGAIN; in btrfs_writepage_cow_fixup()
3027 return -EAGAIN; in btrfs_writepage_cow_fixup()
3033 * page->mapping outside of the page lock. in btrfs_writepage_cow_fixup()
3038 btrfs_init_work(&fixup->work, btrfs_writepage_fixup_worker, NULL, NULL); in btrfs_writepage_cow_fixup()
3039 fixup->page = page; in btrfs_writepage_cow_fixup()
3040 fixup->inode = inode; in btrfs_writepage_cow_fixup()
3041 btrfs_queue_work(fs_info->fixup_workers, &fixup->work); in btrfs_writepage_cow_fixup()
3043 return -EAGAIN; in btrfs_writepage_cow_fixup()
3052 struct btrfs_root *root = inode->root; in insert_reserved_file_extent()
3053 const u64 sectorsize = root->fs_info->sectorsize; in insert_reserved_file_extent()
3067 return -ENOMEM; in insert_reserved_file_extent()
3097 leaf = path->nodes[0]; in insert_reserved_file_extent()
3098 btrfs_set_stack_file_extent_generation(stack_fi, trans->transid); in insert_reserved_file_extent()
3100 btrfs_item_ptr_offset(leaf, path->slots[0]), in insert_reserved_file_extent()
3116 inline_size = drop_args.bytes_found - inline_size; in insert_reserved_file_extent()
3118 drop_args.bytes_found -= inline_size; in insert_reserved_file_extent()
3119 num_bytes -= sectorsize; in insert_reserved_file_extent()
3134 file_pos - offset, in insert_reserved_file_extent()
3150 spin_lock(&cache->lock); in btrfs_release_delalloc_bytes()
3151 cache->delalloc_bytes -= len; in btrfs_release_delalloc_bytes()
3152 spin_unlock(&cache->lock); in btrfs_release_delalloc_bytes()
3162 u64 num_bytes = oe->num_bytes; in insert_ordered_extent_file_extent()
3163 u64 ram_bytes = oe->ram_bytes; in insert_ordered_extent_file_extent()
3167 btrfs_set_stack_file_extent_disk_bytenr(&stack_fi, oe->disk_bytenr); in insert_ordered_extent_file_extent()
3169 oe->disk_num_bytes); in insert_ordered_extent_file_extent()
3170 btrfs_set_stack_file_extent_offset(&stack_fi, oe->offset); in insert_ordered_extent_file_extent()
3171 if (test_bit(BTRFS_ORDERED_TRUNCATED, &oe->flags)) { in insert_ordered_extent_file_extent()
3172 num_bytes = oe->truncated_len; in insert_ordered_extent_file_extent()
3177 btrfs_set_stack_file_extent_compression(&stack_fi, oe->compress_type); in insert_ordered_extent_file_extent()
3186 update_inode_bytes = test_bit(BTRFS_ORDERED_DIRECT, &oe->flags) || in insert_ordered_extent_file_extent()
3187 test_bit(BTRFS_ORDERED_ENCODED, &oe->flags) || in insert_ordered_extent_file_extent()
3188 test_bit(BTRFS_ORDERED_TRUNCATED, &oe->flags); in insert_ordered_extent_file_extent()
3190 return insert_reserved_file_extent(trans, BTRFS_I(oe->inode), in insert_ordered_extent_file_extent()
3191 oe->file_offset, &stack_fi, in insert_ordered_extent_file_extent()
3192 update_inode_bytes, oe->qgroup_rsv); in insert_ordered_extent_file_extent()
3202 struct btrfs_inode *inode = BTRFS_I(ordered_extent->inode); in btrfs_finish_ordered_io()
3203 struct btrfs_root *root = inode->root; in btrfs_finish_ordered_io()
3204 struct btrfs_fs_info *fs_info = root->fs_info; in btrfs_finish_ordered_io()
3206 struct extent_io_tree *io_tree = &inode->io_tree; in btrfs_finish_ordered_io()
3211 u64 logical_len = ordered_extent->num_bytes; in btrfs_finish_ordered_io()
3217 start = ordered_extent->file_offset; in btrfs_finish_ordered_io()
3218 end = start + ordered_extent->num_bytes - 1; in btrfs_finish_ordered_io()
3220 if (!test_bit(BTRFS_ORDERED_NOCOW, &ordered_extent->flags) && in btrfs_finish_ordered_io()
3221 !test_bit(BTRFS_ORDERED_PREALLOC, &ordered_extent->flags) && in btrfs_finish_ordered_io()
3222 !test_bit(BTRFS_ORDERED_DIRECT, &ordered_extent->flags) && in btrfs_finish_ordered_io()
3223 !test_bit(BTRFS_ORDERED_ENCODED, &ordered_extent->flags)) in btrfs_finish_ordered_io()
3230 if (test_bit(BTRFS_ORDERED_IOERR, &ordered_extent->flags)) { in btrfs_finish_ordered_io()
3231 ret = -EIO; in btrfs_finish_ordered_io()
3236 if (ordered_extent->bdev) { in btrfs_finish_ordered_io()
3238 btrfs_zone_finish_endio(fs_info, ordered_extent->disk_bytenr, in btrfs_finish_ordered_io()
3239 ordered_extent->disk_num_bytes); in btrfs_finish_ordered_io()
3244 if (test_bit(BTRFS_ORDERED_TRUNCATED, &ordered_extent->flags)) { in btrfs_finish_ordered_io()
3246 logical_len = ordered_extent->truncated_len; in btrfs_finish_ordered_io()
3252 if (test_bit(BTRFS_ORDERED_NOCOW, &ordered_extent->flags)) { in btrfs_finish_ordered_io()
3253 BUG_ON(!list_empty(&ordered_extent->list)); /* Logic error */ in btrfs_finish_ordered_io()
3265 trans->block_rsv = &inode->block_rsv; in btrfs_finish_ordered_io()
3267 if (ret) /* -ENOMEM or corruption */ in btrfs_finish_ordered_io()
3285 trans->block_rsv = &inode->block_rsv; in btrfs_finish_ordered_io()
3287 if (test_bit(BTRFS_ORDERED_COMPRESSED, &ordered_extent->flags)) in btrfs_finish_ordered_io()
3288 compress_type = ordered_extent->compress_type; in btrfs_finish_ordered_io()
3289 if (test_bit(BTRFS_ORDERED_PREALLOC, &ordered_extent->flags)) { in btrfs_finish_ordered_io()
3292 ordered_extent->file_offset, in btrfs_finish_ordered_io()
3293 ordered_extent->file_offset + in btrfs_finish_ordered_io()
3295 btrfs_zoned_release_data_reloc_bg(fs_info, ordered_extent->disk_bytenr, in btrfs_finish_ordered_io()
3296 ordered_extent->disk_num_bytes); in btrfs_finish_ordered_io()
3298 BUG_ON(root == fs_info->tree_root); in btrfs_finish_ordered_io()
3303 ordered_extent->disk_bytenr, in btrfs_finish_ordered_io()
3304 ordered_extent->disk_num_bytes); in btrfs_finish_ordered_io()
3307 unpin_extent_cache(&inode->extent_tree, ordered_extent->file_offset, in btrfs_finish_ordered_io()
3308 ordered_extent->num_bytes, trans->transid); in btrfs_finish_ordered_io()
3314 ret = add_pending_csums(trans, &ordered_extent->list); in btrfs_finish_ordered_io()
3326 !test_bit(BTRFS_ORDERED_TRUNCATED, &ordered_extent->flags)) in btrfs_finish_ordered_io()
3327 clear_extent_bit(&inode->io_tree, start, end, in btrfs_finish_ordered_io()
3333 if (ret) { /* -ENOMEM or corruption */ in btrfs_finish_ordered_io()
3339 clear_extent_bit(&inode->io_tree, start, end, clear_bits, in btrfs_finish_ordered_io()
3357 &ordered_extent->flags)) in btrfs_finish_ordered_io()
3358 mapping_set_error(ordered_extent->inode->i_mapping, -EIO); in btrfs_finish_ordered_io()
3379 !test_bit(BTRFS_ORDERED_NOCOW, &ordered_extent->flags) && in btrfs_finish_ordered_io()
3380 !test_bit(BTRFS_ORDERED_PREALLOC, &ordered_extent->flags)) { in btrfs_finish_ordered_io()
3387 ordered_extent->disk_bytenr, in btrfs_finish_ordered_io()
3388 ordered_extent->disk_num_bytes, in btrfs_finish_ordered_io()
3391 ordered_extent->disk_bytenr, in btrfs_finish_ordered_io()
3392 ordered_extent->disk_num_bytes, 1); in btrfs_finish_ordered_io()
3416 btrfs_mark_ordered_io_finished(inode, page, start, end + 1 - start, uptodate); in btrfs_writepage_endio_finish_ordered()
3426 SHASH_DESC_ON_STACK(shash, fs_info->csum_shash); in btrfs_check_sector_csum()
3429 ASSERT(pgoff + fs_info->sectorsize <= PAGE_SIZE); in btrfs_check_sector_csum()
3431 shash->tfm = fs_info->csum_shash; in btrfs_check_sector_csum()
3434 crypto_shash_digest(shash, kaddr, fs_info->sectorsize, csum); in btrfs_check_sector_csum()
3437 if (memcmp(csum, csum_expected, fs_info->csum_size)) in btrfs_check_sector_csum()
3438 return -EIO; in btrfs_check_sector_csum()
3444 u64 offset_in_sectors = offset >> fs_info->sectorsize_bits; in btrfs_csum_ptr()
3446 return csums + offset_in_sectors * fs_info->csum_size; in btrfs_csum_ptr()
3450 * check_data_csum - verify checksum of one sector of uncompressed data
3465 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); in btrfs_check_data_csum()
3466 u32 len = fs_info->sectorsize; in btrfs_check_data_csum()
3472 csum_expected = btrfs_csum_ptr(fs_info, bbio->csum, bio_offset); in btrfs_check_data_csum()
3480 bbio->file_offset + bio_offset, in btrfs_check_data_csum()
3481 csum, csum_expected, bbio->mirror_num); in btrfs_check_data_csum()
3482 if (bbio->device) in btrfs_check_data_csum()
3483 btrfs_dev_stat_inc_and_print(bbio->device, in btrfs_check_data_csum()
3486 return -EIO; in btrfs_check_data_csum()
3505 struct inode *inode = page->mapping->host; in btrfs_verify_data_csum()
3506 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); in btrfs_verify_data_csum()
3507 struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree; in btrfs_verify_data_csum()
3508 struct btrfs_root *root = BTRFS_I(inode)->root; in btrfs_verify_data_csum()
3509 const u32 sectorsize = root->fs_info->sectorsize; in btrfs_verify_data_csum()
3518 if (bbio->csum == NULL) in btrfs_verify_data_csum()
3521 if (BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM) in btrfs_verify_data_csum()
3524 if (unlikely(test_bit(BTRFS_FS_STATE_NO_CSUMS, &fs_info->fs_state))) in btrfs_verify_data_csum()
3528 end <= page_offset(page) + PAGE_SIZE - 1); in btrfs_verify_data_csum()
3537 file_offset + sectorsize - 1, in btrfs_verify_data_csum()
3541 file_offset + sectorsize - 1, in btrfs_verify_data_csum()
3547 const int nr_bit = (pg_off - offset_in_page(start)) >> in btrfs_verify_data_csum()
3548 root->fs_info->sectorsize_bits; in btrfs_verify_data_csum()
3557 * btrfs_add_delayed_iput - perform a delayed iput on @inode
3568 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); in btrfs_add_delayed_iput()
3571 if (atomic_add_unless(&inode->i_count, -1, 1)) in btrfs_add_delayed_iput()
3574 atomic_inc(&fs_info->nr_delayed_iputs); in btrfs_add_delayed_iput()
3575 spin_lock(&fs_info->delayed_iput_lock); in btrfs_add_delayed_iput()
3576 ASSERT(list_empty(&binode->delayed_iput)); in btrfs_add_delayed_iput()
3577 list_add_tail(&binode->delayed_iput, &fs_info->delayed_iputs); in btrfs_add_delayed_iput()
3578 spin_unlock(&fs_info->delayed_iput_lock); in btrfs_add_delayed_iput()
3579 if (!test_bit(BTRFS_FS_CLEANER_RUNNING, &fs_info->flags)) in btrfs_add_delayed_iput()
3580 wake_up_process(fs_info->cleaner_kthread); in btrfs_add_delayed_iput()
3586 list_del_init(&inode->delayed_iput); in run_delayed_iput_locked()
3587 spin_unlock(&fs_info->delayed_iput_lock); in run_delayed_iput_locked()
3588 iput(&inode->vfs_inode); in run_delayed_iput_locked()
3589 if (atomic_dec_and_test(&fs_info->nr_delayed_iputs)) in run_delayed_iput_locked()
3590 wake_up(&fs_info->delayed_iputs_wait); in run_delayed_iput_locked()
3591 spin_lock(&fs_info->delayed_iput_lock); in run_delayed_iput_locked()
3597 if (!list_empty(&inode->delayed_iput)) { in btrfs_run_delayed_iput()
3598 spin_lock(&fs_info->delayed_iput_lock); in btrfs_run_delayed_iput()
3599 if (!list_empty(&inode->delayed_iput)) in btrfs_run_delayed_iput()
3601 spin_unlock(&fs_info->delayed_iput_lock); in btrfs_run_delayed_iput()
3608 spin_lock(&fs_info->delayed_iput_lock); in btrfs_run_delayed_iputs()
3609 while (!list_empty(&fs_info->delayed_iputs)) { in btrfs_run_delayed_iputs()
3612 inode = list_first_entry(&fs_info->delayed_iputs, in btrfs_run_delayed_iputs()
3615 cond_resched_lock(&fs_info->delayed_iput_lock); in btrfs_run_delayed_iputs()
3617 spin_unlock(&fs_info->delayed_iput_lock); in btrfs_run_delayed_iputs()
3634 int ret = wait_event_killable(fs_info->delayed_iputs_wait, in btrfs_wait_on_delayed_iputs()
3635 atomic_read(&fs_info->nr_delayed_iputs) == 0); in btrfs_wait_on_delayed_iputs()
3637 return -EINTR; in btrfs_wait_on_delayed_iputs()
3650 ret = btrfs_insert_orphan_item(trans, inode->root, btrfs_ino(inode)); in btrfs_orphan_add()
3651 if (ret && ret != -EEXIST) { in btrfs_orphan_add()
3666 return btrfs_del_orphan_item(trans, inode->root, btrfs_ino(inode)); in btrfs_orphan_del()
3675 struct btrfs_fs_info *fs_info = root->fs_info; in btrfs_orphan_cleanup()
3684 if (test_and_set_bit(BTRFS_ROOT_ORPHAN_CLEANUP, &root->state)) in btrfs_orphan_cleanup()
3689 ret = -ENOMEM; in btrfs_orphan_cleanup()
3692 path->reada = READA_BACK; in btrfs_orphan_cleanup()
3696 key.offset = (u64)-1; in btrfs_orphan_cleanup()
3710 if (path->slots[0] == 0) in btrfs_orphan_cleanup()
3712 path->slots[0]--; in btrfs_orphan_cleanup()
3716 leaf = path->nodes[0]; in btrfs_orphan_cleanup()
3717 btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]); in btrfs_orphan_cleanup()
3737 ret = -EINVAL; in btrfs_orphan_cleanup()
3746 inode = btrfs_iget(fs_info->sb, last_objectid, root); in btrfs_orphan_cleanup()
3748 if (ret && ret != -ENOENT) in btrfs_orphan_cleanup()
3751 if (ret == -ENOENT && root == fs_info->tree_root) { in btrfs_orphan_cleanup()
3766 * fs_info->fs_roots_radix. So here we can find if an in btrfs_orphan_cleanup()
3771 spin_lock(&fs_info->fs_roots_radix_lock); in btrfs_orphan_cleanup()
3772 dead_root = radix_tree_lookup(&fs_info->fs_roots_radix, in btrfs_orphan_cleanup()
3774 if (dead_root && btrfs_root_refs(&dead_root->root_item) == 0) in btrfs_orphan_cleanup()
3776 spin_unlock(&fs_info->fs_roots_radix_lock); in btrfs_orphan_cleanup()
3780 key.offset = found_key.objectid - 1; in btrfs_orphan_cleanup()
3803 * only if this filesystem was last used on a pre-v3.12 kernel in btrfs_orphan_cleanup()
3812 if (ret == -ENOENT || inode->i_nlink) { in btrfs_orphan_cleanup()
3842 if (test_bit(BTRFS_ROOT_ORPHAN_ITEM_INSERTED, &root->state)) { in btrfs_orphan_cleanup()
3882 *first_xattr_slot = -1; in acls_after_inode_item()
3892 if (*first_xattr_slot == -1) in acls_after_inode_item()
3922 if (*first_xattr_slot == -1) in acls_after_inode_item()
3928 * read an inode from the btree into the in-memory inode
3933 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); in btrfs_read_locked_inode()
3937 struct btrfs_root *root = BTRFS_I(inode)->root; in btrfs_read_locked_inode()
3953 return -ENOMEM; in btrfs_read_locked_inode()
3956 memcpy(&location, &BTRFS_I(inode)->location, sizeof(location)); in btrfs_read_locked_inode()
3965 leaf = path->nodes[0]; in btrfs_read_locked_inode()
3970 inode_item = btrfs_item_ptr(leaf, path->slots[0], in btrfs_read_locked_inode()
3972 inode->i_mode = btrfs_inode_mode(leaf, inode_item); in btrfs_read_locked_inode()
3978 round_up(i_size_read(inode), fs_info->sectorsize)); in btrfs_read_locked_inode()
3980 inode->i_atime.tv_sec = btrfs_timespec_sec(leaf, &inode_item->atime); in btrfs_read_locked_inode()
3981 inode->i_atime.tv_nsec = btrfs_timespec_nsec(leaf, &inode_item->atime); in btrfs_read_locked_inode()
3983 inode->i_mtime.tv_sec = btrfs_timespec_sec(leaf, &inode_item->mtime); in btrfs_read_locked_inode()
3984 inode->i_mtime.tv_nsec = btrfs_timespec_nsec(leaf, &inode_item->mtime); in btrfs_read_locked_inode()
3986 inode->i_ctime.tv_sec = btrfs_timespec_sec(leaf, &inode_item->ctime); in btrfs_read_locked_inode()
3987 inode->i_ctime.tv_nsec = btrfs_timespec_nsec(leaf, &inode_item->ctime); in btrfs_read_locked_inode()
3989 BTRFS_I(inode)->i_otime.tv_sec = in btrfs_read_locked_inode()
3990 btrfs_timespec_sec(leaf, &inode_item->otime); in btrfs_read_locked_inode()
3991 BTRFS_I(inode)->i_otime.tv_nsec = in btrfs_read_locked_inode()
3992 btrfs_timespec_nsec(leaf, &inode_item->otime); in btrfs_read_locked_inode()
3995 BTRFS_I(inode)->generation = btrfs_inode_generation(leaf, inode_item); in btrfs_read_locked_inode()
3996 BTRFS_I(inode)->last_trans = btrfs_inode_transid(leaf, inode_item); in btrfs_read_locked_inode()
4000 inode->i_generation = BTRFS_I(inode)->generation; in btrfs_read_locked_inode()
4001 inode->i_rdev = 0; in btrfs_read_locked_inode()
4004 BTRFS_I(inode)->index_cnt = (u64)-1; in btrfs_read_locked_inode()
4006 &BTRFS_I(inode)->flags, &BTRFS_I(inode)->ro_flags); in btrfs_read_locked_inode()
4011 * and then re-read we need to do a full sync since we don't have any in btrfs_read_locked_inode()
4015 * This is required for both inode re-read from disk and delayed inode in btrfs_read_locked_inode()
4018 if (BTRFS_I(inode)->last_trans == fs_info->generation) in btrfs_read_locked_inode()
4020 &BTRFS_I(inode)->runtime_flags); in btrfs_read_locked_inode()
4030 * touch mydir/foo in btrfs_read_locked_inode()
4031 * ln mydir/foo mydir/bar in btrfs_read_locked_inode()
4035 * xfs_io -c fsync mydir/foo in btrfs_read_locked_inode()
4039 * We must make sure that when we fsync our inode foo we also log its in btrfs_read_locked_inode()
4041 * dentry with the "bar" name but our inode foo has a link count of 1 in btrfs_read_locked_inode()
4049 BTRFS_I(inode)->last_unlink_trans = BTRFS_I(inode)->last_trans; in btrfs_read_locked_inode()
4057 BTRFS_I(inode)->last_reflink_trans = BTRFS_I(inode)->last_trans; in btrfs_read_locked_inode()
4059 path->slots[0]++; in btrfs_read_locked_inode()
4060 if (inode->i_nlink != 1 || in btrfs_read_locked_inode()
4061 path->slots[0] >= btrfs_header_nritems(leaf)) in btrfs_read_locked_inode()
4064 btrfs_item_key_to_cpu(leaf, &location, path->slots[0]); in btrfs_read_locked_inode()
4068 ptr = btrfs_item_ptr_offset(leaf, path->slots[0]); in btrfs_read_locked_inode()
4073 BTRFS_I(inode)->dir_index = btrfs_inode_ref_index(leaf, ref); in btrfs_read_locked_inode()
4078 BTRFS_I(inode)->dir_index = btrfs_inode_extref_index(leaf, in btrfs_read_locked_inode()
4086 maybe_acls = acls_after_inode_item(leaf, path->slots[0], in btrfs_read_locked_inode()
4088 if (first_xattr_slot != -1) { in btrfs_read_locked_inode()
4089 path->slots[0] = first_xattr_slot; in btrfs_read_locked_inode()
4095 root->root_key.objectid, ret); in btrfs_read_locked_inode()
4103 switch (inode->i_mode & S_IFMT) { in btrfs_read_locked_inode()
4105 inode->i_mapping->a_ops = &btrfs_aops; in btrfs_read_locked_inode()
4106 inode->i_fop = &btrfs_file_operations; in btrfs_read_locked_inode()
4107 inode->i_op = &btrfs_file_inode_operations; in btrfs_read_locked_inode()
4110 inode->i_fop = &btrfs_dir_file_operations; in btrfs_read_locked_inode()
4111 inode->i_op = &btrfs_dir_inode_operations; in btrfs_read_locked_inode()
4114 inode->i_op = &btrfs_symlink_inode_operations; in btrfs_read_locked_inode()
4116 inode->i_mapping->a_ops = &btrfs_aops; in btrfs_read_locked_inode()
4119 inode->i_op = &btrfs_special_inode_operations; in btrfs_read_locked_inode()
4120 init_special_inode(inode, inode->i_mode, rdev); in btrfs_read_locked_inode()
4143 btrfs_set_token_inode_size(&token, item, BTRFS_I(inode)->disk_i_size); in fill_inode_item()
4144 btrfs_set_token_inode_mode(&token, item, inode->i_mode); in fill_inode_item()
4145 btrfs_set_token_inode_nlink(&token, item, inode->i_nlink); in fill_inode_item()
4147 btrfs_set_token_timespec_sec(&token, &item->atime, in fill_inode_item()
4148 inode->i_atime.tv_sec); in fill_inode_item()
4149 btrfs_set_token_timespec_nsec(&token, &item->atime, in fill_inode_item()
4150 inode->i_atime.tv_nsec); in fill_inode_item()
4152 btrfs_set_token_timespec_sec(&token, &item->mtime, in fill_inode_item()
4153 inode->i_mtime.tv_sec); in fill_inode_item()
4154 btrfs_set_token_timespec_nsec(&token, &item->mtime, in fill_inode_item()
4155 inode->i_mtime.tv_nsec); in fill_inode_item()
4157 btrfs_set_token_timespec_sec(&token, &item->ctime, in fill_inode_item()
4158 inode->i_ctime.tv_sec); in fill_inode_item()
4159 btrfs_set_token_timespec_nsec(&token, &item->ctime, in fill_inode_item()
4160 inode->i_ctime.tv_nsec); in fill_inode_item()
4162 btrfs_set_token_timespec_sec(&token, &item->otime, in fill_inode_item()
4163 BTRFS_I(inode)->i_otime.tv_sec); in fill_inode_item()
4164 btrfs_set_token_timespec_nsec(&token, &item->otime, in fill_inode_item()
4165 BTRFS_I(inode)->i_otime.tv_nsec); in fill_inode_item()
4169 BTRFS_I(inode)->generation); in fill_inode_item()
4171 btrfs_set_token_inode_transid(&token, item, trans->transid); in fill_inode_item()
4172 btrfs_set_token_inode_rdev(&token, item, inode->i_rdev); in fill_inode_item()
4173 flags = btrfs_inode_combine_flags(BTRFS_I(inode)->flags, in fill_inode_item()
4174 BTRFS_I(inode)->ro_flags); in fill_inode_item()
4180 * copy everything in the in-memory inode into the btree.
4193 return -ENOMEM; in btrfs_update_inode_item()
4195 ret = btrfs_lookup_inode(trans, root, path, &inode->location, 1); in btrfs_update_inode_item()
4198 ret = -ENOENT; in btrfs_update_inode_item()
4202 leaf = path->nodes[0]; in btrfs_update_inode_item()
4203 inode_item = btrfs_item_ptr(leaf, path->slots[0], in btrfs_update_inode_item()
4206 fill_inode_item(trans, leaf, inode_item, &inode->vfs_inode); in btrfs_update_inode_item()
4216 * copy everything in the in-memory inode into the btree.
4222 struct btrfs_fs_info *fs_info = root->fs_info; in btrfs_update_inode()
4234 && !test_bit(BTRFS_FS_LOG_RECOVERING, &fs_info->flags)) { in btrfs_update_inode()
4252 if (ret == -ENOSPC) in btrfs_update_inode_fallback()
4268 struct btrfs_root *root = dir->root; in __btrfs_unlink_inode()
4269 struct btrfs_fs_info *fs_info = root->fs_info; in __btrfs_unlink_inode()
4279 ret = -ENOMEM; in __btrfs_unlink_inode()
4284 name, name_len, -1); in __btrfs_unlink_inode()
4286 ret = di ? PTR_ERR(di) : -ENOENT; in __btrfs_unlink_inode()
4304 if (inode->dir_index) { in __btrfs_unlink_inode()
4307 index = inode->dir_index; in __btrfs_unlink_inode()
4323 rename_ctx->index = index; in __btrfs_unlink_inode()
4346 * being run in btrfs-cleaner context. If we have enough of these built in __btrfs_unlink_inode()
4347 * up we can end up burning a lot of time in btrfs-cleaner without any in __btrfs_unlink_inode()
4359 btrfs_i_size_write(dir, dir->vfs_inode.i_size - name_len * 2); in __btrfs_unlink_inode()
4360 inode_inc_iversion(&inode->vfs_inode); in __btrfs_unlink_inode()
4361 inode_inc_iversion(&dir->vfs_inode); in __btrfs_unlink_inode()
4362 inode->vfs_inode.i_ctime = current_time(&inode->vfs_inode); in __btrfs_unlink_inode()
4363 dir->vfs_inode.i_mtime = inode->vfs_inode.i_ctime; in __btrfs_unlink_inode()
4364 dir->vfs_inode.i_ctime = inode->vfs_inode.i_ctime; in __btrfs_unlink_inode()
4377 drop_nlink(&inode->vfs_inode); in btrfs_unlink_inode()
4378 ret = btrfs_update_inode(trans, inode->root, inode); in btrfs_unlink_inode()
4393 struct btrfs_root *root = BTRFS_I(dir)->root; in __unlink_start_trans()
4420 BTRFS_I(d_inode(dentry)), dentry->d_name.name, in btrfs_unlink()
4421 dentry->d_name.len); in btrfs_unlink()
4425 if (inode->i_nlink == 0) { in btrfs_unlink()
4433 btrfs_btree_balance_dirty(BTRFS_I(dir)->root->fs_info); in btrfs_unlink()
4440 struct btrfs_root *root = BTRFS_I(dir)->root; in btrfs_unlink_subvol()
4446 const char *name = dentry->d_name.name; in btrfs_unlink_subvol()
4447 int name_len = dentry->d_name.len; in btrfs_unlink_subvol()
4454 objectid = inode->root->root_key.objectid; in btrfs_unlink_subvol()
4456 objectid = inode->location.objectid; in btrfs_unlink_subvol()
4459 return -EINVAL; in btrfs_unlink_subvol()
4464 return -ENOMEM; in btrfs_unlink_subvol()
4467 name, name_len, -1); in btrfs_unlink_subvol()
4469 ret = di ? PTR_ERR(di) : -ENOENT; in btrfs_unlink_subvol()
4473 leaf = path->nodes[0]; in btrfs_unlink_subvol()
4487 * depending on btrfs_del_root_ref to return -ENOENT here is incorrect. in btrfs_unlink_subvol()
4497 ret = -ENOENT; in btrfs_unlink_subvol()
4504 leaf = path->nodes[0]; in btrfs_unlink_subvol()
4505 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]); in btrfs_unlink_subvol()
4510 root->root_key.objectid, dir_ino, in btrfs_unlink_subvol()
4524 btrfs_i_size_write(BTRFS_I(dir), dir->i_size - name_len * 2); in btrfs_unlink_subvol()
4526 dir->i_mtime = current_time(dir); in btrfs_unlink_subvol()
4527 dir->i_ctime = dir->i_mtime; in btrfs_unlink_subvol()
4542 struct btrfs_fs_info *fs_info = root->fs_info; in may_destroy_subvol()
4551 return -ENOMEM; in may_destroy_subvol()
4554 dir_id = btrfs_super_root_dir(fs_info->super_copy); in may_destroy_subvol()
4555 di = btrfs_lookup_dir_item(NULL, fs_info->tree_root, path, in may_destroy_subvol()
4558 btrfs_dir_item_key_to_cpu(path->nodes[0], di, &key); in may_destroy_subvol()
4559 if (key.objectid == root->root_key.objectid) { in may_destroy_subvol()
4560 ret = -EPERM; in may_destroy_subvol()
4569 key.objectid = root->root_key.objectid; in may_destroy_subvol()
4571 key.offset = (u64)-1; in may_destroy_subvol()
4573 ret = btrfs_search_slot(NULL, fs_info->tree_root, &key, path, 0, 0); in may_destroy_subvol()
4579 if (path->slots[0] > 0) { in may_destroy_subvol()
4580 path->slots[0]--; in may_destroy_subvol()
4581 btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]); in may_destroy_subvol()
4582 if (key.objectid == root->root_key.objectid && in may_destroy_subvol()
4584 ret = -ENOTEMPTY; in may_destroy_subvol()
4594 struct btrfs_fs_info *fs_info = root->fs_info; in btrfs_prune_dentries()
4602 WARN_ON(btrfs_root_refs(&root->root_item) != 0); in btrfs_prune_dentries()
4604 spin_lock(&root->inode_lock); in btrfs_prune_dentries()
4606 node = root->inode_tree.rb_node; in btrfs_prune_dentries()
4613 node = node->rb_left; in btrfs_prune_dentries()
4615 node = node->rb_right; in btrfs_prune_dentries()
4632 inode = igrab(&entry->vfs_inode); in btrfs_prune_dentries()
4634 spin_unlock(&root->inode_lock); in btrfs_prune_dentries()
4635 if (atomic_read(&inode->i_count) > 1) in btrfs_prune_dentries()
4643 spin_lock(&root->inode_lock); in btrfs_prune_dentries()
4647 if (cond_resched_lock(&root->inode_lock)) in btrfs_prune_dentries()
4652 spin_unlock(&root->inode_lock); in btrfs_prune_dentries()
4657 struct btrfs_fs_info *fs_info = btrfs_sb(dentry->d_sb); in btrfs_delete_subvolume()
4658 struct btrfs_root *root = BTRFS_I(dir)->root; in btrfs_delete_subvolume()
4660 struct btrfs_root *dest = BTRFS_I(inode)->root; in btrfs_delete_subvolume()
4671 spin_lock(&dest->root_item_lock); in btrfs_delete_subvolume()
4672 if (dest->send_in_progress) { in btrfs_delete_subvolume()
4673 spin_unlock(&dest->root_item_lock); in btrfs_delete_subvolume()
4676 dest->root_key.objectid); in btrfs_delete_subvolume()
4677 return -EPERM; in btrfs_delete_subvolume()
4679 if (atomic_read(&dest->nr_swapfiles)) { in btrfs_delete_subvolume()
4680 spin_unlock(&dest->root_item_lock); in btrfs_delete_subvolume()
4683 root->root_key.objectid); in btrfs_delete_subvolume()
4684 return -EPERM; in btrfs_delete_subvolume()
4686 root_flags = btrfs_root_flags(&dest->root_item); in btrfs_delete_subvolume()
4687 btrfs_set_root_flags(&dest->root_item, in btrfs_delete_subvolume()
4689 spin_unlock(&dest->root_item_lock); in btrfs_delete_subvolume()
4691 down_write(&fs_info->subvol_sem); in btrfs_delete_subvolume()
4712 trans->block_rsv = &block_rsv; in btrfs_delete_subvolume()
4713 trans->bytes_reserved = block_rsv.size; in btrfs_delete_subvolume()
4729 memset(&dest->root_item.drop_progress, 0, in btrfs_delete_subvolume()
4730 sizeof(dest->root_item.drop_progress)); in btrfs_delete_subvolume()
4731 btrfs_set_root_drop_level(&dest->root_item, 0); in btrfs_delete_subvolume()
4732 btrfs_set_root_refs(&dest->root_item, 0); in btrfs_delete_subvolume()
4734 if (!test_and_set_bit(BTRFS_ROOT_ORPHAN_ITEM_INSERTED, &dest->state)) { in btrfs_delete_subvolume()
4736 fs_info->tree_root, in btrfs_delete_subvolume()
4737 dest->root_key.objectid); in btrfs_delete_subvolume()
4744 ret = btrfs_uuid_tree_remove(trans, dest->root_item.uuid, in btrfs_delete_subvolume()
4746 dest->root_key.objectid); in btrfs_delete_subvolume()
4747 if (ret && ret != -ENOENT) { in btrfs_delete_subvolume()
4751 if (!btrfs_is_empty_uuid(dest->root_item.received_uuid)) { in btrfs_delete_subvolume()
4753 dest->root_item.received_uuid, in btrfs_delete_subvolume()
4755 dest->root_key.objectid); in btrfs_delete_subvolume()
4756 if (ret && ret != -ENOENT) { in btrfs_delete_subvolume()
4762 free_anon_bdev(dest->anon_dev); in btrfs_delete_subvolume()
4763 dest->anon_dev = 0; in btrfs_delete_subvolume()
4765 trans->block_rsv = NULL; in btrfs_delete_subvolume()
4766 trans->bytes_reserved = 0; in btrfs_delete_subvolume()
4768 inode->i_flags |= S_DEAD; in btrfs_delete_subvolume()
4772 up_write(&fs_info->subvol_sem); in btrfs_delete_subvolume()
4774 spin_lock(&dest->root_item_lock); in btrfs_delete_subvolume()
4775 root_flags = btrfs_root_flags(&dest->root_item); in btrfs_delete_subvolume()
4776 btrfs_set_root_flags(&dest->root_item, in btrfs_delete_subvolume()
4778 spin_unlock(&dest->root_item_lock); in btrfs_delete_subvolume()
4782 ASSERT(dest->send_in_progress == 0); in btrfs_delete_subvolume()
4791 struct btrfs_fs_info *fs_info = BTRFS_I(inode)->root->fs_info; in btrfs_rmdir()
4796 if (inode->i_size > BTRFS_EMPTY_DIR_SIZE) in btrfs_rmdir()
4797 return -ENOTEMPTY; in btrfs_rmdir()
4802 return -EOPNOTSUPP; in btrfs_rmdir()
4820 last_unlink_trans = BTRFS_I(inode)->last_unlink_trans; in btrfs_rmdir()
4824 BTRFS_I(d_inode(dentry)), dentry->d_name.name, in btrfs_rmdir()
4825 dentry->d_name.len); in btrfs_rmdir()
4832 * 1) create dir foo in btrfs_rmdir()
4833 * 2) create snapshot under dir foo in btrfs_rmdir()
4835 * 4) rmdir foo in btrfs_rmdir()
4836 * 5) mkdir foo in btrfs_rmdir()
4837 * 6) fsync foo or some file inside foo in btrfs_rmdir()
4839 if (last_unlink_trans >= trans->transid) in btrfs_rmdir()
4840 BTRFS_I(dir)->last_unlink_trans = last_unlink_trans; in btrfs_rmdir()
4850 * btrfs_truncate_block - read, zero a chunk and write a block
4851 * @inode - inode that we're zeroing
4852 * @from - the offset to start zeroing
4853 * @len - the length to zero, 0 to zero the entire range respective to the
4855 * @front - zero up to the offset instead of from the offset on
4863 struct btrfs_fs_info *fs_info = inode->root->fs_info; in btrfs_truncate_block()
4864 struct address_space *mapping = inode->vfs_inode.i_mapping; in btrfs_truncate_block()
4865 struct extent_io_tree *io_tree = &inode->io_tree; in btrfs_truncate_block()
4870 u32 blocksize = fs_info->sectorsize; in btrfs_truncate_block()
4872 unsigned offset = from & (blocksize - 1); in btrfs_truncate_block()
4885 block_end = block_start + blocksize - 1; in btrfs_truncate_block()
4910 ret = -ENOMEM; in btrfs_truncate_block()
4920 if (page->mapping != mapping) { in btrfs_truncate_block()
4926 ret = -EIO; in btrfs_truncate_block()
4944 clear_extent_bit(&inode->io_tree, block_start, block_end, in btrfs_truncate_block()
4957 len = blocksize - offset; in btrfs_truncate_block()
4959 memzero_page(page, (block_start - page_offset(page)), in btrfs_truncate_block()
4962 memzero_page(page, (block_start - page_offset(page)) + offset, in btrfs_truncate_block()
4966 block_end + 1 - block_start); in btrfs_truncate_block()
4967 btrfs_page_set_dirty(fs_info, page, block_start, block_end + 1 - block_start); in btrfs_truncate_block()
4971 set_extent_bit(&inode->io_tree, block_start, block_end, in btrfs_truncate_block()
4995 struct btrfs_fs_info *fs_info = root->fs_info; in maybe_insert_hole()
5010 * 1 - for the one we're dropping in maybe_insert_hole()
5011 * 1 - for the one we're adding in maybe_insert_hole()
5012 * 1 - for updating the inode. in maybe_insert_hole()
5048 struct btrfs_root *root = inode->root; in btrfs_cont_expand()
5049 struct btrfs_fs_info *fs_info = root->fs_info; in btrfs_cont_expand()
5050 struct extent_io_tree *io_tree = &inode->io_tree; in btrfs_cont_expand()
5053 u64 hole_start = ALIGN(oldsize, fs_info->sectorsize); in btrfs_cont_expand()
5054 u64 block_end = ALIGN(size, fs_info->sectorsize); in btrfs_cont_expand()
5072 btrfs_lock_and_flush_ordered_range(inode, hole_start, block_end - 1, in btrfs_cont_expand()
5077 block_end - cur_offset); in btrfs_cont_expand()
5084 last_byte = ALIGN(last_byte, fs_info->sectorsize); in btrfs_cont_expand()
5085 hole_size = last_byte - cur_offset; in btrfs_cont_expand()
5087 if (!test_bit(EXTENT_FLAG_PREALLOC, &em->flags)) { in btrfs_cont_expand()
5103 cur_offset + hole_size - 1, in btrfs_cont_expand()
5108 hole_em->start = cur_offset; in btrfs_cont_expand()
5109 hole_em->len = hole_size; in btrfs_cont_expand()
5110 hole_em->orig_start = cur_offset; in btrfs_cont_expand()
5112 hole_em->block_start = EXTENT_MAP_HOLE; in btrfs_cont_expand()
5113 hole_em->block_len = 0; in btrfs_cont_expand()
5114 hole_em->orig_block_len = 0; in btrfs_cont_expand()
5115 hole_em->ram_bytes = hole_size; in btrfs_cont_expand()
5116 hole_em->compress_type = BTRFS_COMPRESS_NONE; in btrfs_cont_expand()
5117 hole_em->generation = fs_info->generation; in btrfs_cont_expand()
5135 unlock_extent(io_tree, hole_start, block_end - 1, &cached_state); in btrfs_cont_expand()
5141 struct btrfs_root *root = BTRFS_I(inode)->root; in btrfs_setsize()
5144 loff_t newsize = attr->ia_size; in btrfs_setsize()
5145 int mask = attr->ia_valid; in btrfs_setsize()
5157 inode->i_mtime = current_time(inode); in btrfs_setsize()
5158 inode->i_ctime = inode->i_mtime; in btrfs_setsize()
5166 * state of this file - if the snapshot captures this expanding in btrfs_setsize()
5170 btrfs_drew_write_lock(&root->snapshot_lock); in btrfs_setsize()
5173 btrfs_drew_write_unlock(&root->snapshot_lock); in btrfs_setsize()
5179 btrfs_drew_write_unlock(&root->snapshot_lock); in btrfs_setsize()
5187 btrfs_drew_write_unlock(&root->snapshot_lock); in btrfs_setsize()
5190 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); in btrfs_setsize()
5194 ALIGN(newsize, fs_info->sectorsize), in btrfs_setsize()
5195 (u64)-1); in btrfs_setsize()
5207 &BTRFS_I(inode)->runtime_flags); in btrfs_setsize()
5214 if (ret && inode->i_nlink) { in btrfs_setsize()
5218 * Truncate failed, so fix up the in-memory size. We in btrfs_setsize()
5221 * in-memory size to match. in btrfs_setsize()
5223 err = btrfs_wait_ordered_range(inode, 0, (u64)-1); in btrfs_setsize()
5226 i_size_write(inode, BTRFS_I(inode)->disk_i_size); in btrfs_setsize()
5237 struct btrfs_root *root = BTRFS_I(inode)->root; in btrfs_setattr()
5241 return -EROFS; in btrfs_setattr()
5247 if (S_ISREG(inode->i_mode) && (attr->ia_valid & ATTR_SIZE)) { in btrfs_setattr()
5253 if (attr->ia_valid) { in btrfs_setattr()
5258 if (!err && attr->ia_valid & ATTR_MODE) in btrfs_setattr()
5259 err = posix_acl_chmod(mnt_userns, inode, inode->i_mode); in btrfs_setattr()
5280 struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree; in evict_inode_truncate_pages()
5283 ASSERT(inode->i_state & I_FREEING); in evict_inode_truncate_pages()
5284 truncate_inode_pages_final(&inode->i_data); in evict_inode_truncate_pages()
5286 btrfs_drop_extent_map_range(BTRFS_I(inode), 0, (u64)-1, false); in evict_inode_truncate_pages()
5296 * queue kthread), inode references (inode->i_count) were not taken in evict_inode_truncate_pages()
5300 * reference count - if we don't do it, when they access the inode's in evict_inode_truncate_pages()
5302 * use-after-free issue. in evict_inode_truncate_pages()
5304 spin_lock(&io_tree->lock); in evict_inode_truncate_pages()
5305 while (!RB_EMPTY_ROOT(&io_tree->state)) { in evict_inode_truncate_pages()
5312 node = rb_first(&io_tree->state); in evict_inode_truncate_pages()
5314 start = state->start; in evict_inode_truncate_pages()
5315 end = state->end; in evict_inode_truncate_pages()
5316 state_flags = state->state; in evict_inode_truncate_pages()
5317 spin_unlock(&io_tree->lock); in evict_inode_truncate_pages()
5331 end - start + 1); in evict_inode_truncate_pages()
5338 spin_lock(&io_tree->lock); in evict_inode_truncate_pages()
5340 spin_unlock(&io_tree->lock); in evict_inode_truncate_pages()
5346 struct btrfs_fs_info *fs_info = root->fs_info; in evict_refill_and_join()
5362 * if we fail to make this reservation we can re-try without the in evict_refill_and_join()
5365 ret = btrfs_block_rsv_refill(fs_info, rsv, rsv->size + delayed_refs_extra, in evict_refill_and_join()
5368 ret = btrfs_block_rsv_refill(fs_info, rsv, rsv->size, in evict_refill_and_join()
5373 return ERR_PTR(-ENOSPC); in evict_refill_and_join()
5383 trans->block_rsv = &fs_info->trans_block_rsv; in evict_refill_and_join()
5384 trans->bytes_reserved = delayed_refs_extra; in evict_refill_and_join()
5385 btrfs_block_rsv_migrate(rsv, trans->block_rsv, in evict_refill_and_join()
5393 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); in btrfs_evict_inode()
5395 struct btrfs_root *root = BTRFS_I(inode)->root; in btrfs_evict_inode()
5409 if (inode->i_nlink && in btrfs_evict_inode()
5410 ((btrfs_root_refs(&root->root_item) != 0 && in btrfs_evict_inode()
5411 root->root_key.objectid != BTRFS_ROOT_TREE_OBJECTID) || in btrfs_evict_inode()
5418 btrfs_free_io_failure_record(BTRFS_I(inode), 0, (u64)-1); in btrfs_evict_inode()
5420 if (test_bit(BTRFS_FS_LOG_RECOVERING, &fs_info->flags)) in btrfs_evict_inode()
5423 if (inode->i_nlink > 0) { in btrfs_evict_inode()
5424 BUG_ON(btrfs_root_refs(&root->root_item) != 0 && in btrfs_evict_inode()
5425 root->root_key.objectid != BTRFS_ROOT_TREE_OBJECTID); in btrfs_evict_inode()
5448 rsv->size = btrfs_calc_metadata_size(fs_info, 1); in btrfs_evict_inode()
5449 rsv->failfast = true; in btrfs_evict_inode()
5465 trans->block_rsv = rsv; in btrfs_evict_inode()
5468 trans->block_rsv = &fs_info->trans_block_rsv; in btrfs_evict_inode()
5471 if (ret && ret != -ENOSPC && ret != -EAGAIN) in btrfs_evict_inode()
5488 trans->block_rsv = rsv; in btrfs_evict_inode()
5490 trans->block_rsv = &fs_info->trans_block_rsv; in btrfs_evict_inode()
5511 * If no dir entries were found, returns -ENOENT.
5512 * If found a corrupted location in dir entry, returns -EUCLEAN.
5517 const char *name = dentry->d_name.name; in btrfs_inode_by_name()
5518 int namelen = dentry->d_name.len; in btrfs_inode_by_name()
5521 struct btrfs_root *root = BTRFS_I(dir)->root; in btrfs_inode_by_name()
5526 return -ENOMEM; in btrfs_inode_by_name()
5531 ret = di ? PTR_ERR(di) : -ENOENT; in btrfs_inode_by_name()
5535 btrfs_dir_item_key_to_cpu(path->nodes[0], di, location); in btrfs_inode_by_name()
5536 if (location->type != BTRFS_INODE_ITEM_KEY && in btrfs_inode_by_name()
5537 location->type != BTRFS_ROOT_ITEM_KEY) { in btrfs_inode_by_name()
5538 ret = -EUCLEAN; in btrfs_inode_by_name()
5539 btrfs_warn(root->fs_info, in btrfs_inode_by_name()
5542 location->objectid, location->type, location->offset); in btrfs_inode_by_name()
5545 *type = btrfs_dir_type(path->nodes[0], di); in btrfs_inode_by_name()
5572 err = -ENOMEM; in fixup_tree_root_location()
5576 err = -ENOENT; in fixup_tree_root_location()
5577 key.objectid = BTRFS_I(dir)->root->root_key.objectid; in fixup_tree_root_location()
5579 key.offset = location->objectid; in fixup_tree_root_location()
5581 ret = btrfs_search_slot(NULL, fs_info->tree_root, &key, path, 0, 0); in fixup_tree_root_location()
5588 leaf = path->nodes[0]; in fixup_tree_root_location()
5589 ref = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_root_ref); in fixup_tree_root_location()
5591 btrfs_root_ref_name_len(leaf, ref) != dentry->d_name.len) in fixup_tree_root_location()
5594 ret = memcmp_extent_buffer(leaf, dentry->d_name.name, in fixup_tree_root_location()
5596 dentry->d_name.len); in fixup_tree_root_location()
5602 new_root = btrfs_get_fs_root(fs_info, location->objectid, true); in fixup_tree_root_location()
5609 location->objectid = btrfs_root_dirid(&new_root->root_item); in fixup_tree_root_location()
5610 location->type = BTRFS_INODE_ITEM_KEY; in fixup_tree_root_location()
5611 location->offset = 0; in fixup_tree_root_location()
5620 struct btrfs_root *root = BTRFS_I(inode)->root; in inode_tree_add()
5624 struct rb_node *new = &BTRFS_I(inode)->rb_node; in inode_tree_add()
5630 spin_lock(&root->inode_lock); in inode_tree_add()
5631 p = &root->inode_tree.rb_node; in inode_tree_add()
5637 p = &parent->rb_left; in inode_tree_add()
5639 p = &parent->rb_right; in inode_tree_add()
5641 WARN_ON(!(entry->vfs_inode.i_state & in inode_tree_add()
5643 rb_replace_node(parent, new, &root->inode_tree); in inode_tree_add()
5645 spin_unlock(&root->inode_lock); in inode_tree_add()
5650 rb_insert_color(new, &root->inode_tree); in inode_tree_add()
5651 spin_unlock(&root->inode_lock); in inode_tree_add()
5656 struct btrfs_root *root = inode->root; in inode_tree_del()
5659 spin_lock(&root->inode_lock); in inode_tree_del()
5660 if (!RB_EMPTY_NODE(&inode->rb_node)) { in inode_tree_del()
5661 rb_erase(&inode->rb_node, &root->inode_tree); in inode_tree_del()
5662 RB_CLEAR_NODE(&inode->rb_node); in inode_tree_del()
5663 empty = RB_EMPTY_ROOT(&root->inode_tree); in inode_tree_del()
5665 spin_unlock(&root->inode_lock); in inode_tree_del()
5667 if (empty && btrfs_root_refs(&root->root_item) == 0) { in inode_tree_del()
5668 spin_lock(&root->inode_lock); in inode_tree_del()
5669 empty = RB_EMPTY_ROOT(&root->inode_tree); in inode_tree_del()
5670 spin_unlock(&root->inode_lock); in inode_tree_del()
5681 inode->i_ino = args->ino; in btrfs_init_locked_inode()
5682 BTRFS_I(inode)->location.objectid = args->ino; in btrfs_init_locked_inode()
5683 BTRFS_I(inode)->location.type = BTRFS_INODE_ITEM_KEY; in btrfs_init_locked_inode()
5684 BTRFS_I(inode)->location.offset = 0; in btrfs_init_locked_inode()
5685 BTRFS_I(inode)->root = btrfs_grab_root(args->root); in btrfs_init_locked_inode()
5686 BUG_ON(args->root && !BTRFS_I(inode)->root); in btrfs_init_locked_inode()
5688 if (args->root && args->root == args->root->fs_info->tree_root && in btrfs_init_locked_inode()
5689 args->ino != BTRFS_BTREE_INODE_OBJECTID) in btrfs_init_locked_inode()
5691 &BTRFS_I(inode)->runtime_flags); in btrfs_init_locked_inode()
5699 return args->ino == BTRFS_I(inode)->location.objectid && in btrfs_find_actor()
5700 args->root == BTRFS_I(inode)->root; in btrfs_find_actor()
5732 return ERR_PTR(-ENOMEM); in btrfs_iget_path()
5734 if (inode->i_state & I_NEW) { in btrfs_iget_path()
5749 ret = -ENOENT; in btrfs_iget_path()
5769 return ERR_PTR(-ENOMEM); in new_simple_dir()
5771 BTRFS_I(inode)->root = btrfs_grab_root(root); in new_simple_dir()
5772 memcpy(&BTRFS_I(inode)->location, key, sizeof(*key)); in new_simple_dir()
5773 set_bit(BTRFS_INODE_DUMMY, &BTRFS_I(inode)->runtime_flags); in new_simple_dir()
5775 inode->i_ino = BTRFS_EMPTY_SUBVOL_DIR_OBJECTID; in new_simple_dir()
5777 * We only need lookup, the rest is read-only and there's no inode in new_simple_dir()
5780 inode->i_op = &simple_dir_inode_operations; in new_simple_dir()
5781 inode->i_opflags &= ~IOP_XATTR; in new_simple_dir()
5782 inode->i_fop = &simple_dir_operations; in new_simple_dir()
5783 inode->i_mode = S_IFDIR | S_IRUGO | S_IWUSR | S_IXUGO; in new_simple_dir()
5784 inode->i_mtime = current_time(inode); in new_simple_dir()
5785 inode->i_atime = inode->i_mtime; in new_simple_dir()
5786 inode->i_ctime = inode->i_mtime; in new_simple_dir()
5787 BTRFS_I(inode)->i_otime = inode->i_mtime; in new_simple_dir()
5803 return fs_umode_to_ftype(inode->i_mode); in btrfs_inode_type()
5808 struct btrfs_fs_info *fs_info = btrfs_sb(dir->i_sb); in btrfs_lookup_dentry()
5810 struct btrfs_root *root = BTRFS_I(dir)->root; in btrfs_lookup_dentry()
5816 if (dentry->d_name.len > BTRFS_NAME_LEN) in btrfs_lookup_dentry()
5817 return ERR_PTR(-ENAMETOOLONG); in btrfs_lookup_dentry()
5824 inode = btrfs_iget(dir->i_sb, location.objectid, root); in btrfs_lookup_dentry()
5832 inode->i_mode, btrfs_inode_type(inode), in btrfs_lookup_dentry()
5835 return ERR_PTR(-EUCLEAN); in btrfs_lookup_dentry()
5843 if (ret != -ENOENT) in btrfs_lookup_dentry()
5846 inode = new_simple_dir(dir->i_sb, &location, root); in btrfs_lookup_dentry()
5848 inode = btrfs_iget(dir->i_sb, location.objectid, sub_root); in btrfs_lookup_dentry()
5854 down_read(&fs_info->cleanup_work_sem); in btrfs_lookup_dentry()
5855 if (!sb_rdonly(inode->i_sb)) in btrfs_lookup_dentry()
5857 up_read(&fs_info->cleanup_work_sem); in btrfs_lookup_dentry()
5873 inode = d_inode(dentry->d_parent); in btrfs_dentry_delete()
5876 root = BTRFS_I(inode)->root; in btrfs_dentry_delete()
5877 if (btrfs_root_refs(&root->root_item) == 0) in btrfs_dentry_delete()
5891 if (inode == ERR_PTR(-ENOENT)) in btrfs_lookup()
5911 return -ENOMEM; in btrfs_opendir()
5912 private->filldir_buf = kzalloc(PAGE_SIZE, GFP_KERNEL); in btrfs_opendir()
5913 if (!private->filldir_buf) { in btrfs_opendir()
5915 return -ENOMEM; in btrfs_opendir()
5917 file->private_data = private; in btrfs_opendir()
5930 while (entries--) { in btrfs_filldir()
5934 ctx->pos = get_unaligned(&entry->offset); in btrfs_filldir()
5935 if (!dir_emit(ctx, name, get_unaligned(&entry->name_len), in btrfs_filldir()
5936 get_unaligned(&entry->ino), in btrfs_filldir()
5937 get_unaligned(&entry->type))) in btrfs_filldir()
5940 get_unaligned(&entry->name_len); in btrfs_filldir()
5941 ctx->pos++; in btrfs_filldir()
5949 struct btrfs_root *root = BTRFS_I(inode)->root; in btrfs_real_readdir()
5950 struct btrfs_file_private *private = file->private_data; in btrfs_real_readdir()
5971 return -ENOMEM; in btrfs_real_readdir()
5973 addr = private->filldir_buf; in btrfs_real_readdir()
5974 path->reada = READA_FORWARD; in btrfs_real_readdir()
5982 key.offset = ctx->pos; in btrfs_real_readdir()
5987 struct extent_buffer *leaf = path->nodes[0]; in btrfs_real_readdir()
5993 if (found_key.offset < ctx->pos) in btrfs_real_readdir()
5997 di = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_dir_item); in btrfs_real_readdir()
6002 ret = btrfs_filldir(private->filldir_buf, entries, ctx); in btrfs_real_readdir()
6005 addr = private->filldir_buf; in btrfs_real_readdir()
6012 put_unaligned(name_len, &entry->name_len); in btrfs_real_readdir()
6017 &entry->type); in btrfs_real_readdir()
6019 put_unaligned(location.objectid, &entry->ino); in btrfs_real_readdir()
6020 put_unaligned(found_key.offset, &entry->offset); in btrfs_real_readdir()
6031 ret = btrfs_filldir(private->filldir_buf, entries, ctx); in btrfs_real_readdir()
6047 * they're returned by readdir. Until we re-use freed offsets in btrfs_real_readdir()
6056 if (ctx->pos >= INT_MAX) in btrfs_real_readdir()
6057 ctx->pos = LLONG_MAX; in btrfs_real_readdir()
6059 ctx->pos = INT_MAX; in btrfs_real_readdir()
6077 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); in btrfs_dirty_inode()
6078 struct btrfs_root *root = BTRFS_I(inode)->root; in btrfs_dirty_inode()
6082 if (test_bit(BTRFS_INODE_DUMMY, &BTRFS_I(inode)->runtime_flags)) in btrfs_dirty_inode()
6090 if (ret && (ret == -ENOSPC || ret == -EDQUOT)) { in btrfs_dirty_inode()
6100 if (BTRFS_I(inode)->delayed_node) in btrfs_dirty_inode()
6113 struct btrfs_root *root = BTRFS_I(inode)->root; in btrfs_update_time()
6117 return -EROFS; in btrfs_update_time()
6122 inode->i_ctime = *now; in btrfs_update_time()
6124 inode->i_mtime = *now; in btrfs_update_time()
6126 inode->i_atime = *now; in btrfs_update_time()
6132 * and then set the in-memory index_cnt variable to reflect
6137 struct btrfs_root *root = inode->root; in btrfs_set_inode_index_count()
6145 key.offset = (u64)-1; in btrfs_set_inode_index_count()
6149 return -ENOMEM; in btrfs_set_inode_index_count()
6159 if (path->slots[0] == 0) { in btrfs_set_inode_index_count()
6160 inode->index_cnt = BTRFS_DIR_START_INDEX; in btrfs_set_inode_index_count()
6164 path->slots[0]--; in btrfs_set_inode_index_count()
6166 leaf = path->nodes[0]; in btrfs_set_inode_index_count()
6167 btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]); in btrfs_set_inode_index_count()
6171 inode->index_cnt = BTRFS_DIR_START_INDEX; in btrfs_set_inode_index_count()
6175 inode->index_cnt = found_key.offset + 1; in btrfs_set_inode_index_count()
6189 if (dir->index_cnt == (u64)-1) { in btrfs_set_inode_index()
6198 *index = dir->index_cnt; in btrfs_set_inode_index()
6199 dir->index_cnt++; in btrfs_set_inode_index()
6208 args.ino = BTRFS_I(inode)->location.objectid; in btrfs_insert_inode_locked()
6209 args.root = BTRFS_I(inode)->root; in btrfs_insert_inode_locked()
6212 btrfs_inode_hash(inode->i_ino, BTRFS_I(inode)->root), in btrfs_insert_inode_locked()
6219 struct inode *dir = args->dir; in btrfs_new_inode_prepare()
6220 struct inode *inode = args->inode; in btrfs_new_inode_prepare()
6223 ret = posix_acl_create(dir, &inode->i_mode, &args->default_acl, &args->acl); in btrfs_new_inode_prepare()
6230 if (BTRFS_I(dir)->prop_compress) in btrfs_new_inode_prepare()
6233 if (args->default_acl) in btrfs_new_inode_prepare()
6236 if (args->acl) in btrfs_new_inode_prepare()
6240 if (dir->i_security) in btrfs_new_inode_prepare()
6243 if (args->orphan) { in btrfs_new_inode_prepare()
6263 posix_acl_release(args->acl); in btrfs_new_inode_args_destroy()
6264 posix_acl_release(args->default_acl); in btrfs_new_inode_args_destroy()
6276 flags = BTRFS_I(dir)->flags; in btrfs_inherit_iflags()
6279 BTRFS_I(inode)->flags &= ~BTRFS_INODE_COMPRESS; in btrfs_inherit_iflags()
6280 BTRFS_I(inode)->flags |= BTRFS_INODE_NOCOMPRESS; in btrfs_inherit_iflags()
6282 BTRFS_I(inode)->flags &= ~BTRFS_INODE_NOCOMPRESS; in btrfs_inherit_iflags()
6283 BTRFS_I(inode)->flags |= BTRFS_INODE_COMPRESS; in btrfs_inherit_iflags()
6287 BTRFS_I(inode)->flags |= BTRFS_INODE_NODATACOW; in btrfs_inherit_iflags()
6288 if (S_ISREG(inode->i_mode)) in btrfs_inherit_iflags()
6289 BTRFS_I(inode)->flags |= BTRFS_INODE_NODATASUM; in btrfs_inherit_iflags()
6298 struct inode *dir = args->dir; in btrfs_create_new_inode()
6299 struct inode *inode = args->inode; in btrfs_create_new_inode()
6300 const char *name = args->orphan ? NULL : args->dentry->d_name.name; in btrfs_create_new_inode()
6301 int name_len = args->orphan ? 0 : args->dentry->d_name.len; in btrfs_create_new_inode()
6302 struct btrfs_fs_info *fs_info = btrfs_sb(dir->i_sb); in btrfs_create_new_inode()
6317 return -ENOMEM; in btrfs_create_new_inode()
6319 if (!args->subvol) in btrfs_create_new_inode()
6320 BTRFS_I(inode)->root = btrfs_grab_root(BTRFS_I(dir)->root); in btrfs_create_new_inode()
6321 root = BTRFS_I(inode)->root; in btrfs_create_new_inode()
6326 inode->i_ino = objectid; in btrfs_create_new_inode()
6328 if (args->orphan) { in btrfs_create_new_inode()
6337 ret = btrfs_set_inode_index(BTRFS_I(dir), &BTRFS_I(inode)->dir_index); in btrfs_create_new_inode()
6342 BTRFS_I(inode)->index_cnt = BTRFS_DIR_START_INDEX; in btrfs_create_new_inode()
6343 BTRFS_I(inode)->generation = trans->transid; in btrfs_create_new_inode()
6344 inode->i_generation = BTRFS_I(inode)->generation; in btrfs_create_new_inode()
6351 if (!args->subvol) in btrfs_create_new_inode()
6354 if (S_ISREG(inode->i_mode)) { in btrfs_create_new_inode()
6356 BTRFS_I(inode)->flags |= BTRFS_INODE_NODATASUM; in btrfs_create_new_inode()
6358 BTRFS_I(inode)->flags |= BTRFS_INODE_NODATACOW | in btrfs_create_new_inode()
6362 location = &BTRFS_I(inode)->location; in btrfs_create_new_inode()
6363 location->objectid = objectid; in btrfs_create_new_inode()
6364 location->offset = 0; in btrfs_create_new_inode()
6365 location->type = BTRFS_INODE_ITEM_KEY; in btrfs_create_new_inode()
6369 if (!args->orphan) in btrfs_create_new_inode()
6370 BTRFS_I(dir)->index_cnt--; in btrfs_create_new_inode()
6388 if (!args->orphan) { in btrfs_create_new_inode()
6397 if (args->subvol) { in btrfs_create_new_inode()
6408 batch.total_data_size = sizes[0] + (args->orphan ? 0 : sizes[1]); in btrfs_create_new_inode()
6409 batch.nr = args->orphan ? 1 : 2; in btrfs_create_new_inode()
6416 inode->i_mtime = current_time(inode); in btrfs_create_new_inode()
6417 inode->i_atime = inode->i_mtime; in btrfs_create_new_inode()
6418 inode->i_ctime = inode->i_mtime; in btrfs_create_new_inode()
6419 BTRFS_I(inode)->i_otime = inode->i_mtime; in btrfs_create_new_inode()
6426 inode_item = btrfs_item_ptr(path->nodes[0], path->slots[0], in btrfs_create_new_inode()
6428 memzero_extent_buffer(path->nodes[0], (unsigned long)inode_item, in btrfs_create_new_inode()
6430 fill_inode_item(trans, path->nodes[0], inode_item, inode); in btrfs_create_new_inode()
6432 if (!args->orphan) { in btrfs_create_new_inode()
6433 ref = btrfs_item_ptr(path->nodes[0], path->slots[0] + 1, in btrfs_create_new_inode()
6436 if (args->subvol) { in btrfs_create_new_inode()
6437 btrfs_set_inode_ref_name_len(path->nodes[0], ref, 2); in btrfs_create_new_inode()
6438 btrfs_set_inode_ref_index(path->nodes[0], ref, 0); in btrfs_create_new_inode()
6439 write_extent_buffer(path->nodes[0], "..", ptr, 2); in btrfs_create_new_inode()
6441 btrfs_set_inode_ref_name_len(path->nodes[0], ref, name_len); in btrfs_create_new_inode()
6442 btrfs_set_inode_ref_index(path->nodes[0], ref, in btrfs_create_new_inode()
6443 BTRFS_I(inode)->dir_index); in btrfs_create_new_inode()
6444 write_extent_buffer(path->nodes[0], name, ptr, name_len); in btrfs_create_new_inode()
6448 btrfs_mark_buffer_dirty(path->nodes[0]); in btrfs_create_new_inode()
6457 if (args->subvol) { in btrfs_create_new_inode()
6464 parent = btrfs_iget(fs_info->sb, BTRFS_FIRST_FREE_OBJECTID, in btrfs_create_new_inode()
6465 BTRFS_I(dir)->root); in btrfs_create_new_inode()
6478 btrfs_ino(BTRFS_I(inode)), root->root_key.objectid, in btrfs_create_new_inode()
6486 if (!args->subvol) { in btrfs_create_new_inode()
6501 if (args->orphan) { in btrfs_create_new_inode()
6505 name_len, 0, BTRFS_I(inode)->dir_index); in btrfs_create_new_inode()
6538 struct btrfs_root *root = parent_inode->root; in btrfs_add_link()
6543 memcpy(&key, &inode->root->root_key, sizeof(key)); in btrfs_add_link()
6552 root->root_key.objectid, parent_ino, in btrfs_add_link()
6564 btrfs_inode_type(&inode->vfs_inode), index); in btrfs_add_link()
6565 if (ret == -EEXIST || ret == -EOVERFLOW) in btrfs_add_link()
6572 btrfs_i_size_write(parent_inode, parent_inode->vfs_inode.i_size + in btrfs_add_link()
6574 inode_inc_iversion(&parent_inode->vfs_inode); in btrfs_add_link()
6581 if (!test_bit(BTRFS_FS_LOG_RECOVERING, &root->fs_info->flags)) { in btrfs_add_link()
6582 struct timespec64 now = current_time(&parent_inode->vfs_inode); in btrfs_add_link()
6584 parent_inode->vfs_inode.i_mtime = now; in btrfs_add_link()
6585 parent_inode->vfs_inode.i_ctime = now; in btrfs_add_link()
6597 root->root_key.objectid, parent_ino, in btrfs_add_link()
6618 struct btrfs_fs_info *fs_info = btrfs_sb(dir->i_sb); in btrfs_create_common()
6619 struct btrfs_root *root = BTRFS_I(dir)->root; in btrfs_create_common()
6658 inode = new_inode(dir->i_sb); in btrfs_mknod()
6660 return -ENOMEM; in btrfs_mknod()
6662 inode->i_op = &btrfs_special_inode_operations; in btrfs_mknod()
6663 init_special_inode(inode, inode->i_mode, rdev); in btrfs_mknod()
6672 inode = new_inode(dir->i_sb); in btrfs_create()
6674 return -ENOMEM; in btrfs_create()
6676 inode->i_fop = &btrfs_file_operations; in btrfs_create()
6677 inode->i_op = &btrfs_file_inode_operations; in btrfs_create()
6678 inode->i_mapping->a_ops = &btrfs_aops; in btrfs_create()
6686 struct btrfs_root *root = BTRFS_I(dir)->root; in btrfs_link()
6688 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); in btrfs_link()
6694 if (root->root_key.objectid != BTRFS_I(inode)->root->root_key.objectid) in btrfs_link()
6695 return -EXDEV; in btrfs_link()
6697 if (inode->i_nlink >= BTRFS_LINK_MAX) in btrfs_link()
6698 return -EMLINK; in btrfs_link()
6710 trans = btrfs_start_transaction(root, inode->i_nlink ? 5 : 6); in btrfs_link()
6718 BTRFS_I(inode)->dir_index = 0ULL; in btrfs_link()
6721 inode->i_ctime = current_time(inode); in btrfs_link()
6723 set_bit(BTRFS_INODE_COPY_EVERYTHING, &BTRFS_I(inode)->runtime_flags); in btrfs_link()
6726 dentry->d_name.name, dentry->d_name.len, 1, index); in btrfs_link()
6731 struct dentry *parent = dentry->d_parent; in btrfs_link()
6736 if (inode->i_nlink == 1) { in btrfs_link()
6765 inode = new_inode(dir->i_sb); in btrfs_mkdir()
6767 return -ENOMEM; in btrfs_mkdir()
6769 inode->i_op = &btrfs_dir_inode_operations; in btrfs_mkdir()
6770 inode->i_fop = &btrfs_dir_file_operations; in btrfs_mkdir()
6780 struct extent_buffer *leaf = path->nodes[0]; in uncompress_inline()
6790 inline_size = btrfs_file_extent_inline_item_len(leaf, path->slots[0]); in uncompress_inline()
6793 return -ENOMEM; in uncompress_inline()
6812 PAGE_SIZE - max_size - pg_offset); in uncompress_inline()
6818 * btrfs_get_extent - Lookup the first extent overlapping a range in a file.
6826 * range, reading it from the B-tree and caching it if necessary. Note that
6833 * Return: ERR_PTR on error, non-NULL extent_map on success.
6839 struct btrfs_fs_info *fs_info = inode->root->fs_info; in btrfs_get_extent()
6844 int extent_type = -1; in btrfs_get_extent()
6846 struct btrfs_root *root = inode->root; in btrfs_get_extent()
6851 struct extent_map_tree *em_tree = &inode->extent_tree; in btrfs_get_extent()
6853 read_lock(&em_tree->lock); in btrfs_get_extent()
6855 read_unlock(&em_tree->lock); in btrfs_get_extent()
6858 if (em->start > start || em->start + em->len <= start) in btrfs_get_extent()
6860 else if (em->block_start == EXTENT_MAP_INLINE && page) in btrfs_get_extent()
6867 ret = -ENOMEM; in btrfs_get_extent()
6870 em->start = EXTENT_MAP_HOLE; in btrfs_get_extent()
6871 em->orig_start = EXTENT_MAP_HOLE; in btrfs_get_extent()
6872 em->len = (u64)-1; in btrfs_get_extent()
6873 em->block_len = (u64)-1; in btrfs_get_extent()
6877 ret = -ENOMEM; in btrfs_get_extent()
6882 path->reada = READA_FORWARD; in btrfs_get_extent()
6890 path->search_commit_root = 1; in btrfs_get_extent()
6891 path->skip_locking = 1; in btrfs_get_extent()
6898 if (path->slots[0] == 0) in btrfs_get_extent()
6900 path->slots[0]--; in btrfs_get_extent()
6904 leaf = path->nodes[0]; in btrfs_get_extent()
6905 item = btrfs_item_ptr(leaf, path->slots[0], in btrfs_get_extent()
6907 btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]); in btrfs_get_extent()
6926 if (!S_ISREG(inode->vfs_inode.i_mode)) { in btrfs_get_extent()
6927 ret = -EUCLEAN; in btrfs_get_extent()
6929 "regular/prealloc extent found for non-regular inode %llu", in btrfs_get_extent()
6937 path->slots[0], in btrfs_get_extent()
6942 path->slots[0]++; in btrfs_get_extent()
6943 if (path->slots[0] >= btrfs_header_nritems(leaf)) { in btrfs_get_extent()
6950 leaf = path->nodes[0]; in btrfs_get_extent()
6952 btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]); in btrfs_get_extent()
6962 em->start = start; in btrfs_get_extent()
6963 em->orig_start = start; in btrfs_get_extent()
6964 em->len = found_key.offset - start; in btrfs_get_extent()
6965 em->block_start = EXTENT_MAP_HOLE; in btrfs_get_extent()
6985 extent_offset = page_offset(page) + pg_offset - extent_start; in btrfs_get_extent()
6986 copy_size = min_t(u64, PAGE_SIZE - pg_offset, in btrfs_get_extent()
6987 size - extent_offset); in btrfs_get_extent()
6988 em->start = extent_start + extent_offset; in btrfs_get_extent()
6989 em->len = ALIGN(copy_size, fs_info->sectorsize); in btrfs_get_extent()
6990 em->orig_block_len = em->len; in btrfs_get_extent()
6991 em->orig_start = em->start; in btrfs_get_extent()
7007 PAGE_SIZE - pg_offset - in btrfs_get_extent()
7017 em->start = start; in btrfs_get_extent()
7018 em->orig_start = start; in btrfs_get_extent()
7019 em->len = len; in btrfs_get_extent()
7020 em->block_start = EXTENT_MAP_HOLE; in btrfs_get_extent()
7024 if (em->start > start || extent_map_end(em) <= start) { in btrfs_get_extent()
7027 em->start, em->len, start, len); in btrfs_get_extent()
7028 ret = -EIO; in btrfs_get_extent()
7032 write_lock(&em_tree->lock); in btrfs_get_extent()
7034 write_unlock(&em_tree->lock); in btrfs_get_extent()
7077 start + len - 1, false); in btrfs_create_dio_extent()
7089 struct btrfs_root *root = inode->root; in btrfs_new_extent_direct()
7090 struct btrfs_fs_info *fs_info = root->fs_info; in btrfs_new_extent_direct()
7097 ret = btrfs_reserve_extent(root, len, len, fs_info->sectorsize, in btrfs_new_extent_direct()
7119 if (!block_group || block_group->ro) in btrfs_extent_readonly()
7133 * @orig_len: (optional) Return the original on-disk length of the file extent
7150 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); in can_nocow_extent()
7155 struct btrfs_root *root = BTRFS_I(inode)->root; in can_nocow_extent()
7156 struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree; in can_nocow_extent()
7163 return -ENOMEM; in can_nocow_extent()
7164 path->nowait = nowait; in can_nocow_extent()
7172 if (path->slots[0] == 0) { in can_nocow_extent()
7177 path->slots[0]--; in can_nocow_extent()
7180 leaf = path->nodes[0]; in can_nocow_extent()
7181 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]); in can_nocow_extent()
7196 fi = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_file_extent_item); in can_nocow_extent()
7202 nocow_args.end = offset + *len - 1; in can_nocow_extent()
7220 if (!(BTRFS_I(inode)->flags & BTRFS_INODE_NODATACOW) && in can_nocow_extent()
7225 root->fs_info->sectorsize) - 1; in can_nocow_extent()
7229 ret = -EAGAIN; in can_nocow_extent()
7235 *orig_start = key.offset - nocow_args.extent_offset; in can_nocow_extent()
7252 struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree; in lock_extent_direct()
7259 return -EAGAIN; in lock_extent_direct()
7269 lockend - lockstart + 1); in lock_extent_direct()
7279 (!writing || !filemap_range_has_page(inode->i_mapping, in lock_extent_direct()
7288 ret = -EAGAIN; in lock_extent_direct()
7307 test_bit(BTRFS_ORDERED_DIRECT, &ordered->flags)) in lock_extent_direct()
7310 ret = nowait ? -EAGAIN : -ENOTBLK; in lock_extent_direct()
7326 ret = nowait ? -EAGAIN : -ENOTBLK; in lock_extent_direct()
7355 return ERR_PTR(-ENOMEM); in create_io_em()
7357 em->start = start; in create_io_em()
7358 em->orig_start = orig_start; in create_io_em()
7359 em->len = len; in create_io_em()
7360 em->block_len = block_len; in create_io_em()
7361 em->block_start = block_start; in create_io_em()
7362 em->orig_block_len = orig_block_len; in create_io_em()
7363 em->ram_bytes = ram_bytes; in create_io_em()
7364 em->generation = -1; in create_io_em()
7365 set_bit(EXTENT_FLAG_PINNED, &em->flags); in create_io_em()
7367 set_bit(EXTENT_FLAG_FILLING, &em->flags); in create_io_em()
7369 set_bit(EXTENT_FLAG_COMPRESSED, &em->flags); in create_io_em()
7370 em->compress_type = compress_type; in create_io_em()
7391 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); in btrfs_get_blocks_direct_write()
7410 if (test_bit(EXTENT_FLAG_PREALLOC, &em->flags) || in btrfs_get_blocks_direct_write()
7411 ((BTRFS_I(inode)->flags & BTRFS_INODE_NODATACOW) && in btrfs_get_blocks_direct_write()
7412 em->block_start != EXTENT_MAP_HOLE)) { in btrfs_get_blocks_direct_write()
7413 if (test_bit(EXTENT_FLAG_PREALLOC, &em->flags)) in btrfs_get_blocks_direct_write()
7417 len = min(len, em->len - (start - em->start)); in btrfs_get_blocks_direct_write()
7418 block_start = em->block_start + (start - em->start); in btrfs_get_blocks_direct_write()
7440 if (nowait && (ret == -ENOSPC || ret == -EDQUOT)) in btrfs_get_blocks_direct_write()
7441 ret = -EAGAIN; in btrfs_get_blocks_direct_write()
7462 dio_data->nocow_done = true; in btrfs_get_blocks_direct_write()
7469 return -EAGAIN; in btrfs_get_blocks_direct_write()
7475 if (!dio_data->data_space_reserved) in btrfs_get_blocks_direct_write()
7476 return -ENOSPC; in btrfs_get_blocks_direct_write()
7494 len = min(len, em->len - (start - em->start)); in btrfs_get_blocks_direct_write()
7497 prev_len - len, true); in btrfs_get_blocks_direct_write()
7525 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); in btrfs_dio_iomap_begin()
7528 struct btrfs_dio_data *dio_data = iter->private; in btrfs_dio_iomap_begin()
7545 * -EAGAIN at this point so that the normal path is used. in btrfs_dio_iomap_begin()
7548 return -EAGAIN; in btrfs_dio_iomap_begin()
7555 len = min_t(u64, len, fs_info->sectorsize * BTRFS_MAX_BIO_SECTORS); in btrfs_dio_iomap_begin()
7558 lockend = start + len - 1; in btrfs_dio_iomap_begin()
7564 * outstanding dirty pages are on disk - the first flush only starts in btrfs_dio_iomap_begin()
7572 * dirty or under writeback (same as for the non-compression case). in btrfs_dio_iomap_begin()
7579 &BTRFS_I(inode)->runtime_flags)) { in btrfs_dio_iomap_begin()
7581 if (filemap_range_needs_writeback(inode->i_mapping, in btrfs_dio_iomap_begin()
7583 return -EAGAIN; in btrfs_dio_iomap_begin()
7585 ret = filemap_fdatawrite_range(inode->i_mapping, start, in btrfs_dio_iomap_begin()
7586 start + length - 1); in btrfs_dio_iomap_begin()
7605 &dio_data->data_reserved, in btrfs_dio_iomap_begin()
7608 dio_data->data_space_reserved = true; in btrfs_dio_iomap_begin()
7609 else if (ret && !(BTRFS_I(inode)->flags & in btrfs_dio_iomap_begin()
7639 * We return -ENOTBLK because that's what makes DIO go ahead and go back in btrfs_dio_iomap_begin()
7643 if (test_bit(EXTENT_FLAG_COMPRESSED, &em->flags) || in btrfs_dio_iomap_begin()
7644 em->block_start == EXTENT_MAP_INLINE) { in btrfs_dio_iomap_begin()
7647 * If we are in a NOWAIT context, return -EAGAIN in order to in btrfs_dio_iomap_begin()
7651 * space - this happens if we were able to read some data from in btrfs_dio_iomap_begin()
7652 * previous non-compressed extents and then when we fallback to in btrfs_dio_iomap_begin()
7656 * of bytes previously read is > 0, so it does not return -EFAULT). in btrfs_dio_iomap_begin()
7658 ret = (flags & IOMAP_NOWAIT) ? -EAGAIN : -ENOTBLK; in btrfs_dio_iomap_begin()
7662 len = min(len, em->len - (start - em->start)); in btrfs_dio_iomap_begin()
7666 * (or a mix of extents and holes), then we return -EAGAIN to make the in btrfs_dio_iomap_begin()
7682 * which we return back to our caller - we should only return EIOCBQUEUED in btrfs_dio_iomap_begin()
7687 ret = -EAGAIN; in btrfs_dio_iomap_begin()
7698 len = min(len, em->len - (start - em->start)); in btrfs_dio_iomap_begin()
7699 if (dio_data->data_space_reserved) { in btrfs_dio_iomap_begin()
7703 if (dio_data->nocow_done) { in btrfs_dio_iomap_begin()
7708 release_len = data_alloc_len - len; in btrfs_dio_iomap_begin()
7713 dio_data->data_reserved, in btrfs_dio_iomap_begin()
7728 unlock_extent(&BTRFS_I(inode)->io_tree, lockstart, lockend, in btrfs_dio_iomap_begin()
7738 if ((em->block_start == EXTENT_MAP_HOLE) || in btrfs_dio_iomap_begin()
7739 (test_bit(EXTENT_FLAG_PREALLOC, &em->flags) && !write)) { in btrfs_dio_iomap_begin()
7740 iomap->addr = IOMAP_NULL_ADDR; in btrfs_dio_iomap_begin()
7741 iomap->type = IOMAP_HOLE; in btrfs_dio_iomap_begin()
7743 iomap->addr = em->block_start + (start - em->start); in btrfs_dio_iomap_begin()
7744 iomap->type = IOMAP_MAPPED; in btrfs_dio_iomap_begin()
7746 iomap->offset = start; in btrfs_dio_iomap_begin()
7747 iomap->bdev = fs_info->fs_devices->latest_dev->bdev; in btrfs_dio_iomap_begin()
7748 iomap->length = len; in btrfs_dio_iomap_begin()
7750 if (write && btrfs_use_zone_append(BTRFS_I(inode), em->block_start)) in btrfs_dio_iomap_begin()
7751 iomap->flags |= IOMAP_F_ZONE_APPEND; in btrfs_dio_iomap_begin()
7758 unlock_extent(&BTRFS_I(inode)->io_tree, lockstart, lockend, in btrfs_dio_iomap_begin()
7761 if (dio_data->data_space_reserved) { in btrfs_dio_iomap_begin()
7763 dio_data->data_reserved, in btrfs_dio_iomap_begin()
7765 extent_changeset_free(dio_data->data_reserved); in btrfs_dio_iomap_begin()
7775 struct btrfs_dio_data *dio_data = iter->private; in btrfs_dio_iomap_end()
7776 size_t submitted = dio_data->submitted; in btrfs_dio_iomap_end()
7780 if (!write && (iomap->type == IOMAP_HOLE)) { in btrfs_dio_iomap_end()
7782 unlock_extent(&BTRFS_I(inode)->io_tree, pos, pos + length - 1, in btrfs_dio_iomap_end()
7789 length -= submitted; in btrfs_dio_iomap_end()
7794 unlock_extent(&BTRFS_I(inode)->io_tree, pos, in btrfs_dio_iomap_end()
7795 pos + length - 1, NULL); in btrfs_dio_iomap_end()
7796 ret = -ENOTBLK; in btrfs_dio_iomap_end()
7800 extent_changeset_free(dio_data->data_reserved); in btrfs_dio_iomap_end()
7807 * This implies a barrier so that stores to dio_bio->bi_status before in btrfs_dio_private_put()
7808 * this and loads of dio_bio->bi_status after this are fully ordered. in btrfs_dio_private_put()
7810 if (!refcount_dec_and_test(&dip->refs)) in btrfs_dio_private_put()
7813 if (btrfs_op(&dip->bio) == BTRFS_MAP_WRITE) { in btrfs_dio_private_put()
7814 btrfs_mark_ordered_io_finished(BTRFS_I(dip->inode), NULL, in btrfs_dio_private_put()
7815 dip->file_offset, dip->bytes, in btrfs_dio_private_put()
7816 !dip->bio.bi_status); in btrfs_dio_private_put()
7818 unlock_extent(&BTRFS_I(dip->inode)->io_tree, in btrfs_dio_private_put()
7819 dip->file_offset, in btrfs_dio_private_put()
7820 dip->file_offset + dip->bytes - 1, NULL); in btrfs_dio_private_put()
7823 kfree(dip->csums); in btrfs_dio_private_put()
7824 bio_endio(&dip->bio); in btrfs_dio_private_put()
7831 struct btrfs_dio_private *dip = btrfs_bio(bio)->private; in submit_dio_repair_bio()
7832 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); in submit_dio_repair_bio()
7836 refcount_inc(&dip->refs); in submit_dio_repair_bio()
7844 struct inode *inode = dip->inode; in btrfs_check_read_dio_bio()
7845 struct btrfs_fs_info *fs_info = BTRFS_I(inode)->root->fs_info; in btrfs_check_read_dio_bio()
7846 const bool csum = !(BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM); in btrfs_check_read_dio_bio()
7853 u64 start = bbio->file_offset + offset; in btrfs_check_read_dio_bio()
7883 struct btrfs_dio_private *dip = bbio->private; in btrfs_end_dio_bio()
7884 struct bio *bio = &bbio->bio; in btrfs_end_dio_bio()
7885 blk_status_t err = bio->bi_status; in btrfs_end_dio_bio()
7888 btrfs_warn(BTRFS_I(dip->inode)->root->fs_info, in btrfs_end_dio_bio()
7890 btrfs_ino(BTRFS_I(dip->inode)), bio_op(bio), in btrfs_end_dio_bio()
7891 bio->bi_opf, bio->bi_iter.bi_sector, in btrfs_end_dio_bio()
7892 bio->bi_iter.bi_size, err); in btrfs_end_dio_bio()
7898 dip->bio.bi_status = err; in btrfs_end_dio_bio()
7900 btrfs_record_physical_zoned(dip->inode, bbio->file_offset, bio); in btrfs_end_dio_bio()
7909 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); in btrfs_submit_dio_bio()
7910 struct btrfs_dio_private *dip = btrfs_bio(bio)->private; in btrfs_submit_dio_bio()
7915 btrfs_bio(bio)->iter = bio->bi_iter; in btrfs_submit_dio_bio()
7917 if (BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM) in btrfs_submit_dio_bio()
7922 if (async_submit && !atomic_read(&BTRFS_I(inode)->sync_writers) && in btrfs_submit_dio_bio()
7937 btrfs_bio(bio)->csum = btrfs_csum_ptr(fs_info, dip->csums, in btrfs_submit_dio_bio()
7938 file_offset - dip->file_offset); in btrfs_submit_dio_bio()
7949 struct inode *inode = iter->inode; in btrfs_submit_direct()
7951 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); in btrfs_submit_direct()
7964 struct btrfs_dio_data *dio_data = iter->private; in btrfs_submit_direct()
7967 dip->inode = inode; in btrfs_submit_direct()
7968 dip->file_offset = file_offset; in btrfs_submit_direct()
7969 dip->bytes = dio_bio->bi_iter.bi_size; in btrfs_submit_direct()
7970 refcount_set(&dip->refs, 1); in btrfs_submit_direct()
7971 dip->csums = NULL; in btrfs_submit_direct()
7973 if (!write && !(BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM)) { in btrfs_submit_direct()
7975 (dio_bio->bi_iter.bi_size >> fs_info->sectorsize_bits); in btrfs_submit_direct()
7982 dip->csums = kcalloc(nr_sectors, fs_info->csum_size, GFP_NOFS); in btrfs_submit_direct()
7983 if (!dip->csums) in btrfs_submit_direct()
7986 status = btrfs_lookup_bio_sums(inode, dio_bio, dip->csums); in btrfs_submit_direct()
7991 start_sector = dio_bio->bi_iter.bi_sector; in btrfs_submit_direct()
7992 submit_len = dio_bio->bi_iter.bi_size; in btrfs_submit_direct()
8018 btrfs_bio(bio)->file_offset = file_offset; in btrfs_submit_direct()
8030 submit_len -= clone_len; in btrfs_submit_direct()
8042 refcount_inc(&dip->refs); in btrfs_submit_direct()
8055 dio_data->submitted += clone_len; in btrfs_submit_direct()
8067 dio_bio->bi_status = status; in btrfs_submit_direct()
8120 if (fieinfo->fi_flags & FIEMAP_FLAG_SYNC) { in btrfs_fiemap()
8143 * If we continue to release/invalidate the page, we could cause use-after-free
8149 struct btrfs_fs_info *fs_info = btrfs_sb(page->mapping->host->i_sb); in wait_subpage_spinlock()
8155 ASSERT(PagePrivate(page) && page->private); in wait_subpage_spinlock()
8156 subpage = (struct btrfs_subpage *)page->private; in wait_subpage_spinlock()
8169 spin_lock_irq(&subpage->lock); in wait_subpage_spinlock()
8170 spin_unlock_irq(&subpage->lock); in wait_subpage_spinlock()
8175 int ret = try_release_extent_mapping(&folio->page, gfp_flags); in __btrfs_release_folio()
8178 wait_subpage_spinlock(&folio->page); in __btrfs_release_folio()
8179 clear_page_extent_mapped(&folio->page); in __btrfs_release_folio()
8215 struct btrfs_inode *inode = BTRFS_I(folio->mapping->host); in btrfs_invalidate_folio()
8216 struct btrfs_fs_info *fs_info = inode->root->fs_info; in btrfs_invalidate_folio()
8217 struct extent_io_tree *tree = &inode->io_tree; in btrfs_invalidate_folio()
8220 u64 page_end = page_start + folio_size(folio) - 1; in btrfs_invalidate_folio()
8222 int inode_evicting = inode->vfs_inode.i_state & I_FREEING; in btrfs_invalidate_folio()
8238 wait_subpage_spinlock(&folio->page); in btrfs_invalidate_folio()
8245 * shouldn't clear page extent mapped, as folio->private can still in btrfs_invalidate_folio()
8268 page_end + 1 - cur); in btrfs_invalidate_folio()
8278 if (ordered->file_offset > cur) { in btrfs_invalidate_folio()
8280 * There is a range between [cur, oe->file_offset) not in btrfs_invalidate_folio()
8285 range_end = ordered->file_offset - 1; in btrfs_invalidate_folio()
8290 range_end = min(ordered->file_offset + ordered->num_bytes - 1, in btrfs_invalidate_folio()
8292 ASSERT(range_end + 1 - cur < U32_MAX); in btrfs_invalidate_folio()
8293 range_len = range_end + 1 - cur; in btrfs_invalidate_folio()
8294 if (!btrfs_page_test_ordered(fs_info, &folio->page, cur, range_len)) { in btrfs_invalidate_folio()
8303 btrfs_page_clear_ordered(fs_info, &folio->page, cur, range_len); in btrfs_invalidate_folio()
8319 spin_lock_irq(&inode->ordered_tree.lock); in btrfs_invalidate_folio()
8320 set_bit(BTRFS_ORDERED_TRUNCATED, &ordered->flags); in btrfs_invalidate_folio()
8321 ordered->truncated_len = min(ordered->truncated_len, in btrfs_invalidate_folio()
8322 cur - ordered->file_offset); in btrfs_invalidate_folio()
8323 spin_unlock_irq(&inode->ordered_tree.lock); in btrfs_invalidate_folio()
8332 cur, range_end + 1 - cur)) { in btrfs_invalidate_folio()
8358 btrfs_qgroup_free_data(inode, NULL, cur, range_end + 1 - cur); in btrfs_invalidate_folio()
8373 btrfs_page_clear_checked(fs_info, &folio->page, folio_pos(folio), folio_size(folio)); in btrfs_invalidate_folio()
8376 clear_page_extent_mapped(&folio->page); in btrfs_invalidate_folio()
8396 struct page *page = vmf->page; in btrfs_page_mkwrite()
8397 struct inode *inode = file_inode(vmf->vma->vm_file); in btrfs_page_mkwrite()
8398 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); in btrfs_page_mkwrite()
8399 struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree; in btrfs_page_mkwrite()
8415 sb_start_pagefault(inode->i_sb); in btrfs_page_mkwrite()
8417 page_end = page_start + PAGE_SIZE - 1; in btrfs_page_mkwrite()
8431 ret2 = file_update_time(vmf->vma->vm_file); in btrfs_page_mkwrite()
8443 down_read(&BTRFS_I(inode)->i_mmap_lock); in btrfs_page_mkwrite()
8447 if ((page->mapping != inode->i_mapping) || in btrfs_page_mkwrite()
8471 up_read(&BTRFS_I(inode)->i_mmap_lock); in btrfs_page_mkwrite()
8477 if (page->index == ((size - 1) >> PAGE_SHIFT)) { in btrfs_page_mkwrite()
8478 reserved_space = round_up(size - page_start, in btrfs_page_mkwrite()
8479 fs_info->sectorsize); in btrfs_page_mkwrite()
8481 end = page_start + reserved_space - 1; in btrfs_page_mkwrite()
8484 PAGE_SIZE - reserved_space, true); in btrfs_page_mkwrite()
8495 clear_extent_bit(&BTRFS_I(inode)->io_tree, page_start, end, in btrfs_page_mkwrite()
8514 memzero_page(page, zero_start, PAGE_SIZE - zero_start); in btrfs_page_mkwrite()
8517 btrfs_page_set_dirty(fs_info, page, page_start, end + 1 - page_start); in btrfs_page_mkwrite()
8518 btrfs_page_set_uptodate(fs_info, page, page_start, end + 1 - page_start); in btrfs_page_mkwrite()
8523 up_read(&BTRFS_I(inode)->i_mmap_lock); in btrfs_page_mkwrite()
8526 sb_end_pagefault(inode->i_sb); in btrfs_page_mkwrite()
8532 up_read(&BTRFS_I(inode)->i_mmap_lock); in btrfs_page_mkwrite()
8538 sb_end_pagefault(inode->i_sb); in btrfs_page_mkwrite()
8551 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); in btrfs_truncate()
8552 struct btrfs_root *root = BTRFS_I(inode)->root; in btrfs_truncate()
8556 u64 mask = fs_info->sectorsize - 1; in btrfs_truncate()
8560 ret = btrfs_wait_ordered_range(inode, inode->i_size & (~mask), in btrfs_truncate()
8561 (u64)-1); in btrfs_truncate()
8589 * 1) rsv - for the truncate reservation, which we will steal from the in btrfs_truncate()
8591 * 2) fs_info->trans_block_rsv - this will have 1 items worth left for in btrfs_truncate()
8596 return -ENOMEM; in btrfs_truncate()
8597 rsv->size = min_size; in btrfs_truncate()
8598 rsv->failfast = true; in btrfs_truncate()
8611 ret = btrfs_block_rsv_migrate(&fs_info->trans_block_rsv, rsv, in btrfs_truncate()
8615 trans->block_rsv = rsv; in btrfs_truncate()
8619 const u64 new_size = inode->i_size; in btrfs_truncate()
8620 const u64 lock_start = ALIGN_DOWN(new_size, fs_info->sectorsize); in btrfs_truncate()
8623 lock_extent(&BTRFS_I(inode)->io_tree, lock_start, (u64)-1, in btrfs_truncate()
8631 ALIGN(new_size, fs_info->sectorsize), in btrfs_truncate()
8632 (u64)-1, false); in btrfs_truncate()
8639 unlock_extent(&BTRFS_I(inode)->io_tree, lock_start, (u64)-1, in btrfs_truncate()
8642 trans->block_rsv = &fs_info->trans_block_rsv; in btrfs_truncate()
8643 if (ret != -ENOSPC && ret != -EAGAIN) in btrfs_truncate()
8660 btrfs_block_rsv_release(fs_info, rsv, -1, NULL); in btrfs_truncate()
8661 ret = btrfs_block_rsv_migrate(&fs_info->trans_block_rsv, in btrfs_truncate()
8664 trans->block_rsv = rsv; in btrfs_truncate()
8677 ret = btrfs_truncate_block(BTRFS_I(inode), inode->i_size, 0, 0); in btrfs_truncate()
8691 trans->block_rsv = &fs_info->trans_block_rsv; in btrfs_truncate()
8711 * fsync to truncate all the inode's items from the log and re-log them in btrfs_truncate()
8728 inode = new_inode(dir->i_sb); in btrfs_new_subvol_inode()
8736 inode->i_op = &btrfs_dir_inode_operations; in btrfs_new_subvol_inode()
8737 inode->i_fop = &btrfs_dir_file_operations; in btrfs_new_subvol_inode()
8752 ei->root = NULL; in btrfs_alloc_inode()
8753 ei->generation = 0; in btrfs_alloc_inode()
8754 ei->last_trans = 0; in btrfs_alloc_inode()
8755 ei->last_sub_trans = 0; in btrfs_alloc_inode()
8756 ei->logged_trans = 0; in btrfs_alloc_inode()
8757 ei->delalloc_bytes = 0; in btrfs_alloc_inode()
8758 ei->new_delalloc_bytes = 0; in btrfs_alloc_inode()
8759 ei->defrag_bytes = 0; in btrfs_alloc_inode()
8760 ei->disk_i_size = 0; in btrfs_alloc_inode()
8761 ei->flags = 0; in btrfs_alloc_inode()
8762 ei->ro_flags = 0; in btrfs_alloc_inode()
8763 ei->csum_bytes = 0; in btrfs_alloc_inode()
8764 ei->index_cnt = (u64)-1; in btrfs_alloc_inode()
8765 ei->dir_index = 0; in btrfs_alloc_inode()
8766 ei->last_unlink_trans = 0; in btrfs_alloc_inode()
8767 ei->last_reflink_trans = 0; in btrfs_alloc_inode()
8768 ei->last_log_commit = 0; in btrfs_alloc_inode()
8770 spin_lock_init(&ei->lock); in btrfs_alloc_inode()
8771 spin_lock_init(&ei->io_failure_lock); in btrfs_alloc_inode()
8772 ei->outstanding_extents = 0; in btrfs_alloc_inode()
8773 if (sb->s_magic != BTRFS_TEST_MAGIC) in btrfs_alloc_inode()
8774 btrfs_init_metadata_block_rsv(fs_info, &ei->block_rsv, in btrfs_alloc_inode()
8776 ei->runtime_flags = 0; in btrfs_alloc_inode()
8777 ei->prop_compress = BTRFS_COMPRESS_NONE; in btrfs_alloc_inode()
8778 ei->defrag_compress = BTRFS_COMPRESS_NONE; in btrfs_alloc_inode()
8780 ei->delayed_node = NULL; in btrfs_alloc_inode()
8782 ei->i_otime.tv_sec = 0; in btrfs_alloc_inode()
8783 ei->i_otime.tv_nsec = 0; in btrfs_alloc_inode()
8785 inode = &ei->vfs_inode; in btrfs_alloc_inode()
8786 extent_map_tree_init(&ei->extent_tree); in btrfs_alloc_inode()
8787 extent_io_tree_init(fs_info, &ei->io_tree, IO_TREE_INODE_IO, inode); in btrfs_alloc_inode()
8788 extent_io_tree_init(fs_info, &ei->file_extent_tree, in btrfs_alloc_inode()
8790 ei->io_failure_tree = RB_ROOT; in btrfs_alloc_inode()
8791 atomic_set(&ei->sync_writers, 0); in btrfs_alloc_inode()
8792 mutex_init(&ei->log_mutex); in btrfs_alloc_inode()
8793 btrfs_ordered_inode_tree_init(&ei->ordered_tree); in btrfs_alloc_inode()
8794 INIT_LIST_HEAD(&ei->delalloc_inodes); in btrfs_alloc_inode()
8795 INIT_LIST_HEAD(&ei->delayed_iput); in btrfs_alloc_inode()
8796 RB_CLEAR_NODE(&ei->rb_node); in btrfs_alloc_inode()
8797 init_rwsem(&ei->i_mmap_lock); in btrfs_alloc_inode()
8805 btrfs_drop_extent_map_range(BTRFS_I(inode), 0, (u64)-1, false); in btrfs_test_destroy_inode()
8819 struct btrfs_root *root = inode->root; in btrfs_destroy_inode()
8822 WARN_ON(!hlist_empty(&vfs_inode->i_dentry)); in btrfs_destroy_inode()
8823 WARN_ON(vfs_inode->i_data.nrpages); in btrfs_destroy_inode()
8824 WARN_ON(inode->block_rsv.reserved); in btrfs_destroy_inode()
8825 WARN_ON(inode->block_rsv.size); in btrfs_destroy_inode()
8826 WARN_ON(inode->outstanding_extents); in btrfs_destroy_inode()
8827 if (!S_ISDIR(vfs_inode->i_mode)) { in btrfs_destroy_inode()
8828 WARN_ON(inode->delalloc_bytes); in btrfs_destroy_inode()
8829 WARN_ON(inode->new_delalloc_bytes); in btrfs_destroy_inode()
8831 WARN_ON(inode->csum_bytes); in btrfs_destroy_inode()
8832 WARN_ON(inode->defrag_bytes); in btrfs_destroy_inode()
8849 ordered = btrfs_lookup_first_ordered_extent(inode, (u64)-1); in btrfs_destroy_inode()
8853 btrfs_err(root->fs_info, in btrfs_destroy_inode()
8855 ordered->file_offset, ordered->num_bytes); in btrfs_destroy_inode()
8858 btrfs_lockdep_acquire(root->fs_info, btrfs_ordered_extent); in btrfs_destroy_inode()
8867 btrfs_drop_extent_map_range(inode, 0, (u64)-1, false); in btrfs_destroy_inode()
8868 btrfs_inode_clear_file_extent_range(inode, 0, (u64)-1); in btrfs_destroy_inode()
8869 btrfs_put_root(inode->root); in btrfs_destroy_inode()
8874 struct btrfs_root *root = BTRFS_I(inode)->root; in btrfs_drop_inode()
8880 if (btrfs_root_refs(&root->root_item) == 0) in btrfs_drop_inode()
8886 static void init_once(void *foo) in init_once() argument
8888 struct btrfs_inode *ei = foo; in init_once()
8890 inode_init_once(&ei->vfs_inode); in init_once()
8949 return -ENOMEM; in btrfs_init_cachep()
8958 struct inode *inode = d_inode(path->dentry); in btrfs_getattr()
8959 u32 blocksize = inode->i_sb->s_blocksize; in btrfs_getattr()
8960 u32 bi_flags = BTRFS_I(inode)->flags; in btrfs_getattr()
8961 u32 bi_ro_flags = BTRFS_I(inode)->ro_flags; in btrfs_getattr()
8963 stat->result_mask |= STATX_BTIME; in btrfs_getattr()
8964 stat->btime.tv_sec = BTRFS_I(inode)->i_otime.tv_sec; in btrfs_getattr()
8965 stat->btime.tv_nsec = BTRFS_I(inode)->i_otime.tv_nsec; in btrfs_getattr()
8967 stat->attributes |= STATX_ATTR_APPEND; in btrfs_getattr()
8969 stat->attributes |= STATX_ATTR_COMPRESSED; in btrfs_getattr()
8971 stat->attributes |= STATX_ATTR_IMMUTABLE; in btrfs_getattr()
8973 stat->attributes |= STATX_ATTR_NODUMP; in btrfs_getattr()
8975 stat->attributes |= STATX_ATTR_VERITY; in btrfs_getattr()
8977 stat->attributes_mask |= (STATX_ATTR_APPEND | in btrfs_getattr()
8983 stat->dev = BTRFS_I(inode)->root->anon_dev; in btrfs_getattr()
8985 spin_lock(&BTRFS_I(inode)->lock); in btrfs_getattr()
8986 delalloc_bytes = BTRFS_I(inode)->new_delalloc_bytes; in btrfs_getattr()
8988 spin_unlock(&BTRFS_I(inode)->lock); in btrfs_getattr()
8989 stat->blocks = (ALIGN(inode_bytes, blocksize) + in btrfs_getattr()
8999 struct btrfs_fs_info *fs_info = btrfs_sb(old_dir->i_sb); in btrfs_rename_exchange()
9002 struct btrfs_root *root = BTRFS_I(old_dir)->root; in btrfs_rename_exchange()
9003 struct btrfs_root *dest = BTRFS_I(new_dir)->root; in btrfs_rename_exchange()
9004 struct inode *new_inode = new_dentry->d_inode; in btrfs_rename_exchange()
9005 struct inode *old_inode = old_dentry->d_inode; in btrfs_rename_exchange()
9018 * For non-subvolumes allow exchange only within one subvolume, in the in btrfs_rename_exchange()
9025 return -EXDEV; in btrfs_rename_exchange()
9030 down_read(&fs_info->subvol_sem); in btrfs_rename_exchange()
9086 BTRFS_I(old_inode)->dir_index = 0ULL; in btrfs_rename_exchange()
9087 BTRFS_I(new_inode)->dir_index = 0ULL; in btrfs_rename_exchange()
9095 new_dentry->d_name.name, in btrfs_rename_exchange()
9096 new_dentry->d_name.len, in btrfs_rename_exchange()
9111 old_dentry->d_name.name, in btrfs_rename_exchange()
9112 old_dentry->d_name.len, in btrfs_rename_exchange()
9128 old_dir->i_mtime = ctime; in btrfs_rename_exchange()
9129 old_dir->i_ctime = ctime; in btrfs_rename_exchange()
9130 new_dir->i_mtime = ctime; in btrfs_rename_exchange()
9131 new_dir->i_ctime = ctime; in btrfs_rename_exchange()
9132 old_inode->i_ctime = ctime; in btrfs_rename_exchange()
9133 new_inode->i_ctime = ctime; in btrfs_rename_exchange()
9135 if (old_dentry->d_parent != new_dentry->d_parent) { in btrfs_rename_exchange()
9147 BTRFS_I(old_dentry->d_inode), in btrfs_rename_exchange()
9148 old_dentry->d_name.name, in btrfs_rename_exchange()
9149 old_dentry->d_name.len, in btrfs_rename_exchange()
9164 BTRFS_I(new_dentry->d_inode), in btrfs_rename_exchange()
9165 new_dentry->d_name.name, in btrfs_rename_exchange()
9166 new_dentry->d_name.len, in btrfs_rename_exchange()
9177 new_dentry->d_name.name, in btrfs_rename_exchange()
9178 new_dentry->d_name.len, 0, old_idx); in btrfs_rename_exchange()
9185 old_dentry->d_name.name, in btrfs_rename_exchange()
9186 old_dentry->d_name.len, 0, new_idx); in btrfs_rename_exchange()
9192 if (old_inode->i_nlink == 1) in btrfs_rename_exchange()
9193 BTRFS_I(old_inode)->dir_index = old_idx; in btrfs_rename_exchange()
9194 if (new_inode->i_nlink == 1) in btrfs_rename_exchange()
9195 BTRFS_I(new_inode)->dir_index = new_idx; in btrfs_rename_exchange()
9211 old_rename_ctx.index, new_dentry->d_parent); in btrfs_rename_exchange()
9214 new_rename_ctx.index, old_dentry->d_parent); in btrfs_rename_exchange()
9227 up_read(&fs_info->subvol_sem); in btrfs_rename_exchange()
9237 inode = new_inode(dir->i_sb); in new_whiteout_inode()
9241 inode->i_op = &btrfs_special_inode_operations; in new_whiteout_inode()
9242 init_special_inode(inode, inode->i_mode, WHITEOUT_DEV); in new_whiteout_inode()
9252 struct btrfs_fs_info *fs_info = btrfs_sb(old_dir->i_sb); in btrfs_rename()
9259 struct btrfs_root *root = BTRFS_I(old_dir)->root; in btrfs_rename()
9260 struct btrfs_root *dest = BTRFS_I(new_dir)->root; in btrfs_rename()
9270 return -EPERM; in btrfs_rename()
9274 return -EXDEV; in btrfs_rename()
9278 return -ENOTEMPTY; in btrfs_rename()
9280 if (S_ISDIR(old_inode->i_mode) && new_inode && in btrfs_rename()
9281 new_inode->i_size > BTRFS_EMPTY_DIR_SIZE) in btrfs_rename()
9282 return -ENOTEMPTY; in btrfs_rename()
9286 ret = btrfs_check_dir_item_collision(dest, new_dir->i_ino, in btrfs_rename()
9287 new_dentry->d_name.name, in btrfs_rename()
9288 new_dentry->d_name.len); in btrfs_rename()
9291 if (ret == -EEXIST) { in btrfs_rename()
9298 /* maybe -EOVERFLOW */ in btrfs_rename()
9308 if (new_inode && S_ISREG(old_inode->i_mode) && new_inode->i_size) in btrfs_rename()
9309 filemap_flush(old_inode->i_mapping); in btrfs_rename()
9314 return -ENOMEM; in btrfs_rename()
9325 down_read(&fs_info->subvol_sem); in btrfs_rename()
9377 BTRFS_I(old_inode)->dir_index = 0ULL; in btrfs_rename()
9383 new_dentry->d_name.name, in btrfs_rename()
9384 new_dentry->d_name.len, in btrfs_rename()
9394 old_dir->i_mtime = current_time(old_dir); in btrfs_rename()
9395 old_dir->i_ctime = old_dir->i_mtime; in btrfs_rename()
9396 new_dir->i_mtime = old_dir->i_mtime; in btrfs_rename()
9397 new_dir->i_ctime = old_dir->i_mtime; in btrfs_rename()
9398 old_inode->i_ctime = old_dir->i_mtime; in btrfs_rename()
9400 if (old_dentry->d_parent != new_dentry->d_parent) in btrfs_rename()
9409 old_dentry->d_name.name, in btrfs_rename()
9410 old_dentry->d_name.len, in btrfs_rename()
9422 new_inode->i_ctime = current_time(new_inode); in btrfs_rename()
9426 BUG_ON(new_inode->i_nlink == 0); in btrfs_rename()
9430 new_dentry->d_name.name, in btrfs_rename()
9431 new_dentry->d_name.len); in btrfs_rename()
9433 if (!ret && new_inode->i_nlink == 0) in btrfs_rename()
9443 new_dentry->d_name.name, in btrfs_rename()
9444 new_dentry->d_name.len, 0, index); in btrfs_rename()
9450 if (old_inode->i_nlink == 1) in btrfs_rename()
9451 BTRFS_I(old_inode)->dir_index = index; in btrfs_rename()
9455 rename_ctx.index, new_dentry->d_parent); in btrfs_rename()
9473 up_read(&fs_info->subvol_sem); in btrfs_rename()
9489 return -EINVAL; in btrfs_rename2()
9498 btrfs_btree_balance_dirty(BTRFS_I(new_dir)->root->fs_info); in btrfs_rename2()
9517 inode = delalloc_work->inode; in btrfs_run_delalloc_work()
9518 filemap_flush(inode->i_mapping); in btrfs_run_delalloc_work()
9520 &BTRFS_I(inode)->runtime_flags)) in btrfs_run_delalloc_work()
9521 filemap_flush(inode->i_mapping); in btrfs_run_delalloc_work()
9524 complete(&delalloc_work->completion); in btrfs_run_delalloc_work()
9535 init_completion(&work->completion); in btrfs_alloc_delalloc_work()
9536 INIT_LIST_HEAD(&work->list); in btrfs_alloc_delalloc_work()
9537 work->inode = inode; in btrfs_alloc_delalloc_work()
9538 btrfs_init_work(&work->work, btrfs_run_delalloc_work, NULL, NULL); in btrfs_alloc_delalloc_work()
9557 bool full_flush = wbc->nr_to_write == LONG_MAX; in start_delalloc_inodes()
9562 mutex_lock(&root->delalloc_mutex); in start_delalloc_inodes()
9563 spin_lock(&root->delalloc_lock); in start_delalloc_inodes()
9564 list_splice_init(&root->delalloc_inodes, &splice); in start_delalloc_inodes()
9569 list_move_tail(&binode->delalloc_inodes, in start_delalloc_inodes()
9570 &root->delalloc_inodes); in start_delalloc_inodes()
9573 test_bit(BTRFS_INODE_NO_DELALLOC_FLUSH, &binode->runtime_flags)) in start_delalloc_inodes()
9576 inode = igrab(&binode->vfs_inode); in start_delalloc_inodes()
9578 cond_resched_lock(&root->delalloc_lock); in start_delalloc_inodes()
9581 spin_unlock(&root->delalloc_lock); in start_delalloc_inodes()
9585 &binode->runtime_flags); in start_delalloc_inodes()
9590 ret = -ENOMEM; in start_delalloc_inodes()
9593 list_add_tail(&work->list, &works); in start_delalloc_inodes()
9594 btrfs_queue_work(root->fs_info->flush_workers, in start_delalloc_inodes()
9595 &work->work); in start_delalloc_inodes()
9597 ret = filemap_fdatawrite_wbc(inode->i_mapping, wbc); in start_delalloc_inodes()
9599 if (ret || wbc->nr_to_write <= 0) in start_delalloc_inodes()
9603 spin_lock(&root->delalloc_lock); in start_delalloc_inodes()
9605 spin_unlock(&root->delalloc_lock); in start_delalloc_inodes()
9609 list_del_init(&work->list); in start_delalloc_inodes()
9610 wait_for_completion(&work->completion); in start_delalloc_inodes()
9615 spin_lock(&root->delalloc_lock); in start_delalloc_inodes()
9616 list_splice_tail(&splice, &root->delalloc_inodes); in start_delalloc_inodes()
9617 spin_unlock(&root->delalloc_lock); in start_delalloc_inodes()
9619 mutex_unlock(&root->delalloc_mutex); in start_delalloc_inodes()
9631 struct btrfs_fs_info *fs_info = root->fs_info; in btrfs_start_delalloc_snapshot()
9634 return -EROFS; in btrfs_start_delalloc_snapshot()
9653 return -EROFS; in btrfs_start_delalloc_roots()
9657 mutex_lock(&fs_info->delalloc_root_mutex); in btrfs_start_delalloc_roots()
9658 spin_lock(&fs_info->delalloc_root_lock); in btrfs_start_delalloc_roots()
9659 list_splice_init(&fs_info->delalloc_roots, &splice); in btrfs_start_delalloc_roots()
9672 list_move_tail(&root->delalloc_root, in btrfs_start_delalloc_roots()
9673 &fs_info->delalloc_roots); in btrfs_start_delalloc_roots()
9674 spin_unlock(&fs_info->delalloc_root_lock); in btrfs_start_delalloc_roots()
9680 spin_lock(&fs_info->delalloc_root_lock); in btrfs_start_delalloc_roots()
9682 spin_unlock(&fs_info->delalloc_root_lock); in btrfs_start_delalloc_roots()
9687 spin_lock(&fs_info->delalloc_root_lock); in btrfs_start_delalloc_roots()
9688 list_splice_tail(&splice, &fs_info->delalloc_roots); in btrfs_start_delalloc_roots()
9689 spin_unlock(&fs_info->delalloc_root_lock); in btrfs_start_delalloc_roots()
9691 mutex_unlock(&fs_info->delalloc_root_mutex); in btrfs_start_delalloc_roots()
9698 struct btrfs_fs_info *fs_info = btrfs_sb(dir->i_sb); in btrfs_symlink()
9700 struct btrfs_root *root = BTRFS_I(dir)->root; in btrfs_symlink()
9718 return -ENAMETOOLONG; in btrfs_symlink()
9720 inode = new_inode(dir->i_sb); in btrfs_symlink()
9722 return -ENOMEM; in btrfs_symlink()
9724 inode->i_op = &btrfs_symlink_inode_operations; in btrfs_symlink()
9726 inode->i_mapping->a_ops = &btrfs_aops; in btrfs_symlink()
9749 err = -ENOMEM; in btrfs_symlink()
9768 leaf = path->nodes[0]; in btrfs_symlink()
9769 ei = btrfs_item_ptr(leaf, path->slots[0], in btrfs_symlink()
9771 btrfs_set_file_extent_generation(leaf, ei, trans->transid); in btrfs_symlink()
9807 u64 start = ins->objectid; in insert_prealloc_file_extent()
9808 u64 len = ins->offset; in insert_prealloc_file_extent()
9848 ret = -ENOMEM; in insert_prealloc_file_extent()
9853 file_offset + len - 1, &extent_info, in insert_prealloc_file_extent()
9868 btrfs_qgroup_free_refroot(inode->root->fs_info, in insert_prealloc_file_extent()
9869 inode->root->root_key.objectid, qgroup_released, in insert_prealloc_file_extent()
9879 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); in __btrfs_prealloc_file_range()
9881 struct btrfs_root *root = BTRFS_I(inode)->root; in __btrfs_prealloc_file_range()
9887 u64 last_alloc = (u64)-1; in __btrfs_prealloc_file_range()
9890 u64 end = start + num_bytes - 1; in __btrfs_prealloc_file_range()
9911 * ->bytes_may_use to ->bytes_reserved. Any error that happens in __btrfs_prealloc_file_range()
9938 cur_offset + ins.offset - 1, false); in __btrfs_prealloc_file_range()
9943 em->start = cur_offset; in __btrfs_prealloc_file_range()
9944 em->orig_start = cur_offset; in __btrfs_prealloc_file_range()
9945 em->len = ins.offset; in __btrfs_prealloc_file_range()
9946 em->block_start = ins.objectid; in __btrfs_prealloc_file_range()
9947 em->block_len = ins.offset; in __btrfs_prealloc_file_range()
9948 em->orig_block_len = ins.offset; in __btrfs_prealloc_file_range()
9949 em->ram_bytes = ins.offset; in __btrfs_prealloc_file_range()
9950 set_bit(EXTENT_FLAG_PREALLOC, &em->flags); in __btrfs_prealloc_file_range()
9951 em->generation = trans->transid; in __btrfs_prealloc_file_range()
9956 num_bytes -= ins.offset; in __btrfs_prealloc_file_range()
9961 inode->i_ctime = current_time(inode); in __btrfs_prealloc_file_range()
9962 BTRFS_I(inode)->flags |= BTRFS_INODE_PREALLOC; in __btrfs_prealloc_file_range()
9964 (actual_len > inode->i_size) && in __btrfs_prealloc_file_range()
9965 (cur_offset > inode->i_size)) { in __btrfs_prealloc_file_range()
9990 end - clear_offset + 1); in __btrfs_prealloc_file_range()
10015 struct btrfs_root *root = BTRFS_I(inode)->root; in btrfs_permission()
10016 umode_t mode = inode->i_mode; in btrfs_permission()
10021 return -EROFS; in btrfs_permission()
10022 if (BTRFS_I(inode)->flags & BTRFS_INODE_READONLY) in btrfs_permission()
10023 return -EACCES; in btrfs_permission()
10031 struct btrfs_fs_info *fs_info = btrfs_sb(dir->i_sb); in btrfs_tmpfile()
10033 struct btrfs_root *root = BTRFS_I(dir)->root; in btrfs_tmpfile()
10037 .dentry = file->f_path.dentry, in btrfs_tmpfile()
10043 inode = new_inode(dir->i_sb); in btrfs_tmpfile()
10045 return -ENOMEM; in btrfs_tmpfile()
10047 inode->i_fop = &btrfs_file_operations; in btrfs_tmpfile()
10048 inode->i_op = &btrfs_file_inode_operations; in btrfs_tmpfile()
10049 inode->i_mapping->a_ops = &btrfs_aops; in btrfs_tmpfile()
10069 * d_tmpfile() -> inode_dec_link_count() -> drop_nlink() in btrfs_tmpfile()
10091 struct btrfs_fs_info *fs_info = inode->root->fs_info; in btrfs_set_range_writeback()
10097 ASSERT(end + 1 - start <= U32_MAX); in btrfs_set_range_writeback()
10098 len = end + 1 - start; in btrfs_set_range_writeback()
10100 page = find_get_page(inode->vfs_inode.i_mapping, index); in btrfs_set_range_writeback()
10122 if (fs_info->sectorsize < SZ_4K || fs_info->sectorsize > SZ_64K) in btrfs_encoded_io_compression_from_extent()
10123 return -EINVAL; in btrfs_encoded_io_compression_from_extent()
10125 (fs_info->sectorsize_bits - 12); in btrfs_encoded_io_compression_from_extent()
10129 return -EUCLEAN; in btrfs_encoded_io_compression_from_extent()
10142 struct btrfs_inode *inode = BTRFS_I(file_inode(iocb->ki_filp)); in btrfs_encoded_read_inline()
10143 struct btrfs_root *root = inode->root; in btrfs_encoded_read_inline()
10144 struct btrfs_fs_info *fs_info = root->fs_info; in btrfs_encoded_read_inline()
10145 struct extent_io_tree *io_tree = &inode->io_tree; in btrfs_encoded_read_inline()
10156 ret = -ENOMEM; in btrfs_encoded_read_inline()
10164 ret = -EIO; in btrfs_encoded_read_inline()
10168 leaf = path->nodes[0]; in btrfs_encoded_read_inline()
10169 item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_file_extent_item); in btrfs_encoded_read_inline()
10174 encoded->len = min_t(u64, extent_start + ram_bytes, in btrfs_encoded_read_inline()
10175 inode->vfs_inode.i_size) - iocb->ki_pos; in btrfs_encoded_read_inline()
10180 encoded->compression = ret; in btrfs_encoded_read_inline()
10181 if (encoded->compression) { in btrfs_encoded_read_inline()
10185 path->slots[0]); in btrfs_encoded_read_inline()
10187 ret = -ENOBUFS; in btrfs_encoded_read_inline()
10191 encoded->unencoded_len = ram_bytes; in btrfs_encoded_read_inline()
10192 encoded->unencoded_offset = iocb->ki_pos - extent_start; in btrfs_encoded_read_inline()
10194 count = min_t(u64, count, encoded->len); in btrfs_encoded_read_inline()
10195 encoded->len = count; in btrfs_encoded_read_inline()
10196 encoded->unencoded_len = count; in btrfs_encoded_read_inline()
10197 ptr += iocb->ki_pos - extent_start; in btrfs_encoded_read_inline()
10202 ret = -ENOMEM; in btrfs_encoded_read_inline()
10208 btrfs_inode_unlock(&inode->vfs_inode, BTRFS_ILOCK_SHARED); in btrfs_encoded_read_inline()
10213 ret = -EFAULT; in btrfs_encoded_read_inline()
10232 struct btrfs_encoded_read_private *priv = btrfs_bio(bio)->private; in submit_encoded_read_bio()
10233 struct btrfs_fs_info *fs_info = inode->root->fs_info; in submit_encoded_read_bio()
10236 if (!priv->skip_csum) { in submit_encoded_read_bio()
10237 ret = btrfs_lookup_bio_sums(&inode->vfs_inode, bio, NULL); in submit_encoded_read_bio()
10242 atomic_inc(&priv->pending); in submit_encoded_read_bio()
10249 const bool uptodate = (bbio->bio.bi_status == BLK_STS_OK); in btrfs_encoded_read_verify_csum()
10250 struct btrfs_encoded_read_private *priv = bbio->private; in btrfs_encoded_read_verify_csum()
10251 struct btrfs_inode *inode = priv->inode; in btrfs_encoded_read_verify_csum()
10252 struct btrfs_fs_info *fs_info = inode->root->fs_info; in btrfs_encoded_read_verify_csum()
10253 u32 sectorsize = fs_info->sectorsize; in btrfs_encoded_read_verify_csum()
10258 if (priv->skip_csum || !uptodate) in btrfs_encoded_read_verify_csum()
10259 return bbio->bio.bi_status; in btrfs_encoded_read_verify_csum()
10261 bio_for_each_segment_all(bvec, &bbio->bio, iter_all) { in btrfs_encoded_read_verify_csum()
10264 nr_sectors = BTRFS_BYTES_TO_BLKS(fs_info, bvec->bv_len); in btrfs_encoded_read_verify_csum()
10265 pgoff = bvec->bv_offset; in btrfs_encoded_read_verify_csum()
10268 if (btrfs_check_data_csum(&inode->vfs_inode, bbio, bio_offset, in btrfs_encoded_read_verify_csum()
10269 bvec->bv_page, pgoff)) in btrfs_encoded_read_verify_csum()
10280 struct btrfs_encoded_read_private *priv = bbio->private; in btrfs_encoded_read_endio()
10293 WRITE_ONCE(priv->status, status); in btrfs_encoded_read_endio()
10295 if (!atomic_dec_return(&priv->pending)) in btrfs_encoded_read_endio()
10296 wake_up(&priv->wait); in btrfs_encoded_read_endio()
10298 bio_put(&bbio->bio); in btrfs_encoded_read_endio()
10305 struct btrfs_fs_info *fs_info = inode->root->fs_info; in btrfs_encoded_read_regular_fill_pages()
10310 .skip_csum = (inode->flags & BTRFS_INODE_NODATASUM), in btrfs_encoded_read_regular_fill_pages()
10328 disk_io_size - cur); in btrfs_encoded_read_regular_fill_pages()
10340 remaining = min(geom.len, disk_io_size - cur); in btrfs_encoded_read_regular_fill_pages()
10348 bio->bi_iter.bi_sector = in btrfs_encoded_read_regular_fill_pages()
10368 remaining -= bytes; in btrfs_encoded_read_regular_fill_pages()
10387 struct btrfs_inode *inode = BTRFS_I(file_inode(iocb->ki_filp)); in btrfs_encoded_read_regular()
10388 struct extent_io_tree *io_tree = &inode->io_tree; in btrfs_encoded_read_regular()
10398 return -ENOMEM; in btrfs_encoded_read_regular()
10401 ret = -ENOMEM; in btrfs_encoded_read_regular()
10411 btrfs_inode_unlock(&inode->vfs_inode, BTRFS_ILOCK_SHARED); in btrfs_encoded_read_regular()
10418 i = (iocb->ki_pos - start) >> PAGE_SHIFT; in btrfs_encoded_read_regular()
10419 page_offset = (iocb->ki_pos - start) & (PAGE_SIZE - 1); in btrfs_encoded_read_regular()
10423 size_t bytes = min_t(size_t, count - cur, in btrfs_encoded_read_regular()
10424 PAGE_SIZE - page_offset); in btrfs_encoded_read_regular()
10428 ret = -EFAULT; in btrfs_encoded_read_regular()
10448 struct btrfs_inode *inode = BTRFS_I(file_inode(iocb->ki_filp)); in btrfs_encoded_read()
10449 struct btrfs_fs_info *fs_info = inode->root->fs_info; in btrfs_encoded_read()
10450 struct extent_io_tree *io_tree = &inode->io_tree; in btrfs_encoded_read()
10458 file_accessed(iocb->ki_filp); in btrfs_encoded_read()
10460 btrfs_inode_lock(&inode->vfs_inode, BTRFS_ILOCK_SHARED); in btrfs_encoded_read()
10462 if (iocb->ki_pos >= inode->vfs_inode.i_size) { in btrfs_encoded_read()
10463 btrfs_inode_unlock(&inode->vfs_inode, BTRFS_ILOCK_SHARED); in btrfs_encoded_read()
10466 start = ALIGN_DOWN(iocb->ki_pos, fs_info->sectorsize); in btrfs_encoded_read()
10468 * We don't know how long the extent containing iocb->ki_pos is, but if in btrfs_encoded_read()
10471 lockend = start + BTRFS_MAX_UNCOMPRESSED - 1; in btrfs_encoded_read()
10476 ret = btrfs_wait_ordered_range(&inode->vfs_inode, start, in btrfs_encoded_read()
10477 lockend - start + 1); in btrfs_encoded_read()
10482 lockend - start + 1); in btrfs_encoded_read()
10490 em = btrfs_get_extent(inode, NULL, 0, start, lockend - start + 1); in btrfs_encoded_read()
10496 if (em->block_start == EXTENT_MAP_INLINE) { in btrfs_encoded_read()
10497 u64 extent_start = em->start; in btrfs_encoded_read()
10515 encoded->len = min_t(u64, extent_map_end(em), in btrfs_encoded_read()
10516 inode->vfs_inode.i_size) - iocb->ki_pos; in btrfs_encoded_read()
10517 if (em->block_start == EXTENT_MAP_HOLE || in btrfs_encoded_read()
10518 test_bit(EXTENT_FLAG_PREALLOC, &em->flags)) { in btrfs_encoded_read()
10520 count = min_t(u64, count, encoded->len); in btrfs_encoded_read()
10521 encoded->len = count; in btrfs_encoded_read()
10522 encoded->unencoded_len = count; in btrfs_encoded_read()
10523 } else if (test_bit(EXTENT_FLAG_COMPRESSED, &em->flags)) { in btrfs_encoded_read()
10524 disk_bytenr = em->block_start; in btrfs_encoded_read()
10529 if (em->block_len > count) { in btrfs_encoded_read()
10530 ret = -ENOBUFS; in btrfs_encoded_read()
10533 disk_io_size = em->block_len; in btrfs_encoded_read()
10534 count = em->block_len; in btrfs_encoded_read()
10535 encoded->unencoded_len = em->ram_bytes; in btrfs_encoded_read()
10536 encoded->unencoded_offset = iocb->ki_pos - em->orig_start; in btrfs_encoded_read()
10538 em->compress_type); in btrfs_encoded_read()
10541 encoded->compression = ret; in btrfs_encoded_read()
10543 disk_bytenr = em->block_start + (start - em->start); in btrfs_encoded_read()
10544 if (encoded->len > count) in btrfs_encoded_read()
10545 encoded->len = count; in btrfs_encoded_read()
10550 disk_io_size = min(lockend + 1, iocb->ki_pos + encoded->len) - start; in btrfs_encoded_read()
10551 count = start + disk_io_size - iocb->ki_pos; in btrfs_encoded_read()
10552 encoded->len = count; in btrfs_encoded_read()
10553 encoded->unencoded_len = count; in btrfs_encoded_read()
10554 disk_io_size = ALIGN(disk_io_size, fs_info->sectorsize); in btrfs_encoded_read()
10561 btrfs_inode_unlock(&inode->vfs_inode, BTRFS_ILOCK_SHARED); in btrfs_encoded_read()
10565 ret = -EFAULT; in btrfs_encoded_read()
10570 encoded->compression, in btrfs_encoded_read()
10576 iocb->ki_pos += encoded->len; in btrfs_encoded_read()
10584 btrfs_inode_unlock(&inode->vfs_inode, BTRFS_ILOCK_SHARED); in btrfs_encoded_read()
10591 struct btrfs_inode *inode = BTRFS_I(file_inode(iocb->ki_filp)); in btrfs_do_encoded_write()
10592 struct btrfs_root *root = inode->root; in btrfs_do_encoded_write()
10593 struct btrfs_fs_info *fs_info = root->fs_info; in btrfs_do_encoded_write()
10594 struct extent_io_tree *io_tree = &inode->io_tree; in btrfs_do_encoded_write()
10608 switch (encoded->compression) { in btrfs_do_encoded_write()
10621 if (encoded->compression - in btrfs_do_encoded_write()
10623 fs_info->sectorsize_bits) in btrfs_do_encoded_write()
10624 return -EINVAL; in btrfs_do_encoded_write()
10628 return -EINVAL; in btrfs_do_encoded_write()
10630 if (encoded->encryption != BTRFS_ENCODED_IO_ENCRYPTION_NONE) in btrfs_do_encoded_write()
10631 return -EINVAL; in btrfs_do_encoded_write()
10636 if (encoded->unencoded_len > BTRFS_MAX_UNCOMPRESSED || in btrfs_do_encoded_write()
10638 return -EINVAL; in btrfs_do_encoded_write()
10653 if (orig_count >= encoded->unencoded_len) in btrfs_do_encoded_write()
10654 return -EINVAL; in btrfs_do_encoded_write()
10657 start = iocb->ki_pos; in btrfs_do_encoded_write()
10658 if (!IS_ALIGNED(start, fs_info->sectorsize)) in btrfs_do_encoded_write()
10659 return -EINVAL; in btrfs_do_encoded_write()
10666 if (start + encoded->len < inode->vfs_inode.i_size && in btrfs_do_encoded_write()
10667 !IS_ALIGNED(start + encoded->len, fs_info->sectorsize)) in btrfs_do_encoded_write()
10668 return -EINVAL; in btrfs_do_encoded_write()
10670 /* Finally, the offset in the unencoded data must be sector-aligned. */ in btrfs_do_encoded_write()
10671 if (!IS_ALIGNED(encoded->unencoded_offset, fs_info->sectorsize)) in btrfs_do_encoded_write()
10672 return -EINVAL; in btrfs_do_encoded_write()
10674 num_bytes = ALIGN(encoded->len, fs_info->sectorsize); in btrfs_do_encoded_write()
10675 ram_bytes = ALIGN(encoded->unencoded_len, fs_info->sectorsize); in btrfs_do_encoded_write()
10676 end = start + num_bytes - 1; in btrfs_do_encoded_write()
10680 * sector-aligned. For convenience, we extend it with zeroes if it in btrfs_do_encoded_write()
10683 disk_num_bytes = ALIGN(orig_count, fs_info->sectorsize); in btrfs_do_encoded_write()
10687 return -ENOMEM; in btrfs_do_encoded_write()
10694 ret = -ENOMEM; in btrfs_do_encoded_write()
10700 ret = -EFAULT; in btrfs_do_encoded_write()
10704 memset(kaddr + bytes, 0, PAGE_SIZE - bytes); in btrfs_do_encoded_write()
10711 ret = btrfs_wait_ordered_range(&inode->vfs_inode, start, num_bytes); in btrfs_do_encoded_write()
10714 ret = invalidate_inode_pages2_range(inode->vfs_inode.i_mapping, in btrfs_do_encoded_write()
10722 !filemap_range_has_page(inode->vfs_inode.i_mapping, start, end)) in btrfs_do_encoded_write()
10731 * We don't use the higher-level delalloc space functions because our in btrfs_do_encoded_write()
10746 if (start == 0 && encoded->unencoded_len == encoded->len && in btrfs_do_encoded_write()
10747 encoded->unencoded_offset == 0) { in btrfs_do_encoded_write()
10748 ret = cow_file_range_inline(inode, encoded->len, orig_count, in btrfs_do_encoded_write()
10764 start - encoded->unencoded_offset, ins.objectid, in btrfs_do_encoded_write()
10775 encoded->unencoded_offset, in btrfs_do_encoded_write()
10785 if (start + encoded->len > inode->vfs_inode.i_size) in btrfs_do_encoded_write()
10786 i_size_write(&inode->vfs_inode, start + encoded->len); in btrfs_do_encoded_write()
10796 ret = -EIO; in btrfs_do_encoded_write()
10828 iocb->ki_pos += encoded->len; in btrfs_do_encoded_write()
10841 struct btrfs_fs_info *fs_info = BTRFS_I(inode)->root->fs_info; in btrfs_add_swapfile_pin()
10848 return -ENOMEM; in btrfs_add_swapfile_pin()
10849 sp->ptr = ptr; in btrfs_add_swapfile_pin()
10850 sp->inode = inode; in btrfs_add_swapfile_pin()
10851 sp->is_block_group = is_block_group; in btrfs_add_swapfile_pin()
10852 sp->bg_extent_count = 1; in btrfs_add_swapfile_pin()
10854 spin_lock(&fs_info->swapfile_pins_lock); in btrfs_add_swapfile_pin()
10855 p = &fs_info->swapfile_pins.rb_node; in btrfs_add_swapfile_pin()
10859 if (sp->ptr < entry->ptr || in btrfs_add_swapfile_pin()
10860 (sp->ptr == entry->ptr && sp->inode < entry->inode)) { in btrfs_add_swapfile_pin()
10861 p = &(*p)->rb_left; in btrfs_add_swapfile_pin()
10862 } else if (sp->ptr > entry->ptr || in btrfs_add_swapfile_pin()
10863 (sp->ptr == entry->ptr && sp->inode > entry->inode)) { in btrfs_add_swapfile_pin()
10864 p = &(*p)->rb_right; in btrfs_add_swapfile_pin()
10867 entry->bg_extent_count++; in btrfs_add_swapfile_pin()
10868 spin_unlock(&fs_info->swapfile_pins_lock); in btrfs_add_swapfile_pin()
10873 rb_link_node(&sp->node, parent, p); in btrfs_add_swapfile_pin()
10874 rb_insert_color(&sp->node, &fs_info->swapfile_pins); in btrfs_add_swapfile_pin()
10875 spin_unlock(&fs_info->swapfile_pins_lock); in btrfs_add_swapfile_pin()
10882 struct btrfs_fs_info *fs_info = BTRFS_I(inode)->root->fs_info; in btrfs_free_swapfile_pins()
10886 spin_lock(&fs_info->swapfile_pins_lock); in btrfs_free_swapfile_pins()
10887 node = rb_first(&fs_info->swapfile_pins); in btrfs_free_swapfile_pins()
10891 if (sp->inode == inode) { in btrfs_free_swapfile_pins()
10892 rb_erase(&sp->node, &fs_info->swapfile_pins); in btrfs_free_swapfile_pins()
10893 if (sp->is_block_group) { in btrfs_free_swapfile_pins()
10894 btrfs_dec_block_group_swap_extents(sp->ptr, in btrfs_free_swapfile_pins()
10895 sp->bg_extent_count); in btrfs_free_swapfile_pins()
10896 btrfs_put_block_group(sp->ptr); in btrfs_free_swapfile_pins()
10902 spin_unlock(&fs_info->swapfile_pins_lock); in btrfs_free_swapfile_pins()
10928 if (bsi->nr_pages >= sis->max) in btrfs_add_swap_extent()
10931 max_pages = sis->max - bsi->nr_pages; in btrfs_add_swap_extent()
10932 first_ppage = ALIGN(bsi->block_start, PAGE_SIZE) >> PAGE_SHIFT; in btrfs_add_swap_extent()
10933 next_ppage = ALIGN_DOWN(bsi->block_start + bsi->block_len, in btrfs_add_swap_extent()
10938 nr_pages = next_ppage - first_ppage; in btrfs_add_swap_extent()
10942 if (bsi->start == 0) in btrfs_add_swap_extent()
10944 if (bsi->lowest_ppage > first_ppage_reported) in btrfs_add_swap_extent()
10945 bsi->lowest_ppage = first_ppage_reported; in btrfs_add_swap_extent()
10946 if (bsi->highest_ppage < (next_ppage - 1)) in btrfs_add_swap_extent()
10947 bsi->highest_ppage = next_ppage - 1; in btrfs_add_swap_extent()
10949 ret = add_swap_extent(sis, bsi->nr_pages, nr_pages, first_ppage); in btrfs_add_swap_extent()
10952 bsi->nr_extents += ret; in btrfs_add_swap_extent()
10953 bsi->nr_pages += nr_pages; in btrfs_add_swap_extent()
10962 atomic_dec(&BTRFS_I(inode)->root->nr_swapfiles); in btrfs_swap_deactivate()
10969 struct btrfs_root *root = BTRFS_I(inode)->root; in btrfs_swap_activate()
10970 struct btrfs_fs_info *fs_info = root->fs_info; in btrfs_swap_activate()
10971 struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree; in btrfs_swap_activate()
10976 .lowest_ppage = (sector_t)-1ULL, in btrfs_swap_activate()
10987 ret = btrfs_wait_ordered_range(inode, 0, (u64)-1); in btrfs_swap_activate()
10994 if (BTRFS_I(inode)->flags & BTRFS_INODE_COMPRESS) { in btrfs_swap_activate()
10996 return -EINVAL; in btrfs_swap_activate()
10998 if (!(BTRFS_I(inode)->flags & BTRFS_INODE_NODATACOW)) { in btrfs_swap_activate()
10999 btrfs_warn(fs_info, "swapfile must not be copy-on-write"); in btrfs_swap_activate()
11000 return -EINVAL; in btrfs_swap_activate()
11002 if (!(BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM)) { in btrfs_swap_activate()
11004 return -EINVAL; in btrfs_swap_activate()
11011 * fs_info->swapfile_pins prevents them from running while the swap in btrfs_swap_activate()
11019 return -EBUSY; in btrfs_swap_activate()
11029 if (!btrfs_drew_try_write_lock(&root->snapshot_lock)) { in btrfs_swap_activate()
11033 return -EINVAL; in btrfs_swap_activate()
11045 spin_lock(&root->root_item_lock); in btrfs_swap_activate()
11047 spin_unlock(&root->root_item_lock); in btrfs_swap_activate()
11052 root->root_key.objectid); in btrfs_swap_activate()
11053 return -EPERM; in btrfs_swap_activate()
11055 atomic_inc(&root->nr_swapfiles); in btrfs_swap_activate()
11056 spin_unlock(&root->root_item_lock); in btrfs_swap_activate()
11058 isize = ALIGN_DOWN(inode->i_size, fs_info->sectorsize); in btrfs_swap_activate()
11060 lock_extent(io_tree, 0, isize - 1, &cached_state); in btrfs_swap_activate()
11065 u64 len = isize - start; in btrfs_swap_activate()
11073 if (em->block_start == EXTENT_MAP_HOLE) { in btrfs_swap_activate()
11075 ret = -EINVAL; in btrfs_swap_activate()
11078 if (em->block_start == EXTENT_MAP_INLINE) { in btrfs_swap_activate()
11087 ret = -EINVAL; in btrfs_swap_activate()
11090 if (test_bit(EXTENT_FLAG_COMPRESSED, &em->flags)) { in btrfs_swap_activate()
11092 ret = -EINVAL; in btrfs_swap_activate()
11096 logical_block_start = em->block_start + (start - em->start); in btrfs_swap_activate()
11097 len = min(len, em->len - (start - em->start)); in btrfs_swap_activate()
11108 "swapfile must not be copy-on-write"); in btrfs_swap_activate()
11109 ret = -EINVAL; in btrfs_swap_activate()
11119 if (em->map_lookup->type & BTRFS_BLOCK_GROUP_PROFILE_MASK) { in btrfs_swap_activate()
11122 ret = -EINVAL; in btrfs_swap_activate()
11127 device = em->map_lookup->stripes[0].dev; in btrfs_swap_activate()
11133 } else if (device != em->map_lookup->stripes[0].dev) { in btrfs_swap_activate()
11135 ret = -EINVAL; in btrfs_swap_activate()
11139 physical_block_start = (em->map_lookup->stripes[0].physical + in btrfs_swap_activate()
11140 (logical_block_start - em->start)); in btrfs_swap_activate()
11141 len = min(len, em->len - (logical_block_start - em->start)); in btrfs_swap_activate()
11149 ret = -EINVAL; in btrfs_swap_activate()
11155 "block group for swapfile at %llu is read-only%s", in btrfs_swap_activate()
11156 bg->start, in btrfs_swap_activate()
11157 atomic_read(&fs_info->scrubs_running) ? in btrfs_swap_activate()
11160 ret = -EINVAL; in btrfs_swap_activate()
11197 unlock_extent(io_tree, 0, isize - 1, &cached_state); in btrfs_swap_activate()
11202 btrfs_drew_write_unlock(&root->snapshot_lock); in btrfs_swap_activate()
11210 sis->bdev = device->bdev; in btrfs_swap_activate()
11211 *span = bsi.highest_ppage - bsi.lowest_ppage + 1; in btrfs_swap_activate()
11212 sis->max = bsi.nr_pages; in btrfs_swap_activate()
11213 sis->pages = bsi.nr_pages - 1; in btrfs_swap_activate()
11214 sis->highest_bit = bsi.nr_pages - 1; in btrfs_swap_activate()
11225 return -EOPNOTSUPP; in btrfs_swap_activate()
11242 spin_lock(&inode->lock); in btrfs_update_inode_bytes()
11244 inode_sub_bytes(&inode->vfs_inode, del_bytes); in btrfs_update_inode_bytes()
11246 inode_add_bytes(&inode->vfs_inode, add_bytes); in btrfs_update_inode_bytes()
11247 spin_unlock(&inode->lock); in btrfs_update_inode_bytes()
11266 struct btrfs_root *root = inode->root; in btrfs_assert_inode_range_clean()
11272 ordered = btrfs_lookup_first_ordered_range(inode, start, end + 1 - start); in btrfs_assert_inode_range_clean()
11274 btrfs_err(root->fs_info, in btrfs_assert_inode_range_clean()
11276 start, end, btrfs_ino(inode), root->root_key.objectid, in btrfs_assert_inode_range_clean()
11277 ordered->file_offset, in btrfs_assert_inode_range_clean()
11278 ordered->file_offset + ordered->num_bytes - 1); in btrfs_assert_inode_range_clean()