1 // SPDX-License-Identifier: GPL-2.0 2 #ifndef NO_BCACHEFS_FS 3 4 #include "bcachefs.h" 5 #include "acl.h" 6 #include "bkey_buf.h" 7 #include "btree_update.h" 8 #include "buckets.h" 9 #include "chardev.h" 10 #include "dirent.h" 11 #include "errcode.h" 12 #include "extents.h" 13 #include "fs.h" 14 #include "fs-common.h" 15 #include "fs-io.h" 16 #include "fs-ioctl.h" 17 #include "fs-io-buffered.h" 18 #include "fs-io-direct.h" 19 #include "fs-io-pagecache.h" 20 #include "fsck.h" 21 #include "inode.h" 22 #include "io_read.h" 23 #include "journal.h" 24 #include "keylist.h" 25 #include "quota.h" 26 #include "snapshot.h" 27 #include "super.h" 28 #include "xattr.h" 29 #include "trace.h" 30 31 #include <linux/aio.h> 32 #include <linux/backing-dev.h> 33 #include <linux/exportfs.h> 34 #include <linux/fiemap.h> 35 #include <linux/fs_context.h> 36 #include <linux/module.h> 37 #include <linux/pagemap.h> 38 #include <linux/posix_acl.h> 39 #include <linux/random.h> 40 #include <linux/seq_file.h> 41 #include <linux/statfs.h> 42 #include <linux/string.h> 43 #include <linux/xattr.h> 44 45 static struct kmem_cache *bch2_inode_cache; 46 47 static void bch2_vfs_inode_init(struct btree_trans *, subvol_inum, 48 struct bch_inode_info *, 49 struct bch_inode_unpacked *, 50 struct bch_subvolume *); 51 52 void bch2_inode_update_after_write(struct btree_trans *trans, 53 struct bch_inode_info *inode, 54 struct bch_inode_unpacked *bi, 55 unsigned fields) 56 { 57 struct bch_fs *c = trans->c; 58 59 BUG_ON(bi->bi_inum != inode->v.i_ino); 60 61 bch2_assert_pos_locked(trans, BTREE_ID_inodes, POS(0, bi->bi_inum)); 62 63 set_nlink(&inode->v, bch2_inode_nlink_get(bi)); 64 i_uid_write(&inode->v, bi->bi_uid); 65 i_gid_write(&inode->v, bi->bi_gid); 66 inode->v.i_mode = bi->bi_mode; 67 68 if (fields & ATTR_ATIME) 69 inode_set_atime_to_ts(&inode->v, bch2_time_to_timespec(c, bi->bi_atime)); 70 if (fields & ATTR_MTIME) 71 inode_set_mtime_to_ts(&inode->v, bch2_time_to_timespec(c, bi->bi_mtime)); 72 if (fields & ATTR_CTIME) 73 inode_set_ctime_to_ts(&inode->v, bch2_time_to_timespec(c, bi->bi_ctime)); 74 75 inode->ei_inode = *bi; 76 77 bch2_inode_flags_to_vfs(inode); 78 } 79 80 int __must_check bch2_write_inode(struct bch_fs *c, 81 struct bch_inode_info *inode, 82 inode_set_fn set, 83 void *p, unsigned fields) 84 { 85 struct btree_trans *trans = bch2_trans_get(c); 86 struct btree_iter iter = { NULL }; 87 struct bch_inode_unpacked inode_u; 88 int ret; 89 retry: 90 bch2_trans_begin(trans); 91 92 ret = bch2_inode_peek(trans, &iter, &inode_u, inode_inum(inode), 93 BTREE_ITER_intent) ?: 94 (set ? set(trans, inode, &inode_u, p) : 0) ?: 95 bch2_inode_write(trans, &iter, &inode_u) ?: 96 bch2_trans_commit(trans, NULL, NULL, BCH_TRANS_COMMIT_no_enospc); 97 98 /* 99 * the btree node lock protects inode->ei_inode, not ei_update_lock; 100 * this is important for inode updates via bchfs_write_index_update 101 */ 102 if (!ret) 103 bch2_inode_update_after_write(trans, inode, &inode_u, fields); 104 105 bch2_trans_iter_exit(trans, &iter); 106 107 if (bch2_err_matches(ret, BCH_ERR_transaction_restart)) 108 goto retry; 109 110 bch2_fs_fatal_err_on(bch2_err_matches(ret, ENOENT), c, 111 "%s: inode %u:%llu not found when updating", 112 bch2_err_str(ret), 113 inode_inum(inode).subvol, 114 inode_inum(inode).inum); 115 116 bch2_trans_put(trans); 117 return ret < 0 ? ret : 0; 118 } 119 120 int bch2_fs_quota_transfer(struct bch_fs *c, 121 struct bch_inode_info *inode, 122 struct bch_qid new_qid, 123 unsigned qtypes, 124 enum quota_acct_mode mode) 125 { 126 unsigned i; 127 int ret; 128 129 qtypes &= enabled_qtypes(c); 130 131 for (i = 0; i < QTYP_NR; i++) 132 if (new_qid.q[i] == inode->ei_qid.q[i]) 133 qtypes &= ~(1U << i); 134 135 if (!qtypes) 136 return 0; 137 138 mutex_lock(&inode->ei_quota_lock); 139 140 ret = bch2_quota_transfer(c, qtypes, new_qid, 141 inode->ei_qid, 142 inode->v.i_blocks + 143 inode->ei_quota_reserved, 144 mode); 145 if (!ret) 146 for (i = 0; i < QTYP_NR; i++) 147 if (qtypes & (1 << i)) 148 inode->ei_qid.q[i] = new_qid.q[i]; 149 150 mutex_unlock(&inode->ei_quota_lock); 151 152 return ret; 153 } 154 155 static int bch2_iget5_test(struct inode *vinode, void *p) 156 { 157 struct bch_inode_info *inode = to_bch_ei(vinode); 158 subvol_inum *inum = p; 159 160 return inode->ei_subvol == inum->subvol && 161 inode->ei_inode.bi_inum == inum->inum; 162 } 163 164 static int bch2_iget5_set(struct inode *vinode, void *p) 165 { 166 struct bch_inode_info *inode = to_bch_ei(vinode); 167 subvol_inum *inum = p; 168 169 inode->v.i_ino = inum->inum; 170 inode->ei_subvol = inum->subvol; 171 inode->ei_inode.bi_inum = inum->inum; 172 return 0; 173 } 174 175 static unsigned bch2_inode_hash(subvol_inum inum) 176 { 177 return jhash_3words(inum.subvol, inum.inum >> 32, inum.inum, JHASH_INITVAL); 178 } 179 180 struct bch_inode_info *__bch2_inode_hash_find(struct bch_fs *c, subvol_inum inum) 181 { 182 return to_bch_ei(ilookup5_nowait(c->vfs_sb, 183 bch2_inode_hash(inum), 184 bch2_iget5_test, 185 &inum)); 186 } 187 188 static struct bch_inode_info *bch2_inode_insert(struct bch_fs *c, struct bch_inode_info *inode) 189 { 190 subvol_inum inum = inode_inum(inode); 191 struct bch_inode_info *old = to_bch_ei(inode_insert5(&inode->v, 192 bch2_inode_hash(inum), 193 bch2_iget5_test, 194 bch2_iget5_set, 195 &inum)); 196 BUG_ON(!old); 197 198 if (unlikely(old != inode)) { 199 /* 200 * bcachefs doesn't use I_NEW; we have no use for it since we 201 * only insert fully created inodes in the inode hash table. But 202 * discard_new_inode() expects it to be set... 203 */ 204 inode->v.i_state |= I_NEW; 205 /* 206 * We don't want bch2_evict_inode() to delete the inode on disk, 207 * we just raced and had another inode in cache. Normally new 208 * inodes don't have nlink == 0 - except tmpfiles do... 209 */ 210 set_nlink(&inode->v, 1); 211 discard_new_inode(&inode->v); 212 inode = old; 213 } else { 214 mutex_lock(&c->vfs_inodes_lock); 215 list_add(&inode->ei_vfs_inode_list, &c->vfs_inodes_list); 216 mutex_unlock(&c->vfs_inodes_lock); 217 /* 218 * Again, I_NEW makes no sense for bcachefs. This is only needed 219 * for clearing I_NEW, but since the inode was already fully 220 * created and initialized we didn't actually want 221 * inode_insert5() to set it for us. 222 */ 223 unlock_new_inode(&inode->v); 224 } 225 226 return inode; 227 } 228 229 #define memalloc_flags_do(_flags, _do) \ 230 ({ \ 231 unsigned _saved_flags = memalloc_flags_save(_flags); \ 232 typeof(_do) _ret = _do; \ 233 memalloc_noreclaim_restore(_saved_flags); \ 234 _ret; \ 235 }) 236 237 static struct inode *bch2_alloc_inode(struct super_block *sb) 238 { 239 BUG(); 240 } 241 242 static struct bch_inode_info *__bch2_new_inode(struct bch_fs *c) 243 { 244 struct bch_inode_info *inode = kmem_cache_alloc(bch2_inode_cache, GFP_NOFS); 245 if (!inode) 246 return NULL; 247 248 inode_init_once(&inode->v); 249 mutex_init(&inode->ei_update_lock); 250 two_state_lock_init(&inode->ei_pagecache_lock); 251 INIT_LIST_HEAD(&inode->ei_vfs_inode_list); 252 inode->ei_flags = 0; 253 mutex_init(&inode->ei_quota_lock); 254 memset(&inode->ei_devs_need_flush, 0, sizeof(inode->ei_devs_need_flush)); 255 256 if (unlikely(inode_init_always(c->vfs_sb, &inode->v))) { 257 kmem_cache_free(bch2_inode_cache, inode); 258 return NULL; 259 } 260 261 return inode; 262 } 263 264 /* 265 * Allocate a new inode, dropping/retaking btree locks if necessary: 266 */ 267 static struct bch_inode_info *bch2_new_inode(struct btree_trans *trans) 268 { 269 struct bch_inode_info *inode = 270 memalloc_flags_do(PF_MEMALLOC_NORECLAIM|PF_MEMALLOC_NOWARN, 271 __bch2_new_inode(trans->c)); 272 273 if (unlikely(!inode)) { 274 int ret = drop_locks_do(trans, (inode = __bch2_new_inode(trans->c)) ? 0 : -ENOMEM); 275 if (ret && inode) { 276 __destroy_inode(&inode->v); 277 kmem_cache_free(bch2_inode_cache, inode); 278 } 279 if (ret) 280 return ERR_PTR(ret); 281 } 282 283 return inode; 284 } 285 286 struct inode *bch2_vfs_inode_get(struct bch_fs *c, subvol_inum inum) 287 { 288 struct bch_inode_info *inode = 289 to_bch_ei(ilookup5_nowait(c->vfs_sb, 290 bch2_inode_hash(inum), 291 bch2_iget5_test, 292 &inum)); 293 if (inode) 294 return &inode->v; 295 296 struct btree_trans *trans = bch2_trans_get(c); 297 298 struct bch_inode_unpacked inode_u; 299 struct bch_subvolume subvol; 300 int ret = lockrestart_do(trans, 301 bch2_subvolume_get(trans, inum.subvol, true, 0, &subvol) ?: 302 bch2_inode_find_by_inum_trans(trans, inum, &inode_u)) ?: 303 PTR_ERR_OR_ZERO(inode = bch2_new_inode(trans)); 304 if (!ret) { 305 bch2_vfs_inode_init(trans, inum, inode, &inode_u, &subvol); 306 inode = bch2_inode_insert(c, inode); 307 } 308 bch2_trans_put(trans); 309 310 return ret ? ERR_PTR(ret) : &inode->v; 311 } 312 313 struct bch_inode_info * 314 __bch2_create(struct mnt_idmap *idmap, 315 struct bch_inode_info *dir, struct dentry *dentry, 316 umode_t mode, dev_t rdev, subvol_inum snapshot_src, 317 unsigned flags) 318 { 319 struct bch_fs *c = dir->v.i_sb->s_fs_info; 320 struct btree_trans *trans; 321 struct bch_inode_unpacked dir_u; 322 struct bch_inode_info *inode; 323 struct bch_inode_unpacked inode_u; 324 struct posix_acl *default_acl = NULL, *acl = NULL; 325 subvol_inum inum; 326 struct bch_subvolume subvol; 327 u64 journal_seq = 0; 328 int ret; 329 330 /* 331 * preallocate acls + vfs inode before btree transaction, so that 332 * nothing can fail after the transaction succeeds: 333 */ 334 #ifdef CONFIG_BCACHEFS_POSIX_ACL 335 ret = posix_acl_create(&dir->v, &mode, &default_acl, &acl); 336 if (ret) 337 return ERR_PTR(ret); 338 #endif 339 inode = __bch2_new_inode(c); 340 if (unlikely(!inode)) { 341 inode = ERR_PTR(-ENOMEM); 342 goto err; 343 } 344 345 bch2_inode_init_early(c, &inode_u); 346 347 if (!(flags & BCH_CREATE_TMPFILE)) 348 mutex_lock(&dir->ei_update_lock); 349 350 trans = bch2_trans_get(c); 351 retry: 352 bch2_trans_begin(trans); 353 354 ret = bch2_subvol_is_ro_trans(trans, dir->ei_subvol) ?: 355 bch2_create_trans(trans, 356 inode_inum(dir), &dir_u, &inode_u, 357 !(flags & BCH_CREATE_TMPFILE) 358 ? &dentry->d_name : NULL, 359 from_kuid(i_user_ns(&dir->v), current_fsuid()), 360 from_kgid(i_user_ns(&dir->v), current_fsgid()), 361 mode, rdev, 362 default_acl, acl, snapshot_src, flags) ?: 363 bch2_quota_acct(c, bch_qid(&inode_u), Q_INO, 1, 364 KEY_TYPE_QUOTA_PREALLOC); 365 if (unlikely(ret)) 366 goto err_before_quota; 367 368 inum.subvol = inode_u.bi_subvol ?: dir->ei_subvol; 369 inum.inum = inode_u.bi_inum; 370 371 ret = bch2_subvolume_get(trans, inum.subvol, true, 372 BTREE_ITER_with_updates, &subvol) ?: 373 bch2_trans_commit(trans, NULL, &journal_seq, 0); 374 if (unlikely(ret)) { 375 bch2_quota_acct(c, bch_qid(&inode_u), Q_INO, -1, 376 KEY_TYPE_QUOTA_WARN); 377 err_before_quota: 378 if (bch2_err_matches(ret, BCH_ERR_transaction_restart)) 379 goto retry; 380 goto err_trans; 381 } 382 383 if (!(flags & BCH_CREATE_TMPFILE)) { 384 bch2_inode_update_after_write(trans, dir, &dir_u, 385 ATTR_MTIME|ATTR_CTIME); 386 mutex_unlock(&dir->ei_update_lock); 387 } 388 389 bch2_vfs_inode_init(trans, inum, inode, &inode_u, &subvol); 390 391 set_cached_acl(&inode->v, ACL_TYPE_ACCESS, acl); 392 set_cached_acl(&inode->v, ACL_TYPE_DEFAULT, default_acl); 393 394 /* 395 * we must insert the new inode into the inode cache before calling 396 * bch2_trans_exit() and dropping locks, else we could race with another 397 * thread pulling the inode in and modifying it: 398 */ 399 inode = bch2_inode_insert(c, inode); 400 bch2_trans_put(trans); 401 err: 402 posix_acl_release(default_acl); 403 posix_acl_release(acl); 404 return inode; 405 err_trans: 406 if (!(flags & BCH_CREATE_TMPFILE)) 407 mutex_unlock(&dir->ei_update_lock); 408 409 bch2_trans_put(trans); 410 make_bad_inode(&inode->v); 411 iput(&inode->v); 412 inode = ERR_PTR(ret); 413 goto err; 414 } 415 416 /* methods */ 417 418 static struct bch_inode_info *bch2_lookup_trans(struct btree_trans *trans, 419 subvol_inum dir, struct bch_hash_info *dir_hash_info, 420 const struct qstr *name) 421 { 422 struct bch_fs *c = trans->c; 423 struct btree_iter dirent_iter = {}; 424 subvol_inum inum = {}; 425 struct printbuf buf = PRINTBUF; 426 427 struct bkey_s_c k = bch2_hash_lookup(trans, &dirent_iter, bch2_dirent_hash_desc, 428 dir_hash_info, dir, name, 0); 429 int ret = bkey_err(k); 430 if (ret) 431 return ERR_PTR(ret); 432 433 ret = bch2_dirent_read_target(trans, dir, bkey_s_c_to_dirent(k), &inum); 434 if (ret > 0) 435 ret = -ENOENT; 436 if (ret) 437 goto err; 438 439 struct bch_inode_info *inode = 440 to_bch_ei(ilookup5_nowait(c->vfs_sb, 441 bch2_inode_hash(inum), 442 bch2_iget5_test, 443 &inum)); 444 if (inode) 445 goto out; 446 447 struct bch_subvolume subvol; 448 struct bch_inode_unpacked inode_u; 449 ret = bch2_subvolume_get(trans, inum.subvol, true, 0, &subvol) ?: 450 bch2_inode_find_by_inum_nowarn_trans(trans, inum, &inode_u) ?: 451 PTR_ERR_OR_ZERO(inode = bch2_new_inode(trans)); 452 453 bch2_fs_inconsistent_on(bch2_err_matches(ret, ENOENT), 454 c, "dirent to missing inode:\n %s", 455 (bch2_bkey_val_to_text(&buf, c, k), buf.buf)); 456 if (ret) 457 goto err; 458 459 /* regular files may have hardlinks: */ 460 if (bch2_fs_inconsistent_on(bch2_inode_should_have_bp(&inode_u) && 461 !bkey_eq(k.k->p, POS(inode_u.bi_dir, inode_u.bi_dir_offset)), 462 c, 463 "dirent points to inode that does not point back:\n %s", 464 (bch2_bkey_val_to_text(&buf, c, k), 465 prt_printf(&buf, "\n "), 466 bch2_inode_unpacked_to_text(&buf, &inode_u), 467 buf.buf))) { 468 ret = -ENOENT; 469 goto err; 470 } 471 472 bch2_vfs_inode_init(trans, inum, inode, &inode_u, &subvol); 473 inode = bch2_inode_insert(c, inode); 474 out: 475 bch2_trans_iter_exit(trans, &dirent_iter); 476 printbuf_exit(&buf); 477 return inode; 478 err: 479 inode = ERR_PTR(ret); 480 goto out; 481 } 482 483 static struct dentry *bch2_lookup(struct inode *vdir, struct dentry *dentry, 484 unsigned int flags) 485 { 486 struct bch_fs *c = vdir->i_sb->s_fs_info; 487 struct bch_inode_info *dir = to_bch_ei(vdir); 488 struct bch_hash_info hash = bch2_hash_info_init(c, &dir->ei_inode); 489 490 struct bch_inode_info *inode; 491 bch2_trans_do(c, NULL, NULL, 0, 492 PTR_ERR_OR_ZERO(inode = bch2_lookup_trans(trans, inode_inum(dir), 493 &hash, &dentry->d_name))); 494 if (IS_ERR(inode)) 495 inode = NULL; 496 497 return d_splice_alias(&inode->v, dentry); 498 } 499 500 static int bch2_mknod(struct mnt_idmap *idmap, 501 struct inode *vdir, struct dentry *dentry, 502 umode_t mode, dev_t rdev) 503 { 504 struct bch_inode_info *inode = 505 __bch2_create(idmap, to_bch_ei(vdir), dentry, mode, rdev, 506 (subvol_inum) { 0 }, 0); 507 508 if (IS_ERR(inode)) 509 return bch2_err_class(PTR_ERR(inode)); 510 511 d_instantiate(dentry, &inode->v); 512 return 0; 513 } 514 515 static int bch2_create(struct mnt_idmap *idmap, 516 struct inode *vdir, struct dentry *dentry, 517 umode_t mode, bool excl) 518 { 519 return bch2_mknod(idmap, vdir, dentry, mode|S_IFREG, 0); 520 } 521 522 static int __bch2_link(struct bch_fs *c, 523 struct bch_inode_info *inode, 524 struct bch_inode_info *dir, 525 struct dentry *dentry) 526 { 527 struct bch_inode_unpacked dir_u, inode_u; 528 int ret; 529 530 mutex_lock(&inode->ei_update_lock); 531 struct btree_trans *trans = bch2_trans_get(c); 532 533 ret = commit_do(trans, NULL, NULL, 0, 534 bch2_link_trans(trans, 535 inode_inum(dir), &dir_u, 536 inode_inum(inode), &inode_u, 537 &dentry->d_name)); 538 539 if (likely(!ret)) { 540 bch2_inode_update_after_write(trans, dir, &dir_u, 541 ATTR_MTIME|ATTR_CTIME); 542 bch2_inode_update_after_write(trans, inode, &inode_u, ATTR_CTIME); 543 } 544 545 bch2_trans_put(trans); 546 mutex_unlock(&inode->ei_update_lock); 547 return ret; 548 } 549 550 static int bch2_link(struct dentry *old_dentry, struct inode *vdir, 551 struct dentry *dentry) 552 { 553 struct bch_fs *c = vdir->i_sb->s_fs_info; 554 struct bch_inode_info *dir = to_bch_ei(vdir); 555 struct bch_inode_info *inode = to_bch_ei(old_dentry->d_inode); 556 int ret; 557 558 lockdep_assert_held(&inode->v.i_rwsem); 559 560 ret = bch2_subvol_is_ro(c, dir->ei_subvol) ?: 561 bch2_subvol_is_ro(c, inode->ei_subvol) ?: 562 __bch2_link(c, inode, dir, dentry); 563 if (unlikely(ret)) 564 return bch2_err_class(ret); 565 566 ihold(&inode->v); 567 d_instantiate(dentry, &inode->v); 568 return 0; 569 } 570 571 int __bch2_unlink(struct inode *vdir, struct dentry *dentry, 572 bool deleting_snapshot) 573 { 574 struct bch_fs *c = vdir->i_sb->s_fs_info; 575 struct bch_inode_info *dir = to_bch_ei(vdir); 576 struct bch_inode_info *inode = to_bch_ei(dentry->d_inode); 577 struct bch_inode_unpacked dir_u, inode_u; 578 int ret; 579 580 bch2_lock_inodes(INODE_UPDATE_LOCK, dir, inode); 581 582 struct btree_trans *trans = bch2_trans_get(c); 583 584 ret = commit_do(trans, NULL, NULL, 585 BCH_TRANS_COMMIT_no_enospc, 586 bch2_unlink_trans(trans, 587 inode_inum(dir), &dir_u, 588 &inode_u, &dentry->d_name, 589 deleting_snapshot)); 590 if (unlikely(ret)) 591 goto err; 592 593 bch2_inode_update_after_write(trans, dir, &dir_u, 594 ATTR_MTIME|ATTR_CTIME); 595 bch2_inode_update_after_write(trans, inode, &inode_u, 596 ATTR_MTIME); 597 598 if (inode_u.bi_subvol) { 599 /* 600 * Subvolume deletion is asynchronous, but we still want to tell 601 * the VFS that it's been deleted here: 602 */ 603 set_nlink(&inode->v, 0); 604 } 605 err: 606 bch2_trans_put(trans); 607 bch2_unlock_inodes(INODE_UPDATE_LOCK, dir, inode); 608 609 return ret; 610 } 611 612 static int bch2_unlink(struct inode *vdir, struct dentry *dentry) 613 { 614 struct bch_inode_info *dir= to_bch_ei(vdir); 615 struct bch_fs *c = dir->v.i_sb->s_fs_info; 616 617 int ret = bch2_subvol_is_ro(c, dir->ei_subvol) ?: 618 __bch2_unlink(vdir, dentry, false); 619 return bch2_err_class(ret); 620 } 621 622 static int bch2_symlink(struct mnt_idmap *idmap, 623 struct inode *vdir, struct dentry *dentry, 624 const char *symname) 625 { 626 struct bch_fs *c = vdir->i_sb->s_fs_info; 627 struct bch_inode_info *dir = to_bch_ei(vdir), *inode; 628 int ret; 629 630 inode = __bch2_create(idmap, dir, dentry, S_IFLNK|S_IRWXUGO, 0, 631 (subvol_inum) { 0 }, BCH_CREATE_TMPFILE); 632 if (IS_ERR(inode)) 633 return bch2_err_class(PTR_ERR(inode)); 634 635 inode_lock(&inode->v); 636 ret = page_symlink(&inode->v, symname, strlen(symname) + 1); 637 inode_unlock(&inode->v); 638 639 if (unlikely(ret)) 640 goto err; 641 642 ret = filemap_write_and_wait_range(inode->v.i_mapping, 0, LLONG_MAX); 643 if (unlikely(ret)) 644 goto err; 645 646 ret = __bch2_link(c, inode, dir, dentry); 647 if (unlikely(ret)) 648 goto err; 649 650 d_instantiate(dentry, &inode->v); 651 return 0; 652 err: 653 iput(&inode->v); 654 return bch2_err_class(ret); 655 } 656 657 static int bch2_mkdir(struct mnt_idmap *idmap, 658 struct inode *vdir, struct dentry *dentry, umode_t mode) 659 { 660 return bch2_mknod(idmap, vdir, dentry, mode|S_IFDIR, 0); 661 } 662 663 static int bch2_rename2(struct mnt_idmap *idmap, 664 struct inode *src_vdir, struct dentry *src_dentry, 665 struct inode *dst_vdir, struct dentry *dst_dentry, 666 unsigned flags) 667 { 668 struct bch_fs *c = src_vdir->i_sb->s_fs_info; 669 struct bch_inode_info *src_dir = to_bch_ei(src_vdir); 670 struct bch_inode_info *dst_dir = to_bch_ei(dst_vdir); 671 struct bch_inode_info *src_inode = to_bch_ei(src_dentry->d_inode); 672 struct bch_inode_info *dst_inode = to_bch_ei(dst_dentry->d_inode); 673 struct bch_inode_unpacked dst_dir_u, src_dir_u; 674 struct bch_inode_unpacked src_inode_u, dst_inode_u; 675 struct btree_trans *trans; 676 enum bch_rename_mode mode = flags & RENAME_EXCHANGE 677 ? BCH_RENAME_EXCHANGE 678 : dst_dentry->d_inode 679 ? BCH_RENAME_OVERWRITE : BCH_RENAME; 680 int ret; 681 682 if (flags & ~(RENAME_NOREPLACE|RENAME_EXCHANGE)) 683 return -EINVAL; 684 685 if (mode == BCH_RENAME_OVERWRITE) { 686 ret = filemap_write_and_wait_range(src_inode->v.i_mapping, 687 0, LLONG_MAX); 688 if (ret) 689 return ret; 690 } 691 692 bch2_lock_inodes(INODE_UPDATE_LOCK, 693 src_dir, 694 dst_dir, 695 src_inode, 696 dst_inode); 697 698 trans = bch2_trans_get(c); 699 700 ret = bch2_subvol_is_ro_trans(trans, src_dir->ei_subvol) ?: 701 bch2_subvol_is_ro_trans(trans, dst_dir->ei_subvol); 702 if (ret) 703 goto err; 704 705 if (inode_attr_changing(dst_dir, src_inode, Inode_opt_project)) { 706 ret = bch2_fs_quota_transfer(c, src_inode, 707 dst_dir->ei_qid, 708 1 << QTYP_PRJ, 709 KEY_TYPE_QUOTA_PREALLOC); 710 if (ret) 711 goto err; 712 } 713 714 if (mode == BCH_RENAME_EXCHANGE && 715 inode_attr_changing(src_dir, dst_inode, Inode_opt_project)) { 716 ret = bch2_fs_quota_transfer(c, dst_inode, 717 src_dir->ei_qid, 718 1 << QTYP_PRJ, 719 KEY_TYPE_QUOTA_PREALLOC); 720 if (ret) 721 goto err; 722 } 723 724 ret = commit_do(trans, NULL, NULL, 0, 725 bch2_rename_trans(trans, 726 inode_inum(src_dir), &src_dir_u, 727 inode_inum(dst_dir), &dst_dir_u, 728 &src_inode_u, 729 &dst_inode_u, 730 &src_dentry->d_name, 731 &dst_dentry->d_name, 732 mode)); 733 if (unlikely(ret)) 734 goto err; 735 736 BUG_ON(src_inode->v.i_ino != src_inode_u.bi_inum); 737 BUG_ON(dst_inode && 738 dst_inode->v.i_ino != dst_inode_u.bi_inum); 739 740 bch2_inode_update_after_write(trans, src_dir, &src_dir_u, 741 ATTR_MTIME|ATTR_CTIME); 742 743 if (src_dir != dst_dir) 744 bch2_inode_update_after_write(trans, dst_dir, &dst_dir_u, 745 ATTR_MTIME|ATTR_CTIME); 746 747 bch2_inode_update_after_write(trans, src_inode, &src_inode_u, 748 ATTR_CTIME); 749 750 if (dst_inode) 751 bch2_inode_update_after_write(trans, dst_inode, &dst_inode_u, 752 ATTR_CTIME); 753 err: 754 bch2_trans_put(trans); 755 756 bch2_fs_quota_transfer(c, src_inode, 757 bch_qid(&src_inode->ei_inode), 758 1 << QTYP_PRJ, 759 KEY_TYPE_QUOTA_NOCHECK); 760 if (dst_inode) 761 bch2_fs_quota_transfer(c, dst_inode, 762 bch_qid(&dst_inode->ei_inode), 763 1 << QTYP_PRJ, 764 KEY_TYPE_QUOTA_NOCHECK); 765 766 bch2_unlock_inodes(INODE_UPDATE_LOCK, 767 src_dir, 768 dst_dir, 769 src_inode, 770 dst_inode); 771 772 return bch2_err_class(ret); 773 } 774 775 static void bch2_setattr_copy(struct mnt_idmap *idmap, 776 struct bch_inode_info *inode, 777 struct bch_inode_unpacked *bi, 778 struct iattr *attr) 779 { 780 struct bch_fs *c = inode->v.i_sb->s_fs_info; 781 unsigned int ia_valid = attr->ia_valid; 782 783 if (ia_valid & ATTR_UID) 784 bi->bi_uid = from_kuid(i_user_ns(&inode->v), attr->ia_uid); 785 if (ia_valid & ATTR_GID) 786 bi->bi_gid = from_kgid(i_user_ns(&inode->v), attr->ia_gid); 787 788 if (ia_valid & ATTR_SIZE) 789 bi->bi_size = attr->ia_size; 790 791 if (ia_valid & ATTR_ATIME) 792 bi->bi_atime = timespec_to_bch2_time(c, attr->ia_atime); 793 if (ia_valid & ATTR_MTIME) 794 bi->bi_mtime = timespec_to_bch2_time(c, attr->ia_mtime); 795 if (ia_valid & ATTR_CTIME) 796 bi->bi_ctime = timespec_to_bch2_time(c, attr->ia_ctime); 797 798 if (ia_valid & ATTR_MODE) { 799 umode_t mode = attr->ia_mode; 800 kgid_t gid = ia_valid & ATTR_GID 801 ? attr->ia_gid 802 : inode->v.i_gid; 803 804 if (!in_group_p(gid) && 805 !capable_wrt_inode_uidgid(idmap, &inode->v, CAP_FSETID)) 806 mode &= ~S_ISGID; 807 bi->bi_mode = mode; 808 } 809 } 810 811 int bch2_setattr_nonsize(struct mnt_idmap *idmap, 812 struct bch_inode_info *inode, 813 struct iattr *attr) 814 { 815 struct bch_fs *c = inode->v.i_sb->s_fs_info; 816 struct bch_qid qid; 817 struct btree_trans *trans; 818 struct btree_iter inode_iter = { NULL }; 819 struct bch_inode_unpacked inode_u; 820 struct posix_acl *acl = NULL; 821 int ret; 822 823 mutex_lock(&inode->ei_update_lock); 824 825 qid = inode->ei_qid; 826 827 if (attr->ia_valid & ATTR_UID) 828 qid.q[QTYP_USR] = from_kuid(i_user_ns(&inode->v), attr->ia_uid); 829 830 if (attr->ia_valid & ATTR_GID) 831 qid.q[QTYP_GRP] = from_kgid(i_user_ns(&inode->v), attr->ia_gid); 832 833 ret = bch2_fs_quota_transfer(c, inode, qid, ~0, 834 KEY_TYPE_QUOTA_PREALLOC); 835 if (ret) 836 goto err; 837 838 trans = bch2_trans_get(c); 839 retry: 840 bch2_trans_begin(trans); 841 kfree(acl); 842 acl = NULL; 843 844 ret = bch2_inode_peek(trans, &inode_iter, &inode_u, inode_inum(inode), 845 BTREE_ITER_intent); 846 if (ret) 847 goto btree_err; 848 849 bch2_setattr_copy(idmap, inode, &inode_u, attr); 850 851 if (attr->ia_valid & ATTR_MODE) { 852 ret = bch2_acl_chmod(trans, inode_inum(inode), &inode_u, 853 inode_u.bi_mode, &acl); 854 if (ret) 855 goto btree_err; 856 } 857 858 ret = bch2_inode_write(trans, &inode_iter, &inode_u) ?: 859 bch2_trans_commit(trans, NULL, NULL, 860 BCH_TRANS_COMMIT_no_enospc); 861 btree_err: 862 bch2_trans_iter_exit(trans, &inode_iter); 863 864 if (bch2_err_matches(ret, BCH_ERR_transaction_restart)) 865 goto retry; 866 if (unlikely(ret)) 867 goto err_trans; 868 869 bch2_inode_update_after_write(trans, inode, &inode_u, attr->ia_valid); 870 871 if (acl) 872 set_cached_acl(&inode->v, ACL_TYPE_ACCESS, acl); 873 err_trans: 874 bch2_trans_put(trans); 875 err: 876 mutex_unlock(&inode->ei_update_lock); 877 878 return bch2_err_class(ret); 879 } 880 881 static int bch2_getattr(struct mnt_idmap *idmap, 882 const struct path *path, struct kstat *stat, 883 u32 request_mask, unsigned query_flags) 884 { 885 struct bch_inode_info *inode = to_bch_ei(d_inode(path->dentry)); 886 struct bch_fs *c = inode->v.i_sb->s_fs_info; 887 888 stat->dev = inode->v.i_sb->s_dev; 889 stat->ino = inode->v.i_ino; 890 stat->mode = inode->v.i_mode; 891 stat->nlink = inode->v.i_nlink; 892 stat->uid = inode->v.i_uid; 893 stat->gid = inode->v.i_gid; 894 stat->rdev = inode->v.i_rdev; 895 stat->size = i_size_read(&inode->v); 896 stat->atime = inode_get_atime(&inode->v); 897 stat->mtime = inode_get_mtime(&inode->v); 898 stat->ctime = inode_get_ctime(&inode->v); 899 stat->blksize = block_bytes(c); 900 stat->blocks = inode->v.i_blocks; 901 902 stat->subvol = inode->ei_subvol; 903 stat->result_mask |= STATX_SUBVOL; 904 905 if ((request_mask & STATX_DIOALIGN) && S_ISREG(inode->v.i_mode)) { 906 stat->result_mask |= STATX_DIOALIGN; 907 /* 908 * this is incorrect; we should be tracking this in superblock, 909 * and checking the alignment of open devices 910 */ 911 stat->dio_mem_align = SECTOR_SIZE; 912 stat->dio_offset_align = block_bytes(c); 913 } 914 915 if (request_mask & STATX_BTIME) { 916 stat->result_mask |= STATX_BTIME; 917 stat->btime = bch2_time_to_timespec(c, inode->ei_inode.bi_otime); 918 } 919 920 if (inode->ei_inode.bi_flags & BCH_INODE_immutable) 921 stat->attributes |= STATX_ATTR_IMMUTABLE; 922 stat->attributes_mask |= STATX_ATTR_IMMUTABLE; 923 924 if (inode->ei_inode.bi_flags & BCH_INODE_append) 925 stat->attributes |= STATX_ATTR_APPEND; 926 stat->attributes_mask |= STATX_ATTR_APPEND; 927 928 if (inode->ei_inode.bi_flags & BCH_INODE_nodump) 929 stat->attributes |= STATX_ATTR_NODUMP; 930 stat->attributes_mask |= STATX_ATTR_NODUMP; 931 932 return 0; 933 } 934 935 static int bch2_setattr(struct mnt_idmap *idmap, 936 struct dentry *dentry, struct iattr *iattr) 937 { 938 struct bch_inode_info *inode = to_bch_ei(dentry->d_inode); 939 struct bch_fs *c = inode->v.i_sb->s_fs_info; 940 int ret; 941 942 lockdep_assert_held(&inode->v.i_rwsem); 943 944 ret = bch2_subvol_is_ro(c, inode->ei_subvol) ?: 945 setattr_prepare(idmap, dentry, iattr); 946 if (ret) 947 return ret; 948 949 return iattr->ia_valid & ATTR_SIZE 950 ? bchfs_truncate(idmap, inode, iattr) 951 : bch2_setattr_nonsize(idmap, inode, iattr); 952 } 953 954 static int bch2_tmpfile(struct mnt_idmap *idmap, 955 struct inode *vdir, struct file *file, umode_t mode) 956 { 957 struct bch_inode_info *inode = 958 __bch2_create(idmap, to_bch_ei(vdir), 959 file->f_path.dentry, mode, 0, 960 (subvol_inum) { 0 }, BCH_CREATE_TMPFILE); 961 962 if (IS_ERR(inode)) 963 return bch2_err_class(PTR_ERR(inode)); 964 965 d_mark_tmpfile(file, &inode->v); 966 d_instantiate(file->f_path.dentry, &inode->v); 967 return finish_open_simple(file, 0); 968 } 969 970 static int bch2_fill_extent(struct bch_fs *c, 971 struct fiemap_extent_info *info, 972 struct bkey_s_c k, unsigned flags) 973 { 974 if (bkey_extent_is_direct_data(k.k)) { 975 struct bkey_ptrs_c ptrs = bch2_bkey_ptrs_c(k); 976 const union bch_extent_entry *entry; 977 struct extent_ptr_decoded p; 978 int ret; 979 980 if (k.k->type == KEY_TYPE_reflink_v) 981 flags |= FIEMAP_EXTENT_SHARED; 982 983 bkey_for_each_ptr_decode(k.k, ptrs, p, entry) { 984 int flags2 = 0; 985 u64 offset = p.ptr.offset; 986 987 if (p.ptr.unwritten) 988 flags2 |= FIEMAP_EXTENT_UNWRITTEN; 989 990 if (p.crc.compression_type) 991 flags2 |= FIEMAP_EXTENT_ENCODED; 992 else 993 offset += p.crc.offset; 994 995 if ((offset & (block_sectors(c) - 1)) || 996 (k.k->size & (block_sectors(c) - 1))) 997 flags2 |= FIEMAP_EXTENT_NOT_ALIGNED; 998 999 ret = fiemap_fill_next_extent(info, 1000 bkey_start_offset(k.k) << 9, 1001 offset << 9, 1002 k.k->size << 9, flags|flags2); 1003 if (ret) 1004 return ret; 1005 } 1006 1007 return 0; 1008 } else if (bkey_extent_is_inline_data(k.k)) { 1009 return fiemap_fill_next_extent(info, 1010 bkey_start_offset(k.k) << 9, 1011 0, k.k->size << 9, 1012 flags| 1013 FIEMAP_EXTENT_DATA_INLINE); 1014 } else if (k.k->type == KEY_TYPE_reservation) { 1015 return fiemap_fill_next_extent(info, 1016 bkey_start_offset(k.k) << 9, 1017 0, k.k->size << 9, 1018 flags| 1019 FIEMAP_EXTENT_DELALLOC| 1020 FIEMAP_EXTENT_UNWRITTEN); 1021 } else { 1022 BUG(); 1023 } 1024 } 1025 1026 static int bch2_fiemap(struct inode *vinode, struct fiemap_extent_info *info, 1027 u64 start, u64 len) 1028 { 1029 struct bch_fs *c = vinode->i_sb->s_fs_info; 1030 struct bch_inode_info *ei = to_bch_ei(vinode); 1031 struct btree_trans *trans; 1032 struct btree_iter iter; 1033 struct bkey_s_c k; 1034 struct bkey_buf cur, prev; 1035 unsigned offset_into_extent, sectors; 1036 bool have_extent = false; 1037 u32 snapshot; 1038 int ret = 0; 1039 1040 ret = fiemap_prep(&ei->v, info, start, &len, FIEMAP_FLAG_SYNC); 1041 if (ret) 1042 return ret; 1043 1044 struct bpos end = POS(ei->v.i_ino, (start + len) >> 9); 1045 if (start + len < start) 1046 return -EINVAL; 1047 1048 start >>= 9; 1049 1050 bch2_bkey_buf_init(&cur); 1051 bch2_bkey_buf_init(&prev); 1052 trans = bch2_trans_get(c); 1053 retry: 1054 bch2_trans_begin(trans); 1055 1056 ret = bch2_subvolume_get_snapshot(trans, ei->ei_subvol, &snapshot); 1057 if (ret) 1058 goto err; 1059 1060 bch2_trans_iter_init(trans, &iter, BTREE_ID_extents, 1061 SPOS(ei->v.i_ino, start, snapshot), 0); 1062 1063 while (!(ret = btree_trans_too_many_iters(trans)) && 1064 (k = bch2_btree_iter_peek_upto(&iter, end)).k && 1065 !(ret = bkey_err(k))) { 1066 enum btree_id data_btree = BTREE_ID_extents; 1067 1068 if (!bkey_extent_is_data(k.k) && 1069 k.k->type != KEY_TYPE_reservation) { 1070 bch2_btree_iter_advance(&iter); 1071 continue; 1072 } 1073 1074 offset_into_extent = iter.pos.offset - 1075 bkey_start_offset(k.k); 1076 sectors = k.k->size - offset_into_extent; 1077 1078 bch2_bkey_buf_reassemble(&cur, c, k); 1079 1080 ret = bch2_read_indirect_extent(trans, &data_btree, 1081 &offset_into_extent, &cur); 1082 if (ret) 1083 break; 1084 1085 k = bkey_i_to_s_c(cur.k); 1086 bch2_bkey_buf_realloc(&prev, c, k.k->u64s); 1087 1088 sectors = min(sectors, k.k->size - offset_into_extent); 1089 1090 bch2_cut_front(POS(k.k->p.inode, 1091 bkey_start_offset(k.k) + 1092 offset_into_extent), 1093 cur.k); 1094 bch2_key_resize(&cur.k->k, sectors); 1095 cur.k->k.p = iter.pos; 1096 cur.k->k.p.offset += cur.k->k.size; 1097 1098 if (have_extent) { 1099 bch2_trans_unlock(trans); 1100 ret = bch2_fill_extent(c, info, 1101 bkey_i_to_s_c(prev.k), 0); 1102 if (ret) 1103 break; 1104 } 1105 1106 bkey_copy(prev.k, cur.k); 1107 have_extent = true; 1108 1109 bch2_btree_iter_set_pos(&iter, 1110 POS(iter.pos.inode, iter.pos.offset + sectors)); 1111 1112 ret = bch2_trans_relock(trans); 1113 if (ret) 1114 break; 1115 } 1116 start = iter.pos.offset; 1117 bch2_trans_iter_exit(trans, &iter); 1118 err: 1119 if (bch2_err_matches(ret, BCH_ERR_transaction_restart)) 1120 goto retry; 1121 1122 if (!ret && have_extent) { 1123 bch2_trans_unlock(trans); 1124 ret = bch2_fill_extent(c, info, bkey_i_to_s_c(prev.k), 1125 FIEMAP_EXTENT_LAST); 1126 } 1127 1128 bch2_trans_put(trans); 1129 bch2_bkey_buf_exit(&cur, c); 1130 bch2_bkey_buf_exit(&prev, c); 1131 return ret < 0 ? ret : 0; 1132 } 1133 1134 static const struct vm_operations_struct bch_vm_ops = { 1135 .fault = bch2_page_fault, 1136 .map_pages = filemap_map_pages, 1137 .page_mkwrite = bch2_page_mkwrite, 1138 }; 1139 1140 static int bch2_mmap(struct file *file, struct vm_area_struct *vma) 1141 { 1142 file_accessed(file); 1143 1144 vma->vm_ops = &bch_vm_ops; 1145 return 0; 1146 } 1147 1148 /* Directories: */ 1149 1150 static loff_t bch2_dir_llseek(struct file *file, loff_t offset, int whence) 1151 { 1152 return generic_file_llseek_size(file, offset, whence, 1153 S64_MAX, S64_MAX); 1154 } 1155 1156 static int bch2_vfs_readdir(struct file *file, struct dir_context *ctx) 1157 { 1158 struct bch_inode_info *inode = file_bch_inode(file); 1159 struct bch_fs *c = inode->v.i_sb->s_fs_info; 1160 1161 if (!dir_emit_dots(file, ctx)) 1162 return 0; 1163 1164 int ret = bch2_readdir(c, inode_inum(inode), ctx); 1165 1166 bch_err_fn(c, ret); 1167 return bch2_err_class(ret); 1168 } 1169 1170 static int bch2_open(struct inode *vinode, struct file *file) 1171 { 1172 if (file->f_flags & (O_WRONLY|O_RDWR)) { 1173 struct bch_inode_info *inode = to_bch_ei(vinode); 1174 struct bch_fs *c = inode->v.i_sb->s_fs_info; 1175 1176 int ret = bch2_subvol_is_ro(c, inode->ei_subvol); 1177 if (ret) 1178 return ret; 1179 } 1180 1181 file->f_mode |= FMODE_CAN_ODIRECT; 1182 1183 return generic_file_open(vinode, file); 1184 } 1185 1186 static const struct file_operations bch_file_operations = { 1187 .open = bch2_open, 1188 .llseek = bch2_llseek, 1189 .read_iter = bch2_read_iter, 1190 .write_iter = bch2_write_iter, 1191 .mmap = bch2_mmap, 1192 .get_unmapped_area = thp_get_unmapped_area, 1193 .fsync = bch2_fsync, 1194 .splice_read = filemap_splice_read, 1195 .splice_write = iter_file_splice_write, 1196 .fallocate = bch2_fallocate_dispatch, 1197 .unlocked_ioctl = bch2_fs_file_ioctl, 1198 #ifdef CONFIG_COMPAT 1199 .compat_ioctl = bch2_compat_fs_ioctl, 1200 #endif 1201 .remap_file_range = bch2_remap_file_range, 1202 }; 1203 1204 static const struct inode_operations bch_file_inode_operations = { 1205 .getattr = bch2_getattr, 1206 .setattr = bch2_setattr, 1207 .fiemap = bch2_fiemap, 1208 .listxattr = bch2_xattr_list, 1209 #ifdef CONFIG_BCACHEFS_POSIX_ACL 1210 .get_inode_acl = bch2_get_acl, 1211 .set_acl = bch2_set_acl, 1212 #endif 1213 }; 1214 1215 static const struct inode_operations bch_dir_inode_operations = { 1216 .lookup = bch2_lookup, 1217 .create = bch2_create, 1218 .link = bch2_link, 1219 .unlink = bch2_unlink, 1220 .symlink = bch2_symlink, 1221 .mkdir = bch2_mkdir, 1222 .rmdir = bch2_unlink, 1223 .mknod = bch2_mknod, 1224 .rename = bch2_rename2, 1225 .getattr = bch2_getattr, 1226 .setattr = bch2_setattr, 1227 .tmpfile = bch2_tmpfile, 1228 .listxattr = bch2_xattr_list, 1229 #ifdef CONFIG_BCACHEFS_POSIX_ACL 1230 .get_inode_acl = bch2_get_acl, 1231 .set_acl = bch2_set_acl, 1232 #endif 1233 }; 1234 1235 static const struct file_operations bch_dir_file_operations = { 1236 .llseek = bch2_dir_llseek, 1237 .read = generic_read_dir, 1238 .iterate_shared = bch2_vfs_readdir, 1239 .fsync = bch2_fsync, 1240 .unlocked_ioctl = bch2_fs_file_ioctl, 1241 #ifdef CONFIG_COMPAT 1242 .compat_ioctl = bch2_compat_fs_ioctl, 1243 #endif 1244 }; 1245 1246 static const struct inode_operations bch_symlink_inode_operations = { 1247 .get_link = page_get_link, 1248 .getattr = bch2_getattr, 1249 .setattr = bch2_setattr, 1250 .listxattr = bch2_xattr_list, 1251 #ifdef CONFIG_BCACHEFS_POSIX_ACL 1252 .get_inode_acl = bch2_get_acl, 1253 .set_acl = bch2_set_acl, 1254 #endif 1255 }; 1256 1257 static const struct inode_operations bch_special_inode_operations = { 1258 .getattr = bch2_getattr, 1259 .setattr = bch2_setattr, 1260 .listxattr = bch2_xattr_list, 1261 #ifdef CONFIG_BCACHEFS_POSIX_ACL 1262 .get_inode_acl = bch2_get_acl, 1263 .set_acl = bch2_set_acl, 1264 #endif 1265 }; 1266 1267 static const struct address_space_operations bch_address_space_operations = { 1268 .read_folio = bch2_read_folio, 1269 .writepages = bch2_writepages, 1270 .readahead = bch2_readahead, 1271 .dirty_folio = filemap_dirty_folio, 1272 .write_begin = bch2_write_begin, 1273 .write_end = bch2_write_end, 1274 .invalidate_folio = bch2_invalidate_folio, 1275 .release_folio = bch2_release_folio, 1276 #ifdef CONFIG_MIGRATION 1277 .migrate_folio = filemap_migrate_folio, 1278 #endif 1279 .error_remove_folio = generic_error_remove_folio, 1280 }; 1281 1282 struct bcachefs_fid { 1283 u64 inum; 1284 u32 subvol; 1285 u32 gen; 1286 } __packed; 1287 1288 struct bcachefs_fid_with_parent { 1289 struct bcachefs_fid fid; 1290 struct bcachefs_fid dir; 1291 } __packed; 1292 1293 static int bcachefs_fid_valid(int fh_len, int fh_type) 1294 { 1295 switch (fh_type) { 1296 case FILEID_BCACHEFS_WITHOUT_PARENT: 1297 return fh_len == sizeof(struct bcachefs_fid) / sizeof(u32); 1298 case FILEID_BCACHEFS_WITH_PARENT: 1299 return fh_len == sizeof(struct bcachefs_fid_with_parent) / sizeof(u32); 1300 default: 1301 return false; 1302 } 1303 } 1304 1305 static struct bcachefs_fid bch2_inode_to_fid(struct bch_inode_info *inode) 1306 { 1307 return (struct bcachefs_fid) { 1308 .inum = inode->ei_inode.bi_inum, 1309 .subvol = inode->ei_subvol, 1310 .gen = inode->ei_inode.bi_generation, 1311 }; 1312 } 1313 1314 static int bch2_encode_fh(struct inode *vinode, u32 *fh, int *len, 1315 struct inode *vdir) 1316 { 1317 struct bch_inode_info *inode = to_bch_ei(vinode); 1318 struct bch_inode_info *dir = to_bch_ei(vdir); 1319 int min_len; 1320 1321 if (!S_ISDIR(inode->v.i_mode) && dir) { 1322 struct bcachefs_fid_with_parent *fid = (void *) fh; 1323 1324 min_len = sizeof(*fid) / sizeof(u32); 1325 if (*len < min_len) { 1326 *len = min_len; 1327 return FILEID_INVALID; 1328 } 1329 1330 fid->fid = bch2_inode_to_fid(inode); 1331 fid->dir = bch2_inode_to_fid(dir); 1332 1333 *len = min_len; 1334 return FILEID_BCACHEFS_WITH_PARENT; 1335 } else { 1336 struct bcachefs_fid *fid = (void *) fh; 1337 1338 min_len = sizeof(*fid) / sizeof(u32); 1339 if (*len < min_len) { 1340 *len = min_len; 1341 return FILEID_INVALID; 1342 } 1343 *fid = bch2_inode_to_fid(inode); 1344 1345 *len = min_len; 1346 return FILEID_BCACHEFS_WITHOUT_PARENT; 1347 } 1348 } 1349 1350 static struct inode *bch2_nfs_get_inode(struct super_block *sb, 1351 struct bcachefs_fid fid) 1352 { 1353 struct bch_fs *c = sb->s_fs_info; 1354 struct inode *vinode = bch2_vfs_inode_get(c, (subvol_inum) { 1355 .subvol = fid.subvol, 1356 .inum = fid.inum, 1357 }); 1358 if (!IS_ERR(vinode) && vinode->i_generation != fid.gen) { 1359 iput(vinode); 1360 vinode = ERR_PTR(-ESTALE); 1361 } 1362 return vinode; 1363 } 1364 1365 static struct dentry *bch2_fh_to_dentry(struct super_block *sb, struct fid *_fid, 1366 int fh_len, int fh_type) 1367 { 1368 struct bcachefs_fid *fid = (void *) _fid; 1369 1370 if (!bcachefs_fid_valid(fh_len, fh_type)) 1371 return NULL; 1372 1373 return d_obtain_alias(bch2_nfs_get_inode(sb, *fid)); 1374 } 1375 1376 static struct dentry *bch2_fh_to_parent(struct super_block *sb, struct fid *_fid, 1377 int fh_len, int fh_type) 1378 { 1379 struct bcachefs_fid_with_parent *fid = (void *) _fid; 1380 1381 if (!bcachefs_fid_valid(fh_len, fh_type) || 1382 fh_type != FILEID_BCACHEFS_WITH_PARENT) 1383 return NULL; 1384 1385 return d_obtain_alias(bch2_nfs_get_inode(sb, fid->dir)); 1386 } 1387 1388 static struct dentry *bch2_get_parent(struct dentry *child) 1389 { 1390 struct bch_inode_info *inode = to_bch_ei(child->d_inode); 1391 struct bch_fs *c = inode->v.i_sb->s_fs_info; 1392 subvol_inum parent_inum = { 1393 .subvol = inode->ei_inode.bi_parent_subvol ?: 1394 inode->ei_subvol, 1395 .inum = inode->ei_inode.bi_dir, 1396 }; 1397 1398 return d_obtain_alias(bch2_vfs_inode_get(c, parent_inum)); 1399 } 1400 1401 static int bch2_get_name(struct dentry *parent, char *name, struct dentry *child) 1402 { 1403 struct bch_inode_info *inode = to_bch_ei(child->d_inode); 1404 struct bch_inode_info *dir = to_bch_ei(parent->d_inode); 1405 struct bch_fs *c = inode->v.i_sb->s_fs_info; 1406 struct btree_trans *trans; 1407 struct btree_iter iter1; 1408 struct btree_iter iter2; 1409 struct bkey_s_c k; 1410 struct bkey_s_c_dirent d; 1411 struct bch_inode_unpacked inode_u; 1412 subvol_inum target; 1413 u32 snapshot; 1414 struct qstr dirent_name; 1415 unsigned name_len = 0; 1416 int ret; 1417 1418 if (!S_ISDIR(dir->v.i_mode)) 1419 return -EINVAL; 1420 1421 trans = bch2_trans_get(c); 1422 1423 bch2_trans_iter_init(trans, &iter1, BTREE_ID_dirents, 1424 POS(dir->ei_inode.bi_inum, 0), 0); 1425 bch2_trans_iter_init(trans, &iter2, BTREE_ID_dirents, 1426 POS(dir->ei_inode.bi_inum, 0), 0); 1427 retry: 1428 bch2_trans_begin(trans); 1429 1430 ret = bch2_subvolume_get_snapshot(trans, dir->ei_subvol, &snapshot); 1431 if (ret) 1432 goto err; 1433 1434 bch2_btree_iter_set_snapshot(&iter1, snapshot); 1435 bch2_btree_iter_set_snapshot(&iter2, snapshot); 1436 1437 ret = bch2_inode_find_by_inum_trans(trans, inode_inum(inode), &inode_u); 1438 if (ret) 1439 goto err; 1440 1441 if (inode_u.bi_dir == dir->ei_inode.bi_inum) { 1442 bch2_btree_iter_set_pos(&iter1, POS(inode_u.bi_dir, inode_u.bi_dir_offset)); 1443 1444 k = bch2_btree_iter_peek_slot(&iter1); 1445 ret = bkey_err(k); 1446 if (ret) 1447 goto err; 1448 1449 if (k.k->type != KEY_TYPE_dirent) { 1450 ret = -BCH_ERR_ENOENT_dirent_doesnt_match_inode; 1451 goto err; 1452 } 1453 1454 d = bkey_s_c_to_dirent(k); 1455 ret = bch2_dirent_read_target(trans, inode_inum(dir), d, &target); 1456 if (ret > 0) 1457 ret = -BCH_ERR_ENOENT_dirent_doesnt_match_inode; 1458 if (ret) 1459 goto err; 1460 1461 if (target.subvol == inode->ei_subvol && 1462 target.inum == inode->ei_inode.bi_inum) 1463 goto found; 1464 } else { 1465 /* 1466 * File with multiple hardlinks and our backref is to the wrong 1467 * directory - linear search: 1468 */ 1469 for_each_btree_key_continue_norestart(iter2, 0, k, ret) { 1470 if (k.k->p.inode > dir->ei_inode.bi_inum) 1471 break; 1472 1473 if (k.k->type != KEY_TYPE_dirent) 1474 continue; 1475 1476 d = bkey_s_c_to_dirent(k); 1477 ret = bch2_dirent_read_target(trans, inode_inum(dir), d, &target); 1478 if (ret < 0) 1479 break; 1480 if (ret) 1481 continue; 1482 1483 if (target.subvol == inode->ei_subvol && 1484 target.inum == inode->ei_inode.bi_inum) 1485 goto found; 1486 } 1487 } 1488 1489 ret = -ENOENT; 1490 goto err; 1491 found: 1492 dirent_name = bch2_dirent_get_name(d); 1493 1494 name_len = min_t(unsigned, dirent_name.len, NAME_MAX); 1495 memcpy(name, dirent_name.name, name_len); 1496 name[name_len] = '\0'; 1497 err: 1498 if (bch2_err_matches(ret, BCH_ERR_transaction_restart)) 1499 goto retry; 1500 1501 bch2_trans_iter_exit(trans, &iter1); 1502 bch2_trans_iter_exit(trans, &iter2); 1503 bch2_trans_put(trans); 1504 1505 return ret; 1506 } 1507 1508 static const struct export_operations bch_export_ops = { 1509 .encode_fh = bch2_encode_fh, 1510 .fh_to_dentry = bch2_fh_to_dentry, 1511 .fh_to_parent = bch2_fh_to_parent, 1512 .get_parent = bch2_get_parent, 1513 .get_name = bch2_get_name, 1514 }; 1515 1516 static void bch2_vfs_inode_init(struct btree_trans *trans, subvol_inum inum, 1517 struct bch_inode_info *inode, 1518 struct bch_inode_unpacked *bi, 1519 struct bch_subvolume *subvol) 1520 { 1521 bch2_iget5_set(&inode->v, &inum); 1522 bch2_inode_update_after_write(trans, inode, bi, ~0); 1523 1524 inode->v.i_blocks = bi->bi_sectors; 1525 inode->v.i_ino = bi->bi_inum; 1526 inode->v.i_rdev = bi->bi_dev; 1527 inode->v.i_generation = bi->bi_generation; 1528 inode->v.i_size = bi->bi_size; 1529 1530 inode->ei_flags = 0; 1531 inode->ei_quota_reserved = 0; 1532 inode->ei_qid = bch_qid(bi); 1533 inode->ei_subvol = inum.subvol; 1534 1535 if (BCH_SUBVOLUME_SNAP(subvol)) 1536 set_bit(EI_INODE_SNAPSHOT, &inode->ei_flags); 1537 1538 inode->v.i_mapping->a_ops = &bch_address_space_operations; 1539 1540 switch (inode->v.i_mode & S_IFMT) { 1541 case S_IFREG: 1542 inode->v.i_op = &bch_file_inode_operations; 1543 inode->v.i_fop = &bch_file_operations; 1544 break; 1545 case S_IFDIR: 1546 inode->v.i_op = &bch_dir_inode_operations; 1547 inode->v.i_fop = &bch_dir_file_operations; 1548 break; 1549 case S_IFLNK: 1550 inode_nohighmem(&inode->v); 1551 inode->v.i_op = &bch_symlink_inode_operations; 1552 break; 1553 default: 1554 init_special_inode(&inode->v, inode->v.i_mode, inode->v.i_rdev); 1555 inode->v.i_op = &bch_special_inode_operations; 1556 break; 1557 } 1558 1559 mapping_set_large_folios(inode->v.i_mapping); 1560 } 1561 1562 static void bch2_free_inode(struct inode *vinode) 1563 { 1564 kmem_cache_free(bch2_inode_cache, to_bch_ei(vinode)); 1565 } 1566 1567 static int inode_update_times_fn(struct btree_trans *trans, 1568 struct bch_inode_info *inode, 1569 struct bch_inode_unpacked *bi, 1570 void *p) 1571 { 1572 struct bch_fs *c = inode->v.i_sb->s_fs_info; 1573 1574 bi->bi_atime = timespec_to_bch2_time(c, inode_get_atime(&inode->v)); 1575 bi->bi_mtime = timespec_to_bch2_time(c, inode_get_mtime(&inode->v)); 1576 bi->bi_ctime = timespec_to_bch2_time(c, inode_get_ctime(&inode->v)); 1577 1578 return 0; 1579 } 1580 1581 static int bch2_vfs_write_inode(struct inode *vinode, 1582 struct writeback_control *wbc) 1583 { 1584 struct bch_fs *c = vinode->i_sb->s_fs_info; 1585 struct bch_inode_info *inode = to_bch_ei(vinode); 1586 int ret; 1587 1588 mutex_lock(&inode->ei_update_lock); 1589 ret = bch2_write_inode(c, inode, inode_update_times_fn, NULL, 1590 ATTR_ATIME|ATTR_MTIME|ATTR_CTIME); 1591 mutex_unlock(&inode->ei_update_lock); 1592 1593 return bch2_err_class(ret); 1594 } 1595 1596 static void bch2_evict_inode(struct inode *vinode) 1597 { 1598 struct bch_fs *c = vinode->i_sb->s_fs_info; 1599 struct bch_inode_info *inode = to_bch_ei(vinode); 1600 1601 truncate_inode_pages_final(&inode->v.i_data); 1602 1603 clear_inode(&inode->v); 1604 1605 BUG_ON(!is_bad_inode(&inode->v) && inode->ei_quota_reserved); 1606 1607 if (!inode->v.i_nlink && !is_bad_inode(&inode->v)) { 1608 bch2_quota_acct(c, inode->ei_qid, Q_SPC, -((s64) inode->v.i_blocks), 1609 KEY_TYPE_QUOTA_WARN); 1610 bch2_quota_acct(c, inode->ei_qid, Q_INO, -1, 1611 KEY_TYPE_QUOTA_WARN); 1612 bch2_inode_rm(c, inode_inum(inode)); 1613 } 1614 1615 mutex_lock(&c->vfs_inodes_lock); 1616 list_del_init(&inode->ei_vfs_inode_list); 1617 mutex_unlock(&c->vfs_inodes_lock); 1618 } 1619 1620 void bch2_evict_subvolume_inodes(struct bch_fs *c, snapshot_id_list *s) 1621 { 1622 struct bch_inode_info *inode; 1623 DARRAY(struct bch_inode_info *) grabbed; 1624 bool clean_pass = false, this_pass_clean; 1625 1626 /* 1627 * Initially, we scan for inodes without I_DONTCACHE, then mark them to 1628 * be pruned with d_mark_dontcache(). 1629 * 1630 * Once we've had a clean pass where we didn't find any inodes without 1631 * I_DONTCACHE, we wait for them to be freed: 1632 */ 1633 1634 darray_init(&grabbed); 1635 darray_make_room(&grabbed, 1024); 1636 again: 1637 cond_resched(); 1638 this_pass_clean = true; 1639 1640 mutex_lock(&c->vfs_inodes_lock); 1641 list_for_each_entry(inode, &c->vfs_inodes_list, ei_vfs_inode_list) { 1642 if (!snapshot_list_has_id(s, inode->ei_subvol)) 1643 continue; 1644 1645 if (!(inode->v.i_state & I_DONTCACHE) && 1646 !(inode->v.i_state & I_FREEING) && 1647 igrab(&inode->v)) { 1648 this_pass_clean = false; 1649 1650 if (darray_push_gfp(&grabbed, inode, GFP_ATOMIC|__GFP_NOWARN)) { 1651 iput(&inode->v); 1652 break; 1653 } 1654 } else if (clean_pass && this_pass_clean) { 1655 wait_queue_head_t *wq = bit_waitqueue(&inode->v.i_state, __I_NEW); 1656 DEFINE_WAIT_BIT(wait, &inode->v.i_state, __I_NEW); 1657 1658 prepare_to_wait(wq, &wait.wq_entry, TASK_UNINTERRUPTIBLE); 1659 mutex_unlock(&c->vfs_inodes_lock); 1660 1661 schedule(); 1662 finish_wait(wq, &wait.wq_entry); 1663 goto again; 1664 } 1665 } 1666 mutex_unlock(&c->vfs_inodes_lock); 1667 1668 darray_for_each(grabbed, i) { 1669 inode = *i; 1670 d_mark_dontcache(&inode->v); 1671 d_prune_aliases(&inode->v); 1672 iput(&inode->v); 1673 } 1674 grabbed.nr = 0; 1675 1676 if (!clean_pass || !this_pass_clean) { 1677 clean_pass = this_pass_clean; 1678 goto again; 1679 } 1680 1681 darray_exit(&grabbed); 1682 } 1683 1684 static int bch2_statfs(struct dentry *dentry, struct kstatfs *buf) 1685 { 1686 struct super_block *sb = dentry->d_sb; 1687 struct bch_fs *c = sb->s_fs_info; 1688 struct bch_fs_usage_short usage = bch2_fs_usage_read_short(c); 1689 unsigned shift = sb->s_blocksize_bits - 9; 1690 /* 1691 * this assumes inodes take up 64 bytes, which is a decent average 1692 * number: 1693 */ 1694 u64 avail_inodes = ((usage.capacity - usage.used) << 3); 1695 1696 buf->f_type = BCACHEFS_STATFS_MAGIC; 1697 buf->f_bsize = sb->s_blocksize; 1698 buf->f_blocks = usage.capacity >> shift; 1699 buf->f_bfree = usage.free >> shift; 1700 buf->f_bavail = avail_factor(usage.free) >> shift; 1701 1702 buf->f_files = usage.nr_inodes + avail_inodes; 1703 buf->f_ffree = avail_inodes; 1704 1705 buf->f_fsid = uuid_to_fsid(c->sb.user_uuid.b); 1706 buf->f_namelen = BCH_NAME_MAX; 1707 1708 return 0; 1709 } 1710 1711 static int bch2_sync_fs(struct super_block *sb, int wait) 1712 { 1713 struct bch_fs *c = sb->s_fs_info; 1714 int ret; 1715 1716 trace_bch2_sync_fs(sb, wait); 1717 1718 if (c->opts.journal_flush_disabled) 1719 return 0; 1720 1721 if (!wait) { 1722 bch2_journal_flush_async(&c->journal, NULL); 1723 return 0; 1724 } 1725 1726 ret = bch2_journal_flush(&c->journal); 1727 return bch2_err_class(ret); 1728 } 1729 1730 static struct bch_fs *bch2_path_to_fs(const char *path) 1731 { 1732 struct bch_fs *c; 1733 dev_t dev; 1734 int ret; 1735 1736 ret = lookup_bdev(path, &dev); 1737 if (ret) 1738 return ERR_PTR(ret); 1739 1740 c = bch2_dev_to_fs(dev); 1741 if (c) 1742 closure_put(&c->cl); 1743 return c ?: ERR_PTR(-ENOENT); 1744 } 1745 1746 static int bch2_remount(struct super_block *sb, int *flags, 1747 struct bch_opts opts) 1748 { 1749 struct bch_fs *c = sb->s_fs_info; 1750 int ret = 0; 1751 1752 opt_set(opts, read_only, (*flags & SB_RDONLY) != 0); 1753 1754 if (opts.read_only != c->opts.read_only) { 1755 down_write(&c->state_lock); 1756 1757 if (opts.read_only) { 1758 bch2_fs_read_only(c); 1759 1760 sb->s_flags |= SB_RDONLY; 1761 } else { 1762 ret = bch2_fs_read_write(c); 1763 if (ret) { 1764 bch_err(c, "error going rw: %i", ret); 1765 up_write(&c->state_lock); 1766 ret = -EINVAL; 1767 goto err; 1768 } 1769 1770 sb->s_flags &= ~SB_RDONLY; 1771 } 1772 1773 c->opts.read_only = opts.read_only; 1774 1775 up_write(&c->state_lock); 1776 } 1777 1778 if (opt_defined(opts, errors)) 1779 c->opts.errors = opts.errors; 1780 err: 1781 return bch2_err_class(ret); 1782 } 1783 1784 static int bch2_show_devname(struct seq_file *seq, struct dentry *root) 1785 { 1786 struct bch_fs *c = root->d_sb->s_fs_info; 1787 bool first = true; 1788 1789 for_each_online_member(c, ca) { 1790 if (!first) 1791 seq_putc(seq, ':'); 1792 first = false; 1793 seq_puts(seq, ca->disk_sb.sb_name); 1794 } 1795 1796 return 0; 1797 } 1798 1799 static int bch2_show_options(struct seq_file *seq, struct dentry *root) 1800 { 1801 struct bch_fs *c = root->d_sb->s_fs_info; 1802 enum bch_opt_id i; 1803 struct printbuf buf = PRINTBUF; 1804 int ret = 0; 1805 1806 for (i = 0; i < bch2_opts_nr; i++) { 1807 const struct bch_option *opt = &bch2_opt_table[i]; 1808 u64 v = bch2_opt_get_by_id(&c->opts, i); 1809 1810 if ((opt->flags & OPT_HIDDEN) || 1811 !(opt->flags & OPT_MOUNT)) 1812 continue; 1813 1814 if (v == bch2_opt_get_by_id(&bch2_opts_default, i)) 1815 continue; 1816 1817 printbuf_reset(&buf); 1818 bch2_opt_to_text(&buf, c, c->disk_sb.sb, opt, v, 1819 OPT_SHOW_MOUNT_STYLE); 1820 seq_putc(seq, ','); 1821 seq_puts(seq, buf.buf); 1822 } 1823 1824 if (buf.allocation_failure) 1825 ret = -ENOMEM; 1826 printbuf_exit(&buf); 1827 return ret; 1828 } 1829 1830 static void bch2_put_super(struct super_block *sb) 1831 { 1832 struct bch_fs *c = sb->s_fs_info; 1833 1834 __bch2_fs_stop(c); 1835 } 1836 1837 /* 1838 * bcachefs doesn't currently integrate intwrite freeze protection but the 1839 * internal write references serve the same purpose. Therefore reuse the 1840 * read-only transition code to perform the quiesce. The caveat is that we don't 1841 * currently have the ability to block tasks that want a write reference while 1842 * the superblock is frozen. This is fine for now, but we should either add 1843 * blocking support or find a way to integrate sb_start_intwrite() and friends. 1844 */ 1845 static int bch2_freeze(struct super_block *sb) 1846 { 1847 struct bch_fs *c = sb->s_fs_info; 1848 1849 down_write(&c->state_lock); 1850 bch2_fs_read_only(c); 1851 up_write(&c->state_lock); 1852 return 0; 1853 } 1854 1855 static int bch2_unfreeze(struct super_block *sb) 1856 { 1857 struct bch_fs *c = sb->s_fs_info; 1858 int ret; 1859 1860 if (test_bit(BCH_FS_emergency_ro, &c->flags)) 1861 return 0; 1862 1863 down_write(&c->state_lock); 1864 ret = bch2_fs_read_write(c); 1865 up_write(&c->state_lock); 1866 return ret; 1867 } 1868 1869 static const struct super_operations bch_super_operations = { 1870 .alloc_inode = bch2_alloc_inode, 1871 .free_inode = bch2_free_inode, 1872 .write_inode = bch2_vfs_write_inode, 1873 .evict_inode = bch2_evict_inode, 1874 .sync_fs = bch2_sync_fs, 1875 .statfs = bch2_statfs, 1876 .show_devname = bch2_show_devname, 1877 .show_options = bch2_show_options, 1878 .put_super = bch2_put_super, 1879 .freeze_fs = bch2_freeze, 1880 .unfreeze_fs = bch2_unfreeze, 1881 }; 1882 1883 static int bch2_set_super(struct super_block *s, void *data) 1884 { 1885 s->s_fs_info = data; 1886 return 0; 1887 } 1888 1889 static int bch2_noset_super(struct super_block *s, void *data) 1890 { 1891 return -EBUSY; 1892 } 1893 1894 typedef DARRAY(struct bch_fs *) darray_fs; 1895 1896 static int bch2_test_super(struct super_block *s, void *data) 1897 { 1898 struct bch_fs *c = s->s_fs_info; 1899 darray_fs *d = data; 1900 1901 if (!c) 1902 return false; 1903 1904 darray_for_each(*d, i) 1905 if (c != *i) 1906 return false; 1907 return true; 1908 } 1909 1910 static int bch2_fs_get_tree(struct fs_context *fc) 1911 { 1912 struct bch_fs *c; 1913 struct super_block *sb; 1914 struct inode *vinode; 1915 struct bch2_opts_parse *opts_parse = fc->fs_private; 1916 struct bch_opts opts = opts_parse->opts; 1917 darray_str devs; 1918 darray_fs devs_to_fs = {}; 1919 int ret; 1920 1921 opt_set(opts, read_only, (fc->sb_flags & SB_RDONLY) != 0); 1922 opt_set(opts, nostart, true); 1923 1924 if (!fc->source || strlen(fc->source) == 0) 1925 return -EINVAL; 1926 1927 ret = bch2_split_devs(fc->source, &devs); 1928 if (ret) 1929 return ret; 1930 1931 darray_for_each(devs, i) { 1932 ret = darray_push(&devs_to_fs, bch2_path_to_fs(*i)); 1933 if (ret) 1934 goto err; 1935 } 1936 1937 sb = sget(fc->fs_type, bch2_test_super, bch2_noset_super, fc->sb_flags|SB_NOSEC, &devs_to_fs); 1938 if (!IS_ERR(sb)) 1939 goto got_sb; 1940 1941 c = bch2_fs_open(devs.data, devs.nr, opts); 1942 ret = PTR_ERR_OR_ZERO(c); 1943 if (ret) 1944 goto err; 1945 1946 /* Some options can't be parsed until after the fs is started: */ 1947 opts = bch2_opts_empty(); 1948 ret = bch2_parse_mount_opts(c, &opts, NULL, opts_parse->parse_later.buf); 1949 if (ret) 1950 goto err_stop_fs; 1951 1952 bch2_opts_apply(&c->opts, opts); 1953 1954 ret = bch2_fs_start(c); 1955 if (ret) 1956 goto err_stop_fs; 1957 1958 sb = sget(fc->fs_type, NULL, bch2_set_super, fc->sb_flags|SB_NOSEC, c); 1959 ret = PTR_ERR_OR_ZERO(sb); 1960 if (ret) 1961 goto err_stop_fs; 1962 got_sb: 1963 c = sb->s_fs_info; 1964 1965 if (sb->s_root) { 1966 if ((fc->sb_flags ^ sb->s_flags) & SB_RDONLY) { 1967 ret = -EBUSY; 1968 goto err_put_super; 1969 } 1970 goto out; 1971 } 1972 1973 sb->s_blocksize = block_bytes(c); 1974 sb->s_blocksize_bits = ilog2(block_bytes(c)); 1975 sb->s_maxbytes = MAX_LFS_FILESIZE; 1976 sb->s_op = &bch_super_operations; 1977 sb->s_export_op = &bch_export_ops; 1978 #ifdef CONFIG_BCACHEFS_QUOTA 1979 sb->s_qcop = &bch2_quotactl_operations; 1980 sb->s_quota_types = QTYPE_MASK_USR|QTYPE_MASK_GRP|QTYPE_MASK_PRJ; 1981 #endif 1982 sb->s_xattr = bch2_xattr_handlers; 1983 sb->s_magic = BCACHEFS_STATFS_MAGIC; 1984 sb->s_time_gran = c->sb.nsec_per_time_unit; 1985 sb->s_time_min = div_s64(S64_MIN, c->sb.time_units_per_sec) + 1; 1986 sb->s_time_max = div_s64(S64_MAX, c->sb.time_units_per_sec); 1987 sb->s_uuid = c->sb.user_uuid; 1988 sb->s_shrink->seeks = 0; 1989 c->vfs_sb = sb; 1990 strscpy(sb->s_id, c->name, sizeof(sb->s_id)); 1991 1992 ret = super_setup_bdi(sb); 1993 if (ret) 1994 goto err_put_super; 1995 1996 sb->s_bdi->ra_pages = VM_READAHEAD_PAGES; 1997 1998 for_each_online_member(c, ca) { 1999 struct block_device *bdev = ca->disk_sb.bdev; 2000 2001 /* XXX: create an anonymous device for multi device filesystems */ 2002 sb->s_bdev = bdev; 2003 sb->s_dev = bdev->bd_dev; 2004 percpu_ref_put(&ca->io_ref); 2005 break; 2006 } 2007 2008 c->dev = sb->s_dev; 2009 2010 #ifdef CONFIG_BCACHEFS_POSIX_ACL 2011 if (c->opts.acl) 2012 sb->s_flags |= SB_POSIXACL; 2013 #endif 2014 2015 sb->s_shrink->seeks = 0; 2016 2017 vinode = bch2_vfs_inode_get(c, BCACHEFS_ROOT_SUBVOL_INUM); 2018 ret = PTR_ERR_OR_ZERO(vinode); 2019 bch_err_msg(c, ret, "mounting: error getting root inode"); 2020 if (ret) 2021 goto err_put_super; 2022 2023 sb->s_root = d_make_root(vinode); 2024 if (!sb->s_root) { 2025 bch_err(c, "error mounting: error allocating root dentry"); 2026 ret = -ENOMEM; 2027 goto err_put_super; 2028 } 2029 2030 sb->s_flags |= SB_ACTIVE; 2031 out: 2032 fc->root = dget(sb->s_root); 2033 err: 2034 darray_exit(&devs_to_fs); 2035 bch2_darray_str_exit(&devs); 2036 if (ret) 2037 pr_err("error: %s", bch2_err_str(ret)); 2038 /* 2039 * On an inconsistency error in recovery we might see an -EROFS derived 2040 * errorcode (from the journal), but we don't want to return that to 2041 * userspace as that causes util-linux to retry the mount RO - which is 2042 * confusing: 2043 */ 2044 if (bch2_err_matches(ret, EROFS) && ret != -EROFS) 2045 ret = -EIO; 2046 return bch2_err_class(ret); 2047 2048 err_stop_fs: 2049 bch2_fs_stop(c); 2050 goto err; 2051 2052 err_put_super: 2053 __bch2_fs_stop(c); 2054 deactivate_locked_super(sb); 2055 goto err; 2056 } 2057 2058 static void bch2_kill_sb(struct super_block *sb) 2059 { 2060 struct bch_fs *c = sb->s_fs_info; 2061 2062 generic_shutdown_super(sb); 2063 bch2_fs_free(c); 2064 } 2065 2066 static void bch2_fs_context_free(struct fs_context *fc) 2067 { 2068 struct bch2_opts_parse *opts = fc->fs_private; 2069 2070 if (opts) { 2071 printbuf_exit(&opts->parse_later); 2072 kfree(opts); 2073 } 2074 } 2075 2076 static int bch2_fs_parse_param(struct fs_context *fc, 2077 struct fs_parameter *param) 2078 { 2079 /* 2080 * the "source" param, i.e., the name of the device(s) to mount, 2081 * is handled by the VFS layer. 2082 */ 2083 if (!strcmp(param->key, "source")) 2084 return -ENOPARAM; 2085 2086 struct bch2_opts_parse *opts = fc->fs_private; 2087 struct bch_fs *c = NULL; 2088 2089 /* for reconfigure, we already have a struct bch_fs */ 2090 if (fc->root) 2091 c = fc->root->d_sb->s_fs_info; 2092 2093 int ret = bch2_parse_one_mount_opt(c, &opts->opts, 2094 &opts->parse_later, param->key, 2095 param->string); 2096 2097 return bch2_err_class(ret); 2098 } 2099 2100 static int bch2_fs_reconfigure(struct fs_context *fc) 2101 { 2102 struct super_block *sb = fc->root->d_sb; 2103 struct bch2_opts_parse *opts = fc->fs_private; 2104 2105 return bch2_remount(sb, &fc->sb_flags, opts->opts); 2106 } 2107 2108 static const struct fs_context_operations bch2_context_ops = { 2109 .free = bch2_fs_context_free, 2110 .parse_param = bch2_fs_parse_param, 2111 .get_tree = bch2_fs_get_tree, 2112 .reconfigure = bch2_fs_reconfigure, 2113 }; 2114 2115 static int bch2_init_fs_context(struct fs_context *fc) 2116 { 2117 struct bch2_opts_parse *opts = kzalloc(sizeof(*opts), GFP_KERNEL); 2118 2119 if (!opts) 2120 return -ENOMEM; 2121 2122 opts->parse_later = PRINTBUF; 2123 2124 fc->ops = &bch2_context_ops; 2125 fc->fs_private = opts; 2126 2127 return 0; 2128 } 2129 2130 static struct file_system_type bcache_fs_type = { 2131 .owner = THIS_MODULE, 2132 .name = "bcachefs", 2133 .init_fs_context = bch2_init_fs_context, 2134 .kill_sb = bch2_kill_sb, 2135 .fs_flags = FS_REQUIRES_DEV, 2136 }; 2137 2138 MODULE_ALIAS_FS("bcachefs"); 2139 2140 void bch2_vfs_exit(void) 2141 { 2142 unregister_filesystem(&bcache_fs_type); 2143 kmem_cache_destroy(bch2_inode_cache); 2144 } 2145 2146 int __init bch2_vfs_init(void) 2147 { 2148 int ret = -ENOMEM; 2149 2150 bch2_inode_cache = KMEM_CACHE(bch_inode_info, SLAB_RECLAIM_ACCOUNT); 2151 if (!bch2_inode_cache) 2152 goto err; 2153 2154 ret = register_filesystem(&bcache_fs_type); 2155 if (ret) 2156 goto err; 2157 2158 return 0; 2159 err: 2160 bch2_vfs_exit(); 2161 return ret; 2162 } 2163 2164 #endif /* NO_BCACHEFS_FS */ 2165