struct extent_ptr_decoded p;
                struct bpos next_pos;
                bool did_work = false;
-               bool extending = false, should_check_enospc;
+               bool should_check_enospc;
                s64 i_sectors_delta = 0, disk_sectors_delta = 0;
                unsigned i;
 
                bch2_extent_normalize(c, bkey_i_to_s(insert));
 
                ret = bch2_sum_sector_overwrites(&trans, &iter, insert,
-                                                &extending,
                                                 &should_check_enospc,
                                                 &i_sectors_delta,
                                                 &disk_sectors_delta);
 
 int bch2_sum_sector_overwrites(struct btree_trans *trans,
                               struct btree_iter *extent_iter,
                               struct bkey_i *new,
-                              bool *maybe_extending,
                               bool *usage_increasing,
                               s64 *i_sectors_delta,
                               s64 *disk_sectors_delta)
        bool new_compressed = bch2_bkey_sectors_compressed(bkey_i_to_s_c(new));
        int ret = 0;
 
-       *maybe_extending        = true;
        *usage_increasing       = false;
        *i_sectors_delta        = 0;
        *disk_sectors_delta     = 0;
                     (!new_compressed && bch2_bkey_sectors_compressed(old))))
                        *usage_increasing = true;
 
-               if (bkey_ge(old.k->p, new->k.p)) {
-                       /*
-                        * Check if there's already data above where we're
-                        * going to be writing to - this means we're definitely
-                        * not extending the file:
-                        *
-                        * Note that it's not sufficient to check if there's
-                        * data up to the sector offset we're going to be
-                        * writing to, because i_size could be up to one block
-                        * less:
-                        */
-                       if (!bkey_cmp(old.k->p, new->k.p)) {
-                               old = bch2_btree_iter_next(&iter);
-                               ret = bkey_err(old);
-                               if (ret)
-                                       break;
-                       }
-
-                       if (old.k && !bkey_err(old) &&
-                           old.k->p.inode == extent_iter->pos.inode &&
-                           bkey_extent_is_data(old.k))
-                               *maybe_extending = false;
-
+               if (bkey_ge(old.k->p, new->k.p))
                        break;
-               }
        }
 
        bch2_trans_iter_exit(trans, &iter);
        struct bch_inode_unpacked inode_u;
        struct bpos next_pos;
        struct bkey_s_c inode;
-       bool extending = false, usage_increasing;
+       bool usage_increasing;
        s64 i_sectors_delta = 0, disk_sectors_delta = 0;
        int ret;
 
        next_pos = k->k.p;
 
        ret = bch2_sum_sector_overwrites(trans, iter, k,
-                       &extending,
                        &usage_increasing,
                        &i_sectors_delta,
                        &disk_sectors_delta);
                        return ret;
        }
 
-       new_i_size = extending
-               ? min(k->k.p.offset << 9, new_i_size)
-               : 0;
-
        bch2_trans_iter_init(trans, &inode_iter, BTREE_ID_inodes,
                             SPOS(0, inum.inum, iter->snapshot),
                             BTREE_ITER_INTENT|
 
 }
 
 int bch2_sum_sector_overwrites(struct btree_trans *, struct btree_iter *,
-                              struct bkey_i *, bool *, bool *, s64 *, s64 *);
+                              struct bkey_i *, bool *, s64 *, s64 *);
 int bch2_extent_update(struct btree_trans *, subvol_inum,
                       struct btree_iter *, struct bkey_i *,
                       struct disk_reservation *, u64, s64 *, bool);