Sage Weil | 76aa844 | 2009-10-06 11:31:14 -0700 | [diff] [blame] | 1 | #include "ceph_debug.h" |
| 2 | |
Sage Weil | 06edf04 | 2009-12-15 14:44:32 -0800 | [diff] [blame] | 3 | #include <linux/device.h> |
Tejun Heo | 5a0e3ad | 2010-03-24 17:04:11 +0900 | [diff] [blame] | 4 | #include <linux/slab.h> |
Sage Weil | 76aa844 | 2009-10-06 11:31:14 -0700 | [diff] [blame] | 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" |
Sage Weil | 0743304 | 2009-11-18 16:50:41 -0800 | [diff] [blame] | 12 | #include "mon_client.h" |
| 13 | #include "auth.h" |
Sage Weil | 76aa844 | 2009-10-06 11:31:14 -0700 | [diff] [blame] | 14 | |
Sage Weil | 039934b | 2009-11-12 15:05:52 -0800 | [diff] [blame] | 15 | #ifdef CONFIG_DEBUG_FS |
| 16 | |
Sage Weil | 76aa844 | 2009-10-06 11:31:14 -0700 | [diff] [blame] | 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 |
Sage Weil | 06edf04 | 2009-12-15 14:44:32 -0800 | [diff] [blame] | 29 | * .../bdi - symlink to ../../bdi/something |
Sage Weil | 76aa844 | 2009-10-06 11:31:14 -0700 | [diff] [blame] | 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; |
Sage Weil | 4fc51be | 2010-02-16 15:55:03 -0800 | [diff] [blame] | 82 | struct rb_node *n; |
Sage Weil | 76aa844 | 2009-10-06 11:31:14 -0700 | [diff] [blame] | 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" : ""); |
Sage Weil | 4fc51be | 2010-02-16 15:55:03 -0800 | [diff] [blame] | 92 | for (n = rb_first(&client->osdc.osdmap->pg_pools); n; n = rb_next(n)) { |
Sage Weil | 76aa844 | 2009-10-06 11:31:14 -0700 | [diff] [blame] | 93 | struct ceph_pg_pool_info *pool = |
Sage Weil | 4fc51be | 2010-02-16 15:55:03 -0800 | [diff] [blame] | 94 | rb_entry(n, struct ceph_pg_pool_info, node); |
Sage Weil | 76aa844 | 2009-10-06 11:31:14 -0700 | [diff] [blame] | 95 | seq_printf(s, "pg_pool %d pg_num %d / %d, lpg_num %d / %d\n", |
Sage Weil | 4fc51be | 2010-02-16 15:55:03 -0800 | [diff] [blame] | 96 | pool->id, pool->v.pg_num, pool->pg_num_mask, |
Sage Weil | 76aa844 | 2009-10-06 11:31:14 -0700 | [diff] [blame] | 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; |
Yehuda Sadeh | f8c76f6 | 2010-04-22 15:40:37 -0700 | [diff] [blame] | 116 | struct ceph_mon_generic_request *req; |
Sage Weil | 76aa844 | 2009-10-06 11:31:14 -0700 | [diff] [blame] | 117 | struct ceph_mon_client *monc = &client->monc; |
Sage Weil | 85ff03f | 2010-02-15 14:47:28 -0800 | [diff] [blame] | 118 | struct rb_node *rp; |
Sage Weil | 76aa844 | 2009-10-06 11:31:14 -0700 | [diff] [blame] | 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 | |
Yehuda Sadeh | f8c76f6 | 2010-04-22 15:40:37 -0700 | [diff] [blame] | 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); |
Sage Weil | 76aa844 | 2009-10-06 11:31:14 -0700 | [diff] [blame] | 137 | } |
Sage Weil | 76aa844 | 2009-10-06 11:31:14 -0700 | [diff] [blame] | 138 | |
Sage Weil | 85ff03f | 2010-02-15 14:47:28 -0800 | [diff] [blame] | 139 | mutex_unlock(&monc->mutex); |
Sage Weil | 76aa844 | 2009-10-06 11:31:14 -0700 | [diff] [blame] | 140 | return 0; |
| 141 | } |
| 142 | |
| 143 | static int mdsc_show(struct seq_file *s, void *p) |
| 144 | { |
| 145 | struct ceph_client *client = s->private; |
Sage Weil | 76aa844 | 2009-10-06 11:31:14 -0700 | [diff] [blame] | 146 | struct ceph_mds_client *mdsc = &client->mdsc; |
Sage Weil | 44ca18f | 2010-02-15 12:08:46 -0800 | [diff] [blame] | 147 | struct ceph_mds_request *req; |
| 148 | struct rb_node *rp; |
Sage Weil | 76aa844 | 2009-10-06 11:31:14 -0700 | [diff] [blame] | 149 | int pathlen; |
| 150 | u64 pathbase; |
| 151 | char *path; |
| 152 | |
| 153 | mutex_lock(&mdsc->mutex); |
Sage Weil | 44ca18f | 2010-02-15 12:08:46 -0800 | [diff] [blame] | 154 | for (rp = rb_first(&mdsc->request_tree); rp; rp = rb_next(rp)) { |
| 155 | req = rb_entry(rp, struct ceph_mds_request, r_node); |
Sage Weil | 76aa844 | 2009-10-06 11:31:14 -0700 | [diff] [blame] | 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); |
Dan Carpenter | f44c389 | 2010-08-26 11:07:24 +0200 | [diff] [blame] | 174 | if (IS_ERR(path)) |
| 175 | path = NULL; |
Sage Weil | 76aa844 | 2009-10-06 11:31:14 -0700 | [diff] [blame] | 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); |
Dan Carpenter | f44c389 | 2010-08-26 11:07:24 +0200 | [diff] [blame] | 192 | if (IS_ERR(path)) |
| 193 | path = NULL; |
Sage Weil | 76aa844 | 2009-10-06 11:31:14 -0700 | [diff] [blame] | 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 | |
Sage Weil | 7740a42 | 2010-01-08 15:58:25 -0800 | [diff] [blame] | 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)); |
Sage Weil | 76aa844 | 2009-10-06 11:31:14 -0700 | [diff] [blame] | 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 | { |
Yehuda Sadeh | bfaf148 | 2010-06-23 15:52:27 -0700 | [diff] [blame] | 268 | struct ceph_client *client = s->private; |
Sage Weil | 85ccce4 | 2010-02-17 10:02:43 -0800 | [diff] [blame] | 269 | int total, avail, used, reserved, min; |
Sage Weil | 76aa844 | 2009-10-06 11:31:14 -0700 | [diff] [blame] | 270 | |
Sage Weil | 85ccce4 | 2010-02-17 10:02:43 -0800 | [diff] [blame] | 271 | ceph_reservation_status(client, &total, &avail, &used, &reserved, &min); |
Sage Weil | 76aa844 | 2009-10-06 11:31:14 -0700 | [diff] [blame] | 272 | seq_printf(s, "total\t\t%d\n" |
Sage Weil | 85ccce4 | 2010-02-17 10:02:43 -0800 | [diff] [blame] | 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); |
Sage Weil | 76aa844 | 2009-10-06 11:31:14 -0700 | [diff] [blame] | 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 | |
Sage Weil | 213c99e | 2010-08-03 10:25:11 -0700 | [diff] [blame] | 298 | #define DEFINE_SHOW_FUNC(name) \ |
Sage Weil | 76aa844 | 2009-10-06 11:31:14 -0700 | [diff] [blame] | 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 | |
Yehuda Sadeh | 2baba25 | 2009-12-18 13:51:57 -0800 | [diff] [blame] | 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 | |
Sage Weil | 76aa844 | 2009-10-06 11:31:14 -0700 | [diff] [blame] | 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 | |
Sage Weil | a8b763a | 2010-07-08 13:00:18 -0700 | [diff] [blame] | 368 | snprintf(name, sizeof(name), "%pU.client%lld", &client->fsid, |
| 369 | client->monc.auth->global_id); |
Sage Weil | 76aa844 | 2009-10-06 11:31:14 -0700 | [diff] [blame] | 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 | |
Sage Weil | 213c99e | 2010-08-03 10:25:11 -0700 | [diff] [blame] | 439 | client->debugfs_congestion_kb = |
| 440 | debugfs_create_file("writeback_congestion_kb", |
| 441 | 0600, |
| 442 | client->debugfs_dir, |
| 443 | client, |
| 444 | &congestion_kb_fops); |
Yehuda Sadeh | 2baba25 | 2009-12-18 13:51:57 -0800 | [diff] [blame] | 445 | if (!client->debugfs_congestion_kb) |
| 446 | goto out; |
| 447 | |
Sage Weil | 06edf04 | 2009-12-15 14:44:32 -0800 | [diff] [blame] | 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 | |
Sage Weil | 76aa844 | 2009-10-06 11:31:14 -0700 | [diff] [blame] | 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 | { |
Sage Weil | 06edf04 | 2009-12-15 14:44:32 -0800 | [diff] [blame] | 461 | debugfs_remove(client->debugfs_bdi); |
Sage Weil | 76aa844 | 2009-10-06 11:31:14 -0700 | [diff] [blame] | 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); |
Yehuda Sadeh | 2baba25 | 2009-12-18 13:51:57 -0800 | [diff] [blame] | 470 | debugfs_remove(client->debugfs_congestion_kb); |
Sage Weil | 76aa844 | 2009-10-06 11:31:14 -0700 | [diff] [blame] | 471 | debugfs_remove(client->debugfs_dir); |
| 472 | } |
| 473 | |
Sage Weil | 213c99e | 2010-08-03 10:25:11 -0700 | [diff] [blame] | 474 | #else /* CONFIG_DEBUG_FS */ |
Sage Weil | 039934b | 2009-11-12 15:05:52 -0800 | [diff] [blame] | 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 | |
Sage Weil | 213c99e | 2010-08-03 10:25:11 -0700 | [diff] [blame] | 494 | #endif /* CONFIG_DEBUG_FS */ |