X-Git-Url: https://git.whamcloud.com/?p=fs%2Flustre-release.git;a=blobdiff_plain;f=lustre%2Fmdc%2Flproc_mdc.c;h=a2ca754b25255bbc54e1e450bb2022a501939115;hp=1b39a8e1751b6ff182b15881d220ed4bcba76967;hb=023a9e4cde5498aae89971028dc35c1e3279da5b;hpb=ccabce23bd9e366c345c852f565766a799f61238;ds=sidebyside

diff --git a/lustre/mdc/lproc_mdc.c b/lustre/mdc/lproc_mdc.c
index 1b39a8e..a2ca754 100644
--- a/lustre/mdc/lproc_mdc.c
+++ b/lustre/mdc/lproc_mdc.c
@@ -31,65 +31,127 @@
  */
 #define DEBUG_SUBSYSTEM S_CLASS
 
-#include <linux/version.h>
 #include <linux/vfs.h>
 #include <obd_class.h>
 #include <lprocfs_status.h>
 #include <lustre_osc.h>
 #include <cl_object.h>
-
 #include "mdc_internal.h"
 
-#ifdef CONFIG_PROC_FS
-static int mdc_active_seq_show(struct seq_file *m, void *v)
+static ssize_t active_show(struct kobject *kobj, struct attribute *attr,
+			   char *buf)
 {
-	struct obd_device *dev = m->private;
+	struct obd_device *obd = container_of(kobj, struct obd_device,
+					      obd_kset.kobj);
+	struct obd_import *imp;
+	ssize_t len;
 
-	LPROCFS_CLIMP_CHECK(dev);
-	seq_printf(m, "%d\n", !dev->u.cli.cl_import->imp_deactive);
-	LPROCFS_CLIMP_EXIT(dev);
-	return 0;
+	with_imp_locked(obd, imp, len)
+		len = sprintf(buf, "%d\n", !imp->imp_deactive);
+	return len;
 }
 
