Commit dc9d98d6 authored by Kent Overstreet's avatar Kent Overstreet

bcache: Convert debug code to btree_keys

More work to disentangle various code from struct btree
Signed-off-by: default avatarKent Overstreet <kmo@daterainc.com>
parent c052dd9a
...@@ -7,11 +7,121 @@ ...@@ -7,11 +7,121 @@
#include "bcache.h" #include "bcache.h"
#include "btree.h" #include "btree.h"
#include "debug.h"
#include <linux/console.h>
#include <linux/random.h> #include <linux/random.h>
#include <linux/prefetch.h> #include <linux/prefetch.h>
#ifdef CONFIG_BCACHE_DEBUG
void bch_dump_bset(struct btree_keys *b, struct bset *i, unsigned set)
{
struct bkey *k, *next;
for (k = i->start; k < bset_bkey_last(i); k = next) {
next = bkey_next(k);
printk(KERN_ERR "block %u key %zi/%u: ", set,
(uint64_t *) k - i->d, i->keys);
if (b->ops->key_dump)
b->ops->key_dump(b, k);
else
printk("%llu:%llu\n", KEY_INODE(k), KEY_OFFSET(k));
if (next < bset_bkey_last(i) &&
bkey_cmp(k, b->ops->is_extents ?
&START_KEY(next) : next) > 0)
printk(KERN_ERR "Key skipped backwards\n");
}
}
void bch_dump_bucket(struct btree_keys *b)
{
unsigned i;
console_lock();
for (i = 0; i <= b->nsets; i++)
bch_dump_bset(b, b->set[i].data,
bset_sector_offset(b, b->set[i].data));
console_unlock();
}
int __bch_count_data(struct btree_keys *b)
{
unsigned ret = 0;
struct btree_iter iter;
struct bkey *k;
if (b->ops->is_extents)
for_each_key(b, k, &iter)
ret += KEY_SIZE(k);
return ret;
}
void __bch_check_keys(struct btree_keys *b, const char *fmt, ...)
{
va_list args;
struct bkey *k, *p = NULL;
struct btree_iter iter;
const char *err;
for_each_key(b, k, &iter) {
if (b->ops->is_extents) {
err = "Keys out of order";
if (p && bkey_cmp(&START_KEY(p), &START_KEY(k)) > 0)
goto bug;
if (bch_ptr_invalid(b, k))
continue;
err = "Overlapping keys";
if (p && bkey_cmp(p, &START_KEY(k)) > 0)
goto bug;
} else {
if (bch_ptr_bad(b, k))
continue;
err = "Duplicate keys";
if (p && !bkey_cmp(p, k))
goto bug;
}
p = k;
}
#if 0
err = "Key larger than btree node key";
if (p && bkey_cmp(p, &b->key) > 0)
goto bug;
#endif
return;
bug:
bch_dump_bucket(b);
va_start(args, fmt);
vprintk(fmt, args);
va_end(args);
panic("bch_check_keys error: %s:\n", err);
}
static void bch_btree_iter_next_check(struct btree_iter *iter)
{
struct bkey *k = iter->data->k, *next = bkey_next(k);
if (next < iter->data->end &&
bkey_cmp(k, iter->b->ops->is_extents ?
&START_KEY(next) : next) > 0) {
bch_dump_bucket(iter->b);
panic("Key skipped backwards\n");
}
}
#else
static inline void bch_btree_iter_next_check(struct btree_iter *iter) {}
#endif
/* Keylists */ /* Keylists */
int __bch_keylist_realloc(struct keylist *l, unsigned u64s) int __bch_keylist_realloc(struct keylist *l, unsigned u64s)
...@@ -1045,7 +1155,7 @@ void bch_btree_sort_partial(struct btree *b, unsigned start, ...@@ -1045,7 +1155,7 @@ void bch_btree_sort_partial(struct btree *b, unsigned start,
{ {
size_t order = b->keys.page_order, keys = 0; size_t order = b->keys.page_order, keys = 0;
struct btree_iter iter; struct btree_iter iter;
int oldsize = bch_count_data(b); int oldsize = bch_count_data(&b->keys);
__bch_btree_iter_init(&b->keys, &iter, NULL, &b->keys.set[start]); __bch_btree_iter_init(&b->keys, &iter, NULL, &b->keys.set[start]);
...@@ -1063,7 +1173,8 @@ void bch_btree_sort_partial(struct btree *b, unsigned start, ...@@ -1063,7 +1173,8 @@ void bch_btree_sort_partial(struct btree *b, unsigned start,
__btree_sort(&b->keys, &iter, start, order, false, state); __btree_sort(&b->keys, &iter, start, order, false, state);
EBUG_ON(b->written && oldsize >= 0 && bch_count_data(b) != oldsize); EBUG_ON(b->written && oldsize >= 0 &&
bch_count_data(&b->keys) != oldsize);
} }
EXPORT_SYMBOL(bch_btree_sort_partial); EXPORT_SYMBOL(bch_btree_sort_partial);
......
...@@ -193,6 +193,8 @@ struct btree_keys_ops { ...@@ -193,6 +193,8 @@ struct btree_keys_ops {
bool (*key_bad)(struct btree_keys *, const struct bkey *); bool (*key_bad)(struct btree_keys *, const struct bkey *);
bool (*key_merge)(struct btree_keys *, bool (*key_merge)(struct btree_keys *,
struct bkey *, struct bkey *); struct bkey *, struct bkey *);
void (*key_to_text)(char *, size_t, const struct bkey *);
void (*key_dump)(struct btree_keys *, const struct bkey *);
/* /*
* Only used for deciding whether to use START_KEY(k) or just the key * Only used for deciding whether to use START_KEY(k) or just the key
...@@ -243,15 +245,6 @@ static inline unsigned bset_sector_offset(struct btree_keys *b, struct bset *i) ...@@ -243,15 +245,6 @@ static inline unsigned bset_sector_offset(struct btree_keys *b, struct bset *i)
return bset_byte_offset(b, i) >> 9; return bset_byte_offset(b, i) >> 9;
} }
static inline bool btree_keys_expensive_checks(struct btree_keys *b)
{
#ifdef CONFIG_BCACHE_DEBUG
return *b->expensive_debug_checks;
#else
return false;
#endif
}
#define __set_bytes(i, k) (sizeof(*(i)) + (k) * sizeof(uint64_t)) #define __set_bytes(i, k) (sizeof(*(i)) + (k) * sizeof(uint64_t))
#define set_bytes(i) __set_bytes(i, i->keys) #define set_bytes(i) __set_bytes(i, i->keys)
...@@ -446,6 +439,12 @@ static inline bool bch_ptr_bad(struct btree_keys *b, const struct bkey *k) ...@@ -446,6 +439,12 @@ static inline bool bch_ptr_bad(struct btree_keys *b, const struct bkey *k)
return b->ops->key_bad(b, k); return b->ops->key_bad(b, k);
} }
static inline void bch_bkey_to_text(struct btree_keys *b, char *buf,
size_t size, const struct bkey *k)
{
return b->ops->key_to_text(buf, size, k);
}
/* Keylists */ /* Keylists */
struct keylist { struct keylist {
...@@ -509,7 +508,42 @@ struct bkey *bch_keylist_pop(struct keylist *); ...@@ -509,7 +508,42 @@ struct bkey *bch_keylist_pop(struct keylist *);
void bch_keylist_pop_front(struct keylist *); void bch_keylist_pop_front(struct keylist *);
int __bch_keylist_realloc(struct keylist *, unsigned); int __bch_keylist_realloc(struct keylist *, unsigned);
struct cache_set; /* Debug stuff */
const char *bch_ptr_status(struct cache_set *, const struct bkey *);
#ifdef CONFIG_BCACHE_DEBUG
int __bch_count_data(struct btree_keys *);
void __bch_check_keys(struct btree_keys *, const char *, ...);
void bch_dump_bset(struct btree_keys *, struct bset *, unsigned);
void bch_dump_bucket(struct btree_keys *);
#else
static inline int __bch_count_data(struct btree_keys *b) { return -1; }
static inline void __bch_check_keys(struct btree_keys *b, const char *fmt, ...) {}
static inline void bch_dump_bucket(struct btree_keys *b) {}
void bch_dump_bset(struct btree_keys *, struct bset *, unsigned);
#endif
static inline bool btree_keys_expensive_checks(struct btree_keys *b)
{
#ifdef CONFIG_BCACHE_DEBUG
return *b->expensive_debug_checks;
#else
return false;
#endif
}
static inline int bch_count_data(struct btree_keys *b)
{
return btree_keys_expensive_checks(b) ? __bch_count_data(b) : -1;
}
#define bch_check_keys(b, ...) \
do { \
if (btree_keys_expensive_checks(b)) \
__bch_check_keys(b, __VA_ARGS__); \
} while (0)
#endif #endif
...@@ -460,7 +460,7 @@ void bch_btree_node_write(struct btree *b, struct closure *parent) ...@@ -460,7 +460,7 @@ void bch_btree_node_write(struct btree *b, struct closure *parent)
BUG_ON(b->written >= btree_blocks(b)); BUG_ON(b->written >= btree_blocks(b));
BUG_ON(b->written && !i->keys); BUG_ON(b->written && !i->keys);
BUG_ON(btree_bset_first(b)->seq != i->seq); BUG_ON(btree_bset_first(b)->seq != i->seq);
bch_check_keys(b, "writing"); bch_check_keys(&b->keys, "writing");
cancel_delayed_work(&b->work); cancel_delayed_work(&b->work);
...@@ -2007,7 +2007,7 @@ static bool btree_insert_key(struct btree *b, struct btree_op *op, ...@@ -2007,7 +2007,7 @@ static bool btree_insert_key(struct btree *b, struct btree_op *op,
insert: bch_bset_insert(&b->keys, m, k); insert: bch_bset_insert(&b->keys, m, k);
copy: bkey_copy(m, k); copy: bkey_copy(m, k);
merged: merged:
bch_check_keys(b, "%u for %s", status, bch_check_keys(&b->keys, "%u for %s", status,
replace_key ? "replace" : "insert"); replace_key ? "replace" : "insert");
if (b->level && !KEY_OFFSET(k)) if (b->level && !KEY_OFFSET(k))
...@@ -2036,7 +2036,7 @@ static bool bch_btree_insert_keys(struct btree *b, struct btree_op *op, ...@@ -2036,7 +2036,7 @@ static bool bch_btree_insert_keys(struct btree *b, struct btree_op *op,
struct bkey *replace_key) struct bkey *replace_key)
{ {
bool ret = false; bool ret = false;
int oldsize = bch_count_data(b); int oldsize = bch_count_data(&b->keys);
while (!bch_keylist_empty(insert_keys)) { while (!bch_keylist_empty(insert_keys)) {
struct bkey *k = insert_keys->keys; struct bkey *k = insert_keys->keys;
...@@ -2066,7 +2066,7 @@ static bool bch_btree_insert_keys(struct btree *b, struct btree_op *op, ...@@ -2066,7 +2066,7 @@ static bool bch_btree_insert_keys(struct btree *b, struct btree_op *op,
BUG_ON(!bch_keylist_empty(insert_keys) && b->level); BUG_ON(!bch_keylist_empty(insert_keys) && b->level);
BUG_ON(bch_count_data(b) < oldsize); BUG_ON(bch_count_data(&b->keys) < oldsize);
return ret; return ret;
} }
......
...@@ -8,6 +8,7 @@ ...@@ -8,6 +8,7 @@
#include "bcache.h" #include "bcache.h"
#include "btree.h" #include "btree.h"
#include "debug.h" #include "debug.h"
#include "extents.h"
#include <linux/console.h> #include <linux/console.h>
#include <linux/debugfs.h> #include <linux/debugfs.h>
...@@ -17,108 +18,8 @@ ...@@ -17,108 +18,8 @@
static struct dentry *debug; static struct dentry *debug;
const char *bch_ptr_status(struct cache_set *c, const struct bkey *k)
{
unsigned i;
for (i = 0; i < KEY_PTRS(k); i++)
if (ptr_available(c, k, i)) {
struct cache *ca = PTR_CACHE(c, k, i);
size_t bucket = PTR_BUCKET_NR(c, k, i);
size_t r = bucket_remainder(c, PTR_OFFSET(k, i));
if (KEY_SIZE(k) + r > c->sb.bucket_size)
return "bad, length too big";
if (bucket < ca->sb.first_bucket)
return "bad, short offset";
if (bucket >= ca->sb.nbuckets)
return "bad, offset past end of device";
if (ptr_stale(c, k, i))
return "stale";
}
if (!bkey_cmp(k, &ZERO_KEY))
return "bad, null key";
if (!KEY_PTRS(k))
return "bad, no pointers";
if (!KEY_SIZE(k))
return "zeroed key";
return "";
}
int bch_bkey_to_text(char *buf, size_t size, const struct bkey *k)
{
unsigned i = 0;
char *out = buf, *end = buf + size;
#define p(...) (out += scnprintf(out, end - out, __VA_ARGS__))
p("%llu:%llu len %llu -> [", KEY_INODE(k), KEY_START(k), KEY_SIZE(k));
for (i = 0; i < KEY_PTRS(k); i++) {
if (i)
p(", ");
if (PTR_DEV(k, i) == PTR_CHECK_DEV)
p("check dev");
else
p("%llu:%llu gen %llu", PTR_DEV(k, i),
PTR_OFFSET(k, i), PTR_GEN(k, i));
}
p("]");
if (KEY_DIRTY(k))
p(" dirty");
if (KEY_CSUM(k))
p(" cs%llu %llx", KEY_CSUM(k), k->ptr[1]);
#undef p
return out - buf;
}
#ifdef CONFIG_BCACHE_DEBUG #ifdef CONFIG_BCACHE_DEBUG
static void dump_bset(struct btree *b, struct bset *i, unsigned set)
{
struct bkey *k, *next;
unsigned j;
char buf[80];
for (k = i->start; k < bset_bkey_last(i); k = next) {
next = bkey_next(k);
bch_bkey_to_text(buf, sizeof(buf), k);
printk(KERN_ERR "b %u k %zi/%u: %s", set,
(uint64_t *) k - i->d, i->keys, buf);
for (j = 0; j < KEY_PTRS(k); j++) {
size_t n = PTR_BUCKET_NR(b->c, k, j);
printk(" bucket %zu", n);
if (n >= b->c->sb.first_bucket && n < b->c->sb.nbuckets)
printk(" prio %i",
PTR_BUCKET(b->c, k, j)->prio);
}
printk(" %s\n", bch_ptr_status(b->c, k));
if (next < bset_bkey_last(i) &&
bkey_cmp(k, !b->level ? &START_KEY(next) : next) > 0)
printk(KERN_ERR "Key skipped backwards\n");
}
}
static void bch_dump_bucket(struct btree *b)
{
unsigned i;
console_lock();
for (i = 0; i <= b->keys.nsets; i++)
dump_bset(b, b->keys.set[i].data,
bset_block_offset(b, b->keys.set[i].data));
console_unlock();
}
#define for_each_written_bset(b, start, i) \ #define for_each_written_bset(b, start, i) \
for (i = (start); \ for (i = (start); \
(void *) i < (void *) (start) + (KEY_SIZE(&b->key) << 9) &&\ (void *) i < (void *) (start) + (KEY_SIZE(&b->key) << 9) &&\
...@@ -171,17 +72,17 @@ void bch_btree_verify(struct btree *b) ...@@ -171,17 +72,17 @@ void bch_btree_verify(struct btree *b)
console_lock(); console_lock();
printk(KERN_ERR "*** in memory:\n"); printk(KERN_ERR "*** in memory:\n");
dump_bset(b, inmemory, 0); bch_dump_bset(&b->keys, inmemory, 0);
printk(KERN_ERR "*** read back in:\n"); printk(KERN_ERR "*** read back in:\n");
dump_bset(v, sorted, 0); bch_dump_bset(&v->keys, sorted, 0);
for_each_written_bset(b, ondisk, i) { for_each_written_bset(b, ondisk, i) {
unsigned block = ((void *) i - (void *) ondisk) / unsigned block = ((void *) i - (void *) ondisk) /
block_bytes(b->c); block_bytes(b->c);
printk(KERN_ERR "*** on disk block %u:\n", block); printk(KERN_ERR "*** on disk block %u:\n", block);
dump_bset(b, i, block); bch_dump_bset(&b->keys, i, block);
} }
printk(KERN_ERR "*** block %zu not written\n", printk(KERN_ERR "*** block %zu not written\n",
...@@ -239,76 +140,6 @@ void bch_data_verify(struct cached_dev *dc, struct bio *bio) ...@@ -239,76 +140,6 @@ void bch_data_verify(struct cached_dev *dc, struct bio *bio)
bio_put(check); bio_put(check);
} }
int __bch_count_data(struct btree *b)
{
unsigned ret = 0;
struct btree_iter iter;
struct bkey *k;
if (!b->level)
for_each_key(&b->keys, k, &iter)
ret += KEY_SIZE(k);
return ret;
}
void __bch_check_keys(struct btree *b, const char *fmt, ...)
{
va_list args;
struct bkey *k, *p = NULL;
struct btree_iter iter;
const char *err;
for_each_key(&b->keys, k, &iter) {
if (!b->level) {
err = "Keys out of order";
if (p && bkey_cmp(&START_KEY(p), &START_KEY(k)) > 0)
goto bug;
if (bch_ptr_invalid(&b->keys, k))
continue;
err = "Overlapping keys";
if (p && bkey_cmp(p, &START_KEY(k)) > 0)
goto bug;
} else {
if (bch_ptr_bad(&b->keys, k))
continue;
err = "Duplicate keys";
if (p && !bkey_cmp(p, k))
goto bug;
}
p = k;
}
err = "Key larger than btree node key";
if (p && bkey_cmp(p, &b->key) > 0)
goto bug;
return;
bug:
bch_dump_bucket(b);
va_start(args, fmt);
vprintk(fmt, args);
va_end(args);
panic("bcache error: %s:\n", err);
}
void bch_btree_iter_next_check(struct btree_iter *iter)
{
#if 0
struct bkey *k = iter->data->k, *next = bkey_next(k);
if (next < iter->data->end &&
bkey_cmp(k, iter->b->level ? next : &START_KEY(next)) > 0) {
bch_dump_bucket(iter->b);
panic("Key skipped backwards\n");
}
#endif
}
#endif #endif
#ifdef CONFIG_DEBUG_FS #ifdef CONFIG_DEBUG_FS
...@@ -355,7 +186,7 @@ static ssize_t bch_dump_read(struct file *file, char __user *buf, ...@@ -355,7 +186,7 @@ static ssize_t bch_dump_read(struct file *file, char __user *buf,
if (!w) if (!w)
break; break;
bch_bkey_to_text(kbuf, sizeof(kbuf), &w->key); bch_extent_to_text(kbuf, sizeof(kbuf), &w->key);
i->bytes = snprintf(i->buf, PAGE_SIZE, "%s\n", kbuf); i->bytes = snprintf(i->buf, PAGE_SIZE, "%s\n", kbuf);
bch_keybuf_del(&i->keys, w); bch_keybuf_del(&i->keys, w);
} }
......
#ifndef _BCACHE_DEBUG_H #ifndef _BCACHE_DEBUG_H
#define _BCACHE_DEBUG_H #define _BCACHE_DEBUG_H
/* Btree/bkey debug printing */ struct bio;
struct cached_dev;
int bch_bkey_to_text(char *buf, size_t size, const struct bkey *k); struct cache_set;
#ifdef CONFIG_BCACHE_DEBUG #ifdef CONFIG_BCACHE_DEBUG
void bch_btree_verify(struct btree *); void bch_btree_verify(struct btree *);
void bch_data_verify(struct cached_dev *, struct bio *); void bch_data_verify(struct cached_dev *, struct bio *);
int __bch_count_data(struct btree *);
void __bch_check_keys(struct btree *, const char *, ...);
void bch_btree_iter_next_check(struct btree_iter *);
#define EBUG_ON(cond) BUG_ON(cond)
#define expensive_debug_checks(c) ((c)->expensive_debug_checks) #define expensive_debug_checks(c) ((c)->expensive_debug_checks)
#define key_merging_disabled(c) ((c)->key_merging_disabled) #define key_merging_disabled(c) ((c)->key_merging_disabled)
#define bypass_torture_test(d) ((d)->bypass_torture_test) #define bypass_torture_test(d) ((d)->bypass_torture_test)
...@@ -22,26 +18,13 @@ void bch_btree_iter_next_check(struct btree_iter *); ...@@ -22,26 +18,13 @@ void bch_btree_iter_next_check(struct btree_iter *);
static inline void bch_btree_verify(struct btree *b) {} static inline void bch_btree_verify(struct btree *b) {}
static inline void bch_data_verify(struct cached_dev *dc, struct bio *bio) {} static inline void bch_data_verify(struct cached_dev *dc, struct bio *bio) {}
static inline int __bch_count_data(struct btree *b) { return -1; }
static inline void __bch_check_keys(struct btree *b, const char *fmt, ...) {}
static inline void bch_btree_iter_next_check(struct btree_iter *iter) {}
#define EBUG_ON(cond) do { if (cond); } while (0)
#define expensive_debug_checks(c) 0 #define expensive_debug_checks(c) 0
#define key_merging_disabled(c) 0 #define key_merging_disabled(c) 0
#define bypass_torture_test(d) 0 #define bypass_torture_test(d) 0
#endif #endif
#define bch_count_data(b) \
(expensive_debug_checks((b)->c) ? __bch_count_data(b) : -1)
#define bch_check_keys(b, ...) \
do { \
if (expensive_debug_checks((b)->c)) \
__bch_check_keys(b, __VA_ARGS__); \
} while (0)
#ifdef CONFIG_DEBUG_FS #ifdef CONFIG_DEBUG_FS
void bch_debug_init_cache_set(struct cache_set *); void bch_debug_init_cache_set(struct cache_set *);
#else #else
......
...@@ -62,6 +62,87 @@ static bool __ptr_invalid(struct cache_set *c, const struct bkey *k) ...@@ -62,6 +62,87 @@ static bool __ptr_invalid(struct cache_set *c, const struct bkey *k)
return false; return false;
} }
/* Common among btree and extent ptrs */
static const char *bch_ptr_status(struct cache_set *c, const struct bkey *k)
{
unsigned i;
for (i = 0; i < KEY_PTRS(k); i++)
if (ptr_available(c, k, i)) {
struct cache *ca = PTR_CACHE(c, k, i);
size_t bucket = PTR_BUCKET_NR(c, k, i);
size_t r = bucket_remainder(c, PTR_OFFSET(k, i));
if (KEY_SIZE(k) + r > c->sb.bucket_size)
return "bad, length too big";
if (bucket < ca->sb.first_bucket)
return "bad, short offset";
if (bucket >= ca->sb.nbuckets)
return "bad, offset past end of device";
if (ptr_stale(c, k, i))
return "stale";
}
if (!bkey_cmp(k, &ZERO_KEY))
return "bad, null key";
if (!KEY_PTRS(k))
return "bad, no pointers";
if (!KEY_SIZE(k))
return "zeroed key";
return "";
}
void bch_extent_to_text(char *buf, size_t size, const struct bkey *k)
{
unsigned i = 0;
char *out = buf, *end = buf + size;
#define p(...) (out += scnprintf(out, end - out, __VA_ARGS__))
p("%llu:%llu len %llu -> [", KEY_INODE(k), KEY_START(k), KEY_SIZE(k));
for (i = 0; i < KEY_PTRS(k); i++) {
if (i)
p(", ");
if (PTR_DEV(k, i) == PTR_CHECK_DEV)
p("check dev");
else
p("%llu:%llu gen %llu", PTR_DEV(k, i),
PTR_OFFSET(k, i), PTR_GEN(k, i));
}
p("]");
if (KEY_DIRTY(k))
p(" dirty");
if (KEY_CSUM(k))
p(" cs%llu %llx", KEY_CSUM(k), k->ptr[1]);
#undef p
}
static void bch_bkey_dump(struct btree_keys *keys, const struct bkey *k)
{
struct btree *b = container_of(keys, struct btree, keys);
unsigned j;
char buf[80];
bch_extent_to_text(buf, sizeof(buf), k);
printk(" %s", buf);
for (j = 0; j < KEY_PTRS(k); j++) {
size_t n = PTR_BUCKET_NR(b->c, k, j);
printk(" bucket %zu", n);
if (n >= b->c->sb.first_bucket && n < b->c->sb.nbuckets)
printk(" prio %i",
PTR_BUCKET(b->c, k, j)->prio);
}
printk(" %s\n", bch_ptr_status(b->c, k));
}
/* Btree ptrs */ /* Btree ptrs */
bool __bch_btree_ptr_invalid(struct cache_set *c, const struct bkey *k) bool __bch_btree_ptr_invalid(struct cache_set *c, const struct bkey *k)
...@@ -76,7 +157,7 @@ bool __bch_btree_ptr_invalid(struct cache_set *c, const struct bkey *k) ...@@ -76,7 +157,7 @@ bool __bch_btree_ptr_invalid(struct cache_set *c, const struct bkey *k)
return false; return false;
bad: bad:
bch_bkey_to_text(buf, sizeof(buf), k); bch_extent_to_text(buf, sizeof(buf), k);
cache_bug(c, "spotted btree ptr %s: %s", buf, bch_ptr_status(c, k)); cache_bug(c, "spotted btree ptr %s: %s", buf, bch_ptr_status(c, k));
return true; return true;
} }
...@@ -111,7 +192,7 @@ static bool btree_ptr_bad_expensive(struct btree *b, const struct bkey *k) ...@@ -111,7 +192,7 @@ static bool btree_ptr_bad_expensive(struct btree *b, const struct bkey *k)
return false; return false;
err: err:
mutex_unlock(&b->c->bucket_lock); mutex_unlock(&b->c->bucket_lock);
bch_bkey_to_text(buf, sizeof(buf), k); bch_extent_to_text(buf, sizeof(buf), k);
btree_bug(b, btree_bug(b,
"inconsistent btree pointer %s: bucket %li pin %i prio %i gen %i last_gc %i mark %llu gc_gen %i", "inconsistent btree pointer %s: bucket %li pin %i prio %i gen %i last_gc %i mark %llu gc_gen %i",
buf, PTR_BUCKET_NR(b->c, k, i), atomic_read(&g->pin), buf, PTR_BUCKET_NR(b->c, k, i), atomic_read(&g->pin),
...@@ -145,6 +226,8 @@ const struct btree_keys_ops bch_btree_keys_ops = { ...@@ -145,6 +226,8 @@ const struct btree_keys_ops bch_btree_keys_ops = {
.sort_cmp = bch_key_sort_cmp, .sort_cmp = bch_key_sort_cmp,
.key_invalid = bch_btree_ptr_invalid, .key_invalid = bch_btree_ptr_invalid,
.key_bad = bch_btree_ptr_bad, .key_bad = bch_btree_ptr_bad,
.key_to_text = bch_extent_to_text,
.key_dump = bch_bkey_dump,
}; };
/* Extents */ /* Extents */
...@@ -227,7 +310,7 @@ static bool bch_extent_invalid(struct btree_keys *bk, const struct bkey *k) ...@@ -227,7 +310,7 @@ static bool bch_extent_invalid(struct btree_keys *bk, const struct bkey *k)
return false; return false;
bad: bad:
bch_bkey_to_text(buf, sizeof(buf), k); bch_extent_to_text(buf, sizeof(buf), k);
cache_bug(b->c, "spotted extent %s: %s", buf, bch_ptr_status(b->c, k)); cache_bug(b->c, "spotted extent %s: %s", buf, bch_ptr_status(b->c, k));
return true; return true;
} }
...@@ -254,7 +337,7 @@ static bool bch_extent_bad_expensive(struct btree *b, const struct bkey *k, ...@@ -254,7 +337,7 @@ static bool bch_extent_bad_expensive(struct btree *b, const struct bkey *k,
return false; return false;
err: err:
mutex_unlock(&b->c->bucket_lock); mutex_unlock(&b->c->bucket_lock);
bch_bkey_to_text(buf, sizeof(buf), k); bch_extent_to_text(buf, sizeof(buf), k);
btree_bug(b, btree_bug(b,
"inconsistent extent pointer %s:\nbucket %zu pin %i prio %i gen %i last_gc %i mark %llu gc_gen %i", "inconsistent extent pointer %s:\nbucket %zu pin %i prio %i gen %i last_gc %i mark %llu gc_gen %i",
buf, PTR_BUCKET_NR(b->c, k, ptr), atomic_read(&g->pin), buf, PTR_BUCKET_NR(b->c, k, ptr), atomic_read(&g->pin),
...@@ -355,5 +438,7 @@ const struct btree_keys_ops bch_extent_keys_ops = { ...@@ -355,5 +438,7 @@ const struct btree_keys_ops bch_extent_keys_ops = {
.key_invalid = bch_extent_invalid, .key_invalid = bch_extent_invalid,
.key_bad = bch_extent_bad, .key_bad = bch_extent_bad,
.key_merge = bch_extent_merge, .key_merge = bch_extent_merge,
.key_to_text = bch_extent_to_text,
.key_dump = bch_bkey_dump,
.is_extents = true, .is_extents = true,
}; };
...@@ -7,6 +7,7 @@ extern const struct btree_keys_ops bch_extent_keys_ops; ...@@ -7,6 +7,7 @@ extern const struct btree_keys_ops bch_extent_keys_ops;
struct bkey; struct bkey;
struct cache_set; struct cache_set;
void bch_extent_to_text(char *, size_t, const struct bkey *);
bool __bch_btree_ptr_invalid(struct cache_set *, const struct bkey *); bool __bch_btree_ptr_invalid(struct cache_set *, const struct bkey *);
#endif /* _BCACHE_EXTENTS_H */ #endif /* _BCACHE_EXTENTS_H */
...@@ -384,7 +384,7 @@ static void uuid_io(struct cache_set *c, unsigned long rw, ...@@ -384,7 +384,7 @@ static void uuid_io(struct cache_set *c, unsigned long rw,
break; break;
} }
bch_bkey_to_text(buf, sizeof(buf), k); bch_extent_to_text(buf, sizeof(buf), k);
pr_debug("%s UUIDs at %s", rw & REQ_WRITE ? "wrote" : "read", buf); pr_debug("%s UUIDs at %s", rw & REQ_WRITE ? "wrote" : "read", buf);
for (u = c->uuids; u < c->uuids + c->nr_uuids; u++) for (u = c->uuids; u < c->uuids + c->nr_uuids; u++)
......
...@@ -18,11 +18,13 @@ struct closure; ...@@ -18,11 +18,13 @@ struct closure;
#ifdef CONFIG_BCACHE_DEBUG #ifdef CONFIG_BCACHE_DEBUG
#define EBUG_ON(cond) BUG_ON(cond)
#define atomic_dec_bug(v) BUG_ON(atomic_dec_return(v) < 0) #define atomic_dec_bug(v) BUG_ON(atomic_dec_return(v) < 0)
#define atomic_inc_bug(v, i) BUG_ON(atomic_inc_return(v) <= i) #define atomic_inc_bug(v, i) BUG_ON(atomic_inc_return(v) <= i)
#else /* DEBUG */ #else /* DEBUG */
#define EBUG_ON(cond) do { if (cond); } while (0)
#define atomic_dec_bug(v) atomic_dec(v) #define atomic_dec_bug(v) atomic_dec(v)
#define atomic_inc_bug(v, i) atomic_inc(v) #define atomic_inc_bug(v, i) atomic_inc(v)
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment