X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=lustre%2Fofd%2Flproc_ofd.c;h=7609167bb877be49a38ceced0e4f0d23cd3f0108;hb=e9389613eb29297f7b5a6b6cd896bafc7a5551f8;hp=fbd0913fbd5fe529a1836e8e8f2ec34520af968e;hpb=34df4e41d0ee0079235ec136ddd2a56d7e6707e8;p=fs%2Flustre-release.git

diff --git a/lustre/ofd/lproc_ofd.c b/lustre/ofd/lproc_ofd.c
index fbd0913..7609167 100644
--- a/lustre/ofd/lproc_ofd.c
+++ b/lustre/ofd/lproc_ofd.c
@@ -23,7 +23,7 @@
  * Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved.
  * Use is subject to license terms.
  *
- * Copyright (c) 2012, 2014 Intel Corporation.
+ * Copyright (c) 2012, 2016, Intel Corporation.
  */
 /*
  * This file is part of Lustre, http://www.lustre.org/
@@ -48,7 +48,7 @@
 
 #include "ofd_internal.h"
 
-#ifdef LPROCFS
+#ifdef CONFIG_PROC_FS
 
 /**
  * Show number of FID allocation sequences.
@@ -64,7 +64,8 @@ static int ofd_seqs_seq_show(struct seq_file *m, void *data)
 	struct obd_device *obd = m->private;
 	struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
 
-	return seq_printf(m, "%u\n", ofd->ofd_seq_count);
+	seq_printf(m, "%u\n", ofd->ofd_seq_count);
+	return 0;
 }
 LPROC_SEQ_FOPS_RO(ofd_seqs);
 
@@ -80,11 +81,12 @@ LPROC_SEQ_FOPS_RO(ofd_seqs);
 static int ofd_tot_dirty_seq_show(struct seq_file *m, void *data)
 {
 	struct obd_device *obd = m->private;
-	struct ofd_device *ofd;
+	struct tg_grants_data *tgd;
 
 	LASSERT(obd != NULL);
-	ofd = ofd_dev(obd->obd_lu_dev);
-	return seq_printf(m, LPU64"\n", ofd->ofd_tot_dirty);
+	tgd = &obd->u.obt.obt_lut->lut_tgd;
+	seq_printf(m, "%llu\n", tgd->tgd_tot_dirty);
+	return 0;
 }
 LPROC_SEQ_FOPS_RO(ofd_tot_dirty);
 
@@ -100,11 +102,12 @@ LPROC_SEQ_FOPS_RO(ofd_tot_dirty);
 static int ofd_tot_granted_seq_show(struct seq_file *m, void *data)
 {
 	struct obd_device *obd = m->private;
-	struct ofd_device *ofd;
+	struct tg_grants_data *tgd;
 
 	LASSERT(obd != NULL);
-	ofd = ofd_dev(obd->obd_lu_dev);
-	return seq_printf(m, LPU64"\n", ofd->ofd_tot_granted);
+	tgd = &obd->u.obt.obt_lut->lut_tgd;
+	seq_printf(m, "%llu\n", tgd->tgd_tot_granted);
+	return 0;
 }
 LPROC_SEQ_FOPS_RO(ofd_tot_granted);
 
@@ -120,11 +123,12 @@ LPROC_SEQ_FOPS_RO(ofd_tot_granted);
 static int ofd_tot_pending_seq_show(struct seq_file *m, void *data)
 {
 	struct obd_device *obd = m->private;
-	struct ofd_device *ofd;
+	struct tg_grants_data *tgd;
 
 	LASSERT(obd != NULL);
-	ofd = ofd_dev(obd->obd_lu_dev);
-	return seq_printf(m, LPU64"\n", ofd->ofd_tot_pending);
+	tgd = &obd->u.obt.obt_lut->lut_tgd;
+	seq_printf(m, "%llu\n", tgd->tgd_tot_pending);
+	return 0;
 }
 LPROC_SEQ_FOPS_RO(ofd_tot_pending);
 
@@ -142,74 +146,13 @@ static int ofd_grant_precreate_seq_show(struct seq_file *m, void *data)
 	struct obd_device *obd = m->private;
 
 	LASSERT(obd != NULL);
-	return seq_printf(m, "%ld\n",
-			  obd->obd_self_export->exp_filter_data.fed_grant);
+	seq_printf(m, "%ld\n",
+		   obd->obd_self_export->exp_target_data.ted_grant);
+	return 0;
 }
 LPROC_SEQ_FOPS_RO(ofd_grant_precreate);
 
 /**
- * Show total amount of free space reserved for grants.
- *
- * \param[in] m		seq_file handle
- * \param[in] data	unused for single entry
- *
- * \retval		0 on success
- * \retval		negative value on error
- */
-static int ofd_grant_ratio_seq_show(struct seq_file *m, void *data)
-{
-	struct obd_device *obd = m->private;
-	struct ofd_device *ofd;
-
-	LASSERT(obd != NULL);
-	ofd = ofd_dev(obd->obd_lu_dev);
-	return seq_printf(m, "%d%%\n",
-			  (int) ofd_grant_reserved(ofd, 100));
-}
-
-/**
- * Change amount of free space reserved for grants.
- *
- * \param[in] file	proc file
- * \param[in] buffer	string which represents maximum number
- * \param[in] count	\a buffer length
- * \param[in] off	unused for single entry
- *
- * \retval		\a count on success
- * \retval		negative number on error
- */
-static ssize_t
-ofd_grant_ratio_seq_write(struct file *file, const char __user *buffer,
-			  size_t count, loff_t *off)
-{
-	struct seq_file         *m = file->private_data;
-	struct obd_device       *obd = m->private;
-	struct ofd_device	*ofd = ofd_dev(obd->obd_lu_dev);
-	int			 val;
-	int			 rc;
-
-	rc = lprocfs_write_helper(buffer, count, &val);
-	if (rc)
-		return rc;
-
-	if (val > 100 || val < 0)
-		return -EINVAL;
-
-	if (val == 0)
-		CWARN("%s: disabling grant error margin\n", obd->obd_name);
-	if (val > 50)
-		CWARN("%s: setting grant error margin >50%%, be warned that "
-		      "a huge part of the free space is now reserved for "
-		      "grants\n", obd->obd_name);
-
-	spin_lock(&ofd->ofd_grant_lock);
-	ofd->ofd_grant_ratio = ofd_grant_ratio_conv(val);
-	spin_unlock(&ofd->ofd_grant_lock);
-	return count;
-}
-LPROC_SEQ_FOPS(ofd_grant_ratio);
-
-/**
  * Show number of precreates allowed in a single transaction.
  *
  * \param[in] m		seq_file handle
@@ -225,7 +168,8 @@ static int ofd_precreate_batch_seq_show(struct seq_file *m, void *data)
 
 	LASSERT(obd != NULL);
 	ofd = ofd_dev(obd->obd_lu_dev);
-	return seq_printf(m, "%d\n", ofd->ofd_precreate_batch);
+	seq_printf(m, "%d\n", ofd->ofd_precreate_batch);
+	return 0;
 }
 
 /**
@@ -243,17 +187,17 @@ static ssize_t
 ofd_precreate_batch_seq_write(struct file *file, const char __user *buffer,
 			      size_t count, loff_t *off)
 {
-	struct seq_file	  *m = file->private_data;
+	struct seq_file *m = file->private_data;
 	struct obd_device *obd = m->private;
 	struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
-	int val;
+	__s64 val;
 	int rc;
 
-	rc = lprocfs_write_helper(buffer, count, &val);
+	rc = lprocfs_str_to_s64(buffer, count, &val);
 	if (rc)
 		return rc;
 
-	if (val < 1)
+	if (val < 1 || val > INT_MAX)
 		return -EINVAL;
 
 	spin_lock(&ofd->ofd_batch_lock);
@@ -277,7 +221,6 @@ static int ofd_last_id_seq_show(struct seq_file *m, void *data)
 	struct obd_device	*obd = m->private;
 	struct ofd_device	*ofd;
 	struct ofd_seq		*oseq = NULL;
-	int			retval = 0, rc;
 
 	if (obd == NULL)
 		return 0;
@@ -292,15 +235,10 @@ static int ofd_last_id_seq_show(struct seq_file *m, void *data)
 		      fid_idif_seq(ostid_id(&oseq->os_oi),
 				   ofd->ofd_lut.lut_lsd.lsd_osd_index) :
 		      ostid_seq(&oseq->os_oi);
-		rc = seq_printf(m, DOSTID"\n", seq, ostid_id(&oseq->os_oi));
-		if (rc < 0) {
-			retval = rc;
-			break;
-		}
-		retval += rc;
+		seq_printf(m, DOSTID"\n", seq, ostid_id(&oseq->os_oi));
 	}
 	read_unlock(&ofd->ofd_seq_list_lock);
-	return retval;
+	return 0;
 }
 LPROC_SEQ_FOPS_RO(ofd_last_id);
 
@@ -318,7 +256,8 @@ static int ofd_fmd_max_num_seq_show(struct seq_file *m, void *data)
 	struct obd_device *obd = m->private;
 	struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
 
-	return seq_printf(m, "%u\n", ofd->ofd_fmd_max_num);
+	seq_printf(m, "%u\n", ofd->ofd_fmd_max_num);
+	return 0;
 }
 
 /**
@@ -338,13 +277,13 @@ static ssize_t
 ofd_fmd_max_num_seq_write(struct file *file, const char __user *buffer,
 			  size_t count, loff_t *off)
 {
-	struct seq_file		*m = file->private_data;
-	struct obd_device	*obd = m->private;
-	struct ofd_device	*ofd = ofd_dev(obd->obd_lu_dev);
-	int			 val;
-	int			 rc;
+	struct seq_file *m = file->private_data;
+	struct obd_device *obd = m->private;
+	struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
+	__s64 val;
+	int rc;
 
-	rc = lprocfs_write_helper(buffer, count, &val);
+	rc = lprocfs_str_to_s64(buffer, count, &val);
 	if (rc)
 		return rc;
 
@@ -373,7 +312,9 @@ static int ofd_fmd_max_age_seq_show(struct seq_file *m, void *data)
 	struct obd_device *obd = m->private;
 	struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
 
-	return seq_printf(m, "%ld\n", ofd->ofd_fmd_max_age / HZ);
+	seq_printf(m, "%ld\n", jiffies_to_msecs(ofd->ofd_fmd_max_age) /
+		   MSEC_PER_SEC);
+	return 0;
 }
 
 /**
@@ -397,94 +338,22 @@ ofd_fmd_max_age_seq_write(struct file *file, const char __user *buffer,
 	struct seq_file		*m = file->private_data;
 	struct obd_device	*obd = m->private;
 	struct ofd_device	*ofd = ofd_dev(obd->obd_lu_dev);
-	int			 val;
+	__s64			 val;
 	int			 rc;
 
-	rc = lprocfs_write_helper(buffer, count, &val);
+	rc = lprocfs_str_to_s64(buffer, count, &val);
 	if (rc)
 		return rc;
 
 	if (val > 65536 || val < 1)
 		return -EINVAL;
 
-	ofd->ofd_fmd_max_age = val * HZ;
+	ofd->ofd_fmd_max_age = msecs_to_jiffies(val * MSEC_PER_SEC);
 	return count;
 }
 LPROC_SEQ_FOPS(ofd_fmd_max_age);
 
 /**
- * Show if OSS FID capability is enabled or disabled
- *
- * \param[in] m		seq_file handle
- * \param[in] data	unused for single entry
- *
- * \retval		0 on success
- * \retval		negative value on error
- */
-static int ofd_capa_seq_show(struct seq_file *m, void *data)
-{
-	struct obd_device	*obd = m->private;
-
-	return seq_printf(m, "capability on: %s\n",
-			  obd->u.filter.fo_fl_oss_capa ? "oss" : "");
-}
-
-/**
- * Enable or disable OSS FID capability mode.
- *
- * \param[in] file	proc file
- * \param[in] buffer	string which represents mode
- *			1: enable mode
- *			0: disable mode
- * \param[in] count	\a buffer length
- * \param[in] off	unused for single entry
- *
- * \retval		\a count on success
- * \retval		negative number on error
- */
-static ssize_t
-ofd_capa_seq_write(struct file *file, const char *__user buffer, size_t count,
-		   loff_t *off)
-{
-	struct seq_file		*m = file->private_data;
-	struct obd_device	*obd = m->private;
-	int			 val, rc;
-
-	rc = lprocfs_write_helper(buffer, count, &val);
-	if (rc)
-		return rc;
-
-	if (val & ~0x1) {
-		CERROR("invalid capability mode, only 0/1 are accepted.\n"
-		       " 1: enable oss fid capability\n"
-		       " 0: disable oss fid capability\n");
-		return -EINVAL;
-	}
-
-	obd->u.filter.fo_fl_oss_capa = val;
-	LCONSOLE_INFO("OSS %s %s fid capability.\n", obd->obd_name,
-		      val ? "enabled" : "disabled");
-	return count;
-}
-LPROC_SEQ_FOPS(ofd_capa);
-
-/**
- * Show capability count on client and server side.
- *
- * \param[in] m		seq_file handle
- * \param[in] data	unused for single entry
- *
- * \retval		0 on success
- * \retval		negative value on error
- */
-static int ofd_capa_count_seq_show(struct seq_file *m, void *data)
-{
-	return seq_printf(m, "%d %d\n", capa_count[CAPA_SITE_CLIENT],
-			  capa_count[CAPA_SITE_SERVER]);
-}
-LPROC_SEQ_FOPS_RO(ofd_capa_count);
-
-/**
  * Show if the OFD is in degraded mode.
  *
  * Degraded means OFD has a failed drive or is undergoing RAID rebuild.
@@ -504,7 +373,8 @@ static int ofd_degraded_seq_show(struct seq_file *m, void *data)
 	struct obd_device *obd = m->private;
 	struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
 
-	return seq_printf(m, "%u\n", ofd->ofd_raid_degraded);
+	seq_printf(m, "%u\n", ofd->ofd_raid_degraded);
+	return 0;
 }
 
 /**
@@ -528,12 +398,13 @@ static ssize_t
 ofd_degraded_seq_write(struct file *file, const char __user *buffer,
 		       size_t count, loff_t *off)
 {
-	struct seq_file		*m = file->private_data;
-	struct obd_device	*obd = m->private;
-	struct ofd_device	*ofd = ofd_dev(obd->obd_lu_dev);
-	int			 val, rc;
+	struct seq_file *m = file->private_data;
+	struct obd_device *obd = m->private;
+	struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
+	int rc;
+	__s64 val;
 
-	rc = lprocfs_write_helper(buffer, count, &val);
+	rc = lprocfs_str_to_s64(buffer, count, &val);
 	if (rc)
 		return rc;
 
@@ -562,7 +433,8 @@ static int ofd_fstype_seq_show(struct seq_file *m, void *data)
 	LASSERT(ofd->ofd_osd);
 	d = &ofd->ofd_osd->dd_lu_dev;
 	LASSERT(d->ld_type);
-	return seq_printf(m, "%s\n", d->ld_type->ldt_name);
+	seq_printf(m, "%s\n", d->ld_type->ldt_name);
+	return 0;
 }
 LPROC_SEQ_FOPS_RO(ofd_fstype);
 
@@ -588,7 +460,8 @@ static int ofd_syncjournal_seq_show(struct seq_file *m, void *data)
 	struct obd_device	*obd = m->private;
 	struct ofd_device	*ofd = ofd_dev(obd->obd_lu_dev);
 
-	return seq_printf(m, "%u\n", ofd->ofd_syncjournal);
+	seq_printf(m, "%u\n", ofd->ofd_syncjournal);
+	return 0;
 }
 
 /**
@@ -608,13 +481,13 @@ static ssize_t
 ofd_syncjournal_seq_write(struct file *file, const char __user *buffer,
 			  size_t count, loff_t *off)
 {
-	struct seq_file		*m = file->private_data;
-	struct obd_device	*obd = m->private;
-	struct ofd_device	*ofd = ofd_dev(obd->obd_lu_dev);
-	int			 val;
-	int			 rc;
+	struct seq_file	*m = file->private_data;
+	struct obd_device *obd = m->private;
+	struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
+	__s64 val;
+	int rc;
 
-	rc = lprocfs_write_helper(buffer, count, &val);
+	rc = lprocfs_str_to_s64(buffer, count, &val);
 	if (rc)
 		return rc;
 
@@ -632,6 +505,45 @@ LPROC_SEQ_FOPS(ofd_syncjournal);
 
 /* This must be longer than the longest string below */
 #define SYNC_STATES_MAXLEN 16
