int bch2_alloc_read(struct bch_fs *c, struct list_head *journal_replay_list)
{
struct journal_replay *r;
- struct btree_iter iter;
+ struct btree_trans trans;
+ struct btree_iter *iter;
struct bkey_s_c k;
struct bch_dev *ca;
unsigned i;
int ret;
- for_each_btree_key(&iter, c, BTREE_ID_ALLOC, POS_MIN, 0, k) {
+ bch2_trans_init(&trans, c);
+
+ for_each_btree_key(&trans, iter, BTREE_ID_ALLOC, POS_MIN, 0, k) {
bch2_alloc_read_key(c, k);
- bch2_btree_iter_cond_resched(&iter);
+ bch2_trans_cond_resched(&trans);
}
- ret = bch2_btree_iter_unlock(&iter);
+ ret = bch2_trans_exit(&trans);
if (ret)
return ret;
__alloc_write_key(a, g, m);
percpu_up_read(&c->mark_lock);
- bch2_btree_iter_cond_resched(iter);
-
bch2_trans_update(trans, BTREE_INSERT_ENTRY(iter, &a->k_i));
ret = bch2_trans_commit(trans, NULL, journal_seq,
if (ret)
break;
+ bch2_trans_cond_resched(&trans);
*wrote = true;
}
up_read(&ca->bucket_lock);
spin_unlock(&c->freelist_lock);
percpu_up_read(&c->mark_lock);
- bch2_btree_iter_cond_resched(iter);
-
BUG_ON(BKEY_ALLOC_VAL_U64s_MAX > 8);
bch2_btree_iter_set_pos(iter, POS(ca->dev_idx, b));
static int bch2_gc_btree(struct bch_fs *c, enum btree_id btree_id,
bool initial)
{
- struct btree_iter iter;
+ struct btree_trans trans;
+ struct btree_iter *iter;
struct btree *b;
struct range_checks r;
unsigned depth = btree_node_type_needs_gc(btree_id) ? 0 : 1;
u8 max_stale;
int ret = 0;
+ bch2_trans_init(&trans, c);
+
gc_pos_set(c, gc_pos_btree(btree_id, POS_MIN, 0));
/*
btree_node_range_checks_init(&r, depth);
- __for_each_btree_node(&iter, c, btree_id, POS_MIN,
+ __for_each_btree_node(&trans, iter, btree_id, POS_MIN,
0, depth, BTREE_ITER_PREFETCH, b) {
btree_node_range_checks(c, b, &r);
if (!initial) {
if (max_stale > 64)
- bch2_btree_node_rewrite(c, &iter,
+ bch2_btree_node_rewrite(c, iter,
b->data->keys.seq,
BTREE_INSERT_USE_RESERVE|
BTREE_INSERT_NOWAIT|
BTREE_INSERT_GC_LOCK_HELD);
else if (!btree_gc_rewrite_disabled(c) &&
(btree_gc_always_rewrite(c) || max_stale > 16))
- bch2_btree_node_rewrite(c, &iter,
+ bch2_btree_node_rewrite(c, iter,
b->data->keys.seq,
BTREE_INSERT_NOWAIT|
BTREE_INSERT_GC_LOCK_HELD);
}
- bch2_btree_iter_cond_resched(&iter);
+ bch2_trans_cond_resched(&trans);
}
- ret = bch2_btree_iter_unlock(&iter) ?: ret;
+ ret = bch2_trans_exit(&trans) ?: ret;
if (ret)
return ret;
static int bch2_coalesce_btree(struct bch_fs *c, enum btree_id btree_id)
{
- struct btree_iter iter;
+ struct btree_trans trans;
+ struct btree_iter *iter;
struct btree *b;
bool kthread = (current->flags & PF_KTHREAD) != 0;
unsigned i;
struct btree *merge[GC_MERGE_NODES];
u32 lock_seq[GC_MERGE_NODES];
+ bch2_trans_init(&trans, c);
+
/*
* XXX: We don't have a good way of positively matching on sibling nodes
* that have the same parent - this code works by handling the cases
*/
memset(merge, 0, sizeof(merge));
- __for_each_btree_node(&iter, c, btree_id, POS_MIN,
+ __for_each_btree_node(&trans, iter, btree_id, POS_MIN,
BTREE_MAX_DEPTH, 0,
BTREE_ITER_PREFETCH, b) {
memmove(merge + 1, merge,
}
memset(merge + i, 0, (GC_MERGE_NODES - i) * sizeof(merge[0]));
- bch2_coalesce_nodes(c, &iter, merge);
+ bch2_coalesce_nodes(c, iter, merge);
for (i = 1; i < GC_MERGE_NODES && merge[i]; i++) {
lock_seq[i] = merge[i]->lock.state.seq;
lock_seq[0] = merge[0]->lock.state.seq;
if (kthread && kthread_should_stop()) {
- bch2_btree_iter_unlock(&iter);
+ bch2_trans_exit(&trans);
return -ESHUTDOWN;
}
- bch2_btree_iter_cond_resched(&iter);
+ bch2_trans_cond_resched(&trans);
/*
* If the parent node wasn't relocked, it might have been split
* and the nodes in our sliding window might not have the same
* parent anymore - blow away the sliding window:
*/
- if (btree_iter_node(&iter, iter.level + 1) &&
- !btree_node_intent_locked(&iter, iter.level + 1))
+ if (btree_iter_node(iter, iter->level + 1) &&
+ !btree_node_intent_locked(iter, iter->level + 1))
memset(merge + 1, 0,
(GC_MERGE_NODES - 1) * sizeof(merge[0]));
}
- return bch2_btree_iter_unlock(&iter);
+ return bch2_trans_exit(&trans);
}
/**
struct bkey_i_btree_ptr *new_key;
struct bkey_s_btree_ptr bp;
struct bch_extent_ptr *ptr;
- struct btree_iter iter;
+ struct btree_trans trans;
+ struct btree_iter *iter;
int ret;
- __bch2_btree_iter_init(&iter, c, b->btree_id, b->key.k.p,
- BTREE_MAX_DEPTH,
- b->level, BTREE_ITER_NODES);
+ bch2_trans_init(&trans, c);
+
+ iter = bch2_trans_get_node_iter(&trans, b->btree_id, b->key.k.p,
+ BTREE_MAX_DEPTH, b->level, 0);
retry:
- ret = bch2_btree_iter_traverse(&iter);
+ ret = bch2_btree_iter_traverse(iter);
if (ret)
goto err;
/* has node been freed? */
- if (iter.l[b->level].b != b) {
+ if (iter->l[b->level].b != b) {
/* node has been freed: */
BUG_ON(!btree_node_dying(b));
goto out;
if (!bch2_bkey_nr_ptrs(bp.s_c))
goto err;
- ret = bch2_btree_node_update_key(c, &iter, b, new_key);
+ ret = bch2_btree_node_update_key(c, iter, b, new_key);
if (ret == -EINTR)
goto retry;
if (ret)
goto err;
out:
- bch2_btree_iter_unlock(&iter);
+ bch2_trans_exit(&trans);
bio_put(&wbio->wbio.bio);
btree_node_write_done(c, b);
return;
return __bch2_btree_iter_peek_slot(iter);
}
-void __bch2_btree_iter_init(struct btree_iter *iter, struct bch_fs *c,
- enum btree_id btree_id, struct bpos pos,
- unsigned locks_want, unsigned depth,
- unsigned flags)
+static inline void bch2_btree_iter_init(struct btree_iter *iter,
+ struct bch_fs *c, enum btree_id btree_id,
+ struct bpos pos, unsigned flags)
{
unsigned i;
- EBUG_ON(depth >= BTREE_MAX_DEPTH);
- EBUG_ON(locks_want > BTREE_MAX_DEPTH);
+ if (btree_id == BTREE_ID_EXTENTS &&
+ !(flags & BTREE_ITER_NODES))
+ flags |= BTREE_ITER_IS_EXTENTS;
iter->c = c;
iter->pos = pos;
iter->flags = flags;
iter->uptodate = BTREE_ITER_NEED_TRAVERSE;
iter->btree_id = btree_id;
- iter->level = depth;
- iter->locks_want = locks_want;
+ iter->level = 0;
+ iter->locks_want = flags & BTREE_ITER_INTENT ? 1 : 0;
iter->nodes_locked = 0;
iter->nodes_intent_locked = 0;
for (i = 0; i < ARRAY_SIZE(iter->l); i++)
return idx;
}
-void bch2_trans_iter_put(struct btree_trans *trans,
- struct btree_iter *iter)
+int bch2_trans_iter_put(struct btree_trans *trans,
+ struct btree_iter *iter)
{
ssize_t idx = btree_trans_iter_idx(trans, iter);
+ int ret = (iter->flags & BTREE_ITER_ERROR) ? -EIO : 0;
trans->iters_live &= ~(1ULL << idx);
+ return ret;
}
static inline void __bch2_trans_iter_free(struct btree_trans *trans,
bch2_btree_iter_unlink(&trans->iters[idx]);
}
-void bch2_trans_iter_free(struct btree_trans *trans,
- struct btree_iter *iter)
+int bch2_trans_iter_free(struct btree_trans *trans,
+ struct btree_iter *iter)
{
+ int ret = (iter->flags & BTREE_ITER_ERROR) ? -EIO : 0;
+
__bch2_trans_iter_free(trans, btree_trans_iter_idx(trans, iter));
+ return ret;
}
-void bch2_trans_iter_free_on_commit(struct btree_trans *trans,
- struct btree_iter *iter)
+int bch2_trans_iter_free_on_commit(struct btree_trans *trans,
+ struct btree_iter *iter)
{
+ int ret = (iter->flags & BTREE_ITER_ERROR) ? -EIO : 0;
+
trans->iters_unlink_on_commit |=
1ULL << btree_trans_iter_idx(trans, iter);
+ return ret;
}
static int btree_trans_realloc_iters(struct btree_trans *trans,
iter = &trans->iters[idx];
iter->id = iter_id;
- bch2_btree_iter_init(iter, trans->c, btree_id, POS_MIN, flags);
+ bch2_btree_iter_init(iter, trans->c, btree_id, pos, flags);
} else {
iter = &trans->iters[idx];
return iter;
}
+struct btree_iter *bch2_trans_get_node_iter(struct btree_trans *trans,
+ enum btree_id btree_id,
+ struct bpos pos,
+ unsigned locks_want,
+ unsigned depth,
+ unsigned flags)
+{
+ struct btree_iter *iter =
+ __btree_trans_get_iter(trans, btree_id, pos,
+ flags|BTREE_ITER_NODES, 0);
+ unsigned i;
+
+ BUG_ON(IS_ERR(iter));
+ BUG_ON(bkey_cmp(iter->pos, pos));
+
+ iter->locks_want = locks_want;
+ iter->level = depth;
+
+ for (i = 0; i < ARRAY_SIZE(iter->l); i++)
+ iter->l[i].b = NULL;
+ iter->l[iter->level].b = BTREE_ITER_NOT_END;
+
+ return iter;
+}
+
struct btree_iter *__bch2_trans_copy_iter(struct btree_trans *trans,
struct btree_iter *src,
u64 iter_id)
void bch2_btree_iter_set_pos_same_leaf(struct btree_iter *, struct bpos);
void bch2_btree_iter_set_pos(struct btree_iter *, struct bpos);
-void __bch2_btree_iter_init(struct btree_iter *, struct bch_fs *,
- enum btree_id, struct bpos,
- unsigned , unsigned, unsigned);
-
-static inline void bch2_btree_iter_init(struct btree_iter *iter,
- struct bch_fs *c, enum btree_id btree_id,
- struct bpos pos, unsigned flags)
-{
- __bch2_btree_iter_init(iter, c, btree_id, pos,
- flags & BTREE_ITER_INTENT ? 1 : 0, 0,
- (btree_id == BTREE_ID_EXTENTS
- ? BTREE_ITER_IS_EXTENTS : 0)|flags);
-}
-
void bch2_btree_iter_copy(struct btree_iter *, struct btree_iter *);
static inline struct bpos btree_type_successor(enum btree_id id,
}
}
-#define __for_each_btree_node(_iter, _c, _btree_id, _start, \
+#define __for_each_btree_node(_trans, _iter, _btree_id, _start, \
_locks_want, _depth, _flags, _b) \
- for (__bch2_btree_iter_init((_iter), (_c), (_btree_id), _start, \
- _locks_want, _depth, \
- _flags|BTREE_ITER_NODES), \
+ for (iter = bch2_trans_get_node_iter((_trans), (_btree_id), \
+ _start, _locks_want, _depth, _flags), \
_b = bch2_btree_iter_peek_node(_iter); \
(_b); \
(_b) = bch2_btree_iter_next_node(_iter, _depth))
-#define for_each_btree_node(_iter, _c, _btree_id, _start, _flags, _b) \
- __for_each_btree_node(_iter, _c, _btree_id, _start, 0, 0, _flags, _b)
+#define for_each_btree_node(_trans, _iter, _btree_id, _start, \
+ _flags, _b) \
+ __for_each_btree_node(_trans, _iter, _btree_id, _start, \
+ 0, 0, _flags, _b)
static inline struct bkey_s_c __bch2_btree_iter_peek(struct btree_iter *iter,
unsigned flags)
: bch2_btree_iter_next(iter);
}
-#define for_each_btree_key(_iter, _c, _btree_id, _start, _flags, _k) \
- for (bch2_btree_iter_init((_iter), (_c), (_btree_id), \
- (_start), (_flags)), \
+#define for_each_btree_key(_trans, _iter, _btree_id, _start, _flags, _k)\
+ for (iter = bch2_trans_get_iter((_trans), (_btree_id), \
+ (_start), (_flags)), \
(_k) = __bch2_btree_iter_peek(_iter, _flags); \
!IS_ERR_OR_NULL((_k).k); \
(_k) = __bch2_btree_iter_next(_iter, _flags))
/* new multiple iterator interface: */
void bch2_trans_preload_iters(struct btree_trans *);
-void bch2_trans_iter_put(struct btree_trans *, struct btree_iter *);
-void bch2_trans_iter_free(struct btree_trans *, struct btree_iter *);
-void bch2_trans_iter_free_on_commit(struct btree_trans *, struct btree_iter *);
+int bch2_trans_iter_put(struct btree_trans *, struct btree_iter *);
+int bch2_trans_iter_free(struct btree_trans *, struct btree_iter *);
+int bch2_trans_iter_free_on_commit(struct btree_trans *, struct btree_iter *);
void bch2_trans_unlink_iters(struct btree_trans *, u64);
return __bch2_trans_copy_iter(trans, src, __btree_iter_id());
}
+struct btree_iter *bch2_trans_get_node_iter(struct btree_trans *,
+ enum btree_id, struct bpos,
+ unsigned, unsigned, unsigned);
+
void __bch2_trans_begin(struct btree_trans *);
static inline void bch2_trans_begin_updates(struct btree_trans *trans)
void bch2_trans_init(struct btree_trans *, struct bch_fs *);
int bch2_trans_exit(struct btree_trans *);
+static inline void bch2_trans_cond_resched(struct btree_trans *trans)
+{
+ if (need_resched()) {
+ bch2_trans_unlock(trans);
+ schedule();
+ } else if (race_fault()) {
+ bch2_trans_unlock(trans);
+ }
+}
+
#ifdef TRACE_TRANSACTION_RESTARTS
#define bch2_trans_begin(_trans) \
do { \
if (ret)
break;
- bch2_btree_iter_cond_resched(iter);
+ bch2_trans_cond_resched(&trans);
}
bch2_trans_exit(&trans);
struct bch_ioctl_data_event e = {
.type = BCH_DATA_EVENT_PROGRESS,
.p.data_type = ctx->stats.data_type,
- .p.btree_id = ctx->stats.iter.btree_id,
- .p.pos = ctx->stats.iter.pos,
+ .p.btree_id = ctx->stats.btree_id,
+ .p.pos = ctx->stats.pos,
.p.sectors_done = atomic64_read(&ctx->stats.sectors_seen),
.p.sectors_total = bch2_fs_usage_read_short(c).used,
};
size_t size, loff_t *ppos)
{
struct dump_iter *i = file->private_data;
- struct btree_iter iter;
+ struct btree_trans trans;
+ struct btree_iter *iter;
struct bkey_s_c k;
int err;
if (!i->size)
return i->ret;
- bch2_btree_iter_init(&iter, i->c, i->id, i->from, BTREE_ITER_PREFETCH);
- k = bch2_btree_iter_peek(&iter);
+ bch2_trans_init(&trans, i->c);
+
+ iter = bch2_trans_get_iter(&trans, i->id, i->from, BTREE_ITER_PREFETCH);
+ k = bch2_btree_iter_peek(iter);
while (k.k && !(err = btree_iter_err(k))) {
bch2_bkey_val_to_text(&PBUF(i->buf), i->c, k);
i->buf[i->bytes] = '\n';
i->bytes++;
- k = bch2_btree_iter_next(&iter);
- i->from = iter.pos;
+ k = bch2_btree_iter_next(iter);
+ i->from = iter->pos;
err = flush_buf(i);
if (err)
if (!i->size)
break;
}
- bch2_btree_iter_unlock(&iter);
+ bch2_trans_exit(&trans);
return err < 0 ? err : i->ret;
}
size_t size, loff_t *ppos)
{
struct dump_iter *i = file->private_data;
- struct btree_iter iter;
+ struct btree_trans trans;
+ struct btree_iter *iter;
struct btree *b;
int err;
if (!i->size || !bkey_cmp(POS_MAX, i->from))
return i->ret;
- for_each_btree_node(&iter, i->c, i->id, i->from, 0, b) {
+ bch2_trans_init(&trans, i->c);
+
+ for_each_btree_node(&trans, iter, i->id, i->from, 0, b) {
bch2_btree_node_to_text(&PBUF(i->buf), i->c, b);
i->bytes = strlen(i->buf);
err = flush_buf(i);
if (!i->size)
break;
}
- bch2_btree_iter_unlock(&iter);
+ bch2_trans_exit(&trans);
return err < 0 ? err : i->ret;
}
size_t size, loff_t *ppos)
{
struct dump_iter *i = file->private_data;
- struct btree_iter iter;
+ struct btree_trans trans;
+ struct btree_iter *iter;
struct bkey_s_c k;
struct btree *prev_node = NULL;
int err;
if (!i->size)
return i->ret;
- bch2_btree_iter_init(&iter, i->c, i->id, i->from, BTREE_ITER_PREFETCH);
+ bch2_trans_init(&trans, i->c);
+
+ iter = bch2_trans_get_iter(&trans, i->id, i->from, BTREE_ITER_PREFETCH);
- while ((k = bch2_btree_iter_peek(&iter)).k &&
+ while ((k = bch2_btree_iter_peek(iter)).k &&
!(err = btree_iter_err(k))) {
- struct btree_iter_level *l = &iter.l[0];
+ struct btree_iter_level *l = &iter->l[0];
struct bkey_packed *_k =
bch2_btree_node_iter_peek(&l->iter, l->b);
if (err)
break;
- bch2_btree_iter_next(&iter);
- i->from = iter.pos;
+ bch2_btree_iter_next(iter);
+ i->from = iter->pos;
err = flush_buf(i);
if (err)
if (!i->size)
break;
}
- bch2_btree_iter_unlock(&iter);
+ bch2_trans_exit(&trans);
return err < 0 ? err : i->ret;
}
int bch2_empty_dir(struct bch_fs *c, u64 dir_inum)
{
- struct btree_iter iter;
+ struct btree_trans trans;
+ struct btree_iter *iter;
struct bkey_s_c k;
int ret = 0;
- for_each_btree_key(&iter, c, BTREE_ID_DIRENTS, POS(dir_inum, 0), 0, k) {
+ bch2_trans_init(&trans, c);
+
+ for_each_btree_key(&trans, iter, BTREE_ID_DIRENTS,
+ POS(dir_inum, 0), 0, k) {
if (k.k->p.inode > dir_inum)
break;
break;
}
}
- bch2_btree_iter_unlock(&iter);
+ bch2_trans_exit(&trans);
return ret;
}
struct dir_context *ctx)
{
struct bch_inode_info *inode = file_bch_inode(file);
- struct btree_iter iter;
+ struct btree_trans trans;
+ struct btree_iter *iter;
struct bkey_s_c k;
struct bkey_s_c_dirent dirent;
unsigned len;
if (!dir_emit_dots(file, ctx))
return 0;
- for_each_btree_key(&iter, c, BTREE_ID_DIRENTS,
+ bch2_trans_init(&trans, c);
+
+ for_each_btree_key(&trans, iter, BTREE_ID_DIRENTS,
POS(inode->v.i_ino, ctx->pos), 0, k) {
if (k.k->type != KEY_TYPE_dirent)
continue;
ctx->pos = k.k->p.offset + 1;
}
- bch2_btree_iter_unlock(&iter);
+ bch2_trans_exit(&trans);
return 0;
}
/* recovery read path: */
int bch2_ec_read_extent(struct bch_fs *c, struct bch_read_bio *rbio)
{
- struct btree_iter iter;
+ struct btree_trans trans;
+ struct btree_iter *iter;
struct ec_stripe_buf *buf;
struct closure cl;
struct bkey_s_c k;
if (!buf)
return -ENOMEM;
- bch2_btree_iter_init(&iter, c, BTREE_ID_EC,
- POS(0, stripe_idx),
- BTREE_ITER_SLOTS);
- k = bch2_btree_iter_peek_slot(&iter);
+ bch2_trans_init(&trans, c);
+
+ iter = bch2_trans_get_iter(&trans, BTREE_ID_EC,
+ POS(0, stripe_idx),
+ BTREE_ITER_SLOTS);
+ k = bch2_btree_iter_peek_slot(iter);
if (btree_iter_err(k) || k.k->type != KEY_TYPE_stripe) {
__bcache_io_error(c,
"error doing reconstruct read: stripe not found");
kfree(buf);
- return bch2_btree_iter_unlock(&iter) ?: -EIO;
+ return bch2_trans_exit(&trans) ?: -EIO;
}
bkey_reassemble(&buf->key.k_i, k);
- bch2_btree_iter_unlock(&iter);
+ bch2_trans_exit(&trans);
v = &buf->key.v;
int bch2_stripes_read(struct bch_fs *c, struct list_head *journal_replay_list)
{
struct journal_replay *r;
- struct btree_iter iter;
+ struct btree_trans trans;
+ struct btree_iter *iter;
struct bkey_s_c k;
int ret;
if (ret)
return ret;
- for_each_btree_key(&iter, c, BTREE_ID_EC, POS_MIN, 0, k) {
+ bch2_trans_init(&trans, c);
+
+ for_each_btree_key(&trans, iter, BTREE_ID_EC, POS_MIN, 0, k) {
bch2_stripe_read_key(c, k);
- bch2_btree_iter_cond_resched(&iter);
+ bch2_trans_cond_resched(&trans);
}
- ret = bch2_btree_iter_unlock(&iter);
+ ret = bch2_trans_exit(&trans);
if (ret)
return ret;
int bch2_ec_mem_alloc(struct bch_fs *c, bool gc)
{
- struct btree_iter iter;
+ struct btree_trans trans;
+ struct btree_iter *iter;
struct bkey_s_c k;
size_t i, idx = 0;
int ret = 0;
- bch2_btree_iter_init(&iter, c, BTREE_ID_EC, POS(0, U64_MAX), 0);
+ bch2_trans_init(&trans, c);
+
+ iter = bch2_trans_get_iter(&trans, BTREE_ID_EC, POS(0, U64_MAX), 0);
- k = bch2_btree_iter_prev(&iter);
+ k = bch2_btree_iter_prev(iter);
if (!IS_ERR_OR_NULL(k.k))
idx = k.k->p.offset + 1;
- ret = bch2_btree_iter_unlock(&iter);
+ ret = bch2_trans_exit(&trans);
if (ret)
return ret;
bool bch2_check_range_allocated(struct bch_fs *c, struct bpos pos, u64 size,
unsigned nr_replicas)
{
- struct btree_iter iter;
+ struct btree_trans trans;
+ struct btree_iter *iter;
struct bpos end = pos;
struct bkey_s_c k;
bool ret = true;
end.offset += size;
- for_each_btree_key(&iter, c, BTREE_ID_EXTENTS, pos,
- BTREE_ITER_SLOTS, k) {
+ bch2_trans_init(&trans, c);
+
+ for_each_btree_key(&trans, iter, BTREE_ID_EXTENTS, pos,
+ BTREE_ITER_SLOTS, k) {
if (bkey_cmp(bkey_start_pos(k.k), end) >= 0)
break;
break;
}
}
- bch2_btree_iter_unlock(&iter);
+ bch2_trans_exit(&trans);
return ret;
}
struct bch_inode_info *inode = to_bch_ei(ractl->mapping->host);
struct bch_fs *c = inode->v.i_sb->s_fs_info;
struct bch_io_opts opts = io_opts(c, inode);
- struct btree_iter iter;
+ struct btree_trans trans;
+ struct btree_iter *iter;
struct page *page;
struct readpages_iter readpages_iter;
int ret;
ret = readpages_iter_init(&readpages_iter, ractl);
BUG_ON(ret);
- bch2_btree_iter_init(&iter, c, BTREE_ID_EXTENTS, POS_MIN,
- BTREE_ITER_SLOTS);
+ bch2_trans_init(&trans, c);
+
+ iter = bch2_trans_get_iter(&trans, BTREE_ID_EXTENTS, POS_MIN,
+ BTREE_ITER_SLOTS);
bch2_pagecache_add_get(&inode->ei_pagecache_lock);
rbio->bio.bi_end_io = bch2_readpages_end_io;
__bio_add_page(&rbio->bio, page, PAGE_SIZE, 0);
- bchfs_read(c, &iter, rbio, inode->v.i_ino, &readpages_iter);
+ bchfs_read(c, iter, rbio, inode->v.i_ino, &readpages_iter);
}
bch2_pagecache_add_put(&inode->ei_pagecache_lock);
+
+ bch2_trans_exit(&trans);
kfree(readpages_iter.pages);
}
static void __bchfs_readpage(struct bch_fs *c, struct bch_read_bio *rbio,
u64 inum, struct page *page)
{
- struct btree_iter iter;
+ struct btree_trans trans;
+ struct btree_iter *iter;
page_state_init_for_read(page);
rbio->bio.bi_opf = REQ_OP_READ|REQ_SYNC;
bio_add_page_contig(&rbio->bio, page);
- bch2_btree_iter_init(&iter, c, BTREE_ID_EXTENTS, POS_MIN,
- BTREE_ITER_SLOTS);
- bchfs_read(c, &iter, rbio, inum, NULL);
+ bch2_trans_init(&trans, c);
+ iter = bch2_trans_get_iter(&trans, BTREE_ID_EXTENTS, POS_MIN,
+ BTREE_ITER_SLOTS);
+
+ bchfs_read(c, iter, rbio, inum, NULL);
+
+ bch2_trans_exit(&trans);
}
static void bch2_read_single_page_end_io(struct bio *bio)
if (ret)
break;
- bch2_btree_iter_cond_resched(iter);
+ bch2_trans_cond_resched(&trans);
}
bch2_trans_exit(&trans);
struct bpos start,
struct bpos end)
{
-
- struct btree_iter iter;
+ struct btree_trans trans;
+ struct btree_iter *iter;
struct bkey_s_c k;
int ret = 0;
- for_each_btree_key(&iter, c, BTREE_ID_EXTENTS,
- start, 0, k) {
+ bch2_trans_init(&trans, c);
+
+ for_each_btree_key(&trans, iter, BTREE_ID_EXTENTS, start, 0, k) {
if (bkey_cmp(bkey_start_pos(k.k), end) >= 0)
break;
}
}
- return bch2_btree_iter_unlock(&iter) ?: ret;
+ return bch2_trans_exit(&trans) ?: ret;
}
static int __bch2_truncate_page(struct bch_inode_info *inode,
* pointers... which isn't a _super_ serious problem...
*/
- bch2_btree_iter_cond_resched(src);
+ bch2_trans_cond_resched(&trans);
}
bch2_trans_unlock(&trans);
{
struct bch_inode_info *inode = file_bch_inode(file);
struct bch_fs *c = inode->v.i_sb->s_fs_info;
- struct btree_iter iter;
+ struct btree_trans trans;
+ struct btree_iter *iter;
struct bkey_s_c k;
u64 isize, next_data = MAX_LFS_FILESIZE;
int ret;
if (offset >= isize)
return -ENXIO;
- for_each_btree_key(&iter, c, BTREE_ID_EXTENTS,
+ bch2_trans_init(&trans, c);
+
+ for_each_btree_key(&trans, iter, BTREE_ID_EXTENTS,
POS(inode->v.i_ino, offset >> 9), 0, k) {
if (k.k->p.inode != inode->v.i_ino) {
break;
break;
}
- ret = bch2_btree_iter_unlock(&iter);
+ ret = bch2_trans_exit(&trans);
if (ret)
return ret;
{
struct bch_inode_info *inode = file_bch_inode(file);
struct bch_fs *c = inode->v.i_sb->s_fs_info;
- struct btree_iter iter;
+ struct btree_trans trans;
+ struct btree_iter *iter;
struct bkey_s_c k;
u64 isize, next_hole = MAX_LFS_FILESIZE;
int ret;
if (offset >= isize)
return -ENXIO;
- for_each_btree_key(&iter, c, BTREE_ID_EXTENTS,
+ bch2_trans_init(&trans, c);
+
+ for_each_btree_key(&trans, iter, BTREE_ID_EXTENTS,
POS(inode->v.i_ino, offset >> 9),
BTREE_ITER_SLOTS, k) {
if (k.k->p.inode != inode->v.i_ino) {
}
}
- ret = bch2_btree_iter_unlock(&iter);
+ ret = bch2_trans_exit(&trans);
if (ret)
return ret;
void *p)
{
struct bch_fs *c = trans->c;
- struct btree_iter *iter;
+ struct btree_iter *iter = NULL;
struct bkey_inode_buf *inode_p;
int ret;
{
struct bch_fs *c = vinode->i_sb->s_fs_info;
struct bch_inode_info *ei = to_bch_ei(vinode);
- struct btree_iter iter;
+ struct btree_trans trans;
+ struct btree_iter *iter;
struct bkey_s_c k;
BKEY_PADDED(k) tmp;
bool have_extent = false;
if (start + len < start)
return -EINVAL;
- for_each_btree_key(&iter, c, BTREE_ID_EXTENTS,
+ bch2_trans_init(&trans, c);
+
+ for_each_btree_key(&trans, iter, BTREE_ID_EXTENTS,
POS(ei->v.i_ino, start >> 9), 0, k)
if (bkey_extent_is_data(k.k) ||
k.k->type == KEY_TYPE_reservation) {
if (have_extent)
ret = bch2_fill_extent(info, &tmp.k, FIEMAP_EXTENT_LAST);
out:
- bch2_btree_iter_unlock(&iter);
+ bch2_trans_exit(&trans);
return ret < 0 ? ret : 0;
}
#define QSTR(n) { { { .len = strlen(n) } }, .name = n }
+static s64 bch2_count_inode_sectors(struct btree_trans *trans, u64 inum)
+{
+ struct btree_iter *iter;
+ struct bkey_s_c k;
+ u64 sectors = 0;
+
+ for_each_btree_key(trans, iter, BTREE_ID_EXTENTS, POS(inum, 0), 0, k) {
+ if (k.k->p.inode != inum)
+ break;
+
+ if (bkey_extent_is_allocation(k.k))
+ sectors += k.k->size;
+ }
+
+ return bch2_trans_iter_free(trans, iter) ?: sectors;
+}
+
static int remove_dirent(struct bch_fs *c, struct btree_iter *iter,
struct bkey_s_c_dirent dirent)
{
return ret;
}
-/* fsck hasn't been converted to new transactions yet: */
-static int fsck_hash_delete_at(const struct bch_hash_desc desc,
+static int fsck_hash_delete_at(struct btree_trans *trans,
+ const struct bch_hash_desc desc,
struct bch_hash_info *info,
- struct btree_iter *orig_iter)
+ struct btree_iter *iter)
{
- struct btree_trans trans;
- struct btree_iter *iter;
int ret;
-
- bch2_btree_iter_unlock(orig_iter);
-
- bch2_trans_init(&trans, orig_iter->c);
retry:
- bch2_trans_begin(&trans);
-
- iter = bch2_trans_copy_iter(&trans, orig_iter);
- if (IS_ERR(iter)) {
- ret = PTR_ERR(iter);
- goto err;
- }
-
- ret = bch2_hash_delete_at(&trans, desc, info, iter) ?:
- bch2_trans_commit(&trans, NULL, NULL,
+ ret = bch2_hash_delete_at(trans, desc, info, iter) ?:
+ bch2_trans_commit(trans, NULL, NULL,
BTREE_INSERT_ATOMIC|
BTREE_INSERT_NOFAIL|
BTREE_INSERT_LAZY_RW);
-err:
- if (ret == -EINTR)
- goto retry;
+ if (ret == -EINTR) {
+ ret = bch2_btree_iter_traverse(iter);
+ if (!ret)
+ goto retry;
+ }
- bch2_trans_exit(&trans);
return ret;
}
-static int hash_check_duplicates(const struct bch_hash_desc desc,
- struct hash_check *h, struct bch_fs *c,
- struct btree_iter *k_iter, struct bkey_s_c k)
+static int hash_check_duplicates(struct btree_trans *trans,
+ const struct bch_hash_desc desc, struct hash_check *h,
+ struct btree_iter *k_iter, struct bkey_s_c k)
{
+ struct bch_fs *c = trans->c;
struct btree_iter *iter;
struct bkey_s_c k2;
char buf[200];
"duplicate hash table keys:\n%s",
(bch2_bkey_val_to_text(&PBUF(buf), c,
k), buf))) {
- ret = fsck_hash_delete_at(desc, &h->info, k_iter);
+ ret = fsck_hash_delete_at(trans, desc, &h->info, k_iter);
if (ret)
return ret;
ret = 1;
hash <= k.k->p.offset;
}
-static int hash_check_key(const struct bch_hash_desc desc,
- struct btree_trans *trans, struct hash_check *h,
- struct btree_iter *k_iter, struct bkey_s_c k)
+static int hash_check_key(struct btree_trans *trans,
+ const struct bch_hash_desc desc, struct hash_check *h,
+ struct btree_iter *k_iter, struct bkey_s_c k)
{
struct bch_fs *c = trans->c;
char buf[200];
return 1;
}
- ret = hash_check_duplicates(desc, h, c, k_iter, k);
+ ret = hash_check_duplicates(trans, desc, h, k_iter, k);
fsck_err:
return ret;
}
static int check_extents(struct bch_fs *c)
{
struct inode_walker w = inode_walker_init();
- struct btree_iter iter;
+ struct btree_trans trans;
+ struct btree_iter *iter;
struct bkey_s_c k;
u64 i_sectors;
int ret = 0;
+ bch2_trans_init(&trans, c);
+
bch_verbose(c, "checking extents");
- for_each_btree_key(&iter, c, BTREE_ID_EXTENTS,
+ for_each_btree_key(&trans, iter, BTREE_ID_EXTENTS,
POS(BCACHEFS_ROOT_INO, 0), 0, k) {
ret = walk_inode(c, &w, k.k->p.inode);
if (ret)
!S_ISREG(w.inode.bi_mode) && !S_ISLNK(w.inode.bi_mode), c,
"extent type %u for non regular file, inode %llu mode %o",
k.k->type, k.k->p.inode, w.inode.bi_mode)) {
- bch2_btree_iter_unlock(&iter);
+ bch2_trans_unlock(&trans);
ret = bch2_inode_truncate(c, k.k->p.inode, 0);
if (ret)
w.have_inode &&
!(w.inode.bi_flags & BCH_INODE_I_SECTORS_DIRTY) &&
w.inode.bi_sectors !=
- (i_sectors = bch2_count_inode_sectors(c, w.cur_inum)),
+ (i_sectors = bch2_count_inode_sectors(&trans, w.cur_inum)),
c, "i_sectors wrong: got %llu, should be %llu",
w.inode.bi_sectors, i_sectors)) {
struct bkey_inode_buf p;
w.inode.bi_sectors = i_sectors;
- bch2_btree_iter_unlock(&iter);
+ bch2_trans_unlock(&trans);
bch2_inode_pack(&p, &w.inode);
}
/* revalidate iterator: */
- k = bch2_btree_iter_peek(&iter);
+ k = bch2_btree_iter_peek(iter);
}
if (fsck_err_on(w.have_inode &&
k.k->p.offset > round_up(w.inode.bi_size, PAGE_SIZE) >> 9, c,
"extent type %u offset %llu past end of inode %llu, i_size %llu",
k.k->type, k.k->p.offset, k.k->p.inode, w.inode.bi_size)) {
- bch2_btree_iter_unlock(&iter);
+ bch2_trans_unlock(&trans);
ret = bch2_inode_truncate(c, k.k->p.inode,
w.inode.bi_size);
}
err:
fsck_err:
- return bch2_btree_iter_unlock(&iter) ?: ret;
+ return bch2_trans_exit(&trans) ?: ret;
}
/*
if (w.first_this_inode && w.have_inode)
hash_check_set_inode(&h, c, &w.inode);
- ret = hash_check_key(bch2_xattr_hash_desc, &trans, &h, iter, k);
+ ret = hash_check_key(&trans, bch2_xattr_hash_desc,
+ &h, iter, k);
if (ret)
goto fsck_err;
}
struct inode_bitmap dirs_done = { NULL, 0 };
struct pathbuf path = { 0, 0, NULL };
struct pathbuf_entry *e;
- struct btree_iter iter;
+ struct btree_trans trans;
+ struct btree_iter *iter;
struct bkey_s_c k;
struct bkey_s_c_dirent dirent;
bool had_unreachable;
u64 d_inum;
int ret = 0;
+ bch2_trans_init(&trans, c);
+
bch_verbose(c, "checking directory structure");
/* DFS: */
if (e->offset == U64_MAX)
goto up;
- for_each_btree_key(&iter, c, BTREE_ID_DIRENTS,
+ for_each_btree_key(&trans, iter, BTREE_ID_DIRENTS,
POS(e->inum, e->offset + 1), 0, k) {
if (k.k->p.inode != e->inum)
break;
if (fsck_err_on(inode_bitmap_test(&dirs_done, d_inum), c,
"directory %llu has multiple hardlinks",
d_inum)) {
- ret = remove_dirent(c, &iter, dirent);
+ ret = remove_dirent(c, iter, dirent);
if (ret)
goto err;
continue;
goto err;
}
- bch2_btree_iter_unlock(&iter);
+ ret = bch2_trans_iter_free(&trans, iter);
+ if (ret) {
+ bch_err(c, "btree error %i in fsck", ret);
+ goto err;
+ }
goto next;
}
- ret = bch2_btree_iter_unlock(&iter);
+ ret = bch2_trans_iter_free(&trans, iter);
if (ret) {
bch_err(c, "btree error %i in fsck", ret);
goto err;
path.nr--;
}
- for_each_btree_key(&iter, c, BTREE_ID_INODES, POS_MIN, 0, k) {
+ for_each_btree_key(&trans, iter, BTREE_ID_INODES, POS_MIN, 0, k) {
if (k.k->type != KEY_TYPE_inode)
continue;
if (fsck_err_on(!inode_bitmap_test(&dirs_done, k.k->p.inode), c,
"unreachable directory found (inum %llu)",
k.k->p.inode)) {
- bch2_btree_iter_unlock(&iter);
+ bch2_btree_iter_unlock(iter);
ret = reattach_inode(c, lostfound_inode, k.k->p.inode);
if (ret) {
had_unreachable = true;
}
}
- ret = bch2_btree_iter_unlock(&iter);
+ ret = bch2_trans_iter_free(&trans, iter);
if (ret)
goto err;
return ret;
err:
fsck_err:
- ret = bch2_btree_iter_unlock(&iter) ?: ret;
+ ret = bch2_trans_exit(&trans) ?: ret;
goto out;
}
static int bch2_gc_walk_dirents(struct bch_fs *c, nlink_table *links,
u64 range_start, u64 *range_end)
{
- struct btree_iter iter;
+ struct btree_trans trans;
+ struct btree_iter *iter;
struct bkey_s_c k;
struct bkey_s_c_dirent d;
u64 d_inum;
int ret;
+ bch2_trans_init(&trans, c);
+
inc_link(c, links, range_start, range_end, BCACHEFS_ROOT_INO, false);
- for_each_btree_key(&iter, c, BTREE_ID_DIRENTS, POS_MIN, 0, k) {
+ for_each_btree_key(&trans, iter, BTREE_ID_DIRENTS, POS_MIN, 0, k) {
switch (k.k->type) {
case KEY_TYPE_dirent:
d = bkey_s_c_to_dirent(k);
break;
}
- bch2_btree_iter_cond_resched(&iter);
+ bch2_trans_cond_resched(&trans);
}
- ret = bch2_btree_iter_unlock(&iter);
+ ret = bch2_trans_exit(&trans);
if (ret)
bch_err(c, "error in fs gc: btree error %i while walking dirents", ret);
return ret;
}
-s64 bch2_count_inode_sectors(struct bch_fs *c, u64 inum)
-{
- struct btree_iter iter;
- struct bkey_s_c k;
- u64 sectors = 0;
-
- for_each_btree_key(&iter, c, BTREE_ID_EXTENTS, POS(inum, 0), 0, k) {
- if (k.k->p.inode != inum)
- break;
-
- if (bkey_extent_is_allocation(k.k))
- sectors += k.k->size;
- }
-
- return bch2_btree_iter_unlock(&iter) ?: sectors;
-}
-
static int check_inode_nlink(struct bch_fs *c,
struct bch_inode_unpacked *lostfound_inode,
struct bch_inode_unpacked *u,
bch_verbose(c, "recounting sectors for inode %llu",
u.bi_inum);
- sectors = bch2_count_inode_sectors(c, u.bi_inum);
+ sectors = bch2_count_inode_sectors(trans, u.bi_inum);
if (sectors < 0) {
bch_err(c, "error in fs gc: error %i "
"recounting inode sectors",
genradix_iter_advance(&nlinks_iter, links);
bch2_btree_iter_next(iter);
- bch2_btree_iter_cond_resched(iter);
+ bch2_trans_cond_resched(&trans);
}
fsck_err:
bch2_trans_exit(&trans);
#ifndef _BCACHEFS_FSCK_H
#define _BCACHEFS_FSCK_H
-s64 bch2_count_inode_sectors(struct bch_fs *, u64);
int bch2_fsck(struct bch_fs *);
#endif /* _BCACHEFS_FSCK_H */
int bch2_inode_find_by_inum(struct bch_fs *c, u64 inode_nr,
struct bch_inode_unpacked *inode)
{
- struct btree_iter iter;
+ struct btree_trans trans;
+ struct btree_iter *iter;
struct bkey_s_c k;
int ret = -ENOENT;
- for_each_btree_key(&iter, c, BTREE_ID_INODES,
- POS(inode_nr, 0),
- BTREE_ITER_SLOTS, k) {
+ bch2_trans_init(&trans, c);
+
+ for_each_btree_key(&trans, iter, BTREE_ID_INODES,
+ POS(inode_nr, 0), BTREE_ITER_SLOTS, k) {
switch (k.k->type) {
case KEY_TYPE_inode:
ret = bch2_inode_unpack(bkey_s_c_to_inode(k), inode);
break;
}
- return bch2_btree_iter_unlock(&iter) ?: ret;
+ return bch2_trans_exit(&trans) ?: ret;
}
#ifdef CONFIG_BCACHEFS_DEBUG
struct bch_io_failures *failed,
unsigned flags)
{
- struct btree_iter iter;
+ struct btree_trans trans;
+ struct btree_iter *iter;
BKEY_PADDED(k) tmp;
struct bkey_s_c k;
int ret;
flags &= ~BCH_READ_LAST_FRAGMENT;
- bch2_btree_iter_init(&iter, c, BTREE_ID_EXTENTS,
- rbio->pos, BTREE_ITER_SLOTS);
+ bch2_trans_init(&trans, c);
+
+ iter = bch2_trans_get_iter(&trans, BTREE_ID_EXTENTS,
+ rbio->pos, BTREE_ITER_SLOTS);
retry:
rbio->bio.bi_status = 0;
- k = bch2_btree_iter_peek_slot(&iter);
- if (btree_iter_err(k)) {
- bch2_btree_iter_unlock(&iter);
+ k = bch2_btree_iter_peek_slot(iter);
+ if (btree_iter_err(k))
goto err;
- }
bkey_reassemble(&tmp.k, k);
k = bkey_i_to_s_c(&tmp.k);
- bch2_btree_iter_unlock(&iter);
+ bch2_trans_unlock(&trans);
if (!bkey_extent_is_data(k.k) ||
!bch2_extent_matches_ptr(c, bkey_i_to_s_c_extent(&tmp.k),
goto retry;
if (ret)
goto err;
- goto out;
-err:
- rbio->bio.bi_status = BLK_STS_IOERR;
out:
bch2_rbio_done(rbio);
+ bch2_trans_exit(&trans);
+ return;
+err:
+ rbio->bio.bi_status = BLK_STS_IOERR;
+ goto out;
}
static void bch2_read_retry(struct bch_fs *c, struct bch_read_bio *rbio,
struct bvec_iter bvec_iter, u64 inode,
struct bch_io_failures *failed, unsigned flags)
{
- struct btree_iter iter;
+ struct btree_trans trans;
+ struct btree_iter *iter;
struct bkey_s_c k;
int ret;
+ bch2_trans_init(&trans, c);
+
flags &= ~BCH_READ_LAST_FRAGMENT;
flags |= BCH_READ_MUST_CLONE;
retry:
- for_each_btree_key(&iter, c, BTREE_ID_EXTENTS,
+ for_each_btree_key(&trans, iter, BTREE_ID_EXTENTS,
POS(inode, bvec_iter.bi_sector),
BTREE_ITER_SLOTS, k) {
BKEY_PADDED(k) tmp;
bkey_reassemble(&tmp.k, k);
k = bkey_i_to_s_c(&tmp.k);
- bch2_btree_iter_unlock(&iter);
+ bch2_btree_iter_unlock(iter);
bytes = min_t(unsigned, bvec_iter.bi_size,
(k.k->p.offset - bvec_iter.bi_sector) << 9);
* If we get here, it better have been because there was an error
* reading a btree node
*/
- ret = bch2_btree_iter_unlock(&iter);
- BUG_ON(!ret);
- __bcache_io_error(c, "btree IO error %i", ret);
+ BUG_ON(!(iter->flags & BTREE_ITER_ERROR));
+ __bcache_io_error(c, "btree IO error");
err:
rbio->bio.bi_status = BLK_STS_IOERR;
out:
+ bch2_trans_exit(&trans);
bch2_rbio_done(rbio);
}
void bch2_read(struct bch_fs *c, struct bch_read_bio *rbio, u64 inode)
{
- struct btree_iter iter;
+ struct btree_trans trans;
+ struct btree_iter *iter;
struct bkey_s_c k;
unsigned flags = BCH_READ_RETRY_IF_STALE|
BCH_READ_MAY_PROMOTE|
BCH_READ_USER_MAPPED;
- int ret;
+
+ bch2_trans_init(&trans, c);
BUG_ON(rbio->_state);
BUG_ON(flags & BCH_READ_NODECODE);
rbio->c = c;
rbio->start_time = local_clock();
- for_each_btree_key(&iter, c, BTREE_ID_EXTENTS,
+ for_each_btree_key(&trans, iter, BTREE_ID_EXTENTS,
POS(inode, rbio->bio.bi_iter.bi_sector),
BTREE_ITER_SLOTS, k) {
BKEY_PADDED(k) tmp;
*/
bkey_reassemble(&tmp.k, k);
k = bkey_i_to_s_c(&tmp.k);
- bch2_btree_iter_unlock(&iter);
+ bch2_btree_iter_unlock(iter);
bytes = min_t(unsigned, rbio->bio.bi_iter.bi_size,
(k.k->p.offset - rbio->bio.bi_iter.bi_sector) << 9);
* If we get here, it better have been because there was an error
* reading a btree node
*/
- ret = bch2_btree_iter_unlock(&iter);
- BUG_ON(!ret);
- bcache_io_error(c, &rbio->bio, "btree IO error %i", ret);
+ BUG_ON(!(iter->flags & BTREE_ITER_ERROR));
+ bcache_io_error(c, &rbio->bio, "btree IO error");
+
+ bch2_trans_exit(&trans);
bch2_rbio_done(rbio);
}
closure_init_stack(&cl);
for (i = 0;; i++) {
- struct btree_iter iter;
+ struct btree_trans trans;
+ struct btree_iter *iter;
struct btree *b;
+ bch2_trans_init(&trans, c);
+
mutex_lock(&j->blacklist_lock);
if (i >= bl->nr_entries) {
mutex_unlock(&j->blacklist_lock);
n = bl->entries[i];
mutex_unlock(&j->blacklist_lock);
- __bch2_btree_iter_init(&iter, c, n.btree_id, n.pos,
- 0, 0, BTREE_ITER_NODES);
+ iter = bch2_trans_get_node_iter(&trans, n.btree_id, n.pos,
+ 0, 0, 0);
- b = bch2_btree_iter_peek_node(&iter);
+ b = bch2_btree_iter_peek_node(iter);
/* The node might have already been rewritten: */
if (b->data->keys.seq == n.seq) {
- ret = bch2_btree_node_rewrite(c, &iter, n.seq, 0);
+ ret = bch2_btree_node_rewrite(c, iter, n.seq, 0);
if (ret) {
- bch2_btree_iter_unlock(&iter);
+ bch2_trans_exit(&trans);
bch2_fs_fatal_error(c,
"error %i rewriting btree node with blacklisted journal seq",
ret);
}
}
- bch2_btree_iter_unlock(&iter);
+ bch2_trans_exit(&trans);
}
for (i = 0;; i++) {
static int bch2_dev_metadata_drop(struct bch_fs *c, unsigned dev_idx, int flags)
{
- struct btree_iter iter;
+ struct btree_trans trans;
+ struct btree_iter *iter;
struct closure cl;
struct btree *b;
unsigned id;
if (flags & BCH_FORCE_IF_METADATA_LOST)
return -EINVAL;
+ bch2_trans_init(&trans, c);
closure_init_stack(&cl);
mutex_lock(&c->replicas_gc_lock);
bch2_replicas_gc_start(c, 1 << BCH_DATA_BTREE);
for (id = 0; id < BTREE_ID_NR; id++) {
- for_each_btree_node(&iter, c, id, POS_MIN, BTREE_ITER_PREFETCH, b) {
+ for_each_btree_node(&trans, iter, id, POS_MIN,
+ BTREE_ITER_PREFETCH, b) {
__BKEY_PADDED(k, BKEY_BTREE_PTR_VAL_U64s_MAX) tmp;
struct bkey_i_btree_ptr *new_key;
retry:
* but got -EINTR after upgrading the iter, but
* then raced and the node is now gone:
*/
- bch2_btree_iter_downgrade(&iter);
+ bch2_btree_iter_downgrade(iter);
ret = bch2_mark_bkey_replicas(c, bkey_i_to_s_c(&b->key));
if (ret)
if (ret)
goto err;
- ret = bch2_btree_node_update_key(c, &iter, b, new_key);
+ ret = bch2_btree_node_update_key(c, iter, b, new_key);
if (ret == -EINTR) {
- b = bch2_btree_iter_peek_node(&iter);
+ b = bch2_btree_iter_peek_node(iter);
goto retry;
}
if (ret)
goto err;
}
}
- bch2_btree_iter_unlock(&iter);
+ bch2_trans_iter_free(&trans, iter);
}
/* flush relevant btree updates */
}
ret = 0;
-out:
+err:
+ bch2_trans_exit(&trans);
+
ret = bch2_replicas_gc_end(c, ret);
mutex_unlock(&c->replicas_gc_lock);
return ret;
-err:
- bch2_btree_iter_unlock(&iter);
- goto out;
}
int bch2_dev_data_drop(struct bch_fs *c, unsigned dev_idx, int flags)
struct moving_context ctxt = { .stats = stats };
struct bch_io_opts io_opts = bch2_opts_to_inode_opts(c->opts);
BKEY_PADDED(k) tmp;
+ struct btree_trans trans;
+ struct btree_iter *iter;
struct bkey_s_c k;
struct data_opts data_opts;
enum data_cmd data_cmd;
INIT_LIST_HEAD(&ctxt.reads);
init_waitqueue_head(&ctxt.wait);
+ bch2_trans_init(&trans, c);
+
stats->data_type = BCH_DATA_USER;
- bch2_btree_iter_init(&stats->iter, c, BTREE_ID_EXTENTS, start,
- BTREE_ITER_PREFETCH);
+ stats->btree_id = BTREE_ID_EXTENTS;
+ stats->pos = POS_MIN;
+
+ iter = bch2_trans_get_iter(&trans, BTREE_ID_EXTENTS, start,
+ BTREE_ITER_PREFETCH);
if (rate)
bch2_ratelimit_reset(rate);
delay = rate ? bch2_ratelimit_delay(rate) : 0;
if (delay) {
- bch2_btree_iter_unlock(&stats->iter);
+ bch2_trans_unlock(&trans);
set_current_state(TASK_INTERRUPTIBLE);
}
schedule_timeout(delay);
if (unlikely(freezing(current))) {
- bch2_btree_iter_unlock(&stats->iter);
+ bch2_trans_unlock(&trans);
move_ctxt_wait_event(&ctxt, list_empty(&ctxt.reads));
try_to_freeze();
}
} while (delay);
peek:
- k = bch2_btree_iter_peek(&stats->iter);
+ k = bch2_btree_iter_peek(iter);
+
+ stats->pos = iter->pos;
+
if (!k.k)
break;
ret = btree_iter_err(k);
struct bch_inode_unpacked inode;
/* don't hold btree locks while looking up inode: */
- bch2_btree_iter_unlock(&stats->iter);
+ bch2_trans_unlock(&trans);
io_opts = bch2_opts_to_inode_opts(c->opts);
if (!bch2_inode_find_by_inum(c, k.k->p.inode, &inode))
/* unlock before doing IO: */
bkey_reassemble(&tmp.k, k);
k = bkey_i_to_s_c(&tmp.k);
- bch2_btree_iter_unlock(&stats->iter);
+ bch2_trans_unlock(&trans);
ret2 = bch2_move_extent(c, &ctxt, wp, io_opts,
bkey_s_c_to_extent(k),
atomic64_add(k.k->size * bch2_bkey_nr_dirty_ptrs(k),
&stats->sectors_seen);
next_nondata:
- bch2_btree_iter_next(&stats->iter);
- bch2_btree_iter_cond_resched(&stats->iter);
+ bch2_btree_iter_next(iter);
+ bch2_trans_cond_resched(&trans);
}
out:
- bch2_btree_iter_unlock(&stats->iter);
+ bch2_trans_exit(&trans);
move_ctxt_wait_event(&ctxt, list_empty(&ctxt.reads));
closure_sync(&ctxt.cl);
static int bch2_gc_data_replicas(struct bch_fs *c)
{
- struct btree_iter iter;
+ struct btree_trans trans;
+ struct btree_iter *iter;
struct bkey_s_c k;
int ret;
+ bch2_trans_init(&trans, c);
+
mutex_lock(&c->replicas_gc_lock);
bch2_replicas_gc_start(c, (1 << BCH_DATA_USER)|(1 << BCH_DATA_CACHED));
- for_each_btree_key(&iter, c, BTREE_ID_EXTENTS, POS_MIN,
+ for_each_btree_key(&trans, iter, BTREE_ID_EXTENTS, POS_MIN,
BTREE_ITER_PREFETCH, k) {
ret = bch2_mark_bkey_replicas(c, k);
if (ret)
break;
}
- ret = bch2_btree_iter_unlock(&iter) ?: ret;
+ ret = bch2_trans_exit(&trans) ?: ret;
bch2_replicas_gc_end(c, ret);
mutex_unlock(&c->replicas_gc_lock);
static int bch2_gc_btree_replicas(struct bch_fs *c)
{
- struct btree_iter iter;
+ struct btree_trans trans;
+ struct btree_iter *iter;
struct btree *b;
unsigned id;
int ret = 0;
+ bch2_trans_init(&trans, c);
+
mutex_lock(&c->replicas_gc_lock);
bch2_replicas_gc_start(c, 1 << BCH_DATA_BTREE);
for (id = 0; id < BTREE_ID_NR; id++) {
- for_each_btree_node(&iter, c, id, POS_MIN, BTREE_ITER_PREFETCH, b) {
+ for_each_btree_node(&trans, iter, id, POS_MIN,
+ BTREE_ITER_PREFETCH, b) {
ret = bch2_mark_bkey_replicas(c, bkey_i_to_s_c(&b->key));
- bch2_btree_iter_cond_resched(&iter);
+ bch2_trans_cond_resched(&trans);
}
- ret = bch2_btree_iter_unlock(&iter) ?: ret;
+ ret = bch2_trans_iter_free(&trans, iter) ?: ret;
}
+ bch2_trans_exit(&trans);
+
bch2_replicas_gc_end(c, ret);
mutex_unlock(&c->replicas_gc_lock);
struct bch_move_stats *stats)
{
struct bch_io_opts io_opts = bch2_opts_to_inode_opts(c->opts);
+ struct btree_trans trans;
+ struct btree_iter *iter;
struct btree *b;
unsigned id;
struct data_opts data_opts;
enum data_cmd cmd;
int ret = 0;
+ bch2_trans_init(&trans, c);
+
stats->data_type = BCH_DATA_BTREE;
for (id = 0; id < BTREE_ID_NR; id++) {
- for_each_btree_node(&stats->iter, c, id, POS_MIN, BTREE_ITER_PREFETCH, b) {
+ stats->btree_id = id;
+
+ for_each_btree_node(&trans, iter, id, POS_MIN,
+ BTREE_ITER_PREFETCH, b) {
+ stats->pos = iter->pos;
+
switch ((cmd = pred(c, arg,
bkey_i_to_s_c(&b->key),
&io_opts, &data_opts))) {
BUG();
}
- ret = bch2_btree_node_rewrite(c, &stats->iter,
+ ret = bch2_btree_node_rewrite(c, iter,
b->data->keys.seq, 0) ?: ret;
next:
- bch2_btree_iter_cond_resched(&stats->iter);
+ bch2_trans_cond_resched(&trans);
}
- ret = bch2_btree_iter_unlock(&stats->iter) ?: ret;
+ ret = bch2_trans_iter_free(&trans, iter) ?: ret;
}
+ bch2_trans_exit(&trans);
+
return ret;
}
struct bch_move_stats {
enum bch_data_type data_type;
- struct btree_iter iter;
+ enum btree_id btree_id;
+ struct bpos pos;
atomic64_t keys_moved;
atomic64_t sectors_moved;
static int bch2_quota_init_type(struct bch_fs *c, enum quota_types type)
{
- struct btree_iter iter;
+ struct btree_trans trans;
+ struct btree_iter *iter;
struct bkey_s_c k;
int ret = 0;
- for_each_btree_key(&iter, c, BTREE_ID_QUOTAS, POS(type, 0),
+ bch2_trans_init(&trans, c);
+
+ for_each_btree_key(&trans, iter, BTREE_ID_QUOTAS, POS(type, 0),
BTREE_ITER_PREFETCH, k) {
if (k.k->p.inode != type)
break;
break;
}
- return bch2_btree_iter_unlock(&iter) ?: ret;
+ return bch2_trans_exit(&trans) ?: ret;
}
void bch2_fs_quota_exit(struct bch_fs *c)
{
unsigned i, qtypes = enabled_qtypes(c);
struct bch_memquota_type *q;
- struct btree_iter iter;
+ struct btree_trans trans;
+ struct btree_iter *iter;
struct bch_inode_unpacked u;
struct bkey_s_c k;
int ret;
return ret;
}
- for_each_btree_key(&iter, c, BTREE_ID_INODES, POS_MIN,
+ bch2_trans_init(&trans, c);
+
+ for_each_btree_key(&trans, iter, BTREE_ID_INODES, POS_MIN,
BTREE_ITER_PREFETCH, k) {
switch (k.k->type) {
case KEY_TYPE_inode:
KEY_TYPE_QUOTA_NOCHECK);
}
}
- return bch2_btree_iter_unlock(&iter) ?: ret;
+ return bch2_trans_exit(&trans) ?: ret;
}
/* Enable/disable/delete quotas for an entire filesystem: */
case REBALANCE_RUNNING:
pr_buf(&out, "running\n");
pr_buf(&out, "pos %llu:%llu\n",
- r->move_stats.iter.pos.inode,
- r->move_stats.iter.pos.offset);
+ r->move_stats.pos.inode,
+ r->move_stats.pos.offset);
break;
}
for_each_btree_key_continue(iter, BTREE_ITER_SLOTS, k) {
if (k.k->type != desc.key_type &&
k.k->type != KEY_TYPE_whiteout)
- return false;
+ break;
if (k.k->type == desc.key_type &&
- desc.hash_bkey(info, k) <= start->pos.offset)
- return true;
+ desc.hash_bkey(info, k) <= start->pos.offset) {
+ bch2_trans_iter_free_on_commit(trans, iter);
+ return 1;
+ }
}
- return btree_iter_err(k);
+
+ return bch2_trans_iter_free(trans, iter);
}
static __always_inline
{
struct btree_iter *iter, *slot = NULL;
struct bkey_s_c k;
+ bool found = false;
+ int ret = 0;
iter = bch2_trans_get_iter(trans, desc.btree_id,
POS(inode, desc.hash_bkey(info, bkey_i_to_s_c(insert))),
goto not_found;
}
- return btree_iter_err(k) ?: -ENOSPC;
-not_found:
- if (flags & BCH_HASH_SET_MUST_REPLACE)
- return -ENOENT;
+ if (slot)
+ bch2_trans_iter_free(trans, iter);
- insert->k.p = slot->pos;
- bch2_trans_update(trans, BTREE_INSERT_ENTRY(slot, insert));
- return 0;
+ return bch2_trans_iter_free(trans, iter) ?: -ENOSPC;
found:
- if (flags & BCH_HASH_SET_MUST_CREATE)
- return -EEXIST;
+ found = true;
+not_found:
- insert->k.p = iter->pos;
- bch2_trans_update(trans, BTREE_INSERT_ENTRY(iter, insert));
- return 0;
+ if (!found && (flags & BCH_HASH_SET_MUST_REPLACE)) {
+ ret = -ENOENT;
+ } else if (found && (flags & BCH_HASH_SET_MUST_CREATE)) {
+ ret = -EEXIST;
+ } else {
+ if (!found && slot) {
+ bch2_trans_iter_free(trans, iter);
+ iter = slot;
+ }
+
+ insert->k.p = iter->pos;
+ bch2_trans_update(trans, BTREE_INSERT_ENTRY(iter, insert));
+ bch2_trans_iter_free_on_commit(trans, iter);
+ }
+
+ return ret;
}
static __always_inline
static ssize_t bch2_compression_stats(struct bch_fs *c, char *buf)
{
- struct btree_iter iter;
+ struct btree_trans trans;
+ struct btree_iter *iter;
struct bkey_s_c k;
u64 nr_uncompressed_extents = 0, uncompressed_sectors = 0,
nr_compressed_extents = 0,
if (!test_bit(BCH_FS_STARTED, &c->flags))
return -EPERM;
- for_each_btree_key(&iter, c, BTREE_ID_EXTENTS, POS_MIN, 0, k)
+ bch2_trans_init(&trans, c);
+
+ for_each_btree_key(&trans, iter, BTREE_ID_EXTENTS, POS_MIN, 0, k)
if (k.k->type == KEY_TYPE_extent) {
struct bkey_s_c_extent e = bkey_s_c_to_extent(k);
const union bch_extent_entry *entry;
break;
}
}
- bch2_btree_iter_unlock(&iter);
+ bch2_trans_exit(&trans);
return scnprintf(buf, PAGE_SIZE,
"uncompressed data:\n"
static void test_iterate(struct bch_fs *c, u64 nr)
{
- struct btree_iter iter;
+ struct btree_trans trans;
+ struct btree_iter *iter;
struct bkey_s_c k;
u64 i;
int ret;
+ bch2_trans_init(&trans, c);
+
delete_test_keys(c);
pr_info("inserting test keys");
i = 0;
- for_each_btree_key(&iter, c, BTREE_ID_DIRENTS, POS(0, 0), 0, k)
+ for_each_btree_key(&trans, iter, BTREE_ID_DIRENTS, POS(0, 0), 0, k)
BUG_ON(k.k->p.offset != i++);
- bch2_btree_iter_unlock(&iter);
BUG_ON(i != nr);
pr_info("iterating backwards");
- while (!IS_ERR_OR_NULL((k = bch2_btree_iter_prev(&iter)).k))
+ while (!IS_ERR_OR_NULL((k = bch2_btree_iter_prev(iter)).k))
BUG_ON(k.k->p.offset != --i);
- bch2_btree_iter_unlock(&iter);
BUG_ON(i);
+
+ bch2_trans_exit(&trans);
}
static void test_iterate_extents(struct bch_fs *c, u64 nr)
{
- struct btree_iter iter;
+ struct btree_trans trans;
+ struct btree_iter *iter;
struct bkey_s_c k;
u64 i;
int ret;
+ bch2_trans_init(&trans, c);
+
delete_test_keys(c);
pr_info("inserting test extents");
i = 0;
- for_each_btree_key(&iter, c, BTREE_ID_EXTENTS, POS(0, 0), 0, k) {
+ for_each_btree_key(&trans, iter, BTREE_ID_EXTENTS, POS(0, 0), 0, k) {
BUG_ON(bkey_start_offset(k.k) != i);
i = k.k->p.offset;
}
- bch2_btree_iter_unlock(&iter);
BUG_ON(i != nr);
pr_info("iterating backwards");
- while (!IS_ERR_OR_NULL((k = bch2_btree_iter_prev(&iter)).k)) {
+ while (!IS_ERR_OR_NULL((k = bch2_btree_iter_prev(iter)).k)) {
BUG_ON(k.k->p.offset != i);
i = bkey_start_offset(k.k);
}
- bch2_btree_iter_unlock(&iter);
BUG_ON(i);
+
+ bch2_trans_exit(&trans);
}
static void test_iterate_slots(struct bch_fs *c, u64 nr)
{
- struct btree_iter iter;
+ struct btree_trans trans;
+ struct btree_iter *iter;
struct bkey_s_c k;
u64 i;
int ret;
+ bch2_trans_init(&trans, c);
+
delete_test_keys(c);
pr_info("inserting test keys");
i = 0;
- for_each_btree_key(&iter, c, BTREE_ID_DIRENTS, POS(0, 0), 0, k) {
+ for_each_btree_key(&trans, iter, BTREE_ID_DIRENTS, POS(0, 0), 0, k) {
BUG_ON(k.k->p.offset != i);
i += 2;
}
- bch2_btree_iter_unlock(&iter);
+ bch2_trans_iter_free(&trans, iter);
BUG_ON(i != nr * 2);
i = 0;
- for_each_btree_key(&iter, c, BTREE_ID_DIRENTS, POS(0, 0),
+ for_each_btree_key(&trans, iter, BTREE_ID_DIRENTS, POS(0, 0),
BTREE_ITER_SLOTS, k) {
BUG_ON(bkey_deleted(k.k) != (i & 1));
BUG_ON(k.k->p.offset != i++);
if (i == nr * 2)
break;
}
- bch2_btree_iter_unlock(&iter);
+
+ bch2_trans_exit(&trans);
}
static void test_iterate_slots_extents(struct bch_fs *c, u64 nr)
{
- struct btree_iter iter;
+ struct btree_trans trans;
+ struct btree_iter *iter;
struct bkey_s_c k;
u64 i;
int ret;
+ bch2_trans_init(&trans, c);
+
delete_test_keys(c);
pr_info("inserting test keys");
i = 0;
- for_each_btree_key(&iter, c, BTREE_ID_EXTENTS, POS(0, 0), 0, k) {
+ for_each_btree_key(&trans, iter, BTREE_ID_EXTENTS, POS(0, 0), 0, k) {
BUG_ON(bkey_start_offset(k.k) != i + 8);
BUG_ON(k.k->size != 8);
i += 16;
}
- bch2_btree_iter_unlock(&iter);
+ bch2_trans_iter_free(&trans, iter);
BUG_ON(i != nr);
i = 0;
- for_each_btree_key(&iter, c, BTREE_ID_EXTENTS, POS(0, 0),
+ for_each_btree_key(&trans, iter, BTREE_ID_EXTENTS, POS(0, 0),
BTREE_ITER_SLOTS, k) {
BUG_ON(bkey_deleted(k.k) != !(i % 16));
if (i == nr)
break;
}
- bch2_btree_iter_unlock(&iter);
+
+ bch2_trans_exit(&trans);
}
/*
*/
static void test_peek_end(struct bch_fs *c, u64 nr)
{
- struct btree_iter iter;
+ struct btree_trans trans;
+ struct btree_iter *iter;
struct bkey_s_c k;
- bch2_btree_iter_init(&iter, c, BTREE_ID_DIRENTS, POS_MIN, 0);
+ bch2_trans_init(&trans, c);
+
+ iter = bch2_trans_get_iter(&trans, BTREE_ID_DIRENTS, POS_MIN, 0);
- k = bch2_btree_iter_peek(&iter);
+ k = bch2_btree_iter_peek(iter);
BUG_ON(k.k);
- k = bch2_btree_iter_peek(&iter);
+ k = bch2_btree_iter_peek(iter);
BUG_ON(k.k);
- bch2_btree_iter_unlock(&iter);
+ bch2_trans_exit(&trans);
}
static void test_peek_end_extents(struct bch_fs *c, u64 nr)
{
- struct btree_iter iter;
+ struct btree_trans trans;
+ struct btree_iter *iter;
struct bkey_s_c k;
- bch2_btree_iter_init(&iter, c, BTREE_ID_EXTENTS, POS_MIN, 0);
+ bch2_trans_init(&trans, c);
+
+ iter = bch2_trans_get_iter(&trans, BTREE_ID_EXTENTS, POS_MIN, 0);
- k = bch2_btree_iter_peek(&iter);
+ k = bch2_btree_iter_peek(iter);
BUG_ON(k.k);
- k = bch2_btree_iter_peek(&iter);
+ k = bch2_btree_iter_peek(iter);
BUG_ON(k.k);
- bch2_btree_iter_unlock(&iter);
+ bch2_trans_exit(&trans);
}
/* extent unit tests */
static void rand_lookup(struct bch_fs *c, u64 nr)
{
+ struct btree_trans trans;
+ struct btree_iter *iter;
+ struct bkey_s_c k;
u64 i;
- for (i = 0; i < nr; i++) {
- struct btree_iter iter;
- struct bkey_s_c k;
+ bch2_trans_init(&trans, c);
- bch2_btree_iter_init(&iter, c, BTREE_ID_DIRENTS,
- POS(0, test_rand()), 0);
+ for (i = 0; i < nr; i++) {
+ iter = bch2_trans_get_iter(&trans, BTREE_ID_DIRENTS,
+ POS(0, test_rand()), 0);
- k = bch2_btree_iter_peek(&iter);
- bch2_btree_iter_unlock(&iter);
+ k = bch2_btree_iter_peek(iter);
+ bch2_trans_iter_free(&trans, iter);
}
+
+ bch2_trans_exit(&trans);
}
static void rand_mixed(struct bch_fs *c, u64 nr)
{
+ struct btree_trans trans;
+ struct btree_iter *iter;
+ struct bkey_s_c k;
int ret;
u64 i;
- for (i = 0; i < nr; i++) {
- struct btree_trans trans;
- struct btree_iter *iter;
- struct bkey_s_c k;
-
- bch2_trans_init(&trans, c);
+ bch2_trans_init(&trans, c);
+ for (i = 0; i < nr; i++) {
iter = bch2_trans_get_iter(&trans, BTREE_ID_DIRENTS,
POS(0, test_rand()), 0);
BUG_ON(ret);
}
- bch2_trans_exit(&trans);
+ bch2_trans_iter_free(&trans, iter);
}
+ bch2_trans_exit(&trans);
}
static void rand_delete(struct bch_fs *c, u64 nr)
static void seq_lookup(struct bch_fs *c, u64 nr)
{
- struct btree_iter iter;
+ struct btree_trans trans;
+ struct btree_iter *iter;
struct bkey_s_c k;
- for_each_btree_key(&iter, c, BTREE_ID_DIRENTS, POS_MIN, 0, k)
+ bch2_trans_init(&trans, c);
+
+ for_each_btree_key(&trans, iter, BTREE_ID_DIRENTS, POS_MIN, 0, k)
;
- bch2_btree_iter_unlock(&iter);
+ bch2_trans_exit(&trans);
}
static void seq_overwrite(struct bch_fs *c, u64 nr)
{
struct bch_fs *c = dentry->d_sb->s_fs_info;
struct bch_inode_info *inode = to_bch_ei(dentry->d_inode);
- struct btree_iter iter;
+ struct btree_trans trans;
+ struct btree_iter *iter;
struct bkey_s_c k;
u64 inum = dentry->d_inode->i_ino;
ssize_t ret = 0;
- for_each_btree_key(&iter, c, BTREE_ID_XATTRS, POS(inum, 0), 0, k) {
+ bch2_trans_init(&trans, c);
+
+ for_each_btree_key(&trans, iter, BTREE_ID_XATTRS,
+ POS(inum, 0), 0, k) {
BUG_ON(k.k->p.inode < inum);
if (k.k->p.inode > inum)
if (ret < 0)
break;
}
- bch2_btree_iter_unlock(&iter);
+ bch2_trans_exit(&trans);
if (ret < 0)
return ret;
projects / linux.git / commitdiff