X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=lustre%2Fobdclass%2Flprocfs_status.c;h=7d7299c68de4844c47407c97cd2937a3d572c8c3;hb=0c51fa10d3b36eb9810d219a273738f02e56783f;hp=02764bd1e292017fec166d3896b18c7b92daaf60;hpb=807a40c5678109087e2c8759bd86253034804c8d;p=fs%2Flustre-release.git

diff --git a/lustre/obdclass/lprocfs_status.c b/lustre/obdclass/lprocfs_status.c
index 02764bd..7d7299c 100644
--- a/lustre/obdclass/lprocfs_status.c
+++ b/lustre/obdclass/lprocfs_status.c
@@ -27,7 +27,7 @@
  * Copyright (c) 2002, 2010, Oracle and/or its affiliates. All rights reserved.
  * Use is subject to license terms.
  *
- * Copyright (c) 2011, 2014, Intel Corporation.
+ * Copyright (c) 2011, 2015, Intel Corporation.
  */
 /*
  * This file is part of Lustre, http://www.lustre.org/
@@ -47,8 +47,8 @@
 #ifdef CONFIG_PROC_FS
 
 static int lprocfs_no_percpu_stats = 0;
-CFS_MODULE_PARM(lprocfs_no_percpu_stats, "i", int, 0644,
-                "Do not alloc percpu data for lprocfs stats");
+module_param(lprocfs_no_percpu_stats, int, 0644);
+MODULE_PARM_DESC(lprocfs_no_percpu_stats, "Do not alloc percpu data for lprocfs stats");
 
 #define MAX_STRING_SIZE 128
 
@@ -292,7 +292,8 @@ EXPORT_SYMBOL(lprocfs_register);
 /* Generic callbacks */
 int lprocfs_uint_seq_show(struct seq_file *m, void *data)
 {
-	return seq_printf(m, "%u\n", *(unsigned int *)data);
+	seq_printf(m, "%u\n", *(unsigned int *)data);
+	return 0;
 }
 EXPORT_SYMBOL(lprocfs_uint_seq_show);
 
@@ -320,9 +321,10 @@ ssize_t lprocfs_uint_seq_write(struct file *file, const char __user *buffer,
 			       size_t count, loff_t *off)
 {
 	int *data = ((struct seq_file *)file->private_data)->private;
-	int val = 0, rc;
+	int rc;
+	__s64 val = 0;
 
-	rc = lprocfs_write_helper(buffer, count, &val);
+	rc = lprocfs_str_to_s64(buffer, count, &val);
 	if (rc < 0)
 		return rc;
 
@@ -333,7 +335,8 @@ EXPORT_SYMBOL(lprocfs_uint_seq_write);
 int lprocfs_u64_seq_show(struct seq_file *m, void *data)
 {
 	LASSERT(data != NULL);
-	return seq_printf(m, LPU64"\n", *(__u64 *)data);
+	seq_printf(m, LPU64"\n", *(__u64 *)data);
+	return 0;
 }
 EXPORT_SYMBOL(lprocfs_u64_seq_show);
 
@@ -341,7 +344,8 @@ int lprocfs_atomic_seq_show(struct seq_file *m, void *data)
 {
 	atomic_t *atom = data;
 	LASSERT(atom != NULL);
-	return seq_printf(m, "%d\n", atomic_read(atom));
+	seq_printf(m, "%d\n", atomic_read(atom));
+	return 0;
 }
 EXPORT_SYMBOL(lprocfs_atomic_seq_show);
 
@@ -350,14 +354,14 @@ lprocfs_atomic_seq_write(struct file *file, const char __user *buffer,
 			size_t count, loff_t *off)
 {
 	atomic_t *atm = ((struct seq_file *)file->private_data)->private;
-	int val = 0;
+	__s64 val = 0;
 	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)
+	if (val <= 0 || val > INT_MAX)
 		return -ERANGE;
 
 	atomic_set(atm, val);
@@ -370,7 +374,8 @@ int lprocfs_uuid_seq_show(struct seq_file *m, void *data)
 	struct obd_device *obd = data;
 
 	LASSERT(obd != NULL);
-	return seq_printf(m, "%s\n", obd->obd_uuid.uuid);
+	seq_printf(m, "%s\n", obd->obd_uuid.uuid);
+	return 0;
 }
 EXPORT_SYMBOL(lprocfs_uuid_seq_show);
 
@@ -379,7 +384,8 @@ int lprocfs_name_seq_show(struct seq_file *m, void *data)
 	struct obd_device *dev = data;
 
 	LASSERT(dev != NULL);
-	return seq_printf(m, "%s\n", dev->obd_name);
+	seq_printf(m, "%s\n", dev->obd_name);
+	return 0;
 }
 EXPORT_SYMBOL(lprocfs_name_seq_show);
 
@@ -391,7 +397,7 @@ int lprocfs_blksize_seq_show(struct seq_file *m, void *data)
 			    cfs_time_shift_64(-OBD_STATFS_CACHE_SECONDS),
 			    OBD_STATFS_NODELAY);
 	if (!rc)
-		rc = seq_printf(m, "%u\n", osfs.os_bsize);
+		seq_printf(m, "%u\n", osfs.os_bsize);
 	return rc;
 }
 EXPORT_SYMBOL(lprocfs_blksize_seq_show);
@@ -410,7 +416,7 @@ int lprocfs_kbytestotal_seq_show(struct seq_file *m, void *data)
 		while (blk_size >>= 1)
 			result <<= 1;
 
