?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
printf: Remove unused 'bprintf'
[drm/drm-misc.git] / fs / bcachefs / fs.c
bloba41d0d8a2f7beb8c281f32489ba5b76b7cf1ba77
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 */
Kernel DRM miscellaneous fixes and cross-tree changes