X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=lustre%2Fobdclass%2Flprocfs_status.c;h=9b39be3972cd2b8d164c81710300f34f0acee2fd;hb=62660c799be886e557ae0426126fc3e4b61927d4;hp=8b52d52933f5538de651c8028c4f1c8a5ce48a0a;hpb=6f827e863f99f21fc03c6fa55fe7fd4a74966c7e;p=fs%2Flustre-release.git

diff --git a/lustre/obdclass/lprocfs_status.c b/lustre/obdclass/lprocfs_status.c
index 8b52d52..9b39be3 100644
--- a/lustre/obdclass/lprocfs_status.c
+++ b/lustre/obdclass/lprocfs_status.c
@@ -41,7 +41,7 @@
 #define DEBUG_SUBSYSTEM S_CLASS
 
 #ifndef __KERNEL__
-# include <liblustre.h>
+#include <liblustre.h>
 #endif
 
 #include <obd_class.h>
@@ -56,24 +56,23 @@ CFS_MODULE_PARM(lprocfs_no_percpu_stats, "i", int, 0644,
 
 #define MAX_STRING_SIZE 128
 
-/* for bug 10866, global variable */
-DECLARE_RWSEM(_lprocfs_lock);
-EXPORT_SYMBOL(_lprocfs_lock);
-
 int lprocfs_single_release(struct inode *inode, struct file *file)
 {
-        LPROCFS_EXIT();
         return single_release(inode, file);
 }
 EXPORT_SYMBOL(lprocfs_single_release);
 
 int lprocfs_seq_release(struct inode *inode, struct file *file)
 {
-        LPROCFS_EXIT();
         return seq_release(inode, file);
 }
 EXPORT_SYMBOL(lprocfs_seq_release);
 
+#ifndef HAVE_ONLY_PROCFS_SEQ
+/* for b=10866, global variable */
+DECLARE_RWSEM(_lprocfs_lock);
+EXPORT_SYMBOL(_lprocfs_lock);
+
 static struct proc_dir_entry *__lprocfs_srch(struct proc_dir_entry *head,
                                              const char *name)
 {
@@ -111,6 +110,7 @@ EXPORT_SYMBOL(lprocfs_srch);
    the page pointer for the next write into the buffer, incrementing the total
    length written to the buffer, and decrementing the size left in the
    buffer. */
+#ifdef HAVE_SERVER_SUPPORT
 static int lprocfs_obd_snprintf(char **page, int end, int *len,
                                 const char *format, ...)
 {
@@ -127,11 +127,15 @@ static int lprocfs_obd_snprintf(char **page, int end, int *len,
         *page += n; *len += n;
         return n;
 }
+#endif	/* HAVE_SERVER_SUPPORT */
+#endif	/* HAVE_ONLY_PROCFS_SEQ */
 
 cfs_proc_dir_entry_t *lprocfs_add_simple(struct proc_dir_entry *root,
                                          char *name,
-                                         read_proc_t *read_proc,
-                                         write_proc_t *write_proc,
+#ifndef HAVE_ONLY_PROCFS_SEQ
+					 read_proc_t *read_proc,
+					 write_proc_t *write_proc,
+#endif
                                          void *data,
                                          struct file_operations *fops)
 {
@@ -140,25 +144,40 @@ cfs_proc_dir_entry_t *lprocfs_add_simple(struct proc_dir_entry *root,
 
         if (root == NULL || name == NULL)
                 return ERR_PTR(-EINVAL);
-        if (read_proc)
-                mode = 0444;
-        if (write_proc)
-                mode |= 0200;
-        if (fops)
-                mode = 0644;
-        LPROCFS_WRITE_ENTRY();
-        proc = create_proc_entry(name, mode, root);
-        if (!proc) {
-                CERROR("LprocFS: No memory to create /proc entry %s", name);
-                LPROCFS_WRITE_EXIT();
-                return ERR_PTR(-ENOMEM);
-        }
-        proc->read_proc = read_proc;
-        proc->write_proc = write_proc;
-        proc->data = data;
-        if (fops)
-                proc->proc_fops = fops;
-        LPROCFS_WRITE_EXIT();
+
+	if (!fops) {
+#ifndef HAVE_ONLY_PROCFS_SEQ
+		if (read_proc)
+			mode = 0444;
+		if (write_proc)
+			mode |= 0200;
+
+		LPROCFS_WRITE_ENTRY();
+		proc = create_proc_entry(name, mode, root);
+		if (!proc) {
+			CERROR("LprocFS: No memory to create /proc entry %s", name);
+			LPROCFS_WRITE_EXIT();
+			return ERR_PTR(-ENOMEM);
+		}
+		proc->read_proc = read_proc;
+		proc->write_proc = write_proc;
+		proc->data = data;
+		LPROCFS_WRITE_EXIT();
+#else
+		return ERR_PTR(-EINVAL);
+#endif
+	} else {
+		if (fops->read)
+			mode = 0444;
+		if (fops->write)
+			mode |= 0200;
+		proc = proc_create_data(name, mode, root, fops, data);
+		if (!proc) {
+			CERROR("LprocFS: No memory to create /proc entry %s",
+			       name);
+			return ERR_PTR(-ENOMEM);
+		}
+	}
         return proc;
 }
 EXPORT_SYMBOL(lprocfs_add_simple);
@@ -191,6 +210,7 @@ struct proc_dir_entry *lprocfs_add_symlink(const char *name,
 }
 EXPORT_SYMBOL(lprocfs_add_symlink);
 
+#ifndef HAVE_ONLY_PROCFS_SEQ
 static ssize_t lprocfs_fops_read(struct file *f, char __user *buf,
                                  size_t size, loff_t *ppos)
 {
@@ -205,7 +225,7 @@ static ssize_t lprocfs_fops_read(struct file *f, char __user *buf,
         if (page == NULL)
                 return -ENOMEM;
 
-        if (LPROCFS_ENTRY_AND_CHECK(dp)) {
+	if (LPROCFS_ENTRY_CHECK(dp)) {
                 rc = -ENOENT;
                 goto out;
         }
@@ -214,7 +234,6 @@ static ssize_t lprocfs_fops_read(struct file *f, char __user *buf,
         if (dp->read_proc)
 		rc = dp->read_proc(page, &start, *ppos, PAGE_CACHE_SIZE,
                                    &eof, dp->data);
-        LPROCFS_EXIT();
         if (rc <= 0)
                 goto out;
 
@@ -250,11 +269,10 @@ static ssize_t lprocfs_fops_write(struct file *f, const char __user *buf,
         struct proc_dir_entry *dp = PDE(f->f_dentry->d_inode);
         int rc = -EIO;
 
-        if (LPROCFS_ENTRY_AND_CHECK(dp))
+	if (LPROCFS_ENTRY_CHECK(dp))
                 return -ENOENT;
         if (dp->write_proc)
                 rc = dp->write_proc(f, buf, size, dp->data);
-        LPROCFS_EXIT();
         return rc;
 }
 
@@ -263,7 +281,11 @@ static struct file_operations lprocfs_generic_fops = {
         .read = lprocfs_fops_read,
         .write = lprocfs_fops_write,
 };
+#else
+static struct file_operations lprocfs_generic_fops = { };
+#endif
 
+#ifdef HAVE_SERVER_SUPPORT
 int lprocfs_evict_client_open(struct inode *inode, struct file *f)
 {
         struct proc_dir_entry *dp = PDE(f->f_dentry->d_inode);
@@ -276,13 +298,13 @@ int lprocfs_evict_client_open(struct inode *inode, struct file *f)
 
 int lprocfs_evict_client_release(struct inode *inode, struct file *f)
 {
-        struct proc_dir_entry *dp = PDE(f->f_dentry->d_inode);
-        struct obd_device *obd = dp->data;
+	struct proc_dir_entry *dp = PDE(f->f_dentry->d_inode);
+	struct obd_device *obd = dp->data;
 
-        cfs_atomic_dec(&obd->obd_evict_inprogress);
-        cfs_waitq_signal(&obd->obd_evict_inprogress_waitq);
+	cfs_atomic_dec(&obd->obd_evict_inprogress);
+	wake_up(&obd->obd_evict_inprogress_waitq);
 
-        return 0;
+	return 0;
 }
 
 struct file_operations lprocfs_evict_client_fops = {
@@ -293,7 +315,9 @@ struct file_operations lprocfs_evict_client_fops = {
         .release = lprocfs_evict_client_release,
 };
 EXPORT_SYMBOL(lprocfs_evict_client_fops);
+#endif
 
+#ifndef HAVE_ONLY_PROCFS_SEQ
 static int __lprocfs_add_vars(struct proc_dir_entry *root,
 			      struct lprocfs_vars *list,
 			      void *data)
@@ -370,6 +394,21 @@ out:
         return rc;
 }
 
+int lprocfs_add_vars(struct proc_dir_entry *root, struct lprocfs_vars *list,
+		     void *data)
+{
+	int rc = 0;
+
+	LPROCFS_WRITE_ENTRY();
+	rc = __lprocfs_add_vars(root, list, data);
+	LPROCFS_WRITE_EXIT();
+
+	return rc;
+}
+EXPORT_SYMBOL(lprocfs_add_vars);
+
+#endif
+
 /**
  * Add /proc entries.
  *
@@ -381,19 +420,37 @@ out:
  * \retval 0   on success
  *         < 0 on error
  */
-int lprocfs_add_vars(struct proc_dir_entry *root, struct lprocfs_vars *list,
+int
+lprocfs_seq_add_vars(struct proc_dir_entry *root, struct lprocfs_seq_vars *list,
 		     void *data)
 {
-	int rc;
+	if (root == NULL || list == NULL)
+		return -EINVAL;
 
-	LPROCFS_WRITE_ENTRY();
-	rc = __lprocfs_add_vars(root, list, data);
-	LPROCFS_WRITE_EXIT();
+	while (list->name != NULL) {
+		struct proc_dir_entry *proc;
+		mode_t mode = 0;
 
-	return rc;
+		if (list->proc_mode != 0000) {
+			mode = list->proc_mode;
+		} else if (list->fops) {
+			if (list->fops->read)
+				mode = 0444;
+			if (list->fops->write)
+				mode |= 0200;
+		}
+		proc = proc_create_data(list->name, mode, root,
+					list->fops ?: &lprocfs_generic_fops,
+					list->data ?: data);
+		if (proc == NULL)
+			return -ENOMEM;
+		list++;
+	}
+	return 0;
 }
-EXPORT_SYMBOL(lprocfs_add_vars);
+EXPORT_SYMBOL(lprocfs_seq_add_vars);
 
+#ifndef HAVE_ONLY_PROCFS_SEQ
 void lprocfs_remove_nolock(struct proc_dir_entry **proot)
 {
 	struct proc_dir_entry *root = *proot;
@@ -426,12 +483,18 @@ void lprocfs_remove_nolock(struct proc_dir_entry **proot)
                         break;
         }
 }
+#endif
 
 void lprocfs_remove(struct proc_dir_entry **rooth)
 {
+#ifndef HAVE_ONLY_PROCFS_SEQ
 	LPROCFS_WRITE_ENTRY(); /* search vs remove race */
 	lprocfs_remove_nolock(rooth);
 	LPROCFS_WRITE_EXIT();
+#else
+	proc_remove(*rooth);
+	*rooth = NULL;
+#endif
 }
 EXPORT_SYMBOL(lprocfs_remove);
 
@@ -442,6 +505,7 @@ void lprocfs_remove_proc_entry(const char *name, struct proc_dir_entry *parent)
 }
 EXPORT_SYMBOL(lprocfs_remove_proc_entry);
 
+#ifndef HAVE_ONLY_PROCFS_SEQ
 void lprocfs_try_remove_proc_entry(const char *name,
 				   struct proc_dir_entry *parent)
 {
@@ -515,19 +579,35 @@ struct proc_dir_entry *lprocfs_register(const char *name,
 	}
 out:
 	LPROCFS_WRITE_EXIT();
-
 	return entry;
 }
 EXPORT_SYMBOL(lprocfs_register);
+#endif
+
+struct proc_dir_entry *
+lprocfs_seq_register(const char *name, struct proc_dir_entry *parent,
+		     struct lprocfs_seq_vars *list, void *data)
+{
+	struct proc_dir_entry *newchild;
+
+	newchild = proc_mkdir(name, parent);
+	if (newchild != NULL && list != NULL) {
+		int rc = lprocfs_seq_add_vars(newchild, list, data);
+		if (rc) {
+			lprocfs_remove(&newchild);
+			return ERR_PTR(rc);
+		}
+	}
+	return newchild;
+}
+EXPORT_SYMBOL(lprocfs_seq_register);
 
 /* Generic callbacks */
-int lprocfs_rd_uint(char *page, char **start, off_t off,
-                    int count, int *eof, void *data)
+int lprocfs_uint_seq_show(struct seq_file *m, void *data)
 {
-        unsigned int *temp = data;
-        return snprintf(page, count, "%u\n", *temp);
+	return seq_printf(m, "%u\n", *(unsigned int *)data);
 }
-EXPORT_SYMBOL(lprocfs_rd_uint);
+EXPORT_SYMBOL(lprocfs_uint_seq_show);
 
 int lprocfs_wr_uint(struct file *file, const char *buffer,
                     unsigned long count, void *data)
@@ -549,6 +629,666 @@ int lprocfs_wr_uint(struct file *file, const char *buffer,
 }
 EXPORT_SYMBOL(lprocfs_wr_uint);
 
+ssize_t lprocfs_uint_seq_write(struct file *file, const char *buffer,
+			       size_t count, loff_t *off)
+{
+	int *data = ((struct seq_file *)file->private_data)->private;
+	int val = 0, rc;
+
+	rc = lprocfs_write_helper(buffer, count, &val);
+	if (rc < 0)
+		return rc;
+
+	return lprocfs_wr_uint(file, buffer, count, data);
+}
+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);
+}
+EXPORT_SYMBOL(lprocfs_u64_seq_show);
+
+int lprocfs_atomic_seq_show(struct seq_file *m, void *data)
+{
+	cfs_atomic_t *atom = data;
+	LASSERT(atom != NULL);
+	return seq_printf(m, "%d\n", atomic_read(atom));
+}
+EXPORT_SYMBOL(lprocfs_atomic_seq_show);
+
+ssize_t
+lprocfs_atomic_seq_write(struct file *file, const char *buffer,
+			size_t count, loff_t *off)
+{
+	cfs_atomic_t *atm = ((struct seq_file *)file->private_data)->private;
+	int val = 0;
+	int rc;
+
+	rc = lprocfs_write_helper(buffer, count, &val);
+	if (rc < 0)
+		return rc;
+
+	if (val <= 0)
+		return -ERANGE;
+
+	cfs_atomic_set(atm, val);
+	return count;
+}
+EXPORT_SYMBOL(lprocfs_atomic_seq_write);
+
+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);
+}
+EXPORT_SYMBOL(lprocfs_uuid_seq_show);
+
+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);
+}
+EXPORT_SYMBOL(lprocfs_name_seq_show);
+
+int lprocfs_blksize_seq_show(struct seq_file *m, void *data)
+{
+	struct obd_device *obd = data;
+	struct obd_statfs  osfs;
+	int rc = obd_statfs(NULL, obd->obd_self_export, &osfs,
+			    cfs_time_shift_64(-OBD_STATFS_CACHE_SECONDS),
+			    OBD_STATFS_NODELAY);
+	if (!rc)
+		rc = seq_printf(m, "%u\n", osfs.os_bsize);
+	return rc;
+}
+EXPORT_SYMBOL(lprocfs_blksize_seq_show);
+
+int lprocfs_kbytestotal_seq_show(struct seq_file *m, void *data)
+{
+	struct obd_device *obd = data;
+	struct obd_statfs  osfs;
+	int rc = obd_statfs(NULL, obd->obd_self_export, &osfs,
+			    cfs_time_shift_64(-OBD_STATFS_CACHE_SECONDS),
+			    OBD_STATFS_NODELAY);
+	if (!rc) {
+		__u32 blk_size = osfs.os_bsize >> 10;
+		__u64 result = osfs.os_blocks;
+
+		while (blk_size >>= 1)
+			result <<= 1;
+
+		rc = seq_printf(m, LPU64"\n", result);
+	}
+	return rc;
+}
+EXPORT_SYMBOL(lprocfs_kbytestotal_seq_show);
+
+int lprocfs_kbytesfree_seq_show(struct seq_file *m, void *data)
+{
+	struct obd_device *obd = data;
+	struct obd_statfs  osfs;
+	int rc = obd_statfs(NULL, obd->obd_self_export, &osfs,
+			    cfs_time_shift_64(-OBD_STATFS_CACHE_SECONDS),
+			    OBD_STATFS_NODELAY);
+	if (!rc) {
+		__u32 blk_size = osfs.os_bsize >> 10;
+		__u64 result = osfs.os_bfree;
+
+		while (blk_size >>= 1)
+			result <<= 1;
+
+		rc = seq_printf(m, LPU64"\n", result);
+	}
+	return rc;
+}
+EXPORT_SYMBOL(lprocfs_kbytesfree_seq_show);
+
+int lprocfs_kbytesavail_seq_show(struct seq_file *m, void *data)
+{
+	struct obd_device *obd = data;
+	struct obd_statfs  osfs;
+	int rc = obd_statfs(NULL, obd->obd_self_export, &osfs,
+			    cfs_time_shift_64(-OBD_STATFS_CACHE_SECONDS),
+			    OBD_STATFS_NODELAY);
+	if (!rc) {
+		__u32 blk_size = osfs.os_bsize >> 10;
+		__u64 result = osfs.os_bavail;
+
+		while (blk_size >>= 1)
+			result <<= 1;
+
+		rc = seq_printf(m, LPU64"\n", result);
+	}
+	return rc;
+}
+EXPORT_SYMBOL(lprocfs_kbytesavail_seq_show);
+
+int lprocfs_filestotal_seq_show(struct seq_file *m, void *data)
+{
+	struct obd_device *obd = data;
+	struct obd_statfs  osfs;
+	int rc = obd_statfs(NULL, obd->obd_self_export, &osfs,
+			    cfs_time_shift_64(-OBD_STATFS_CACHE_SECONDS),
+			    OBD_STATFS_NODELAY);
+	if (!rc)
+		rc = seq_printf(m, LPU64"\n", osfs.os_files);
+	return rc;
+}
+EXPORT_SYMBOL(lprocfs_filestotal_seq_show);
+
+int lprocfs_filesfree_seq_show(struct seq_file *m, void *data)
+{
+	struct obd_device *obd = data;
+	struct obd_statfs  osfs;
+	int rc = obd_statfs(NULL, obd->obd_self_export, &osfs,
+			    cfs_time_shift_64(-OBD_STATFS_CACHE_SECONDS),
+			    OBD_STATFS_NODELAY);
+	if (!rc)
+		rc = seq_printf(m, LPU64"\n", osfs.os_ffree);
+	return rc;
+}
+EXPORT_SYMBOL(lprocfs_filesfree_seq_show);
+
+int lprocfs_server_uuid_seq_show(struct seq_file *m, void *data)
+{
+	struct obd_device *obd = data;
+	struct obd_import *imp;
+	char *imp_state_name = NULL;
+	int rc = 0;
+
+	LASSERT(obd != NULL);
+	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" : "");
+
+	LPROCFS_CLIMP_EXIT(obd);
+	return rc;
+}
+EXPORT_SYMBOL(lprocfs_server_uuid_seq_show);
+
+int lprocfs_conn_uuid_seq_show(struct seq_file *m, void *data)
+{
+	struct obd_device *obd = data;
+	struct ptlrpc_connection *conn;
+	int rc = 0;
+
+	LASSERT(obd != NULL);
+
+	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);
+	else
+		rc = seq_printf(m, "%s\n", "<none>");
+
+	LPROCFS_CLIMP_EXIT(obd);
+	return rc;
+}
+EXPORT_SYMBOL(lprocfs_conn_uuid_seq_show);
+
+/** add up per-cpu counters */
+void lprocfs_stats_collect(struct lprocfs_stats *stats, int idx,
+			   struct lprocfs_counter *cnt)
+{
+	unsigned int			num_entry;
+	struct lprocfs_counter		*percpu_cntr;
+	int				i;
+	unsigned long			flags = 0;
+
+	memset(cnt, 0, sizeof(*cnt));
+
+	if (stats == NULL) {
+		/* set count to 1 to avoid divide-by-zero errs in callers */
+		cnt->lc_count = 1;
+		return;
+	}
+
+	cnt->lc_min = LC_MIN_INIT;
+
+	num_entry = lprocfs_stats_lock(stats, LPROCFS_GET_NUM_CPU, &flags);
+
+	for (i = 0; i < num_entry; i++) {
+		if (stats->ls_percpu[i] == NULL)
+			continue;
+		percpu_cntr = lprocfs_stats_counter_get(stats, i, idx);
+
+		cnt->lc_count += percpu_cntr->lc_count;
+		cnt->lc_sum += percpu_cntr->lc_sum;
+		if (percpu_cntr->lc_min < cnt->lc_min)
+			cnt->lc_min = percpu_cntr->lc_min;
+		if (percpu_cntr->lc_max > cnt->lc_max)
+			cnt->lc_max = percpu_cntr->lc_max;
+		cnt->lc_sumsquare += percpu_cntr->lc_sumsquare;
+	}
+
+	lprocfs_stats_unlock(stats, LPROCFS_GET_NUM_CPU, &flags);
+}
+EXPORT_SYMBOL(lprocfs_stats_collect);
+
+/**
+ * Append a space separated list of current set flags to str.
+ */
+#define flag2seqstr(flag)						\
+	do {								\
+		if (imp->imp_##flag)					\
+			seq_printf(m, "%s" #flag, first ? "" : ", ");	\
+	} while (0)
+static int obd_import_flags2seqstr(struct obd_import *imp, struct seq_file *m)
+{
+	bool first = true;
+
+	if (imp->imp_obd->obd_no_recov) {
+		seq_printf(m, "no_recov");
+		first = false;
+	}
+
+	flag2seqstr(invalid);
+	flag2seqstr(deactive);
+	flag2seqstr(replayable);
+	flag2seqstr(pingable);
+	return 0;
+}
+#undef flags2seqstr
+
+static const char *obd_connect_names[] = {
+	"read_only",
+	"lov_index",
+	"connect_from_mds",
+	"write_grant",
+	"server_lock",
+	"version",
+	"request_portal",
+	"acl",
+	"xattr",
+	"create_on_write",
+	"truncate_lock",
+	"initial_transno",
+	"inode_bit_locks",
+	"join_file(obsolete)",
+	"getattr_by_fid",
+	"no_oh_for_devices",
+	"remote_client",
+	"remote_client_by_force",
+	"max_byte_per_rpc",
+	"64bit_qdata",
+	"mds_capability",
+	"oss_capability",
+	"early_lock_cancel",
+	"som",
+	"adaptive_timeouts",
+	"lru_resize",
+	"mds_mds_connection",
+	"real_conn",
+	"change_qunit_size",
+	"alt_checksum_algorithm",
+	"fid_is_enabled",
+	"version_recovery",
+	"pools",
+	"grant_shrink",
+	"skip_orphan",
+	"large_ea",
+	"full20",
+	"layout_lock",
+	"64bithash",
+	"object_max_bytes",
+	"imp_recov",
+	"jobstats",
+	"umask",
+	"einprogress",
+	"grant_param",
+	"flock_owner",
+	"lvb_type",
+	"nanoseconds_times",
+	"lightweight_conn",
+	"short_io",
+	"pingless",
+	"flock_deadlock",
+	"disp_stripe",
+	"unknown",
+	NULL
+};
+
+static void obd_connect_seq_flags2str(struct seq_file *m, __u64 flags, char *sep)
+{
+	bool first = true;
+	__u64 mask = 1;
+	int i;
+
+	for (i = 0; obd_connect_names[i] != NULL; i++, mask <<= 1) {
+		if (flags & mask) {
+			seq_printf(m, "%s%s",
+				   first ? "" : sep, obd_connect_names[i]);
+			first = false;
+		}
+	}
+	if (flags & ~(mask - 1))
+		seq_printf(m, "%sunknown flags "LPX64,
+			   first ? "" : sep, flags & ~(mask - 1));
+}
+
+int obd_connect_flags2str(char *page, int count, __u64 flags, char *sep)
+{
+	__u64 mask = 1;
+	int i, ret = 0;
+
+	for (i = 0; obd_connect_names[i] != NULL; 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 flags "LPX64,
+				ret ? sep : "", flags & ~(mask - 1));
+	return ret;
+}
+EXPORT_SYMBOL(obd_connect_flags2str);
+
+static void obd_connect_data_seqprint(struct seq_file *m,
+				      struct obd_connect_data *ocd)
+{
+	int flags;
+
+	LASSERT(ocd != NULL);
+	flags = ocd->ocd_connect_flags;
+
+	seq_printf(m, "    connect_data:\n"
+		      "       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));
+	if (flags & OBD_CONNECT_MDS)
+		seq_printf(m, "       mdt_index: %d\n", ocd->ocd_group);
+	if (flags & OBD_CONNECT_GRANT)
+		seq_printf(m, "       initial_grant: %d\n", ocd->ocd_grant);
+	if (flags & OBD_CONNECT_INDEX)
+		seq_printf(m, "       target_index: %u\n", ocd->ocd_index);
+	if (flags & OBD_CONNECT_BRW_SIZE)
+		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);
+	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);
+	if (flags & OBD_CONNECT_TRANSNO)
+		seq_printf(m, "       first_transno: "LPX64"\n",
+				ocd->ocd_transno);
+	if (flags & OBD_CONNECT_CKSUM)
+		seq_printf(m, "       cksum_types: %#x\n",
+			      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);
+}
+
+int lprocfs_import_seq_show(struct seq_file *m, void *data)
+{
+	struct lprocfs_counter          ret;
+	struct lprocfs_counter_header   *header;
+	struct obd_device               *obd    = (struct obd_device *)data;
+	struct obd_import               *imp;
+	struct obd_import_conn          *conn;
+	struct obd_connect_data		*ocd;
+	int                             j;
+	int                             k;
+	int                             rw      = 0;
+
+	LASSERT(obd != NULL);
+	LPROCFS_CLIMP_CHECK(obd);
+	imp = obd->u.cli.cl_import;
+	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));
+	obd_connect_seq_flags2str(m, imp->imp_connect_data.ocd_connect_flags,
+					", ");
+	seq_printf(m, "]\n");
+	obd_connect_data_seqprint(m, ocd);
+	seq_printf(m, "    import_flags: [");
+	obd_import_flags2seqstr(imp, m);
+
+	seq_printf(m, "]\n"
+		      "    connection:\n"
+		      "       failover_nids: [");
+	spin_lock(&imp->imp_lock);
+	j = 0;
+	list_for_each_entry(conn, &imp->imp_conn_list, oic_item) {
+		seq_printf(m, "%s%s", j ? ", " : "",
+			   libcfs_nid2str(conn->oic_conn->c_peer.nid));
+		j++;
+	}
+	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>" :
+			      libcfs_nid2str(imp->imp_connection->c_peer.nid),
+		      imp->imp_conn_cnt,
+		      imp->imp_generation,
+		      atomic_read(&imp->imp_inval_count));
+	spin_unlock(&imp->imp_lock);
+
+	if (obd->obd_svc_stats == NULL)
+		goto out_climp;
+
+	header = &obd->obd_svc_stats->ls_cnt_header[PTLRPC_REQWAIT_CNTR];
+	lprocfs_stats_collect(obd->obd_svc_stats, PTLRPC_REQWAIT_CNTR, &ret);
+	if (ret.lc_count != 0) {
+		/* first argument to do_div MUST be __u64 */
+		__u64 sum = ret.lc_sum;
+		do_div(sum, ret.lc_count);
+		ret.lc_sum = sum;
+	} 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);
+
+	k = 0;
+	for(j = 0; j < IMP_AT_MAX_PORTALS; j++) {
+		if (imp->imp_at.iat_portal[j] == 0)
+			break;
+		k = max_t(unsigned int, k,
+			  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));
+
+	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);
+
+	/* avg data rates */
+	for (rw = 0; rw <= 1; rw++) {
+		lprocfs_stats_collect(obd->obd_svc_stats,
+				      PTLRPC_LAST_CNTR + BRW_READ_BYTES + rw,
+				      &ret);
+		if (ret.lc_sum > 0 && ret.lc_count > 0) {
+			/* first argument to do_div MUST be __u64 */
+			__u64 sum = ret.lc_sum;
+			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);
+		}
+		k = (int)ret.lc_sum;
+		j = opcode_offset(OST_READ + rw) + EXTRA_MAX_OPCODES;
+		header = &obd->obd_svc_stats->ls_cnt_header[j];
+		lprocfs_stats_collect(obd->obd_svc_stats, j, &ret);
+		if (ret.lc_sum > 0 && ret.lc_count != 0) {
+			/* first argument to do_div MUST be __u64 */
+			__u64 sum = ret.lc_sum;
+			do_div(sum, ret.lc_count);
+			ret.lc_sum = sum;
+			seq_printf(m, "       %s_per_rpc: "LPU64"\n",
+					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);
+		}
+	}
+
+out_climp:
+	LPROCFS_CLIMP_EXIT(obd);
+	return 0;
+}
+EXPORT_SYMBOL(lprocfs_import_seq_show);
+
+int lprocfs_state_seq_show(struct seq_file *m, void *data)
+{
+	struct obd_device *obd = (struct obd_device *)data;
+	struct obd_import *imp;
+	int j, k;
+
+	LASSERT(obd != NULL);
+	LPROCFS_CLIMP_CHECK(obd);
+	imp = obd->u.cli.cl_import;
+
+	seq_printf(m, "current_state: %s\n",
+		   ptlrpc_import_state_name(imp->imp_state));
+	seq_printf(m, "state_history:\n");
+	k = imp->imp_state_hist_idx;
+	for (j = 0; j < IMP_STATE_HIST_LEN; j++) {
+		struct import_state_hist *ish =
+			&imp->imp_state_hist[(k + j) % IMP_STATE_HIST_LEN];
+		if (ish->ish_state == 0)
+			continue;
+		seq_printf(m, " - ["CFS_TIME_T", %s]\n",
+			   ish->ish_time,
+		ptlrpc_import_state_name(ish->ish_state));
+	}
+
+	LPROCFS_CLIMP_EXIT(obd);
+	return 0;
+}
+EXPORT_SYMBOL(lprocfs_state_seq_show);
+
+int lprocfs_seq_at_hist_helper(struct seq_file *m, struct adaptive_timeout *at)
+{
+	int i;
+	for (i = 0; i < AT_BINS; i++)
+		seq_printf(m, "%3u ", at->at_hist[i]);
+	seq_printf(m, "\n");
+	return 0;
+}
+EXPORT_SYMBOL(lprocfs_seq_at_hist_helper);
+
+/* See also ptlrpc_lprocfs_timeouts_show_seq */
+int lprocfs_timeouts_seq_show(struct seq_file *m, void *data)
+{
+	struct obd_device *obd = (struct obd_device *)data;
+	struct obd_import *imp;
+	unsigned int cur, worst;
+	time_t now, worstt;
+	struct dhms ts;
+	int i;
+
+	LASSERT(obd != NULL);
+	LPROCFS_CLIMP_CHECK(obd);
+	imp = obd->u.cli.cl_import;
+
+	now = cfs_time_current_sec();
+
+	/* Some network health info for kicks */
+	s2dhms(&ts, now - imp->imp_last_reply_time);
+	seq_printf(m, "%-10s : %ld, "DHMS_FMT" ago\n",
+		   "last reply", imp->imp_last_reply_time, DHMS_VARS(&ts));
+
+	cur = at_get(&imp->imp_at.iat_net_latency);
+	worst = imp->imp_at.iat_net_latency.at_worst_ever;
+	worstt = imp->imp_at.iat_net_latency.at_worst_time;
+	s2dhms(&ts, now - worstt);
+	seq_printf(m, "%-10s : cur %3u  worst %3u (at %ld, "DHMS_FMT" ago) ",
+		   "network", cur, worst, worstt, DHMS_VARS(&ts));
+	lprocfs_seq_at_hist_helper(m, &imp->imp_at.iat_net_latency);
+
+	for(i = 0; i < IMP_AT_MAX_PORTALS; i++) {
+		if (imp->imp_at.iat_portal[i] == 0)
+			break;
+		cur = at_get(&imp->imp_at.iat_service_estimate[i]);
+		worst = imp->imp_at.iat_service_estimate[i].at_worst_ever;
+		worstt = imp->imp_at.iat_service_estimate[i].at_worst_time;
+		s2dhms(&ts, now - worstt);
+		seq_printf(m, "portal %-2d  : cur %3u  worst %3u (at %ld, "
+			   DHMS_FMT" ago) ", imp->imp_at.iat_portal[i],
+			   cur, worst, worstt, DHMS_VARS(&ts));
+		lprocfs_seq_at_hist_helper(m, &imp->imp_at.iat_service_estimate[i]);
+	}
+
+	LPROCFS_CLIMP_EXIT(obd);
+	return 0;
+}
+EXPORT_SYMBOL(lprocfs_timeouts_seq_show);
+
+int lprocfs_connect_flags_seq_show(struct seq_file *m, void *data)
+{
+	struct obd_device *obd = data;
+	__u64 flags;
+
+	LPROCFS_CLIMP_CHECK(obd);
+	flags = obd->u.cli.cl_import->imp_connect_data.ocd_connect_flags;
+	seq_printf(m, "flags="LPX64"\n", flags);
+	obd_connect_seq_flags2str(m, flags, "\n");
+	seq_printf(m, "\n");
+	LPROCFS_CLIMP_EXIT(obd);
+	return 0;
+}
+EXPORT_SYMBOL(lprocfs_connect_flags_seq_show);
+
+#ifndef HAVE_ONLY_PROCFS_SEQ
+
+int lprocfs_rd_uint(char *page, char **start, off_t off,
+		    int count, int *eof, void *data)
+{
+	unsigned int *temp = data;
+	return snprintf(page, count, "%u\n", *temp);
+}
+EXPORT_SYMBOL(lprocfs_rd_uint);
+
 int lprocfs_rd_u64(char *page, char **start, off_t off,
                    int count, int *eof, void *data)
 {
@@ -770,47 +1510,6 @@ int lprocfs_rd_conn_uuid(char *page, char **start, off_t off, int count,
 }
 EXPORT_SYMBOL(lprocfs_rd_conn_uuid);
 
-/** add up per-cpu counters */
-void lprocfs_stats_collect(struct lprocfs_stats *stats, int idx,
-			   struct lprocfs_counter *cnt)
-{
-	unsigned int			num_entry;
-	struct lprocfs_counter		*percpu_cntr;
-	struct lprocfs_counter_header	*cntr_header;
-	int				i;
-	unsigned long			flags = 0;
-
-	memset(cnt, 0, sizeof(*cnt));
-
-	if (stats == NULL) {
-		/* set count to 1 to avoid divide-by-zero errs in callers */
-		cnt->lc_count = 1;
-		return;
-	}
-
-	cnt->lc_min = LC_MIN_INIT;
-
-	num_entry = lprocfs_stats_lock(stats, LPROCFS_GET_NUM_CPU, &flags);
-
-	for (i = 0; i < num_entry; i++) {
-		if (stats->ls_percpu[i] == NULL)
-			continue;
-		cntr_header = &stats->ls_cnt_header[idx];
-		percpu_cntr = lprocfs_stats_counter_get(stats, i, idx);
-
-		cnt->lc_count += percpu_cntr->lc_count;
-		cnt->lc_sum += percpu_cntr->lc_sum;
-		if (percpu_cntr->lc_min < cnt->lc_min)
-			cnt->lc_min = percpu_cntr->lc_min;
-		if (percpu_cntr->lc_max > cnt->lc_max)
-			cnt->lc_max = percpu_cntr->lc_max;
-		cnt->lc_sumsquare += percpu_cntr->lc_sumsquare;
-	}
-
-	lprocfs_stats_unlock(stats, LPROCFS_GET_NUM_CPU, &flags);
-}
-EXPORT_SYMBOL(lprocfs_stats_collect);
-
 /**
  * Append a space separated list of current set flags to str.
  */
@@ -832,80 +1531,6 @@ static int obd_import_flags2str(struct obd_import *imp, char *str, int max)
 }
 #undef flags2str
 
