LU-13814 clio: remove cp_state usage for DIO pages

DIO pages don't really go through the state transitions of
cached pages, so don't do it for them.  This is a step
towards removing cl_pages for DIO/transient pages.

Signed-off-by: Patrick Farrell <pfarrell@whamcloud.com>
Change-Id: I5b4cd52ec19c97d0a5b815fcd68958a108a3444a
Reviewed-on: https://review.whamcloud.com/c/fs/lustre-release/+/52074
Tested-by: jenkins <devops@whamcloud.com>
Tested-by: Maloo <maloo@whamcloud.com>
Reviewed-by: Oleg Drokin <green@whamcloud.com>
Reviewed-by: Sebastien Buisson <sbuisson@ddn.com>
Reviewed-by: Andreas Dilger <adilger@whamcloud.com>

diff --git a/lustre/mdc/mdc_dev.c b/lustre/mdc/mdc_dev.c
index cef8fdb..13d1cb5 100644 (file)
--- a/lustre/mdc/mdc_dev.c
+++ b/lustre/mdc/mdc_dev.c
@@ -215,7 +215,8 @@ static bool mdc_check_and_discard_cb(const struct lu_env *env, struct cl_io *io,
                                cl_page_discard(env, io, page);
                                cl_page_disown(env, io, page);
                        } else {
-                               LASSERT(page->cp_state == CPS_FREEING);
+                               if (page->cp_type != CPT_TRANSIENT)
+                                       LASSERT(page->cp_state == CPS_FREEING);
                        }
                }
 

