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 <neilb@suse.de>
Reviewed-on: https://review.whamcloud.com/c/fs/lustre-release/+/48803
Tested-by: jenkins <devops@whamcloud.com>
Tested-by: Maloo <maloo@whamcloud.com>
Reviewed-by: Arshad Hussain <arshad.hussain@aeoncomputing.com>
Reviewed-by: Oleg Drokin <green@whamcloud.com>

diff --git a/lustre/include/cl_object.h b/lustre/include/cl_object.h
index 278db69..b7de8eb 100644 (file)
--- 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 (file)
--- 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 (file)
--- 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 (file)
--- a/lustre/obdclass/cl_lock.c
+++ b/lustre/obdclass/cl_lock.c
@@ -44,16 +44,16 @@
 #include <cl_object.h>
 #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 (file)
--- a/lustre/obdclass/cl_page.c
+++ b/lustre/obdclass/cl_page.c
@@ -44,7 +44,7 @@
 #include <cl_object.h>
 #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);