1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
|
// SPDX-License-Identifier: GPL-2.0
/*
* Async obj debugging: keep asynchronous objects on (very fast) lists, make
* them visibile in debugfs:
*/
#include "bcachefs.h"
#include "async_objs.h"
#include "btree_io.h"
#include "debug.h"
#include "io_read.h"
#include <linux/debugfs.h>
static void promote_obj_to_text(struct printbuf *out, void *obj)
{
bch2_promote_op_to_text(out, obj);
}
static void rbio_obj_to_text(struct printbuf *out, void *obj)
{
bch2_read_bio_to_text(out, obj);
}
static void btree_read_bio_obj_to_text(struct printbuf *out, void *obj)
{
struct btree_read_bio *rbio = obj;
bch2_btree_read_bio_to_text(out, rbio);
}
static void btree_write_bio_obj_to_text(struct printbuf *out, void *obj)
{
struct btree_write_bio *wbio = obj;
bch2_bio_to_text(out, &wbio->wbio.bio);
}
static int bch2_async_obj_list_open(struct inode *inode, struct file *file)
{
struct async_obj_list *list = inode->i_private;
struct dump_iter *i;
i = kzalloc(sizeof(struct dump_iter), GFP_KERNEL);
if (!i)
return -ENOMEM;
file->private_data = i;
i->from = POS_MIN;
i->iter = 0;
i->c = container_of(list, struct bch_fs, async_objs[list->idx]);
i->list = list;
i->buf = PRINTBUF;
return 0;
}
static ssize_t bch2_async_obj_list_read(struct file *file, char __user *buf,
size_t size, loff_t *ppos)
{
struct dump_iter *i = file->private_data;
struct async_obj_list *list = i->list;
ssize_t ret = 0;
i->ubuf = buf;
i->size = size;
i->ret = 0;
struct genradix_iter iter;
void *obj;
fast_list_for_each_from(&list->list, iter, obj, i->iter) {
ret = bch2_debugfs_flush_buf(i);
if (ret)
return ret;
if (!i->size)
break;
list->obj_to_text(&i->buf, obj);
}
if (i->buf.allocation_failure)
ret = -ENOMEM;
else
i->iter = iter.pos;
if (!ret)
ret = bch2_debugfs_flush_buf(i);
return ret ?: i->ret;
}
static const struct file_operations async_obj_ops = {
.owner = THIS_MODULE,
.open = bch2_async_obj_list_open,
.release = bch2_dump_release,
.read = bch2_async_obj_list_read,
};
void bch2_fs_async_obj_debugfs_init(struct bch_fs *c)
{
c->async_obj_dir = debugfs_create_dir("async_objs", c->fs_debug_dir);
#define x(n) debugfs_create_file(#n, 0400, c->async_obj_dir, \
&c->async_objs[BCH_ASYNC_OBJ_LIST_##n], &async_obj_ops);
BCH_ASYNC_OBJ_LISTS()
#undef x
}
void bch2_fs_async_obj_exit(struct bch_fs *c)
{
for (unsigned i = 0; i < ARRAY_SIZE(c->async_objs); i++)
fast_list_exit(&c->async_objs[i].list);
}
int bch2_fs_async_obj_init(struct bch_fs *c)
{
for (unsigned i = 0; i < ARRAY_SIZE(c->async_objs); i++) {
if (fast_list_init(&c->async_objs[i].list))
return -BCH_ERR_ENOMEM_async_obj_init;
c->async_objs[i].idx = i;
}
#define x(n) c->async_objs[BCH_ASYNC_OBJ_LIST_##n].obj_to_text = n##_obj_to_text;
BCH_ASYNC_OBJ_LISTS()
#undef x
return 0;
}
|
