Yehuda Sadeh | 3d14c5d | 2010-04-06 15:14:15 -0700 | [diff] [blame] | 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 |
Ilya Dryomov | 5cf7bd3 | 2015-03-25 21:07:41 +0300 | [diff] [blame] | 25 | * .../client_options - libceph-only (i.e. not rbd or cephfs) options |
Yehuda Sadeh | 3d14c5d | 2010-04-06 15:14:15 -0700 | [diff] [blame] | 26 | * .../dentry_lru - dump contents of dentry lru |
| 27 | * .../caps - expose cap (reservation) stats |
| 28 | * .../bdi - symlink to ../../bdi/something |
| 29 | */ |
| 30 | |
| 31 | static struct dentry *ceph_debugfs_dir; |
| 32 | |
| 33 | static int monmap_show(struct seq_file *s, void *p) |
| 34 | { |
| 35 | int i; |
| 36 | struct ceph_client *client = s->private; |
| 37 | |
| 38 | if (client->monc.monmap == NULL) |
| 39 | return 0; |
| 40 | |
| 41 | seq_printf(s, "epoch %d\n", client->monc.monmap->epoch); |
| 42 | for (i = 0; i < client->monc.monmap->num_mon; i++) { |
| 43 | struct ceph_entity_inst *inst = |
| 44 | &client->monc.monmap->mon_inst[i]; |
| 45 | |
| 46 | seq_printf(s, "\t%s%lld\t%s\n", |
| 47 | ENTITY_NAME(inst->name), |
| 48 | ceph_pr_addr(&inst->addr.in_addr)); |
| 49 | } |
| 50 | return 0; |
| 51 | } |
| 52 | |
| 53 | static int osdmap_show(struct seq_file *s, void *p) |
| 54 | { |
| 55 | int i; |
| 56 | struct ceph_client *client = s->private; |
Ilya Dryomov | b4f3479 | 2016-04-28 16:07:27 +0200 | [diff] [blame] | 57 | struct ceph_osd_client *osdc = &client->osdc; |
| 58 | struct ceph_osdmap *map = osdc->osdmap; |
Yehuda Sadeh | 3d14c5d | 2010-04-06 15:14:15 -0700 | [diff] [blame] | 59 | struct rb_node *n; |
| 60 | |
Ilya Dryomov | 35fea3a | 2014-03-13 16:36:12 +0200 | [diff] [blame] | 61 | if (map == NULL) |
Yehuda Sadeh | 3d14c5d | 2010-04-06 15:14:15 -0700 | [diff] [blame] | 62 | return 0; |
Ilya Dryomov | 35fea3a | 2014-03-13 16:36:12 +0200 | [diff] [blame] | 63 | |
Ilya Dryomov | b4f3479 | 2016-04-28 16:07:27 +0200 | [diff] [blame] | 64 | down_read(&osdc->lock); |
| 65 | seq_printf(s, "epoch %d flags 0x%x\n", map->epoch, map->flags); |
Ilya Dryomov | 35fea3a | 2014-03-13 16:36:12 +0200 | [diff] [blame] | 66 | |
| 67 | for (n = rb_first(&map->pg_pools); n; n = rb_next(n)) { |
Ilya Dryomov | 04812ac | 2016-04-28 16:07:23 +0200 | [diff] [blame] | 68 | struct ceph_pg_pool_info *pi = |
Yehuda Sadeh | 3d14c5d | 2010-04-06 15:14:15 -0700 | [diff] [blame] | 69 | rb_entry(n, struct ceph_pg_pool_info, node); |
Ilya Dryomov | 35fea3a | 2014-03-13 16:36:12 +0200 | [diff] [blame] | 70 | |
Ilya Dryomov | 04812ac | 2016-04-28 16:07:23 +0200 | [diff] [blame] | 71 | seq_printf(s, "pool %lld '%s' type %d size %d min_size %d pg_num %u pg_num_mask %d flags 0x%llx lfor %u read_tier %lld write_tier %lld\n", |
| 72 | pi->id, pi->name, pi->type, pi->size, pi->min_size, |
| 73 | pi->pg_num, pi->pg_num_mask, pi->flags, |
| 74 | pi->last_force_request_resend, pi->read_tier, |
| 75 | pi->write_tier); |
Yehuda Sadeh | 3d14c5d | 2010-04-06 15:14:15 -0700 | [diff] [blame] | 76 | } |
Ilya Dryomov | 35fea3a | 2014-03-13 16:36:12 +0200 | [diff] [blame] | 77 | for (i = 0; i < map->max_osd; i++) { |
| 78 | struct ceph_entity_addr *addr = &map->osd_addr[i]; |
| 79 | int state = map->osd_state[i]; |
Yehuda Sadeh | 3d14c5d | 2010-04-06 15:14:15 -0700 | [diff] [blame] | 80 | char sb[64]; |
| 81 | |
Ilya Dryomov | 2cfa34f | 2014-03-21 19:05:30 +0200 | [diff] [blame] | 82 | seq_printf(s, "osd%d\t%s\t%3d%%\t(%s)\t%3d%%\n", |
Yehuda Sadeh | 3d14c5d | 2010-04-06 15:14:15 -0700 | [diff] [blame] | 83 | i, ceph_pr_addr(&addr->in_addr), |
Ilya Dryomov | 35fea3a | 2014-03-13 16:36:12 +0200 | [diff] [blame] | 84 | ((map->osd_weight[i]*100) >> 16), |
Ilya Dryomov | 2cfa34f | 2014-03-21 19:05:30 +0200 | [diff] [blame] | 85 | ceph_osdmap_state_str(sb, sizeof(sb), state), |
| 86 | ((ceph_get_primary_affinity(map, i)*100) >> 16)); |
Yehuda Sadeh | 3d14c5d | 2010-04-06 15:14:15 -0700 | [diff] [blame] | 87 | } |
Ilya Dryomov | 1c00240 | 2014-03-13 16:36:13 +0200 | [diff] [blame] | 88 | for (n = rb_first(&map->pg_temp); n; n = rb_next(n)) { |
| 89 | struct ceph_pg_mapping *pg = |
| 90 | rb_entry(n, struct ceph_pg_mapping, node); |
| 91 | |
| 92 | seq_printf(s, "pg_temp %llu.%x [", pg->pgid.pool, |
| 93 | pg->pgid.seed); |
Ilya Dryomov | 35a935d | 2014-03-21 19:05:29 +0200 | [diff] [blame] | 94 | for (i = 0; i < pg->pg_temp.len; i++) |
Ilya Dryomov | 1c00240 | 2014-03-13 16:36:13 +0200 | [diff] [blame] | 95 | seq_printf(s, "%s%d", (i == 0 ? "" : ","), |
Ilya Dryomov | 35a935d | 2014-03-21 19:05:29 +0200 | [diff] [blame] | 96 | pg->pg_temp.osds[i]); |
Ilya Dryomov | 1c00240 | 2014-03-13 16:36:13 +0200 | [diff] [blame] | 97 | seq_printf(s, "]\n"); |
| 98 | } |
Ilya Dryomov | 9686f94 | 2014-03-21 19:05:29 +0200 | [diff] [blame] | 99 | for (n = rb_first(&map->primary_temp); n; n = rb_next(n)) { |
| 100 | struct ceph_pg_mapping *pg = |
| 101 | rb_entry(n, struct ceph_pg_mapping, node); |
| 102 | |
| 103 | seq_printf(s, "primary_temp %llu.%x %d\n", pg->pgid.pool, |
| 104 | pg->pgid.seed, pg->primary_temp.osd); |
| 105 | } |
Ilya Dryomov | 35fea3a | 2014-03-13 16:36:12 +0200 | [diff] [blame] | 106 | |
Ilya Dryomov | b4f3479 | 2016-04-28 16:07:27 +0200 | [diff] [blame] | 107 | up_read(&osdc->lock); |
Yehuda Sadeh | 3d14c5d | 2010-04-06 15:14:15 -0700 | [diff] [blame] | 108 | return 0; |
| 109 | } |
| 110 | |
| 111 | static int monc_show(struct seq_file *s, void *p) |
| 112 | { |
| 113 | struct ceph_client *client = s->private; |
| 114 | struct ceph_mon_generic_request *req; |
| 115 | struct ceph_mon_client *monc = &client->monc; |
| 116 | struct rb_node *rp; |
Ilya Dryomov | 82dcaba | 2016-01-19 16:19:06 +0100 | [diff] [blame] | 117 | int i; |
Yehuda Sadeh | 3d14c5d | 2010-04-06 15:14:15 -0700 | [diff] [blame] | 118 | |
| 119 | mutex_lock(&monc->mutex); |
| 120 | |
Ilya Dryomov | 82dcaba | 2016-01-19 16:19:06 +0100 | [diff] [blame] | 121 | for (i = 0; i < ARRAY_SIZE(monc->subs); i++) { |
| 122 | seq_printf(s, "have %s %u", ceph_sub_str[i], |
| 123 | monc->subs[i].have); |
| 124 | if (monc->subs[i].want) |
| 125 | seq_printf(s, " want %llu%s", |
| 126 | le64_to_cpu(monc->subs[i].item.start), |
| 127 | (monc->subs[i].item.flags & |
| 128 | CEPH_SUBSCRIBE_ONETIME ? "" : "+")); |
| 129 | seq_putc(s, '\n'); |
| 130 | } |
Ilya Dryomov | 737cc81e | 2016-05-26 00:05:01 +0200 | [diff] [blame] | 131 | seq_printf(s, "fs_cluster_id %d\n", monc->fs_cluster_id); |
Yehuda Sadeh | 3d14c5d | 2010-04-06 15:14:15 -0700 | [diff] [blame] | 132 | |
| 133 | for (rp = rb_first(&monc->generic_request_tree); rp; rp = rb_next(rp)) { |
| 134 | __u16 op; |
| 135 | req = rb_entry(rp, struct ceph_mon_generic_request, node); |
| 136 | op = le16_to_cpu(req->request->hdr.type); |
| 137 | if (op == CEPH_MSG_STATFS) |
Ilya Dryomov | 002b36b | 2014-05-12 13:05:47 +0400 | [diff] [blame] | 138 | seq_printf(s, "%llu statfs\n", req->tid); |
Ilya Dryomov | 513a824 | 2014-05-13 11:19:26 +0400 | [diff] [blame] | 139 | else if (op == CEPH_MSG_MON_GET_VERSION) |
| 140 | seq_printf(s, "%llu mon_get_version", req->tid); |
Yehuda Sadeh | 3d14c5d | 2010-04-06 15:14:15 -0700 | [diff] [blame] | 141 | else |
Ilya Dryomov | 002b36b | 2014-05-12 13:05:47 +0400 | [diff] [blame] | 142 | seq_printf(s, "%llu unknown\n", req->tid); |
Yehuda Sadeh | 3d14c5d | 2010-04-06 15:14:15 -0700 | [diff] [blame] | 143 | } |
| 144 | |
| 145 | mutex_unlock(&monc->mutex); |
| 146 | return 0; |
| 147 | } |
| 148 | |
Ilya Dryomov | bb873b5 | 2016-05-26 00:29:52 +0200 | [diff] [blame] | 149 | static void dump_target(struct seq_file *s, struct ceph_osd_request_target *t) |
| 150 | { |
| 151 | int i; |
| 152 | |
| 153 | seq_printf(s, "osd%d\t%llu.%x\t[", t->osd, t->pgid.pool, t->pgid.seed); |
| 154 | for (i = 0; i < t->up.size; i++) |
| 155 | seq_printf(s, "%s%d", (!i ? "" : ","), t->up.osds[i]); |
| 156 | seq_printf(s, "]/%d\t[", t->up.primary); |
| 157 | for (i = 0; i < t->acting.size; i++) |
| 158 | seq_printf(s, "%s%d", (!i ? "" : ","), t->acting.osds[i]); |
| 159 | seq_printf(s, "]/%d\t%*pE\t0x%x", t->acting.primary, |
| 160 | t->target_oid.name_len, t->target_oid.name, t->flags); |
| 161 | if (t->paused) |
| 162 | seq_puts(s, "\tP"); |
| 163 | } |
| 164 | |
| 165 | static void dump_request(struct seq_file *s, struct ceph_osd_request *req) |
| 166 | { |
| 167 | int i; |
| 168 | |
| 169 | seq_printf(s, "%llu\t", req->r_tid); |
| 170 | dump_target(s, &req->r_t); |
| 171 | |
| 172 | seq_printf(s, "\t%d\t%u'%llu", req->r_attempts, |
| 173 | le32_to_cpu(req->r_replay_version.epoch), |
| 174 | le64_to_cpu(req->r_replay_version.version)); |
| 175 | |
| 176 | for (i = 0; i < req->r_num_ops; i++) { |
| 177 | struct ceph_osd_req_op *op = &req->r_ops[i]; |
| 178 | |
| 179 | seq_printf(s, "%s%s", (i == 0 ? "\t" : ","), |
| 180 | ceph_osd_op_name(op->op)); |
Ilya Dryomov | 922dab6 | 2016-05-26 01:15:02 +0200 | [diff] [blame] | 181 | if (op->op == CEPH_OSD_OP_WATCH) |
| 182 | seq_printf(s, "-%s", |
| 183 | ceph_osd_watch_op_name(op->watch.op)); |
Ilya Dryomov | bb873b5 | 2016-05-26 00:29:52 +0200 | [diff] [blame] | 184 | } |
| 185 | |
| 186 | seq_putc(s, '\n'); |
| 187 | } |
| 188 | |
Ilya Dryomov | 5aea3dc | 2016-04-28 16:07:26 +0200 | [diff] [blame] | 189 | static void dump_requests(struct seq_file *s, struct ceph_osd *osd) |
| 190 | { |
| 191 | struct rb_node *n; |
| 192 | |
| 193 | mutex_lock(&osd->lock); |
| 194 | for (n = rb_first(&osd->o_requests); n; n = rb_next(n)) { |
| 195 | struct ceph_osd_request *req = |
| 196 | rb_entry(n, struct ceph_osd_request, r_node); |
| 197 | |
| 198 | dump_request(s, req); |
| 199 | } |
| 200 | |
| 201 | mutex_unlock(&osd->lock); |
| 202 | } |
| 203 | |
Ilya Dryomov | 922dab6 | 2016-05-26 01:15:02 +0200 | [diff] [blame] | 204 | static void dump_linger_request(struct seq_file *s, |
| 205 | struct ceph_osd_linger_request *lreq) |
| 206 | { |
| 207 | seq_printf(s, "%llu\t", lreq->linger_id); |
| 208 | dump_target(s, &lreq->t); |
| 209 | |
Ilya Dryomov | 1907920 | 2016-04-28 16:07:27 +0200 | [diff] [blame] | 210 | seq_printf(s, "\t%u\t%s%s/%d\n", lreq->register_gen, |
| 211 | lreq->is_watch ? "W" : "N", lreq->committed ? "C" : "", |
| 212 | lreq->last_error); |
Ilya Dryomov | 922dab6 | 2016-05-26 01:15:02 +0200 | [diff] [blame] | 213 | } |
| 214 | |
| 215 | static void dump_linger_requests(struct seq_file *s, struct ceph_osd *osd) |
| 216 | { |
| 217 | struct rb_node *n; |
| 218 | |
| 219 | mutex_lock(&osd->lock); |
| 220 | for (n = rb_first(&osd->o_linger_requests); n; n = rb_next(n)) { |
| 221 | struct ceph_osd_linger_request *lreq = |
| 222 | rb_entry(n, struct ceph_osd_linger_request, node); |
| 223 | |
| 224 | dump_linger_request(s, lreq); |
| 225 | } |
| 226 | |
| 227 | mutex_unlock(&osd->lock); |
| 228 | } |
| 229 | |
Yehuda Sadeh | 3d14c5d | 2010-04-06 15:14:15 -0700 | [diff] [blame] | 230 | static int osdc_show(struct seq_file *s, void *pp) |
| 231 | { |
| 232 | struct ceph_client *client = s->private; |
| 233 | struct ceph_osd_client *osdc = &client->osdc; |
Ilya Dryomov | 5aea3dc | 2016-04-28 16:07:26 +0200 | [diff] [blame] | 234 | struct rb_node *n; |
Yehuda Sadeh | 3d14c5d | 2010-04-06 15:14:15 -0700 | [diff] [blame] | 235 | |
Ilya Dryomov | 5aea3dc | 2016-04-28 16:07:26 +0200 | [diff] [blame] | 236 | down_read(&osdc->lock); |
| 237 | seq_printf(s, "REQUESTS %d homeless %d\n", |
| 238 | atomic_read(&osdc->num_requests), |
| 239 | atomic_read(&osdc->num_homeless)); |
| 240 | for (n = rb_first(&osdc->osds); n; n = rb_next(n)) { |
| 241 | struct ceph_osd *osd = rb_entry(n, struct ceph_osd, o_node); |
Yehuda Sadeh | 3d14c5d | 2010-04-06 15:14:15 -0700 | [diff] [blame] | 242 | |
Ilya Dryomov | 5aea3dc | 2016-04-28 16:07:26 +0200 | [diff] [blame] | 243 | dump_requests(s, osd); |
Yehuda Sadeh | 3d14c5d | 2010-04-06 15:14:15 -0700 | [diff] [blame] | 244 | } |
Ilya Dryomov | 5aea3dc | 2016-04-28 16:07:26 +0200 | [diff] [blame] | 245 | dump_requests(s, &osdc->homeless_osd); |
| 246 | |
Ilya Dryomov | 922dab6 | 2016-05-26 01:15:02 +0200 | [diff] [blame] | 247 | seq_puts(s, "LINGER REQUESTS\n"); |
| 248 | for (n = rb_first(&osdc->osds); n; n = rb_next(n)) { |
| 249 | struct ceph_osd *osd = rb_entry(n, struct ceph_osd, o_node); |
| 250 | |
| 251 | dump_linger_requests(s, osd); |
| 252 | } |
| 253 | dump_linger_requests(s, &osdc->homeless_osd); |
| 254 | |
Ilya Dryomov | 5aea3dc | 2016-04-28 16:07:26 +0200 | [diff] [blame] | 255 | up_read(&osdc->lock); |
Yehuda Sadeh | 3d14c5d | 2010-04-06 15:14:15 -0700 | [diff] [blame] | 256 | return 0; |
| 257 | } |
| 258 | |
Ilya Dryomov | 5cf7bd3 | 2015-03-25 21:07:41 +0300 | [diff] [blame] | 259 | static int client_options_show(struct seq_file *s, void *p) |
| 260 | { |
| 261 | struct ceph_client *client = s->private; |
| 262 | int ret; |
| 263 | |
| 264 | ret = ceph_print_client_options(s, client); |
| 265 | if (ret) |
| 266 | return ret; |
| 267 | |
| 268 | seq_putc(s, '\n'); |
| 269 | return 0; |
| 270 | } |
| 271 | |
Yehuda Sadeh | 3d14c5d | 2010-04-06 15:14:15 -0700 | [diff] [blame] | 272 | CEPH_DEFINE_SHOW_FUNC(monmap_show) |
| 273 | CEPH_DEFINE_SHOW_FUNC(osdmap_show) |
| 274 | CEPH_DEFINE_SHOW_FUNC(monc_show) |
| 275 | CEPH_DEFINE_SHOW_FUNC(osdc_show) |
Ilya Dryomov | 5cf7bd3 | 2015-03-25 21:07:41 +0300 | [diff] [blame] | 276 | CEPH_DEFINE_SHOW_FUNC(client_options_show) |
Yehuda Sadeh | 3d14c5d | 2010-04-06 15:14:15 -0700 | [diff] [blame] | 277 | |
| 278 | int ceph_debugfs_init(void) |
| 279 | { |
| 280 | ceph_debugfs_dir = debugfs_create_dir("ceph", NULL); |
| 281 | if (!ceph_debugfs_dir) |
| 282 | return -ENOMEM; |
| 283 | return 0; |
| 284 | } |
| 285 | |
| 286 | void ceph_debugfs_cleanup(void) |
| 287 | { |
| 288 | debugfs_remove(ceph_debugfs_dir); |
| 289 | } |
| 290 | |
| 291 | int ceph_debugfs_client_init(struct ceph_client *client) |
| 292 | { |
| 293 | int ret = -ENOMEM; |
| 294 | char name[80]; |
| 295 | |
| 296 | snprintf(name, sizeof(name), "%pU.client%lld", &client->fsid, |
| 297 | client->monc.auth->global_id); |
| 298 | |
Sage Weil | d1c338a | 2012-08-19 12:29:16 -0700 | [diff] [blame] | 299 | dout("ceph_debugfs_client_init %p %s\n", client, name); |
| 300 | |
| 301 | BUG_ON(client->debugfs_dir); |
Yehuda Sadeh | 3d14c5d | 2010-04-06 15:14:15 -0700 | [diff] [blame] | 302 | client->debugfs_dir = debugfs_create_dir(name, ceph_debugfs_dir); |
| 303 | if (!client->debugfs_dir) |
| 304 | goto out; |
| 305 | |
| 306 | client->monc.debugfs_file = debugfs_create_file("monc", |
| 307 | 0600, |
| 308 | client->debugfs_dir, |
| 309 | client, |
| 310 | &monc_show_fops); |
| 311 | if (!client->monc.debugfs_file) |
| 312 | goto out; |
| 313 | |
| 314 | client->osdc.debugfs_file = debugfs_create_file("osdc", |
| 315 | 0600, |
| 316 | client->debugfs_dir, |
| 317 | client, |
| 318 | &osdc_show_fops); |
| 319 | if (!client->osdc.debugfs_file) |
| 320 | goto out; |
| 321 | |
| 322 | client->debugfs_monmap = debugfs_create_file("monmap", |
| 323 | 0600, |
| 324 | client->debugfs_dir, |
| 325 | client, |
| 326 | &monmap_show_fops); |
| 327 | if (!client->debugfs_monmap) |
| 328 | goto out; |
| 329 | |
| 330 | client->debugfs_osdmap = debugfs_create_file("osdmap", |
| 331 | 0600, |
| 332 | client->debugfs_dir, |
| 333 | client, |
| 334 | &osdmap_show_fops); |
| 335 | if (!client->debugfs_osdmap) |
| 336 | goto out; |
| 337 | |
Ilya Dryomov | 5cf7bd3 | 2015-03-25 21:07:41 +0300 | [diff] [blame] | 338 | client->debugfs_options = debugfs_create_file("client_options", |
| 339 | 0600, |
| 340 | client->debugfs_dir, |
| 341 | client, |
| 342 | &client_options_show_fops); |
| 343 | if (!client->debugfs_options) |
| 344 | goto out; |
| 345 | |
Yehuda Sadeh | 3d14c5d | 2010-04-06 15:14:15 -0700 | [diff] [blame] | 346 | return 0; |
| 347 | |
| 348 | out: |
| 349 | ceph_debugfs_client_cleanup(client); |
| 350 | return ret; |
| 351 | } |
| 352 | |
| 353 | void ceph_debugfs_client_cleanup(struct ceph_client *client) |
| 354 | { |
Sage Weil | d1c338a | 2012-08-19 12:29:16 -0700 | [diff] [blame] | 355 | dout("ceph_debugfs_client_cleanup %p\n", client); |
Ilya Dryomov | 5cf7bd3 | 2015-03-25 21:07:41 +0300 | [diff] [blame] | 356 | debugfs_remove(client->debugfs_options); |
Yehuda Sadeh | 3d14c5d | 2010-04-06 15:14:15 -0700 | [diff] [blame] | 357 | debugfs_remove(client->debugfs_osdmap); |
| 358 | debugfs_remove(client->debugfs_monmap); |
| 359 | debugfs_remove(client->osdc.debugfs_file); |
| 360 | debugfs_remove(client->monc.debugfs_file); |
| 361 | debugfs_remove(client->debugfs_dir); |
| 362 | } |
| 363 | |
| 364 | #else /* CONFIG_DEBUG_FS */ |
| 365 | |
| 366 | int ceph_debugfs_init(void) |
| 367 | { |
| 368 | return 0; |
| 369 | } |
| 370 | |
| 371 | void ceph_debugfs_cleanup(void) |
| 372 | { |
| 373 | } |
| 374 | |
Yehuda Sadeh | 602adf4 | 2010-08-12 16:11:25 -0700 | [diff] [blame] | 375 | int ceph_debugfs_client_init(struct ceph_client *client) |
Yehuda Sadeh | 3d14c5d | 2010-04-06 15:14:15 -0700 | [diff] [blame] | 376 | { |
| 377 | return 0; |
| 378 | } |
| 379 | |
| 380 | void ceph_debugfs_client_cleanup(struct ceph_client *client) |
| 381 | { |
| 382 | } |
| 383 | |
| 384 | #endif /* CONFIG_DEBUG_FS */ |
| 385 | |
| 386 | EXPORT_SYMBOL(ceph_debugfs_init); |
| 387 | EXPORT_SYMBOL(ceph_debugfs_cleanup); |