+
+static int ofd_brw_size_seq_show(struct seq_file *m, void *data)
+{
+	struct obd_device	*obd = m->private;
+	struct ofd_device	*ofd = ofd_dev(obd->obd_lu_dev);
+
+	seq_printf(m, "%u\n", ofd->ofd_brw_size / ONE_MB_BRW_SIZE);
+	return 0;
+}
+
+static ssize_t
+ofd_brw_size_seq_write(struct file *file, const char __user *buffer,
+		       size_t count, loff_t *off)
+{
+	struct seq_file	*m = file->private_data;
+	struct obd_device *obd = m->private;
+	struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
+	__s64 val;
+	int rc;
+
+	rc = lprocfs_str_with_units_to_s64(buffer, count, &val, 'M');
+	if (rc)
+		return rc;
+
+	if (val <= 0)
+		return -EINVAL;
+
+	if (val > DT_MAX_BRW_SIZE ||
+	    val < (1 << ofd->ofd_lut.lut_tgd.tgd_blockbits))
+		return -ERANGE;
+
+	spin_lock(&ofd->ofd_flags_lock);
+	ofd->ofd_brw_size = val;
+	spin_unlock(&ofd->ofd_flags_lock);
+
+	return count;
+}
+LPROC_SEQ_FOPS(ofd_brw_size);
+
 static char *sync_on_cancel_states[] = {"never",
 					"blocking",
 					"always" };
