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