-4b5917839c4b279b303133b87cd94cc1a352a0e6
+33a60d9b05f523be93973b25e0df1ab2d65fa4fc
#include <linux/compiler.h>
#include <linux/math.h>
+#define BIT(nr) (1UL << (nr))
+#define BIT_ULL(nr) (1ULL << (nr))
+
#define __ARG_PLACEHOLDER_1 0,
#define __take_second_arg(__ignored, val, ...) val
}
#endif
+#define abs(x) __abs_choose_expr(x, long long, \
+ __abs_choose_expr(x, long, \
+ __abs_choose_expr(x, int, \
+ __abs_choose_expr(x, short, \
+ __abs_choose_expr(x, char, \
+ __builtin_choose_expr( \
+ __builtin_types_compatible_p(typeof(x), char), \
+ (char)({ signed char __x = (x); __x<0?-__x:__x; }), \
+ ((void)0)))))))
+
+#define __abs_choose_expr(x, type, other) __builtin_choose_expr( \
+ __builtin_types_compatible_p(typeof(x), signed type) || \
+ __builtin_types_compatible_p(typeof(x), unsigned type), \
+ ({ signed type __x = (x); __x < 0 ? -__x : __x; }), other)
+
#endif /* _LINUX_MATH_H */
#include <linux/rculist.h>
#include <linux/bit_spinlock.h>
-#define BIT(nr) (1UL << (nr))
-#define BIT_ULL(nr) (1ULL << (nr))
-
#include <linux/rhashtable-types.h>
/*
* Objects in an rhashtable have an embedded struct rhash_head
}
#define kzalloc(size, flags) kmalloc(size, flags|__GFP_ZERO)
-#define kmalloc_array(n, size, flags) \
- ((size) != 0 && (n) > SIZE_MAX / (size) \
- ? NULL : kmalloc((n) * (size), flags))
+
+static inline void *kmalloc_array(size_t n, size_t size, gfp_t flags)
+{
+ size_t bytes;
+
+ if (unlikely(check_mul_overflow(n, size, &bytes)))
+ return NULL;
+ return kmalloc(bytes, flags);
+}
#define kvmalloc_array(n, size, flags) \
((size) != 0 && (n) > SIZE_MAX / (size) \
return v;
}
-static inline void alloc_field_v1_put(struct bkey_i_alloc *a, void **p,
- unsigned field, u64 v)
-{
- unsigned bytes = BCH_ALLOC_V1_FIELD_BYTES[field];
-
- if (!v)
- return;
-
- a->v.fields |= 1 << field;
-
- switch (bytes) {
- case 1:
- *((u8 *) *p) = v;
- break;
- case 2:
- *((__le16 *) *p) = cpu_to_le16(v);
- break;
- case 4:
- *((__le32 *) *p) = cpu_to_le32(v);
- break;
- case 8:
- *((__le64 *) *p) = cpu_to_le64(v);
- break;
- default:
- BUG();
- }
-
- *p += bytes;
-}
-
static void bch2_alloc_unpack_v1(struct bkey_alloc_unpacked *out,
struct bkey_s_c k)
{
}
int bch2_alloc_v4_invalid(const struct bch_fs *c, struct bkey_s_c k,
- unsigned flags, struct printbuf *err)
+ enum bkey_invalid_flags flags,
+ struct printbuf *err)
{
struct bkey_s_c_alloc_v4 a = bkey_s_c_to_alloc_v4(k);
int rw = flags & WRITE;
struct btree_iter *iter,
struct bpos end)
{
- if (!btree_node_type_is_extents(iter->btree_id)) {
+ if (!btree_id_is_extents(iter->btree_id)) {
return __bch2_check_discard_freespace_key(trans, iter);
} else {
int ret;
unsigned i;
if (!drop && ob->ec) {
+ unsigned nr_blocks;
+
mutex_lock(&ob->ec->lock);
- for (i = 0; i < ob->ec->new_stripe.key.v.nr_blocks; i++) {
+ nr_blocks = bkey_i_to_stripe(&ob->ec->new_stripe.key)->v.nr_blocks;
+
+ for (i = 0; i < nr_blocks; i++) {
if (!ob->ec->blocks[i])
continue;
};
#define BCH_WATERMARK_BITS 3
-#define BCH_WATERMARK_MASK ~(~0 << BCH_WATERMARK_BITS)
+#define BCH_WATERMARK_MASK ~(~0U << BCH_WATERMARK_BITS)
#define OPEN_BUCKETS_COUNT 1024
__le64 _buckets_unavailable; /* No longer used */
struct jset_entry_dev_usage_type d[];
-} __packed;
+};
static inline unsigned jset_entry_dev_usage_nr_types(struct jset_entry_dev_usage *u)
{
/* Btree: */
-#define BCH_BTREE_IDS() \
- x(extents, 0) \
- x(inodes, 1) \
- x(dirents, 2) \
- x(xattrs, 3) \
- x(alloc, 4) \
- x(quotas, 5) \
- x(stripes, 6) \
- x(reflink, 7) \
- x(subvolumes, 8) \
- x(snapshots, 9) \
- x(lru, 10) \
- x(freespace, 11) \
- x(need_discard, 12) \
- x(backpointers, 13) \
- x(bucket_gens, 14) \
- x(snapshot_trees, 15)
+enum btree_id_flags {
+ BTREE_ID_EXTENTS = BIT(0),
+ BTREE_ID_SNAPSHOTS = BIT(1),
+ BTREE_ID_DATA = BIT(2),
+};
+
+#define BCH_BTREE_IDS() \
+ x(extents, 0, BTREE_ID_EXTENTS|BTREE_ID_SNAPSHOTS|BTREE_ID_DATA,\
+ BIT_ULL(KEY_TYPE_whiteout)| \
+ BIT_ULL(KEY_TYPE_error)| \
+ BIT_ULL(KEY_TYPE_cookie)| \
+ BIT_ULL(KEY_TYPE_extent)| \
+ BIT_ULL(KEY_TYPE_reservation)| \
+ BIT_ULL(KEY_TYPE_reflink_p)| \
+ BIT_ULL(KEY_TYPE_inline_data)) \
+ x(inodes, 1, BTREE_ID_SNAPSHOTS, \
+ BIT_ULL(KEY_TYPE_whiteout)| \
+ BIT_ULL(KEY_TYPE_inode)| \
+ BIT_ULL(KEY_TYPE_inode_v2)| \
+ BIT_ULL(KEY_TYPE_inode_v3)| \
+ BIT_ULL(KEY_TYPE_inode_generation)) \
+ x(dirents, 2, BTREE_ID_SNAPSHOTS, \
+ BIT_ULL(KEY_TYPE_whiteout)| \
+ BIT_ULL(KEY_TYPE_hash_whiteout)| \
+ BIT_ULL(KEY_TYPE_dirent)) \
+ x(xattrs, 3, BTREE_ID_SNAPSHOTS, \
+ BIT_ULL(KEY_TYPE_whiteout)| \
+ BIT_ULL(KEY_TYPE_cookie)| \
+ BIT_ULL(KEY_TYPE_hash_whiteout)| \
+ BIT_ULL(KEY_TYPE_xattr)) \
+ x(alloc, 4, 0, \
+ BIT_ULL(KEY_TYPE_alloc)| \
+ BIT_ULL(KEY_TYPE_alloc_v2)| \
+ BIT_ULL(KEY_TYPE_alloc_v3)| \
+ BIT_ULL(KEY_TYPE_alloc_v4)) \
+ x(quotas, 5, 0, \
+ BIT_ULL(KEY_TYPE_quota)) \
+ x(stripes, 6, 0, \
+ BIT_ULL(KEY_TYPE_stripe)) \
+ x(reflink, 7, BTREE_ID_EXTENTS|BTREE_ID_DATA, \
+ BIT_ULL(KEY_TYPE_reflink_v)| \
+ BIT_ULL(KEY_TYPE_indirect_inline_data)) \
+ x(subvolumes, 8, 0, \
+ BIT_ULL(KEY_TYPE_subvolume)) \
+ x(snapshots, 9, 0, \
+ BIT_ULL(KEY_TYPE_snapshot)) \
+ x(lru, 10, 0, \
+ BIT_ULL(KEY_TYPE_set)) \
+ x(freespace, 11, BTREE_ID_EXTENTS, \
+ BIT_ULL(KEY_TYPE_set)) \
+ x(need_discard, 12, 0, \
+ BIT_ULL(KEY_TYPE_set)) \
+ x(backpointers, 13, 0, \
+ BIT_ULL(KEY_TYPE_backpointer)) \
+ x(bucket_gens, 14, 0, \
+ BIT_ULL(KEY_TYPE_bucket_gens)) \
+ x(snapshot_trees, 15, 0, \
+ BIT_ULL(KEY_TYPE_snapshot_tree))
enum btree_id {
-#define x(kwd, val) BTREE_ID_##kwd = val,
+#define x(name, nr, ...) BTREE_ID_##name = nr,
BCH_BTREE_IDS()
#undef x
BTREE_ID_NR
return ops->key_invalid(c, k, flags, err);
}
-static unsigned bch2_key_types_allowed[] = {
- [BKEY_TYPE_extents] =
- (1U << KEY_TYPE_deleted)|
- (1U << KEY_TYPE_whiteout)|
- (1U << KEY_TYPE_error)|
- (1U << KEY_TYPE_cookie)|
- (1U << KEY_TYPE_extent)|
- (1U << KEY_TYPE_reservation)|
- (1U << KEY_TYPE_reflink_p)|
- (1U << KEY_TYPE_inline_data),
- [BKEY_TYPE_inodes] =
- (1U << KEY_TYPE_deleted)|
- (1U << KEY_TYPE_whiteout)|
- (1U << KEY_TYPE_inode)|
- (1U << KEY_TYPE_inode_v2)|
- (1U << KEY_TYPE_inode_v3)|
- (1U << KEY_TYPE_inode_generation),
- [BKEY_TYPE_dirents] =
- (1U << KEY_TYPE_deleted)|
- (1U << KEY_TYPE_whiteout)|
- (1U << KEY_TYPE_hash_whiteout)|
- (1U << KEY_TYPE_dirent),
- [BKEY_TYPE_xattrs] =
- (1U << KEY_TYPE_deleted)|
- (1U << KEY_TYPE_whiteout)|
- (1U << KEY_TYPE_cookie)|
- (1U << KEY_TYPE_hash_whiteout)|
- (1U << KEY_TYPE_xattr),
- [BKEY_TYPE_alloc] =
- (1U << KEY_TYPE_deleted)|
- (1U << KEY_TYPE_alloc)|
- (1U << KEY_TYPE_alloc_v2)|
- (1U << KEY_TYPE_alloc_v3)|
- (1U << KEY_TYPE_alloc_v4),
- [BKEY_TYPE_quotas] =
- (1U << KEY_TYPE_deleted)|
- (1U << KEY_TYPE_quota),
- [BKEY_TYPE_stripes] =
- (1U << KEY_TYPE_deleted)|
- (1U << KEY_TYPE_stripe),
- [BKEY_TYPE_reflink] =
- (1U << KEY_TYPE_deleted)|
- (1U << KEY_TYPE_reflink_v)|
- (1U << KEY_TYPE_indirect_inline_data),
- [BKEY_TYPE_subvolumes] =
- (1U << KEY_TYPE_deleted)|
- (1U << KEY_TYPE_subvolume),
- [BKEY_TYPE_snapshots] =
- (1U << KEY_TYPE_deleted)|
- (1U << KEY_TYPE_snapshot),
- [BKEY_TYPE_lru] =
- (1U << KEY_TYPE_deleted)|
- (1U << KEY_TYPE_set),
- [BKEY_TYPE_freespace] =
- (1U << KEY_TYPE_deleted)|
- (1U << KEY_TYPE_set),
- [BKEY_TYPE_need_discard] =
- (1U << KEY_TYPE_deleted)|
- (1U << KEY_TYPE_set),
- [BKEY_TYPE_backpointers] =
- (1U << KEY_TYPE_deleted)|
- (1U << KEY_TYPE_backpointer),
- [BKEY_TYPE_bucket_gens] =
- (1U << KEY_TYPE_deleted)|
- (1U << KEY_TYPE_bucket_gens),
- [BKEY_TYPE_snapshot_trees] =
- (1U << KEY_TYPE_deleted)|
- (1U << KEY_TYPE_snapshot_tree),
+static u64 bch2_key_types_allowed[] = {
+#define x(name, nr, flags, keys) [BKEY_TYPE_##name] = BIT_ULL(KEY_TYPE_deleted)|keys,
+ BCH_BTREE_IDS()
+#undef x
[BKEY_TYPE_btree] =
- (1U << KEY_TYPE_deleted)|
- (1U << KEY_TYPE_btree_ptr)|
- (1U << KEY_TYPE_btree_ptr_v2),
+ BIT_ULL(KEY_TYPE_deleted)|
+ BIT_ULL(KEY_TYPE_btree_ptr)|
+ BIT_ULL(KEY_TYPE_btree_ptr_v2),
};
int __bch2_bkey_invalid(struct bch_fs *c, struct bkey_s_c k,
}
if (flags & BKEY_INVALID_COMMIT &&
- !(bch2_key_types_allowed[type] & (1U << k.k->type))) {
+ !(bch2_key_types_allowed[type] & BIT_ULL(k.k->type))) {
prt_printf(err, "invalid key type for btree %s (%s)",
bch2_btree_ids[type], bch2_bkey_types[k.k->type]);
return -BCH_ERR_invalid_bkey;
: &bch2_bkey_null_ops;
}
-int bch2_bkey_val_invalid(struct bch_fs *, struct bkey_s_c, unsigned, struct printbuf *);
-int __bch2_bkey_invalid(struct bch_fs *, struct bkey_s_c,
- enum btree_node_type, unsigned, struct printbuf *);
-int bch2_bkey_invalid(struct bch_fs *, struct bkey_s_c,
- enum btree_node_type, unsigned, struct printbuf *);
+int bch2_bkey_val_invalid(struct bch_fs *, struct bkey_s_c,
+ enum bkey_invalid_flags, struct printbuf *);
+int __bch2_bkey_invalid(struct bch_fs *, struct bkey_s_c, enum btree_node_type,
+ enum bkey_invalid_flags, struct printbuf *);
+int bch2_bkey_invalid(struct bch_fs *, struct bkey_s_c, enum btree_node_type,
+ enum bkey_invalid_flags, struct printbuf *);
int bch2_bkey_in_btree_node(struct btree *, struct bkey_s_c, struct printbuf *);
void bch2_bpos_to_text(struct printbuf *, struct bpos);
static inline enum gc_phase btree_id_to_gc_phase(enum btree_id id)
{
switch (id) {
-#define x(name, v) case BTREE_ID_##name: return GC_PHASE_BTREE_##name;
+#define x(name, v, ...) case BTREE_ID_##name: return GC_PHASE_BTREE_##name;
BCH_BTREE_IDS()
#undef x
default:
static struct btree_path *btree_path_alloc(struct btree_trans *, struct btree_path *);
-/*
- * Unlocks before scheduling
- * Note: does not revalidate iterator
- */
-static inline int bch2_trans_cond_resched(struct btree_trans *trans)
-{
- if (need_resched() || race_fault())
- return drop_locks_do(trans, (schedule(), 0));
- else
- return 0;
-}
-
static inline int __btree_path_cmp(const struct btree_path *l,
enum btree_id r_btree_id,
bool r_cached,
iter->key_cache_path = NULL;
}
-static inline void bch2_trans_iter_init_inlined(struct btree_trans *trans,
- struct btree_iter *iter,
- unsigned btree_id, struct bpos pos,
- unsigned flags)
-{
- bch2_trans_iter_init_common(trans, iter, btree_id, pos, 0, 0,
- bch2_btree_iter_flags(trans, btree_id, flags),
- _RET_IP_);
-}
-
void bch2_trans_iter_init_outlined(struct btree_trans *trans,
struct btree_iter *iter,
unsigned btree_id, struct bpos pos,
six_lock_readers_add(&b->lock, readers);
if (ret)
- mark_btree_node_locked_noreset(path, b->level, SIX_LOCK_intent);
+ mark_btree_node_locked_noreset(path, b->level, BTREE_NODE_INTENT_LOCKED);
return ret;
}
trace_and_count(trans->c, btree_path_upgrade_fail, trans, _RET_IP_, path, level);
return false;
success:
- mark_btree_node_locked_noreset(path, level, SIX_LOCK_intent);
+ mark_btree_node_locked_noreset(path, level, BTREE_NODE_INTENT_LOCKED);
return true;
}
} else {
if (btree_node_intent_locked(path, l)) {
six_lock_downgrade(&path->l[l].b->c.lock);
- mark_btree_node_locked_noreset(path, l, SIX_LOCK_read);
+ mark_btree_node_locked_noreset(path, l, BTREE_NODE_READ_LOCKED);
}
break;
}
EBUG_ON(path->l[b->c.level].lock_seq != six_lock_seq(&b->c.lock));
EBUG_ON(btree_node_locked_type(path, b->c.level) != SIX_LOCK_write);
- mark_btree_node_locked_noreset(path, b->c.level, SIX_LOCK_intent);
+ mark_btree_node_locked_noreset(path, b->c.level, BTREE_NODE_INTENT_LOCKED);
trans_for_each_path_with_node(trans, b, linked)
linked->l[b->c.level].lock_seq++;
* write lock: thus, we need to tell the cycle detector we have a write
* lock _before_ taking the lock:
*/
- mark_btree_node_locked_noreset(path, b->level, SIX_LOCK_write);
+ mark_btree_node_locked_noreset(path, b->level, BTREE_NODE_WRITE_LOCKED);
return likely(six_trylock_write(&b->lock))
? 0
}
enum btree_node_type {
-#define x(kwd, val) BKEY_TYPE_##kwd = val,
+#define x(kwd, val, ...) BKEY_TYPE_##kwd = val,
BCH_BTREE_IDS()
#undef x
BKEY_TYPE_btree,
}
#define BTREE_NODE_TYPE_HAS_TRANS_TRIGGERS \
- ((1U << BKEY_TYPE_extents)| \
- (1U << BKEY_TYPE_alloc)| \
- (1U << BKEY_TYPE_inodes)| \
- (1U << BKEY_TYPE_stripes)| \
- (1U << BKEY_TYPE_reflink)| \
- (1U << BKEY_TYPE_btree))
+ (BIT(BKEY_TYPE_extents)| \
+ BIT(BKEY_TYPE_alloc)| \
+ BIT(BKEY_TYPE_inodes)| \
+ BIT(BKEY_TYPE_stripes)| \
+ BIT(BKEY_TYPE_reflink)| \
+ BIT(BKEY_TYPE_btree))
#define BTREE_NODE_TYPE_HAS_MEM_TRIGGERS \
- ((1U << BKEY_TYPE_alloc)| \
- (1U << BKEY_TYPE_inodes)| \
- (1U << BKEY_TYPE_stripes)| \
- (1U << BKEY_TYPE_snapshots))
+ (BIT(BKEY_TYPE_alloc)| \
+ BIT(BKEY_TYPE_inodes)| \
+ BIT(BKEY_TYPE_stripes)| \
+ BIT(BKEY_TYPE_snapshots))
#define BTREE_NODE_TYPE_HAS_TRIGGERS \
(BTREE_NODE_TYPE_HAS_TRANS_TRIGGERS| \
BTREE_NODE_TYPE_HAS_MEM_TRIGGERS)
-#define BTREE_ID_IS_EXTENTS \
- ((1U << BTREE_ID_extents)| \
- (1U << BTREE_ID_reflink)| \
- (1U << BTREE_ID_freespace))
+static inline bool btree_node_type_needs_gc(enum btree_node_type type)
+{
+ return BTREE_NODE_TYPE_HAS_TRIGGERS & (1U << type);
+}
static inline bool btree_node_type_is_extents(enum btree_node_type type)
{
- return (1U << type) & BTREE_ID_IS_EXTENTS;
+ const unsigned mask = 0
+#define x(name, nr, flags, ...) |((!!((flags) & BTREE_ID_EXTENTS)) << nr)
+ BCH_BTREE_IDS()
+#undef x
+ ;
+
+ return (1U << type) & mask;
}
static inline bool btree_id_is_extents(enum btree_id btree)
return btree_node_type_is_extents((enum btree_node_type) btree);
}
-#define BTREE_ID_HAS_SNAPSHOTS \
- ((1U << BTREE_ID_extents)| \
- (1U << BTREE_ID_inodes)| \
- (1U << BTREE_ID_dirents)| \
- (1U << BTREE_ID_xattrs))
-
-#define BTREE_ID_HAS_PTRS \
- ((1U << BTREE_ID_extents)| \
- (1U << BTREE_ID_reflink))
-
static inline bool btree_type_has_snapshots(enum btree_id id)
{
- return (1 << id) & BTREE_ID_HAS_SNAPSHOTS;
+ const unsigned mask = 0
+#define x(name, nr, flags, ...) |((!!((flags) & BTREE_ID_SNAPSHOTS)) << nr)
+ BCH_BTREE_IDS()
+#undef x
+ ;
+
+ return (1U << id) & mask;
}
static inline bool btree_type_has_ptrs(enum btree_id id)
{
- return (1 << id) & BTREE_ID_HAS_PTRS;
-}
+ const unsigned mask = 0
+#define x(name, nr, flags, ...) |((!!((flags) & BTREE_ID_DATA)) << nr)
+ BCH_BTREE_IDS()
+#undef x
+ ;
-static inline bool btree_node_type_needs_gc(enum btree_node_type type)
-{
- return BTREE_NODE_TYPE_HAS_TRIGGERS & (1U << type);
+ return (1U << id) & mask;
}
struct btree_root {
int bch2_btree_bit_mod(struct btree_trans *, enum btree_id, struct bpos, bool);
-int bch2_btree_node_rewrite(struct btree_trans *, struct btree_iter *,
- struct btree *, unsigned);
-void bch2_btree_node_rewrite_async(struct bch_fs *, struct btree *);
-int bch2_btree_node_update_key(struct btree_trans *, struct btree_iter *,
- struct btree *, struct bkey_i *,
- unsigned, bool);
-int bch2_btree_node_update_key_get_iter(struct btree_trans *, struct btree *,
- struct bkey_i *, unsigned, bool);
-
int __bch2_insert_snapshot_whiteouts(struct btree_trans *, enum btree_id,
struct bpos, struct bpos);
return __bch2_insert_snapshot_whiteouts(trans, btree, old_pos, new_pos);
}
-int bch2_trans_update_extent(struct btree_trans *, struct btree_iter *,
- struct bkey_i *, enum btree_update_flags);
+int bch2_trans_update_extent_overwrite(struct btree_trans *, struct btree_iter *,
+ enum btree_update_flags,
+ struct bkey_s_c, struct bkey_s_c);
int bch2_bkey_get_empty_slot(struct btree_trans *, struct btree_iter *,
enum btree_id, struct bpos);
bch2_btree_node_hash_remove(&c->btree_cache, b);
__btree_node_free(c, b);
six_unlock_write(&b->c.lock);
- mark_btree_node_locked_noreset(path, level, SIX_LOCK_intent);
+ mark_btree_node_locked_noreset(path, level, BTREE_NODE_INTENT_LOCKED);
trans_for_each_path(trans, path)
if (path->l[level].b == b) {
mutex_unlock(&c->btree_interior_update_lock);
- mark_btree_node_locked_noreset(path, b->c.level, SIX_LOCK_intent);
+ mark_btree_node_locked_noreset(path, b->c.level, BTREE_NODE_INTENT_LOCKED);
six_unlock_write(&b->c.lock);
btree_node_write_if_need(c, b, SIX_LOCK_intent);
btree_next_sib);
}
+int bch2_btree_node_rewrite(struct btree_trans *, struct btree_iter *,
+ struct btree *, unsigned);
+void bch2_btree_node_rewrite_async(struct bch_fs *, struct btree *);
+int bch2_btree_node_update_key(struct btree_trans *, struct btree_iter *,
+ struct btree *, struct bkey_i *,
+ unsigned, bool);
+int bch2_btree_node_update_key_get_iter(struct btree_trans *, struct btree *,
+ struct bkey_i *, unsigned, bool);
+
void bch2_btree_set_root_for_read(struct bch_fs *, struct btree *);
void bch2_btree_root_alloc(struct bch_fs *, enum btree_id);
if (unlikely(flags & BTREE_TRIGGER_NORUN))
return 0;
- if (!btree_node_type_needs_gc(i->btree_id))
+ if (!btree_node_type_needs_gc((enum btree_node_type) i->btree_id))
return 0;
if (old_ops->atomic_trigger == new_ops->atomic_trigger &&
{
struct bch_fs *c = trans->c;
struct btree_insert_entry *i;
- int ret, u64s_delta = 0;
+ int ret = 0, u64s_delta = 0;
#ifdef CONFIG_BCACHEFS_DEBUG
- struct printbuf buf = PRINTBUF;
-
trans_for_each_update(trans, i) {
+ struct printbuf buf = PRINTBUF;
enum bkey_invalid_flags invalid_flags = 0;
if (!(flags & BTREE_INSERT_JOURNAL_REPLAY))
if (unlikely(bch2_bkey_invalid(c, bkey_i_to_s_c(i->k),
i->bkey_type, invalid_flags, &buf)))
- return bch2_trans_commit_bkey_invalid(trans, flags, i, &buf);
+ ret = bch2_trans_commit_bkey_invalid(trans, flags, i, &buf);
btree_insert_entry_checks(trans, i);
+ printbuf_exit(&buf);
+
+ if (ret)
+ return ret;
}
- printbuf_exit(&buf);
#endif
trans_for_each_update(trans, i) {
struct bpos new_pos)
{
struct bch_fs *c = trans->c;
- struct btree_iter old_iter, new_iter;
+ struct btree_iter old_iter, new_iter = { NULL };
struct bkey_s_c old_k, new_k;
snapshot_id_list s;
struct bkey_i *update;
if (ret)
break;
}
+ bch2_trans_iter_exit(trans, &new_iter);
bch2_trans_iter_exit(trans, &old_iter);
darray_exit(&s);
return ret;
}
-int bch2_trans_update_extent(struct btree_trans *trans,
- struct btree_iter *orig_iter,
- struct bkey_i *insert,
- enum btree_update_flags flags)
+int bch2_trans_update_extent_overwrite(struct btree_trans *trans,
+ struct btree_iter *iter,
+ enum btree_update_flags flags,
+ struct bkey_s_c old,
+ struct bkey_s_c new)
{
- struct btree_iter iter;
- struct bpos start = bkey_start_pos(&insert->k);
+ enum btree_id btree_id = iter->btree_id;
struct bkey_i *update;
+ struct bpos new_start = bkey_start_pos(new.k);
+ bool front_split = bkey_lt(bkey_start_pos(old.k), new_start);
+ bool back_split = bkey_gt(old.k->p, new.k->p);
+ int ret = 0, compressed_sectors;
+
+ /*
+ * If we're going to be splitting a compressed extent, note it
+ * so that __bch2_trans_commit() can increase our disk
+ * reservation:
+ */
+ if (((front_split && back_split) ||
+ ((front_split || back_split) && old.k->p.snapshot != new.k->p.snapshot)) &&
+ (compressed_sectors = bch2_bkey_sectors_compressed(old)))
+ trans->extra_journal_res += compressed_sectors;
+
+ if (front_split) {
+ update = bch2_bkey_make_mut_noupdate(trans, old);
+ if ((ret = PTR_ERR_OR_ZERO(update)))
+ return ret;
+
+ bch2_cut_back(new_start, update);
+
+ ret = bch2_insert_snapshot_whiteouts(trans, btree_id,
+ old.k->p, update->k.p) ?:
+ bch2_btree_insert_nonextent(trans, btree_id, update,
+ BTREE_UPDATE_INTERNAL_SNAPSHOT_NODE|flags);
+ if (ret)
+ return ret;
+ }
+
+ /* If we're overwriting in a different snapshot - middle split: */
+ if (old.k->p.snapshot != new.k->p.snapshot &&
+ (front_split || back_split)) {
+ update = bch2_bkey_make_mut_noupdate(trans, old);
+ if ((ret = PTR_ERR_OR_ZERO(update)))
+ return ret;
+
+ bch2_cut_front(new_start, update);
+ bch2_cut_back(new.k->p, update);
+
+ ret = bch2_insert_snapshot_whiteouts(trans, btree_id,
+ old.k->p, update->k.p) ?:
+ bch2_btree_insert_nonextent(trans, btree_id, update,
+ BTREE_UPDATE_INTERNAL_SNAPSHOT_NODE|flags);
+ if (ret)
+ return ret;
+ }
+
+ if (bkey_le(old.k->p, new.k->p)) {
+ update = bch2_trans_kmalloc(trans, sizeof(*update));
+ if ((ret = PTR_ERR_OR_ZERO(update)))
+ return ret;
+
+ bkey_init(&update->k);
+ update->k.p = old.k->p;
+ update->k.p.snapshot = new.k->p.snapshot;
+
+ if (new.k->p.snapshot != old.k->p.snapshot) {
+ update->k.type = KEY_TYPE_whiteout;
+ } else if (btree_type_has_snapshots(btree_id)) {
+ ret = need_whiteout_for_snapshot(trans, btree_id, update->k.p);
+ if (ret < 0)
+ return ret;
+ if (ret)
+ update->k.type = KEY_TYPE_whiteout;
+ }
+
+ ret = bch2_btree_insert_nonextent(trans, btree_id, update,
+ BTREE_UPDATE_INTERNAL_SNAPSHOT_NODE|flags);
+ if (ret)
+ return ret;
+ }
+
+ if (back_split) {
+ update = bch2_bkey_make_mut_noupdate(trans, old);
+ if ((ret = PTR_ERR_OR_ZERO(update)))
+ return ret;
+
+ bch2_cut_front(new.k->p, update);
+
+ ret = bch2_trans_update_by_path(trans, iter->path, update,
+ BTREE_UPDATE_INTERNAL_SNAPSHOT_NODE|
+ flags, _RET_IP_);
+ if (ret)
+ return ret;
+ }
+
+ return 0;
+}
+
+static int bch2_trans_update_extent(struct btree_trans *trans,
+ struct btree_iter *orig_iter,
+ struct bkey_i *insert,
+ enum btree_update_flags flags)
+{
+ struct btree_iter iter;
struct bkey_s_c k;
enum btree_id btree_id = orig_iter->btree_id;
- int ret = 0, compressed_sectors;
+ int ret = 0;
- bch2_trans_iter_init(trans, &iter, btree_id, start,
+ bch2_trans_iter_init(trans, &iter, btree_id, bkey_start_pos(&insert->k),
BTREE_ITER_INTENT|
BTREE_ITER_WITH_UPDATES|
BTREE_ITER_NOT_EXTENTS);
}
while (bkey_gt(insert->k.p, bkey_start_pos(k.k))) {
- bool front_split = bkey_lt(bkey_start_pos(k.k), start);
- bool back_split = bkey_gt(k.k->p, insert->k.p);
+ bool done = bkey_lt(insert->k.p, k.k->p);
- /*
- * If we're going to be splitting a compressed extent, note it
- * so that __bch2_trans_commit() can increase our disk
- * reservation:
- */
- if (((front_split && back_split) ||
- ((front_split || back_split) && k.k->p.snapshot != insert->k.p.snapshot)) &&
- (compressed_sectors = bch2_bkey_sectors_compressed(k)))
- trans->extra_journal_res += compressed_sectors;
-
- if (front_split) {
- update = bch2_bkey_make_mut_noupdate(trans, k);
- if ((ret = PTR_ERR_OR_ZERO(update)))
- goto err;
-
- bch2_cut_back(start, update);
-
- ret = bch2_insert_snapshot_whiteouts(trans, btree_id,
- k.k->p, update->k.p) ?:
- bch2_btree_insert_nonextent(trans, btree_id, update,
- BTREE_UPDATE_INTERNAL_SNAPSHOT_NODE|flags);
- if (ret)
- goto err;
- }
-
- if (k.k->p.snapshot != insert->k.p.snapshot &&
- (front_split || back_split)) {
- update = bch2_bkey_make_mut_noupdate(trans, k);
- if ((ret = PTR_ERR_OR_ZERO(update)))
- goto err;
-
- bch2_cut_front(start, update);
- bch2_cut_back(insert->k.p, update);
-
- ret = bch2_insert_snapshot_whiteouts(trans, btree_id,
- k.k->p, update->k.p) ?:
- bch2_btree_insert_nonextent(trans, btree_id, update,
- BTREE_UPDATE_INTERNAL_SNAPSHOT_NODE|flags);
- if (ret)
- goto err;
- }
-
- if (bkey_le(k.k->p, insert->k.p)) {
- update = bch2_trans_kmalloc(trans, sizeof(*update));
- if ((ret = PTR_ERR_OR_ZERO(update)))
- goto err;
-
- bkey_init(&update->k);
- update->k.p = k.k->p;
- update->k.p.snapshot = insert->k.p.snapshot;
-
- if (insert->k.p.snapshot != k.k->p.snapshot) {
- update->k.type = KEY_TYPE_whiteout;
- } else if (btree_type_has_snapshots(btree_id)) {
- ret = need_whiteout_for_snapshot(trans, btree_id, update->k.p);
- if (ret < 0)
- goto err;
- if (ret)
- update->k.type = KEY_TYPE_whiteout;
- }
-
- ret = bch2_btree_insert_nonextent(trans, btree_id, update,
- BTREE_UPDATE_INTERNAL_SNAPSHOT_NODE|flags);
- if (ret)
- goto err;
- }
-
- if (back_split) {
- update = bch2_bkey_make_mut_noupdate(trans, k);
- if ((ret = PTR_ERR_OR_ZERO(update)))
- goto err;
-
- bch2_cut_front(insert->k.p, update);
+ ret = bch2_trans_update_extent_overwrite(trans, &iter, flags, k, bkey_i_to_s_c(insert));
+ if (ret)
+ goto err;
- ret = bch2_trans_update_by_path(trans, iter.path, update,
- BTREE_UPDATE_INTERNAL_SNAPSHOT_NODE|
- flags, _RET_IP_);
- if (ret)
- goto err;
+ if (done)
goto out;
- }
next:
bch2_btree_iter_advance(&iter);
k = bch2_btree_iter_peek_upto(&iter, POS(insert->k.p.inode, U64_MAX));
goto err;
}
out:
- if (!bkey_deleted(&insert->k)) {
- /*
- * Rewinding iterators is expensive: get a new one and the one
- * that points to the start of insert will be cloned from:
- */
- bch2_trans_iter_exit(trans, &iter);
- bch2_trans_iter_init(trans, &iter, btree_id, insert->k.p,
- BTREE_ITER_NOT_EXTENTS|
- BTREE_ITER_INTENT);
- ret = bch2_btree_iter_traverse(&iter) ?:
- bch2_trans_update(trans, &iter, insert, flags);
- }
+ if (!bkey_deleted(&insert->k))
+ ret = bch2_btree_insert_nonextent(trans, btree_id, insert, flags);
err:
bch2_trans_iter_exit(trans, &iter);
#define darray_first(_d) ((_d).data[0])
#define darray_last(_d) ((_d).data[(_d).nr - 1])
-#define darray_insert_item(_d, _pos, _item) \
+#define darray_insert_item(_d, pos, _item) \
({ \
- size_t pos = (_pos); \
+ size_t _pos = (pos); \
int _ret = darray_make_room((_d), 1); \
\
if (!_ret) \
- array_insert_item((_d)->data, (_d)->nr, pos, (_item)); \
+ array_insert_item((_d)->data, (_d)->nr, _pos, (_item)); \
_ret; \
})
static void ec_stripe_buf_exit(struct ec_stripe_buf *buf)
{
- unsigned i;
+ if (buf->key.k.type == KEY_TYPE_stripe) {
+ struct bkey_i_stripe *s = bkey_i_to_stripe(&buf->key);
+ unsigned i;
- for (i = 0; i < buf->key.v.nr_blocks; i++) {
- kvpfree(buf->data[i], buf->size << 9);
- buf->data[i] = NULL;
+ for (i = 0; i < s->v.nr_blocks; i++) {
+ kvpfree(buf->data[i], buf->size << 9);
+ buf->data[i] = NULL;
+ }
}
}
static int ec_stripe_buf_init(struct ec_stripe_buf *buf,
unsigned offset, unsigned size)
{
- struct bch_stripe *v = &buf->key.v;
+ struct bch_stripe *v = &bkey_i_to_stripe(&buf->key)->v;
unsigned csum_granularity = 1U << v->csum_granularity_bits;
unsigned end = offset + size;
unsigned i;
memset(buf->valid, 0xFF, sizeof(buf->valid));
- for (i = 0; i < buf->key.v.nr_blocks; i++) {
+ for (i = 0; i < v->nr_blocks; i++) {
buf->data[i] = kvpmalloc(buf->size << 9, GFP_KERNEL);
if (!buf->data[i])
goto err;
static struct bch_csum ec_block_checksum(struct ec_stripe_buf *buf,
unsigned block, unsigned offset)
{
- struct bch_stripe *v = &buf->key.v;
+ struct bch_stripe *v = &bkey_i_to_stripe(&buf->key)->v;
unsigned csum_granularity = 1 << v->csum_granularity_bits;
unsigned end = buf->offset + buf->size;
unsigned len = min(csum_granularity, end - offset);
static void ec_generate_checksums(struct ec_stripe_buf *buf)
{
- struct bch_stripe *v = &buf->key.v;
+ struct bch_stripe *v = &bkey_i_to_stripe(&buf->key)->v;
unsigned i, j, csums_per_device = stripe_csums_per_device(v);
if (!v->csum_type)
static void ec_validate_checksums(struct bch_fs *c, struct ec_stripe_buf *buf)
{
- struct bch_stripe *v = &buf->key.v;
+ struct bch_stripe *v = &bkey_i_to_stripe(&buf->key)->v;
unsigned csum_granularity = 1 << v->csum_granularity_bits;
unsigned i;
if (bch2_crc_cmp(want, got)) {
struct printbuf buf2 = PRINTBUF;
- bch2_bkey_val_to_text(&buf2, c, bkey_i_to_s_c(&buf->key.k_i));
+ bch2_bkey_val_to_text(&buf2, c, bkey_i_to_s_c(&buf->key));
bch_err_ratelimited(c,
"stripe checksum error for %ps at %u:%u: csum type %u, expected %llx got %llx\n%s",
static void ec_generate_ec(struct ec_stripe_buf *buf)
{
- struct bch_stripe *v = &buf->key.v;
+ struct bch_stripe *v = &bkey_i_to_stripe(&buf->key)->v;
unsigned nr_data = v->nr_blocks - v->nr_redundant;
unsigned bytes = le16_to_cpu(v->sectors) << 9;
static unsigned ec_nr_failed(struct ec_stripe_buf *buf)
{
- return buf->key.v.nr_blocks -
- bitmap_weight(buf->valid, buf->key.v.nr_blocks);
+ struct bch_stripe *v = &bkey_i_to_stripe(&buf->key)->v;
+
+ return v->nr_blocks - bitmap_weight(buf->valid, v->nr_blocks);
}
static int ec_do_recov(struct bch_fs *c, struct ec_stripe_buf *buf)
{
- struct bch_stripe *v = &buf->key.v;
+ struct bch_stripe *v = &bkey_i_to_stripe(&buf->key)->v;
unsigned i, failed[BCH_BKEY_PTRS_MAX], nr_failed = 0;
unsigned nr_data = v->nr_blocks - v->nr_redundant;
unsigned bytes = buf->size << 9;
static void ec_block_endio(struct bio *bio)
{
struct ec_bio *ec_bio = container_of(bio, struct ec_bio, bio);
- struct bch_stripe *v = &ec_bio->buf->key.v;
+ struct bch_stripe *v = &bkey_i_to_stripe(&ec_bio->buf->key)->v;
struct bch_extent_ptr *ptr = &v->ptrs[ec_bio->idx];
struct bch_dev *ca = ec_bio->ca;
struct closure *cl = bio->bi_private;
static void ec_block_io(struct bch_fs *c, struct ec_stripe_buf *buf,
blk_opf_t opf, unsigned idx, struct closure *cl)
{
- struct bch_stripe *v = &buf->key.v;
+ struct bch_stripe *v = &bkey_i_to_stripe(&buf->key)->v;
unsigned offset = 0, bytes = buf->size << 9;
struct bch_extent_ptr *ptr = &v->ptrs[idx];
struct bch_dev *ca = bch_dev_bkey_exists(c, ptr->dev);
- enum bch_data_type data_type = idx < buf->key.v.nr_blocks - buf->key.v.nr_redundant
+ enum bch_data_type data_type = idx < v->nr_blocks - v->nr_redundant
? BCH_DATA_user
: BCH_DATA_parity;
int rw = op_is_write(opf);
ret = -ENOENT;
goto err;
}
- bkey_reassemble(&stripe->key.k_i, k);
+ bkey_reassemble(&stripe->key, k);
err:
bch2_trans_iter_exit(trans, &iter);
return ret;
return -EIO;
}
- v = &buf->key.v;
+ v = &bkey_i_to_stripe(&buf->key)->v;
if (!bch2_ptr_matches_stripe(v, rbio->pick)) {
bch_err_ratelimited(c,
struct ec_stripe_buf *s,
struct bpos *bp_pos)
{
+ struct bch_stripe *v = &bkey_i_to_stripe(&s->key)->v;
struct bch_fs *c = trans->c;
struct bch_backpointer bp;
struct btree_iter iter;
if (extent_has_stripe_ptr(k, s->key.k.p.offset))
goto out;
- ptr_c = bkey_matches_stripe(&s->key.v, k, &block);
+ ptr_c = bkey_matches_stripe(v, k, &block);
/*
* It doesn't generally make sense to erasure code cached ptrs:
* XXX: should we be incrementing a counter?
if (!ptr_c || ptr_c->cached)
goto out;
- dev = s->key.v.ptrs[block].dev;
+ dev = v->ptrs[block].dev;
n = bch2_trans_kmalloc(trans, bkey_bytes(k.k) + sizeof(stripe_ptr));
ret = PTR_ERR_OR_ZERO(n);
stripe_ptr = (struct bch_extent_stripe_ptr) {
.type = 1 << BCH_EXTENT_ENTRY_stripe_ptr,
.block = block,
- .redundancy = s->key.v.nr_redundant,
+ .redundancy = v->nr_redundant,
.idx = s->key.k.p.offset,
};
unsigned block)
{
struct bch_fs *c = trans->c;
- struct bch_extent_ptr bucket = s->key.v.ptrs[block];
+ struct bch_stripe *v = &bkey_i_to_stripe(&s->key)->v;
+ struct bch_extent_ptr bucket = v->ptrs[block];
struct bpos bucket_pos = PTR_BUCKET_POS(c, &bucket);
struct bpos bp_pos = POS_MIN;
int ret = 0;
static int ec_stripe_update_extents(struct bch_fs *c, struct ec_stripe_buf *s)
{
struct btree_trans trans;
- struct bch_stripe *v = &s->key.v;
+ struct bch_stripe *v = &bkey_i_to_stripe(&s->key)->v;
unsigned i, nr_data = v->nr_blocks - v->nr_redundant;
int ret = 0;
{
struct bch_fs *c = s->c;
struct open_bucket *ob;
- struct bch_stripe *v = &s->new_stripe.key.v;
+ struct bch_stripe *v = &bkey_i_to_stripe(&s->new_stripe.key)->v;
unsigned i, nr_data = v->nr_blocks - v->nr_redundant;
int ret;
}
for (i = 0; i < nr_data; i++)
- if (stripe_blockcount_get(&s->existing_stripe.key.v, i))
+ if (stripe_blockcount_get(&bkey_i_to_stripe(&s->existing_stripe.key)->v, i))
swap(s->new_stripe.data[i],
s->existing_stripe.data[i]);
ret = bch2_trans_do(c, &s->res, NULL,
BTREE_INSERT_NOCHECK_RW|
BTREE_INSERT_NOFAIL,
- ec_stripe_key_update(&trans, &s->new_stripe.key,
- !s->have_existing_stripe));
+ ec_stripe_key_update(&trans,
+ bkey_i_to_stripe(&s->new_stripe.key),
+ !s->have_existing_stripe));
if (ret) {
bch_err(c, "error creating stripe: error creating stripe key");
goto err;
}
static void ec_stripe_key_init(struct bch_fs *c,
- struct bkey_i_stripe *s,
+ struct bkey_i *k,
unsigned nr_data,
unsigned nr_parity,
unsigned stripe_size)
{
+ struct bkey_i_stripe *s = bkey_stripe_init(k);
unsigned u64s;
- bkey_stripe_init(&s->k_i);
s->v.sectors = cpu_to_le16(stripe_size);
s->v.algorithm = 0;
s->v.nr_blocks = nr_data + nr_parity;
BCH_BKEY_PTRS_MAX) - h->redundancy;
s->nr_parity = h->redundancy;
- ec_stripe_key_init(c, &s->new_stripe.key, s->nr_data,
- s->nr_parity, h->blocksize);
+ ec_stripe_key_init(c, &s->new_stripe.key,
+ s->nr_data, s->nr_parity, h->blocksize);
h->s = s;
return 0;
struct bch_devs_mask devs = h->devs;
struct open_bucket *ob;
struct open_buckets buckets;
+ struct bch_stripe *v = &bkey_i_to_stripe(&h->s->new_stripe.key)->v;
unsigned i, j, nr_have_parity = 0, nr_have_data = 0;
bool have_cache = true;
int ret = 0;
- BUG_ON(h->s->new_stripe.key.v.nr_blocks != h->s->nr_data + h->s->nr_parity);
- BUG_ON(h->s->new_stripe.key.v.nr_redundant != h->s->nr_parity);
+ BUG_ON(v->nr_blocks != h->s->nr_data + h->s->nr_parity);
+ BUG_ON(v->nr_redundant != h->s->nr_parity);
- for_each_set_bit(i, h->s->blocks_gotten, h->s->new_stripe.key.v.nr_blocks) {
- __clear_bit(h->s->new_stripe.key.v.ptrs[i].dev, devs.d);
+ for_each_set_bit(i, h->s->blocks_gotten, v->nr_blocks) {
+ __clear_bit(v->ptrs[i].dev, devs.d);
if (i < h->s->nr_data)
nr_have_data++;
else
BUG_ON(j >= h->s->nr_data + h->s->nr_parity);
h->s->blocks[j] = buckets.v[i];
- h->s->new_stripe.key.v.ptrs[j] = bch2_ob_ptr(c, ob);
+ v->ptrs[j] = bch2_ob_ptr(c, ob);
__set_bit(j, h->s->blocks_gotten);
}
BUG_ON(j >= h->s->nr_data);
h->s->blocks[j] = buckets.v[i];
- h->s->new_stripe.key.v.ptrs[j] = bch2_ob_ptr(c, ob);
+ v->ptrs[j] = bch2_ob_ptr(c, ob);
__set_bit(j, h->s->blocks_gotten);
}
static int __bch2_ec_stripe_head_reuse(struct btree_trans *trans, struct ec_stripe_head *h)
{
struct bch_fs *c = trans->c;
+ struct bch_stripe *new_v = &bkey_i_to_stripe(&h->s->new_stripe.key)->v;
+ struct bch_stripe *existing_v;
unsigned i;
s64 idx;
int ret;
return ret;
}
- BUG_ON(h->s->existing_stripe.key.v.nr_redundant != h->s->nr_parity);
- h->s->nr_data = h->s->existing_stripe.key.v.nr_blocks -
- h->s->existing_stripe.key.v.nr_redundant;
+ existing_v = &bkey_i_to_stripe(&h->s->existing_stripe.key)->v;
+
+ BUG_ON(existing_v->nr_redundant != h->s->nr_parity);
+ h->s->nr_data = existing_v->nr_blocks -
+ existing_v->nr_redundant;
ret = ec_stripe_buf_init(&h->s->existing_stripe, 0, h->blocksize);
if (ret) {
}
BUG_ON(h->s->existing_stripe.size != h->blocksize);
- BUG_ON(h->s->existing_stripe.size != le16_to_cpu(h->s->existing_stripe.key.v.sectors));
+ BUG_ON(h->s->existing_stripe.size != le16_to_cpu(existing_v->sectors));
/*
* Free buckets we initially allocated - they might conflict with
* blocks from the stripe we're reusing:
*/
- for_each_set_bit(i, h->s->blocks_gotten, h->s->new_stripe.key.v.nr_blocks) {
+ for_each_set_bit(i, h->s->blocks_gotten, new_v->nr_blocks) {
bch2_open_bucket_put(c, c->open_buckets + h->s->blocks[i]);
h->s->blocks[i] = 0;
}
memset(h->s->blocks_gotten, 0, sizeof(h->s->blocks_gotten));
memset(h->s->blocks_allocated, 0, sizeof(h->s->blocks_allocated));
- for (i = 0; i < h->s->existing_stripe.key.v.nr_blocks; i++) {
- if (stripe_blockcount_get(&h->s->existing_stripe.key.v, i)) {
+ for (i = 0; i < existing_v->nr_blocks; i++) {
+ if (stripe_blockcount_get(existing_v, i)) {
__set_bit(i, h->s->blocks_gotten);
__set_bit(i, h->s->blocks_allocated);
}
ec_block_io(c, &h->s->existing_stripe, READ, i, &h->s->iodone);
}
- bkey_copy(&h->s->new_stripe.key.k_i, &h->s->existing_stripe.key.k_i);
+ bkey_copy(&h->s->new_stripe.key, &h->s->existing_stripe.key);
h->s->have_existing_stripe = true;
return 0;
if (!ca)
goto found;
- for (i = 0; i < h->s->new_stripe.key.v.nr_blocks; i++) {
+ for (i = 0; i < bkey_i_to_stripe(&h->s->new_stripe.key)->v.nr_blocks; i++) {
if (!h->s->blocks[i])
continue;
break;
if (h->s) {
- for (i = 0; i < h->s->new_stripe.key.v.nr_blocks; i++)
+ for (i = 0; i < bkey_i_to_stripe(&h->s->new_stripe.key)->v.nr_blocks; i++)
BUG_ON(h->s->blocks[i]);
kfree(h->s);
void *data[BCH_BKEY_PTRS_MAX];
- union {
- struct bkey_i_stripe key;
- u64 pad[255];
- };
+ __BKEY_PADDED(key, 255);
};
struct ec_stripe_head;
void bch2_bkey_ptrs_to_text(struct printbuf *, struct bch_fs *,
struct bkey_s_c);
int bch2_bkey_ptrs_invalid(const struct bch_fs *, struct bkey_s_c,
- unsigned, struct printbuf *);
+ enum bkey_invalid_flags, struct printbuf *);
void bch2_ptr_swab(struct bkey_s);
return ret;
}
-static int fsck_inode_rm(struct btree_trans *trans, u64 inum, u32 snapshot)
-{
- struct bch_fs *c = trans->c;
- struct btree_iter iter = { NULL };
- struct bkey_i_inode_generation delete;
- struct bch_inode_unpacked inode_u;
- struct bkey_s_c k;
- int ret;
-
- do {
- ret = bch2_btree_delete_range_trans(trans, BTREE_ID_extents,
- SPOS(inum, 0, snapshot),
- SPOS(inum, U64_MAX, snapshot),
- 0, NULL) ?:
- bch2_btree_delete_range_trans(trans, BTREE_ID_dirents,
- SPOS(inum, 0, snapshot),
- SPOS(inum, U64_MAX, snapshot),
- 0, NULL) ?:
- bch2_btree_delete_range_trans(trans, BTREE_ID_xattrs,
- SPOS(inum, 0, snapshot),
- SPOS(inum, U64_MAX, snapshot),
- 0, NULL);
- } while (ret == -BCH_ERR_transaction_restart_nested);
- if (ret)
- goto err;
-retry:
- bch2_trans_begin(trans);
-
- k = bch2_bkey_get_iter(trans, &iter, BTREE_ID_inodes,
- SPOS(0, inum, snapshot), BTREE_ITER_INTENT);
- ret = bkey_err(k);
- if (ret)
- goto err;
-
- if (!bkey_is_inode(k.k)) {
- bch2_fs_inconsistent(c,
- "inode %llu:%u not found when deleting",
- inum, snapshot);
- ret = -EIO;
- goto err;
- }
-
- bch2_inode_unpack(k, &inode_u);
-
- /* Subvolume root? */
- if (inode_u.bi_subvol)
- bch_warn(c, "deleting inode %llu marked as unlinked, but also a subvolume root!?", inode_u.bi_inum);
-
- bkey_inode_generation_init(&delete.k_i);
- delete.k.p = iter.pos;
- delete.v.bi_generation = cpu_to_le32(inode_u.bi_generation + 1);
-
- ret = bch2_trans_update(trans, &iter, &delete.k_i, 0) ?:
- bch2_trans_commit(trans, NULL, NULL,
- BTREE_INSERT_NOFAIL);
-err:
- bch2_trans_iter_exit(trans, &iter);
- if (bch2_err_matches(ret, BCH_ERR_transaction_restart))
- goto retry;
-
- return ret ?: -BCH_ERR_transaction_restart_nested;
-}
-
static int __remove_dirent(struct btree_trans *trans, struct bpos pos)
{
struct bch_fs *c = trans->c;
u32 id, u32 ancestor)
{
ssize_t i;
- u32 top = seen->ids.nr ? seen->ids.data[seen->ids.nr - 1].equiv : 0;
EBUG_ON(id > ancestor);
EBUG_ON(!bch2_snapshot_is_equiv(c, id));
/* @ancestor should be the snapshot most recently added to @seen */
EBUG_ON(ancestor != seen->pos.snapshot);
- EBUG_ON(ancestor != top);
+ EBUG_ON(ancestor != seen->ids.data[seen->ids.nr - 1].equiv);
if (id == ancestor)
return true;
bch2_trans_unlock(trans);
bch2_fs_lazy_rw(c);
- ret = fsck_inode_rm(trans, u.bi_inum, iter->pos.snapshot);
+ ret = bch2_inode_rm_snapshot(trans, u.bi_inum, iter->pos.snapshot);
if (ret && !bch2_err_matches(ret, BCH_ERR_transaction_restart))
bch_err(c, "error in fsck: error while deleting inode: %s",
bch2_err_str(ret));
BUG_ON(bkey_le(pos1, bkey_start_pos(&pos2)));
- prt_str(&buf, "\n ");
- bch2_bpos_to_text(&buf, pos1);
- prt_str(&buf, "\n ");
-
- bch2_bkey_to_text(&buf, &pos2);
- prt_str(&buf, "\n ");
-
bch2_trans_iter_init(trans, &iter, btree, SPOS(pos1.inode, pos1.offset - 1, snapshot), 0);
k = bch2_btree_iter_peek_upto(&iter, POS(pos1.inode, U64_MAX));
ret = bkey_err(k);
if (ret)
goto err;
+ prt_str(&buf, "\n ");
bch2_bkey_val_to_text(&buf, c, k);
if (!bpos_eq(pos1, k.k->p)) {
if (opts->nocow)
opts->compression = opts->background_compression = opts->data_checksum = opts->erasure_code = 0;
}
+
+int bch2_inode_rm_snapshot(struct btree_trans *trans, u64 inum, u32 snapshot)
+{
+ struct bch_fs *c = trans->c;
+ struct btree_iter iter = { NULL };
+ struct bkey_i_inode_generation delete;
+ struct bch_inode_unpacked inode_u;
+ struct bkey_s_c k;
+ int ret;
+
+ do {
+ ret = bch2_btree_delete_range_trans(trans, BTREE_ID_extents,
+ SPOS(inum, 0, snapshot),
+ SPOS(inum, U64_MAX, snapshot),
+ 0, NULL) ?:
+ bch2_btree_delete_range_trans(trans, BTREE_ID_dirents,
+ SPOS(inum, 0, snapshot),
+ SPOS(inum, U64_MAX, snapshot),
+ 0, NULL) ?:
+ bch2_btree_delete_range_trans(trans, BTREE_ID_xattrs,
+ SPOS(inum, 0, snapshot),
+ SPOS(inum, U64_MAX, snapshot),
+ 0, NULL);
+ } while (ret == -BCH_ERR_transaction_restart_nested);
+ if (ret)
+ goto err;
+retry:
+ bch2_trans_begin(trans);
+
+ k = bch2_bkey_get_iter(trans, &iter, BTREE_ID_inodes,
+ SPOS(0, inum, snapshot), BTREE_ITER_INTENT);
+ ret = bkey_err(k);
+ if (ret)
+ goto err;
+
+ if (!bkey_is_inode(k.k)) {
+ bch2_fs_inconsistent(c,
+ "inode %llu:%u not found when deleting",
+ inum, snapshot);
+ ret = -EIO;
+ goto err;
+ }
+
+ bch2_inode_unpack(k, &inode_u);
+
+ /* Subvolume root? */
+ if (inode_u.bi_subvol)
+ bch_warn(c, "deleting inode %llu marked as unlinked, but also a subvolume root!?", inode_u.bi_inum);
+
+ bkey_inode_generation_init(&delete.k_i);
+ delete.k.p = iter.pos;
+ delete.v.bi_generation = cpu_to_le32(inode_u.bi_generation + 1);
+
+ ret = bch2_trans_update(trans, &iter, &delete.k_i, 0) ?:
+ bch2_trans_commit(trans, NULL, NULL,
+ BTREE_INSERT_NOFAIL);
+err:
+ bch2_trans_iter_exit(trans, &iter);
+ if (bch2_err_matches(ret, BCH_ERR_transaction_restart))
+ goto retry;
+
+ return ret ?: -BCH_ERR_transaction_restart_nested;
+}
void bch2_inode_opts_get(struct bch_io_opts *, struct bch_fs *,
struct bch_inode_unpacked *);
+int bch2_inode_rm_snapshot(struct btree_trans *, u64, u32);
+
#endif /* _BCACHEFS_INODE_H */
#include "super-io.h"
#include "util.h"
-#define x(t, n) [n] = #t,
+#define x(t, n, ...) [n] = #t,
const char * const bch2_error_actions[] = {
BCH_ERROR_ACTIONS()
#undef x
-int bch2_opt_fix_errors_parse(struct bch_fs *c, const char *val, u64 *res,
- struct printbuf *err)
+static int bch2_opt_fix_errors_parse(struct bch_fs *c, const char *val, u64 *res,
+ struct printbuf *err)
{
if (!val) {
*res = FSCK_FIX_yes;
return 0;
}
-void bch2_opt_fix_errors_to_text(struct printbuf *out,
- struct bch_fs *c,
- struct bch_sb *sb,
- u64 v)
+static void bch2_opt_fix_errors_to_text(struct printbuf *out,
+ struct bch_fs *c,
+ struct bch_sb *sb,
+ u64 v)
{
prt_str(out, bch2_fsck_fix_opts[v]);
}
-static const struct bch_opt_fn bch2_opt_fix_errors = {
- .parse = bch2_opt_fix_errors_parse,
- .to_text = bch2_opt_fix_errors_to_text,
-};
+#define bch2_opt_fix_errors (struct bch_opt_fn) { \
+ .parse = bch2_opt_fix_errors_parse, \
+ .to_text = bch2_opt_fix_errors_to_text, \
+}
const char * const bch2_d_types[BCH_DT_MAX] = {
[DT_UNKNOWN] = "unknown",
if (!new)
return NULL;
- old = c->snapshots;
+ old = rcu_dereference_protected(c->snapshots, true);
if (old)
memcpy(new->s,
rcu_dereference_protected(c->snapshots, true)->s,
return ret;
}
+static int cmp_le32(__le32 l, __le32 r)
+{
+ return cmp_int(le32_to_cpu(l), le32_to_cpu(r));
+}
+
static int check_snapshot(struct btree_trans *trans,
struct btree_iter *iter,
struct bkey_s_c k)
for (i = 0; i < ARRAY_SIZE(u->v.skip); i++)
u->v.skip[i] = cpu_to_le32(snapshot_skiplist_get(c, parent_id));
- bubble_sort(u->v.skip, ARRAY_SIZE(u->v.skip), cmp_int);
+ bubble_sort(u->v.skip, ARRAY_SIZE(u->v.skip), cmp_le32);
s = u->v;
}
ret = 0;
void bch2_fs_snapshots_exit(struct bch_fs *c)
{
- kfree(c->snapshots);
+ kfree(rcu_dereference_protected(c->snapshots, true));
}
int bch2_snapshots_read(struct bch_fs *c)
for (j = 0; j < ARRAY_SIZE(n->v.skip); j++)
n->v.skip[j] = cpu_to_le32(snapshot_skiplist_get(c, parent));
- bubble_sort(n->v.skip, ARRAY_SIZE(n->v.skip), cmp_int);
+ bubble_sort(n->v.skip, ARRAY_SIZE(n->v.skip), cmp_le32);
SET_BCH_SNAPSHOT_SUBVOL(&n->v, true);
ret = bch2_mark_snapshot(trans, BTREE_ID_snapshots, 0,
/* Superblock validate: */
-static inline void __bch2_sb_layout_size_assert(void)
-{
- BUILD_BUG_ON(sizeof(struct bch_sb_layout) != 512);
-}
-
static int validate_sb_layout(struct bch_sb_layout *layout, struct printbuf *out)
{
u64 offset, prev_offset, max_sectors;
unsigned i;
+ BUILD_BUG_ON(sizeof(struct bch_sb_layout) != 512);
+
if (!uuid_equal(&layout->magic, &BCACHE_MAGIC) &&
!uuid_equal(&layout->magic, &BCHFS_MAGIC)) {
prt_printf(out, "Not a bcachefs superblock layout");
{
struct fiemap_extent e;
- BUG_ON(iter->idx > iter->f.fm_mapped_extents);
+ BUG_ON(iter->idx > iter->f->fm_mapped_extents);
- if (iter->idx == iter->f.fm_mapped_extents) {
- xioctl(iter->fd, FS_IOC_FIEMAP, &iter->f);
+ if (iter->idx == iter->f->fm_mapped_extents) {
+ xioctl(iter->fd, FS_IOC_FIEMAP, iter->f);
- if (!iter->f.fm_mapped_extents)
+ if (!iter->f->fm_mapped_extents)
return (struct fiemap_extent) { .fe_length = 0 };
iter->idx = 0;
}
- e = iter->f.fm_extents[iter->idx++];
+ e = iter->f->fm_extents[iter->idx++];
BUG_ON(!e.fe_length);
- iter->f.fm_start = e.fe_logical + e.fe_length;
+ iter->f->fm_start = e.fe_logical + e.fe_length;
return e;
}
#include <linux/fiemap.h>
struct fiemap_iter {
- struct fiemap f;
- struct fiemap_extent fe[1024];
+ struct fiemap *f;
unsigned idx;
int fd;
};
{
memset(iter, 0, sizeof(*iter));
- iter->f.fm_extent_count = ARRAY_SIZE(iter->fe);
- iter->f.fm_length = FIEMAP_MAX_OFFSET;
+ iter->f = xmalloc(sizeof(struct fiemap) +
+ sizeof(struct fiemap_extent) * 1024);
+
+ iter->f->fm_extent_count = 1024;
+ iter->f->fm_length = FIEMAP_MAX_OFFSET;
iter->fd = fd;
}
+static inline void fiemap_iter_exit(struct fiemap_iter *iter)
+{
+ free(iter->f);
+ memset(iter, 0, sizeof(*iter));
+}
+
struct fiemap_extent fiemap_iter_next(struct fiemap_iter *);
#define fiemap_for_each(fd, iter, extent) \
projects / bcachefs-tools-debian / commitdiff