Lines Matching defs:start
86 u64 start, u64 end, int *page_started,
88 static struct extent_map *create_io_em(struct btrfs_inode *inode, u64 start,
163 u64 start, size_t size, size_t compressed_size,
189 key.offset = start;
229 start >> PAGE_SHIFT);
232 offset = offset_in_page(start);
245 ret = btrfs_inode_set_file_extent_range(BTRFS_I(inode), start, size);
271 static noinline int cow_file_range_inline(struct btrfs_inode *inode, u64 start,
281 u64 inline_len = actual_end - start;
292 if (start > 0 ||
320 ret = __btrfs_drop_extents(trans, root, inode, path, start, aligned_end,
331 root, &inode->vfs_inode, start,
343 btrfs_drop_extent_cache(inode, start, aligned_end - 1, 0);
358 u64 start;
370 u64 start;
386 u64 start, u64 ram_size,
396 async_extent->start = start;
421 static inline int inode_need_compress(struct btrfs_inode *inode, u64 start,
444 return btrfs_compress_heuristic(&inode->vfs_inode, start, end);
449 u64 start, u64 end, u64 num_bytes, u64 small_write)
453 (start > 0 || end + 1 < inode->disk_i_size))
479 u64 start = async_chunk->start;
494 inode_should_defrag(BTRFS_I(inode), start, end, end - start + 1,
512 nr_pages = (end >> PAGE_SHIFT) - (start >> PAGE_SHIFT) + 1;
520 * end of the file is before the start of our current
527 if (actual_end <= start)
530 total_compressed = actual_end - start;
537 (start > 0 || end + 1 < BTRFS_I(inode)->disk_i_size))
550 if (inode_need_compress(BTRFS_I(inode), start, end)) {
573 * Note that the remaining part is redirtied, the start pointer
577 extent_range_clear_dirty_for_io(inode, start, end);
584 inode->i_mapping, start,
608 if (start == 0) {
614 ret = cow_file_range_inline(BTRFS_I(inode), start, end,
619 ret = cow_file_range_inline(BTRFS_I(inode), start, end,
641 extent_clear_unlock_delalloc(BTRFS_I(inode), start, end,
688 add_async_extent(async_chunk, start, total_in,
692 if (start + total_in < end) {
693 start += total_in;
729 (page_offset(async_chunk->locked_page) >= start &&
736 extent_range_redirty_for_io(inode, start, end);
737 add_async_extent(async_chunk, start, end - start + 1, 0, NULL, 0,
785 lock_extent(io_tree, async_extent->start,
786 async_extent->start + async_extent->ram_size - 1);
794 async_extent->start,
795 async_extent->start +
809 async_extent->start,
810 async_extent->start +
828 unlock_extent(io_tree, async_extent->start,
829 async_extent->start +
839 async_extent->start,
840 async_extent->start +
851 em = create_io_em(inode, async_extent->start,
853 async_extent->start, /* orig_start */
866 async_extent->start,
873 btrfs_drop_extent_cache(inode, async_extent->start,
874 async_extent->start +
883 extent_clear_unlock_delalloc(inode, async_extent->start,
884 async_extent->start +
889 if (btrfs_submit_compressed_write(inode, async_extent->start,
897 const u64 start = async_extent->start;
898 const u64 end = start + async_extent->ram_size - 1;
901 btrfs_writepage_endio_finish_ordered(p, start, end, 0);
904 extent_clear_unlock_delalloc(inode, start, end, NULL, 0,
918 extent_clear_unlock_delalloc(inode, async_extent->start,
919 async_extent->start +
932 static u64 get_extent_allocation_hint(struct btrfs_inode *inode, u64 start,
940 em = search_extent_mapping(em_tree, start, num_bytes);
943 * if block start isn't an actual block number then find the
974 * required to start IO on it. It may be clean and already done with
979 u64 start, u64 end, int *page_started,
1002 num_bytes = ALIGN(end - start + 1, blocksize);
1006 inode_should_defrag(inode, start, end, num_bytes, SZ_64K);
1008 if (start == 0) {
1010 ret = cow_file_range_inline(inode, start, end, 0,
1019 extent_clear_unlock_delalloc(inode, start, end, NULL,
1026 (end - start + PAGE_SIZE) / PAGE_SIZE;
1034 alloc_hint = get_extent_allocation_hint(inode, start, num_bytes);
1035 btrfs_drop_extent_cache(inode, start, start + num_bytes - 1, 0);
1064 em = create_io_em(inode, start, ins.offset, /* len */
1065 start, /* orig_start */
1078 ret = btrfs_add_ordered_extent(inode, start, ins.objectid,
1085 ret = btrfs_reloc_clone_csums(inode, start,
1095 * So we must continue until @start is increased to
1099 btrfs_drop_extent_cache(inode, start,
1100 start + ram_size - 1, 0);
1115 extent_clear_unlock_delalloc(inode, start, start + ram_size - 1,
1124 start += cur_alloc_size;
1128 * btrfs_reloc_clone_csums() error, since start is increased
1139 btrfs_drop_extent_cache(inode, start, start + ram_size - 1, 0);
1159 extent_clear_unlock_delalloc(inode, start,
1160 start + cur_alloc_size - 1,
1164 start += cur_alloc_size;
1165 if (start >= end)
1168 extent_clear_unlock_delalloc(inode, start, end, locked_page,
1201 nr_pages = (async_chunk->end - async_chunk->start + PAGE_SIZE) >>
1239 u64 start, u64 end, int *page_started,
1248 u64 num_chunks = DIV_ROUND_UP(end - start, SZ_512K);
1254 unlock_extent(&inode->io_tree, start, end);
1276 extent_clear_unlock_delalloc(inode, start, end, locked_page,
1286 cur_end = min(end, start + SZ_512K - 1);
1297 async_chunk[i].start = start;
1322 cur_end - start);
1339 nr_pages = DIV_ROUND_UP(cur_end - start, PAGE_SIZE);
1345 start = cur_end + 1;
1374 const u64 start, const u64 end,
1380 const u64 range_bytes = end + 1 - start;
1382 u64 range_start = start;
1432 clear_extent_bit(io_tree, start, end, EXTENT_NORESERVE,
1436 return cow_file_range(inode, locked_page, start, end, page_started,
1449 const u64 start, const u64 end,
1457 u64 cur_offset = start;
1467 extent_clear_unlock_delalloc(inode, start, end, locked_page,
1656 if (extent_end <= start) {
1792 static inline int need_force_cow(struct btrfs_inode *inode, u64 start, u64 end)
1805 test_range_bit(&inode->io_tree, start, end, EXTENT_DEFRAG, 0, NULL))
1816 u64 start, u64 end, int *page_started, unsigned long *nr_written,
1820 int force_cow = need_force_cow(inode, start, end);
1823 ret = run_delalloc_nocow(inode, locked_page, start, end,
1826 ret = run_delalloc_nocow(inode, locked_page, start, end,
1829 !inode_need_compress(inode, start, end)) {
1830 ret = cow_file_range(inode, locked_page, start, end,
1834 ret = cow_file_range_async(inode, wbc, locked_page, start, end,
1838 btrfs_cleanup_ordered_extents(inode, locked_page, start,
1839 end - start + 1);
1852 size = orig->end - orig->start + 1;
1863 new_size = split - orig->start;
1889 if (new->start > other->start)
1890 new_size = new->end - other->start + 1;
1892 new_size = other->end - new->start + 1;
1920 old_size = other->end - other->start + 1;
1922 old_size = new->end - new->start + 1;
2002 u64 len = state->end + 1 - state->start;
2030 state->start;
2044 u64 len = state->end + 1 - state->start;
2256 const u64 start,
2260 u64 search_start = start;
2261 const u64 end = start + len - 1;
2277 if (em->start < search_start)
2278 em_len -= search_start - em->start;
2295 int btrfs_set_extent_delalloc(struct btrfs_inode *inode, u64 start, u64 end,
2301 if (start >= i_size_read(&inode->vfs_inode) &&
2311 ret = btrfs_find_new_delalloc_bytes(inode, start,
2312 end + 1 - start,
2318 return set_extent_delalloc(&inode->io_tree, start, end, extra_bits,
2469 int btrfs_writepage_cow_fixup(struct page *page, u64 start, u64 end)
2584 u64 start, u64 len)
2588 cache = btrfs_lookup_block_group(fs_info, start);
2636 u64 start, end;
2647 start = ordered_extent->file_offset;
2648 end = start + ordered_extent->num_bytes - 1;
2662 btrfs_free_io_failure_record(BTRFS_I(inode), start, end);
2693 lock_extent_bits(io_tree, start, end, &cached_state);
2752 clear_extent_bit(&BTRFS_I(inode)->io_tree, start, end, clear_bits,
2760 u64 unwritten_start = start;
2831 void btrfs_writepage_endio_finish_ordered(struct page *page, u64 start,
2839 trace_btrfs_writepage_end_io_hook(page, start, end, uptodate);
2842 if (!btrfs_dec_test_ordered_pending(inode, &ordered_extent, start,
2843 end - start + 1, uptodate))
2856 int icsum, struct page *page, int pgoff, u64 start,
2879 btrfs_print_data_csum_error(BTRFS_I(inode), start, csum, csum_expected,
2896 struct page *page, u64 start, u64 end, int mirror)
2898 size_t offset = start - page_offset(page);
2912 test_range_bit(io_tree, start, end, EXTENT_NODATASUM, 1, NULL)) {
2913 clear_extent_bits(io_tree, start, end, EXTENT_NODATASUM);
2918 return check_data_csum(inode, io_bio, phy_offset, page, offset, start,
2919 (size_t)(end - start + 1));
3730 * helper to start transaction for unlink and rmdir.
4559 * @from - the offset to start zeroing
4818 hole_em->start = cur_offset;
5033 u64 start;
5039 start = state->start;
5044 lock_extent_bits(io_tree, start, end, &cached_state);
5055 btrfs_qgroup_free_data(BTRFS_I(inode), NULL, start,
5056 end - start + 1);
5058 clear_extent_bit(io_tree, start, end,
5888 * since we search a directory based on f_pos we have to start at 2
5890 * else has to start at 2
6576 * @start: file offset
6577 * @len: length of range starting at @start
6591 u64 start, u64 len)
6609 em = lookup_extent_mapping(em_tree, start, len);
6613 if (em->start > start || em->start + em->len <= start)
6625 em->start = EXTENT_MAP_HOLE;
6647 ret = btrfs_lookup_file_extent(NULL, root, path, objectid, start, 0);
6669 extent_end = start;
6694 if (start >= extent_end) {
6709 if (start + len <= found_key.offset)
6711 if (start > found_key.offset)
6715 em->start = start;
6716 em->orig_start = start;
6717 em->len = found_key.offset - start;
6741 em->start = extent_start + extent_offset;
6744 em->orig_start = em->start;
6768 set_extent_uptodate(io_tree, em->start,
6773 em->start = start;
6774 em->orig_start = start;
6780 if (em->start > start || extent_map_end(em) <= start) {
6783 em->start, em->len, start, len);
6789 ret = btrfs_add_extent_mapping(fs_info, em_tree, &em, start, len);
6804 u64 start, u64 len)
6808 u64 delalloc_start = start;
6814 em = btrfs_get_extent(inode, NULL, 0, start, len);
6830 end = start + len;
6831 if (end < start)
6849 if (delalloc_start > end || delalloc_end <= start) {
6857 * the start they passed in
6859 delalloc_start = max(start, delalloc_start);
6879 * make sure it is based on the start from the caller
6881 if (hole_end <= start || hole_em->start > end) {
6885 hole_start = max(hole_em->start, start);
6896 em->start = hole_start;
6899 * Don't adjust block start at all, it is fixed at
6911 em->start = delalloc_start;
6931 const u64 start,
6944 em = create_io_em(inode, start, len, orig_start, block_start,
6951 ret = btrfs_add_ordered_extent_dio(inode, start, block_start, len,
6956 btrfs_drop_extent_cache(inode, start, start + len - 1, 0);
6966 u64 start, u64 len)
6975 alloc_hint = get_extent_allocation_hint(inode, start, len);
6981 em = btrfs_create_dio_extent(inode, start, ins.offset, start,
7242 static struct extent_map *create_io_em(struct btrfs_inode *inode, u64 start,
7262 em->start = start;
7279 btrfs_drop_extent_cache(inode, em->start,
7280 em->start + em->len - 1, 0);
7303 u64 start, u64 len)
7328 len = min(len, em->len - (start - em->start));
7329 block_start = em->block_start + (start - em->start);
7331 if (can_nocow_extent(inode, start, &len, &orig_start,
7336 em2 = btrfs_create_dio_extent(BTRFS_I(inode), start, len,
7362 *map = em = btrfs_new_extent_direct(BTRFS_I(inode), start, len);
7368 len = min(len, em->len - (start - em->start));
7375 if (start + len > i_size_read(inode))
7376 i_size_write(inode, start + len);
7383 static int btrfs_dio_iomap_begin(struct inode *inode, loff_t start,
7411 lockstart = start;
7412 lockend = start + len - 1;
7422 ret = filemap_fdatawrite_range(inode->i_mapping, start,
7423 start + length - 1);
7438 start, dio_data->reserve);
7457 em = btrfs_get_extent(BTRFS_I(inode), NULL, 0, start, len);
7496 len = min(len, em->len - (start - em->start));
7499 start, len);
7504 len = min(len, em->len - (start - em->start));
7510 lockstart = start + len;
7531 iomap->addr = em->block_start + (start - em->start);
7534 iomap->offset = start;
7548 dio_data->data_reserved, start,
7662 u64 start = io_bio->logical;
7676 start, sectorsize))) {
7678 start, bvec.bv_page,
7686 start - io_bio->logical,
7688 start,
7689 start + sectorsize - 1,
7695 start += sectorsize;
8103 u64 start, u64 len)
8107 ret = fiemap_prep(inode, fieinfo, start, &len, 0);
8111 return extent_fiemap(BTRFS_I(inode), fieinfo, start, len);
8117 u64 start = page_offset(page);
8118 u64 end = start + PAGE_SIZE - 1;
8123 btrfs_lock_and_flush_ordered_range(inode, start, end, NULL);
8218 u64 start;
8223 * we have the page locked, so new writeback can't start,
8251 start = page_start;
8253 ordered = btrfs_lookup_ordered_range(inode, start, page_end - start + 1);
8262 clear_extent_bit(tree, start, end,
8278 new_len = start - ordered->file_offset;
8284 start,
8285 end - start + 1, 1))
8291 lock_extent_bits(tree, start, end,
8295 start = end + 1;
8296 if (start < page_end)
8520 * need to be able to stop the transaction and start a new one, which
9726 u64 start = ins->objectid;
9733 btrfs_set_stack_file_extent_disk_bytenr(&stack_fi, start);
9752 extent_info.disk_offset = start;
9777 u64 start, u64 num_bytes, u64 min_size,
9786 u64 cur_offset = start;
9787 u64 clear_offset = start;
9793 u64 end = start + num_bytes - 1;
9847 em->start = cur_offset;
9908 u64 start, u64 num_bytes, u64 min_size,
9911 return __btrfs_prealloc_file_range(inode, mode, start, num_bytes,
9918 u64 start, u64 num_bytes, u64 min_size,
9921 return __btrfs_prealloc_file_range(inode, mode, start, num_bytes,
10009 void btrfs_set_range_writeback(struct extent_io_tree *tree, u64 start, u64 end)
10012 unsigned long index = start >> PAGE_SHIFT;
10099 u64 start;
10135 if (bsi->start == 0)
10173 u64 start;
10254 start = 0;
10255 while (start < isize) {
10258 u64 len = isize - start;
10260 em = btrfs_get_extent(BTRFS_I(inode), NULL, 0, start, len);
10289 logical_block_start = em->block_start + (start - em->start);
10290 len = min(len, em->len - (start - em->start));
10294 ret = can_nocow_extent(inode, start, &len, NULL, NULL, NULL, true);
10333 (logical_block_start - em->start));
10334 len = min(len, em->len - (logical_block_start - em->start));
10349 bg->start,
10375 bsi.start = start;
10380 start += len;