Quelle  io_misc.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0
/*
 * io_misc.c - fallocate, fpunch, truncate:
 */

#include "bcachefs.h"
#include "alloc_foreground.h"
#include "bkey_buf.h"
#include "btree_update.h"
#include "buckets.h"
#include "clock.h"
#include "error.h"
#include "extents.h"
#include "extent_update.h"
#include "inode.h"
#include "io_misc.h"
#include "io_write.h"
#include "logged_ops.h"
#include "rebalance.h"
#include "subvolume.h"

/* Overwrites whatever was present with zeroes: */
int bch2_extent_fallocate(struct btree_trans *trans,
     subvol_inum inum,
     struct btree_iter *iter,
     u64 sectors,
     struct bch_io_opts opts,
     s64 *i_sectors_delta,
     struct write_point_specifier write_point)
{
 struct bch_fs *c = trans->c;
 struct disk_reservation disk_res = { 0 };
 struct closure cl;
 struct open_buckets open_buckets = { 0 };
 struct bkey_s_c k;
 struct bkey_buf old, new;
 unsigned sectors_allocated = 0, new_replicas;
 bool unwritten = opts.nocow &&
     c->sb.version >= bcachefs_metadata_version_unwritten_extents;
 int ret;

 bch2_bkey_buf_init(&old);
 bch2_bkey_buf_init(&new);
 closure_init_stack(&cl);

 k = bch2_btree_iter_peek_slot(trans, iter);
 ret = bkey_err(k);
 if (ret)
  return ret;

 sectors = min_t(u64, sectors, k.k->p.offset - iter->pos.offset);
 new_replicas = max(0, (int) opts.data_replicas -
      (int) bch2_bkey_nr_ptrs_fully_allocated(k));

 /*
 * Get a disk reservation before (in the nocow case) calling
 * into the allocator:
 */
 ret = bch2_disk_reservation_get(c, &disk_res, sectors, new_replicas, 0);
 if (unlikely(ret))
  goto err_noprint;

 bch2_bkey_buf_reassemble(&old, c, k);

 if (!unwritten) {
  struct bkey_i_reservation *reservation;

  bch2_bkey_buf_realloc(&new, c, sizeof(*reservation) / sizeof(u64));
  reservation = bkey_reservation_init(new.k);
  reservation->k.p = iter->pos;
  bch2_key_resize(&reservation->k, sectors);
  reservation->v.nr_replicas = opts.data_replicas;
 } else {
  struct bkey_i_extent *e;
  struct bch_devs_list devs_have;
  struct write_point *wp;

  devs_have.nr = 0;

  bch2_bkey_buf_realloc(&new, c, BKEY_EXTENT_U64s_MAX);

  e = bkey_extent_init(new.k);
  e->k.p = iter->pos;

  ret = bch2_alloc_sectors_start_trans(trans,
    opts.foreground_target,
    false,
    write_point,
    &devs_have,
    opts.data_replicas,
    opts.data_replicas,
    BCH_WATERMARK_normal, 0, &cl, &wp);
  if (bch2_err_matches(ret, BCH_ERR_operation_blocked))
   ret = bch_err_throw(c, transaction_restart_nested);
  if (ret)
   goto err;

  sectors = min_t(u64, sectors, wp->sectors_free);
  sectors_allocated = sectors;

  bch2_key_resize(&e->k, sectors);

  bch2_open_bucket_get(c, wp, &open_buckets);
  bch2_alloc_sectors_append_ptrs(c, wp, &e->k_i, sectors, false);
  bch2_alloc_sectors_done(c, wp);

  extent_for_each_ptr(extent_i_to_s(e), ptr)
   ptr->unwritten = true;
 }

 ret = bch2_extent_update(trans, inum, iter, new.k, &disk_res,
     0, i_sectors_delta, true);
err:
 if (!ret && sectors_allocated)
  bch2_increment_clock(c, sectors_allocated, WRITE);
 if (should_print_err(ret)) {
  struct printbuf buf = PRINTBUF;
  lockrestart_do(trans,
   bch2_inum_offset_err_msg_trans(trans, &buf, inum, iter->pos.offset << 9));
  prt_printf(&buf, "fallocate error: %s", bch2_err_str(ret));
  bch_err_ratelimited(c, "%s", buf.buf);
  printbuf_exit(&buf);
 }
err_noprint:
 bch2_open_buckets_put(c, &open_buckets);
 bch2_disk_reservation_put(c, &disk_res);
 bch2_bkey_buf_exit(&new, c);
 bch2_bkey_buf_exit(&old, c);

