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, 2016, 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 tg_grants_data *tgd;
87 tgd = &obd->u.obt.obt_lut->lut_tgd;
88 seq_printf(m, "%llu\n", tgd->tgd_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 tg_grants_data *tgd;
107 LASSERT(obd != NULL);
108 tgd = &obd->u.obt.obt_lut->lut_tgd;
109 seq_printf(m, "%llu\n", tgd->tgd_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 tg_grants_data *tgd;
128 LASSERT(obd != NULL);
129 tgd = &obd->u.obt.obt_lut->lut_tgd;
130 seq_printf(m, "%llu\n", tgd->tgd_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_target_data.ted_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_str_to_s64(buffer, count, &val);
200 if (val < 1 || val > INT_MAX)
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_str_to_s64(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 * \param[in] m seq_file handle
302 * \param[in] data unused for single entry
304 * \retval 0 on success
305 * \retval negative value on error
307 static int ofd_fmd_max_age_seq_show(struct seq_file *m, void *data)
309 struct obd_device *obd = m->private;
310 struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
312 seq_printf(m, "%lld\n", ofd->ofd_fmd_max_age);
317 * Set the maximum age of FMD data in seconds.
319 * This defines how long FMD data stays in the FMD list.
321 * \param[in] file proc file
322 * \param[in] buffer string which represents maximum number
323 * \param[in] count \a buffer length
324 * \param[in] off unused for single entry
326 * \retval \a count on success
327 * \retval negative number on error
330 ofd_fmd_max_age_seq_write(struct file *file, const char __user *buffer,
331 size_t count, loff_t *off)
333 struct seq_file *m = file->private_data;
334 struct obd_device *obd = m->private;
335 struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
339 rc = lprocfs_str_to_s64(buffer, count, &val);
343 if (val > 65536 || val < 1)
346 ofd->ofd_fmd_max_age = val;
349 LPROC_SEQ_FOPS(ofd_fmd_max_age);
352 * Show if the OFD is in degraded mode.
354 * Degraded means OFD has a failed drive or is undergoing RAID rebuild.
355 * The MDS will try to avoid using this OST for new object allocations
356 * to reduce the impact to global IO performance when clients writing to
357 * this OST are slowed down. It also reduces the contention on the OST
358 * RAID device, allowing it to rebuild more quickly.
360 * \param[in] m seq_file handle
361 * \param[in] data unused for single entry
363 * \retval 0 on success
364 * \retval negative value on error
366 static int ofd_degraded_seq_show(struct seq_file *m, void *data)
368 struct obd_device *obd = m->private;
369 struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
371 seq_printf(m, "%u\n", ofd->ofd_raid_degraded);
376 * Set OFD to degraded mode.
378 * This is used to interface to userspace administrative tools for
379 * the underlying RAID storage, so that they can mark an OST
380 * as having degraded performance.
382 * \param[in] file proc file
383 * \param[in] buffer string which represents mode
384 * 1: set degraded mode
385 * 0: unset degraded mode
386 * \param[in] count \a buffer length
387 * \param[in] off unused for single entry
389 * \retval \a count on success
390 * \retval negative number on error
393 ofd_degraded_seq_write(struct file *file, const char __user *buffer,
394 size_t count, loff_t *off)
396 struct seq_file *m = file->private_data;
397 struct obd_device *obd = m->private;
398 struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
402 rc = lprocfs_str_to_s64(buffer, count, &val);
406 spin_lock(&ofd->ofd_flags_lock);
407 ofd->ofd_raid_degraded = !!val;
408 spin_unlock(&ofd->ofd_flags_lock);
411 LPROC_SEQ_FOPS(ofd_degraded);
414 * Show OFD filesystem type.
416 * \param[in] m seq_file handle
417 * \param[in] data unused for single entry
419 * \retval 0 on success
420 * \retval negative value on error
422 static int ofd_fstype_seq_show(struct seq_file *m, void *data)
424 struct obd_device *obd = m->private;
425 struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
428 LASSERT(ofd->ofd_osd);
429 d = &ofd->ofd_osd->dd_lu_dev;
431 seq_printf(m, "%s\n", d->ld_type->ldt_name);
434 LPROC_SEQ_FOPS_RO(ofd_fstype);
437 * Show journal handling mode: synchronous or asynchronous.
439 * When running in asynchronous mode the journal transactions are not
440 * committed to disk before the RPC is replied back to the client.
441 * This will typically improve client performance when only a small number
442 * of clients are writing, since the client(s) can have more write RPCs
443 * in flight. However, it also means that the client has to handle recovery
444 * on bulk RPCs, and will have to keep more dirty pages in cache before they
445 * are committed on the OST.
447 * \param[in] m seq_file handle
448 * \param[in] data unused for single entry
450 * \retval 0 on success
451 * \retval negative value on error
453 static int ofd_syncjournal_seq_show(struct seq_file *m, void *data)
455 struct obd_device *obd = m->private;
456 struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
458 seq_printf(m, "%u\n", ofd->ofd_syncjournal);
463 * Set journal mode to synchronous or asynchronous.
465 * \param[in] file proc file
466 * \param[in] buffer string which represents mode
467 * 1: synchronous mode
468 * 0: asynchronous mode
469 * \param[in] count \a buffer length
470 * \param[in] off unused for single entry
472 * \retval \a count on success
473 * \retval negative number on error
476 ofd_syncjournal_seq_write(struct file *file, const char __user *buffer,
477 size_t count, loff_t *off)
479 struct seq_file *m = file->private_data;
480 struct obd_device *obd = m->private;
481 struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
485 rc = lprocfs_str_to_s64(buffer, count, &val);
492 spin_lock(&ofd->ofd_flags_lock);
493 ofd->ofd_syncjournal = !!val;
495 spin_unlock(&ofd->ofd_flags_lock);
499 LPROC_SEQ_FOPS(ofd_syncjournal);
501 /* This must be longer than the longest string below */
502 #define SYNC_STATES_MAXLEN 16
504 static int ofd_brw_size_seq_show(struct seq_file *m, void *data)
506 struct obd_device *obd = m->private;
507 struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
509 seq_printf(m, "%u\n", ofd->ofd_brw_size / ONE_MB_BRW_SIZE);
514 ofd_brw_size_seq_write(struct file *file, const char __user *buffer,
515 size_t count, loff_t *off)
517 struct seq_file *m = file->private_data;
518 struct obd_device *obd = m->private;
519 struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
523 rc = lprocfs_str_with_units_to_s64(buffer, count, &val, 'M');
530 if (val > DT_MAX_BRW_SIZE ||
531 val < (1 << ofd->ofd_lut.lut_tgd.tgd_blockbits))
534 spin_lock(&ofd->ofd_flags_lock);
535 ofd->ofd_brw_size = val;
536 spin_unlock(&ofd->ofd_flags_lock);
540 LPROC_SEQ_FOPS(ofd_brw_size);
542 static char *sync_on_cancel_states[] = {"never",
547 * Show OFD policy for handling dirty data under a lock being cancelled.
549 * \param[in] m seq_file handle
550 * \param[in] data unused for single entry
552 * \retval 0 on success
553 * \retval negative value on error
555 static int ofd_sync_lock_cancel_seq_show(struct seq_file *m, void *data)
557 struct obd_device *obd = m->private;
558 struct lu_target *tgt = obd->u.obt.obt_lut;
560 seq_printf(m, "%s\n",
561 sync_on_cancel_states[tgt->lut_sync_lock_cancel]);
566 * Change OFD policy for handling dirty data under a lock being cancelled.
568 * This variable defines what action OFD takes upon lock cancel
569 * There are three possible modes:
570 * 1) never - never do sync upon lock cancel. This can lead to data
571 * inconsistencies if both the OST and client crash while writing a file
572 * that is also concurrently being read by another client. In these cases,
573 * this may allow the file data to "rewind" to an earlier state.
574 * 2) blocking - do sync only if there is blocking lock, e.g. if another
575 * client is trying to access this same object
576 * 3) always - do sync always
578 * \param[in] file proc file
579 * \param[in] buffer string which represents policy
580 * \param[in] count \a buffer length
581 * \param[in] off unused for single entry
583 * \retval \a count on success
584 * \retval negative number on error
587 ofd_sync_lock_cancel_seq_write(struct file *file, const char __user *buffer,
588 size_t count, loff_t *off)
590 struct seq_file *m = file->private_data;
591 struct obd_device *obd = m->private;
592 struct lu_target *tgt = obd->u.obt.obt_lut;
593 char kernbuf[SYNC_STATES_MAXLEN];
597 if (count == 0 || count >= sizeof(kernbuf))
600 if (copy_from_user(kernbuf, buffer, count))
604 if (kernbuf[count - 1] == '\n')
605 kernbuf[count - 1] = 0;
607 for (i = 0 ; i < NUM_SYNC_ON_CANCEL_STATES; i++) {
608 if (strcmp(kernbuf, sync_on_cancel_states[i]) == 0) {
614 /* Legacy numeric codes */
616 int rc = lprocfs_str_to_s64(buffer, count, &val);
621 if (val < 0 || val > 2)
624 spin_lock(&tgt->lut_flags_lock);
625 tgt->lut_sync_lock_cancel = val;
626 spin_unlock(&tgt->lut_flags_lock);
629 LPROC_SEQ_FOPS(ofd_sync_lock_cancel);
632 * Show if grants compatibility mode is disabled.
634 * When tgd_grant_compat_disable is set, we don't grant any space to clients
635 * not supporting OBD_CONNECT_GRANT_PARAM. Otherwise, space granted to such
636 * a client is inflated since it consumes PAGE_SIZE of grant space per
637 * block, (i.e. typically 4kB units), but underlaying file system might have
638 * block size bigger than page size, e.g. ZFS. See LU-2049 for details.
640 * \param[in] m seq_file handle
641 * \param[in] data unused for single entry
643 * \retval 0 on success
644 * \retval negative value on error
646 static int ofd_grant_compat_disable_seq_show(struct seq_file *m, void *data)
648 struct obd_device *obd = m->private;
649 struct tg_grants_data *tgd = &obd->u.obt.obt_lut->lut_tgd;
651 seq_printf(m, "%u\n", tgd->tgd_grant_compat_disable);
656 * Change grant compatibility mode.
658 * Setting tgd_grant_compat_disable prohibit any space granting to clients
659 * not supporting OBD_CONNECT_GRANT_PARAM. See details above.
661 * \param[in] file proc file
662 * \param[in] buffer string which represents mode
663 * 1: disable compatibility mode
664 * 0: enable compatibility mode
665 * \param[in] count \a buffer length
666 * \param[in] off unused for single entry
668 * \retval \a count on success
669 * \retval negative number on error
672 ofd_grant_compat_disable_seq_write(struct file *file,
673 const char __user *buffer,
674 size_t count, loff_t *off)
676 struct seq_file *m = file->private_data;
677 struct obd_device *obd = m->private;
678 struct tg_grants_data *tgd = &obd->u.obt.obt_lut->lut_tgd;
682 rc = lprocfs_str_to_s64(buffer, count, &val);
689 tgd->tgd_grant_compat_disable = !!val;
693 LPROC_SEQ_FOPS(ofd_grant_compat_disable);
696 * Show the limit of soft sync RPCs.
698 * This value defines how many IO RPCs with OBD_BRW_SOFT_SYNC flag
699 * are allowed before sync update will be triggered.
701 * \param[in] m seq_file handle
702 * \param[in] data unused for single entry
704 * \retval 0 on success
705 * \retval negative value on error
707 static int ofd_soft_sync_limit_seq_show(struct seq_file *m, void *data)
709 struct obd_device *obd = m->private;
710 struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
712 return lprocfs_uint_seq_show(m, &ofd->ofd_soft_sync_limit);
716 * Change the limit of soft sync RPCs.
718 * Define how many IO RPCs with OBD_BRW_SOFT_SYNC flag
719 * allowed before sync update will be done.
721 * This limit is global across all exports.
723 * \param[in] file proc file
724 * \param[in] buffer string which represents limit
725 * \param[in] count \a buffer length
726 * \param[in] off unused for single entry
728 * \retval \a count on success
729 * \retval negative number on error
732 ofd_soft_sync_limit_seq_write(struct file *file, const char __user *buffer,
733 size_t count, loff_t *off)
735 struct seq_file *m = file->private_data;
736 struct obd_device *obd = m->private;
737 struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
739 return lprocfs_uint_seq_write(file, buffer, count,
740 (loff_t *) &ofd->ofd_soft_sync_limit);
742 LPROC_SEQ_FOPS(ofd_soft_sync_limit);
745 * Show the LFSCK speed limit.
747 * The maximum number of items scanned per second.
749 * \param[in] m seq_file handle
750 * \param[in] data unused for single entry
752 * \retval 0 on success
753 * \retval negative value on error
755 static int ofd_lfsck_speed_limit_seq_show(struct seq_file *m, void *data)
757 struct obd_device *obd = m->private;
758 struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
760 return lfsck_get_speed(m, ofd->ofd_osd);
764 * Change the LFSCK speed limit.
766 * Limit number of items that may be scanned per second.
768 * \param[in] file proc file
769 * \param[in] buffer string which represents limit
770 * \param[in] count \a buffer length
771 * \param[in] off unused for single entry
773 * \retval \a count on success
774 * \retval negative number on error
777 ofd_lfsck_speed_limit_seq_write(struct file *file, const char __user *buffer,
778 size_t count, loff_t *off)
780 struct seq_file *m = file->private_data;
781 struct obd_device *obd = m->private;
782 struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
786 rc = lprocfs_str_to_s64(buffer, count, &val);
793 rc = lfsck_set_speed(ofd->ofd_osd, val);
795 return rc != 0 ? rc : count;
797 LPROC_SEQ_FOPS(ofd_lfsck_speed_limit);
800 * Show LFSCK layout verification stats from the most recent LFSCK run.
802 * \param[in] m seq_file handle
803 * \param[in] data unused for single entry
805 * \retval 0 on success
806 * \retval negative value on error
808 static int ofd_lfsck_layout_seq_show(struct seq_file *m, void *data)
810 struct obd_device *obd = m->private;
811 struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
813 return lfsck_dump(m, ofd->ofd_osd, LFSCK_TYPE_LAYOUT);
815 LPROC_SEQ_FOPS_RO(ofd_lfsck_layout);
818 * Show if LFSCK performed parent FID verification.
820 * \param[in] m seq_file handle
821 * \param[in] data unused for single entry
823 * \retval 0 on success
824 * \retval negative value on error
826 static int ofd_lfsck_verify_pfid_seq_show(struct seq_file *m, void *data)
828 struct obd_device *obd = m->private;
829 struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
831 seq_printf(m, "switch: %s\ndetected: %llu\nrepaired: %llu\n",
832 ofd->ofd_lfsck_verify_pfid ? "on" : "off",
833 ofd->ofd_inconsistency_self_detected,
834 ofd->ofd_inconsistency_self_repaired);
839 * Set the LFSCK behavior to verify parent FID correctness.
841 * If flag ofd_lfsck_verify_pfid is set then LFSCK does parent FID
842 * verification during read/write operations.
844 * \param[in] file proc file
845 * \param[in] buffer string which represents behavior
846 * 1: verify parent FID
847 * 0: don't verify parent FID
848 * \param[in] count \a buffer length
849 * \param[in] off unused for single entry
851 * \retval \a count on success
852 * \retval negative number on error
855 ofd_lfsck_verify_pfid_seq_write(struct file *file, const char __user *buffer,
856 size_t count, loff_t *off)
858 struct seq_file *m = file->private_data;
859 struct obd_device *obd = m->private;
860 struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
864 rc = lprocfs_str_to_s64(buffer, count, &val);
868 ofd->ofd_lfsck_verify_pfid = !!val;
869 if (!ofd->ofd_lfsck_verify_pfid) {
870 ofd->ofd_inconsistency_self_detected = 0;
871 ofd->ofd_inconsistency_self_repaired = 0;
876 LPROC_SEQ_FOPS(ofd_lfsck_verify_pfid);
878 static int ofd_site_stats_seq_show(struct seq_file *m, void *data)
880 struct obd_device *obd = m->private;
882 return lu_site_stats_seq_print(obd->obd_lu_dev->ld_site, m);
884 LPROC_SEQ_FOPS_RO(ofd_site_stats);
886 LPROC_SEQ_FOPS_RO_TYPE(ofd, recovery_status);
887 LPROC_SEQ_FOPS_RW_TYPE(ofd, recovery_time_soft);
888 LPROC_SEQ_FOPS_RW_TYPE(ofd, recovery_time_hard);
889 LPROC_SEQ_FOPS_WR_ONLY(ofd, evict_client);
890 LPROC_SEQ_FOPS_RO_TYPE(ofd, num_exports);
891 LPROC_SEQ_FOPS_RO_TYPE(ofd, target_instance);
892 LPROC_SEQ_FOPS_RW_TYPE(ofd, ir_factor);
893 LPROC_SEQ_FOPS_RW_TYPE(ofd, checksum_dump);
894 LPROC_SEQ_FOPS_RW_TYPE(ofd, job_interval);
896 struct lprocfs_vars lprocfs_ofd_obd_vars[] = {
897 { .name = "seqs_allocated",
898 .fops = &ofd_seqs_fops },
900 .fops = &ofd_fstype_fops },
902 .fops = &ofd_last_id_fops },
903 { .name = "tot_dirty",
904 .fops = &ofd_tot_dirty_fops },
905 { .name = "tot_pending",
906 .fops = &ofd_tot_pending_fops },
907 { .name = "tot_granted",
908 .fops = &ofd_tot_granted_fops },
909 { .name = "grant_precreate",
910 .fops = &ofd_grant_precreate_fops },
911 { .name = "precreate_batch",
912 .fops = &ofd_precreate_batch_fops },
913 { .name = "recovery_status",
914 .fops = &ofd_recovery_status_fops },
915 { .name = "recovery_time_soft",
916 .fops = &ofd_recovery_time_soft_fops },
917 { .name = "recovery_time_hard",
918 .fops = &ofd_recovery_time_hard_fops },
919 { .name = "evict_client",
920 .fops = &ofd_evict_client_fops },
921 { .name = "num_exports",
922 .fops = &ofd_num_exports_fops },
923 { .name = "degraded",
924 .fops = &ofd_degraded_fops },
925 { .name = "sync_journal",
926 .fops = &ofd_syncjournal_fops },
927 { .name = "brw_size",
928 .fops = &ofd_brw_size_fops },
929 { .name = "sync_on_lock_cancel",
930 .fops = &ofd_sync_lock_cancel_fops },
931 { .name = "instance",
932 .fops = &ofd_target_instance_fops },
933 { .name = "ir_factor",
934 .fops = &ofd_ir_factor_fops },
935 { .name = "checksum_dump",
936 .fops = &ofd_checksum_dump_fops },
937 { .name = "grant_compat_disable",
938 .fops = &ofd_grant_compat_disable_fops },
939 { .name = "client_cache_count",
940 .fops = &ofd_fmd_max_num_fops },
941 { .name = "client_cache_seconds",
942 .fops = &ofd_fmd_max_age_fops },
943 { .name = "job_cleanup_interval",
944 .fops = &ofd_job_interval_fops },
945 { .name = "soft_sync_limit",
946 .fops = &ofd_soft_sync_limit_fops },
947 { .name = "lfsck_speed_limit",
948 .fops = &ofd_lfsck_speed_limit_fops },
949 { .name = "lfsck_layout",
950 .fops = &ofd_lfsck_layout_fops },
951 { .name = "lfsck_verify_pfid",
952 .fops = &ofd_lfsck_verify_pfid_fops },
953 { .name = "site_stats",
954 .fops = &ofd_site_stats_fops },
959 * Initialize OFD statistics counters
961 * param[in] stats statistics counters
963 void ofd_stats_counter_init(struct lprocfs_stats *stats)
965 LASSERT(stats && stats->ls_num >= LPROC_OFD_STATS_LAST);
967 lprocfs_counter_init(stats, LPROC_OFD_STATS_READ,
968 LPROCFS_CNTR_AVGMINMAX, "read_bytes", "bytes");
969 lprocfs_counter_init(stats, LPROC_OFD_STATS_WRITE,
970 LPROCFS_CNTR_AVGMINMAX, "write_bytes", "bytes");
971 lprocfs_counter_init(stats, LPROC_OFD_STATS_GETATTR,
972 0, "getattr", "reqs");
973 lprocfs_counter_init(stats, LPROC_OFD_STATS_SETATTR,
974 0, "setattr", "reqs");
975 lprocfs_counter_init(stats, LPROC_OFD_STATS_PUNCH,
977 lprocfs_counter_init(stats, LPROC_OFD_STATS_SYNC,
979 lprocfs_counter_init(stats, LPROC_OFD_STATS_DESTROY,
980 0, "destroy", "reqs");
981 lprocfs_counter_init(stats, LPROC_OFD_STATS_CREATE,
982 0, "create", "reqs");
983 lprocfs_counter_init(stats, LPROC_OFD_STATS_STATFS,
984 0, "statfs", "reqs");
985 lprocfs_counter_init(stats, LPROC_OFD_STATS_GET_INFO,
986 0, "get_info", "reqs");
987 lprocfs_counter_init(stats, LPROC_OFD_STATS_SET_INFO,
988 0, "set_info", "reqs");
989 lprocfs_counter_init(stats, LPROC_OFD_STATS_QUOTACTL,
990 0, "quotactl", "reqs");
993 #endif /* CONFIG_PROC_FS */