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

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

Version: ~ [ linux-5.6-rc1 ] ~ [ linux-5.5.2 ] ~ [ linux-5.4.17 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.102 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.170 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.213 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.213 ] ~ [ 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.81 ] ~ [ 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_printf(s, "\t(unsafe)");
 75                 else
 76                         seq_printf(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/%.*s (%s)",
 87                                    ceph_ino(req->r_dentry->d_parent->d_inode),
 88                                    req->r_dentry->d_name.len,
 89                                    req->r_dentry->d_name.name,
 90                                    path ? path : "");
 91                         spin_unlock(&req->r_dentry->d_lock);
 92                         kfree(path);
 93                 } else if (req->r_path1) {
 94                         seq_printf(s, " #%llx/%s", req->r_ino1.ino,
 95                                    req->r_path1);
 96                 }
 97 
 98                 if (req->r_old_dentry) {
 99                         path = ceph_mdsc_build_path(req->r_old_dentry, &pathlen,
100                                                     &pathbase, 0);
101                         if (IS_ERR(path))
102                                 path = NULL;
103                         spin_lock(&req->r_old_dentry->d_lock);
104                         seq_printf(s, " #%llx/%.*s (%s)",
105                            ceph_ino(req->r_old_dentry_dir),
106                                    req->r_old_dentry->d_name.len,
107                                    req->r_old_dentry->d_name.name,
108                                    path ? path : "");
109                         spin_unlock(&req->r_old_dentry->d_lock);
110                         kfree(path);
111                 } else if (req->r_path2) {
112                         if (req->r_ino2.ino)
113                                 seq_printf(s, " #%llx/%s", req->r_ino2.ino,
114                                            req->r_path2);
115                         else
116                                 seq_printf(s, " %s", req->r_path2);
117                 }
118 
119                 seq_printf(s, "\n");
120         }
121         mutex_unlock(&mdsc->mutex);
122 
123         return 0;
124 }
125 
126 static int caps_show(struct seq_file *s, void *p)
127 {
128         struct ceph_fs_client *fsc = s->private;
129         int total, avail, used, reserved, min;
130 
131         ceph_reservation_status(fsc, &total, &avail, &used, &reserved, &min);
132         seq_printf(s, "total\t\t%d\n"
133                    "avail\t\t%d\n"
134                    "used\t\t%d\n"
135                    "reserved\t%d\n"
136                    "min\t%d\n",
137                    total, avail, used, reserved, min);
138         return 0;
139 }
140 
141 static int dentry_lru_show(struct seq_file *s, void *ptr)
142 {
143         struct ceph_fs_client *fsc = s->private;
144         struct ceph_mds_client *mdsc = fsc->mdsc;
145         struct ceph_dentry_info *di;
146 
147         spin_lock(&mdsc->dentry_lru_lock);
148         list_for_each_entry(di, &mdsc->dentry_lru, lru) {
149                 struct dentry *dentry = di->dentry;
150                 seq_printf(s, "%p %p\t%.*s\n",
151                            di, dentry, dentry->d_name.len, dentry->d_name.name);
152         }
153         spin_unlock(&mdsc->dentry_lru_lock);
154 
155         return 0;
156 }
157 
158 CEPH_DEFINE_SHOW_FUNC(mdsmap_show)
159 CEPH_DEFINE_SHOW_FUNC(mdsc_show)
160 CEPH_DEFINE_SHOW_FUNC(caps_show)
161 CEPH_DEFINE_SHOW_FUNC(dentry_lru_show)
162 
163 
164 /*
165  * debugfs
166  */
167 static int congestion_kb_set(void *data, u64 val)
168 {
169         struct ceph_fs_client *fsc = (struct ceph_fs_client *)data;
170 
171         fsc->mount_options->congestion_kb = (int)val;
172         return 0;
173 }
174 
175 static int congestion_kb_get(void *data, u64 *val)
176 {
177         struct ceph_fs_client *fsc = (struct ceph_fs_client *)data;
178 
179         *val = (u64)fsc->mount_options->congestion_kb;
180         return 0;
181 }
182 
183 DEFINE_SIMPLE_ATTRIBUTE(congestion_kb_fops, congestion_kb_get,
184                         congestion_kb_set, "%llu\n");
185 
186 
187 void ceph_fs_debugfs_cleanup(struct ceph_fs_client *fsc)
188 {
189         dout("ceph_fs_debugfs_cleanup\n");
190         debugfs_remove(fsc->debugfs_bdi);
191         debugfs_remove(fsc->debugfs_congestion_kb);
192         debugfs_remove(fsc->debugfs_mdsmap);
193         debugfs_remove(fsc->debugfs_caps);
194         debugfs_remove(fsc->debugfs_mdsc);
195         debugfs_remove(fsc->debugfs_dentry_lru);
196 }
197 
198 int ceph_fs_debugfs_init(struct ceph_fs_client *fsc)
199 {
200         char name[100];
201         int err = -ENOMEM;
202 
203         dout("ceph_fs_debugfs_init\n");
204         BUG_ON(!fsc->client->debugfs_dir);
205         fsc->debugfs_congestion_kb =
206                 debugfs_create_file("writeback_congestion_kb",
207                                     0600,
208                                     fsc->client->debugfs_dir,
209                                     fsc,
210                                     &congestion_kb_fops);
211         if (!fsc->debugfs_congestion_kb)
212                 goto out;
213 
214         snprintf(name, sizeof(name), "../../bdi/%s",
215                  dev_name(fsc->backing_dev_info.dev));
216         fsc->debugfs_bdi =
217                 debugfs_create_symlink("bdi",
218                                        fsc->client->debugfs_dir,
219                                        name);
220         if (!fsc->debugfs_bdi)
221                 goto out;
222 
223         fsc->debugfs_mdsmap = debugfs_create_file("mdsmap",
224                                         0600,
225                                         fsc->client->debugfs_dir,
226                                         fsc,
227                                         &mdsmap_show_fops);
228         if (!fsc->debugfs_mdsmap)
229                 goto out;
230 
231         fsc->debugfs_mdsc = debugfs_create_file("mdsc",
232                                                 0600,
233                                                 fsc->client->debugfs_dir,
234                                                 fsc,
235                                                 &mdsc_show_fops);
236         if (!fsc->debugfs_mdsc)
237                 goto out;
238 
239         fsc->debugfs_caps = debugfs_create_file("caps",
240                                                    0400,
241                                                    fsc->client->debugfs_dir,
242                                                    fsc,
243                                                    &caps_show_fops);
244         if (!fsc->debugfs_caps)
245                 goto out;
246 
247         fsc->debugfs_dentry_lru = debugfs_create_file("dentry_lru",
248                                         0600,
249                                         fsc->client->debugfs_dir,
250                                         fsc,
251                                         &dentry_lru_show_fops);
252         if (!fsc->debugfs_dentry_lru)
253                 goto out;
254 
255         return 0;
256 
257 out:
258         ceph_fs_debugfs_cleanup(fsc);
259         return err;
260 }
261 
262 
263 #else  /* CONFIG_DEBUG_FS */
264 
265 int ceph_fs_debugfs_init(struct ceph_fs_client *fsc)
266 {
267         return 0;
268 }
269 
270 void ceph_fs_debugfs_cleanup(struct ceph_fs_client *fsc)
271 {
272 }
273 
274 #endif  /* CONFIG_DEBUG_FS */
275 

~ [ 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