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 * 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_str_to_s64(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);
407 rc = lprocfs_str_to_s64(buffer, count, &val);
411 spin_lock(&ofd->ofd_flags_lock);
412 ofd->ofd_raid_degraded = !!val;
413 spin_unlock(&ofd->ofd_flags_lock);
416 LPROC_SEQ_FOPS(ofd_degraded);
419 * Show OFD filesystem type.
421 * \param[in] m seq_file handle
422 * \param[in] data unused for single entry
424 * \retval 0 on success
425 * \retval negative value on error
427 static int ofd_fstype_seq_show(struct seq_file *m, void *data)
429 struct obd_device *obd = m->private;
430 struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
433 LASSERT(ofd->ofd_osd);
434 d = &ofd->ofd_osd->dd_lu_dev;
436 seq_printf(m, "%s\n", d->ld_type->ldt_name);
439 LPROC_SEQ_FOPS_RO(ofd_fstype);
442 * Show journal handling mode: synchronous or asynchronous.
444 * When running in asynchronous mode the journal transactions are not
445 * committed to disk before the RPC is replied back to the client.
446 * This will typically improve client performance when only a small number
447 * of clients are writing, since the client(s) can have more write RPCs
448 * in flight. However, it also means that the client has to handle recovery
449 * on bulk RPCs, and will have to keep more dirty pages in cache before they
450 * are committed on the OST.
452 * \param[in] m seq_file handle
453 * \param[in] data unused for single entry
455 * \retval 0 on success
456 * \retval negative value on error
458 static int ofd_syncjournal_seq_show(struct seq_file *m, void *data)
460 struct obd_device *obd = m->private;
461 struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
463 seq_printf(m, "%u\n", ofd->ofd_syncjournal);
468 * Set journal mode to synchronous or asynchronous.
470 * \param[in] file proc file
471 * \param[in] buffer string which represents mode
472 * 1: synchronous mode
473 * 0: asynchronous mode
474 * \param[in] count \a buffer length
475 * \param[in] off unused for single entry
477 * \retval \a count on success
478 * \retval negative number on error
481 ofd_syncjournal_seq_write(struct file *file, const char __user *buffer,
482 size_t count, loff_t *off)
484 struct seq_file *m = file->private_data;
485 struct obd_device *obd = m->private;
486 struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
490 rc = lprocfs_str_to_s64(buffer, count, &val);
497 spin_lock(&ofd->ofd_flags_lock);
498 ofd->ofd_syncjournal = !!val;
500 spin_unlock(&ofd->ofd_flags_lock);
504 LPROC_SEQ_FOPS(ofd_syncjournal);
506 /* This must be longer than the longest string below */
507 #define SYNC_STATES_MAXLEN 16
509 static int ofd_brw_size_seq_show(struct seq_file *m, void *data)
511 struct obd_device *obd = m->private;
512 struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
514 seq_printf(m, "%u\n", ofd->ofd_brw_size / ONE_MB_BRW_SIZE);
519 ofd_brw_size_seq_write(struct file *file, const char __user *buffer,
520 size_t count, loff_t *off)
522 struct seq_file *m = file->private_data;
523 struct obd_device *obd = m->private;
524 struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
528 rc = lprocfs_str_with_units_to_s64(buffer, count, &val, 'M');
535 if (val > DT_MAX_BRW_SIZE ||
536 val < (1 << ofd->ofd_lut.lut_tgd.tgd_blockbits))
539 spin_lock(&ofd->ofd_flags_lock);
540 ofd->ofd_brw_size = val;
541 spin_unlock(&ofd->ofd_flags_lock);
545 LPROC_SEQ_FOPS(ofd_brw_size);
547 static char *sync_on_cancel_states[] = {"never",
552 * Show OFD policy for handling dirty data under a lock being cancelled.
554 * \param[in] m seq_file handle
555 * \param[in] data unused for single entry
557 * \retval 0 on success
558 * \retval negative value on error
560 static int ofd_sync_lock_cancel_seq_show(struct seq_file *m, void *data)
562 struct obd_device *obd = m->private;
563 struct lu_target *tgt = obd->u.obt.obt_lut;
565 seq_printf(m, "%s\n",
566 sync_on_cancel_states[tgt->lut_sync_lock_cancel]);
571 * Change OFD policy for handling dirty data under a lock being cancelled.
573 * This variable defines what action OFD takes upon lock cancel
574 * There are three possible modes:
575 * 1) never - never do sync upon lock cancel. This can lead to data
576 * inconsistencies if both the OST and client crash while writing a file
577 * that is also concurrently being read by another client. In these cases,
578 * this may allow the file data to "rewind" to an earlier state.
579 * 2) blocking - do sync only if there is blocking lock, e.g. if another
580 * client is trying to access this same object
581 * 3) always - do sync always
583 * \param[in] file proc file
584 * \param[in] buffer string which represents policy
585 * \param[in] count \a buffer length
586 * \param[in] off unused for single entry
588 * \retval \a count on success
589 * \retval negative number on error
592 ofd_sync_lock_cancel_seq_write(struct file *file, const char __user *buffer,
593 size_t count, loff_t *off)
595 struct seq_file *m = file->private_data;
596 struct obd_device *obd = m->private;
597 struct lu_target *tgt = obd->u.obt.obt_lut;
598 char kernbuf[SYNC_STATES_MAXLEN];
602 if (count == 0 || count >= sizeof(kernbuf))
605 if (copy_from_user(kernbuf, buffer, count))
609 if (kernbuf[count - 1] == '\n')
610 kernbuf[count - 1] = 0;
612 for (i = 0 ; i < NUM_SYNC_ON_CANCEL_STATES; i++) {
613 if (strcmp(kernbuf, sync_on_cancel_states[i]) == 0) {
619 /* Legacy numeric codes */
621 int rc = lprocfs_str_to_s64(buffer, count, &val);
626 if (val < 0 || val > 2)
629 spin_lock(&tgt->lut_flags_lock);
630 tgt->lut_sync_lock_cancel = val;
631 spin_unlock(&tgt->lut_flags_lock);
634 LPROC_SEQ_FOPS(ofd_sync_lock_cancel);
637 * Show if grants compatibility mode is disabled.
639 * When tgd_grant_compat_disable is set, we don't grant any space to clients
640 * not supporting OBD_CONNECT_GRANT_PARAM. Otherwise, space granted to such
641 * a client is inflated since it consumes PAGE_SIZE of grant space per
642 * block, (i.e. typically 4kB units), but underlaying file system might have
643 * block size bigger than page size, e.g. ZFS. See LU-2049 for details.
645 * \param[in] m seq_file handle
646 * \param[in] data unused for single entry
648 * \retval 0 on success
649 * \retval negative value on error
651 static int ofd_grant_compat_disable_seq_show(struct seq_file *m, void *data)
653 struct obd_device *obd = m->private;
654 struct tg_grants_data *tgd = &obd->u.obt.obt_lut->lut_tgd;
656 seq_printf(m, "%u\n", tgd->tgd_grant_compat_disable);
661 * Change grant compatibility mode.
663 * Setting tgd_grant_compat_disable prohibit any space granting to clients
664 * not supporting OBD_CONNECT_GRANT_PARAM. See details above.
666 * \param[in] file proc file
667 * \param[in] buffer string which represents mode
668 * 1: disable compatibility mode
669 * 0: enable compatibility mode
670 * \param[in] count \a buffer length
671 * \param[in] off unused for single entry
673 * \retval \a count on success
674 * \retval negative number on error
677 ofd_grant_compat_disable_seq_write(struct file *file,
678 const char __user *buffer,
679 size_t count, loff_t *off)
681 struct seq_file *m = file->private_data;
682 struct obd_device *obd = m->private;
683 struct tg_grants_data *tgd = &obd->u.obt.obt_lut->lut_tgd;
687 rc = lprocfs_str_to_s64(buffer, count, &val);
694 tgd->tgd_grant_compat_disable = !!val;
698 LPROC_SEQ_FOPS(ofd_grant_compat_disable);
701 * Show the limit of soft sync RPCs.
703 * This value defines how many IO RPCs with OBD_BRW_SOFT_SYNC flag
704 * are allowed before sync update will be triggered.
706 * \param[in] m seq_file handle
707 * \param[in] data unused for single entry
709 * \retval 0 on success
710 * \retval negative value on error
712 static int ofd_soft_sync_limit_seq_show(struct seq_file *m, void *data)
714 struct obd_device *obd = m->private;
715 struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
717 return lprocfs_uint_seq_show(m, &ofd->ofd_soft_sync_limit);
721 * Change the limit of soft sync RPCs.
723 * Define how many IO RPCs with OBD_BRW_SOFT_SYNC flag
724 * allowed before sync update will be done.
726 * This limit is global across all exports.
728 * \param[in] file proc file
729 * \param[in] buffer string which represents limit
730 * \param[in] count \a buffer length
731 * \param[in] off unused for single entry
733 * \retval \a count on success
734 * \retval negative number on error
737 ofd_soft_sync_limit_seq_write(struct file *file, const char __user *buffer,
738 size_t count, loff_t *off)
740 struct seq_file *m = file->private_data;
741 struct obd_device *obd = m->private;
742 struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
744 return lprocfs_uint_seq_write(file, buffer, count,
745 (loff_t *) &ofd->ofd_soft_sync_limit);
747 LPROC_SEQ_FOPS(ofd_soft_sync_limit);
750 * Show the LFSCK speed limit.
752 * The maximum number of items scanned per second.
754 * \param[in] m seq_file handle
755 * \param[in] data unused for single entry
757 * \retval 0 on success
758 * \retval negative value on error
760 static int ofd_lfsck_speed_limit_seq_show(struct seq_file *m, void *data)
762 struct obd_device *obd = m->private;
763 struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
765 return lfsck_get_speed(m, ofd->ofd_osd);
769 * Change the LFSCK speed limit.
771 * Limit number of items that may be scanned per second.
773 * \param[in] file proc file
774 * \param[in] buffer string which represents limit
775 * \param[in] count \a buffer length
776 * \param[in] off unused for single entry
778 * \retval \a count on success
779 * \retval negative number on error
782 ofd_lfsck_speed_limit_seq_write(struct file *file, const char __user *buffer,
783 size_t count, loff_t *off)
785 struct seq_file *m = file->private_data;
786 struct obd_device *obd = m->private;
787 struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
791 rc = lprocfs_str_to_s64(buffer, count, &val);
798 rc = lfsck_set_speed(ofd->ofd_osd, val);
800 return rc != 0 ? rc : count;
802 LPROC_SEQ_FOPS(ofd_lfsck_speed_limit);
805 * Show LFSCK layout verification stats from the most recent LFSCK run.
807 * \param[in] m seq_file handle
808 * \param[in] data unused for single entry
810 * \retval 0 on success
811 * \retval negative value on error
813 static int ofd_lfsck_layout_seq_show(struct seq_file *m, void *data)
815 struct obd_device *obd = m->private;
816 struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
818 return lfsck_dump(m, ofd->ofd_osd, LFSCK_TYPE_LAYOUT);
820 LPROC_SEQ_FOPS_RO(ofd_lfsck_layout);
823 * Show if LFSCK performed parent FID verification.
825 * \param[in] m seq_file handle
826 * \param[in] data unused for single entry
828 * \retval 0 on success
829 * \retval negative value on error
831 static int ofd_lfsck_verify_pfid_seq_show(struct seq_file *m, void *data)
833 struct obd_device *obd = m->private;
834 struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
836 seq_printf(m, "switch: %s\ndetected: %llu\nrepaired: %llu\n",
837 ofd->ofd_lfsck_verify_pfid ? "on" : "off",
838 ofd->ofd_inconsistency_self_detected,
839 ofd->ofd_inconsistency_self_repaired);
844 * Set the LFSCK behavior to verify parent FID correctness.
846 * If flag ofd_lfsck_verify_pfid is set then LFSCK does parent FID
847 * verification during read/write operations.
849 * \param[in] file proc file
850 * \param[in] buffer string which represents behavior
851 * 1: verify parent FID
852 * 0: don't verify parent FID
853 * \param[in] count \a buffer length
854 * \param[in] off unused for single entry
856 * \retval \a count on success
857 * \retval negative number on error
860 ofd_lfsck_verify_pfid_seq_write(struct file *file, const char __user *buffer,
861 size_t count, loff_t *off)
863 struct seq_file *m = file->private_data;
864 struct obd_device *obd = m->private;
865 struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
869 rc = lprocfs_str_to_s64(buffer, count, &val);
873 ofd->ofd_lfsck_verify_pfid = !!val;
874 if (!ofd->ofd_lfsck_verify_pfid) {
875 ofd->ofd_inconsistency_self_detected = 0;
876 ofd->ofd_inconsistency_self_repaired = 0;
881 LPROC_SEQ_FOPS(ofd_lfsck_verify_pfid);
883 static int ofd_site_stats_seq_show(struct seq_file *m, void *data)
885 struct obd_device *obd = m->private;
887 return lu_site_stats_seq_print(obd->obd_lu_dev->ld_site, m);
889 LPROC_SEQ_FOPS_RO(ofd_site_stats);
891 LPROC_SEQ_FOPS_RO_TYPE(ofd, uuid);
892 LPROC_SEQ_FOPS_RO_TYPE(ofd, blksize);
893 LPROC_SEQ_FOPS_RO_TYPE(ofd, kbytestotal);
894 LPROC_SEQ_FOPS_RO_TYPE(ofd, kbytesfree);
895 LPROC_SEQ_FOPS_RO_TYPE(ofd, kbytesavail);
896 LPROC_SEQ_FOPS_RO_TYPE(ofd, filestotal);
897 LPROC_SEQ_FOPS_RO_TYPE(ofd, filesfree);
899 LPROC_SEQ_FOPS_RO_TYPE(ofd, recovery_status);
900 LPROC_SEQ_FOPS_RW_TYPE(ofd, recovery_time_soft);
901 LPROC_SEQ_FOPS_RW_TYPE(ofd, recovery_time_hard);
902 LPROC_SEQ_FOPS_WO_TYPE(ofd, evict_client);
903 LPROC_SEQ_FOPS_RO_TYPE(ofd, num_exports);
904 LPROC_SEQ_FOPS_RO_TYPE(ofd, target_instance);
905 LPROC_SEQ_FOPS_RW_TYPE(ofd, ir_factor);
906 LPROC_SEQ_FOPS_RW_TYPE(ofd, checksum_dump);
907 LPROC_SEQ_FOPS_RW_TYPE(ofd, job_interval);
909 struct lprocfs_vars lprocfs_ofd_obd_vars[] = {
911 .fops = &ofd_uuid_fops },
912 { .name = "blocksize",
913 .fops = &ofd_blksize_fops },
914 { .name = "kbytestotal",
915 .fops = &ofd_kbytestotal_fops },
916 { .name = "kbytesfree",
917 .fops = &ofd_kbytesfree_fops },
918 { .name = "kbytesavail",
919 .fops = &ofd_kbytesavail_fops },
920 { .name = "filestotal",
921 .fops = &ofd_filestotal_fops },
922 { .name = "filesfree",
923 .fops = &ofd_filesfree_fops },
924 { .name = "seqs_allocated",
925 .fops = &ofd_seqs_fops },
927 .fops = &ofd_fstype_fops },
929 .fops = &ofd_last_id_fops },
930 { .name = "tot_dirty",
931 .fops = &ofd_tot_dirty_fops },
932 { .name = "tot_pending",
933 .fops = &ofd_tot_pending_fops },
934 { .name = "tot_granted",
935 .fops = &ofd_tot_granted_fops },
936 { .name = "grant_precreate",
937 .fops = &ofd_grant_precreate_fops },
938 { .name = "precreate_batch",
939 .fops = &ofd_precreate_batch_fops },
940 { .name = "recovery_status",
941 .fops = &ofd_recovery_status_fops },
942 { .name = "recovery_time_soft",
943 .fops = &ofd_recovery_time_soft_fops },
944 { .name = "recovery_time_hard",
945 .fops = &ofd_recovery_time_hard_fops },
946 { .name = "evict_client",
947 .fops = &ofd_evict_client_fops },
948 { .name = "num_exports",
949 .fops = &ofd_num_exports_fops },
950 { .name = "degraded",
951 .fops = &ofd_degraded_fops },
952 { .name = "sync_journal",
953 .fops = &ofd_syncjournal_fops },
954 { .name = "brw_size",
955 .fops = &ofd_brw_size_fops },
956 { .name = "sync_on_lock_cancel",
957 .fops = &ofd_sync_lock_cancel_fops },
958 { .name = "instance",
959 .fops = &ofd_target_instance_fops },
960 { .name = "ir_factor",
961 .fops = &ofd_ir_factor_fops },
962 { .name = "checksum_dump",
963 .fops = &ofd_checksum_dump_fops },
964 { .name = "grant_compat_disable",
965 .fops = &ofd_grant_compat_disable_fops },
966 { .name = "client_cache_count",
967 .fops = &ofd_fmd_max_num_fops },
968 { .name = "client_cache_seconds",
969 .fops = &ofd_fmd_max_age_fops },
970 { .name = "job_cleanup_interval",
971 .fops = &ofd_job_interval_fops },
972 { .name = "soft_sync_limit",
973 .fops = &ofd_soft_sync_limit_fops },
974 { .name = "lfsck_speed_limit",
975 .fops = &ofd_lfsck_speed_limit_fops },
976 { .name = "lfsck_layout",
977 .fops = &ofd_lfsck_layout_fops },
978 { .name = "lfsck_verify_pfid",
979 .fops = &ofd_lfsck_verify_pfid_fops },
980 { .name = "site_stats",
981 .fops = &ofd_site_stats_fops },
986 * Initialize OFD statistics counters
988 * param[in] stats statistics counters
990 void ofd_stats_counter_init(struct lprocfs_stats *stats)
992 LASSERT(stats && stats->ls_num >= LPROC_OFD_STATS_LAST);
994 lprocfs_counter_init(stats, LPROC_OFD_STATS_READ,
995 LPROCFS_CNTR_AVGMINMAX, "read_bytes", "bytes");
996 lprocfs_counter_init(stats, LPROC_OFD_STATS_WRITE,
997 LPROCFS_CNTR_AVGMINMAX, "write_bytes", "bytes");
998 lprocfs_counter_init(stats, LPROC_OFD_STATS_GETATTR,
999 0, "getattr", "reqs");
1000 lprocfs_counter_init(stats, LPROC_OFD_STATS_SETATTR,
1001 0, "setattr", "reqs");
1002 lprocfs_counter_init(stats, LPROC_OFD_STATS_PUNCH,
1003 0, "punch", "reqs");
1004 lprocfs_counter_init(stats, LPROC_OFD_STATS_SYNC,
1006 lprocfs_counter_init(stats, LPROC_OFD_STATS_DESTROY,
1007 0, "destroy", "reqs");
1008 lprocfs_counter_init(stats, LPROC_OFD_STATS_CREATE,
1009 0, "create", "reqs");
1010 lprocfs_counter_init(stats, LPROC_OFD_STATS_STATFS,
1011 0, "statfs", "reqs");
1012 lprocfs_counter_init(stats, LPROC_OFD_STATS_GET_INFO,
1013 0, "get_info", "reqs");
1014 lprocfs_counter_init(stats, LPROC_OFD_STATS_SET_INFO,
1015 0, "set_info", "reqs");
1016 lprocfs_counter_init(stats, LPROC_OFD_STATS_QUOTACTL,
1017 0, "quotactl", "reqs");
1020 #endif /* CONFIG_PROC_FS */