Whamcloud - gitweb
dd39312a0e64541d8e90c9efab54c99fbb27f3f9
[fs/lustre-release.git] / lustre / mds / lproc_mds.c
1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
2  * vim:expandtab:shiftwidth=8:tabstop=8:
3  *
4  *  Copyright (C) 2002 Cluster File Systems, Inc.
5  *
6  *   This file is part of Lustre, http://www.lustre.org.
7  *
8  *   Lustre is free software; you can redistribute it and/or
9  *   modify it under the terms of version 2 of the GNU General Public
10  *   License as published by the Free Software Foundation.
11  *
12  *   Lustre is distributed in the hope that it will be useful,
13  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
14  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  *   GNU General Public License for more details.
16  *
17  *   You should have received a copy of the GNU General Public License
18  *   along with Lustre; if not, write to the Free Software
19  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20  *
21  */
22 #define DEBUG_SUBSYSTEM S_CLASS
23
24 #include <linux/version.h>
25 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0))
26 #include <asm/statfs.h>
27 #endif
28 #include <linux/obd.h>
29 #include <linux/obd_class.h>
30 #include <linux/lprocfs_status.h>
31 #include "mds_internal.h"
32
33 #ifndef LPROCFS
34
35 struct lprocfs_vars lprocfs_mds_obd_vars[]  = { {0} };
36 struct lprocfs_vars lprocfs_mds_module_vars[] = { {0} };
37 struct lprocfs_vars lprocfs_mdt_obd_vars[] = { {0} };
38 struct lprocfs_vars lprocfs_mdt_module_vars[] = { {0} };
39
40 #else
41
42 static int lprocfs_mds_rd_mntdev(char *page, char **start, off_t off,
43                                  int count, int *eof, void *data)
44 {
45         struct obd_device* obd = (struct obd_device *)data;
46
47         LASSERT(obd != NULL);
48         LASSERT(obd->u.mds.mds_vfsmnt->mnt_devname);
49         *eof = 1;
50
51         return snprintf(page, count, "%s\n",
52                         obd->u.mds.mds_vfsmnt->mnt_devname);
53 }
54
55 static int lprocfs_mds_wr_evict_client(struct file *file, const char *buffer,
56                                        unsigned long count, void *data)
57 {
58         struct obd_device *obd = data;
59         struct obd_export *doomed_exp = NULL;
60         struct obd_uuid doomed;
61         struct list_head *p;
62         char tmpbuf[sizeof(doomed)];
63
64         sscanf(buffer, "%40s", tmpbuf);
65         obd_str2uuid(&doomed, tmpbuf);
66
67         spin_lock(&obd->obd_dev_lock);
68         list_for_each(p, &obd->obd_exports) {
69                 doomed_exp = list_entry(p, struct obd_export, exp_obd_chain);
70                 if (obd_uuid_equals(&doomed, &doomed_exp->exp_client_uuid)) {
71                         class_export_get(doomed_exp);
72                         break;
73                 }
74                 doomed_exp = NULL;
75         }
76         spin_unlock(&obd->obd_dev_lock);
77
78         if (doomed_exp == NULL) {
79                 CERROR("can't disconnect %s: no export found\n",
80                        doomed.uuid);
81         } else {
82                 CERROR("evicting %s at adminstrative request\n",
83                        doomed.uuid);
84                 ptlrpc_fail_export(doomed_exp);
85                 class_export_put(doomed_exp);
86         }
87         return count;
88 }
89
90 static int lprocfs_mds_wr_config_update(struct file *file, const char *buffer,
91                                         unsigned long count, void *data)
92 {
93         struct obd_device *obd = data;
94         ENTRY;
95
96         RETURN(mds_lov_update_config(obd, 0));
97 }
98
99 static int lprocfs_rd_last_fid(char *page, char **start, off_t off,
100                                int count, int *eof, void *data)
101 {
102         struct obd_device *obd = (struct obd_device *)data;
103         struct mds_obd *mds = &obd->u.mds;
104         __u64 last_fid;
105
106         down(&mds->mds_last_fid_sem);
107         last_fid = mds->mds_last_fid;
108         up(&mds->mds_last_fid_sem);
109
110         *eof = 1;
111         return snprintf(page, count, LPD64"\n", last_fid);
112 }
113
114 static int lprocfs_rd_group(char *page, char **start, off_t off,
115                             int count, int *eof, void *data)
116 {
117         struct obd_device *obd = (struct obd_device *)data;
118         struct mds_obd *mds = &obd->u.mds;
119
120         *eof = 1;
121         return snprintf(page, count, "%lu\n",
122                         (unsigned long)mds->mds_num);
123 }
124
125 struct lprocfs_vars lprocfs_mds_obd_vars[] = {
126         { "uuid",         lprocfs_rd_uuid,        0, 0 },
127         { "blocksize",    lprocfs_rd_blksize,     0, 0 },
128         { "kbytestotal",  lprocfs_rd_kbytestotal, 0, 0 },
129         { "kbytesfree",   lprocfs_rd_kbytesfree,  0, 0 },
130         { "kbytesavail",  lprocfs_rd_kbytesavail, 0, 0 },
131         { "fstype",       lprocfs_rd_fstype,      0, 0 },
132         { "filestotal",   lprocfs_rd_filestotal,  0, 0 },
133         { "filesfree",    lprocfs_rd_filesfree,   0, 0 },
134         { "mntdev",       lprocfs_mds_rd_mntdev,  0, 0 },
135         { "last_fid",     lprocfs_rd_last_fid,    0, 0 },
136         { "group",        lprocfs_rd_group,       0, 0 },
137         { "recovery_status", lprocfs_obd_rd_recovery_status, 0, 0 },
138         { "evict_client", 0, lprocfs_mds_wr_evict_client, 0 },
139         { "config_update", 0, lprocfs_mds_wr_config_update, 0 },
140         { "num_exports",  lprocfs_rd_num_exports, 0, 0 },
141         { 0 }
142 };
143
144 /*
145  * group hash proc entries handler
146  */
147 static int lprocfs_wr_group_info(struct file *file, const char *buffer,
148                                  unsigned long count, void *data)
149 {
150         struct {
151                 int             err;
152                 uid_t           uid;
153                 uint32_t        ngroups;
154                 gid_t          *groups;
155         } param;
156         gid_t   gids_local[NGROUPS_SMALL];
157         gid_t  *gids = NULL;
158
159         if (count != sizeof(param)) {
160                 CERROR("invalid data size %lu\n", count);
161                 return count;
162         }
163         if (copy_from_user(&param, buffer, count)) {
164                 CERROR("broken downcall\n");
165                 return count;
166         }
167         if (param.ngroups > NGROUPS_MAX) {
168                 CERROR("%d groups?\n", param.ngroups);
169                 return count;
170         }
171
172         if (param.ngroups <= NGROUPS_SMALL)
173                 gids = gids_local;
174         else {
175                 OBD_ALLOC(gids, param.ngroups * sizeof(gid_t));
176                 if (!gids) {
177                         CERROR("fail to alloc memory for %d gids\n",
178                                 param.ngroups);
179                         return count;
180                 }
181         }
182         if (copy_from_user(gids, param.groups,
183                            param.ngroups * sizeof(gid_t))) {
184                 CERROR("broken downcall\n");
185                 goto out;
186         }
187
188         mds_handle_group_downcall(param.err, param.uid,
189                                   param.ngroups, gids);
190
191 out:
192         if (gids && gids != gids_local)
193                 OBD_FREE(gids, param.ngroups * sizeof(gid_t));
194         return count;
195 }
196
197 static int lprocfs_rd_expire(char *page, char **start, off_t off, int count,
198                              int *eof, void *data)
199 {
200         struct mds_grp_hash *hash = __mds_get_global_group_hash();
201
202         *eof = 1;
203         return snprintf(page, count, "%d\n", hash->gh_entry_expire);
204 }
205
206 static int lprocfs_wr_expire(struct file *file, const char *buffer,
207                              unsigned long count, void *data)
208 {
209         struct mds_grp_hash *hash = __mds_get_global_group_hash();
210         char buf[32];
211
212         if (copy_from_user(buf, buffer, min(count, 32UL)))
213                 return count;
214         buf[31] = 0;
215         sscanf(buf, "%d", &hash->gh_entry_expire);
216         return count;
217 }
218
219 static int lprocfs_rd_ac_expire(char *page, char **start, off_t off, int count,
220                                 int *eof, void *data)
221 {
222         struct mds_grp_hash *hash = __mds_get_global_group_hash();
223
224         *eof = 1;
225         return snprintf(page, count, "%d\n", hash->gh_acquire_expire);
226 }
227
228 static int lprocfs_wr_ac_expire(struct file *file, const char *buffer,
229                                 unsigned long count, void *data)
230 {
231         struct mds_grp_hash *hash = __mds_get_global_group_hash();
232         char buf[32];
233
234         if (copy_from_user(buf, buffer, min(count, 32UL)))
235                 return count;
236         buf[31] = 0;
237         sscanf(buf, "%d", &hash->gh_acquire_expire);
238         return count;
239 }
240
241 static int lprocfs_rd_hash_upcall(char *page, char **start, off_t off, int count,
242                                 int *eof, void *data)
243 {
244         struct mds_grp_hash *hash = __mds_get_global_group_hash();
245
246         *eof = 1;
247         return snprintf(page, count, "%s\n", hash->gh_upcall);
248 }
249
250 static int lprocfs_wr_hash_upcall(struct file *file, const char *buffer,
251                                   unsigned long count, void *data)
252 {
253         struct mds_grp_hash *hash = __mds_get_global_group_hash();
254
255         if (count < MDSGRP_UPCALL_MAXPATH) {
256                 sscanf(buffer, "%1024s", hash->gh_upcall);
257                 hash->gh_upcall[MDSGRP_UPCALL_MAXPATH-1] = 0;
258         }
259         return count;
260 }
261
262 static int lprocfs_wr_hash_flush(struct file *file, const char *buffer,
263                                   unsigned long count, void *data)
264 {
265         mds_group_hash_flush_idle();
266         return count;
267 }
268
269 static int lprocfs_rd_allow_setgroups(char *page, char **start, off_t off,
270                                       int count, int *eof, void *data)
271 {
272         struct mds_grp_hash *hash = __mds_get_global_group_hash();
273
274         *eof = 1;
275         return snprintf(page, count, "%d\n", hash->gh_allow_setgroups);
276 }
277
278 static int lprocfs_wr_allow_setgroups(struct file *file, const char *buffer,
279                                       unsigned long count, void *data)
280 {
281         struct mds_grp_hash *hash = __mds_get_global_group_hash();
282         char buf[8];
283         int val;
284
285         if (copy_from_user(buf, buffer, min(count, 8UL)))
286                 return count;
287         buf[7] = 0;
288         sscanf(buf, "%d", &val);
289         hash->gh_allow_setgroups = (val != 0);
290         return count;
291 }
292
293 struct lprocfs_vars lprocfs_mds_module_vars[] = {
294         { "num_refs", lprocfs_rd_numrefs, 0, 0 },
295         { "grp_hash_expire_interval",lprocfs_rd_expire,
296           lprocfs_wr_expire, 0},
297         { "grp_hash_acquire_expire", lprocfs_rd_ac_expire,
298           lprocfs_wr_ac_expire, 0},
299         { "grp_hash_upcall", lprocfs_rd_hash_upcall,
300           lprocfs_wr_hash_upcall, 0},
301         { "grp_hash_flush", 0, lprocfs_wr_hash_flush, 0},
302         { "group_info", 0, lprocfs_wr_group_info, 0 },
303         { "allow_setgroups", lprocfs_rd_allow_setgroups,
304           lprocfs_wr_allow_setgroups, 0},
305         { 0 }
306 };
307
308 struct lprocfs_vars lprocfs_mdt_obd_vars[] = {
309         { "uuid",         lprocfs_rd_uuid,        0, 0 },
310         { 0 }
311 };
312
313 struct lprocfs_vars lprocfs_mdt_module_vars[] = {
314         { "num_refs",     lprocfs_rd_numrefs,     0, 0 },
315         { 0 }
316 };
317 #endif /* LPROCFS */
318
319 struct lprocfs_static_vars lprocfs_array_vars[] = { {lprocfs_mds_module_vars,
320                                                      lprocfs_mds_obd_vars},
321                                                     {lprocfs_mdt_module_vars,
322                                                      lprocfs_mdt_obd_vars}};
323
324 LPROCFS_INIT_MULTI_VARS(lprocfs_array_vars,
325                         (sizeof(lprocfs_array_vars) /
326                          sizeof(struct lprocfs_static_vars)))