]>
Commit | Line | Data |
---|---|---|
76aa844d SW |
1 | #include "ceph_debug.h" |
2 | ||
06edf046 | 3 | #include <linux/device.h> |
5a0e3ad6 | 4 | #include <linux/slab.h> |
76aa844d SW |
5 | #include <linux/module.h> |
6 | #include <linux/ctype.h> | |
7 | #include <linux/debugfs.h> | |
8 | #include <linux/seq_file.h> | |
9 | ||
10 | #include "super.h" | |
11 | #include "mds_client.h" | |
0743304d SW |
12 | #include "mon_client.h" |
13 | #include "auth.h" | |
76aa844d | 14 | |
039934b8 SW |
15 | #ifdef CONFIG_DEBUG_FS |
16 | ||
76aa844d SW |
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 | * .../mdsmap - current mdsmap | |
23 | * .../monmap - current monmap | |
24 | * .../osdc - active osd requests | |
25 | * .../mdsc - active mds requests | |
26 | * .../monc - mon client state | |
27 | * .../dentry_lru - dump contents of dentry lru | |
28 | * .../caps - expose cap (reservation) stats | |
06edf046 | 29 | * .../bdi - symlink to ../../bdi/something |
76aa844d SW |
30 | */ |
31 | ||
32 | static struct dentry *ceph_debugfs_dir; | |
33 | ||
34 | static int monmap_show(struct seq_file *s, void *p) | |
35 | { | |
36 | int i; | |
37 | struct ceph_client *client = s->private; | |
38 | ||
39 | if (client->monc.monmap == NULL) | |
40 | return 0; | |
41 | ||
42 | seq_printf(s, "epoch %d\n", client->monc.monmap->epoch); | |
43 | for (i = 0; i < client->monc.monmap->num_mon; i++) { | |
44 | struct ceph_entity_inst *inst = | |
45 | &client->monc.monmap->mon_inst[i]; | |
46 | ||
47 | seq_printf(s, "\t%s%lld\t%s\n", | |
48 | ENTITY_NAME(inst->name), | |
49 | pr_addr(&inst->addr.in_addr)); | |
50 | } | |
51 | return 0; | |
52 | } | |
53 | ||
54 | static int mdsmap_show(struct seq_file *s, void *p) | |
55 | { | |
56 | int i; | |
57 | struct ceph_client *client = s->private; | |
58 | ||
59 | if (client->mdsc.mdsmap == NULL) | |
60 | return 0; | |
61 | seq_printf(s, "epoch %d\n", client->mdsc.mdsmap->m_epoch); | |
62 | seq_printf(s, "root %d\n", client->mdsc.mdsmap->m_root); | |
63 | seq_printf(s, "session_timeout %d\n", | |
64 | client->mdsc.mdsmap->m_session_timeout); | |
65 | seq_printf(s, "session_autoclose %d\n", | |
66 | client->mdsc.mdsmap->m_session_autoclose); | |
67 | for (i = 0; i < client->mdsc.mdsmap->m_max_mds; i++) { | |
68 | struct ceph_entity_addr *addr = | |
69 | &client->mdsc.mdsmap->m_info[i].addr; | |
70 | int state = client->mdsc.mdsmap->m_info[i].state; | |
71 | ||
72 | seq_printf(s, "\tmds%d\t%s\t(%s)\n", i, pr_addr(&addr->in_addr), | |
73 | ceph_mds_state_name(state)); | |
74 | } | |
75 | return 0; | |
76 | } | |
77 | ||
78 | static int osdmap_show(struct seq_file *s, void *p) | |
79 | { | |
80 | int i; | |
81 | struct ceph_client *client = s->private; | |
4fc51be8 | 82 | struct rb_node *n; |
76aa844d SW |
83 | |
84 | if (client->osdc.osdmap == NULL) | |
85 | return 0; | |
86 | seq_printf(s, "epoch %d\n", client->osdc.osdmap->epoch); | |
87 | seq_printf(s, "flags%s%s\n", | |
88 | (client->osdc.osdmap->flags & CEPH_OSDMAP_NEARFULL) ? | |
89 | " NEARFULL" : "", | |
90 | (client->osdc.osdmap->flags & CEPH_OSDMAP_FULL) ? | |
91 | " FULL" : ""); | |
4fc51be8 | 92 | for (n = rb_first(&client->osdc.osdmap->pg_pools); n; n = rb_next(n)) { |
76aa844d | 93 | struct ceph_pg_pool_info *pool = |
4fc51be8 | 94 | rb_entry(n, struct ceph_pg_pool_info, node); |
76aa844d | 95 | seq_printf(s, "pg_pool %d pg_num %d / %d, lpg_num %d / %d\n", |
4fc51be8 | 96 | pool->id, pool->v.pg_num, pool->pg_num_mask, |
76aa844d SW |
97 | pool->v.lpg_num, pool->lpg_num_mask); |
98 | } | |
99 | for (i = 0; i < client->osdc.osdmap->max_osd; i++) { | |
100 | struct ceph_entity_addr *addr = | |
101 | &client->osdc.osdmap->osd_addr[i]; | |
102 | int state = client->osdc.osdmap->osd_state[i]; | |
103 | char sb[64]; | |
104 | ||
105 | seq_printf(s, "\tosd%d\t%s\t%3d%%\t(%s)\n", | |
106 | i, pr_addr(&addr->in_addr), | |
107 | ((client->osdc.osdmap->osd_weight[i]*100) >> 16), | |
108 | ceph_osdmap_state_str(sb, sizeof(sb), state)); | |
109 | } | |
110 | return 0; | |
111 | } | |
112 | ||
113 | static int monc_show(struct seq_file *s, void *p) | |
114 | { | |
115 | struct ceph_client *client = s->private; | |
f8c76f6f | 116 | struct ceph_mon_generic_request *req; |
76aa844d | 117 | struct ceph_mon_client *monc = &client->monc; |
85ff03f6 | 118 | struct rb_node *rp; |
76aa844d SW |
119 | |
120 | mutex_lock(&monc->mutex); | |
121 | ||
122 | if (monc->have_mdsmap) | |
123 | seq_printf(s, "have mdsmap %u\n", (unsigned)monc->have_mdsmap); | |
124 | if (monc->have_osdmap) | |
125 | seq_printf(s, "have osdmap %u\n", (unsigned)monc->have_osdmap); | |
126 | if (monc->want_next_osdmap) | |
127 | seq_printf(s, "want next osdmap\n"); | |
128 | ||
f8c76f6f YS |
129 | for (rp = rb_first(&monc->generic_request_tree); rp; rp = rb_next(rp)) { |
130 | __u16 op; | |
131 | req = rb_entry(rp, struct ceph_mon_generic_request, node); | |
132 | op = le16_to_cpu(req->request->hdr.type); | |
133 | if (op == CEPH_MSG_STATFS) | |
134 | seq_printf(s, "%lld statfs\n", req->tid); | |
135 | else | |
136 | seq_printf(s, "%lld unknown\n", req->tid); | |
76aa844d | 137 | } |
76aa844d | 138 | |
85ff03f6 | 139 | mutex_unlock(&monc->mutex); |
76aa844d SW |
140 | return 0; |
141 | } | |
142 | ||
143 | static int mdsc_show(struct seq_file *s, void *p) | |
144 | { | |
145 | struct ceph_client *client = s->private; | |
76aa844d | 146 | struct ceph_mds_client *mdsc = &client->mdsc; |
44ca18f2 SW |
147 | struct ceph_mds_request *req; |
148 | struct rb_node *rp; | |
76aa844d SW |
149 | int pathlen; |
150 | u64 pathbase; | |
151 | char *path; | |
152 | ||
153 | mutex_lock(&mdsc->mutex); | |
44ca18f2 SW |
154 | for (rp = rb_first(&mdsc->request_tree); rp; rp = rb_next(rp)) { |
155 | req = rb_entry(rp, struct ceph_mds_request, r_node); | |
76aa844d SW |
156 | |
157 | if (req->r_request) | |
158 | seq_printf(s, "%lld\tmds%d\t", req->r_tid, req->r_mds); | |
159 | else | |
160 | seq_printf(s, "%lld\t(no request)\t", req->r_tid); | |
161 | ||
162 | seq_printf(s, "%s", ceph_mds_op_name(req->r_op)); | |
163 | ||
164 | if (req->r_got_unsafe) | |
165 | seq_printf(s, "\t(unsafe)"); | |
166 | else | |
167 | seq_printf(s, "\t"); | |
168 | ||
169 | if (req->r_inode) { | |
170 | seq_printf(s, " #%llx", ceph_ino(req->r_inode)); | |
171 | } else if (req->r_dentry) { | |
172 | path = ceph_mdsc_build_path(req->r_dentry, &pathlen, | |
173 | &pathbase, 0); | |
f44c3890 DC |
174 | if (IS_ERR(path)) |
175 | path = NULL; | |
76aa844d SW |
176 | spin_lock(&req->r_dentry->d_lock); |
177 | seq_printf(s, " #%llx/%.*s (%s)", | |
178 | ceph_ino(req->r_dentry->d_parent->d_inode), | |
179 | req->r_dentry->d_name.len, | |
180 | req->r_dentry->d_name.name, | |
181 | path ? path : ""); | |
182 | spin_unlock(&req->r_dentry->d_lock); | |
183 | kfree(path); | |
184 | } else if (req->r_path1) { | |
185 | seq_printf(s, " #%llx/%s", req->r_ino1.ino, | |
186 | req->r_path1); | |
187 | } | |
188 | ||
189 | if (req->r_old_dentry) { | |
190 | path = ceph_mdsc_build_path(req->r_old_dentry, &pathlen, | |
191 | &pathbase, 0); | |
f44c3890 DC |
192 | if (IS_ERR(path)) |
193 | path = NULL; | |
76aa844d SW |
194 | spin_lock(&req->r_old_dentry->d_lock); |
195 | seq_printf(s, " #%llx/%.*s (%s)", | |
196 | ceph_ino(req->r_old_dentry->d_parent->d_inode), | |
197 | req->r_old_dentry->d_name.len, | |
198 | req->r_old_dentry->d_name.name, | |
199 | path ? path : ""); | |
200 | spin_unlock(&req->r_old_dentry->d_lock); | |
201 | kfree(path); | |
202 | } else if (req->r_path2) { | |
203 | if (req->r_ino2.ino) | |
204 | seq_printf(s, " #%llx/%s", req->r_ino2.ino, | |
205 | req->r_path2); | |
206 | else | |
207 | seq_printf(s, " %s", req->r_path2); | |
208 | } | |
209 | ||
210 | seq_printf(s, "\n"); | |
211 | } | |
212 | mutex_unlock(&mdsc->mutex); | |
213 | ||
214 | return 0; | |
215 | } | |
216 | ||
217 | static int osdc_show(struct seq_file *s, void *pp) | |
218 | { | |
219 | struct ceph_client *client = s->private; | |
220 | struct ceph_osd_client *osdc = &client->osdc; | |
221 | struct rb_node *p; | |
222 | ||
223 | mutex_lock(&osdc->request_mutex); | |
224 | for (p = rb_first(&osdc->requests); p; p = rb_next(p)) { | |
225 | struct ceph_osd_request *req; | |
226 | struct ceph_osd_request_head *head; | |
227 | struct ceph_osd_op *op; | |
228 | int num_ops; | |
229 | int opcode, olen; | |
230 | int i; | |
231 | ||
232 | req = rb_entry(p, struct ceph_osd_request, r_node); | |
233 | ||
7740a42f SW |
234 | seq_printf(s, "%lld\tosd%d\t%d.%x\t", req->r_tid, |
235 | req->r_osd ? req->r_osd->o_osd : -1, | |
236 | le32_to_cpu(req->r_pgid.pool), | |
237 | le16_to_cpu(req->r_pgid.ps)); | |
76aa844d SW |
238 | |
239 | head = req->r_request->front.iov_base; | |
240 | op = (void *)(head + 1); | |
241 | ||
242 | num_ops = le16_to_cpu(head->num_ops); | |
243 | olen = le32_to_cpu(head->object_len); | |
244 | seq_printf(s, "%.*s", olen, | |
245 | (const char *)(head->ops + num_ops)); | |
246 | ||
247 | if (req->r_reassert_version.epoch) | |
248 | seq_printf(s, "\t%u'%llu", | |
249 | (unsigned)le32_to_cpu(req->r_reassert_version.epoch), | |
250 | le64_to_cpu(req->r_reassert_version.version)); | |
251 | else | |
252 | seq_printf(s, "\t"); | |
253 | ||
254 | for (i = 0; i < num_ops; i++) { | |
255 | opcode = le16_to_cpu(op->op); | |
256 | seq_printf(s, "\t%s", ceph_osd_op_name(opcode)); | |
257 | op++; | |
258 | } | |
259 | ||
260 | seq_printf(s, "\n"); | |
261 | } | |
262 | mutex_unlock(&osdc->request_mutex); | |
263 | return 0; | |
264 | } | |
265 | ||
266 | static int caps_show(struct seq_file *s, void *p) | |
267 | { | |
bfaf148e | 268 | struct ceph_client *client = s->private; |
85ccce43 | 269 | int total, avail, used, reserved, min; |
76aa844d | 270 | |
85ccce43 | 271 | ceph_reservation_status(client, &total, &avail, &used, &reserved, &min); |
76aa844d | 272 | seq_printf(s, "total\t\t%d\n" |
85ccce43 SW |
273 | "avail\t\t%d\n" |
274 | "used\t\t%d\n" | |
275 | "reserved\t%d\n" | |
276 | "min\t%d\n", | |
277 | total, avail, used, reserved, min); | |
76aa844d SW |
278 | return 0; |
279 | } | |
280 | ||
281 | static int dentry_lru_show(struct seq_file *s, void *ptr) | |
282 | { | |
283 | struct ceph_client *client = s->private; | |
284 | struct ceph_mds_client *mdsc = &client->mdsc; | |
285 | struct ceph_dentry_info *di; | |
286 | ||
287 | spin_lock(&mdsc->dentry_lru_lock); | |
288 | list_for_each_entry(di, &mdsc->dentry_lru, lru) { | |
289 | struct dentry *dentry = di->dentry; | |
290 | seq_printf(s, "%p %p\t%.*s\n", | |
291 | di, dentry, dentry->d_name.len, dentry->d_name.name); | |
292 | } | |
293 | spin_unlock(&mdsc->dentry_lru_lock); | |
294 | ||
295 | return 0; | |
296 | } | |
297 | ||
213c99ee | 298 | #define DEFINE_SHOW_FUNC(name) \ |
76aa844d SW |
299 | static int name##_open(struct inode *inode, struct file *file) \ |
300 | { \ | |
301 | struct seq_file *sf; \ | |
302 | int ret; \ | |
303 | \ | |
304 | ret = single_open(file, name, NULL); \ | |
305 | sf = file->private_data; \ | |
306 | sf->private = inode->i_private; \ | |
307 | return ret; \ | |
308 | } \ | |
309 | \ | |
310 | static const struct file_operations name##_fops = { \ | |
311 | .open = name##_open, \ | |
312 | .read = seq_read, \ | |
313 | .llseek = seq_lseek, \ | |
314 | .release = single_release, \ | |
315 | }; | |
316 | ||
317 | DEFINE_SHOW_FUNC(monmap_show) | |
318 | DEFINE_SHOW_FUNC(mdsmap_show) | |
319 | DEFINE_SHOW_FUNC(osdmap_show) | |
320 | DEFINE_SHOW_FUNC(monc_show) | |
321 | DEFINE_SHOW_FUNC(mdsc_show) | |
322 | DEFINE_SHOW_FUNC(osdc_show) | |
323 | DEFINE_SHOW_FUNC(dentry_lru_show) | |
324 | DEFINE_SHOW_FUNC(caps_show) | |
325 | ||
2baba250 YS |
326 | static int congestion_kb_set(void *data, u64 val) |
327 | { | |
328 | struct ceph_client *client = (struct ceph_client *)data; | |
329 | ||
330 | if (client) | |
331 | client->mount_args->congestion_kb = (int)val; | |
332 | ||
333 | return 0; | |
334 | } | |
335 | ||
336 | static int congestion_kb_get(void *data, u64 *val) | |
337 | { | |
338 | struct ceph_client *client = (struct ceph_client *)data; | |
339 | ||
340 | if (client) | |
341 | *val = (u64)client->mount_args->congestion_kb; | |
342 | ||
343 | return 0; | |
344 | } | |
345 | ||
346 | ||
347 | DEFINE_SIMPLE_ATTRIBUTE(congestion_kb_fops, congestion_kb_get, | |
348 | congestion_kb_set, "%llu\n"); | |
349 | ||
76aa844d SW |
350 | int __init ceph_debugfs_init(void) |
351 | { | |
352 | ceph_debugfs_dir = debugfs_create_dir("ceph", NULL); | |
353 | if (!ceph_debugfs_dir) | |
354 | return -ENOMEM; | |
355 | return 0; | |
356 | } | |
357 | ||
358 | void ceph_debugfs_cleanup(void) | |
359 | { | |
360 | debugfs_remove(ceph_debugfs_dir); | |
361 | } | |
362 | ||
363 | int ceph_debugfs_client_init(struct ceph_client *client) | |
364 | { | |
365 | int ret = 0; | |
366 | char name[80]; | |
367 | ||
a8b763a9 SW |
368 | snprintf(name, sizeof(name), "%pU.client%lld", &client->fsid, |
369 | client->monc.auth->global_id); | |
76aa844d SW |
370 | |
371 | client->debugfs_dir = debugfs_create_dir(name, ceph_debugfs_dir); | |
372 | if (!client->debugfs_dir) | |
373 | goto out; | |
374 | ||
375 | client->monc.debugfs_file = debugfs_create_file("monc", | |
376 | 0600, | |
377 | client->debugfs_dir, | |
378 | client, | |
379 | &monc_show_fops); | |
380 | if (!client->monc.debugfs_file) | |
381 | goto out; | |
382 | ||
383 | client->mdsc.debugfs_file = debugfs_create_file("mdsc", | |
384 | 0600, | |
385 | client->debugfs_dir, | |
386 | client, | |
387 | &mdsc_show_fops); | |
388 | if (!client->mdsc.debugfs_file) | |
389 | goto out; | |
390 | ||
391 | client->osdc.debugfs_file = debugfs_create_file("osdc", | |
392 | 0600, | |
393 | client->debugfs_dir, | |
394 | client, | |
395 | &osdc_show_fops); | |
396 | if (!client->osdc.debugfs_file) | |
397 | goto out; | |
398 | ||
399 | client->debugfs_monmap = debugfs_create_file("monmap", | |
400 | 0600, | |
401 | client->debugfs_dir, | |
402 | client, | |
403 | &monmap_show_fops); | |
404 | if (!client->debugfs_monmap) | |
405 | goto out; | |
406 | ||
407 | client->debugfs_mdsmap = debugfs_create_file("mdsmap", | |
408 | 0600, | |
409 | client->debugfs_dir, | |
410 | client, | |
411 | &mdsmap_show_fops); | |
412 | if (!client->debugfs_mdsmap) | |
413 | goto out; | |
414 | ||
415 | client->debugfs_osdmap = debugfs_create_file("osdmap", | |
416 | 0600, | |
417 | client->debugfs_dir, | |
418 | client, | |
419 | &osdmap_show_fops); | |
420 | if (!client->debugfs_osdmap) | |
421 | goto out; | |
422 | ||
423 | client->debugfs_dentry_lru = debugfs_create_file("dentry_lru", | |
424 | 0600, | |
425 | client->debugfs_dir, | |
426 | client, | |
427 | &dentry_lru_show_fops); | |
428 | if (!client->debugfs_dentry_lru) | |
429 | goto out; | |
430 | ||
431 | client->debugfs_caps = debugfs_create_file("caps", | |
432 | 0400, | |
433 | client->debugfs_dir, | |
434 | client, | |
435 | &caps_show_fops); | |
436 | if (!client->debugfs_caps) | |
437 | goto out; | |
438 | ||
213c99ee SW |
439 | client->debugfs_congestion_kb = |
440 | debugfs_create_file("writeback_congestion_kb", | |
441 | 0600, | |
442 | client->debugfs_dir, | |
443 | client, | |
444 | &congestion_kb_fops); | |
2baba250 YS |
445 | if (!client->debugfs_congestion_kb) |
446 | goto out; | |
447 | ||
06edf046 SW |
448 | sprintf(name, "../../bdi/%s", dev_name(client->sb->s_bdi->dev)); |
449 | client->debugfs_bdi = debugfs_create_symlink("bdi", client->debugfs_dir, | |
450 | name); | |
451 | ||
76aa844d SW |
452 | return 0; |
453 | ||
454 | out: | |
455 | ceph_debugfs_client_cleanup(client); | |
456 | return ret; | |
457 | } | |
458 | ||
459 | void ceph_debugfs_client_cleanup(struct ceph_client *client) | |
460 | { | |
06edf046 | 461 | debugfs_remove(client->debugfs_bdi); |
76aa844d SW |
462 | debugfs_remove(client->debugfs_caps); |
463 | debugfs_remove(client->debugfs_dentry_lru); | |
464 | debugfs_remove(client->debugfs_osdmap); | |
465 | debugfs_remove(client->debugfs_mdsmap); | |
466 | debugfs_remove(client->debugfs_monmap); | |
467 | debugfs_remove(client->osdc.debugfs_file); | |
468 | debugfs_remove(client->mdsc.debugfs_file); | |
469 | debugfs_remove(client->monc.debugfs_file); | |
2baba250 | 470 | debugfs_remove(client->debugfs_congestion_kb); |
76aa844d SW |
471 | debugfs_remove(client->debugfs_dir); |
472 | } | |
473 | ||
213c99ee | 474 | #else /* CONFIG_DEBUG_FS */ |
039934b8 SW |
475 | |
476 | int __init ceph_debugfs_init(void) | |
477 | { | |
478 | return 0; | |
479 | } | |
480 | ||
481 | void ceph_debugfs_cleanup(void) | |
482 | { | |
483 | } | |
484 | ||
485 | int ceph_debugfs_client_init(struct ceph_client *client) | |
486 | { | |
487 | return 0; | |
488 | } | |
489 | ||
490 | void ceph_debugfs_client_cleanup(struct ceph_client *client) | |
491 | { | |
492 | } | |
493 | ||
213c99ee | 494 | #endif /* CONFIG_DEBUG_FS */ |