X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=lustre%2Fmdt%2Fmdt_lproc.c;h=514139414d93cab2abe0812b903afdca600b2385;hb=e8273a3dd71c4e6ab5ca9de3fbfbc0f7603d6930;hp=f8d0c0af731fc597cc5f8b18d1a868f8c344353f;hpb=b1e595c09e1b07a6840142b3ae015b8a5a8affeb;p=fs%2Flustre-release.git

diff --git a/lustre/mdt/mdt_lproc.c b/lustre/mdt/mdt_lproc.c
index f8d0c0a..5141394 100644
--- a/lustre/mdt/mdt_lproc.c
+++ b/lustre/mdt/mdt_lproc.c
@@ -27,7 +27,7 @@
  * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
  * Use is subject to license terms.
  *
- * Copyright (c) 2011, 2013, Intel Corporation.
+ * Copyright (c) 2011, 2014, Intel Corporation.
  */
 /*
  * This file is part of Lustre, http://www.lustre.org/
@@ -217,7 +217,8 @@ static int mdt_identity_expire_seq_show(struct seq_file *m, void *data)
 	struct obd_device *obd = m->private;
 	struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
 
-	return seq_printf(m, "%u\n", mdt->mdt_identity_cache->uc_entry_expire);
+	seq_printf(m, "%u\n", mdt->mdt_identity_cache->uc_entry_expire);
+	return 0;
 }
 
 static ssize_t
@@ -227,13 +228,17 @@ mdt_identity_expire_seq_write(struct file *file, const char __user *buffer,
 	struct seq_file	  *m = file->private_data;
 	struct obd_device *obd = m->private;
 	struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
-	int rc, val;
+	int rc;
+	__s64 val;
 
-	rc = lprocfs_write_helper(buffer, count, &val);
+	rc = lprocfs_str_to_s64(buffer, count, &val);
 	if (rc)
 		return rc;
+	if (val < 0 || val > INT_MAX)
+		return -ERANGE;
 
 	mdt->mdt_identity_cache->uc_entry_expire = val;
+
 	return count;
 }
 LPROC_SEQ_FOPS(mdt_identity_expire);
@@ -243,7 +248,8 @@ static int mdt_identity_acquire_expire_seq_show(struct seq_file *m, void *data)
 	struct obd_device *obd = m->private;
 	struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
 
-	return seq_printf(m, "%u\n", mdt->mdt_identity_cache->uc_acquire_expire);
+	seq_printf(m, "%u\n", mdt->mdt_identity_cache->uc_acquire_expire);
+	return 0;
 }
 
 static ssize_t
@@ -254,13 +260,17 @@ mdt_identity_acquire_expire_seq_write(struct file *file,
 	struct seq_file	  *m = file->private_data;
 	struct obd_device *obd = m->private;
 	struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
-	int rc, val;
+	int rc;
+	__s64 val;
 
-	rc = lprocfs_write_helper(buffer, count, &val);
+	rc = lprocfs_str_to_s64(buffer, count, &val);
 	if (rc)
 		return rc;
+	if (val < 0 || val > INT_MAX)
+		return -ERANGE;
 
 	mdt->mdt_identity_cache->uc_acquire_expire = val;
+
 	return count;
 }
 LPROC_SEQ_FOPS(mdt_identity_acquire_expire);
@@ -271,9 +281,9 @@ static int mdt_identity_upcall_seq_show(struct seq_file *m, void *data)
 	struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
 	struct upcall_cache *hash = mdt->mdt_identity_cache;
 
-	read_lock(&hash->uc_upcall_rwlock);
+	down_read(&hash->uc_upcall_rwsem);
 	seq_printf(m, "%s\n", hash->uc_upcall);
-	read_unlock(&hash->uc_upcall_rwlock);
+	up_read(&hash->uc_upcall_rwsem);
 	return 0;
 }
 
@@ -299,9 +309,9 @@ mdt_identity_upcall_seq_write(struct file *file, const char __user *buffer,
 		GOTO(failed, rc = -EFAULT);
 
 	/* Remove any extraneous bits from the upcall (e.g. linefeeds) */