 if (closure_nr_remaining(&cl) != 1) {
  bch2_trans_unlock_long(trans);
  bch2_wait_on_allocator(c, &cl);
 }

 return ret;
}

/* For fsck */
int bch2_fpunch_snapshot(struct btree_trans *trans, struct bpos start, struct bpos end)
{
 u32 restart_count = trans->restart_count;
 struct bch_fs *c = trans->c;
 struct disk_reservation disk_res = bch2_disk_reservation_init(c, 0);
 unsigned max_sectors = KEY_SIZE_MAX & (~0 << c->block_bits);
 struct bkey_i delete;

 int ret = for_each_btree_key_max_commit(trans, iter, BTREE_ID_extents,
   start, end, 0, k,
   &disk_res, NULL, BCH_TRANS_COMMIT_no_enospc, ({
  bkey_init(&delete.k);
  delete.k.p = iter.pos;

  /* create the biggest key we can */
  bch2_key_resize(&delete.k, max_sectors);
  bch2_cut_back(end, &delete);

  bch2_extent_trim_atomic(trans, &iter, &delete) ?:
  bch2_trans_update(trans, &iter, &delete, 0);
 }));

 bch2_disk_reservation_put(c, &disk_res);
 return ret ?: trans_was_restarted(trans, restart_count);
}

/*
 * Returns -BCH_ERR_transacton_restart if we had to drop locks:
 */
int bch2_fpunch_at(struct btree_trans *trans, struct btree_iter *iter,
     subvol_inum inum, u64 end,
     s64 *i_sectors_delta)
{
 struct bch_fs *c = trans->c;
 unsigned max_sectors = KEY_SIZE_MAX & (~0 << c->block_bits);
 struct bpos end_pos = POS(inum.inum, end);
 struct bkey_s_c k;
 int ret = 0, ret2 = 0;
 u32 snapshot;

 while (!ret ||
        bch2_err_matches(ret, BCH_ERR_transaction_restart)) {
  struct disk_reservation disk_res =
   bch2_disk_reservation_init(c, 0);
  struct bkey_i delete;

  if (ret)
   ret2 = ret;

  bch2_trans_begin(trans);

  ret = bch2_subvolume_get_snapshot(trans, inum.subvol, &snapshot);
  if (ret)
   continue;

  bch2_btree_iter_set_snapshot(trans, iter, snapshot);

  /*
 * peek_max() doesn't have ideal semantics for extents:
 */
  k = bch2_btree_iter_peek_max(trans, iter, end_pos);
  if (!k.k)
   break;

  ret = bkey_err(k);
  if (ret)
   continue;

  bkey_init(&delete.k);
  delete.k.p = iter->pos;

  /* create the biggest key we can */
  bch2_key_resize(&delete.k, max_sectors);
  bch2_cut_back(end_pos, &delete);

  ret = bch2_extent_update(trans, inum, iter, &delete,
    &disk_res, 0, i_sectors_delta, false);
  bch2_disk_reservation_put(c, &disk_res);
 }

 return ret ?: ret2;
}

int bch2_fpunch(struct bch_fs *c, subvol_inum inum, u64 start, u64 end,
  s64 *i_sectors_delta)
{
 struct btree_trans *trans = bch2_trans_get(c);
 struct btree_iter iter;
 int ret;

 bch2_trans_iter_init(trans, &iter, BTREE_ID_extents,
        POS(inum.inum, start),
        BTREE_ITER_intent);

 ret = bch2_fpunch_at(trans, &iter, inum, end, i_sectors_delta);

 bch2_trans_iter_exit(trans, &iter);
 bch2_trans_put(trans);

 if (bch2_err_matches(ret, BCH_ERR_transaction_restart))
  ret = 0;

 return ret;
}

/* truncate: */