-		rc = seq_printf(m, LPU64"\n", result);
+		seq_printf(m, LPU64"\n", result);
 	}
 	return rc;
 }
@@ -430,7 +436,7 @@ int lprocfs_kbytesfree_seq_show(struct seq_file *m, void *data)
 		while (blk_size >>= 1)
 			result <<= 1;
 
-		rc = seq_printf(m, LPU64"\n", result);
+		seq_printf(m, LPU64"\n", result);
 	}
 	return rc;
 }
@@ -450,7 +456,7 @@ int lprocfs_kbytesavail_seq_show(struct seq_file *m, void *data)
 		while (blk_size >>= 1)
 			result <<= 1;
 
-		rc = seq_printf(m, LPU64"\n", result);
+		seq_printf(m, LPU64"\n", result);
 	}
 	return rc;
 }
@@ -464,7 +470,7 @@ int lprocfs_filestotal_seq_show(struct seq_file *m, void *data)
 			    cfs_time_shift_64(-OBD_STATFS_CACHE_SECONDS),
 			    OBD_STATFS_NODELAY);
 	if (!rc)
-		rc = seq_printf(m, LPU64"\n", osfs.os_files);
+		seq_printf(m, LPU64"\n", osfs.os_files);
 	return rc;
 }
 EXPORT_SYMBOL(lprocfs_filestotal_seq_show);
@@ -477,7 +483,7 @@ int lprocfs_filesfree_seq_show(struct seq_file *m, void *data)
 			    cfs_time_shift_64(-OBD_STATFS_CACHE_SECONDS),
 			    OBD_STATFS_NODELAY);
 	if (!rc)
-		rc = seq_printf(m, LPU64"\n", osfs.os_ffree);
+		seq_printf(m, LPU64"\n", osfs.os_ffree);
 	return rc;
 }
 EXPORT_SYMBOL(lprocfs_filesfree_seq_show);
@@ -493,8 +499,8 @@ int lprocfs_server_uuid_seq_show(struct seq_file *m, void *data)
 	LPROCFS_CLIMP_CHECK(obd);
 	imp = obd->u.cli.cl_import;
 	imp_state_name = ptlrpc_import_state_name(imp->imp_state);
-	rc = seq_printf(m, "%s\t%s%s\n", obd2cli_tgt(obd), imp_state_name,
-			imp->imp_deactive ? "\tDEACTIVATED" : "");
+	seq_printf(m, "%s\t%s%s\n", obd2cli_tgt(obd), imp_state_name,
+		   imp->imp_deactive ? "\tDEACTIVATED" : "");
 
 	LPROCFS_CLIMP_EXIT(obd);
 	return rc;
@@ -512,9 +518,9 @@ int lprocfs_conn_uuid_seq_show(struct seq_file *m, void *data)
 	LPROCFS_CLIMP_CHECK(obd);
 	conn = obd->u.cli.cl_import->imp_connection;
 	if (conn && obd->u.cli.cl_import)
-		rc = seq_printf(m, "%s\n", conn->c_remote_uuid.uuid);
+		seq_printf(m, "%s\n", conn->c_remote_uuid.uuid);
 	else
-		rc = seq_printf(m, "%s\n", "<none>");
+		seq_printf(m, "%s\n", "<none>");
 
 	LPROCFS_CLIMP_EXIT(obd);
 	return rc;
