fs/bcachefs/fs.c

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