Kernel/linux
1
0
Fork 0
mirror of https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git synced 2025-01-10 07:10:27 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

bcachefs: Kill deferred btree updates

Browse Source 
Will be replaced by cached btree iterators

Signed-off-by: Kent Overstreet <kent.overstreet@linux.dev>
This commit is contained in:
Kent Overstreet 2019-09-22 18:49:16 -04:00 committed by Kent Overstreet
parent 877dfb348d
commit a7199432c3
22 changed files with 97 additions and 346 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
fs/bcachefs/acl.c
View File

@ -378,7 +378,7 @@ int bch2_acl_chmod(struct btree_trans *trans,
}
new->k.p = iter->pos;
bch2_trans_update(trans, BTREE_INSERT_ENTRY(iter, &new->k_i));
bch2_trans_update(trans, iter, &new->k_i);
*new_acl = acl;
acl = NULL;
err:

4
fs/bcachefs/alloc_background.c
View File

@ -311,7 +311,7 @@ retry:
a->k.p = iter->pos;
bch2_alloc_pack(a, new_u);
bch2_trans_update(trans, BTREE_INSERT_ENTRY(iter, &a->k_i));
bch2_trans_update(trans, iter, &a->k_i);
ret = bch2_trans_commit(trans, NULL, NULL,
BTREE_INSERT_ATOMIC|
BTREE_INSERT_NOFAIL|
@ -899,7 +899,7 @@ retry:
a->k.p = iter->pos;
bch2_alloc_pack(a, u);
bch2_trans_update(trans, BTREE_INSERT_ENTRY(iter, &a->k_i));
bch2_trans_update(trans, iter, &a->k_i);
/*
* XXX:

20
fs/bcachefs/btree_types.h
View File

@ -246,29 +246,9 @@ static inline enum btree_iter_type btree_iter_type(struct btree_iter *iter)
return iter->flags & BTREE_ITER_TYPE;
}
struct deferred_update {
struct journal_preres res;
struct journal_entry_pin journal;
spinlock_t lock;
unsigned dirty:1;
u8 allocated_u64s;
enum btree_id btree_id;
/* must be last: */
struct bkey_i k;
};
struct btree_insert_entry {
struct bkey_i *k;
union {
struct btree_iter *iter;
struct deferred_update *d;
};
bool deferred;
};
#define BTREE_ITER_MAX 64

43
fs/bcachefs/btree_update.h
View File

@ -15,24 +15,6 @@ bool bch2_btree_bset_insert_key(struct btree_iter *, struct btree *,
void bch2_btree_journal_key(struct btree_trans *, struct btree_iter *,
struct bkey_i *);
void bch2_deferred_update_free(struct bch_fs *,
struct deferred_update *);
struct deferred_update *
bch2_deferred_update_alloc(struct bch_fs *, enum btree_id, unsigned);
#define BTREE_INSERT_ENTRY(_iter, _k) \
((struct btree_insert_entry) { \
.iter = (_iter), \
.k = (_k), \
})
#define BTREE_INSERT_DEFERRED(_d, _k) \
((struct btree_insert_entry) { \
.k = (_k), \
.d = (_d), \
.deferred = true, \
})
enum {
__BTREE_INSERT_ATOMIC,
__BTREE_INSERT_NOUNLOCK,
@ -120,11 +102,14 @@ int bch2_trans_commit(struct btree_trans *,
u64 *, unsigned);
static inline void bch2_trans_update(struct btree_trans *trans,
struct btree_insert_entry entry)
struct btree_iter *iter,
struct bkey_i *k)
{
EBUG_ON(trans->nr_updates >= trans->nr_iters + 4);
trans->updates[trans->nr_updates++] = entry;
trans->updates[trans->nr_updates++] = (struct btree_insert_entry) {
.iter = iter, .k = k
};
}
#define bch2_trans_do(_c, _journal_seq, _flags, _do) \
@ -145,23 +130,9 @@ static inline void bch2_trans_update(struct btree_trans *trans,
_ret; \
})
#define __trans_next_update(_trans, _i, _filter) \
({ \
while ((_i) < (_trans)->updates + (_trans->nr_updates) && !(_filter))\
(_i)++; \
\
(_i) < (_trans)->updates + (_trans->nr_updates); \
})
#define __trans_for_each_update(_trans, _i, _filter) \
#define trans_for_each_update(_trans, _i) \
for ((_i) = (_trans)->updates; \
__trans_next_update(_trans, _i, _filter); \
(_i) < (_trans)->updates + (_trans)->nr_updates; \
(_i)++)
#define trans_for_each_update(trans, i) \
__trans_for_each_update(trans, i, true)
#define trans_for_each_update_iter(trans, i) \
__trans_for_each_update(trans, i, !(i)->deferred)
#endif /* _BCACHEFS_BTREE_UPDATE_H */