-	write_lock(&hash->uc_upcall_rwlock);
+	down_write(&hash->uc_upcall_rwsem);
 	sscanf(kernbuf, "%s", hash->uc_upcall);
-	write_unlock(&hash->uc_upcall_rwlock);
+	up_write(&hash->uc_upcall_rwsem);
 
 	if (strcmp(hash->uc_name, mdt_obd_name(mdt)) != 0)
 		CWARN("%s: write to upcall name %s\n",
@@ -330,11 +340,14 @@ lprocfs_identity_flush_seq_write(struct file *file, const char __user *buffer,
 	struct seq_file   *m = file->private_data;
 	struct obd_device *obd = m->private;
 	struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
-	int rc, uid;
+	int rc;
+	__s64 uid;
 
-	rc = lprocfs_write_helper(buffer, count, &uid);
+	rc = lprocfs_str_to_s64(buffer, count, &uid);
 	if (rc)
 		return rc;
+	if (uid < INT_MIN || uid > INT_MAX)
+		return -ERANGE;
 
 	mdt_flush_identity(mdt->mdt_identity_cache, uid);
 	return count;
@@ -409,68 +422,6 @@ out:
 }
 LPROC_SEQ_FOPS_WO_TYPE(mdt, identity_info);
 
-/* for debug only */
-static int mdt_capa_seq_show(struct seq_file *m, void *data)
-{
-	struct obd_device *obd = m->private;
-	struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
-
-	return seq_printf(m, "capability on: %s %s\n",
-			  mdt->mdt_lut.lut_oss_capa ? "oss" : "",
-			  mdt->mdt_lut.lut_mds_capa ? "mds" : "");
-}
-
-static ssize_t
-mdt_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;
-	struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
-	int val, rc;
-
-	rc = lprocfs_write_helper(buffer, count, &val);
-	if (rc)
-		return rc;
-
-	if (val < 0 || val > 3) {
-		CERROR("invalid capability mode, only 0/2/3 is accepted.\n"
-		       " 0:  disable fid capability\n"
-		       " 2:  enable MDS fid capability\n"
-		       " 3:  enable both MDS and OSS fid capability\n");
-		return -EINVAL;
-	}
-
-	/* OSS fid capability needs enable both MDS and OSS fid capability on
-	 * MDS */
-	if (val == 1) {
-		CERROR("can't enable OSS fid capability only, you should use "
-		       "'3' to enable both MDS and OSS fid capability.\n");
-		return -EINVAL;
-	}
-
-	spin_lock(&mdt->mdt_lut.lut_flags_lock);
-	mdt->mdt_lut.lut_oss_capa = !!(val & 0x1);
-	mdt->mdt_lut.lut_mds_capa = !!(val & 0x2);
-	spin_unlock(&mdt->mdt_lut.lut_flags_lock);
-	mdt->mdt_capa_conf = 1;
-	LCONSOLE_INFO("MDS %s %s MDS fid capability.\n",
-		      mdt_obd_name(mdt),
-		      mdt->mdt_lut.lut_mds_capa ? "enabled" : "disabled");
-	LCONSOLE_INFO("MDS %s %s OSS fid capability.\n",
-		      mdt_obd_name(mdt),
-		      mdt->mdt_lut.lut_oss_capa ? "enabled" : "disabled");
-	return count;
-}
-LPROC_SEQ_FOPS(mdt_capa);
-
-static int mdt_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(mdt_capa_count);
-
 static int mdt_site_stats_seq_show(struct seq_file *m, void *data)
 {
 	struct obd_device *obd = m->private;
@@ -480,142 +431,96 @@ static int mdt_site_stats_seq_show(struct seq_file *m, void *data)
 }
 LPROC_SEQ_FOPS_RO(mdt_site_stats);
 
