1 // SPDX-License-Identifier: GPL-2.0
4 #include "btree_key_cache.h"
5 #include "btree_update.h"
13 void bch2_snapshot_to_text(struct printbuf *out, struct bch_fs *c,
16 struct bkey_s_c_snapshot s = bkey_s_c_to_snapshot(k);
18 prt_printf(out, "is_subvol %llu deleted %llu parent %10u children %10u %10u subvol %u",
19 BCH_SNAPSHOT_SUBVOL(s.v),
20 BCH_SNAPSHOT_DELETED(s.v),
21 le32_to_cpu(s.v->parent),
22 le32_to_cpu(s.v->children[0]),
23 le32_to_cpu(s.v->children[1]),
24 le32_to_cpu(s.v->subvol));
27 int bch2_snapshot_invalid(const struct bch_fs *c, struct bkey_s_c k,
28 int rw, struct printbuf *err)
30 struct bkey_s_c_snapshot s;
33 if (bkey_cmp(k.k->p, POS(0, U32_MAX)) > 0 ||
34 bkey_cmp(k.k->p, POS(0, 1)) < 0) {
35 prt_printf(err, "bad pos");
36 return -BCH_ERR_invalid_bkey;
39 if (bkey_val_bytes(k.k) != sizeof(struct bch_snapshot)) {
40 prt_printf(err, "bad val size (%zu != %zu)",
41 bkey_val_bytes(k.k), sizeof(struct bch_snapshot));
42 return -BCH_ERR_invalid_bkey;
45 s = bkey_s_c_to_snapshot(k);
47 id = le32_to_cpu(s.v->parent);
48 if (id && id <= k.k->p.offset) {
49 prt_printf(err, "bad parent node (%u <= %llu)",
51 return -BCH_ERR_invalid_bkey;
54 if (le32_to_cpu(s.v->children[0]) < le32_to_cpu(s.v->children[1])) {
55 prt_printf(err, "children not normalized");
56 return -BCH_ERR_invalid_bkey;
59 if (s.v->children[0] &&
60 s.v->children[0] == s.v->children[1]) {
61 prt_printf(err, "duplicate child nodes");
62 return -BCH_ERR_invalid_bkey;
65 for (i = 0; i < 2; i++) {
66 id = le32_to_cpu(s.v->children[i]);
68 if (id >= k.k->p.offset) {
69 prt_printf(err, "bad child node (%u >= %llu)",
71 return -BCH_ERR_invalid_bkey;
78 int bch2_mark_snapshot(struct btree_trans *trans,
79 struct bkey_s_c old, struct bkey_s_c new,
82 struct bch_fs *c = trans->c;
85 t = genradix_ptr_alloc(&c->snapshots,
86 U32_MAX - new.k->p.offset,
91 if (new.k->type == KEY_TYPE_snapshot) {
92 struct bkey_s_c_snapshot s = bkey_s_c_to_snapshot(new);
94 t->parent = le32_to_cpu(s.v->parent);
95 t->children[0] = le32_to_cpu(s.v->children[0]);
96 t->children[1] = le32_to_cpu(s.v->children[1]);
97 t->subvol = BCH_SNAPSHOT_SUBVOL(s.v) ? le32_to_cpu(s.v->subvol) : 0;
108 static int snapshot_lookup(struct btree_trans *trans, u32 id,
109 struct bch_snapshot *s)
111 struct btree_iter iter;
115 bch2_trans_iter_init(trans, &iter, BTREE_ID_snapshots, POS(0, id),
116 BTREE_ITER_WITH_UPDATES);
117 k = bch2_btree_iter_peek_slot(&iter);
118 ret = bkey_err(k) ?: k.k->type == KEY_TYPE_snapshot ? 0 : -ENOENT;
121 *s = *bkey_s_c_to_snapshot(k).v;
123 bch2_trans_iter_exit(trans, &iter);
127 static int snapshot_live(struct btree_trans *trans, u32 id)
129 struct bch_snapshot v;
135 ret = snapshot_lookup(trans, id, &v);
137 bch_err(trans->c, "snapshot node %u not found", id);
141 return !BCH_SNAPSHOT_DELETED(&v);
144 static int bch2_snapshot_set_equiv(struct btree_trans *trans, struct bkey_s_c k)
146 struct bch_fs *c = trans->c;
147 unsigned i, nr_live = 0, live_idx = 0;
148 struct bkey_s_c_snapshot snap;
149 u32 id = k.k->p.offset, child[2];
151 if (k.k->type != KEY_TYPE_snapshot)
154 snap = bkey_s_c_to_snapshot(k);
156 child[0] = le32_to_cpu(snap.v->children[0]);
157 child[1] = le32_to_cpu(snap.v->children[1]);
159 for (i = 0; i < 2; i++) {
160 int ret = snapshot_live(trans, child[i]);
170 snapshot_t(c, id)->equiv = nr_live == 1
171 ? snapshot_t(c, child[live_idx])->equiv
177 static int check_snapshot(struct btree_trans *trans,
178 struct btree_iter *iter,
181 struct bch_fs *c = trans->c;
182 struct bkey_s_c_snapshot s;
183 struct bch_subvolume subvol;
184 struct bch_snapshot v;
185 struct printbuf buf = PRINTBUF;
186 bool should_have_subvol;
190 if (k.k->type != KEY_TYPE_snapshot)
193 s = bkey_s_c_to_snapshot(k);
194 id = le32_to_cpu(s.v->parent);
196 ret = snapshot_lookup(trans, id, &v);
198 bch_err(c, "snapshot with nonexistent parent:\n %s",
199 (bch2_bkey_val_to_text(&buf, c, s.s_c), buf.buf));
203 if (le32_to_cpu(v.children[0]) != s.k->p.offset &&
204 le32_to_cpu(v.children[1]) != s.k->p.offset) {
205 bch_err(c, "snapshot parent %u missing pointer to child %llu",
212 for (i = 0; i < 2 && s.v->children[i]; i++) {
213 id = le32_to_cpu(s.v->children[i]);
215 ret = snapshot_lookup(trans, id, &v);
217 bch_err(c, "snapshot node %llu has nonexistent child %u",
222 if (le32_to_cpu(v.parent) != s.k->p.offset) {
223 bch_err(c, "snapshot child %u has wrong parent (got %u should be %llu)",
224 id, le32_to_cpu(v.parent), s.k->p.offset);
230 should_have_subvol = BCH_SNAPSHOT_SUBVOL(s.v) &&
231 !BCH_SNAPSHOT_DELETED(s.v);
233 if (should_have_subvol) {
234 id = le32_to_cpu(s.v->subvol);
235 ret = bch2_subvolume_get(trans, id, 0, false, &subvol);
237 bch_err(c, "snapshot points to nonexistent subvolume:\n %s",
238 (bch2_bkey_val_to_text(&buf, c, s.s_c), buf.buf));
242 if (BCH_SNAPSHOT_SUBVOL(s.v) != (le32_to_cpu(subvol.snapshot) == s.k->p.offset)) {
243 bch_err(c, "snapshot node %llu has wrong BCH_SNAPSHOT_SUBVOL",
249 if (fsck_err_on(s.v->subvol, c, "snapshot should not point to subvol:\n %s",
250 (bch2_bkey_val_to_text(&buf, c, s.s_c), buf.buf))) {
251 struct bkey_i_snapshot *u = bch2_trans_kmalloc(trans, sizeof(*u));
253 ret = PTR_ERR_OR_ZERO(u);
257 bkey_reassemble(&u->k_i, s.s_c);
259 ret = bch2_trans_update(trans, iter, &u->k_i, 0);
265 if (BCH_SNAPSHOT_DELETED(s.v))
266 set_bit(BCH_FS_HAVE_DELETED_SNAPSHOTS, &c->flags);
273 int bch2_fs_check_snapshots(struct bch_fs *c)
275 struct btree_trans trans;
276 struct btree_iter iter;
280 bch2_trans_init(&trans, c, 0, 0);
282 ret = for_each_btree_key_commit(&trans, iter,
283 BTREE_ID_snapshots, POS_MIN,
284 BTREE_ITER_PREFETCH, k,
285 NULL, NULL, BTREE_INSERT_LAZY_RW|BTREE_INSERT_NOFAIL,
286 check_snapshot(&trans, &iter, k));
289 bch_err(c, "error %i checking snapshots", ret);
291 bch2_trans_exit(&trans);
295 static int check_subvol(struct btree_trans *trans,
296 struct btree_iter *iter,
299 struct bkey_s_c_subvolume subvol;
300 struct bch_snapshot snapshot;
304 if (k.k->type != KEY_TYPE_subvolume)
307 subvol = bkey_s_c_to_subvolume(k);
308 snapid = le32_to_cpu(subvol.v->snapshot);
309 ret = snapshot_lookup(trans, snapid, &snapshot);
312 bch_err(trans->c, "subvolume %llu points to nonexistent snapshot %u",
313 k.k->p.offset, snapid);
317 if (BCH_SUBVOLUME_UNLINKED(subvol.v)) {
318 ret = bch2_subvolume_delete(trans, iter->pos.offset);
319 if (ret && !bch2_err_matches(ret, BCH_ERR_transaction_restart))
320 bch_err(trans->c, "error deleting subvolume %llu: %s",
321 iter->pos.offset, bch2_err_str(ret));
329 int bch2_fs_check_subvols(struct bch_fs *c)
331 struct btree_trans trans;
332 struct btree_iter iter;
336 bch2_trans_init(&trans, c, 0, 0);
338 ret = for_each_btree_key_commit(&trans, iter,
339 BTREE_ID_subvolumes, POS_MIN, BTREE_ITER_PREFETCH, k,
340 NULL, NULL, BTREE_INSERT_LAZY_RW|BTREE_INSERT_NOFAIL,
341 check_subvol(&trans, &iter, k));
343 bch2_trans_exit(&trans);
348 void bch2_fs_snapshots_exit(struct bch_fs *c)
350 genradix_free(&c->snapshots);
353 int bch2_fs_snapshots_start(struct bch_fs *c)
355 struct btree_trans trans;
356 struct btree_iter iter;
360 bch2_trans_init(&trans, c, 0, 0);
362 for_each_btree_key2(&trans, iter, BTREE_ID_snapshots,
364 bch2_mark_snapshot(&trans, bkey_s_c_null, k, 0) ?:
365 bch2_snapshot_set_equiv(&trans, k));
367 bch2_trans_exit(&trans);
370 bch_err(c, "error starting snapshots: %s", bch2_err_str(ret));
375 * Mark a snapshot as deleted, for future cleanup:
377 static int bch2_snapshot_node_set_deleted(struct btree_trans *trans, u32 id)
379 struct btree_iter iter;
381 struct bkey_i_snapshot *s;
384 bch2_trans_iter_init(trans, &iter, BTREE_ID_snapshots, POS(0, id),
386 k = bch2_btree_iter_peek_slot(&iter);
391 if (k.k->type != KEY_TYPE_snapshot) {
392 bch2_fs_inconsistent(trans->c, "missing snapshot %u", id);
397 /* already deleted? */
398 if (BCH_SNAPSHOT_DELETED(bkey_s_c_to_snapshot(k).v))
401 s = bch2_trans_kmalloc(trans, sizeof(*s));
402 ret = PTR_ERR_OR_ZERO(s);
406 bkey_reassemble(&s->k_i, k);
407 SET_BCH_SNAPSHOT_DELETED(&s->v, true);
408 SET_BCH_SNAPSHOT_SUBVOL(&s->v, false);
411 ret = bch2_trans_update(trans, &iter, &s->k_i, 0);
415 bch2_trans_iter_exit(trans, &iter);
419 static int bch2_snapshot_node_delete(struct btree_trans *trans, u32 id)
421 struct btree_iter iter, p_iter = (struct btree_iter) { NULL };
423 struct bkey_s_c_snapshot s;
424 struct bkey_i_snapshot *parent;
429 bch2_trans_iter_init(trans, &iter, BTREE_ID_snapshots, POS(0, id),
431 k = bch2_btree_iter_peek_slot(&iter);
436 if (k.k->type != KEY_TYPE_snapshot) {
437 bch2_fs_inconsistent(trans->c, "missing snapshot %u", id);
442 s = bkey_s_c_to_snapshot(k);
444 BUG_ON(!BCH_SNAPSHOT_DELETED(s.v));
445 parent_id = le32_to_cpu(s.v->parent);
448 bch2_trans_iter_init(trans, &p_iter, BTREE_ID_snapshots,
451 k = bch2_btree_iter_peek_slot(&p_iter);
456 if (k.k->type != KEY_TYPE_snapshot) {
457 bch2_fs_inconsistent(trans->c, "missing snapshot %u", parent_id);
462 parent = bch2_trans_kmalloc(trans, sizeof(*parent));
463 ret = PTR_ERR_OR_ZERO(parent);
467 bkey_reassemble(&parent->k_i, k);
469 for (i = 0; i < 2; i++)
470 if (le32_to_cpu(parent->v.children[i]) == id)
474 bch_err(trans->c, "snapshot %u missing child pointer to %u",
477 parent->v.children[i] = 0;
479 if (le32_to_cpu(parent->v.children[0]) <
480 le32_to_cpu(parent->v.children[1]))
481 swap(parent->v.children[0],
482 parent->v.children[1]);
484 ret = bch2_trans_update(trans, &p_iter, &parent->k_i, 0);
489 ret = bch2_btree_delete_at(trans, &iter, 0);
491 bch2_trans_iter_exit(trans, &p_iter);
492 bch2_trans_iter_exit(trans, &iter);
496 int bch2_snapshot_node_create(struct btree_trans *trans, u32 parent,
498 u32 *snapshot_subvols,
501 struct btree_iter iter;
502 struct bkey_i_snapshot *n;
507 bch2_trans_iter_init(trans, &iter, BTREE_ID_snapshots,
508 POS_MIN, BTREE_ITER_INTENT);
509 k = bch2_btree_iter_peek(&iter);
514 for (i = 0; i < nr_snapids; i++) {
515 k = bch2_btree_iter_prev_slot(&iter);
520 if (!k.k || !k.k->p.offset) {
521 ret = -BCH_ERR_ENOSPC_snapshot_create;
525 n = bch2_trans_kmalloc(trans, sizeof(*n));
526 ret = PTR_ERR_OR_ZERO(n);
530 bkey_snapshot_init(&n->k_i);
533 n->v.parent = cpu_to_le32(parent);
534 n->v.subvol = cpu_to_le32(snapshot_subvols[i]);
536 SET_BCH_SNAPSHOT_SUBVOL(&n->v, true);
538 ret = bch2_trans_update(trans, &iter, &n->k_i, 0) ?:
539 bch2_mark_snapshot(trans, bkey_s_c_null, bkey_i_to_s_c(&n->k_i), 0);
543 new_snapids[i] = iter.pos.offset;
547 bch2_btree_iter_set_pos(&iter, POS(0, parent));
548 k = bch2_btree_iter_peek(&iter);
553 if (k.k->type != KEY_TYPE_snapshot) {
554 bch_err(trans->c, "snapshot %u not found", parent);
559 n = bch2_trans_kmalloc(trans, sizeof(*n));
560 ret = PTR_ERR_OR_ZERO(n);
564 bkey_reassemble(&n->k_i, k);
566 if (n->v.children[0] || n->v.children[1]) {
567 bch_err(trans->c, "Trying to add child snapshot nodes to parent that already has children");
572 n->v.children[0] = cpu_to_le32(new_snapids[0]);
573 n->v.children[1] = cpu_to_le32(new_snapids[1]);
575 SET_BCH_SNAPSHOT_SUBVOL(&n->v, false);
576 ret = bch2_trans_update(trans, &iter, &n->k_i, 0);
581 bch2_trans_iter_exit(trans, &iter);
585 static int snapshot_delete_key(struct btree_trans *trans,
586 struct btree_iter *iter,
588 snapshot_id_list *deleted,
589 snapshot_id_list *equiv_seen,
590 struct bpos *last_pos)
592 struct bch_fs *c = trans->c;
593 u32 equiv = snapshot_t(c, k.k->p.snapshot)->equiv;
595 if (bkey_cmp(k.k->p, *last_pos))
599 if (snapshot_list_has_id(deleted, k.k->p.snapshot) ||
600 snapshot_list_has_id(equiv_seen, equiv)) {
601 return bch2_btree_delete_at(trans, iter,
602 BTREE_UPDATE_INTERNAL_SNAPSHOT_NODE);
604 return snapshot_list_add(c, equiv_seen, equiv);
608 static int bch2_delete_redundant_snapshot(struct btree_trans *trans, struct btree_iter *iter,
611 struct bkey_s_c_snapshot snap;
615 if (k.k->type != KEY_TYPE_snapshot)
618 snap = bkey_s_c_to_snapshot(k);
619 if (BCH_SNAPSHOT_DELETED(snap.v) ||
620 BCH_SNAPSHOT_SUBVOL(snap.v))
623 children[0] = le32_to_cpu(snap.v->children[0]);
624 children[1] = le32_to_cpu(snap.v->children[1]);
626 ret = snapshot_live(trans, children[0]) ?:
627 snapshot_live(trans, children[1]);
632 return bch2_snapshot_node_set_deleted(trans, k.k->p.offset);
636 int bch2_delete_dead_snapshots(struct bch_fs *c)
638 struct btree_trans trans;
639 struct btree_iter iter;
641 struct bkey_s_c_snapshot snap;
642 snapshot_id_list deleted = { 0 };
646 if (!test_bit(BCH_FS_HAVE_DELETED_SNAPSHOTS, &c->flags))
649 if (!test_bit(BCH_FS_STARTED, &c->flags)) {
650 ret = bch2_fs_read_write_early(c);
652 bch_err(c, "error deleleting dead snapshots: error going rw: %s", bch2_err_str(ret));
657 bch2_trans_init(&trans, c, 0, 0);
660 * For every snapshot node: If we have no live children and it's not
661 * pointed to by a subvolume, delete it:
663 ret = for_each_btree_key_commit(&trans, iter, BTREE_ID_snapshots,
666 bch2_delete_redundant_snapshot(&trans, &iter, k));
668 bch_err(c, "error deleting redundant snapshots: %s", bch2_err_str(ret));
672 for_each_btree_key2(&trans, iter, BTREE_ID_snapshots,
674 bch2_snapshot_set_equiv(&trans, k));
676 bch_err(c, "error in bch2_snapshots_set_equiv: %s", bch2_err_str(ret));
680 for_each_btree_key(&trans, iter, BTREE_ID_snapshots,
681 POS_MIN, 0, k, ret) {
682 if (k.k->type != KEY_TYPE_snapshot)
685 snap = bkey_s_c_to_snapshot(k);
686 if (BCH_SNAPSHOT_DELETED(snap.v)) {
687 ret = snapshot_list_add(c, &deleted, k.k->p.offset);
692 bch2_trans_iter_exit(&trans, &iter);
695 bch_err(c, "error walking snapshots: %s", bch2_err_str(ret));
699 for (id = 0; id < BTREE_ID_NR; id++) {
700 struct bpos last_pos = POS_MIN;
701 snapshot_id_list equiv_seen = { 0 };
703 if (!btree_type_has_snapshots(id))
706 ret = for_each_btree_key_commit(&trans, iter,
708 BTREE_ITER_PREFETCH|BTREE_ITER_ALL_SNAPSHOTS, k,
709 NULL, NULL, BTREE_INSERT_NOFAIL,
710 snapshot_delete_key(&trans, &iter, k, &deleted, &equiv_seen, &last_pos));
712 darray_exit(&equiv_seen);
715 bch_err(c, "error deleting snapshot keys: %s", bch2_err_str(ret));
720 for (i = 0; i < deleted.nr; i++) {
721 ret = commit_do(&trans, NULL, NULL, 0,
722 bch2_snapshot_node_delete(&trans, deleted.data[i]));
724 bch_err(c, "error deleting snapshot %u: %s",
725 deleted.data[i], bch2_err_str(ret));
730 clear_bit(BCH_FS_HAVE_DELETED_SNAPSHOTS, &c->flags);
732 darray_exit(&deleted);
733 bch2_trans_exit(&trans);
737 static void bch2_delete_dead_snapshots_work(struct work_struct *work)
739 struct bch_fs *c = container_of(work, struct bch_fs, snapshot_delete_work);
741 bch2_delete_dead_snapshots(c);
742 percpu_ref_put(&c->writes);
745 void bch2_delete_dead_snapshots_async(struct bch_fs *c)
747 if (!percpu_ref_tryget_live(&c->writes))
750 if (!queue_work(system_long_wq, &c->snapshot_delete_work))
751 percpu_ref_put(&c->writes);
754 static int bch2_delete_dead_snapshots_hook(struct btree_trans *trans,
755 struct btree_trans_commit_hook *h)
757 struct bch_fs *c = trans->c;
759 set_bit(BCH_FS_HAVE_DELETED_SNAPSHOTS, &c->flags);
761 if (!test_bit(BCH_FS_FSCK_DONE, &c->flags))
764 bch2_delete_dead_snapshots_async(c);
770 int bch2_subvolume_invalid(const struct bch_fs *c, struct bkey_s_c k,
771 int rw, struct printbuf *err)
773 if (bkey_cmp(k.k->p, SUBVOL_POS_MIN) < 0 ||
774 bkey_cmp(k.k->p, SUBVOL_POS_MAX) > 0) {
775 prt_printf(err, "invalid pos");
776 return -BCH_ERR_invalid_bkey;
779 if (bkey_val_bytes(k.k) != sizeof(struct bch_subvolume)) {
780 prt_printf(err, "incorrect value size (%zu != %zu)",
781 bkey_val_bytes(k.k), sizeof(struct bch_subvolume));
782 return -BCH_ERR_invalid_bkey;
788 void bch2_subvolume_to_text(struct printbuf *out, struct bch_fs *c,
791 struct bkey_s_c_subvolume s = bkey_s_c_to_subvolume(k);
793 prt_printf(out, "root %llu snapshot id %u",
794 le64_to_cpu(s.v->inode),
795 le32_to_cpu(s.v->snapshot));
798 int bch2_subvolume_get(struct btree_trans *trans, unsigned subvol,
799 bool inconsistent_if_not_found,
801 struct bch_subvolume *s)
803 struct btree_iter iter;
807 bch2_trans_iter_init(trans, &iter, BTREE_ID_subvolumes, POS(0, subvol),
809 k = bch2_btree_iter_peek_slot(&iter);
810 ret = bkey_err(k) ?: k.k->type == KEY_TYPE_subvolume ? 0 : -ENOENT;
812 if (ret == -ENOENT && inconsistent_if_not_found)
813 bch2_fs_inconsistent(trans->c, "missing subvolume %u", subvol);
815 *s = *bkey_s_c_to_subvolume(k).v;
817 bch2_trans_iter_exit(trans, &iter);
821 int bch2_snapshot_get_subvol(struct btree_trans *trans, u32 snapshot,
822 struct bch_subvolume *subvol)
824 struct bch_snapshot snap;
826 return snapshot_lookup(trans, snapshot, &snap) ?:
827 bch2_subvolume_get(trans, le32_to_cpu(snap.subvol), true, 0, subvol);
830 int bch2_subvolume_get_snapshot(struct btree_trans *trans, u32 subvol,
833 struct bch_subvolume s;
836 ret = bch2_subvolume_get(trans, subvol, true,
838 BTREE_ITER_WITH_UPDATES,
841 *snapid = le32_to_cpu(s.snapshot);
846 * Delete subvolume, mark snapshot ID as deleted, queue up snapshot
849 int bch2_subvolume_delete(struct btree_trans *trans, u32 subvolid)
851 struct btree_iter iter;
853 struct bkey_s_c_subvolume subvol;
854 struct btree_trans_commit_hook *h;
858 bch2_trans_iter_init(trans, &iter, BTREE_ID_subvolumes,
862 k = bch2_btree_iter_peek_slot(&iter);
867 if (k.k->type != KEY_TYPE_subvolume) {
868 bch2_fs_inconsistent(trans->c, "missing subvolume %u", subvolid);
873 subvol = bkey_s_c_to_subvolume(k);
874 snapid = le32_to_cpu(subvol.v->snapshot);
876 ret = bch2_btree_delete_at(trans, &iter, 0);
880 ret = bch2_snapshot_node_set_deleted(trans, snapid);
884 h = bch2_trans_kmalloc(trans, sizeof(*h));
885 ret = PTR_ERR_OR_ZERO(h);
889 h->fn = bch2_delete_dead_snapshots_hook;
890 bch2_trans_commit_hook(trans, h);
892 bch2_trans_iter_exit(trans, &iter);
896 void bch2_subvolume_wait_for_pagecache_and_delete(struct work_struct *work)
898 struct bch_fs *c = container_of(work, struct bch_fs,
899 snapshot_wait_for_pagecache_and_delete_work);
905 mutex_lock(&c->snapshots_unlinked_lock);
906 s = c->snapshots_unlinked;
907 darray_init(&c->snapshots_unlinked);
908 mutex_unlock(&c->snapshots_unlinked_lock);
913 bch2_evict_subvolume_inodes(c, &s);
915 for (id = s.data; id < s.data + s.nr; id++) {
916 ret = bch2_trans_do(c, NULL, NULL, BTREE_INSERT_NOFAIL,
917 bch2_subvolume_delete(&trans, *id));
919 bch_err(c, "error deleting subvolume %u: %s", *id, bch2_err_str(ret));
927 percpu_ref_put(&c->writes);
930 struct subvolume_unlink_hook {
931 struct btree_trans_commit_hook h;
935 int bch2_subvolume_wait_for_pagecache_and_delete_hook(struct btree_trans *trans,
936 struct btree_trans_commit_hook *_h)
938 struct subvolume_unlink_hook *h = container_of(_h, struct subvolume_unlink_hook, h);
939 struct bch_fs *c = trans->c;
942 mutex_lock(&c->snapshots_unlinked_lock);
943 if (!snapshot_list_has_id(&c->snapshots_unlinked, h->subvol))
944 ret = snapshot_list_add(c, &c->snapshots_unlinked, h->subvol);
945 mutex_unlock(&c->snapshots_unlinked_lock);
950 if (unlikely(!percpu_ref_tryget_live(&c->writes)))
953 if (!queue_work(system_long_wq, &c->snapshot_wait_for_pagecache_and_delete_work))
954 percpu_ref_put(&c->writes);
958 int bch2_subvolume_unlink(struct btree_trans *trans, u32 subvolid)
960 struct btree_iter iter;
962 struct bkey_i_subvolume *n;
963 struct subvolume_unlink_hook *h;
966 bch2_trans_iter_init(trans, &iter, BTREE_ID_subvolumes,
970 k = bch2_btree_iter_peek_slot(&iter);
975 if (k.k->type != KEY_TYPE_subvolume) {
976 bch2_fs_inconsistent(trans->c, "missing subvolume %u", subvolid);
981 n = bch2_trans_kmalloc(trans, sizeof(*n));
982 ret = PTR_ERR_OR_ZERO(n);
986 bkey_reassemble(&n->k_i, k);
987 SET_BCH_SUBVOLUME_UNLINKED(&n->v, true);
989 ret = bch2_trans_update(trans, &iter, &n->k_i, 0);
993 h = bch2_trans_kmalloc(trans, sizeof(*h));
994 ret = PTR_ERR_OR_ZERO(h);
998 h->h.fn = bch2_subvolume_wait_for_pagecache_and_delete_hook;
999 h->subvol = subvolid;
1000 bch2_trans_commit_hook(trans, &h->h);
1002 bch2_trans_iter_exit(trans, &iter);
1006 int bch2_subvolume_create(struct btree_trans *trans, u64 inode,
1009 u32 *new_snapshotid,
1012 struct bch_fs *c = trans->c;
1013 struct btree_iter dst_iter, src_iter = (struct btree_iter) { NULL };
1014 struct bkey_i_subvolume *new_subvol = NULL;
1015 struct bkey_i_subvolume *src_subvol = NULL;
1017 u32 parent = 0, new_nodes[2], snapshot_subvols[2];
1020 for_each_btree_key(trans, dst_iter, BTREE_ID_subvolumes, SUBVOL_POS_MIN,
1021 BTREE_ITER_SLOTS|BTREE_ITER_INTENT, k, ret) {
1022 if (bkey_cmp(k.k->p, SUBVOL_POS_MAX) > 0)
1026 * bch2_subvolume_delete() doesn't flush the btree key cache -
1027 * ideally it would but that's tricky
1029 if (bkey_deleted(k.k) &&
1030 !bch2_btree_key_cache_find(c, BTREE_ID_subvolumes, dst_iter.pos))
1035 ret = -BCH_ERR_ENOSPC_subvolume_create;
1038 snapshot_subvols[0] = dst_iter.pos.offset;
1039 snapshot_subvols[1] = src_subvolid;
1042 /* Creating a snapshot: */
1043 src_subvol = bch2_trans_kmalloc(trans, sizeof(*src_subvol));
1044 ret = PTR_ERR_OR_ZERO(src_subvol);
1048 bch2_trans_iter_init(trans, &src_iter, BTREE_ID_subvolumes,
1049 POS(0, src_subvolid),
1052 k = bch2_btree_iter_peek_slot(&src_iter);
1057 if (k.k->type != KEY_TYPE_subvolume) {
1058 bch_err(c, "subvolume %u not found", src_subvolid);
1063 bkey_reassemble(&src_subvol->k_i, k);
1064 parent = le32_to_cpu(src_subvol->v.snapshot);
1067 ret = bch2_snapshot_node_create(trans, parent, new_nodes,
1069 src_subvolid ? 2 : 1);
1074 src_subvol->v.snapshot = cpu_to_le32(new_nodes[1]);
1075 ret = bch2_trans_update(trans, &src_iter, &src_subvol->k_i, 0);
1080 new_subvol = bch2_trans_kmalloc(trans, sizeof(*new_subvol));
1081 ret = PTR_ERR_OR_ZERO(new_subvol);
1085 bkey_subvolume_init(&new_subvol->k_i);
1086 new_subvol->v.flags = 0;
1087 new_subvol->v.snapshot = cpu_to_le32(new_nodes[0]);
1088 new_subvol->v.inode = cpu_to_le64(inode);
1089 SET_BCH_SUBVOLUME_RO(&new_subvol->v, ro);
1090 SET_BCH_SUBVOLUME_SNAP(&new_subvol->v, src_subvolid != 0);
1091 new_subvol->k.p = dst_iter.pos;
1092 ret = bch2_trans_update(trans, &dst_iter, &new_subvol->k_i, 0);
1096 *new_subvolid = new_subvol->k.p.offset;
1097 *new_snapshotid = new_nodes[0];
1099 bch2_trans_iter_exit(trans, &src_iter);
1100 bch2_trans_iter_exit(trans, &dst_iter);
1104 int bch2_fs_subvolumes_init(struct bch_fs *c)
1106 INIT_WORK(&c->snapshot_delete_work, bch2_delete_dead_snapshots_work);
1107 INIT_WORK(&c->snapshot_wait_for_pagecache_and_delete_work,
1108 bch2_subvolume_wait_for_pagecache_and_delete);
1109 mutex_init(&c->snapshots_unlinked_lock);