@@ -650,8 +562,9 @@ static int ofd_sync_lock_cancel_seq_show(struct seq_file *m, void *data)
 	struct obd_device	*obd = m->private;
 	struct lu_target	*tgt = obd->u.obt.obt_lut;
 
-	return seq_printf(m, "%s\n",
-			  sync_on_cancel_states[tgt->lut_sync_lock_cancel]);
+	seq_printf(m, "%s\n",
+		   sync_on_cancel_states[tgt->lut_sync_lock_cancel]);
+	return 0;
 }
 
 /**
@@ -679,12 +592,12 @@ static ssize_t
 ofd_sync_lock_cancel_seq_write(struct file *file, const char __user *buffer,
 			       size_t count, loff_t *off)
 {
-	struct seq_file		*m = file->private_data;
-	struct obd_device	*obd = m->private;
-	struct lu_target	*tgt = obd->u.obt.obt_lut;
-	char			 kernbuf[SYNC_STATES_MAXLEN];
-	int			 val = -1;
-	int			 i;
+	struct seq_file *m = file->private_data;
+	struct obd_device *obd = m->private;
+	struct lu_target *tgt = obd->u.obt.obt_lut;
+	char kernbuf[SYNC_STATES_MAXLEN];
+	__s64 val = -1;
+	int i;
 
 	if (count == 0 || count >= sizeof(kernbuf))
 		return -EINVAL;
@@ -705,11 +618,7 @@ ofd_sync_lock_cancel_seq_write(struct file *file, const char __user *buffer,
 
 	/* Legacy numeric codes */
 	if (val == -1) {
-		int rc;
-
-		/* Safe to use userspace buffer as lprocfs_write_helper will
-		 * use copy from user for parsing */
-		rc = lprocfs_write_helper(buffer, count, &val);
+		int rc = lprocfs_str_to_s64(buffer, count, &val);
 		if (rc)
 			return rc;
 	}
