~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/ceph/debugfs.c

Version: ~ [ linux-5.4-rc7 ] ~ [ linux-5.3.11 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.84 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.154 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.201 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.201 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.77 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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 #include "super.h"
 16 
 17 #ifdef CONFIG_DEBUG_FS
 18 
 19 #include "mds_client.h"
 20 
 21 static int mdsmap_show(struct seq_file *s, void *p)
 22 {
 23         int i;
 24         struct ceph_fs_client *fsc = s->private;
 25 
 26         if (fsc->mdsc == NULL || fsc->mdsc->mdsmap == NULL)
 27                 return 0;
 28         seq_printf(s, "epoch %d\n", fsc->mdsc->mdsmap->m_epoch);
 29         seq_printf(s, "root %d\n", fsc->mdsc->mdsmap->m_root);
 30         seq_printf(s, "session_timeout %d\n",
 31                        fsc->mdsc->mdsmap->m_session_timeout);
 32         seq_printf(s, "session_autoclose %d\n",
 33                        fsc->mdsc->mdsmap->m_session_autoclose);
 34         for (i = 0; i < fsc->mdsc->mdsmap->m_max_mds; i++) {
 35                 struct ceph_entity_addr *addr =
 36                         &fsc->mdsc->mdsmap->m_info[i].addr;
 37                 int state = fsc->mdsc->mdsmap->m_info[i].state;
 38 
 39                 seq_printf(s, "\tmds%d\t%s\t(%s)\n", i,
 40                                ceph_pr_addr(&addr->in_addr),
 41                                ceph_mds_state_name(state));
 42         }
 43         return 0;
 44 }
 45 
 46 /*
 47  * mdsc debugfs
 48  */
 49 static int mdsc_show(struct seq_file *s, void *p)
 50 {
 51         struct ceph_fs_client *fsc = s->private;
 52         struct ceph_mds_client *mdsc = fsc->mdsc;
 53         struct ceph_mds_request *req;
 54         struct rb_node *rp;
 55         int pathlen;
 56         u64 pathbase;
 57         char *path;
 58 
 59         mutex_lock(&mdsc->mutex);
 60         for (rp = rb_first(&mdsc->request_tree); rp; rp = rb_next(rp)) {
 61                 req = rb_entry(rp, struct ceph_mds_request, r_node);
 62 
 63                 if (req->r_request && req->r_session)
 64                         seq_printf(s, "%lld\tmds%d\t", req->r_tid,
 65                                    req->r_session->s_mds);
 66                 else if (!req->r_request)
 67                         seq_printf(s, "%lld\t(no request)\t", req->r_tid);
 68                 else
 69                         seq_printf(s, "%lld\t(no session)\t", req->r_tid);
 70 
 71                 seq_printf(s, "%s", ceph_mds_op_name(req->r_op));
 72 
 73                 if (req->r_got_unsafe)
 74                         seq_puts(s, "\t(unsafe)");
 75                 else
 76                         seq_puts(s, "\t");
 77 
 78                 if (req->r_inode) {
 79                         seq_printf(s, " #%llx", ceph_ino(req->r_inode));
 80                 } else if (req->r_dentry) {
 81                         path = ceph_mdsc_build_path(req->r_dentry, &pathlen,
 82                                                     &pathbase, 0);
 83                         if (IS_ERR(path))
 84                                 path = NULL;
 85                         spin_lock(&req->r_dentry->d_lock);
 86                         seq_printf(s, " #%llx/%pd (%s)",
 87                                    ceph_ino(d_inode(req->r_dentry->d_parent)),
 88                                    req->r_dentry,
 89                                    path ? path : "");
 90                         spin_unlock(&req->r_dentry->d_lock);
 91                         kfree(path);
 92                 } else if (req->r_path1) {
 93                         seq_printf(s, " #%llx/%s", req->r_ino1.ino,
 94                                    req->r_path1);
 95                 } else {
 96                         seq_printf(s, " #%llx", req->r_ino1.ino);
 97                 }
 98 
 99                 if (req->r_old_dentry) {
100                         path = ceph_mdsc_build_path(req->r_old_dentry, &pathlen,
101                                                     &pathbase, 0);
102                         if (IS_ERR(path))
103                                 path = NULL;
104                         spin_lock(&req->r_old_dentry->d_lock);
105                         seq_printf(s, " #%llx/%pd (%s)",
106                                    req->r_old_dentry_dir ?
107                                    ceph_ino(req->r_old_dentry_dir) : 0,
108                                    req->r_old_dentry,
109                                    path ? path : "");
110                         spin_unlock(&req->r_old_dentry->d_lock);
111                         kfree(path);
112                 } else if (req->r_path2 && req->r_op != CEPH_MDS_OP_SYMLINK) {
113                         if (req->r_ino2.ino)
114                                 seq_printf(s, " #%llx/%s", req->r_ino2.ino,
115                                            req->r_path2);
116                         else
117                                 seq_printf(s, " %s", req->r_path2);
118                 }
119 
120                 seq_puts(s, "\n");
121         }
122         mutex_unlock(&mdsc->mutex);
123 
124         return 0;
125 }
126 
127 static int caps_show(struct seq_file *s, void *p)
128 {
129         struct ceph_fs_client *fsc = s->private;
130         int total, avail, used, reserved, min;
131 
132         ceph_reservation_status(fsc, &total, &avail, &used, &reserved, &min);
133         seq_printf(s, "total\t\t%d\n"
134                    "avail\t\t%d\n"
135                    "used\t\t%d\n"
136                    "reserved\t%d\n"
137                    "min\t%d\n",
138                    total, avail, used, reserved, min);
139         return 0;
140 }
141 
142 static int dentry_lru_show(struct seq_file *s, void *ptr)
143 {
144         struct ceph_fs_client *fsc = s->private;
145         struct ceph_mds_client *mdsc = fsc->mdsc;
146         struct ceph_dentry_info *di;
147 
148         spin_lock(&mdsc->dentry_lru_lock);
149         list_for_each_entry(di, &mdsc->dentry_lru, lru) {
150                 struct dentry *dentry = di->dentry;
151                 seq_printf(s, "%p %p\t%pd\n",
152                            di, dentry, dentry);
153         }
154         spin_unlock(&mdsc->dentry_lru_lock);
155 
156         return 0;
157 }
158 
159 static int mds_sessions_show(struct seq_file *s, void *ptr)
160 {
161         struct ceph_fs_client *fsc = s->private;
162         struct ceph_mds_client *mdsc = fsc->mdsc;
163         struct ceph_auth_client *ac = fsc->client->monc.auth;
164         struct ceph_options *opt = fsc->client->options;
165         int mds = -1;
166 
167         mutex_lock(&mdsc->mutex);
168 
169         /* The 'num' portion of an 'entity name' */
170         seq_printf(s, "global_id %llu\n", ac->global_id);
171 
172         /* The -o name mount argument */
173         seq_printf(s, "name \"%s\"\n", opt->name ? opt->name : "");
174 
175         /* The list of MDS session rank+state */
176         for (mds = 0; mds < mdsc->max_sessions; mds++) {
177                 struct ceph_mds_session *session =
178                         __ceph_lookup_mds_session(mdsc, mds);
179                 if (!session) {
180                         continue;
181                 }
182                 mutex_unlock(&mdsc->mutex);
183                 seq_printf(s, "mds.%d %s\n",
184                                 session->s_mds,
185                                 ceph_session_state_name(session->s_state));
186 
187                 ceph_put_mds_session(session);
188                 mutex_lock(&mdsc->mutex);
189         }
190         mutex_unlock(&mdsc->mutex);
191 
192         return 0;
193 }
194 
195 CEPH_DEFINE_SHOW_FUNC(mdsmap_show)
196 CEPH_DEFINE_SHOW_FUNC(mdsc_show)
197 CEPH_DEFINE_SHOW_FUNC(caps_show)
198 CEPH_DEFINE_SHOW_FUNC(dentry_lru_show)
199 CEPH_DEFINE_SHOW_FUNC(mds_sessions_show)
200 
201 
202 /*
203  * debugfs
204  */
205 static int congestion_kb_set(void *data, u64 val)
206 {
207         struct ceph_fs_client *fsc = (struct ceph_fs_client *)data;
208 
209         fsc->mount_options->congestion_kb = (int)val;
210         return 0;
211 }
212 
213 static int congestion_kb_get(void *data, u64 *val)
214 {
215         struct ceph_fs_client *fsc = (struct ceph_fs_client *)data;
216 
217         *val = (u64)fsc->mount_options->congestion_kb;
218         return 0;
219 }
220 
221 DEFINE_SIMPLE_ATTRIBUTE(congestion_kb_fops, congestion_kb_get,
222                         congestion_kb_set, "%llu\n");
223 
224 
225 void ceph_fs_debugfs_cleanup(struct ceph_fs_client *fsc)
226 {
227         dout("ceph_fs_debugfs_cleanup\n");
228         debugfs_remove(fsc->debugfs_bdi);
229         debugfs_remove(fsc->debugfs_congestion_kb);
230         debugfs_remove(fsc->debugfs_mdsmap);
231         debugfs_remove(fsc->debugfs_mds_sessions);
232         debugfs_remove(fsc->debugfs_caps);
233         debugfs_remove(fsc->debugfs_mdsc);
234         debugfs_remove(fsc->debugfs_dentry_lru);
235 }
236 
237 int ceph_fs_debugfs_init(struct ceph_fs_client *fsc)
238 {
239         char name[100];
240         int err = -ENOMEM;
241 
242         dout("ceph_fs_debugfs_init\n");
243         BUG_ON(!fsc->client->debugfs_dir);
244         fsc->debugfs_congestion_kb =
245                 debugfs_create_file("writeback_congestion_kb",
246                                     0600,
247                                     fsc->client->debugfs_dir,
248                                     fsc,
249                                     &congestion_kb_fops);
250         if (!fsc->debugfs_congestion_kb)
251                 goto out;
252 
253         snprintf(name, sizeof(name), "../../bdi/%s",
254                  dev_name(fsc->backing_dev_info.dev));
255         fsc->debugfs_bdi =
256                 debugfs_create_symlink("bdi",
257                                        fsc->client->debugfs_dir,
258                                        name);
259         if (!fsc->debugfs_bdi)
260                 goto out;
261 
262         fsc->debugfs_mdsmap = debugfs_create_file("mdsmap",
263                                         0600,
264                                         fsc->client->debugfs_dir,
265                                         fsc,
266                                         &mdsmap_show_fops);
267         if (!fsc->debugfs_mdsmap)
268                 goto out;
269 
270         fsc->debugfs_mds_sessions = debugfs_create_file("mds_sessions",
271                                         0600,
272                                         fsc->client->debugfs_dir,
273                                         fsc,
274                                         &mds_sessions_show_fops);
275         if (!fsc->debugfs_mds_sessions)
276                 goto out;
277 
278         fsc->debugfs_mdsc = debugfs_create_file("mdsc",
279                                                 0600,
280                                                 fsc->client->debugfs_dir,
281                                                 fsc,
282                                                 &mdsc_show_fops);
283         if (!fsc->debugfs_mdsc)
284                 goto out;
285 
286         fsc->debugfs_caps = debugfs_create_file("caps",
287                                                    0400,
288                                                    fsc->client->debugfs_dir,
289                                                    fsc,
290                                                    &caps_show_fops);
291         if (!fsc->debugfs_caps)
292                 goto out;
293 
294         fsc->debugfs_dentry_lru = debugfs_create_file("dentry_lru",
295                                         0600,
296                                         fsc->client->debugfs_dir,
297                                         fsc,
298                                         &dentry_lru_show_fops);
299         if (!fsc->debugfs_dentry_lru)
300                 goto out;
301 
302         return 0;
303 
304 out:
305         ceph_fs_debugfs_cleanup(fsc);
306         return err;
307 }
308 
309 
310 #else  /* CONFIG_DEBUG_FS */
311 
312 int ceph_fs_debugfs_init(struct ceph_fs_client *fsc)
313 {
314         return 0;
315 }
316 
317 void ceph_fs_debugfs_cleanup(struct ceph_fs_client *fsc)
318 {
319 }
320 
321 #endif  /* CONFIG_DEBUG_FS */
322 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp