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