-static int mdt_capa_timeout_seq_show(struct seq_file *m, void *data)
-{
-	struct obd_device *obd = m->private;
-	struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
-
-	return seq_printf(m, "%lu\n", mdt->mdt_capa_timeout);
-}
-
-static ssize_t
-mdt_capa_timeout_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 mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
-	int val, rc;
-
-	rc = lprocfs_write_helper(buffer, count, &val);
-	if (rc)
-		return rc;
-
-	mdt->mdt_capa_timeout = (unsigned long)val;
-	mdt->mdt_capa_conf = 1;
-	return count;
-}
-LPROC_SEQ_FOPS(mdt_capa_timeout);
-
-static int mdt_ck_timeout_seq_show(struct seq_file *m, void *data)
-{
-	struct obd_device *obd = m->private;
-	struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
-
-	return seq_printf(m, "%lu\n", mdt->mdt_ck_timeout);
-}
+#define BUFLEN (UUID_MAX + 4)
 
 static ssize_t
-mdt_ck_timeout_seq_write(struct file *file, const char __user *buffer,
-			 size_t count, loff_t *off)
+lprocfs_mds_evict_client_seq_write(struct file *file, const char __user *buf,
+				   size_t count, loff_t *off)
 {
 	struct seq_file	  *m = file->private_data;
 	struct obd_device *obd = m->private;
 	struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
-	int val, rc;
-
-	rc = lprocfs_write_helper(buffer, count, &val);
-	if (rc)
-		return rc;
+	char *kbuf;
+	char *tmpbuf;
+	int rc = 0;
 
-	mdt->mdt_ck_timeout = (unsigned long)val;
-	mdt->mdt_capa_conf = 1;
-	return count;
-}
-LPROC_SEQ_FOPS(mdt_ck_timeout);
+	OBD_ALLOC(kbuf, BUFLEN);
+	if (kbuf == NULL)
+		return -ENOMEM;
 
-#define BUFLEN (UUID_MAX + 4)
+	/*
+	 * OBD_ALLOC() will zero kbuf, but we only copy BUFLEN - 1
+	 * bytes into kbuf, to ensure that the string is NUL-terminated.
+	 * UUID_MAX should include a trailing NUL already.
+	 */
+	if (copy_from_user(kbuf, buf, min_t(unsigned long, BUFLEN - 1, count)))
+		GOTO(out, rc = -EFAULT);
+	tmpbuf = cfs_firststr(kbuf, min_t(unsigned long, BUFLEN - 1, count));
 
-static ssize_t
-lprocfs_mds_evict_client_seq_write(struct file *file,
-				   const char __user *buffer,
-				   size_t count, loff_t *off)
-{
-	char *kbuf;
-	char *tmpbuf;
+	if (strncmp(tmpbuf, "nid:", 4) != 0) {
+		count = lprocfs_evict_client_seq_write(file, buf, count, off);
+		goto out;
+	}
 
-        OBD_ALLOC(kbuf, BUFLEN);
-        if (kbuf == NULL)
-                return -ENOMEM;
-
-        /*
-         * OBD_ALLOC() will zero kbuf, but we only copy BUFLEN - 1
-         * bytes into kbuf, to ensure that the string is NUL-terminated.
-         * UUID_MAX should include a trailing NUL already.
-         */
-	if (copy_from_user(kbuf, buffer,
-			   min_t(unsigned long, BUFLEN - 1, count))) {
-                count = -EFAULT;
-                goto out;
-        }
-        tmpbuf = cfs_firststr(kbuf, min_t(unsigned long, BUFLEN - 1, count));
+	if (mdt->mdt_opts.mo_evict_tgt_nids) {
+		rc = obd_set_info_async(NULL, mdt->mdt_child_exp,
+					sizeof(KEY_EVICT_BY_NID),
+					KEY_EVICT_BY_NID,
+					strlen(tmpbuf + 4) + 1,
+					tmpbuf + 4, NULL);
+		if (rc)
+			CERROR("Failed to evict nid %s from OSTs: rc %d\n",
+			       tmpbuf + 4, rc);
+	}
 
-        if (strncmp(tmpbuf, "nid:", 4) != 0) {
-		count = lprocfs_evict_client_seq_write(file, buffer, count,
-						       off);
-                goto out;
-        }
+	/* See the comments in function lprocfs_wr_evict_client()
+	 * in ptlrpc/lproc_ptlrpc.c for details. - jay */
+	class_incref(obd, __func__, current);
+	obd_export_evict_by_nid(obd, tmpbuf + 4);
+	class_decref(obd, __func__, current);
 
-        CERROR("NOT implement evict client by nid %s\n", tmpbuf);
 
 out:
-        OBD_FREE(kbuf, BUFLEN);
-        return count;
+	OBD_FREE(kbuf, BUFLEN);
+	return rc < 0 ? rc : count;
 }
 
 #undef BUFLEN
 
