LU-5051 hsm: do not reallocate hsm receive buffer

[fs/lustre-release.git] / lustre / obdclass / cl_page.c

diff --git a/lustre/obdclass/cl_page.c b/lustre/obdclass/cl_page.c
index a42d12f..4dfc98a 100644 (file)
--- a/lustre/obdclass/cl_page.c
+++ b/lustre/obdclass/cl_page.c
@@ -80,13 +80,13 @@ static void cl_page_delete0(const struct lu_env *env, struct cl_page *pg);
 /* Disable page statistic by default due to huge performance penalty. */
 #ifdef CONFIG_DEBUG_PAGESTATE_TRACKING
 #define CS_PAGE_INC(o, item) \
-       cfs_atomic_inc(&cl_object_site(o)->cs_pages.cs_stats[CS_##item])
+       atomic_inc(&cl_object_site(o)->cs_pages.cs_stats[CS_##item])
 #define CS_PAGE_DEC(o, item) \
-       cfs_atomic_dec(&cl_object_site(o)->cs_pages.cs_stats[CS_##item])
+       atomic_dec(&cl_object_site(o)->cs_pages.cs_stats[CS_##item])
 #define CS_PAGESTATE_INC(o, state) \
-       cfs_atomic_inc(&cl_object_site(o)->cs_pages_state[state])
+       atomic_inc(&cl_object_site(o)->cs_pages_state[state])
 #define CS_PAGESTATE_DEC(o, state) \
-       cfs_atomic_dec(&cl_object_site(o)->cs_pages_state[state])
+       atomic_dec(&cl_object_site(o)->cs_pages_state[state])
 #else
 #define CS_PAGE_INC(o, item)
 #define CS_PAGE_DEC(o, item)
@@ -106,8 +106,8 @@ static void cl_page_delete0(const struct lu_env *env, struct cl_page *pg);
  */
 static void cl_page_get_trust(struct cl_page *page)
 {
-        LASSERT(cfs_atomic_read(&page->cp_ref) > 0);
-        cfs_atomic_inc(&page->cp_ref);
+       LASSERT(atomic_read(&page->cp_ref) > 0);
+       atomic_inc(&page->cp_ref);
 }
 
 /**
@@ -179,10 +179,10 @@ struct cl_page *cl_page_alloc(const struct lu_env *env,
 
        ENTRY;
        OBD_ALLOC_GFP(page, cl_object_header(o)->coh_page_bufsize,
-                       __GFP_IO);
+                       GFP_NOFS);
        if (page != NULL) {
                int result = 0;
-               cfs_atomic_set(&page->cp_ref, 1);
+               atomic_set(&page->cp_ref, 1);
                page->cp_obj = o;
                cl_object_get(o);
                lu_object_ref_add_at(&o->co_lu, &page->cp_obj_ref, "cl_page",
@@ -382,12 +382,12 @@ void cl_page_put(const struct lu_env *env, struct cl_page *page)
 {
         ENTRY;
         CL_PAGE_HEADER(D_TRACE, env, page, "%d\n",
-                       cfs_atomic_read(&page->cp_ref));
+                      atomic_read(&page->cp_ref));
 
-       if (cfs_atomic_dec_and_test(&page->cp_ref)) {
+       if (atomic_dec_and_test(&page->cp_ref)) {
                LASSERT(page->cp_state == CPS_FREEING);
 
-               LASSERT(cfs_atomic_read(&page->cp_ref) == 0);
+               LASSERT(atomic_read(&page->cp_ref) == 0);
                PASSERT(env, page, page->cp_owner == NULL);
                PASSERT(env, page, cfs_list_empty(&page->cp_batch));
                /*
@@ -458,6 +458,30 @@ EXPORT_SYMBOL(cl_page_at);
        __result;                                                       \
 })
 
+#define CL_PAGE_INVOKE_REVERSE(_env, _page, _op, _proto, ...)          \
+({                                                                     \
+       const struct lu_env        *__env  = (_env);                    \
+       struct cl_page             *__page = (_page);                   \
+       const struct cl_page_slice *__scan;                             \
+       int                         __result;                           \
+       ptrdiff_t                   __op   = (_op);                     \
+       int                       (*__method)_proto;                    \
+                                                                       \
+       __result = 0;                                                   \
+       list_for_each_entry_reverse(__scan, &__page->cp_layers,         \
+                                       cpl_linkage) {                  \
+               __method = *(void **)((char *)__scan->cpl_ops +  __op); \
+               if (__method != NULL) {                                 \
+                       __result = (*__method)(__env, __scan, ## __VA_ARGS__); \
+                       if (__result != 0)                              \
+                               break;                                  \
+               }                                                       \
+       }                                                               \
+       if (__result > 0)                                               \
+               __result = 0;                                           \
+       __result;                                                       \
+})
+
 #define CL_PAGE_INVOID(_env, _page, _op, _proto, ...)                  \
 do {                                                                   \
        const struct lu_env        *__env  = (_env);                    \
@@ -1026,19 +1050,19 @@ EXPORT_SYMBOL(cl_page_flush);
  * \see cl_page_operations::cpo_is_under_lock()
  */
 int cl_page_is_under_lock(const struct lu_env *env, struct cl_io *io,
-                          struct cl_page *page)
+                          struct cl_page *page, pgoff_t *max_index)
 {
-        int rc;
+       int rc;
 
-        PINVRNT(env, page, cl_page_invariant(page));
+       PINVRNT(env, page, cl_page_invariant(page));
 
-        ENTRY;
-        rc = CL_PAGE_INVOKE(env, page, CL_PAGE_OP(cpo_is_under_lock),
-                            (const struct lu_env *,
-                             const struct cl_page_slice *, struct cl_io *),
-                            io);
-        PASSERT(env, page, rc != 0);
-        RETURN(rc);
+       ENTRY;
+       rc = CL_PAGE_INVOKE_REVERSE(env, page, CL_PAGE_OP(cpo_is_under_lock),
+                                   (const struct lu_env *,
+                                    const struct cl_page_slice *,
+                                    struct cl_io *, pgoff_t *),
+                                   io, max_index);
+       RETURN(rc);
 }
 EXPORT_SYMBOL(cl_page_is_under_lock);
 
@@ -1068,7 +1092,7 @@ void cl_page_header_print(const struct lu_env *env, void *cookie,
 {
        (*printer)(env, cookie,
                   "page@%p[%d %p %d %d %d %p %p %#x]\n",
-                  pg, cfs_atomic_read(&pg->cp_ref), pg->cp_obj,
+                  pg, atomic_read(&pg->cp_ref), pg->cp_obj,
                   pg->cp_state, pg->cp_error, pg->cp_type,
                   pg->cp_owner, pg->cp_req, pg->cp_flags);
 }
@@ -1134,15 +1158,16 @@ EXPORT_SYMBOL(cl_page_size);
  * \see cl_lock_slice_add(), cl_req_slice_add(), cl_io_slice_add()
  */
 void cl_page_slice_add(struct cl_page *page, struct cl_page_slice *slice,
-                       struct cl_object *obj,
-                       const struct cl_page_operations *ops)
+                      struct cl_object *obj, pgoff_t index,
+                      const struct cl_page_operations *ops)
 {
-        ENTRY;
-        cfs_list_add_tail(&slice->cpl_linkage, &page->cp_layers);
-        slice->cpl_obj  = obj;
-        slice->cpl_ops  = ops;
-        slice->cpl_page = page;
-        EXIT;
+       ENTRY;
+       list_add_tail(&slice->cpl_linkage, &page->cp_layers);
+       slice->cpl_obj  = obj;
+       slice->cpl_index = index;
+       slice->cpl_ops  = ops;
+       slice->cpl_page = page;
+       EXIT;
 }
 EXPORT_SYMBOL(cl_page_slice_add);