-static ssize_t mdc_active_seq_write(struct file *file,
-				    const char __user *buffer,
-				    size_t count, loff_t *off)
+static ssize_t active_store(struct kobject *kobj, struct attribute *attr,
+			    const char *buffer, size_t count)
 {
-	struct obd_device *dev;
+	struct obd_device *obd = container_of(kobj, struct obd_device,
+					      obd_kset.kobj);
+	bool val;
 	int rc;
-	__s64 val;
 
-	dev = ((struct seq_file *)file->private_data)->private;
-	rc = lprocfs_str_to_s64(buffer, count, &val);
+	rc = kstrtobool(buffer, &val);
 	if (rc)
 		return rc;
-	if (val < 0 || val > 1)
-		return -ERANGE;
 
 	/* opposite senses */
-	if (dev->u.cli.cl_import->imp_deactive == val)
-		rc = ptlrpc_set_import_active(dev->u.cli.cl_import, val);
+	if (obd->u.cli.cl_import->imp_deactive == val)
+		rc = ptlrpc_set_import_active(obd->u.cli.cl_import, val);
 	else
-		CDEBUG(D_CONFIG, "activate %llu: ignoring repeat request\n",
+		CDEBUG(D_CONFIG, "activate %u: ignoring repeat request\n",
 		       val);
 
 	return count;
 }
-LPROC_SEQ_FOPS(mdc_active);
+LUSTRE_RW_ATTR(active);
 
-static int mdc_max_dirty_mb_seq_show(struct seq_file *m, void *v)
+static ssize_t max_rpcs_in_flight_show(struct kobject *kobj,
+				       struct attribute *attr,
+				       char *buf)
 {
-	struct obd_device *dev = m->private;
-	struct client_obd *cli = &dev->u.cli;
-	long val;
-	int mult;
+	struct obd_device *obd = container_of(kobj, struct obd_device,
+					      obd_kset.kobj);
+	ssize_t len;
+	u32 max;
 
-	spin_lock(&cli->cl_loi_list_lock);
-	val = cli->cl_dirty_max_pages;
-	spin_unlock(&cli->cl_loi_list_lock);
+	max = obd_get_max_rpcs_in_flight(&obd->u.cli);
+	len = sprintf(buf, "%u\n", max);
+
+	return len;
+}
 
-	mult = 1 << (20 - PAGE_SHIFT);
-	return lprocfs_seq_read_frac_helper(m, val, mult);
+static ssize_t max_rpcs_in_flight_store(struct kobject *kobj,
+					struct attribute *attr,
+					const char *buffer,
+					size_t count)
+{
+	struct obd_device *obd = container_of(kobj, struct obd_device,
+					      obd_kset.kobj);
+	unsigned int val;
+	int rc;
+
+	rc = kstrtouint(buffer, 10, &val);
+	if (rc)
+		return rc;
+
+	rc = obd_set_max_rpcs_in_flight(&obd->u.cli, val);
+	if (rc)
+		count = rc;
+
+	return count;
+}
+LUSTRE_RW_ATTR(max_rpcs_in_flight);
+
+static ssize_t max_mod_rpcs_in_flight_show(struct kobject *kobj,
+					   struct attribute *attr,
+					   char *buf)
+{
+	struct obd_device *obd = container_of(kobj, struct obd_device,
+					      obd_kset.kobj);
+	u16 max;
+
+	max = obd_get_max_mod_rpcs_in_flight(&obd->u.cli);
+	return sprintf(buf, "%hu\n", max);
+}
+
+static ssize_t max_mod_rpcs_in_flight_store(struct kobject *kobj,
+					    struct attribute *attr,
+					    const char *buffer,
+					    size_t count)
+{
+	struct obd_device *obd = container_of(kobj, struct obd_device,
+					      obd_kset.kobj);
+	u16 val;
+	int rc;
+
+	rc = kstrtou16(buffer, 10, &val);
+	if (rc)
+		return rc;
+
+	rc = obd_set_max_mod_rpcs_in_flight(&obd->u.cli, val);
+	if (rc)
+		count = rc;
+
+	return count;
+}
+LUSTRE_RW_ATTR(max_mod_rpcs_in_flight);
+
+static int mdc_max_dirty_mb_seq_show(struct seq_file *m, void *v)
+{
+	struct obd_device *obd = m->private;
+	struct client_obd *cli = &obd->u.cli;
+
+	seq_printf(m, "%lu\n", PAGES_TO_MiB(cli->cl_dirty_max_pages));
+	return 0;
 }
 
 static ssize_t mdc_max_dirty_mb_seq_write(struct file *file,
@@ -97,20 +159,28 @@ static ssize_t mdc_max_dirty_mb_seq_write(struct file *file,
 					  size_t count, loff_t *off)
 {
 	struct seq_file *sfl = file->private_data;
-	struct obd_device *dev = sfl->private;
-	struct client_obd *cli = &dev->u.cli;
-	__s64 pages_number;
+	struct obd_device *obd = sfl->private;
+	struct client_obd *cli = &obd->u.cli;
+	char kernbuf[22] = "";
+	u64 pages_number;
 	int rc;
 
-	rc = lprocfs_str_with_units_to_s64(buffer, count, &pages_number, 'M');
-	if (rc)
-		return rc;
+	if (count >= sizeof(kernbuf))
+		return -EINVAL;
 
-	pages_number >>= PAGE_SHIFT;
+	if (copy_from_user(kernbuf, buffer, count))
+		return -EFAULT;
+	kernbuf[count] = 0;
 
+	rc = sysfs_memparse(kernbuf, count, &pages_number, "MiB");
+	if (rc < 0)
+		return rc;
+
+	/* MB -> pages */
+	pages_number = round_up(pages_number, 1024 * 1024) >> PAGE_SHIFT;
 	if (pages_number <= 0 ||
-	    pages_number >= OSC_MAX_DIRTY_MB_MAX << (20 - PAGE_SHIFT) ||
-	    pages_number > totalram_pages / 4) /* 1/4 of RAM */
+	    pages_number >= MiB_TO_PAGES(OSC_MAX_DIRTY_MB_MAX) ||
+	    pages_number > cfs_totalram_pages() / 4) /* 1/4 of RAM */
 		return -ERANGE;
 
 	spin_lock(&cli->cl_loi_list_lock);
@@ -122,10 +192,47 @@ static ssize_t mdc_max_dirty_mb_seq_write(struct file *file,
 }
 LPROC_SEQ_FOPS(mdc_max_dirty_mb);
 
+static ssize_t contention_seconds_show(struct kobject *kobj,
+				       struct attribute *attr,
+				       char *buf)
+{
+	struct obd_device *obd = container_of(kobj, struct obd_device,
+					      obd_kset.kobj);
+	struct osc_device *od = obd2osc_dev(obd);
+
+	return sprintf(buf, "%lld\n", od->od_contention_time);
+}
+
+static ssize_t contention_seconds_store(struct kobject *kobj,
+					struct attribute *attr,
+					const char *buffer,
+					size_t count)
+{
+	struct obd_device *obd = container_of(kobj, struct obd_device,
+					      obd_kset.kobj);
+	struct osc_device *od = obd2osc_dev(obd);
+	time64_t val;
+	int rc;
+
+	rc = kstrtoll(buffer, 0, &val);
+	if (rc)
+		return rc;
+
+	od->od_contention_time = val;
+
+	return count;
+}
+LUSTRE_RW_ATTR(contention_seconds);
+
+LUSTRE_ATTR(mds_conn_uuid, 0444, conn_uuid_show, NULL);
+LUSTRE_RO_ATTR(conn_uuid);
+
+LUSTRE_RW_ATTR(ping);
+
 static int mdc_cached_mb_seq_show(struct seq_file *m, void *v)
 {
-	struct obd_device *dev = m->private;
-	struct client_obd *cli = &dev->u.cli;
+	struct obd_device *obd = m->private;
+	struct client_obd *cli = &obd->u.cli;
 	int shift = 20 - PAGE_SHIFT;
 
 	seq_printf(m, "used_mb: %ld\n"
@@ -145,9 +252,10 @@ mdc_cached_mb_seq_write(struct file *file, const char __user *buffer,
 			size_t count, loff_t *off)
 {
 	struct seq_file *sfl = file->private_data;
-	struct obd_device *dev = sfl->private;
-	struct client_obd *cli = &dev->u.cli;
-	__s64 pages_number;
+	struct obd_device *obd = sfl->private;
+	struct client_obd *cli = &obd->u.cli;
+	u64 pages_number;
+	const char *tmp;
 	long rc;
 	char kernbuf[128];
 
@@ -158,17 +266,13 @@ mdc_cached_mb_seq_write(struct file *file, const char __user *buffer,
 		return -EFAULT;
 	kernbuf[count] = 0;
 
-	buffer += lprocfs_find_named_value(kernbuf, "used_mb:", &count) -
-		  kernbuf;
-	rc = lprocfs_str_with_units_to_s64(buffer, count, &pages_number, 'M');
-	if (rc)
+	tmp = lprocfs_find_named_value(kernbuf, "used_mb:", &count);
+	rc = sysfs_memparse(tmp, count, &pages_number, "MiB");
+	if (rc < 0)
 		return rc;
 
 	pages_number >>= PAGE_SHIFT;
 
-	if (pages_number < 0)
-		return -ERANGE;
-
 	rc = atomic_long_read(&cli->cl_lru_in_list) - pages_number;
 	if (rc > 0) {
 		struct lu_env *env;
@@ -185,41 +289,10 @@ mdc_cached_mb_seq_write(struct file *file, const char __user *buffer,
 }
 LPROC_SEQ_FOPS(mdc_cached_mb);
 
-static int mdc_contention_seconds_seq_show(struct seq_file *m, void *v)
-{
-	struct obd_device *obd = m->private;
-	struct osc_device *od  = obd2osc_dev(obd);
-
-	seq_printf(m, "%u\n", od->od_contention_time);
-	return 0;
-}
-
-static ssize_t mdc_contention_seconds_seq_write(struct file *file,
-						const char __user *buffer,
-						size_t count, loff_t *off)
-{
-	struct seq_file *sfl = file->private_data;
-	struct obd_device *obd = sfl->private;
-	struct osc_device *od  = obd2osc_dev(obd);
-	int rc;
-	__s64 val;
-
-	rc = lprocfs_str_to_s64(buffer, count, &val);
-	if (rc)
-		return rc;
-	if (val < 0 || val > INT_MAX)
-		return -ERANGE;
-
-	od->od_contention_time = val;
-
-	return count;
-}
-LPROC_SEQ_FOPS(mdc_contention_seconds);
-
 static int mdc_unstable_stats_seq_show(struct seq_file *m, void *v)
 {
-	struct obd_device *dev = m->private;
-	struct client_obd *cli = &dev->u.cli;
+	struct obd_device *obd = m->private;
+	struct client_obd *cli = &obd->u.cli;
 	long pages;
 	int mb;
 
@@ -232,83 +305,13 @@ static int mdc_unstable_stats_seq_show(struct seq_file *m, void *v)
 }
 LPROC_SEQ_FOPS_RO(mdc_unstable_stats);
 
-static int mdc_max_rpcs_in_flight_seq_show(struct seq_file *m, void *v)
-{
-	struct obd_device *dev = m->private;
-	__u32 max;
-
-	max = obd_get_max_rpcs_in_flight(&dev->u.cli);
-	seq_printf(m, "%u\n", max);
-
-	return 0;
-}
-
-static ssize_t mdc_max_rpcs_in_flight_seq_write(struct file *file,
-						const char __user *buffer,
-						size_t count, loff_t *off)
-{
-	struct obd_device *dev;
-	__s64 val;
-	int rc;
-
-	dev = ((struct seq_file *)file->private_data)->private;
-	rc = lprocfs_str_to_s64(buffer, count, &val);
-	if (rc)
-		return rc;
-
-	if (val < 0 || val > UINT_MAX)
-		return -ERANGE;
-
-	rc = obd_set_max_rpcs_in_flight(&dev->u.cli, val);
-	if (rc)
-		return rc;
-
-	return count;
-}
-LPROC_SEQ_FOPS(mdc_max_rpcs_in_flight);
-
-static int mdc_max_mod_rpcs_in_flight_seq_show(struct seq_file *m, void *v)
-{
-	struct obd_device *dev = m->private;
-	__u16 max;
-
-	max = obd_get_max_mod_rpcs_in_flight(&dev->u.cli);
-	seq_printf(m, "%hu\n", max);
-
-	return 0;
-}
-
-static ssize_t mdc_max_mod_rpcs_in_flight_seq_write(struct file *file,
-						    const char __user *buffer,
-						    size_t count, loff_t *off)
-{
-	struct obd_device *dev;
-	__s64 val;
-	int rc;
-
-	dev =  ((struct seq_file *)file->private_data)->private;
-	rc = lprocfs_str_to_s64(buffer, count, &val);
-	if (rc)
-		return rc;
-
-	if (val < 0 || val > USHRT_MAX)
-		return -ERANGE;
-
-	rc = obd_set_max_mod_rpcs_in_flight(&dev->u.cli, val);
-	if (rc)
-		count = rc;
-
-	return count;
-}
-LPROC_SEQ_FOPS(mdc_max_mod_rpcs_in_flight);
-
 static ssize_t mdc_rpc_stats_seq_write(struct file *file,
 				       const char __user *buf,
 				       size_t len, loff_t *off)
 {
 	struct seq_file *seq = file->private_data;
-	struct obd_device *dev = seq->private;
-	struct client_obd *cli = &dev->u.cli;
+	struct obd_device *obd = seq->private;
+	struct client_obd *cli = &obd->u.cli;
 
 	lprocfs_oh_clear(&cli->cl_mod_rpcs_hist);
 
@@ -322,15 +325,14 @@ static ssize_t mdc_rpc_stats_seq_write(struct file *file,
 	return len;
 }
 
-#define pct(a, b) (b ? a * 100 / b : 0)
 static int mdc_rpc_stats_seq_show(struct seq_file *seq, void *v)
 {
-	struct obd_device *dev = seq->private;
-	struct client_obd *cli = &dev->u.cli;
+	struct obd_device *obd = seq->private;
+	struct client_obd *cli = &obd->u.cli;
 	unsigned long read_tot = 0, write_tot = 0, read_cum, write_cum;
 	int i;
 
-	obd_mod_rpc_stats_seq_show(&dev->u.cli, seq);
+	obd_mod_rpc_stats_seq_show(cli, seq);
 
 	spin_lock(&cli->cl_loi_list_lock);
 
@@ -358,7 +360,7 @@ static int mdc_rpc_stats_seq_show(struct seq_file *seq, void *v)
 
 		read_cum += r;
 		write_cum += w;
-		seq_printf(seq, "%d:\t\t%10lu %3lu %3lu   | %10lu %3lu %3lu\n",
+		seq_printf(seq, "%d:\t\t%10lu %3u %3u   | %10lu %3u %3u\n",
 			   1 << i, r, pct(r, read_tot),
 			   pct(read_cum, read_tot), w,
 			   pct(w, write_tot),
@@ -382,7 +384,7 @@ static int mdc_rpc_stats_seq_show(struct seq_file *seq, void *v)
 
 		read_cum += r;
 		write_cum += w;
-		seq_printf(seq, "%d:\t\t%10lu %3lu %3lu   | %10lu %3lu %3lu\n",
+		seq_printf(seq, "%d:\t\t%10lu %3u %3u   | %10lu %3u %3u\n",
 			   i, r, pct(r, read_tot), pct(read_cum, read_tot), w,
 			   pct(w, write_tot), pct(write_cum, write_tot));
 		if (read_cum == read_tot && write_cum == write_tot)
@@ -404,7 +406,7 @@ static int mdc_rpc_stats_seq_show(struct seq_file *seq, void *v)
 
 		read_cum += r;
 		write_cum += w;
-		seq_printf(seq, "%d:\t\t%10lu %3lu %3lu   | %10lu %3lu %3lu\n",
+		seq_printf(seq, "%d:\t\t%10lu %3u %3u   | %10lu %3u %3u\n",
 			   (i == 0) ? 0 : 1 << (i - 1),
 			   r, pct(r, read_tot), pct(read_cum, read_tot),
 			   w, pct(w, write_tot), pct(write_cum, write_tot));
@@ -415,14 +417,13 @@ static int mdc_rpc_stats_seq_show(struct seq_file *seq, void *v)
 
 	return 0;
 }
-#undef pct
 LPROC_SEQ_FOPS(mdc_rpc_stats);
 
 static int mdc_stats_seq_show(struct seq_file *seq, void *v)
 {
 	struct timespec64 now;
-	struct obd_device *dev = seq->private;
-	struct osc_stats *stats = &obd2osc_dev(dev)->od_stats;
+	struct obd_device *obd = seq->private;
+	struct osc_stats *stats = &obd2osc_dev(obd)->od_stats;
 
 	ktime_get_real_ts64(&now);
 
@@ -442,19 +443,46 @@ static ssize_t mdc_stats_seq_write(struct file *file,
 				   size_t len, loff_t *off)
 {
 	struct seq_file *seq = file->private_data;
-	struct obd_device *dev = seq->private;
-	struct osc_stats *stats = &obd2osc_dev(dev)->od_stats;
+	struct obd_device *obd = seq->private;
+	struct osc_stats *stats = &obd2osc_dev(obd)->od_stats;
 
 	memset(stats, 0, sizeof(*stats));
 	return len;
 }
 LPROC_SEQ_FOPS(mdc_stats);
 
-LPROC_SEQ_FOPS_WR_ONLY(mdc, ping);
+static int mdc_dom_min_repsize_seq_show(struct seq_file *m, void *v)
+{
+	struct obd_device *obd = m->private;
+
+	seq_printf(m, "%u\n", obd->u.cli.cl_dom_min_inline_repsize);
+
+	return 0;
+}
+
+static ssize_t mdc_dom_min_repsize_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;
+	unsigned int val;
+	int rc;
+
+	rc = kstrtouint_from_user(buffer, count, 0, &val);
+	if (rc)
+		return rc;
+
+	if (val > MDC_DOM_MAX_INLINE_REPSIZE)
+		return -ERANGE;
+
+	obd->u.cli.cl_dom_min_inline_repsize = val;
+	return count;
+}
+LPROC_SEQ_FOPS(mdc_dom_min_repsize);
 
 LPROC_SEQ_FOPS_RO_TYPE(mdc, connect_flags);
 LPROC_SEQ_FOPS_RO_TYPE(mdc, server_uuid);
-LPROC_SEQ_FOPS_RO_TYPE(mdc, conn_uuid);
 LPROC_SEQ_FOPS_RO_TYPE(mdc, timeouts);
 LPROC_SEQ_FOPS_RO_TYPE(mdc, state);
 LPROC_SEQ_FOPS_RW_TYPE(mdc, obd_max_pages_per_rpc);
@@ -462,29 +490,18 @@ LPROC_SEQ_FOPS_RW_TYPE(mdc, import);
 LPROC_SEQ_FOPS_RW_TYPE(mdc, pinger_recov);
 
 struct lprocfs_vars lprocfs_mdc_obd_vars[] = {
-	{ .name	=	"ping",
-	  .fops	=	&mdc_ping_fops,
-	  .proc_mode =	0222			},
 	{ .name	=	"connect_flags",
 	  .fops	=	&mdc_connect_flags_fops	},
 	{ .name	=	"mds_server_uuid",
 	  .fops	=	&mdc_server_uuid_fops	},
-	{ .name	=	"mds_conn_uuid",
-	  .fops	=	&mdc_conn_uuid_fops	},
-	{ .name	=	"max_pages_per_rpc",
-	  .fops	=	&mdc_obd_max_pages_per_rpc_fops	},
-	{ .name	=	"max_rpcs_in_flight",
-	  .fops	=	&mdc_max_rpcs_in_flight_fops	},
-	{ .name	=	"max_mod_rpcs_in_flight",
-	  .fops	=	&mdc_max_mod_rpcs_in_flight_fops },
-	{ .name	=	"max_dirty_mb",
-	  .fops	=	&mdc_max_dirty_mb_fops		},
+	{ .name =	"max_pages_per_rpc",
+	  .fops =	&mdc_obd_max_pages_per_rpc_fops },
+	{ .name =	"max_dirty_mb",
+	  .fops =	&mdc_max_dirty_mb_fops		},
 	{ .name	=	"mdc_cached_mb",
 	  .fops	=	&mdc_cached_mb_fops		},
 	{ .name	=	"timeouts",
 	  .fops	=	&mdc_timeouts_fops		},
-	{ .name	=	"contention_seconds",
-	  .fops	=	&mdc_contention_seconds_fops	},
 	{ .name	=	"import",
 	  .fops	=	&mdc_import_fops		},
 	{ .name	=	"state",
@@ -493,13 +510,53 @@ struct lprocfs_vars lprocfs_mdc_obd_vars[] = {
 	  .fops	=	&mdc_pinger_recov_fops		},
 	{ .name	=	"rpc_stats",
 	  .fops	=	&mdc_rpc_stats_fops		},
-	{ .name	=	"active",
-	  .fops	=	&mdc_active_fops		},
 	{ .name	=	"unstable_stats",
 	  .fops	=	&mdc_unstable_stats_fops	},
 	{ .name	=	"mdc_stats",
 	  .fops	=	&mdc_stats_fops			},
+	{ .name	=	"mdc_dom_min_repsize",
+	  .fops	=	&mdc_dom_min_repsize_fops	},
 	{ NULL }
 };
 
-#endif /* CONFIG_PROC_FS */
+static struct attribute *mdc_attrs[] = {
+	&lustre_attr_active.attr,
+	&lustre_attr_max_rpcs_in_flight.attr,
+	&lustre_attr_max_mod_rpcs_in_flight.attr,
+	&lustre_attr_contention_seconds.attr,
+	&lustre_attr_mds_conn_uuid.attr,
+	&lustre_attr_conn_uuid.attr,
+	&lustre_attr_ping.attr,
+	NULL,
+};
+
+int mdc_tunables_init(struct obd_device *obd)
+{
+	int rc;
+
+	obd->obd_ktype.default_attrs = mdc_attrs;
+	obd->obd_vars = lprocfs_mdc_obd_vars;
+
+	rc = lprocfs_obd_setup(obd, false);
+	if (rc)
+		goto out_failed;
+#ifdef CONFIG_PROC_FS
+	rc = lprocfs_alloc_md_stats(obd, 0);
+	if (rc) {
+		lprocfs_obd_cleanup(obd);
+		goto out_failed;
+	}
+#endif
+	rc = sptlrpc_lprocfs_cliobd_attach(obd);
+	if (rc) {
+#ifdef CONFIG_PROC_FS
+		lprocfs_free_md_stats(obd);
+#endif
+		lprocfs_obd_cleanup(obd);
+		goto out_failed;
+	}
+	ptlrpc_lprocfs_register_obd(obd);
+
+out_failed:
+	return rc;
+}