-static int mdt_sec_level_seq_show(struct seq_file *m, void *data)
+static int mdt_evict_tgt_nids_seq_show(struct seq_file *m, void *data)
 {
 	struct obd_device *obd = m->private;
 	struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
 
-	return seq_printf(m, "%d\n", mdt->mdt_lut.lut_sec_level);
+	seq_printf(m, "%u\n", mdt->mdt_opts.mo_evict_tgt_nids);
+	return 0;
 }
 
 static ssize_t
-mdt_sec_level_seq_write(struct file *file, const char __user *buffer,
-			size_t count, loff_t *off)
+mdt_evict_tgt_nids_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 mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
-	int val, rc;
-
-        rc = lprocfs_write_helper(buffer, count, &val);
-        if (rc)
-                return rc;
-
-        if (val > LUSTRE_SEC_ALL || val < LUSTRE_SEC_NONE)
-                return -EINVAL;
-
-        if (val == LUSTRE_SEC_SPECIFY) {
-                CWARN("security level %d will be supported in future.\n",
-                      LUSTRE_SEC_SPECIFY);
-                return -EINVAL;
-        }
+	__s64 val;
+	int rc;
 
-	mdt->mdt_lut.lut_sec_level = val;
+	rc = lprocfs_str_to_s64(buffer, count, &val);
+	if (rc)
+		return rc;
+	mdt->mdt_opts.mo_evict_tgt_nids = !!val;
 	return count;
 }
-LPROC_SEQ_FOPS(mdt_sec_level);
+LPROC_SEQ_FOPS(mdt_evict_tgt_nids);
 
 static int mdt_cos_seq_show(struct seq_file *m, void *data)
 {
 	struct obd_device *obd = m->private;
 	struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
 
-	return seq_printf(m, "%u\n", mdt_cos_is_enabled(mdt));
+	seq_printf(m, "%u\n", mdt_cos_is_enabled(mdt));
+	return 0;
 }
 
 static ssize_t
@@ -625,11 +530,15 @@ mdt_cos_seq_write(struct file *file, const char __user *buffer,
 	struct seq_file   *m = file->private_data;
 	struct obd_device *obd = m->private;
 	struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
-	int val, rc;
+	int rc;
+	__s64 val;
 
-	rc = lprocfs_write_helper(buffer, count, &val);
+	rc = lprocfs_str_to_s64(buffer, count, &val);
 	if (rc)
 		return rc;
+	if (val < INT_MIN || val > INT_MAX)
+		return -ERANGE;
+
 	mdt_enable_cos(mdt, val);
 	return count;
 }
@@ -641,8 +550,9 @@ static int mdt_root_squash_seq_show(struct seq_file *m, void *data)
 	struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
 	struct root_squash_info *squash = &mdt->mdt_squash;
 
-	return seq_printf(m, "%u:%u\n", squash->rsi_uid,
-			  squash->rsi_gid);
+	seq_printf(m, "%u:%u\n", squash->rsi_uid,
+		   squash->rsi_gid);
+	return 0;
 }
 
 static ssize_t
@@ -664,19 +574,19 @@ static int mdt_nosquash_nids_seq_show(struct seq_file *m, void *data)
 	struct obd_device *obd = m->private;
 	struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
 	struct root_squash_info *squash = &mdt->mdt_squash;
