Update bcachefs sources to 01d7ad6d95 bcachefs: snapshot_to_text() includes snapshot...

diff --git a/.bcachefs_revision b/.bcachefs_revision
index d1b87e30d0151b827f87523f2f85fd98d138e5ab..b9058b5e1bc2fed661fb02ce93226f8e9895bc2a 100644 (file)
--- a/.bcachefs_revision
+++ b/.bcachefs_revision
@@ -1 +1 @@
-ed6b7f81a7b51ac05d02635907f92aff4a3f8445
+01d7ad6d95c85cf5434a891e6dd7971797e0e1fa

diff --git a/libbcachefs/alloc_foreground.c b/libbcachefs/alloc_foreground.c
index 95829bbfe033558818b6cbc03dd393103928789f..3c5100c269161bfcb3dfa3cf7209930be5591f17 100644 (file)
--- a/libbcachefs/alloc_foreground.c
+++ b/libbcachefs/alloc_foreground.c
@@ -35,6 +35,15 @@
 #include <linux/rculist.h>
 #include <linux/rcupdate.h>
 
+static void bch2_trans_mutex_lock_norelock(struct btree_trans *trans,
+                                          struct mutex *lock)
+{
+       if (!mutex_trylock(lock)) {
+               bch2_trans_unlock(trans);
+               mutex_lock(lock);
+       }
+}
+
 const char * const bch2_alloc_reserves[] = {
 #define x(t) #t,
        BCH_ALLOC_RESERVES()
@@ -150,9 +159,7 @@ static struct open_bucket *bch2_open_bucket_alloc(struct bch_fs *c)
        return ob;
 }
 
-static void open_bucket_free_unused(struct bch_fs *c,
-                                   struct write_point *wp,
-                                   struct open_bucket *ob)
+static void open_bucket_free_unused(struct bch_fs *c, struct open_bucket *ob)
 {
        BUG_ON(c->open_buckets_partial_nr >=
               ARRAY_SIZE(c->open_buckets_partial));
@@ -1158,9 +1165,12 @@ static bool try_increase_writepoints(struct bch_fs *c)
        return true;
 }
 
