diff options
Diffstat (limited to 'sys-cluster/lustre/files')
14 files changed, 2000 insertions, 1927 deletions
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 deleted file mode 100644 index 63fcb0af9..000000000 --- a/sys-cluster/lustre/files/0001-LU-2982-build-make-AC-check-for-linux-arch-sandbox-f.patch +++ /dev/null @@ -1,95 +0,0 @@ -From f384f155612fb8b3fa6a12c4c969e29629f82027 Mon Sep 17 00:00:00 2001 -From: Alexey Shvetsov <alexxy@gentoo.org> -Date: Mon, 18 Mar 2013 16:22:27 +0400 -Subject: [PATCH 01/12] LU-2982 build: make AC check for linux arch sandbox - friendly - -this commit makes AC check for linux kernel arch sandbox friendly - -Signed-off-by: Alexey Shvetsov <alexxy@gentoo.org> -Change-Id: I173cd892bca5587519806cf6d300a5053dfb935f -Signed-off-by: Alexey Shvetsov <alexxy@gentoo.org> ---- - config/lustre-build-linux.m4 | 66 ++++++++++++++++++++++++++++++++++++++------ - 1 file changed, 58 insertions(+), 8 deletions(-) - -diff --git a/config/lustre-build-linux.m4 b/config/lustre-build-linux.m4 -index 894101c..8062ace 100644 ---- a/config/lustre-build-linux.m4 -+++ b/config/lustre-build-linux.m4 -@@ -394,14 +394,64 @@ rm -f build/conftest.o build/conftest.mod.c build/conftest.mod.o build/conftest. - # Determine the kernel's idea of the current architecture - # - AC_DEFUN([LB_LINUX_ARCH], -- [AC_MSG_CHECKING([Linux kernel architecture]) -- AS_IF([rm -f $PWD/build/arch -- make -s --no-print-directory echoarch -f $PWD/build/Makefile \ -- LUSTRE_LINUX_CONFIG=$LINUX_CONFIG -C $LINUX $CROSS_VARS \ -- ARCHFILE=$PWD/build/arch && LINUX_ARCH=`cat $PWD/build/arch`], -- [AC_MSG_RESULT([$LINUX_ARCH])], -- [AC_MSG_ERROR([Could not determine the kernel architecture.])]) -- rm -f build/arch]) -+[LINUXARCH= -+rm -f build/conftest.i -+AC_MSG_CHECKING([Linux kernel architecture]) -+if test -s $LINUX_OBJ/include/$AUTOCONF_HDIR/compile.h ; then -+ LINUXARCHHEADER=$AUTOCONF_HDIR/compile.h -+else -+ LINUXARCHHEADER=linux/autoconf.h -+fi -+LB_LINUX_TRY_MAKE([ -+#include <$LINUXARCHHEADER> -+ -+#ifndef UTS_MACHINE -+ -+ #ifdef CONFIG_X86 -+ #ifdef CONFIG_X86_32 -+ #define UTS_MACHINE i386 -+ #endif -+ #ifdef CONFIG_X86_64 -+ #define UTS_MACHINE x86_64 -+ #endif -+ #endif -+ -+ #ifdef CONFIG_IA64 -+ #define UTS_MACHINE ia64 -+ #endif -+ -+ #ifdef CONFIG_PPC -+ #ifdef CONFIG_PPC32 -+ #define UTS_MACHINE ppc -+ #endif -+ #ifdef CONFIG_PPC64 -+ #define UTS_MACHINE ppc64 -+ #endif -+ #endif -+ -+#endif -+],[ -+ char *LINUXARCH; -+ LINUXARCH=UTS_MACHINE; -+],[ -+ $makerule LUSTRE_KERNEL_TEST=conftest.i -+],[ -+ test -s build/conftest.i -+],[ -+ # LINUXARCH="UTS_MACHINE" -+ eval $(grep "LINUXARCH=" build/conftest.i) -+],[ -+ AC_MSG_RESULT([unknown]) -+ AC_MSG_ERROR([Could not preprocess test program. Consult config.log for details.]) -+]) -+ rm -f build/conftest.i -+ if test x$LINUXARCH = x ; then -+ AC_MSG_RESULT([unknown]) -+ AC_MSG_ERROR([Could not determine Linux architecture from linux/version.h.]) -+ fi -+AC_MSG_RESULT([$LINUXARCH]) -+AC_SUBST(LINUXARCH) -+]) - - # - # LB_LINUX_TRY_COMPILE --- -1.8.5.3 - diff --git a/sys-cluster/lustre/files/0001-LU-3319-procfs-fix-symlink-handling.patch b/sys-cluster/lustre/files/0001-LU-3319-procfs-fix-symlink-handling.patch new file mode 100644 index 000000000..d0b6e9c2e --- /dev/null +++ b/sys-cluster/lustre/files/0001-LU-3319-procfs-fix-symlink-handling.patch @@ -0,0 +1,1132 @@ +From 4c418e7208a62c7bb7d61c1f97cf300675215bd4 Mon Sep 17 00:00:00 2001 +From: James Simmons <uja.ornl@gmail.com> +Date: Fri, 28 Mar 2014 11:19:07 -0400 +Subject: [PATCH 1/9] LU-3319 procfs: fix symlink handling + +While working on symlink handling for seq files I noticed a +long outstanding bug. Code was developed to link osc obds +to target_obds of the lov layer. The target_obds directory +was never created for the symlinks. This patch enables this +long forgotten feature. Also addressed is the race condition +experinced with server side code ported to seq_files that +used symlinks. To avoid the race the handle obd_proc_private +was moved from struct obd_device to struct obd_type which +now allows earlier registeration that only happens once. +The second problem addressed is the module loading race. +Several modules share the same top proc directory entry which +can become a issue if a client exist on a server node since +the linux proc system allows multiple directories of the same +name. Original Lustre had a lprocfs_srch but that doesn't +work if you use the kernels internal cache for the proc +system so you need to keep track of who grabs the proc root +first and then use the first one registered for when the +next module loads. + +Change-Id: Ib158ec4444ed7abc0f3c3e820ee4a333631a58d1 +Signed-off-by: James Simmons <uja.ornl@gmail.com> +--- + lustre/include/lprocfs_status.h | 4 +- + lustre/include/obd.h | 17 +++-- + lustre/include/obd_class.h | 5 +- + lustre/lmv/lmv_obd.c | 65 +++++----------- + lustre/lod/lod_dev.c | 28 +++---- + lustre/lov/lov_obd.c | 156 ++++++++++++++++++++++++--------------- + lustre/mdc/mdc_request.c | 6 +- + lustre/mdd/mdd_device.c | 6 +- + lustre/mdt/mdt_handler.c | 6 +- + lustre/mdt/mdt_mds.c | 6 +- + lustre/mgc/libmgc.c | 6 +- + lustre/mgc/mgc_request.c | 6 +- + lustre/mgs/mgs_handler.c | 6 +- + lustre/obdclass/genops.c | 55 ++++++++------ + lustre/obdclass/llog_test.c | 6 +- + lustre/obdclass/lprocfs_status.c | 1 - + lustre/obdecho/echo_client.c | 10 +-- + lustre/ofd/ofd_dev.c | 6 +- + lustre/osc/osc_request.c | 49 +++++++++--- + lustre/osd-ldiskfs/osd_handler.c | 6 +- + lustre/osd-zfs/osd_handler.c | 6 +- + lustre/osp/osp_dev.c | 33 +++++---- + lustre/ost/ost_handler.c | 6 +- + lustre/quota/qmt_dev.c | 6 +- + 24 files changed, 277 insertions(+), 224 deletions(-) + +diff --git a/lustre/include/lprocfs_status.h b/lustre/include/lprocfs_status.h +index 978b10c..0d6fd4c 100644 +--- a/lustre/include/lprocfs_status.h ++++ b/lustre/include/lprocfs_status.h +@@ -1145,12 +1145,10 @@ static inline int lprocfs_seq_add_vars(cfs_proc_dir_entry_t *root, + struct lprocfs_seq_vars *var, + void *data) + { return 0; } +-#ifndef HAVE_ONLY_PROCFS_SEQ + static inline cfs_proc_dir_entry_t * + lprocfs_seq_register(const char *name, cfs_proc_dir_entry_t *parent, +- struct lprocfs_vars *list, void *data) ++ struct lprocfs_seq_vars *list, void *data) + { return NULL; } +-#endif + static inline void lprocfs_remove(cfs_proc_dir_entry_t **root) + { return; } + static inline void lprocfs_remove_proc_entry(const char *name, +diff --git a/lustre/include/obd.h b/lustre/include/obd.h +index bb67e43..5353524 100644 +--- a/lustre/include/obd.h ++++ b/lustre/include/obd.h +@@ -190,13 +190,15 @@ struct obd_info { + }; + + struct obd_type { +- cfs_list_t typ_chain; +- struct obd_ops *typ_dt_ops; +- struct md_ops *typ_md_ops; +- cfs_proc_dir_entry_t *typ_procroot; +- char *typ_name; +- int typ_refcnt; +- struct lu_device_type *typ_lu; ++ struct list_head typ_chain; ++ struct obd_ops *typ_dt_ops; ++ struct md_ops *typ_md_ops; ++ struct proc_dir_entry *typ_procroot; ++ struct proc_dir_entry *typ_procsym; ++ __u32 typ_sym_filter; ++ char *typ_name; ++ int typ_refcnt; ++ struct lu_device_type *typ_lu; + spinlock_t obd_type_lock; + }; + +@@ -834,7 +836,6 @@ struct obd_device { + + struct proc_dir_entry *obd_proc_entry; + struct proc_dir_entry *obd_proc_exports_entry; +- void *obd_proc_private; /* type private PDEs */ + struct proc_dir_entry *obd_svc_procroot; + struct lprocfs_stats *obd_svc_stats; + struct lprocfs_seq_vars *obd_vars; +diff --git a/lustre/include/obd_class.h b/lustre/include/obd_class.h +index aeb94ba..5de7cd7 100644 +--- a/lustre/include/obd_class.h ++++ b/lustre/include/obd_class.h +@@ -86,13 +86,12 @@ struct lu_device_type; + + /* genops.c */ + struct obd_export *class_conn2export(struct lustre_handle *); +-int class_register_type(struct obd_ops *, struct md_ops *, ++int class_register_type(struct obd_ops *, struct md_ops *, bool enable_proc, + struct lprocfs_seq_vars *module_vars, + #ifndef HAVE_ONLY_PROCFS_SEQ + struct lprocfs_vars *, + #endif +- const char *nm, +- struct lu_device_type *ldt); ++ const char *nm, struct lu_device_type *ldt); + int class_unregister_type(const char *nm); + + struct obd_device *class_newdev(const char *type_name, const char *name); +diff --git a/lustre/lmv/lmv_obd.c b/lustre/lmv/lmv_obd.c +index 8f26e6c..cd16eaf 100644 +--- a/lustre/lmv/lmv_obd.c ++++ b/lustre/lmv/lmv_obd.c +@@ -270,9 +270,6 @@ static int lmv_connect(const struct lu_env *env, + struct obd_uuid *cluuid, struct obd_connect_data *data, + void *localdata) + { +-#ifdef __KERNEL__ +- struct proc_dir_entry *lmv_proc_dir; +-#endif + struct lmv_obd *lmv = &obd->u.lmv; + struct lustre_handle conn = { 0 }; + int rc = 0; +@@ -304,21 +301,16 @@ static int lmv_connect(const struct lu_env *env, + if (data) + lmv->conn_data = *data; + +-#ifdef __KERNEL__ +- 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)) { ++ if (obd->obd_type->typ_procsym == NULL) { ++ obd->obd_type->typ_procsym = lprocfs_seq_register("target_obds", ++ obd->obd_proc_entry, ++ NULL, NULL); ++ if (IS_ERR(obd->obd_type->typ_procsym)) { + 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_type->typ_procsym = NULL; + } +- obd->obd_proc_private = lmv_proc_dir; + } +-#endif + + /* + * All real clients should perform actual connection right away, because +@@ -329,12 +321,8 @@ static int lmv_connect(const struct lu_env *env, + if (data != NULL && (data->ocd_connect_flags & OBD_CONNECT_REAL)) + rc = lmv_check_connect(obd); + +-#ifdef __KERNEL__ +- if (rc && lmv_proc_dir) { +- lprocfs_remove(&lmv_proc_dir); +- obd->obd_proc_private = NULL; +- } +-#endif ++ if (rc && obd->obd_type->typ_procsym != NULL) ++ lprocfs_remove(&obd->obd_type->typ_procsym); + RETURN(rc); + } + +@@ -416,9 +404,6 @@ static int lmv_init_ea_size(struct obd_export *exp, int easize, + + int lmv_connect_mdc(struct obd_device *obd, struct lmv_tgt_desc *tgt) + { +-#ifdef __KERNEL__ +- struct proc_dir_entry *lmv_proc_dir; +-#endif + struct lmv_obd *lmv = &obd->u.lmv; + struct obd_uuid *cluuid = &lmv->cluuid; + struct obd_uuid lmv_mdc_uuid = { "LMV_MDC_UUID" }; +@@ -497,15 +482,13 @@ int lmv_connect_mdc(struct obd_device *obd, struct lmv_tgt_desc *tgt) + mdc_obd->obd_name, mdc_obd->obd_uuid.uuid, + atomic_read(&obd->obd_refcount)); + +-#ifdef __KERNEL__ +- lmv_proc_dir = obd->obd_proc_private; +- if (lmv_proc_dir) { ++ if (obd->obd_type->typ_procsym != NULL) { + 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, ++ obd->obd_type->typ_procsym, + "../../../%s/%s", + mdc_obd->obd_type->typ_name, + mdc_obd->obd_name); +@@ -514,11 +497,9 @@ int lmv_connect_mdc(struct obd_device *obd, struct lmv_tgt_desc *tgt) + "/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; ++ lprocfs_remove(&obd->obd_type->typ_procsym); + } + } +-#endif + RETURN(0); + } + +@@ -706,9 +687,6 @@ int lmv_check_connect(struct obd_device *obd) + + static int lmv_disconnect_mdc(struct obd_device *obd, struct lmv_tgt_desc *tgt) + { +-#ifdef __KERNEL__ +- struct proc_dir_entry *lmv_proc_dir; +-#endif + struct lmv_obd *lmv = &obd->u.lmv; + struct obd_device *mdc_obd; + int rc; +@@ -725,11 +703,10 @@ static int lmv_disconnect_mdc(struct obd_device *obd, struct lmv_tgt_desc *tgt) + mdc_obd->obd_no_recov = obd->obd_no_recov; + } + +-#ifdef __KERNEL__ +- lmv_proc_dir = obd->obd_proc_private; +- if (lmv_proc_dir) +- lprocfs_remove_proc_entry(mdc_obd->obd_name, lmv_proc_dir); +-#endif ++ if (obd->obd_type->typ_procsym != NULL) ++ lprocfs_remove_proc_entry(mdc_obd->obd_name, ++ obd->obd_type->typ_procsym); ++ + rc = obd_fid_fini(tgt->ltd_exp->exp_obd); + if (rc) + CERROR("Can't finanize fids factory\n"); +@@ -777,13 +754,11 @@ static int lmv_disconnect(struct obd_export *exp) + lmv_disconnect_mdc(obd, lmv->tgts[i]); + } + +-#ifdef __KERNEL__ +- if (obd->obd_proc_private) +- lprocfs_remove((struct proc_dir_entry **)&obd->obd_proc_private); ++ if (obd->obd_type->typ_procsym != NULL) ++ lprocfs_remove(&obd->obd_type->typ_procsym); + else + CERROR("/proc/fs/lustre/%s/%s/target_obds missing\n", + obd->obd_type->typ_name, obd->obd_name); +-#endif + + out_local: + /* +@@ -3423,11 +3398,11 @@ struct md_ops lmv_md_ops = { + + int __init lmv_init(void) + { +- return class_register_type(&lmv_obd_ops, &lmv_md_ops, NULL, ++ return class_register_type(&lmv_obd_ops, &lmv_md_ops, true, NULL, + #ifndef HAVE_ONLY_PROCFS_SEQ +- NULL, ++ NULL, + #endif +- LUSTRE_LMV_NAME, NULL); ++ LUSTRE_LMV_NAME, NULL); + } + + #ifdef __KERNEL__ +diff --git a/lustre/lod/lod_dev.c b/lustre/lod/lod_dev.c +index 1d4849f..a653d6a 100644 +--- a/lustre/lod/lod_dev.c ++++ b/lustre/lod/lod_dev.c +@@ -892,8 +892,8 @@ static struct obd_ops lod_obd_device_ops = { + static int __init lod_mod_init(void) + { + struct lprocfs_static_vars lvars = { 0 }; +- cfs_proc_dir_entry_t *lov_proc_dir; +- int rc; ++ struct obd_type *type; ++ int rc; + + rc = lu_kmem_init(lod_caches); + if (rc) +@@ -901,32 +901,32 @@ static int __init lod_mod_init(void) + + lprocfs_lod_init_vars(&lvars); + +- rc = class_register_type(&lod_obd_device_ops, NULL, NULL, ++ rc = class_register_type(&lod_obd_device_ops, NULL, true, NULL, + #ifndef HAVE_ONLY_PROCFS_SEQ +- lvars.module_vars, ++ lvars.module_vars, + #endif +- LUSTRE_LOD_NAME, &lod_device_type); ++ LUSTRE_LOD_NAME, &lod_device_type); + if (rc) { + lu_kmem_fini(lod_caches); + return rc; + } + + /* create "lov" entry in procfs for compatibility purposes */ +- lov_proc_dir = lprocfs_srch(proc_lustre_root, "lov"); +- if (lov_proc_dir == NULL) { +- lov_proc_dir = lprocfs_register("lov", proc_lustre_root, +- NULL, NULL); +- if (IS_ERR(lov_proc_dir)) +- CERROR("lod: can't create compat entry \"lov\": %d\n", +- (int)PTR_ERR(lov_proc_dir)); +- } ++ type = class_search_type(LUSTRE_LOV_NAME); ++ if (type != NULL && type->typ_procroot != NULL) ++ return rc; + ++ type = class_search_type(LUSTRE_LOD_NAME); ++ type->typ_procsym = lprocfs_register("lov", proc_lustre_root, ++ NULL, NULL); ++ if (IS_ERR(type->typ_procsym)) ++ CERROR("lod: can't create compat entry \"lov\": %d\n", ++ (int)PTR_ERR(type->typ_procsym)); + return rc; + } + + static void __exit lod_mod_exit(void) + { +- + lprocfs_try_remove_proc_entry("lov", proc_lustre_root); + + class_unregister_type(LUSTRE_LOD_NAME); +diff --git a/lustre/lov/lov_obd.c b/lustre/lov/lov_obd.c +index 9d47ec5..78c11fb 100644 +--- a/lustre/lov/lov_obd.c ++++ b/lustre/lov/lov_obd.c +@@ -124,19 +124,16 @@ static int lov_notify(struct obd_device *obd, struct obd_device *watched, + int lov_connect_obd(struct obd_device *obd, __u32 index, int activate, + struct obd_connect_data *data) + { +- struct lov_obd *lov = &obd->u.lov; +- struct obd_uuid *tgt_uuid; +- struct obd_device *tgt_obd; +- static struct obd_uuid lov_osc_uuid = { "LOV_OSC_UUID" }; +- struct obd_import *imp; +-#ifdef __KERNEL__ +- struct proc_dir_entry *lov_proc_dir; +-#endif +- int rc; +- ENTRY; ++ struct lov_obd *lov = &obd->u.lov; ++ struct obd_uuid *tgt_uuid; ++ struct obd_device *tgt_obd; ++ static struct obd_uuid lov_osc_uuid = { "LOV_OSC_UUID" }; ++ struct obd_import *imp; ++ int rc; ++ ENTRY; + +- if (!lov->lov_tgts[index]) +- RETURN(-EINVAL); ++ if (lov->lov_tgts[index] == NULL) ++ RETURN(-EINVAL); + + tgt_uuid = &lov->lov_tgts[index]->ltd_uuid; + tgt_obd = lov->lov_tgts[index]->ltd_obd; +@@ -191,32 +188,29 @@ int lov_connect_obd(struct obd_device *obd, __u32 index, int activate, + CDEBUG(D_CONFIG, "Connected tgt idx %d %s (%s) %sactive\n", index, + obd_uuid2str(tgt_uuid), tgt_obd->obd_name, activate ? "":"in"); + +-#ifdef __KERNEL__ +- lov_proc_dir = obd->obd_proc_private; +- if (lov_proc_dir) { +- struct obd_device *osc_obd = lov->lov_tgts[index]->ltd_exp->exp_obd; ++ if (obd->obd_type->typ_procsym != NULL) { + struct proc_dir_entry *osc_symlink; +- +- LASSERT(osc_obd != NULL); +- LASSERT(osc_obd->obd_magic == OBD_DEVICE_MAGIC); +- LASSERT(osc_obd->obd_type->typ_name != NULL); +- +- osc_symlink = lprocfs_add_symlink(osc_obd->obd_name, +- lov_proc_dir, +- "../../../%s/%s", +- osc_obd->obd_type->typ_name, +- osc_obd->obd_name); +- if (osc_symlink == NULL) { +- CERROR("could not register LOV target " +- "/proc/fs/lustre/%s/%s/target_obds/%s.", +- obd->obd_type->typ_name, obd->obd_name, +- osc_obd->obd_name); +- lprocfs_remove(&lov_proc_dir); +- obd->obd_proc_private = NULL; ++ struct obd_device *osc_obd; ++ ++ osc_obd = lov->lov_tgts[index]->ltd_exp->exp_obd; ++ ++ LASSERT(osc_obd != NULL); ++ LASSERT(osc_obd->obd_magic == OBD_DEVICE_MAGIC); ++ LASSERT(osc_obd->obd_type->typ_name != NULL); ++ ++ osc_symlink = lprocfs_add_symlink(osc_obd->obd_name, ++ obd->obd_type->typ_procsym, ++ "../../../%s/%s", ++ osc_obd->obd_type->typ_name, ++ osc_obd->obd_name); ++ if (osc_symlink == NULL) { ++ CERROR("could not register LOV target " ++ "/proc/fs/lustre/%s/%s/target_obds/%s.", ++ obd->obd_type->typ_name, obd->obd_name, ++ osc_obd->obd_name); ++ lprocfs_remove(&obd->obd_type->typ_procsym); + } + } +-#endif +- + RETURN(0); + } + +@@ -247,6 +241,15 @@ static int lov_connect(const struct lu_env *env, + if (data) + lov->lov_ocd = *data; + ++ obd->obd_type->typ_procsym = lprocfs_seq_register("target_obds", ++ obd->obd_proc_entry, ++ NULL, NULL); ++ if (IS_ERR(obd->obd_type->typ_procsym)) { ++ CERROR("%s: could not register /proc/fs/lustre/%s/%s/target_obds.", ++ obd->obd_name, obd->obd_type->typ_name, obd->obd_name); ++ obd->obd_type->typ_procsym = NULL; ++ } ++ + obd_getref(obd); + for (i = 0; i < lov->desc.ld_tgt_count; i++) { + tgt = lov->lov_tgts[i]; +@@ -277,7 +280,6 @@ static int lov_connect(const struct lu_env *env, + + static int lov_disconnect_obd(struct obd_device *obd, struct lov_tgt_desc *tgt) + { +- struct proc_dir_entry *lov_proc_dir; + struct lov_obd *lov = &obd->u.lov; + struct obd_device *osc_obd; + int rc; +@@ -293,19 +295,19 @@ static int lov_disconnect_obd(struct obd_device *obd, struct lov_tgt_desc *tgt) + tgt->ltd_exp->exp_obd->obd_inactive = 1; + } + +- lov_proc_dir = obd->obd_proc_private; +- if (lov_proc_dir) +- lprocfs_remove_proc_entry(osc_obd->obd_name, lov_proc_dir); ++ if (osc_obd) { ++ /* Pass it on to our clients. ++ * XXX This should be an argument to disconnect, ++ * XXX not a back-door flag on the OBD. Ah well. ++ */ ++ osc_obd->obd_force = obd->obd_force; ++ osc_obd->obd_fail = obd->obd_fail; ++ osc_obd->obd_no_recov = obd->obd_no_recov; + +- if (osc_obd) { +- /* Pass it on to our clients. +- * XXX This should be an argument to disconnect, +- * XXX not a back-door flag on the OBD. Ah well. +- */ +- osc_obd->obd_force = obd->obd_force; +- osc_obd->obd_fail = obd->obd_fail; +- osc_obd->obd_no_recov = obd->obd_no_recov; +- } ++ if (obd->obd_type->typ_procsym) ++ lprocfs_remove_proc_entry(osc_obd->obd_name, ++ obd->obd_type->typ_procsym); ++ } + + obd_register_observer(osc_obd, NULL); + +@@ -350,6 +352,9 @@ static int lov_disconnect(struct obd_export *exp) + } + obd_putref(obd); + ++ if (obd->obd_type->typ_procsym) ++ lprocfs_remove(&obd->obd_type->typ_procsym); ++ + out: + rc = class_disconnect(exp); /* bz 9811 */ + RETURN(rc); +@@ -779,6 +784,9 @@ int lov_setup(struct obd_device *obd, struct lustre_cfg *lcfg) + { + struct lov_desc *desc; + struct lov_obd *lov = &obd->u.lov; ++#ifdef LPROCFS ++ struct obd_type *type; ++#endif + int rc; + ENTRY; + +@@ -834,15 +842,41 @@ int lov_setup(struct obd_device *obd, struct lustre_cfg *lcfg) + + #ifdef LPROCFS + obd->obd_vars = lprocfs_lov_obd_vars; +- lprocfs_seq_obd_setup(obd); +- rc = lprocfs_seq_create(obd->obd_proc_entry, "target_obd", 0444, +- &lov_proc_target_fops, obd); +- if (rc) +- CWARN("Error adding the target_obd file\n"); ++ /* If this is true then both client (lov) and server ++ * (lod) are on the same node. The lod layer if loaded ++ * first will register the lov proc directory. In that ++ * case obd->obd_type->typ_procroot will be not set. ++ * Instead we use type->typ_procsym as the parent. */ ++ type = class_search_type(LUSTRE_LOD_NAME); ++ if (type != NULL && type->typ_procsym != NULL) { ++ obd->obd_proc_entry = lprocfs_seq_register(obd->obd_name, ++ type->typ_procsym, ++ obd->obd_vars, obd); ++ if (IS_ERR(obd->obd_proc_entry)) { ++ rc = PTR_ERR(obd->obd_proc_entry); ++ CERROR("error %d setting up lprocfs for %s\n", rc, ++ obd->obd_name); ++ obd->obd_proc_entry = NULL; ++ } ++ } else { ++ rc = lprocfs_seq_obd_setup(obd); ++ } ++ ++ if (rc == 0) { ++ rc = lprocfs_seq_create(obd->obd_proc_entry, "target_obd", ++ 0444, &lov_proc_target_fops, obd); ++ if (rc) ++ CWARN("Error adding the target_obd file\n"); + +- lov->lov_pool_proc_entry = lprocfs_seq_register("pools", ++ lov->lov_pool_proc_entry = lprocfs_seq_register("pools", + obd->obd_proc_entry, + NULL, NULL); ++ if (IS_ERR(lov->lov_pool_proc_entry)) { ++ rc = PTR_ERR(lov->lov_pool_proc_entry); ++ CERROR("error %d setting up lprocfs for pools\n", rc); ++ lov->lov_pool_proc_entry = NULL; ++ } ++ } + #endif + RETURN(0); + +@@ -2365,8 +2399,10 @@ extern struct lu_kmem_descr lov_caches[]; + + int __init lov_init(void) + { ++ bool enable_proc = true; ++ struct obd_type *type; + int rc; +- ENTRY; ++ ENTRY; + + /* print an address of _any_ initialized kernel symbol from this + * module, to allow debugging with gdb that doesn't support data +@@ -2385,11 +2421,15 @@ int __init lov_init(void) + return -ENOMEM; + } + +- rc = class_register_type(&lov_obd_ops, NULL, NULL, ++ type = class_search_type(LUSTRE_LOD_NAME); ++ if (type != NULL && type->typ_procsym != NULL) ++ enable_proc = false; ++ ++ rc = class_register_type(&lov_obd_ops, NULL, enable_proc, NULL, + #ifndef HAVE_ONLY_PROCFS_SEQ +- NULL, ++ NULL, + #endif +- LUSTRE_LOV_NAME, &lov_device_type); ++ LUSTRE_LOV_NAME, &lov_device_type); + + if (rc) { + kmem_cache_destroy(lov_oinfo_slab); +diff --git a/lustre/mdc/mdc_request.c b/lustre/mdc/mdc_request.c +index ee3a654..cea78ac 100644 +--- a/lustre/mdc/mdc_request.c ++++ b/lustre/mdc/mdc_request.c +@@ -3429,11 +3429,11 @@ struct md_ops mdc_md_ops = { + + int __init mdc_init(void) + { +- return class_register_type(&mdc_obd_ops, &mdc_md_ops, NULL, ++ return class_register_type(&mdc_obd_ops, &mdc_md_ops, true, NULL, + #ifndef HAVE_ONLY_PROCFS_SEQ +- NULL, ++ NULL, + #endif +- LUSTRE_MDC_NAME, NULL); ++ LUSTRE_MDC_NAME, NULL); + } + + #ifdef __KERNEL__ +diff --git a/lustre/mdd/mdd_device.c b/lustre/mdd/mdd_device.c +index fe9de80..0fe590e 100644 +--- a/lustre/mdd/mdd_device.c ++++ b/lustre/mdd/mdd_device.c +@@ -1582,11 +1582,11 @@ static int __init mdd_mod_init(void) + hsm_actions_logops.lop_add = llog_cat_add_rec; + hsm_actions_logops.lop_declare_add = llog_cat_declare_add_rec; + +- rc = class_register_type(&mdd_obd_device_ops, NULL, NULL, ++ rc = class_register_type(&mdd_obd_device_ops, NULL, true, NULL, + #ifndef HAVE_ONLY_PROCFS_SEQ +- lvars.module_vars, ++ lvars.module_vars, + #endif +- LUSTRE_MDD_NAME, &mdd_device_type); ++ LUSTRE_MDD_NAME, &mdd_device_type); + if (rc) + lu_kmem_fini(mdd_caches); + return rc; +diff --git a/lustre/mdt/mdt_handler.c b/lustre/mdt/mdt_handler.c +index 0e1f0f6..69b1c30 100644 +--- a/lustre/mdt/mdt_handler.c ++++ b/lustre/mdt/mdt_handler.c +@@ -5901,11 +5901,11 @@ static int __init mdt_mod_init(void) + GOTO(lu_fini, rc); + + lprocfs_mdt_init_vars(&lvars); +- rc = class_register_type(&mdt_obd_device_ops, NULL, NULL, ++ rc = class_register_type(&mdt_obd_device_ops, NULL, true, NULL, + #ifndef HAVE_ONLY_PROCFS_SEQ +- lvars.module_vars, ++ lvars.module_vars, + #endif +- LUSTRE_MDT_NAME, &mdt_device_type); ++ LUSTRE_MDT_NAME, &mdt_device_type); + if (rc) + GOTO(mds_fini, rc); + lu_fini: +diff --git a/lustre/mdt/mdt_mds.c b/lustre/mdt/mdt_mds.c +index 367f659..390164f 100644 +--- a/lustre/mdt/mdt_mds.c ++++ b/lustre/mdt/mdt_mds.c +@@ -539,11 +539,11 @@ int mds_mod_init(void) + mds_num_threads = mdt_num_threads; + } + +- return class_register_type(&mds_obd_device_ops, NULL, NULL, ++ return class_register_type(&mds_obd_device_ops, NULL, true, NULL, + #ifndef HAVE_ONLY_PROCFS_SEQ +- lprocfs_mds_module_vars, ++ lprocfs_mds_module_vars, + #endif +- LUSTRE_MDS_NAME, &mds_device_type); ++ LUSTRE_MDS_NAME, &mds_device_type); + } + + void mds_mod_exit(void) +diff --git a/lustre/mgc/libmgc.c b/lustre/mgc/libmgc.c +index 49a329a..ec915c7 100644 +--- a/lustre/mgc/libmgc.c ++++ b/lustre/mgc/libmgc.c +@@ -158,9 +158,9 @@ struct obd_ops mgc_obd_ops = { + + int __init mgc_init(void) + { +- return class_register_type(&mgc_obd_ops, NULL, NULL, ++ return class_register_type(&mgc_obd_ops, NULL, true, NULL, + #ifndef HAVE_ONLY_PROCFS_SEQ +- NULL, ++ NULL, + #endif +- LUSTRE_MGC_NAME, NULL); ++ LUSTRE_MGC_NAME, NULL); + } +diff --git a/lustre/mgc/mgc_request.c b/lustre/mgc/mgc_request.c +index 8935814..7741bbf 100644 +--- a/lustre/mgc/mgc_request.c ++++ b/lustre/mgc/mgc_request.c +@@ -2022,11 +2022,11 @@ struct obd_ops mgc_obd_ops = { + + int __init mgc_init(void) + { +- return class_register_type(&mgc_obd_ops, NULL, NULL, ++ return class_register_type(&mgc_obd_ops, NULL, true, NULL, + #ifndef HAVE_ONLY_PROCFS_SEQ +- NULL, ++ NULL, + #endif +- LUSTRE_MGC_NAME, NULL); ++ LUSTRE_MGC_NAME, NULL); + } + + #ifdef __KERNEL__ +diff --git a/lustre/mgs/mgs_handler.c b/lustre/mgs/mgs_handler.c +index 8961fc3..85b219c 100644 +--- a/lustre/mgs/mgs_handler.c ++++ b/lustre/mgs/mgs_handler.c +@@ -1516,11 +1516,11 @@ static int __init mgs_init(void) + struct lprocfs_static_vars lvars; + + lprocfs_mgs_init_vars(&lvars); +- return class_register_type(&mgs_obd_device_ops, NULL, NULL, ++ return class_register_type(&mgs_obd_device_ops, NULL, true, NULL, + #ifndef HAVE_ONLY_PROCFS_SEQ +- lvars.module_vars, ++ lvars.module_vars, + #endif +- LUSTRE_MGS_NAME, &mgs_device_type); ++ LUSTRE_MGS_NAME, &mgs_device_type); + } + + static void /*__exit*/ mgs_exit(void) +diff --git a/lustre/obdclass/genops.c b/lustre/obdclass/genops.c +index bf8b6ce..98dbcce 100644 +--- a/lustre/obdclass/genops.c ++++ b/lustre/obdclass/genops.c +@@ -162,7 +162,7 @@ EXPORT_SYMBOL(class_put_type); + #define CLASS_MAX_NAME 1024 + + int class_register_type(struct obd_ops *dt_ops, struct md_ops *md_ops, +- struct lprocfs_seq_vars *module_vars, ++ bool enable_proc, struct lprocfs_seq_vars *module_vars, + #ifndef HAVE_ONLY_PROCFS_SEQ + struct lprocfs_vars *vars, + #endif +@@ -202,22 +202,24 @@ int class_register_type(struct obd_ops *dt_ops, struct md_ops *md_ops, + spin_lock_init(&type->obd_type_lock); + + #ifdef LPROCFS ++ if (enable_proc) { + #ifndef HAVE_ONLY_PROCFS_SEQ +- if (vars) { +- type->typ_procroot = lprocfs_register(type->typ_name, +- proc_lustre_root, +- vars, type); +- } else ++ if (vars) { ++ type->typ_procroot = lprocfs_register(type->typ_name, ++ proc_lustre_root, ++ vars, type); ++ } else + #endif +- { +- type->typ_procroot = lprocfs_seq_register(type->typ_name, +- proc_lustre_root, +- module_vars, type); +- } +- if (IS_ERR(type->typ_procroot)) { +- rc = PTR_ERR(type->typ_procroot); +- type->typ_procroot = NULL; +- GOTO (failed, rc); ++ { ++ type->typ_procroot = lprocfs_seq_register(type->typ_name, ++ proc_lustre_root, ++ module_vars, type); ++ } ++ if (IS_ERR(type->typ_procroot)) { ++ rc = PTR_ERR(type->typ_procroot); ++ type->typ_procroot = NULL; ++ GOTO(failed, rc); ++ } + } + #endif + if (ldt != NULL) { +@@ -233,18 +235,20 @@ int class_register_type(struct obd_ops *dt_ops, struct md_ops *md_ops, + + RETURN (0); + +- failed: +-#ifdef LPROCFS ++failed: + if (type->typ_name != NULL) { ++#ifdef LPROCFS ++ if (type->typ_procroot != NULL) { + #ifndef HAVE_ONLY_PROCFS_SEQ +- lprocfs_try_remove_proc_entry(type->typ_name, proc_lustre_root); ++ lprocfs_try_remove_proc_entry(type->typ_name, ++ proc_lustre_root); + #else +- remove_proc_subtree(type->typ_name, proc_lustre_root); ++ remove_proc_subtree(type->typ_name, proc_lustre_root); + #endif +- } ++ } + #endif +- if (type->typ_name != NULL) + OBD_FREE(type->typ_name, strlen(name) + 1); ++ } + if (type->typ_md_ops != NULL) + OBD_FREE_PTR(type->typ_md_ops); + if (type->typ_dt_ops != NULL) +@@ -278,11 +282,16 @@ int class_unregister_type(const char *name) + * we can't reference pointer as it can get invalided when another + * module removes the entry */ + #ifdef LPROCFS ++ if (type->typ_procroot != NULL) { + #ifndef HAVE_ONLY_PROCFS_SEQ +- lprocfs_try_remove_proc_entry(type->typ_name, proc_lustre_root); ++ lprocfs_try_remove_proc_entry(type->typ_name, proc_lustre_root); + #else +- remove_proc_subtree(type->typ_name, proc_lustre_root); ++ remove_proc_subtree(type->typ_name, proc_lustre_root); + #endif ++ } ++ ++ if (type->typ_procsym != NULL) ++ lprocfs_remove(&type->typ_procsym); + #endif + if (type->typ_lu) + lu_device_type_fini(type->typ_lu); +diff --git a/lustre/obdclass/llog_test.c b/lustre/obdclass/llog_test.c +index a1051c2..18d5843 100644 +--- a/lustre/obdclass/llog_test.c ++++ b/lustre/obdclass/llog_test.c +@@ -1261,11 +1261,11 @@ static struct obd_ops llog_obd_ops = { + + static int __init llog_test_init(void) + { +- return class_register_type(&llog_obd_ops, NULL, NULL, ++ return class_register_type(&llog_obd_ops, NULL, true, NULL, + #ifndef HAVE_ONLY_PROCFS_SEQ +- NULL, ++ NULL, + #endif +- "llog_test", NULL); ++ "llog_test", NULL); + } + + static void __exit llog_test_exit(void) +diff --git a/lustre/obdclass/lprocfs_status.c b/lustre/obdclass/lprocfs_status.c +index 9956ada..30d9f59 100644 +--- a/lustre/obdclass/lprocfs_status.c ++++ b/lustre/obdclass/lprocfs_status.c +@@ -1936,7 +1936,6 @@ lprocfs_seq_obd_setup(struct obd_device *obd) + int rc = 0; + + LASSERT(obd != NULL); +- LASSERT(obd->obd_vars != NULL); + LASSERT(obd->obd_magic == OBD_DEVICE_MAGIC); + LASSERT(obd->obd_type->typ_procroot != NULL); + +diff --git a/lustre/obdecho/echo_client.c b/lustre/obdecho/echo_client.c +index 38cff00..632bf52 100644 +--- a/lustre/obdecho/echo_client.c ++++ b/lustre/obdecho/echo_client.c +@@ -3169,12 +3169,12 @@ int echo_client_init(void) + + rc = lu_kmem_init(echo_caches); + if (rc == 0) { +- rc = class_register_type(&echo_client_obd_ops, NULL, NULL, ++ rc = class_register_type(&echo_client_obd_ops, NULL, true, NULL, + #ifndef HAVE_ONLY_PROCFS_SEQ +- NULL, ++ NULL, + #endif +- LUSTRE_ECHO_CLIENT_NAME, +- &echo_device_type); ++ LUSTRE_ECHO_CLIENT_NAME, ++ &echo_device_type); + if (rc) + lu_kmem_fini(echo_caches); + } +@@ -3202,7 +3202,7 @@ static int __init obdecho_init(void) + if (rc != 0) + goto failed_0; + +- rc = class_register_type(&echo_obd_ops, NULL, NULL, ++ rc = class_register_type(&echo_obd_ops, NULL, true, NULL, + #ifndef HAVE_ONLY_PROCFS_SEQ + NULL, + #endif +diff --git a/lustre/ofd/ofd_dev.c b/lustre/ofd/ofd_dev.c +index 4cafa48..5d7f0b4 100644 +--- a/lustre/ofd/ofd_dev.c ++++ b/lustre/ofd/ofd_dev.c +@@ -2394,11 +2394,11 @@ int __init ofd_init(void) + + lprocfs_ofd_init_vars(&lvars); + +- rc = class_register_type(&ofd_obd_ops, NULL, NULL, ++ rc = class_register_type(&ofd_obd_ops, NULL, true, NULL, + #ifndef HAVE_ONLY_PROCFS_SEQ +- lvars.module_vars, ++ lvars.module_vars, + #endif +- LUSTRE_OST_NAME, &ofd_device_type); ++ LUSTRE_OST_NAME, &ofd_device_type); + return rc; + } + +diff --git a/lustre/osc/osc_request.c b/lustre/osc/osc_request.c +index 2b60765..076dcf6 100644 +--- a/lustre/osc/osc_request.c ++++ b/lustre/osc/osc_request.c +@@ -3091,9 +3091,10 @@ static int brw_queue_work(const struct lu_env *env, void *data) + + int osc_setup(struct obd_device *obd, struct lustre_cfg *lcfg) + { +- struct client_obd *cli = &obd->u.cli; +- void *handler; +- int rc; ++ struct client_obd *cli = &obd->u.cli; ++ struct obd_type *type; ++ void *handler; ++ int rc; + ENTRY; + + rc = ptlrpcd_addref(); +@@ -3119,10 +3120,32 @@ int osc_setup(struct obd_device *obd, struct lustre_cfg *lcfg) + GOTO(out_ptlrpcd_work, rc); + + cli->cl_grant_shrink_interval = GRANT_SHRINK_INTERVAL; ++ + #ifdef LPROCFS + obd->obd_vars = lprocfs_osc_obd_vars; + #endif +- if (lprocfs_seq_obd_setup(obd) == 0) { ++ /* If this is true then both client (osc) and server (osp) are on the ++ * same node. The osp layer if loaded first will register the osc proc ++ * directory. In that case this obd_device will be attached its proc ++ * tree to type->typ_procsym instead of obd->obd_type->typ_procroot. */ ++ type = class_search_type(LUSTRE_OSP_NAME); ++ if (type && type->typ_procsym) { ++ obd->obd_proc_entry = lprocfs_seq_register(obd->obd_name, ++ type->typ_procsym, ++ obd->obd_vars, obd); ++ if (IS_ERR(obd->obd_proc_entry)) { ++ rc = PTR_ERR(obd->obd_proc_entry); ++ CERROR("error %d setting up lprocfs for %s\n", rc, ++ obd->obd_name); ++ obd->obd_proc_entry = NULL; ++ } ++ } else { ++ rc = lprocfs_seq_obd_setup(obd); ++ } ++ ++ /* If the basic OSC proc tree construction succeeded then ++ * lets do the rest. */ ++ if (rc == 0) { + lproc_osc_attach_seqstat(obd); + sptlrpc_lprocfs_cliobd_attach(obd); + ptlrpc_lprocfs_register_obd(obd); +@@ -3140,7 +3163,7 @@ int osc_setup(struct obd_device *obd, struct lustre_cfg *lcfg) + + CFS_INIT_LIST_HEAD(&cli->cl_grant_shrink_list); + ns_register_cancel(obd->obd_namespace, osc_cancel_weight); +- RETURN(rc); ++ RETURN(0); + + out_ptlrpcd_work: + if (cli->cl_writeback_work != NULL) { +@@ -3282,8 +3305,10 @@ extern struct lock_class_key osc_ast_guard_class; + + int __init osc_init(void) + { +- int rc; +- ENTRY; ++ bool enable_proc = true; ++ struct obd_type *type; ++ int rc; ++ ENTRY; + + /* print an address of _any_ initialized kernel symbol from this + * module, to allow debugging with gdb that doesn't support data +@@ -3294,11 +3319,15 @@ int __init osc_init(void) + if (rc) + RETURN(rc); + +- rc = class_register_type(&osc_obd_ops, NULL, NULL, ++ type = class_search_type(LUSTRE_OSP_NAME); ++ if (type != NULL && type->typ_procsym != NULL) ++ enable_proc = false; ++ ++ rc = class_register_type(&osc_obd_ops, NULL, enable_proc, NULL, + #ifndef HAVE_ONLY_PROCFS_SEQ +- NULL, ++ NULL, + #endif +- LUSTRE_OSC_NAME, &osc_device_type); ++ LUSTRE_OSC_NAME, &osc_device_type); + if (rc) { + lu_kmem_fini(osc_caches); + RETURN(rc); +diff --git a/lustre/osd-ldiskfs/osd_handler.c b/lustre/osd-ldiskfs/osd_handler.c +index 7461f9d..e0da7e6 100644 +--- a/lustre/osd-ldiskfs/osd_handler.c ++++ b/lustre/osd-ldiskfs/osd_handler.c +@@ -6019,11 +6019,11 @@ static int __init osd_mod_init(void) + if (rc) + return rc; + +- rc = class_register_type(&osd_obd_device_ops, NULL, NULL, ++ rc = class_register_type(&osd_obd_device_ops, NULL, true, NULL, + #ifndef HAVE_ONLY_PROCFS_SEQ +- lprocfs_osd_module_vars, ++ lprocfs_osd_module_vars, + #endif +- LUSTRE_OSD_LDISKFS_NAME, &osd_device_type); ++ LUSTRE_OSD_LDISKFS_NAME, &osd_device_type); + if (rc) + lu_kmem_fini(ldiskfs_caches); + return rc; +diff --git a/lustre/osd-zfs/osd_handler.c b/lustre/osd-zfs/osd_handler.c +index 1025be9..47bbc76 100644 +--- a/lustre/osd-zfs/osd_handler.c ++++ b/lustre/osd-zfs/osd_handler.c +@@ -912,11 +912,11 @@ int __init osd_init(void) + if (rc) + return rc; + +- rc = class_register_type(&osd_obd_device_ops, NULL, NULL, ++ rc = class_register_type(&osd_obd_device_ops, NULL, true, NULL, + #ifndef HAVE_ONLY_PROCFS_SEQ +- lprocfs_osd_module_vars, ++ lprocfs_osd_module_vars, + #endif +- LUSTRE_OSD_ZFS_NAME, &osd_device_type); ++ LUSTRE_OSD_ZFS_NAME, &osd_device_type); + if (rc) + lu_kmem_fini(osd_caches); + return rc; +diff --git a/lustre/osp/osp_dev.c b/lustre/osp/osp_dev.c +index 550ba5e..60bf8ef 100644 +--- a/lustre/osp/osp_dev.c ++++ b/lustre/osp/osp_dev.c +@@ -1239,7 +1239,7 @@ struct llog_operations osp_mds_ost_orig_logops; + static int __init osp_mod_init(void) + { + struct lprocfs_static_vars lvars; +- cfs_proc_dir_entry_t *osc_proc_dir; ++ struct obd_type *type; + int rc; + + rc = lu_kmem_init(osp_caches); +@@ -1248,11 +1248,11 @@ static int __init osp_mod_init(void) + + lprocfs_osp_init_vars(&lvars); + +- rc = class_register_type(&osp_obd_device_ops, NULL, NULL, ++ rc = class_register_type(&osp_obd_device_ops, NULL, true, NULL, + #ifndef HAVE_ONLY_PROCFS_SEQ +- lvars.module_vars, ++ lvars.module_vars, + #endif +- LUSTRE_OSP_NAME, &osp_device_type); ++ LUSTRE_OSP_NAME, &osp_device_type); + + /* create "osc" entry in procfs for compatibility purposes */ + if (rc != 0) { +@@ -1262,11 +1262,11 @@ static int __init osp_mod_init(void) + + lprocfs_lwp_init_vars(&lvars); + +- rc = class_register_type(&lwp_obd_device_ops, NULL, NULL, ++ rc = class_register_type(&lwp_obd_device_ops, NULL, true, NULL, + #ifndef HAVE_ONLY_PROCFS_SEQ +- lvars.module_vars, ++ lvars.module_vars, + #endif +- LUSTRE_LWP_NAME, &lwp_device_type); ++ LUSTRE_LWP_NAME, &lwp_device_type); + if (rc != 0) { + class_unregister_type(LUSTRE_OSP_NAME); + lu_kmem_fini(osp_caches); +@@ -1278,14 +1278,17 @@ static int __init osp_mod_init(void) + osp_mds_ost_orig_logops.lop_add = llog_cat_add_rec; + osp_mds_ost_orig_logops.lop_declare_add = llog_cat_declare_add_rec; + +- osc_proc_dir = lprocfs_srch(proc_lustre_root, "osc"); +- if (osc_proc_dir == NULL) { +- osc_proc_dir = lprocfs_register("osc", proc_lustre_root, NULL, +- NULL); +- if (IS_ERR(osc_proc_dir)) +- CERROR("osp: can't create compat entry \"osc\": %d\n", +- (int) PTR_ERR(osc_proc_dir)); +- } ++ /* create "osc" entry in procfs for compatibility purposes */ ++ type = class_search_type(LUSTRE_OSC_NAME); ++ if (type != NULL && type->typ_procroot != NULL) ++ return rc; ++ ++ type = class_search_type(LUSTRE_OSP_NAME); ++ type->typ_procsym = lprocfs_register("osc", proc_lustre_root, ++ NULL, NULL); ++ if (IS_ERR(type->typ_procsym)) ++ CERROR("osp: can't create compat entry \"osc\": %d\n", ++ (int) PTR_ERR(type->typ_procsym)); + return rc; + } + +diff --git a/lustre/ost/ost_handler.c b/lustre/ost/ost_handler.c +index f7448d4..d8897cc 100644 +--- a/lustre/ost/ost_handler.c ++++ b/lustre/ost/ost_handler.c +@@ -470,11 +470,11 @@ static int __init ost_init(void) + + ENTRY; + +- rc = class_register_type(&ost_obd_ops, NULL, NULL, ++ rc = class_register_type(&ost_obd_ops, NULL, true, NULL, + #ifndef HAVE_ONLY_PROCFS_SEQ +- NULL, ++ NULL, + #endif +- LUSTRE_OSS_NAME, NULL); ++ LUSTRE_OSS_NAME, NULL); + + if (ost_num_threads != 0 && oss_num_threads == 0) { + LCONSOLE_INFO("ost_num_threads module parameter is deprecated, " +diff --git a/lustre/quota/qmt_dev.c b/lustre/quota/qmt_dev.c +index 02ec55b..28783a0 100644 +--- a/lustre/quota/qmt_dev.c ++++ b/lustre/quota/qmt_dev.c +@@ -466,11 +466,11 @@ int qmt_glb_init(void) + int rc; + ENTRY; + +- rc = class_register_type(&qmt_obd_ops, NULL, NULL, ++ rc = class_register_type(&qmt_obd_ops, NULL, true, NULL, + #ifndef HAVE_ONLY_PROCFS_SEQ +- NULL, ++ NULL, + #endif +- LUSTRE_QMT_NAME, &qmt_device_type); ++ LUSTRE_QMT_NAME, &qmt_device_type); + RETURN(rc); + } + +-- +1.9.1 + diff --git a/sys-cluster/lustre/files/0002-LU-3319-procfs-Move-NRS-TBF-proc-handling-to-seq_fil.patch b/sys-cluster/lustre/files/0002-LU-3319-procfs-Move-NRS-TBF-proc-handling-to-seq_fil.patch new file mode 100644 index 000000000..d7da497ce --- /dev/null +++ b/sys-cluster/lustre/files/0002-LU-3319-procfs-Move-NRS-TBF-proc-handling-to-seq_fil.patch @@ -0,0 +1,123 @@ +From 7dbddd98e60ab73580ea52c8b53274da2283d624 Mon Sep 17 00:00:00 2001 +From: James Simmons <uja.ornl@gmail.com> +Date: Tue, 25 Feb 2014 12:54:05 -0500 +Subject: [PATCH 2/9] LU-3319 procfs: Move NRS TBF proc handling to seq_files + +With newer kernels moving their proc file system handling +to seq_files this patch migrates the proc handling for NRS +TBF to this new approach. + +Change-Id: I121755b611296bf7b9527de65d0e6cf8c4980151 +Signed-off-by: James Simmons <uja.ornl@gmail.com> +--- + lustre/ptlrpc/nrs_tbf.c | 35 ++++++++++++++--------------------- + 1 file changed, 14 insertions(+), 21 deletions(-) + +diff --git a/lustre/ptlrpc/nrs_tbf.c b/lustre/ptlrpc/nrs_tbf.c +index 96eac30..09ab0e7 100644 +--- a/lustre/ptlrpc/nrs_tbf.c ++++ b/lustre/ptlrpc/nrs_tbf.c +@@ -1572,30 +1572,26 @@ static void nrs_tbf_req_stop(struct ptlrpc_nrs_policy *policy, + */ + #define LPROCFS_NRS_RATE_MAX 65535 + +-static int ptlrpc_lprocfs_rd_nrs_tbf_rule(char *page, char **start, +- off_t off, int count, int *eof, +- void *data) ++static int ++ptlrpc_lprocfs_nrs_tbf_rule_seq_show(struct seq_file *m, void *data) + { +- struct ptlrpc_service *svc = data; ++ struct ptlrpc_service *svc = m->private; + int rc; + int rc2; + struct nrs_tbf_dump dump; + +- rc2 = snprintf(page, count, "regular_requests:\n"); ++ rc2 = seq_printf(m, "regular_requests:\n"); + /** + * Perform two separate calls to this as only one of the NRS heads' + * policies may be in the ptlrpc_nrs_pol_state::NRS_POL_STATE_STARTED or + * ptlrpc_nrs_pol_state::NRS_POL_STATE_STOPPING state. + */ + dump.td_length = 0; +- dump.td_buff = page + rc2; +- dump.td_size = count - rc2; + rc = ptlrpc_nrs_policy_control(svc, PTLRPC_NRS_QUEUE_REG, + NRS_POL_NAME_TBF, + NRS_CTL_TBF_RD_RULE, + false, &dump); + if (rc == 0) { +- *eof = 1; + rc2 += dump.td_length; + /** + * Ignore -ENODEV as the regular NRS head's policy may be in the +@@ -1608,16 +1604,13 @@ static int ptlrpc_lprocfs_rd_nrs_tbf_rule(char *page, char **start, + if (!nrs_svc_has_hp(svc)) + goto no_hp; + +- rc2 += snprintf(page + rc2, count - rc2, "high_priority_requests:\n"); ++ rc2 += seq_printf(m, "high_priority_requests:\n"); + dump.td_length = 0; +- dump.td_buff = page + rc2; +- dump.td_size = count - rc2; + rc = ptlrpc_nrs_policy_control(svc, PTLRPC_NRS_QUEUE_HP, + NRS_POL_NAME_TBF, + NRS_CTL_TBF_RD_RULE, + false, &dump); + if (rc == 0) { +- *eof = 1; + rc2 += dump.td_length; + /** + * Ignore -ENODEV as the high priority NRS head's policy may be +@@ -1762,11 +1755,12 @@ out: + + extern struct nrs_core nrs_core; + #define LPROCFS_WR_NRS_TBF_MAX_CMD (4096) +-static int ptlrpc_lprocfs_wr_nrs_tbf_rule(struct file *file, +- const char *buffer, +- unsigned long count, void *data) ++static ssize_t ++ptlrpc_lprocfs_nrs_tbf_rule_seq_write(struct file *file, const char *buffer, ++ size_t count, loff_t *off) + { +- struct ptlrpc_service *svc = data; ++ struct seq_file *m = file->private_data; ++ struct ptlrpc_service *svc = m->private; + char *kernbuf; + char *val; + int rc; +@@ -1830,7 +1824,7 @@ out_free_kernbuff: + out: + return rc ? rc : count; + } +- ++LPROC_SEQ_FOPS(ptlrpc_lprocfs_nrs_tbf_rule); + + /** + * Initializes a TBF policy's lprocfs interface for service \a svc +@@ -1843,10 +1837,9 @@ out: + int nrs_tbf_lprocfs_init(struct ptlrpc_service *svc) + { + int rc; +- struct lprocfs_vars nrs_tbf_lprocfs_vars[] = { ++ struct lprocfs_seq_vars nrs_tbf_lprocfs_vars[] = { + { .name = "nrs_tbf_rule", +- .read_fptr = ptlrpc_lprocfs_rd_nrs_tbf_rule, +- .write_fptr = ptlrpc_lprocfs_wr_nrs_tbf_rule, ++ .fops = &ptlrpc_lprocfs_nrs_tbf_rule_fops, + .data = svc }, + { NULL } + }; +@@ -1854,7 +1847,7 @@ int nrs_tbf_lprocfs_init(struct ptlrpc_service *svc) + if (svc->srv_procroot == NULL) + return 0; + +- rc = lprocfs_add_vars(svc->srv_procroot, nrs_tbf_lprocfs_vars, NULL); ++ rc = lprocfs_seq_add_vars(svc->srv_procroot, nrs_tbf_lprocfs_vars, NULL); + + return rc; + } +-- +1.9.1 + diff --git a/sys-cluster/lustre/files/0002-LU-3319-procfs-update-zfs-proc-handling-to-seq_files.patch b/sys-cluster/lustre/files/0003-LU-3319-procfs-update-zfs-proc-handling-to-seq_files.patch index ff3c6bf44..b06c8da15 100644 --- a/sys-cluster/lustre/files/0002-LU-3319-procfs-update-zfs-proc-handling-to-seq_files.patch +++ b/sys-cluster/lustre/files/0003-LU-3319-procfs-update-zfs-proc-handling-to-seq_files.patch @@ -1,7 +1,7 @@ -From 699242b35f07c7c64959dca02cc359d389c7f568 Mon Sep 17 00:00:00 2001 +From abe827ebe8722336c55affd8388dacfbb38b49f1 Mon Sep 17 00:00:00 2001 From: James Simmons <uja.ornl@gmail.com> -Date: Fri, 3 Jan 2014 09:55:26 -0500 -Subject: [PATCH 02/12] LU-3319 procfs: update zfs proc handling to seq_files +Date: Tue, 18 Feb 2014 18:44:22 -0500 +Subject: [PATCH 3/9] LU-3319 procfs: update zfs proc handling to seq_files Migrate all zfs proc handling to using strictly seq_files. @@ -9,68 +9,61 @@ Signed-off-by: James Simmons <uja.ornl@gmail.com> Change-Id: I6dc7e65c3e74e7934a17939815ec3c334fac58c7 --- lustre/osd-zfs/osd_handler.c | 13 ++++--- - lustre/osd-zfs/osd_internal.h | 3 -- - lustre/osd-zfs/osd_lproc.c | 88 ++++++++++++++++++++++++------------------- - 3 files changed, 57 insertions(+), 47 deletions(-) + lustre/osd-zfs/osd_internal.h | 3 +- + lustre/osd-zfs/osd_lproc.c | 90 +++++++++++++++++++++++++------------------ + 3 files changed, 60 insertions(+), 46 deletions(-) diff --git a/lustre/osd-zfs/osd_handler.c b/lustre/osd-zfs/osd_handler.c -index 1025be9..c9bf49a 100644 +index 47bbc76..05820e0 100644 --- a/lustre/osd-zfs/osd_handler.c +++ b/lustre/osd-zfs/osd_handler.c -@@ -748,6 +748,7 @@ static int osd_device_init(const struct lu_env *env, struct lu_device *d, - static int osd_process_config(const struct lu_env *env, - struct lu_device *d, struct lustre_cfg *cfg) - { -+ struct obd_device *obd = d->ld_obd; - struct osd_device *o = osd_dev(d); - int rc; - ENTRY; -@@ -761,12 +762,12 @@ static int osd_process_config(const struct lu_env *env, +@@ -761,12 +761,13 @@ static int osd_process_config(const struct lu_env *env, break; case LCFG_PARAM: { LASSERT(&o->od_dt_dev); - rc = class_process_proc_param(PARAM_OSD, lprocfs_osd_obd_vars, - cfg, &o->od_dt_dev); -+ rc = class_process_proc_seq_param(PARAM_OSD, obd->obd_vars, -+ cfg, &o->od_dt_dev); ++ rc = class_process_proc_seq_param(PARAM_OSD, ++ lprocfs_osd_obd_vars, cfg, ++ &o->od_dt_dev); if (rc > 0 || rc == -ENOSYS) - rc = class_process_proc_param(PARAM_OST, - lprocfs_osd_obd_vars, - cfg, &o->od_dt_dev); + rc = class_process_proc_seq_param(PARAM_OST, -+ obd->obd_vars, cfg, -+ &o->od_dt_dev); ++ lprocfs_osd_obd_vars, ++ cfg, &o->od_dt_dev); break; } default: @@ -914,7 +915,7 @@ int __init osd_init(void) - rc = class_register_type(&osd_obd_device_ops, NULL, NULL, + rc = class_register_type(&osd_obd_device_ops, NULL, true, NULL, #ifndef HAVE_ONLY_PROCFS_SEQ -- lprocfs_osd_module_vars, -+ NULL, +- lprocfs_osd_module_vars, ++ NULL, #endif - LUSTRE_OSD_ZFS_NAME, &osd_device_type); + LUSTRE_OSD_ZFS_NAME, &osd_device_type); if (rc) diff --git a/lustre/osd-zfs/osd_internal.h b/lustre/osd-zfs/osd_internal.h -index bc51cb1..77b118f 100644 +index bc51cb1..3dc4881 100644 --- a/lustre/osd-zfs/osd_internal.h +++ b/lustre/osd-zfs/osd_internal.h -@@ -402,9 +402,6 @@ enum { +@@ -402,8 +402,7 @@ enum { }; /* osd_lproc.c */ -extern struct lprocfs_vars lprocfs_osd_obd_vars[]; -extern struct lprocfs_vars lprocfs_osd_module_vars[]; -- ++extern struct lprocfs_seq_vars lprocfs_osd_obd_vars[]; + int osd_procfs_init(struct osd_device *osd, const char *name); int osd_procfs_fini(struct osd_device *osd); - diff --git a/lustre/osd-zfs/osd_lproc.c b/lustre/osd-zfs/osd_lproc.c -index 0854ce6..a7ce60d 100644 +index 0854ce6..bed08e9 100644 --- a/lustre/osd-zfs/osd_lproc.c +++ b/lustre/osd-zfs/osd_lproc.c -@@ -107,27 +107,26 @@ out: +@@ -107,27 +107,27 @@ out: RETURN(result); } @@ -105,11 +98,12 @@ index 0854ce6..a7ce60d 100644 + size_t count, loff_t *off) { - struct dt_device *dt = data; -+ struct dt_device *dt = ((struct seq_file *)file->private_data)->private; ++ struct seq_file *m = file->private_data; ++ struct dt_device *dt = m->private; struct lu_env env; int rc; -@@ -139,20 +138,21 @@ static int lprocfs_osd_wr_force_sync(struct file *file, const char *buffer, +@@ -139,20 +139,22 @@ static int lprocfs_osd_wr_force_sync(struct file *file, const char *buffer, return rc == 0 ? count : rc; } @@ -133,12 +127,13 @@ index 0854ce6..a7ce60d 100644 + size_t count, loff_t *off) { - struct osd_device *osd = osd_dt_dev((struct dt_device *)data); -+ struct dt_device *dt = ((struct seq_file *)file->private_data)->private; ++ struct seq_file *m = file->private_data; ++ struct dt_device *dt = m->private; + struct osd_device *osd = osd_dt_dev(dt); int rc, val; LASSERT(osd != NULL); -@@ -165,24 +165,36 @@ static int lprocfs_osd_wr_iused_est(struct file *file, const char *buffer, +@@ -165,24 +167,36 @@ static int lprocfs_osd_wr_iused_est(struct file *file, const char *buffer, return count; } @@ -193,7 +188,7 @@ index 0854ce6..a7ce60d 100644 { 0 } }; -@@ -202,7 +214,7 @@ int osd_procfs_init(struct osd_device *osd, const char *name) +@@ -202,7 +216,7 @@ int osd_procfs_init(struct osd_device *osd, const char *name) LASSERT(name != NULL); LASSERT(type != NULL); @@ -203,5 +198,5 @@ index 0854ce6..a7ce60d 100644 if (IS_ERR(osd->od_proc_entry)) { rc = PTR_ERR(osd->od_proc_entry); -- -1.8.5.3 +1.9.1 diff --git a/sys-cluster/lustre/files/0004-LU-3319-procfs-fix-symlink-handling.patch b/sys-cluster/lustre/files/0004-LU-3319-procfs-fix-symlink-handling.patch deleted file mode 100644 index 935325e9c..000000000 --- a/sys-cluster/lustre/files/0004-LU-3319-procfs-fix-symlink-handling.patch +++ /dev/null @@ -1,371 +0,0 @@ -From 4bc21601224ea84152d9c3cc83eee33af8eb8cb2 Mon Sep 17 00:00:00 2001 -From: James Simmons <uja.ornl@gmail.com> -Date: Sun, 9 Feb 2014 09:37:44 -0500 -Subject: [PATCH 04/12] LU-3319 procfs: fix symlink handling - -While working on symlink handling for seq files I noticed a -long outstanding bug. Code was developed to link osc obds -to target_obds of the lov layer. The target_obds directory -was never created for the symlinks. This patches enables -this long forgotten feature. Also addressed is the race -condition experinced with server side code ported to -seq_files that used symlinks. To avoid the race the handle -obd_proc_private was moved from struct obd_device to -struct obd_type which now allows earlier registeration that -only happens once. - -Change-Id: Ib158ec4444ed7abc0f3c3e820ee4a333631a58d1 -Signed-off-by: James Simmons <uja.ornl@gmail.com> ---- - lustre/include/obd.h | 17 +++++---- - lustre/lmv/lmv_obd.c | 48 ++++++++--------------- - lustre/lov/lov_obd.c | 99 +++++++++++++++++++++++++++--------------------- - lustre/obdclass/genops.c | 17 +++++---- - 4 files changed, 91 insertions(+), 90 deletions(-) - -diff --git a/lustre/include/obd.h b/lustre/include/obd.h -index ac80412..42266da 100644 ---- a/lustre/include/obd.h -+++ b/lustre/include/obd.h -@@ -183,13 +183,15 @@ struct obd_info { - }; - - struct obd_type { -- cfs_list_t typ_chain; -- struct obd_ops *typ_dt_ops; -- struct md_ops *typ_md_ops; -- cfs_proc_dir_entry_t *typ_procroot; -- char *typ_name; -- int typ_refcnt; -- struct lu_device_type *typ_lu; -+ struct list_head typ_chain; -+ struct obd_ops *typ_dt_ops; -+ struct md_ops *typ_md_ops; -+ cfs_proc_dir_entry_t *typ_procroot; -+ cfs_proc_dir_entry_t *typ_procsym; -+ __u32 typ_sym_filter; -+ char *typ_name; -+ int typ_refcnt; -+ struct lu_device_type *typ_lu; - spinlock_t obd_type_lock; - }; - -@@ -825,7 +827,6 @@ struct obd_device { - - struct proc_dir_entry *obd_proc_entry; - struct proc_dir_entry *obd_proc_exports_entry; -- void *obd_proc_private; /* type private PDEs */ - struct proc_dir_entry *obd_svc_procroot; - struct lprocfs_stats *obd_svc_stats; - struct lprocfs_seq_vars *obd_vars; -diff --git a/lustre/lmv/lmv_obd.c b/lustre/lmv/lmv_obd.c -index ee5f3a7..66a9448 100644 ---- a/lustre/lmv/lmv_obd.c -+++ b/lustre/lmv/lmv_obd.c -@@ -263,9 +263,6 @@ static int lmv_connect(const struct lu_env *env, - struct obd_uuid *cluuid, struct obd_connect_data *data, - void *localdata) - { --#ifdef __KERNEL__ -- struct proc_dir_entry *lmv_proc_dir; --#endif - struct lmv_obd *lmv = &obd->u.lmv; - struct lustre_handle conn = { 0 }; - int rc = 0; -@@ -298,18 +295,15 @@ static int lmv_connect(const struct lu_env *env, - lmv->conn_data = *data; - - #ifdef __KERNEL__ -- 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)) { -+ if (obd->obd_type->typ_procsym == NULL) { -+ obd->obd_type->typ_procsym = lprocfs_seq_register("target_obds", -+ obd->obd_proc_entry, -+ NULL, NULL); -+ if (IS_ERR(obd->obd_type->typ_procsym)) { - 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_type->typ_procsym = NULL; - } -- obd->obd_proc_private = lmv_proc_dir; - } - #endif - -@@ -323,10 +317,8 @@ static int lmv_connect(const struct lu_env *env, - rc = lmv_check_connect(obd); - - #ifdef __KERNEL__ -- if (rc && lmv_proc_dir) { -- lprocfs_remove(&lmv_proc_dir); -- obd->obd_proc_private = NULL; -- } -+ if (rc && obd->obd_type->typ_procsym != NULL) -+ lprocfs_remove(&obd->obd_type->typ_procsym); - #endif - RETURN(rc); - } -@@ -405,9 +397,6 @@ static int lmv_init_ea_size(struct obd_export *exp, int easize, - - int lmv_connect_mdc(struct obd_device *obd, struct lmv_tgt_desc *tgt) - { --#ifdef __KERNEL__ -- struct proc_dir_entry *lmv_proc_dir; --#endif - struct lmv_obd *lmv = &obd->u.lmv; - struct obd_uuid *cluuid = &lmv->cluuid; - struct obd_uuid lmv_mdc_uuid = { "LMV_MDC_UUID" }; -@@ -487,14 +476,13 @@ int lmv_connect_mdc(struct obd_device *obd, struct lmv_tgt_desc *tgt) - cfs_atomic_read(&obd->obd_refcount)); - - #ifdef __KERNEL__ -- lmv_proc_dir = obd->obd_proc_private; -- if (lmv_proc_dir) { -+ if (obd->obd_type->typ_procsym != NULL) { - 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, -+ obd->obd_type->typ_procsym, - "../../../%s/%s", - mdc_obd->obd_type->typ_name, - mdc_obd->obd_name); -@@ -503,8 +491,7 @@ int lmv_connect_mdc(struct obd_device *obd, struct lmv_tgt_desc *tgt) - "/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; -+ lprocfs_remove(&obd->obd_type->typ_procsym); - } - } - #endif -@@ -696,9 +683,6 @@ int lmv_check_connect(struct obd_device *obd) - - static int lmv_disconnect_mdc(struct obd_device *obd, struct lmv_tgt_desc *tgt) - { --#ifdef __KERNEL__ -- struct proc_dir_entry *lmv_proc_dir; --#endif - struct lmv_obd *lmv = &obd->u.lmv; - struct obd_device *mdc_obd; - int rc; -@@ -716,9 +700,9 @@ static int lmv_disconnect_mdc(struct obd_device *obd, struct lmv_tgt_desc *tgt) - } - - #ifdef __KERNEL__ -- lmv_proc_dir = obd->obd_proc_private; -- if (lmv_proc_dir) -- lprocfs_remove_proc_entry(mdc_obd->obd_name, lmv_proc_dir); -+ if (obd->obd_type->typ_procsym != NULL) -+ lprocfs_remove_proc_entry(mdc_obd->obd_name, -+ obd->obd_type->typ_procsym); - #endif - rc = obd_fid_fini(tgt->ltd_exp->exp_obd); - if (rc) -@@ -768,8 +752,8 @@ static int lmv_disconnect(struct obd_export *exp) - } - - #ifdef __KERNEL__ -- if (obd->obd_proc_private) -- lprocfs_remove((struct proc_dir_entry **)&obd->obd_proc_private); -+ if (obd->obd_type->typ_procsym != NULL) -+ lprocfs_remove(&obd->obd_type->typ_procsym); - else - CERROR("/proc/fs/lustre/%s/%s/target_obds missing\n", - obd->obd_type->typ_name, obd->obd_name); -diff --git a/lustre/lov/lov_obd.c b/lustre/lov/lov_obd.c -index 286cd15..a3310fd 100644 ---- a/lustre/lov/lov_obd.c -+++ b/lustre/lov/lov_obd.c -@@ -127,19 +127,16 @@ static int lov_notify(struct obd_device *obd, struct obd_device *watched, - int lov_connect_obd(struct obd_device *obd, __u32 index, int activate, - struct obd_connect_data *data) - { -- struct lov_obd *lov = &obd->u.lov; -- struct obd_uuid *tgt_uuid; -- struct obd_device *tgt_obd; -- static struct obd_uuid lov_osc_uuid = { "LOV_OSC_UUID" }; -- struct obd_import *imp; --#ifdef __KERNEL__ -- struct proc_dir_entry *lov_proc_dir; --#endif -- int rc; -- ENTRY; -+ struct lov_obd *lov = &obd->u.lov; -+ struct obd_uuid *tgt_uuid; -+ struct obd_device *tgt_obd; -+ static struct obd_uuid lov_osc_uuid = { "LOV_OSC_UUID" }; -+ struct obd_import *imp; -+ int rc; -+ ENTRY; - -- if (!lov->lov_tgts[index]) -- RETURN(-EINVAL); -+ if (lov->lov_tgts[index] == NULL) -+ RETURN(-EINVAL); - - tgt_uuid = &lov->lov_tgts[index]->ltd_uuid; - tgt_obd = lov->lov_tgts[index]->ltd_obd; -@@ -195,27 +192,25 @@ int lov_connect_obd(struct obd_device *obd, __u32 index, int activate, - obd_uuid2str(tgt_uuid), tgt_obd->obd_name, activate ? "":"in"); - - #ifdef __KERNEL__ -- lov_proc_dir = obd->obd_proc_private; -- if (lov_proc_dir) { -- struct obd_device *osc_obd = lov->lov_tgts[index]->ltd_exp->exp_obd; -+ if (obd->obd_type->typ_procsym != NULL) { -+ struct obd_device *osc_obd = lov->lov_tgts[index]->ltd_exp->exp_obd; - struct proc_dir_entry *osc_symlink; - -- LASSERT(osc_obd != NULL); -- LASSERT(osc_obd->obd_magic == OBD_DEVICE_MAGIC); -- LASSERT(osc_obd->obd_type->typ_name != NULL); -- -- osc_symlink = lprocfs_add_symlink(osc_obd->obd_name, -- lov_proc_dir, -- "../../../%s/%s", -- osc_obd->obd_type->typ_name, -- osc_obd->obd_name); -- if (osc_symlink == NULL) { -- CERROR("could not register LOV target " -- "/proc/fs/lustre/%s/%s/target_obds/%s.", -- obd->obd_type->typ_name, obd->obd_name, -- osc_obd->obd_name); -- lprocfs_remove(&lov_proc_dir); -- obd->obd_proc_private = NULL; -+ LASSERT(osc_obd != NULL); -+ LASSERT(osc_obd->obd_magic == OBD_DEVICE_MAGIC); -+ LASSERT(osc_obd->obd_type->typ_name != NULL); -+ -+ osc_symlink = lprocfs_add_symlink(osc_obd->obd_name, -+ obd->obd_type->typ_procsym, -+ "../../../%s/%s", -+ osc_obd->obd_type->typ_name, -+ osc_obd->obd_name); -+ if (osc_symlink == NULL) { -+ CERROR("could not register LOV target " -+ "/proc/fs/lustre/%s/%s/target_obds/%s.", -+ obd->obd_type->typ_name, obd->obd_name, -+ osc_obd->obd_name); -+ lprocfs_remove(&obd->obd_type->typ_procsym); - } - } - #endif -@@ -250,6 +245,17 @@ static int lov_connect(const struct lu_env *env, - if (data) - lov->lov_ocd = *data; - -+#ifdef __KERNEL__ -+ obd->obd_type->typ_procsym = lprocfs_seq_register("target_obds", -+ obd->obd_proc_entry, -+ NULL, NULL); -+ if (IS_ERR(obd->obd_type->typ_procsym)) { -+ CERROR("could not register /proc/fs/lustre/%s/%s/target_obds.", -+ obd->obd_type->typ_name, obd->obd_name); -+ obd->obd_type->typ_procsym = NULL; -+ } -+#endif -+ - obd_getref(obd); - for (i = 0; i < lov->desc.ld_tgt_count; i++) { - tgt = lov->lov_tgts[i]; -@@ -280,7 +286,6 @@ static int lov_connect(const struct lu_env *env, - - static int lov_disconnect_obd(struct obd_device *obd, struct lov_tgt_desc *tgt) - { -- struct proc_dir_entry *lov_proc_dir; - struct lov_obd *lov = &obd->u.lov; - struct obd_device *osc_obd; - int rc; -@@ -296,18 +301,18 @@ static int lov_disconnect_obd(struct obd_device *obd, struct lov_tgt_desc *tgt) - tgt->ltd_exp->exp_obd->obd_inactive = 1; - } - -- lov_proc_dir = obd->obd_proc_private; -- if (lov_proc_dir) -- lprocfs_remove_proc_entry(osc_obd->obd_name, lov_proc_dir); -+ if (obd->obd_type->typ_procsym) -+ lprocfs_remove_proc_entry(osc_obd->obd_name, -+ obd->obd_type->typ_procsym); - -- if (osc_obd) { -- /* Pass it on to our clients. -- * XXX This should be an argument to disconnect, -- * XXX not a back-door flag on the OBD. Ah well. -- */ -- osc_obd->obd_force = obd->obd_force; -- osc_obd->obd_fail = obd->obd_fail; -- osc_obd->obd_no_recov = obd->obd_no_recov; -+ if (osc_obd) { -+ /* Pass it on to our clients. -+ * XXX This should be an argument to disconnect, -+ * XXX not a back-door flag on the OBD. Ah well. -+ */ -+ osc_obd->obd_force = obd->obd_force; -+ osc_obd->obd_fail = obd->obd_fail; -+ osc_obd->obd_no_recov = obd->obd_no_recov; - } - - obd_register_observer(osc_obd, NULL); -@@ -353,6 +358,14 @@ static int lov_disconnect(struct obd_export *exp) - } - obd_putref(obd); - -+#ifdef __KERNEL__ -+ if (obd->obd_type->typ_procsym) -+ lprocfs_remove(&obd->obd_type->typ_procsym); -+ else -+ CERROR("/proc/fs/lustre/%s/%s/target_obds missing\n", -+ obd->obd_type->typ_name, obd->obd_name); -+#endif -+ - out: - rc = class_disconnect(exp); /* bz 9811 */ - RETURN(rc); -diff --git a/lustre/obdclass/genops.c b/lustre/obdclass/genops.c -index 20cd0a0..00bf342 100644 ---- a/lustre/obdclass/genops.c -+++ b/lustre/obdclass/genops.c -@@ -181,14 +181,15 @@ int class_register_type(struct obd_ops *dt_ops, struct md_ops *md_ops, - RETURN(-EEXIST); - } - -- rc = -ENOMEM; -- OBD_ALLOC(type, sizeof(*type)); -- if (type == NULL) -- RETURN(rc); -+ rc = -ENOMEM; -+ OBD_ALLOC(type, sizeof(*type)); -+ if (type == NULL) -+ RETURN(rc); -+ memset(type, 0, sizeof(*type)); - -- OBD_ALLOC_PTR(type->typ_dt_ops); -- OBD_ALLOC_PTR(type->typ_md_ops); -- OBD_ALLOC(type->typ_name, strlen(name) + 1); -+ OBD_ALLOC_PTR(type->typ_dt_ops); -+ OBD_ALLOC_PTR(type->typ_md_ops); -+ OBD_ALLOC(type->typ_name, strlen(name) + 1); - - if (type->typ_dt_ops == NULL || - type->typ_md_ops == NULL || -@@ -242,6 +243,8 @@ int class_register_type(struct obd_ops *dt_ops, struct md_ops *md_ops, - if (type->typ_dt_ops != NULL) - OBD_FREE_PTR(type->typ_dt_ops); - #ifdef LPROCFS -+ if (type->typ_procsym != NULL) -+ lprocfs_remove(&type->typ_procsym); - #ifndef HAVE_ONLY_PROCFS_SEQ - lprocfs_try_remove_proc_entry(type->typ_name, proc_lustre_root); - #else --- -1.8.5.3 - diff --git a/sys-cluster/lustre/files/0003-LU-3319-procfs-move-mgs-proc-handling-to-seq_files.patch b/sys-cluster/lustre/files/0004-LU-3319-procfs-move-mgs-proc-handling-to-seq_files.patch index 38785b257..c7d415a61 100644 --- a/sys-cluster/lustre/files/0003-LU-3319-procfs-move-mgs-proc-handling-to-seq_files.patch +++ b/sys-cluster/lustre/files/0004-LU-3319-procfs-move-mgs-proc-handling-to-seq_files.patch @@ -1,7 +1,7 @@ -From 44eb91a37b43a71a0d531359c9da082b6e1ec454 Mon Sep 17 00:00:00 2001 +From 00e2e7c431e38433b919735890481e4bb5707cd4 Mon Sep 17 00:00:00 2001 From: James Simmons <uja.ornl@gmail.com> -Date: Fri, 3 Jan 2014 09:58:53 -0500 -Subject: [PATCH 03/12] LU-3319 procfs: move mgs proc handling to seq_files +Date: Tue, 4 Mar 2014 10:45:30 -0500 +Subject: [PATCH 4/9] LU-3319 procfs: move mgs proc handling to seq_files With 3.10 linux kernel and above proc handling now only uses struct seq_files. This patch migrates the mgs @@ -271,22 +271,22 @@ index ffa2d0d..f0ea956 100644 -} #endif diff --git a/lustre/mgs/mgs_handler.c b/lustre/mgs/mgs_handler.c -index 5be9040..4bb842c 100644 +index 85b219c..a9b0857 100644 --- a/lustre/mgs/mgs_handler.c +++ b/lustre/mgs/mgs_handler.c -@@ -1434,12 +1434,9 @@ static struct obd_ops mgs_obd_device_ops = { +@@ -1513,12 +1513,9 @@ static struct obd_ops mgs_obd_device_ops = { static int __init mgs_init(void) { - struct lprocfs_static_vars lvars; - - lprocfs_mgs_init_vars(&lvars); - return class_register_type(&mgs_obd_device_ops, NULL, NULL, + return class_register_type(&mgs_obd_device_ops, NULL, true, NULL, #ifndef HAVE_ONLY_PROCFS_SEQ -- lvars.module_vars, -+ NULL, +- lvars.module_vars, ++ NULL, #endif - LUSTRE_MGS_NAME, &mgs_device_type); + LUSTRE_MGS_NAME, &mgs_device_type); } diff --git a/lustre/mgs/mgs_internal.h b/lustre/mgs/mgs_internal.h index ca2846e..d3baacd 100644 @@ -327,7 +327,7 @@ index ca2846e..d3baacd 100644 /* mgs/lproc_mgs.c */ diff --git a/lustre/mgs/mgs_nids.c b/lustre/mgs/mgs_nids.c -index a2bae59..3248387 100644 +index 24c9d22..a4d8800 100644 --- a/lustre/mgs/mgs_nids.c +++ b/lustre/mgs/mgs_nids.c @@ -838,15 +838,14 @@ int lprocfs_rd_ir_state(struct seq_file *seq, void *data) @@ -352,5 +352,5 @@ index a2bae59..3248387 100644 return lprocfs_wr_uint(file, buffer, count, &ir_timeout); } -- -1.8.5.3 +1.9.1 diff --git a/sys-cluster/lustre/files/0005-LU-3319-procfs-move-osp-proc-handling-to-seq_files.patch b/sys-cluster/lustre/files/0005-LU-3319-procfs-move-osp-proc-handling-to-seq_files.patch index 2d5a97490..e43904195 100644 --- a/sys-cluster/lustre/files/0005-LU-3319-procfs-move-osp-proc-handling-to-seq_files.patch +++ b/sys-cluster/lustre/files/0005-LU-3319-procfs-move-osp-proc-handling-to-seq_files.patch @@ -1,7 +1,7 @@ -From e9786df9c5618c2cff7d81088548fefee874468a Mon Sep 17 00:00:00 2001 +From ab793e8472447314f6428025175f80afc26339ac Mon Sep 17 00:00:00 2001 From: James Simmons <uja.ornl@gmail.com> -Date: Sun, 9 Feb 2014 17:10:18 -0500 -Subject: [PATCH 05/12] LU-3319 procfs: move osp proc handling to seq_files +Date: Wed, 26 Mar 2014 19:59:18 -0400 +Subject: [PATCH 5/9] LU-3319 procfs: move osp proc handling to seq_files With 3.10 linux kernel and above proc handling now only uses struct seq_files. This patch migrates the osp @@ -10,17 +10,17 @@ layer proc entries over to using seq_files. Signed-off-by: James Simmons <uja.ornl@gmail.com> Change-Id: Id8f77d72fd35755f1b7b1c17fcf27e0731bd5ac1 --- - lustre/osp/lproc_osp.c | 373 ++++++++++++++++++++++++---------------------- - lustre/osp/lwp_dev.c | 18 +-- - lustre/osp/osp_dev.c | 48 +++--- + lustre/osp/lproc_osp.c | 402 +++++++++++++++++++++++++--------------------- + lustre/osp/lwp_dev.c | 19 +-- + lustre/osp/osp_dev.c | 32 ++-- lustre/osp/osp_internal.h | 2 - - 4 files changed, 222 insertions(+), 219 deletions(-) + 4 files changed, 228 insertions(+), 227 deletions(-) diff --git a/lustre/osp/lproc_osp.c b/lustre/osp/lproc_osp.c -index 75ebeb1..1ec40fc 100644 +index 75ebeb1..1271b7c 100644 --- a/lustre/osp/lproc_osp.c +++ b/lustre/osp/lproc_osp.c -@@ -45,24 +45,23 @@ +@@ -45,24 +45,24 @@ #include "osp_internal.h" #ifdef LPROCFS @@ -48,12 +48,13 @@ index 75ebeb1..1ec40fc 100644 { - struct obd_device *dev = data; - int val, rc; -+ struct obd_device *dev = ((struct seq_file *)file->private_data)->private; ++ struct seq_file *m = file->private_data; ++ struct obd_device *dev = m->private; + int val, rc; rc = lprocfs_write_helper(buffer, count, &val); if (rc) -@@ -81,67 +80,60 @@ static int osp_wr_active(struct file *file, const char *buffer, +@@ -81,67 +81,61 @@ static int osp_wr_active(struct file *file, const char *buffer, LPROCFS_CLIMP_EXIT(dev); return count; } @@ -137,11 +138,12 @@ index 75ebeb1..1ec40fc 100644 + size_t count, loff_t *off) { - struct obd_device *dev = data; -+ struct obd_device *dev = ((struct seq_file *)file->private_data)->private; ++ struct seq_file *m = file->private_data; ++ struct obd_device *dev = m->private; struct osp_device *osp = lu2osp_dev(dev->obd_lu_dev); int val, rc; -@@ -158,25 +150,24 @@ static int osp_wr_max_rpcs_in_flight(struct file *file, const char *buffer, +@@ -158,25 +152,25 @@ static int osp_wr_max_rpcs_in_flight(struct file *file, const char *buffer, osp->opd_syn_max_rpc_in_flight = val; return count; } @@ -171,11 +173,12 @@ index 75ebeb1..1ec40fc 100644 + size_t count, loff_t *off) { - struct obd_device *dev = data; -+ struct obd_device *dev = ((struct seq_file *)file->private_data)->private; ++ struct seq_file *m = file->private_data; ++ struct obd_device *dev = m->private; struct osp_device *osp = lu2osp_dev(dev->obd_lu_dev); int val, rc; -@@ -194,23 +185,24 @@ static int osp_wr_max_rpcs_in_prog(struct file *file, const char *buffer, +@@ -194,23 +188,25 @@ static int osp_wr_max_rpcs_in_prog(struct file *file, const char *buffer, return count; } @@ -203,11 +206,12 @@ index 75ebeb1..1ec40fc 100644 + size_t count, loff_t *off) { - struct obd_device *obd = data; -+ struct obd_device *obd = ((struct seq_file *)file->private_data)->private; ++ struct seq_file *m = file->private_data; ++ struct obd_device *obd = m->private; struct osp_device *osp = lu2osp_dev(obd->obd_lu_dev); int val, rc, i; -@@ -242,23 +234,24 @@ static int osp_wr_create_count(struct file *file, const char *buffer, +@@ -242,23 +238,25 @@ static int osp_wr_create_count(struct file *file, const char *buffer, return count; } @@ -235,11 +239,12 @@ index 75ebeb1..1ec40fc 100644 + size_t count, loff_t *off) { - struct obd_device *obd = data; -+ struct obd_device *obd = ((struct seq_file *)file->private_data)->private; ++ struct seq_file *m = file->private_data; ++ struct obd_device *obd = m->private; struct osp_device *osp = lu2osp_dev(obd->obd_lu_dev); int val, rc; -@@ -281,89 +274,85 @@ static int osp_wr_max_create_count(struct file *file, const char *buffer, +@@ -281,89 +279,86 @@ static int osp_wr_max_create_count(struct file *file, const char *buffer, return count; } @@ -353,11 +358,12 @@ index 75ebeb1..1ec40fc 100644 + size_t count, loff_t *off) { - struct obd_device *dev = data; -+ struct obd_device *dev = ((struct seq_file *)file->private_data)->private; ++ struct seq_file *m = file->private_data; ++ struct obd_device *dev = m->private; struct osp_device *osp = lu2osp_dev(dev->obd_lu_dev); int val, rc; -@@ -381,25 +370,23 @@ static int osp_wr_maxage(struct file *file, const char *buffer, +@@ -381,25 +376,23 @@ static int osp_wr_maxage(struct file *file, const char *buffer, return count; } @@ -390,7 +396,7 @@ index 75ebeb1..1ec40fc 100644 struct osp_device *osp = lu2osp_dev(dev->obd_lu_dev); if (osp == NULL) -@@ -411,87 +398,126 @@ static int osp_rd_destroys_in_flight(char *page, char **start, off_t off, +@@ -411,126 +404,161 @@ static int osp_rd_destroys_in_flight(char *page, char **start, off_t off, * - sync changes are zero - no llog records * - sync in progress are zero - no RPCs in flight */ @@ -566,31 +572,49 @@ index 75ebeb1..1ec40fc 100644 { struct obd_device *obd = osp->opd_obd; - struct proc_dir_entry *osc_proc_dir; -+ struct proc_dir_entry *symlink = NULL; ++ struct proc_dir_entry *osc_proc_dir = NULL; ++ struct obd_type *type; int rc; - obd->obd_proc_entry = lprocfs_register(obd->obd_name, -+ obd->obd_proc_entry = lprocfs_seq_register(obd->obd_name, - obd->obd_type->typ_procroot, - lprocfs_osp_osd_vars, - &osp->opd_dt_dev); -@@ -502,34 +528,29 @@ void osp_lprocfs_init(struct osp_device *osp) +- obd->obd_type->typ_procroot, +- lprocfs_osp_osd_vars, +- &osp->opd_dt_dev); +- if (IS_ERR(obd->obd_proc_entry)) { +- CERROR("%s: can't register in lprocfs: %ld\n", +- obd->obd_name, PTR_ERR(obd->obd_proc_entry)); +- obd->obd_proc_entry = NULL; ++ obd->obd_vars = lprocfs_osp_obd_vars; ++ if (lprocfs_seq_obd_setup(obd) != 0) return; - } +- } - rc = lprocfs_add_vars(obd->obd_proc_entry, lprocfs_osp_obd_vars, obd); -+ rc = lprocfs_seq_add_vars(obd->obd_proc_entry, lprocfs_osp_obd_vars, obd); ++ rc = lprocfs_seq_add_vars(obd->obd_proc_entry, lprocfs_osp_osd_vars, ++ &osp->opd_dt_dev); if (rc) { - CERROR("%s: can't register in lprocfs: %ld\n", - obd->obd_name, PTR_ERR(obd->obd_proc_entry)); +- CERROR("%s: can't register in lprocfs: %ld\n", +- obd->obd_name, PTR_ERR(obd->obd_proc_entry)); ++ CERROR("%s: can't register in lprocfs, rc %d\n", ++ obd->obd_name, rc); return; } -+ obd->obd_vars = lprocfs_osp_obd_vars; ptlrpc_lprocfs_register_obd(obd); -+ if (osp->opd_connect_mdt || obd->obd_type->typ_procsym == NULL || -+ !strstr(obd->obd_name, "osc")) ++ if (osp->opd_connect_mdt || !strstr(obd->obd_name, "osc")) ++ return; ++ ++ /* If the real OSC is present which is the case for setups ++ * with both server and clients on the same node then use ++ * the OSC's proc root */ ++ type = class_search_type(LUSTRE_OSC_NAME); ++ if (type != NULL && type->typ_procroot != NULL) ++ osc_proc_dir = type->typ_procroot; ++ else ++ osc_proc_dir = obd->obd_type->typ_procsym; ++ ++ if (osc_proc_dir == NULL) + return; + /* for compatibility we link old procfs's OSC entries to osp ones */ @@ -612,31 +636,28 @@ index 75ebeb1..1ec40fc 100644 - OBD_FREE(name, strlen(obd->obd_name) + 1); - osp->opd_symlink = symlink; - } -+ symlink = lprocfs_add_symlink(obd->obd_name, obd->obd_type->typ_procsym, -+ "../osp/%s", obd->obd_name); -+ if (symlink == NULL) { +- } ++ osp->opd_symlink = lprocfs_add_symlink(obd->obd_name, osc_proc_dir, ++ "../osp/%s", obd->obd_name); ++ if (osp->opd_symlink == NULL) + CERROR("could not register OSC symlink for " + "/proc/fs/lustre/osp/%s.", obd->obd_name); -+ lprocfs_remove(&obd->obd_type->typ_procsym); -+ } else { -+ osp->opd_symlink = symlink; - } } + #endif /* LPROCFS */ diff --git a/lustre/osp/lwp_dev.c b/lustre/osp/lwp_dev.c -index dc4f978..b6e84e1 100644 +index a73973a..c115ee6 100644 --- a/lustre/osp/lwp_dev.c +++ b/lustre/osp/lwp_dev.c -@@ -184,25 +184,13 @@ const struct lu_device_operations lwp_lu_ops = { +@@ -184,25 +184,9 @@ const struct lu_device_operations lwp_lu_ops = { .ldo_process_config = lwp_process_config, }; -static struct lprocfs_vars lprocfs_lwp_module_vars[] = { - { "num_refs", lprocfs_rd_numrefs, 0, 0 }, -+static struct lprocfs_seq_vars lprocfs_lwp_obd_vars[] = { - { 0 } - }; - +- { 0 } +-}; +- -static struct lprocfs_vars lprocfs_lwp_obd_vars[] = { - { 0 } -}; @@ -654,19 +675,18 @@ index dc4f978..b6e84e1 100644 int rc; ENTRY; -@@ -231,8 +219,8 @@ int lwp_init0(const struct lu_env *env, struct lwp_device *lwp, +@@ -231,8 +215,7 @@ int lwp_init0(const struct lu_env *env, struct lwp_device *lwp, RETURN(rc); } - lprocfs_lwp_init_vars(&lvars); - if (lprocfs_obd_setup(lwp->lpd_obd, lvars.obd_vars) == 0) -+ lwp->lpd_obd->obd_vars = lprocfs_lwp_obd_vars; + if (lprocfs_seq_obd_setup(lwp->lpd_obd) == 0) ptlrpc_lprocfs_register_obd(lwp->lpd_obd); RETURN(0); diff --git a/lustre/osp/osp_dev.c b/lustre/osp/osp_dev.c -index a8d75ea..336b9f0 100644 +index 60bf8ef..b0c68ad 100644 --- a/lustre/osp/osp_dev.c +++ b/lustre/osp/osp_dev.c @@ -366,7 +366,7 @@ static int osp_process_config(const struct lu_env *env, @@ -693,24 +713,13 @@ index a8d75ea..336b9f0 100644 if (rc > 0) rc = 0; if (rc == -ENOSYS) { -@@ -844,6 +842,9 @@ static struct lu_device *osp_device_fini(const struct lu_env *env, - OBD_FREE_PTR(cli->cl_rpc_lock); - cli->cl_rpc_lock = NULL; - } -+ } else { -+ if (m->opd_obd->obd_type->typ_procsym != NULL) -+ lprocfs_remove(&m->opd_obd->obd_type->typ_procsym); - } - - rc = client_obd_cleanup(m->opd_obd); -@@ -1233,33 +1234,26 @@ struct llog_operations osp_mds_ost_orig_logops; +@@ -1238,33 +1236,27 @@ struct llog_operations osp_mds_ost_orig_logops; static int __init osp_mod_init(void) { - struct lprocfs_static_vars lvars; -- cfs_proc_dir_entry_t *osc_proc_dir; + struct obd_type *type; - int rc; -+ struct obd_type *type; + int rc; rc = lu_kmem_init(osp_caches); @@ -718,13 +727,13 @@ index a8d75ea..336b9f0 100644 return rc; - lprocfs_osp_init_vars(&lvars); -- - rc = class_register_type(&osp_obd_device_ops, NULL, NULL, + + rc = class_register_type(&osp_obd_device_ops, NULL, true, NULL, #ifndef HAVE_ONLY_PROCFS_SEQ -- lvars.module_vars, -+ NULL, +- lvars.module_vars, ++ NULL, #endif - LUSTRE_OSP_NAME, &osp_device_type); + LUSTRE_OSP_NAME, &osp_device_type); - - /* create "osc" entry in procfs for compatibility purposes */ if (rc != 0) { @@ -734,36 +743,27 @@ index a8d75ea..336b9f0 100644 - lprocfs_lwp_init_vars(&lvars); - - rc = class_register_type(&lwp_obd_device_ops, NULL, NULL, + rc = class_register_type(&lwp_obd_device_ops, NULL, true, NULL, #ifndef HAVE_ONLY_PROCFS_SEQ -- lvars.module_vars, -+ NULL, +- lvars.module_vars, ++ NULL, #endif - LUSTRE_LWP_NAME, &lwp_device_type); + LUSTRE_LWP_NAME, &lwp_device_type); if (rc != 0) { -@@ -1273,21 +1267,23 @@ static int __init osp_mod_init(void) - osp_mds_ost_orig_logops.lop_add = llog_cat_add_rec; - osp_mds_ost_orig_logops.lop_declare_add = llog_cat_declare_add_rec; - -- osc_proc_dir = lprocfs_srch(proc_lustre_root, "osc"); -- if (osc_proc_dir == NULL) { -- osc_proc_dir = lprocfs_register("osc", proc_lustre_root, NULL, -- NULL); -- if (IS_ERR(osc_proc_dir)) -- CERROR("osp: can't create compat entry \"osc\": %d\n", -- (int) PTR_ERR(osc_proc_dir)); -+ type = class_search_type(LUSTRE_OSC_NAME); -+ if (type) -+ return rc; -+ -+ type = class_search_type(LUSTRE_OSP_NAME); +@@ -1284,18 +1276,18 @@ static int __init osp_mod_init(void) + return rc; + + type = class_search_type(LUSTRE_OSP_NAME); +- type->typ_procsym = lprocfs_register("osc", proc_lustre_root, +- NULL, NULL); +- if (IS_ERR(type->typ_procsym)) + type->typ_procsym = lprocfs_seq_register("osc", proc_lustre_root, + NULL, NULL); + if (IS_ERR(type->typ_procsym)) { -+ CERROR("osp: can't create compat entry \"osc\": %d\n", -+ (int) PTR_ERR(type->typ_procsym)); + CERROR("osp: can't create compat entry \"osc\": %d\n", + (int) PTR_ERR(type->typ_procsym)); + type->typ_procsym = NULL; - } ++ } return rc; } @@ -775,10 +775,10 @@ index a8d75ea..336b9f0 100644 class_unregister_type(LUSTRE_OSP_NAME); lu_kmem_fini(osp_caches); diff --git a/lustre/osp/osp_internal.h b/lustre/osp/osp_internal.h -index 2af16c0..84eca11 100644 +index 1291374..66ad203 100644 --- a/lustre/osp/osp_internal.h +++ b/lustre/osp/osp_internal.h -@@ -526,7 +526,6 @@ int osp_write_last_oid_seq_files(struct lu_env *env, struct osp_device *osp, +@@ -530,7 +530,6 @@ int osp_write_last_oid_seq_files(struct lu_env *env, struct osp_device *osp, int osp_init_pre_fid(struct osp_device *osp); /* lproc_osp.c */ @@ -786,7 +786,7 @@ index 2af16c0..84eca11 100644 void osp_lprocfs_init(struct osp_device *osp); /* osp_sync.c */ -@@ -540,7 +539,6 @@ int osp_sync_fini(struct osp_device *d); +@@ -544,7 +543,6 @@ int osp_sync_fini(struct osp_device *d); void __osp_sync_check_for_work(struct osp_device *d); /* lwp_dev.c */ @@ -795,5 +795,5 @@ index 2af16c0..84eca11 100644 extern struct lu_device_type lwp_device_type; -- -1.8.5.3 +1.9.1 diff --git a/sys-cluster/lustre/files/0006-LU-3319-procfs-move-lod-proc-handling-to-seq_files.patch b/sys-cluster/lustre/files/0006-LU-3319-procfs-move-lod-proc-handling-to-seq_files.patch index 06e3571f0..d9bcc89da 100644 --- a/sys-cluster/lustre/files/0006-LU-3319-procfs-move-lod-proc-handling-to-seq_files.patch +++ b/sys-cluster/lustre/files/0006-LU-3319-procfs-move-lod-proc-handling-to-seq_files.patch @@ -1,7 +1,7 @@ -From 2670599090a754d9fa8c7d952b530bc8fb88d56e Mon Sep 17 00:00:00 2001 +From 1394aacb441c3ba07b24a4b465f2496af8eb3c73 Mon Sep 17 00:00:00 2001 From: James Simmons <uja.ornl@gmail.com> -Date: Sun, 9 Feb 2014 11:08:45 -0500 -Subject: [PATCH 06/12] LU-3319 procfs: move lod proc handling to seq_files +Date: Wed, 26 Mar 2014 19:57:44 -0400 +Subject: [PATCH 6/9] LU-3319 procfs: move lod proc handling to seq_files With 3.10 linux kernel and above proc handling now only uses struct seq_files. This patch migrates the lod @@ -10,14 +10,14 @@ layer proc entries over to using seq_files. Signed-off-by: James Simmons <uja.ornl@gmail.com> Change-Id: Iaa0f617fcd430e91f12afbc0faf6906fd275a7a5 --- - lustre/lod/lod_dev.c | 39 ++++--- + lustre/lod/lod_dev.c | 23 ++-- lustre/lod/lod_internal.h | 1 - lustre/lod/lod_pool.c | 7 +- - lustre/lod/lproc_lod.c | 251 ++++++++++++++++++++++++---------------------- - 4 files changed, 152 insertions(+), 146 deletions(-) + lustre/lod/lproc_lod.c | 267 +++++++++++++++++++++++++--------------------- + 4 files changed, 157 insertions(+), 141 deletions(-) diff --git a/lustre/lod/lod_dev.c b/lustre/lod/lod_dev.c -index a451462..8776aa3 100644 +index a653d6a..1baeb37 100644 --- a/lustre/lod/lod_dev.c +++ b/lustre/lod/lod_dev.c @@ -289,12 +289,10 @@ static int lod_process_config(const struct lu_env *env, @@ -36,70 +36,56 @@ index a451462..8776aa3 100644 if (rc > 0) rc = 0; GOTO(out, rc); -@@ -890,19 +888,16 @@ static struct obd_ops lod_obd_device_ops = { +@@ -891,7 +889,6 @@ static struct obd_ops lod_obd_device_ops = { static int __init lod_mod_init(void) { - struct lprocfs_static_vars lvars = { 0 }; -- cfs_proc_dir_entry_t *lov_proc_dir; -- int rc; -+ struct obd_type *lod, *lov; -+ int rc; + struct obd_type *type; + int rc; - rc = lu_kmem_init(lod_caches); +@@ -899,11 +896,9 @@ static int __init lod_mod_init(void) if (rc) return rc; - lprocfs_lod_init_vars(&lvars); - - rc = class_register_type(&lod_obd_device_ops, NULL, NULL, + rc = class_register_type(&lod_obd_device_ops, NULL, true, NULL, #ifndef HAVE_ONLY_PROCFS_SEQ -- lvars.module_vars, -+ NULL, +- lvars.module_vars, ++ NULL, #endif - LUSTRE_LOD_NAME, &lod_device_type); + LUSTRE_LOD_NAME, &lod_device_type); if (rc) { -@@ -911,23 +906,25 @@ static int __init lod_mod_init(void) - } +@@ -917,18 +912,18 @@ static int __init lod_mod_init(void) + return rc; - /* create "lov" entry in procfs for compatibility purposes */ -- lov_proc_dir = lprocfs_srch(proc_lustre_root, "lov"); -- if (lov_proc_dir == NULL) { -- lov_proc_dir = lprocfs_register("lov", proc_lustre_root, -- NULL, NULL); -- if (IS_ERR(lov_proc_dir)) -+ lod = class_search_type(LUSTRE_LOD_NAME); -+ lov = class_search_type(LUSTRE_LOV_NAME); -+ if (lov == NULL) { -+ lod->typ_procsym = lprocfs_seq_register("lov", proc_lustre_root, -+ NULL, NULL); -+ if (IS_ERR(lod->typ_procsym)) { - CERROR("lod: can't create compat entry \"lov\": %d\n", -- (int)PTR_ERR(lov_proc_dir)); -+ (int)PTR_ERR(lod->typ_procsym)); -+ lod->typ_procsym = NULL; -+ } -+ } else { -+ /* Map lov proc root to lod symlink */ -+ lod->typ_procsym = lov->typ_procroot; - } -- + type = class_search_type(LUSTRE_LOD_NAME); +- type->typ_procsym = lprocfs_register("lov", proc_lustre_root, +- NULL, NULL); +- if (IS_ERR(type->typ_procsym)) ++ type->typ_procsym = lprocfs_seq_register("lov", proc_lustre_root, ++ NULL, NULL); ++ if (IS_ERR(type->typ_procsym)) { + CERROR("lod: can't create compat entry \"lov\": %d\n", + (int)PTR_ERR(type->typ_procsym)); ++ type->typ_procsym = NULL; ++ } return rc; } static void __exit lod_mod_exit(void) { -- - lprocfs_try_remove_proc_entry("lov", proc_lustre_root); - class_unregister_type(LUSTRE_LOD_NAME); lu_kmem_fini(lod_caches); } diff --git a/lustre/lod/lod_internal.h b/lustre/lod/lod_internal.h -index 2a00890..65ba47a 100644 +index c3b1bc3..fc18f3d 100644 --- a/lustre/lod/lod_internal.h +++ b/lustre/lod/lod_internal.h -@@ -431,7 +431,6 @@ int qos_add_tgt(struct lod_device*, struct lod_tgt_desc *); +@@ -432,7 +432,6 @@ int qos_add_tgt(struct lod_device*, struct lod_tgt_desc *); int qos_del_tgt(struct lod_device *, struct lod_tgt_desc *); /* lproc_lod.c */ @@ -133,10 +119,10 @@ index 98b2416..1849e5d 100644 &pool_proc_operations); if (IS_ERR(new_pool->pool_proc_entry)) { diff --git a/lustre/lod/lproc_lod.c b/lustre/lod/lproc_lod.c -index e976063..e420a5e 100644 +index e976063..1598658 100644 --- a/lustre/lod/lproc_lod.c +++ b/lustre/lod/lproc_lod.c -@@ -42,23 +42,22 @@ +@@ -42,23 +42,23 @@ #include <lustre_param.h> #ifdef LPROCFS @@ -163,11 +149,12 @@ index e976063..e420a5e 100644 + 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; ++ struct seq_file *m = file->private_data; ++ struct obd_device *dev = m->private; struct lod_device *lod; __u64 val; int rc; -@@ -73,24 +72,24 @@ static int lod_wr_stripesize(struct file *file, const char *buffer, +@@ -73,24 +73,25 @@ static int lod_wr_stripesize(struct file *file, const char *buffer, lod->lod_desc.ld_default_stripe_size = val; return count; } @@ -196,11 +183,12 @@ index e976063..e420a5e 100644 + 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; ++ struct seq_file *m = file->private_data; ++ struct obd_device *dev = m->private; struct lod_device *lod; __u64 val; int rc; -@@ -104,23 +103,23 @@ static int lod_wr_stripeoffset(struct file *file, const char *buffer, +@@ -104,23 +105,24 @@ static int lod_wr_stripeoffset(struct file *file, const char *buffer, lod->lod_desc.ld_default_stripe_offset = val; return count; } @@ -228,11 +216,12 @@ index e976063..e420a5e 100644 + 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; ++ struct seq_file *m = file->private_data; ++ struct obd_device *dev = m->private; struct lod_device *lod; int val, rc; -@@ -134,24 +133,24 @@ static int lod_wr_stripetype(struct file *file, const char *buffer, +@@ -134,24 +136,25 @@ static int lod_wr_stripetype(struct file *file, const char *buffer, lod->lod_desc.ld_pattern = val; return count; } @@ -261,11 +250,12 @@ index e976063..e420a5e 100644 + 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; ++ struct seq_file *m = file->private_data; ++ struct obd_device *dev = m->private; struct lod_device *lod; int val, rc; -@@ -165,62 +164,57 @@ static int lod_wr_stripecount(struct file *file, const char *buffer, +@@ -165,62 +168,58 @@ static int lod_wr_stripecount(struct file *file, const char *buffer, lod->lod_desc.ld_default_stripe_count = val; return count; } @@ -293,7 +283,7 @@ index e976063..e420a5e 100644 +static int lod_activeobd_seq_show(struct seq_file *m, void *v) { - struct obd_device* dev = (struct obd_device*)data; -+ struct obd_device* dev = m->private; ++ struct obd_device *dev = m->private; struct lod_device *lod; LASSERT(dev != NULL); @@ -344,11 +334,12 @@ index e976063..e420a5e 100644 + 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; ++ struct seq_file *m = file->private_data; ++ struct obd_device *dev = m->private; struct lod_device *lod; int val, rc; -@@ -238,24 +232,24 @@ static int lod_wr_qos_priofree(struct file *file, const char *buffer, +@@ -238,24 +237,25 @@ static int lod_wr_qos_priofree(struct file *file, const char *buffer, lod->lod_qos.lq_reset = 1; return count; } @@ -377,11 +368,12 @@ index e976063..e420a5e 100644 + 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; ++ struct seq_file *m = file->private_data; ++ struct obd_device *dev = m->private; struct lod_device *lod; int val, rc; -@@ -273,23 +267,23 @@ static int lod_wr_qos_thresholdrr(struct file *file, const char *buffer, +@@ -273,23 +273,24 @@ static int lod_wr_qos_thresholdrr(struct file *file, const char *buffer, lod->lod_qos.lq_dirty = 1; return count; } @@ -409,11 +401,12 @@ index e976063..e420a5e 100644 + 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; ++ struct seq_file *m = file->private_data; ++ struct obd_device *dev = m->private; struct lustre_cfg_bufs bufs; struct lod_device *lod; struct lu_device *next; -@@ -327,6 +321,7 @@ static int lod_wr_qos_maxage(struct file *file, const char *buffer, +@@ -327,6 +328,7 @@ static int lod_wr_qos_maxage(struct file *file, const char *buffer, return count; } @@ -421,7 +414,7 @@ index e976063..e420a5e 100644 static void *lod_osts_seq_start(struct seq_file *p, loff_t *pos) { -@@ -414,56 +409,63 @@ static const struct seq_operations lod_osts_sops = { +@@ -414,56 +416,63 @@ static const struct seq_operations lod_osts_sops = { static int lod_osts_seq_open(struct inode *inode, struct file *file) { @@ -452,6 +445,16 @@ index e976063..e420a5e 100644 - { "qos_prio_free",lod_rd_qos_priofree, lod_wr_qos_priofree, 0 }, - { "qos_threshold_rr", lod_rd_qos_thresholdrr, lod_wr_qos_thresholdrr, 0 }, - { "qos_maxage", lod_rd_qos_maxage, lod_wr_qos_maxage, 0 }, +- { 0 } +-}; +- +-static struct lprocfs_vars lprocfs_lod_osd_vars[] = { +- { "blocksize", lprocfs_dt_rd_blksize, 0, 0 }, +- { "kbytestotal", lprocfs_dt_rd_kbytestotal, 0, 0 }, +- { "kbytesfree", lprocfs_dt_rd_kbytesfree, 0, 0 }, +- { "kbytesavail", lprocfs_dt_rd_kbytesavail, 0, 0 }, +- { "filestotal", lprocfs_dt_rd_filestotal, 0, 0 }, +- { "filesfree", lprocfs_dt_rd_filesfree, 0, 0 }, +LPROC_SEQ_FOPS_RO_TYPE(lod, uuid); + +LPROC_SEQ_FOPS_RO_TYPE(lod, dt_blksize); @@ -487,13 +490,8 @@ index e976063..e420a5e 100644 { 0 } }; --static struct lprocfs_vars lprocfs_lod_osd_vars[] = { -- { "blocksize", lprocfs_dt_rd_blksize, 0, 0 }, -- { "kbytestotal", lprocfs_dt_rd_kbytestotal, 0, 0 }, -- { "kbytesfree", lprocfs_dt_rd_kbytesfree, 0, 0 }, -- { "kbytesavail", lprocfs_dt_rd_kbytesavail, 0, 0 }, -- { "filestotal", lprocfs_dt_rd_filestotal, 0, 0 }, -- { "filesfree", lprocfs_dt_rd_filesfree, 0, 0 }, +-static struct lprocfs_vars lprocfs_lod_module_vars[] = { +- { "num_refs", lprocfs_rd_numrefs, 0, 0 }, +static struct lprocfs_seq_vars lprocfs_lod_osd_vars[] = { + { "blocksize", &lod_dt_blksize_fops }, + { "kbytestotal", &lod_dt_kbytestotal_fops }, @@ -504,11 +502,6 @@ index e976063..e420a5e 100644 { 0 } }; --static struct lprocfs_vars lprocfs_lod_module_vars[] = { -- { "num_refs", lprocfs_rd_numrefs, 0, 0 }, -- { 0 } --}; -- -void lprocfs_lod_init_vars(struct lprocfs_static_vars *lvars) -{ - lvars->module_vars = lprocfs_lod_module_vars; @@ -518,13 +511,18 @@ index e976063..e420a5e 100644 static const struct file_operations lod_proc_target_fops = { .owner = THIS_MODULE, .open = lod_osts_seq_open, -@@ -475,20 +477,18 @@ static const struct file_operations lod_proc_target_fops = { +@@ -474,21 +483,21 @@ static const struct file_operations lod_proc_target_fops = { + int lod_procfs_init(struct lod_device *lod) { - struct obd_device *obd = lod2obd(lod); +- struct obd_device *obd = lod2obd(lod); - struct lprocfs_static_vars lvars; - cfs_proc_dir_entry_t *lov_proc_dir; - int rc; +- int rc; ++ struct obd_device *obd = lod2obd(lod); ++ struct proc_dir_entry *lov_proc_dir = NULL; ++ struct obd_type *type; ++ int rc; - lprocfs_lod_init_vars(&lvars); - rc = lprocfs_obd_setup(obd, lvars.obd_vars); @@ -543,7 +541,7 @@ index e976063..e420a5e 100644 if (rc) { CERROR("%s: cannot setup procfs entry: %d\n", obd->obd_name, rc); -@@ -503,9 +503,9 @@ int lod_procfs_init(struct lod_device *lod) +@@ -503,9 +512,9 @@ int lod_procfs_init(struct lod_device *lod) GOTO(out, rc); } @@ -556,42 +554,38 @@ index e976063..e420a5e 100644 if (IS_ERR(lod->lod_pool_proc_entry)) { rc = PTR_ERR(lod->lod_pool_proc_entry); lod->lod_pool_proc_entry = NULL; -@@ -514,14 +514,18 @@ int lod_procfs_init(struct lod_device *lod) +@@ -514,14 +523,24 @@ int lod_procfs_init(struct lod_device *lod) GOTO(out, rc); } - /* for compatibility we link old procfs's OSC entries to osp ones */ - lov_proc_dir = lprocfs_srch(proc_lustre_root, "lov"); - if (lov_proc_dir != NULL && strstr(obd->obd_name, "lov") != NULL) -+ /* for compatibility we link old procfs's LOV entries to lod ones */ -+ if (obd->obd_type->typ_procsym != NULL) { - lod->lod_symlink = lprocfs_add_symlink(obd->obd_name, +- lod->lod_symlink = lprocfs_add_symlink(obd->obd_name, - lov_proc_dir, - "../lod/%s", - obd->obd_name); -- -+ obd->obd_type->typ_procsym, -+ "../lod/%s", -+ obd->obd_name); -+ if (lod->lod_symlink == NULL) { -+ CERROR("could not register LOV symlink for " -+ "/proc/fs/lustre/lod/%s.", obd->obd_name); -+ lprocfs_remove(&obd->obd_type->typ_procsym); -+ } -+ } ++ /* If the real LOV is present which is the case for setups ++ * with both server and clients on the same node then use ++ * the LOV's proc root */ ++ type = class_search_type(LUSTRE_LOV_NAME); ++ if (type != NULL && type->typ_procroot != NULL) ++ lov_proc_dir = type->typ_procroot; ++ else ++ lov_proc_dir = obd->obd_type->typ_procsym; ++ ++ if (lov_proc_dir == NULL) ++ RETURN(0); + ++ /* for compatibility we link old procfs's LOV entries to lod ones */ ++ lod->lod_symlink = lprocfs_add_symlink(obd->obd_name, lov_proc_dir, ++ "../lod/%s", obd->obd_name); ++ if (lod->lod_symlink == NULL) ++ CERROR("could not register LOV symlink for " ++ "/proc/fs/lustre/lod/%s.", obd->obd_name); RETURN(0); out: -@@ -542,6 +546,9 @@ void lod_procfs_fini(struct lod_device *lod) - lod->lod_pool_proc_entry = NULL; - } - -+ if (obd->obd_type->typ_procsym != NULL) -+ lprocfs_remove(&obd->obd_type->typ_procsym); -+ - lprocfs_obd_cleanup(obd); - } - -- -1.8.5.3 +1.9.1 diff --git a/sys-cluster/lustre/files/0008-LU-3319-procfs-move-mdt-mds-proc-handling-to-seq_fil.patch b/sys-cluster/lustre/files/0007-LU-3319-procfs-move-mdt-mds-proc-handling-to-seq_fil.patch index c271eb742..5c1c9cd8e 100644 --- a/sys-cluster/lustre/files/0008-LU-3319-procfs-move-mdt-mds-proc-handling-to-seq_fil.patch +++ b/sys-cluster/lustre/files/0007-LU-3319-procfs-move-mdt-mds-proc-handling-to-seq_fil.patch @@ -1,7 +1,7 @@ -From 9ab620dbc6aae86b9d39d97ba50912dc93b6e4e2 Mon Sep 17 00:00:00 2001 +From 039e3e44e07b59923d94bea976173d9e3cbd0ba9 Mon Sep 17 00:00:00 2001 From: James Simmons <uja.ornl@gmail.com> -Date: Sun, 9 Feb 2014 11:04:31 -0500 -Subject: [PATCH 08/12] LU-3319 procfs: move mdt/mds proc handling to seq_files +Date: Tue, 25 Mar 2014 11:10:33 -0400 +Subject: [PATCH 7/9] LU-3319 procfs: move mdt/mds proc handling to seq_files With 3.10 linux kernel and above proc handling now only uses struct seq_files. This patch migrates the mdt/mds @@ -10,21 +10,21 @@ layer proc entries over to using seq_files. Signed-off-by: James Simmons <uja.ornl@gmail.com> Change-Id: Icbafdcd2c2fe3959a51dda3f9c715b0ff8d95742 --- - lustre/mdt/mdt_coordinator.c | 259 +++++++-------- + lustre/mdt/mdt_coordinator.c | 269 +++++++--------- lustre/mdt/mdt_handler.c | 16 +- lustre/mdt/mdt_hsm_cdt_actions.c | 5 +- lustre/mdt/mdt_hsm_cdt_agent.c | 5 +- lustre/mdt/mdt_hsm_cdt_requests.c | 5 +- lustre/mdt/mdt_internal.h | 14 +- - lustre/mdt/mdt_lproc.c | 639 ++++++++++++++++++-------------------- + lustre/mdt/mdt_lproc.c | 659 +++++++++++++++++++------------------- lustre/mdt/mdt_mds.c | 12 +- - 8 files changed, 442 insertions(+), 513 deletions(-) + 8 files changed, 469 insertions(+), 516 deletions(-) diff --git a/lustre/mdt/mdt_coordinator.c b/lustre/mdt/mdt_coordinator.c -index 037bcbd..9bbcbd4 100644 +index a9ee560..062f6cc 100644 --- a/lustre/mdt/mdt_coordinator.c +++ b/lustre/mdt/mdt_coordinator.c -@@ -46,7 +46,7 @@ +@@ -45,7 +45,7 @@ #include <lustre_log.h> #include "mdt_internal.h" @@ -33,7 +33,7 @@ index 037bcbd..9bbcbd4 100644 /** * get obj and HSM attributes on a fid -@@ -393,7 +393,7 @@ int hsm_cdt_procfs_init(struct mdt_device *mdt) +@@ -392,7 +392,7 @@ int hsm_cdt_procfs_init(struct mdt_device *mdt) ENTRY; /* init /proc entries, failure is not critical */ @@ -42,7 +42,7 @@ index 037bcbd..9bbcbd4 100644 mdt2obd_dev(mdt)->obd_proc_entry, lprocfs_mdt_hsm_vars, mdt); if (IS_ERR(cdt->cdt_proc_dir)) { -@@ -425,7 +425,7 @@ void hsm_cdt_procfs_fini(struct mdt_device *mdt) +@@ -424,7 +424,7 @@ void hsm_cdt_procfs_fini(struct mdt_device *mdt) * \param none * \retval var vector */ @@ -51,7 +51,7 @@ index 037bcbd..9bbcbd4 100644 { return lprocfs_mdt_hsm_vars; } -@@ -1786,22 +1786,17 @@ static __u64 hsm_policy_str2bit(const char *name) +@@ -1785,22 +1785,17 @@ static __u64 hsm_policy_str2bit(const char *name) * \param hexa [IN] print mask before bit names * \param buffer [OUT] string * \param count [IN] size of buffer @@ -80,7 +80,7 @@ index 037bcbd..9bbcbd4 100644 for (i = 0; i < CDT_POLICY_SHIFT_COUNT; i++) { bit = (1ULL << i); -@@ -1810,48 +1805,34 @@ static int hsm_policy_bit2str(const __u64 mask, const bool hexa, char *buffer, +@@ -1809,48 +1804,37 @@ static int hsm_policy_bit2str(const __u64 mask, const bool hexa, char *buffer, break; } if (bit & mask) @@ -95,10 +95,12 @@ index 037bcbd..9bbcbd4 100644 - count -= sz; + seq_printf(m, "%s ", hsm_policy_names[j].name); } -- /* remove last ' ' */ + /* remove last ' ' */ - *ptr = '\0'; - ptr--; - RETURN(ptr - buffer); ++ m->count--; ++ seq_putc(m, '\0'); } /* methods to read/write HSM policy flags */ @@ -140,7 +142,7 @@ index 037bcbd..9bbcbd4 100644 int rc; ENTRY; -@@ -1884,18 +1865,10 @@ static int lprocfs_wr_hsm_policy(struct file *file, const char *buffer, +@@ -1883,18 +1867,10 @@ static int lprocfs_wr_hsm_policy(struct file *file, const char *buffer, policy = hsm_policy_str2bit(token); if (policy == 0) { @@ -156,13 +158,13 @@ index 037bcbd..9bbcbd4 100644 - "supported policies are: %s\n", mdt_obd_name(mdt), - token, msg); - OBD_FREE(msg, sz); -+ "supported policies are: \n", mdt_obd_name(mdt), -+ token); ++ "supported policies are:\n", mdt_obd_name(mdt), ++ token); + hsm_policy_bit2str(m, 0, false); GOTO(out, rc = -EINVAL); } switch (sign) { -@@ -1934,25 +1907,24 @@ out: +@@ -1933,25 +1909,25 @@ out: OBD_FREE(buf, count + 1); RETURN(rc); } @@ -193,11 +195,12 @@ index 037bcbd..9bbcbd4 100644 \ { \ - struct mdt_device *mdt = data; \ -+ struct mdt_device *mdt = ((struct seq_file *)file->private_data)->private;\ ++ struct seq_file *m = file->private_data; \ ++ struct mdt_device *mdt = m->private; \ struct coordinator *cdt = &mdt->mdt_coordinator; \ int val; \ int rc; \ -@@ -1966,7 +1938,7 @@ static int lprocfs_wr_hsm_##VAR(struct file *file, const char *buffer, \ +@@ -1965,7 +1941,7 @@ static int lprocfs_wr_hsm_##VAR(struct file *file, const char *buffer, \ RETURN(count); \ } \ RETURN(-EINVAL); \ @@ -206,7 +209,7 @@ index 037bcbd..9bbcbd4 100644 GENERATE_PROC_METHOD(cdt_loop_period) GENERATE_PROC_METHOD(cdt_grace_delay) -@@ -1984,10 +1956,11 @@ GENERATE_PROC_METHOD(cdt_default_archive_id) +@@ -1983,10 +1959,12 @@ GENERATE_PROC_METHOD(cdt_default_archive_id) #define CDT_PURGE_CMD "purge" #define CDT_HELP_CMD "help" @@ -217,11 +220,12 @@ index 037bcbd..9bbcbd4 100644 + size_t count, loff_t *off) { - struct obd_device *obd = data; -+ struct obd_device *obd = ((struct seq_file *)file->private_data)->private; ++ struct seq_file *m = file->private_data; ++ struct obd_device *obd = m->private; struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev); struct coordinator *cdt = &(mdt->mdt_coordinator); int rc, usage = 0; -@@ -2041,83 +2014,71 @@ int lprocfs_wr_hsm_cdt_control(struct file *file, const char *buffer, +@@ -2040,83 +2018,71 @@ int lprocfs_wr_hsm_cdt_control(struct file *file, const char *buffer, RETURN(count); } @@ -327,7 +331,7 @@ index 037bcbd..9bbcbd4 100644 } static inline enum hsm_copytool_action -@@ -2137,9 +2098,9 @@ hsm_copytool_name2action(const char *name) +@@ -2136,9 +2102,9 @@ hsm_copytool_name2action(const char *name) return -1; } @@ -340,7 +344,7 @@ index 037bcbd..9bbcbd4 100644 { char *buf, *pos, *name; size_t buf_size; -@@ -2183,69 +2144,73 @@ out: +@@ -2182,69 +2148,76 @@ out: RETURN(rc); } @@ -352,7 +356,8 @@ index 037bcbd..9bbcbd4 100644 + size_t count, loff_t *off) { - struct mdt_device *mdt = data; -+ struct mdt_device *mdt = ((struct seq_file *)file->private_data)->private; ++ struct seq_file *m = file->private_data; ++ struct mdt_device *mdt = m->private; struct coordinator *cdt = &mdt->mdt_coordinator; - return lprocfs_wr_hsm_request_mask(file, buf, count, @@ -368,8 +373,10 @@ index 037bcbd..9bbcbd4 100644 + size_t count, loff_t *off) { - struct mdt_device *mdt = data; -+ struct mdt_device *mdt = ((struct seq_file *)file->private_data)->private; - struct coordinator *cdt = &mdt->mdt_coordinator; +- struct coordinator *cdt = &mdt->mdt_coordinator; ++ struct seq_file *m = file->private_data; ++ struct mdt_device *mdt = m->private; ++ struct coordinator *cdt = &mdt->mdt_coordinator; - return lprocfs_wr_hsm_request_mask(file, buf, count, + return mdt_write_hsm_request_mask(file, buf, count, @@ -384,8 +391,10 @@ index 037bcbd..9bbcbd4 100644 + size_t count, loff_t *off) { - struct mdt_device *mdt = data; -+ struct mdt_device *mdt = ((struct seq_file *)file->private_data)->private; - struct coordinator *cdt = &mdt->mdt_coordinator; +- struct coordinator *cdt = &mdt->mdt_coordinator; ++ struct seq_file *m = file->private_data; ++ struct mdt_device *mdt = m->private; ++ struct coordinator *cdt = &mdt->mdt_coordinator; - return lprocfs_wr_hsm_request_mask(file, buf, count, + return mdt_write_hsm_request_mask(file, buf, count, @@ -461,10 +470,10 @@ index 037bcbd..9bbcbd4 100644 { 0 } }; diff --git a/lustre/mdt/mdt_handler.c b/lustre/mdt/mdt_handler.c -index 17b7605..2b08be9 100644 +index 69b1c30..8b4634f 100644 --- a/lustre/mdt/mdt_handler.c +++ b/lustre/mdt/mdt_handler.c -@@ -4584,7 +4584,6 @@ static int mdt_process_config(const struct lu_env *env, +@@ -4644,7 +4644,6 @@ static int mdt_process_config(const struct lu_env *env, switch (cfg->lcfg_command) { case LCFG_PARAM: { @@ -472,7 +481,7 @@ index 17b7605..2b08be9 100644 struct obd_device *obd = d->ld_obd; /* For interoperability */ -@@ -4619,14 +4618,13 @@ static int mdt_process_config(const struct lu_env *env, +@@ -4679,14 +4678,13 @@ static int mdt_process_config(const struct lu_env *env, } } @@ -492,7 +501,7 @@ index 17b7605..2b08be9 100644 if (rc > 0 || rc == -ENOSYS) /* we don't understand; pass it on */ rc = next->ld_ops->ldo_process_config(env, next, -@@ -5825,7 +5823,6 @@ static struct lu_device_type mdt_device_type = { +@@ -5885,7 +5883,6 @@ static struct lu_device_type mdt_device_type = { static int __init mdt_mod_init(void) { @@ -500,17 +509,17 @@ index 17b7605..2b08be9 100644 int rc; CLASSERT(sizeof("0x0123456789ABCDEF:0x01234567:0x01234567") == -@@ -5840,10 +5837,9 @@ static int __init mdt_mod_init(void) +@@ -5900,10 +5897,9 @@ static int __init mdt_mod_init(void) if (rc) GOTO(lu_fini, rc); - lprocfs_mdt_init_vars(&lvars); - rc = class_register_type(&mdt_obd_device_ops, NULL, NULL, + rc = class_register_type(&mdt_obd_device_ops, NULL, true, NULL, #ifndef HAVE_ONLY_PROCFS_SEQ -- lvars.module_vars, -+ NULL, +- lvars.module_vars, ++ NULL, #endif - LUSTRE_MDT_NAME, &mdt_device_type); + LUSTRE_MDT_NAME, &mdt_device_type); if (rc) diff --git a/lustre/mdt/mdt_hsm_cdt_actions.c b/lustre/mdt/mdt_hsm_cdt_actions.c index da7f5a9..49c6b8b 100644 @@ -578,10 +587,10 @@ index 1300861..3125dcc 100644 RETURN(rc); } diff --git a/lustre/mdt/mdt_internal.h b/lustre/mdt/mdt_internal.h -index c3d4f7f..7b0381a 100644 +index 7970b86..8fb96c8 100644 --- a/lustre/mdt/mdt_internal.h +++ b/lustre/mdt/mdt_internal.h -@@ -787,9 +787,6 @@ void mdt_thread_info_init(struct ptlrpc_request *req, +@@ -785,9 +785,6 @@ void mdt_thread_info_init(struct ptlrpc_request *req, void mdt_thread_info_fini(struct mdt_thread_info *mti); struct mdt_thread_info *tsi2mdt_info(struct tgt_session_info *tsi); @@ -591,7 +600,7 @@ index c3d4f7f..7b0381a 100644 int mdt_hsm_attr_set(struct mdt_thread_info *info, struct mdt_object *obj, const struct md_hsm *mh); -@@ -924,13 +921,12 @@ int mdt_hsm_cdt_fini(struct mdt_device *mdt); +@@ -925,13 +922,12 @@ int mdt_hsm_cdt_fini(struct mdt_device *mdt); int mdt_hsm_cdt_wakeup(struct mdt_device *mdt); /* coordinator control /proc interface */ @@ -609,7 +618,7 @@ index c3d4f7f..7b0381a 100644 /* md_hsm helpers */ struct mdt_object *mdt_hsm_get_md_hsm(struct mdt_thread_info *mti, const struct lu_fid *fid, -@@ -1070,8 +1066,6 @@ enum { +@@ -1071,8 +1067,6 @@ enum { }; void mdt_counter_incr(struct ptlrpc_request *req, int opcode); void mdt_stats_counter_init(struct lprocfs_stats *stats); @@ -619,7 +628,7 @@ index c3d4f7f..7b0381a 100644 void mdt_procfs_fini(struct mdt_device *mdt); diff --git a/lustre/mdt/mdt_lproc.c b/lustre/mdt/mdt_lproc.c -index 0ee5148..658f00d 100644 +index 0ee5148..a895d57 100644 --- a/lustre/mdt/mdt_lproc.c +++ b/lustre/mdt/mdt_lproc.c @@ -156,7 +156,6 @@ static ssize_t mdt_rename_stats_seq_write(struct file *file, const char *buf, @@ -630,13 +639,12 @@ index 0ee5148..658f00d 100644 LPROC_SEQ_FOPS(mdt_rename_stats); static int lproc_mdt_attach_rename_seqstat(struct mdt_device *mdt) -@@ -213,143 +212,73 @@ void mdt_rename_counter_tally(struct mdt_thread_info *info, +@@ -213,143 +212,76 @@ void mdt_rename_counter_tally(struct mdt_thread_info *info, (unsigned int)ma->ma_attr.la_size); } -int mdt_procfs_init(struct mdt_device *mdt, const char *name) -+static int mdt_identity_expire_seq_show(struct seq_file *m, void *data) - { +-{ - struct obd_device *obd = mdt2obd_dev(mdt); - struct lprocfs_static_vars lvars; - int rc; @@ -682,7 +690,8 @@ index 0ee5148..658f00d 100644 -} - -void mdt_procfs_fini(struct mdt_device *mdt) --{ ++static int mdt_identity_expire_seq_show(struct seq_file *m, void *data) + { - struct obd_device *obd = mdt2obd_dev(mdt); - - if (obd->obd_proc_exports_entry != NULL) { @@ -721,7 +730,8 @@ index 0ee5148..658f00d 100644 - struct obd_device *obd = data; - struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev); - int rc, val; -+ struct obd_device *obd = ((struct seq_file *)file->private_data)->private; ++ struct seq_file *m = file->private_data; ++ struct obd_device *obd = m->private; + struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev); + int rc, val; @@ -752,7 +762,7 @@ index 0ee5148..658f00d 100644 - *eof = 1; - return snprintf(page, count, "%u\n", - mdt->mdt_identity_cache->uc_acquire_expire); -+ return seq_printf(m,"%u\n", mdt->mdt_identity_cache->uc_acquire_expire); ++ return seq_printf(m, "%u\n", mdt->mdt_identity_cache->uc_acquire_expire); } -static int lprocfs_wr_identity_acquire_expire(struct file *file, @@ -766,7 +776,8 @@ index 0ee5148..658f00d 100644 - struct obd_device *obd = data; - struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev); - int rc, val; -+ struct obd_device *obd = ((struct seq_file *)file->private_data)->private; ++ struct seq_file *m = file->private_data; ++ struct obd_device *obd = m->private; + struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev); + int rc, val; @@ -812,11 +823,12 @@ index 0ee5148..658f00d 100644 + size_t count, loff_t *off) { - struct obd_device *obd = data; -+ struct obd_device *obd = ((struct seq_file *)file->private_data)->private; ++ struct seq_file *m = file->private_data; ++ struct obd_device *obd = m->private; struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev); struct upcall_cache *hash = mdt->mdt_identity_cache; int rc; -@@ -388,11 +317,13 @@ static int lprocfs_wr_identity_upcall(struct file *file, const char *buffer, +@@ -388,11 +320,14 @@ static int lprocfs_wr_identity_upcall(struct file *file, const char *buffer, OBD_FREE(kernbuf, count + 1); RETURN(rc); } @@ -829,11 +841,12 @@ index 0ee5148..658f00d 100644 + size_t count, void *data) { - struct obd_device *obd = data; -+ struct obd_device *obd = ((struct seq_file *)file->private_data)->private; ++ struct seq_file *m = file->private_data; ++ struct obd_device *obd = m->private; struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev); int rc, uid; -@@ -403,11 +334,13 @@ static int lprocfs_wr_identity_flush(struct file *file, const char *buffer, +@@ -403,11 +338,14 @@ static int lprocfs_wr_identity_flush(struct file *file, const char *buffer, mdt_flush_identity(mdt->mdt_identity_cache, uid); return count; } @@ -846,11 +859,12 @@ index 0ee5148..658f00d 100644 + size_t count, void *data) { - struct obd_device *obd = data; -+ struct obd_device *obd = ((struct seq_file *)file->private_data)->private; ++ struct seq_file *m = file->private_data; ++ struct obd_device *obd = m->private; struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev); struct identity_downcall_data *param; int size = sizeof(*param), rc, checked = 0; -@@ -415,7 +348,7 @@ static int lprocfs_wr_identity_info(struct file *file, const char *buffer, +@@ -415,7 +353,7 @@ static int lprocfs_wr_identity_info(struct file *file, const char *buffer, again: if (count < size) { CERROR("%s: invalid data count = %lu, size = %d\n", @@ -859,7 +873,7 @@ index 0ee5148..658f00d 100644 return -EINVAL; } -@@ -468,23 +401,24 @@ out: +@@ -468,23 +406,25 @@ out: return rc ? rc : count; } @@ -887,11 +901,12 @@ index 0ee5148..658f00d 100644 + size_t count, loff_t *off) { - struct obd_device *obd = data; -+ struct obd_device *obd = ((struct seq_file *)file->private_data)->private; ++ struct seq_file *m = file->private_data; ++ struct obd_device *obd = m->private; struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev); int val, rc; -@@ -521,64 +455,65 @@ static int lprocfs_wr_capa(struct file *file, const char *buffer, +@@ -521,64 +461,67 @@ static int lprocfs_wr_capa(struct file *file, const char *buffer, mdt->mdt_lut.lut_oss_capa ? "enabled" : "disabled"); return count; } @@ -945,7 +960,8 @@ index 0ee5148..658f00d 100644 - struct obd_device *obd = data; - struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev); - int val, rc; -+ struct obd_device *obd = ((struct seq_file *)file->private_data)->private; ++ struct seq_file *m = file->private_data; ++ struct obd_device *obd = m->private; + struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev); + int val, rc; @@ -987,13 +1003,14 @@ index 0ee5148..658f00d 100644 - struct obd_device *obd = data; - struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev); - int val, rc; -+ struct obd_device *obd = ((struct seq_file *)file->private_data)->private; -+ struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev); ++ struct seq_file *m = file->private_data; ++ struct obd_device *obd = m->private; ++ struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev); + int val, rc; rc = lprocfs_write_helper(buffer, count, &val); if (rc) -@@ -588,11 +523,13 @@ static int lprocfs_wr_ck_timeout(struct file *file, const char *buffer, +@@ -588,11 +531,13 @@ static int lprocfs_wr_ck_timeout(struct file *file, const char *buffer, mdt->mdt_capa_conf = 1; return count; } @@ -1009,16 +1026,17 @@ index 0ee5148..658f00d 100644 { char *kbuf; char *tmpbuf; -@@ -614,7 +551,7 @@ static int lprocfs_mdt_wr_evict_client(struct file *file, const char *buffer, +@@ -614,7 +559,8 @@ static int lprocfs_mdt_wr_evict_client(struct file *file, const char *buffer, tmpbuf = cfs_firststr(kbuf, min_t(unsigned long, BUFLEN - 1, count)); if (strncmp(tmpbuf, "nid:", 4) != 0) { - count = lprocfs_wr_evict_client(file, buffer, count, data); -+ count = lprocfs_evict_client_seq_write(file, buffer, count, off); ++ count = lprocfs_evict_client_seq_write(file, buffer, count, ++ off); goto out; } -@@ -627,21 +564,21 @@ out: +@@ -627,21 +573,22 @@ out: #undef BUFLEN @@ -1044,13 +1062,14 @@ index 0ee5148..658f00d 100644 - struct obd_device *obd = data; - struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev); - int val, rc; -+ struct obd_device *obd = ((struct seq_file *)file->private_data)->private; -+ struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev); ++ struct seq_file *m = file->private_data; ++ struct obd_device *obd = m->private; ++ struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev); + int val, rc; rc = lprocfs_write_helper(buffer, count, &val); if (rc) -@@ -659,22 +596,23 @@ static int lprocfs_wr_sec_level(struct file *file, const char *buffer, +@@ -659,22 +606,24 @@ static int lprocfs_wr_sec_level(struct file *file, const char *buffer, mdt->mdt_lut.lut_sec_level = val; return count; } @@ -1078,13 +1097,14 @@ index 0ee5148..658f00d 100644 - struct obd_device *obd = data; - struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev); - int val, rc; -+ struct obd_device *obd = ((struct seq_file *)file->private_data)->private; -+ struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev); ++ struct seq_file *m = file->private_data; ++ struct obd_device *obd = m->private; ++ struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev); + int val, rc; rc = lprocfs_write_helper(buffer, count, &val); if (rc) -@@ -682,15 +620,15 @@ static int lprocfs_wr_cos(struct file *file, const char *buffer, +@@ -682,15 +631,15 @@ static int lprocfs_wr_cos(struct file *file, const char *buffer, mdt_enable_cos(mdt, val); return count; } @@ -1106,7 +1126,7 @@ index 0ee5148..658f00d 100644 } static int safe_strtoul(const char *str, char **endp, unsigned long *res) -@@ -708,10 +646,11 @@ static int safe_strtoul(const char *str, char **endp, unsigned long *res) +@@ -708,11 +657,13 @@ static int safe_strtoul(const char *str, char **endp, unsigned long *res) return 0; } @@ -1117,11 +1137,14 @@ index 0ee5148..658f00d 100644 + size_t count, loff_t *off) { - struct obd_device *obd = data; -+ struct obd_device *obd = ((struct seq_file *)file->private_data)->private; - struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev); +- struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev); ++ struct seq_file *m = file->private_data; ++ struct obd_device *obd = m->private; ++ struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev); int rc; char kernbuf[50], *tmp, *end, *errmsg; -@@ -765,22 +704,23 @@ failed: + unsigned long uid, gid; +@@ -765,23 +716,25 @@ failed: mdt_obd_name(mdt), buffer, errmsg, rc); RETURN(rc); } @@ -1151,11 +1174,14 @@ index 0ee5148..658f00d 100644 + size_t count, loff_t *off) { - struct obd_device *obd = data; -+ struct obd_device *obd = ((struct seq_file *)file->private_data)->private; - struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev); +- struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev); ++ struct seq_file *m = file->private_data; ++ struct obd_device *obd = m->private; ++ struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev); int rc; char *kernbuf, *errmsg; -@@ -842,25 +782,26 @@ failed: + cfs_list_t tmp; +@@ -842,25 +795,27 @@ failed: OBD_FREE(kernbuf, count + 1); RETURN(rc); } @@ -1187,7 +1213,8 @@ index 0ee5148..658f00d 100644 - struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev); - char kernbuf[16]; - unsigned long val = 0; -+ struct obd_device *obd = ((struct seq_file *)file->private_data)->private; ++ struct seq_file *m = file->private_data; ++ struct obd_device *obd = m->private; + struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev); + struct obd_export *exp; + char kernbuf[16]; @@ -1195,7 +1222,7 @@ index 0ee5148..658f00d 100644 if (count > (sizeof(kernbuf) - 1)) return -EINVAL; -@@ -902,20 +843,21 @@ static int lprocfs_wr_mdt_som(struct file *file, const char *buffer, +@@ -902,20 +857,22 @@ static int lprocfs_wr_mdt_som(struct file *file, const char *buffer, return count; } @@ -1220,11 +1247,12 @@ index 0ee5148..658f00d 100644 + size_t count, loff_t *off) { - struct obd_device *obd = data; -+ struct obd_device *obd = ((struct seq_file *)file->private_data)->private; ++ struct seq_file *m = file->private_data; ++ struct obd_device *obd = m->private; struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev); __u32 val; int rc; -@@ -930,22 +872,22 @@ static int lprocfs_wr_enable_remote_dir(struct file *file, const char *buffer, +@@ -930,22 +887,23 @@ static int lprocfs_wr_enable_remote_dir(struct file *file, const char *buffer, mdt->mdt_enable_remote_dir = val; return count; } @@ -1252,11 +1280,12 @@ index 0ee5148..658f00d 100644 + size_t count, loff_t *off) { - struct obd_device *obd = data; -+ struct obd_device *obd = ((struct seq_file *)file->private_data)->private; ++ struct seq_file *m = file->private_data; ++ struct obd_device *obd = m->private; struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev); __u32 val; int rc; -@@ -957,97 +899,72 @@ static int lprocfs_wr_enable_remote_dir_gid(struct file *file, +@@ -957,97 +915,72 @@ static int lprocfs_wr_enable_remote_dir_gid(struct file *file, mdt->mdt_enable_remote_dir_gid = val; return count; } @@ -1420,7 +1449,7 @@ index 0ee5148..658f00d 100644 { 0 } }; -@@ -1085,21 +1002,15 @@ int lprocfs_mdt_open_files_seq_show(struct seq_file *seq, void *v) +@@ -1085,21 +1018,15 @@ int lprocfs_mdt_open_files_seq_show(struct seq_file *seq, void *v) int lprocfs_mdt_open_files_seq_open(struct inode *inode, struct file *file) { @@ -1443,7 +1472,7 @@ index 0ee5148..658f00d 100644 return 0; } -@@ -1140,3 +1051,67 @@ void mdt_stats_counter_init(struct lprocfs_stats *stats) +@@ -1140,3 +1067,67 @@ void mdt_stats_counter_init(struct lprocfs_stats *stats) lprocfs_counter_init(stats, LPROC_MDT_CROSSDIR_RENAME, 0, "crossdir_rename", "reqs"); } @@ -1512,7 +1541,7 @@ index 0ee5148..658f00d 100644 + lprocfs_job_stats_fini(obd); +} diff --git a/lustre/mdt/mdt_mds.c b/lustre/mdt/mdt_mds.c -index 367f659..4fa66c3 100644 +index 390164f..424ddf5 100644 --- a/lustre/mdt/mdt_mds.c +++ b/lustre/mdt/mdt_mds.c @@ -464,6 +464,13 @@ static struct lu_device *mds_device_free(const struct lu_env *env, @@ -1541,13 +1570,13 @@ index 367f659..4fa66c3 100644 l = ERR_PTR(rc); @@ -541,7 +549,7 @@ int mds_mod_init(void) - return class_register_type(&mds_obd_device_ops, NULL, NULL, + return class_register_type(&mds_obd_device_ops, NULL, true, NULL, #ifndef HAVE_ONLY_PROCFS_SEQ -- lprocfs_mds_module_vars, -+ NULL, +- lprocfs_mds_module_vars, ++ NULL, #endif - LUSTRE_MDS_NAME, &mds_device_type); + LUSTRE_MDS_NAME, &mds_device_type); } -- -1.8.5.3 +1.9.1 diff --git a/sys-cluster/lustre/files/0007-LU-3319-procfs-move-mdd-ofd-proc-handling-to-seq_fil.patch b/sys-cluster/lustre/files/0008-LU-3319-procfs-move-mdd-ofd-proc-handling-to-seq_fil.patch index b2921fc4f..6c6106b54 100644 --- a/sys-cluster/lustre/files/0007-LU-3319-procfs-move-mdd-ofd-proc-handling-to-seq_fil.patch +++ b/sys-cluster/lustre/files/0008-LU-3319-procfs-move-mdd-ofd-proc-handling-to-seq_fil.patch @@ -1,41 +1,36 @@ -From 6af3bd54359520829a6199e81171fd849a6656f4 Mon Sep 17 00:00:00 2001 -From: Alexey Shvetsov <alexxy@gentoo.org> -Date: Thu, 27 Feb 2014 16:06:08 +0400 -Subject: [PATCH 07/12] LU-3319 procfs: move mdd/ofd proc handling to seq_files +From c6c3f4063e244cea365940adc0fd1a1c35d0b525 Mon Sep 17 00:00:00 2001 +From: James Simmons <uja.ornl@gmail.com> +Date: Wed, 26 Mar 2014 20:01:52 -0400 +Subject: [PATCH 8/9] LU-3319 procfs: move mdd/ofd proc handling to seq_files With 3.10 linux kernel and above proc handling now only uses struct seq_files. This patch migrates the mdd/ofd layer proc entries over to using seq_files. -Conflicts: - lustre/mdd/mdd_lproc.c - lustre/lfsck/lfsck_layout.c - Signed-off-by: James Simmons <uja.ornl@gmail.com> -Signed-off-by: Alexey Shvetsov <alexxy@gentoo.org> Change-Id: I61b7df6bfd5efd0f12e3ca1a1813b7b62d493168 --- lustre/include/lustre_lfsck.h | 6 +- lustre/lfsck/lfsck_internal.h | 9 +- - lustre/lfsck/lfsck_layout.c | 101 ++------- - lustre/lfsck/lfsck_lib.c | 77 +++---- + lustre/lfsck/lfsck_layout.c | 104 +++------ + lustre/lfsck/lfsck_lib.c | 88 +++----- lustre/lfsck/lfsck_namespace.c | 75 ++----- lustre/mdd/mdd_device.c | 25 +-- lustre/mdd/mdd_internal.h | 1 - - lustre/mdd/mdd_lproc.c | 300 ++++++++++++--------------- + lustre/mdd/mdd_lproc.c | 302 +++++++++++-------------- lustre/obdclass/lprocfs_status.c | 9 +- - lustre/ofd/lproc_ofd.c | 436 ++++++++++++++++++++------------------- - lustre/ofd/ofd_dev.c | 48 ++--- + lustre/ofd/lproc_ofd.c | 467 ++++++++++++++++++++------------------- + lustre/ofd/ofd_dev.c | 80 +++---- lustre/ofd/ofd_internal.h | 6 +- lustre/osd-ldiskfs/osd_handler.c | 1 + lustre/osd-zfs/osd_handler.c | 1 + - 14 files changed, 462 insertions(+), 633 deletions(-) + 14 files changed, 517 insertions(+), 657 deletions(-) diff --git a/lustre/include/lustre_lfsck.h b/lustre/include/lustre_lfsck.h -index 1209bc2..bdb0955 100644 +index 0d6f666..5adbffe 100644 --- a/lustre/include/lustre_lfsck.h +++ b/lustre/include/lustre_lfsck.h -@@ -158,12 +158,12 @@ int lfsck_in_notify(const struct lu_env *env, struct dt_device *key, +@@ -148,12 +148,12 @@ int lfsck_in_notify(const struct lu_env *env, struct dt_device *key, int lfsck_query(const struct lu_env *env, struct dt_device *key, struct lfsck_request *lr); @@ -52,10 +47,10 @@ index 1209bc2..bdb0955 100644 static inline void lfsck_pack_rfa(struct lfsck_request *lr, const struct lu_fid *fid) diff --git a/lustre/lfsck/lfsck_internal.h b/lustre/lfsck/lfsck_internal.h -index 9f20729..48d3d82 100644 +index 4f84c3b..c4e6430 100644 --- a/lustre/lfsck/lfsck_internal.h +++ b/lustre/lfsck/lfsck_internal.h -@@ -293,8 +293,7 @@ struct lfsck_operations { +@@ -299,8 +299,7 @@ struct lfsck_operations { int (*lfsck_dump)(const struct lu_env *env, struct lfsck_component *com, @@ -65,7 +60,7 @@ index 9f20729..48d3d82 100644 int (*lfsck_double_scan)(const struct lu_env *env, struct lfsck_component *com); -@@ -571,10 +570,10 @@ void lfsck_component_cleanup(const struct lu_env *env, +@@ -586,10 +585,10 @@ void lfsck_component_cleanup(const struct lu_env *env, struct lfsck_component *com); void lfsck_instance_cleanup(const struct lu_env *env, struct lfsck_instance *lfsck); @@ -80,10 +75,19 @@ index 9f20729..48d3d82 100644 void lfsck_pos_fill(const struct lu_env *env, struct lfsck_instance *lfsck, struct lfsck_position *pos, bool init); diff --git a/lustre/lfsck/lfsck_layout.c b/lustre/lfsck/lfsck_layout.c -index f77ee87..27394e2 100644 +index de96726..c3b4458 100644 --- a/lustre/lfsck/lfsck_layout.c +++ b/lustre/lfsck/lfsck_layout.c -@@ -3657,69 +3657,53 @@ static int lfsck_layout_slave_post(const struct lu_env *env, +@@ -471,7 +471,7 @@ static struct lfsck_rbtree_node *lfsck_rbtree_new(const struct lu_env *env, + return ERR_PTR(-ENOMEM); + } + +- rb_init_node(&lrn->lrn_node); ++ RB_CLEAR_NODE(&lrn->lrn_node); + lrn->lrn_seq = fid_seq(fid); + lrn->lrn_first_oid = fid_oid(fid) & ~LFSCK_RBTREE_BITMAP_MASK; + atomic_set(&lrn->lrn_known_count, 0); +@@ -4798,69 +4798,53 @@ static int lfsck_layout_slave_post(const struct lu_env *env, } static int lfsck_layout_dump(const struct lu_env *env, @@ -152,17 +156,17 @@ index f77ee87..27394e2 100644 lo->ll_pos_first_inconsistent); - if (rc <= 0) - goto out; -- + - buf += rc; - len -= rc; - +- - rc = snprintf(buf, len, - "success_count: %u\n" + seq_printf(m, "success_count: %u\n" "repaired_dangling: "LPU64"\n" "repaired_unmatched_pair: "LPU64"\n" "repaired_multiple_referenced: "LPU64"\n" -@@ -3739,11 +3723,6 @@ static int lfsck_layout_dump(const struct lu_env *env, +@@ -4880,11 +4864,6 @@ static int lfsck_layout_dump(const struct lu_env *env, lo->ll_objs_skipped, lo->ll_objs_failed_phase1, lo->ll_objs_failed_phase2); @@ -174,7 +178,7 @@ index f77ee87..27394e2 100644 if (lo->ll_status == LS_SCANNING_PHASE1) { __u64 pos; -@@ -3760,8 +3739,7 @@ static int lfsck_layout_dump(const struct lu_env *env, +@@ -4901,8 +4880,7 @@ static int lfsck_layout_dump(const struct lu_env *env, do_div(new_checked, duration); if (rtime != 0) do_div(speed, rtime); @@ -184,7 +188,7 @@ index f77ee87..27394e2 100644 "checked_phase2: "LPU64"\n" "run_time_phase1: %u seconds\n" "run_time_phase2: %u seconds\n" -@@ -3775,11 +3753,6 @@ static int lfsck_layout_dump(const struct lu_env *env, +@@ -4916,11 +4894,6 @@ static int lfsck_layout_dump(const struct lu_env *env, lo->ll_run_time_phase2, speed, new_checked); @@ -196,29 +200,24 @@ index f77ee87..27394e2 100644 LASSERT(lfsck->li_di_oit != NULL); -@@ -3792,47 +3765,7 @@ static int lfsck_layout_dump(const struct lu_env *env, +@@ -4933,12 +4906,8 @@ static int lfsck_layout_dump(const struct lu_env *env, pos = iops->store(env, lfsck->li_di_oit); if (!lfsck->li_current_oit_processed) pos--; - rc = snprintf(buf, len, "current_position: "LPU64"\n", pos); - if (rc <= 0) - goto out; -- ++ seq_printf(m, "current_position: "LPU64"\n", pos); + - buf += rc; - len -= rc; -- } else if (lo->ll_status == LS_SCANNING_PHASE2) { -- cfs_duration_t duration = cfs_time_current() - -- lfsck->li_time_last_checkpoint; -- __u64 checked = lo->ll_objs_checked_phase1 + com->lc_new_checked; -- __u64 speed = checked; -- __u64 new_checked = com->lc_new_checked * HZ; -- __u32 rtime = lo->ll_run_time_phase1 + -- cfs_duration_sec(duration + HALF_SEC); -- -- if (duration != 0) -- do_div(new_checked, duration); -- if (rtime != 0) -- do_div(speed, rtime); + } else if (lo->ll_status == LS_SCANNING_PHASE2) { + cfs_duration_t duration = cfs_time_current() - + lfsck->li_time_last_checkpoint; +@@ -4952,28 +4921,25 @@ static int lfsck_layout_dump(const struct lu_env *env, + do_div(new_checked, duration); + if (rtime != 0) + do_div(speed, rtime); - rc = snprintf(buf, len, - "checked_phase1: "LPU64"\n" - "checked_phase2: "LPU64"\n" @@ -237,15 +236,31 @@ index f77ee87..27394e2 100644 - new_checked, - PFID(&com->lc_fid_latest_scanned_phase2)); - if (rc <= 0) -- goto out; -- ++ rc = seq_printf(m, "checked_phase1: "LPU64"\n" ++ "checked_phase2: "LPU64"\n" ++ "run_time_phase1: %u seconds\n" ++ "run_time_phase2: %u seconds\n" ++ "average_speed_phase1: "LPU64" items/sec\n" ++ "average_speed_phase2: N/A\n" ++ "real-time_speed_phase1: "LPU64" items/sec\n" ++ "real-time_speed_phase2: N/A\n" ++ "current_position: "DFID"\n", ++ checked, ++ lo->ll_objs_checked_phase2, ++ rtime, ++ lo->ll_run_time_phase2, ++ speed, ++ new_checked, ++ PFID(&com->lc_fid_latest_scanned_phase2)); ++ if (rc < 0) + goto out; + - buf += rc; - len -= rc; -+ seq_printf(m, "current_position: "LPU64"\n", pos); } else { __u64 speed1 = lo->ll_objs_checked_phase1; __u64 speed2 = lo->ll_objs_checked_phase2; -@@ -3841,8 +3774,7 @@ static int lfsck_layout_dump(const struct lu_env *env, +@@ -4982,8 +4948,7 @@ static int lfsck_layout_dump(const struct lu_env *env, do_div(speed1, lo->ll_run_time_phase1); if (lo->ll_run_time_phase2 != 0) do_div(speed2, lo->ll_run_time_phase2); @@ -255,7 +270,7 @@ index f77ee87..27394e2 100644 "checked_phase2: "LPU64"\n" "run_time_phase1: %u seconds\n" "run_time_phase2: %u seconds\n" -@@ -3857,18 +3789,11 @@ static int lfsck_layout_dump(const struct lu_env *env, +@@ -4998,18 +4963,11 @@ static int lfsck_layout_dump(const struct lu_env *env, lo->ll_run_time_phase2, speed1, speed2); @@ -276,10 +291,10 @@ index f77ee87..27394e2 100644 static int lfsck_layout_master_double_scan(const struct lu_env *env, diff --git a/lustre/lfsck/lfsck_lib.c b/lustre/lfsck/lfsck_lib.c -index de7b849..d358ca1 100644 +index 3b1fe0c..84ffc08 100644 --- a/lustre/lfsck/lfsck_lib.c +++ b/lustre/lfsck/lfsck_lib.c -@@ -426,77 +426,52 @@ static inline int lfsck_instance_add(struct lfsck_instance *lfsck) +@@ -899,21 +899,15 @@ static inline int lfsck_instance_add(struct lfsck_instance *lfsck) return 0; } @@ -291,8 +306,9 @@ index de7b849..d358ca1 100644 int flag; - int rc; int i; + bool newline = (bits != 0 ? false : true); -- rc = snprintf(*buf, *len, "%s:%c", prefix, bits != 0 ? ' ' : '\n'); +- rc = snprintf(*buf, *len, "%s:%c", prefix, newline ? '\n' : ' '); - if (rc <= 0) - return -ENOSPC; + seq_printf(m, "%s:%c", prefix, bits != 0 ? ' ' : '\n'); @@ -302,20 +318,35 @@ index de7b849..d358ca1 100644 for (i = 0, flag = 1; bits != 0; i++, flag = 1 << i) { if (flag & bits) { bits &= ~flag; - if (names[i] != NULL) { +@@ -921,69 +915,43 @@ int lfsck_bits_dump(char **buf, int *len, int bits, const char *names[], + if (bits == 0) + newline = true; + - rc = snprintf(*buf, *len, "%s%c", names[i], -- bits != 0 ? ',' : '\n'); +- newline ? '\n' : ','); - if (rc <= 0) - return -ENOSPC; - - *buf += rc; - *len -= rc; + seq_printf(m, "%s%c", names[i], -+ bits != 0 ? ',' : '\n'); ++ newline ? '\n' : ','); } } } + +- if (!newline) { +- rc = snprintf(*buf, *len, "\n"); +- if (rc <= 0) +- return -ENOSPC; +- +- *buf += rc; +- *len -= rc; +- } +- - return save - *len; ++ if (!newline) ++ seq_printf(m, "\n"); + return 0; } @@ -328,7 +359,7 @@ index de7b849..d358ca1 100644 - rc = snprintf(*buf, *len, "%s: "LPU64" seconds\n", prefix, - cfs_time_current_sec() - time); + seq_printf(m, "%s: "LPU64" seconds\n", prefix, -+ cfs_time_current_sec() - time); ++ cfs_time_current_sec() - time); else - rc = snprintf(*buf, *len, "%s: N/A\n", prefix); - if (rc <= 0) @@ -376,7 +407,7 @@ index de7b849..d358ca1 100644 } void lfsck_pos_fill(const struct lu_env *env, struct lfsck_instance *lfsck, -@@ -1149,7 +1124,7 @@ int lfsck_async_request(const struct lu_env *env, struct obd_export *exp, +@@ -1658,7 +1626,7 @@ int lfsck_async_request(const struct lu_env *env, struct obd_export *exp, /* external interfaces */ @@ -385,7 +416,7 @@ index de7b849..d358ca1 100644 { struct lu_env env; struct lfsck_instance *lfsck; -@@ -1162,8 +1137,7 @@ int lfsck_get_speed(struct dt_device *key, void *buf, int len) +@@ -1671,8 +1639,7 @@ int lfsck_get_speed(struct dt_device *key, void *buf, int len) lfsck = lfsck_instance_find(key, true, false); if (likely(lfsck != NULL)) { @@ -394,8 +425,8 @@ index de7b849..d358ca1 100644 + seq_printf(m, "%u\n", lfsck->li_bookmark_ram.lb_speed_limit); lfsck_instance_put(&env, lfsck); } else { - rc = -ENODEV; -@@ -1203,7 +1177,7 @@ int lfsck_set_speed(struct dt_device *key, int val) + rc = -ENXIO; +@@ -1712,7 +1679,7 @@ int lfsck_set_speed(struct dt_device *key, int val) } EXPORT_SYMBOL(lfsck_set_speed); @@ -404,7 +435,7 @@ index de7b849..d358ca1 100644 { struct lu_env env; struct lfsck_instance *lfsck; -@@ -1216,8 +1190,7 @@ int lfsck_get_windows(struct dt_device *key, void *buf, int len) +@@ -1725,8 +1692,7 @@ int lfsck_get_windows(struct dt_device *key, void *buf, int len) lfsck = lfsck_instance_find(key, true, false); if (likely(lfsck != NULL)) { @@ -413,8 +444,8 @@ index de7b849..d358ca1 100644 + seq_printf(m, "%u\n", lfsck->li_bookmark_ram.lb_async_windows); lfsck_instance_put(&env, lfsck); } else { - rc = -ENODEV; -@@ -1267,7 +1240,7 @@ int lfsck_set_windows(struct dt_device *key, int val) + rc = -ENXIO; +@@ -1776,7 +1742,7 @@ int lfsck_set_windows(struct dt_device *key, int val) } EXPORT_SYMBOL(lfsck_set_windows); @@ -423,7 +454,7 @@ index de7b849..d358ca1 100644 { struct lu_env env; struct lfsck_instance *lfsck; -@@ -1283,7 +1256,7 @@ int lfsck_dump(struct dt_device *key, void *buf, int len, enum lfsck_type type) +@@ -1792,7 +1758,7 @@ int lfsck_dump(struct dt_device *key, void *buf, int len, enum lfsck_type type) if (likely(lfsck != NULL)) { com = lfsck_component_find(lfsck, type); if (likely(com != NULL)) { @@ -433,7 +464,7 @@ index de7b849..d358ca1 100644 } else { rc = -ENOTSUPP; diff --git a/lustre/lfsck/lfsck_namespace.c b/lustre/lfsck/lfsck_namespace.c -index 6fc08fb..2abad67 100644 +index c80fb48..bcbfb8e 100644 --- a/lustre/lfsck/lfsck_namespace.c +++ b/lustre/lfsck/lfsck_namespace.c @@ -1088,65 +1088,56 @@ static int lfsck_namespace_post(const struct lu_env *env, @@ -604,10 +635,10 @@ index 6fc08fb..2abad67 100644 static int lfsck_namespace_double_scan_main(void *args) diff --git a/lustre/mdd/mdd_device.c b/lustre/mdd/mdd_device.c -index 40a4ee3..b0acecb 100644 +index 0fe590e..f1c76d6 100644 --- a/lustre/mdd/mdd_device.c +++ b/lustre/mdd/mdd_device.c -@@ -812,16 +812,16 @@ static int mdd_process_config(const struct lu_env *env, +@@ -884,16 +884,16 @@ static int mdd_process_config(const struct lu_env *env, ENTRY; switch (cfg->lcfg_command) { @@ -634,7 +665,7 @@ index 40a4ee3..b0acecb 100644 case LCFG_SETUP: rc = next->ld_ops->ldo_process_config(env, next, cfg); if (rc) -@@ -1497,11 +1497,8 @@ LU_CONTEXT_KEY_DEFINE(mdd, LCT_MD_THREAD); +@@ -1564,11 +1564,8 @@ LU_CONTEXT_KEY_DEFINE(mdd, LCT_MD_THREAD); static int __init mdd_mod_init(void) { @@ -646,20 +677,20 @@ index 40a4ee3..b0acecb 100644 rc = lu_kmem_init(mdd_caches); if (rc) return rc; -@@ -1517,7 +1514,7 @@ static int __init mdd_mod_init(void) +@@ -1584,7 +1581,7 @@ static int __init mdd_mod_init(void) - rc = class_register_type(&mdd_obd_device_ops, NULL, NULL, + rc = class_register_type(&mdd_obd_device_ops, NULL, true, NULL, #ifndef HAVE_ONLY_PROCFS_SEQ -- lvars.module_vars, -+ NULL, +- lvars.module_vars, ++ NULL, #endif - LUSTRE_MDD_NAME, &mdd_device_type); + LUSTRE_MDD_NAME, &mdd_device_type); if (rc) diff --git a/lustre/mdd/mdd_internal.h b/lustre/mdd/mdd_internal.h -index 0bfb2a2..bccef77 100644 +index b536821..8e67fa1 100644 --- a/lustre/mdd/mdd_internal.h +++ b/lustre/mdd/mdd_internal.h -@@ -342,7 +342,6 @@ int orph_declare_index_delete(const struct lu_env *, struct mdd_object *, +@@ -346,7 +346,6 @@ int orph_declare_index_delete(const struct lu_env *, struct mdd_object *, struct thandle *); /* mdd_lproc.c */ @@ -668,7 +699,7 @@ index 0bfb2a2..bccef77 100644 int mdd_procfs_fini(struct mdd_device *mdd); diff --git a/lustre/mdd/mdd_lproc.c b/lustre/mdd/mdd_lproc.c -index de379b3..5714ee6 100644 +index de379b3..7ac4afa 100644 --- a/lustre/mdd/mdd_lproc.c +++ b/lustre/mdd/mdd_lproc.c @@ -49,56 +49,14 @@ @@ -711,10 +742,7 @@ index de379b3..5714ee6 100644 -} - -int mdd_procfs_fini(struct mdd_device *mdd) -+static ssize_t -+mdd_atime_diff_seq_write(struct file *file, const char *buffer, -+ size_t count, loff_t *off) - { +-{ - if (mdd->mdd_proc_entry) { - lprocfs_remove(&mdd->mdd_proc_entry); - mdd->mdd_proc_entry = NULL; @@ -724,7 +752,10 @@ index de379b3..5714ee6 100644 - -static int lprocfs_wr_atime_diff(struct file *file, const char *buffer, - unsigned long count, void *data) --{ ++static ssize_t ++mdd_atime_diff_seq_write(struct file *file, const char *buffer, ++ size_t count, loff_t *off) + { - struct mdd_device *mdd = data; - char kernbuf[20], *end; - unsigned long diff = 0; @@ -867,7 +898,7 @@ index de379b3..5714ee6 100644 llog_cat_process(&env, ctxt->loc_handle, lprocfs_changelog_users_cb, - &cucb, 0, 0); -+ &m, 0, 0); ++ m, 0, 0); lu_env_fini(&env); llog_ctxt_put(ctxt); @@ -968,7 +999,7 @@ index de379b3..5714ee6 100644 __u32 val; int rc; -@@ -320,54 +255,77 @@ static int lprocfs_wr_lfsck_async_windows(struct file *file, const char *buffer, +@@ -320,54 +255,87 @@ static int lprocfs_wr_lfsck_async_windows(struct file *file, const char *buffer, return rc != 0 ? rc : count; } @@ -989,12 +1020,35 @@ index de379b3..5714ee6 100644 - return rc; + return lfsck_dump(m, mdd->mdd_bottom, LT_NAMESPACE); } ++LPROC_SEQ_FOPS_RO(mdd_lfsck_namespace); -static int lprocfs_rd_lfsck_layout(char *page, char **start, off_t off, - int count, int *eof, void *data) --{ ++static int mdd_lfsck_layout_seq_show(struct seq_file *m, void *data) + { - struct mdd_device *mdd = data; -+LPROC_SEQ_FOPS_RO(mdd_lfsck_namespace); ++ struct mdd_device *mdd = m->private; + + LASSERT(mdd != NULL); +- *eof = 1; + +- return lfsck_dump(mdd->mdd_bottom, page, count, LT_LAYOUT); ++ return lfsck_dump(m, mdd->mdd_bottom, LT_LAYOUT); + } +- +-static struct lprocfs_vars lprocfs_mdd_obd_vars[] = { +- { "atime_diff", lprocfs_rd_atime_diff, lprocfs_wr_atime_diff, 0 }, +- { "changelog_mask", lprocfs_rd_changelog_mask, +- lprocfs_wr_changelog_mask, 0 }, +- { "changelog_users", lprocfs_rd_changelog_users, 0, 0}, +- { "sync_permission", lprocfs_rd_sync_perm, lprocfs_wr_sync_perm, 0 }, +- { "lfsck_speed_limit", lprocfs_rd_lfsck_speed_limit, +- lprocfs_wr_lfsck_speed_limit, 0 }, +- { "lfsck_async_windows", lprocfs_rd_lfsck_async_windows, +- lprocfs_wr_lfsck_async_windows, 0 }, +- { "lfsck_namespace", lprocfs_rd_lfsck_namespace, 0, 0 }, +- { "lfsck_layout", lprocfs_rd_lfsck_layout, 0, 0 }, ++LPROC_SEQ_FOPS_RO(mdd_lfsck_layout); + +static struct lprocfs_seq_vars lprocfs_mdd_obd_vars[] = { + { .name = "atime_diff", @@ -1007,42 +1061,34 @@ index de379b3..5714ee6 100644 + .fops = &mdd_sync_perm_fops }, + { .name = "lfsck_speed_limit", + .fops = &mdd_lfsck_speed_limit_fops }, -+ { .name = "lfsck_async_windows", -+ .fops = &mdd_lfsck_async_windows_fops }, -+ { .name = "lfsck_namespace", -+ .fops = &mdd_lfsck_namespace_fops }, -+ { 0 } -+}; - -- LASSERT(mdd != NULL); -- *eof = 1; ++ { .name = "lfsck_async_windows", ++ .fops = &mdd_lfsck_async_windows_fops }, ++ { .name = "lfsck_namespace", ++ .fops = &mdd_lfsck_namespace_fops }, ++ { .name = "lfsck_layout", ++ .fops = &mdd_lfsck_layout_fops }, + { 0 } + }; + +-static struct lprocfs_vars lprocfs_mdd_module_vars[] = { +- { "num_refs", lprocfs_rd_numrefs, 0, 0 }, +- { 0 } +-}; +- +-void lprocfs_mdd_init_vars(struct lprocfs_static_vars *lvars) +int mdd_procfs_init(struct mdd_device *mdd, const char *name) -+{ + { +- lvars->module_vars = lprocfs_mdd_module_vars; +- lvars->obd_vars = lprocfs_mdd_obd_vars; + struct obd_device *obd = class_name2obd(name); + struct obd_type *type; + int rc; + ENTRY; - -- return lfsck_dump(mdd->mdd_bottom, page, count, LT_LAYOUT); --} ++ + /* at the moment there is no linkage between lu_type + * and obd_type, so we lookup obd_type this way */ + type = class_search_type(LUSTRE_MDD_NAME); - --static struct lprocfs_vars lprocfs_mdd_obd_vars[] = { -- { "atime_diff", lprocfs_rd_atime_diff, lprocfs_wr_atime_diff, 0 }, -- { "changelog_mask", lprocfs_rd_changelog_mask, -- lprocfs_wr_changelog_mask, 0 }, -- { "changelog_users", lprocfs_rd_changelog_users, 0, 0}, -- { "sync_permission", lprocfs_rd_sync_perm, lprocfs_wr_sync_perm, 0 }, -- { "lfsck_speed_limit", lprocfs_rd_lfsck_speed_limit, -- lprocfs_wr_lfsck_speed_limit, 0 }, -- { "lfsck_async_windows", lprocfs_rd_lfsck_async_windows, -- lprocfs_wr_lfsck_async_windows, 0 }, -- { "lfsck_namespace", lprocfs_rd_lfsck_namespace, 0, 0 }, -- { "lfsck_layout", lprocfs_rd_lfsck_layout, 0, 0 }, -- { 0 } --}; ++ + LASSERT(name != NULL); + LASSERT(type != NULL); + LASSERT(obd != NULL); @@ -1059,32 +1105,23 @@ index de379b3..5714ee6 100644 + GOTO(out, rc); + } + rc = 0; - --static struct lprocfs_vars lprocfs_mdd_module_vars[] = { -- { "num_refs", lprocfs_rd_numrefs, 0, 0 }, -- { 0 } --}; + EXIT; +out: + if (rc) + mdd_procfs_fini(mdd); + return rc; -+} + } --void lprocfs_mdd_init_vars(struct lprocfs_static_vars *lvars) +int mdd_procfs_fini(struct mdd_device *mdd) - { -- lvars->module_vars = lprocfs_mdd_module_vars; -- lvars->obd_vars = lprocfs_mdd_obd_vars; ++{ + if (mdd->mdd_proc_entry) { + lprocfs_remove(&mdd->mdd_proc_entry); + mdd->mdd_proc_entry = NULL; + } + RETURN(0); - } -- ++} diff --git a/lustre/obdclass/lprocfs_status.c b/lustre/obdclass/lprocfs_status.c -index 0ca58c5..5b72a5a 100644 +index 30d9f59..5e479c8 100644 --- a/lustre/obdclass/lprocfs_status.c +++ b/lustre/obdclass/lprocfs_status.c @@ -388,11 +388,10 @@ EXPORT_SYMBOL(lprocfs_evict_client_seq_write); @@ -1104,7 +1141,7 @@ index 0ca58c5..5b72a5a 100644 EXPORT_SYMBOL(lprocfs_evict_client_fops); #endif diff --git a/lustre/ofd/lproc_ofd.c b/lustre/ofd/lproc_ofd.c -index e303fd6..1759a7d 100644 +index 000d4ae..eb6bef0 100644 --- a/lustre/ofd/lproc_ofd.c +++ b/lustre/ofd/lproc_ofd.c @@ -47,80 +47,75 @@ @@ -1600,7 +1637,7 @@ index e303fd6..1759a7d 100644 struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev); __u32 val; int rc; -@@ -516,84 +512,108 @@ static int lprocfs_wr_lfsck_speed_limit(struct file *file, const char *buffer, +@@ -516,37 +512,34 @@ static int lprocfs_wr_lfsck_speed_limit(struct file *file, const char *buffer, return rc != 0 ? rc : count; } @@ -1611,13 +1648,55 @@ index e303fd6..1759a7d 100644 +static int ofd_lfsck_layout_seq_show(struct seq_file *m, void *data) { - struct obd_device *obd = data; +- struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev); +- +- *eof = 1; ++ struct obd_device *obd = m->private; ++ struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev); + +- return lfsck_dump(ofd->ofd_osd, page, count, LT_LAYOUT); ++ return lfsck_dump(m, ofd->ofd_osd, LT_LAYOUT); + } ++LPROC_SEQ_FOPS_RO(ofd_lfsck_layout); + +-static int lprocfs_rd_lfsck_verify_pfid(char *page, char **start, off_t off, +- int count, int *eof, void *data) ++static int ofd_lfsck_verify_pfid_seq_show(struct seq_file *m, void *data) + { +- struct obd_device *obd = data; +- struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev); +- +- *eof = 1; ++ struct obd_device *obd = m->private; ++ struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev); + +- return snprintf(page, count, +- "switch: %s\ndetected: "LPU64"\nrepaired: "LPU64"\n", +- ofd->ofd_lfsck_verify_pfid ? "on" : "off", +- ofd->ofd_inconsistency_self_detected, +- ofd->ofd_inconsistency_self_repaired); ++ return seq_printf(m, "switch: %s\ndetected: "LPU64"\nrepaired: "LPU64"\n", ++ ofd->ofd_lfsck_verify_pfid ? "on" : "off", ++ ofd->ofd_inconsistency_self_detected, ++ ofd->ofd_inconsistency_self_repaired); + } + +-static int lprocfs_wr_lfsck_verify_pfid(struct file *file, const char *buffer, +- unsigned long count, void *data) ++static ssize_t ++ofd_lfsck_verify_pfid_seq_write(struct file *file, const char *buffer, ++ size_t count, loff_t *off) + { +- struct obd_device *obd = data; ++ struct seq_file *m = file->private_data; + struct obd_device *obd = m->private; struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev); + __u32 val; + int rc; +@@ -559,75 +552,101 @@ static int lprocfs_wr_lfsck_verify_pfid(struct file *file, const char *buffer, -- *eof = 1; -- -- return lfsck_dump(ofd->ofd_osd, page, count, LT_LAYOUT); --} + return count; + } - -static struct lprocfs_vars lprocfs_ofd_obd_vars[] = { - { "uuid", lprocfs_rd_uuid, 0, 0 }, @@ -1671,14 +1750,14 @@ index e303fd6..1759a7d 100644 - { "lfsck_speed_limit", lprocfs_rd_lfsck_speed_limit, - lprocfs_wr_lfsck_speed_limit, 0 }, - { "lfsck_layout", lprocfs_rd_lfsck_layout, 0, 0 }, +- { "lfsck_verify_pfid", lprocfs_rd_lfsck_verify_pfid, +- lprocfs_wr_lfsck_verify_pfid, 0 }, - { 0 } -}; - -static struct lprocfs_vars lprocfs_ofd_module_vars[] = { - { "num_refs", lprocfs_rd_numrefs, 0, 0 }, -+ return lfsck_dump(m, ofd->ofd_osd, LT_LAYOUT); -+} -+LPROC_SEQ_FOPS_RO(ofd_lfsck_layout); ++LPROC_SEQ_FOPS(ofd_lfsck_verify_pfid); + +LPROC_SEQ_FOPS_RO_TYPE(ofd, uuid); +LPROC_SEQ_FOPS_RO_TYPE(ofd, blksize); @@ -1764,10 +1843,12 @@ index e303fd6..1759a7d 100644 + .fops = &ofd_job_interval_fops }, + { .name = "soft_sync_limit", + .fops = &ofd_soft_sync_limit_fops }, -+ { .name = "lfsck_speed_limit", -+ .fops = &ofd_lfsck_speed_limit_fops }, -+ { .name = "lfsck_layout", -+ .fops = &ofd_lfsck_layout_fops }, ++ { .name = "lfsck_speed_limit", ++ .fops = &ofd_lfsck_speed_limit_fops }, ++ { .name = "lfsck_layout", ++ .fops = &ofd_lfsck_layout_fops }, ++ { .name = "lfsck_verify_pfid", ++ .fops = &ofd_lfsck_verify_pfid_fops }, { 0 } }; @@ -1781,7 +1862,7 @@ index e303fd6..1759a7d 100644 { LASSERT(stats && stats->ls_num >= LPROC_OFD_STATS_LAST); diff --git a/lustre/ofd/ofd_dev.c b/lustre/ofd/ofd_dev.c -index 9900bed..a9cc81f 100644 +index 5d7f0b4..f75ffe1 100644 --- a/lustre/ofd/ofd_dev.c +++ b/lustre/ofd/ofd_dev.c @@ -240,8 +240,7 @@ static int ofd_process_config(const struct lu_env *env, struct lu_device *d, @@ -1827,16 +1908,17 @@ index 9900bed..a9cc81f 100644 if (rc) { CERROR("%s: lprocfs_obd_setup failed: %d.\n", obd->obd_name, rc); -@@ -524,7 +523,7 @@ static int ofd_procfs_init(struct ofd_device *ofd) +@@ -524,7 +523,8 @@ static int ofd_procfs_init(struct ofd_device *ofd) obd->obd_uses_nid_stats = 1; - entry = lprocfs_register("exports", obd->obd_proc_entry, NULL, NULL); -+ entry = lprocfs_seq_register("exports", obd->obd_proc_entry, NULL, NULL); ++ entry = lprocfs_seq_register("exports", obd->obd_proc_entry, NULL, ++ NULL); if (IS_ERR(entry)) { rc = PTR_ERR(entry); CERROR("%s: error %d setting up lprocfs for %s\n", -@@ -534,8 +533,10 @@ static int ofd_procfs_init(struct ofd_device *ofd) +@@ -534,8 +534,10 @@ static int ofd_procfs_init(struct ofd_device *ofd) obd->obd_proc_exports_entry = entry; entry = lprocfs_add_simple(obd->obd_proc_exports_entry, "clear", @@ -1849,7 +1931,7 @@ index 9900bed..a9cc81f 100644 if (IS_ERR(entry)) { rc = PTR_ERR(entry); CERROR("%s: add proc entry 'clear' failed: %d.\n", -@@ -551,7 +552,7 @@ static int ofd_procfs_init(struct ofd_device *ofd) +@@ -551,7 +553,7 @@ static int ofd_procfs_init(struct ofd_device *ofd) GOTO(remove_entry_clear, rc); RETURN(0); remove_entry_clear: @@ -1858,42 +1940,59 @@ index 9900bed..a9cc81f 100644 obd_cleanup: lprocfs_obd_cleanup(obd); lprocfs_free_obd_stats(obd); -@@ -564,29 +565,28 @@ static void ofd_procfs_add_brw_stats_symlink(struct ofd_device *ofd) +@@ -563,47 +565,36 @@ static void ofd_procfs_add_brw_stats_symlink(struct ofd_device *ofd) + { struct obd_device *obd = ofd_obd(ofd); struct obd_device *osd_obd = ofd->ofd_osd_exp->exp_obd; - cfs_proc_dir_entry_t *osd_root = osd_obd->obd_type->typ_procroot; +- cfs_proc_dir_entry_t *osd_root = osd_obd->obd_type->typ_procroot; - cfs_proc_dir_entry_t *osd_dir; -+ cfs_proc_dir_entry_t *osd_dir = osd_obd->obd_type->typ_procsym; ++ struct proc_dir_entry *osd_dir = osd_obd->obd_type->typ_procsym; - osd_dir = lprocfs_srch(osd_root, obd->obd_name); if (osd_dir == NULL) return; - if (lprocfs_srch(osd_dir, "brw_stats") != NULL) -+ //if (lprocfs_srch(osd_dir, "brw_stats") != NULL) - lprocfs_add_symlink("brw_stats", obd->obd_proc_entry, - "../../%s/%s/brw_stats", - osd_root->name, osd_dir->name); - +- lprocfs_add_symlink("brw_stats", obd->obd_proc_entry, +- "../../%s/%s/brw_stats", +- osd_root->name, osd_dir->name); +- - if (lprocfs_srch(osd_dir, "read_cache_enable") != NULL) -+ //if (lprocfs_srch(osd_dir, "read_cache_enable") != NULL) - lprocfs_add_symlink("read_cache_enable", obd->obd_proc_entry, - "../../%s/%s/read_cache_enable", - osd_root->name, osd_dir->name); - +- lprocfs_add_symlink("read_cache_enable", obd->obd_proc_entry, +- "../../%s/%s/read_cache_enable", +- osd_root->name, osd_dir->name); +- - if (lprocfs_srch(osd_dir, "readcache_max_filesize") != NULL) -+ //if (lprocfs_srch(osd_dir, "readcache_max_filesize") != NULL) - lprocfs_add_symlink("readcache_max_filesize", - obd->obd_proc_entry, - "../../%s/%s/readcache_max_filesize", - osd_root->name, osd_dir->name); - +- lprocfs_add_symlink("readcache_max_filesize", +- obd->obd_proc_entry, +- "../../%s/%s/readcache_max_filesize", +- osd_root->name, osd_dir->name); +- - if (lprocfs_srch(osd_dir, "writethrough_cache_enable") != NULL) -+ //if (lprocfs_srch(osd_dir, "writethrough_cache_enable") != NULL) - lprocfs_add_symlink("writethrough_cache_enable", - obd->obd_proc_entry, - "../../%s/%s/writethrough_cache_enable", -@@ -597,13 +597,8 @@ static void ofd_procfs_fini(struct ofd_device *ofd) +- lprocfs_add_symlink("writethrough_cache_enable", +- obd->obd_proc_entry, +- "../../%s/%s/writethrough_cache_enable", +- osd_root->name, osd_dir->name); ++ lprocfs_add_symlink("brw_stats", obd->obd_proc_entry, ++ "../../%s/%s/brw_stats", ++ osd_obd->obd_type->typ_name, obd->obd_name); ++ ++ lprocfs_add_symlink("read_cache_enable", obd->obd_proc_entry, ++ "../../%s/%s/read_cache_enable", ++ osd_obd->obd_type->typ_name, obd->obd_name); ++ ++ lprocfs_add_symlink("readcache_max_filesize", ++ obd->obd_proc_entry, ++ "../../%s/%s/readcache_max_filesize", ++ osd_obd->obd_type->typ_name, obd->obd_name); ++ ++ lprocfs_add_symlink("writethrough_cache_enable", ++ obd->obd_proc_entry, ++ "../../%s/%s/writethrough_cache_enable", ++ osd_obd->obd_type->typ_name, obd->obd_name); + } + + static void ofd_procfs_fini(struct ofd_device *ofd) { struct obd_device *obd = ofd_obd(ofd); @@ -1909,7 +2008,7 @@ index 9900bed..a9cc81f 100644 lprocfs_free_per_client_stats(obd); lprocfs_obd_cleanup(obd); lprocfs_free_obd_stats(obd); -@@ -2368,7 +2363,6 @@ static struct lu_device_type ofd_device_type = { +@@ -2379,7 +2370,6 @@ static struct lu_device_type ofd_device_type = { int __init ofd_init(void) { @@ -1917,24 +2016,24 @@ index 9900bed..a9cc81f 100644 int rc; rc = lu_kmem_init(ofd_caches); -@@ -2381,11 +2375,9 @@ int __init ofd_init(void) +@@ -2392,11 +2382,9 @@ int __init ofd_init(void) return(rc); } - lprocfs_ofd_init_vars(&lvars); - - rc = class_register_type(&ofd_obd_ops, NULL, NULL, + rc = class_register_type(&ofd_obd_ops, NULL, true, NULL, #ifndef HAVE_ONLY_PROCFS_SEQ -- lvars.module_vars, -+ NULL, +- lvars.module_vars, ++ NULL, #endif - LUSTRE_OST_NAME, &ofd_device_type); + LUSTRE_OST_NAME, &ofd_device_type); return rc; diff --git a/lustre/ofd/ofd_internal.h b/lustre/ofd/ofd_internal.h -index ab041ce..60cfb50 100644 +index 3aae6dd..1bdcb80 100644 --- a/lustre/ofd/ofd_internal.h +++ b/lustre/ofd/ofd_internal.h -@@ -392,13 +392,9 @@ int ofd_txn_stop_cb(const struct lu_env *env, struct thandle *txn, +@@ -403,13 +403,9 @@ int ofd_txn_stop_cb(const struct lu_env *env, struct thandle *txn, /* lproc_ofd.c */ #ifdef LPROCFS @@ -1950,10 +2049,10 @@ index ab041ce..60cfb50 100644 #endif diff --git a/lustre/osd-ldiskfs/osd_handler.c b/lustre/osd-ldiskfs/osd_handler.c -index a8022f0..4e1ec4a 100644 +index e0da7e6..14808ee 100644 --- a/lustre/osd-ldiskfs/osd_handler.c +++ b/lustre/osd-ldiskfs/osd_handler.c -@@ -5892,6 +5892,7 @@ static int osd_obd_connect(const struct lu_env *env, struct obd_export **exp, +@@ -5921,6 +5921,7 @@ static int osd_obd_connect(const struct lu_env *env, struct obd_export **exp, osd->od_connects++; spin_unlock(&osd->od_osfs_lock); @@ -1962,7 +2061,7 @@ index a8022f0..4e1ec4a 100644 } diff --git a/lustre/osd-zfs/osd_handler.c b/lustre/osd-zfs/osd_handler.c -index c9bf49a..bd2463a 100644 +index 05820e0..e711727 100644 --- a/lustre/osd-zfs/osd_handler.c +++ b/lustre/osd-zfs/osd_handler.c @@ -816,6 +816,7 @@ static int osd_obd_connect(const struct lu_env *env, struct obd_export **exp, @@ -1974,5 +2073,5 @@ index c9bf49a..bd2463a 100644 } -- -1.8.5.3 +1.9.1 diff --git a/sys-cluster/lustre/files/0009-LU-3319-procfs-update-ldiskfs-proc-handling-to-seq_f.patch b/sys-cluster/lustre/files/0009-LU-3319-procfs-update-ldiskfs-proc-handling-to-seq_f.patch index 7f9d4d784..cc93d1988 100644 --- a/sys-cluster/lustre/files/0009-LU-3319-procfs-update-ldiskfs-proc-handling-to-seq_f.patch +++ b/sys-cluster/lustre/files/0009-LU-3319-procfs-update-ldiskfs-proc-handling-to-seq_f.patch @@ -1,12 +1,11 @@ -From 98a6eee60a100d445d7533eeba907e4e75c36f18 Mon Sep 17 00:00:00 2001 +From 671de4e9a7ec811db225a763b88e48379d5a4daf Mon Sep 17 00:00:00 2001 From: James Simmons <uja.ornl@gmail.com> -Date: Sun, 9 Feb 2014 10:45:37 -0500 -Subject: [PATCH 09/12] LU-3319 procfs: update ldiskfs proc handling to - seq_files +Date: Tue, 25 Mar 2014 12:37:41 -0400 +Subject: [PATCH 9/9] LU-3319 procfs: update ldiskfs proc handling to seq_files Migrate all ldiskfs proc handling to using strictly seq_files. Also include a fix with newer gcc complaining -certain variables are initialized. +certain variables are uninitialized. Signed-off-by: James Simmons <uja.ornl@gmail.com> Change-Id: Ia296a4682e2feda02bcfbe0100de8a89404cd731 @@ -14,12 +13,12 @@ Change-Id: Ia296a4682e2feda02bcfbe0100de8a89404cd731 lustre/osd-ldiskfs/osd_compat.c | 6 +- lustre/osd-ldiskfs/osd_handler.c | 16 +- lustre/osd-ldiskfs/osd_internal.h | 6 +- - lustre/osd-ldiskfs/osd_lproc.c | 336 ++++++++++++++++++++------------------ - lustre/osd-ldiskfs/osd_scrub.c | 73 +++------ - 5 files changed, 220 insertions(+), 217 deletions(-) + lustre/osd-ldiskfs/osd_lproc.c | 343 ++++++++++++++++++++------------------ + lustre/osd-ldiskfs/osd_scrub.c | 104 ++++-------- + 5 files changed, 235 insertions(+), 240 deletions(-) diff --git a/lustre/osd-ldiskfs/osd_compat.c b/lustre/osd-ldiskfs/osd_compat.c -index e693e8d..3fb6783 100644 +index 8b91b64..6330066 100644 --- a/lustre/osd-ldiskfs/osd_compat.c +++ b/lustre/osd-ldiskfs/osd_compat.c @@ -1164,7 +1164,7 @@ int osd_obj_spec_update(struct osd_thread_info *info, struct osd_device *osd, @@ -50,53 +49,46 @@ index e693e8d..3fb6783 100644 ENTRY; diff --git a/lustre/osd-ldiskfs/osd_handler.c b/lustre/osd-ldiskfs/osd_handler.c -index 4e1ec4a..1d9a2ba 100644 +index 14808ee..2cb9af5 100644 --- a/lustre/osd-ldiskfs/osd_handler.c +++ b/lustre/osd-ldiskfs/osd_handler.c -@@ -5824,6 +5824,7 @@ static struct lu_device *osd_device_free(const struct lu_env *env, - static int osd_process_config(const struct lu_env *env, - struct lu_device *d, struct lustre_cfg *cfg) - { -+ struct obd_device *obd = d->ld_obd; - struct osd_device *o = osd_dev(d); - int rc; - ENTRY; -@@ -5838,12 +5839,12 @@ static int osd_process_config(const struct lu_env *env, +@@ -5867,12 +5867,13 @@ static int osd_process_config(const struct lu_env *env, break; case LCFG_PARAM: LASSERT(&o->od_dt_dev); - rc = class_process_proc_param(PARAM_OSD, lprocfs_osd_obd_vars, - cfg, &o->od_dt_dev); -+ rc = class_process_proc_seq_param(PARAM_OSD, obd->obd_vars, ++ rc = class_process_proc_seq_param(PARAM_OSD, ++ lprocfs_osd_obd_vars, + cfg, &o->od_dt_dev); if (rc > 0 || rc == -ENOSYS) - rc = class_process_proc_param(PARAM_OST, - lprocfs_osd_obd_vars, - cfg, &o->od_dt_dev); + rc = class_process_proc_seq_param(PARAM_OST, -+ obd->obd_vars, cfg, -+ &o->od_dt_dev); ++ lprocfs_osd_obd_vars, ++ cfg, &o->od_dt_dev); break; default: rc = -ENOSYS; -@@ -5991,9 +5992,10 @@ static int __init osd_mod_init(void) +@@ -6020,9 +6021,10 @@ static int __init osd_mod_init(void) if (rc) return rc; -- rc = class_register_type(&osd_obd_device_ops, NULL, NULL, +- rc = class_register_type(&osd_obd_device_ops, NULL, true, NULL, -#ifndef HAVE_ONLY_PROCFS_SEQ -+ rc = class_register_type(&osd_obd_device_ops, NULL, - lprocfs_osd_module_vars, ++ rc = class_register_type(&osd_obd_device_ops, NULL, true, + lprocfs_osd_module_vars, +#ifndef HAVE_ONLY_PROCFS_SEQ -+ NULL, ++ NULL, #endif - LUSTRE_OSD_LDISKFS_NAME, &osd_device_type); + LUSTRE_OSD_LDISKFS_NAME, &osd_device_type); if (rc) diff --git a/lustre/osd-ldiskfs/osd_internal.h b/lustre/osd-ldiskfs/osd_internal.h -index dc52885..7d54162 100644 +index 185d63d..e1bde19 100644 --- a/lustre/osd-ldiskfs/osd_internal.h +++ b/lustre/osd-ldiskfs/osd_internal.h -@@ -616,8 +616,8 @@ static inline int __osd_xattr_set(struct osd_thread_info *info, +@@ -617,8 +617,8 @@ static inline int __osd_xattr_set(struct osd_thread_info *info, #ifdef LPROCFS /* osd_lproc.c */ @@ -107,7 +99,7 @@ index dc52885..7d54162 100644 int osd_procfs_init(struct osd_device *osd, const char *name); int osd_procfs_fini(struct osd_device *osd); void osd_brw_stats_update(struct osd_device *osd, struct osd_iobuf *iobuf); -@@ -672,7 +672,7 @@ int osd_oii_insert(struct osd_device *dev, struct osd_idmap_cache *oic, +@@ -673,7 +673,7 @@ int osd_oii_insert(struct osd_device *dev, struct osd_idmap_cache *oic, int insert); int osd_oii_lookup(struct osd_device *dev, const struct lu_fid *fid, struct osd_inode_id *id); @@ -117,7 +109,7 @@ index dc52885..7d54162 100644 int osd_fld_lookup(const struct lu_env *env, struct osd_device *osd, obd_seq seq, struct lu_seq_range *range); diff --git a/lustre/osd-ldiskfs/osd_lproc.c b/lustre/osd-ldiskfs/osd_lproc.c -index b9b4e3d..947a4b9 100644 +index b9b4e3d..ddaa169 100644 --- a/lustre/osd-ldiskfs/osd_lproc.c +++ b/lustre/osd-ldiskfs/osd_lproc.c @@ -237,92 +237,46 @@ out: @@ -125,7 +117,8 @@ index b9b4e3d..947a4b9 100644 } -int osd_procfs_init(struct osd_device *osd, const char *name) --{ ++static int ldiskfs_osd_fstype_seq_show(struct seq_file *m, void *data) + { - struct obd_type *type; - int rc; - ENTRY; @@ -148,7 +141,8 @@ index b9b4e3d..947a4b9 100644 - osd->od_proc_entry = NULL; - GOTO(out, rc); - } -- ++ struct osd_device *osd = osd_dt_dev((struct dt_device *)m->private); + - rc = osd_stats_init(osd); - - EXIT; @@ -172,11 +166,9 @@ index b9b4e3d..947a4b9 100644 - -static int lprocfs_osd_rd_fstype(char *page, char **start, off_t off, int count, - int *eof, void *data) -+static int ldiskfs_osd_fstype_seq_show(struct seq_file *m, void *data) - { +-{ - struct osd_device *osd = osd_dt_dev(data); -+ struct osd_device *osd = osd_dt_dev((struct dt_device *)m->private); - +- - LASSERT(osd != NULL); - return snprintf(page, count, "ldiskfs\n"); + LASSERT(osd != NULL); @@ -200,7 +192,7 @@ index b9b4e3d..947a4b9 100644 + return -EINPROGRESS; - return snprintf(page, count, "%s\n", osd->od_mntdev); -+ return seq_printf(m, "%u\n", osd->od_read_cache); ++ return seq_printf(m, "%s\n", osd->od_mntdev); } +LPROC_SEQ_FOPS_RO(ldiskfs_osd_mntdev); @@ -227,14 +219,14 @@ index b9b4e3d..947a4b9 100644 { - struct osd_device *osd = osd_dt_dev(data); - int val, rc; -+ struct seq_file *m = file->private_data; ++ struct seq_file *m = file->private_data; + struct dt_device *dt = m->private; + struct osd_device *osd = osd_dt_dev(dt); + int val, rc; LASSERT(osd != NULL); if (unlikely(osd->od_mnt == NULL)) -@@ -335,24 +289,26 @@ static int lprocfs_osd_wr_cache(struct file *file, const char *buffer, +@@ -335,24 +289,27 @@ static int lprocfs_osd_wr_cache(struct file *file, const char *buffer, osd->od_read_cache = !!val; return count; } @@ -263,13 +255,14 @@ index b9b4e3d..947a4b9 100644 { - struct osd_device *osd = osd_dt_dev(data); - int val, rc; -+ struct dt_device *dt = ((struct seq_file *)file->private_data)->private; ++ struct seq_file *m = file->private_data; ++ struct dt_device *dt = m->private; + struct osd_device *osd = osd_dt_dev(dt); + int val, rc; LASSERT(osd != NULL); if (unlikely(osd->od_mnt == NULL)) -@@ -365,14 +321,16 @@ static int lprocfs_osd_wr_wcache(struct file *file, const char *buffer, +@@ -365,14 +322,17 @@ static int lprocfs_osd_wr_wcache(struct file *file, const char *buffer, osd->od_writethrough_cache = !!val; return count; } @@ -285,14 +278,15 @@ index b9b4e3d..947a4b9 100644 - struct dt_device *dt = data; - struct lu_env env; - int rc; -+ struct dt_device *dt = ((struct seq_file *)file->private_data)->private; ++ struct seq_file *m = file->private_data; ++ struct dt_device *dt = m->private; + struct osd_device *osd = osd_dt_dev(dt); + struct lu_env env; + int rc; LASSERT(osd != NULL); if (unlikely(osd->od_mnt == NULL)) -@@ -386,20 +344,18 @@ static int lprocfs_osd_wr_force_sync(struct file *file, const char *buffer, +@@ -386,20 +346,18 @@ static int lprocfs_osd_wr_force_sync(struct file *file, const char *buffer, return rc == 0 ? count : rc; } @@ -320,7 +314,7 @@ index b9b4e3d..947a4b9 100644 rc = lprocfs_write_helper(buffer, count, &pdo); if (rc != 0) -@@ -409,24 +365,25 @@ static int lprocfs_osd_wr_pdo(struct file *file, const char *buffer, +@@ -409,24 +367,26 @@ static int lprocfs_osd_wr_pdo(struct file *file, const char *buffer, return count; } @@ -349,12 +343,13 @@ index b9b4e3d..947a4b9 100644 + size_t count, loff_t *off) { - struct osd_device *dev = osd_dt_dev(data); -+ struct dt_device *dt = ((struct seq_file *)file->private_data)->private; ++ struct seq_file *m = file->private_data; ++ struct dt_device *dt = m->private; + struct osd_device *dev = osd_dt_dev(dt); int val, rc; LASSERT(dev != NULL); -@@ -440,19 +397,18 @@ static int lprocfs_osd_wr_auto_scrub(struct file *file, const char *buffer, +@@ -440,19 +400,18 @@ static int lprocfs_osd_wr_auto_scrub(struct file *file, const char *buffer, dev->od_noscrub = !val; return count; } @@ -381,13 +376,11 @@ index b9b4e3d..947a4b9 100644 { int track_declares_assert; int rc; -@@ -465,38 +421,39 @@ static int lprocfs_osd_wr_track_declares_assert(struct file *file, +@@ -465,40 +424,40 @@ static int lprocfs_osd_wr_track_declares_assert(struct file *file, return count; } +LPROC_SEQ_FOPS(ldiskfs_osd_track_declares_assert); -+ -+extern int osd_scrub_dump(struct seq_file *m, struct osd_device *dev); -static int lprocfs_osd_rd_oi_scrub(char *page, char **start, off_t off, - int count, int *eof, void *data) @@ -430,12 +423,17 @@ index b9b4e3d..947a4b9 100644 + size_t count, loff_t *off) { - struct osd_device *osd = osd_dt_dev(data); -+ struct dt_device *dt = ((struct seq_file *)file->private_data)->private; -+ struct osd_device *osd = osd_dt_dev(dt); - __u64 val; - int rc; +- __u64 val; +- int rc; ++ struct seq_file *m = file->private_data; ++ struct dt_device *dt = m->private; ++ struct osd_device *osd = osd_dt_dev(dt); ++ __u64 val; ++ int rc; -@@ -512,24 +469,25 @@ int lprocfs_osd_wr_readcache(struct file *file, const char *buffer, + LASSERT(osd != NULL); + if (unlikely(osd->od_mnt == NULL)) +@@ -512,24 +471,26 @@ int lprocfs_osd_wr_readcache(struct file *file, const char *buffer, OSD_MAX_CACHE_SIZE : val; return count; } @@ -464,12 +462,13 @@ index b9b4e3d..947a4b9 100644 + size_t count, loff_t *off) { - struct osd_device *dev = osd_dt_dev(data); -+ struct dt_device *dt = ((struct seq_file *)file->private_data)->private; ++ struct seq_file *m = file->private_data; ++ struct dt_device *dt = m->private; + struct osd_device *dev = osd_dt_dev(dt); int val; int rc; -@@ -544,38 +502,102 @@ static int lprocfs_osd_wr_lma_self_repair(struct file *file, const char *buffer, +@@ -544,38 +505,102 @@ static int lprocfs_osd_wr_lma_self_repair(struct file *file, const char *buffer, dev->od_lma_self_repair = !!val; return count; } @@ -602,10 +601,10 @@ index b9b4e3d..947a4b9 100644 +} #endif diff --git a/lustre/osd-ldiskfs/osd_scrub.c b/lustre/osd-ldiskfs/osd_scrub.c -index e558163..b5b91c8 100644 +index 7d6c011..05e9f25 100644 --- a/lustre/osd-ldiskfs/osd_scrub.c +++ b/lustre/osd-ldiskfs/osd_scrub.c -@@ -2551,80 +2551,69 @@ static const char *scrub_param_names[] = { +@@ -2571,134 +2571,112 @@ static const char *scrub_param_names[] = { NULL }; @@ -619,9 +618,11 @@ index e558163..b5b91c8 100644 int i; - rc = snprintf(*buf, *len, "%s:%c", prefix, bits != 0 ? ' ' : '\n'); +- if (rc <= 0) +- return -ENOSPC; + rc = seq_printf(m, "%s:%c", prefix, bits != 0 ? ' ' : '\n'); - if (rc <= 0) - return -ENOSPC; ++ if (rc < 0) ++ return rc; - *buf += rc; - *len -= rc; @@ -630,13 +631,15 @@ index e558163..b5b91c8 100644 bits &= ~flag; - rc = snprintf(*buf, *len, "%s%c", names[i], - bits != 0 ? ',' : '\n'); -+ rc = seq_printf(m, "%s%c", names[i], -+ bits != 0 ? ',' : '\n'); - if (rc <= 0) - return -ENOSPC; +- if (rc <= 0) +- return -ENOSPC; - - *buf += rc; - *len -= rc; ++ rc = seq_printf(m, "%s%c", names[i], ++ bits != 0 ? ',' : '\n'); ++ if (rc < 0) ++ return rc; } } - return save - *len; @@ -654,14 +657,13 @@ index e558163..b5b91c8 100644 cfs_time_current_sec() - time); else - rc = snprintf(*buf, *len, "%s: N/A\n", prefix); -+ rc = seq_printf(m, "%s: N/A\n", prefix); - if (rc <= 0) - return -ENOSPC; - +- if (rc <= 0) +- return -ENOSPC; +- - *buf += rc; - *len -= rc; -- return rc; -+ return 0; ++ rc = seq_printf(m, "%s: N/A\n", prefix); + return rc; } -static int scrub_pos_dump(char **buf, int *len, __u64 pos, const char *prefix) @@ -674,34 +676,42 @@ index e558163..b5b91c8 100644 + rc = seq_printf(m, "%s: "LPU64"\n", prefix, pos); else - rc = snprintf(*buf, *len, "%s: N/A\n", prefix); -+ rc = seq_printf(m, "%s: N/A\n", prefix); - if (rc <= 0) - return -ENOSPC; - +- if (rc <= 0) +- return -ENOSPC; +- - *buf += rc; - *len -= rc; ++ rc = seq_printf(m, "%s: N/A\n", prefix); return rc; } -int osd_scrub_dump(struct osd_device *dev, char *buf, int len) -+int osd_scrub_dump(struct seq_file *m,struct osd_device *dev) ++int osd_scrub_dump(struct seq_file *m, struct osd_device *dev) { struct osd_scrub *scrub = &dev->od_scrub; struct scrub_file *sf = &scrub->os_file; __u64 checked; __u64 speed; - int save = len; - int ret = -ENOSPC; +- int ret = -ENOSPC; int rc; down_read(&scrub->os_rwsem); - rc = snprintf(buf, len, -+ rc = seq_printf(m, - "name: OI_scrub\n" - "magic: 0x%x\n" - "oi_files: %d\n" -@@ -2634,51 +2623,48 @@ int osd_scrub_dump(struct osd_device *dev, char *buf, int len) - if (rc <= 0) +- "name: OI_scrub\n" +- "magic: 0x%x\n" +- "oi_files: %d\n" +- "status: %s\n", +- sf->sf_magic, (int)sf->sf_oi_count, +- scrub_status_names[sf->sf_status]); +- if (rc <= 0) ++ rc = seq_printf(m, "name: OI_scrub\n" ++ "magic: 0x%x\n" ++ "oi_files: %d\n" ++ "status: %s\n", ++ sf->sf_magic, (int)sf->sf_oi_count, ++ scrub_status_names[sf->sf_status]); ++ if (rc < 0) goto out; - buf += rc; @@ -761,8 +771,12 @@ index e558163..b5b91c8 100644 "updated: "LPU64"\n" "failed: "LPU64"\n" "prior_updated: "LPU64"\n" -@@ -2691,8 +2677,6 @@ int osd_scrub_dump(struct osd_device *dev, char *buf, int len) - if (rc <= 0) +@@ -2708,11 +2686,9 @@ int osd_scrub_dump(struct osd_device *dev, char *buf, int len) + checked, sf->sf_items_updated, sf->sf_items_failed, + sf->sf_items_updated_prior, sf->sf_items_noscrub, + sf->sf_items_igif, sf->sf_success_count); +- if (rc <= 0) ++ if (rc < 0) goto out; - buf += rc; @@ -770,7 +784,7 @@ index e558163..b5b91c8 100644 speed = checked; if (thread_is_running(&scrub->os_thread)) { cfs_duration_t duration = cfs_time_current() - -@@ -2705,8 +2689,7 @@ int osd_scrub_dump(struct osd_device *dev, char *buf, int len) +@@ -2725,8 +2701,7 @@ int osd_scrub_dump(struct osd_device *dev, char *buf, int len) do_div(new_checked, duration); if (rtime != 0) do_div(speed, rtime); @@ -780,7 +794,7 @@ index e558163..b5b91c8 100644 "average_speed: "LPU64" objects/sec\n" "real-time_speed: "LPU64" objects/sec\n" "current_position: %u\n" -@@ -2719,8 +2702,7 @@ int osd_scrub_dump(struct osd_device *dev, char *buf, int len) +@@ -2739,8 +2714,7 @@ int osd_scrub_dump(struct osd_device *dev, char *buf, int len) } else { if (sf->sf_run_time != 0) do_div(speed, sf->sf_run_time); @@ -790,18 +804,22 @@ index e558163..b5b91c8 100644 "average_speed: "LPU64" objects/sec\n" "real-time_speed: N/A\n" "current_position: N/A\n" -@@ -2732,10 +2714,7 @@ int osd_scrub_dump(struct osd_device *dev, char *buf, int len) +@@ -2750,14 +2724,8 @@ int osd_scrub_dump(struct osd_device *dev, char *buf, int len) + sf->sf_run_time, speed, scrub->os_lf_scanned, + scrub->os_lf_repaired, scrub->os_lf_failed); } - if (rc <= 0) - goto out; +- if (rc <= 0) +- goto out; - - buf += rc; - len -= rc; - ret = save - len; -+ ret = 0; out: up_read(&scrub->os_rwsem); +- return ret; ++ return (rc < 0 ? -ENOSPC : 0); + } -- -1.8.5.3 +1.9.1 diff --git a/sys-cluster/lustre/files/0010-LU-3319-lprocfs-client-side-cleanups.patch b/sys-cluster/lustre/files/0010-LU-3319-lprocfs-client-side-cleanups.patch deleted file mode 100644 index b076a3ad9..000000000 --- a/sys-cluster/lustre/files/0010-LU-3319-lprocfs-client-side-cleanups.patch +++ /dev/null @@ -1,463 +0,0 @@ -From 48d1258335516d5335567f11f5be91ceafbbac4e Mon Sep 17 00:00:00 2001 -From: James Simmons <uja.ornl@gmail.com> -Date: Tue, 21 Jan 2014 12:06:59 -0500 -Subject: [PATCH 10/12] LU-3319 lprocfs: client side cleanups - -Now that all the client side seq_file patches it is -time to handle the issue that people pointed out but -were not severe enough to prevent landing. This patch -addresses all the concerns as well and move all struct -lprocfs_seq_var to be initialized C99 style. - -Change-Id: I89e8b719bd067ecf4e3cab481a2d4c62d5052af0 -Signed-off-by: James Simmons <uja.ornl@gmail.com> ---- - lustre/fid/lproc_fid.c | 21 ++++++--- - lustre/lmv/lproc_lmv.c | 15 ++++--- - lustre/lov/lproc_lov.c | 42 ++++++++++++------ - lustre/mdc/lproc_mdc.c | 52 ++++++++++++++-------- - lustre/mgc/lproc_mgc.c | 25 +++++++---- - lustre/obdclass/lprocfs_status.c | 1 - - lustre/obdecho/echo.c | 3 +- - lustre/osc/lproc_osc.c | 94 +++++++++++++++++++++++++++------------- - lustre/osc/osc_request.c | 2 +- - lustre/ost/ost_handler.c | 3 +- - lustre/ptlrpc/lproc_ptlrpc.c | 2 +- - lustre/quota/qmt_pool.c | 3 +- - lustre/quota/qsd_lib.c | 12 +++-- - 13 files changed, 183 insertions(+), 92 deletions(-) - -diff --git a/lustre/fid/lproc_fid.c b/lustre/fid/lproc_fid.c -index d89c4f6..3b9d170 100644 ---- a/lustre/fid/lproc_fid.c -+++ b/lustre/fid/lproc_fid.c -@@ -203,9 +203,12 @@ LPROC_SEQ_FOPS(lprocfs_server_fid_width); - LPROC_SEQ_FOPS_RO(lprocfs_server_fid_server); - - struct lprocfs_seq_vars seq_server_proc_list[] = { -- { "space", &lprocfs_server_fid_space_fops }, -- { "width", &lprocfs_server_fid_width_fops }, -- { "server", &lprocfs_server_fid_server_fops }, -+ { .name = "space", -+ .fops = &lprocfs_server_fid_space_fops }, -+ { .name = "width", -+ .fops = &lprocfs_server_fid_width_fops }, -+ { .name = "server", -+ .fops = &lprocfs_server_fid_server_fops }, - { NULL } - }; - -@@ -623,10 +626,14 @@ LPROC_SEQ_FOPS_RO(lprocfs_client_fid_server); - LPROC_SEQ_FOPS_RO(lprocfs_client_fid_fid); - - struct lprocfs_seq_vars seq_client_proc_list[] = { -- { "space", &lprocfs_client_fid_space_fops }, -- { "width", &lprocfs_client_fid_width_fops }, -- { "server", &lprocfs_client_fid_server_fops }, -- { "fid", &lprocfs_client_fid_fid_fops }, -+ { .name = "space", -+ .fops = &lprocfs_client_fid_space_fops }, -+ { .name = "width", -+ .fops = &lprocfs_client_fid_width_fops }, -+ { .name = "server", -+ .fops = &lprocfs_client_fid_server_fops }, -+ { .name = "fid", -+ .fops = &lprocfs_client_fid_fid_fops }, - { NULL } - }; - #endif -diff --git a/lustre/lmv/lproc_lmv.c b/lustre/lmv/lproc_lmv.c -index eea5927..5a7271a 100644 ---- a/lustre/lmv/lproc_lmv.c -+++ b/lustre/lmv/lproc_lmv.c -@@ -203,11 +203,16 @@ static int lmv_target_seq_open(struct inode *inode, struct file *file) - LPROC_SEQ_FOPS_RO_TYPE(lmv, uuid); - - 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 }, -+ { .name = "numobd", -+ .fops = &lmv_numobd_fops }, -+ { .name = "placement", -+ .fops = &lmv_placement_fops }, -+ { .name = "activeobd", -+ .fops = &lmv_activeobd_fops }, -+ { .name = "uuid", -+ .fops = &lmv_uuid_fops }, -+ { .name = "desc_uuid", -+ .fops = &lmv_desc_uuid_fops }, - { 0 } - }; - -diff --git a/lustre/lov/lproc_lov.c b/lustre/lov/lproc_lov.c -index e400faf..7786513 100644 ---- a/lustre/lov/lproc_lov.c -+++ b/lustre/lov/lproc_lov.c -@@ -263,20 +263,34 @@ LPROC_SEQ_FOPS_RO_TYPE(lov, kbytesfree); - LPROC_SEQ_FOPS_RO_TYPE(lov, kbytesavail); - - struct lprocfs_seq_vars lprocfs_lov_obd_vars[] = { -- { "uuid", &lov_uuid_fops }, -- { "stripesize", &lov_stripesize_fops }, -- { "stripeoffset", &lov_stripeoffset_fops }, -- { "stripecount", &lov_stripecount_fops }, -- { "stripetype", &lov_stripetype_fops }, -- { "numobd", &lov_numobd_fops }, -- { "activeobd", &lov_activeobd_fops }, -- { "filestotal", &lov_filestotal_fops }, -- { "filesfree", &lov_filesfree_fops }, -- { "blocksize", &lov_blksize_fops }, -- { "kbytestotal", &lov_kbytestotal_fops }, -- { "kbytesfree", &lov_kbytesfree_fops }, -- { "kbytesavail", &lov_kbytesavail_fops }, -- { "desc_uuid", &lov_desc_uuid_fops }, -+ { .name = "uuid", -+ .fops = &lov_uuid_fops }, -+ { .name = "stripesize", -+ .fops = &lov_stripesize_fops }, -+ { .name = "stripeoffset", -+ .fops = &lov_stripeoffset_fops }, -+ { .name = "stripecount", -+ .fops = &lov_stripecount_fops }, -+ { .name = "stripetype", -+ .fops = &lov_stripetype_fops }, -+ { .name = "numobd", -+ .fops = &lov_numobd_fops }, -+ { .name = "activeobd", -+ .fops = &lov_activeobd_fops }, -+ { .name = "filestotal", -+ .fops = &lov_filestotal_fops }, -+ { .name = "filesfree", -+ .fops = &lov_filesfree_fops }, -+ { .name = "blocksize", -+ .fops = &lov_blksize_fops }, -+ { .name = "kbytestotal", -+ .fops = &lov_kbytestotal_fops }, -+ { .name = "kbytesfree", -+ .fops = &lov_kbytesfree_fops }, -+ { .name = "kbytesavail", -+ .fops = &lov_kbytesavail_fops }, -+ { .name = "desc_uuid", -+ .fops = &lov_desc_uuid_fops }, - { 0 } - }; - -diff --git a/lustre/mdc/lproc_mdc.c b/lustre/mdc/lproc_mdc.c -index cba4f61..69e377f 100644 ---- a/lustre/mdc/lproc_mdc.c -+++ b/lustre/mdc/lproc_mdc.c -@@ -103,29 +103,47 @@ LPROC_SEQ_FOPS_RW_TYPE(mdc, import); - LPROC_SEQ_FOPS_RW_TYPE(mdc, pinger_recov); - - struct lprocfs_seq_vars lprocfs_mdc_obd_vars[] = { -- { "uuid", &mdc_uuid_fops, 0, 0 }, -- { "ping", &mdc_ping_fops, 0, 0222 }, -- { "connect_flags", &mdc_connect_flags_fops,0, 0 }, -- { "blocksize", &mdc_blksize_fops, 0, 0 }, -- { "kbytestotal", &mdc_kbytestotal_fops, 0, 0 }, -- { "kbytesfree", &mdc_kbytesfree_fops, 0, 0 }, -- { "kbytesavail", &mdc_kbytesavail_fops, 0, 0 }, -- { "filestotal", &mdc_filestotal_fops, 0, 0 }, -- { "filesfree", &mdc_filesfree_fops, 0, 0 }, -- { "mds_server_uuid", &mdc_server_uuid_fops, 0, 0 }, -- { "mds_conn_uuid", &mdc_conn_uuid_fops, 0, 0 }, -+ { .name = "uuid", -+ .fops = &mdc_uuid_fops }, -+ { .name = "ping", -+ .fops = &mdc_ping_fops, -+ .proc_mode = 0222 }, -+ { .name = "connect_flags", -+ .fops = &mdc_connect_flags_fops }, -+ { .name = "blocksize", -+ .fops = &mdc_blksize_fops }, -+ { .name = "kbytestotal", -+ .fops = &mdc_kbytestotal_fops }, -+ { .name = "kbytesfree", -+ .fops = &mdc_kbytesfree_fops }, -+ { .name = "kbytesavail", -+ .fops = &mdc_kbytesavail_fops }, -+ { .name = "filestotal", -+ .fops = &mdc_filestotal_fops }, -+ { .name = "filesfree", -+ .fops = &mdc_filesfree_fops }, -+ { .name = "mds_server_uuid", -+ .fops = &mdc_server_uuid_fops }, -+ { .name = "mds_conn_uuid", -+ .fops = &mdc_conn_uuid_fops }, - /* - * FIXME: below proc entry is provided, but not in used, instead - * sbi->sb_md_brw_size is used, the per obd variable should be used - * when CMD is enabled, and dir pages are managed in MDC layer. - * Remember to enable proc write function. - */ -- { "max_pages_per_rpc", &mdc_obd_max_pages_per_rpc_fops }, -- { "max_rpcs_in_flight", &mdc_max_rpcs_in_flight_fops }, -- { "timeouts", &mdc_timeouts_fops }, -- { "import", &mdc_import_fops }, -- { "state", &mdc_state_fops }, -- { "pinger_recov", &mdc_pinger_recov_fops }, -+ { .name = "max_pages_per_rpc", -+ .fops = &mdc_obd_max_pages_per_rpc_fops }, -+ { .name = "max_rpcs_in_flight", -+ .fops = &mdc_max_rpcs_in_flight_fops }, -+ { .name = "timeouts", -+ .fops = &mdc_timeouts_fops }, -+ { .name = "import", -+ .fops = &mdc_import_fops }, -+ { .name = "state", -+ .fops = &mdc_state_fops }, -+ { .name = "pinger_recov", -+ .fops = &mdc_pinger_recov_fops }, - { 0 } - }; - #endif /* LPROCFS */ -diff --git a/lustre/mgc/lproc_mgc.c b/lustre/mgc/lproc_mgc.c -index 648b6e5..f818def 100644 ---- a/lustre/mgc/lproc_mgc.c -+++ b/lustre/mgc/lproc_mgc.c -@@ -59,14 +59,23 @@ static int mgc_ir_state_seq_show(struct seq_file *m, void *v) - LPROC_SEQ_FOPS_RO(mgc_ir_state); - - struct lprocfs_seq_vars lprocfs_mgc_obd_vars[] = { -- { "uuid", &mgc_uuid_fops, 0, 0 }, -- { "ping", &mgc_ping_fops, 0, 0222 }, -- { "connect_flags", &mgc_connect_flags_fops,0, 0 }, -- { "mgs_server_uuid", &mgc_server_uuid_fops, 0, 0 }, -- { "mgs_conn_uuid", &mgc_conn_uuid_fops, 0, 0 }, -- { "import", &mgc_import_fops, 0, 0 }, -- { "state", &mgc_state_fops, 0, 0 }, -- { "ir_state", &mgc_ir_state_fops, 0, 0 }, -+ { .name = "uuid", -+ .fops = &mgc_uuid_fops }, -+ { .name = "ping", -+ .fops = &mgc_ping_fops, -+ .proc_mode = 0222 }, -+ { .name = "connect_flags", -+ .fops = &mgc_connect_flags_fops }, -+ { .name = "mgs_server_uuid", -+ .fops = &mgc_server_uuid_fops }, -+ { .name = "mgs_conn_uuid", -+ .fops = &mgc_conn_uuid_fops }, -+ { .name = "import", -+ .fops = &mgc_import_fops }, -+ { .name = "state", -+ .fops = &mgc_state_fops }, -+ { .name = "ir_state", -+ .fops = &mgc_ir_state_fops }, - { 0 } - }; - #endif /* LPROCFS */ -diff --git a/lustre/obdclass/lprocfs_status.c b/lustre/obdclass/lprocfs_status.c -index 5b72a5a..551f629 100644 ---- a/lustre/obdclass/lprocfs_status.c -+++ b/lustre/obdclass/lprocfs_status.c -@@ -2583,7 +2583,6 @@ void lprocfs_init_ldlm_stats(struct lprocfs_stats *ldlm_stats) - EXPORT_SYMBOL(lprocfs_init_ldlm_stats); - - #ifdef HAVE_SERVER_SUPPORT --/* No one appears to be using this ?? */ - int lprocfs_exp_nid_seq_show(struct seq_file *m, void *data) - { - struct obd_export *exp = m->private; -diff --git a/lustre/obdecho/echo.c b/lustre/obdecho/echo.c -index 6d63aff..8563e68 100644 ---- a/lustre/obdecho/echo.c -+++ b/lustre/obdecho/echo.c -@@ -561,7 +561,8 @@ commitrw_cleanup: - - LPROC_SEQ_FOPS_RO_TYPE(echo, uuid); - static struct lprocfs_seq_vars lprocfs_echo_obd_vars[] = { -- { "uuid", &echo_uuid_fops }, -+ { .name = "uuid", -+ .fops = &echo_uuid_fops }, - { 0 } - }; - -diff --git a/lustre/osc/lproc_osc.c b/lustre/osc/lproc_osc.c -index d6e3703..ccfc212 100644 ---- a/lustre/osc/lproc_osc.c -+++ b/lustre/osc/lproc_osc.c -@@ -543,37 +543,69 @@ LPROC_SEQ_FOPS_RW_TYPE(osc, import); - LPROC_SEQ_FOPS_RW_TYPE(osc, pinger_recov); - - struct lprocfs_seq_vars lprocfs_osc_obd_vars[] = { -- { "uuid", &osc_uuid_fops }, -- { "ping", &osc_ping_fops, 0, 0222 }, -- { "connect_flags", &osc_connect_flags_fops }, -- { "blocksize", &osc_blksize_fops }, -- { "kbytestotal", &osc_kbytestotal_fops }, -- { "kbytesfree", &osc_kbytesfree_fops }, -- { "kbytesavail", &osc_kbytesavail_fops }, -- { "filestotal", &osc_filestotal_fops }, -- { "filesfree", &osc_filesfree_fops }, -- { "ost_server_uuid", &osc_server_uuid_fops }, -- { "ost_conn_uuid", &osc_conn_uuid_fops }, -- { "active", &osc_active_fops }, -- { "max_pages_per_rpc", &osc_obd_max_pages_per_rpc_fops }, -- { "max_rpcs_in_flight", &osc_max_rpcs_in_flight_fops }, -- { "destroys_in_flight", &osc_destroys_in_flight_fops }, -- { "max_dirty_mb", &osc_max_dirty_mb_fops }, -- { "osc_cached_mb", &osc_cached_mb_fops }, -- { "cur_dirty_bytes", &osc_cur_dirty_bytes_fops }, -- { "cur_grant_bytes", &osc_cur_grant_bytes_fops }, -- { "cur_lost_grant_bytes", &osc_cur_lost_grant_bytes_fops }, -- { "grant_shrink_interval", &osc_grant_shrink_interval_fops }, -- { "checksums", &osc_checksum_fops }, -- { "checksum_type", &osc_checksum_type_fops }, -- { "resend_count", &osc_resend_count_fops }, -- { "timeouts", &osc_timeouts_fops }, -- { "contention_seconds", &osc_contention_seconds_fops }, -- { "lockless_truncate", &osc_lockless_truncate_fops }, -- { "import", &osc_import_fops }, -- { "state", &osc_state_fops }, -- { "pinger_recov", &osc_pinger_recov_fops }, -- { "unstable_stats", &osc_unstable_stats_fops }, -+ { .name = "uuid", -+ .fops = &osc_uuid_fops }, -+ { .name = "ping", -+ .fops = &osc_ping_fops, -+ .proc_mode = 0222 }, -+ { .name = "connect_flags", -+ .fops = &osc_connect_flags_fops }, -+ { .name = "blocksize", -+ .fops = &osc_blksize_fops }, -+ { .name = "kbytestotal", -+ .fops = &osc_kbytestotal_fops }, -+ { .name = "kbytesfree", -+ .fops = &osc_kbytesfree_fops }, -+ { .name = "kbytesavail", -+ .fops = &osc_kbytesavail_fops }, -+ { .name = "filestotal", -+ .fops = &osc_filestotal_fops }, -+ { .name = "filesfree", -+ .fops = &osc_filesfree_fops }, -+ { .name = "ost_server_uuid", -+ .fops = &osc_server_uuid_fops }, -+ { .name = "ost_conn_uuid", -+ .fops = &osc_conn_uuid_fops }, -+ { .name = "active", -+ .fops = &osc_active_fops }, -+ { .name = "max_pages_per_rpc", -+ .fops = &osc_obd_max_pages_per_rpc_fops }, -+ { .name = "max_rpcs_in_flight", -+ .fops = &osc_max_rpcs_in_flight_fops }, -+ { .name = "destroys_in_flight", -+ .fops = &osc_destroys_in_flight_fops }, -+ { .name = "max_dirty_mb", -+ .fops = &osc_max_dirty_mb_fops }, -+ { .name = "osc_cached_mb", -+ .fops = &osc_cached_mb_fops }, -+ { .name = "cur_dirty_bytes", -+ .fops = &osc_cur_dirty_bytes_fops }, -+ { .name = "cur_grant_bytes", -+ .fops = &osc_cur_grant_bytes_fops }, -+ { .name = "cur_lost_grant_bytes", -+ .fops = &osc_cur_lost_grant_bytes_fops }, -+ { .name = "grant_shrink_interval", -+ .fops = &osc_grant_shrink_interval_fops }, -+ { .name = "checksums", -+ .fops = &osc_checksum_fops }, -+ { .name = "checksum_type", -+ .fops = &osc_checksum_type_fops }, -+ { .name = "resend_count", -+ .fops = &osc_resend_count_fops }, -+ { .name = "timeouts", -+ .fops = &osc_timeouts_fops }, -+ { .name = "contention_seconds", -+ .fops = &osc_contention_seconds_fops }, -+ { .name = "lockless_truncate", -+ .fops = &osc_lockless_truncate_fops }, -+ { .name = "import", -+ .fops = &osc_import_fops }, -+ { .name = "state", -+ .fops = &osc_state_fops }, -+ { .name = "pinger_recov", -+ .fops = &osc_pinger_recov_fops }, -+ { .name = "unstable_stats", -+ .fops = &osc_unstable_stats_fops }, - { 0 } - }; - -diff --git a/lustre/osc/osc_request.c b/lustre/osc/osc_request.c -index b9d1b71..f95fb55 100644 ---- a/lustre/osc/osc_request.c -+++ b/lustre/osc/osc_request.c -@@ -3669,7 +3669,7 @@ int osc_process_config_base(struct obd_device *obd, struct lustre_cfg *lcfg) - { - int rc = class_process_proc_seq_param(PARAM_OSC, obd->obd_vars, - lcfg, obd); -- return(rc > 0 ? 0: rc); -+ return rc > 0 ? 0: rc; - } - - static int osc_process_config(struct obd_device *obd, obd_count len, void *buf) -diff --git a/lustre/ost/ost_handler.c b/lustre/ost/ost_handler.c -index a39381f..d5458b2 100644 ---- a/lustre/ost/ost_handler.c -+++ b/lustre/ost/ost_handler.c -@@ -75,7 +75,8 @@ static struct cfs_cpt_table *ost_io_cptable; - LPROC_SEQ_FOPS_RO_TYPE(ost, uuid); - - static struct lprocfs_seq_vars lprocfs_ost_obd_vars[] = { -- { "uuid", &ost_uuid_fops }, -+ { .name = "uuid", -+ .fops = &ost_uuid_fops }, - { 0 } - }; - #endif /* LPROCFS */ -diff --git a/lustre/ptlrpc/lproc_ptlrpc.c b/lustre/ptlrpc/lproc_ptlrpc.c -index 8e5a397..bf21958 100644 ---- a/lustre/ptlrpc/lproc_ptlrpc.c -+++ b/lustre/ptlrpc/lproc_ptlrpc.c -@@ -1382,7 +1382,7 @@ lprocfs_import_seq_write(struct file *file, const char *buffer, size_t count, - - *ptr = 0; - do_reconn = 0; -- ptr += strlen("::"); -+ ptr += 2; /* Skip :: */ - inst = simple_strtol(ptr, &endptr, 10); - if (*endptr) { - CERROR("config: wrong instance # %s\n", ptr); -diff --git a/lustre/quota/qmt_pool.c b/lustre/quota/qmt_pool.c -index afd450c..df6d6fc 100644 ---- a/lustre/quota/qmt_pool.c -+++ b/lustre/quota/qmt_pool.c -@@ -171,7 +171,8 @@ static int qpi_state_seq_show(struct seq_file *m, void *data) - LPROC_SEQ_FOPS_RO(qpi_state); - - static struct lprocfs_seq_vars lprocfs_quota_qpi_vars[] = { -- { "info", &qpi_state_fops }, -+ { .name = "info", -+ .fops = &qpi_state_fops }, - { NULL } - }; - -diff --git a/lustre/quota/qsd_lib.c b/lustre/quota/qsd_lib.c -index 990cfee..573473c 100644 ---- a/lustre/quota/qsd_lib.c -+++ b/lustre/quota/qsd_lib.c -@@ -208,10 +208,14 @@ qsd_timeout_seq_write(struct file *file, const char *buffer, - LPROC_SEQ_FOPS(qsd_timeout); - - static struct lprocfs_seq_vars lprocfs_quota_qsd_vars[] = { -- { "info", &qsd_state_fops }, -- { "enabled", &qsd_enabled_fops }, -- { "force_reint", &qsd_force_reint_fops }, -- { "timeout", &qsd_timeout_fops }, -+ { .name = "info", -+ .fops = &qsd_state_fops }, -+ { .name = "enabled", -+ .fops = &qsd_enabled_fops }, -+ { .name = "force_reint", -+ .fops = &qsd_force_reint_fops }, -+ { .name = "timeout", -+ .fops = &qsd_timeout_fops }, - { NULL } - }; - --- -1.8.5.3 - diff --git a/sys-cluster/lustre/files/0011-LU-3974-llite-use-new-struct-dir_context.patch b/sys-cluster/lustre/files/0011-LU-3974-llite-use-new-struct-dir_context.patch deleted file mode 100644 index 5b3983dee..000000000 --- a/sys-cluster/lustre/files/0011-LU-3974-llite-use-new-struct-dir_context.patch +++ /dev/null @@ -1,254 +0,0 @@ -From b3af9f9fde020df881b52b059a9e0d5d2c6ccfb9 Mon Sep 17 00:00:00 2001 -From: James Simmons <uja.ornl@gmail.com> -Date: Mon, 20 Jan 2014 21:23:00 -0500 -Subject: [PATCH 11/12] 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 -kernel a new struct dir_context was introduced to -minimize the impact of future expansion. This patch -addresses this change. - -Conflicts: - lustre/llite/dir.c - -Signed-off-by: James Simmons <uja.ornl@gmail.com> -Change-Id: Ib42bf8cb06635a2a64e63b294d79e66ac82a1a5b -Signed-off-by: Alexey Shvetsov <alexxy@gentoo.org> ---- - lustre/autoconf/lustre-core.m4 | 20 ++++++++++++++++ - lustre/llite/dir.c | 54 ++++++++++++++++++++++++++++++++---------- - lustre/llite/llite_internal.h | 14 ++++++++--- - lustre/llite/llite_nfs.c | 17 +++++++++---- - 4 files changed, 85 insertions(+), 20 deletions(-) - -diff --git a/lustre/autoconf/lustre-core.m4 b/lustre/autoconf/lustre-core.m4 -index e6207c9..f44a277 100644 ---- a/lustre/autoconf/lustre-core.m4 -+++ b/lustre/autoconf/lustre-core.m4 -@@ -1349,6 +1349,25 @@ LB_LINUX_TRY_COMPILE([ - ]) - - # -+# 3.11 readdir now takes the new struct dir_context -+# -+AC_DEFUN([LC_HAVE_DIR_CONTEXT], -+[AC_MSG_CHECKING([if dir_context exist]) -+LB_LINUX_TRY_COMPILE([ -+ #include <linux/fs.h> -+],[ -+ struct dir_context ctx; -+ -+ ctx.pos = 0; -+],[ -+ AC_DEFINE(HAVE_DIR_CONTEXT, 1, [dir_context exist]) -+ AC_MSG_RESULT([yes]) -+],[ -+ AC_MSG_RESULT([no]) -+]) -+]) -+ -+# - # 3.11 dentry_operations.d_compare() taken 5 arguments. - # - AC_DEFUN([LC_D_COMPARE_5ARGS], -@@ -1523,6 +1542,7 @@ AC_DEFUN([LC_PROG_LINUX], - LC_BLKDEV_RELEASE_RETURN_INT - - # 3.11 -+ LC_HAVE_DIR_CONTEXT - LC_D_COMPARE_5ARGS - LC_HAVE_DCOUNT - -diff --git a/lustre/llite/dir.c b/lustre/llite/dir.c -index 6a1e3c5..05639f0 100644 ---- a/lustre/llite/dir.c -+++ b/lustre/llite/dir.c -@@ -195,9 +195,16 @@ struct lu_dirent *ll_dir_entry_next(struct inode *dir, - return entry; - } - -+ -+#ifdef HAVE_DIR_CONTEXT -+int ll_dir_read(struct inode *inode, struct md_op_data *op_data, -+ struct dir_context *ctx) -+{ -+#else - int ll_dir_read(struct inode *inode, struct md_op_data *op_data, - void *cookie, filldir_t filldir) - { -+#endif - struct ll_sb_info *sbi = ll_i2sbi(inode); - struct ll_dir_chain chain; - struct lu_dirent *ent; -@@ -241,12 +248,17 @@ int ll_dir_read(struct inode *inode, struct md_op_data *op_data, - fid_le_to_cpu(&fid, &ent->lde_fid); - ino = cl_fid_build_ino(&fid, api32); - type = ll_dirent_type_get(ent); -+ -+#ifdef HAVE_DIR_CONTEXT - /* For 'll_nfs_get_name_filldir()', it will try - * to access the 'ent' through its 'lde_name', - * so the parameter 'name' for 'filldir()' must - * be part of the 'ent'. */ -+ done = !dir_emit(ctx, ent->lde_name, namelen, ino, type); -+#else - done = filldir(cookie, ent->lde_name, namelen, lhash, - ino, type); -+#endif - if (done) { - if (op_data->op_hash_offset != MDS_DIR_END_OFF) - op_data->op_hash_offset = last_hash; -@@ -268,7 +280,11 @@ int ll_dir_read(struct inode *inode, struct md_op_data *op_data, - RETURN(rc); - } - -+#ifdef HAVE_DIR_CONTEXT -+static int ll_iterate(struct file *filp, struct dir_context *ctx) -+#else - static int ll_readdir(struct file *filp, void *cookie, filldir_t filldir) -+#endif - { - struct inode *inode = filp->f_dentry->d_inode; - struct ll_file_data *lfd = LUSTRE_FPRIVATE(filp); -@@ -305,22 +321,32 @@ static int ll_readdir(struct file *filp, void *cookie, filldir_t filldir) - - op_data->op_hash_offset = pos; - op_data->op_max_pages = sbi->ll_md_brw_size >> PAGE_CACHE_SHIFT; -+#ifdef HAVE_DIR_CONTEXT -+ ctx->pos = pos; -+ rc = ll_dir_read(inode, op_data, ctx); -+ pos = ctx->pos; -+#else - rc = ll_dir_read(inode, op_data, cookie, filldir); -+#endif - if (lfd != NULL) - lfd->lfd_pos = op_data->op_hash_offset; - - if (pos == MDS_DIR_END_OFF) { - if (api32) -- filp->f_pos = LL_DIR_END_OFF_32BIT; -+ pos = LL_DIR_END_OFF_32BIT; - else -- filp->f_pos = LL_DIR_END_OFF; -+ pos = LL_DIR_END_OFF; - } else { - if (api32 && hash64) -- filp->f_pos = op_data->op_hash_offset >> 32; -+ pos = op_data->op_hash_offset >> 32; - else -- filp->f_pos = op_data->op_hash_offset; -+ pos = op_data->op_hash_offset; - } -- -+#ifdef HAVE_DIR_CONTEXT -+ ctx->pos = pos; -+#else -+ filp->f_pos = pos; -+#endif - ll_finish_md_op_data(op_data); - filp->f_version = inode->i_version; - #ifdef HAVE_TOUCH_ATIME_1ARG -@@ -1809,11 +1835,15 @@ int ll_dir_release(struct inode *inode, struct file *file) - } - - struct file_operations ll_dir_operations = { -- .llseek = ll_dir_seek, -- .open = ll_dir_open, -- .release = ll_dir_release, -- .read = generic_read_dir, -- .readdir = ll_readdir, -- .unlocked_ioctl = ll_dir_ioctl, -- .fsync = ll_fsync, -+ .llseek = ll_dir_seek, -+ .open = ll_dir_open, -+ .release = ll_dir_release, -+ .read = generic_read_dir, -+#ifdef HAVE_DIR_CONTEXT -+ .iterate = ll_iterate, -+#else -+ .readdir = ll_readdir, -+#endif -+ .unlocked_ioctl = ll_dir_ioctl, -+ .fsync = ll_fsync, - }; -diff --git a/lustre/llite/llite_internal.h b/lustre/llite/llite_internal.h -index 59ecdfb..148f6fa 100644 ---- a/lustre/llite/llite_internal.h -+++ b/lustre/llite/llite_internal.h -@@ -92,9 +92,12 @@ extern struct file_operations ll_pgcache_seq_fops; - #define REMOTE_PERM_HASHSIZE 16 - - struct ll_getname_data { -- char *lgd_name; /* points to a buffer with NAME_MAX+1 size */ -- struct lu_fid lgd_fid; /* target fid we are looking for */ -- int lgd_found; /* inode matched? */ -+#ifdef HAVE_DIR_CONTEXT -+ struct dir_context ctx; -+#endif -+ char *lgd_name; /* points to a buffer with NAME_MAX+1 size */ -+ struct lu_fid lgd_fid; /* target fid we are looking for */ -+ int lgd_found; /* inode matched? */ - }; - - /* llite setxid/access permission for user on remote client */ -@@ -726,8 +729,13 @@ static void ll_stats_ops_tally(struct ll_sb_info *sbi, int op, int count) {} - /* llite/dir.c */ - extern struct file_operations ll_dir_operations; - extern struct inode_operations ll_dir_inode_operations; -+#ifdef HAVE_DIR_CONTEXT -+int ll_dir_read(struct inode *inode, struct md_op_data *op_data, -+ struct dir_context *ctx); -+#else - int ll_dir_read(struct inode *inode, struct md_op_data *op_data, - void *cookie, filldir_t filldir); -+#endif - int ll_get_mdt_idx(struct inode *inode); - - struct lu_dirent *ll_dir_entry_start(struct inode *dir, -diff --git a/lustre/llite/llite_nfs.c b/lustre/llite/llite_nfs.c -index f96d17e..713e846 100644 ---- a/lustre/llite/llite_nfs.c -+++ b/lustre/llite/llite_nfs.c -@@ -230,7 +230,14 @@ static int ll_get_name(struct dentry *dentry, char *name, - struct dentry *child) - { - struct inode *dir = dentry->d_inode; -- struct ll_getname_data lgd; -+ struct ll_getname_data lgd = { -+ .lgd_name = name, -+ .lgd_fid = ll_i2info(child->d_inode)->lli_fid, -+#ifdef HAVE_DIR_CONTEXT -+ .ctx.actor = ll_nfs_get_name_filldir, -+#endif -+ .lgd_found = 0, -+ }; - struct md_op_data *op_data; - int rc; - ENTRY; -@@ -241,10 +248,6 @@ static int ll_get_name(struct dentry *dentry, char *name, - if (!dir->i_fop) - GOTO(out, rc = -EINVAL); - -- lgd.lgd_name = name; -- lgd.lgd_fid = ll_i2info(child->d_inode)->lli_fid; -- lgd.lgd_found = 0; -- - op_data = ll_prep_md_op_data(NULL, dir, dir, NULL, 0, 0, - LUSTRE_OPC_ANY, dir); - if (IS_ERR(op_data)) -@@ -254,7 +257,11 @@ static int ll_get_name(struct dentry *dentry, char *name, - op_data->op_max_pages = - ll_i2sbi(dir)->ll_md_brw_size >> PAGE_CACHE_SHIFT; - mutex_lock(&dir->i_mutex); -+#ifdef HAVE_DIR_CONTEXT -+ rc = ll_dir_read(dir, op_data, &lgd.ctx); -+#else - rc = ll_dir_read(dir, op_data, &lgd, ll_nfs_get_name_filldir); -+#endif - mutex_unlock(&dir->i_mutex); - ll_finish_md_op_data(op_data); - if (!rc && !lgd.lgd_found) --- -1.8.5.3 - diff --git a/sys-cluster/lustre/files/0012-LU-3974-llite-invalidatepage-api-changed.patch b/sys-cluster/lustre/files/0012-LU-3974-llite-invalidatepage-api-changed.patch deleted file mode 100644 index 90e558ece..000000000 --- a/sys-cluster/lustre/files/0012-LU-3974-llite-invalidatepage-api-changed.patch +++ /dev/null @@ -1,134 +0,0 @@ -From 95cacafafbc5bc0ec28bbf7898df28bb0f0295e6 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 12/12] 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 -in the page to invalidate. Starting with the 3.11 kernel -you can also specify the length of the data in the page -to invalidate. This patch enables us to handle the new -case. - -Signed-off-by: James Simmons <uja.ornl@gmail.com> -Change-Id: Iedf458b20b2604bc3099d5ae38bf0ad07df83bd3 ---- - lustre/autoconf/lustre-core.m4 | 20 ++++++++++++++++++++ - lustre/include/linux/lustre_patchless_compat.h | 19 +++++++++++-------- - lustre/llite/rw26.c | 24 +++++++++++++++++------- - 3 files changed, 48 insertions(+), 15 deletions(-) - -diff --git a/lustre/autoconf/lustre-core.m4 b/lustre/autoconf/lustre-core.m4 -index f44a277..5409fde 100644 ---- a/lustre/autoconf/lustre-core.m4 -+++ b/lustre/autoconf/lustre-core.m4 -@@ -1349,6 +1349,25 @@ LB_LINUX_TRY_COMPILE([ - ]) - - # -+# 3.11 invalidatepage requires the length of the range to invalidate -+# -+AC_DEFUN([LC_INVALIDATE_RANGE], -+[AC_MSG_CHECKING([if address_space_operations.invalidatepage requires 3 arguments]) -+LB_LINUX_TRY_COMPILE([ -+ #include <linux/fs.h> -+],[ -+ struct address_space_operations a_ops; -+ -+ a_ops.invalidatepage(NULL,0,0); -+],[ -+ AC_DEFINE(HAVE_INVALIDATE_RANGE, 1, [address_space_operations.invalidatepage needs 3 arguments]) -+ AC_MSG_RESULT([yes]) -+],[ -+ AC_MSG_RESULT([no]) -+]) -+]) -+ -+# - # 3.11 readdir now takes the new struct dir_context - # - AC_DEFUN([LC_HAVE_DIR_CONTEXT], -@@ -1542,6 +1561,7 @@ AC_DEFUN([LC_PROG_LINUX], - LC_BLKDEV_RELEASE_RETURN_INT - - # 3.11 -+ LC_INVALIDATE_RANGE - LC_HAVE_DIR_CONTEXT - LC_D_COMPARE_5ARGS - LC_HAVE_DCOUNT -diff --git a/lustre/include/linux/lustre_patchless_compat.h b/lustre/include/linux/lustre_patchless_compat.h -index 747bd4d..5b7bab6 100644 ---- a/lustre/include/linux/lustre_patchless_compat.h -+++ b/lustre/include/linux/lustre_patchless_compat.h -@@ -78,15 +78,18 @@ static inline void ll_delete_from_page_cache(struct page *page) - static inline void - truncate_complete_page(struct address_space *mapping, struct page *page) - { -- if (page->mapping != mapping) -- return; -+ if (page->mapping != mapping) -+ return; - -- if (PagePrivate(page)) -- page->mapping->a_ops->invalidatepage(page, 0); -- -- cancel_dirty_page(page, PAGE_SIZE); -- ClearPageMappedToDisk(page); -- ll_delete_from_page_cache(page); -+ if (PagePrivate(page)) -+#ifdef HAVE_INVALIDATE_RANGE -+ page->mapping->a_ops->invalidatepage(page, 0, PAGE_CACHE_SIZE); -+#else -+ page->mapping->a_ops->invalidatepage(page, 0); -+#endif -+ cancel_dirty_page(page, PAGE_SIZE); -+ ClearPageMappedToDisk(page); -+ ll_delete_from_page_cache(page); - } - #endif /* !HAVE_TRUNCATE_COMPLETE_PAGE */ - -diff --git a/lustre/llite/rw26.c b/lustre/llite/rw26.c -index 447dc43..77151de 100644 ---- a/lustre/llite/rw26.c -+++ b/lustre/llite/rw26.c -@@ -76,7 +76,13 @@ - * aligned truncate). Lustre leaves partially truncated page in the cache, - * relying on struct inode::i_size to limit further accesses. - */ --static void ll_invalidatepage(struct page *vmpage, unsigned long offset) -+static void ll_invalidatepage(struct page *vmpage, -+#ifdef HAVE_INVALIDATE_RANGE -+ unsigned int offset, unsigned int length -+#else -+ unsigned long offset -+#endif -+ ) - { - struct inode *inode; - struct lu_env *env; -@@ -88,12 +94,16 @@ static void ll_invalidatepage(struct page *vmpage, unsigned long offset) - LASSERT(PageLocked(vmpage)); - LASSERT(!PageWriteback(vmpage)); - -- /* -- * It is safe to not check anything in invalidatepage/releasepage -- * below because they are run with page locked and all our io is -- * happening with locked page too -- */ -- if (offset == 0) { -+ /* -+ * It is safe to not check anything in invalidatepage/releasepage -+ * below because they are run with page locked and all our io is -+ * happening with locked page too -+ */ -+#ifdef HAVE_INVALIDATE_RANGE -+ if (offset == 0 && length == PAGE_CACHE_SIZE) { -+#else -+ if (offset == 0) { -+#endif - env = cl_env_get(&refcheck); - if (!IS_ERR(env)) { - inode = vmpage->mapping->host; --- -1.8.5.3 - |