Whamcloud - gitweb
LU-1187 tests: Add DNE test cases in sanity.
[fs/lustre-release.git] / lustre / osp / lproc_osp.c
1 /*
2  * GPL HEADER START
3  *
4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License version 2 only,
8  * as published by the Free Software Foundation.
9  *
10  * This program is distributed in the hope that it will be useful, but
11  * WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * General Public License version 2 for more details (a copy is included
14  * in the LICENSE file that accompanied this code).
15  *
16  * You should have received a copy of the GNU General Public License
17  * version 2 along with this program; If not, see
18  * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
19  *
20  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
21  * CA 95054 USA or visit www.sun.com if you need additional information or
22  * have any questions.
23  *
24  * GPL HEADER END
25  */
26 /*
27  * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
28  * Use is subject to license terms.
29  *
30  * Copyright (c) 2011, 2012, Intel, Inc.
31  */
32 /*
33  * This file is part of Lustre, http://www.lustre.org/
34  * Lustre is a trademark of Sun Microsystems, Inc.
35  *
36  * lustre/osp/lproc_osp.c
37  *
38  * Lustre OST Proxy Device, procfs functions
39  *
40  * Author: Alex Zhuravlev <alexey.zhuravlev@intel.com>
41  */
42
43 #define DEBUG_SUBSYSTEM S_CLASS
44
45 #include "osp_internal.h"
46
47 #ifdef LPROCFS
48 static int osp_rd_active(char *page, char **start, off_t off,
49                          int count, int *eof, void *data)
50 {
51         struct obd_device       *dev = data;
52         int                      rc;
53
54         LPROCFS_CLIMP_CHECK(dev);
55         rc = snprintf(page, count, "%d\n",
56                       !dev->u.cli.cl_import->imp_deactive);
57         LPROCFS_CLIMP_EXIT(dev);
58         return rc;
59 }
60
61 static int osp_wr_active(struct file *file, const char *buffer,
62                          unsigned long count, void *data)
63 {
64         struct obd_device       *dev = data;
65         int                      val, rc;
66
67         rc = lprocfs_write_helper(buffer, count, &val);
68         if (rc)
69                 return rc;
70         if (val < 0 || val > 1)
71                 return -ERANGE;
72
73         LPROCFS_CLIMP_CHECK(dev);
74         /* opposite senses */
75         if (dev->u.cli.cl_import->imp_deactive == val)
76                 rc = ptlrpc_set_import_active(dev->u.cli.cl_import, val);
77         else
78                 CDEBUG(D_CONFIG, "activate %d: ignoring repeat request\n",
79                        val);
80
81         LPROCFS_CLIMP_EXIT(dev);
82         return count;
83 }
84
85 static int osp_rd_syn_in_flight(char *page, char **start, off_t off,
86                                 int count, int *eof, void *data)
87 {
88         struct obd_device       *dev = data;
89         struct osp_device       *osp = lu2osp_dev(dev->obd_lu_dev);
90         int                      rc;
91
92         if (osp == NULL)
93                 return -EINVAL;
94
95         rc = snprintf(page, count, "%u\n", osp->opd_syn_rpc_in_flight);
96         return rc;
97 }
98
99 static int osp_rd_syn_in_prog(char *page, char **start, off_t off, int count,
100                               int *eof, void *data)
101 {
102         struct obd_device       *dev = data;
103         struct osp_device       *osp = lu2osp_dev(dev->obd_lu_dev);
104         int                      rc;
105
106         if (osp == NULL)
107                 return -EINVAL;
108
109         rc = snprintf(page, count, "%u\n", osp->opd_syn_rpc_in_progress);
110         return rc;
111 }
112
113 static int osp_rd_syn_changes(char *page, char **start, off_t off,
114                               int count, int *eof, void *data)
115 {
116         struct obd_device       *dev = data;
117         struct osp_device       *osp = lu2osp_dev(dev->obd_lu_dev);
118         int                      rc;
119
120         if (osp == NULL)
121                 return -EINVAL;
122
123         rc = snprintf(page, count, "%lu\n", osp->opd_syn_changes);
124         return rc;
125 }
126
127 static int osp_rd_max_rpcs_in_flight(char *page, char **start, off_t off,
128                                      int count, int *eof, void *data)
129 {
130         struct obd_device       *dev = data;
131         struct osp_device       *osp = lu2osp_dev(dev->obd_lu_dev);
132         int                      rc;
133
134         if (osp == NULL)
135                 return -EINVAL;
136
137         rc = snprintf(page, count, "%u\n", osp->opd_syn_max_rpc_in_flight);
138         return rc;
139 }
140
141 static int osp_wr_max_rpcs_in_flight(struct file *file, const char *buffer,
142                                      unsigned long count, void *data)
143 {
144         struct obd_device       *dev = data;
145         struct osp_device       *osp = lu2osp_dev(dev->obd_lu_dev);
146         int                      val, rc;
147
148         if (osp == NULL)
149                 return -EINVAL;
150
151         rc = lprocfs_write_helper(buffer, count, &val);
152         if (rc)
153                 return rc;
154
155         if (val < 1)
156                 return -ERANGE;
157
158         osp->opd_syn_max_rpc_in_flight = val;
159         return count;
160 }
161
162 static int osp_rd_max_rpcs_in_prog(char *page, char **start, off_t off,
163                                    int count, int *eof, void *data)
164 {
165         struct obd_device       *dev = data;
166         struct osp_device       *osp = lu2osp_dev(dev->obd_lu_dev);
167         int                      rc;
168
169         if (osp == NULL)
170                 return -EINVAL;
171
172         rc = snprintf(page, count, "%u\n", osp->opd_syn_max_rpc_in_progress);
173         return rc;
174 }
175
176 static int osp_wr_max_rpcs_in_prog(struct file *file, const char *buffer,
177                                    unsigned long count, void *data)
178 {
179         struct obd_device       *dev = data;
180         struct osp_device       *osp = lu2osp_dev(dev->obd_lu_dev);
181         int                      val, rc;
182
183         if (osp == NULL)
184                 return -EINVAL;
185
186         rc = lprocfs_write_helper(buffer, count, &val);
187         if (rc)
188                 return rc;
189
190         if (val < 1)
191                 return -ERANGE;
192
193         osp->opd_syn_max_rpc_in_progress = val;
194
195         return count;
196 }
197
198 static int osp_rd_create_count(char *page, char **start, off_t off, int count,
199                                int *eof, void *data)
200 {
201         struct obd_device *obd = data;
202         struct osp_device *osp = lu2osp_dev(obd->obd_lu_dev);
203
204         if (osp == NULL)
205                 return 0;
206
207         return snprintf(page, count, "%d\n", osp->opd_pre_grow_count);
208 }
209
210 static int osp_wr_create_count(struct file *file, const char *buffer,
211                                unsigned long count, void *data)
212 {
213         struct obd_device       *obd = data;
214         struct osp_device       *osp = lu2osp_dev(obd->obd_lu_dev);
215         int                      val, rc, i;
216
217         if (osp == NULL)
218                 return 0;
219
220         rc = lprocfs_write_helper(buffer, count, &val);
221         if (rc)
222                 return rc;
223
224         /* The MDT ALWAYS needs to limit the precreate count to
225          * OST_MAX_PRECREATE, and the constant cannot be changed
226          * because it is a value shared between the OSP and OST
227          * that is the maximum possible number of objects that will
228          * ever be handled by MDT->OST recovery processing.
229          *
230          * If the OST ever gets a request to delete more orphans,
231          * this implies that something has gone badly on the MDT
232          * and the OST will refuse to delete so much data from the
233          * filesystem as a safety measure. */
234         if (val < OST_MIN_PRECREATE || val > OST_MAX_PRECREATE)
235                 return -ERANGE;
236         if (val > osp->opd_pre_max_grow_count)
237                 return -ERANGE;
238
239         for (i = 1; (i << 1) <= val; i <<= 1)
240                 ;
241         osp->opd_pre_grow_count = i;
242
243         return count;
244 }
245
246 static int osp_rd_max_create_count(char *page, char **start, off_t off,
247                                    int count, int *eof, void *data)
248 {
249         struct obd_device *obd = data;
250         struct osp_device *osp = lu2osp_dev(obd->obd_lu_dev);
251
252         if (osp == NULL)
253                 return 0;
254
255         return snprintf(page, count, "%d\n", osp->opd_pre_max_grow_count);
256 }
257
258 static int osp_wr_max_create_count(struct file *file, const char *buffer,
259                                    unsigned long count, void *data)
260 {
261         struct obd_device       *obd = data;
262         struct osp_device       *osp = lu2osp_dev(obd->obd_lu_dev);
263         int                      val, rc;
264
265         if (osp == NULL)
266                 return 0;
267
268         rc = lprocfs_write_helper(buffer, count, &val);
269         if (rc)
270                 return rc;
271
272         if (val < 0)
273                 return -ERANGE;
274         if (val > OST_MAX_PRECREATE)
275                 return -ERANGE;
276
277         if (osp->opd_pre_grow_count > val)
278                 osp->opd_pre_grow_count = val;
279
280         osp->opd_pre_max_grow_count = val;
281
282         return count;
283 }
284
285 static int osp_rd_prealloc_next_id(char *page, char **start, off_t off,
286                                    int count, int *eof, void *data)
287 {
288         struct obd_device *obd = data;
289         struct osp_device *osp = lu2osp_dev(obd->obd_lu_dev);
290
291         if (osp == NULL)
292                 return 0;
293
294         return snprintf(page, count, LPU64"\n", osp->opd_pre_used_id + 1);
295 }
296
297 static int osp_rd_prealloc_last_id(char *page, char **start, off_t off,
298                                    int count, int *eof, void *data)
299 {
300         struct obd_device *obd = data;
301         struct osp_device *osp = lu2osp_dev(obd->obd_lu_dev);
302
303         if (osp == NULL)
304                 return 0;
305
306         return snprintf(page, count, LPU64"\n", osp->opd_pre_last_created);
307 }
308
309 static int osp_rd_prealloc_reserved(char *page, char **start, off_t off,
310                                     int count, int *eof, void *data)
311 {
312         struct obd_device *obd = data;
313         struct osp_device *osp = lu2osp_dev(obd->obd_lu_dev);
314
315         if (osp == NULL)
316                 return 0;
317
318         return snprintf(page, count, LPU64"\n", osp->opd_pre_reserved);
319 }
320
321 static int osp_rd_maxage(char *page, char **start, off_t off,
322                          int count, int *eof, void *data)
323 {
324         struct obd_device       *dev = data;
325         struct osp_device       *osp = lu2osp_dev(dev->obd_lu_dev);
326         int                      rc;
327
328         if (osp == NULL)
329                 return -EINVAL;
330
331         rc = snprintf(page, count, "%u\n", osp->opd_statfs_maxage);
332         return rc;
333 }
334
335 static int osp_wr_maxage(struct file *file, const char *buffer,
336                          unsigned long count, void *data)
337 {
338         struct obd_device       *dev = data;
339         struct osp_device       *osp = lu2osp_dev(dev->obd_lu_dev);
340         int                      val, rc;
341
342         if (osp == NULL)
343                 return -EINVAL;
344
345         rc = lprocfs_write_helper(buffer, count, &val);
346         if (rc)
347                 return rc;
348
349         if (val < 1)
350                 return -ERANGE;
351
352         osp->opd_statfs_maxage = val;
353
354         return count;
355 }
356
357 static int osp_rd_pre_status(char *page, char **start, off_t off,
358                              int count, int *eof, void *data)
359 {
360         struct obd_device       *dev = data;
361         struct osp_device       *osp = lu2osp_dev(dev->obd_lu_dev);
362         int                      rc;
363
364         if (osp == NULL)
365                 return -EINVAL;
366
367         rc = snprintf(page, count, "%d\n", osp->opd_pre_status);
368         return rc;
369 }
370
371 static int osp_rd_destroys_in_flight(char *page, char **start, off_t off,
372                                      int count, int *eof, void *data)
373 {
374         struct obd_device *dev = data;
375         struct osp_device *osp = lu2osp_dev(dev->obd_lu_dev);
376
377         /*
378          * This counter used to determine if OST has space returned.
379          * Now we need to wait for the following:
380          * - sync changes are zero - no llog records
381          * - sync in progress are zero - no RPCs in flight
382          */
383         return snprintf(page, count, "%lu\n",
384                         osp->opd_syn_rpc_in_progress + osp->opd_syn_changes);
385 }
386
387 static int osp_rd_old_sync_processed(char *page, char **start, off_t off,
388                                      int count, int *eof, void *data)
389 {
390         struct obd_device       *dev = data;
391         struct osp_device       *osp = lu2osp_dev(dev->obd_lu_dev);
392         int                      rc;
393
394         if (osp == NULL)
395                 return -EINVAL;
396
397         rc = snprintf(page, count, "%d\n", osp->opd_syn_prev_done);
398         return rc;
399 }
400
401 static struct lprocfs_vars lprocfs_osp_obd_vars[] = {
402         { "uuid",               lprocfs_rd_uuid, 0, 0 },
403         { "ping",               0, lprocfs_wr_ping, 0, 0, 0222 },
404         { "connect_flags",      lprocfs_rd_connect_flags, 0, 0 },
405         { "ost_server_uuid",    lprocfs_rd_server_uuid, 0, 0 },
406         { "ost_conn_uuid",      lprocfs_rd_conn_uuid, 0, 0 },
407         { "active",             osp_rd_active, osp_wr_active, 0 },
408         { "max_rpcs_in_flight", osp_rd_max_rpcs_in_flight,
409                                 osp_wr_max_rpcs_in_flight, 0 },
410         { "max_rpcs_in_progress", osp_rd_max_rpcs_in_prog,
411                                   osp_wr_max_rpcs_in_prog, 0 },
412         { "create_count",       osp_rd_create_count,
413                                 osp_wr_create_count, 0 },
414         { "max_create_count",   osp_rd_max_create_count,
415                                 osp_wr_max_create_count, 0 },
416         { "prealloc_next_id",   osp_rd_prealloc_next_id, 0, 0 },
417         { "prealloc_last_id",   osp_rd_prealloc_last_id, 0, 0 },
418         { "prealloc_reserved",  osp_rd_prealloc_reserved, 0, 0 },
419         { "timeouts",           lprocfs_rd_timeouts, 0, 0 },
420         { "import",             lprocfs_rd_import, lprocfs_wr_import, 0 },
421         { "state",              lprocfs_rd_state, 0, 0 },
422         { "maxage",             osp_rd_maxage, osp_wr_maxage, 0 },
423         { "prealloc_status",    osp_rd_pre_status, 0, 0 },
424         { "sync_changes",       osp_rd_syn_changes, 0, 0 },
425         { "sync_in_flight",     osp_rd_syn_in_flight, 0, 0 },
426         { "sync_in_progress",   osp_rd_syn_in_prog, 0, 0 },
427         { "old_sync_processed", osp_rd_old_sync_processed, 0, 0 },
428
429         /* for compatibility reasons */
430         { "destroys_in_flight", osp_rd_destroys_in_flight, 0, 0 },
431         { 0 }
432 };
433
434 static struct lprocfs_vars lprocfs_osp_osd_vars[] = {
435         { "blocksize",          lprocfs_osd_rd_blksize, 0, 0 },
436         { "kbytestotal",        lprocfs_osd_rd_kbytestotal, 0, 0 },
437         { "kbytesfree",         lprocfs_osd_rd_kbytesfree, 0, 0 },
438         { "kbytesavail",        lprocfs_osd_rd_kbytesavail, 0, 0 },
439         { "filestotal",         lprocfs_osd_rd_filestotal, 0, 0 },
440         { "filesfree",          lprocfs_osd_rd_filesfree, 0, 0 },
441         { 0 }
442 };
443
444 static struct lprocfs_vars lprocfs_osp_module_vars[] = {
445         { "num_refs",           lprocfs_rd_numrefs, 0, 0 },
446         { 0 }
447 };
448
449 void lprocfs_osp_init_vars(struct lprocfs_static_vars *lvars)
450 {
451         lvars->module_vars = lprocfs_osp_module_vars;
452         lvars->obd_vars = lprocfs_osp_obd_vars;
453 }
454
455 void osp_lprocfs_init(struct osp_device *osp)
456 {
457         struct obd_device       *obd = osp->opd_obd;
458         struct proc_dir_entry   *osc_proc_dir;
459         int                      rc;
460
461         obd->obd_proc_entry = lprocfs_register(obd->obd_name,
462                                                obd->obd_type->typ_procroot,
463                                                lprocfs_osp_osd_vars,
464                                                &osp->opd_dt_dev);
465         if (IS_ERR(obd->obd_proc_entry)) {
466                 CERROR("%s: can't register in lprocfs: %ld\n",
467                        obd->obd_name, PTR_ERR(obd->obd_proc_entry));
468                 obd->obd_proc_entry = NULL;
469                 return;
470         }
471
472         rc = lprocfs_add_vars(obd->obd_proc_entry, lprocfs_osp_obd_vars, obd);
473         if (rc) {
474                 CERROR("%s: can't register in lprocfs: %ld\n",
475                        obd->obd_name, PTR_ERR(obd->obd_proc_entry));
476                 return;
477         }
478
479         ptlrpc_lprocfs_register_obd(obd);
480
481         /* for compatibility we link old procfs's OSC entries to osp ones */
482         osc_proc_dir = lprocfs_srch(proc_lustre_root, "osc");
483         if (osc_proc_dir) {
484                 cfs_proc_dir_entry_t    *symlink = NULL;
485                 char                    *name;
486
487                 OBD_ALLOC(name, strlen(obd->obd_name) + 1);
488                 if (name == NULL)
489                         return;
490
491                 strcpy(name, obd->obd_name);
492                 if (strstr(name, "osc"))
493                         symlink = lprocfs_add_symlink(name, osc_proc_dir,
494                                                       "../osp/%s",
495                                                       obd->obd_name);
496                 OBD_FREE(name, strlen(obd->obd_name) + 1);
497                 osp->opd_symlink = symlink;
498         }
499 }
500
501 #endif /* LPROCFS */
502