From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from lists.gentoo.org (pigeon.gentoo.org [208.92.234.80]) by finch.gentoo.org (Postfix) with ESMTP id D43CB138247 for ; Thu, 19 Dec 2013 13:29:40 +0000 (UTC) Received: from pigeon.gentoo.org (localhost [127.0.0.1]) by pigeon.gentoo.org (Postfix) with SMTP id A5854E0B3D; Thu, 19 Dec 2013 13:29:39 +0000 (UTC) Received: from smtp.gentoo.org (smtp.gentoo.org [140.211.166.183]) (using TLSv1 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by pigeon.gentoo.org (Postfix) with ESMTPS id 20D25E0B3D for ; Thu, 19 Dec 2013 13:29:39 +0000 (UTC) Received: from hornbill.gentoo.org (hornbill.gentoo.org [94.100.119.163]) (using TLSv1 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by smtp.gentoo.org (Postfix) with ESMTPS id EE49E33F1E7 for ; Thu, 19 Dec 2013 13:29:37 +0000 (UTC) Received: from localhost.localdomain (localhost [127.0.0.1]) by hornbill.gentoo.org (Postfix) with ESMTP id 978BB1102ED for ; Thu, 19 Dec 2013 13:29:36 +0000 (UTC) From: "Alexey Shvetsov" To: gentoo-commits@lists.gentoo.org Content-Transfer-Encoding: 8bit Content-type: text/plain; charset=UTF-8 Reply-To: gentoo-dev@lists.gentoo.org, "Alexey Shvetsov" Message-ID: <1387459759.e4356da29fa5d3f53d2c49e1b44a83ec740e93ee.alexxy@gentoo> Subject: [gentoo-commits] proj/sci:master commit in: sys-cluster/lustre/, sys-cluster/lustre/files/ X-VCS-Repository: proj/sci X-VCS-Files: sys-cluster/lustre/ChangeLog sys-cluster/lustre/files/0001-LU-2982-build-make-AC-check-for-linux-arch-sandbox-f.patch sys-cluster/lustre/files/0002-LU-3373-ldiskfs-ldiskfs-patches-for-3.11.1-fc19.patch sys-cluster/lustre/files/0003-LU-3974-llite-dentry-d_compare-changes-in-3.11.patch sys-cluster/lustre/files/0004-LU-3974-llite-use-new-struct-dir_context.patch sys-cluster/lustre/files/0005-LU-3974-llite-invalidatepage-api-changed.patch sys-cluster/lustre/files/0006-LU-3319-procfs-move-llite-proc-handling-over-to-seq_.patch sys-cluster/lustre/files/0007-LU-3319-procfs-move-lmv-proc-handling-over-to-seq_fi.patch sys-cluster/lustre/files/0008-LU-3319-procfs-move-ldlm-proc-handling-over-to-seq_f.patch sys-cluster/lustre/files/0009-LU-3319-procfs-move-ost-proc-handling-over-to-seq_fi.patch sys-cluster/lustre/lustre-9999.ebuild X-VCS-Directories: sys-cluster/lustre/ sys-cluster/lustre/files/ X-VCS-Committer: alexxy X-VCS-Committer-Name: Alexey Shvetsov X-VCS-Revision: e4356da29fa5d3f53d2c49e1b44a83ec740e93ee X-VCS-Branch: master Date: Thu, 19 Dec 2013 13:29:36 +0000 (UTC) Precedence: bulk List-Post: List-Help: List-Unsubscribe: List-Subscribe: List-Id: Gentoo Linux mail X-BeenThere: gentoo-commits@lists.gentoo.org X-Archives-Salt: 4657c8d4-8783-4ea6-9281-78559489acc9 X-Archives-Hash: f85beb0b295895c0132edb2d82f538b5 commit: e4356da29fa5d3f53d2c49e1b44a83ec740e93ee Author: Alexey Shvetsov gentoo org> AuthorDate: Thu Dec 19 13:29:19 2013 +0000 Commit: Alexey Shvetsov gentoo 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 + +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 +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 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 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 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 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 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 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 +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 +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 +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 +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 +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 +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 +-#include +-#include +-#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() {