176
fs/bcachefs/btree_update_leaf.c
View File

@ -28,8 +28,7 @@ static inline bool same_leaf_as_prev(struct btree_trans *trans,
? trans->updates + trans->updates_sorted[sorted_idx - 1]
: NULL;
return !i->deferred &&
prev &&
return prev &&
i->iter->l[0].b == prev->iter->l[0].b;
}
@ -73,13 +72,6 @@ static void btree_trans_lock_write(struct btree_trans *trans, bool lock)
}
}
static inline int btree_trans_cmp(struct btree_insert_entry l,
struct btree_insert_entry r)
{
return cmp_int(l.deferred, r.deferred) ?:
btree_iter_cmp(l.iter, r.iter);
}
static inline void btree_trans_sort_updates(struct btree_trans *trans)
{
struct btree_insert_entry *l, *r;
@ -89,7 +81,7 @@ static inline void btree_trans_sort_updates(struct btree_trans *trans)
for (pos = 0; pos < nr; pos++) {
r = trans->updates + trans->updates_sorted[pos];
if (btree_trans_cmp(*l, *r) <= 0)
if (btree_iter_cmp(l->iter, r->iter) <= 0)
break;
}
@ -312,143 +304,23 @@ static void btree_insert_key_leaf(struct btree_trans *trans,
trace_btree_insert_key(c, b, insert->k);
}
/* Deferred btree updates: */
static void deferred_update_flush(struct journal *j,
struct journal_entry_pin *pin,
u64 seq)
{
struct bch_fs *c = container_of(j, struct bch_fs, journal);
struct deferred_update *d =
container_of(pin, struct deferred_update, journal);
struct journal_preres res = { 0 };
u64 tmp[32];
struct bkey_i *k = (void *) tmp;
int ret;
if (d->allocated_u64s > ARRAY_SIZE(tmp)) {
k = kmalloc(d->allocated_u64s * sizeof(u64), GFP_NOFS);
BUG_ON(!k); /* XXX */
}
spin_lock(&d->lock);
if (d->dirty) {
BUG_ON(jset_u64s(d->k.k.u64s) > d->res.u64s);
swap(res, d->res);
BUG_ON(d->k.k.u64s > d->allocated_u64s);
bkey_copy(k, &d->k);
d->dirty = false;
spin_unlock(&d->lock);
ret = bch2_btree_insert(c, d->btree_id, k, NULL, NULL,
BTREE_INSERT_NOFAIL|
BTREE_INSERT_USE_RESERVE|
BTREE_INSERT_JOURNAL_RESERVED);
bch2_fs_fatal_err_on(ret && !bch2_journal_error(j),
c, "error flushing deferred btree update: %i", ret);
spin_lock(&d->lock);
}
if (!d->dirty)
bch2_journal_pin_drop(j, &d->journal);
spin_unlock(&d->lock);
bch2_journal_preres_put(j, &res);
if (k != (void *) tmp)
kfree(k);
}
static void btree_insert_key_deferred(struct btree_trans *trans,
struct btree_insert_entry *insert)
{
struct bch_fs *c = trans->c;
struct journal *j = &c->journal;
struct deferred_update *d = insert->d;
int difference;
BUG_ON(trans->flags & BTREE_INSERT_JOURNAL_REPLAY);
BUG_ON(insert->k->u64s > d->allocated_u64s);
__btree_journal_key(trans, d->btree_id, insert->k);
spin_lock(&d->lock);
BUG_ON(jset_u64s(insert->k->u64s) >
trans->journal_preres.u64s);
difference = jset_u64s(insert->k->u64s) - d->res.u64s;
if (difference > 0) {
trans->journal_preres.u64s -= difference;
d->res.u64s += difference;
}
bkey_copy(&d->k, insert->k);
d->dirty = true;
bch2_journal_pin_update(j, trans->journal_res.seq, &d->journal,
deferred_update_flush);
spin_unlock(&d->lock);
}
void bch2_deferred_update_free(struct bch_fs *c,
struct deferred_update *d)
{
deferred_update_flush(&c->journal, &d->journal, 0);
BUG_ON(journal_pin_active(&d->journal));
bch2_journal_pin_flush(&c->journal, &d->journal);
kfree(d);
}
struct deferred_update *
bch2_deferred_update_alloc(struct bch_fs *c,
enum btree_id btree_id,
unsigned u64s)
{
struct deferred_update *d;
BUG_ON(u64s > U8_MAX);
d = kmalloc(offsetof(struct deferred_update, k) +
u64s * sizeof(u64), GFP_NOFS);
BUG_ON(!d);
memset(d, 0, offsetof(struct deferred_update, k));
spin_lock_init(&d->lock);
d->allocated_u64s = u64s;
d->btree_id = btree_id;
return d;
}
/* Normal update interface: */
static inline void btree_insert_entry_checks(struct btree_trans *trans,
struct btree_insert_entry *i)
{
struct bch_fs *c = trans->c;
enum btree_id btree_id = !i->deferred
? i->iter->btree_id
: i->d->btree_id;
if (!i->deferred) {
BUG_ON(i->iter->level);
BUG_ON(bkey_cmp(bkey_start_pos(&i->k->k), i->iter->pos));
EBUG_ON((i->iter->flags & BTREE_ITER_IS_EXTENTS) &&
bkey_cmp(i->k->k.p, i->iter->l[0].b->key.k.p) > 0);
EBUG_ON((i->iter->flags & BTREE_ITER_IS_EXTENTS) &&
!(trans->flags & BTREE_INSERT_ATOMIC));
}
BUG_ON(i->iter->level);
BUG_ON(bkey_cmp(bkey_start_pos(&i->k->k), i->iter->pos));
EBUG_ON((i->iter->flags & BTREE_ITER_IS_EXTENTS) &&
bkey_cmp(i->k->k.p, i->iter->l[0].b->key.k.p) > 0);
EBUG_ON((i->iter->flags & BTREE_ITER_IS_EXTENTS) &&
!(trans->flags & BTREE_INSERT_ATOMIC));
BUG_ON(debug_check_bkeys(c) &&
!bkey_deleted(&i->k->k) &&
bch2_bkey_invalid(c, bkey_i_to_s_c(i->k), btree_id));
bch2_bkey_invalid(c, bkey_i_to_s_c(i->k), i->iter->btree_id));
}
static int bch2_trans_journal_preres_get(struct btree_trans *trans)
@ -459,7 +331,7 @@ static int bch2_trans_journal_preres_get(struct btree_trans *trans)
int ret;
trans_for_each_update(trans, i)
if (i->deferred)
if (0)
u64s += jset_u64s(i->k->k.u64s);
if (!u64s)
@ -551,10 +423,7 @@ static int btree_trans_check_can_insert(struct btree_trans *trans,
static inline void do_btree_insert_one(struct btree_trans *trans,
struct btree_insert_entry *insert)
{
if (likely(!insert->deferred))
btree_insert_key_leaf(trans, insert);
else
btree_insert_key_deferred(trans, insert);
btree_insert_key_leaf(trans, insert);
}
static inline bool update_triggers_transactional(struct btree_trans *trans,
@ -570,7 +439,6 @@ static inline bool update_has_triggers(struct btree_trans *trans,
struct btree_insert_entry *i)
{
return likely(!(trans->flags & BTREE_INSERT_NOMARK)) &&
!i->deferred &&
btree_node_type_needs_gc(i->iter->btree_id);
}
@ -588,14 +456,14 @@ static inline int do_btree_insert_at(struct btree_trans *trans,
: 0;
int ret;
trans_for_each_update_iter(trans, i)
trans_for_each_update(trans, i)
BUG_ON(i->iter->uptodate >= BTREE_ITER_NEED_RELOCK);
/*
* note: running triggers will append more updates to the list of
* updates as we're walking it:
*/
trans_for_each_update_iter(trans, i)
trans_for_each_update(trans, i)
if (update_has_triggers(trans, i) &&
update_triggers_transactional(trans, i)) {
ret = bch2_trans_mark_update(trans, i->iter, i->k);
@ -633,7 +501,7 @@ static inline int do_btree_insert_at(struct btree_trans *trans,
if (ret)
goto out;
trans_for_each_update_iter(trans, i) {
trans_for_each_update(trans, i) {
if (!btree_node_type_needs_gc(i->iter->btree_id))
continue;
@ -673,7 +541,7 @@ static inline int do_btree_insert_at(struct btree_trans *trans,
i->k->k.version = MAX_VERSION;
}
trans_for_each_update_iter(trans, i)
trans_for_each_update(trans, i)
if (update_has_triggers(trans, i) &&
!update_triggers_transactional(trans, i))
bch2_mark_update(trans, i, &fs_usage->u, mark_flags);
@ -687,7 +555,7 @@ static inline int do_btree_insert_at(struct btree_trans *trans,
if (likely(!(trans->flags & BTREE_INSERT_NOMARK)) &&
unlikely(c->gc_pos.phase))
trans_for_each_update_iter(trans, i)
trans_for_each_update(trans, i)
if (gc_visited(c, gc_pos_btree_node(i->iter->l[0].b)))
bch2_mark_update(trans, i, NULL,
mark_flags|
@ -772,7 +640,7 @@ int bch2_trans_commit_error(struct btree_trans *trans,
case BTREE_INSERT_NEED_MARK_REPLICAS:
bch2_trans_unlock(trans);
trans_for_each_update_iter(trans, i) {
trans_for_each_update(trans, i) {
ret = bch2_mark_bkey_replicas(c, bkey_i_to_s_c(i->k));
if (ret)
return ret;
@ -842,7 +710,7 @@ static int __bch2_trans_commit(struct btree_trans *trans,
unsigned iter;
int ret;
trans_for_each_update_iter(trans, i) {
trans_for_each_update(trans, i) {
if (!bch2_btree_iter_upgrade(i->iter, 1)) {
trace_trans_restart_upgrade(trans->ip);
ret = -EINTR;
@ -868,7 +736,7 @@ static int __bch2_trans_commit(struct btree_trans *trans,
trans->nounlock = false;
trans_for_each_update_iter(trans, i)
trans_for_each_update(trans, i)
bch2_btree_iter_downgrade(i->iter);
err:
/* make sure we didn't drop or screw up locks: */
@ -995,7 +863,7 @@ retry:
iter = bch2_trans_get_iter(&trans, id, bkey_start_pos(&k->k),
BTREE_ITER_INTENT);
bch2_trans_update(&trans, BTREE_INSERT_ENTRY(iter, k));
bch2_trans_update(&trans, iter, k);
ret = bch2_trans_commit(&trans, disk_res, journal_seq, flags);
if (ret == -EINTR)
@ -1045,7 +913,7 @@ retry:
break;
}
bch2_trans_update(trans, BTREE_INSERT_ENTRY(iter, &delete));
bch2_trans_update(trans, iter, &delete);
ret = bch2_trans_commit(trans, NULL, journal_seq,
BTREE_INSERT_ATOMIC|
BTREE_INSERT_NOFAIL);
@ -1072,7 +940,7 @@ int bch2_btree_delete_at(struct btree_trans *trans,
bkey_init(&k.k);
k.k.p = iter->pos;
bch2_trans_update(trans, BTREE_INSERT_ENTRY(iter, &k));
bch2_trans_update(trans, iter, &k);
return bch2_trans_commit(trans, NULL, NULL,
BTREE_INSERT_NOFAIL|
BTREE_INSERT_USE_RESERVE|flags);

8
fs/bcachefs/buckets.c
View File

@ -1316,7 +1316,7 @@ void bch2_trans_fs_usage_apply(struct btree_trans *trans,
bch_err(c, "disk usage increased more than %llu sectors reserved",
disk_res_sectors);
trans_for_each_update_iter(trans, i) {
trans_for_each_update(trans, i) {
struct btree_iter *iter = i->iter;
struct btree *b = iter->l[0].b;
struct btree_node_iter node_iter = iter->l[0].iter;
@ -1358,7 +1358,7 @@ static int trans_get_key(struct btree_trans *trans,
struct btree_insert_entry *i;
int ret;
trans_for_each_update_iter(trans, i)
trans_for_each_update(trans, i)
if (i->iter->btree_id == btree_id &&
(btree_node_type_is_extents(btree_id)
? bkey_cmp(pos, bkey_start_pos(&i->k->k)) >= 0 &&
@ -1397,13 +1397,13 @@ static void *trans_update_key(struct btree_trans *trans,
bkey_init(&new_k->k);
new_k->k.p = iter->pos;
trans_for_each_update_iter(trans, i)
trans_for_each_update(trans, i)
if (i->iter == iter) {
i->k = new_k;
return new_k;
}
bch2_trans_update(trans, BTREE_INSERT_ENTRY(iter, new_k));
bch2_trans_update(trans, iter, new_k);
return new_k;
}

9
fs/bcachefs/dirent.c
View File

@ -255,9 +255,8 @@ int bch2_dirent_rename(struct btree_trans *trans,
* new_dst at the src position:
*/
new_dst->k.p = src_iter->pos;
bch2_trans_update(trans,
BTREE_INSERT_ENTRY(src_iter,
&new_dst->k_i));
bch2_trans_update(trans, src_iter,
&new_dst->k_i);
return 0;
} else {
/* If we're overwriting, we can't insert new_dst
@ -280,8 +279,8 @@ int bch2_dirent_rename(struct btree_trans *trans,
}
}
bch2_trans_update(trans, BTREE_INSERT_ENTRY(src_iter, &new_src->k_i));
bch2_trans_update(trans, BTREE_INSERT_ENTRY(dst_iter, &new_dst->k_i));
bch2_trans_update(trans, src_iter, &new_src->k_i);
bch2_trans_update(trans, dst_iter, &new_dst->k_i);
return 0;
}

6
fs/bcachefs/ec.c
View File

@ -738,7 +738,7 @@ found_slot:
stripe->k.p = iter->pos;
bch2_trans_update(&trans, BTREE_INSERT_ENTRY(iter, &stripe->k_i));
bch2_trans_update(&trans, iter, &stripe->k_i);
ret = bch2_trans_commit(&trans, NULL, NULL,
BTREE_INSERT_ATOMIC|
@ -819,7 +819,7 @@ static int ec_stripe_update_ptrs(struct bch_fs *c,
extent_stripe_ptr_add(e, s, ptr, idx);
bch2_trans_update(&trans, BTREE_INSERT_ENTRY(iter, &tmp.k));
bch2_trans_update(&trans, iter, &tmp.k);
ret = bch2_trans_commit(&trans, NULL, NULL,
BTREE_INSERT_ATOMIC|
@ -1231,7 +1231,7 @@ static int __bch2_stripe_write_key(struct btree_trans *trans,
spin_unlock(&c->ec_stripes_heap_lock);
bch2_trans_update(trans, BTREE_INSERT_ENTRY(iter, &new_key->k_i));
bch2_trans_update(trans, iter, &new_key->k_i);
return bch2_trans_commit(trans, NULL, NULL,
BTREE_INSERT_NOFAIL|flags);

78
fs/bcachefs/fs-io.c
View File

@ -324,69 +324,36 @@ int bch2_extent_update(struct btree_trans *trans,
if (!may_allocate && allocating)
return -ENOSPC;
bch2_trans_update(trans, BTREE_INSERT_ENTRY(extent_iter, k));
bch2_trans_update(trans, extent_iter, k);
new_i_size = min(k->k.p.offset << 9, new_i_size);
/* XXX: inode->i_size locking */
if (i_sectors_delta ||
new_i_size > inode->ei_inode.bi_size) {
if (c->opts.new_inode_updates) {
bch2_trans_unlock(trans);
mutex_lock(&inode->ei_update_lock);
inode_iter = bch2_trans_get_iter(trans,
BTREE_ID_INODES,
POS(k->k.p.inode, 0),
BTREE_ITER_SLOTS|BTREE_ITER_INTENT);
if (IS_ERR(inode_iter))
return PTR_ERR(inode_iter);
if (!bch2_trans_relock(trans)) {
mutex_unlock(&inode->ei_update_lock);
return -EINTR;
}
ret = bch2_btree_iter_traverse(inode_iter);
if (ret)
goto err;
inode_locked = true;
inode_u = inode->ei_inode;
inode_u.bi_sectors += i_sectors_delta;
if (!inode->ei_inode_update)
inode->ei_inode_update =
bch2_deferred_update_alloc(c,
BTREE_ID_INODES, 64);
inode_u = inode->ei_inode;
inode_u.bi_sectors += i_sectors_delta;
/* XXX: this is slightly suspect */
if (!(inode_u.bi_flags & BCH_INODE_I_SIZE_DIRTY) &&
new_i_size > inode_u.bi_size) {
inode_u.bi_size = new_i_size;
extended = true;
}
bch2_inode_pack(&inode_p, &inode_u);
bch2_trans_update(trans,
BTREE_INSERT_DEFERRED(inode->ei_inode_update,
&inode_p.inode.k_i));
} else {
inode_iter = bch2_trans_get_iter(trans,
BTREE_ID_INODES,
POS(k->k.p.inode, 0),
BTREE_ITER_SLOTS|BTREE_ITER_INTENT);
if (IS_ERR(inode_iter))
return PTR_ERR(inode_iter);
ret = bch2_btree_iter_traverse(inode_iter);
if (ret)
goto err;
inode_u = inode->ei_inode;
inode_u.bi_sectors += i_sectors_delta;
/* XXX: this is slightly suspect */
if (!(inode_u.bi_flags & BCH_INODE_I_SIZE_DIRTY) &&
new_i_size > inode_u.bi_size) {
inode_u.bi_size = new_i_size;
extended = true;
}
bch2_inode_pack(&inode_p, &inode_u);
bch2_trans_update(trans,
BTREE_INSERT_ENTRY(inode_iter, &inode_p.inode.k_i));
/* XXX: this is slightly suspect */
if (!(inode_u.bi_flags & BCH_INODE_I_SIZE_DIRTY) &&
new_i_size > inode_u.bi_size) {
inode_u.bi_size = new_i_size;
extended = true;
}
bch2_inode_pack(&inode_p, &inode_u);
bch2_trans_update(trans, inode_iter, &inode_p.inode.k_i);
}
ret = bch2_trans_commit(trans, disk_res,
@ -2793,9 +2760,8 @@ reassemble:
bkey_start_pos(&delete.k));
}
bch2_trans_update(&trans, BTREE_INSERT_ENTRY(dst, &copy.k));
bch2_trans_update(&trans,
BTREE_INSERT_ENTRY(del ?: src, &delete));
bch2_trans_update(&trans, dst, &copy.k);
bch2_trans_update(&trans, del ?: src, &delete);
if (copy.k.k.size == k.k->size) {
/*

40
fs/bcachefs/fs.c
View File

@ -154,30 +154,22 @@ int __must_check bch2_write_inode_trans(struct btree_trans *trans,
inode_set_fn set,
void *p)
{
struct bch_fs *c = trans->c;
struct btree_iter *iter = NULL;
struct bkey_inode_buf *inode_p;
int ret;
lockdep_assert_held(&inode->ei_update_lock);
if (c->opts.new_inode_updates) {
/* XXX: Don't do this with btree locks held */
if (!inode->ei_inode_update)
inode->ei_inode_update =
bch2_deferred_update_alloc(c, BTREE_ID_INODES, 64);
} else {
iter = bch2_trans_get_iter(trans, BTREE_ID_INODES,
POS(inode->v.i_ino, 0),
BTREE_ITER_SLOTS|BTREE_ITER_INTENT);
if (IS_ERR(iter))
return PTR_ERR(iter);
iter = bch2_trans_get_iter(trans, BTREE_ID_INODES,
POS(inode->v.i_ino, 0),
BTREE_ITER_SLOTS|BTREE_ITER_INTENT);
if (IS_ERR(iter))
return PTR_ERR(iter);
/* The btree node lock is our lock on the inode: */
ret = bch2_btree_iter_traverse(iter);
if (ret)
return ret;
}
/* The btree node lock is our lock on the inode: */
ret = bch2_btree_iter_traverse(iter);
if (ret)
return ret;
*inode_u = inode->ei_inode;
@ -192,14 +184,7 @@ int __must_check bch2_write_inode_trans(struct btree_trans *trans,
return PTR_ERR(inode_p);
bch2_inode_pack(inode_p, inode_u);
if (!inode->ei_inode_update)
bch2_trans_update(trans,
BTREE_INSERT_ENTRY(iter, &inode_p->inode.k_i));
else
bch2_trans_update(trans,
BTREE_INSERT_DEFERRED(inode->ei_inode_update,
&inode_p->inode.k_i));
bch2_trans_update(trans, iter, &inode_p->inode.k_i);
return 0;
}
@ -1482,7 +1467,6 @@ static struct inode *bch2_alloc_inode(struct super_block *sb)
mutex_init(&inode->ei_update_lock);
pagecache_lock_init(&inode->ei_pagecache_lock);
mutex_init(&inode->ei_quota_lock);
inode->ei_inode_update = NULL;
inode->ei_journal_seq = 0;
return &inode->v;
@ -1540,10 +1524,6 @@ static void bch2_evict_inode(struct inode *vinode)
BUG_ON(!is_bad_inode(&inode->v) && inode->ei_quota_reserved);
if (inode->ei_inode_update)
bch2_deferred_update_free(c, inode->ei_inode_update);
inode->ei_inode_update = NULL;
if (!inode->v.i_nlink && !is_bad_inode(&inode->v)) {
bch2_quota_acct(c, inode->ei_qid, Q_SPC, -((s64) inode->v.i_blocks),
KEY_TYPE_QUOTA_WARN);

1
fs/bcachefs/fs.h
View File

@ -34,7 +34,6 @@ struct bch_inode_info {
struct inode v;
struct mutex ei_update_lock;
struct deferred_update *ei_inode_update;
u64 ei_journal_seq;
u64 ei_quota_reserved;
unsigned long ei_last_dirtied;

7
fs/bcachefs/fsck.c
View File

@ -393,7 +393,7 @@ static int check_dirent_hash(struct btree_trans *trans, struct hash_check *h,
if (fsck_err(c, "dirent with junk at end, was %s (%zu) now %s (%u)",
buf, strlen(buf), d->v.d_name, len)) {
bch2_trans_update(trans, BTREE_INSERT_ENTRY(iter, &d->k_i));
bch2_trans_update(trans, iter, &d->k_i);
ret = bch2_trans_commit(trans, NULL, NULL,
BTREE_INSERT_NOFAIL|
@ -663,8 +663,7 @@ retry:
bkey_reassemble(&n->k_i, d.s_c);
n->v.d_type = mode_to_type(target.bi_mode);
bch2_trans_update(&trans,
BTREE_INSERT_ENTRY(iter, &n->k_i));
bch2_trans_update(&trans, iter, &n->k_i);
ret = bch2_trans_commit(&trans, NULL, NULL,
BTREE_INSERT_NOFAIL|
@ -1293,7 +1292,7 @@ static int check_inode(struct btree_trans *trans,
struct bkey_inode_buf p;
bch2_inode_pack(&p, &u);
bch2_trans_update(trans, BTREE_INSERT_ENTRY(iter, &p.inode.k_i));
bch2_trans_update(trans, iter, &p.inode.k_i);
ret = bch2_trans_commit(trans, NULL, NULL,
BTREE_INSERT_NOFAIL|

6
fs/bcachefs/inode.c
View File

@ -345,8 +345,7 @@ again:
inode_u->bi_generation = bkey_generation(k);
bch2_inode_pack(inode_p, inode_u);
bch2_trans_update(trans,
BTREE_INSERT_ENTRY(iter, &inode_p->inode.k_i));
bch2_trans_update(trans, iter, &inode_p->inode.k_i);
return 0;
}
}
@ -435,8 +434,7 @@ int bch2_inode_rm(struct bch_fs *c, u64 inode_nr)
delete.v.bi_generation = cpu_to_le32(bi_generation);
}
bch2_trans_update(&trans,
BTREE_INSERT_ENTRY(iter, &delete.k_i));
bch2_trans_update(&trans, iter, &delete.k_i);
ret = bch2_trans_commit(&trans, NULL, NULL,
BTREE_INSERT_ATOMIC|

5
fs/bcachefs/io.c
View File

@ -290,8 +290,7 @@ retry:
if (ret)
break;
bch2_trans_update(&trans,
BTREE_INSERT_ENTRY(iter, &split.k));
bch2_trans_update(&trans, iter, &split.k);
ret = bch2_trans_commit(&trans, &op->res, op_journal_seq(op),
BTREE_INSERT_NOFAIL|
@ -1445,7 +1444,7 @@ retry:
if (!bch2_bkey_narrow_crcs(&new.k, new_crc))
goto out;
bch2_trans_update(&trans, BTREE_INSERT_ENTRY(iter, &new.k));
bch2_trans_update(&trans, iter, &new.k);
ret = bch2_trans_commit(&trans, NULL, NULL,
BTREE_INSERT_ATOMIC|
BTREE_INSERT_NOFAIL|

5
fs/bcachefs/migrate.c
View File

@ -72,10 +72,9 @@ static int __bch2_dev_usrdata_drop(struct bch_fs *c, unsigned dev_idx, int flags
*/
bch2_extent_normalize(c, bkey_i_to_s(&tmp.key));
/* XXX not sketchy at all */
iter->pos = bkey_start_pos(&tmp.key.k);
bch2_btree_iter_set_pos(iter, bkey_start_pos(&tmp.key.k));
bch2_trans_update(&trans, BTREE_INSERT_ENTRY(iter, &tmp.key));
bch2_trans_update(&trans, iter, &tmp.key);
ret = bch2_trans_commit(&trans, NULL, NULL,
BTREE_INSERT_ATOMIC|

3
fs/bcachefs/move.c
View File

@ -147,8 +147,7 @@ static int bch2_migrate_index_update(struct bch_write_op *op)
goto next;
}
bch2_trans_update(&trans,
BTREE_INSERT_ENTRY(iter, insert));
bch2_trans_update(&trans, iter, insert);
ret = bch2_trans_commit(&trans, &op->res,
op_journal_seq(op),

8
fs/bcachefs/opts.h
View File

@ -295,13 +295,7 @@ enum opt_type {
OPT_UINT(0, BCH_REPLICAS_MAX), \
NO_SB_OPT, 1, \
"n", "Data written to this device will be considered\n"\
"to have already been replicated n times") \
x(new_inode_updates, u8, \
OPT_MOUNT, \
OPT_BOOL(), \
NO_SB_OPT, false, \
NULL, "Enable new btree write-cache for inode updates")
"to have already been replicated n times")
struct bch_opts {
#define x(_name, _bits, ...) unsigned _name##_defined:1;

2
fs/bcachefs/quota.c
View File

@ -752,7 +752,7 @@ static int bch2_set_quota(struct super_block *sb, struct kqid qid,
if (qdq->d_fieldmask & QC_INO_HARD)
new_quota.v.c[Q_INO].hardlimit = cpu_to_le64(qdq->d_ino_hardlimit);
bch2_trans_update(&trans, BTREE_INSERT_ENTRY(iter, &new_quota.k_i));
bch2_trans_update(&trans, iter, &new_quota.k_i);
ret = bch2_trans_commit(&trans, NULL, NULL, 0);

2
fs/bcachefs/recovery.c
View File

@ -301,7 +301,7 @@ retry:
bch2_cut_front(split_iter->pos, split);
bch2_cut_back(atomic_end, &split->k);
bch2_trans_update(&trans, BTREE_INSERT_ENTRY(split_iter, split));
bch2_trans_update(&trans, split_iter, split);
bch2_btree_iter_set_pos(iter, split->k.p);
} while (bkey_cmp(iter->pos, k->k.p) < 0);

4
fs/bcachefs/reflink.c
View File

@ -120,7 +120,7 @@ static int bch2_make_extent_indirect(struct btree_trans *trans,
r_v->v.refcount = 0;
memcpy(r_v->v.start, e->v.start, bkey_val_bytes(&e->k));
bch2_trans_update(trans, BTREE_INSERT_ENTRY(reflink_iter, &r_v->k_i));
bch2_trans_update(trans, reflink_iter, &r_v->k_i);
r_p = bch2_trans_kmalloc(trans, sizeof(*r_p));
if (IS_ERR(r_p))
@ -131,7 +131,7 @@ static int bch2_make_extent_indirect(struct btree_trans *trans,
set_bkey_val_bytes(&r_p->k, sizeof(r_p->v));
r_p->v.idx = cpu_to_le64(bkey_start_offset(&r_v->k));
bch2_trans_update(trans, BTREE_INSERT_ENTRY(extent_iter, &r_p->k_i));
bch2_trans_update(trans, extent_iter, &r_p->k_i);
err:
if (!IS_ERR(reflink_iter)) {
c->reflink_hint = reflink_iter->pos.offset;

4
fs/bcachefs/str_hash.h
View File

@ -267,7 +267,7 @@ not_found:
}
insert->k.p = iter->pos;
bch2_trans_update(trans, BTREE_INSERT_ENTRY(iter, insert));
bch2_trans_update(trans, iter, insert);
bch2_trans_iter_free_on_commit(trans, iter);
}
@ -295,7 +295,7 @@ int bch2_hash_delete_at(struct btree_trans *trans,
delete->k.p = iter->pos;
delete->k.type = ret ? KEY_TYPE_whiteout : KEY_TYPE_deleted;
bch2_trans_update(trans, BTREE_INSERT_ENTRY(iter, delete));
bch2_trans_update(trans, iter, delete);
return 0;
}

10
fs/bcachefs/tests.c
View File

@ -43,7 +43,7 @@ static void test_delete(struct bch_fs *c, u64 nr)
ret = bch2_btree_iter_traverse(iter);
BUG_ON(ret);
bch2_trans_update(&trans, BTREE_INSERT_ENTRY(iter, &k.k_i));
bch2_trans_update(&trans, iter, &k.k_i);
ret = bch2_trans_commit(&trans, NULL, NULL, 0);
BUG_ON(ret);
@ -75,7 +75,7 @@ static void test_delete_written(struct bch_fs *c, u64 nr)
ret = bch2_btree_iter_traverse(iter);
BUG_ON(ret);
bch2_trans_update(&trans, BTREE_INSERT_ENTRY(iter, &k.k_i));
bch2_trans_update(&trans, iter, &k.k_i);
ret = bch2_trans_commit(&trans, NULL, NULL, 0);
BUG_ON(ret);
@ -465,7 +465,7 @@ static void rand_mixed(struct bch_fs *c, u64 nr)
bkey_cookie_init(&k.k_i);
k.k.p = iter->pos;
bch2_trans_update(&trans, BTREE_INSERT_ENTRY(iter, &k.k_i));
bch2_trans_update(&trans, iter, &k.k_i);
ret = bch2_trans_commit(&trans, NULL, NULL, 0);
BUG_ON(ret);
}
@ -509,7 +509,7 @@ static void seq_insert(struct bch_fs *c, u64 nr)
BTREE_ITER_SLOTS|BTREE_ITER_INTENT, k, ret) {
insert.k.p = iter->pos;
bch2_trans_update(&trans, BTREE_INSERT_ENTRY(iter, &insert.k_i));
bch2_trans_update(&trans, iter, &insert.k_i);
ret = bch2_trans_commit(&trans, NULL, NULL, 0);
BUG_ON(ret);
@ -548,7 +548,7 @@ static void seq_overwrite(struct bch_fs *c, u64 nr)
bkey_reassemble(&u.k_i, k);
bch2_trans_update(&trans, BTREE_INSERT_ENTRY(iter, &u.k_i));
bch2_trans_update(&trans, iter, &u.k_i);
ret = bch2_trans_commit(&trans, NULL, NULL, 0);
BUG_ON(ret);
}