From: "Alexey Shvetsov" <alexxy@gentoo.org>
To: gentoo-commits@lists.gentoo.org
Subject: [gentoo-commits] proj/sci:master commit in: sys-cluster/lustre/, sys-cluster/lustre/files/
Date: Thu, 19 Dec 2013 13:29:36 +0000 (UTC) [thread overview]
Message-ID: <1387459759.e4356da29fa5d3f53d2c49e1b44a83ec740e93ee.alexxy@gentoo> (raw)
commit: e4356da29fa5d3f53d2c49e1b44a83ec740e93ee
Author: Alexey Shvetsov <alexxy <AT> gentoo <DOT> org>
AuthorDate: Thu Dec 19 13:29:19 2013 +0000
Commit: Alexey Shvetsov <alexxy <AT> gentoo <DOT> org>
CommitDate: Thu Dec 19 13:29:19 2013 +0000
URL: http://git.overlays.gentoo.org/gitweb/?p=proj/sci.git;a=commit;h=e4356da2
Give me more patches =D
Package-Manager: portage-2.2.7
RepoMan-Options: --force
---
sys-cluster/lustre/ChangeLog | 13 +
...ld-make-AC-check-for-linux-arch-sandbox-f.patch | 2 +-
...3-ldiskfs-ldiskfs-patches-for-3.11.1-fc19.patch | 2 +-
...74-llite-dentry-d_compare-changes-in-3.11.patch | 2 +-
...-LU-3974-llite-use-new-struct-dir_context.patch | 2 +-
...-LU-3974-llite-invalidatepage-api-changed.patch | 2 +-
...cfs-move-llite-proc-handling-over-to-seq_.patch | 3 +-
...cfs-move-lmv-proc-handling-over-to-seq_fi.patch | 409 +++++++++++
...cfs-move-ldlm-proc-handling-over-to-seq_f.patch | 789 +++++++++++++++++++++
...cfs-move-ost-proc-handling-over-to-seq_fi.patch | 174 +++++
sys-cluster/lustre/lustre-9999.ebuild | 3 +
11 files changed, 1395 insertions(+), 6 deletions(-)
diff --git a/sys-cluster/lustre/ChangeLog b/sys-cluster/lustre/ChangeLog
index 5ca35a5..33ff78c 100644
--- a/sys-cluster/lustre/ChangeLog
+++ b/sys-cluster/lustre/ChangeLog
@@ -3,6 +3,19 @@
# $Header: $
19 Dec 2013; Alexey Shvetsov <alexxy@gentoo.org>
+ +files/0007-LU-3319-procfs-move-lmv-proc-handling-over-to-seq_fi.patch,
+ +files/0008-LU-3319-procfs-move-ldlm-proc-handling-over-to-seq_f.patch,
+ +files/0009-LU-3319-procfs-move-ost-proc-handling-over-to-seq_fi.patch,
+ files/0001-LU-2982-build-make-AC-check-for-linux-arch-sandbox-f.patch,
+ files/0002-LU-3373-ldiskfs-ldiskfs-patches-for-3.11.1-fc19.patch,
+ files/0003-LU-3974-llite-dentry-d_compare-changes-in-3.11.patch,
+ files/0004-LU-3974-llite-use-new-struct-dir_context.patch,
+ files/0005-LU-3974-llite-invalidatepage-api-changed.patch,
+ files/0006-LU-3319-procfs-move-llite-proc-handling-over-to-seq_.patch,
+ lustre-9999.ebuild:
+ Give me more patches =D
+
+ 19 Dec 2013; Alexey Shvetsov <alexxy@gentoo.org>
+files/0006-LU-3319-procfs-move-llite-proc-handling-over-to-seq_.patch,
files/0001-LU-2982-build-make-AC-check-for-linux-arch-sandbox-f.patch,
files/0002-LU-3373-ldiskfs-ldiskfs-patches-for-3.11.1-fc19.patch,
diff --git a/sys-cluster/lustre/files/0001-LU-2982-build-make-AC-check-for-linux-arch-sandbox-f.patch b/sys-cluster/lustre/files/0001-LU-2982-build-make-AC-check-for-linux-arch-sandbox-f.patch
index 8ace887..b1123cc 100644
--- a/sys-cluster/lustre/files/0001-LU-2982-build-make-AC-check-for-linux-arch-sandbox-f.patch
+++ b/sys-cluster/lustre/files/0001-LU-2982-build-make-AC-check-for-linux-arch-sandbox-f.patch
@@ -1,7 +1,7 @@
From a607b37a64f797b766825ccb6f41176685cd843f Mon Sep 17 00:00:00 2001
From: Alexey Shvetsov <alexxy@gentoo.org>
Date: Mon, 18 Mar 2013 16:22:27 +0400
-Subject: [PATCH 1/6] LU-2982 build: make AC check for linux arch sandbox
+Subject: [PATCH 01/10] LU-2982 build: make AC check for linux arch sandbox
friendly
this commit makes AC check for linux kernel arch sandbox friendly
diff --git a/sys-cluster/lustre/files/0002-LU-3373-ldiskfs-ldiskfs-patches-for-3.11.1-fc19.patch b/sys-cluster/lustre/files/0002-LU-3373-ldiskfs-ldiskfs-patches-for-3.11.1-fc19.patch
index 975d6a9..d231dd4 100644
--- a/sys-cluster/lustre/files/0002-LU-3373-ldiskfs-ldiskfs-patches-for-3.11.1-fc19.patch
+++ b/sys-cluster/lustre/files/0002-LU-3373-ldiskfs-ldiskfs-patches-for-3.11.1-fc19.patch
@@ -1,7 +1,7 @@
From e53207df22261a635315a62f1405eb8c7b700963 Mon Sep 17 00:00:00 2001
From: James Simmons <uja.ornl@gmail.com>
Date: Thu, 5 Dec 2013 09:05:22 -0500
-Subject: [PATCH 2/6] LU-3373 ldiskfs: ldiskfs patches for 3.11.1 fc19
+Subject: [PATCH 02/10] LU-3373 ldiskfs: ldiskfs patches for 3.11.1 fc19
ldiskfs patches
diff --git a/sys-cluster/lustre/files/0003-LU-3974-llite-dentry-d_compare-changes-in-3.11.patch b/sys-cluster/lustre/files/0003-LU-3974-llite-dentry-d_compare-changes-in-3.11.patch
index 7034391..09fccee 100644
--- a/sys-cluster/lustre/files/0003-LU-3974-llite-dentry-d_compare-changes-in-3.11.patch
+++ b/sys-cluster/lustre/files/0003-LU-3974-llite-dentry-d_compare-changes-in-3.11.patch
@@ -1,7 +1,7 @@
From 18cfd561fae3b2eac663b51f8e5147b59c711af7 Mon Sep 17 00:00:00 2001
From: James Simmons <uja.ornl@gmail.com>
Date: Wed, 11 Dec 2013 10:29:41 -0500
-Subject: [PATCH 3/6] LU-3974 llite: dentry d_compare changes in 3.11
+Subject: [PATCH 03/10] LU-3974 llite: dentry d_compare changes in 3.11
In the linux 3.11 kernel the d_compare function has
removed passing in any struct inode arguments. This
diff --git a/sys-cluster/lustre/files/0004-LU-3974-llite-use-new-struct-dir_context.patch b/sys-cluster/lustre/files/0004-LU-3974-llite-use-new-struct-dir_context.patch
index f50491f..d60c144 100644
--- a/sys-cluster/lustre/files/0004-LU-3974-llite-use-new-struct-dir_context.patch
+++ b/sys-cluster/lustre/files/0004-LU-3974-llite-use-new-struct-dir_context.patch
@@ -1,7 +1,7 @@
From 82f692de87cb6c7db8f050b3201d23f4852a404c Mon Sep 17 00:00:00 2001
From: James Simmons <uja.ornl@gmail.com>
Date: Mon, 2 Dec 2013 12:05:14 -0500
-Subject: [PATCH 4/6] LU-3974 llite: use new struct dir_context
+Subject: [PATCH 04/10] LU-3974 llite: use new struct dir_context
The readdir and nfs code over time has added more
parameters to be passed to be processed. For the 3.11
diff --git a/sys-cluster/lustre/files/0005-LU-3974-llite-invalidatepage-api-changed.patch b/sys-cluster/lustre/files/0005-LU-3974-llite-invalidatepage-api-changed.patch
index 823c159..ea5eea5 100644
--- a/sys-cluster/lustre/files/0005-LU-3974-llite-invalidatepage-api-changed.patch
+++ b/sys-cluster/lustre/files/0005-LU-3974-llite-invalidatepage-api-changed.patch
@@ -1,7 +1,7 @@
From 2725bc0f3bc5fa7706b9a475ccb0c191f21ca884 Mon Sep 17 00:00:00 2001
From: James Simmons <uja.ornl@gmail.com>
Date: Tue, 24 Sep 2013 12:29:47 -0400
-Subject: [PATCH 5/6] LU-3974 llite: invalidatepage api changed
+Subject: [PATCH 05/10] LU-3974 llite: invalidatepage api changed
Until recently invalidating pages from the buffer cache
was dependent only on the page passed in and the start
diff --git a/sys-cluster/lustre/files/0006-LU-3319-procfs-move-llite-proc-handling-over-to-seq_.patch b/sys-cluster/lustre/files/0006-LU-3319-procfs-move-llite-proc-handling-over-to-seq_.patch
index 427e088..1df7373 100644
--- a/sys-cluster/lustre/files/0006-LU-3319-procfs-move-llite-proc-handling-over-to-seq_.patch
+++ b/sys-cluster/lustre/files/0006-LU-3319-procfs-move-llite-proc-handling-over-to-seq_.patch
@@ -1,7 +1,8 @@
From 01ce737ef8bba37c904d79f3aabe88a4ead20b74 Mon Sep 17 00:00:00 2001
From: James Simmons <uja.ornl@gmail.com>
Date: Thu, 5 Dec 2013 13:53:37 -0500
-Subject: [PATCH 6/6] LU-3319 procfs: move llite proc handling over to seq_file
+Subject: [PATCH 06/10] LU-3319 procfs: move llite proc handling over to
+ seq_file
For lustre clients a special abstract layer so a lustre
client can be mounted. In order to support 3.10+ kernels
diff --git a/sys-cluster/lustre/files/0007-LU-3319-procfs-move-lmv-proc-handling-over-to-seq_fi.patch b/sys-cluster/lustre/files/0007-LU-3319-procfs-move-lmv-proc-handling-over-to-seq_fi.patch
new file mode 100644
index 0000000..c710c5c
--- /dev/null
+++ b/sys-cluster/lustre/files/0007-LU-3319-procfs-move-lmv-proc-handling-over-to-seq_fi.patch
@@ -0,0 +1,409 @@
+From 4169735b41f2452d884e24c92581af0c4fbf6121 Mon Sep 17 00:00:00 2001
+From: James Simmons <uja.ornl@gmail.com>
+Date: Thu, 14 Nov 2013 09:32:29 -0500
+Subject: [PATCH 07/10] LU-3319 procfs: move lmv proc handling over to seq_file
+
+In order to support 3.10+ kernels for clients we adapt
+the lmv proc handling to using seq_files.
+
+Signed-off-by: James Simmons <uja.ornl@gmail.com>
+Change-Id: I34f58c3a484ee79b41b59d4a60f6a21726373152
+---
+ lustre/lmv/lmv_internal.h | 7 +--
+ lustre/lmv/lmv_obd.c | 138 ++++++++++++++++++++--------------------------
+ lustre/lmv/lproc_lmv.c | 78 ++++++++++----------------
+ 3 files changed, 91 insertions(+), 132 deletions(-)
+
+diff --git a/lustre/lmv/lmv_internal.h b/lustre/lmv/lmv_internal.h
+index 15692c5..1d027d7 100644
+--- a/lustre/lmv/lmv_internal.h
++++ b/lustre/lmv/lmv_internal.h
+@@ -147,12 +147,7 @@ struct lmv_tgt_desc
+ struct lu_fid *fid);
+ /* lproc_lmv.c */
+ #ifdef LPROCFS
+-void lprocfs_lmv_init_vars(struct lprocfs_static_vars *lvars);
+-#else
+-static inline void lprocfs_lmv_init_vars(struct lprocfs_static_vars *lvars)
+-{
+- memset(lvars, 0, sizeof(*lvars));
+-}
++extern struct lprocfs_seq_vars lprocfs_lmv_obd_vars[];
+ #endif
+ extern struct file_operations lmv_proc_target_fops;
+
+diff --git a/lustre/lmv/lmv_obd.c b/lustre/lmv/lmv_obd.c
+index 56d6e20..888a86f 100644
+--- a/lustre/lmv/lmv_obd.c
++++ b/lustre/lmv/lmv_obd.c
+@@ -239,13 +239,19 @@ static int lmv_connect(const struct lu_env *env,
+ lmv->conn_data = *data;
+
+ #ifdef __KERNEL__
+- lmv_proc_dir = lprocfs_register("target_obds", obd->obd_proc_entry,
+- NULL, NULL);
+- if (IS_ERR(lmv_proc_dir)) {
+- CERROR("could not register /proc/fs/lustre/%s/%s/target_obds.",
+- obd->obd_type->typ_name, obd->obd_name);
+- lmv_proc_dir = NULL;
+- }
++ if (obd->obd_proc_private != NULL) {
++ lmv_proc_dir = obd->obd_proc_private;
++ } else {
++ lmv_proc_dir = lprocfs_seq_register("target_obds",
++ obd->obd_proc_entry,
++ NULL, NULL);
++ if (IS_ERR(lmv_proc_dir)) {
++ CERROR("could not register /proc/fs/lustre/%s/%s/target_obds.",
++ obd->obd_type->typ_name, obd->obd_name);
++ lmv_proc_dir = NULL;
++ }
++ obd->obd_proc_private = lmv_proc_dir;
++ }
+ #endif
+
+ /*
+@@ -258,12 +264,11 @@ static int lmv_connect(const struct lu_env *env,
+ rc = lmv_check_connect(obd);
+
+ #ifdef __KERNEL__
+- if (rc) {
+- if (lmv_proc_dir)
+- lprocfs_remove(&lmv_proc_dir);
+- }
++ if (rc && lmv_proc_dir) {
++ lprocfs_remove(&lmv_proc_dir);
++ obd->obd_proc_private = NULL;
++ }
+ #endif
+-
+ RETURN(rc);
+ }
+
+@@ -423,28 +428,28 @@ int lmv_connect_mdc(struct obd_device *obd, struct lmv_tgt_desc *tgt)
+ cfs_atomic_read(&obd->obd_refcount));
+
+ #ifdef __KERNEL__
+- lmv_proc_dir = lprocfs_srch(obd->obd_proc_entry, "target_obds");
+- if (lmv_proc_dir) {
+- struct proc_dir_entry *mdc_symlink;
+-
+- LASSERT(mdc_obd->obd_type != NULL);
+- LASSERT(mdc_obd->obd_type->typ_name != NULL);
+- mdc_symlink = lprocfs_add_symlink(mdc_obd->obd_name,
+- lmv_proc_dir,
+- "../../../%s/%s",
+- mdc_obd->obd_type->typ_name,
+- mdc_obd->obd_name);
+- if (mdc_symlink == NULL) {
+- CERROR("Could not register LMV target "
+- "/proc/fs/lustre/%s/%s/target_obds/%s.",
+- obd->obd_type->typ_name, obd->obd_name,
+- mdc_obd->obd_name);
+- lprocfs_remove(&lmv_proc_dir);
+- lmv_proc_dir = NULL;
+- }
+- }
++ lmv_proc_dir = obd->obd_proc_private;
++ if (lmv_proc_dir) {
++ struct proc_dir_entry *mdc_symlink;
++
++ LASSERT(mdc_obd->obd_type != NULL);
++ LASSERT(mdc_obd->obd_type->typ_name != NULL);
++ mdc_symlink = lprocfs_add_symlink(mdc_obd->obd_name,
++ lmv_proc_dir,
++ "../../../%s/%s",
++ mdc_obd->obd_type->typ_name,
++ mdc_obd->obd_name);
++ if (mdc_symlink == NULL) {
++ CERROR("Could not register LMV target "
++ "/proc/fs/lustre/%s/%s/target_obds/%s.",
++ obd->obd_type->typ_name, obd->obd_name,
++ mdc_obd->obd_name);
++ lprocfs_remove(&lmv_proc_dir);
++ obd->obd_proc_private = NULL;
++ }
++ }
+ #endif
+- RETURN(0);
++ RETURN(0);
+ }
+
+ static void lmv_del_target(struct lmv_obd *lmv, int index)
+@@ -652,19 +657,9 @@ static int lmv_disconnect_mdc(struct obd_device *obd, struct lmv_tgt_desc *tgt)
+ }
+
+ #ifdef __KERNEL__
+- lmv_proc_dir = lprocfs_srch(obd->obd_proc_entry, "target_obds");
+- if (lmv_proc_dir) {
+- struct proc_dir_entry *mdc_symlink;
+-
+- mdc_symlink = lprocfs_srch(lmv_proc_dir, mdc_obd->obd_name);
+- if (mdc_symlink) {
+- lprocfs_remove(&mdc_symlink);
+- } else {
+- CERROR("/proc/fs/lustre/%s/%s/target_obds/%s missing\n",
+- obd->obd_type->typ_name, obd->obd_name,
+- mdc_obd->obd_name);
+- }
+- }
++ lmv_proc_dir = obd->obd_proc_private;
++ if (lmv_proc_dir)
++ lprocfs_remove_proc_entry(mdc_obd->obd_name, lmv_proc_dir);
+ #endif
+ rc = obd_fid_fini(tgt->ltd_exp->exp_obd);
+ if (rc)
+@@ -691,9 +686,6 @@ static int lmv_disconnect_mdc(struct obd_device *obd, struct lmv_tgt_desc *tgt)
+ static int lmv_disconnect(struct obd_export *exp)
+ {
+ struct obd_device *obd = class_exp2obd(exp);
+-#ifdef __KERNEL__
+- struct proc_dir_entry *lmv_proc_dir;
+-#endif
+ struct lmv_obd *lmv = &obd->u.lmv;
+ int rc;
+ __u32 i;
+@@ -717,13 +709,11 @@ static int lmv_disconnect(struct obd_export *exp)
+ }
+
+ #ifdef __KERNEL__
+- lmv_proc_dir = lprocfs_srch(obd->obd_proc_entry, "target_obds");
+- if (lmv_proc_dir) {
+- lprocfs_remove(&lmv_proc_dir);
+- } else {
+- CERROR("/proc/fs/lustre/%s/%s/target_obds missing\n",
+- obd->obd_type->typ_name, obd->obd_name);
+- }
++ if (obd->obd_proc_private)
++ lprocfs_remove((struct proc_dir_entry **)&obd->obd_proc_private);
++ else
++ CERROR("/proc/fs/lustre/%s/%s/target_obds missing\n",
++ obd->obd_type->typ_name, obd->obd_name);
+ #endif
+
+ out_local:
+@@ -1383,11 +1373,10 @@ int lmv_fid_alloc(struct obd_export *exp, struct lu_fid *fid,
+
+ static int lmv_setup(struct obd_device *obd, struct lustre_cfg *lcfg)
+ {
+- struct lmv_obd *lmv = &obd->u.lmv;
+- struct lprocfs_static_vars lvars;
+- struct lmv_desc *desc;
+- int rc;
+- ENTRY;
++ struct lmv_obd *lmv = &obd->u.lmv;
++ struct lmv_desc *desc;
++ int rc;
++ ENTRY;
+
+ if (LUSTRE_CFG_BUFLEN(lcfg, 1) < 1) {
+ CERROR("LMV setup requires a descriptor\n");
+@@ -1417,18 +1406,15 @@ static int lmv_setup(struct obd_device *obd, struct lustre_cfg *lcfg)
+ spin_lock_init(&lmv->lmv_lock);
+ mutex_init(&lmv->init_mutex);
+
+- lprocfs_lmv_init_vars(&lvars);
+-
+- lprocfs_obd_setup(obd, lvars.obd_vars);
+- lprocfs_alloc_md_stats(obd, 0);
+ #ifdef LPROCFS
+- {
+- rc = lprocfs_seq_create(obd->obd_proc_entry, "target_obd",
+- 0444, &lmv_proc_target_fops, obd);
+- if (rc)
+- CWARN("%s: error adding LMV target_obd file: rc = %d\n",
+- obd->obd_name, rc);
+- }
++ obd->obd_vars = lprocfs_lmv_obd_vars;
++ lprocfs_seq_obd_setup(obd);
++ lprocfs_alloc_md_stats(obd, 0);
++ rc = lprocfs_seq_create(obd->obd_proc_entry, "target_obd",
++ 0444, &lmv_proc_target_fops, obd);
++ if (rc)
++ CWARN("%s: error adding LMV target_obd file: rc = %d\n",
++ obd->obd_name, rc);
+ #endif
+ rc = fld_client_init(&lmv->lmv_fld, obd->obd_name,
+ LUSTRE_CLI_FLD_HASH_DHT);
+@@ -2477,7 +2463,7 @@ int lmv_set_info_async(const struct lu_env *env, struct obd_export *exp,
+ obd_count keylen, void *key, obd_count vallen,
+ void *val, struct ptlrpc_request_set *set)
+ {
+- struct lmv_tgt_desc *tgt;
++ struct lmv_tgt_desc *tgt = NULL;
+ struct obd_device *obd;
+ struct lmv_obd *lmv;
+ int rc = 0;
+@@ -2982,13 +2968,9 @@ struct md_ops lmv_md_ops = {
+
+ int __init lmv_init(void)
+ {
+- struct lprocfs_static_vars lvars;
+-
+- lprocfs_lmv_init_vars(&lvars);
+-
+ return class_register_type(&lmv_obd_ops, &lmv_md_ops, NULL,
+ #ifndef HAVE_ONLY_PROCFS_SEQ
+- lvars.module_vars,
++ NULL,
+ #endif
+ LUSTRE_LMV_NAME, NULL);
+ }
+diff --git a/lustre/lmv/lproc_lmv.c b/lustre/lmv/lproc_lmv.c
+index 6a3b128..eea5927 100644
+--- a/lustre/lmv/lproc_lmv.c
++++ b/lustre/lmv/lproc_lmv.c
+@@ -46,18 +46,16 @@
+ static struct lprocfs_vars lprocfs_module_vars[] = { {0} };
+ static struct lprocfs_vars lprocfs_obd_vars[] = { {0} };
+ #else
+-static int lmv_rd_numobd(char *page, char **start, off_t off, int count,
+- int *eof, void *data)
++static int lmv_numobd_seq_show(struct seq_file *m, void *v)
+ {
+- struct obd_device *dev = (struct obd_device*)data;
++ struct obd_device *dev = (struct obd_device *)m->private;
+ struct lmv_desc *desc;
+
+ LASSERT(dev != NULL);
+ desc = &dev->u.lmv.desc;
+- *eof = 1;
+- return snprintf(page, count, "%u\n", desc->ld_tgt_count);
+-
++ return seq_printf(m, "%u\n", desc->ld_tgt_count);
+ }
++LPROC_SEQ_FOPS_RO(lmv_numobd);
+
+ static const char *placement_name[] = {
+ [PLACEMENT_CHAR_POLICY] = "CHAR",
+@@ -82,26 +80,22 @@ static const char *placement_policy2name(placement_policy_t placement)
+ return placement_name[placement];
+ }
+
+-static int lmv_rd_placement(char *page, char **start, off_t off, int count,
+- int *eof, void *data)
++static int lmv_placement_seq_show(struct seq_file *m, void *v)
+ {
+- struct obd_device *dev = (struct obd_device*)data;
++ struct obd_device *dev = (struct obd_device *)m->private;
+ struct lmv_obd *lmv;
+
+ LASSERT(dev != NULL);
+ lmv = &dev->u.lmv;
+- *eof = 1;
+- return snprintf(page, count, "%s\n",
+- placement_policy2name(lmv->lmv_placement));
+-
++ return seq_printf(m, "%s\n", placement_policy2name(lmv->lmv_placement));
+ }
+
+ #define MAX_POLICY_STRING_SIZE 64
+
+-static int lmv_wr_placement(struct file *file, const char *buffer,
+- unsigned long count, void *data)
++static ssize_t lmv_placement_seq_write(struct file *file, const char *buffer,
++ size_t count, loff_t *off)
+ {
+- struct obd_device *dev = (struct obd_device *)data;
++ struct obd_device *dev = ((struct seq_file *)file->private_data)->private;
+ char dummy[MAX_POLICY_STRING_SIZE + 1];
+ int len = count;
+ placement_policy_t policy;
+@@ -131,30 +125,29 @@ static int lmv_wr_placement(struct file *file, const char *buffer,
+ }
+ return count;
+ }
++LPROC_SEQ_FOPS(lmv_placement);
+
+-static int lmv_rd_activeobd(char *page, char **start, off_t off, int count,
+- int *eof, void *data)
++static int lmv_activeobd_seq_show(struct seq_file *m, void *v)
+ {
+- struct obd_device *dev = (struct obd_device*)data;
++ struct obd_device *dev = (struct obd_device *)m->private;
+ struct lmv_desc *desc;
+
+ LASSERT(dev != NULL);
+ desc = &dev->u.lmv.desc;
+- *eof = 1;
+- return snprintf(page, count, "%u\n", desc->ld_active_tgt_count);
++ return seq_printf(m, "%u\n", desc->ld_active_tgt_count);
+ }
++LPROC_SEQ_FOPS_RO(lmv_activeobd);
+
+-static int lmv_rd_desc_uuid(char *page, char **start, off_t off, int count,
+- int *eof, void *data)
++static int lmv_desc_uuid_seq_show(struct seq_file *m, void *v)
+ {
+- struct obd_device *dev = (struct obd_device*) data;
++ struct obd_device *dev = (struct obd_device*)m->private;
+ struct lmv_obd *lmv;
+
+ LASSERT(dev != NULL);
+ lmv = &dev->u.lmv;
+- *eof = 1;
+- return snprintf(page, count, "%s\n", lmv->desc.ld_uuid.uuid);
++ return seq_printf(m, "%s\n", lmv->desc.ld_uuid.uuid);
+ }
++LPROC_SEQ_FOPS_RO(lmv_desc_uuid);
+
+ static void *lmv_tgt_seq_start(struct seq_file *p, loff_t *pos)
+ {
+@@ -195,7 +188,6 @@ struct seq_operations lmv_tgt_sops = {
+
+ static int lmv_target_seq_open(struct inode *inode, struct file *file)
+ {
+- struct proc_dir_entry *dp = PDE(inode);
+ struct seq_file *seq;
+ int rc;
+
+@@ -203,24 +195,20 @@ static int lmv_target_seq_open(struct inode *inode, struct file *file)
+ if (rc)
+ return rc;
+
+- seq = file->private_data;
+- seq->private = dp->data;
+-
+- return 0;
++ seq = file->private_data;
++ seq->private = PDE_DATA(inode);
++ return 0;
+ }
+
+-struct lprocfs_vars lprocfs_lmv_obd_vars[] = {
+- { "numobd", lmv_rd_numobd, 0, 0 },
+- { "placement", lmv_rd_placement, lmv_wr_placement, 0 },
+- { "activeobd", lmv_rd_activeobd, 0, 0 },
+- { "uuid", lprocfs_rd_uuid, 0, 0 },
+- { "desc_uuid", lmv_rd_desc_uuid, 0, 0 },
+- { 0 }
+-};
++LPROC_SEQ_FOPS_RO_TYPE(lmv, uuid);
+
+-static struct lprocfs_vars lprocfs_lmv_module_vars[] = {
+- { "num_refs", lprocfs_rd_numrefs, 0, 0 },
+- { 0 }
++struct lprocfs_seq_vars lprocfs_lmv_obd_vars[] = {
++ { "numobd", &lmv_numobd_fops },
++ { "placement", &lmv_placement_fops },
++ { "activeobd", &lmv_activeobd_fops },
++ { "uuid", &lmv_uuid_fops },
++ { "desc_uuid", &lmv_desc_uuid_fops },
++ { 0 }
+ };
+
+ struct file_operations lmv_proc_target_fops = {
+@@ -230,10 +218,4 @@ struct file_operations lmv_proc_target_fops = {
+ .llseek = seq_lseek,
+ .release = seq_release,
+ };
+-
+ #endif /* LPROCFS */
+-void lprocfs_lmv_init_vars(struct lprocfs_static_vars *lvars)
+-{
+- lvars->module_vars = lprocfs_lmv_module_vars;
+- lvars->obd_vars = lprocfs_lmv_obd_vars;
+-}
+--
+1.8.5.1
+
diff --git a/sys-cluster/lustre/files/0008-LU-3319-procfs-move-ldlm-proc-handling-over-to-seq_f.patch b/sys-cluster/lustre/files/0008-LU-3319-procfs-move-ldlm-proc-handling-over-to-seq_f.patch
new file mode 100644
index 0000000..5d2cd20
--- /dev/null
+++ b/sys-cluster/lustre/files/0008-LU-3319-procfs-move-ldlm-proc-handling-over-to-seq_f.patch
@@ -0,0 +1,789 @@
+From a464fd862a7876e1c4f679b32956904eee88d45e Mon Sep 17 00:00:00 2001
+From: James Simmons <uja.ornl@gmail.com>
+Date: Tue, 17 Dec 2013 19:11:15 -0500
+Subject: [PATCH 08/10] LU-3319 procfs: move ldlm proc handling over to
+ seq_file
+
+In order to support 3.10+ kernels for clients we adapt
+the ldlm proc handling to using seq_files.
+
+Signed-off-by: James Simmons <uja.ornl@gmail.com>
+Change-Id: Iaedae5fe1e1cd2985a6240314810db9bba3cd747
+---
+ lustre/include/lustre_dlm.h | 5 +-
+ lustre/ldlm/ldlm_internal.h | 85 ++++++------
+ lustre/ldlm/ldlm_pool.c | 197 +++++++++++++---------------
+ lustre/ldlm/ldlm_resource.c | 306 +++++++++++++++++++-------------------------
+ 4 files changed, 270 insertions(+), 323 deletions(-)
+
+diff --git a/lustre/include/lustre_dlm.h b/lustre/include/lustre_dlm.h
+index 30b70b5..d01b7e9 100644
+--- a/lustre/include/lustre_dlm.h
++++ b/lustre/include/lustre_dlm.h
+@@ -243,7 +243,7 @@ struct ldlm_pool_ops {
+ */
+ struct ldlm_pool {
+ /** Pool proc directory. */
+- cfs_proc_dir_entry_t *pl_proc_dir;
++ struct proc_dir_entry *pl_proc_dir;
+ /** Pool name, must be long enough to hold compound proc entry name. */
+ char pl_name[100];
+ /** Lock for protecting SLV/CLV updates. */
+@@ -400,6 +400,9 @@ struct ldlm_namespace {
+ /** Client side original connect flags supported by server. */
+ __u64 ns_orig_connect_flags;
+
++ /* namespace proc dir entry */
++ struct proc_dir_entry *ns_proc_dir_entry;
++
+ /**
+ * Position in global namespace list linking all namespaces on
+ * the node.
+diff --git a/lustre/ldlm/ldlm_internal.h b/lustre/ldlm/ldlm_internal.h
+index 5077072..ffc528b 100644
+--- a/lustre/ldlm/ldlm_internal.h
++++ b/lustre/ldlm/ldlm_internal.h
+@@ -212,8 +212,8 @@ void ldlm_destroy_flock_export(struct obd_export *exp);
+ void l_check_ns_lock(struct ldlm_namespace *ns);
+ void l_check_no_ns_lock(struct ldlm_namespace *ns);
+
+-extern cfs_proc_dir_entry_t *ldlm_svc_proc_dir;
+-extern cfs_proc_dir_entry_t *ldlm_type_proc_dir;
++extern struct proc_dir_entry *ldlm_svc_proc_dir;
++extern struct proc_dir_entry *ldlm_type_proc_dir;
+
+ struct ldlm_state {
+ struct ptlrpc_service *ldlm_cb_service;
+@@ -252,42 +252,51 @@ enum ldlm_policy_res {
+
+ typedef enum ldlm_policy_res ldlm_policy_res_t;
+
+-#define LDLM_POOL_PROC_READER(var, type) \
+- static int lprocfs_rd_##var(char *page, char **start, off_t off, \
+- int count, int *eof, void *data) \
+- { \
+- struct ldlm_pool *pl = data; \
+- type tmp; \
+- \
+- spin_lock(&pl->pl_lock); \
+- tmp = pl->pl_##var; \
+- spin_unlock(&pl->pl_lock); \
+- \
+- return lprocfs_rd_uint(page, start, off, count, eof, &tmp); \
+- } \
+- struct __##var##__dummy_read {;} /* semicolon catcher */
+-
+-#define LDLM_POOL_PROC_WRITER(var, type) \
+- int lprocfs_wr_##var(struct file *file, const char *buffer, \
+- unsigned long count, void *data) \
+- { \
+- struct ldlm_pool *pl = data; \
+- type tmp; \
+- int rc; \
+- \
+- rc = lprocfs_wr_uint(file, buffer, count, &tmp); \
+- if (rc < 0) { \
+- CERROR("Can't parse user input, rc = %d\n", rc); \
+- return rc; \
+- } \
+- \
+- spin_lock(&pl->pl_lock); \
+- pl->pl_##var = tmp; \
+- spin_unlock(&pl->pl_lock); \
+- \
+- return rc; \
+- } \
+- struct __##var##__dummy_write {;} /* semicolon catcher */
++#define LDLM_POOL_PROC_READER_SEQ_SHOW(var, type) \
++ static int lprocfs_##var##_seq_show(struct seq_file *m, void *v)\
++ { \
++ struct ldlm_pool *pl = m->private; \
++ type tmp; \
++ \
++ spin_lock(&pl->pl_lock); \
++ tmp = pl->pl_##var; \
++ spin_unlock(&pl->pl_lock); \
++ \
++ return lprocfs_uint_seq_show(m, &tmp); \
++ } \
++ struct __##var##__dummy_read {;} /* semicolon catcher */
++
++#define LDLM_POOL_PROC_WRITER(var, type) \
++ int lprocfs_wr_##var(struct file *file, const char *buffer, \
++ unsigned long count, void *data) \
++ { \
++ struct ldlm_pool *pl = data; \
++ type tmp; \
++ int rc; \
++ \
++ rc = lprocfs_wr_uint(file, buffer, count, &tmp); \
++ if (rc < 0) { \
++ CERROR("Can't parse user input, rc = %d\n", rc);\
++ return rc; \
++ } \
++ \
++ spin_lock(&pl->pl_lock); \
++ pl->pl_##var = tmp; \
++ spin_unlock(&pl->pl_lock); \
++ \
++ return rc; \
++ } \
++ struct __##var##__dummy_write {;} /* semicolon catcher */
++
++static inline void
++ldlm_add_var(struct lprocfs_seq_vars *vars, struct proc_dir_entry *proc_dir,
++ const char *name, void *data, const struct file_operations *ops)
++{
++ snprintf((char *)vars->name, MAX_STRING_SIZE, "%s", name);
++ vars->data = data;
++ vars->fops = ops;
++ lprocfs_seq_add_vars(proc_dir, vars, 0);
++}
+
+ static inline int is_granted_or_cancelled(struct ldlm_lock *lock)
+ {
+diff --git a/lustre/ldlm/ldlm_pool.c b/lustre/ldlm/ldlm_pool.c
+index 734b330..c1b7ac6 100644
+--- a/lustre/ldlm/ldlm_pool.c
++++ b/lustre/ldlm/ldlm_pool.c
+@@ -148,7 +148,7 @@
+ #define LDLM_POOL_SLV_SHIFT (10)
+
+ #ifdef __KERNEL__
+-extern cfs_proc_dir_entry_t *ldlm_ns_proc_dir;
++extern struct proc_dir_entry *ldlm_ns_proc_dir;
+ #endif
+
+ static inline __u64 dru(__u64 val, __u32 shift, int round_up)
+@@ -656,14 +656,13 @@ int ldlm_pool_setup(struct ldlm_pool *pl, int limit)
+ EXPORT_SYMBOL(ldlm_pool_setup);
+
+ #ifdef __KERNEL__
+-static int lprocfs_rd_pool_state(char *page, char **start, off_t off,
+- int count, int *eof, void *data)
++static int lprocfs_pool_state_seq_show(struct seq_file *m, void *unused)
+ {
+- int granted, grant_rate, cancel_rate, grant_step;
+- int nr = 0, grant_speed, grant_plan, lvf;
+- struct ldlm_pool *pl = data;
+- __u64 slv, clv;
+- __u32 limit;
++ int granted, grant_rate, cancel_rate, grant_step;
++ int grant_speed, grant_plan, lvf;
++ struct ldlm_pool *pl = m->private;
++ __u64 slv, clv;
++ __u32 limit;
+
+ spin_lock(&pl->pl_lock);
+ slv = pl->pl_server_lock_volume;
+@@ -678,35 +677,28 @@ static int lprocfs_rd_pool_state(char *page, char **start, off_t off,
+ grant_step = ldlm_pool_t2gsp(pl->pl_recalc_period);
+ spin_unlock(&pl->pl_lock);
+
+- nr += snprintf(page + nr, count - nr, "LDLM pool state (%s):\n",
+- pl->pl_name);
+- nr += snprintf(page + nr, count - nr, " SLV: "LPU64"\n", slv);
+- nr += snprintf(page + nr, count - nr, " CLV: "LPU64"\n", clv);
+- nr += snprintf(page + nr, count - nr, " LVF: %d\n", lvf);
+-
+- if (ns_is_server(ldlm_pl2ns(pl))) {
+- nr += snprintf(page + nr, count - nr, " GSP: %d%%\n",
+- grant_step);
+- nr += snprintf(page + nr, count - nr, " GP: %d\n",
+- grant_plan);
+- }
+- nr += snprintf(page + nr, count - nr, " GR: %d\n",
+- grant_rate);
+- nr += snprintf(page + nr, count - nr, " CR: %d\n",
+- cancel_rate);
+- nr += snprintf(page + nr, count - nr, " GS: %d\n",
+- grant_speed);
+- nr += snprintf(page + nr, count - nr, " G: %d\n",
+- granted);
+- nr += snprintf(page + nr, count - nr, " L: %d\n",
+- limit);
+- return nr;
++ seq_printf(m, "LDLM pool state (%s):\n"
++ " SLV: "LPU64"\n"
++ " CLV: "LPU64"\n"
++ " LVF: %d\n",
++ pl->pl_name, slv, clv, lvf);
++
++ if (ns_is_server(ldlm_pl2ns(pl))) {
++ seq_printf(m, " GSP: %d%%\n"
++ " GP: %d\n",
++ grant_step, grant_plan);
++ }
++ seq_printf(m, " GR: %d\n" " CR: %d\n" " GS: %d\n"
++ " G: %d\n" " L: %d\n",
++ grant_rate, cancel_rate, grant_speed,
++ granted, limit);
++ return 0;
+ }
++LPROC_SEQ_FOPS_RO(lprocfs_pool_state);
+
+-static int lprocfs_rd_grant_speed(char *page, char **start, off_t off,
+- int count, int *eof, void *data)
++static int lprocfs_grant_speed_seq_show(struct seq_file *m, void *unused)
+ {
+- struct ldlm_pool *pl = data;
++ struct ldlm_pool *pl = m->private;
+ int grant_speed;
+
+ spin_lock(&pl->pl_lock);
+@@ -714,35 +706,50 @@ static int lprocfs_rd_grant_speed(char *page, char **start, off_t off,
+ grant_speed = cfs_atomic_read(&pl->pl_grant_rate) -
+ cfs_atomic_read(&pl->pl_cancel_rate);
+ spin_unlock(&pl->pl_lock);
+- return lprocfs_rd_uint(page, start, off, count, eof, &grant_speed);
++ return lprocfs_uint_seq_show(m, &grant_speed);
+ }
+
+-LDLM_POOL_PROC_READER(grant_plan, int);
+-LDLM_POOL_PROC_READER(recalc_period, int);
++LDLM_POOL_PROC_READER_SEQ_SHOW(grant_plan, int);
++LPROC_SEQ_FOPS_RO(lprocfs_grant_plan);
++
++LDLM_POOL_PROC_READER_SEQ_SHOW(recalc_period, int);
+ LDLM_POOL_PROC_WRITER(recalc_period, int);
++static ssize_t lprocfs_recalc_period_seq_write(struct file *file, const char *buf,
++ size_t len, loff_t *off)
++{
++ struct seq_file *seq = file->private_data;
++
++ return lprocfs_wr_recalc_period(file, buf, len, seq->private);
++}
++LPROC_SEQ_FOPS(lprocfs_recalc_period);
++
++LPROC_SEQ_FOPS_RO_TYPE(ldlm_pool, u64);
++LPROC_SEQ_FOPS_RO_TYPE(ldlm_pool, atomic);
++LPROC_SEQ_FOPS_RW_TYPE(ldlm_pool_rw, atomic);
++
++LPROC_SEQ_FOPS_RO(lprocfs_grant_speed);
+
+ static int ldlm_pool_proc_init(struct ldlm_pool *pl)
+ {
+- struct ldlm_namespace *ns = ldlm_pl2ns(pl);
+- struct proc_dir_entry *parent_ns_proc;
+- struct lprocfs_vars pool_vars[2];
+- char *var_name = NULL;
+- int rc = 0;
+- ENTRY;
++ struct ldlm_namespace *ns = ldlm_pl2ns(pl);
++ struct proc_dir_entry *parent_ns_proc;
++ struct lprocfs_seq_vars pool_vars[2];
++ char *var_name = NULL;
++ int rc = 0;
++ ENTRY;
+
+- OBD_ALLOC(var_name, MAX_STRING_SIZE + 1);
+- if (!var_name)
+- RETURN(-ENOMEM);
++ OBD_ALLOC(var_name, MAX_STRING_SIZE + 1);
++ if (!var_name)
++ RETURN(-ENOMEM);
+
+- parent_ns_proc = lprocfs_srch(ldlm_ns_proc_dir,
+- ldlm_ns_name(ns));
+- if (parent_ns_proc == NULL) {
+- CERROR("%s: proc entry is not initialized\n",
+- ldlm_ns_name(ns));
+- GOTO(out_free_name, rc = -EINVAL);
+- }
+- pl->pl_proc_dir = lprocfs_register("pool", parent_ns_proc,
+- NULL, NULL);
++ parent_ns_proc = ns->ns_proc_dir_entry;
++ if (parent_ns_proc == NULL) {
++ CERROR("%s: proc entry is not initialized\n",
++ ldlm_ns_name(ns));
++ GOTO(out_free_name, rc = -EINVAL);
++ }
++ pl->pl_proc_dir = lprocfs_seq_register("pool", parent_ns_proc,
++ NULL, NULL);
+ if (IS_ERR(pl->pl_proc_dir)) {
+ rc = PTR_ERR(pl->pl_proc_dir);
+ pl->pl_proc_dir = NULL;
+@@ -751,62 +758,30 @@ static int ldlm_pool_proc_init(struct ldlm_pool *pl)
+ GOTO(out_free_name, rc);
+ }
+
+- var_name[MAX_STRING_SIZE] = '\0';
+- memset(pool_vars, 0, sizeof(pool_vars));
+- pool_vars[0].name = var_name;
+-
+- snprintf(var_name, MAX_STRING_SIZE, "server_lock_volume");
+- pool_vars[0].data = &pl->pl_server_lock_volume;
+- pool_vars[0].read_fptr = lprocfs_rd_u64;
+- lprocfs_add_vars(pl->pl_proc_dir, pool_vars, 0);
+-
+- snprintf(var_name, MAX_STRING_SIZE, "limit");
+- pool_vars[0].data = &pl->pl_limit;
+- pool_vars[0].read_fptr = lprocfs_rd_atomic;
+- pool_vars[0].write_fptr = lprocfs_wr_atomic;
+- lprocfs_add_vars(pl->pl_proc_dir, pool_vars, 0);
+-
+- snprintf(var_name, MAX_STRING_SIZE, "granted");
+- pool_vars[0].data = &pl->pl_granted;
+- pool_vars[0].read_fptr = lprocfs_rd_atomic;
+- lprocfs_add_vars(pl->pl_proc_dir, pool_vars, 0);
+-
+- snprintf(var_name, MAX_STRING_SIZE, "grant_speed");
+- pool_vars[0].data = pl;
+- pool_vars[0].read_fptr = lprocfs_rd_grant_speed;
+- lprocfs_add_vars(pl->pl_proc_dir, pool_vars, 0);
+-
+- snprintf(var_name, MAX_STRING_SIZE, "cancel_rate");
+- pool_vars[0].data = &pl->pl_cancel_rate;
+- pool_vars[0].read_fptr = lprocfs_rd_atomic;
+- lprocfs_add_vars(pl->pl_proc_dir, pool_vars, 0);
+-
+- snprintf(var_name, MAX_STRING_SIZE, "grant_rate");
+- pool_vars[0].data = &pl->pl_grant_rate;
+- pool_vars[0].read_fptr = lprocfs_rd_atomic;
+- lprocfs_add_vars(pl->pl_proc_dir, pool_vars, 0);
+-
+- snprintf(var_name, MAX_STRING_SIZE, "grant_plan");
+- pool_vars[0].data = pl;
+- pool_vars[0].read_fptr = lprocfs_rd_grant_plan;
+- lprocfs_add_vars(pl->pl_proc_dir, pool_vars, 0);
+-
+- snprintf(var_name, MAX_STRING_SIZE, "recalc_period");
+- pool_vars[0].data = pl;
+- pool_vars[0].read_fptr = lprocfs_rd_recalc_period;
+- pool_vars[0].write_fptr = lprocfs_wr_recalc_period;
+- lprocfs_add_vars(pl->pl_proc_dir, pool_vars, 0);
+-
+- snprintf(var_name, MAX_STRING_SIZE, "lock_volume_factor");
+- pool_vars[0].data = &pl->pl_lock_volume_factor;
+- pool_vars[0].read_fptr = lprocfs_rd_atomic;
+- pool_vars[0].write_fptr = lprocfs_wr_atomic;
+- lprocfs_add_vars(pl->pl_proc_dir, pool_vars, 0);
+-
+- snprintf(var_name, MAX_STRING_SIZE, "state");
+- pool_vars[0].data = pl;
+- pool_vars[0].read_fptr = lprocfs_rd_pool_state;
+- lprocfs_add_vars(pl->pl_proc_dir, pool_vars, 0);
++ var_name[MAX_STRING_SIZE] = '\0';
++ memset(pool_vars, 0, sizeof(pool_vars));
++ pool_vars[0].name = var_name;
++
++ ldlm_add_var(&pool_vars[0], pl->pl_proc_dir, "server_lock_volume",
++ &pl->pl_server_lock_volume, &ldlm_pool_u64_fops);
++ ldlm_add_var(&pool_vars[0], pl->pl_proc_dir, "limit", &pl->pl_limit,
++ &ldlm_pool_rw_atomic_fops);
++ ldlm_add_var(&pool_vars[0], pl->pl_proc_dir, "granted",
++ &pl->pl_granted, &ldlm_pool_atomic_fops);
++ ldlm_add_var(&pool_vars[0], pl->pl_proc_dir, "grant_speed", pl,
++ &lprocfs_grant_speed_fops);
++ ldlm_add_var(&pool_vars[0], pl->pl_proc_dir, "cancel_rate",
++ &pl->pl_cancel_rate, &ldlm_pool_atomic_fops);
++ ldlm_add_var(&pool_vars[0], pl->pl_proc_dir, "grant_rate",
++ &pl->pl_grant_rate, &ldlm_pool_atomic_fops);
++ ldlm_add_var(&pool_vars[0], pl->pl_proc_dir, "grant_plan", pl,
++ &lprocfs_grant_plan_fops);
++ ldlm_add_var(&pool_vars[0], pl->pl_proc_dir, "recalc_period",
++ pl, &lprocfs_recalc_period_fops);
++ ldlm_add_var(&pool_vars[0], pl->pl_proc_dir, "lock_volume_factor",
++ &pl->pl_lock_volume_factor, &ldlm_pool_rw_atomic_fops);
++ ldlm_add_var(&pool_vars[0], pl->pl_proc_dir, "state", pl,
++ &lprocfs_pool_state_fops);
+
+ pl->pl_stats = lprocfs_alloc_stats(LDLM_POOL_LAST_STAT -
+ LDLM_POOL_FIRST_STAT, 0);
+diff --git a/lustre/ldlm/ldlm_resource.c b/lustre/ldlm/ldlm_resource.c
+index e1b8787..e504cff 100644
+--- a/lustre/ldlm/ldlm_resource.c
++++ b/lustre/ldlm/ldlm_resource.c
+@@ -66,9 +66,9 @@ CFS_LIST_HEAD(ldlm_cli_active_namespace_list);
+ /* Client namespaces that don't have any locks in them */
+ CFS_LIST_HEAD(ldlm_cli_inactive_namespace_list);
+
+-cfs_proc_dir_entry_t *ldlm_type_proc_dir = NULL;
+-cfs_proc_dir_entry_t *ldlm_ns_proc_dir = NULL;
+-cfs_proc_dir_entry_t *ldlm_svc_proc_dir = NULL;
++struct proc_dir_entry *ldlm_type_proc_dir = NULL;
++struct proc_dir_entry *ldlm_ns_proc_dir = NULL;
++struct proc_dir_entry *ldlm_svc_proc_dir = NULL;
+
+ extern unsigned int ldlm_cancel_unused_locks_before_replay;
+
+@@ -77,57 +77,64 @@ extern unsigned int ldlm_cancel_unused_locks_before_replay;
+ unsigned int ldlm_dump_granted_max = 256;
+
+ #ifdef LPROCFS
+-static int ldlm_proc_dump_ns(struct file *file, const char *buffer,
+- unsigned long count, void *data)
++static ssize_t
++lprocfs_dump_ns_seq_write(struct file *file, const char *buffer,
++ size_t count, loff_t *off)
+ {
+- ldlm_dump_all_namespaces(LDLM_NAMESPACE_SERVER, D_DLMTRACE);
+- ldlm_dump_all_namespaces(LDLM_NAMESPACE_CLIENT, D_DLMTRACE);
+- RETURN(count);
++ ldlm_dump_all_namespaces(LDLM_NAMESPACE_SERVER, D_DLMTRACE);
++ ldlm_dump_all_namespaces(LDLM_NAMESPACE_CLIENT, D_DLMTRACE);
++ RETURN(count);
+ }
++LPROC_SEQ_FOPS_WO_TYPE(ldlm, dump_ns);
++
++LPROC_SEQ_FOPS_RW_TYPE(ldlm_rw, uint);
++LPROC_SEQ_FOPS_RO_TYPE(ldlm, uint);
+
+ int ldlm_proc_setup(void)
+ {
+- int rc;
+- struct lprocfs_vars list[] = {
+- { "dump_namespaces", NULL, ldlm_proc_dump_ns, NULL },
+- { "dump_granted_max",
+- lprocfs_rd_uint, lprocfs_wr_uint,
+- &ldlm_dump_granted_max, NULL },
+- { "cancel_unused_locks_before_replay",
+- lprocfs_rd_uint, lprocfs_wr_uint,
+- &ldlm_cancel_unused_locks_before_replay, NULL },
+- { NULL }};
+- ENTRY;
+- LASSERT(ldlm_ns_proc_dir == NULL);
+-
+- ldlm_type_proc_dir = lprocfs_register(OBD_LDLM_DEVICENAME,
+- proc_lustre_root,
+- NULL, NULL);
+- if (IS_ERR(ldlm_type_proc_dir)) {
+- CERROR("LProcFS failed in ldlm-init\n");
+- rc = PTR_ERR(ldlm_type_proc_dir);
+- GOTO(err, rc);
+- }
++ int rc;
++ struct lprocfs_seq_vars list[] = {
++ { .name = "dump_namespaces",
++ .fops = &ldlm_dump_ns_fops,
++ .proc_mode = 0222 },
++ { .name = "dump_granted_max",
++ .fops = &ldlm_rw_uint_fops,
++ .data = &ldlm_dump_granted_max },
++ { .name = "cancel_unused_locks_before_replay",
++ .fops = &ldlm_rw_uint_fops,
++ .data = &ldlm_cancel_unused_locks_before_replay },
++ { NULL }};
++ ENTRY;
++ LASSERT(ldlm_ns_proc_dir == NULL);
++
++ ldlm_type_proc_dir = lprocfs_seq_register(OBD_LDLM_DEVICENAME,
++ proc_lustre_root,
++ NULL, NULL);
++ if (IS_ERR(ldlm_type_proc_dir)) {
++ CERROR("LProcFS failed in ldlm-init\n");
++ rc = PTR_ERR(ldlm_type_proc_dir);
++ GOTO(err, rc);
++ }
+
+- ldlm_ns_proc_dir = lprocfs_register("namespaces",
+- ldlm_type_proc_dir,
+- NULL, NULL);
+- if (IS_ERR(ldlm_ns_proc_dir)) {
+- CERROR("LProcFS failed in ldlm-init\n");
+- rc = PTR_ERR(ldlm_ns_proc_dir);
+- GOTO(err_type, rc);
+- }
++ ldlm_ns_proc_dir = lprocfs_seq_register("namespaces",
++ ldlm_type_proc_dir,
++ NULL, NULL);
++ if (IS_ERR(ldlm_ns_proc_dir)) {
++ CERROR("LProcFS failed in ldlm-init\n");
++ rc = PTR_ERR(ldlm_ns_proc_dir);
++ GOTO(err_type, rc);
++ }
+
+- ldlm_svc_proc_dir = lprocfs_register("services",
+- ldlm_type_proc_dir,
+- NULL, NULL);
+- if (IS_ERR(ldlm_svc_proc_dir)) {
+- CERROR("LProcFS failed in ldlm-init\n");
+- rc = PTR_ERR(ldlm_svc_proc_dir);
+- GOTO(err_ns, rc);
+- }
++ ldlm_svc_proc_dir = lprocfs_seq_register("services",
++ ldlm_type_proc_dir,
++ NULL, NULL);
++ if (IS_ERR(ldlm_svc_proc_dir)) {
++ CERROR("LProcFS failed in ldlm-init\n");
++ rc = PTR_ERR(ldlm_svc_proc_dir);
++ GOTO(err_ns, rc);
++ }
+
+- rc = lprocfs_add_vars(ldlm_type_proc_dir, list, NULL);
++ rc = lprocfs_seq_add_vars(ldlm_type_proc_dir, list, NULL);
+ if (rc != 0) {
+ CERROR("LProcFS failed in ldlm-init\n");
+ GOTO(err_svc, rc);
+@@ -158,46 +165,45 @@ void ldlm_proc_cleanup(void)
+ lprocfs_remove(&ldlm_type_proc_dir);
+ }
+
+-static int lprocfs_rd_ns_resources(char *page, char **start, off_t off,
+- int count, int *eof, void *data)
++static int lprocfs_ns_resources_seq_show(struct seq_file *m, void *v)
+ {
+- struct ldlm_namespace *ns = data;
+- __u64 res = 0;
+- cfs_hash_bd_t bd;
+- int i;
+-
+- /* result is not strictly consistant */
+- cfs_hash_for_each_bucket(ns->ns_rs_hash, &bd, i)
+- res += cfs_hash_bd_count_get(&bd);
+- return lprocfs_rd_u64(page, start, off, count, eof, &res);
++ struct ldlm_namespace *ns = m->private;
++ __u64 res = 0;
++ cfs_hash_bd_t bd;
++ int i;
++
++ /* result is not strictly consistant */
++ cfs_hash_for_each_bucket(ns->ns_rs_hash, &bd, i)
++ res += cfs_hash_bd_count_get(&bd);
++ return lprocfs_u64_seq_show(m, &res);
+ }
++LPROC_SEQ_FOPS_RO(lprocfs_ns_resources);
+
+-static int lprocfs_rd_ns_locks(char *page, char **start, off_t off,
+- int count, int *eof, void *data)
++static int lprocfs_ns_locks_seq_show(struct seq_file *m, void *v)
+ {
+- struct ldlm_namespace *ns = data;
+- __u64 locks;
++ struct ldlm_namespace *ns = m->private;
++ __u64 locks;
+
+- locks = lprocfs_stats_collector(ns->ns_stats, LDLM_NSS_LOCKS,
+- LPROCFS_FIELDS_FLAGS_SUM);
+- return lprocfs_rd_u64(page, start, off, count, eof, &locks);
++ locks = lprocfs_stats_collector(ns->ns_stats, LDLM_NSS_LOCKS,
++ LPROCFS_FIELDS_FLAGS_SUM);
++ return lprocfs_u64_seq_show(m, &locks);
+ }
++LPROC_SEQ_FOPS_RO(lprocfs_ns_locks);
+
+-static int lprocfs_rd_lru_size(char *page, char **start, off_t off,
+- int count, int *eof, void *data)
++static int lprocfs_lru_size_seq_show(struct seq_file *m, void *v)
+ {
+- struct ldlm_namespace *ns = data;
+- __u32 *nr = &ns->ns_max_unused;
++ struct ldlm_namespace *ns = m->private;
++ __u32 *nr = &ns->ns_max_unused;
+
+- if (ns_connect_lru_resize(ns))
+- nr = &ns->ns_nr_unused;
+- return lprocfs_rd_uint(page, start, off, count, eof, nr);
++ if (ns_connect_lru_resize(ns))
++ nr = &ns->ns_nr_unused;
++ return lprocfs_uint_seq_show(m, nr);
+ }
+
+-static int lprocfs_wr_lru_size(struct file *file, const char *buffer,
+- unsigned long count, void *data)
++static ssize_t lprocfs_lru_size_seq_write(struct file *file, const char *buffer,
++ size_t count, loff_t *off)
+ {
+- struct ldlm_namespace *ns = data;
++ struct ldlm_namespace *ns = ((struct seq_file *)file->private_data)->private;
+ char dummy[MAX_STRING_SIZE + 1], *end;
+ unsigned long tmp;
+ int lru_resize;
+@@ -280,20 +286,20 @@ static int lprocfs_wr_lru_size(struct file *file, const char *buffer,
+
+ return count;
+ }
++LPROC_SEQ_FOPS(lprocfs_lru_size);
+
+-static int lprocfs_rd_elc(char *page, char **start, off_t off,
+- int count, int *eof, void *data)
++static int lprocfs_elc_seq_show(struct seq_file *m, void *v)
+ {
+- struct ldlm_namespace *ns = data;
++ struct ldlm_namespace *ns = m->private;
+ unsigned int supp = ns_connect_cancelset(ns);
+
+- return lprocfs_rd_uint(page, start, off, count, eof, &supp);
++ return lprocfs_uint_seq_show(m, &supp);
+ }
+
+-static int lprocfs_wr_elc(struct file *file, const char *buffer,
+- unsigned long count, void *data)
++static ssize_t lprocfs_elc_seq_write(struct file *file, const char *buffer,
++ size_t count, loff_t *off)
+ {
+- struct ldlm_namespace *ns = data;
++ struct ldlm_namespace *ns = ((struct seq_file *)file->private_data)->private;
+ unsigned int supp = -1;
+ int rc;
+
+@@ -307,31 +313,38 @@ static int lprocfs_wr_elc(struct file *file, const char *buffer,
+ ns->ns_connect_flags |= OBD_CONNECT_CANCELSET;
+ return count;
+ }
++LPROC_SEQ_FOPS(lprocfs_elc);
+
+ void ldlm_namespace_proc_unregister(struct ldlm_namespace *ns)
+ {
+- struct proc_dir_entry *dir;
+-
+- dir = lprocfs_srch(ldlm_ns_proc_dir, ldlm_ns_name(ns));
+- if (dir == NULL) {
++ if (ns->ns_proc_dir_entry == NULL)
+ CERROR("dlm namespace %s has no procfs dir?\n",
+ ldlm_ns_name(ns));
+- } else {
+- lprocfs_remove(&dir);
+- }
++ else
++ lprocfs_remove(&ns->ns_proc_dir_entry);
+
+- if (ns->ns_stats != NULL)
+- lprocfs_free_stats(&ns->ns_stats);
++ if (ns->ns_stats != NULL)
++ lprocfs_free_stats(&ns->ns_stats);
+ }
+
+ int ldlm_namespace_proc_register(struct ldlm_namespace *ns)
+ {
+- struct lprocfs_vars lock_vars[2];
++ struct lprocfs_seq_vars lock_vars[2];
+ char lock_name[MAX_STRING_SIZE + 1];
++ struct proc_dir_entry *ns_pde;
+
+ LASSERT(ns != NULL);
+ LASSERT(ns->ns_rs_hash != NULL);
+
++ if (ns->ns_proc_dir_entry != NULL) {
++ ns_pde = ns->ns_proc_dir_entry;
++ } else {
++ ns_pde = proc_mkdir(ldlm_ns_name(ns), ldlm_ns_proc_dir);
++ if (ns_pde == NULL)
++ return -ENOMEM;
++ ns->ns_proc_dir_entry = ns_pde;
++ }
++
+ ns->ns_stats = lprocfs_alloc_stats(LDLM_NSS_LAST, 0);
+ if (ns->ns_stats == NULL)
+ return -ENOMEM;
+@@ -344,88 +357,35 @@ int ldlm_namespace_proc_register(struct ldlm_namespace *ns)
+ memset(lock_vars, 0, sizeof(lock_vars));
+ lock_vars[0].name = lock_name;
+
+- snprintf(lock_name, MAX_STRING_SIZE, "%s/resource_count",
+- ldlm_ns_name(ns));
+- lock_vars[0].data = ns;
+- lock_vars[0].read_fptr = lprocfs_rd_ns_resources;
+- lprocfs_add_vars(ldlm_ns_proc_dir, lock_vars, 0);
+-
+- snprintf(lock_name, MAX_STRING_SIZE, "%s/lock_count",
+- ldlm_ns_name(ns));
+- lock_vars[0].data = ns;
+- lock_vars[0].read_fptr = lprocfs_rd_ns_locks;
+- lprocfs_add_vars(ldlm_ns_proc_dir, lock_vars, 0);
+-
+- if (ns_is_client(ns)) {
+- snprintf(lock_name, MAX_STRING_SIZE, "%s/lock_unused_count",
+- ldlm_ns_name(ns));
+- lock_vars[0].data = &ns->ns_nr_unused;
+- lock_vars[0].read_fptr = lprocfs_rd_uint;
+- lprocfs_add_vars(ldlm_ns_proc_dir, lock_vars, 0);
+-
+- snprintf(lock_name, MAX_STRING_SIZE, "%s/lru_size",
+- ldlm_ns_name(ns));
+- lock_vars[0].data = ns;
+- lock_vars[0].read_fptr = lprocfs_rd_lru_size;
+- lock_vars[0].write_fptr = lprocfs_wr_lru_size;
+- lprocfs_add_vars(ldlm_ns_proc_dir, lock_vars, 0);
+-
+- snprintf(lock_name, MAX_STRING_SIZE, "%s/lru_max_age",
+- ldlm_ns_name(ns));
+- lock_vars[0].data = &ns->ns_max_age;
+- lock_vars[0].read_fptr = lprocfs_rd_uint;
+- lock_vars[0].write_fptr = lprocfs_wr_uint;
+- lprocfs_add_vars(ldlm_ns_proc_dir, lock_vars, 0);
+-
+- snprintf(lock_name, MAX_STRING_SIZE, "%s/early_lock_cancel",
+- ldlm_ns_name(ns));
+- lock_vars[0].data = ns;
+- lock_vars[0].read_fptr = lprocfs_rd_elc;
+- lock_vars[0].write_fptr = lprocfs_wr_elc;
+- lprocfs_add_vars(ldlm_ns_proc_dir, lock_vars, 0);
+- } else {
+- snprintf(lock_name, MAX_STRING_SIZE, "%s/ctime_age_limit",
+- ldlm_ns_name(ns));
+- lock_vars[0].data = &ns->ns_ctime_age_limit;
+- lock_vars[0].read_fptr = lprocfs_rd_uint;
+- lock_vars[0].write_fptr = lprocfs_wr_uint;
+- lprocfs_add_vars(ldlm_ns_proc_dir, lock_vars, 0);
+-
+- snprintf(lock_name, MAX_STRING_SIZE, "%s/lock_timeouts",
+- ldlm_ns_name(ns));
+- lock_vars[0].data = &ns->ns_timeouts;
+- lock_vars[0].read_fptr = lprocfs_rd_uint;
+- lprocfs_add_vars(ldlm_ns_proc_dir, lock_vars, 0);
+-
+- snprintf(lock_name, MAX_STRING_SIZE, "%s/max_nolock_bytes",
+- ldlm_ns_name(ns));
+- lock_vars[0].data = &ns->ns_max_nolock_size;
+- lock_vars[0].read_fptr = lprocfs_rd_uint;
+- lock_vars[0].write_fptr = lprocfs_wr_uint;
+- lprocfs_add_vars(ldlm_ns_proc_dir, lock_vars, 0);
+-
+- snprintf(lock_name, MAX_STRING_SIZE, "%s/contention_seconds",
+- ldlm_ns_name(ns));
+- lock_vars[0].data = &ns->ns_contention_time;
+- lock_vars[0].read_fptr = lprocfs_rd_uint;
+- lock_vars[0].write_fptr = lprocfs_wr_uint;
+- lprocfs_add_vars(ldlm_ns_proc_dir, lock_vars, 0);
+-
+- snprintf(lock_name, MAX_STRING_SIZE, "%s/contended_locks",
+- ldlm_ns_name(ns));
+- lock_vars[0].data = &ns->ns_contended_locks;
+- lock_vars[0].read_fptr = lprocfs_rd_uint;
+- lock_vars[0].write_fptr = lprocfs_wr_uint;
+- lprocfs_add_vars(ldlm_ns_proc_dir, lock_vars, 0);
+-
+- snprintf(lock_name, MAX_STRING_SIZE, "%s/max_parallel_ast",
+- ldlm_ns_name(ns));
+- lock_vars[0].data = &ns->ns_max_parallel_ast;
+- lock_vars[0].read_fptr = lprocfs_rd_uint;
+- lock_vars[0].write_fptr = lprocfs_wr_uint;
+- lprocfs_add_vars(ldlm_ns_proc_dir, lock_vars, 0);
+- }
+- return 0;
++ ldlm_add_var(&lock_vars[0], ns_pde, "resource_count", ns,
++ &lprocfs_ns_resources_fops);
++ ldlm_add_var(&lock_vars[0], ns_pde, "lock_count", ns,
++ &lprocfs_ns_locks_fops);
++
++ if (ns_is_client(ns)) {
++ ldlm_add_var(&lock_vars[0], ns_pde, "lock_unused_count",
++ &ns->ns_nr_unused, &ldlm_uint_fops);
++ ldlm_add_var(&lock_vars[0], ns_pde, "lru_size", ns,
++ &lprocfs_lru_size_fops);
++ ldlm_add_var(&lock_vars[0], ns_pde, "lru_max_age",
++ &ns->ns_max_age, &ldlm_rw_uint_fops);
++ ldlm_add_var(&lock_vars[0], ns_pde, "early_lock_cancel",
++ ns, &lprocfs_elc_fops);
++ } else {
++ ldlm_add_var(&lock_vars[0], ns_pde, "ctime_age_limit",
++ &ns->ns_ctime_age_limit, &ldlm_rw_uint_fops);
++ ldlm_add_var(&lock_vars[0], ns_pde, "lock_timeouts",
++ &ns->ns_timeouts, &ldlm_uint_fops);
++ ldlm_add_var(&lock_vars[0], ns_pde, "max_nolock_bytes",
++ &ns->ns_max_nolock_size, &ldlm_rw_uint_fops);
++ ldlm_add_var(&lock_vars[0], ns_pde, "contention_seconds",
++ &ns->ns_contention_time, &ldlm_rw_uint_fops);
++ ldlm_add_var(&lock_vars[0], ns_pde, "contended_locks",
++ &ns->ns_contended_locks, &ldlm_rw_uint_fops);
++ ldlm_add_var(&lock_vars[0], ns_pde, "max_parallel_ast",
++ &ns->ns_max_parallel_ast, &ldlm_rw_uint_fops);
++ }
++ return 0;
+ }
+ #undef MAX_STRING_SIZE
+ #else /* LPROCFS */
+--
+1.8.5.1
+
diff --git a/sys-cluster/lustre/files/0009-LU-3319-procfs-move-ost-proc-handling-over-to-seq_fi.patch b/sys-cluster/lustre/files/0009-LU-3319-procfs-move-ost-proc-handling-over-to-seq_fi.patch
new file mode 100644
index 0000000..0f01c97
--- /dev/null
+++ b/sys-cluster/lustre/files/0009-LU-3319-procfs-move-ost-proc-handling-over-to-seq_fi.patch
@@ -0,0 +1,174 @@
+From 917c26236db7d3684733f693ccc579c3dd41f26c Mon Sep 17 00:00:00 2001
+From: James Simmons <uja.ornl@gmail.com>
+Date: Thu, 14 Nov 2013 09:48:08 -0500
+Subject: [PATCH 09/10] LU-3319 procfs: move ost proc handling over to seq_file
+
+Most of the current proc handling of the OST is already
+based on seq_file handling except for the reporting of
+the UUID of the OST. This patch moves this last piece
+so that the OST layer will use strictly proc files with
+seq_files.
+
+Signed-off-by: James Simmons <uja.ornl@gmail.com>
+Change-Id: Idf2bc014ada9292d545f761aa27c777412a66671
+---
+ lustre/ost/Makefile.in | 2 +-
+ lustre/ost/lproc_ost.c | 58 -----------------------------------------------
+ lustre/ost/ost_handler.c | 21 +++++++++++------
+ lustre/ost/ost_internal.h | 9 --------
+ 4 files changed, 15 insertions(+), 75 deletions(-)
+ delete mode 100644 lustre/ost/lproc_ost.c
+
+diff --git a/lustre/ost/Makefile.in b/lustre/ost/Makefile.in
+index 6bd8be3..bae023e 100644
+--- a/lustre/ost/Makefile.in
++++ b/lustre/ost/Makefile.in
+@@ -1,5 +1,5 @@
+ MODULES := ost
+-ost-objs := ost_handler.o lproc_ost.o
++ost-objs := ost_handler.o
+
+ EXTRA_DIST = $(ost-objs:%.o=%.c) ost_internal.h
+
+diff --git a/lustre/ost/lproc_ost.c b/lustre/ost/lproc_ost.c
+deleted file mode 100644
+index a978c51..0000000
+--- a/lustre/ost/lproc_ost.c
++++ /dev/null
+@@ -1,58 +0,0 @@
+-/*
+- * GPL HEADER START
+- *
+- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+- *
+- * This program is free software; you can redistribute it and/or modify
+- * it under the terms of the GNU General Public License version 2 only,
+- * as published by the Free Software Foundation.
+- *
+- * This program is distributed in the hope that it will be useful, but
+- * WITHOUT ANY WARRANTY; without even the implied warranty of
+- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+- * General Public License version 2 for more details (a copy is included
+- * in the LICENSE file that accompanied this code).
+- *
+- * You should have received a copy of the GNU General Public License
+- * version 2 along with this program; If not, see
+- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
+- *
+- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+- * CA 95054 USA or visit www.sun.com if you need additional information or
+- * have any questions.
+- *
+- * GPL HEADER END
+- */
+-/*
+- * Copyright (c) 2002, 2010, Oracle and/or its affiliates. All rights reserved.
+- * Use is subject to license terms.
+- */
+-/*
+- * This file is part of Lustre, http://www.lustre.org/
+- * Lustre is a trademark of Sun Microsystems, Inc.
+- */
+-#define DEBUG_SUBSYSTEM S_OST
+-
+-#include <obd_class.h>
+-#include <lprocfs_status.h>
+-#include <linux/seq_file.h>
+-#include "ost_internal.h"
+-
+-#ifdef LPROCFS
+-static struct lprocfs_vars lprocfs_ost_obd_vars[] = {
+- { "uuid", lprocfs_rd_uuid, 0, 0 },
+- { 0 }
+-};
+-
+-static struct lprocfs_vars lprocfs_ost_module_vars[] = {
+- { "num_refs", lprocfs_rd_numrefs, 0, 0 },
+- { 0 }
+-};
+-
+-void lprocfs_ost_init_vars(struct lprocfs_static_vars *lvars)
+-{
+- lvars->module_vars = lprocfs_ost_module_vars;
+- lvars->obd_vars = lprocfs_ost_obd_vars;
+-}
+-
+-#endif /* LPROCFS */
+diff --git a/lustre/ost/ost_handler.c b/lustre/ost/ost_handler.c
+index 662a489..7567acf 100644
+--- a/lustre/ost/ost_handler.c
++++ b/lustre/ost/ost_handler.c
+@@ -538,12 +538,20 @@ static int ost_io_hpreq_handler(struct ptlrpc_request *req)
+
+ static struct cfs_cpt_table *ost_io_cptable;
+
++#ifdef LPROCFS
++LPROC_SEQ_FOPS_RO_TYPE(ost, uuid);
++
++static struct lprocfs_seq_vars lprocfs_ost_obd_vars[] = {
++ { "uuid", &ost_uuid_fops },
++ { 0 }
++};
++#endif /* LPROCFS */
++
+ /* Sigh - really, this is an OSS, the _server_, not the _target_ */
+ static int ost_setup(struct obd_device *obd, struct lustre_cfg* lcfg)
+ {
+ static struct ptlrpc_service_conf svc_conf;
+ struct ost_obd *ost = &obd->u.ost;
+- struct lprocfs_static_vars lvars;
+ nodemask_t *mask;
+ int rc;
+ ENTRY;
+@@ -552,9 +560,10 @@ static int ost_setup(struct obd_device *obd, struct lustre_cfg* lcfg)
+ if (rc)
+ RETURN(rc);
+
+- lprocfs_ost_init_vars(&lvars);
+- lprocfs_obd_setup(obd, lvars.obd_vars);
+-
++#ifdef LPROCFS
++ obd->obd_vars = lprocfs_ost_obd_vars;
++ lprocfs_seq_obd_setup(obd);
++#endif
+ mutex_init(&ost->ost_health_mutex);
+
+ svc_conf = (typeof(svc_conf)) {
+@@ -877,15 +886,13 @@ static struct obd_ops ost_obd_ops = {
+
+ static int __init ost_init(void)
+ {
+- struct lprocfs_static_vars lvars;
+ int rc;
+
+ ENTRY;
+
+- lprocfs_ost_init_vars(&lvars);
+ rc = class_register_type(&ost_obd_ops, NULL, NULL,
+ #ifndef HAVE_ONLY_PROCFS_SEQ
+- lvars.module_vars,
++ NULL,
+ #endif
+ LUSTRE_OSS_NAME, NULL);
+
+diff --git a/lustre/ost/ost_internal.h b/lustre/ost/ost_internal.h
+index 8b475a1..63c8415 100644
+--- a/lustre/ost/ost_internal.h
++++ b/lustre/ost/ost_internal.h
+@@ -39,13 +39,4 @@
+
+ #define OSS_SERVICE_WATCHDOG_FACTOR 2
+
+-#ifdef LPROCFS
+-void lprocfs_ost_init_vars(struct lprocfs_static_vars *lvars);
+-#else
+-static void lprocfs_ost_init_vars(struct lprocfs_static_vars *lvars)
+-{
+- memset(lvars, 0, sizeof(*lvars));
+-}
+-#endif
+-
+ #endif /* OST_INTERNAL_H */
+--
+1.8.5.1
+
diff --git a/sys-cluster/lustre/lustre-9999.ebuild b/sys-cluster/lustre/lustre-9999.ebuild
index e19d1d4..610c755 100644
--- a/sys-cluster/lustre/lustre-9999.ebuild
+++ b/sys-cluster/lustre/lustre-9999.ebuild
@@ -39,6 +39,9 @@ PATCHES=(
"${FILESDIR}/0004-LU-3974-llite-use-new-struct-dir_context.patch"
"${FILESDIR}/0005-LU-3974-llite-invalidatepage-api-changed.patch"
"${FILESDIR}/0006-LU-3319-procfs-move-llite-proc-handling-over-to-seq_.patch"
+ "${FILESDIR}/0007-LU-3319-procfs-move-lmv-proc-handling-over-to-seq_fi.patch"
+ "${FILESDIR}/0008-LU-3319-procfs-move-ldlm-proc-handling-over-to-seq_f.patch"
+ "${FILESDIR}/0009-LU-3319-procfs-move-ost-proc-handling-over-to-seq_fi.patch"
)
pkg_setup() {
next reply other threads:[~2013-12-19 13:29 UTC|newest]
Thread overview: 53+ messages / expand[flat|nested] mbox.gz Atom feed top
2013-12-19 13:29 Alexey Shvetsov [this message]
-- strict thread matches above, loose matches on Subject: below --
2016-06-29 10:28 [gentoo-commits] proj/sci:master commit in: sys-cluster/lustre/, sys-cluster/lustre/files/ Alexey Shvetsov
2016-06-12 20:32 Alexey Shvetsov
2016-06-12 19:19 Alexey Shvetsov
2016-06-10 19:06 Alexey Shvetsov
2014-05-29 12:44 Alexey Shvetsov
2014-05-24 22:55 Alexey Shvetsov
2014-05-20 13:44 Alexey Shvetsov
2014-05-20 12:43 Alexey Shvetsov
2014-05-19 9:06 Alexey Shvetsov
2014-04-22 8:41 Alexey Shvetsov
2014-04-22 7:22 Alexey Shvetsov
2014-04-02 12:29 Alexey Shvetsov
2014-04-02 10:50 Alexey Shvetsov
2014-02-27 12:08 Alexey Shvetsov
2014-02-12 6:56 Alexey Shvetsov
2014-02-12 6:39 Alexey Shvetsov
2014-02-12 6:36 Alexey Shvetsov
2014-02-04 11:28 Alexey Shvetsov
2013-12-19 14:21 Alexey Shvetsov
2013-12-19 14:13 Alexey Shvetsov
2013-12-19 13:45 Alexey Shvetsov
2013-12-19 13:23 Alexey Shvetsov
2013-12-19 12:54 Alexey Shvetsov
2013-07-11 15:36 Justin Lecher
2013-07-11 13:25 Alexey Shvetsov
2013-05-07 18:45 Alexey Shvetsov
2013-05-07 9:20 Alexey Shvetsov
2013-04-23 7:43 Alexey Shvetsov
2013-04-22 9:25 Alexey Shvetsov
2013-04-17 9:59 Alexey Shvetsov
2013-04-17 9:45 Alexey Shvetsov
2013-04-16 12:08 Alexey Shvetsov
2013-04-16 11:27 Alexey Shvetsov
2013-03-31 17:20 Alexey Shvetsov
2013-03-31 11:28 Alexey Shvetsov
2013-03-31 11:15 Alexey Shvetsov
2013-03-27 5:05 Alexey Shvetsov
2013-03-22 11:08 Alexey Shvetsov
2013-03-22 10:27 Alexey Shvetsov
2013-03-18 23:14 Alexey Shvetsov
2013-03-18 20:53 Alexey Shvetsov
2013-03-18 14:10 Alexey Shvetsov
2013-03-18 14:00 Alexey Shvetsov
2013-03-18 12:29 Alexey Shvetsov
2013-03-18 12:21 Alexey Shvetsov
2013-03-18 12:13 Alexey Shvetsov
2013-03-18 3:53 Alexey Shvetsov
2013-03-14 11:57 Alexey Shvetsov
2013-03-14 10:21 Alexey Shvetsov
2013-03-14 9:47 Alexey Shvetsov
2013-03-06 12:37 Alexey Shvetsov
2012-09-20 19:15 Alexey Shvetsov
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=1387459759.e4356da29fa5d3f53d2c49e1b44a83ec740e93ee.alexxy@gentoo \
--to=alexxy@gentoo.org \
--cc=gentoo-commits@lists.gentoo.org \
--cc=gentoo-dev@lists.gentoo.org \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox