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 total number of grants for precreate.
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_grant_precreate_seq_show(struct seq_file *m, void *data)
83 struct obd_device *obd = m->private;
86 seq_printf(m, "%ld\n",
87 obd->obd_self_export->exp_target_data.ted_grant);
90 LPROC_SEQ_FOPS_RO(ofd_grant_precreate);
93 * Show number of precreates allowed in a single transaction.
95 * \param[in] m seq_file handle
96 * \param[in] data unused for single entry
98 * \retval 0 on success
99 * \retval negative value on error
101 static int ofd_precreate_batch_seq_show(struct seq_file *m, void *data)
103 struct obd_device *obd = m->private;
104 struct ofd_device *ofd;
106 LASSERT(obd != NULL);
107 ofd = ofd_dev(obd->obd_lu_dev);
108 seq_printf(m, "%d\n", ofd->ofd_precreate_batch);
113 * Change number of precreates allowed in a single transaction.
115 * \param[in] file proc file
116 * \param[in] buffer string which represents maximum number
117 * \param[in] count \a buffer length
118 * \param[in] off unused for single entry
120 * \retval \a count on success
121 * \retval negative number on error
124 ofd_precreate_batch_seq_write(struct file *file, const char __user *buffer,
125 size_t count, loff_t *off)
127 struct seq_file *m = file->private_data;
128 struct obd_device *obd = m->private;
129 struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
133 rc = lprocfs_str_to_s64(buffer, count, &val);
137 if (val < 1 || val > INT_MAX)
140 spin_lock(&ofd->ofd_batch_lock);
141 ofd->ofd_precreate_batch = val;
142 spin_unlock(&ofd->ofd_batch_lock);
145 LPROC_SEQ_FOPS(ofd_precreate_batch);
148 * Show the last used ID for each FID sequence used by OFD.
150 * \param[in] m seq_file handle
151 * \param[in] data unused for single entry
153 * \retval 0 on success
154 * \retval negative value on error
156 static int ofd_last_id_seq_show(struct seq_file *m, void *data)
158 struct obd_device *obd = m->private;
159 struct ofd_device *ofd;
160 struct ofd_seq *oseq = NULL;
165 ofd = ofd_dev(obd->obd_lu_dev);
167 read_lock(&ofd->ofd_seq_list_lock);
168 list_for_each_entry(oseq, &ofd->ofd_seq_list, os_list) {
171 seq = ostid_seq(&oseq->os_oi) == 0 ?
172 fid_idif_seq(ostid_id(&oseq->os_oi),
173 ofd->ofd_lut.lut_lsd.lsd_osd_index) :
174 ostid_seq(&oseq->os_oi);
175 seq_printf(m, DOSTID"\n", seq, ostid_id(&oseq->os_oi));
177 read_unlock(&ofd->ofd_seq_list_lock);
180 LPROC_SEQ_FOPS_RO(ofd_last_id);
183 * Show maximum number of Filter Modification Data (FMD) maintained by OFD.
185 * \param[in] m seq_file handle
186 * \param[in] data unused for single entry
188 * \retval 0 on success
189 * \retval negative value on error
191 static int ofd_fmd_max_num_seq_show(struct seq_file *m, void *data)
193 struct obd_device *obd = m->private;
194 struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
196 seq_printf(m, "%u\n", ofd->ofd_fmd_max_num);
201 * Change number of FMDs maintained by OFD.
203 * This defines how large the list of FMDs can be.
205 * \param[in] file proc file
206 * \param[in] buffer string which represents maximum number
207 * \param[in] count \a buffer length
208 * \param[in] off unused for single entry
210 * \retval \a count on success
211 * \retval negative number on error
214 ofd_fmd_max_num_seq_write(struct file *file, const char __user *buffer,
215 size_t count, loff_t *off)
217 struct seq_file *m = file->private_data;
218 struct obd_device *obd = m->private;
219 struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
223 rc = lprocfs_str_to_s64(buffer, count, &val);
227 if (val > 65536 || val < 1)
230 ofd->ofd_fmd_max_num = val;
233 LPROC_SEQ_FOPS(ofd_fmd_max_num);
236 * Show the maximum age of FMD data in seconds.
238 * Though it is shown in seconds, it is stored internally in units
239 * of jiffies for efficiency.
241 * \param[in] m seq_file handle
242 * \param[in] data unused for single entry
244 * \retval 0 on success
245 * \retval negative value on error
247 static int ofd_fmd_max_age_seq_show(struct seq_file *m, void *data)
249 struct obd_device *obd = m->private;
250 struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
252 seq_printf(m, "%ld\n", jiffies_to_msecs(ofd->ofd_fmd_max_age) /
258 * Set the maximum age of FMD data in seconds.
260 * This defines how long FMD data stays in the FMD list.
261 * It is stored internally in units of jiffies for efficiency.
263 * \param[in] file proc file
264 * \param[in] buffer string which represents maximum number
265 * \param[in] count \a buffer length
266 * \param[in] off unused for single entry
268 * \retval \a count on success
269 * \retval negative number on error
272 ofd_fmd_max_age_seq_write(struct file *file, const char __user *buffer,
273 size_t count, loff_t *off)
275 struct seq_file *m = file->private_data;
276 struct obd_device *obd = m->private;
277 struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
281 rc = lprocfs_str_to_s64(buffer, count, &val);
285 if (val > 65536 || val < 1)
288 ofd->ofd_fmd_max_age = msecs_to_jiffies(val * MSEC_PER_SEC);
291 LPROC_SEQ_FOPS(ofd_fmd_max_age);
294 * Show if the OFD is in degraded mode.
296 * Degraded means OFD has a failed drive or is undergoing RAID rebuild.
297 * The MDS will try to avoid using this OST for new object allocations
298 * to reduce the impact to global IO performance when clients writing to
299 * this OST are slowed down. It also reduces the contention on the OST
300 * RAID device, allowing it to rebuild more quickly.
302 * \param[in] m seq_file handle
303 * \param[in] data unused for single entry
305 * \retval 0 on success
306 * \retval negative value on error
308 static int ofd_degraded_seq_show(struct seq_file *m, void *data)
310 struct obd_device *obd = m->private;
311 struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
313 seq_printf(m, "%u\n", ofd->ofd_raid_degraded);
318 * Set OFD to degraded mode.
320 * This is used to interface to userspace administrative tools for
321 * the underlying RAID storage, so that they can mark an OST
322 * as having degraded performance.
324 * \param[in] file proc file
325 * \param[in] buffer string which represents mode
326 * 1: set degraded mode
327 * 0: unset degraded mode
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_degraded_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_str_to_s64(buffer, count, &val);
348 spin_lock(&ofd->ofd_flags_lock);
349 ofd->ofd_raid_degraded = !!val;
350 spin_unlock(&ofd->ofd_flags_lock);
353 LPROC_SEQ_FOPS(ofd_degraded);
356 * Show OFD filesystem type.
358 * \param[in] m seq_file handle
359 * \param[in] data unused for single entry
361 * \retval 0 on success
362 * \retval negative value on error
364 static int ofd_fstype_seq_show(struct seq_file *m, void *data)
366 struct obd_device *obd = m->private;
367 struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
370 LASSERT(ofd->ofd_osd);
371 d = &ofd->ofd_osd->dd_lu_dev;
373 seq_printf(m, "%s\n", d->ld_type->ldt_name);
376 LPROC_SEQ_FOPS_RO(ofd_fstype);
379 * Show journal handling mode: synchronous or asynchronous.
381 * When running in asynchronous mode the journal transactions are not
382 * committed to disk before the RPC is replied back to the client.
383 * This will typically improve client performance when only a small number
384 * of clients are writing, since the client(s) can have more write RPCs
385 * in flight. However, it also means that the client has to handle recovery
386 * on bulk RPCs, and will have to keep more dirty pages in cache before they
387 * are committed on the OST.
389 * \param[in] m seq_file handle
390 * \param[in] data unused for single entry
392 * \retval 0 on success
393 * \retval negative value on error
395 static int ofd_syncjournal_seq_show(struct seq_file *m, void *data)
397 struct obd_device *obd = m->private;
398 struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
400 seq_printf(m, "%u\n", ofd->ofd_syncjournal);
405 * Set journal mode to synchronous or asynchronous.
407 * \param[in] file proc file
408 * \param[in] buffer string which represents mode
409 * 1: synchronous mode
410 * 0: asynchronous mode
411 * \param[in] count \a buffer length
412 * \param[in] off unused for single entry
414 * \retval \a count on success
415 * \retval negative number on error
418 ofd_syncjournal_seq_write(struct file *file, const char __user *buffer,
419 size_t count, loff_t *off)
421 struct seq_file *m = file->private_data;
422 struct obd_device *obd = m->private;
423 struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
427 rc = lprocfs_str_to_s64(buffer, count, &val);
434 spin_lock(&ofd->ofd_flags_lock);
435 ofd->ofd_syncjournal = !!val;
437 spin_unlock(&ofd->ofd_flags_lock);
441 LPROC_SEQ_FOPS(ofd_syncjournal);
443 /* This must be longer than the longest string below */
444 #define SYNC_STATES_MAXLEN 16
446 static int ofd_brw_size_seq_show(struct seq_file *m, void *data)
448 struct obd_device *obd = m->private;
449 struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
451 seq_printf(m, "%u\n", ofd->ofd_brw_size / ONE_MB_BRW_SIZE);
456 ofd_brw_size_seq_write(struct file *file, const char __user *buffer,
457 size_t count, loff_t *off)
459 struct seq_file *m = file->private_data;
460 struct obd_device *obd = m->private;
461 struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
465 rc = lprocfs_str_with_units_to_s64(buffer, count, &val, 'M');
472 if (val > DT_MAX_BRW_SIZE ||
473 val < (1 << ofd->ofd_lut.lut_tgd.tgd_blockbits))
476 spin_lock(&ofd->ofd_flags_lock);
477 ofd->ofd_brw_size = val;
478 spin_unlock(&ofd->ofd_flags_lock);
482 LPROC_SEQ_FOPS(ofd_brw_size);
484 static char *sync_on_cancel_states[] = {"never",
489 * Show OFD policy for handling dirty data under a lock being cancelled.
491 * \param[in] m seq_file handle
492 * \param[in] data unused for single entry
494 * \retval 0 on success
495 * \retval negative value on error
497 static int ofd_sync_lock_cancel_seq_show(struct seq_file *m, void *data)
499 struct obd_device *obd = m->private;
500 struct lu_target *tgt = obd->u.obt.obt_lut;
502 seq_printf(m, "%s\n",
503 sync_on_cancel_states[tgt->lut_sync_lock_cancel]);
508 * Change OFD policy for handling dirty data under a lock being cancelled.
510 * This variable defines what action OFD takes upon lock cancel
511 * There are three possible modes:
512 * 1) never - never do sync upon lock cancel. This can lead to data
513 * inconsistencies if both the OST and client crash while writing a file
514 * that is also concurrently being read by another client. In these cases,
515 * this may allow the file data to "rewind" to an earlier state.
516 * 2) blocking - do sync only if there is blocking lock, e.g. if another
517 * client is trying to access this same object
518 * 3) always - do sync always
520 * \param[in] file proc file
521 * \param[in] buffer string which represents policy
522 * \param[in] count \a buffer length
523 * \param[in] off unused for single entry
525 * \retval \a count on success
526 * \retval negative number on error
529 ofd_sync_lock_cancel_seq_write(struct file *file, const char __user *buffer,
530 size_t count, loff_t *off)
532 struct seq_file *m = file->private_data;
533 struct obd_device *obd = m->private;
534 struct lu_target *tgt = obd->u.obt.obt_lut;
535 char kernbuf[SYNC_STATES_MAXLEN];
539 if (count == 0 || count >= sizeof(kernbuf))
542 if (copy_from_user(kernbuf, buffer, count))
546 if (kernbuf[count - 1] == '\n')
547 kernbuf[count - 1] = 0;
549 for (i = 0 ; i < NUM_SYNC_ON_CANCEL_STATES; i++) {
550 if (strcmp(kernbuf, sync_on_cancel_states[i]) == 0) {
556 /* Legacy numeric codes */
558 int rc = lprocfs_str_to_s64(buffer, count, &val);
563 if (val < 0 || val > 2)
566 spin_lock(&tgt->lut_flags_lock);
567 tgt->lut_sync_lock_cancel = val;
568 spin_unlock(&tgt->lut_flags_lock);
571 LPROC_SEQ_FOPS(ofd_sync_lock_cancel);
574 * Show the limit of soft sync RPCs.
576 * This value defines how many IO RPCs with OBD_BRW_SOFT_SYNC flag
577 * are allowed before sync update will be triggered.
579 * \param[in] m seq_file handle
580 * \param[in] data unused for single entry
582 * \retval 0 on success
583 * \retval negative value on error
585 static int ofd_soft_sync_limit_seq_show(struct seq_file *m, void *data)
587 struct obd_device *obd = m->private;
588 struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
590 return lprocfs_uint_seq_show(m, &ofd->ofd_soft_sync_limit);
594 * Change the limit of soft sync RPCs.
596 * Define how many IO RPCs with OBD_BRW_SOFT_SYNC flag
597 * allowed before sync update will be done.
599 * This limit is global across all exports.
601 * \param[in] file proc file
602 * \param[in] buffer string which represents limit
603 * \param[in] count \a buffer length
604 * \param[in] off unused for single entry
606 * \retval \a count on success
607 * \retval negative number on error
610 ofd_soft_sync_limit_seq_write(struct file *file, const char __user *buffer,
611 size_t count, loff_t *off)
613 struct seq_file *m = file->private_data;
614 struct obd_device *obd = m->private;
615 struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
617 return lprocfs_uint_seq_write(file, buffer, count,
618 (loff_t *) &ofd->ofd_soft_sync_limit);
620 LPROC_SEQ_FOPS(ofd_soft_sync_limit);
623 * Show the LFSCK speed limit.
625 * The maximum number of items scanned per second.
627 * \param[in] m seq_file handle
628 * \param[in] data unused for single entry
630 * \retval 0 on success
631 * \retval negative value on error
633 static int ofd_lfsck_speed_limit_seq_show(struct seq_file *m, void *data)
635 struct obd_device *obd = m->private;
636 struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
638 return lfsck_get_speed(m, ofd->ofd_osd);
642 * Change the LFSCK speed limit.
644 * Limit number of items that may be scanned per second.
646 * \param[in] file proc file
647 * \param[in] buffer string which represents limit
648 * \param[in] count \a buffer length
649 * \param[in] off unused for single entry
651 * \retval \a count on success
652 * \retval negative number on error
655 ofd_lfsck_speed_limit_seq_write(struct file *file, const char __user *buffer,
656 size_t count, loff_t *off)
658 struct seq_file *m = file->private_data;
659 struct obd_device *obd = m->private;
660 struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
664 rc = lprocfs_str_to_s64(buffer, count, &val);
671 rc = lfsck_set_speed(ofd->ofd_osd, val);
673 return rc != 0 ? rc : count;
675 LPROC_SEQ_FOPS(ofd_lfsck_speed_limit);
678 * Show LFSCK layout verification stats from the most recent LFSCK run.
680 * \param[in] m seq_file handle
681 * \param[in] data unused for single entry
683 * \retval 0 on success
684 * \retval negative value on error
686 static int ofd_lfsck_layout_seq_show(struct seq_file *m, void *data)
688 struct obd_device *obd = m->private;
689 struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
691 return lfsck_dump(m, ofd->ofd_osd, LFSCK_TYPE_LAYOUT);
693 LPROC_SEQ_FOPS_RO(ofd_lfsck_layout);
696 * Show if LFSCK performed parent FID verification.
698 * \param[in] m seq_file handle
699 * \param[in] data unused for single entry
701 * \retval 0 on success
702 * \retval negative value on error
704 static int ofd_lfsck_verify_pfid_seq_show(struct seq_file *m, void *data)
706 struct obd_device *obd = m->private;
707 struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
709 seq_printf(m, "switch: %s\ndetected: %llu\nrepaired: %llu\n",
710 ofd->ofd_lfsck_verify_pfid ? "on" : "off",
711 ofd->ofd_inconsistency_self_detected,
712 ofd->ofd_inconsistency_self_repaired);
717 * Set the LFSCK behavior to verify parent FID correctness.
719 * If flag ofd_lfsck_verify_pfid is set then LFSCK does parent FID
720 * verification during read/write operations.
722 * \param[in] file proc file
723 * \param[in] buffer string which represents behavior
724 * 1: verify parent FID
725 * 0: don't verify parent FID
726 * \param[in] count \a buffer length
727 * \param[in] off unused for single entry
729 * \retval \a count on success
730 * \retval negative number on error
733 ofd_lfsck_verify_pfid_seq_write(struct file *file, const char __user *buffer,
734 size_t count, loff_t *off)
736 struct seq_file *m = file->private_data;
737 struct obd_device *obd = m->private;
738 struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
742 rc = lprocfs_str_to_s64(buffer, count, &val);
746 ofd->ofd_lfsck_verify_pfid = !!val;
747 if (!ofd->ofd_lfsck_verify_pfid) {
748 ofd->ofd_inconsistency_self_detected = 0;
749 ofd->ofd_inconsistency_self_repaired = 0;
754 LPROC_SEQ_FOPS(ofd_lfsck_verify_pfid);
756 static int ofd_site_stats_seq_show(struct seq_file *m, void *data)
758 struct obd_device *obd = m->private;
760 return lu_site_stats_seq_print(obd->obd_lu_dev->ld_site, m);
762 LPROC_SEQ_FOPS_RO(ofd_site_stats);
764 LPROC_SEQ_FOPS_RO_TYPE(ofd, recovery_status);
765 LPROC_SEQ_FOPS_RW_TYPE(ofd, recovery_time_soft);
766 LPROC_SEQ_FOPS_RW_TYPE(ofd, recovery_time_hard);
767 LPROC_SEQ_FOPS_WR_ONLY(ofd, evict_client);
768 LPROC_SEQ_FOPS_RO_TYPE(ofd, num_exports);
769 LPROC_SEQ_FOPS_RO_TYPE(ofd, target_instance);
770 LPROC_SEQ_FOPS_RW_TYPE(ofd, ir_factor);
771 LPROC_SEQ_FOPS_RW_TYPE(ofd, checksum_dump);
772 LPROC_SEQ_FOPS_RW_TYPE(ofd, job_interval);
774 LPROC_SEQ_FOPS_RO(tgt_tot_dirty);
775 LPROC_SEQ_FOPS_RO(tgt_tot_granted);
776 LPROC_SEQ_FOPS_RO(tgt_tot_pending);
777 LPROC_SEQ_FOPS(tgt_grant_compat_disable);
779 struct lprocfs_vars lprocfs_ofd_obd_vars[] = {
780 { .name = "seqs_allocated",
781 .fops = &ofd_seqs_fops },
783 .fops = &ofd_fstype_fops },
785 .fops = &ofd_last_id_fops },
786 { .name = "tot_dirty",
787 .fops = &tgt_tot_dirty_fops },
788 { .name = "tot_pending",
789 .fops = &tgt_tot_pending_fops },
790 { .name = "tot_granted",
791 .fops = &tgt_tot_granted_fops },
792 { .name = "grant_precreate",
793 .fops = &ofd_grant_precreate_fops },
794 { .name = "precreate_batch",
795 .fops = &ofd_precreate_batch_fops },
796 { .name = "recovery_status",
797 .fops = &ofd_recovery_status_fops },
798 { .name = "recovery_time_soft",
799 .fops = &ofd_recovery_time_soft_fops },
800 { .name = "recovery_time_hard",
801 .fops = &ofd_recovery_time_hard_fops },
802 { .name = "evict_client",
803 .fops = &ofd_evict_client_fops },
804 { .name = "num_exports",
805 .fops = &ofd_num_exports_fops },
806 { .name = "degraded",
807 .fops = &ofd_degraded_fops },
808 { .name = "sync_journal",
809 .fops = &ofd_syncjournal_fops },
810 { .name = "brw_size",
811 .fops = &ofd_brw_size_fops },
812 { .name = "sync_on_lock_cancel",
813 .fops = &ofd_sync_lock_cancel_fops },
814 { .name = "instance",
815 .fops = &ofd_target_instance_fops },
816 { .name = "ir_factor",
817 .fops = &ofd_ir_factor_fops },
818 { .name = "checksum_dump",
819 .fops = &ofd_checksum_dump_fops },
820 { .name = "grant_compat_disable",
821 .fops = &tgt_grant_compat_disable_fops },
822 { .name = "client_cache_count",
823 .fops = &ofd_fmd_max_num_fops },
824 { .name = "client_cache_seconds",
825 .fops = &ofd_fmd_max_age_fops },
826 { .name = "job_cleanup_interval",
827 .fops = &ofd_job_interval_fops },
828 { .name = "soft_sync_limit",
829 .fops = &ofd_soft_sync_limit_fops },
830 { .name = "lfsck_speed_limit",
831 .fops = &ofd_lfsck_speed_limit_fops },
832 { .name = "lfsck_layout",
833 .fops = &ofd_lfsck_layout_fops },
834 { .name = "lfsck_verify_pfid",
835 .fops = &ofd_lfsck_verify_pfid_fops },
836 { .name = "site_stats",
837 .fops = &ofd_site_stats_fops },
842 * Initialize OFD statistics counters
844 * param[in] stats statistics counters
846 void ofd_stats_counter_init(struct lprocfs_stats *stats)
848 LASSERT(stats && stats->ls_num >= LPROC_OFD_STATS_LAST);
850 lprocfs_counter_init(stats, LPROC_OFD_STATS_READ,
851 LPROCFS_CNTR_AVGMINMAX, "read_bytes", "bytes");
852 lprocfs_counter_init(stats, LPROC_OFD_STATS_WRITE,
853 LPROCFS_CNTR_AVGMINMAX, "write_bytes", "bytes");
854 lprocfs_counter_init(stats, LPROC_OFD_STATS_GETATTR,
855 0, "getattr", "reqs");
856 lprocfs_counter_init(stats, LPROC_OFD_STATS_SETATTR,
857 0, "setattr", "reqs");
858 lprocfs_counter_init(stats, LPROC_OFD_STATS_PUNCH,
860 lprocfs_counter_init(stats, LPROC_OFD_STATS_SYNC,
862 lprocfs_counter_init(stats, LPROC_OFD_STATS_DESTROY,
863 0, "destroy", "reqs");
864 lprocfs_counter_init(stats, LPROC_OFD_STATS_CREATE,
865 0, "create", "reqs");
866 lprocfs_counter_init(stats, LPROC_OFD_STATS_STATFS,
867 0, "statfs", "reqs");
868 lprocfs_counter_init(stats, LPROC_OFD_STATS_GET_INFO,
869 0, "get_info", "reqs");
870 lprocfs_counter_init(stats, LPROC_OFD_STATS_SET_INFO,
871 0, "set_info", "reqs");
872 lprocfs_counter_init(stats, LPROC_OFD_STATS_QUOTACTL,
873 0, "quotactl", "reqs");
876 #endif /* CONFIG_PROC_FS */