Whamcloud - gitweb
6dc92878195f8498e8a1c22f7da97c3560489f2d
[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.gnu.org/licenses/gpl-2.0.html
19  *
20  * GPL HEADER END
21  */
22 /*
23  * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
24  * Use is subject to license terms.
25  *
26  * Copyright (c) 2012, 2015, Intel Corporation.
27  */
28 /*
29  * This file is part of Lustre, http://www.lustre.org/
30  * Lustre is a trademark of Sun Microsystems, Inc.
31  *
32  * lustre/osp/lproc_osp.c
33  *
34  * Lustre OST Proxy Device (OSP), procfs functions
35  *
36  * Author: Alex Zhuravlev <alexey.zhuravlev@intel.com>
37  */
38
39 #define DEBUG_SUBSYSTEM S_CLASS
40
41 #include "osp_internal.h"
42
43 #ifdef CONFIG_PROC_FS
44 /**
45  * Show OSP active status
46  *
47  * \param[in] m         seq_file handle
48  * \param[in] data      unused for single entry
49  * \retval              0 on success
50  * \retval              negative number on error
51  */
52 static int osp_active_seq_show(struct seq_file *m, void *data)
53 {
54         struct obd_device       *dev = m->private;
55
56         LPROCFS_CLIMP_CHECK(dev);
57         seq_printf(m, "%d\n", !dev->u.cli.cl_import->imp_deactive);
58         LPROCFS_CLIMP_EXIT(dev);
59         return 0;
60 }
61
62 /**
63  * Activate/Deactivate OSP
64  *
65  * \param[in] file      proc file
66  * \param[in] buffer    string, which is "1" or "0" to activate/deactivate OSP
67  * \param[in] count     \a buffer length
68  * \param[in] off       unused for single entry
69  * \retval              \a count on success
70  * \retval              negative number on error
71  */
72 static ssize_t
73 osp_active_seq_write(struct file *file, const char __user *buffer,
74                         size_t count, loff_t *off)
75 {
76         struct seq_file *m = file->private_data;
77         struct obd_device *dev = m->private;
78         int rc;
79         __s64 val;
80
81         rc = lprocfs_str_to_s64(buffer, count, &val);
82         if (rc)
83                 return rc;
84         if (val < 0 || val > 1)
85                 return -ERANGE;
86
87         LPROCFS_CLIMP_CHECK(dev);
88         /* opposite senses */
89         if (dev->u.cli.cl_import->imp_deactive == val)
90                 rc = ptlrpc_set_import_active(dev->u.cli.cl_import, val);
91         else
92                 CDEBUG(D_CONFIG, "activate "LPD64": ignoring repeat request\n",
93                        val);
94
95         LPROCFS_CLIMP_EXIT(dev);
96         return count;
97 }
98 LPROC_SEQ_FOPS(osp_active);
99
100 /**
101  * Show number of RPCs in flight
102  *
103  * \param[in] m         seq_file handle
104  * \param[in] data      unused for single entry
105  * \retval              0 on success
106  * \retval              negative number on error
107  */
108 static int osp_syn_in_flight_seq_show(struct seq_file *m, void *data)
109 {
110         struct obd_device       *dev = m->private;
111         struct osp_device       *osp = lu2osp_dev(dev->obd_lu_dev);
112
113         if (osp == NULL)
114                 return -EINVAL;
115
116         seq_printf(m, "%u\n", osp->opd_syn_rpc_in_flight);
117         return 0;
118 }
119 LPROC_SEQ_FOPS_RO(osp_syn_in_flight);
120
121 /**
122  * Show number of RPCs in processing (including uncommitted by OST)
123  *
124  * \param[in] m         seq_file handle
125  * \param[in] data      unused for single entry
126  * \retval              0 on success
127  * \retval              negative number on error
128  */
129 static int osp_syn_in_prog_seq_show(struct seq_file *m, void *data)
130 {
131         struct obd_device       *dev = m->private;
132         struct osp_device       *osp = lu2osp_dev(dev->obd_lu_dev);
133
134         if (osp == NULL)
135                 return -EINVAL;
136
137         seq_printf(m, "%u\n", osp->opd_syn_rpc_in_progress);
138         return 0;
139 }
140 LPROC_SEQ_FOPS_RO(osp_syn_in_prog);
141
142 /**
143  * Show number of changes to sync
144  *
145  * \param[in] m         seq_file handle
146  * \param[in] data      unused for single entry
147  * \retval              0 on success
148  * \retval              negative number on error
149  */
150 static int osp_syn_changes_seq_show(struct seq_file *m, void *data)
151 {
152         struct obd_device       *dev = m->private;
153         struct osp_device       *osp = lu2osp_dev(dev->obd_lu_dev);
154
155         if (osp == NULL)
156                 return -EINVAL;
157
158         seq_printf(m, "%lu\n", osp->opd_syn_changes);
159         return 0;
160 }
161
162 /**
163  * Sync changes
164  *
165  * \param[in] file      proc file
166  * \param[in] buffer    unused because any input will do
167  * \param[in] count     \a buffer length
168  * \param[in] off       unused for single entry
169  * \retval              \a count on success
170  * \retval              negative number on error
171  */
172 static ssize_t osp_syn_changes_seq_write(struct file *file,
173                                          const char __user *buffer,
174                                          size_t count, loff_t *off)
175 {
176         struct seq_file         *m      = file->private_data;
177         struct obd_device       *dev    = m->private;
178         struct osp_device       *osp    = lu2osp_dev(dev->obd_lu_dev);
179         struct lu_env            env;
180         int                      rc;
181
182         rc = lu_env_init(&env, LCT_LOCAL);
183         if (rc != 0)
184                 return rc;
185
186         rc = dt_sync(&env, &osp->opd_dt_dev);
187         lu_env_fini(&env);
188
189         return rc == 0 ? count : rc;
190 }
191 LPROC_SEQ_FOPS(osp_syn_changes);
192
193 /**
194  * Show maximum number of RPCs in flight allowed
195  *
196  * \param[in] m         seq_file handle
197  * \param[in] data      unused for single entry
198  * \retval              0 on success
199  * \retval              negative number on error
200  */
201 static int osp_max_rpcs_in_flight_seq_show(struct seq_file *m, void *data)
202 {
203         struct obd_device       *dev = m->private;
204         struct osp_device       *osp = lu2osp_dev(dev->obd_lu_dev);
205
206         if (osp == NULL)
207                 return -EINVAL;
208
209         seq_printf(m, "%u\n", osp->opd_syn_max_rpc_in_flight);
210         return 0;
211 }
212
213 /**
214  * Change maximum number of RPCs in flight allowed
215  *
216  * \param[in] file      proc file
217  * \param[in] buffer    string which represents maximum number
218  * \param[in] count     \a buffer length
219  * \param[in] off       unused for single entry
220  * \retval              \a count on success
221  * \retval              negative number on error
222  */
223 static ssize_t
224 osp_max_rpcs_in_flight_seq_write(struct file *file, const char __user *buffer,
225                                 size_t count, loff_t *off)
226 {
227         struct seq_file *m = file->private_data;
228         struct obd_device *dev = m->private;
229         struct osp_device *osp = lu2osp_dev(dev->obd_lu_dev);
230         int rc;
231         __s64 val;
232
233         if (osp == NULL)
234                 return -EINVAL;
235
236         rc = lprocfs_str_to_s64(buffer, count, &val);
237         if (rc)
238                 return rc;
239
240         if (val < 1 || val > INT_MAX)
241                 return -ERANGE;
242
243         osp->opd_syn_max_rpc_in_flight = val;
244         return count;
245 }
246 LPROC_SEQ_FOPS(osp_max_rpcs_in_flight);
247
248 /**
249  * Show maximum number of RPCs in processing allowed
250  *
251  * \param[in] m         seq_file handle
252  * \param[in] data      unused
253  * \retval              0 on success
254  * \retval              negative number on error
255  */
256 static int osp_max_rpcs_in_prog_seq_show(struct seq_file *m, void *data)
257 {
258         struct obd_device       *dev = m->private;
259         struct osp_device       *osp = lu2osp_dev(dev->obd_lu_dev);
260
261         if (osp == NULL)
262                 return -EINVAL;
263
264         seq_printf(m, "%u\n", osp->opd_syn_max_rpc_in_progress);
265         return 0;
266 }
267
268 /**
269  * Change maximum number of RPCs in processing allowed
270  *
271  * \param[in] file      proc file
272  * \param[in] buffer    string which represents maximum number
273  * \param[in] count     \a buffer length
274  * \param[in] off       unused for single entry
275  * \retval              \a count on success
276  * \retval              negative number on error
277  */
278 static ssize_t
279 osp_max_rpcs_in_prog_seq_write(struct file *file, const char __user *buffer,
280                                 size_t count, loff_t *off)
281 {
282         struct seq_file *m = file->private_data;
283         struct obd_device *dev = m->private;
284         struct osp_device *osp = lu2osp_dev(dev->obd_lu_dev);
285         int rc;
286         __s64 val;
287
288         if (osp == NULL)
289                 return -EINVAL;
290
291         rc = lprocfs_str_to_s64(buffer, count, &val);
292         if (rc)
293                 return rc;
294
295         if (val < 1 || val > INT_MAX)
296                 return -ERANGE;
297
298         osp->opd_syn_max_rpc_in_progress = val;
299
300         return count;
301 }
302 LPROC_SEQ_FOPS(osp_max_rpcs_in_prog);
303
304 /**
305  * Show number of objects to precreate next time
306  *
307  * \param[in] m         seq_file handle
308  * \param[in] data      unused for single entry
309  * \retval              0 on success
310  * \retval              negative number on error
311  */
312 static int osp_create_count_seq_show(struct seq_file *m, void *data)
313 {
314         struct obd_device *obd = m->private;
315         struct osp_device *osp = lu2osp_dev(obd->obd_lu_dev);
316
317         if (osp == NULL || osp->opd_pre == NULL)
318                 return 0;
319
320         seq_printf(m, "%d\n", osp->opd_pre_create_count);
321         return 0;
322 }
323
324 /**
325  * Change number of objects to precreate next time
326  *
327  * \param[in] file      proc file
328  * \param[in] buffer    string which represents number of objects to precreate
329  * \param[in] count     \a buffer length
330  * \param[in] off       unused for single entry
331  * \retval              \a count on success
332  * \retval              negative number on error
333  */
334 static ssize_t
335 osp_create_count_seq_write(struct file *file, const char __user *buffer,
336                                 size_t count, loff_t *off)
337 {
338         struct seq_file *m = file->private_data;
339         struct obd_device *obd = m->private;
340         struct osp_device *osp = lu2osp_dev(obd->obd_lu_dev);
341         int rc, i;
342         __s64 val;
343
344         if (osp == NULL || osp->opd_pre == NULL)
345                 return 0;
346
347         rc = lprocfs_str_to_s64(buffer, count, &val);
348         if (rc)
349                 return rc;
350
351         /* The MDT ALWAYS needs to limit the precreate count to
352          * OST_MAX_PRECREATE, and the constant cannot be changed
353          * because it is a value shared between the OSP and OST
354          * that is the maximum possible number of objects that will
355          * ever be handled by MDT->OST recovery processing.
356          *
357          * If the OST ever gets a request to delete more orphans,
358          * this implies that something has gone badly on the MDT
359          * and the OST will refuse to delete so much data from the
360          * filesystem as a safety measure. */
361         if (val < OST_MIN_PRECREATE || val > OST_MAX_PRECREATE)
362                 return -ERANGE;
363         if (val > osp->opd_pre_max_create_count)
364                 return -ERANGE;
365
366         for (i = 1; (i << 1) <= val; i <<= 1)
367                 ;
368         osp->opd_pre_create_count = i;
369
370         return count;
371 }
372 LPROC_SEQ_FOPS(osp_create_count);
373
374 /**
375  * Show maximum number of objects to precreate
376  *
377  * \param[in] m         seq_file handle
378  * \param[in] data      unused for single entry
379  * \retval              0 on success
380  * \retval              negative number on error
381  */
382 static int osp_max_create_count_seq_show(struct seq_file *m, void *data)
383 {
384         struct obd_device *obd = m->private;
385         struct osp_device *osp = lu2osp_dev(obd->obd_lu_dev);
386
387         if (osp == NULL || osp->opd_pre == NULL)
388                 return 0;
389
390         seq_printf(m, "%d\n", osp->opd_pre_max_create_count);
391         return 0;
392 }
393
394 /**
395  * Change maximum number of objects to precreate
396  *
397  * \param[in] file      proc file
398  * \param[in] buffer    string which represents maximum number
399  * \param[in] count     \a buffer length
400  * \param[in] off       unused for single entry
401  * \retval              \a count on success
402  * \retval              negative number on error
403  */
404 static ssize_t
405 osp_max_create_count_seq_write(struct file *file, const char __user *buffer,
406                                 size_t count, loff_t *off)
407 {
408         struct seq_file *m = file->private_data;
409         struct obd_device *obd = m->private;
410         struct osp_device *osp = lu2osp_dev(obd->obd_lu_dev);
411         int rc;
412         __s64 val;
413
414         if (osp == NULL || osp->opd_pre == NULL)
415                 return 0;
416
417         rc = lprocfs_str_to_s64(buffer, count, &val);
418         if (rc)
419                 return rc;
420
421         if (val < 0 || val > INT_MAX)
422                 return -ERANGE;
423         if (val > OST_MAX_PRECREATE)
424                 return -ERANGE;
425
426         if (osp->opd_pre_create_count > val)
427                 osp->opd_pre_create_count = val;
428
429         osp->opd_pre_max_create_count = val;
430
431         return count;
432 }
433 LPROC_SEQ_FOPS(osp_max_create_count);
434
435 /**
436  * Show last id to assign in creation
437  *
438  * \param[in] m         seq_file handle
439  * \param[in] data      unused for single entry
440  * \retval              0 on success
441  * \retval              negative number on error
442  */
443 static int osp_prealloc_next_id_seq_show(struct seq_file *m, void *data)
444 {
445         struct obd_device *obd = m->private;
446         struct osp_device *osp = lu2osp_dev(obd->obd_lu_dev);
447
448         if (osp == NULL || osp->opd_pre == NULL)
449                 return 0;
450
451         seq_printf(m, "%u\n", fid_oid(&osp->opd_pre_used_fid) + 1);
452         return 0;
453 }
454 LPROC_SEQ_FOPS_RO(osp_prealloc_next_id);
455
456 /**
457  * Show last created id OST reported
458  *
459  * \param[in] m         seq_file handle
460  * \param[in] data      unused for single entry
461  * \retval              0 on success
462  * \retval              negative number on error
463  */
464 static int osp_prealloc_last_id_seq_show(struct seq_file *m, void *data)
465 {
466         struct obd_device *obd = m->private;
467         struct osp_device *osp = lu2osp_dev(obd->obd_lu_dev);
468
469         if (osp == NULL || osp->opd_pre == NULL)
470                 return 0;
471
472         seq_printf(m, "%u\n", fid_oid(&osp->opd_pre_last_created_fid));
473         return 0;
474 }
475 LPROC_SEQ_FOPS_RO(osp_prealloc_last_id);
476
477 /**
478  * Show next FID sequence to precreate
479  *
480  * \param[in] m         seq_file handle
481  * \param[in] data      unused for single entry
482  * \retval              0 on success
483  * \retval              negative number on error
484  */
485 static int osp_prealloc_next_seq_seq_show(struct seq_file *m, void *data)
486 {
487         struct obd_device *obd = m->private;
488         struct osp_device *osp = lu2osp_dev(obd->obd_lu_dev);
489
490         if (osp == NULL || osp->opd_pre == NULL)
491                 return 0;
492
493         seq_printf(m, LPX64"\n", fid_seq(&osp->opd_pre_used_fid));
494         return 0;
495 }
496 LPROC_SEQ_FOPS_RO(osp_prealloc_next_seq);
497
498 /**
499  * Show last created FID sequence OST reported
500  *
501  * \param[in] m         seq_file handle
502  * \param[in] data      unused for single entry
503  * \retval              0 on success
504  * \retval              negative number on error
505  */
506 static int osp_prealloc_last_seq_seq_show(struct seq_file *m, void *data)
507 {
508         struct obd_device *obd = m->private;
509         struct osp_device *osp = lu2osp_dev(obd->obd_lu_dev);
510
511         if (osp == NULL || osp->opd_pre == NULL)
512                 return 0;
513
514         seq_printf(m, LPX64"\n",
515                    fid_seq(&osp->opd_pre_last_created_fid));
516         return 0;
517 }
518 LPROC_SEQ_FOPS_RO(osp_prealloc_last_seq);
519
520 /**
521  * Show the number of ids reserved by declare
522  *
523  * \param[in] m         seq_file handle
524  * \param[in] data      unused for single entry
525  * \retval              0 on success
526  * \retval              negative number on error
527  */
528 static int osp_prealloc_reserved_seq_show(struct seq_file *m, void *data)
529 {
530         struct obd_device *obd = m->private;
531         struct osp_device *osp = lu2osp_dev(obd->obd_lu_dev);
532
533         if (osp == NULL || osp->opd_pre == NULL)
534                 return 0;
535
536         seq_printf(m, LPU64"\n", osp->opd_pre_reserved);
537         return 0;
538 }
539 LPROC_SEQ_FOPS_RO(osp_prealloc_reserved);
540
541 /**
542  * Show interval (in seconds) to update statfs data
543  *
544  * \param[in] m         seq_file handle
545  * \param[in] data      unused for single entry
546  * \retval              0 on success
547  * \retval              negative number on error
548  */
549 static int osp_maxage_seq_show(struct seq_file *m, void *data)
550 {
551         struct obd_device       *dev = m->private;
552         struct osp_device       *osp = lu2osp_dev(dev->obd_lu_dev);
553
554         if (osp == NULL)
555                 return -EINVAL;
556
557         seq_printf(m, "%u\n", osp->opd_statfs_maxage);
558         return 0;
559 }
560
561 /**
562  * Change interval to update statfs data
563  *
564  * \param[in] file      proc file
565  * \param[in] buffer    string which represents statfs interval (in seconds)
566  * \param[in] count     \a buffer length
567  * \param[in] off       unused for single entry
568  * \retval              \a count on success
569  * \retval              negative number on error
570  */
571 static ssize_t
572 osp_maxage_seq_write(struct file *file, const char __user *buffer,
573                         size_t count, loff_t *off)
574 {
575         struct seq_file *m = file->private_data;
576         struct obd_device *dev = m->private;
577         struct osp_device *osp = lu2osp_dev(dev->obd_lu_dev);
578         int rc;
579         __s64 val;
580
581         if (osp == NULL)
582                 return -EINVAL;
583
584         rc = lprocfs_str_to_s64(buffer, count, &val);
585         if (rc)
586                 return rc;
587
588         if (val < 1 || val > INT_MAX)
589                 return -ERANGE;
590
591         osp->opd_statfs_maxage = val;
592
593         return count;
594 }
595 LPROC_SEQ_FOPS(osp_maxage);
596
597 /**
598  * Show current precreation status: output 0 means success, otherwise negative
599  * number is printed
600  *
601  * \param[in] m         seq_file handle
602  * \param[in] data      unused for single entry
603  * \retval              0 on success
604  * \retval              negative number on error
605  */
606 static int osp_pre_status_seq_show(struct seq_file *m, void *data)
607 {
608         struct obd_device       *dev = m->private;
609         struct osp_device       *osp = lu2osp_dev(dev->obd_lu_dev);
610
611         if (osp == NULL || osp->opd_pre == NULL)
612                 return -EINVAL;
613
614         seq_printf(m, "%d\n", osp->opd_pre_status);
615         return 0;
616 }
617 LPROC_SEQ_FOPS_RO(osp_pre_status);
618
619 /**
620  * Show the number of RPCs in processing (including uncommitted by OST) plus
621  * changes to sync, i.e. this is the total number of changes OST needs to apply
622  * and commit.
623  *
624  * This counter is used to determine if OST has space returned. A zero value
625  * indicates that OST storage space consumed by destroyed objects has been freed
626  * on disk, the associated llog records have been cleared, and no synchronous
627  * RPC are being processed.
628  *
629  * \param[in] m         seq_file handle
630  * \param[in] data      unused for single entry
631  * \retval              0 on success
632  * \retval              negative number on error
633  */
634 static int osp_destroys_in_flight_seq_show(struct seq_file *m, void *data)
635 {
636         struct obd_device *dev = m->private;
637         struct osp_device *osp = lu2osp_dev(dev->obd_lu_dev);
638
639         if (osp == NULL)
640                 return -EINVAL;
641
642         seq_printf(m, "%lu\n",
643                    osp->opd_syn_rpc_in_progress + osp->opd_syn_changes);
644         return 0;
645 }
646 LPROC_SEQ_FOPS_RO(osp_destroys_in_flight);
647
648 /**
649  * Show changes synced from previous mount
650  *
651  * \param[in] m         seq_file handle
652  * \param[in] data      unused for single entry
653  * \retval              0 on success
654  * \retval              negative number on error
655  */
656 static int osp_old_sync_processed_seq_show(struct seq_file *m, void *data)
657 {
658         struct obd_device       *dev = m->private;
659         struct osp_device       *osp = lu2osp_dev(dev->obd_lu_dev);
660
661         if (osp == NULL)
662                 return -EINVAL;
663
664         seq_printf(m, "%d\n", osp->opd_syn_prev_done);
665         return 0;
666 }
667 LPROC_SEQ_FOPS_RO(osp_old_sync_processed);
668
669 /**
670  * Show maximum number of RPCs in flight
671  *
672  * \param[in] m         seq_file handle
673  * \param[in] data      unused for single entry
674  * \retval              0 on success
675  * \retval              negative number on error
676  */
677 static int
678 osp_lfsck_max_rpcs_in_flight_seq_show(struct seq_file *m, void *data)
679 {
680         struct obd_device *dev = m->private;
681         __u32 max;
682
683         max = obd_get_max_rpcs_in_flight(&dev->u.cli);
684         seq_printf(m, "%u\n", max);
685         return 0;
686 }
687
688 /**
689  * Change maximum number of RPCs in flight
690  *
691  * \param[in] file      proc file
692  * \param[in] buffer    string which represents maximum number of RPCs in flight
693  * \param[in] count     \a buffer length
694  * \param[in] off       unused for single entry
695  * \retval              \a count on success
696  * \retval              negative number on error
697  */
698 static ssize_t
699 osp_lfsck_max_rpcs_in_flight_seq_write(struct file *file,
700                                        const char __user *buffer,
701                                        size_t count, loff_t *off)
702 {
703         struct seq_file   *m = file->private_data;
704         struct obd_device *dev = m->private;
705         __s64 val;
706         int rc;
707
708         rc = lprocfs_str_to_s64(buffer, count, &val);
709         if (rc == 0) {
710                 if (val < 0)
711                         return -ERANGE;
712
713                 rc = obd_set_max_rpcs_in_flight(&dev->u.cli, val);
714         } else {
715                 count = rc;
716         }
717
718         return count;
719 }
720 LPROC_SEQ_FOPS(osp_lfsck_max_rpcs_in_flight);
721
722 LPROC_SEQ_FOPS_WO_TYPE(osp, ping);
723 LPROC_SEQ_FOPS_RO_TYPE(osp, uuid);
724 LPROC_SEQ_FOPS_RO_TYPE(osp, connect_flags);
725 LPROC_SEQ_FOPS_RO_TYPE(osp, server_uuid);
726 LPROC_SEQ_FOPS_RO_TYPE(osp, conn_uuid);
727
728 /**
729  * Show maximum pages per bulk RPC
730  *
731  * \param[in] m         seq_file handle
732  * \param[in] data      unused for single entry
733  * \retval              0 on success
734  * \retval              negative number on error
735  */
736 static int osp_max_pages_per_rpc_seq_show(struct seq_file *m, void *v)
737 {
738         return lprocfs_obd_max_pages_per_rpc_seq_show(m, m->private);
739 }
740 LPROC_SEQ_FOPS_RO(osp_max_pages_per_rpc);
741 LPROC_SEQ_FOPS_RO_TYPE(osp, timeouts);
742
743 LPROC_SEQ_FOPS_RW_TYPE(osp, import);
744 LPROC_SEQ_FOPS_RO_TYPE(osp, state);
745
746 static struct lprocfs_vars lprocfs_osp_obd_vars[] = {
747         { .name =       "uuid",
748           .fops =       &osp_uuid_fops                  },
749         { .name =       "ping",
750           .fops =       &osp_ping_fops,
751           .proc_mode =  0222                            },
752         { .name =       "connect_flags",
753           .fops =       &osp_connect_flags_fops         },
754         { .name =       "ost_server_uuid",
755           .fops =       &osp_server_uuid_fops           },
756         { .name =       "ost_conn_uuid",
757           .fops =       &osp_conn_uuid_fops             },
758         { .name =       "active",
759           .fops =       &osp_active_fops                },
760         { .name =       "max_rpcs_in_flight",
761           .fops =       &osp_max_rpcs_in_flight_fops    },
762         { .name =       "max_rpcs_in_progress",
763           .fops =       &osp_max_rpcs_in_prog_fops      },
764         { .name =       "create_count",
765           .fops =       &osp_create_count_fops          },
766         { .name =       "max_create_count",
767           .fops =       &osp_max_create_count_fops      },
768         { .name =       "prealloc_next_id",
769           .fops =       &osp_prealloc_next_id_fops      },
770         { .name =       "prealloc_next_seq",
771           .fops =       &osp_prealloc_next_seq_fops     },
772         { .name =       "prealloc_last_id",
773           .fops =       &osp_prealloc_last_id_fops      },
774         { .name =       "prealloc_last_seq",
775           .fops =       &osp_prealloc_last_seq_fops     },
776         { .name =       "prealloc_reserved",
777           .fops =       &osp_prealloc_reserved_fops     },
778         { .name =       "timeouts",
779           .fops =       &osp_timeouts_fops              },
780         { .name =       "import",
781           .fops =       &osp_import_fops                },
782         { .name =       "state",
783           .fops =       &osp_state_fops                 },
784         { .name =       "maxage",
785           .fops =       &osp_maxage_fops                },
786         { .name =       "prealloc_status",
787           .fops =       &osp_pre_status_fops            },
788         { .name =       "sync_changes",
789           .fops =       &osp_syn_changes_fops           },
790         { .name =       "sync_in_flight",
791           .fops =       &osp_syn_in_flight_fops         },
792         { .name =       "sync_in_progress",
793           .fops =       &osp_syn_in_prog_fops           },
794         { .name =       "old_sync_processed",
795           .fops =       &osp_old_sync_processed_fops    },
796
797         /* for compatibility reasons */
798         { .name =       "destroys_in_flight",
799           .fops =       &osp_destroys_in_flight_fops            },
800         { .name =       "lfsck_max_rpcs_in_flight",
801           .fops =       &osp_lfsck_max_rpcs_in_flight_fops      },
802         { NULL }
803 };
804
805 static struct lprocfs_vars lprocfs_osp_md_vars[] = {
806         { .name =       "uuid",
807           .fops =       &osp_uuid_fops                  },
808         { .name =       "ping",
809           .fops =       &osp_ping_fops,
810           .proc_mode =  0222                            },
811         { .name =       "connect_flags",
812           .fops =       &osp_connect_flags_fops         },
813         { .name =       "mdt_server_uuid",
814           .fops =       &osp_server_uuid_fops           },
815         { .name =       "mdt_conn_uuid",
816           .fops =       &osp_conn_uuid_fops             },
817         { .name =       "active",
818           .fops =       &osp_active_fops                },
819         { .name =       "max_rpcs_in_flight",
820           .fops =       &osp_max_rpcs_in_flight_fops    },
821         { .name =       "max_rpcs_in_progress",
822           .fops =       &osp_max_rpcs_in_prog_fops      },
823         { .name =       "timeouts",
824           .fops =       &osp_timeouts_fops              },
825         { .name =       "import",
826           .fops =       &osp_import_fops                },
827         { .name =       "state",
828           .fops =       &osp_state_fops                 },
829         { .name =       "maxage",
830           .fops =       &osp_maxage_fops                },
831         { .name =       "prealloc_status",
832           .fops =       &osp_pre_status_fops            },
833
834         /* for compatibility reasons */
835         { .name =       "destroys_in_flight",
836           .fops =       &osp_destroys_in_flight_fops            },
837         { .name =       "lfsck_max_rpcs_in_flight",
838           .fops =       &osp_lfsck_max_rpcs_in_flight_fops      },
839         { NULL }
840 };
841
842 LPROC_SEQ_FOPS_RO_TYPE(osp, dt_blksize);
843 LPROC_SEQ_FOPS_RO_TYPE(osp, dt_kbytestotal);
844 LPROC_SEQ_FOPS_RO_TYPE(osp, dt_kbytesfree);
845 LPROC_SEQ_FOPS_RO_TYPE(osp, dt_kbytesavail);
846 LPROC_SEQ_FOPS_RO_TYPE(osp, dt_filestotal);
847 LPROC_SEQ_FOPS_RO_TYPE(osp, dt_filesfree);
848
849 static struct lprocfs_vars lprocfs_osp_osd_vars[] = {
850         { .name =       "blocksize",
851           .fops =       &osp_dt_blksize_fops            },
852         { .name =       "kbytestotal",
853           .fops =       &osp_dt_kbytestotal_fops        },
854         { .name =       "kbytesfree",
855           .fops =       &osp_dt_kbytesfree_fops         },
856         { .name =       "kbytesavail",
857           .fops =       &osp_dt_kbytesavail_fops        },
858         { .name =       "filestotal",
859           .fops =       &osp_dt_filestotal_fops         },
860         { .name =       "filesfree",
861           .fops =       &osp_dt_filesfree_fops          },
862         { NULL }
863 };
864
865 /**
866  * Initialize OSP lprocfs
867  *
868  * param[in] osp        OSP device
869  */
870 void osp_lprocfs_init(struct osp_device *osp)
871 {
872         struct obd_device       *obd = osp->opd_obd;
873         struct proc_dir_entry   *osc_proc_dir = NULL;
874         struct obd_type         *type;
875         int                      rc;
876
877         if (osp->opd_connect_mdt)
878                 obd->obd_vars = lprocfs_osp_md_vars;
879         else
880                 obd->obd_vars = lprocfs_osp_obd_vars;
881         if (lprocfs_obd_setup(obd) != 0)
882                 return;
883
884         rc = lprocfs_add_vars(obd->obd_proc_entry, lprocfs_osp_osd_vars,
885                               &osp->opd_dt_dev);
886         if (rc) {
887                 CERROR("%s: can't register in lprocfs, rc %d\n",
888                        obd->obd_name, rc);
889                 return;
890         }
891
892         sptlrpc_lprocfs_cliobd_attach(obd);
893         ptlrpc_lprocfs_register_obd(obd);
894
895         if (osp->opd_connect_mdt || !strstr(obd->obd_name, "osc"))
896                 return;
897
898         /* If the real OSC is present which is the case for setups
899          * with both server and clients on the same node then use
900          * the OSC's proc root */
901         type = class_search_type(LUSTRE_OSC_NAME);
902         if (type != NULL && type->typ_procroot != NULL)
903                 osc_proc_dir = type->typ_procroot;
904         else
905                 osc_proc_dir = obd->obd_type->typ_procsym;
906
907         if (osc_proc_dir == NULL)
908                 return;
909
910         /* for compatibility we link old procfs's OSC entries to osp ones */
911         osp->opd_symlink = lprocfs_add_symlink(obd->obd_name, osc_proc_dir,
912                                                "../osp/%s", obd->obd_name);
913         if (osp->opd_symlink == NULL)
914                 CERROR("cannot create OSC symlink for /proc/fs/lustre/osp/%s\n",
915                        obd->obd_name);
916 }
917
918 #endif /* CONFIG_PROC_FS */
919