-static bool try_decrease_writepoints(struct bch_fs *c, unsigned old_nr)
+static bool try_decrease_writepoints(struct btree_trans *trans, unsigned old_nr)
 {
+       struct bch_fs *c = trans->c;
        struct write_point *wp;
+       struct open_bucket *ob;
+       unsigned i;
 
        mutex_lock(&c->write_points_hash_lock);
        if (c->write_points_nr < old_nr) {
@@ -1179,19 +1189,13 @@ static bool try_decrease_writepoints(struct bch_fs *c, unsigned old_nr)
        hlist_del_rcu(&wp->node);
        mutex_unlock(&c->write_points_hash_lock);
 
-       bch2_writepoint_stop(c, NULL, false, wp);
+       bch2_trans_mutex_lock_norelock(trans, &wp->lock);
+       open_bucket_for_each(c, &wp->ptrs, ob, i)
+               open_bucket_free_unused(c, ob);
+       mutex_unlock(&wp->lock);
        return true;
 }
 
-static void bch2_trans_mutex_lock_norelock(struct btree_trans *trans,
-                                 struct mutex *lock)
-{
-       if (!mutex_trylock(lock)) {
-               bch2_trans_unlock(trans);
-               mutex_lock(lock);
-       }
-}
-
 static struct write_point *writepoint_find(struct btree_trans *trans,
                                           unsigned long write_point)
 {
@@ -1336,7 +1340,7 @@ alloc_done:
 
        /* Free buckets we didn't use: */
        open_bucket_for_each(c, &wp->ptrs, ob, i)
-               open_bucket_free_unused(c, wp, ob);
+               open_bucket_free_unused(c, ob);
 
        wp->ptrs = ptrs;
 
@@ -1353,13 +1357,13 @@ err:
                if (ptrs.nr < ARRAY_SIZE(ptrs.v))
                        ob_push(c, &ptrs, ob);
                else
-                       open_bucket_free_unused(c, wp, ob);
+                       open_bucket_free_unused(c, ob);
        wp->ptrs = ptrs;
 
        mutex_unlock(&wp->lock);
 
        if (bch2_err_matches(ret, BCH_ERR_freelist_empty) &&
-           try_decrease_writepoints(c, write_points_nr))
+           try_decrease_writepoints(trans, write_points_nr))
                goto retry;
 
        if (bch2_err_matches(ret, BCH_ERR_open_buckets_empty) ||

diff --git a/libbcachefs/btree_update_interior.c b/libbcachefs/btree_update_interior.c
index 66da1da2f0757eaa14b2417d7b305813bb32b77a..d2811c4756b7d7be5f753d26ad08c2c16778a856 100644 (file)
--- a/libbcachefs/btree_update_interior.c
+++ b/libbcachefs/btree_update_interior.c
@@ -1674,9 +1674,6 @@ static int bch2_btree_insert_node(struct btree_update *as, struct btree_trans *t
        BUG_ON(!as || as->b);
        bch2_verify_keylist_sorted(keys);
 
-       if ((local_clock() & 63) == 63)
-               return btree_trans_restart(trans, BCH_ERR_transaction_restart_split_race);
-
        ret = bch2_btree_node_lock_write(trans, path, &b->c);
        if (ret)
                return ret;

diff --git a/libbcachefs/btree_update_leaf.c b/libbcachefs/btree_update_leaf.c
index bf7b1199cee5b17bc5d1061b1f08a85b999184b1..b42b83c55c5bf58ba24606e19f6fed54d72fe4fd 100644 (file)
--- a/libbcachefs/btree_update_leaf.c
+++ b/libbcachefs/btree_update_leaf.c
@@ -1311,130 +1311,64 @@ static int need_whiteout_for_snapshot(struct btree_trans *trans,
        return ret;
 }
 
-static int get_snapshot_overwrites(struct btree_trans *trans,
-                                  enum btree_id btree,
-                                  struct bpos pos,
-                                  snapshot_id_list *overwrites)
-{
-       struct bch_fs *c = trans->c;
-       struct btree_iter iter;
-       struct bkey_s_c k;
-       snapshot_id_list overwrites2;
-       u32 *i;
-       int ret = 0;
-
-       darray_init(overwrites);
-       darray_init(&overwrites2);
-
-       for_each_btree_key_norestart(trans, iter, btree,
-                                    SPOS(pos.inode, pos.offset, 0),
-                                    BTREE_ITER_ALL_SNAPSHOTS, k, ret) {
-               if (bpos_ge(k.k->p, pos))
-                       break;
-
-               if (bch2_snapshot_is_ancestor(c, k.k->p.snapshot, pos.snapshot)) {
-                       ret = snapshot_list_add(c, &overwrites2, k.k->p.snapshot);
-                       if (ret)
-                               break;
-               }
-       }
-       bch2_trans_iter_exit(trans, &iter);
-
-       if (ret)
-               goto err;
-
-       darray_for_each(overwrites2, i)
-               if (!snapshot_list_has_ancestor(c, &overwrites2, *i)) {
-                       ret = snapshot_list_add(c, overwrites, *i);
-                       if (ret)
-                               goto err;
-               }
-
-       *overwrites = overwrites2;
-out:
-       darray_exit(&overwrites2);
-       return ret;
-err:
-       darray_exit(overwrites);
-       goto out;
-}
-
 int __bch2_insert_snapshot_whiteouts(struct btree_trans *trans,
-                                  enum btree_id btree,
+                                  enum btree_id id,
                                   struct bpos old_pos,
                                   struct bpos new_pos)
 {
        struct bch_fs *c = trans->c;
-       snapshot_id_list old_overwrites, new_overwrites, updates;
-       bool began_transaction = false;
-       u32 *i;
+       struct btree_iter old_iter, new_iter;
+       struct bkey_s_c old_k, new_k;
+       snapshot_id_list s;
+       struct bkey_i *update;
        int ret;
 
        if (!bch2_snapshot_has_children(c, old_pos.snapshot))
                return 0;
 
-       darray_init(&old_overwrites);
-       darray_init(&new_overwrites);
-       darray_init(&updates);
+       darray_init(&s);
 
-       ret =   get_snapshot_overwrites(trans, btree, old_pos, &old_overwrites) ?:
-               get_snapshot_overwrites(trans, btree, new_pos, &new_overwrites);
-       if (ret)
-               goto err;
-
-       darray_for_each(old_overwrites, i)
-               if (!snapshot_list_has_ancestor(c, &new_overwrites, *i)) {
-                       ret = darray_push(&updates, *i);
-                       if (ret)
-                               goto err;
-               }
-
-       if (updates.nr > 4) {
-               bch2_trans_begin(trans);
-               began_transaction = true;
-       }
-
-       darray_for_each(updates, i) {
-               struct btree_iter iter;
-               struct bkey_i *update;
+       bch2_trans_iter_init(trans, &old_iter, id, old_pos,
+                            BTREE_ITER_NOT_EXTENTS|
+                            BTREE_ITER_ALL_SNAPSHOTS);
+       while ((old_k = bch2_btree_iter_prev(&old_iter)).k &&
+              !(ret = bkey_err(old_k)) &&
+              bkey_eq(old_pos, old_k.k->p)) {
+               struct bpos whiteout_pos =
+                       SPOS(new_pos.inode, new_pos.offset, old_k.k->p.snapshot);;
+
+               if (!bch2_snapshot_is_ancestor(c, old_k.k->p.snapshot, old_pos.snapshot) ||
+                   snapshot_list_has_ancestor(c, &s, old_k.k->p.snapshot))
+                       continue;
 
-               bch2_trans_iter_init(trans, &iter, btree,
-                                    SPOS(new_pos.inode, new_pos.offset, *i),
-                                    BTREE_ITER_NOT_EXTENTS|
-                                    BTREE_ITER_INTENT);
-               update = bch2_trans_kmalloc(trans, sizeof(struct bkey_i));
-               ret = PTR_ERR_OR_ZERO(update);
+               new_k = bch2_bkey_get_iter(trans, &new_iter, id, whiteout_pos,
+                                          BTREE_ITER_NOT_EXTENTS|
+                                          BTREE_ITER_INTENT);
+               ret = bkey_err(new_k);
                if (ret)
                        break;
 
-               bkey_init(&update->k);
-               update->k.p             = iter.pos;
-               update->k.type          = KEY_TYPE_whiteout;
-
-               ret   = bch2_btree_iter_traverse(&iter) ?:
-                       bch2_trans_update(trans, &iter, update,
-                                         BTREE_UPDATE_INTERNAL_SNAPSHOT_NODE) ?:
-                       (began_transaction && trans->nr_updates > 4
-                        ? bch2_trans_commit(trans, NULL, NULL, BTREE_INSERT_NOFAIL) : 0);
+               if (new_k.k->type == KEY_TYPE_deleted) {
+                       update = bch2_trans_kmalloc(trans, sizeof(struct bkey_i));
+                       ret = PTR_ERR_OR_ZERO(update);
+                       if (ret)
+                               break;
 
-               bch2_trans_iter_exit(trans, &iter);
+                       bkey_init(&update->k);
+                       update->k.p             = whiteout_pos;
+                       update->k.type          = KEY_TYPE_whiteout;
 
-               if (ret)
-                       goto err;
-       }
+                       ret = bch2_trans_update(trans, &new_iter, update,
+                                               BTREE_UPDATE_INTERNAL_SNAPSHOT_NODE);
+               }
+               bch2_trans_iter_exit(trans, &new_iter);
 
-       if (began_transaction && trans->nr_updates) {
-               ret = bch2_trans_commit(trans, NULL, NULL, BTREE_INSERT_NOFAIL);
+               ret = snapshot_list_add(c, &s, old_k.k->p.snapshot);
                if (ret)
-                       goto err;
+                       break;
        }
-
-       if (began_transaction)
-               ret = -BCH_ERR_transaction_restart_nested;
-err:
-       darray_exit(&updates);
-       darray_exit(&new_overwrites);
-       darray_exit(&old_overwrites);
+       bch2_trans_iter_exit(trans, &old_iter);
+       darray_exit(&s);
 
        return ret;
 }

diff --git a/libbcachefs/btree_write_buffer.c b/libbcachefs/btree_write_buffer.c
index 9983a47853b91b66b3e466990a573eddb0b22bb6..88c4b50dd70fa0987e19fbf9fe8e33cf897e6d79 100644 (file)
--- a/libbcachefs/btree_write_buffer.c
+++ b/libbcachefs/btree_write_buffer.c
@@ -78,6 +78,7 @@ trans_commit:
        return  bch2_trans_update(trans, iter, &wb->k, 0) ?:
                bch2_trans_commit(trans, NULL, NULL,
                                  commit_flags|
+                                 BTREE_INSERT_NOCHECK_RW|
                                  BTREE_INSERT_NOFAIL|
                                  BTREE_INSERT_JOURNAL_RECLAIM);
 }

diff --git a/libbcachefs/subvolume.c b/libbcachefs/subvolume.c
index f07b3e2b3226a0c7918ce7032f08509c28adc2f2..4b6631c229ee0233117479905e099797d2da35bb 100644 (file)
--- a/libbcachefs/subvolume.c
+++ b/libbcachefs/subvolume.c
@@ -86,13 +86,14 @@ void bch2_snapshot_to_text(struct printbuf *out, struct bch_fs *c,
 {
        struct bkey_s_c_snapshot s = bkey_s_c_to_snapshot(k);
 
-       prt_printf(out, "is_subvol %llu deleted %llu parent %10u children %10u %10u subvol %u",
+       prt_printf(out, "is_subvol %llu deleted %llu parent %10u children %10u %10u subvol %u tree %u",
               BCH_SNAPSHOT_SUBVOL(s.v),
               BCH_SNAPSHOT_DELETED(s.v),
               le32_to_cpu(s.v->parent),
               le32_to_cpu(s.v->children[0]),
               le32_to_cpu(s.v->children[1]),
-              le32_to_cpu(s.v->subvol));
+              le32_to_cpu(s.v->subvol),
+              le32_to_cpu(s.v->tree));
 }
 
 int bch2_snapshot_invalid(const struct bch_fs *c, struct bkey_s_c k,

diff --git a/libbcachefs/subvolume.h b/libbcachefs/subvolume.h
index f884a20332300e3ad814adf3c0c3a56af77037df..1a39f713db87c8731778d297f045a946c6835904 100644 (file)
--- a/libbcachefs/subvolume.h
+++ b/libbcachefs/subvolume.h
@@ -121,7 +121,7 @@ static inline int snapshot_list_add(struct bch_fs *c, snapshot_id_list *s, u32 i
 {
        int ret;
 
-       EBUG_ON(snapshot_list_has_id(s, id));
+       BUG_ON(snapshot_list_has_id(s, id));
        ret = darray_push(s, id);
        if (ret)
                bch_err(c, "error reallocating snapshot_id_list (size %zu)", s->size);

diff --git a/libbcachefs/super.c b/libbcachefs/super.c
index a659f8068d42cfab2dedfcd7580e3acef23930c8..2754f023032c6a656ef45a0e1d92faacbbead1aa 100644 (file)
--- a/libbcachefs/super.c
+++ b/libbcachefs/super.c
@@ -302,6 +302,11 @@ void bch2_fs_read_only(struct bch_fs *c)
            test_bit(BCH_FS_STARTED, &c->flags) &&
            test_bit(BCH_FS_CLEAN_SHUTDOWN, &c->flags) &&
            !c->opts.norecovery) {
+               BUG_ON(c->journal.last_empty_seq != journal_cur_seq(&c->journal));
+               BUG_ON(atomic_read(&c->btree_cache.dirty));
+               BUG_ON(atomic_long_read(&c->btree_key_cache.nr_dirty));
+               BUG_ON(c->btree_write_buffer.state.nr);
+
                bch_verbose(c, "marking filesystem clean");
                bch2_fs_mark_clean(c);
        }