@@ -593,6 +599,7 @@ static void obd_import_flags2str(struct obd_import *imp, struct seq_file *m)
 #undef flag2str
 
 static const char *obd_connect_names[] = {
+	/* flags names  */
 	"read_only",
 	"lov_index",
 	"connect_from_mds",
@@ -652,42 +659,86 @@ static const char *obd_connect_names[] = {
 	"unlink_close",
 	"multi_mod_rpcs",
 	"dir_stripe",
-	"unknown",
+	"subtree",
+	"lock_ahead",
+	"bulk_mbits",
+	"compact_obdo",
+	"second_flags",
+	/* flags2 names */
+	"file_secctx",
 	NULL
 };
 
-static void obd_connect_seq_flags2str(struct seq_file *m, __u64 flags, char *sep)
+static void obd_connect_seq_flags2str(struct seq_file *m, __u64 flags,
+				      __u64 flags2, const char *sep)
 {
 	bool first = true;
-	__u64 mask = 1;
+	__u64 mask;
 	int i;
 
-	for (i = 0; obd_connect_names[i] != NULL; i++, mask <<= 1) {
+	for (i = 0, mask = 1; i < 64; i++, mask <<= 1) {
 		if (flags & mask) {
 			seq_printf(m, "%s%s",
 				   first ? "" : sep, obd_connect_names[i]);
 			first = false;
 		}
 	}
-	if (flags & ~(mask - 1))
+
+	if (flags & ~(mask - 1)) {
 		seq_printf(m, "%sunknown_"LPX64,
 			   first ? "" : sep, flags & ~(mask - 1));
+		first = false;
+	}
+
+	if (!(flags & OBD_CONNECT_FLAGS2) || flags2 == 0)
+		return;
+
+	for (i = 64, mask = 1; obd_connect_names[i] != NULL; i++, mask <<= 1) {
+		if (flags2 & mask) {
+			seq_printf(m, "%s%s",
+				   first ? "" : sep, obd_connect_names[i]);
+			first = false;
+		}
+	}
+
+	if (flags2 & ~(mask - 1)) {
+		seq_printf(m, "%sunknown2_"LPX64,
+			   first ? "" : sep, flags2 & ~(mask - 1));
+		first = false;
+	}
 }
 
-int obd_connect_flags2str(char *page, int count, __u64 flags, char *sep)
+int obd_connect_flags2str(char *page, int count, __u64 flags, __u64 flags2,
+			  const char *sep)
 {
-	__u64 mask = 1;
+	__u64 mask;
 	int i, ret = 0;
 
-	for (i = 0; obd_connect_names[i] != NULL; i++, mask <<= 1) {
+	for (i = 0, mask = 1; i < 64; i++, mask <<= 1) {
 		if (flags & mask)
 			ret += snprintf(page + ret, count - ret, "%s%s",
 					ret ? sep : "", obd_connect_names[i]);
 	}
+
 	if (flags & ~(mask - 1))
 		ret += snprintf(page + ret, count - ret,
 				"%sunknown_"LPX64,
 				ret ? sep : "", flags & ~(mask - 1));
+
+	if (!(flags & OBD_CONNECT_FLAGS2) || flags2 == 0)
+		return ret;
+
+	for (i = 64, mask = 1; obd_connect_names[i] != NULL; i++, mask <<= 1) {
+		if (flags2 & mask)
+			ret += snprintf(page + ret, count - ret, "%s%s",
+					ret ? sep : "", obd_connect_names[i]);
+	}
+
+	if (flags2 & ~(mask - 1))
+		ret += snprintf(page + ret, count - ret,
+				"%sunknown2_"LPX64,
+				ret ? sep : "", flags2 & ~(mask - 1));
+
 	return ret;
 }
 EXPORT_SYMBOL(obd_connect_flags2str);
@@ -701,16 +752,16 @@ static void obd_connect_data_seqprint(struct seq_file *m,
 	flags = ocd->ocd_connect_flags;
 
 	seq_printf(m, "    connect_data:\n"
-		      "       flags: "LPX64"\n"
-		      "       instance: %u\n",
-		      ocd->ocd_connect_flags,
-		      ocd->ocd_instance);
+		   "       flags: "LPX64"\n"
+		   "       instance: %u\n",
+		   ocd->ocd_connect_flags,
+		   ocd->ocd_instance);
 	if (flags & OBD_CONNECT_VERSION)
 		seq_printf(m, "       target_version: %u.%u.%u.%u\n",
-			      OBD_OCD_VERSION_MAJOR(ocd->ocd_version),
-			      OBD_OCD_VERSION_MINOR(ocd->ocd_version),
-			      OBD_OCD_VERSION_PATCH(ocd->ocd_version),
-			      OBD_OCD_VERSION_FIX(ocd->ocd_version));
+			   OBD_OCD_VERSION_MAJOR(ocd->ocd_version),
+			   OBD_OCD_VERSION_MINOR(ocd->ocd_version),
+			   OBD_OCD_VERSION_PATCH(ocd->ocd_version),
+			   OBD_OCD_VERSION_FIX(ocd->ocd_version));
 	if (flags & OBD_CONNECT_MDS)
 		seq_printf(m, "       mdt_index: %d\n", ocd->ocd_group);
 	if (flags & OBD_CONNECT_GRANT)
@@ -721,28 +772,30 @@ static void obd_connect_data_seqprint(struct seq_file *m,
 		seq_printf(m, "       max_brw_size: %d\n", ocd->ocd_brw_size);
 	if (flags & OBD_CONNECT_IBITS)
 		seq_printf(m, "       ibits_known: "LPX64"\n",
-				ocd->ocd_ibits_known);
+			   ocd->ocd_ibits_known);
 	if (flags & OBD_CONNECT_GRANT_PARAM)
 		seq_printf(m, "       grant_block_size: %d\n"
-			      "       grant_inode_size: %d\n"
-			      "       grant_extent_overhead: %d\n",
-			      ocd->ocd_blocksize,
-			      ocd->ocd_inodespace,
-			      ocd->ocd_grant_extent);
+			   "       grant_inode_size: %d\n"
+			   "       grant_max_extent_size: %d\n"
+			   "       grant_extent_tax: %d\n",
+			   1 << ocd->ocd_grant_blkbits,
+			   1 << ocd->ocd_grant_inobits,
+			   ocd->ocd_grant_max_blks << ocd->ocd_grant_blkbits,
+			   ocd->ocd_grant_tax_kb << 10);
 	if (flags & OBD_CONNECT_TRANSNO)
 		seq_printf(m, "       first_transno: "LPX64"\n",
-				ocd->ocd_transno);
+			   ocd->ocd_transno);
 	if (flags & OBD_CONNECT_CKSUM)
 		seq_printf(m, "       cksum_types: %#x\n",
-			      ocd->ocd_cksum_types);
+			   ocd->ocd_cksum_types);
 	if (flags & OBD_CONNECT_MAX_EASIZE)
 		seq_printf(m, "       max_easize: %d\n", ocd->ocd_max_easize);
 	if (flags & OBD_CONNECT_MAXBYTES)
 		seq_printf(m, "       max_object_bytes: "LPU64"\n",
-			      ocd->ocd_maxbytes);
+			   ocd->ocd_maxbytes);
 	if (flags & OBD_CONNECT_MULTIMODRPCS)
 		seq_printf(m, "       max_mod_rpcs: %hu\n",
-			      ocd->ocd_maxmodrpcs);
+			   ocd->ocd_maxmodrpcs);
 }
 
 int lprocfs_import_seq_show(struct seq_file *m, void *data)