-	int len = 0, rc;
+	int len = 0;
 
 	down_read(&squash->rsi_sem);
 	if (!list_empty(&squash->rsi_nosquash_nids)) {
 		len = cfs_print_nidlist(m->buf + m->count, m->size - m->count,
 					&squash->rsi_nosquash_nids);
 		m->count += len;
-		rc = seq_printf(m, "\n");
+		seq_putc(m, '\n');
 	} else
-		rc = seq_printf(m, "NONE\n");
+		seq_puts(m, "NONE\n");
 	up_read(&squash->rsi_sem);
 
-	return rc;
+	return 0;
 }
 
 static ssize_t
@@ -693,126 +603,169 @@ mdt_nosquash_nids_seq_write(struct file *file, const char __user *buffer,
 }
 LPROC_SEQ_FOPS(mdt_nosquash_nids);
 
-static int mdt_som_seq_show(struct seq_file *m, void *data)
+static int mdt_enable_remote_dir_seq_show(struct seq_file *m, void *data)
 {
 	struct obd_device *obd = m->private;
 	struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
 
-	return seq_printf(m, "%sabled\n",
-			  mdt->mdt_som_conf ? "en" : "dis");
+	seq_printf(m, "%u\n", mdt->mdt_enable_remote_dir);
+	return 0;
 }
 
 static ssize_t
-mdt_som_seq_write(struct file *file, const char __user *buffer,
-		  size_t count, loff_t *off)
+mdt_enable_remote_dir_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 mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
-	struct obd_export *exp;
-	char kernbuf[16];
-	unsigned long val = 0;
+	__s64 val;
+	int rc;
 
-        if (count > (sizeof(kernbuf) - 1))
-                return -EINVAL;
+	rc = lprocfs_str_to_s64(buffer, count, &val);
+	if (rc)
+		return rc;
 
-	if (copy_from_user(kernbuf, buffer, count))
-                return -EFAULT;
+	if (val > 1 || val < 0)
+		return -ERANGE;
 
-        kernbuf[count] = '\0';
+	mdt->mdt_enable_remote_dir = val;
+	return count;
+}
+LPROC_SEQ_FOPS(mdt_enable_remote_dir);
 
-        if (!strcmp(kernbuf, "enabled"))
-                val = 1;
-        else if (strcmp(kernbuf, "disabled"))
-                return -EINVAL;
+static int mdt_enable_remote_dir_gid_seq_show(struct seq_file *m, void *data)
+{
+	struct obd_device *obd = m->private;
+	struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
 
-        if (mdt->mdt_som_conf == val)
-                return count;
+	seq_printf(m, "%d\n",
+		  (int)mdt->mdt_enable_remote_dir_gid);
+	return 0;
+}
 
-        if (!obd->obd_process_conf) {
-                CERROR("Temporary SOM change is not supported, use lctl "
-                       "conf_param for permanent setting\n");
-                return count;
-        }
+static ssize_t
+mdt_enable_remote_dir_gid_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 mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
+	__s64 val;
+	int rc;
 
-	/* 1 stands for self export. */
-	list_for_each_entry(exp, &obd->obd_exports, exp_obd_chain) {
-		if (exp == obd->obd_self_export)
-			continue;
-		if (exp_connect_flags(exp) & OBD_CONNECT_MDS_MDS)
-			continue;
-                /* Some clients are already connected, skip the change */
-                LCONSOLE_INFO("%s is already connected, SOM will be %s on "
-                              "the next mount\n", exp->exp_client_uuid.uuid,
-                              val ? "enabled" : "disabled");
-                return count;
-        }
+	rc = lprocfs_str_to_s64(buffer, count, &val);
+	if (rc)
+		return rc;
 
