git.sesse.net Git - bcachefs-tools-debian/blob - libbcachefs/io_misc.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * io_misc.c - fallocate, fpunch, truncate:
   4  */
   5
   6 #include "bcachefs.h"
   7 #include "alloc_foreground.h"
   8 #include "bkey_buf.h"
   9 #include "btree_update.h"
  10 #include "buckets.h"
  11 #include "clock.h"
  12 #include "error.h"
  13 #include "extents.h"
  14 #include "extent_update.h"
  15 #include "inode.h"
  16 #include "io_misc.h"
  17 #include "io_write.h"
  18 #include "logged_ops.h"
  19 #include "subvolume.h"
  20
  21 /* Overwrites whatever was present with zeroes: */
  22 int bch2_extent_fallocate(struct btree_trans *trans,
  23                           subvol_inum inum,
  24                           struct btree_iter *iter,
  25                           unsigned sectors,
  26                           struct bch_io_opts opts,
  27                           s64 *i_sectors_delta,
  28                           struct write_point_specifier write_point)
  29 {
  30         struct bch_fs *c = trans->c;
  31         struct disk_reservation disk_res = { 0 };
  32         struct closure cl;
  33         struct open_buckets open_buckets = { 0 };
  34         struct bkey_s_c k;
  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;
  40         int ret;
  41
  42         bch2_bkey_buf_init(&old);
  43         bch2_bkey_buf_init(&new);
  44         closure_init_stack(&cl);
  45
  46         k = bch2_btree_iter_peek_slot(iter);
  47         ret = bkey_err(k);
  48         if (ret)
  49                 return ret;
  50
  51         sectors = min_t(u64, sectors, k.k->p.offset - iter->pos.offset);
  52
  53         if (!have_reservation) {
  54                 unsigned new_replicas =
  55                         max(0, (int) opts.data_replicas -
  56                             (int) bch2_bkey_nr_ptrs_fully_allocated(k));
  57                 /*
  58                  * Get a disk reservation before (in the nocow case) calling
  59                  * into the allocator:
  60                  */
  61                 ret = bch2_disk_reservation_get(c, &disk_res, sectors, new_replicas, 0);
  62                 if (unlikely(ret))
  63                         goto err;
  64
  65                 bch2_bkey_buf_reassemble(&old, c, k);
  66         }
  67
  68         if (have_reservation) {
  69                 if (!bch2_extents_match(k, bkey_i_to_s_c(old.k)))
  70                         goto err;
  71
  72                 bch2_key_resize(&new.k->k, sectors);
  73         } else if (!unwritten) {
  74                 struct bkey_i_reservation *reservation;
  75
  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;
  81         } else {
  82                 struct bkey_i_extent *e;
  83                 struct bch_devs_list devs_have;
  84                 struct write_point *wp;
  85                 struct bch_extent_ptr *ptr;
  86
  87                 devs_have.nr = 0;
  88
  89                 bch2_bkey_buf_realloc(&new, c, BKEY_EXTENT_U64s_MAX);
  90
  91                 e = bkey_extent_init(new.k);
  92                 e->k.p = iter->pos;
  93
  94                 ret = bch2_alloc_sectors_start_trans(trans,
  95                                 opts.foreground_target,
  96                                 false,
  97                                 write_point,
  98                                 &devs_have,
  99                                 opts.data_replicas,
 100                                 opts.data_replicas,
 101                                 BCH_WATERMARK_normal, 0, &cl, &wp);
 102                 if (bch2_err_matches(ret, BCH_ERR_operation_blocked))
 103                         ret = -BCH_ERR_transaction_restart_nested;
 104                 if (ret)
 105                         goto err;
 106
 107                 sectors = min(sectors, wp->sectors_free);
 108                 sectors_allocated = sectors;
 109
 110                 bch2_key_resize(&e->k, sectors);
 111
 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);
 115
 116                 extent_for_each_ptr(extent_i_to_s(e), ptr)
 117                         ptr->unwritten = true;
 118         }
 119
 120         have_reservation = true;
 121
 122         ret = bch2_extent_update(trans, inum, iter, new.k, &disk_res,
 123                                  0, i_sectors_delta, true);
 124 err:
 125         if (!ret && sectors_allocated)
 126                 bch2_increment_clock(c, sectors_allocated, WRITE);
 127
 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);
 132
 133         if (closure_nr_remaining(&cl) != 1) {
 134                 bch2_trans_unlock(trans);
 135                 closure_sync(&cl);
 136         }
 137
 138         return ret;
 139 }
 140
 141 /*
 142  * Returns -BCH_ERR_transacton_restart if we had to drop locks:
 143  */
 144 int bch2_fpunch_at(struct btree_trans *trans, struct btree_iter *iter,
 145                    subvol_inum inum, u64 end,
 146                    s64 *i_sectors_delta)
 147 {
 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);
 151         struct bkey_s_c k;
 152         int ret = 0, ret2 = 0;
 153         u32 snapshot;
 154
 155         while (!ret ||
 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;
 160
 161                 if (ret)
 162                         ret2 = ret;
 163
 164                 bch2_trans_begin(trans);
 165
 166                 ret = bch2_subvolume_get_snapshot(trans, inum.subvol, &snapshot);
 167                 if (ret)
 168                         continue;
 169
 170                 bch2_btree_iter_set_snapshot(iter, snapshot);
 171
 172                 /*
 173                  * peek_upto() doesn't have ideal semantics for extents:
 174                  */
 175                 k = bch2_btree_iter_peek_upto(iter, end_pos);
 176                 if (!k.k)
 177                         break;
 178
 179                 ret = bkey_err(k);
 180                 if (ret)
 181                         continue;
 182
 183                 bkey_init(&delete.k);
 184                 delete.k.p = iter->pos;
 185
 186                 /* create the biggest key we can */
 187                 bch2_key_resize(&delete.k, max_sectors);
 188                 bch2_cut_back(end_pos, &delete);
 189
 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);
 193         }
 194
 195         return ret ?: ret2;
 196 }
 197
 198 int bch2_fpunch(struct bch_fs *c, subvol_inum inum, u64 start, u64 end,
 199                 s64 *i_sectors_delta)
 200 {
 201         struct btree_trans *trans = bch2_trans_get(c);
 202         struct btree_iter iter;
 203         int ret;
 204
 205         bch2_trans_iter_init(trans, &iter, BTREE_ID_extents,
 206                              POS(inum.inum, start),
 207                              BTREE_ITER_INTENT);
 208
 209         ret = bch2_fpunch_at(trans, &iter, inum, end, i_sectors_delta);
 210
 211         bch2_trans_iter_exit(trans, &iter);
 212         bch2_trans_put(trans);
 213
 214         if (bch2_err_matches(ret, BCH_ERR_transaction_restart))
 215                 ret = 0;
 216
 217         return ret;
 218 }
 219
 220 /* truncate: */
 221
 222 void bch2_logged_op_truncate_to_text(struct printbuf *out, struct bch_fs *c, struct bkey_s_c k)
 223 {
 224         struct bkey_s_c_logged_op_truncate op = bkey_s_c_to_logged_op_truncate(k);
 225
 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));
 229 }
 230
 231 static int truncate_set_isize(struct btree_trans *trans,
 232                               subvol_inum inum,
 233                               u64 new_i_size)
 234 {
 235         struct btree_iter iter = { NULL };
 236         struct bch_inode_unpacked inode_u;
 237         int ret;
 238
 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);
 242
 243         bch2_trans_iter_exit(trans, &iter);
 244         return ret;
 245 }
 246
 247 static int __bch2_resume_logged_op_truncate(struct btree_trans *trans,
 248                                             struct bkey_i *op_k,
 249                                             u64 *i_sectors_delta)
 250 {
 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);
 256         int ret;
 257
 258         ret = commit_do(trans, NULL, NULL, BTREE_INSERT_NOFAIL,
 259                         truncate_set_isize(trans, inum, new_i_size));
 260         if (ret)
 261                 goto err;
 262
 263         bch2_trans_iter_init(trans, &fpunch_iter, BTREE_ID_extents,
 264                              POS(inum.inum, round_up(new_i_size, block_bytes(c)) >> 9),
 265                              BTREE_ITER_INTENT);
 266         ret = bch2_fpunch_at(trans, &fpunch_iter, inum, U64_MAX, i_sectors_delta);
 267         bch2_trans_iter_exit(trans, &fpunch_iter);
 268
 269         if (bch2_err_matches(ret, BCH_ERR_transaction_restart))
 270                 ret = 0;
 271 err:
 272         bch2_logged_op_finish(trans, op_k);
 273         return ret;
 274 }
 275
 276 int bch2_resume_logged_op_truncate(struct btree_trans *trans, struct bkey_i *op_k)
 277 {
 278         return __bch2_resume_logged_op_truncate(trans, op_k, NULL);
 279 }
 280
 281 int bch2_truncate(struct bch_fs *c, subvol_inum inum, u64 new_i_size, u64 *i_sectors_delta)
 282 {
 283         struct bkey_i_logged_op_truncate op;
 284
 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);
 289
 290         return bch2_trans_run(c,
 291                 bch2_logged_op_start(trans, &op.k_i) ?:
 292                 __bch2_resume_logged_op_truncate(trans, &op.k_i, i_sectors_delta));
 293 }
 294
 295 /* finsert/fcollapse: */
 296
 297 void bch2_logged_op_finsert_to_text(struct printbuf *out, struct bch_fs *c, struct bkey_s_c k)
 298 {
 299         struct bkey_s_c_logged_op_finsert op = bkey_s_c_to_logged_op_finsert(k);
 300
 301         prt_printf(out, "subvol=%u",            le32_to_cpu(op.v->subvol));
 302         prt_printf(out, " inum=%llu",           le64_to_cpu(op.v->inum));
 303         prt_printf(out, " dst_offset=%lli",     le64_to_cpu(op.v->dst_offset));
 304         prt_printf(out, " src_offset=%llu",     le64_to_cpu(op.v->src_offset));
 305 }
 306
 307 static int adjust_i_size(struct btree_trans *trans, subvol_inum inum, u64 offset, s64 len)
 308 {
 309         struct btree_iter iter;
 310         struct bch_inode_unpacked inode_u;
 311         int ret;
 312
 313         offset  <<= 9;
 314         len     <<= 9;
 315
 316         ret = bch2_inode_peek(trans, &iter, &inode_u, inum, BTREE_ITER_INTENT);
 317         if (ret)
 318                 return ret;
 319
 320         if (len > 0) {
 321                 if (MAX_LFS_FILESIZE - inode_u.bi_size < len) {
 322                         ret = -EFBIG;
 323                         goto err;
 324                 }
 325
 326                 if (offset >= inode_u.bi_size) {
 327                         ret = -EINVAL;
 328                         goto err;
 329                 }
 330         }
 331
 332         inode_u.bi_size += len;
 333         inode_u.bi_mtime = inode_u.bi_ctime = bch2_current_time(trans->c);
 334
 335         ret = bch2_inode_write(trans, &iter, &inode_u);
 336 err:
 337         bch2_trans_iter_exit(trans, &iter);
 338         return ret;
 339 }
 340
 341 static int __bch2_resume_logged_op_finsert(struct btree_trans *trans,
 342                                            struct bkey_i *op_k,
 343                                            u64 *i_sectors_delta)
 344 {
 345         struct bch_fs *c = trans->c;
 346         struct btree_iter iter;
 347         struct bkey_i_logged_op_finsert *op = bkey_i_to_logged_op_finsert(op_k);
 348         subvol_inum inum = { le32_to_cpu(op->v.subvol), le64_to_cpu(op->v.inum) };
 349         u64 dst_offset = le64_to_cpu(op->v.dst_offset);
 350         u64 src_offset = le64_to_cpu(op->v.src_offset);
 351         s64 shift = dst_offset - src_offset;
 352         u64 len = abs(shift);
 353         u64 pos = le64_to_cpu(op->v.pos);
 354         bool insert = shift > 0;
 355         int ret = 0;
 356
 357         bch2_trans_iter_init(trans, &iter, BTREE_ID_extents,
 358                              POS(inum.inum, 0),
 359                              BTREE_ITER_INTENT);
 360
 361         switch (op->v.state) {
 362 case LOGGED_OP_FINSERT_start:
 363         op->v.state = LOGGED_OP_FINSERT_shift_extents;
 364
 365         if (insert) {
 366                 ret = commit_do(trans, NULL, NULL, BTREE_INSERT_NOFAIL,
 367                                 adjust_i_size(trans, inum, src_offset, len) ?:
 368                                 bch2_logged_op_update(trans, &op->k_i));
 369                 if (ret)
 370                         goto err;
 371         } else {
 372                 bch2_btree_iter_set_pos(&iter, POS(inum.inum, src_offset));
 373
 374                 ret = bch2_fpunch_at(trans, &iter, inum, src_offset + len, i_sectors_delta);
 375                 if (ret && !bch2_err_matches(ret, BCH_ERR_transaction_restart))
 376                         goto err;
 377
 378                 ret = commit_do(trans, NULL, NULL, BTREE_INSERT_NOFAIL,
 379                                 bch2_logged_op_update(trans, &op->k_i));
 380         }
 381
 382         fallthrough;
 383 case LOGGED_OP_FINSERT_shift_extents:
 384         while (1) {
 385                 struct disk_reservation disk_res =
 386                         bch2_disk_reservation_init(c, 0);
 387                 struct bkey_i delete, *copy;
 388                 struct bkey_s_c k;
 389                 struct bpos src_pos = POS(inum.inum, src_offset);
 390                 u32 snapshot;
 391
 392                 bch2_trans_begin(trans);
 393
 394                 ret = bch2_subvolume_get_snapshot(trans, inum.subvol, &snapshot);
 395                 if (ret)
 396                         goto btree_err;
 397
 398                 bch2_btree_iter_set_snapshot(&iter, snapshot);
 399                 bch2_btree_iter_set_pos(&iter, SPOS(inum.inum, pos, snapshot));
 400
 401                 k = insert
 402                         ? bch2_btree_iter_peek_prev(&iter)
 403                         : bch2_btree_iter_peek_upto(&iter, POS(inum.inum, U64_MAX));
 404                 if ((ret = bkey_err(k)))
 405                         goto btree_err;
 406
 407                 if (!k.k ||
 408                     k.k->p.inode != inum.inum ||
 409                     bkey_le(k.k->p, POS(inum.inum, src_offset)))
 410                         break;
 411
 412                 copy = bch2_bkey_make_mut_noupdate(trans, k);
 413                 if ((ret = PTR_ERR_OR_ZERO(copy)))
 414                         goto btree_err;
 415
 416                 if (insert &&
 417                     bkey_lt(bkey_start_pos(k.k), src_pos)) {
 418                         bch2_cut_front(src_pos, copy);
 419
 420                         /* Splitting compressed extent? */
 421                         bch2_disk_reservation_add(c, &disk_res,
 422                                         copy->k.size *
 423                                         bch2_bkey_nr_ptrs_allocated(bkey_i_to_s_c(copy)),
 424                                         BCH_DISK_RESERVATION_NOFAIL);
 425                 }
 426
 427                 bkey_init(&delete.k);
 428                 delete.k.p = copy->k.p;
 429                 delete.k.p.snapshot = snapshot;
 430                 delete.k.size = copy->k.size;
 431
 432                 copy->k.p.offset += shift;
 433                 copy->k.p.snapshot = snapshot;
 434
 435                 op->v.pos = cpu_to_le64(insert ? bkey_start_offset(&delete.k) : delete.k.p.offset);
 436
 437                 ret =   bch2_btree_insert_trans(trans, BTREE_ID_extents, &delete, 0) ?:
 438                         bch2_btree_insert_trans(trans, BTREE_ID_extents, copy, 0) ?:
 439                         bch2_logged_op_update(trans, &op->k_i) ?:
 440                         bch2_trans_commit(trans, &disk_res, NULL, BTREE_INSERT_NOFAIL);
 441 btree_err:
 442                 bch2_disk_reservation_put(c, &disk_res);
 443
 444                 if (bch2_err_matches(ret, BCH_ERR_transaction_restart))
 445                         continue;
 446                 if (ret)
 447                         goto err;
 448
 449                 pos = le64_to_cpu(op->v.pos);
 450         }
 451
 452         op->v.state = LOGGED_OP_FINSERT_finish;
 453
 454         if (!insert) {
 455                 ret = commit_do(trans, NULL, NULL, BTREE_INSERT_NOFAIL,
 456                                 adjust_i_size(trans, inum, src_offset, shift) ?:
 457                                 bch2_logged_op_update(trans, &op->k_i));
 458         } else {
 459                 /* We need an inode update to update bi_journal_seq for fsync: */
 460                 ret = commit_do(trans, NULL, NULL, BTREE_INSERT_NOFAIL,
 461                                 adjust_i_size(trans, inum, 0, 0) ?:
 462                                 bch2_logged_op_update(trans, &op->k_i));
 463         }
 464
 465         break;
 466 case LOGGED_OP_FINSERT_finish:
 467         break;
 468         }
 469 err:
 470         bch2_logged_op_finish(trans, op_k);
 471         bch2_trans_iter_exit(trans, &iter);
 472         return ret;
 473 }
 474
 475 int bch2_resume_logged_op_finsert(struct btree_trans *trans, struct bkey_i *op_k)
 476 {
 477         return __bch2_resume_logged_op_finsert(trans, op_k, NULL);
 478 }
 479
 480 int bch2_fcollapse_finsert(struct bch_fs *c, subvol_inum inum,
 481                            u64 offset, u64 len, bool insert,
 482                            s64 *i_sectors_delta)
 483 {
 484         struct bkey_i_logged_op_finsert op;
 485         s64 shift = insert ? len : -len;
 486
 487         bkey_logged_op_finsert_init(&op.k_i);
 488         op.v.subvol     = cpu_to_le32(inum.subvol);
 489         op.v.inum       = cpu_to_le64(inum.inum);
 490         op.v.dst_offset = cpu_to_le64(offset + shift);
 491         op.v.src_offset = cpu_to_le64(offset);
 492         op.v.pos        = cpu_to_le64(insert ? U64_MAX : offset);
 493
 494         return bch2_trans_run(c,
 495                 bch2_logged_op_start(trans, &op.k_i) ?:
 496                 __bch2_resume_logged_op_finsert(trans, &op.k_i, i_sectors_delta));
 497 }