void bch2_logged_op_truncate_to_text(struct printbuf *out, struct bch_fs *c, struct bkey_s_c k)
{
 struct bkey_s_c_logged_op_truncate op = bkey_s_c_to_logged_op_truncate(k);

 prt_printf(out, "subvol=%u", le32_to_cpu(op.v->subvol));
 prt_printf(out, " inum=%llu", le64_to_cpu(op.v->inum));
 prt_printf(out, " new_i_size=%llu", le64_to_cpu(op.v->new_i_size));
}

static int truncate_set_isize(struct btree_trans *trans,
         subvol_inum inum,
         u64 new_i_size,
         bool warn)
{
 struct btree_iter iter = {};
 struct bch_inode_unpacked inode_u;
 int ret;

 ret   = __bch2_inode_peek(trans, &iter, &inode_u, inum, BTREE_ITER_intent, warn) ?:
  (inode_u.bi_size = new_i_size, 0) ?:
  bch2_inode_write(trans, &iter, &inode_u);

 bch2_trans_iter_exit(trans, &iter);
 return ret;
}

static int __bch2_resume_logged_op_truncate(struct btree_trans *trans,
         struct bkey_i *op_k,
         u64 *i_sectors_delta)
{
 struct bch_fs *c = trans->c;
 struct btree_iter fpunch_iter;
 struct bkey_i_logged_op_truncate *op = bkey_i_to_logged_op_truncate(op_k);
 subvol_inum inum = { le32_to_cpu(op->v.subvol), le64_to_cpu(op->v.inum) };
 u64 new_i_size = le64_to_cpu(op->v.new_i_size);
 bool warn_errors = i_sectors_delta != NULL;
 int ret;

 ret = commit_do(trans, NULL, NULL, BCH_TRANS_COMMIT_no_enospc,
   truncate_set_isize(trans, inum, new_i_size, i_sectors_delta != NULL));
 if (ret)
  goto err;

 bch2_trans_iter_init(trans, &fpunch_iter, BTREE_ID_extents,
        POS(inum.inum, round_up(new_i_size, block_bytes(c)) >> 9),
        BTREE_ITER_intent);
 ret = bch2_fpunch_at(trans, &fpunch_iter, inum, U64_MAX, i_sectors_delta);
 bch2_trans_iter_exit(trans, &fpunch_iter);

 if (bch2_err_matches(ret, BCH_ERR_transaction_restart))
  ret = 0;
err:
 if (warn_errors)
  bch_err_fn(c, ret);
 return ret;
}

int bch2_resume_logged_op_truncate(struct btree_trans *trans, struct bkey_i *op_k)
{
 return __bch2_resume_logged_op_truncate(trans, op_k, NULL);
}

int bch2_truncate(struct bch_fs *c, subvol_inum inum, u64 new_i_size, u64 *i_sectors_delta)
{
 struct bkey_i_logged_op_truncate op;

 bkey_logged_op_truncate_init(&op.k_i);
 op.v.subvol = cpu_to_le32(inum.subvol);
 op.v.inum = cpu_to_le64(inum.inum);
 op.v.new_i_size = cpu_to_le64(new_i_size);

 /*
 * Logged ops aren't atomic w.r.t. snapshot creation: creating a
 * snapshot while they're in progress, then crashing, will result in the
 * resume only proceeding in one of the snapshots
 */
 down_read(&c->snapshot_create_lock);
 struct btree_trans *trans = bch2_trans_get(c);
 int ret = bch2_logged_op_start(trans, &op.k_i);
 if (ret)
  goto out;
 ret = __bch2_resume_logged_op_truncate(trans, &op.k_i, i_sectors_delta);
 ret = bch2_logged_op_finish(trans, &op.k_i) ?: ret;
out:
 bch2_trans_put(trans);
 up_read(&c->snapshot_create_lock);

 return ret;
}

/* finsert/fcollapse: */

void bch2_logged_op_finsert_to_text(struct printbuf *out, struct bch_fs *c, struct bkey_s_c k)
{
 struct bkey_s_c_logged_op_finsert op = bkey_s_c_to_logged_op_finsert(k);

 prt_printf(out, "subvol=%u",  le32_to_cpu(op.v->subvol));
 prt_printf(out, " inum=%llu",  le64_to_cpu(op.v->inum));
 prt_printf(out, " dst_offset=%lli", le64_to_cpu(op.v->dst_offset));
 prt_printf(out, " src_offset=%llu", le64_to_cpu(op.v->src_offset));
}