-        mdt->mdt_som_conf = val;
-        LCONSOLE_INFO("Enabling SOM\n");
+	mdt->mdt_enable_remote_dir_gid = val;
+	return count;
+}
+LPROC_SEQ_FOPS(mdt_enable_remote_dir_gid);
+
+/**
+ * Show MDT policy for handling dirty metadata under a lock being cancelled.
+ *
+ * \param[in] m		seq_file handle
+ * \param[in] data	unused for single entry
+ *
+ * \retval		0 on success
+ * \retval		negative value on error
+ */
+static int mdt_slc_seq_show(struct seq_file *m, void *data)
+{
+	struct obd_device *obd = m->private;
+	struct lu_target *tgt = obd->u.obt.obt_lut;
+	char *slc_states[] = {"never", "blocking", "always" };
 
-        return count;
+	seq_printf(m, "%s\n", slc_states[tgt->lut_sync_lock_cancel]);
+	return 0;
 }
-LPROC_SEQ_FOPS(mdt_som);
+LPROC_SEQ_FOPS_RO(mdt_slc);
 
-static int mdt_enable_remote_dir_seq_show(struct seq_file *m, void *data)
+/**
+ * Show MDT async commit count.
+ *
+ * \param[in] m		seq_file handle
+ * \param[in] data	unused for single entry
+ *
+ * \retval		0 on success
+ * \retval		negative value on error
+ */
+static int mdt_async_commit_count_seq_show(struct seq_file *m, void *data)
 {
 	struct obd_device *obd = m->private;
 	struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
 
-	return seq_printf(m, "%u\n", mdt->mdt_enable_remote_dir);
+	seq_printf(m, "%d\n", atomic_read(&mdt->mdt_async_commit_count));
+	return 0;
 }
 
 static ssize_t
-mdt_enable_remote_dir_seq_write(struct file *file, const char __user *buffer,
-				size_t count, loff_t *off)
+mdt_async_commit_count_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 mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
-	__u32 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 < INT_MIN || val > INT_MAX)
 		return -ERANGE;
 
-	mdt->mdt_enable_remote_dir = val;
+	atomic_set(&mdt->mdt_async_commit_count, val);
+
 	return count;
 }
-LPROC_SEQ_FOPS(mdt_enable_remote_dir);
+LPROC_SEQ_FOPS(mdt_async_commit_count);
 
-static int mdt_enable_remote_dir_gid_seq_show(struct seq_file *m, void *data)
+/**
+ * Show MDT sync count.
+ *
+ * \param[in] m		seq_file handle
+ * \param[in] data	unused for single entry
+ *
+ * \retval		0 on success
+ * \retval		negative value on error
+ */
+static int mdt_sync_count_seq_show(struct seq_file *m, void *data)
 {
 	struct obd_device *obd = m->private;
-	struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
+	struct lu_target *tgt = obd->u.obt.obt_lut;
 
-	return seq_printf(m, "%d\n",
-			  (int)mdt->mdt_enable_remote_dir_gid);
+	seq_printf(m, "%d\n", atomic_read(&tgt->lut_sync_count));
+	return 0;
 }
 
 static ssize_t
-mdt_enable_remote_dir_gid_seq_write(struct file *file,
-				    const char __user *buffer,
-				    size_t count, loff_t *off)
+mdt_sync_count_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 mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
-	__u32 val;
+	struct lu_target *tgt = obd->u.obt.obt_lut;
+	__s64 val;
 	int rc;
 
-	rc = lprocfs_write_helper(buffer, count, &val);
+	rc = lprocfs_str_to_s64(buffer, count, &val);
 	if (rc)
 		return rc;
 
-	mdt->mdt_enable_remote_dir_gid = val;
+	if (val < INT_MIN || val > INT_MAX)
+		return -ERANGE;
+
+	atomic_set(&tgt->lut_sync_count, val);
+
 	return count;
 }
-LPROC_SEQ_FOPS(mdt_enable_remote_dir_gid);
+LPROC_SEQ_FOPS(mdt_sync_count);
+
 
 LPROC_SEQ_FOPS_RO_TYPE(mdt, uuid);
 LPROC_SEQ_FOPS_RO_TYPE(mdt, recovery_status);
@@ -825,7 +778,10 @@ LPROC_SEQ_FOPS_RW_TYPE(mdt, ir_factor);
 LPROC_SEQ_FOPS_RW_TYPE(mdt, nid_stats_clear);
 LPROC_SEQ_FOPS(mdt_hsm_cdt_control);
 