@@ -764,23 +817,24 @@ int lprocfs_import_seq_show(struct seq_file *m, void *data)
 	ocd = &imp->imp_connect_data;
 
 	seq_printf(m, "import:\n"
-		      "    name: %s\n"
-		      "    target: %s\n"
-		      "    state: %s\n"
-		      "    connect_flags: [ ",
-		      obd->obd_name,
-		      obd2cli_tgt(obd),
-		      ptlrpc_import_state_name(imp->imp_state));
+		   "    name: %s\n"
+		   "    target: %s\n"
+		   "    state: %s\n"
+		   "    connect_flags: [ ",
+		   obd->obd_name,
+		   obd2cli_tgt(obd),
+		   ptlrpc_import_state_name(imp->imp_state));
 	obd_connect_seq_flags2str(m, imp->imp_connect_data.ocd_connect_flags,
-					", ");
+				  imp->imp_connect_data.ocd_connect_flags2,
+				  ", ");
 	seq_printf(m, " ]\n");
 	obd_connect_data_seqprint(m, ocd);
 	seq_printf(m, "    import_flags: [ ");
 	obd_import_flags2str(imp, m);
 
 	seq_printf(m, " ]\n"
-		      "    connection:\n"
-		      "       failover_nids: [ ");
+		   "    connection:\n"
+		   "       failover_nids: [ ");
 	spin_lock(&imp->imp_lock);
 	j = 0;
 	list_for_each_entry(conn, &imp->imp_conn_list, oic_item) {
@@ -789,17 +843,20 @@ int lprocfs_import_seq_show(struct seq_file *m, void *data)
 		seq_printf(m, "%s%s", j ? ", " : "", nidstr);
 		j++;
 	}
-	libcfs_nid2str_r(imp->imp_connection->c_peer.nid,
-			 nidstr, sizeof(nidstr));
+	if (imp->imp_connection != NULL)
+		libcfs_nid2str_r(imp->imp_connection->c_peer.nid,
+				 nidstr, sizeof(nidstr));
+	else
+		strncpy(nidstr, "<none>", sizeof(nidstr));
 	seq_printf(m, " ]\n"
-		      "       current_connection: %s\n"
-		      "       connection_attempts: %u\n"
-		      "       generation: %u\n"
-		      "       in-progress_invalidations: %u\n",
-		      imp->imp_connection == NULL ? "<none>" : nidstr,
-		      imp->imp_conn_cnt,
-		      imp->imp_generation,
-		      atomic_read(&imp->imp_inval_count));
+		   "       current_connection: %s\n"
+		   "       connection_attempts: %u\n"
+		   "       generation: %u\n"
+		   "       in-progress_invalidations: %u\n",
+		   nidstr,
+		   imp->imp_conn_cnt,
+		   imp->imp_generation,
+		   atomic_read(&imp->imp_inval_count));
 	spin_unlock(&imp->imp_lock);
 
 	if (obd->obd_svc_stats == NULL)
@@ -815,14 +872,14 @@ int lprocfs_import_seq_show(struct seq_file *m, void *data)
 	} else
 		ret.lc_sum = 0;
 	seq_printf(m, "    rpcs:\n"
-		      "       inflight: %u\n"
-		      "       unregistering: %u\n"
-		      "       timeouts: %u\n"
-		      "       avg_waittime: "LPU64" %s\n",
-		      atomic_read(&imp->imp_inflight),
-		      atomic_read(&imp->imp_unregistering),
-		      atomic_read(&imp->imp_timeouts),
-		      ret.lc_sum, header->lc_units);
+		   "       inflight: %u\n"
+		   "       unregistering: %u\n"
+		   "       timeouts: %u\n"
+		   "       avg_waittime: "LPU64" %s\n",
+		   atomic_read(&imp->imp_inflight),
+		   atomic_read(&imp->imp_unregistering),
+		   atomic_read(&imp->imp_timeouts),
+		   ret.lc_sum, header->lc_units);
 
 	k = 0;
 	for(j = 0; j < IMP_AT_MAX_PORTALS; j++) {
@@ -832,18 +889,18 @@ int lprocfs_import_seq_show(struct seq_file *m, void *data)
 			  at_get(&imp->imp_at.iat_service_estimate[j]));
 	}
 	seq_printf(m, "    service_estimates:\n"
-		      "       services: %u sec\n"
-		      "       network: %u sec\n",
-		      k,
-		      at_get(&imp->imp_at.iat_net_latency));
+		   "       services: %u sec\n"
+		   "       network: %u sec\n",
+		   k,
+		   at_get(&imp->imp_at.iat_net_latency));
 
 	seq_printf(m, "    transactions:\n"
-		      "       last_replay: "LPU64"\n"
-		      "       peer_committed: "LPU64"\n"
-		      "       last_checked: "LPU64"\n",
-		      imp->imp_last_replay_transno,
-		      imp->imp_peer_committed_transno,
-		      imp->imp_last_transno_checked);
+		   "       last_replay: "LPU64"\n"
+		   "       peer_committed: "LPU64"\n"
+		   "       last_checked: "LPU64"\n",
+		   imp->imp_last_replay_transno,
+		   imp->imp_peer_committed_transno,
+		   imp->imp_last_transno_checked);
 
 	/* avg data rates */
 	for (rw = 0; rw <= 1; rw++) {
@@ -856,9 +913,9 @@ int lprocfs_import_seq_show(struct seq_file *m, void *data)
 			do_div(sum, ret.lc_count);
 			ret.lc_sum = sum;
 			seq_printf(m, "    %s_data_averages:\n"
-				      "       bytes_per_rpc: "LPU64"\n",
-				      rw ? "write" : "read",
-				      ret.lc_sum);
+				   "       bytes_per_rpc: "LPU64"\n",
+				   rw ? "write" : "read",
+				   ret.lc_sum);
 		}
 		k = (int)ret.lc_sum;
 		j = opcode_offset(OST_READ + rw) + EXTRA_MAX_OPCODES;