-static const char *obd_connect_names[] = {
-        "read_only",
-        "lov_index",
-        "unused",
-        "write_grant",
-        "server_lock",
-        "version",
-        "request_portal",
-        "acl",
-        "xattr",
-        "create_on_write",
-        "truncate_lock",
-        "initial_transno",
-        "inode_bit_locks",
-        "join_file(obsolete)",
-        "getattr_by_fid",
-        "no_oh_for_devices",
-        "remote_client",
-        "remote_client_by_force",
-        "max_byte_per_rpc",
-        "64bit_qdata",
-        "mds_capability",
-        "oss_capability",
-        "early_lock_cancel",
-        "som",
-        "adaptive_timeouts",
-        "lru_resize",
-        "mds_mds_connection",
-        "real_conn",
-        "change_qunit_size",
-        "alt_checksum_algorithm",
-        "fid_is_enabled",
-        "version_recovery",
-        "pools",
-        "grant_shrink",
-        "skip_orphan",
-        "large_ea",
-        "full20",
-        "layout_lock",
-        "64bithash",
-        "object_max_bytes",
-        "imp_recov",
-        "jobstats",
-        "umask",
-        "einprogress",
-        "grant_param",
-	"flock_owner",
-	"lvb_type",
-	"nanoseconds_times",
-	"lightweight_conn",
-	"short_io",
-	"pingless",
-	"unknown",
-        NULL
-};
-
-int obd_connect_flags2str(char *page, int count, __u64 flags, char *sep)
-{
-        __u64 mask = 1;
-        int i, ret = 0;
-
-        for (i = 0; obd_connect_names[i] != NULL; 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 flags "LPX64,
-                                ret ? sep : "", flags & ~(mask - 1));
-        return ret;
-}
-EXPORT_SYMBOL(obd_connect_flags2str);
-
 int lprocfs_rd_import(char *page, char **start, off_t off, int count,
                       int *eof, void *data)
 {
@@ -1193,23 +1818,46 @@ EXPORT_SYMBOL(lprocfs_rd_numrefs);
 
 int lprocfs_obd_setup(struct obd_device *obd, struct lprocfs_vars *list)
 {
-        int rc = 0;
+	int rc = 0;
 
-        LASSERT(obd != NULL);
-        LASSERT(obd->obd_magic == OBD_DEVICE_MAGIC);
-        LASSERT(obd->obd_type->typ_procroot != NULL);
-
-        obd->obd_proc_entry = lprocfs_register(obd->obd_name,
-                                               obd->obd_type->typ_procroot,
-                                               list, obd);
-        if (IS_ERR(obd->obd_proc_entry)) {
-                rc = PTR_ERR(obd->obd_proc_entry);
-                CERROR("error %d setting up lprocfs for %s\n",rc,obd->obd_name);
-                obd->obd_proc_entry = NULL;
-        }
-        return rc;
+	LASSERT(obd != NULL);
+	LASSERT(obd->obd_magic == OBD_DEVICE_MAGIC);
+	LASSERT(obd->obd_type->typ_procroot != NULL);
+
+	obd->obd_proc_entry = lprocfs_register(obd->obd_name,
+					       obd->obd_type->typ_procroot,
+					       list, obd);
+	if (IS_ERR(obd->obd_proc_entry)) {
+		rc = PTR_ERR(obd->obd_proc_entry);
+		CERROR("error %d setting up lprocfs for %s\n",rc,obd->obd_name);
+		obd->obd_proc_entry = NULL;
+	}
+	return rc;
 }
 EXPORT_SYMBOL(lprocfs_obd_setup);
+#endif
+
+int
+lprocfs_seq_obd_setup(struct obd_device *obd)
+{
+	int rc = 0;
+
+	LASSERT(obd != NULL);
+	LASSERT(obd->obd_vars != NULL);
+	LASSERT(obd->obd_magic == OBD_DEVICE_MAGIC);
+	LASSERT(obd->obd_type->typ_procroot != NULL);
+
+	obd->obd_proc_entry = lprocfs_seq_register(obd->obd_name,
+						   obd->obd_type->typ_procroot,
+						   obd->obd_vars, obd);
+	if (IS_ERR(obd->obd_proc_entry)) {
+		rc = PTR_ERR(obd->obd_proc_entry);
+		CERROR("error %d setting up lprocfs for %s\n",rc,obd->obd_name);
+		obd->obd_proc_entry = NULL;
+	}
+	return rc;
+}
+EXPORT_SYMBOL(lprocfs_seq_obd_setup);
 
 int lprocfs_obd_cleanup(struct obd_device *obd)
 {
@@ -1217,7 +1865,6 @@ int lprocfs_obd_cleanup(struct obd_device *obd)
                 return -EINVAL;
         if (obd->obd_proc_exports_entry) {
                 /* Should be no exports left */
-                LASSERT(obd->obd_proc_exports_entry->subdir == NULL);
                 lprocfs_remove(&obd->obd_proc_exports_entry);
                 obd->obd_proc_exports_entry = NULL;
         }
@@ -1271,6 +1918,44 @@ void lprocfs_free_per_client_stats(struct obd_device *obd)
 }
 EXPORT_SYMBOL(lprocfs_free_per_client_stats);
 
+int lprocfs_stats_alloc_one(struct lprocfs_stats *stats, unsigned int cpuid)
+{
+	struct lprocfs_counter  *cntr;
+	unsigned int            percpusize;
+	int                     rc = -ENOMEM;
+	unsigned long           flags = 0;
+	int                     i;
+
+	LASSERT(stats->ls_percpu[cpuid] == NULL);
+	LASSERT((stats->ls_flags & LPROCFS_STATS_FLAG_NOPERCPU) == 0);
+
+	percpusize = lprocfs_stats_counter_size(stats);
+	LIBCFS_ALLOC_ATOMIC(stats->ls_percpu[cpuid], percpusize);
+	if (stats->ls_percpu[cpuid] != NULL) {
+		rc = 0;
+		if (unlikely(stats->ls_biggest_alloc_num <= cpuid)) {
+			if (stats->ls_flags & LPROCFS_STATS_FLAG_IRQ_SAFE)
+				spin_lock_irqsave(&stats->ls_lock, flags);
+			else
+				spin_lock(&stats->ls_lock);
+			if (stats->ls_biggest_alloc_num <= cpuid)
+				stats->ls_biggest_alloc_num = cpuid + 1;
+			if (stats->ls_flags & LPROCFS_STATS_FLAG_IRQ_SAFE) {
+				spin_unlock_irqrestore(&stats->ls_lock, flags);
+			} else {
+				spin_unlock(&stats->ls_lock);
+			}
+		}
+		/* initialize the ls_percpu[cpuid] non-zero counter */
+		for (i = 0; i < stats->ls_num; ++i) {
+			cntr = lprocfs_stats_counter_get(stats, cpuid, i);
+			cntr->lc_min = LC_MIN_INIT;
+		}
+	}
+	return rc;
+}
+EXPORT_SYMBOL(lprocfs_stats_alloc_one);
+
 struct lprocfs_stats *lprocfs_alloc_stats(unsigned int num,
                                           enum lprocfs_stats_flags flags)
 {
@@ -1288,7 +1973,7 @@ struct lprocfs_stats *lprocfs_alloc_stats(unsigned int num,
 	if (flags & LPROCFS_STATS_FLAG_NOPERCPU)
 		num_entry = 1;
 	else
-		num_entry = cfs_num_possible_cpus();
+		num_entry = num_possible_cpus();
 
 	/* alloc percpu pointers for all possible cpu slots */
 	LIBCFS_ALLOC(stats, offsetof(typeof(*stats), ls_percpu[num_entry]));
@@ -1341,7 +2026,7 @@ void lprocfs_free_stats(struct lprocfs_stats **statsh)
 	if (stats->ls_flags & LPROCFS_STATS_FLAG_NOPERCPU)
 		num_entry = 1;
 	else
-		num_entry = cfs_num_possible_cpus();
+		num_entry = num_possible_cpus();
 
 	percpusize = lprocfs_stats_counter_size(stats);
 	for (i = 0; i < num_entry; i++)
@@ -1357,7 +2042,6 @@ EXPORT_SYMBOL(lprocfs_free_stats);
 void lprocfs_clear_stats(struct lprocfs_stats *stats)
 {
 	struct lprocfs_counter		*percpu_cntr;
-	struct lprocfs_counter_header	*header;
 	int				i;
 	int				j;
 	unsigned int			num_entry;
@@ -1369,7 +2053,6 @@ void lprocfs_clear_stats(struct lprocfs_stats *stats)
 		if (stats->ls_percpu[i] == NULL)
 			continue;
 		for (j = 0; j < stats->ls_num; j++) {
-			header = &stats->ls_cnt_header[j];
 			percpu_cntr = lprocfs_stats_counter_get(stats, i, j);
 			percpu_cntr->lc_count		= 0;
 			percpu_cntr->lc_min		= LC_MIN_INIT;
@@ -1426,7 +2109,7 @@ static int lprocfs_stats_seq_show(struct seq_file *p, void *v)
 	if (idx == 0) {
 		struct timeval now;
 
-		cfs_gettimeofday(&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)
@@ -1468,21 +2151,19 @@ struct seq_operations lprocfs_stats_seq_sops = {
 
 static int lprocfs_stats_seq_open(struct inode *inode, struct file *file)
 {
-        struct proc_dir_entry *dp = PDE(inode);
-        struct seq_file *seq;
-        int rc;
-
-        if (LPROCFS_ENTRY_AND_CHECK(dp))
-                return -ENOENT;
+	struct seq_file *seq;
+	int rc;
 
-        rc = seq_open(file, &lprocfs_stats_seq_sops);
-        if (rc) {
-                LPROCFS_EXIT();
-                return rc;
-        }
-        seq = file->private_data;
-        seq->private = dp->data;
-        return 0;
+#ifndef HAVE_ONLY_PROCFS_SEQ
+	if (LPROCFS_ENTRY_CHECK(PDE(inode)))
+		return -ENOENT;
+#endif
+	rc = seq_open(file, &lprocfs_stats_seq_sops);
+	if (rc)
+		return rc;
+	seq = file->private_data;
+	seq->private = PDE_DATA(inode);
+	return 0;
 }
 
 struct file_operations lprocfs_stats_seq_fops = {
@@ -1497,22 +2178,14 @@ struct file_operations lprocfs_stats_seq_fops = {
 int lprocfs_register_stats(struct proc_dir_entry *root, const char *name,
                            struct lprocfs_stats *stats)
 {
-        struct proc_dir_entry *entry;
-        LASSERT(root != NULL);
-
-        LPROCFS_WRITE_ENTRY();
-        entry = create_proc_entry(name, 0644, root);
-        if (entry) {
-                entry->proc_fops = &lprocfs_stats_seq_fops;
-                entry->data = stats;
-        }
-
-        LPROCFS_WRITE_EXIT();
-
-        if (entry == NULL)
-                return -ENOMEM;
+	struct proc_dir_entry *entry;
+	LASSERT(root != NULL);
 
-        return 0;
+	entry = proc_create_data(name, 0644, root,
+				 &lprocfs_stats_seq_fops, stats);
+	if (entry == NULL)
+		return -ENOMEM;
+	return 0;
 }
 EXPORT_SYMBOL(lprocfs_register_stats);
 
@@ -1628,6 +2301,8 @@ void lprocfs_init_ops_stats(int num_private_stats, struct lprocfs_stats *stats)
         LPROCFS_OBD_OP_INIT(num_private_stats, stats, pool_del);
         LPROCFS_OBD_OP_INIT(num_private_stats, stats, getref);
         LPROCFS_OBD_OP_INIT(num_private_stats, stats, putref);
+
+	CLASSERT(NUM_OBD_STATS == OBD_COUNTER_OFFSET(putref) + 1);
 }
 EXPORT_SYMBOL(lprocfs_init_ops_stats);
 
@@ -1641,8 +2316,7 @@ int lprocfs_alloc_obd_stats(struct obd_device *obd, unsigned num_private_stats)
         LASSERT(obd->obd_proc_entry != NULL);
         LASSERT(obd->obd_cntr_base == 0);
 
-        num_stats = ((int)sizeof(*obd->obd_type->typ_dt_ops) / sizeof(void *)) +
-                num_private_stats - 1 /* o_owner */;
+	num_stats = NUM_OBD_STATS + num_private_stats;
         stats = lprocfs_alloc_stats(num_stats, 0);
         if (stats == NULL)
                 return -ENOMEM;
@@ -1677,12 +2351,18 @@ void lprocfs_free_obd_stats(struct obd_device *obd)
 }
 EXPORT_SYMBOL(lprocfs_free_obd_stats);
 
-#define LPROCFS_MD_OP_INIT(base, stats, op)                             \
-do {                                                                    \
-        unsigned int coffset = base + MD_COUNTER_OFFSET(op);            \
-        LASSERT(coffset < stats->ls_num);                               \
-        lprocfs_counter_init(stats, coffset, 0, #op, "reqs");           \
-} while (0)
+/* Note that we only init md counters for ops whose offset is less
+ * than NUM_MD_STATS. This is explained in a comment in the definition
+ * of struct md_ops. */
+#define LPROCFS_MD_OP_INIT(base, stats, op)				       \
+	do {								       \
+		unsigned int _idx = base + MD_COUNTER_OFFSET(op);	       \
+									       \
+		if (MD_COUNTER_OFFSET(op) < NUM_MD_STATS) {		       \
+			LASSERT(_idx < stats->ls_num);			       \
+			lprocfs_counter_init(stats, _idx, 0, #op, "reqs");     \
+		}							       \
+	} while (0)
 
 void lprocfs_init_mps_stats(int num_private_stats, struct lprocfs_stats *stats)
 {
@@ -1700,7 +2380,7 @@ void lprocfs_init_mps_stats(int num_private_stats, struct lprocfs_stats *stats)
         LPROCFS_MD_OP_INIT(num_private_stats, stats, rename);
         LPROCFS_MD_OP_INIT(num_private_stats, stats, is_subdir);
         LPROCFS_MD_OP_INIT(num_private_stats, stats, setattr);
-        LPROCFS_MD_OP_INIT(num_private_stats, stats, sync);
+	LPROCFS_MD_OP_INIT(num_private_stats, stats, fsync);
         LPROCFS_MD_OP_INIT(num_private_stats, stats, readpage);
         LPROCFS_MD_OP_INIT(num_private_stats, stats, unlink);
         LPROCFS_MD_OP_INIT(num_private_stats, stats, setxattr);
@@ -1722,52 +2402,65 @@ void lprocfs_init_mps_stats(int num_private_stats, struct lprocfs_stats *stats)
 EXPORT_SYMBOL(lprocfs_init_mps_stats);
 
 int lprocfs_alloc_md_stats(struct obd_device *obd,
-                           unsigned num_private_stats)
-{
-        struct lprocfs_stats *stats;
-        unsigned int num_stats;
-        int rc, i;
-
-        LASSERT(obd->md_stats == NULL);
-        LASSERT(obd->obd_proc_entry != NULL);
-        LASSERT(obd->md_cntr_base == 0);
+			   unsigned int num_private_stats)
+{
+	struct lprocfs_stats *stats;
+	unsigned int num_stats;
+	int rc, i;
+
+	CLASSERT(offsetof(struct md_ops, MD_STATS_FIRST_OP) == 0);
+	CLASSERT(_MD_COUNTER_OFFSET(MD_STATS_FIRST_OP) == 0);
+	CLASSERT(_MD_COUNTER_OFFSET(MD_STATS_LAST_OP) > 0);
+
+	/* TODO Ensure that this function is only used where
+	 * appropriate by adding an assertion to the effect that
+	 * obd->obd_type->typ_md_ops is not NULL. We can't do this now
+	 * because mdt_procfs_init() uses this function to allocate
+	 * the stats backing /proc/fs/lustre/mdt/.../md_stats but the
+	 * mdt layer does not use the md_ops interface. This is
+	 * confusing and a waste of memory. See LU-2484.
+	 */
+	LASSERT(obd->obd_proc_entry != NULL);
+	LASSERT(obd->obd_md_stats == NULL);
+	LASSERT(obd->obd_md_cntr_base == 0);
 
-        num_stats = 1 + MD_COUNTER_OFFSET(revalidate_lock) +
-                    num_private_stats;
-        stats = lprocfs_alloc_stats(num_stats, 0);
-        if (stats == NULL)
-                return -ENOMEM;
+	num_stats = NUM_MD_STATS + num_private_stats;
+	stats = lprocfs_alloc_stats(num_stats, 0);
+	if (stats == NULL)
+		return -ENOMEM;
 
-        lprocfs_init_mps_stats(num_private_stats, stats);
+	lprocfs_init_mps_stats(num_private_stats, stats);
 
-        for (i = num_private_stats; i < num_stats; i++) {
+	for (i = num_private_stats; i < num_stats; i++) {
 		if (stats->ls_cnt_header[i].lc_name == NULL) {
-                        CERROR("Missing md_stat initializer md_op "
-                               "operation at offset %d. Aborting.\n",
-                               i - num_private_stats);
-                        LBUG();
-                }
-        }
-        rc = lprocfs_register_stats(obd->obd_proc_entry, "md_stats", stats);
-        if (rc < 0) {
-                lprocfs_free_stats(&stats);
-        } else {
-                obd->md_stats  = stats;
-                obd->md_cntr_base = num_private_stats;
-        }
-        return rc;
+			CERROR("Missing md_stat initializer md_op "
+			       "operation at offset %d. Aborting.\n",
+			       i - num_private_stats);
+			LBUG();
+		}
+	}
+
+	rc = lprocfs_register_stats(obd->obd_proc_entry, "md_stats", stats);
+	if (rc < 0) {
+		lprocfs_free_stats(&stats);
+	} else {
+		obd->obd_md_stats = stats;
+		obd->obd_md_cntr_base = num_private_stats;
+	}
+
+	return rc;
 }
 EXPORT_SYMBOL(lprocfs_alloc_md_stats);
 
 void lprocfs_free_md_stats(struct obd_device *obd)
 {
-        struct lprocfs_stats *stats = obd->md_stats;
+	struct lprocfs_stats *stats = obd->obd_md_stats;
 
-        if (stats != NULL) {
-                obd->md_stats = NULL;
-                obd->md_cntr_base = 0;
-                lprocfs_free_stats(&stats);
-        }
+	if (stats != NULL) {
+		obd->obd_md_stats = NULL;
+		obd->obd_md_cntr_base = 0;
+		lprocfs_free_stats(&stats);
+	}
 }
 EXPORT_SYMBOL(lprocfs_free_md_stats);
 
@@ -1937,6 +2630,7 @@ int lprocfs_nid_stats_clear_write(struct file *file, const char *buffer,
 }
 EXPORT_SYMBOL(lprocfs_nid_stats_clear_write);
 
+#ifdef HAVE_SERVER_SUPPORT
 int lprocfs_exp_setup(struct obd_export *exp, lnet_nid_t *nid, int *newnid)
 {
         struct nid_stat *new_stat, *old_stat;
@@ -1958,6 +2652,13 @@ int lprocfs_exp_setup(struct obd_export *exp, lnet_nid_t *nid, int *newnid)
         if (!nid || *nid == LNET_NID_ANY)
                 RETURN(0);
 
+	spin_lock(&exp->exp_lock);
+	if (exp->exp_nid_stats != NULL) {
+		spin_unlock(&exp->exp_lock);
+		RETURN(-EALREADY);
+	}
+	spin_unlock(&exp->exp_lock);
+
         obd = exp->exp_obd;
 
         CDEBUG(D_CONFIG, "using hash %p\n", obd->obd_nid_stats_hash);
@@ -1977,19 +2678,12 @@ int lprocfs_exp_setup(struct obd_export *exp, lnet_nid_t *nid, int *newnid)
                old_stat, libcfs_nid2str(*nid),
                cfs_atomic_read(&new_stat->nid_exp_ref_count));
 
-        /* We need to release old stats because lprocfs_exp_cleanup() hasn't
-         * been and will never be called. */
-        if (exp->exp_nid_stats) {
-                nidstat_putref(exp->exp_nid_stats);
-                exp->exp_nid_stats = NULL;
-        }
-
-        /* Return -EALREADY here so that we know that the /proc
-         * entry already has been created */
-        if (old_stat != new_stat) {
-                exp->exp_nid_stats = old_stat;
-                GOTO(destroy_new, rc = -EALREADY);
-        }
+	/* Return -EALREADY here so that we know that the /proc
+	 * entry already has been created */
+	if (old_stat != new_stat) {
+		nidstat_putref(old_stat);
+		GOTO(destroy_new, rc = -EALREADY);
+	}
         /* not found - create */
         OBD_ALLOC(buffer, LNET_NIDSTR_SIZE);
         if (buffer == NULL)
@@ -2025,7 +2719,9 @@ int lprocfs_exp_setup(struct obd_export *exp, lnet_nid_t *nid, int *newnid)
                 GOTO(destroy_new_ns, rc);
         }
 
-        exp->exp_nid_stats = new_stat;
+	spin_lock(&exp->exp_lock);
+	exp->exp_nid_stats = new_stat;
+	spin_unlock(&exp->exp_lock);
         *newnid = 1;
         /* protect competitive add to list, not need locking on destroy */
 	spin_lock(&obd->obd_nid_lock);
@@ -2045,6 +2741,7 @@ destroy_new:
         RETURN(rc);
 }
 EXPORT_SYMBOL(lprocfs_exp_setup);
+#endif
 
 int lprocfs_exp_cleanup(struct obd_export *exp)
 {
@@ -2060,6 +2757,47 @@ int lprocfs_exp_cleanup(struct obd_export *exp)
 }
 EXPORT_SYMBOL(lprocfs_exp_cleanup);
 
+__s64 lprocfs_read_helper(struct lprocfs_counter *lc,
+			  struct lprocfs_counter_header *header,
+			  enum lprocfs_stats_flags flags,
+			  enum lprocfs_fields_flags field)
+{
+	__s64 ret = 0;
+
+	if (lc == NULL || header == NULL)
+		RETURN(0);
+
+	switch (field) {
+		case LPROCFS_FIELDS_FLAGS_CONFIG:
+			ret = header->lc_config;
+			break;
+		case LPROCFS_FIELDS_FLAGS_SUM:
+			ret = lc->lc_sum;
+			if ((flags & LPROCFS_STATS_FLAG_IRQ_SAFE) != 0)
+				ret += lc->lc_sum_irq;
+			break;
+		case LPROCFS_FIELDS_FLAGS_MIN:
+			ret = lc->lc_min;
+			break;
+		case LPROCFS_FIELDS_FLAGS_MAX:
+			ret = lc->lc_max;
+			break;
+		case LPROCFS_FIELDS_FLAGS_AVG:
+			ret = (lc->lc_max - lc->lc_min) / 2;
+			break;
+		case LPROCFS_FIELDS_FLAGS_SUMSQUARE:
+			ret = lc->lc_sumsquare;
+			break;
+		case LPROCFS_FIELDS_FLAGS_COUNT:
+			ret = lc->lc_count;
+			break;
+		default:
+			break;
+	};
+	RETURN(ret);
+}
+EXPORT_SYMBOL(lprocfs_read_helper);
+
 int lprocfs_write_helper(const char *buffer, unsigned long count,
                          int *val)
 {
@@ -2165,6 +2903,31 @@ int lprocfs_read_frac_helper(char *buffer, unsigned long count, long val,
 }
 EXPORT_SYMBOL(lprocfs_read_frac_helper);
 
+int lprocfs_seq_read_frac_helper(struct seq_file *m, long val, int mult)
+{
+	long decimal_val, frac_val;
+
+	decimal_val = val / mult;
+	seq_printf(m, "%ld", decimal_val);
+	frac_val = val % mult;
+
+	if (frac_val > 0) {
+		frac_val *= 100;
+		frac_val /= mult;
+	}
+	if (frac_val > 0) {
+		/* Three cases: x0, xx, 0x */
+		if ((frac_val % 10) != 0)
+			seq_printf(m, ".%ld", frac_val);
+		else
+			seq_printf(m, ".%ld", frac_val / 10);
+	}
+
+	seq_printf(m, "\n");
+	return 0;
+}
+EXPORT_SYMBOL(lprocfs_seq_read_frac_helper);
+
 int lprocfs_write_u64_helper(const char *buffer, unsigned long count,__u64 *val)
 {
         return lprocfs_write_frac_u64_helper(buffer, count, val, 1);
@@ -2210,18 +2973,20 @@ int lprocfs_write_frac_u64_helper(const char *buffer, unsigned long count,
         }
 
         units = 1;
-        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;
-        }
+	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;
+		}
+	}
         /* Specified units override the multiplier */
         if (units)
                 mult = mult < 0 ? -units : units;
@@ -2255,7 +3020,7 @@ static char *lprocfs_strnstr(const char *s1, const char *s2, size_t len)
  * If \a name is not found the original \a buffer is returned.
  */
 char *lprocfs_find_named_value(const char *buffer, const char *name,
-				unsigned long *count)
+				size_t *count)
 {
 	char *val;
 	size_t buflen = *count;
@@ -2285,24 +3050,18 @@ int lprocfs_seq_create(cfs_proc_dir_entry_t *parent,
 		       const struct file_operations *seq_fops,
 		       void *data)
 {
-        struct proc_dir_entry *entry;
-        ENTRY;
+	struct proc_dir_entry *entry;
+	ENTRY;
 
 	/* Disallow secretly (un)writable entries. */
 	LASSERT((seq_fops->write == NULL) == ((mode & 0222) == 0));
 
-        LPROCFS_WRITE_ENTRY();
-        entry = create_proc_entry(name, mode, parent);
-        if (entry) {
-                entry->proc_fops = seq_fops;
-                entry->data = data;
-        }
-        LPROCFS_WRITE_EXIT();
+	entry = proc_create_data(name, mode, parent, seq_fops, data);
 
-        if (entry == NULL)
-                RETURN(-ENOMEM);
+	if (entry == NULL)
+		RETURN(-ENOMEM);
 
-        RETURN(0);
+	RETURN(0);
 }
 EXPORT_SYMBOL(lprocfs_seq_create);
 
@@ -2330,12 +3089,12 @@ EXPORT_SYMBOL(lprocfs_oh_tally);
 
 void lprocfs_oh_tally_log2(struct obd_histogram *oh, unsigned int value)
 {
-        unsigned int val;
+	unsigned int val = 0;
 
-        for (val = 0; ((1 << val) < value) && (val <= OBD_HIST_MAX); val++)
-                ;
+	if (likely(value != 0))
+		val = min(fls(value - 1), OBD_HIST_MAX);
 
-        lprocfs_oh_tally(oh, val);
+	lprocfs_oh_tally(oh, val);
 }
 EXPORT_SYMBOL(lprocfs_oh_tally_log2);
 
@@ -2376,6 +3135,7 @@ int lprocfs_obd_rd_hash(char *page, char **start, off_t off,
 }
 EXPORT_SYMBOL(lprocfs_obd_rd_hash);
 
+#ifdef HAVE_SERVER_SUPPORT
 int lprocfs_obd_rd_recovery_status(char *page, char **start, off_t off,
                                    int count, int *eof, void *data)
 {
@@ -2501,6 +3261,7 @@ out:
         return min(count, len - (int)off);
 }
 EXPORT_SYMBOL(lprocfs_obd_rd_recovery_status);
+#endif
 
 int lprocfs_obd_rd_ir_factor(char *page, char **start, off_t off,
                              int count, int *eof, void *data)
@@ -2599,6 +3360,19 @@ int lprocfs_obd_rd_max_pages_per_rpc(char *page, char **start, off_t off,
 }
 EXPORT_SYMBOL(lprocfs_obd_rd_max_pages_per_rpc);
 
+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;
+
+	client_obd_list_lock(&cli->cl_loi_list_lock);
+	rc = seq_printf(m, "%d\n", cli->cl_max_pages_per_rpc);
+	client_obd_list_unlock(&cli->cl_loi_list_lock);
+	return rc;
+}
+EXPORT_SYMBOL(lprocfs_obd_max_pages_per_rpc_seq_show);
+
 #ifdef HAVE_SERVER_SUPPORT
 int lprocfs_target_rd_instance(char *page, char **start, off_t off,
                                int count, int *eof, void *data)