Merge tag 'efi-urgent' of git://git.kernel.org/pub/scm/linux/kernel/git/mfleming...
[firefly-linux-kernel-4.4.55.git] / net / ceph / debugfs.c
1 #include <linux/ceph/ceph_debug.h>
2
3 #include <linux/device.h>
4 #include <linux/slab.h>
5 #include <linux/module.h>
6 #include <linux/ctype.h>
7 #include <linux/debugfs.h>
8 #include <linux/seq_file.h>
9
10 #include <linux/ceph/libceph.h>
11 #include <linux/ceph/mon_client.h>
12 #include <linux/ceph/auth.h>
13 #include <linux/ceph/debugfs.h>
14
15 #ifdef CONFIG_DEBUG_FS
16
17 /*
18  * Implement /sys/kernel/debug/ceph fun
19  *
20  * /sys/kernel/debug/ceph/client*  - an instance of the ceph client
21  *      .../osdmap      - current osdmap
22  *      .../monmap      - current monmap
23  *      .../osdc        - active osd requests
24  *      .../monc        - mon client state
25  *      .../dentry_lru  - dump contents of dentry lru
26  *      .../caps        - expose cap (reservation) stats
27  *      .../bdi         - symlink to ../../bdi/something
28  */
29
30 static struct dentry *ceph_debugfs_dir;
31
32 static int monmap_show(struct seq_file *s, void *p)
33 {
34         int i;
35         struct ceph_client *client = s->private;
36
37         if (client->monc.monmap == NULL)
38                 return 0;
39
40         seq_printf(s, "epoch %d\n", client->monc.monmap->epoch);
41         for (i = 0; i < client->monc.monmap->num_mon; i++) {
42                 struct ceph_entity_inst *inst =
43                         &client->monc.monmap->mon_inst[i];
44
45                 seq_printf(s, "\t%s%lld\t%s\n",
46                            ENTITY_NAME(inst->name),
47                            ceph_pr_addr(&inst->addr.in_addr));
48         }
49         return 0;
50 }
51
52 static int osdmap_show(struct seq_file *s, void *p)
53 {
54         int i;
55         struct ceph_client *client = s->private;
56         struct ceph_osdmap *map = client->osdc.osdmap;
57         struct rb_node *n;
58
59         if (map == NULL)
60                 return 0;
61
62         seq_printf(s, "epoch %d\n", map->epoch);
63         seq_printf(s, "flags%s%s\n",
64                    (map->flags & CEPH_OSDMAP_NEARFULL) ?  " NEARFULL" : "",
65                    (map->flags & CEPH_OSDMAP_FULL) ?  " FULL" : "");
66
67         for (n = rb_first(&map->pg_pools); n; n = rb_next(n)) {
68                 struct ceph_pg_pool_info *pool =
69                         rb_entry(n, struct ceph_pg_pool_info, node);
70
71                 seq_printf(s, "pool %lld pg_num %u (%d) read_tier %lld write_tier %lld\n",
72                            pool->id, pool->pg_num, pool->pg_num_mask,
73                            pool->read_tier, pool->write_tier);
74         }
75         for (i = 0; i < map->max_osd; i++) {
76                 struct ceph_entity_addr *addr = &map->osd_addr[i];
77                 int state = map->osd_state[i];
78                 char sb[64];
79
80                 seq_printf(s, "osd%d\t%s\t%3d%%\t(%s)\t%3d%%\n",
81                            i, ceph_pr_addr(&addr->in_addr),
82                            ((map->osd_weight[i]*100) >> 16),
83                            ceph_osdmap_state_str(sb, sizeof(sb), state),
84                            ((ceph_get_primary_affinity(map, i)*100) >> 16));
85         }
86         for (n = rb_first(&map->pg_temp); n; n = rb_next(n)) {
87                 struct ceph_pg_mapping *pg =
88                         rb_entry(n, struct ceph_pg_mapping, node);
89
90                 seq_printf(s, "pg_temp %llu.%x [", pg->pgid.pool,
91                            pg->pgid.seed);
92                 for (i = 0; i < pg->pg_temp.len; i++)
93                         seq_printf(s, "%s%d", (i == 0 ? "" : ","),
94                                    pg->pg_temp.osds[i]);
95                 seq_printf(s, "]\n");
96         }
97         for (n = rb_first(&map->primary_temp); n; n = rb_next(n)) {
98                 struct ceph_pg_mapping *pg =
99                         rb_entry(n, struct ceph_pg_mapping, node);
100
101                 seq_printf(s, "primary_temp %llu.%x %d\n", pg->pgid.pool,
102                            pg->pgid.seed, pg->primary_temp.osd);
103         }
104
105         return 0;
106 }
107
108 static int monc_show(struct seq_file *s, void *p)
109 {
110         struct ceph_client *client = s->private;
111         struct ceph_mon_generic_request *req;
112         struct ceph_mon_client *monc = &client->monc;
113         struct rb_node *rp;
114
115         mutex_lock(&monc->mutex);
116
117         if (monc->have_mdsmap)
118                 seq_printf(s, "have mdsmap %u\n", (unsigned int)monc->have_mdsmap);
119         if (monc->have_osdmap)
120                 seq_printf(s, "have osdmap %u\n", (unsigned int)monc->have_osdmap);
121         if (monc->want_next_osdmap)
122                 seq_printf(s, "want next osdmap\n");
123
124         for (rp = rb_first(&monc->generic_request_tree); rp; rp = rb_next(rp)) {
125                 __u16 op;
126                 req = rb_entry(rp, struct ceph_mon_generic_request, node);
127                 op = le16_to_cpu(req->request->hdr.type);
128                 if (op == CEPH_MSG_STATFS)
129                         seq_printf(s, "%llu statfs\n", req->tid);
130                 else if (op == CEPH_MSG_MON_GET_VERSION)
131                         seq_printf(s, "%llu mon_get_version", req->tid);
132                 else
133                         seq_printf(s, "%llu unknown\n", req->tid);
134         }
135
136         mutex_unlock(&monc->mutex);
137         return 0;
138 }
139
140 static int osdc_show(struct seq_file *s, void *pp)
141 {
142         struct ceph_client *client = s->private;
143         struct ceph_osd_client *osdc = &client->osdc;
144         struct rb_node *p;
145
146         mutex_lock(&osdc->request_mutex);
147         for (p = rb_first(&osdc->requests); p; p = rb_next(p)) {
148                 struct ceph_osd_request *req;
149                 unsigned int i;
150                 int opcode;
151
152                 req = rb_entry(p, struct ceph_osd_request, r_node);
153
154                 seq_printf(s, "%lld\tosd%d\t%lld.%x\t", req->r_tid,
155                            req->r_osd ? req->r_osd->o_osd : -1,
156                            req->r_pgid.pool, req->r_pgid.seed);
157
158                 seq_printf(s, "%.*s", req->r_base_oid.name_len,
159                            req->r_base_oid.name);
160
161                 if (req->r_reassert_version.epoch)
162                         seq_printf(s, "\t%u'%llu",
163                            (unsigned int)le32_to_cpu(req->r_reassert_version.epoch),
164                            le64_to_cpu(req->r_reassert_version.version));
165                 else
166                         seq_printf(s, "\t");
167
168                 for (i = 0; i < req->r_num_ops; i++) {
169                         opcode = req->r_ops[i].op;
170                         seq_printf(s, "%s%s", (i == 0 ? "\t" : ","),
171                                    ceph_osd_op_name(opcode));
172                 }
173
174                 seq_printf(s, "\n");
175         }
176         mutex_unlock(&osdc->request_mutex);
177         return 0;
178 }
179
180 CEPH_DEFINE_SHOW_FUNC(monmap_show)
181 CEPH_DEFINE_SHOW_FUNC(osdmap_show)
182 CEPH_DEFINE_SHOW_FUNC(monc_show)
183 CEPH_DEFINE_SHOW_FUNC(osdc_show)
184
185 int ceph_debugfs_init(void)
186 {
187         ceph_debugfs_dir = debugfs_create_dir("ceph", NULL);
188         if (!ceph_debugfs_dir)
189                 return -ENOMEM;
190         return 0;
191 }
192
193 void ceph_debugfs_cleanup(void)
194 {
195         debugfs_remove(ceph_debugfs_dir);
196 }
197
198 int ceph_debugfs_client_init(struct ceph_client *client)
199 {
200         int ret = -ENOMEM;
201         char name[80];
202
203         snprintf(name, sizeof(name), "%pU.client%lld", &client->fsid,
204                  client->monc.auth->global_id);
205
206         dout("ceph_debugfs_client_init %p %s\n", client, name);
207
208         BUG_ON(client->debugfs_dir);
209         client->debugfs_dir = debugfs_create_dir(name, ceph_debugfs_dir);
210         if (!client->debugfs_dir)
211                 goto out;
212
213         client->monc.debugfs_file = debugfs_create_file("monc",
214                                                       0600,
215                                                       client->debugfs_dir,
216                                                       client,
217                                                       &monc_show_fops);
218         if (!client->monc.debugfs_file)
219                 goto out;
220
221         client->osdc.debugfs_file = debugfs_create_file("osdc",
222                                                       0600,
223                                                       client->debugfs_dir,
224                                                       client,
225                                                       &osdc_show_fops);
226         if (!client->osdc.debugfs_file)
227                 goto out;
228
229         client->debugfs_monmap = debugfs_create_file("monmap",
230                                         0600,
231                                         client->debugfs_dir,
232                                         client,
233                                         &monmap_show_fops);
234         if (!client->debugfs_monmap)
235                 goto out;
236
237         client->debugfs_osdmap = debugfs_create_file("osdmap",
238                                         0600,
239                                         client->debugfs_dir,
240                                         client,
241                                         &osdmap_show_fops);
242         if (!client->debugfs_osdmap)
243                 goto out;
244
245         return 0;
246
247 out:
248         ceph_debugfs_client_cleanup(client);
249         return ret;
250 }
251
252 void ceph_debugfs_client_cleanup(struct ceph_client *client)
253 {
254         dout("ceph_debugfs_client_cleanup %p\n", client);
255         debugfs_remove(client->debugfs_osdmap);
256         debugfs_remove(client->debugfs_monmap);
257         debugfs_remove(client->osdc.debugfs_file);
258         debugfs_remove(client->monc.debugfs_file);
259         debugfs_remove(client->debugfs_dir);
260 }
261
262 #else  /* CONFIG_DEBUG_FS */
263
264 int ceph_debugfs_init(void)
265 {
266         return 0;
267 }
268
269 void ceph_debugfs_cleanup(void)
270 {
271 }
272
273 int ceph_debugfs_client_init(struct ceph_client *client)
274 {
275         return 0;
276 }
277
278 void ceph_debugfs_client_cleanup(struct ceph_client *client)
279 {
280 }
281
282 #endif  /* CONFIG_DEBUG_FS */
283
284 EXPORT_SYMBOL(ceph_debugfs_init);
285 EXPORT_SYMBOL(ceph_debugfs_cleanup);