diff --git a/lustre/obdclass/cl_page.c b/lustre/obdclass/cl_page.c
index 631d66b..6a05aad 100644 (file)
--- a/lustre/obdclass/cl_page.c
+++ b/lustre/obdclass/cl_page.c
@@ -168,7 +168,8 @@ static void cl_page_free(const struct lu_env *env, struct cl_page *cp,
        ENTRY;
        PASSERT(env, cp, list_empty(&cp->cp_batch));
        PASSERT(env, cp, cp->cp_owner == NULL);
-       PASSERT(env, cp, cp->cp_state == CPS_FREEING);
+       if (cp->cp_type != CPT_TRANSIENT)
+               PASSERT(env, cp, cp->cp_state == CPS_FREEING);
 
        if (cp->cp_type == CPT_CACHEABLE) {
                /* vmpage->private was already cleared when page was
@@ -188,7 +189,8 @@ static void cl_page_free(const struct lu_env *env, struct cl_page *cp,
 
        cp->cp_layer_count = 0;
        cs_page_dec(obj, CS_total);
-       cs_pagestate_dec(obj, cp->cp_state);
+       if (cp->cp_type != CPT_TRANSIENT)
+               cs_pagestate_dec(obj, cp->cp_state);
        lu_object_ref_del_at(&obj->co_lu, &cp->cp_obj_ref, "cl_page", cp);
        if (cp->cp_type != CPT_TRANSIENT)
                cl_object_put(env, obj);
@@ -276,7 +278,8 @@ struct cl_page *cl_page_alloc(const struct lu_env *env, struct cl_object *o,
                lu_object_ref_add_at(&o->co_lu, &cl_page->cp_obj_ref,
                                     "cl_page", cl_page);
                cl_page->cp_vmpage = vmpage;
-               cl_page->cp_state = CPS_CACHED;
+               if (cl_page->cp_type != CPT_TRANSIENT)
+                       cl_page->cp_state = CPS_CACHED;
                cl_page->cp_type = type;
                if (type == CPT_TRANSIENT)
                        /* correct inode to be added in ll_direct_rw_pages */
@@ -432,6 +435,7 @@ static void __cl_page_state_set(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)
 {
+       LASSERT(page->cp_type != CPT_TRANSIENT);
        __cl_page_state_set(env, page, state);
 }
 
@@ -465,7 +469,8 @@ void cl_batch_put(const struct lu_env *env, struct cl_page *page,
                       refcount_read(&page->cp_ref));
 
        if (refcount_dec_and_test(&page->cp_ref)) {
-               LASSERT(page->cp_state == CPS_FREEING);
+               if (page->cp_type != CPT_TRANSIENT)
+                       LASSERT(page->cp_state == CPS_FREEING);
 
                LASSERT(refcount_read(&page->cp_ref) == 0);
                PASSERT(env, page, page->cp_owner == NULL);
@@ -541,15 +546,14 @@ void __cl_page_disown(const struct lu_env *env, struct cl_page *cp)
        enum cl_page_state state;
 
        ENTRY;
-       state = cp->cp_state;
-       PINVRNT(env, cp, state == CPS_OWNED || state == CPS_FREEING);
-       PINVRNT(env, cp, cl_page_invariant(cp) || state == CPS_FREEING);
        cl_page_owner_clear(cp);
 
-       if (state == CPS_OWNED)
-               cl_page_state_set(env, cp, CPS_CACHED);
-
        if (cp->cp_type == CPT_CACHEABLE) {
+               state = cp->cp_state;
+               PINVRNT(env, cp, state == CPS_OWNED || state == CPS_FREEING);
+               PINVRNT(env, cp, cl_page_invariant(cp) || state == CPS_FREEING);
+               if (state == CPS_OWNED)
+                       cl_page_state_set(env, cp, CPS_CACHED);
                vmpage = cp->cp_vmpage;
                LASSERT(vmpage != NULL);
                LASSERT(PageLocked(vmpage));
@@ -566,7 +570,10 @@ int cl_page_is_owned(const struct cl_page *pg, const struct cl_io *io)
 
        LINVRNT(cl_object_same(pg->cp_obj, top->ci_obj));
        ENTRY;
-       RETURN(pg->cp_state == CPS_OWNED && pg->cp_owner == top);
+       if (pg->cp_type != CPT_TRANSIENT)
+               RETURN(pg->cp_state == CPS_OWNED && pg->cp_owner == top);
+       else
+               RETURN(pg->cp_owner == top);
 }
 EXPORT_SYMBOL(cl_page_is_owned);
 
@@ -598,7 +605,8 @@ static int __cl_page_own(const struct lu_env *env, struct cl_io *io,
        ENTRY;
        PINVRNT(env, cl_page, !cl_page_is_owned(cl_page, io));
 
-       if (cl_page->cp_state == CPS_FREEING) {
+       if (cl_page->cp_type != CPT_TRANSIENT &&
+           cl_page->cp_state == CPS_FREEING) {
                result = -ENOENT;
                goto out;
        }
@@ -627,13 +635,16 @@ static int __cl_page_own(const struct lu_env *env, struct cl_io *io,
        cl_page->cp_owner = cl_io_top(io);
        cl_page_owner_set(cl_page);
 
-       if (cl_page->cp_state == CPS_FREEING) {
-               __cl_page_disown(env, cl_page);
-               result = -ENOENT;
-               goto out;
+       if (cl_page->cp_type != CPT_TRANSIENT) {
+               if (cl_page->cp_state == CPS_FREEING) {
+                       __cl_page_disown(env, cl_page);
+                       result = -ENOENT;
+                       goto out;
+               }
+
+               cl_page_state_set(env, cl_page, CPS_OWNED);
        }
 
-       cl_page_state_set(env, cl_page, CPS_OWNED);
        result = 0;
 out:
        CDEBUG(D_INFO, "res %d\n", result);
@@ -684,7 +695,8 @@ void cl_page_assume(const struct lu_env *env,
        PASSERT(env, cp, cp->cp_owner == NULL);
        cp->cp_owner = cl_io_top(io);
        cl_page_owner_set(cp);
-       cl_page_state_set(env, cp, CPS_OWNED);
+       if (cp->cp_type != CPT_TRANSIENT)
+               cl_page_state_set(env, cp, CPS_OWNED);
        EXIT;
 }
 EXPORT_SYMBOL(cl_page_assume);
@@ -708,7 +720,8 @@ void cl_page_unassume(const struct lu_env *env,
        PINVRNT(env, cp, cl_page_invariant(cp));
 
        cl_page_owner_clear(cp);
-       cl_page_state_set(env, cp, CPS_CACHED);
+       if (cp->cp_type != CPT_TRANSIENT)
+               cl_page_state_set(env, cp, CPS_CACHED);
 
        if (cp->cp_type == CPT_CACHEABLE) {
                vmpage = cp->cp_vmpage;
@@ -733,8 +746,10 @@ EXPORT_SYMBOL(cl_page_unassume);
 void cl_page_disown(const struct lu_env *env,
                    struct cl_io *io, struct cl_page *pg)
 {
-       PINVRNT(env, pg, cl_page_is_owned(pg, cl_io_top(io)) ||
-               pg->cp_state == CPS_FREEING);
+       if (pg->cp_type != CPT_TRANSIENT) {
+               PINVRNT(env, pg, cl_page_is_owned(pg, cl_io_top(io)) ||
+                       pg->cp_state == CPS_FREEING);
+       }
 
        __cl_page_disown(env, pg);
 }
@@ -787,11 +802,13 @@ static void __cl_page_delete(const struct lu_env *env, struct cl_page *cp)
        int i;
 
        ENTRY;
-       PASSERT(env, cp, cp->cp_state != CPS_FREEING);
+       if (cp->cp_type != CPT_TRANSIENT)
+               PASSERT(env, cp, cp->cp_state != CPS_FREEING);
 
        /* Severe all ways to obtain new pointers to @pg. */
        cl_page_owner_clear(cp);
-       __cl_page_state_set(env, cp, CPS_FREEING);
+       if (cp->cp_type != CPT_TRANSIENT)
+               __cl_page_state_set(env, cp, CPS_FREEING);
 
        cl_page_slice_for_each_reverse(cp, slice, i) {
                if (slice->cpl_ops->cpo_delete != NULL)
@@ -863,7 +880,8 @@ static void cl_page_io_start(const struct lu_env *env,
        /* Page is queued for IO, change its state. */
        ENTRY;
        cl_page_owner_clear(pg);
-       cl_page_state_set(env, pg, cl_req_type_state(crt));
+       if (pg->cp_type != CPT_TRANSIENT)
+               cl_page_state_set(env, pg, cl_req_type_state(crt));
        EXIT;
 }
 
@@ -931,10 +949,13 @@ void cl_page_completion(const struct lu_env *env,
 
        ENTRY;
        PASSERT(env, cl_page, crt < CRT_NR);
-       PASSERT(env, cl_page, cl_page->cp_state == cl_req_type_state(crt));
+       if (cl_page->cp_type != CPT_TRANSIENT)
+               PASSERT(env, cl_page,
+                       cl_page->cp_state == cl_req_type_state(crt));
 
        CL_PAGE_HEADER(D_TRACE, env, cl_page, "%d %d\n", crt, ioret);
-       cl_page_state_set(env, cl_page, CPS_CACHED);
+       if (cl_page->cp_type != CPT_TRANSIENT)
+               cl_page_state_set(env, cl_page, CPS_CACHED);
        if (crt >= CRT_NR)
                return;
 

diff --git a/lustre/osc/osc_cache.c b/lustre/osc/osc_cache.c
index 91d37f7..ec71de5 100644 (file)
--- a/lustre/osc/osc_cache.c
+++ b/lustre/osc/osc_cache.c
@@ -1306,11 +1306,13 @@ static int osc_completion(const struct lu_env *env, struct osc_object *osc,
        ENTRY;
 
        cmd &= ~OBD_BRW_NOQUOTA;
-       LASSERTF(equi(page->cp_state == CPS_PAGEIN,  cmd == OBD_BRW_READ),
-                "cp_state:%u, cmd:%d\n", page->cp_state, cmd);
-       LASSERTF(equi(page->cp_state == CPS_PAGEOUT, cmd == OBD_BRW_WRITE),
-               "cp_state:%u, cmd:%d\n", page->cp_state, cmd);
-       LASSERT(opg->ops_transfer_pinned);
+       if (page->cp_type != CPT_TRANSIENT) {
+               LASSERTF(equi(page->cp_state == CPS_PAGEIN,  cmd == OBD_BRW_READ),
+                        "cp_state:%u, cmd:%d\n", page->cp_state, cmd);
+               LASSERTF(equi(page->cp_state == CPS_PAGEOUT, cmd == OBD_BRW_WRITE),
+                       "cp_state:%u, cmd:%d\n", page->cp_state, cmd);
+               LASSERT(opg->ops_transfer_pinned);
+       }
 
        crt = cmd == OBD_BRW_READ ? CRT_READ : CRT_WRITE;
        /* Clear opg->ops_transfer_pinned before VM lock is released. */