@@ -727,9 +636,9 @@ LPROC_SEQ_FOPS(ofd_sync_lock_cancel);
 /**
  * Show if grants compatibility mode is disabled.
  *
- * When ofd_grant_compat_disable is set, we don't grant any space to clients
+ * When tgd_grant_compat_disable is set, we don't grant any space to clients
  * not supporting OBD_CONNECT_GRANT_PARAM. Otherwise, space granted to such
- * a client is inflated since it consumes PAGE_CACHE_SIZE of grant space per
+ * a client is inflated since it consumes PAGE_SIZE of grant space per
  * block, (i.e. typically 4kB units), but underlaying file system might have
  * block size bigger than page size, e.g. ZFS. See LU-2049 for details.
  *
@@ -742,15 +651,16 @@ LPROC_SEQ_FOPS(ofd_sync_lock_cancel);
 static int ofd_grant_compat_disable_seq_show(struct seq_file *m, void *data)
 {
 	struct obd_device *obd = m->private;
-	struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
+	struct tg_grants_data *tgd = &obd->u.obt.obt_lut->lut_tgd;
 
-	return seq_printf(m, "%u\n", ofd->ofd_grant_compat_disable);
+	seq_printf(m, "%u\n", tgd->tgd_grant_compat_disable);
+	return 0;
 }
 
 /**
  * Change grant compatibility mode.
  *
- * Setting ofd_grant_compat_disable prohibit any space granting to clients
+ * Setting tgd_grant_compat_disable prohibit any space granting to clients
  * not supporting OBD_CONNECT_GRANT_PARAM. See details above.
  *
  * \param[in] file	proc file
@@ -768,22 +678,20 @@ ofd_grant_compat_disable_seq_write(struct file *file,
 				   const char __user *buffer,
 				   size_t count, loff_t *off)
 {
-	struct seq_file		*m = file->private_data;
-	struct obd_device	*obd = m->private;
-	struct ofd_device	*ofd = ofd_dev(obd->obd_lu_dev);
-	int			 val;
-	int			 rc;
+	struct seq_file *m = file->private_data;
+	struct obd_device *obd = m->private;
+	struct tg_grants_data *tgd = &obd->u.obt.obt_lut->lut_tgd;
+	__s64 val;
+	int rc;
 
-	rc = lprocfs_write_helper(buffer, count, &val);
+	rc = lprocfs_str_to_s64(buffer, count, &val);
 	if (rc)
 		return rc;
 
 	if (val < 0)
 		return -EINVAL;
 
-	spin_lock(&ofd->ofd_flags_lock);
-	ofd->ofd_grant_compat_disable = !!val;
-	spin_unlock(&ofd->ofd_flags_lock);
+	tgd->tgd_grant_compat_disable = !!val;
 
 	return count;
 }
@@ -874,16 +782,19 @@ static ssize_t
 ofd_lfsck_speed_limit_seq_write(struct file *file, const char __user *buffer,
 				size_t count, loff_t *off)
 {
-	struct seq_file		*m = file->private_data;
-	struct obd_device	*obd = m->private;
-	struct ofd_device	*ofd = ofd_dev(obd->obd_lu_dev);
-	__u32			 val;
-	int			 rc;
+	struct seq_file *m = file->private_data;
+	struct obd_device *obd = m->private;
+	struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
+	__s64 val;
+	int rc;
 
-	rc = lprocfs_write_helper(buffer, count, &val);
+	rc = lprocfs_str_to_s64(buffer, count, &val);
 	if (rc != 0)
 		return rc;
 
+	if (val < 0)
+		return -ERANGE;
+
 	rc = lfsck_set_speed(ofd->ofd_osd, val);
 
 	return rc != 0 ? rc : count;
@@ -922,11 +833,11 @@ static int ofd_lfsck_verify_pfid_seq_show(struct seq_file *m, void *data)
 	struct obd_device *obd = m->private;
 	struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
 
-	return seq_printf(m,
-			  "switch: %s\ndetected: "LPU64"\nrepaired: "LPU64"\n",
-			  ofd->ofd_lfsck_verify_pfid ? "on" : "off",
-			  ofd->ofd_inconsistency_self_detected,
-			  ofd->ofd_inconsistency_self_repaired);
+	seq_printf(m, "switch: %s\ndetected: %llu\nrepaired: %llu\n",
+		   ofd->ofd_lfsck_verify_pfid ? "on" : "off",
+		   ofd->ofd_inconsistency_self_detected,
+		   ofd->ofd_inconsistency_self_repaired);
+	return 0;
 }
 
 /**
@@ -949,22 +860,34 @@ static ssize_t
 ofd_lfsck_verify_pfid_seq_write(struct file *file, const char __user *buffer,
 				size_t count, loff_t *off)
 {
-	struct seq_file		*m = file->private_data;
-	struct obd_device	*obd = m->private;
-	struct ofd_device	*ofd = ofd_dev(obd->obd_lu_dev);
-	__u32			 val;
-	int			 rc;
+	struct seq_file *m = file->private_data;
+	struct obd_device *obd = m->private;
+	struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
+	__s64 val;
+	int rc;
 
-	rc = lprocfs_write_helper(buffer, count, &val);
+	rc = lprocfs_str_to_s64(buffer, count, &val);
 	if (rc != 0)
 		return rc;
 
 	ofd->ofd_lfsck_verify_pfid = !!val;
+	if (!ofd->ofd_lfsck_verify_pfid) {
+		ofd->ofd_inconsistency_self_detected = 0;
+		ofd->ofd_inconsistency_self_repaired = 0;
+	}
 
 	return count;
 }
 LPROC_SEQ_FOPS(ofd_lfsck_verify_pfid);
 
+static int ofd_site_stats_seq_show(struct seq_file *m, void *data)
+{
+	struct obd_device *obd = m->private;
+
+	return lu_site_stats_seq_print(obd->obd_lu_dev->ld_site, m);
+}
+LPROC_SEQ_FOPS_RO(ofd_site_stats);
+
 LPROC_SEQ_FOPS_RO_TYPE(ofd, uuid);
 LPROC_SEQ_FOPS_RO_TYPE(ofd, blksize);
 LPROC_SEQ_FOPS_RO_TYPE(ofd, kbytestotal);
@@ -982,7 +905,7 @@ LPROC_SEQ_FOPS_RO_TYPE(ofd, target_instance);
 LPROC_SEQ_FOPS_RW_TYPE(ofd, ir_factor);
 LPROC_SEQ_FOPS_RW_TYPE(ofd, job_interval);
 
-struct lprocfs_seq_vars lprocfs_ofd_obd_vars[] = {
+struct lprocfs_vars lprocfs_ofd_obd_vars[] = {
 	{ .name =	"uuid",
 	  .fops =	&ofd_uuid_fops			},
 	{ .name =	"blocksize",
@@ -1011,8 +934,6 @@ struct lprocfs_seq_vars lprocfs_ofd_obd_vars[] = {
 	  .fops =	&ofd_tot_granted_fops		},
 	{ .name =	"grant_precreate",
 	  .fops =	&ofd_grant_precreate_fops	},
-	{ .name =	"grant_ratio",
-	  .fops =	&ofd_grant_ratio_fops		},
 	{ .name =	"precreate_batch",
 	  .fops =	&ofd_precreate_batch_fops	},
 	{ .name =	"recovery_status",
@@ -1029,6 +950,8 @@ struct lprocfs_seq_vars lprocfs_ofd_obd_vars[] = {
 	  .fops =	&ofd_degraded_fops		},
 	{ .name =	"sync_journal",
 	  .fops =	&ofd_syncjournal_fops		},
+	{ .name =	"brw_size",
+	  .fops =	&ofd_brw_size_fops		},
 	{ .name =	"sync_on_lock_cancel",
 	  .fops =	&ofd_sync_lock_cancel_fops	},
 	{ .name =	"instance",
@@ -1041,10 +964,6 @@ struct lprocfs_seq_vars lprocfs_ofd_obd_vars[] = {
 	  .fops =	&ofd_fmd_max_num_fops		},
 	{ .name =	"client_cache_seconds",
 	  .fops =	&ofd_fmd_max_age_fops		},
-	{ .name =	"capa",
-	  .fops =	&ofd_capa_fops			},
-	{ .name =	"capa_count",
-	  .fops =	&ofd_capa_count_fops		},
 	{ .name =	"job_cleanup_interval",
 	  .fops =	&ofd_job_interval_fops		},
 	{ .name =	"soft_sync_limit",
@@ -1055,7 +974,9 @@ struct lprocfs_seq_vars lprocfs_ofd_obd_vars[] = {
 	  .fops =	&ofd_lfsck_layout_fops		},
 	{ .name	=	"lfsck_verify_pfid",
 	  .fops	=	&ofd_lfsck_verify_pfid_fops	},
-	{ 0 }
+	{ .name =	"site_stats",
+	  .fops =	&ofd_site_stats_fops		},
+	{ NULL }
 };
 
 /**
@@ -1093,4 +1014,4 @@ void ofd_stats_counter_init(struct lprocfs_stats *stats)
 			     0, "quotactl", "reqs");
 }
 
-#endif /* LPROCFS */
+#endif /* CONFIG_PROC_FS */