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 /* 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 294 */ 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); 300 301 return ret; 302 } 303 304 /* finsert/fcollapse: */ 305 306 void bch2_logged_op_finsert_to_text(struct printbuf *out, struct bch_fs *c, struct bkey_s_c k) 307 { 308 struct bkey_s_c_logged_op_finsert op = bkey_s_c_to_logged_op_finsert(k); 309 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)); 314 } 315 316 static int adjust_i_size(struct btree_trans *trans, subvol_inum inum, u64 offset, s64 len) 317 { 318 struct btree_iter iter; 319 struct bch_inode_unpacked inode_u; 320 int ret; 321 322 offset <<= 9; 323 len <<= 9; 324 325 ret = bch2_inode_peek(trans, &iter, &inode_u, inum, BTREE_ITER_INTENT); 326 if (ret) 327 return ret; 328 329 if (len > 0) { 330 if (MAX_LFS_FILESIZE - inode_u.bi_size < len) { 331 ret = -EFBIG; 332 goto err; 333 } 334 335 if (offset >= inode_u.bi_size) { 336 ret = -EINVAL; 337 goto err; 338 } 339 } 340 341 inode_u.bi_size += len; 342 inode_u.bi_mtime = inode_u.bi_ctime = bch2_current_time(trans->c); 343 344 ret = bch2_inode_write(trans, &iter, &inode_u); 345 err: 346 bch2_trans_iter_exit(trans, &iter); 347 return ret; 348 } 349 350 static int __bch2_resume_logged_op_finsert(struct btree_trans *trans, 351 struct bkey_i *op_k, 352 u64 *i_sectors_delta) 353 { 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; 364 int ret = 0; 365 366 bch2_trans_iter_init(trans, &iter, BTREE_ID_extents, 367 POS(inum.inum, 0), 368 BTREE_ITER_INTENT); 369 370 switch (op->v.state) { 371 case LOGGED_OP_FINSERT_start: 372 op->v.state = LOGGED_OP_FINSERT_shift_extents; 373 374 if (insert) { 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)); 378 if (ret) 379 goto err; 380 } else { 381 bch2_btree_iter_set_pos(&iter, POS(inum.inum, src_offset)); 382 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)) 385 goto err; 386 387 ret = commit_do(trans, NULL, NULL, BTREE_INSERT_NOFAIL, 388 bch2_logged_op_update(trans, &op->k_i)); 389 } 390 391 fallthrough; 392 case LOGGED_OP_FINSERT_shift_extents: 393 while (1) { 394 struct disk_reservation disk_res = 395 bch2_disk_reservation_init(c, 0); 396 struct bkey_i delete, *copy; 397 struct bkey_s_c k; 398 struct bpos src_pos = POS(inum.inum, src_offset); 399 u32 snapshot; 400 401 bch2_trans_begin(trans); 402 403 ret = bch2_subvolume_get_snapshot(trans, inum.subvol, &snapshot); 404 if (ret) 405 goto btree_err; 406 407 bch2_btree_iter_set_snapshot(&iter, snapshot); 408 bch2_btree_iter_set_pos(&iter, SPOS(inum.inum, pos, snapshot)); 409 410 k = insert 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))) 414 goto btree_err; 415 416 if (!k.k || 417 k.k->p.inode != inum.inum || 418 bkey_le(k.k->p, POS(inum.inum, src_offset))) 419 break; 420 421 copy = bch2_bkey_make_mut_noupdate(trans, k); 422 if ((ret = PTR_ERR_OR_ZERO(copy))) 423 goto btree_err; 424 425 if (insert && 426 bkey_lt(bkey_start_pos(k.k), src_pos)) { 427 bch2_cut_front(src_pos, copy); 428 429 /* Splitting compressed extent? */ 430 bch2_disk_reservation_add(c, &disk_res, 431 copy->k.size * 432 bch2_bkey_nr_ptrs_allocated(bkey_i_to_s_c(copy)), 433 BCH_DISK_RESERVATION_NOFAIL); 434 } 435 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; 440 441 copy->k.p.offset += shift; 442 copy->k.p.snapshot = snapshot; 443 444 op->v.pos = cpu_to_le64(insert ? bkey_start_offset(&delete.k) : delete.k.p.offset); 445 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); 450 btree_err: 451 bch2_disk_reservation_put(c, &disk_res); 452 453 if (bch2_err_matches(ret, BCH_ERR_transaction_restart)) 454 continue; 455 if (ret) 456 goto err; 457 458 pos = le64_to_cpu(op->v.pos); 459 } 460 461 op->v.state = LOGGED_OP_FINSERT_finish; 462 463 if (!insert) { 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)); 467 } else { 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)); 472 } 473 474 break; 475 case LOGGED_OP_FINSERT_finish: 476 break; 477 } 478 err: 479 bch2_logged_op_finish(trans, op_k); 480 bch2_trans_iter_exit(trans, &iter); 481 return ret; 482 } 483 484 int bch2_resume_logged_op_finsert(struct btree_trans *trans, struct bkey_i *op_k) 485 { 486 return __bch2_resume_logged_op_finsert(trans, op_k, NULL); 487 } 488 489 int bch2_fcollapse_finsert(struct bch_fs *c, subvol_inum inum, 490 u64 offset, u64 len, bool insert, 491 s64 *i_sectors_delta) 492 { 493 struct bkey_i_logged_op_finsert op; 494 s64 shift = insert ? len : -len; 495 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); 502 503 /* 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 507 */ 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); 513 514 return ret; 515 } 516