4 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 only,
8 * as published by the Free Software Foundation.
10 * This program is distributed in the hope that it will be useful, but
11 * WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * General Public License version 2 for more details (a copy is included
14 * in the LICENSE file that accompanied this code).
16 * You should have received a copy of the GNU General Public License
17 * version 2 along with this program; If not, see
18 * http://www.gnu.org/licenses/gpl-2.0.html
23 * Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved.
24 * Use is subject to license terms.
26 * Copyright (c) 2012, 2014 Intel Corporation.
29 * This file is part of Lustre, http://www.lustre.org/
30 * Lustre is a trademark of Sun Microsystems, Inc.
32 * lustre/ofd/lproc_ofd.c
34 * This file provides functions of procfs interface for OBD Filter Device (OFD).
36 * Author: Andreas Dilger <andreas.dilger@intel.com>
37 * Author: Mikhail Pershin <mike.pershin@intel.com>
38 * Author: Johann Lombardi <johann.lombardi@intel.com>
39 * Author: Fan Yong <fan.yong@intel.com>
42 #define DEBUG_SUBSYSTEM S_CLASS
45 #include <lprocfs_status.h>
46 #include <linux/seq_file.h>
47 #include <lustre_lfsck.h>
49 #include "ofd_internal.h"
54 * Show number of FID allocation sequences.
56 * \param[in] m seq_file handle
57 * \param[in] data unused for single entry
59 * \retval 0 on success
60 * \retval negative value on error
62 static int ofd_seqs_seq_show(struct seq_file *m, void *data)
64 struct obd_device *obd = m->private;
65 struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
67 return seq_printf(m, "%u\n", ofd->ofd_seq_count);
69 LPROC_SEQ_FOPS_RO(ofd_seqs);
72 * Show estimate of total amount of dirty data on clients.
74 * \param[in] m seq_file handle
75 * \param[in] data unused for single entry
77 * \retval 0 on success
78 * \retval negative value on error
80 static int ofd_tot_dirty_seq_show(struct seq_file *m, void *data)
82 struct obd_device *obd = m->private;
83 struct ofd_device *ofd;
86 ofd = ofd_dev(obd->obd_lu_dev);
87 return seq_printf(m, LPU64"\n", ofd->ofd_tot_dirty);
89 LPROC_SEQ_FOPS_RO(ofd_tot_dirty);
92 * Show total amount of space granted to clients.
94 * \param[in] m seq_file handle
95 * \param[in] data unused for single entry
97 * \retval 0 on success
98 * \retval negative value on error
100 static int ofd_tot_granted_seq_show(struct seq_file *m, void *data)
102 struct obd_device *obd = m->private;
103 struct ofd_device *ofd;
105 LASSERT(obd != NULL);
106 ofd = ofd_dev(obd->obd_lu_dev);
107 return seq_printf(m, LPU64"\n", ofd->ofd_tot_granted);
109 LPROC_SEQ_FOPS_RO(ofd_tot_granted);
112 * Show total amount of space used by IO in progress.
114 * \param[in] m seq_file handle
115 * \param[in] data unused for single entry
117 * \retval 0 on success
118 * \retval negative value on error
120 static int ofd_tot_pending_seq_show(struct seq_file *m, void *data)
122 struct obd_device *obd = m->private;
123 struct ofd_device *ofd;
125 LASSERT(obd != NULL);
126 ofd = ofd_dev(obd->obd_lu_dev);
127 return seq_printf(m, LPU64"\n", ofd->ofd_tot_pending);
129 LPROC_SEQ_FOPS_RO(ofd_tot_pending);
132 * Show total number of grants for precreate.
134 * \param[in] m seq_file handle
135 * \param[in] data unused for single entry
137 * \retval 0 on success
138 * \retval negative value on error
140 static int ofd_grant_precreate_seq_show(struct seq_file *m, void *data)
142 struct obd_device *obd = m->private;
144 LASSERT(obd != NULL);
145 return seq_printf(m, "%ld\n",
146 obd->obd_self_export->exp_filter_data.fed_grant);
148 LPROC_SEQ_FOPS_RO(ofd_grant_precreate);
151 * Show total amount of free space reserved for grants.
153 * \param[in] m seq_file handle
154 * \param[in] data unused for single entry
156 * \retval 0 on success
157 * \retval negative value on error
159 static int ofd_grant_ratio_seq_show(struct seq_file *m, void *data)
161 struct obd_device *obd = m->private;
162 struct ofd_device *ofd;
164 LASSERT(obd != NULL);
165 ofd = ofd_dev(obd->obd_lu_dev);
166 return seq_printf(m, "%d%%\n",
167 (int) ofd_grant_reserved(ofd, 100));
171 * Change amount of free space reserved for grants.
173 * \param[in] file proc file
174 * \param[in] buffer string which represents maximum number
175 * \param[in] count \a buffer length
176 * \param[in] off unused for single entry
178 * \retval \a count on success
179 * \retval negative number on error
182 ofd_grant_ratio_seq_write(struct file *file, const char __user *buffer,
183 size_t count, loff_t *off)
185 struct seq_file *m = file->private_data;
186 struct obd_device *obd = m->private;
187 struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
191 rc = lprocfs_write_helper(buffer, count, &val);
195 if (val > 100 || val < 0)
199 CWARN("%s: disabling grant error margin\n", obd->obd_name);
201 CWARN("%s: setting grant error margin >50%%, be warned that "
202 "a huge part of the free space is now reserved for "
203 "grants\n", obd->obd_name);
205 spin_lock(&ofd->ofd_grant_lock);
206 ofd->ofd_grant_ratio = ofd_grant_ratio_conv(val);
207 spin_unlock(&ofd->ofd_grant_lock);
210 LPROC_SEQ_FOPS(ofd_grant_ratio);
213 * Show number of precreates allowed in a single transaction.
215 * \param[in] m seq_file handle
216 * \param[in] data unused for single entry
218 * \retval 0 on success
219 * \retval negative value on error
221 static int ofd_precreate_batch_seq_show(struct seq_file *m, void *data)
223 struct obd_device *obd = m->private;
224 struct ofd_device *ofd;
226 LASSERT(obd != NULL);
227 ofd = ofd_dev(obd->obd_lu_dev);
228 return seq_printf(m, "%d\n", ofd->ofd_precreate_batch);
232 * Change number of precreates allowed in a single transaction.
234 * \param[in] file proc file
235 * \param[in] buffer string which represents maximum number
236 * \param[in] count \a buffer length
237 * \param[in] off unused for single entry
239 * \retval \a count on success
240 * \retval negative number on error
243 ofd_precreate_batch_seq_write(struct file *file, const char __user *buffer,
244 size_t count, loff_t *off)
246 struct seq_file *m = file->private_data;
247 struct obd_device *obd = m->private;
248 struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
252 rc = lprocfs_write_helper(buffer, count, &val);
259 spin_lock(&ofd->ofd_batch_lock);
260 ofd->ofd_precreate_batch = val;
261 spin_unlock(&ofd->ofd_batch_lock);
264 LPROC_SEQ_FOPS(ofd_precreate_batch);
267 * Show the last used ID for each FID sequence used by OFD.
269 * \param[in] m seq_file handle
270 * \param[in] data unused for single entry
272 * \retval 0 on success
273 * \retval negative value on error
275 static int ofd_last_id_seq_show(struct seq_file *m, void *data)
277 struct obd_device *obd = m->private;
278 struct ofd_device *ofd;
279 struct ofd_seq *oseq = NULL;
285 ofd = ofd_dev(obd->obd_lu_dev);
287 read_lock(&ofd->ofd_seq_list_lock);
288 list_for_each_entry(oseq, &ofd->ofd_seq_list, os_list) {
291 seq = ostid_seq(&oseq->os_oi) == 0 ?
292 fid_idif_seq(ostid_id(&oseq->os_oi),
293 ofd->ofd_lut.lut_lsd.lsd_osd_index) :
294 ostid_seq(&oseq->os_oi);
295 rc = seq_printf(m, DOSTID"\n", seq, ostid_id(&oseq->os_oi));
302 read_unlock(&ofd->ofd_seq_list_lock);
305 LPROC_SEQ_FOPS_RO(ofd_last_id);
308 * Show maximum number of Filter Modification Data (FMD) maintained by OFD.
310 * \param[in] m seq_file handle
311 * \param[in] data unused for single entry
313 * \retval 0 on success
314 * \retval negative value on error
316 static int ofd_fmd_max_num_seq_show(struct seq_file *m, void *data)
318 struct obd_device *obd = m->private;
319 struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
321 return seq_printf(m, "%u\n", ofd->ofd_fmd_max_num);
325 * Change number of FMDs maintained by OFD.
327 * This defines how large the list of FMDs can be.
329 * \param[in] file proc file
330 * \param[in] buffer string which represents maximum number
331 * \param[in] count \a buffer length
332 * \param[in] off unused for single entry
334 * \retval \a count on success
335 * \retval negative number on error
338 ofd_fmd_max_num_seq_write(struct file *file, const char __user *buffer,
339 size_t count, loff_t *off)
341 struct seq_file *m = file->private_data;
342 struct obd_device *obd = m->private;
343 struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
347 rc = lprocfs_write_helper(buffer, count, &val);
351 if (val > 65536 || val < 1)
354 ofd->ofd_fmd_max_num = val;
357 LPROC_SEQ_FOPS(ofd_fmd_max_num);
360 * Show the maximum age of FMD data in seconds.
362 * Though it is shown in seconds, it is stored internally in units
363 * of jiffies for efficiency.
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_fmd_max_age_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 return seq_printf(m, "%ld\n", jiffies_to_msecs(ofd->ofd_fmd_max_age) /
381 * Set the maximum age of FMD data in seconds.
383 * This defines how long FMD data stays in the FMD list.
384 * It is stored internally in units of jiffies for efficiency.
386 * \param[in] file proc file
387 * \param[in] buffer string which represents maximum number
388 * \param[in] count \a buffer length
389 * \param[in] off unused for single entry
391 * \retval \a count on success
392 * \retval negative number on error
395 ofd_fmd_max_age_seq_write(struct file *file, const char __user *buffer,
396 size_t count, loff_t *off)
398 struct seq_file *m = file->private_data;
399 struct obd_device *obd = m->private;
400 struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
404 rc = lprocfs_write_helper(buffer, count, &val);
408 if (val > 65536 || val < 1)
411 ofd->ofd_fmd_max_age = msecs_to_jiffies(val * MSEC_PER_SEC);
414 LPROC_SEQ_FOPS(ofd_fmd_max_age);
417 * Show if OSS FID capability is enabled or disabled
419 * \param[in] m seq_file handle
420 * \param[in] data unused for single entry
422 * \retval 0 on success
423 * \retval negative value on error
425 static int ofd_capa_seq_show(struct seq_file *m, void *data)
427 struct obd_device *obd = m->private;
429 return seq_printf(m, "capability on: %s\n",
430 obd->u.filter.fo_fl_oss_capa ? "oss" : "");
434 * Enable or disable OSS FID capability mode.
436 * \param[in] file proc file
437 * \param[in] buffer string which represents mode
440 * \param[in] count \a buffer length
441 * \param[in] off unused for single entry
443 * \retval \a count on success
444 * \retval negative number on error
447 ofd_capa_seq_write(struct file *file, const char *__user buffer, size_t count,
450 struct seq_file *m = file->private_data;
451 struct obd_device *obd = m->private;
454 rc = lprocfs_write_helper(buffer, count, &val);
459 CERROR("invalid capability mode, only 0/1 are accepted.\n"
460 " 1: enable oss fid capability\n"
461 " 0: disable oss fid capability\n");
465 obd->u.filter.fo_fl_oss_capa = val;
466 LCONSOLE_INFO("OSS %s %s fid capability.\n", obd->obd_name,
467 val ? "enabled" : "disabled");
470 LPROC_SEQ_FOPS(ofd_capa);
473 * Show capability count on client and server side.
475 * \param[in] m seq_file handle
476 * \param[in] data unused for single entry
478 * \retval 0 on success
479 * \retval negative value on error
481 static int ofd_capa_count_seq_show(struct seq_file *m, void *data)
483 return seq_printf(m, "%d %d\n", capa_count[CAPA_SITE_CLIENT],
484 capa_count[CAPA_SITE_SERVER]);
486 LPROC_SEQ_FOPS_RO(ofd_capa_count);
489 * Show if the OFD is in degraded mode.
491 * Degraded means OFD has a failed drive or is undergoing RAID rebuild.
492 * The MDS will try to avoid using this OST for new object allocations
493 * to reduce the impact to global IO performance when clients writing to
494 * this OST are slowed down. It also reduces the contention on the OST
495 * RAID device, allowing it to rebuild more quickly.
497 * \param[in] m seq_file handle
498 * \param[in] data unused for single entry
500 * \retval 0 on success
501 * \retval negative value on error
503 static int ofd_degraded_seq_show(struct seq_file *m, void *data)
505 struct obd_device *obd = m->private;
506 struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
508 return seq_printf(m, "%u\n", ofd->ofd_raid_degraded);
512 * Set OFD to degraded mode.
514 * This is used to interface to userspace administrative tools for
515 * the underlying RAID storage, so that they can mark an OST
516 * as having degraded performance.
518 * \param[in] file proc file
519 * \param[in] buffer string which represents mode
520 * 1: set degraded mode
521 * 0: unset degraded mode
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_degraded_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 ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
537 rc = lprocfs_write_helper(buffer, count, &val);
541 spin_lock(&ofd->ofd_flags_lock);
542 ofd->ofd_raid_degraded = !!val;
543 spin_unlock(&ofd->ofd_flags_lock);
546 LPROC_SEQ_FOPS(ofd_degraded);
549 * Show OFD filesystem type.
551 * \param[in] m seq_file handle
552 * \param[in] data unused for single entry
554 * \retval 0 on success
555 * \retval negative value on error
557 static int ofd_fstype_seq_show(struct seq_file *m, void *data)
559 struct obd_device *obd = m->private;
560 struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
563 LASSERT(ofd->ofd_osd);
564 d = &ofd->ofd_osd->dd_lu_dev;
566 return seq_printf(m, "%s\n", d->ld_type->ldt_name);
568 LPROC_SEQ_FOPS_RO(ofd_fstype);
571 * Show journal handling mode: synchronous or asynchronous.
573 * When running in asynchronous mode the journal transactions are not
574 * committed to disk before the RPC is replied back to the client.
575 * This will typically improve client performance when only a small number
576 * of clients are writing, since the client(s) can have more write RPCs
577 * in flight. However, it also means that the client has to handle recovery
578 * on bulk RPCs, and will have to keep more dirty pages in cache before they
579 * are committed on the OST.
581 * \param[in] m seq_file handle
582 * \param[in] data unused for single entry
584 * \retval 0 on success
585 * \retval negative value on error
587 static int ofd_syncjournal_seq_show(struct seq_file *m, void *data)
589 struct obd_device *obd = m->private;
590 struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
592 return seq_printf(m, "%u\n", ofd->ofd_syncjournal);
596 * Set journal mode to synchronous or asynchronous.
598 * \param[in] file proc file
599 * \param[in] buffer string which represents mode
600 * 1: synchronous mode
601 * 0: asynchronous mode
602 * \param[in] count \a buffer length
603 * \param[in] off unused for single entry
605 * \retval \a count on success
606 * \retval negative number on error
609 ofd_syncjournal_seq_write(struct file *file, const char __user *buffer,
610 size_t count, loff_t *off)
612 struct seq_file *m = file->private_data;
613 struct obd_device *obd = m->private;
614 struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
618 rc = lprocfs_write_helper(buffer, count, &val);
625 spin_lock(&ofd->ofd_flags_lock);
626 ofd->ofd_syncjournal = !!val;
628 spin_unlock(&ofd->ofd_flags_lock);
632 LPROC_SEQ_FOPS(ofd_syncjournal);
634 /* This must be longer than the longest string below */
635 #define SYNC_STATES_MAXLEN 16
636 static char *sync_on_cancel_states[] = {"never",
641 * Show OFD policy for handling dirty data under a lock being cancelled.
643 * \param[in] m seq_file handle
644 * \param[in] data unused for single entry
646 * \retval 0 on success
647 * \retval negative value on error
649 static int ofd_sync_lock_cancel_seq_show(struct seq_file *m, void *data)
651 struct obd_device *obd = m->private;
652 struct lu_target *tgt = obd->u.obt.obt_lut;
654 return seq_printf(m, "%s\n",
655 sync_on_cancel_states[tgt->lut_sync_lock_cancel]);
659 * Change OFD policy for handling dirty data under a lock being cancelled.
661 * This variable defines what action OFD takes upon lock cancel
662 * There are three possible modes:
663 * 1) never - never do sync upon lock cancel. This can lead to data
664 * inconsistencies if both the OST and client crash while writing a file
665 * that is also concurrently being read by another client. In these cases,
666 * this may allow the file data to "rewind" to an earlier state.
667 * 2) blocking - do sync only if there is blocking lock, e.g. if another
668 * client is trying to access this same object
669 * 3) always - do sync always
671 * \param[in] file proc file
672 * \param[in] buffer string which represents policy
673 * \param[in] count \a buffer length
674 * \param[in] off unused for single entry
676 * \retval \a count on success
677 * \retval negative number on error
680 ofd_sync_lock_cancel_seq_write(struct file *file, const char __user *buffer,
681 size_t count, loff_t *off)
683 struct seq_file *m = file->private_data;
684 struct obd_device *obd = m->private;
685 struct lu_target *tgt = obd->u.obt.obt_lut;
686 char kernbuf[SYNC_STATES_MAXLEN];
690 if (count == 0 || count >= sizeof(kernbuf))
693 if (copy_from_user(kernbuf, buffer, count))
697 if (kernbuf[count - 1] == '\n')
698 kernbuf[count - 1] = 0;
700 for (i = 0 ; i < NUM_SYNC_ON_CANCEL_STATES; i++) {
701 if (strcmp(kernbuf, sync_on_cancel_states[i]) == 0) {
707 /* Legacy numeric codes */
711 /* Safe to use userspace buffer as lprocfs_write_helper will
712 * use copy from user for parsing */
713 rc = lprocfs_write_helper(buffer, count, &val);
718 if (val < 0 || val > 2)
721 spin_lock(&tgt->lut_flags_lock);
722 tgt->lut_sync_lock_cancel = val;
723 spin_unlock(&tgt->lut_flags_lock);
726 LPROC_SEQ_FOPS(ofd_sync_lock_cancel);
729 * Show if grants compatibility mode is disabled.
731 * When ofd_grant_compat_disable is set, we don't grant any space to clients
732 * not supporting OBD_CONNECT_GRANT_PARAM. Otherwise, space granted to such
733 * a client is inflated since it consumes PAGE_CACHE_SIZE of grant space per
734 * block, (i.e. typically 4kB units), but underlaying file system might have
735 * block size bigger than page size, e.g. ZFS. See LU-2049 for details.
737 * \param[in] m seq_file handle
738 * \param[in] data unused for single entry
740 * \retval 0 on success
741 * \retval negative value on error
743 static int ofd_grant_compat_disable_seq_show(struct seq_file *m, void *data)
745 struct obd_device *obd = m->private;
746 struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
748 return seq_printf(m, "%u\n", ofd->ofd_grant_compat_disable);
752 * Change grant compatibility mode.
754 * Setting ofd_grant_compat_disable prohibit any space granting to clients
755 * not supporting OBD_CONNECT_GRANT_PARAM. See details above.
757 * \param[in] file proc file
758 * \param[in] buffer string which represents mode
759 * 1: disable compatibility mode
760 * 0: enable compatibility mode
761 * \param[in] count \a buffer length
762 * \param[in] off unused for single entry
764 * \retval \a count on success
765 * \retval negative number on error
768 ofd_grant_compat_disable_seq_write(struct file *file,
769 const char __user *buffer,
770 size_t count, loff_t *off)
772 struct seq_file *m = file->private_data;
773 struct obd_device *obd = m->private;
774 struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
778 rc = lprocfs_write_helper(buffer, count, &val);
785 spin_lock(&ofd->ofd_flags_lock);
786 ofd->ofd_grant_compat_disable = !!val;
787 spin_unlock(&ofd->ofd_flags_lock);
791 LPROC_SEQ_FOPS(ofd_grant_compat_disable);
794 * Show the limit of soft sync RPCs.
796 * This value defines how many IO RPCs with OBD_BRW_SOFT_SYNC flag
797 * are allowed before sync update will be triggered.
799 * \param[in] m seq_file handle
800 * \param[in] data unused for single entry
802 * \retval 0 on success
803 * \retval negative value on error
805 static int ofd_soft_sync_limit_seq_show(struct seq_file *m, void *data)
807 struct obd_device *obd = m->private;
808 struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
810 return lprocfs_uint_seq_show(m, &ofd->ofd_soft_sync_limit);
814 * Change the limit of soft sync RPCs.
816 * Define how many IO RPCs with OBD_BRW_SOFT_SYNC flag
817 * allowed before sync update will be done.
819 * This limit is global across all exports.
821 * \param[in] file proc file
822 * \param[in] buffer string which represents limit
823 * \param[in] count \a buffer length
824 * \param[in] off unused for single entry
826 * \retval \a count on success
827 * \retval negative number on error
830 ofd_soft_sync_limit_seq_write(struct file *file, const char __user *buffer,
831 size_t count, loff_t *off)
833 struct seq_file *m = file->private_data;
834 struct obd_device *obd = m->private;
835 struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
837 return lprocfs_uint_seq_write(file, buffer, count,
838 (loff_t *) &ofd->ofd_soft_sync_limit);
840 LPROC_SEQ_FOPS(ofd_soft_sync_limit);
843 * Show the LFSCK speed limit.
845 * The maximum number of items scanned per second.
847 * \param[in] m seq_file handle
848 * \param[in] data unused for single entry
850 * \retval 0 on success
851 * \retval negative value on error
853 static int ofd_lfsck_speed_limit_seq_show(struct seq_file *m, void *data)
855 struct obd_device *obd = m->private;
856 struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
858 return lfsck_get_speed(m, ofd->ofd_osd);
862 * Change the LFSCK speed limit.
864 * Limit number of items that may be scanned per second.
866 * \param[in] file proc file
867 * \param[in] buffer string which represents limit
868 * \param[in] count \a buffer length
869 * \param[in] off unused for single entry
871 * \retval \a count on success
872 * \retval negative number on error
875 ofd_lfsck_speed_limit_seq_write(struct file *file, const char __user *buffer,
876 size_t count, loff_t *off)
878 struct seq_file *m = file->private_data;
879 struct obd_device *obd = m->private;
880 struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
884 rc = lprocfs_write_helper(buffer, count, &val);
888 rc = lfsck_set_speed(ofd->ofd_osd, val);
890 return rc != 0 ? rc : count;
892 LPROC_SEQ_FOPS(ofd_lfsck_speed_limit);
895 * Show LFSCK layout verification stats from the most recent LFSCK run.
897 * \param[in] m seq_file handle
898 * \param[in] data unused for single entry
900 * \retval 0 on success
901 * \retval negative value on error
903 static int ofd_lfsck_layout_seq_show(struct seq_file *m, void *data)
905 struct obd_device *obd = m->private;
906 struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
908 return lfsck_dump(m, ofd->ofd_osd, LFSCK_TYPE_LAYOUT);
910 LPROC_SEQ_FOPS_RO(ofd_lfsck_layout);
913 * Show if LFSCK performed parent FID verification.
915 * \param[in] m seq_file handle
916 * \param[in] data unused for single entry
918 * \retval 0 on success
919 * \retval negative value on error
921 static int ofd_lfsck_verify_pfid_seq_show(struct seq_file *m, void *data)
923 struct obd_device *obd = m->private;
924 struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
927 "switch: %s\ndetected: "LPU64"\nrepaired: "LPU64"\n",
928 ofd->ofd_lfsck_verify_pfid ? "on" : "off",
929 ofd->ofd_inconsistency_self_detected,
930 ofd->ofd_inconsistency_self_repaired);
934 * Set the LFSCK behavior to verify parent FID correctness.
936 * If flag ofd_lfsck_verify_pfid is set then LFSCK does parent FID
937 * verification during read/write operations.
939 * \param[in] file proc file
940 * \param[in] buffer string which represents behavior
941 * 1: verify parent FID
942 * 0: don't verify parent FID
943 * \param[in] count \a buffer length
944 * \param[in] off unused for single entry
946 * \retval \a count on success
947 * \retval negative number on error
950 ofd_lfsck_verify_pfid_seq_write(struct file *file, const char __user *buffer,
951 size_t count, loff_t *off)
953 struct seq_file *m = file->private_data;
954 struct obd_device *obd = m->private;
955 struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
959 rc = lprocfs_write_helper(buffer, count, &val);
963 ofd->ofd_lfsck_verify_pfid = !!val;
967 LPROC_SEQ_FOPS(ofd_lfsck_verify_pfid);
969 LPROC_SEQ_FOPS_RO_TYPE(ofd, uuid);
970 LPROC_SEQ_FOPS_RO_TYPE(ofd, blksize);
971 LPROC_SEQ_FOPS_RO_TYPE(ofd, kbytestotal);
972 LPROC_SEQ_FOPS_RO_TYPE(ofd, kbytesfree);
973 LPROC_SEQ_FOPS_RO_TYPE(ofd, kbytesavail);
974 LPROC_SEQ_FOPS_RO_TYPE(ofd, filestotal);
975 LPROC_SEQ_FOPS_RO_TYPE(ofd, filesfree);
977 LPROC_SEQ_FOPS_RO_TYPE(ofd, recovery_status);
978 LPROC_SEQ_FOPS_RW_TYPE(ofd, recovery_time_soft);
979 LPROC_SEQ_FOPS_RW_TYPE(ofd, recovery_time_hard);
980 LPROC_SEQ_FOPS_WO_TYPE(ofd, evict_client);
981 LPROC_SEQ_FOPS_RO_TYPE(ofd, num_exports);
982 LPROC_SEQ_FOPS_RO_TYPE(ofd, target_instance);
983 LPROC_SEQ_FOPS_RW_TYPE(ofd, ir_factor);
984 LPROC_SEQ_FOPS_RW_TYPE(ofd, job_interval);
986 struct lprocfs_seq_vars lprocfs_ofd_obd_vars[] = {
988 .fops = &ofd_uuid_fops },
989 { .name = "blocksize",
990 .fops = &ofd_blksize_fops },
991 { .name = "kbytestotal",
992 .fops = &ofd_kbytestotal_fops },
993 { .name = "kbytesfree",
994 .fops = &ofd_kbytesfree_fops },
995 { .name = "kbytesavail",
996 .fops = &ofd_kbytesavail_fops },
997 { .name = "filestotal",
998 .fops = &ofd_filestotal_fops },
999 { .name = "filesfree",
1000 .fops = &ofd_filesfree_fops },
1001 { .name = "seqs_allocated",
1002 .fops = &ofd_seqs_fops },
1004 .fops = &ofd_fstype_fops },
1005 { .name = "last_id",
1006 .fops = &ofd_last_id_fops },
1007 { .name = "tot_dirty",
1008 .fops = &ofd_tot_dirty_fops },
1009 { .name = "tot_pending",
1010 .fops = &ofd_tot_pending_fops },
1011 { .name = "tot_granted",
1012 .fops = &ofd_tot_granted_fops },
1013 { .name = "grant_precreate",
1014 .fops = &ofd_grant_precreate_fops },
1015 { .name = "grant_ratio",
1016 .fops = &ofd_grant_ratio_fops },
1017 { .name = "precreate_batch",
1018 .fops = &ofd_precreate_batch_fops },
1019 { .name = "recovery_status",
1020 .fops = &ofd_recovery_status_fops },
1021 { .name = "recovery_time_soft",
1022 .fops = &ofd_recovery_time_soft_fops },
1023 { .name = "recovery_time_hard",
1024 .fops = &ofd_recovery_time_hard_fops },
1025 { .name = "evict_client",
1026 .fops = &ofd_evict_client_fops },
1027 { .name = "num_exports",
1028 .fops = &ofd_num_exports_fops },
1029 { .name = "degraded",
1030 .fops = &ofd_degraded_fops },
1031 { .name = "sync_journal",
1032 .fops = &ofd_syncjournal_fops },
1033 { .name = "sync_on_lock_cancel",
1034 .fops = &ofd_sync_lock_cancel_fops },
1035 { .name = "instance",
1036 .fops = &ofd_target_instance_fops },
1037 { .name = "ir_factor",
1038 .fops = &ofd_ir_factor_fops },
1039 { .name = "grant_compat_disable",
1040 .fops = &ofd_grant_compat_disable_fops },
1041 { .name = "client_cache_count",
1042 .fops = &ofd_fmd_max_num_fops },
1043 { .name = "client_cache_seconds",
1044 .fops = &ofd_fmd_max_age_fops },
1046 .fops = &ofd_capa_fops },
1047 { .name = "capa_count",
1048 .fops = &ofd_capa_count_fops },
1049 { .name = "job_cleanup_interval",
1050 .fops = &ofd_job_interval_fops },
1051 { .name = "soft_sync_limit",
1052 .fops = &ofd_soft_sync_limit_fops },
1053 { .name = "lfsck_speed_limit",
1054 .fops = &ofd_lfsck_speed_limit_fops },
1055 { .name = "lfsck_layout",
1056 .fops = &ofd_lfsck_layout_fops },
1057 { .name = "lfsck_verify_pfid",
1058 .fops = &ofd_lfsck_verify_pfid_fops },
1063 * Initialize OFD statistics counters
1065 * param[in] stats statistics counters
1067 void ofd_stats_counter_init(struct lprocfs_stats *stats)
1069 LASSERT(stats && stats->ls_num >= LPROC_OFD_STATS_LAST);
1071 lprocfs_counter_init(stats, LPROC_OFD_STATS_READ,
1072 LPROCFS_CNTR_AVGMINMAX, "read_bytes", "bytes");
1073 lprocfs_counter_init(stats, LPROC_OFD_STATS_WRITE,
1074 LPROCFS_CNTR_AVGMINMAX, "write_bytes", "bytes");
1075 lprocfs_counter_init(stats, LPROC_OFD_STATS_GETATTR,
1076 0, "getattr", "reqs");
1077 lprocfs_counter_init(stats, LPROC_OFD_STATS_SETATTR,
1078 0, "setattr", "reqs");
1079 lprocfs_counter_init(stats, LPROC_OFD_STATS_PUNCH,
1080 0, "punch", "reqs");
1081 lprocfs_counter_init(stats, LPROC_OFD_STATS_SYNC,
1083 lprocfs_counter_init(stats, LPROC_OFD_STATS_DESTROY,
1084 0, "destroy", "reqs");
1085 lprocfs_counter_init(stats, LPROC_OFD_STATS_CREATE,
1086 0, "create", "reqs");
1087 lprocfs_counter_init(stats, LPROC_OFD_STATS_STATFS,
1088 0, "statfs", "reqs");
1089 lprocfs_counter_init(stats, LPROC_OFD_STATS_GET_INFO,
1090 0, "get_info", "reqs");
1091 lprocfs_counter_init(stats, LPROC_OFD_STATS_SET_INFO,
1092 0, "set_info", "reqs");
1093 lprocfs_counter_init(stats, LPROC_OFD_STATS_QUOTACTL,
1094 0, "quotactl", "reqs");
1097 #endif /* LPROCFS */