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 ofd_device *ofd;
87 ofd = ofd_dev(obd->obd_lu_dev);
88 seq_printf(m, "%llu\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, "%llu\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, "%llu\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_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_to_s64(buffer, count, &val);
535 val = val * ONE_MB_BRW_SIZE;
536 if (val <= 0 || val > DT_MAX_BRW_SIZE ||
537 val < (1 << ofd->ofd_blockbits))
540 spin_lock(&ofd->ofd_flags_lock);
541 ofd->ofd_brw_size = val;
542 spin_unlock(&ofd->ofd_flags_lock);
546 LPROC_SEQ_FOPS(ofd_brw_size);
548 static char *sync_on_cancel_states[] = {"never",
553 * Show OFD policy for handling dirty data under a lock being cancelled.
555 * \param[in] m seq_file handle
556 * \param[in] data unused for single entry
558 * \retval 0 on success
559 * \retval negative value on error
561 static int ofd_sync_lock_cancel_seq_show(struct seq_file *m, void *data)
563 struct obd_device *obd = m->private;
564 struct lu_target *tgt = obd->u.obt.obt_lut;
566 seq_printf(m, "%s\n",
567 sync_on_cancel_states[tgt->lut_sync_lock_cancel]);
572 * Change OFD policy for handling dirty data under a lock being cancelled.
574 * This variable defines what action OFD takes upon lock cancel
575 * There are three possible modes:
576 * 1) never - never do sync upon lock cancel. This can lead to data
577 * inconsistencies if both the OST and client crash while writing a file
578 * that is also concurrently being read by another client. In these cases,
579 * this may allow the file data to "rewind" to an earlier state.
580 * 2) blocking - do sync only if there is blocking lock, e.g. if another
581 * client is trying to access this same object
582 * 3) always - do sync always
584 * \param[in] file proc file
585 * \param[in] buffer string which represents policy
586 * \param[in] count \a buffer length
587 * \param[in] off unused for single entry
589 * \retval \a count on success
590 * \retval negative number on error
593 ofd_sync_lock_cancel_seq_write(struct file *file, const char __user *buffer,
594 size_t count, loff_t *off)
596 struct seq_file *m = file->private_data;
597 struct obd_device *obd = m->private;
598 struct lu_target *tgt = obd->u.obt.obt_lut;
599 char kernbuf[SYNC_STATES_MAXLEN];
603 if (count == 0 || count >= sizeof(kernbuf))
606 if (copy_from_user(kernbuf, buffer, count))
610 if (kernbuf[count - 1] == '\n')
611 kernbuf[count - 1] = 0;
613 for (i = 0 ; i < NUM_SYNC_ON_CANCEL_STATES; i++) {
614 if (strcmp(kernbuf, sync_on_cancel_states[i]) == 0) {
620 /* Legacy numeric codes */
622 int rc = lprocfs_str_to_s64(buffer, count, &val);
627 if (val < 0 || val > 2)
630 spin_lock(&tgt->lut_flags_lock);
631 tgt->lut_sync_lock_cancel = val;
632 spin_unlock(&tgt->lut_flags_lock);
635 LPROC_SEQ_FOPS(ofd_sync_lock_cancel);
638 * Show if grants compatibility mode is disabled.
640 * When ofd_grant_compat_disable is set, we don't grant any space to clients
641 * not supporting OBD_CONNECT_GRANT_PARAM. Otherwise, space granted to such
642 * a client is inflated since it consumes PAGE_SIZE of grant space per
643 * block, (i.e. typically 4kB units), but underlaying file system might have
644 * block size bigger than page size, e.g. ZFS. See LU-2049 for details.
646 * \param[in] m seq_file handle
647 * \param[in] data unused for single entry
649 * \retval 0 on success
650 * \retval negative value on error
652 static int ofd_grant_compat_disable_seq_show(struct seq_file *m, void *data)
654 struct obd_device *obd = m->private;
655 struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
657 seq_printf(m, "%u\n", ofd->ofd_grant_compat_disable);
662 * Change grant compatibility mode.
664 * Setting ofd_grant_compat_disable prohibit any space granting to clients
665 * not supporting OBD_CONNECT_GRANT_PARAM. See details above.
667 * \param[in] file proc file
668 * \param[in] buffer string which represents mode
669 * 1: disable compatibility mode
670 * 0: enable compatibility mode
671 * \param[in] count \a buffer length
672 * \param[in] off unused for single entry
674 * \retval \a count on success
675 * \retval negative number on error
678 ofd_grant_compat_disable_seq_write(struct file *file,
679 const char __user *buffer,
680 size_t count, loff_t *off)
682 struct seq_file *m = file->private_data;
683 struct obd_device *obd = m->private;
684 struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
688 rc = lprocfs_str_to_s64(buffer, count, &val);
695 spin_lock(&ofd->ofd_flags_lock);
696 ofd->ofd_grant_compat_disable = !!val;
697 spin_unlock(&ofd->ofd_flags_lock);
701 LPROC_SEQ_FOPS(ofd_grant_compat_disable);
704 * Show the limit of soft sync RPCs.
706 * This value defines how many IO RPCs with OBD_BRW_SOFT_SYNC flag
707 * are allowed before sync update will be triggered.
709 * \param[in] m seq_file handle
710 * \param[in] data unused for single entry
712 * \retval 0 on success
713 * \retval negative value on error
715 static int ofd_soft_sync_limit_seq_show(struct seq_file *m, void *data)
717 struct obd_device *obd = m->private;
718 struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
720 return lprocfs_uint_seq_show(m, &ofd->ofd_soft_sync_limit);
724 * Change the limit of soft sync RPCs.
726 * Define how many IO RPCs with OBD_BRW_SOFT_SYNC flag
727 * allowed before sync update will be done.
729 * This limit is global across all exports.
731 * \param[in] file proc file
732 * \param[in] buffer string which represents limit
733 * \param[in] count \a buffer length
734 * \param[in] off unused for single entry
736 * \retval \a count on success
737 * \retval negative number on error
740 ofd_soft_sync_limit_seq_write(struct file *file, const char __user *buffer,
741 size_t count, loff_t *off)
743 struct seq_file *m = file->private_data;
744 struct obd_device *obd = m->private;
745 struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
747 return lprocfs_uint_seq_write(file, buffer, count,
748 (loff_t *) &ofd->ofd_soft_sync_limit);
750 LPROC_SEQ_FOPS(ofd_soft_sync_limit);
753 * Show the LFSCK speed limit.
755 * The maximum number of items scanned per second.
757 * \param[in] m seq_file handle
758 * \param[in] data unused for single entry
760 * \retval 0 on success
761 * \retval negative value on error
763 static int ofd_lfsck_speed_limit_seq_show(struct seq_file *m, void *data)
765 struct obd_device *obd = m->private;
766 struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
768 return lfsck_get_speed(m, ofd->ofd_osd);
772 * Change the LFSCK speed limit.
774 * Limit number of items that may be scanned per second.
776 * \param[in] file proc file
777 * \param[in] buffer string which represents limit
778 * \param[in] count \a buffer length
779 * \param[in] off unused for single entry
781 * \retval \a count on success
782 * \retval negative number on error
785 ofd_lfsck_speed_limit_seq_write(struct file *file, const char __user *buffer,
786 size_t count, loff_t *off)
788 struct seq_file *m = file->private_data;
789 struct obd_device *obd = m->private;
790 struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
794 rc = lprocfs_str_to_s64(buffer, count, &val);
801 rc = lfsck_set_speed(ofd->ofd_osd, val);
803 return rc != 0 ? rc : count;
805 LPROC_SEQ_FOPS(ofd_lfsck_speed_limit);
808 * Show LFSCK layout verification stats from the most recent LFSCK run.
810 * \param[in] m seq_file handle
811 * \param[in] data unused for single entry
813 * \retval 0 on success
814 * \retval negative value on error
816 static int ofd_lfsck_layout_seq_show(struct seq_file *m, void *data)
818 struct obd_device *obd = m->private;
819 struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
821 return lfsck_dump(m, ofd->ofd_osd, LFSCK_TYPE_LAYOUT);
823 LPROC_SEQ_FOPS_RO(ofd_lfsck_layout);
826 * Show if LFSCK performed parent FID verification.
828 * \param[in] m seq_file handle
829 * \param[in] data unused for single entry
831 * \retval 0 on success
832 * \retval negative value on error
834 static int ofd_lfsck_verify_pfid_seq_show(struct seq_file *m, void *data)
836 struct obd_device *obd = m->private;
837 struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
839 seq_printf(m, "switch: %s\ndetected: %llu\nrepaired: %llu\n",
840 ofd->ofd_lfsck_verify_pfid ? "on" : "off",
841 ofd->ofd_inconsistency_self_detected,
842 ofd->ofd_inconsistency_self_repaired);
847 * Set the LFSCK behavior to verify parent FID correctness.
849 * If flag ofd_lfsck_verify_pfid is set then LFSCK does parent FID
850 * verification during read/write operations.
852 * \param[in] file proc file
853 * \param[in] buffer string which represents behavior
854 * 1: verify parent FID
855 * 0: don't verify parent FID
856 * \param[in] count \a buffer length
857 * \param[in] off unused for single entry
859 * \retval \a count on success
860 * \retval negative number on error
863 ofd_lfsck_verify_pfid_seq_write(struct file *file, const char __user *buffer,
864 size_t count, loff_t *off)
866 struct seq_file *m = file->private_data;
867 struct obd_device *obd = m->private;
868 struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
872 rc = lprocfs_str_to_s64(buffer, count, &val);
876 ofd->ofd_lfsck_verify_pfid = !!val;
880 LPROC_SEQ_FOPS(ofd_lfsck_verify_pfid);
882 static int ofd_site_stats_seq_show(struct seq_file *m, void *data)
884 struct obd_device *obd = m->private;
886 return lu_site_stats_seq_print(obd->obd_lu_dev->ld_site, m);
888 LPROC_SEQ_FOPS_RO(ofd_site_stats);
890 LPROC_SEQ_FOPS_RO_TYPE(ofd, uuid);
891 LPROC_SEQ_FOPS_RO_TYPE(ofd, blksize);
892 LPROC_SEQ_FOPS_RO_TYPE(ofd, kbytestotal);
893 LPROC_SEQ_FOPS_RO_TYPE(ofd, kbytesfree);
894 LPROC_SEQ_FOPS_RO_TYPE(ofd, kbytesavail);
895 LPROC_SEQ_FOPS_RO_TYPE(ofd, filestotal);
896 LPROC_SEQ_FOPS_RO_TYPE(ofd, filesfree);
898 LPROC_SEQ_FOPS_RO_TYPE(ofd, recovery_status);
899 LPROC_SEQ_FOPS_RW_TYPE(ofd, recovery_time_soft);
900 LPROC_SEQ_FOPS_RW_TYPE(ofd, recovery_time_hard);
901 LPROC_SEQ_FOPS_WO_TYPE(ofd, evict_client);
902 LPROC_SEQ_FOPS_RO_TYPE(ofd, num_exports);
903 LPROC_SEQ_FOPS_RO_TYPE(ofd, target_instance);
904 LPROC_SEQ_FOPS_RW_TYPE(ofd, ir_factor);
905 LPROC_SEQ_FOPS_RW_TYPE(ofd, job_interval);
907 struct lprocfs_vars lprocfs_ofd_obd_vars[] = {
909 .fops = &ofd_uuid_fops },
910 { .name = "blocksize",
911 .fops = &ofd_blksize_fops },
912 { .name = "kbytestotal",
913 .fops = &ofd_kbytestotal_fops },
914 { .name = "kbytesfree",
915 .fops = &ofd_kbytesfree_fops },
916 { .name = "kbytesavail",
917 .fops = &ofd_kbytesavail_fops },
918 { .name = "filestotal",
919 .fops = &ofd_filestotal_fops },
920 { .name = "filesfree",
921 .fops = &ofd_filesfree_fops },
922 { .name = "seqs_allocated",
923 .fops = &ofd_seqs_fops },
925 .fops = &ofd_fstype_fops },
927 .fops = &ofd_last_id_fops },
928 { .name = "tot_dirty",
929 .fops = &ofd_tot_dirty_fops },
930 { .name = "tot_pending",
931 .fops = &ofd_tot_pending_fops },
932 { .name = "tot_granted",
933 .fops = &ofd_tot_granted_fops },
934 { .name = "grant_precreate",
935 .fops = &ofd_grant_precreate_fops },
936 { .name = "precreate_batch",
937 .fops = &ofd_precreate_batch_fops },
938 { .name = "recovery_status",
939 .fops = &ofd_recovery_status_fops },
940 { .name = "recovery_time_soft",
941 .fops = &ofd_recovery_time_soft_fops },
942 { .name = "recovery_time_hard",
943 .fops = &ofd_recovery_time_hard_fops },
944 { .name = "evict_client",
945 .fops = &ofd_evict_client_fops },
946 { .name = "num_exports",
947 .fops = &ofd_num_exports_fops },
948 { .name = "degraded",
949 .fops = &ofd_degraded_fops },
950 { .name = "sync_journal",
951 .fops = &ofd_syncjournal_fops },
952 { .name = "brw_size",
953 .fops = &ofd_brw_size_fops },
954 { .name = "sync_on_lock_cancel",
955 .fops = &ofd_sync_lock_cancel_fops },
956 { .name = "instance",
957 .fops = &ofd_target_instance_fops },
958 { .name = "ir_factor",
959 .fops = &ofd_ir_factor_fops },
960 { .name = "grant_compat_disable",
961 .fops = &ofd_grant_compat_disable_fops },
962 { .name = "client_cache_count",
963 .fops = &ofd_fmd_max_num_fops },
964 { .name = "client_cache_seconds",
965 .fops = &ofd_fmd_max_age_fops },
966 { .name = "job_cleanup_interval",
967 .fops = &ofd_job_interval_fops },
968 { .name = "soft_sync_limit",
969 .fops = &ofd_soft_sync_limit_fops },
970 { .name = "lfsck_speed_limit",
971 .fops = &ofd_lfsck_speed_limit_fops },
972 { .name = "lfsck_layout",
973 .fops = &ofd_lfsck_layout_fops },
974 { .name = "lfsck_verify_pfid",
975 .fops = &ofd_lfsck_verify_pfid_fops },
976 { .name = "site_stats",
977 .fops = &ofd_site_stats_fops },
982 * Initialize OFD statistics counters
984 * param[in] stats statistics counters
986 void ofd_stats_counter_init(struct lprocfs_stats *stats)
988 LASSERT(stats && stats->ls_num >= LPROC_OFD_STATS_LAST);
990 lprocfs_counter_init(stats, LPROC_OFD_STATS_READ,
991 LPROCFS_CNTR_AVGMINMAX, "read_bytes", "bytes");
992 lprocfs_counter_init(stats, LPROC_OFD_STATS_WRITE,
993 LPROCFS_CNTR_AVGMINMAX, "write_bytes", "bytes");
994 lprocfs_counter_init(stats, LPROC_OFD_STATS_GETATTR,
995 0, "getattr", "reqs");
996 lprocfs_counter_init(stats, LPROC_OFD_STATS_SETATTR,
997 0, "setattr", "reqs");
998 lprocfs_counter_init(stats, LPROC_OFD_STATS_PUNCH,
1000 lprocfs_counter_init(stats, LPROC_OFD_STATS_SYNC,
1002 lprocfs_counter_init(stats, LPROC_OFD_STATS_DESTROY,
1003 0, "destroy", "reqs");
1004 lprocfs_counter_init(stats, LPROC_OFD_STATS_CREATE,
1005 0, "create", "reqs");
1006 lprocfs_counter_init(stats, LPROC_OFD_STATS_STATFS,
1007 0, "statfs", "reqs");
1008 lprocfs_counter_init(stats, LPROC_OFD_STATS_GET_INFO,
1009 0, "get_info", "reqs");
1010 lprocfs_counter_init(stats, LPROC_OFD_STATS_SET_INFO,
1011 0, "set_info", "reqs");
1012 lprocfs_counter_init(stats, LPROC_OFD_STATS_QUOTACTL,
1013 0, "quotactl", "reqs");
1016 #endif /* CONFIG_PROC_FS */