-7227ff07f14b424e92b13dd5099aba9ece1ec43c
+d7dbddc4504c1bf509f8eb5818b5042342dc9ed1
if (bkey_cmp(k.k->p, end) > 0)
break;
- bch2_bkey_val_to_text(c, bkey_type(0, btree_id),
- buf, sizeof(buf), k);
+ bch2_bkey_val_to_text(&PBUF(buf), c,
+ bkey_type(0, btree_id), k);
puts(buf);
}
bch2_btree_iter_unlock(&iter);
if (bkey_cmp(b->key.k.p, end) > 0)
break;
- bch2_print_btree_node(c, b, buf, sizeof(buf));
+ bch2_btree_node_to_text(&PBUF(buf), c, b);
puts(buf);
}
bch2_btree_iter_unlock(&iter);
if (bkey_cmp(b->key.k.p, end) > 0)
break;
- bch2_print_btree_node(c, b, buf, sizeof(buf));
+ bch2_btree_node_to_text(&PBUF(buf), c, b);
fputs(buf, stdout);
- buf[0] = '\t';
-
for_each_btree_node_key_unpack(b, k, &node_iter, &unpacked) {
- bch2_bkey_val_to_text(c, bkey_type(0, btree_id),
- buf + 1, sizeof(buf) - 1, k);
+ bch2_bkey_val_to_text(&PBUF(buf), c,
+ bkey_type(0, btree_id), k);
+ putchar('\t');
puts(buf);
}
}
strcpy(group, "(none)");
}
- bch2_scnprint_flag_list(data_allowed_str,
- sizeof(data_allowed_str),
- bch2_data_types,
- BCH_MEMBER_DATA_ALLOWED(m));
+ bch2_flags_to_text(&PBUF(data_allowed_str),
+ bch2_data_types,
+ BCH_MEMBER_DATA_ALLOWED(m));
if (!data_allowed_str[0])
strcpy(data_allowed_str, "(none)");
- bch2_scnprint_flag_list(data_has_str,
- sizeof(data_has_str),
- bch2_data_types,
- get_dev_has_data(sb, i));
+ bch2_flags_to_text(&PBUF(data_has_str),
+ bch2_data_types,
+ get_dev_has_data(sb, i));
if (!data_has_str[0])
strcpy(data_has_str, "(none)");
vstruct_for_each(sb, f)
fields_have |= 1 << le32_to_cpu(f->type);
- bch2_scnprint_flag_list(fields_have_str, sizeof(fields_have_str),
- bch2_sb_fields, fields_have);
+ bch2_flags_to_text(&PBUF(fields_have_str),
+ bch2_sb_fields, fields_have);
printf("External UUID: %s\n"
"Internal UUID: %s\n"
return NULL;
}
-int bch2_alloc_to_text(struct bch_fs *c, char *buf,
- size_t size, struct bkey_s_c k)
+void bch2_alloc_to_text(struct printbuf *out, struct bch_fs *c,
+ struct bkey_s_c k)
{
- buf[0] = '\0';
-
switch (k.k->type) {
- case BCH_ALLOC:
+ case BCH_ALLOC: {
+ struct bkey_s_c_alloc a = bkey_s_c_to_alloc(k);
+
+ pr_buf(out, "gen %u", a.v->gen);
break;
}
-
- return 0;
+ }
}
static inline unsigned get_alloc_field(const u8 **p, unsigned bytes)
#define ALLOC_SCAN_BATCH(ca) max_t(size_t, 1, (ca)->mi.nbuckets >> 9)
const char *bch2_alloc_invalid(const struct bch_fs *, struct bkey_s_c);
-int bch2_alloc_to_text(struct bch_fs *, char *, size_t, struct bkey_s_c);
+void bch2_alloc_to_text(struct printbuf *, struct bch_fs *, struct bkey_s_c);
#define bch2_bkey_alloc_ops (struct bkey_ops) { \
.key_invalid = bch2_alloc_invalid, \
char buf1[160], buf2[160];
char buf3[160], buf4[160];
- bch2_bkey_to_text(buf1, sizeof(buf1), unpacked);
- bch2_bkey_to_text(buf2, sizeof(buf2), &tmp);
+ bch2_bkey_to_text(&PBUF(buf1), unpacked);
+ bch2_bkey_to_text(&PBUF(buf2), &tmp);
bch2_to_binary(buf3, (void *) unpacked, 80);
bch2_to_binary(buf4, high_word(format, packed), 80);
if (invalid) {
char buf[160];
- bch2_bkey_val_to_text(c, type, buf, sizeof(buf), k);
+ bch2_bkey_val_to_text(&PBUF(buf), c, type, k);
bch2_fs_bug(c, "invalid bkey %s: %s", buf, invalid);
return;
}
ops->key_debugcheck(c, b, k);
}
-#define p(...) (out += scnprintf(out, end - out, __VA_ARGS__))
-
-int bch2_bpos_to_text(char *buf, size_t size, struct bpos pos)
+void bch2_bpos_to_text(struct printbuf *out, struct bpos pos)
{
- char *out = buf, *end = buf + size;
-
if (!bkey_cmp(pos, POS_MIN))
- p("POS_MIN");
+ pr_buf(out, "POS_MIN");
else if (!bkey_cmp(pos, POS_MAX))
- p("POS_MAX");
+ pr_buf(out, "POS_MAX");
else
- p("%llu:%llu", pos.inode, pos.offset);
-
- return out - buf;
+ pr_buf(out, "%llu:%llu", pos.inode, pos.offset);
}
-int bch2_bkey_to_text(char *buf, size_t size, const struct bkey *k)
+void bch2_bkey_to_text(struct printbuf *out, const struct bkey *k)
{
- char *out = buf, *end = buf + size;
-
- p("u64s %u type %u ", k->u64s, k->type);
+ pr_buf(out, "u64s %u type %u ", k->u64s, k->type);
- out += bch2_bpos_to_text(out, end - out, k->p);
+ bch2_bpos_to_text(out, k->p);
- p(" snap %u len %u ver %llu", k->p.snapshot, k->size, k->version.lo);
-
- return out - buf;
+ pr_buf(out, " snap %u len %u ver %llu",
+ k->p.snapshot, k->size, k->version.lo);
}
-int bch2_val_to_text(struct bch_fs *c, enum bkey_type type,
- char *buf, size_t size, struct bkey_s_c k)
+void bch2_val_to_text(struct printbuf *out, struct bch_fs *c,
+ enum bkey_type type, struct bkey_s_c k)
{
const struct bkey_ops *ops = &bch2_bkey_ops[type];
- char *out = buf, *end = buf + size;
switch (k.k->type) {
case KEY_TYPE_DELETED:
- p(" deleted");
+ pr_buf(out, " deleted");
break;
case KEY_TYPE_DISCARD:
- p(" discard");
+ pr_buf(out, " discard");
break;
case KEY_TYPE_ERROR:
- p(" error");
+ pr_buf(out, " error");
break;
case KEY_TYPE_COOKIE:
- p(" cookie");
+ pr_buf(out, " cookie");
break;
default:
if (k.k->type >= KEY_TYPE_GENERIC_NR && ops->val_to_text)
- out += ops->val_to_text(c, out, end - out, k);
+ ops->val_to_text(out, c, k);
break;
}
-
- return out - buf;
}
-int bch2_bkey_val_to_text(struct bch_fs *c, enum bkey_type type,
- char *buf, size_t size, struct bkey_s_c k)
+void bch2_bkey_val_to_text(struct printbuf *out, struct bch_fs *c,
+ enum bkey_type type, struct bkey_s_c k)
{
- char *out = buf, *end = buf + size;
-
- out += bch2_bkey_to_text(out, end - out, k.k);
- out += scnprintf(out, end - out, ": ");
- out += bch2_val_to_text(c, type, out, end - out, k);
-
- return out - buf;
+ bch2_bkey_to_text(out, k.k);
+ pr_buf(out, ": ");
+ bch2_val_to_text(out, c, type, k);
}
void bch2_bkey_swab(enum bkey_type type,
struct bkey_s_c);
void (*key_debugcheck)(struct bch_fs *, struct btree *,
struct bkey_s_c);
- int (*val_to_text)(struct bch_fs *, char *,
- size_t, struct bkey_s_c);
+ void (*val_to_text)(struct printbuf *, struct bch_fs *,
+ struct bkey_s_c);
void (*swab)(const struct bkey_format *, struct bkey_packed *);
key_filter_fn key_normalize;
key_merge_fn key_merge;
void bch2_bkey_debugcheck(struct bch_fs *, struct btree *, struct bkey_s_c);
-int bch2_bpos_to_text(char *, size_t, struct bpos);
-int bch2_bkey_to_text(char *, size_t, const struct bkey *);
-int bch2_val_to_text(struct bch_fs *, enum bkey_type,
- char *, size_t, struct bkey_s_c);
-int bch2_bkey_val_to_text(struct bch_fs *, enum bkey_type,
- char *, size_t, struct bkey_s_c);
+void bch2_bpos_to_text(struct printbuf *, struct bpos);
+void bch2_bkey_to_text(struct printbuf *, const struct bkey *);
+void bch2_val_to_text(struct printbuf *, struct bch_fs *, enum bkey_type,
+ struct bkey_s_c);
+void bch2_bkey_val_to_text(struct printbuf *, struct bch_fs *,
+ enum bkey_type, struct bkey_s_c);
void bch2_bkey_swab(enum bkey_type, const struct bkey_format *,
struct bkey_packed *);
_k = _n, k = n) {
_n = bkey_next(_k);
- bch2_bkey_to_text(buf, sizeof(buf), &k);
+ bch2_bkey_to_text(&PBUF(buf), &k);
printk(KERN_ERR "block %u key %5u: %s\n", set,
__btree_node_key_to_offset(b, _k), buf);
struct bkey uk = bkey_unpack_key(b, k);
char buf[100];
- bch2_bkey_to_text(buf, sizeof(buf), &uk);
+ bch2_bkey_to_text(&PBUF(buf), &uk);
printk(KERN_ERR "set %zu key %zi/%u: %s\n", t - b->set,
k->_data - bset(b, t)->_data, bset(b, t)->u64s, buf);
}
char buf1[80], buf2[80];
bch2_dump_btree_node(b);
- bch2_bkey_to_text(buf1, sizeof(buf1), &ku);
- bch2_bkey_to_text(buf2, sizeof(buf2), &nu);
+ bch2_bkey_to_text(&PBUF(buf1), &ku);
+ bch2_bkey_to_text(&PBUF(buf2), &nu);
printk(KERN_ERR "out of order/overlapping:\n%s\n%s\n",
buf1, buf2);
printk(KERN_ERR "iter was:");
char buf2[100];
bch2_dump_btree_node(b);
- bch2_bkey_to_text(buf1, sizeof(buf1), &k1);
- bch2_bkey_to_text(buf2, sizeof(buf2), &k2);
+ bch2_bkey_to_text(&PBUF(buf1), &k1);
+ bch2_bkey_to_text(&PBUF(buf2), &k2);
panic("prev > insert:\n"
"prev key %5u %s\n"
char buf2[100];
bch2_dump_btree_node(b);
- bch2_bkey_to_text(buf1, sizeof(buf1), &k1);
- bch2_bkey_to_text(buf2, sizeof(buf2), &k2);
+ bch2_bkey_to_text(&PBUF(buf1), &k1);
+ bch2_bkey_to_text(&PBUF(buf2), &k2);
panic("insert > next:\n"
"insert key %5u %s\n"
}
}
-int bch2_bkey_print_bfloat(struct btree *b, struct bkey_packed *k,
- char *buf, size_t size)
+void bch2_bfloat_to_text(struct printbuf *out, struct btree *b,
+ struct bkey_packed *k)
{
struct bset_tree *t = bch2_bkey_to_bset(b, k);
struct bkey_packed *l, *r, *p;
char buf1[200], buf2[200];
unsigned j, inorder;
- if (!size)
- return 0;
+ if (out->pos != out->end)
+ *out->pos = '\0';
if (!bset_has_ro_aux_tree(t))
- goto out;
+ return;
inorder = bkey_to_cacheline(b, t, k);
if (!inorder || inorder >= t->size)
- goto out;
+ return;
j = __inorder_to_eytzinger1(inorder, t->size, t->extra);
if (k != tree_to_bkey(b, t, j))
- goto out;
+ return;
switch (bkey_float(b, t, j)->exponent) {
case BFLOAT_FAILED_UNPACKED:
uk = bkey_unpack_key(b, k);
- return scnprintf(buf, size,
- " failed unpacked at depth %u\n"
- "\t%llu:%llu\n",
- ilog2(j),
- uk.p.inode, uk.p.offset);
+ pr_buf(out,
+ " failed unpacked at depth %u\n"
+ "\t%llu:%llu\n",
+ ilog2(j),
+ uk.p.inode, uk.p.offset);
+ break;
case BFLOAT_FAILED_PREV:
p = tree_to_prev_bkey(b, t, j);
l = is_power_of_2(j)
bch2_to_binary(buf1, high_word(&b->format, p), b->nr_key_bits);
bch2_to_binary(buf2, high_word(&b->format, k), b->nr_key_bits);
- return scnprintf(buf, size,
- " failed prev at depth %u\n"
- "\tkey starts at bit %u but first differing bit at %u\n"
- "\t%llu:%llu\n"
- "\t%llu:%llu\n"
- "\t%s\n"
- "\t%s\n",
- ilog2(j),
- bch2_bkey_greatest_differing_bit(b, l, r),
- bch2_bkey_greatest_differing_bit(b, p, k),
- uk.p.inode, uk.p.offset,
- up.p.inode, up.p.offset,
- buf1, buf2);
+ pr_buf(out,
+ " failed prev at depth %u\n"
+ "\tkey starts at bit %u but first differing bit at %u\n"
+ "\t%llu:%llu\n"
+ "\t%llu:%llu\n"
+ "\t%s\n"
+ "\t%s\n",
+ ilog2(j),
+ bch2_bkey_greatest_differing_bit(b, l, r),
+ bch2_bkey_greatest_differing_bit(b, p, k),
+ uk.p.inode, uk.p.offset,
+ up.p.inode, up.p.offset,
+ buf1, buf2);
+ break;
case BFLOAT_FAILED_OVERFLOW:
uk = bkey_unpack_key(b, k);
- return scnprintf(buf, size,
- " failed overflow at depth %u\n"
- "\t%llu:%llu\n",
- ilog2(j),
- uk.p.inode, uk.p.offset);
+ pr_buf(out,
+ " failed overflow at depth %u\n"
+ "\t%llu:%llu\n",
+ ilog2(j),
+ uk.p.inode, uk.p.offset);
+ break;
}
-out:
- *buf = '\0';
- return 0;
}
};
void bch2_btree_keys_stats(struct btree *, struct bset_stats *);
-int bch2_bkey_print_bfloat(struct btree *, struct bkey_packed *,
- char *, size_t);
+void bch2_bfloat_to_text(struct printbuf *, struct btree *,
+ struct bkey_packed *);
/* Debug stuff */
bch2_btree_node_fill(c, iter, k, level, SIX_LOCK_read, false);
}
-int bch2_print_btree_node(struct bch_fs *c, struct btree *b,
- char *buf, size_t len)
+void bch2_btree_node_to_text(struct printbuf *out, struct bch_fs *c,
+ struct btree *b)
{
const struct bkey_format *f = &b->format;
struct bset_stats stats;
- char ptrs[100];
memset(&stats, 0, sizeof(stats));
- bch2_val_to_text(c, BKEY_TYPE_BTREE, ptrs, sizeof(ptrs),
- bkey_i_to_s_c(&b->key));
bch2_btree_keys_stats(b, &stats);
- return scnprintf(buf, len,
- "l %u %llu:%llu - %llu:%llu:\n"
- " ptrs: %s\n"
- " format: u64s %u fields %u %u %u %u %u\n"
- " unpack fn len: %u\n"
- " bytes used %zu/%zu (%zu%% full)\n"
- " sib u64s: %u, %u (merge threshold %zu)\n"
- " nr packed keys %u\n"
- " nr unpacked keys %u\n"
- " floats %zu\n"
- " failed unpacked %zu\n"
- " failed prev %zu\n"
- " failed overflow %zu\n",
- b->level,
- b->data->min_key.inode,
- b->data->min_key.offset,
- b->data->max_key.inode,
- b->data->max_key.offset,
- ptrs,
- f->key_u64s,
- f->bits_per_field[0],
- f->bits_per_field[1],
- f->bits_per_field[2],
- f->bits_per_field[3],
- f->bits_per_field[4],
- b->unpack_fn_len,
- b->nr.live_u64s * sizeof(u64),
- btree_bytes(c) - sizeof(struct btree_node),
- b->nr.live_u64s * 100 / btree_max_u64s(c),
- b->sib_u64s[0],
- b->sib_u64s[1],
- BTREE_FOREGROUND_MERGE_THRESHOLD(c),
- b->nr.packed_keys,
- b->nr.unpacked_keys,
- stats.floats,
- stats.failed_unpacked,
- stats.failed_prev,
- stats.failed_overflow);
+ pr_buf(out,
+ "l %u %llu:%llu - %llu:%llu:\n"
+ " ptrs: ",
+ b->level,
+ b->data->min_key.inode,
+ b->data->min_key.offset,
+ b->data->max_key.inode,
+ b->data->max_key.offset);
+ bch2_val_to_text(out, c, BKEY_TYPE_BTREE,
+ bkey_i_to_s_c(&b->key));
+ pr_buf(out, "\n"
+ " format: u64s %u fields %u %u %u %u %u\n"
+ " unpack fn len: %u\n"
+ " bytes used %zu/%zu (%zu%% full)\n"
+ " sib u64s: %u, %u (merge threshold %zu)\n"
+ " nr packed keys %u\n"
+ " nr unpacked keys %u\n"
+ " floats %zu\n"
+ " failed unpacked %zu\n"
+ " failed prev %zu\n"
+ " failed overflow %zu\n",
+ f->key_u64s,
+ f->bits_per_field[0],
+ f->bits_per_field[1],
+ f->bits_per_field[2],
+ f->bits_per_field[3],
+ f->bits_per_field[4],
+ b->unpack_fn_len,
+ b->nr.live_u64s * sizeof(u64),
+ btree_bytes(c) - sizeof(struct btree_node),
+ b->nr.live_u64s * 100 / btree_max_u64s(c),
+ b->sib_u64s[0],
+ b->sib_u64s[1],
+ BTREE_FOREGROUND_MERGE_THRESHOLD(c),
+ b->nr.packed_keys,
+ b->nr.unpacked_keys,
+ stats.floats,
+ stats.failed_unpacked,
+ stats.failed_prev,
+ stats.failed_overflow);
}
#define btree_node_root(_c, _b) ((_c)->btree_roots[(_b)->btree_id].b)
-int bch2_print_btree_node(struct bch_fs *, struct btree *,
- char *, size_t);
+void bch2_btree_node_to_text(struct printbuf *, struct bch_fs *,
+ struct btree *);
#endif /* _BCACHEFS_BTREE_CACHE_H */
vstruct_end(i) - (void *) i->_data);
}
-static int btree_err_msg(struct bch_fs *c, struct btree *b, struct bset *i,
- unsigned offset, int write, char *buf, size_t len)
+static void btree_err_msg(struct printbuf *out, struct bch_fs *c,
+ struct btree *b, struct bset *i,
+ unsigned offset, int write)
{
- char *out = buf, *end = buf + len;
-
- out += scnprintf(out, end - out,
- "error validating btree node %s"
- "at btree %u level %u/%u\n"
- "pos %llu:%llu node offset %u",
- write ? "before write " : "",
- b->btree_id, b->level,
- c->btree_roots[b->btree_id].level,
- b->key.k.p.inode, b->key.k.p.offset,
- b->written);
+ pr_buf(out, "error validating btree node %s"
+ "at btree %u level %u/%u\n"
+ "pos %llu:%llu node offset %u",
+ write ? "before write " : "",
+ b->btree_id, b->level,
+ c->btree_roots[b->btree_id].level,
+ b->key.k.p.inode, b->key.k.p.offset,
+ b->written);
if (i)
- out += scnprintf(out, end - out,
- " bset u64s %u",
- le16_to_cpu(i->u64s));
-
- return out - buf;
+ pr_buf(out, " bset u64s %u", le16_to_cpu(i->u64s));
}
enum btree_err_type {
#define btree_err(type, c, b, i, msg, ...) \
({ \
__label__ out; \
- char _buf[300], *out = _buf, *end = out + sizeof(_buf); \
+ char _buf[300]; \
+ struct printbuf out = PBUF(_buf); \
\
- out += btree_err_msg(c, b, i, b->written, write, out, end - out);\
- out += scnprintf(out, end - out, ": " msg, ##__VA_ARGS__); \
+ btree_err_msg(&out, c, b, i, b->written, write); \
+ pr_buf(&out, ": " msg, ##__VA_ARGS__); \
\
if (type == BTREE_ERR_FIXABLE && \
write == READ && \
if (invalid) {
char buf[160];
- bch2_bkey_val_to_text(c, type, buf, sizeof(buf), u);
+ bch2_bkey_val_to_text(&PBUF(buf), c, type, u);
btree_err(BTREE_ERR_FIXABLE, c, b, i,
"invalid bkey:\n%s\n%s", invalid, buf);
!bversion_cmp(u.k->version, MAX_VERSION))) {
char buf[160];
- bch2_bkey_val_to_text(c, type, buf, sizeof(buf), u);
+ bch2_bkey_val_to_text(&PBUF(buf), c, type, u);
btree_err(BTREE_ERR_FIXABLE, c, b, i,
"invalid bkey %s: %s", buf, invalid);
ssize_t bch2_dirty_btree_nodes_print(struct bch_fs *c, char *buf)
{
- char *out = buf, *end = buf + PAGE_SIZE;
+ struct printbuf out = _PBUF(buf, PAGE_SIZE);
struct bucket_table *tbl;
struct rhash_head *pos;
struct btree *b;
!(b->will_make_reachable & 1))
continue;
- out += scnprintf(out, end - out, "%p d %u l %u w %u b %u r %u:%lu c %u p %u\n",
- b,
- (flags & (1 << BTREE_NODE_dirty)) != 0,
- b->level,
- b->written,
- !list_empty_careful(&b->write_blocked),
- b->will_make_reachable != 0,
- b->will_make_reachable & 1,
- b->writes[ idx].wait.list.first != NULL,
- b->writes[!idx].wait.list.first != NULL);
+ pr_buf(&out, "%p d %u l %u w %u b %u r %u:%lu c %u p %u\n",
+ b,
+ (flags & (1 << BTREE_NODE_dirty)) != 0,
+ b->level,
+ b->written,
+ !list_empty_careful(&b->write_blocked),
+ b->will_make_reachable != 0,
+ b->will_make_reachable & 1,
+ b->writes[ idx].wait.list.first != NULL,
+ b->writes[!idx].wait.list.first != NULL);
}
rcu_read_unlock();
- return out - buf;
+ return out.pos - buf;
}
char buf[100];
struct bkey uk = bkey_unpack_key(b, k);
- bch2_bkey_to_text(buf, sizeof(buf), &uk);
+ bch2_bkey_to_text(&PBUF(buf), &uk);
panic("prev key should be before iter pos:\n%s\n%llu:%llu\n",
buf, iter->pos.inode, iter->pos.offset);
}
char buf[100];
struct bkey uk = bkey_unpack_key(b, k);
- bch2_bkey_to_text(buf, sizeof(buf), &uk);
+ bch2_bkey_to_text(&PBUF(buf), &uk);
panic("iter should be after current key:\n"
"iter pos %llu:%llu\n"
"cur key %s\n",
char buf[100];
struct bkey uk = bkey_unpack_key(b, k);
- bch2_bkey_to_text(buf, sizeof(buf), &uk);
+ bch2_bkey_to_text(&PBUF(buf), &uk);
panic("parent iter doesn't point to new node:\n%s\n%llu:%llu\n",
buf, b->key.k.p.inode, b->key.k.p.offset);
}
: KEY_OFFSET_MAX) -
n.p.offset));
- //EBUG_ON(!n.size);
- if (!n.size) {
- char buf[100];
- bch2_dump_btree_node(iter->l[0].b);
-
- bch2_bkey_to_text(buf, sizeof(buf), k.k);
- panic("iter at %llu:%llu\n"
- "next key %s\n",
- iter->pos.inode,
- iter->pos.offset,
- buf);
- }
+ EBUG_ON(!n.size);
iter->k = n;
iter->uptodate = BTREE_ITER_UPTODATE;
ssize_t bch2_btree_updates_print(struct bch_fs *c, char *buf)
{
- char *out = buf, *end = buf + PAGE_SIZE;
+ struct printbuf out = _PBUF(buf, PAGE_SIZE);
struct btree_update *as;
mutex_lock(&c->btree_interior_update_lock);
list_for_each_entry(as, &c->btree_interior_update_list, list)
- out += scnprintf(out, end - out, "%p m %u w %u r %u j %llu\n",
- as,
- as->mode,
- as->nodes_written,
- atomic_read(&as->cl.remaining) & CLOSURE_REMAINING_MASK,
- as->journal.seq);
+ pr_buf(&out, "%p m %u w %u r %u j %llu\n",
+ as,
+ as->mode,
+ as->nodes_written,
+ atomic_read(&as->cl.remaining) & CLOSURE_REMAINING_MASK,
+ as->journal.seq);
mutex_unlock(&c->btree_interior_update_lock);
- return out - buf;
+ return out.pos - buf;
}
size_t bch2_btree_interior_updates_nr_pending(struct bch_fs *c)
k = bch2_btree_iter_peek(&iter);
while (k.k && !(err = btree_iter_err(k))) {
- bch2_bkey_val_to_text(i->c, bkey_type(0, i->id),
- i->buf, sizeof(i->buf), k);
+ bch2_bkey_val_to_text(&PBUF(i->buf), i->c,
+ bkey_type(0, i->id), k);
i->bytes = strlen(i->buf);
BUG_ON(i->bytes >= PAGE_SIZE);
i->buf[i->bytes] = '\n';
return i->ret;
for_each_btree_node(&iter, i->c, i->id, i->from, 0, b) {
- i->bytes = bch2_print_btree_node(i->c, b, i->buf,
- sizeof(i->buf));
+ bch2_btree_node_to_text(&PBUF(i->buf), i->c, b);
+ i->bytes = strlen(i->buf);
err = flush_buf(i);
if (err)
break;
bch2_btree_node_iter_peek(&l->iter, l->b);
if (l->b != prev_node) {
- i->bytes = bch2_print_btree_node(i->c, l->b, i->buf,
- sizeof(i->buf));
+ bch2_btree_node_to_text(&PBUF(i->buf), i->c, l->b);
+ i->bytes = strlen(i->buf);
err = flush_buf(i);
if (err)
break;
}
prev_node = l->b;
- i->bytes = bch2_bkey_print_bfloat(l->b, _k, i->buf,
- sizeof(i->buf));
-
+ bch2_bfloat_to_text(&PBUF(i->buf), l->b, _k);
+ i->bytes = strlen(i->buf);
err = flush_buf(i);
if (err)
break;
}
}
-int bch2_dirent_to_text(struct bch_fs *c, char *buf,
- size_t size, struct bkey_s_c k)
+void bch2_dirent_to_text(struct printbuf *out, struct bch_fs *c,
+ struct bkey_s_c k)
{
- char *out = buf, *end = buf + size;
struct bkey_s_c_dirent d;
switch (k.k->type) {
case BCH_DIRENT:
d = bkey_s_c_to_dirent(k);
- out += bch_scnmemcpy(out, end - out, d.v->d_name,
- bch2_dirent_name_bytes(d));
- out += scnprintf(out, end - out, " -> %llu", d.v->d_inum);
+ bch_scnmemcpy(out, d.v->d_name,
+ bch2_dirent_name_bytes(d));
+ pr_buf(out, " -> %llu", d.v->d_inum);
break;
case BCH_DIRENT_WHITEOUT:
- out += scnprintf(out, end - out, "whiteout");
+ pr_buf(out, "whiteout");
break;
}
-
- return out - buf;
}
static struct bkey_i_dirent *dirent_create_key(struct btree_trans *trans,
extern const struct bch_hash_desc bch2_dirent_hash_desc;
const char *bch2_dirent_invalid(const struct bch_fs *, struct bkey_s_c);
-int bch2_dirent_to_text(struct bch_fs *, char *, size_t, struct bkey_s_c);
+void bch2_dirent_to_text(struct printbuf *, struct bch_fs *, struct bkey_s_c);
#define bch2_bkey_dirent_ops (struct bkey_ops) { \
.key_invalid = bch2_dirent_invalid, \
return err;
}
-static size_t bch2_sb_disk_groups_to_text(char *buf, size_t size,
+static void bch2_sb_disk_groups_to_text(struct printbuf *out,
struct bch_sb *sb,
struct bch_sb_field *f)
{
- char *out = buf, *end = buf + size;
struct bch_sb_field_disk_groups *groups =
field_to_type(f, disk_groups);
struct bch_disk_group *g;
g < groups->entries + nr_groups;
g++) {
if (g != groups->entries)
- out += scnprintf(out, end - out, " ");
+ pr_buf(out, " ");
if (BCH_GROUP_DELETED(g))
- out += scnprintf(out, end - out, "[deleted]");
+ pr_buf(out, "[deleted]");
else
- out += scnprintf(out, end - out,
- "[parent %llu name %s]",
- BCH_GROUP_PARENT(g),
- g->label);
+ pr_buf(out, "[parent %llu name %s]",
+ BCH_GROUP_PARENT(g), g->label);
}
-
- return out - buf;
}
const struct bch_sb_field_ops bch_sb_field_ops_disk_groups = {
return v;
}
-int bch2_disk_path_print(struct bch_sb_handle *sb,
- char *buf, size_t len, unsigned v)
+void bch2_disk_path_to_text(struct printbuf *out,
+ struct bch_sb_handle *sb,
+ unsigned v)
{
- char *out = buf, *end = out + len;
struct bch_sb_field_disk_groups *groups =
bch2_sb_get_disk_groups(sb->sb);
struct bch_disk_group *g;
}
while (nr) {
- unsigned b = 0;
-
v = path[--nr];
g = groups->entries + v;
- if (end != out)
- b = min_t(size_t, end - out,
- strnlen(g->label, sizeof(g->label)));
- memcpy(out, g->label, b);
- if (b < end - out)
- out[b] = '\0';
- out += b;
+ bch_scnmemcpy(out, g->label,
+ strnlen(g->label, sizeof(g->label)));
if (nr)
- out += scnprintf(out, end - out, ".");
+ pr_buf(out, ".");
}
-
- return out - buf;
+ return;
inval:
- return scnprintf(buf, len, "invalid group %u", v);
+ pr_buf(out, "invalid group %u", v);
}
int bch2_dev_group_set(struct bch_fs *c, struct bch_dev *ca, const char *name)
return -EINVAL;
}
-int bch2_opt_target_print(struct bch_fs *c, char *buf, size_t len, u64 v)
+void bch2_opt_target_to_text(struct printbuf *out, struct bch_fs *c, u64 v)
{
struct target t = target_decode(v);
- int ret;
switch (t.type) {
case TARGET_NULL:
- return scnprintf(buf, len, "none");
+ pr_buf(out, "none");
+ break;
case TARGET_DEV: {
struct bch_dev *ca;
if (ca && percpu_ref_tryget(&ca->io_ref)) {
char b[BDEVNAME_SIZE];
- ret = scnprintf(buf, len, "/dev/%s",
- bdevname(ca->disk_sb.bdev, b));
+ pr_buf(out, "/dev/%s",
+ bdevname(ca->disk_sb.bdev, b));
percpu_ref_put(&ca->io_ref);
} else if (ca) {
- ret = scnprintf(buf, len, "offline device %u", t.dev);
+ pr_buf(out, "offline device %u", t.dev);
} else {
- ret = scnprintf(buf, len, "invalid device %u", t.dev);
+ pr_buf(out, "invalid device %u", t.dev);
}
rcu_read_unlock();
}
case TARGET_GROUP:
mutex_lock(&c->sb_lock);
- ret = bch2_disk_path_print(&c->disk_sb, buf, len, t.group);
+ bch2_disk_path_to_text(out, &c->disk_sb, t.group);
mutex_unlock(&c->sb_lock);
break;
default:
BUG();
}
-
- return ret;
}
int bch2_disk_path_find(struct bch_sb_handle *, const char *);
int bch2_disk_path_find_or_create(struct bch_sb_handle *, const char *);
-int bch2_disk_path_print(struct bch_sb_handle *, char *, size_t, unsigned);
+void bch2_disk_path_to_text(struct printbuf *, struct bch_sb_handle *,
+ unsigned);
int bch2_opt_target_parse(struct bch_fs *, const char *, u64 *);
-int bch2_opt_target_print(struct bch_fs *, char *, size_t, u64);
+void bch2_opt_target_to_text(struct printbuf *, struct bch_fs *, u64);
int bch2_sb_disk_groups_to_cpu(struct bch_fs *);
return NULL;
}
-static size_t extent_print_ptrs(struct bch_fs *c, char *buf,
- size_t size, struct bkey_s_c_extent e)
+static void extent_print_ptrs(struct printbuf *out, struct bch_fs *c,
+ struct bkey_s_c_extent e)
{
- char *out = buf, *end = buf + size;
const union bch_extent_entry *entry;
struct bch_extent_crc_unpacked crc;
const struct bch_extent_ptr *ptr;
struct bch_dev *ca;
bool first = true;
-#define p(...) (out += scnprintf(out, end - out, __VA_ARGS__))
-
extent_for_each_entry(e, entry) {
if (!first)
- p(" ");
+ pr_buf(out, " ");
switch (__extent_entry_type(entry)) {
case BCH_EXTENT_ENTRY_crc32:
case BCH_EXTENT_ENTRY_crc128:
crc = bch2_extent_crc_unpack(e.k, entry_to_crc(entry));
- p("crc: c_size %u size %u offset %u nonce %u csum %u compress %u",
- crc.compressed_size,
- crc.uncompressed_size,
- crc.offset, crc.nonce,
- crc.csum_type,
- crc.compression_type);
+ pr_buf(out, "crc: c_size %u size %u offset %u nonce %u csum %u compress %u",
+ crc.compressed_size,
+ crc.uncompressed_size,
+ crc.offset, crc.nonce,
+ crc.csum_type,
+ crc.compression_type);
break;
case BCH_EXTENT_ENTRY_ptr:
ptr = entry_to_ptr(entry);
? bch_dev_bkey_exists(c, ptr->dev)
: NULL;
- p("ptr: %u:%llu gen %u%s%s", ptr->dev,
- (u64) ptr->offset, ptr->gen,
- ptr->cached ? " cached" : "",
- ca && ptr_stale(ca, ptr)
- ? " stale" : "");
+ pr_buf(out, "ptr: %u:%llu gen %u%s%s", ptr->dev,
+ (u64) ptr->offset, ptr->gen,
+ ptr->cached ? " cached" : "",
+ ca && ptr_stale(ca, ptr)
+ ? " stale" : "");
break;
default:
- p("(invalid extent entry %.16llx)", *((u64 *) entry));
+ pr_buf(out, "(invalid extent entry %.16llx)", *((u64 *) entry));
goto out;
}
}
out:
if (bkey_extent_is_cached(e.k))
- p(" cached");
-#undef p
- return out - buf;
+ pr_buf(out, " cached");
}
static struct bch_dev_io_failures *dev_io_failures(struct bch_io_failures *f,
if (!test_bit(BCH_FS_REBUILD_REPLICAS, &c->flags) &&
!bch2_bkey_replicas_marked(c, btree_node_type(b), e.s_c)) {
- bch2_bkey_val_to_text(c, btree_node_type(b),
- buf, sizeof(buf), k);
+ bch2_bkey_val_to_text(&PBUF(buf), c, btree_node_type(b), k);
bch2_fs_bug(c,
"btree key bad (replicas not marked in superblock):\n%s",
buf);
return;
err:
- bch2_bkey_val_to_text(c, btree_node_type(b), buf, sizeof(buf), k);
- bch2_fs_bug(c, "%s btree pointer %s: bucket %zi "
- "gen %i mark %08x",
- err, buf, PTR_BUCKET_NR(ca, ptr),
- mark.gen, (unsigned) mark.v.counter);
+ bch2_bkey_val_to_text(&PBUF(buf), c, btree_node_type(b), k);
+ bch2_fs_bug(c, "%s btree pointer %s: bucket %zi gen %i mark %08x",
+ err, buf, PTR_BUCKET_NR(ca, ptr),
+ mark.gen, (unsigned) mark.v.counter);
}
-int bch2_btree_ptr_to_text(struct bch_fs *c, char *buf,
- size_t size, struct bkey_s_c k)
+void bch2_btree_ptr_to_text(struct printbuf *out, struct bch_fs *c,
+ struct bkey_s_c k)
{
- char *out = buf, *end = buf + size;
const char *invalid;
-#define p(...) (out += scnprintf(out, end - out, __VA_ARGS__))
-
if (bkey_extent_is_data(k.k))
- out += extent_print_ptrs(c, buf, size, bkey_s_c_to_extent(k));
+ extent_print_ptrs(out, c, bkey_s_c_to_extent(k));
invalid = bch2_btree_ptr_invalid(c, k);
if (invalid)
- p(" invalid: %s", invalid);
-#undef p
- return out - buf;
+ pr_buf(out, " invalid: %s", invalid);
}
int bch2_btree_pick_ptr(struct bch_fs *c, const struct btree *b,
char buf1[100];
char buf2[100];
- bch2_bkey_to_text(buf1, sizeof(buf1), &insert->k);
- bch2_bkey_to_text(buf2, sizeof(buf2), &uk);
+ bch2_bkey_to_text(&PBUF(buf1), &insert->k);
+ bch2_bkey_to_text(&PBUF(buf2), &uk);
bch2_dump_btree_node(b);
panic("insert > next :\n"
}
if (replicas > BCH_REPLICAS_MAX) {
- bch2_bkey_val_to_text(c, btree_node_type(b), buf,
- sizeof(buf), e.s_c);
+ bch2_bkey_val_to_text(&PBUF(buf), c, btree_node_type(b),
+ e.s_c);
bch2_fs_bug(c,
"extent key bad (too many replicas: %u): %s",
replicas, buf);
if (!test_bit(BCH_FS_REBUILD_REPLICAS, &c->flags) &&
!bch2_bkey_replicas_marked(c, btree_node_type(b), e.s_c)) {
- bch2_bkey_val_to_text(c, btree_node_type(b),
- buf, sizeof(buf), e.s_c);
+ bch2_bkey_val_to_text(&PBUF(buf), c, btree_node_type(b),
+ e.s_c);
bch2_fs_bug(c,
"extent key bad (replicas not marked in superblock):\n%s",
buf);
return;
bad_ptr:
- bch2_bkey_val_to_text(c, btree_node_type(b), buf,
- sizeof(buf), e.s_c);
+ bch2_bkey_val_to_text(&PBUF(buf), c, btree_node_type(b),
+ e.s_c);
bch2_fs_bug(c, "extent pointer bad gc mark: %s:\nbucket %zu "
"gen %i type %u", buf,
PTR_BUCKET_NR(ca, ptr), mark.gen, mark.data_type);
- return;
}
void bch2_extent_debugcheck(struct bch_fs *c, struct btree *b, struct bkey_s_c k)
}
}
-int bch2_extent_to_text(struct bch_fs *c, char *buf,
- size_t size, struct bkey_s_c k)
+void bch2_extent_to_text(struct printbuf *out, struct bch_fs *c,
+ struct bkey_s_c k)
{
- char *out = buf, *end = buf + size;
const char *invalid;
-#define p(...) (out += scnprintf(out, end - out, __VA_ARGS__))
-
if (bkey_extent_is_data(k.k))
- out += extent_print_ptrs(c, buf, size, bkey_s_c_to_extent(k));
+ extent_print_ptrs(out, c, bkey_s_c_to_extent(k));
invalid = bch2_extent_invalid(c, k);
if (invalid)
- p(" invalid: %s", invalid);
-#undef p
- return out - buf;
+ pr_buf(out, " invalid: %s", invalid);
}
static void bch2_extent_crc_init(union bch_extent_crc *crc,
const char *bch2_btree_ptr_invalid(const struct bch_fs *, struct bkey_s_c);
void bch2_btree_ptr_debugcheck(struct bch_fs *, struct btree *,
struct bkey_s_c);
-int bch2_btree_ptr_to_text(struct bch_fs *, char *, size_t, struct bkey_s_c);
+void bch2_btree_ptr_to_text(struct printbuf *, struct bch_fs *,
+ struct bkey_s_c);
void bch2_ptr_swab(const struct bkey_format *, struct bkey_packed *);
#define bch2_bkey_btree_ops (struct bkey_ops) { \
const char *bch2_extent_invalid(const struct bch_fs *, struct bkey_s_c);
void bch2_extent_debugcheck(struct bch_fs *, struct btree *, struct bkey_s_c);
-int bch2_extent_to_text(struct bch_fs *, char *, size_t, struct bkey_s_c);
+void bch2_extent_to_text(struct printbuf *, struct bch_fs *, struct bkey_s_c);
bool bch2_ptr_normalize(struct bch_fs *, struct btree *, struct bkey_s);
enum merge_result bch2_extent_merge(struct bch_fs *, struct btree *,
struct bkey_i *, struct bkey_i *);
if (v == bch2_opt_get_by_id(&bch2_opts_default, i))
continue;
- bch2_opt_to_text(c, buf, sizeof(buf), opt, v,
+ bch2_opt_to_text(&PBUF(buf), c, opt, v,
OPT_SHOW_MOUNT_STYLE);
seq_putc(seq, ',');
seq_puts(seq, buf);
if (fsck_err_on(k2.k->type == desc.key_type &&
!desc.cmp_bkey(k, k2), c,
"duplicate hash table keys:\n%s",
- (bch2_bkey_val_to_text(c, bkey_type(0, desc.btree_id),
- buf, sizeof(buf), k), buf))) {
+ (bch2_bkey_val_to_text(&PBUF(buf), c,
+ bkey_type(0, desc.btree_id),
+ k), buf))) {
ret = fsck_hash_delete_at(desc, &h->info, k_iter);
if (ret)
return ret;
"hashed to %llu chain starts at %llu\n%s",
desc.btree_id, k.k->p.offset,
hashed, h->chain->pos.offset,
- (bch2_bkey_val_to_text(c, bkey_type(0, desc.btree_id),
- buf, sizeof(buf), k), buf))) {
+ (bch2_bkey_val_to_text(&PBUF(buf), c,
+ bkey_type(0, desc.btree_id),
+ k), buf))) {
ret = hash_redo_key(desc, h, c, k_iter, k, hashed);
if (ret) {
bch_err(c, "hash_redo_key err %i", ret);
"hashed to %llu chain starts at %llu\n%s",
buf, strlen(buf), BTREE_ID_DIRENTS,
k->k->p.offset, hash, h->chain->pos.offset,
- (bch2_bkey_val_to_text(c, bkey_type(0, BTREE_ID_DIRENTS),
- buf, sizeof(buf), *k), buf))) {
+ (bch2_bkey_val_to_text(&PBUF(buf), c,
+ bkey_type(0, BTREE_ID_DIRENTS),
+ *k), buf))) {
ret = hash_redo_key(bch2_dirent_hash_desc,
h, c, iter, *k, hash);
if (ret)
if (fsck_err_on(!w.have_inode, c,
"dirent in nonexisting directory:\n%s",
- (bch2_bkey_val_to_text(c, BTREE_ID_DIRENTS,
- buf, sizeof(buf), k), buf)) ||
+ (bch2_bkey_val_to_text(&PBUF(buf), c,
+ BTREE_ID_DIRENTS,
+ k), buf)) ||
fsck_err_on(!S_ISDIR(w.inode.bi_mode), c,
"dirent in non directory inode type %u:\n%s",
mode_to_type(w.inode.bi_mode),
- (bch2_bkey_val_to_text(c, BTREE_ID_DIRENTS,
- buf, sizeof(buf), k), buf))) {
+ (bch2_bkey_val_to_text(&PBUF(buf), c,
+ BTREE_ID_DIRENTS,
+ k), buf))) {
ret = bch2_btree_delete_at(iter, 0);
if (ret)
goto err;
if (fsck_err_on(d_inum == d.k->p.inode, c,
"dirent points to own directory:\n%s",
- (bch2_bkey_val_to_text(c, BTREE_ID_DIRENTS,
- buf, sizeof(buf), k), buf))) {
+ (bch2_bkey_val_to_text(&PBUF(buf), c,
+ BTREE_ID_DIRENTS,
+ k), buf))) {
ret = remove_dirent(c, iter, d);
if (ret)
goto err;
if (fsck_err_on(!have_target, c,
"dirent points to missing inode:\n%s",
- (bch2_bkey_val_to_text(c, BTREE_ID_DIRENTS,
- buf, sizeof(buf), k), buf))) {
+ (bch2_bkey_val_to_text(&PBUF(buf), c,
+ BTREE_ID_DIRENTS,
+ k), buf))) {
ret = remove_dirent(c, iter, d);
if (ret)
goto err;
mode_to_type(target.bi_mode), c,
"incorrect d_type: should be %u:\n%s",
mode_to_type(target.bi_mode),
- (bch2_bkey_val_to_text(c, BTREE_ID_DIRENTS,
- buf, sizeof(buf), k), buf))) {
+ (bch2_bkey_val_to_text(&PBUF(buf), c,
+ BTREE_ID_DIRENTS,
+ k), buf))) {
struct bkey_i_dirent *n;
n = kmalloc(bkey_bytes(d.k), GFP_KERNEL);
}
}
-int bch2_inode_to_text(struct bch_fs *c, char *buf,
- size_t size, struct bkey_s_c k)
+void bch2_inode_to_text(struct printbuf *out, struct bch_fs *c,
+ struct bkey_s_c k)
{
- char *out = buf, *end = out + size;
struct bkey_s_c_inode inode;
struct bch_inode_unpacked unpacked;
case BCH_INODE_FS:
inode = bkey_s_c_to_inode(k);
if (bch2_inode_unpack(inode, &unpacked)) {
- out += scnprintf(out, end - out, "(unpack error)");
+ pr_buf(out, "(unpack error)");
break;
}
#define BCH_INODE_FIELD(_name, _bits) \
- out += scnprintf(out, end - out, #_name ": %llu ", (u64) unpacked._name);
+ pr_buf(out, #_name ": %llu ", (u64) unpacked._name);
BCH_INODE_FIELDS()
#undef BCH_INODE_FIELD
break;
}
-
- return out - buf;
}
void bch2_inode_init(struct bch_fs *c, struct bch_inode_unpacked *inode_u,
#include <linux/math64.h>
const char *bch2_inode_invalid(const struct bch_fs *, struct bkey_s_c);
-int bch2_inode_to_text(struct bch_fs *, char *, size_t, struct bkey_s_c);
+void bch2_inode_to_text(struct printbuf *, struct bch_fs *, struct bkey_s_c);
#define bch2_bkey_inode_ops (struct bkey_ops) { \
.key_invalid = bch2_inode_invalid, \
ssize_t bch2_journal_print_debug(struct journal *j, char *buf)
{
+ struct printbuf out = _PBUF(buf, PAGE_SIZE);
struct bch_fs *c = container_of(j, struct bch_fs, journal);
union journal_res_state *s = &j->reservations;
struct bch_dev *ca;
unsigned iter;
- ssize_t ret = 0;
rcu_read_lock();
spin_lock(&j->lock);
- ret += scnprintf(buf + ret, PAGE_SIZE - ret,
- "active journal entries:\t%llu\n"
- "seq:\t\t\t%llu\n"
- "last_seq:\t\t%llu\n"
- "last_seq_ondisk:\t%llu\n"
- "reservation count:\t%u\n"
- "reservation offset:\t%u\n"
- "current entry u64s:\t%u\n"
- "io in flight:\t\t%i\n"
- "need write:\t\t%i\n"
- "dirty:\t\t\t%i\n"
- "replay done:\t\t%i\n",
- fifo_used(&j->pin),
- journal_cur_seq(j),
- journal_last_seq(j),
- j->last_seq_ondisk,
- journal_state_count(*s, s->idx),
- s->cur_entry_offset,
- j->cur_entry_u64s,
- s->prev_buf_unwritten,
- test_bit(JOURNAL_NEED_WRITE, &j->flags),
- journal_entry_is_open(j),
- test_bit(JOURNAL_REPLAY_DONE, &j->flags));
+ pr_buf(&out,
+ "active journal entries:\t%llu\n"
+ "seq:\t\t\t%llu\n"
+ "last_seq:\t\t%llu\n"
+ "last_seq_ondisk:\t%llu\n"
+ "reservation count:\t%u\n"
+ "reservation offset:\t%u\n"
+ "current entry u64s:\t%u\n"
+ "io in flight:\t\t%i\n"
+ "need write:\t\t%i\n"
+ "dirty:\t\t\t%i\n"
+ "replay done:\t\t%i\n",
+ fifo_used(&j->pin),
+ journal_cur_seq(j),
+ journal_last_seq(j),
+ j->last_seq_ondisk,
+ journal_state_count(*s, s->idx),
+ s->cur_entry_offset,
+ j->cur_entry_u64s,
+ s->prev_buf_unwritten,
+ test_bit(JOURNAL_NEED_WRITE, &j->flags),
+ journal_entry_is_open(j),
+ test_bit(JOURNAL_REPLAY_DONE, &j->flags));
for_each_member_device_rcu(ca, c, iter,
&c->rw_devs[BCH_DATA_JOURNAL]) {
if (!ja->nr)
continue;
- ret += scnprintf(buf + ret, PAGE_SIZE - ret,
- "dev %u:\n"
- "\tnr\t\t%u\n"
- "\tcur_idx\t\t%u (seq %llu)\n"
- "\tlast_idx\t%u (seq %llu)\n",
- iter, ja->nr,
- ja->cur_idx, ja->bucket_seq[ja->cur_idx],
- ja->last_idx, ja->bucket_seq[ja->last_idx]);
+ pr_buf(&out,
+ "dev %u:\n"
+ "\tnr\t\t%u\n"
+ "\tcur_idx\t\t%u (seq %llu)\n"
+ "\tlast_idx\t%u (seq %llu)\n",
+ iter, ja->nr,
+ ja->cur_idx, ja->bucket_seq[ja->cur_idx],
+ ja->last_idx, ja->bucket_seq[ja->last_idx]);
}
spin_unlock(&j->lock);
rcu_read_unlock();
- return ret;
+ return out.pos - buf;
}
ssize_t bch2_journal_print_pins(struct journal *j, char *buf)
{
+ struct printbuf out = _PBUF(buf, PAGE_SIZE);
struct journal_entry_pin_list *pin_list;
struct journal_entry_pin *pin;
- ssize_t ret = 0;
u64 i;
spin_lock(&j->lock);
fifo_for_each_entry_ptr(pin_list, &j->pin, i) {
- ret += scnprintf(buf + ret, PAGE_SIZE - ret,
- "%llu: count %u\n",
- i, atomic_read(&pin_list->count));
+ pr_buf(&out, "%llu: count %u\n",
+ i, atomic_read(&pin_list->count));
list_for_each_entry(pin, &pin_list->list, list)
- ret += scnprintf(buf + ret, PAGE_SIZE - ret,
- "\t%p %pf\n",
- pin, pin->flush);
+ pr_buf(&out, "\t%p %pf\n",
+ pin, pin->flush);
if (!list_empty(&pin_list->flushed))
- ret += scnprintf(buf + ret, PAGE_SIZE - ret,
- "flushed:\n");
+ pr_buf(&out, "flushed:\n");
list_for_each_entry(pin, &pin_list->flushed, list)
- ret += scnprintf(buf + ret, PAGE_SIZE - ret,
- "\t%p %pf\n",
- pin, pin->flush);
+ pr_buf(&out, "\t%p %pf\n",
+ pin, pin->flush);
}
spin_unlock(&j->lock);
- return ret;
+ return out.pos - buf;
}
{
void *next = vstruct_next(entry);
const char *invalid;
- char buf[160];
int ret = 0;
if (journal_entry_err_on(!k->k.u64s, c,
invalid = bch2_bkey_invalid(c, key_type, bkey_i_to_s_c(k));
if (invalid) {
- bch2_bkey_val_to_text(c, key_type, buf, sizeof(buf),
- bkey_i_to_s_c(k));
+ char buf[160];
+
+ bch2_bkey_val_to_text(&PBUF(buf), c, key_type,
+ bkey_i_to_s_c(k));
mustfix_fsck_err(c, "invalid %s in journal: %s\n%s",
type, invalid, buf);
#define OPT_STR(_choices) .type = BCH_OPT_STR, .choices = _choices
#define OPT_FN(_fn) .type = BCH_OPT_FN, \
.parse = _fn##_parse, \
- .print = _fn##_print
+ .to_text = _fn##_to_text
#define BCH_OPT(_name, _bits, _mode, _type, _sb_opt, _default) \
[Opt_##_name] = { \
return 0;
}
-int bch2_opt_to_text(struct bch_fs *c, char *buf, size_t len,
- const struct bch_option *opt, u64 v,
- unsigned flags)
+void bch2_opt_to_text(struct printbuf *out, struct bch_fs *c,
+ const struct bch_option *opt, u64 v,
+ unsigned flags)
{
- char *out = buf, *end = buf + len;
-
if (flags & OPT_SHOW_MOUNT_STYLE) {
- if (opt->type == BCH_OPT_BOOL)
- return scnprintf(out, end - out, "%s%s",
- v ? "" : "no",
- opt->attr.name);
+ if (opt->type == BCH_OPT_BOOL) {
+ pr_buf(out, "%s%s",
+ v ? "" : "no",
+ opt->attr.name);
+ return;
+ }
- out += scnprintf(out, end - out, "%s=", opt->attr.name);
+ pr_buf(out, "%s=", opt->attr.name);
}
switch (opt->type) {
case BCH_OPT_BOOL:
case BCH_OPT_UINT:
- out += scnprintf(out, end - out, "%lli", v);
+ pr_buf(out, "%lli", v);
break;
case BCH_OPT_STR:
- out += (flags & OPT_SHOW_FULL_LIST)
- ? bch2_scnprint_string_list(out, end - out, opt->choices, v)
- : scnprintf(out, end - out, opt->choices[v]);
+ if (flags & OPT_SHOW_FULL_LIST)
+ bch2_string_opt_to_text(out, opt->choices, v);
+ else
+ pr_buf(out, opt->choices[v]);
break;
case BCH_OPT_FN:
- return opt->print(c, out, end - out, v);
+ opt->to_text(out, c, v);
+ break;
default:
BUG();
}
-
- return out - buf;
}
int bch2_parse_mount_opts(struct bch_opts *opts, char *options)
};
struct bch_fs;
+struct printbuf;
struct bch_option {
struct attribute attr;
};
struct {
int (*parse)(struct bch_fs *, const char *, u64 *);
- int (*print)(struct bch_fs *, char *, size_t, u64);
+ void (*to_text)(struct printbuf *, struct bch_fs *, u64);
};
};
#define OPT_SHOW_FULL_LIST (1 << 0)
#define OPT_SHOW_MOUNT_STYLE (1 << 1)
-int bch2_opt_to_text(struct bch_fs *, char *, size_t,
- const struct bch_option *, u64, unsigned);
+void bch2_opt_to_text(struct printbuf *, struct bch_fs *,
+ const struct bch_option *, u64, unsigned);
int bch2_parse_mount_opts(struct bch_opts *, char *);
"inodes",
};
-int bch2_quota_to_text(struct bch_fs *c, char *buf,
- size_t size, struct bkey_s_c k)
+void bch2_quota_to_text(struct printbuf *out, struct bch_fs *c,
+ struct bkey_s_c k)
{
- char *out = buf, *end = buf + size;
struct bkey_s_c_quota dq;
unsigned i;
dq = bkey_s_c_to_quota(k);
for (i = 0; i < Q_COUNTERS; i++)
- out += scnprintf(out, end - out, "%s hardlimit %llu softlimit %llu",
- bch2_quota_counters[i],
- le64_to_cpu(dq.v->c[i].hardlimit),
- le64_to_cpu(dq.v->c[i].softlimit));
+ pr_buf(out, "%s hardlimit %llu softlimit %llu",
+ bch2_quota_counters[i],
+ le64_to_cpu(dq.v->c[i].hardlimit),
+ le64_to_cpu(dq.v->c[i].softlimit));
break;
}
-
- return out - buf;
}
#ifdef CONFIG_BCACHEFS_QUOTA
extern const struct bch_sb_field_ops bch_sb_field_ops_quota;
const char *bch2_quota_invalid(const struct bch_fs *, struct bkey_s_c);
-int bch2_quota_to_text(struct bch_fs *, char *, size_t, struct bkey_s_c);
+void bch2_quota_to_text(struct printbuf *, struct bch_fs *, struct bkey_s_c);
#define bch2_bkey_quota_ops (struct bkey_ops) { \
.key_invalid = bch2_quota_invalid, \
ssize_t bch2_rebalance_work_show(struct bch_fs *c, char *buf)
{
- char *out = buf, *end = out + PAGE_SIZE;
+ struct printbuf out = _PBUF(buf, PAGE_SIZE);
struct bch_fs_rebalance *r = &c->rebalance;
struct rebalance_work w = rebalance_work(c);
char h1[21], h2[21];
bch2_hprint(h1, w.dev_most_full_work << 9);
bch2_hprint(h2, w.dev_most_full_capacity << 9);
- out += scnprintf(out, end - out,
- "fullest_dev (%i):\t%s/%s\n",
- w.dev_most_full_idx, h1, h2);
+ pr_buf(&out, "fullest_dev (%i):\t%s/%s\n",
+ w.dev_most_full_idx, h1, h2);
bch2_hprint(h1, w.total_work << 9);
bch2_hprint(h2, c->capacity << 9);
- out += scnprintf(out, end - out,
- "total work:\t\t%s/%s\n",
- h1, h2);
+ pr_buf(&out, "total work:\t\t%s/%s\n", h1, h2);
- out += scnprintf(out, end - out,
- "rate:\t\t\t%u\n",
- r->pd.rate.rate);
+ pr_buf(&out, "rate:\t\t\t%u\n", r->pd.rate.rate);
switch (r->state) {
case REBALANCE_WAITING:
- out += scnprintf(out, end - out, "waiting\n");
+ pr_buf(&out, "waiting\n");
break;
case REBALANCE_THROTTLED:
bch2_hprint(h1,
(r->throttled_until_iotime -
atomic_long_read(&c->io_clock[WRITE].now)) << 9);
- out += scnprintf(out, end - out,
- "throttled for %lu sec or %s io\n",
- (r->throttled_until_cputime - jiffies) / HZ,
- h1);
+ pr_buf(&out, "throttled for %lu sec or %s io\n",
+ (r->throttled_until_cputime - jiffies) / HZ,
+ h1);
break;
case REBALANCE_RUNNING:
- out += scnprintf(out, end - out, "running\n");
- out += scnprintf(out, end - out, "pos %llu:%llu\n",
- r->move_stats.iter.pos.inode,
- r->move_stats.iter.pos.offset);
+ pr_buf(&out, "running\n");
+ pr_buf(&out, "pos %llu:%llu\n",
+ r->move_stats.iter.pos.inode,
+ r->move_stats.iter.pos.offset);
break;
}
- return out - buf;
+ return out.pos - buf;
}
void bch2_rebalance_stop(struct bch_fs *c)
eytzinger0_sort(r->entries, r->nr, r->entry_size, memcmp, NULL);
}
-static int replicas_entry_to_text(struct bch_replicas_entry *e,
- char *buf, size_t size)
+static void replicas_entry_to_text(struct printbuf *out,
+ struct bch_replicas_entry *e)
{
- char *out = buf, *end = out + size;
unsigned i;
- out += scnprintf(out, end - out, "%u: [", e->data_type);
+ pr_buf(out, "%u: [", e->data_type);
for (i = 0; i < e->nr_devs; i++)
- out += scnprintf(out, end - out,
- i ? " %u" : "%u", e->devs[i]);
- out += scnprintf(out, end - out, "]");
-
- return out - buf;
+ pr_buf(out, i ? " %u" : "%u", e->devs[i]);
+ pr_buf(out, "]");
}
-int bch2_cpu_replicas_to_text(struct bch_replicas_cpu *r,
- char *buf, size_t size)
+void bch2_cpu_replicas_to_text(struct printbuf *out,
+ struct bch_replicas_cpu *r)
{
- char *out = buf, *end = out + size;
struct bch_replicas_entry *e;
bool first = true;
for_each_cpu_replicas_entry(r, e) {
if (!first)
- out += scnprintf(out, end - out, " ");
+ pr_buf(out, " ");
first = false;
- out += replicas_entry_to_text(e, out, end - out);
+ replicas_entry_to_text(out, e);
}
-
- return out - buf;
}
static void extent_to_replicas(struct bkey_s_c k,
struct bch_replicas_entry_padded search;
int ret;
+ memset(&search, 0, sizeof(search));
+
if (type == BKEY_TYPE_EXTENTS) {
struct bch_devs_list cached = bch2_bkey_cached_devs(k);
unsigned i;
return err;
}
-const struct bch_sb_field_ops bch_sb_field_ops_replicas = {
- .validate = bch2_sb_validate_replicas,
-};
-
-int bch2_sb_replicas_to_text(struct bch_sb_field_replicas *r, char *buf, size_t size)
+static void bch2_sb_replicas_to_text(struct printbuf *out,
+ struct bch_sb *sb,
+ struct bch_sb_field *f)
{
- char *out = buf, *end = out + size;
+ struct bch_sb_field_replicas *r = field_to_type(f, replicas);
struct bch_replicas_entry *e;
bool first = true;
- if (!r) {
- out += scnprintf(out, end - out, "(no replicas section found)");
- return out - buf;
- }
-
for_each_replicas_entry(r, e) {
if (!first)
- out += scnprintf(out, end - out, " ");
+ pr_buf(out, " ");
first = false;
- out += replicas_entry_to_text(e, out, end - out);
+ replicas_entry_to_text(out, e);
}
-
- return out - buf;
}
+const struct bch_sb_field_ops bch_sb_field_ops_replicas = {
+ .validate = bch2_sb_validate_replicas,
+ .to_text = bch2_sb_replicas_to_text,
+};
+
/* Query replicas: */
bool bch2_replicas_marked(struct bch_fs *c,
struct bch_replicas_entry_padded search;
bool ret;
+ memset(&search, 0, sizeof(search));
+
if (type == BKEY_TYPE_EXTENTS) {
struct bch_devs_list cached = bch2_bkey_cached_devs(k);
unsigned i;
int bch2_mark_bkey_replicas(struct bch_fs *, enum bkey_type,
struct bkey_s_c);
-int bch2_cpu_replicas_to_text(struct bch_replicas_cpu *, char *, size_t);
-int bch2_sb_replicas_to_text(struct bch_sb_field_replicas *, char *, size_t);
+void bch2_cpu_replicas_to_text(struct printbuf *, struct bch_replicas_cpu *);
struct replicas_status {
struct {
: NULL;
}
-size_t bch2_sb_field_to_text(char *buf, size_t size,
- struct bch_sb *sb, struct bch_sb_field *f)
+void bch2_sb_field_to_text(struct printbuf *out, struct bch_sb *sb,
+ struct bch_sb_field *f)
{
unsigned type = le32_to_cpu(f->type);
- size_t (*to_text)(char *, size_t, struct bch_sb *,
- struct bch_sb_field *) =
- type < BCH_SB_FIELD_NR
- ? bch2_sb_field_ops[type]->to_text
- : NULL;
+ const struct bch_sb_field_ops *ops = type < BCH_SB_FIELD_NR
+ ? bch2_sb_field_ops[type] : NULL;
- if (!to_text) {
- if (size)
- buf[0] = '\0';
- return 0;
- }
+ if (ops)
+ pr_buf(out, "%s", bch2_sb_fields[type]);
+ else
+ pr_buf(out, "(unknown field %u)", type);
+
+ pr_buf(out, " (size %llu):", vstruct_bytes(f));
- return to_text(buf, size, sb, f);
+ if (ops && ops->to_text)
+ bch2_sb_field_ops[type]->to_text(out, sb, f);
}
struct bch_sb_field_ops {
const char * (*validate)(struct bch_sb *, struct bch_sb_field *);
- size_t (*to_text)(char *, size_t, struct bch_sb *,
+ void (*to_text)(struct printbuf *, struct bch_sb *,
struct bch_sb_field *);
};
void bch2_fs_mark_clean(struct bch_fs *, bool);
-size_t bch2_sb_field_to_text(char *, size_t, struct bch_sb *,
- struct bch_sb_field *);
+void bch2_sb_field_to_text(struct printbuf *, struct bch_sb *,
+ struct bch_sb_field *);
#endif /* _BCACHEFS_SUPER_IO_H */
data = bch2_dev_has_data(c, ca);
if (data) {
char data_has_str[100];
- bch2_scnprint_flag_list(data_has_str,
- sizeof(data_has_str),
- bch2_data_types,
- data);
+
+ bch2_string_opt_to_text(&PBUF(data_has_str),
+ bch2_data_types, data);
bch_err(ca, "Remove failed, still has data (%s)", data_has_str);
ret = -EBUSY;
goto err;
static ssize_t show_fs_alloc_debug(struct bch_fs *c, char *buf)
{
- char *out = buf, *end = buf + PAGE_SIZE;
+ struct printbuf out = _PBUF(buf, PAGE_SIZE);
struct bch_fs_usage stats = bch2_fs_usage_read(c);
unsigned replicas, type;
- out += scnprintf(out, end - out,
- "capacity:\t\t%llu\n",
- c->capacity);
+ pr_buf(&out, "capacity:\t\t%llu\n", c->capacity);
for (replicas = 0; replicas < ARRAY_SIZE(stats.replicas); replicas++) {
- out += scnprintf(out, end - out,
- "%u replicas:\n",
- replicas + 1);
+ pr_buf(&out, "%u replicas:\n", replicas + 1);
for (type = BCH_DATA_SB; type < BCH_DATA_NR; type++)
- out += scnprintf(out, end - out,
- "\t%s:\t\t%llu\n",
- bch2_data_types[type],
- stats.replicas[replicas].data[type]);
- out += scnprintf(out, end - out,
- "\treserved:\t%llu\n",
- stats.replicas[replicas].persistent_reserved);
+ pr_buf(&out, "\t%s:\t\t%llu\n",
+ bch2_data_types[type],
+ stats.replicas[replicas].data[type]);
+ pr_buf(&out, "\treserved:\t%llu\n",
+ stats.replicas[replicas].persistent_reserved);
}
- out += scnprintf(out, end - out, "bucket usage\n");
+ pr_buf(&out, "bucket usage\n");
for (type = BCH_DATA_SB; type < BCH_DATA_NR; type++)
- out += scnprintf(out, end - out,
- "\t%s:\t\t%llu\n",
- bch2_data_types[type],
- stats.buckets[type]);
+ pr_buf(&out, "\t%s:\t\t%llu\n",
+ bch2_data_types[type],
+ stats.buckets[type]);
- out += scnprintf(out, end - out,
- "online reserved:\t%llu\n",
- stats.online_reserved);
+ pr_buf(&out, "online reserved:\t%llu\n",
+ stats.online_reserved);
- return out - buf;
+ return out.pos - buf;
}
static ssize_t bch2_compression_stats(struct bch_fs *c, char *buf)
SHOW(bch2_fs_opts_dir)
{
- char *out = buf, *end = buf + PAGE_SIZE;
+ struct printbuf out = _PBUF(buf, PAGE_SIZE);
struct bch_fs *c = container_of(kobj, struct bch_fs, opts_dir);
const struct bch_option *opt = container_of(attr, struct bch_option, attr);
int id = opt - bch2_opt_table;
u64 v = bch2_opt_get_by_id(&c->opts, id);
- out += bch2_opt_to_text(c, out, end - out, opt, v, OPT_SHOW_FULL_LIST);
- out += scnprintf(out, end - out, "\n");
+ bch2_opt_to_text(&out, c, opt, v, OPT_SHOW_FULL_LIST);
+ pr_buf(&out, "\n");
- return out - buf;
+ return out.pos - buf;
}
STORE(bch2_fs_opts_dir)
static ssize_t show_reserve_stats(struct bch_dev *ca, char *buf)
{
+ struct printbuf out = _PBUF(buf, PAGE_SIZE);
enum alloc_reserve i;
- ssize_t ret;
spin_lock(&ca->freelist_lock);
- ret = scnprintf(buf, PAGE_SIZE,
- "free_inc:\t%zu\t%zu\n",
- fifo_used(&ca->free_inc),
- ca->free_inc.size);
+ pr_buf(&out, "free_inc:\t%zu\t%zu\n",
+ fifo_used(&ca->free_inc),
+ ca->free_inc.size);
for (i = 0; i < RESERVE_NR; i++)
- ret += scnprintf(buf + ret, PAGE_SIZE - ret,
- "free[%u]:\t%zu\t%zu\n", i,
- fifo_used(&ca->free[i]),
- ca->free[i].size);
+ pr_buf(&out, "free[%u]:\t%zu\t%zu\n", i,
+ fifo_used(&ca->free[i]),
+ ca->free[i].size);
spin_unlock(&ca->freelist_lock);
- return ret;
+ return out.pos - buf;
}
static ssize_t show_dev_alloc_debug(struct bch_dev *ca, char *buf)
static ssize_t show_dev_iodone(struct bch_dev *ca, char *buf)
{
- char *out = buf, *end = buf + PAGE_SIZE;
+ struct printbuf out = _PBUF(buf, PAGE_SIZE);
int rw, i, cpu;
for (rw = 0; rw < 2; rw++) {
- out += scnprintf(out, end - out, "%s:\n", bch2_rw[rw]);
+ pr_buf(&out, "%s:\n", bch2_rw[rw]);
for (i = 1; i < BCH_DATA_NR; i++) {
u64 n = 0;
for_each_possible_cpu(cpu)
n += per_cpu_ptr(ca->io_done, cpu)->sectors[rw][i];
- out += scnprintf(out, end - out, "%-12s:%12llu\n",
- bch2_data_types[i], n << 9);
+ pr_buf(&out, "%-12s:%12llu\n",
+ bch2_data_types[i], n << 9);
}
}
- return out - buf;
+ return out.pos - buf;
}
SHOW(bch2_dev)
{
struct bch_dev *ca = container_of(kobj, struct bch_dev, kobj);
struct bch_fs *c = ca->fs;
- char *out = buf, *end = buf + PAGE_SIZE;
+ struct printbuf out = _PBUF(buf, PAGE_SIZE);
sysfs_printf(uuid, "%pU\n", ca->uuid.b);
if (attr == &sysfs_label) {
if (ca->mi.group) {
mutex_lock(&c->sb_lock);
- out += bch2_disk_path_print(&c->disk_sb, out, end - out,
- ca->mi.group - 1);
+ bch2_disk_path_to_text(&out, &c->disk_sb,
+ ca->mi.group - 1);
mutex_unlock(&c->sb_lock);
} else {
- out += scnprintf(out, end - out, "none");
+ pr_buf(&out, "none");
}
- out += scnprintf(out, end - out, "\n");
- return out - buf;
+ pr_buf(&out, "\n");
+ return out.pos - buf;
}
if (attr == &sysfs_has_data) {
- out += bch2_scnprint_flag_list(out, end - out,
- bch2_data_types,
- bch2_dev_has_data(c, ca));
- out += scnprintf(out, end - out, "\n");
- return out - buf;
+ bch2_flags_to_text(&out, bch2_data_types,
+ bch2_dev_has_data(c, ca));
+ pr_buf(&out, "\n");
+ return out.pos - buf;
}
sysfs_pd_controller_show(copy_gc, &ca->copygc_pd);
if (attr == &sysfs_cache_replacement_policy) {
- out += bch2_scnprint_string_list(out, end - out,
- bch2_cache_replacement_policies,
- ca->mi.replacement);
- out += scnprintf(out, end - out, "\n");
- return out - buf;
+ bch2_string_opt_to_text(&out,
+ bch2_cache_replacement_policies,
+ ca->mi.replacement);
+ pr_buf(&out, "\n");
+ return out.pos - buf;
}
if (attr == &sysfs_state_rw) {
- out += bch2_scnprint_string_list(out, end - out,
- bch2_dev_state,
- ca->mi.state);
- out += scnprintf(out, end - out, "\n");
- return out - buf;
+ bch2_string_opt_to_text(&out, bch2_dev_state,
+ ca->mi.state);
+ pr_buf(&out, "\n");
+ return out.pos - buf;
}
if (attr == &sysfs_iodone)
return sprintf(buf, "%lli%s%c", v, dec, si_units[u]);
}
-ssize_t bch2_scnprint_string_list(char *buf, size_t size,
- const char * const list[],
- size_t selected)
+void bch2_string_opt_to_text(struct printbuf *out,
+ const char * const list[],
+ size_t selected)
{
- char *out = buf;
size_t i;
- if (size)
- *out = '\0';
-
for (i = 0; list[i]; i++)
- out += scnprintf(out, buf + size - out,
- i == selected ? "[%s] " : "%s ", list[i]);
-
- if (out != buf)
- *--out = '\0';
-
- return out - buf;
+ pr_buf(out, i == selected ? "[%s] " : "%s ", list[i]);
}
-ssize_t bch2_scnprint_flag_list(char *buf, size_t size,
- const char * const list[], u64 flags)
+void bch2_flags_to_text(struct printbuf *out,
+ const char * const list[], u64 flags)
{
- char *out = buf, *end = buf + size;
unsigned bit, nr = 0;
+ if (out->pos != out->end)
+ *out->pos = '\0';
+
while (list[nr])
nr++;
- if (size)
- *out = '\0';
-
while (flags && (bit = __ffs(flags)) < nr) {
- out += scnprintf(out, end - out, "%s,", list[bit]);
+ pr_buf(out, "%s,", list[bit]);
flags ^= 1 << bit;
}
-
- if (out != buf)
- *--out = '\0';
-
- return out - buf;
}
u64 bch2_read_flag_list(char *opt, const char * const list[])
return u;
}
-static size_t pr_time_units(char *buf, size_t len, u64 ns)
+static void pr_time_units(struct printbuf *out, u64 ns)
{
const struct time_unit *u = pick_time_units(ns);
- return scnprintf(buf, len, "%llu %s", div_u64(ns, u->nsecs), u->name);
+ pr_buf(out, "%llu %s", div_u64(ns, u->nsecs), u->name);
}
size_t bch2_time_stats_print(struct time_stats *stats, char *buf, size_t len)
{
- char *out = buf, *end = buf + len;
+ struct printbuf out = _PBUF(buf, len);
const struct time_unit *u;
u64 freq = READ_ONCE(stats->average_frequency);
u64 q, last_q = 0;
int i;
- out += scnprintf(out, end - out, "count:\t\t%llu\n",
+ pr_buf(&out, "count:\t\t%llu\n",
stats->count);
- out += scnprintf(out, end - out, "rate:\t\t%llu/sec\n",
- freq ? div64_u64(NSEC_PER_SEC, freq) : 0);
+ pr_buf(&out, "rate:\t\t%llu/sec\n",
+ freq ? div64_u64(NSEC_PER_SEC, freq) : 0);
- out += scnprintf(out, end - out, "frequency:\t");
- out += pr_time_units(out, end - out, freq);
+ pr_buf(&out, "frequency:\t");
+ pr_time_units(&out, freq);
- out += scnprintf(out, end - out, "\navg duration:\t");
- out += pr_time_units(out, end - out, stats->average_duration);
+ pr_buf(&out, "\navg duration:\t");
+ pr_time_units(&out, stats->average_duration);
- out += scnprintf(out, end - out, "\nmax duration:\t");
- out += pr_time_units(out, end - out, stats->max_duration);
+ pr_buf(&out, "\nmax duration:\t");
+ pr_time_units(&out, stats->max_duration);
i = eytzinger0_first(NR_QUANTILES);
u = pick_time_units(stats->quantiles.entries[i].m);
- out += scnprintf(out, end - out, "\nquantiles (%s):\t", u->name);
+ pr_buf(&out, "\nquantiles (%s):\t", u->name);
eytzinger0_for_each(i, NR_QUANTILES) {
bool is_last = eytzinger0_next(i, NR_QUANTILES) == -1;
q = max(stats->quantiles.entries[i].m, last_q);
- out += scnprintf(out, end - out, "%llu%s",
- div_u64(q, u->nsecs),
- is_last ? "\n" : " ");
+ pr_buf(&out, "%llu%s",
+ div_u64(q, u->nsecs),
+ is_last ? "\n" : " ");
last_q = q;
}
- return out - buf;
+ return out.pos - buf;
}
void bch2_time_stats_exit(struct time_stats *stats)
}
}
-size_t bch_scnmemcpy(char *buf, size_t size, const char *src, size_t len)
+void bch_scnmemcpy(struct printbuf *out,
+ const char *src, size_t len)
{
- size_t n;
-
- if (!size)
- return 0;
+ size_t n = printbuf_remaining(out);
- n = min(size - 1, len);
- memcpy(buf, src, n);
- buf[n] = '\0';
-
- return n;
+ if (n) {
+ n = min(n - 1, len);
+ memcpy(out->pos, src, n);
+ out->pos += n;
+ *out->pos = '\0';
+ }
}
#include "eytzinger.h"
#define ANYSINT_MAX(t) \
((((t) 1 << (sizeof(t) * 8 - 2)) - (t) 1) * (t) 2 + (t) 1)
+struct printbuf {
+ char *pos;
+ char *end;
+};
+
+static inline size_t printbuf_remaining(struct printbuf *buf)
+{
+ return buf->end - buf->pos;
+}
+
+#define _PBUF(_buf, _len) \
+ ((struct printbuf) { \
+ .pos = _buf, \
+ .end = _buf + _len, \
+ })
+
+#define PBUF(_buf) _PBUF(_buf, sizeof(_buf))
+
+#define pr_buf(_out, ...) \
+do { \
+ (_out)->pos += scnprintf((_out)->pos, printbuf_remaining(_out), \
+ __VA_ARGS__); \
+} while (0)
+
+void bch_scnmemcpy(struct printbuf *, const char *, size_t);
+
int bch2_strtoint_h(const char *, int *);
int bch2_strtouint_h(const char *, unsigned int *);
int bch2_strtoll_h(const char *, long long *);
bool bch2_is_zero(const void *, size_t);
-ssize_t bch2_scnprint_string_list(char *, size_t, const char * const[], size_t);
+void bch2_string_opt_to_text(struct printbuf *,
+ const char * const [], size_t);
-ssize_t bch2_scnprint_flag_list(char *, size_t, const char * const[], u64);
+void bch2_flags_to_text(struct printbuf *, const char * const[], u64);
u64 bch2_read_flag_list(char *, const char * const[]);
#define NR_QUANTILES 15
(var)->p_term_inverse, 1, INT_MAX); \
} while (0)
-#define __DIV_SAFE(n, d, zero) \
-({ \
- typeof(n) _n = (n); \
- typeof(d) _d = (d); \
- _d ? _n / _d : zero; \
-})
-
-#define DIV_SAFE(n, d) __DIV_SAFE(n, d, 0)
-
#define container_of_or_null(ptr, type, member) \
({ \
typeof(ptr) _ptr = ptr; \
_ptr ? container_of(_ptr, type, member) : NULL; \
})
-#define RB_INSERT(root, new, member, cmp) \
-({ \
- __label__ dup; \
- struct rb_node **n = &(root)->rb_node, *parent = NULL; \
- typeof(new) this; \
- int res, ret = -1; \
- \
- while (*n) { \
- parent = *n; \
- this = container_of(*n, typeof(*(new)), member); \
- res = cmp(new, this); \
- if (!res) \
- goto dup; \
- n = res < 0 \
- ? &(*n)->rb_left \
- : &(*n)->rb_right; \
- } \
- \
- rb_link_node(&(new)->member, parent, n); \
- rb_insert_color(&(new)->member, root); \
- ret = 0; \
-dup: \
- ret; \
-})
-
-#define RB_SEARCH(root, search, member, cmp) \
-({ \
- struct rb_node *n = (root)->rb_node; \
- typeof(&(search)) this, ret = NULL; \
- int res; \
- \
- while (n) { \
- this = container_of(n, typeof(search), member); \
- res = cmp(&(search), this); \
- if (!res) { \
- ret = this; \
- break; \
- } \
- n = res < 0 \
- ? n->rb_left \
- : n->rb_right; \
- } \
- ret; \
-})
-
-#define RB_GREATER(root, search, member, cmp) \
-({ \
- struct rb_node *n = (root)->rb_node; \
- typeof(&(search)) this, ret = NULL; \
- int res; \
- \
- while (n) { \
- this = container_of(n, typeof(search), member); \
- res = cmp(&(search), this); \
- if (res < 0) { \
- ret = this; \
- n = n->rb_left; \
- } else \
- n = n->rb_right; \
- } \
- ret; \
-})
-
-#define RB_FIRST(root, type, member) \
- container_of_or_null(rb_first(root), type, member)
-
-#define RB_LAST(root, type, member) \
- container_of_or_null(rb_last(root), type, member)
-
-#define RB_NEXT(ptr, member) \
- container_of_or_null(rb_next(&(ptr)->member), typeof(*ptr), member)
-
-#define RB_PREV(ptr, member) \
- container_of_or_null(rb_prev(&(ptr)->member), typeof(*ptr), member)
-
/* Does linear interpolation between powers of two */
static inline unsigned fract_exp_two(unsigned x, unsigned fract_bits)
{
#define bio_for_each_contig_segment(bv, bio, iter) \
__bio_for_each_contig_segment(bv, bio, iter, (bio)->bi_iter)
-size_t bch_scnmemcpy(char *, size_t, const char *, size_t);
-
void sort_cmp_size(void *base, size_t num, size_t size,
int (*cmp_func)(const void *, const void *, size_t),
void (*swap_func)(void *, void *, size_t));
}
}
-int bch2_xattr_to_text(struct bch_fs *c, char *buf,
- size_t size, struct bkey_s_c k)
+void bch2_xattr_to_text(struct printbuf *out, struct bch_fs *c,
+ struct bkey_s_c k)
{
- char *out = buf, *end = buf + size;
const struct xattr_handler *handler;
struct bkey_s_c_xattr xattr;
handler = bch2_xattr_type_to_handler(xattr.v->x_type);
if (handler && handler->prefix)
- out += scnprintf(out, end - out, "%s", handler->prefix);
+ pr_buf(out, "%s", handler->prefix);
else if (handler)
- out += scnprintf(out, end - out, "(type %u)",
- xattr.v->x_type);
+ pr_buf(out, "(type %u)", xattr.v->x_type);
else
- out += scnprintf(out, end - out, "(unknown type %u)",
- xattr.v->x_type);
-
- out += bch_scnmemcpy(out, end - out, xattr.v->x_name,
- xattr.v->x_name_len);
- out += scnprintf(out, end - out, ":");
- out += bch_scnmemcpy(out, end - out, xattr_val(xattr.v),
- le16_to_cpu(xattr.v->x_val_len));
+ pr_buf(out, "(unknown type %u)", xattr.v->x_type);
+
+ bch_scnmemcpy(out, xattr.v->x_name,
+ xattr.v->x_name_len);
+ pr_buf(out, ":");
+ bch_scnmemcpy(out, xattr_val(xattr.v),
+ le16_to_cpu(xattr.v->x_val_len));
break;
case BCH_XATTR_WHITEOUT:
- out += scnprintf(out, end - out, "whiteout");
+ pr_buf(out, "whiteout");
break;
}
-
- return out - buf;
}
int bch2_xattr_get(struct bch_fs *c, struct bch_inode_info *inode,
struct bch_opts opts =
bch2_inode_opts_to_opts(bch2_inode_opts_get(&inode->ei_inode));
const struct bch_option *opt;
- int ret, id;
+ int id;
u64 v;
id = bch2_opt_lookup(name);
v = bch2_opt_get_by_id(&opts, id);
- ret = bch2_opt_to_text(c, buffer, size, opt, v, 0);
+ if (!buffer) {
+ char buf[512];
+ struct printbuf out = PBUF(buf);
- return ret < size || !buffer ? ret : -ERANGE;
+ bch2_opt_to_text(&out, c, opt, v, 0);
+
+ return out.pos - buf;
+ } else {
+ struct printbuf out = _PBUF(buffer, size);
+
+ bch2_opt_to_text(&out, c, opt, v, 0);
+
+ return printbuf_remaining(&out)
+ ? (void *) out.pos - buffer
+ : -ERANGE;
+ }
}
struct inode_opt_set {
extern const struct bch_hash_desc bch2_xattr_hash_desc;
const char *bch2_xattr_invalid(const struct bch_fs *, struct bkey_s_c);
-int bch2_xattr_to_text(struct bch_fs *, char *, size_t, struct bkey_s_c);
+void bch2_xattr_to_text(struct printbuf *, struct bch_fs *, struct bkey_s_c);
#define bch2_bkey_xattr_ops (struct bkey_ops) { \
.key_invalid = bch2_xattr_invalid, \
projects / bcachefs-tools-debian / commitdiff