1 // SPDX-License-Identifier: GPL-2.0
3 * io_misc.c - fallocate, fpunch, truncate:
7 #include "alloc_foreground.h"
9 #include "btree_update.h"
14 #include "extent_update.h"
18 #include "logged_ops.h"
19 #include "subvolume.h"
21 /* Overwrites whatever was present with zeroes: */
22 int bch2_extent_fallocate(struct btree_trans *trans,
24 struct btree_iter *iter,
26 struct bch_io_opts opts,
28 struct write_point_specifier write_point)
30 struct bch_fs *c = trans->c;
31 struct disk_reservation disk_res = { 0 };
33 struct open_buckets open_buckets = { 0 };
35 struct bkey_buf old, new;
36 unsigned sectors_allocated = 0;
37 bool have_reservation = false;
38 bool unwritten = opts.nocow &&
39 c->sb.version >= bcachefs_metadata_version_unwritten_extents;
42 bch2_bkey_buf_init(&old);
43 bch2_bkey_buf_init(&new);
44 closure_init_stack(&cl);
46 k = bch2_btree_iter_peek_slot(iter);
51 sectors = min_t(u64, sectors, k.k->p.offset - iter->pos.offset);
53 if (!have_reservation) {
54 unsigned new_replicas =
55 max(0, (int) opts.data_replicas -
56 (int) bch2_bkey_nr_ptrs_fully_allocated(k));
58 * Get a disk reservation before (in the nocow case) calling
61 ret = bch2_disk_reservation_get(c, &disk_res, sectors, new_replicas, 0);
65 bch2_bkey_buf_reassemble(&old, c, k);
68 if (have_reservation) {
69 if (!bch2_extents_match(k, bkey_i_to_s_c(old.k)))
72 bch2_key_resize(&new.k->k, sectors);
73 } else if (!unwritten) {
74 struct bkey_i_reservation *reservation;
76 bch2_bkey_buf_realloc(&new, c, sizeof(*reservation) / sizeof(u64));
77 reservation = bkey_reservation_init(new.k);
78 reservation->k.p = iter->pos;
79 bch2_key_resize(&reservation->k, sectors);
80 reservation->v.nr_replicas = opts.data_replicas;
82 struct bkey_i_extent *e;
83 struct bch_devs_list devs_have;
84 struct write_point *wp;
85 struct bch_extent_ptr *ptr;
89 bch2_bkey_buf_realloc(&new, c, BKEY_EXTENT_U64s_MAX);
91 e = bkey_extent_init(new.k);
94 ret = bch2_alloc_sectors_start_trans(trans,
95 opts.foreground_target,
101 BCH_WATERMARK_normal, 0, &cl, &wp);
102 if (bch2_err_matches(ret, BCH_ERR_operation_blocked))
103 ret = -BCH_ERR_transaction_restart_nested;
107 sectors = min(sectors, wp->sectors_free);
108 sectors_allocated = sectors;
110 bch2_key_resize(&e->k, sectors);
112 bch2_open_bucket_get(c, wp, &open_buckets);
113 bch2_alloc_sectors_append_ptrs(c, wp, &e->k_i, sectors, false);
114 bch2_alloc_sectors_done(c, wp);
116 extent_for_each_ptr(extent_i_to_s(e), ptr)
117 ptr->unwritten = true;
120 have_reservation = true;
122 ret = bch2_extent_update(trans, inum, iter, new.k, &disk_res,
123 0, i_sectors_delta, true);
125 if (!ret && sectors_allocated)
126 bch2_increment_clock(c, sectors_allocated, WRITE);
128 bch2_open_buckets_put(c, &open_buckets);
129 bch2_disk_reservation_put(c, &disk_res);
130 bch2_bkey_buf_exit(&new, c);
131 bch2_bkey_buf_exit(&old, c);
133 if (closure_nr_remaining(&cl) != 1) {
134 bch2_trans_unlock(trans);
142 * Returns -BCH_ERR_transacton_restart if we had to drop locks:
144 int bch2_fpunch_at(struct btree_trans *trans, struct btree_iter *iter,
145 subvol_inum inum, u64 end,
146 s64 *i_sectors_delta)
148 struct bch_fs *c = trans->c;
149 unsigned max_sectors = KEY_SIZE_MAX & (~0 << c->block_bits);
150 struct bpos end_pos = POS(inum.inum, end);
152 int ret = 0, ret2 = 0;
156 bch2_err_matches(ret, BCH_ERR_transaction_restart)) {
157 struct disk_reservation disk_res =
158 bch2_disk_reservation_init(c, 0);
159 struct bkey_i delete;
164 bch2_trans_begin(trans);
166 ret = bch2_subvolume_get_snapshot(trans, inum.subvol, &snapshot);
170 bch2_btree_iter_set_snapshot(iter, snapshot);
173 * peek_upto() doesn't have ideal semantics for extents:
175 k = bch2_btree_iter_peek_upto(iter, end_pos);
183 bkey_init(&delete.k);
184 delete.k.p = iter->pos;
186 /* create the biggest key we can */
187 bch2_key_resize(&delete.k, max_sectors);
188 bch2_cut_back(end_pos, &delete);
190 ret = bch2_extent_update(trans, inum, iter, &delete,
191 &disk_res, 0, i_sectors_delta, false);
192 bch2_disk_reservation_put(c, &disk_res);
198 int bch2_fpunch(struct bch_fs *c, subvol_inum inum, u64 start, u64 end,
199 s64 *i_sectors_delta)
201 struct btree_trans *trans = bch2_trans_get(c);
202 struct btree_iter iter;
205 bch2_trans_iter_init(trans, &iter, BTREE_ID_extents,
206 POS(inum.inum, start),
209 ret = bch2_fpunch_at(trans, &iter, inum, end, i_sectors_delta);
211 bch2_trans_iter_exit(trans, &iter);
212 bch2_trans_put(trans);
214 if (bch2_err_matches(ret, BCH_ERR_transaction_restart))
222 void bch2_logged_op_truncate_to_text(struct printbuf *out, struct bch_fs *c, struct bkey_s_c k)
224 struct bkey_s_c_logged_op_truncate op = bkey_s_c_to_logged_op_truncate(k);
226 prt_printf(out, "subvol=%u", le32_to_cpu(op.v->subvol));
227 prt_printf(out, " inum=%llu", le64_to_cpu(op.v->inum));
228 prt_printf(out, " new_i_size=%llu", le64_to_cpu(op.v->new_i_size));
231 static int truncate_set_isize(struct btree_trans *trans,
235 struct btree_iter iter = { NULL };
236 struct bch_inode_unpacked inode_u;
239 ret = bch2_inode_peek(trans, &iter, &inode_u, inum, BTREE_ITER_INTENT) ?:
240 (inode_u.bi_size = new_i_size, 0) ?:
241 bch2_inode_write(trans, &iter, &inode_u);
243 bch2_trans_iter_exit(trans, &iter);
247 static int __bch2_resume_logged_op_truncate(struct btree_trans *trans,
249 u64 *i_sectors_delta)
251 struct bch_fs *c = trans->c;
252 struct btree_iter fpunch_iter;
253 struct bkey_i_logged_op_truncate *op = bkey_i_to_logged_op_truncate(op_k);
254 subvol_inum inum = { le32_to_cpu(op->v.subvol), le64_to_cpu(op->v.inum) };
255 u64 new_i_size = le64_to_cpu(op->v.new_i_size);
258 ret = commit_do(trans, NULL, NULL, BTREE_INSERT_NOFAIL,
259 truncate_set_isize(trans, inum, new_i_size));
263 bch2_trans_iter_init(trans, &fpunch_iter, BTREE_ID_extents,
264 POS(inum.inum, round_up(new_i_size, block_bytes(c)) >> 9),
266 ret = bch2_fpunch_at(trans, &fpunch_iter, inum, U64_MAX, i_sectors_delta);
267 bch2_trans_iter_exit(trans, &fpunch_iter);
269 if (bch2_err_matches(ret, BCH_ERR_transaction_restart))
272 bch2_logged_op_finish(trans, op_k);
276 int bch2_resume_logged_op_truncate(struct btree_trans *trans, struct bkey_i *op_k)
278 return __bch2_resume_logged_op_truncate(trans, op_k, NULL);
281 int bch2_truncate(struct bch_fs *c, subvol_inum inum, u64 new_i_size, u64 *i_sectors_delta)
283 struct bkey_i_logged_op_truncate op;
285 bkey_logged_op_truncate_init(&op.k_i);
286 op.v.subvol = cpu_to_le32(inum.subvol);
287 op.v.inum = cpu_to_le64(inum.inum);
288 op.v.new_i_size = cpu_to_le64(new_i_size);
291 * Logged ops aren't atomic w.r.t. snapshot creation: creating a
292 * snapshot while they're in progress, then crashing, will result in the
293 * resume only proceeding in one of the snapshots
295 down_read(&c->snapshot_create_lock);
296 int ret = bch2_trans_run(c,
297 bch2_logged_op_start(trans, &op.k_i) ?:
298 __bch2_resume_logged_op_truncate(trans, &op.k_i, i_sectors_delta));
299 up_read(&c->snapshot_create_lock);
304 /* finsert/fcollapse: */
306 void bch2_logged_op_finsert_to_text(struct printbuf *out, struct bch_fs *c, struct bkey_s_c k)
308 struct bkey_s_c_logged_op_finsert op = bkey_s_c_to_logged_op_finsert(k);
310 prt_printf(out, "subvol=%u", le32_to_cpu(op.v->subvol));
311 prt_printf(out, " inum=%llu", le64_to_cpu(op.v->inum));
312 prt_printf(out, " dst_offset=%lli", le64_to_cpu(op.v->dst_offset));
313 prt_printf(out, " src_offset=%llu", le64_to_cpu(op.v->src_offset));
316 static int adjust_i_size(struct btree_trans *trans, subvol_inum inum, u64 offset, s64 len)
318 struct btree_iter iter;
319 struct bch_inode_unpacked inode_u;
325 ret = bch2_inode_peek(trans, &iter, &inode_u, inum, BTREE_ITER_INTENT);
330 if (MAX_LFS_FILESIZE - inode_u.bi_size < len) {
335 if (offset >= inode_u.bi_size) {
341 inode_u.bi_size += len;
342 inode_u.bi_mtime = inode_u.bi_ctime = bch2_current_time(trans->c);
344 ret = bch2_inode_write(trans, &iter, &inode_u);
346 bch2_trans_iter_exit(trans, &iter);
350 static int __bch2_resume_logged_op_finsert(struct btree_trans *trans,
352 u64 *i_sectors_delta)
354 struct bch_fs *c = trans->c;
355 struct btree_iter iter;
356 struct bkey_i_logged_op_finsert *op = bkey_i_to_logged_op_finsert(op_k);
357 subvol_inum inum = { le32_to_cpu(op->v.subvol), le64_to_cpu(op->v.inum) };
358 u64 dst_offset = le64_to_cpu(op->v.dst_offset);
359 u64 src_offset = le64_to_cpu(op->v.src_offset);
360 s64 shift = dst_offset - src_offset;
361 u64 len = abs(shift);
362 u64 pos = le64_to_cpu(op->v.pos);
363 bool insert = shift > 0;
366 bch2_trans_iter_init(trans, &iter, BTREE_ID_extents,
370 switch (op->v.state) {
371 case LOGGED_OP_FINSERT_start:
372 op->v.state = LOGGED_OP_FINSERT_shift_extents;
375 ret = commit_do(trans, NULL, NULL, BTREE_INSERT_NOFAIL,
376 adjust_i_size(trans, inum, src_offset, len) ?:
377 bch2_logged_op_update(trans, &op->k_i));
381 bch2_btree_iter_set_pos(&iter, POS(inum.inum, src_offset));
383 ret = bch2_fpunch_at(trans, &iter, inum, src_offset + len, i_sectors_delta);
384 if (ret && !bch2_err_matches(ret, BCH_ERR_transaction_restart))
387 ret = commit_do(trans, NULL, NULL, BTREE_INSERT_NOFAIL,
388 bch2_logged_op_update(trans, &op->k_i));
392 case LOGGED_OP_FINSERT_shift_extents:
394 struct disk_reservation disk_res =
395 bch2_disk_reservation_init(c, 0);
396 struct bkey_i delete, *copy;
398 struct bpos src_pos = POS(inum.inum, src_offset);
401 bch2_trans_begin(trans);
403 ret = bch2_subvolume_get_snapshot(trans, inum.subvol, &snapshot);
407 bch2_btree_iter_set_snapshot(&iter, snapshot);
408 bch2_btree_iter_set_pos(&iter, SPOS(inum.inum, pos, snapshot));
411 ? bch2_btree_iter_peek_prev(&iter)
412 : bch2_btree_iter_peek_upto(&iter, POS(inum.inum, U64_MAX));
413 if ((ret = bkey_err(k)))
417 k.k->p.inode != inum.inum ||
418 bkey_le(k.k->p, POS(inum.inum, src_offset)))
421 copy = bch2_bkey_make_mut_noupdate(trans, k);
422 if ((ret = PTR_ERR_OR_ZERO(copy)))
426 bkey_lt(bkey_start_pos(k.k), src_pos)) {
427 bch2_cut_front(src_pos, copy);
429 /* Splitting compressed extent? */
430 bch2_disk_reservation_add(c, &disk_res,
432 bch2_bkey_nr_ptrs_allocated(bkey_i_to_s_c(copy)),
433 BCH_DISK_RESERVATION_NOFAIL);
436 bkey_init(&delete.k);
437 delete.k.p = copy->k.p;
438 delete.k.p.snapshot = snapshot;
439 delete.k.size = copy->k.size;
441 copy->k.p.offset += shift;
442 copy->k.p.snapshot = snapshot;
444 op->v.pos = cpu_to_le64(insert ? bkey_start_offset(&delete.k) : delete.k.p.offset);
446 ret = bch2_btree_insert_trans(trans, BTREE_ID_extents, &delete, 0) ?:
447 bch2_btree_insert_trans(trans, BTREE_ID_extents, copy, 0) ?:
448 bch2_logged_op_update(trans, &op->k_i) ?:
449 bch2_trans_commit(trans, &disk_res, NULL, BTREE_INSERT_NOFAIL);
451 bch2_disk_reservation_put(c, &disk_res);
453 if (bch2_err_matches(ret, BCH_ERR_transaction_restart))
458 pos = le64_to_cpu(op->v.pos);
461 op->v.state = LOGGED_OP_FINSERT_finish;
464 ret = commit_do(trans, NULL, NULL, BTREE_INSERT_NOFAIL,
465 adjust_i_size(trans, inum, src_offset, shift) ?:
466 bch2_logged_op_update(trans, &op->k_i));
468 /* We need an inode update to update bi_journal_seq for fsync: */
469 ret = commit_do(trans, NULL, NULL, BTREE_INSERT_NOFAIL,
470 adjust_i_size(trans, inum, 0, 0) ?:
471 bch2_logged_op_update(trans, &op->k_i));
475 case LOGGED_OP_FINSERT_finish:
479 bch2_logged_op_finish(trans, op_k);
480 bch2_trans_iter_exit(trans, &iter);
484 int bch2_resume_logged_op_finsert(struct btree_trans *trans, struct bkey_i *op_k)
486 return __bch2_resume_logged_op_finsert(trans, op_k, NULL);
489 int bch2_fcollapse_finsert(struct bch_fs *c, subvol_inum inum,
490 u64 offset, u64 len, bool insert,
491 s64 *i_sectors_delta)
493 struct bkey_i_logged_op_finsert op;
494 s64 shift = insert ? len : -len;
496 bkey_logged_op_finsert_init(&op.k_i);
497 op.v.subvol = cpu_to_le32(inum.subvol);
498 op.v.inum = cpu_to_le64(inum.inum);
499 op.v.dst_offset = cpu_to_le64(offset + shift);
500 op.v.src_offset = cpu_to_le64(offset);
501 op.v.pos = cpu_to_le64(insert ? U64_MAX : offset);
504 * Logged ops aren't atomic w.r.t. snapshot creation: creating a
505 * snapshot while they're in progress, then crashing, will result in the
506 * resume only proceeding in one of the snapshots
508 down_read(&c->snapshot_create_lock);
509 int ret = bch2_trans_run(c,
510 bch2_logged_op_start(trans, &op.k_i) ?:
511 __bch2_resume_logged_op_finsert(trans, &op.k_i, i_sectors_delta));
512 up_read(&c->snapshot_create_lock);