4 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
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.
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).
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
23 * Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved.
24 * Use is subject to license terms.
26 * Copyright (c) 2012, 2014 Intel Corporation.
29 * This file is part of Lustre, http://www.lustre.org/
30 * Lustre is a trademark of Sun Microsystems, Inc.
32 * lustre/ofd/lproc_ofd.c
34 * This file provides functions of procfs interface for OBD Filter Device (OFD).
36 * Author: Andreas Dilger <andreas.dilger@intel.com>
37 * Author: Mikhail Pershin <mike.pershin@intel.com>
38 * Author: Johann Lombardi <johann.lombardi@intel.com>
39 * Author: Fan Yong <fan.yong@intel.com>
42 #define DEBUG_SUBSYSTEM S_CLASS
45 #include <lprocfs_status.h>
46 #include <linux/seq_file.h>
47 #include <lustre_lfsck.h>
49 #include "ofd_internal.h"
54 * Show number of FID allocation sequences.
56 * \param[in] m seq_file handle
57 * \param[in] data unused for single entry
59 * \retval 0 on success
60 * \retval negative value on error
62 static int ofd_seqs_seq_show(struct seq_file *m, void *data)
64 struct obd_device *obd = m->private;
65 struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
67 seq_printf(m, "%u\n", ofd->ofd_seq_count);
70 LPROC_SEQ_FOPS_RO(ofd_seqs);
73 * Show estimate of total amount of dirty data on clients.
75 * \param[in] m seq_file handle
76 * \param[in] data unused for single entry
78 * \retval 0 on success
79 * \retval negative value on error
81 static int ofd_tot_dirty_seq_show(struct seq_file *m, void *data)
83 struct obd_device *obd = m->private;
84 struct ofd_device *ofd;
87 ofd = ofd_dev(obd->obd_lu_dev);
88 seq_printf(m, LPU64"\n", ofd->ofd_tot_dirty);
91 LPROC_SEQ_FOPS_RO(ofd_tot_dirty);
94 * Show total amount of space granted to clients.
96 * \param[in] m seq_file handle
97 * \param[in] data unused for single entry
99 * \retval 0 on success
100 * \retval negative value on error
102 static int ofd_tot_granted_seq_show(struct seq_file *m, void *data)
104 struct obd_device *obd = m->private;
105 struct ofd_device *ofd;
107 LASSERT(obd != NULL);
108 ofd = ofd_dev(obd->obd_lu_dev);
109 seq_printf(m, LPU64"\n", ofd->ofd_tot_granted);
112 LPROC_SEQ_FOPS_RO(ofd_tot_granted);
115 * Show total amount of space used by IO in progress.
117 * \param[in] m seq_file handle
118 * \param[in] data unused for single entry
120 * \retval 0 on success
121 * \retval negative value on error
123 static int ofd_tot_pending_seq_show(struct seq_file *m, void *data)
125 struct obd_device *obd = m->private;
126 struct ofd_device *ofd;
128 LASSERT(obd != NULL);
129 ofd = ofd_dev(obd->obd_lu_dev);
130 seq_printf(m, LPU64"\n", ofd->ofd_tot_pending);
133 LPROC_SEQ_FOPS_RO(ofd_tot_pending);
136 * Show total number of grants for precreate.
138 * \param[in] m seq_file handle
139 * \param[in] data unused for single entry
141 * \retval 0 on success
142 * \retval negative value on error
144 static int ofd_grant_precreate_seq_show(struct seq_file *m, void *data)
146 struct obd_device *obd = m->private;
148 LASSERT(obd != NULL);
149 seq_printf(m, "%ld\n",
150 obd->obd_self_export->exp_filter_data.fed_grant);
153 LPROC_SEQ_FOPS_RO(ofd_grant_precreate);
156 * Show number of precreates allowed in a single transaction.
158 * \param[in] m seq_file handle
159 * \param[in] data unused for single entry
161 * \retval 0 on success
162 * \retval negative value on error
164 static int ofd_precreate_batch_seq_show(struct seq_file *m, void *data)
166 struct obd_device *obd = m->private;
167 struct ofd_device *ofd;
169 LASSERT(obd != NULL);
170 ofd = ofd_dev(obd->obd_lu_dev);
171 seq_printf(m, "%d\n", ofd->ofd_precreate_batch);
176 * Change number of precreates allowed in a single transaction.
178 * \param[in] file proc file
179 * \param[in] buffer string which represents maximum number
180 * \param[in] count \a buffer length
181 * \param[in] off unused for single entry
183 * \retval \a count on success
184 * \retval negative number on error
187 ofd_precreate_batch_seq_write(struct file *file, const char __user *buffer,
188 size_t count, loff_t *off)
190 struct seq_file *m = file->private_data;
191 struct obd_device *obd = m->private;
192 struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
196 rc = lprocfs_write_helper(buffer, count, &val);
203 spin_lock(&ofd->ofd_batch_lock);
204 ofd->ofd_precreate_batch = val;
205 spin_unlock(&ofd->ofd_batch_lock);
208 LPROC_SEQ_FOPS(ofd_precreate_batch);
211 * Show the last used ID for each FID sequence used by OFD.
213 * \param[in] m seq_file handle
214 * \param[in] data unused for single entry
216 * \retval 0 on success
217 * \retval negative value on error
219 static int ofd_last_id_seq_show(struct seq_file *m, void *data)
221 struct obd_device *obd = m->private;
222 struct ofd_device *ofd;
223 struct ofd_seq *oseq = NULL;
228 ofd = ofd_dev(obd->obd_lu_dev);
230 read_lock(&ofd->ofd_seq_list_lock);
231 list_for_each_entry(oseq, &ofd->ofd_seq_list, os_list) {
234 seq = ostid_seq(&oseq->os_oi) == 0 ?
235 fid_idif_seq(ostid_id(&oseq->os_oi),
236 ofd->ofd_lut.lut_lsd.lsd_osd_index) :
237 ostid_seq(&oseq->os_oi);
238 seq_printf(m, DOSTID"\n", seq, ostid_id(&oseq->os_oi));
240 read_unlock(&ofd->ofd_seq_list_lock);
243 LPROC_SEQ_FOPS_RO(ofd_last_id);
246 * Show maximum number of Filter Modification Data (FMD) maintained by OFD.
248 * \param[in] m seq_file handle
249 * \param[in] data unused for single entry
251 * \retval 0 on success
252 * \retval negative value on error
254 static int ofd_fmd_max_num_seq_show(struct seq_file *m, void *data)
256 struct obd_device *obd = m->private;
257 struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
259 seq_printf(m, "%u\n", ofd->ofd_fmd_max_num);
264 * Change number of FMDs maintained by OFD.
266 * This defines how large the list of FMDs can be.
268 * \param[in] file proc file
269 * \param[in] buffer string which represents maximum number
270 * \param[in] count \a buffer length
271 * \param[in] off unused for single entry
273 * \retval \a count on success
274 * \retval negative number on error
277 ofd_fmd_max_num_seq_write(struct file *file, const char __user *buffer,
278 size_t count, loff_t *off)
280 struct seq_file *m = file->private_data;
281 struct obd_device *obd = m->private;
282 struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
286 rc = lprocfs_write_helper(buffer, count, &val);
290 if (val > 65536 || val < 1)
293 ofd->ofd_fmd_max_num = val;
296 LPROC_SEQ_FOPS(ofd_fmd_max_num);
299 * Show the maximum age of FMD data in seconds.
301 * Though it is shown in seconds, it is stored internally in units
302 * of jiffies for efficiency.
304 * \param[in] m seq_file handle
305 * \param[in] data unused for single entry
307 * \retval 0 on success
308 * \retval negative value on error
310 static int ofd_fmd_max_age_seq_show(struct seq_file *m, void *data)
312 struct obd_device *obd = m->private;
313 struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
315 seq_printf(m, "%ld\n", jiffies_to_msecs(ofd->ofd_fmd_max_age) /
321 * Set the maximum age of FMD data in seconds.
323 * This defines how long FMD data stays in the FMD list.
324 * It is stored internally in units of jiffies for efficiency.
326 * \param[in] file proc file
327 * \param[in] buffer string which represents maximum number
328 * \param[in] count \a buffer length
329 * \param[in] off unused for single entry
331 * \retval \a count on success
332 * \retval negative number on error
335 ofd_fmd_max_age_seq_write(struct file *file, const char __user *buffer,
336 size_t count, loff_t *off)
338 struct seq_file *m = file->private_data;
339 struct obd_device *obd = m->private;
340 struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
344 rc = lprocfs_write_helper(buffer, count, &val);
348 if (val > 65536 || val < 1)
351 ofd->ofd_fmd_max_age = msecs_to_jiffies(val * MSEC_PER_SEC);
354 LPROC_SEQ_FOPS(ofd_fmd_max_age);
357 * Show if the OFD is in degraded mode.
359 * Degraded means OFD has a failed drive or is undergoing RAID rebuild.
360 * The MDS will try to avoid using this OST for new object allocations
361 * to reduce the impact to global IO performance when clients writing to
362 * this OST are slowed down. It also reduces the contention on the OST
363 * RAID device, allowing it to rebuild more quickly.
365 * \param[in] m seq_file handle
366 * \param[in] data unused for single entry
368 * \retval 0 on success
369 * \retval negative value on error
371 static int ofd_degraded_seq_show(struct seq_file *m, void *data)
373 struct obd_device *obd = m->private;
374 struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
376 seq_printf(m, "%u\n", ofd->ofd_raid_degraded);
381 * Set OFD to degraded mode.
383 * This is used to interface to userspace administrative tools for
384 * the underlying RAID storage, so that they can mark an OST
385 * as having degraded performance.
387 * \param[in] file proc file
388 * \param[in] buffer string which represents mode
389 * 1: set degraded mode
390 * 0: unset degraded mode
391 * \param[in] count \a buffer length
392 * \param[in] off unused for single entry
394 * \retval \a count on success
395 * \retval negative number on error
398 ofd_degraded_seq_write(struct file *file, const char __user *buffer,
399 size_t count, loff_t *off)
401 struct seq_file *m = file->private_data;
402 struct obd_device *obd = m->private;
403 struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
406 rc = lprocfs_write_helper(buffer, count, &val);
410 spin_lock(&ofd->ofd_flags_lock);
411 ofd->ofd_raid_degraded = !!val;
412 spin_unlock(&ofd->ofd_flags_lock);
415 LPROC_SEQ_FOPS(ofd_degraded);
418 * Show OFD filesystem type.
420 * \param[in] m seq_file handle
421 * \param[in] data unused for single entry
423 * \retval 0 on success
424 * \retval negative value on error
426 static int ofd_fstype_seq_show(struct seq_file *m, void *data)
428 struct obd_device *obd = m->private;
429 struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
432 LASSERT(ofd->ofd_osd);
433 d = &ofd->ofd_osd->dd_lu_dev;
435 seq_printf(m, "%s\n", d->ld_type->ldt_name);
438 LPROC_SEQ_FOPS_RO(ofd_fstype);
441 * Show journal handling mode: synchronous or asynchronous.
443 * When running in asynchronous mode the journal transactions are not
444 * committed to disk before the RPC is replied back to the client.
445 * This will typically improve client performance when only a small number
446 * of clients are writing, since the client(s) can have more write RPCs
447 * in flight. However, it also means that the client has to handle recovery
448 * on bulk RPCs, and will have to keep more dirty pages in cache before they
449 * are committed on the OST.
451 * \param[in] m seq_file handle
452 * \param[in] data unused for single entry
454 * \retval 0 on success
455 * \retval negative value on error
457 static int ofd_syncjournal_seq_show(struct seq_file *m, void *data)
459 struct obd_device *obd = m->private;
460 struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
462 seq_printf(m, "%u\n", ofd->ofd_syncjournal);
467 * Set journal mode to synchronous or asynchronous.
469 * \param[in] file proc file
470 * \param[in] buffer string which represents mode
471 * 1: synchronous mode
472 * 0: asynchronous mode
473 * \param[in] count \a buffer length
474 * \param[in] off unused for single entry
476 * \retval \a count on success
477 * \retval negative number on error
480 ofd_syncjournal_seq_write(struct file *file, const char __user *buffer,
481 size_t count, loff_t *off)
483 struct seq_file *m = file->private_data;
484 struct obd_device *obd = m->private;
485 struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
489 rc = lprocfs_write_helper(buffer, count, &val);
496 spin_lock(&ofd->ofd_flags_lock);
497 ofd->ofd_syncjournal = !!val;
499 spin_unlock(&ofd->ofd_flags_lock);
503 LPROC_SEQ_FOPS(ofd_syncjournal);
505 /* This must be longer than the longest string below */
506 #define SYNC_STATES_MAXLEN 16
507 static char *sync_on_cancel_states[] = {"never",
512 * Show OFD policy for handling dirty data under a lock being cancelled.
514 * \param[in] m seq_file handle
515 * \param[in] data unused for single entry
517 * \retval 0 on success
518 * \retval negative value on error
520 static int ofd_sync_lock_cancel_seq_show(struct seq_file *m, void *data)
522 struct obd_device *obd = m->private;
523 struct lu_target *tgt = obd->u.obt.obt_lut;
525 seq_printf(m, "%s\n",
526 sync_on_cancel_states[tgt->lut_sync_lock_cancel]);
531 * Change OFD policy for handling dirty data under a lock being cancelled.
533 * This variable defines what action OFD takes upon lock cancel
534 * There are three possible modes:
535 * 1) never - never do sync upon lock cancel. This can lead to data
536 * inconsistencies if both the OST and client crash while writing a file
537 * that is also concurrently being read by another client. In these cases,
538 * this may allow the file data to "rewind" to an earlier state.
539 * 2) blocking - do sync only if there is blocking lock, e.g. if another
540 * client is trying to access this same object
541 * 3) always - do sync always
543 * \param[in] file proc file
544 * \param[in] buffer string which represents policy
545 * \param[in] count \a buffer length
546 * \param[in] off unused for single entry
548 * \retval \a count on success
549 * \retval negative number on error
552 ofd_sync_lock_cancel_seq_write(struct file *file, const char __user *buffer,
553 size_t count, loff_t *off)
555 struct seq_file *m = file->private_data;
556 struct obd_device *obd = m->private;
557 struct lu_target *tgt = obd->u.obt.obt_lut;
558 char kernbuf[SYNC_STATES_MAXLEN];
562 if (count == 0 || count >= sizeof(kernbuf))
565 if (copy_from_user(kernbuf, buffer, count))
569 if (kernbuf[count - 1] == '\n')
570 kernbuf[count - 1] = 0;
572 for (i = 0 ; i < NUM_SYNC_ON_CANCEL_STATES; i++) {
573 if (strcmp(kernbuf, sync_on_cancel_states[i]) == 0) {
579 /* Legacy numeric codes */
583 /* Safe to use userspace buffer as lprocfs_write_helper will
584 * use copy from user for parsing */
585 rc = lprocfs_write_helper(buffer, count, &val);
590 if (val < 0 || val > 2)
593 spin_lock(&tgt->lut_flags_lock);
594 tgt->lut_sync_lock_cancel = val;
595 spin_unlock(&tgt->lut_flags_lock);
598 LPROC_SEQ_FOPS(ofd_sync_lock_cancel);
601 * Show if grants compatibility mode is disabled.
603 * When ofd_grant_compat_disable is set, we don't grant any space to clients
604 * not supporting OBD_CONNECT_GRANT_PARAM. Otherwise, space granted to such
605 * a client is inflated since it consumes PAGE_CACHE_SIZE of grant space per
606 * block, (i.e. typically 4kB units), but underlaying file system might have
607 * block size bigger than page size, e.g. ZFS. See LU-2049 for details.
609 * \param[in] m seq_file handle
610 * \param[in] data unused for single entry
612 * \retval 0 on success
613 * \retval negative value on error
615 static int ofd_grant_compat_disable_seq_show(struct seq_file *m, void *data)
617 struct obd_device *obd = m->private;
618 struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
620 seq_printf(m, "%u\n", ofd->ofd_grant_compat_disable);
625 * Change grant compatibility mode.
627 * Setting ofd_grant_compat_disable prohibit any space granting to clients
628 * not supporting OBD_CONNECT_GRANT_PARAM. See details above.
630 * \param[in] file proc file
631 * \param[in] buffer string which represents mode
632 * 1: disable compatibility mode
633 * 0: enable compatibility mode
634 * \param[in] count \a buffer length
635 * \param[in] off unused for single entry
637 * \retval \a count on success
638 * \retval negative number on error
641 ofd_grant_compat_disable_seq_write(struct file *file,
642 const char __user *buffer,
643 size_t count, loff_t *off)
645 struct seq_file *m = file->private_data;
646 struct obd_device *obd = m->private;
647 struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
651 rc = lprocfs_write_helper(buffer, count, &val);
658 spin_lock(&ofd->ofd_flags_lock);
659 ofd->ofd_grant_compat_disable = !!val;
660 spin_unlock(&ofd->ofd_flags_lock);
664 LPROC_SEQ_FOPS(ofd_grant_compat_disable);
667 * Show the limit of soft sync RPCs.
669 * This value defines how many IO RPCs with OBD_BRW_SOFT_SYNC flag
670 * are allowed before sync update will be triggered.
672 * \param[in] m seq_file handle
673 * \param[in] data unused for single entry
675 * \retval 0 on success
676 * \retval negative value on error
678 static int ofd_soft_sync_limit_seq_show(struct seq_file *m, void *data)
680 struct obd_device *obd = m->private;
681 struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
683 return lprocfs_uint_seq_show(m, &ofd->ofd_soft_sync_limit);
687 * Change the limit of soft sync RPCs.
689 * Define how many IO RPCs with OBD_BRW_SOFT_SYNC flag
690 * allowed before sync update will be done.
692 * This limit is global across all exports.
694 * \param[in] file proc file
695 * \param[in] buffer string which represents limit
696 * \param[in] count \a buffer length
697 * \param[in] off unused for single entry
699 * \retval \a count on success
700 * \retval negative number on error
703 ofd_soft_sync_limit_seq_write(struct file *file, const char __user *buffer,
704 size_t count, loff_t *off)
706 struct seq_file *m = file->private_data;
707 struct obd_device *obd = m->private;
708 struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
710 return lprocfs_uint_seq_write(file, buffer, count,
711 (loff_t *) &ofd->ofd_soft_sync_limit);
713 LPROC_SEQ_FOPS(ofd_soft_sync_limit);
716 * Show the LFSCK speed limit.
718 * The maximum number of items scanned per second.
720 * \param[in] m seq_file handle
721 * \param[in] data unused for single entry
723 * \retval 0 on success
724 * \retval negative value on error
726 static int ofd_lfsck_speed_limit_seq_show(struct seq_file *m, void *data)
728 struct obd_device *obd = m->private;
729 struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
731 return lfsck_get_speed(m, ofd->ofd_osd);
735 * Change the LFSCK speed limit.
737 * Limit number of items that may be scanned per second.
739 * \param[in] file proc file
740 * \param[in] buffer string which represents limit
741 * \param[in] count \a buffer length
742 * \param[in] off unused for single entry
744 * \retval \a count on success
745 * \retval negative number on error
748 ofd_lfsck_speed_limit_seq_write(struct file *file, const char __user *buffer,
749 size_t count, loff_t *off)
751 struct seq_file *m = file->private_data;
752 struct obd_device *obd = m->private;
753 struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
757 rc = lprocfs_write_helper(buffer, count, &val);
761 rc = lfsck_set_speed(ofd->ofd_osd, val);
763 return rc != 0 ? rc : count;
765 LPROC_SEQ_FOPS(ofd_lfsck_speed_limit);
768 * Show LFSCK layout verification stats from the most recent LFSCK run.
770 * \param[in] m seq_file handle
771 * \param[in] data unused for single entry
773 * \retval 0 on success
774 * \retval negative value on error
776 static int ofd_lfsck_layout_seq_show(struct seq_file *m, void *data)
778 struct obd_device *obd = m->private;
779 struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
781 return lfsck_dump(m, ofd->ofd_osd, LFSCK_TYPE_LAYOUT);
783 LPROC_SEQ_FOPS_RO(ofd_lfsck_layout);
786 * Show if LFSCK performed parent FID verification.
788 * \param[in] m seq_file handle
789 * \param[in] data unused for single entry
791 * \retval 0 on success
792 * \retval negative value on error
794 static int ofd_lfsck_verify_pfid_seq_show(struct seq_file *m, void *data)
796 struct obd_device *obd = m->private;
797 struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
799 seq_printf(m, "switch: %s\ndetected: "LPU64"\nrepaired: "LPU64"\n",
800 ofd->ofd_lfsck_verify_pfid ? "on" : "off",
801 ofd->ofd_inconsistency_self_detected,
802 ofd->ofd_inconsistency_self_repaired);
807 * Set the LFSCK behavior to verify parent FID correctness.
809 * If flag ofd_lfsck_verify_pfid is set then LFSCK does parent FID
810 * verification during read/write operations.
812 * \param[in] file proc file
813 * \param[in] buffer string which represents behavior
814 * 1: verify parent FID
815 * 0: don't verify parent FID
816 * \param[in] count \a buffer length
817 * \param[in] off unused for single entry
819 * \retval \a count on success
820 * \retval negative number on error
823 ofd_lfsck_verify_pfid_seq_write(struct file *file, const char __user *buffer,
824 size_t count, loff_t *off)
826 struct seq_file *m = file->private_data;
827 struct obd_device *obd = m->private;
828 struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
832 rc = lprocfs_write_helper(buffer, count, &val);
836 ofd->ofd_lfsck_verify_pfid = !!val;
840 LPROC_SEQ_FOPS(ofd_lfsck_verify_pfid);
842 static int ofd_site_stats_seq_show(struct seq_file *m, void *data)
844 struct obd_device *obd = m->private;
846 return lu_site_stats_seq_print(obd->obd_lu_dev->ld_site, m);
848 LPROC_SEQ_FOPS_RO(ofd_site_stats);
850 LPROC_SEQ_FOPS_RO_TYPE(ofd, uuid);
851 LPROC_SEQ_FOPS_RO_TYPE(ofd, blksize);
852 LPROC_SEQ_FOPS_RO_TYPE(ofd, kbytestotal);
853 LPROC_SEQ_FOPS_RO_TYPE(ofd, kbytesfree);
854 LPROC_SEQ_FOPS_RO_TYPE(ofd, kbytesavail);
855 LPROC_SEQ_FOPS_RO_TYPE(ofd, filestotal);
856 LPROC_SEQ_FOPS_RO_TYPE(ofd, filesfree);
858 LPROC_SEQ_FOPS_RO_TYPE(ofd, recovery_status);
859 LPROC_SEQ_FOPS_RW_TYPE(ofd, recovery_time_soft);
860 LPROC_SEQ_FOPS_RW_TYPE(ofd, recovery_time_hard);
861 LPROC_SEQ_FOPS_WO_TYPE(ofd, evict_client);
862 LPROC_SEQ_FOPS_RO_TYPE(ofd, num_exports);
863 LPROC_SEQ_FOPS_RO_TYPE(ofd, target_instance);
864 LPROC_SEQ_FOPS_RW_TYPE(ofd, ir_factor);
865 LPROC_SEQ_FOPS_RW_TYPE(ofd, job_interval);
867 struct lprocfs_vars lprocfs_ofd_obd_vars[] = {
869 .fops = &ofd_uuid_fops },
870 { .name = "blocksize",
871 .fops = &ofd_blksize_fops },
872 { .name = "kbytestotal",
873 .fops = &ofd_kbytestotal_fops },
874 { .name = "kbytesfree",
875 .fops = &ofd_kbytesfree_fops },
876 { .name = "kbytesavail",
877 .fops = &ofd_kbytesavail_fops },
878 { .name = "filestotal",
879 .fops = &ofd_filestotal_fops },
880 { .name = "filesfree",
881 .fops = &ofd_filesfree_fops },
882 { .name = "seqs_allocated",
883 .fops = &ofd_seqs_fops },
885 .fops = &ofd_fstype_fops },
887 .fops = &ofd_last_id_fops },
888 { .name = "tot_dirty",
889 .fops = &ofd_tot_dirty_fops },
890 { .name = "tot_pending",
891 .fops = &ofd_tot_pending_fops },
892 { .name = "tot_granted",
893 .fops = &ofd_tot_granted_fops },
894 { .name = "grant_precreate",
895 .fops = &ofd_grant_precreate_fops },
896 { .name = "precreate_batch",
897 .fops = &ofd_precreate_batch_fops },
898 { .name = "recovery_status",
899 .fops = &ofd_recovery_status_fops },
900 { .name = "recovery_time_soft",
901 .fops = &ofd_recovery_time_soft_fops },
902 { .name = "recovery_time_hard",
903 .fops = &ofd_recovery_time_hard_fops },
904 { .name = "evict_client",
905 .fops = &ofd_evict_client_fops },
906 { .name = "num_exports",
907 .fops = &ofd_num_exports_fops },
908 { .name = "degraded",
909 .fops = &ofd_degraded_fops },
910 { .name = "sync_journal",
911 .fops = &ofd_syncjournal_fops },
912 { .name = "sync_on_lock_cancel",
913 .fops = &ofd_sync_lock_cancel_fops },
914 { .name = "instance",
915 .fops = &ofd_target_instance_fops },
916 { .name = "ir_factor",
917 .fops = &ofd_ir_factor_fops },
918 { .name = "grant_compat_disable",
919 .fops = &ofd_grant_compat_disable_fops },
920 { .name = "client_cache_count",
921 .fops = &ofd_fmd_max_num_fops },
922 { .name = "client_cache_seconds",
923 .fops = &ofd_fmd_max_age_fops },
924 { .name = "job_cleanup_interval",
925 .fops = &ofd_job_interval_fops },
926 { .name = "soft_sync_limit",
927 .fops = &ofd_soft_sync_limit_fops },
928 { .name = "lfsck_speed_limit",
929 .fops = &ofd_lfsck_speed_limit_fops },
930 { .name = "lfsck_layout",
931 .fops = &ofd_lfsck_layout_fops },
932 { .name = "lfsck_verify_pfid",
933 .fops = &ofd_lfsck_verify_pfid_fops },
934 { .name = "site_stats",
935 .fops = &ofd_site_stats_fops },
940 * Initialize OFD statistics counters
942 * param[in] stats statistics counters
944 void ofd_stats_counter_init(struct lprocfs_stats *stats)
946 LASSERT(stats && stats->ls_num >= LPROC_OFD_STATS_LAST);
948 lprocfs_counter_init(stats, LPROC_OFD_STATS_READ,
949 LPROCFS_CNTR_AVGMINMAX, "read_bytes", "bytes");
950 lprocfs_counter_init(stats, LPROC_OFD_STATS_WRITE,
951 LPROCFS_CNTR_AVGMINMAX, "write_bytes", "bytes");
952 lprocfs_counter_init(stats, LPROC_OFD_STATS_GETATTR,
953 0, "getattr", "reqs");
954 lprocfs_counter_init(stats, LPROC_OFD_STATS_SETATTR,
955 0, "setattr", "reqs");
956 lprocfs_counter_init(stats, LPROC_OFD_STATS_PUNCH,
958 lprocfs_counter_init(stats, LPROC_OFD_STATS_SYNC,
960 lprocfs_counter_init(stats, LPROC_OFD_STATS_DESTROY,
961 0, "destroy", "reqs");
962 lprocfs_counter_init(stats, LPROC_OFD_STATS_CREATE,
963 0, "create", "reqs");
964 lprocfs_counter_init(stats, LPROC_OFD_STATS_STATFS,
965 0, "statfs", "reqs");
966 lprocfs_counter_init(stats, LPROC_OFD_STATS_GET_INFO,
967 0, "get_info", "reqs");
968 lprocfs_counter_init(stats, LPROC_OFD_STATS_SET_INFO,
969 0, "set_info", "reqs");
970 lprocfs_counter_init(stats, LPROC_OFD_STATS_QUOTACTL,
971 0, "quotactl", "reqs");
974 #endif /* CONFIG_PROC_FS */