static int adjust_i_size(struct btree_trans *trans, subvol_inum inum,
    u64 offset, s64 len, bool warn)
{
 struct btree_iter iter;
 struct bch_inode_unpacked inode_u;
 int ret;

 offset <<= 9;
 len <<= 9;

 ret = __bch2_inode_peek(trans, &iter, &inode_u, inum, BTREE_ITER_intent, warn);
 if (ret)
  return ret;

 if (len > 0) {
  if (MAX_LFS_FILESIZE - inode_u.bi_size < len) {
   ret = -EFBIG;
   goto err;
  }

  if (offset >= inode_u.bi_size) {
   ret = -EINVAL;
   goto err;
  }
 }

 inode_u.bi_size += len;
 inode_u.bi_mtime = inode_u.bi_ctime = bch2_current_time(trans->c);

 ret = bch2_inode_write(trans, &iter, &inode_u);
err:
 bch2_trans_iter_exit(trans, &iter);
 return ret;
}

static int __bch2_resume_logged_op_finsert(struct btree_trans *trans,
        struct bkey_i *op_k,
        u64 *i_sectors_delta)
{
 struct bch_fs *c = trans->c;
 struct btree_iter iter;
 struct bkey_i_logged_op_finsert *op = bkey_i_to_logged_op_finsert(op_k);
 subvol_inum inum = { le32_to_cpu(op->v.subvol), le64_to_cpu(op->v.inum) };
 struct bch_io_opts opts;
 u64 dst_offset = le64_to_cpu(op->v.dst_offset);
 u64 src_offset = le64_to_cpu(op->v.src_offset);
 s64 shift = dst_offset - src_offset;
 u64 len = abs(shift);
 u64 pos = le64_to_cpu(op->v.pos);
 bool insert = shift > 0;
 u32 snapshot;
 bool warn_errors = i_sectors_delta != NULL;
 int ret = 0;

 ret = bch2_inum_opts_get(trans, inum, &opts);
 if (ret)
  return ret;

 /*
 * check for missing subvolume before fpunch, as in resume we don't want
 * it to be a fatal error
 */
 ret = lockrestart_do(trans, __bch2_subvolume_get_snapshot(trans, inum.subvol, &snapshot, warn_errors));
 if (ret)
  return ret;

 bch2_trans_iter_init(trans, &iter, BTREE_ID_extents,
        POS(inum.inum, 0),
        BTREE_ITER_intent);

 switch (op->v.state) {
case LOGGED_OP_FINSERT_start:
 op->v.state = LOGGED_OP_FINSERT_shift_extents;

 if (insert) {
  ret = commit_do(trans, NULL, NULL, BCH_TRANS_COMMIT_no_enospc,
    adjust_i_size(trans, inum, src_offset, len, warn_errors) ?:
    bch2_logged_op_update(trans, &op->k_i));
  if (ret)
   goto err;
 } else {
  bch2_btree_iter_set_pos(trans, &iter, POS(inum.inum, src_offset));

  ret = bch2_fpunch_at(trans, &iter, inum, src_offset + len, i_sectors_delta);
  if (ret && !bch2_err_matches(ret, BCH_ERR_transaction_restart))
   goto err;

  ret = commit_do(trans, NULL, NULL, BCH_TRANS_COMMIT_no_enospc,
    bch2_logged_op_update(trans, &op->k_i));
 }

 fallthrough;
case LOGGED_OP_FINSERT_shift_extents:
 while (1) {
  struct disk_reservation disk_res =
   bch2_disk_reservation_init(c, 0);
  struct bkey_i delete, *copy;
  struct bkey_s_c k;
  struct bpos src_pos = POS(inum.inum, src_offset);

  bch2_trans_begin(trans);

  ret = __bch2_subvolume_get_snapshot(trans, inum.subvol, &snapshot,
          warn_errors);
  if (ret)
   goto btree_err;

  bch2_btree_iter_set_snapshot(trans, &iter, snapshot);
  bch2_btree_iter_set_pos(trans, &iter, SPOS(inum.inum, pos, snapshot));

  k = insert
   ? bch2_btree_iter_peek_prev_min(trans, &iter, POS(inum.inum, 0))
   : bch2_btree_iter_peek_max(trans, &iter, POS(inum.inum, U64_MAX));
  if ((ret = bkey_err(k)))
   goto btree_err;

  if (!k.k ||
      k.k->p.inode != inum.inum ||
      bkey_le(k.k->p, POS(inum.inum, src_offset)))
   break;

  copy = bch2_bkey_make_mut_noupdate(trans, k);
  if ((ret = PTR_ERR_OR_ZERO(copy)))
   goto btree_err;

  if (insert &&
      bkey_lt(bkey_start_pos(k.k), src_pos)) {
   bch2_cut_front(src_pos, copy);

   /* Splitting compressed extent? */
   bch2_disk_reservation_add(c, &disk_res,
     copy->k.size *
     bch2_bkey_nr_ptrs_allocated(bkey_i_to_s_c(copy)),
     BCH_DISK_RESERVATION_NOFAIL);
  }

  bkey_init(&delete.k);
  delete.k.p = copy->k.p;
  delete.k.p.snapshot = snapshot;
  delete.k.size = copy->k.size;

  copy->k.p.offset += shift;
  copy->k.p.snapshot = snapshot;

  op->v.pos = cpu_to_le64(insert ? bkey_start_offset(&delete.k) : delete.k.p.offset);

  ret =   bch2_bkey_set_needs_rebalance(c, &opts, copy) ?:
   bch2_btree_insert_trans(trans, BTREE_ID_extents, &delete, 0) ?:
   bch2_btree_insert_trans(trans, BTREE_ID_extents, copy, 0) ?:
   bch2_logged_op_update(trans, &op->k_i) ?:
   bch2_trans_commit(trans, &disk_res, NULL, BCH_TRANS_COMMIT_no_enospc);
btree_err:
  bch2_disk_reservation_put(c, &disk_res);

  if (bch2_err_matches(ret, BCH_ERR_transaction_restart))
   continue;
  if (ret)
   goto err;

  pos = le64_to_cpu(op->v.pos);
 }

 op->v.state = LOGGED_OP_FINSERT_finish;

 if (!insert) {
  ret = commit_do(trans, NULL, NULL, BCH_TRANS_COMMIT_no_enospc,
    adjust_i_size(trans, inum, src_offset, shift, warn_errors) ?:
    bch2_logged_op_update(trans, &op->k_i));
 } else {
  /* We need an inode update to update bi_journal_seq for fsync: */
  ret = commit_do(trans, NULL, NULL, BCH_TRANS_COMMIT_no_enospc,
    adjust_i_size(trans, inum, 0, 0, warn_errors) ?:
    bch2_logged_op_update(trans, &op->k_i));
 }

 break;
case LOGGED_OP_FINSERT_finish:
 break;
 }
err:
 bch2_trans_iter_exit(trans, &iter);
 if (warn_errors)
  bch_err_fn(c, ret);
 return ret;
}

