From 8828aa8e75f28808da42f521662a245c6b8a9896 Mon Sep 17 00:00:00 2001 From: "Mr. NeilBrown" Date: Fri, 7 Oct 2022 08:57:29 -0400 Subject: [PATCH] LU-6142 obdclass: change some foo0() to __foo() Change: cl_io_init0 -> __cl_io_init cl_lock_trace0 -> __cl_lock_trace cl_page_delete0 -> __cl_page_delete cl_page_state_set0 -> __cl_page_state_set cl_page_own0 -> __cl_page_own cl_page_disown0 -> __cl_page_disown cl_page_delete0 -> __cl_page_delete This is more consistent with Linux naming style. Test-Parameters: trivial Change-Id: If38b52465d42ac425d47c1e9ded62bd7f013e0eb Signed-off-by: Mr. NeilBrown Reviewed-on: https://review.whamcloud.com/c/fs/lustre-release/+/48803 Tested-by: jenkins Tested-by: Maloo Reviewed-by: Arshad Hussain Reviewed-by: Oleg Drokin --- lustre/include/cl_object.h | 2 +- lustre/obdclass/cl_internal.h | 2 +- lustre/obdclass/cl_io.c | 14 +++++++------- lustre/obdclass/cl_lock.c | 8 ++++---- lustre/obdclass/cl_page.c | 38 +++++++++++++++++++------------------- 5 files changed, 32 insertions(+), 32 deletions(-) diff --git a/lustre/include/cl_object.h b/lustre/include/cl_object.h index 278db69..b7de8eb 100644 --- a/lustre/include/cl_object.h +++ b/lustre/include/cl_object.h @@ -830,7 +830,7 @@ struct cl_page_operations { /** * cl_page<->struct page methods. Only one layer in the stack has to * implement these. Current code assumes that this functionality is - * provided by the topmost layer, see cl_page_disown0() as an example. + * provided by the topmost layer, see __cl_page_disown() as an example. */ /** diff --git a/lustre/obdclass/cl_internal.h b/lustre/obdclass/cl_internal.h index 3c8f22b..dba8cc4 100644 --- a/lustre/obdclass/cl_internal.h +++ b/lustre/obdclass/cl_internal.h @@ -51,6 +51,6 @@ extern struct kmem_cache *cl_page_kmem_array[16]; extern unsigned short cl_page_kmem_size_array[16]; struct cl_thread_info *cl_env_info(const struct lu_env *env); -void cl_page_disown0(const struct lu_env *env, struct cl_page *pg); +void __cl_page_disown(const struct lu_env *env, struct cl_page *pg); #endif /* _CL_INTERNAL_H */ diff --git a/lustre/obdclass/cl_io.c b/lustre/obdclass/cl_io.c index 40e17de..bd78143 100644 --- a/lustre/obdclass/cl_io.c +++ b/lustre/obdclass/cl_io.c @@ -133,8 +133,8 @@ void cl_io_fini(const struct lu_env *env, struct cl_io *io) } EXPORT_SYMBOL(cl_io_fini); -static int cl_io_init0(const struct lu_env *env, struct cl_io *io, - enum cl_io_type iot, struct cl_object *obj) +static int __cl_io_init(const struct lu_env *env, struct cl_io *io, + enum cl_io_type iot, struct cl_object *obj) { struct cl_object *scan; int result; @@ -172,7 +172,7 @@ int cl_io_sub_init(const struct lu_env *env, struct cl_io *io, { LASSERT(obj != cl_object_top(obj)); - return cl_io_init0(env, io, iot, obj); + return __cl_io_init(env, io, iot, obj); } EXPORT_SYMBOL(cl_io_sub_init); @@ -194,7 +194,7 @@ int cl_io_init(const struct lu_env *env, struct cl_io *io, /* clear I/O restart from previous instance */ io->ci_need_restart = 0; - return cl_io_init0(env, io, iot, obj); + return __cl_io_init(env, io, iot, obj); } EXPORT_SYMBOL(cl_io_init); @@ -960,14 +960,14 @@ void cl_page_list_disown(const struct lu_env *env, struct cl_page_list *plist) list_del_init(&page->cp_batch); --plist->pl_nr; /* - * cl_page_disown0 rather than usual cl_page_disown() is used, + * __cl_page_disown rather than usual cl_page_disown() is used, * because pages are possibly in CPS_FREEING state already due * to the call to cl_page_list_discard(). */ /* - * XXX cl_page_disown0() will fail if page is not locked. + * XXX __cl_page_disown() will fail if page is not locked. */ - cl_page_disown0(env, page); + __cl_page_disown(env, page); lu_ref_del_at(&page->cp_reference, &page->cp_queue_ref, "queue", plist); cl_page_put(env, page); diff --git a/lustre/obdclass/cl_lock.c b/lustre/obdclass/cl_lock.c index 6dd0663..7750ae9 100644 --- a/lustre/obdclass/cl_lock.c +++ b/lustre/obdclass/cl_lock.c @@ -44,16 +44,16 @@ #include #include "cl_internal.h" -static void cl_lock_trace0(int level, const struct lu_env *env, - const char *prefix, const struct cl_lock *lock, - const char *func, const int line) +static void __cl_lock_trace(int level, const struct lu_env *env, + const char *prefix, const struct cl_lock *lock, + const char *func, const int line) { struct cl_object_header *h = cl_object_header(lock->cll_descr.cld_obj); CDEBUG(level, "%s: %p (%p/%d) at %s():%d\n", prefix, lock, env, h->coh_nesting, func, line); } #define cl_lock_trace(level, env, prefix, lock) \ - cl_lock_trace0(level, env, prefix, lock, __FUNCTION__, __LINE__) + __cl_lock_trace(level, env, prefix, lock, __FUNCTION__, __LINE__) /** * Adds lock slice to the compound lock. diff --git a/lustre/obdclass/cl_page.c b/lustre/obdclass/cl_page.c index cf84cc9..29a5bc1 100644 --- a/lustre/obdclass/cl_page.c +++ b/lustre/obdclass/cl_page.c @@ -44,7 +44,7 @@ #include #include "cl_internal.h" -static void cl_page_delete0(const struct lu_env *env, struct cl_page *pg); +static void __cl_page_delete(const struct lu_env *env, struct cl_page *pg); static DEFINE_MUTEX(cl_page_kmem_mutex); #ifdef LIBCFS_DEBUG @@ -296,7 +296,7 @@ struct cl_page *cl_page_alloc(const struct lu_env *env, struct cl_object *o, result = o->co_ops->coo_page_init(env, o, cl_page, ind); if (result != 0) { - cl_page_delete0(env, cl_page); + __cl_page_delete(env, cl_page); cl_page_free(env, cl_page, NULL); cl_page = ERR_PTR(result); break; @@ -375,9 +375,9 @@ static inline int cl_page_invariant(const struct cl_page *pg) return cl_page_in_use_noref(pg); } -static void cl_page_state_set0(const struct lu_env *env, - struct cl_page *cl_page, - enum cl_page_state state) +static void __cl_page_state_set(const struct lu_env *env, + struct cl_page *cl_page, + enum cl_page_state state) { enum cl_page_state old; @@ -440,7 +440,7 @@ static void cl_page_state_set0(const struct lu_env *env, static void cl_page_state_set(const struct lu_env *env, struct cl_page *page, enum cl_page_state state) { - cl_page_state_set0(env, page, state); + __cl_page_state_set(env, page, state); } /** @@ -548,7 +548,7 @@ static void cl_page_owner_set(struct cl_page *page) EXIT; } -void cl_page_disown0(const struct lu_env *env, struct cl_page *cp) +void __cl_page_disown(const struct lu_env *env, struct cl_page *cp) { struct page *vmpage; enum cl_page_state state; @@ -603,8 +603,8 @@ EXPORT_SYMBOL(cl_page_is_owned); * \see cl_page_own_try() * \see cl_page_own */ -static int cl_page_own0(const struct lu_env *env, struct cl_io *io, - struct cl_page *cl_page, int nonblock) +static int __cl_page_own(const struct lu_env *env, struct cl_io *io, + struct cl_page *cl_page, int nonblock) { struct page *vmpage = cl_page->cp_vmpage; int result; @@ -642,7 +642,7 @@ static int cl_page_own0(const struct lu_env *env, struct cl_io *io, cl_page_owner_set(cl_page); if (cl_page->cp_state == CPS_FREEING) { - cl_page_disown0(env, cl_page); + __cl_page_disown(env, cl_page); result = -ENOENT; goto out; } @@ -658,23 +658,23 @@ out: /** * Own a page, might be blocked. * - * \see cl_page_own0() + * \see __cl_page_own() */ int cl_page_own(const struct lu_env *env, struct cl_io *io, struct cl_page *pg) { - return cl_page_own0(env, io, pg, 0); + return __cl_page_own(env, io, pg, 0); } EXPORT_SYMBOL(cl_page_own); /** * Nonblock version of cl_page_own(). * - * \see cl_page_own0() + * \see __cl_page_own() */ int cl_page_own_try(const struct lu_env *env, struct cl_io *io, struct cl_page *pg) { - return cl_page_own0(env, io, pg, 1); + return __cl_page_own(env, io, pg, 1); } EXPORT_SYMBOL(cl_page_own_try); @@ -757,7 +757,7 @@ void cl_page_disown(const struct lu_env *env, PINVRNT(env, pg, cl_page_is_owned(pg, io) || pg->cp_state == CPS_FREEING); - cl_page_disown0(env, pg); + __cl_page_disown(env, pg); } EXPORT_SYMBOL(cl_page_disown); @@ -799,10 +799,10 @@ EXPORT_SYMBOL(cl_page_discard); /** * Version of cl_page_delete() that can be called for not fully constructed - * cl_pages, e.g. in an error handling cl_page_find()->cl_page_delete0() + * cl_pages, e.g. in an error handling cl_page_find()->__cl_page_delete() * path. Doesn't check cl_page invariant. */ -static void cl_page_delete0(const struct lu_env *env, struct cl_page *cp) +static void __cl_page_delete(const struct lu_env *env, struct cl_page *cp) { struct page *vmpage; const struct cl_page_slice *slice; @@ -816,7 +816,7 @@ static void cl_page_delete0(const struct lu_env *env, struct cl_page *cp) * Severe all ways to obtain new pointers to @pg. */ cl_page_owner_clear(cp); - cl_page_state_set0(env, cp, CPS_FREEING); + __cl_page_state_set(env, cp, CPS_FREEING); cl_page_slice_for_each_reverse(cp, slice, i) { if (slice->cpl_ops->cpo_delete != NULL) @@ -873,7 +873,7 @@ void cl_page_delete(const struct lu_env *env, struct cl_page *pg) { PINVRNT(env, pg, cl_page_invariant(pg)); ENTRY; - cl_page_delete0(env, pg); + __cl_page_delete(env, pg); EXIT; } EXPORT_SYMBOL(cl_page_delete); -- 1.8.3.1