Lines Matching refs:start
300 range.start = defrag->last_offset;
312 defrag->last_offset = range.start;
317 * we didn't start at zero. Make sure we loop
318 * around to the start of the file.
457 * sure holes are created between the current EOF and the start of
515 * [start, end]. Existing extents are split as required.
517 void btrfs_drop_extent_cache(struct btrfs_inode *inode, u64 start, u64 end,
524 u64 len = end - start + 1;
532 WARN_ON(end < start);
549 em = lookup_extent_mapping(em_tree, start, len);
557 if (testend && em->start + em->len >= start + len) {
562 start = em->start + em->len;
564 len = start + len - (em->start + em->len);
576 if (em->start < start) {
577 split->start = em->start;
578 split->len = start - em->start;
592 split->orig_start = split->start;
607 if (testend && em->start + em->len > start + len) {
608 u64 diff = start + len - em->start;
610 split->start = start + len;
611 split->len = em->start + em->len - (start + len);
633 split->orig_start = split->start;
668 * in the range start - end. hint_block is filled in with a block number
677 struct btrfs_path *path, u64 start, u64 end,
691 u64 search_start = start;
696 u64 last_end = start;
708 btrfs_drop_extent_cache(inode, start, end - 1, 0);
710 if (start >= inode->disk_i_size && !replace_extent)
720 if (ret > 0 && path->slots[0] > 0 && search_start == start) {
797 search_start = max(key.offset, start);
808 if (start > key.offset && end < extent_end) {
816 new_key.offset = start;
830 start - key.offset);
835 extent_offset += start - key.offset;
838 extent_end - start);
848 start - extent_offset);
852 key.offset = start;
864 if (start <= key.offset && end < extent_end) {
889 if (start > key.offset && end >= extent_end) {
897 start - key.offset);
900 inode_sub_bytes(vfs_inode, extent_end - start);
912 if (start <= key.offset && end >= extent_end) {
994 key.offset = start;
1014 struct btrfs_root *root, struct inode *inode, u64 start,
1023 ret = __btrfs_drop_extents(trans, root, BTRFS_I(inode), path, start,
1031 u64 *start, u64 *end)
1054 if ((*start && *start != key.offset) || (*end && *end != extent_end))
1057 *start = key.offset;
1063 * Mark extent in the range start - end as written.
1070 struct btrfs_inode *inode, u64 start, u64 end)
1098 split = start;
1125 if (key.offset > start || extent_end < end) {
1136 if (start == key.offset && end < extent_end) {
1138 other_end = start;
1163 if (start > key.offset && end == extent_end) {
1172 start - key.offset);
1176 new_key.offset = start;
1184 other_end - start);
1186 start - orig_offset);
1192 while (start > key.offset || end < extent_end) {
1193 if (key.offset == start)
1233 if (split == start) {
1234 key.offset = start;
1236 if (start != key.offset) {
1269 other_end = start;
1457 * no way someone can start IO on any dirty pages in this range.
1739 * start offset is >= i_size, we might still have a non-NULL
1938 * need to start yet another transaction to update the inode as we will
2040 static int start_ordered_ops(struct inode *inode, loff_t start, loff_t end)
2053 ret = btrfs_fdatawrite_range(inode, start, end);
2095 int btrfs_sync_file(struct file *file, loff_t start, loff_t end, int datasync)
2118 start = 0;
2128 ret = start_ordered_ops(inode, start, end);
2154 * any such pages does not start while we are logging the inode, because
2169 ret = start_ordered_ops(inode, start, end);
2188 ret = btrfs_wait_ordered_range(inode, start, len);
2197 ret = filemap_fdatawait_range(inode->i_mapping, start, end);
2226 * We use start here because we will need to wait on the IO to complete
2230 * happen that is blocked on a transaction trying to commit. With start
2232 * before we start blocking joiners. This comment is to keep somebody
2271 ret = btrfs_wait_ordered_range(inode, start, len);
2315 int slot, u64 start, u64 end)
2338 if (key.offset + btrfs_file_extent_num_bytes(leaf, fi) == start)
2420 hole_em->start = offset;
2447 * Find a hole extent on given inode and change start/len to the end of hole
2448 * extent.(hole/vacuum extent whose em->start <= start &&
2449 * em->start + em->len > start)
2450 * When a hole extent is found, return 1 and modify start/len.
2452 static int find_first_non_hole(struct inode *inode, u64 *start, u64 *len)
2459 round_down(*start, fs_info->sectorsize),
2467 *len = em->start + em->len > *start + *len ?
2468 0 : *start + *len - em->start - em->len;
2469 *start = em->start + em->len;
2607 const u64 start, const u64 end,
2620 u64 len = end - start;
2623 if (end <= start)
2657 cur_offset = start;
3010 u64 start;
3018 * [start, len)
3020 static int add_falloc_range(struct list_head *head, u64 start, u64 len)
3033 if (prev->start + prev->len == start) {
3041 range->start = start;
3134 if (em->start <= alloc_start &&
3136 const u64 em_end = em->start + em->len;
3457 range->start,
3462 data_reserved, range->start,
3497 u64 start;
3505 * offset can be negative, in this case we start finding DATA/HOLE from
3506 * the very start of the file.
3508 start = max_t(loff_t, 0, offset);
3510 lockstart = round_down(start, fs_info->sectorsize);
3520 while (start < i_size) {
3521 em = btrfs_get_extent_fiemap(BTRFS_I(inode), start, len);
3537 start = em->start + em->len;
3548 if (whence == SEEK_DATA && start >= i_size)
3551 offset = min_t(loff_t, start, i_size);
3637 int btrfs_fdatawrite_range(struct inode *inode, loff_t start, loff_t end)
3655 ret = filemap_fdatawrite_range(inode->i_mapping, start, end);
3658 ret = filemap_fdatawrite_range(inode->i_mapping, start, end);