@@ -870,11 +927,11 @@ int lprocfs_import_seq_show(struct seq_file *m, void *data)
 			do_div(sum, ret.lc_count);
 			ret.lc_sum = sum;
 			seq_printf(m, "       %s_per_rpc: "LPU64"\n",
-					header->lc_units, ret.lc_sum);
+				   header->lc_units, ret.lc_sum);
 			j = (int)ret.lc_sum;
 			if (j > 0)
 				seq_printf(m, "       MB_per_sec: %u.%.02u\n",
-						k / j, (100 * k / j) % 100);
+					   k / j, (100 * k / j) % 100);
 		}
 	}
 
@@ -974,11 +1031,14 @@ int lprocfs_connect_flags_seq_show(struct seq_file *m, void *data)
 {
 	struct obd_device *obd = data;
 	__u64 flags;
+	__u64 flags2;
 
 	LPROCFS_CLIMP_CHECK(obd);
 	flags = obd->u.cli.cl_import->imp_connect_data.ocd_connect_flags;
+	flags2 = obd->u.cli.cl_import->imp_connect_data.ocd_connect_flags2;
 	seq_printf(m, "flags="LPX64"\n", flags);
-	obd_connect_seq_flags2str(m, flags, "\n");
+	seq_printf(m, "flags2="LPX64"\n", flags2);
+	obd_connect_seq_flags2str(m, flags, flags2, "\n");
 	seq_printf(m, "\n");
 	LPROCFS_CLIMP_EXIT(obd);
 	return 0;
@@ -1059,6 +1119,7 @@ int lprocfs_stats_alloc_one(struct lprocfs_stats *stats, unsigned int cpuid)
 	}
 	return rc;
 }
+EXPORT_SYMBOL(lprocfs_stats_alloc_one);
 
 struct lprocfs_stats *lprocfs_alloc_stats(unsigned int num,
                                           enum lprocfs_stats_flags flags)
@@ -1209,42 +1270,32 @@ static int lprocfs_stats_seq_show(struct seq_file *p, void *v)
 	struct lprocfs_counter_header	*hdr;
 	struct lprocfs_counter		 ctr;
 	int				 idx	= *(loff_t *)v;
-	int				 rc	= 0;
 
 	if (idx == 0) {
 		struct timeval now;
 
 		do_gettimeofday(&now);
-		rc = seq_printf(p, "%-25s %lu.%lu secs.usecs\n",
-				"snapshot_time", now.tv_sec, now.tv_usec);
-		if (rc < 0)
-			return rc;
+		seq_printf(p, "%-25s %lu.%lu secs.usecs\n",
+			   "snapshot_time", now.tv_sec, now.tv_usec);
 	}
 
 	hdr = &stats->ls_cnt_header[idx];
 	lprocfs_stats_collect(stats, idx, &ctr);
 
 	if (ctr.lc_count == 0)
-		goto out;
+		return 0;
 
-	rc = seq_printf(p, "%-25s "LPD64" samples [%s]", hdr->lc_name,
-			ctr.lc_count, hdr->lc_units);
-	if (rc < 0)
-		goto out;
+	seq_printf(p, "%-25s "LPD64" samples [%s]", hdr->lc_name,
+		   ctr.lc_count, hdr->lc_units);
 
 	if ((hdr->lc_config & LPROCFS_CNTR_AVGMINMAX) && ctr.lc_count > 0) {
-		rc = seq_printf(p, " "LPD64" "LPD64" "LPD64,
-				ctr.lc_min, ctr.lc_max, ctr.lc_sum);
-		if (rc < 0)
-			goto out;
+		seq_printf(p, " "LPD64" "LPD64" "LPD64,
+			   ctr.lc_min, ctr.lc_max, ctr.lc_sum);
 		if (hdr->lc_config & LPROCFS_CNTR_STDDEV)
-			rc = seq_printf(p, " "LPD64, ctr.lc_sumsquare);
-		if (rc < 0)
-			goto out;
+			seq_printf(p, " "LPD64, ctr.lc_sumsquare);
 	}