int bch2_resume_logged_op_finsert(struct btree_trans *trans, struct bkey_i *op_k)
{
 return __bch2_resume_logged_op_finsert(trans, op_k, NULL);
}

int bch2_fcollapse_finsert(struct bch_fs *c, subvol_inum inum,
      u64 offset, u64 len, bool insert,
      s64 *i_sectors_delta)
{
 struct bkey_i_logged_op_finsert op;
 s64 shift = insert ? len : -len;

 bkey_logged_op_finsert_init(&op.k_i);
 op.v.subvol = cpu_to_le32(inum.subvol);
 op.v.inum = cpu_to_le64(inum.inum);
 op.v.dst_offset = cpu_to_le64(offset + shift);
 op.v.src_offset = cpu_to_le64(offset);
 op.v.pos = cpu_to_le64(insert ? U64_MAX : offset);

 /*
 * Logged ops aren't atomic w.r.t. snapshot creation: creating a
 * snapshot while they're in progress, then crashing, will result in the
 * resume only proceeding in one of the snapshots
 */
 down_read(&c->snapshot_create_lock);
 struct btree_trans *trans = bch2_trans_get(c);
 int ret = bch2_logged_op_start(trans, &op.k_i);
 if (ret)
  goto out;
 ret = __bch2_resume_logged_op_finsert(trans, &op.k_i, i_sectors_delta);
 ret = bch2_logged_op_finish(trans, &op.k_i) ?: ret;
out:
 bch2_trans_put(trans);
 up_read(&c->snapshot_create_lock);

 return ret;
}