-static struct lprocfs_seq_vars lprocfs_mdt_obd_vars[] = {
+LPROC_SEQ_FOPS_RW_TYPE(mdt, recovery_time_hard);
+LPROC_SEQ_FOPS_RW_TYPE(mdt, recovery_time_soft);
+
+static struct lprocfs_vars lprocfs_mdt_obd_vars[] = {
 	{ .name =	"uuid",
 	  .fops =	&mdt_uuid_fops				},
 	{ .name =	"recovery_status",
@@ -842,30 +798,20 @@ static struct lprocfs_seq_vars lprocfs_mdt_obd_vars[] = {
 	  .fops =	&mdt_identity_flush_fops		},
 	{ .name =	"identity_info",
 	  .fops =	&mdt_identity_info_fops			},
-	{ .name =	"capa",
-	  .fops =	&mdt_capa_fops				},
-	{ .name =	"capa_timeout",
-	  .fops =	&mdt_capa_timeout_fops			},
-	{ .name =	"capa_key_timeout",
-	  .fops =	&mdt_ck_timeout_fops			},
-	{ .name =	"capa_count",
-	  .fops =	&mdt_capa_count_fops			},
 	{ .name =	"site_stats",
 	  .fops =	&mdt_site_stats_fops			},
 	{ .name =	"evict_client",
 	  .fops =	&mdt_mds_evict_client_fops		},
+	{ .name =	"evict_tgt_nids",
+	  .fops =	&mdt_evict_tgt_nids_fops		},
 	{ .name =	"hash_stats",
 	  .fops =	&mdt_hash_fops				},
-	{ .name =	"sec_level",
-	  .fops =	&mdt_sec_level_fops			},
 	{ .name =	"commit_on_sharing",
 	  .fops =	&mdt_cos_fops				},
 	{ .name =	"root_squash",
 	  .fops =	&mdt_root_squash_fops			},
 	{ .name =	"nosquash_nids",
 	  .fops =	&mdt_nosquash_nids_fops			},
-	{ .name =	"som",
-	  .fops =	&mdt_som_fops				},
 	{ .name =	"instance",
 	  .fops =	&mdt_target_instance_fops		},
 	{ .name =	"ir_factor",
@@ -878,11 +824,22 @@ static struct lprocfs_seq_vars lprocfs_mdt_obd_vars[] = {
 	  .fops =	&mdt_enable_remote_dir_gid_fops		},
 	{ .name =	"hsm_control",
 	  .fops =	&mdt_hsm_cdt_control_fops		},
-	{ 0 }
+	{ .name =	"recovery_time_hard",
+	  .fops =	&mdt_recovery_time_hard_fops	},
+	{ .name =	"recovery_time_soft",
+	  .fops =	&mdt_recovery_time_soft_fops	},
+	{ .name =	"sync_lock_cancel",
+	  .fops =	&mdt_slc_fops				},
+	{ .name =	"async_commit_count",
+	  .fops =	&mdt_async_commit_count_fops		},
+	{ .name =	"sync_count",
+	  .fops =	&mdt_sync_count_fops			},
+	{ NULL }
 };
 
-int lprocfs_mdt_print_open_files(cfs_hash_t *hs, cfs_hash_bd_t *bd,
-				 struct hlist_node *hnode, void *v)
+static int
+lprocfs_mdt_print_open_files(struct cfs_hash *hs, struct cfs_hash_bd *bd,
+			     struct hlist_node *hnode, void *v)
 {
 	struct obd_export	*exp = cfs_hash_object(hs, hnode);
 	struct seq_file		*seq = v;
@@ -902,7 +859,7 @@ int lprocfs_mdt_print_open_files(cfs_hash_t *hs, cfs_hash_bd_t *bd,
 	return 0;
 }
 
-int lprocfs_mdt_open_files_seq_show(struct seq_file *seq, void *v)
+static int lprocfs_mdt_open_files_seq_show(struct seq_file *seq, void *v)
 {
 	struct nid_stat *stats = seq->private;
 	struct obd_device *obd = stats->nid_obd;