-	rc = seq_printf(p, "\n");
-out:
-	return (rc < 0) ? rc : 0;
+	seq_putc(p, '\n');
+	return 0;
 }
 
 static const struct seq_operations lprocfs_stats_seq_sops = {
@@ -1345,9 +1396,8 @@ EXPORT_SYMBOL(lprocfs_counter_init);
 
 void lprocfs_init_mps_stats(int num_private_stats, struct lprocfs_stats *stats)
 {
-        LPROCFS_MD_OP_INIT(num_private_stats, stats, getstatus);
+	LPROCFS_MD_OP_INIT(num_private_stats, stats, get_root);
         LPROCFS_MD_OP_INIT(num_private_stats, stats, null_inode);
-        LPROCFS_MD_OP_INIT(num_private_stats, stats, find_cbdata);
         LPROCFS_MD_OP_INIT(num_private_stats, stats, close);
         LPROCFS_MD_OP_INIT(num_private_stats, stats, create);
         LPROCFS_MD_OP_INIT(num_private_stats, stats, enqueue);
@@ -1371,8 +1421,6 @@ void lprocfs_init_mps_stats(int num_private_stats, struct lprocfs_stats *stats)
         LPROCFS_MD_OP_INIT(num_private_stats, stats, set_lock_data);
         LPROCFS_MD_OP_INIT(num_private_stats, stats, lock_match);
         LPROCFS_MD_OP_INIT(num_private_stats, stats, cancel_unused);
-        LPROCFS_MD_OP_INIT(num_private_stats, stats, renew_capa);
-        LPROCFS_MD_OP_INIT(num_private_stats, stats, unpack_capa);
         LPROCFS_MD_OP_INIT(num_private_stats, stats, get_remote_perm);
         LPROCFS_MD_OP_INIT(num_private_stats, stats, intent_getattr_async);
         LPROCFS_MD_OP_INIT(num_private_stats, stats, revalidate_lock);
@@ -1505,56 +1553,6 @@ __s64 lprocfs_read_helper(struct lprocfs_counter *lc,
 }
 EXPORT_SYMBOL(lprocfs_read_helper);
 
-int lprocfs_write_helper(const char __user *buffer, unsigned long count,
-                         int *val)
-{
-        return lprocfs_write_frac_helper(buffer, count, val, 1);
-}
-EXPORT_SYMBOL(lprocfs_write_helper);
-
-int lprocfs_write_frac_helper(const char __user *buffer, unsigned long count,
-                              int *val, int mult)
-{
-        char kernbuf[20], *end, *pbuf;
-
-        if (count > (sizeof(kernbuf) - 1))
-                return -EINVAL;
-
-	if (copy_from_user(kernbuf, buffer, count))
-                return -EFAULT;
-
-        kernbuf[count] = '\0';
-        pbuf = kernbuf;
-        if (*pbuf == '-') {
-                mult = -mult;
-                pbuf++;
-        }
-
-        *val = (int)simple_strtoul(pbuf, &end, 10) * mult;
-        if (pbuf == end)
-                return -EINVAL;
-
-        if (end != NULL && *end == '.') {
-                int temp_val, pow = 1;
-                int i;
-
-                pbuf = end + 1;
-                if (strlen(pbuf) > 5)
-                        pbuf[5] = '\0'; /*only allow 5bits fractional*/
-
-                temp_val = (int)simple_strtoul(pbuf, &end, 10) * mult;
-
-                if (pbuf < end) {
-                        for (i = 0; i < (end - pbuf); i++)
-                                pow *= 10;
-
-                        *val += temp_val / pow;
-                }
-        }
-        return 0;
-}
-EXPORT_SYMBOL(lprocfs_write_frac_helper);
-
 int lprocfs_read_frac_helper(char *buffer, unsigned long count, long val,
                              int mult)
 {
@@ -1634,77 +1632,309 @@ int lprocfs_seq_read_frac_helper(struct seq_file *m, long val, int mult)
 }
 EXPORT_SYMBOL(lprocfs_seq_read_frac_helper);
 
-int lprocfs_write_u64_helper(const char __user *buffer, unsigned long count,
-			     __u64 *val)
+/* Obtains the conversion factor for the unit specified */
+static int get_mult(char unit, __u64 *mult)
+{
+	__u64 units = 1;
+
+	switch (unit) {
+	/* peta, tera, giga, mega, and kilo */
+	case 'p':
+	case 'P':
+		units <<= 10;
+	case 't':
+	case 'T':
+		units <<= 10;
+	case 'g':
+	case 'G':
+		units <<= 10;
+	case 'm':
+	case 'M':
+		units <<= 10;
+	case 'k':
+	case 'K':
+		units <<= 10;
+		break;
+	/* some tests expect % to be accepted */
+	case '%':
+		units = 1;
+		break;
+	default:
+		return -EINVAL;
+	}
+
+	*mult = units;
+
+	return 0;
+}
+
+/*
+ * Ensures the numeric string is valid. The function provides the final
+ * multiplier in the case a unit exists at the end of the string. It also
+ * locates the start of the whole and fractional parts (if any). This
+ * function modifies the string so kstrtoull can be used to parse both
+ * the whole and fraction portions. This function also figures out
+ * the base of the number.
+ */
+static int preprocess_numeric_str(char *buffer, __u64 *mult, __u64 def_mult,
+				  bool allow_units, char **whole, char **frac,
+				  unsigned int *base)
 {
-        return lprocfs_write_frac_u64_helper(buffer, count, val, 1);
+	bool hit_decimal = false;
+	bool hit_unit = false;
+	int rc = 0;
+	char *start;
+	*mult = def_mult;
+	*whole = NULL;
+	*frac = NULL;
+	*base = 10;
+
+	/* a hex string if it starts with "0x" */
+	if (buffer[0] == '0' && tolower(buffer[1]) == 'x') {
+		*base = 16;
+		buffer += 2;
+	}
+
+	start = buffer;
+
+	while (*buffer) {
+		/* allow for a single new line before the null terminator */
+		if (*buffer == '\n') {
+			*buffer = '\0';
+			buffer++;
+
+			if (*buffer)
+				return -EINVAL;
+
+			break;
+		}
+
+		/* any chars after our unit indicates a malformed string */
+		if (hit_unit)
+			return -EINVAL;
+
+		/* ensure we only hit one decimal */
+		if (*buffer == '.') {
+			if (hit_decimal)
+				return -EINVAL;
+
+			/* if past start, there's a whole part */
+			if (start != buffer)
+				*whole = start;
+
+			*buffer = '\0';
+			start = buffer + 1;
+			hit_decimal = true;
+		} else if (!isdigit(*buffer) &&
+			   !(*base == 16 && isxdigit(*buffer))) {
+			if (allow_units) {
+				/* if we allow units, attempt to get mult */
+				hit_unit = true;
+				rc = get_mult(*buffer, mult);
+				if (rc)
+					return rc;
+
+				/* string stops here, but keep processing */
+				*buffer = '\0';
+			} else {
+				/* bad string */
+				return -EINVAL;
+			}
+		}
+
+		buffer++;
+	}
+
+	if (hit_decimal) {
+		/* hit a decimal, make sure there's a fractional part */
+		if (!*start)
+			return -EINVAL;
+
+		*frac = start;
+	} else {
+		/* didn't hit a decimal, but may have a whole part */
+		if (start != buffer && *start)
+			*whole = start;
+	}
+
+	/* malformed string if we didn't get anything */
+	if (!*frac && !*whole)
+		return -EINVAL;
+
+	return 0;
 }
-EXPORT_SYMBOL(lprocfs_write_u64_helper);
 
-int lprocfs_write_frac_u64_helper(const char __user *buffer,
-				  unsigned long count,
-				  __u64 *val, int mult)
+/*
+ * Parses a numeric string which can contain a whole and fraction portion
+ * into a __u64. Accepts a multiplier to apply to the value parsed. Also
+ * allows the string to have a unit at the end. The function handles
+ * wrapping of the final unsigned value.
+ */
+static int str_to_u64_parse(char *buffer, unsigned long count,
+			    __u64 *val, __u64 def_mult, bool allow_units)
 {
-        char kernbuf[22], *end, *pbuf;
-        __u64 whole, frac = 0, units;
-        unsigned frac_d = 1;
+	__u64 whole = 0;
+	__u64 frac = 0;
+	unsigned int frac_d = 1;
+	__u64 wrap_indicator = ULLONG_MAX;
+	int rc = 0;
+	__u64 mult;
+	char *strwhole;
+	char *strfrac;
+	unsigned int base = 10;
 
-        if (count > (sizeof(kernbuf) - 1))
-                return -EINVAL;
+	rc = preprocess_numeric_str(buffer, &mult, def_mult, allow_units,
+				    &strwhole, &strfrac, &base);
 
-	if (copy_from_user(kernbuf, buffer, count))
-                return -EFAULT;
+	if (rc)
+		return rc;
 
-        kernbuf[count] = '\0';
-        pbuf = kernbuf;
-        if (*pbuf == '-') {
-                mult = -mult;
-                pbuf++;
-        }
+	if (mult == 0) {
+		*val = 0;
+		return 0;
+	}
 
-        whole = simple_strtoull(pbuf, &end, 10);
-        if (pbuf == end)
-                return -EINVAL;
+	/* the multiplier limits how large the value can be */
+	wrap_indicator /=  mult;
+
+	if (strwhole) {
+		rc = kstrtoull(strwhole, base, &whole);
+		if (rc)
+			return rc;
 
-        if (end != NULL && *end == '.') {
-                int i;
-                pbuf = end + 1;
+		if (whole > wrap_indicator)
+			return -ERANGE;
 
-                /* need to limit frac_d to a __u32 */
-                if (strlen(pbuf) > 10)
-                        pbuf[10] = '\0';
+		whole *= mult;
+	}
 
-                frac = simple_strtoull(pbuf, &end, 10);
-                /* count decimal places */
-                for (i = 0; i < (end - pbuf); i++)
-                        frac_d *= 10;
-        }
+	if (strfrac) {
+		if (strlen(strfrac) > 10)
+			strfrac[10] = '\0';
+
+		rc = kstrtoull(strfrac, base, &frac);
+		if (rc)
+			return rc;
 
-        units = 1;
-	if (end != NULL) {
-		switch (*end) {
-		case 'p': case 'P':
-			units <<= 10;
-		case 't': case 'T':
-			units <<= 10;
-		case 'g': case 'G':
-			units <<= 10;
-		case 'm': case 'M':
-			units <<= 10;
-		case 'k': case 'K':
-			units <<= 10;
+		/* determine power of fractional portion */
+		while (*strfrac) {
+			frac_d *= base;
+			strfrac++;
 		}
+
+		/* fractional portion is too large to perform calculation */
+		if (frac > wrap_indicator)
+			return -ERANGE;
+
+		frac *= mult;
+		do_div(frac, frac_d);
 	}
-        /* Specified units override the multiplier */
-	if (units > 1)
-                mult = mult < 0 ? -units : units;
 
-        frac *= mult;
-        do_div(frac, frac_d);
-        *val = whole * mult + frac;
-        return 0;
+	/* check that the sum of whole and fraction fits in u64 */
+	if (whole > (ULLONG_MAX - frac))
+		return -ERANGE;
+
+	*val = whole + frac;
+
+	return 0;
+}
+
+/*
+ * This function parses numeric/hex strings into __s64. It accepts a multiplier
+ * which will apply to the value parsed. It also can allow the string to
+ * have a unit as the last character. The function handles overflow/underflow
+ * of the signed integer.
+ */
+static int str_to_s64_internal(const char __user *buffer, unsigned long count,
+			       __s64 *val, __u64 def_mult, bool allow_units)
+{
+	char kernbuf[22];
+	__u64 tmp;
+	unsigned int offset = 0;
+	int signed sign = 1;
+	__u64 max = LLONG_MAX;
+	int rc = 0;
+
+	if (count > (sizeof(kernbuf) - 1))
+		return -EINVAL;
+
+	if (copy_from_user(kernbuf, buffer, count))
+		return -EFAULT;
+
+	kernbuf[count] = '\0';
+
+	/* keep track of our sign */
+	if (*kernbuf == '-') {
+		sign = -1;
+		offset++;
+		/* equivalent to max = -LLONG_MIN, avoids overflow */
+		max++;
+	}
+
+	rc = str_to_u64_parse(kernbuf + offset, count - offset,
+			      &tmp, def_mult, allow_units);
+	if (rc)
+		return rc;
+
+	/* check for overflow/underflow */
+	if (max < tmp)
+		return -ERANGE;
+
+	*val = (__s64)tmp * sign;
+
+	return 0;
+}
+
+/**
+ * Convert a user string into a signed 64 bit number. This function produces
+ * an error when the value parsed from the string underflows or
+ * overflows. This function accepts strings which contain digits and
+ * optionally a decimal or hex strings which are prefixed with "0x".
+ *
+ * \param[in] buffer	string consisting of numbers and optionally a decimal
+ * \param[in] count	buffer length
+ * \param[in] val	if successful, the value represented by the string
+ *
+ * \retval		0 on success
+ * \retval		negative number on error
+ */
+int lprocfs_str_to_s64(const char __user *buffer, unsigned long count,
+		       __s64 *val)
+{
+	return str_to_s64_internal(buffer, count, val, 1, false);
+}
+EXPORT_SYMBOL(lprocfs_str_to_s64);
+
+/**
+ * Convert a user string into a signed 64 bit number. This function produces
+ * an error when the value parsed from the string times multiplier underflows or
+ * overflows. This function only accepts strings that contains digits, an
+ * optional decimal, and a char representing a unit at the end. If a unit is
+ * specified in the string, the multiplier provided by the caller is ignored.
+ * This function can also accept hexadecimal strings which are prefixed with
+ * "0x".
+ *
+ * \param[in] buffer	string consisting of numbers, a decimal, and a unit
+ * \param[in] count	buffer length
+ * \param[in] val	if successful, the value represented by the string
+ * \param[in] defunit	default unit if string doesn't contain one
+ *
+ * \retval		0 on success
+ * \retval		negative number on error
+ */
+int lprocfs_str_with_units_to_s64(const char __user *buffer,
+				  unsigned long count, __s64 *val, char defunit)
+{
+	__u64 mult;
+	int rc;
+
+	rc = get_mult(defunit, &mult);
+	if (rc)
+		return rc;
+
+	return str_to_s64_internal(buffer, count, val, mult, true);
 }
-EXPORT_SYMBOL(lprocfs_write_frac_u64_helper);
+EXPORT_SYMBOL(lprocfs_str_with_units_to_s64);
 
 static char *lprocfs_strnstr(const char *s1, const char *s2, size_t len)
 {
@@ -1843,12 +2073,11 @@ int lprocfs_obd_max_pages_per_rpc_seq_show(struct seq_file *m, void *data)
 {
 	struct obd_device *dev = data;
 	struct client_obd *cli = &dev->u.cli;
-	int rc;
 
 	spin_lock(&cli->cl_loi_list_lock);
-	rc = seq_printf(m, "%d\n", cli->cl_max_pages_per_rpc);
+	seq_printf(m, "%d\n", cli->cl_max_pages_per_rpc);
 	spin_unlock(&cli->cl_loi_list_lock);
-	return rc;
+	return 0;
 }
 EXPORT_SYMBOL(lprocfs_obd_max_pages_per_rpc_seq_show);
 
@@ -1921,6 +2150,7 @@ int lprocfs_wr_nosquash_nids(const char __user *buffer, unsigned long count,
 	char *kernbuf = NULL;
 	char *errmsg;
 	struct list_head tmp;
+	int len = count;
 	ENTRY;
 
 	if (count > 4096) {
@@ -1940,9 +2170,10 @@ int lprocfs_wr_nosquash_nids(const char __user *buffer, unsigned long count,
 	kernbuf[count] = '\0';
 
 	if (count > 0 && kernbuf[count - 1] == '\n')
-		kernbuf[count - 1] = '\0';
+		len = count - 1;
 
-	if (strcmp(kernbuf, "NONE") == 0 || strcmp(kernbuf, "clear") == 0) {
+	if ((len == 4 && strncmp(kernbuf, "NONE", len) == 0) ||
+	    (len == 5 && strncmp(kernbuf, "clear", len) == 0)) {
 		/* empty string is special case */
 		down_write(&squash->rsi_sem);
 		if (!list_empty(&squash->rsi_nosquash_nids))