LU-2237 tests: new test for re-recreating last_rcvd

[fs/lustre-release.git] / lustre / osc / osc_page.c

diff --git a/lustre/osc/osc_page.c b/lustre/osc/osc_page.c
index 29774de..4f467fe 100644 (file)
--- a/lustre/osc/osc_page.c
+++ b/lustre/osc/osc_page.c
@@ -126,7 +126,7 @@ static int osc_page_protected(const struct lu_env *env,
                 descr->cld_mode = mode;
                 descr->cld_start = page->cp_index;
                 descr->cld_end   = page->cp_index;
-                cfs_spin_lock(&hdr->coh_lock_guard);
+               spin_lock(&hdr->coh_lock_guard);
                 cfs_list_for_each_entry(scan, &hdr->coh_locks, cll_linkage) {
                         /*
                          * Lock-less sub-lock has to be either in HELD state
@@ -144,7 +144,7 @@ static int osc_page_protected(const struct lu_env *env,
                                 break;
                         }
                 }
-                cfs_spin_unlock(&hdr->coh_lock_guard);
+               spin_unlock(&hdr->coh_lock_guard);
         }
         return result;
 }
@@ -207,10 +207,10 @@ static void osc_page_transfer_add(const struct lu_env *env,
         * first and then use it as inflight. */
        osc_lru_del(osc_cli(obj), opg, false);
 
-        cfs_spin_lock(&obj->oo_seatbelt);
-        cfs_list_add(&opg->ops_inflight, &obj->oo_inflight[crt]);
-        opg->ops_submitter = cfs_current();
-        cfs_spin_unlock(&obj->oo_seatbelt);
+       spin_lock(&obj->oo_seatbelt);
+       cfs_list_add(&opg->ops_inflight, &obj->oo_inflight[crt]);
+       opg->ops_submitter = cfs_current();
+       spin_unlock(&obj->oo_seatbelt);
 }
 
 static int osc_page_cache_add(const struct lu_env *env,
@@ -432,13 +432,13 @@ static void osc_page_delete(const struct lu_env *env,
                 LASSERT(0);
         }
 
-       cfs_spin_lock(&obj->oo_seatbelt);
+       spin_lock(&obj->oo_seatbelt);
        if (opg->ops_submitter != NULL) {
                LASSERT(!cfs_list_empty(&opg->ops_inflight));
                cfs_list_del_init(&opg->ops_inflight);
                opg->ops_submitter = NULL;
        }
-       cfs_spin_unlock(&obj->oo_seatbelt);
+       spin_unlock(&obj->oo_seatbelt);
 
        osc_lru_del(osc_cli(obj), opg, true);
        EXIT;
@@ -454,9 +454,9 @@ void osc_page_clip(const struct lu_env *env, const struct cl_page_slice *slice,
 
         opg->ops_from = from;
         opg->ops_to   = to;
-        cfs_spin_lock(&oap->oap_lock);
-        oap->oap_async_flags |= ASYNC_COUNT_STABLE;
-        cfs_spin_unlock(&oap->oap_lock);
+       spin_lock(&oap->oap_lock);
+       oap->oap_async_flags |= ASYNC_COUNT_STABLE;
+       spin_unlock(&oap->oap_lock);
 }
 
 static int osc_page_cancel(const struct lu_env *env,
@@ -610,7 +610,7 @@ static const int lru_shrink_max = 32 << (20 - CFS_PAGE_SHIFT); /* 32M */
  * Return how many LRU pages should be freed. */
 static int osc_cache_too_much(struct client_obd *cli)
 {
-       struct cl_client_lru *lru = cli->cl_lru;
+       struct cl_client_cache *cache = cli->cl_cache;
        int pages = cfs_atomic_read(&cli->cl_lru_in_list) >> 1;
 
        if (cfs_atomic_read(&osc_lru_waiters) > 0 &&
@@ -620,11 +620,11 @@ static int osc_cache_too_much(struct client_obd *cli)
 
        /* if it's going to run out LRU slots, we should free some, but not
         * too much to maintain faireness among OSCs. */
-       if (cfs_atomic_read(cli->cl_lru_left) < lru->ccl_page_max >> 4) {
-               unsigned long budget;
+       if (cfs_atomic_read(cli->cl_lru_left) < cache->ccc_lru_max >> 4) {
+               unsigned long tmp;
 
-               budget = lru->ccl_page_max / cfs_atomic_read(&lru->ccl_users);
-               if (pages > budget)
+               tmp = cache->ccc_lru_max / cfs_atomic_read(&cache->ccc_users);
+               if (pages > tmp)
                        return min(pages, lru_shrink_max);
 
                return pages > lru_shrink_min ? lru_shrink_min : 0;
@@ -647,7 +647,7 @@ static int discard_pagevec(const struct lu_env *env, struct cl_io *io,
                         * This check is necessary to avoid freeing the pages
                         * having already been removed from LRU and pinned
                         * for IO. */
-                       if (cfs_atomic_read(&page->cp_ref) == 1) {
+                       if (!cl_page_in_use(page)) {
                                cl_page_unmap(env, io, page);
                                cl_page_discard(env, io, page);
                                ++count;
@@ -700,8 +700,7 @@ int osc_lru_shrink(struct client_obd *cli, int target)
                opg = cfs_list_entry(cli->cl_lru_list.next, struct osc_page,
                                     ops_lru);
                page = cl_page_top(opg->ops_cl.cpl_page);
-               if (page->cp_state == CPS_FREEING ||
-                   cfs_atomic_read(&page->cp_ref) > 0) {
+               if (cl_page_in_use_noref(page)) {
                        cfs_list_move_tail(&opg->ops_lru, &cli->cl_lru_list);
                        continue;
                }
@@ -822,13 +821,13 @@ static void osc_lru_del(struct client_obd *cli, struct osc_page *opg, bool del)
 
 static int osc_lru_reclaim(struct client_obd *cli)
 {
-       struct cl_client_lru *lru = cli->cl_lru;
+       struct cl_client_cache *cache = cli->cl_cache;
        struct client_obd *victim;
        struct client_obd *tmp;
        int rc;
 
-       LASSERT(lru != NULL);
-       LASSERT(!cfs_list_empty(&lru->ccl_list));
+       LASSERT(cache != NULL);
+       LASSERT(!cfs_list_empty(&cache->ccc_lru));
 
        rc = osc_lru_shrink(cli, lru_shrink_min);
        if (rc > 0) {
@@ -844,10 +843,10 @@ static int osc_lru_reclaim(struct client_obd *cli)
 
        /* Reclaim LRU slots from other client_obd as it can't free enough
         * from its own. This should rarely happen. */
-       cfs_spin_lock(&lru->ccl_lock);
-       lru->ccl_reclaim_count++;
-       cfs_list_move_tail(&cli->cl_lru_osc, &lru->ccl_list);
-       cfs_list_for_each_entry_safe(victim, tmp, &lru->ccl_list, cl_lru_osc) {
+       spin_lock(&cache->ccc_lru_lock);
+       cache->ccc_lru_shrinkers++;
+       cfs_list_move_tail(&cli->cl_lru_osc, &cache->ccc_lru);
+       cfs_list_for_each_entry_safe(victim, tmp, &cache->ccc_lru, cl_lru_osc) {
                if (victim == cli)
                        break;
 
@@ -856,11 +855,11 @@ static int osc_lru_reclaim(struct client_obd *cli)
                        cfs_atomic_read(&victim->cl_lru_in_list),
                        cfs_atomic_read(&victim->cl_lru_busy));
 
-               cfs_list_move_tail(&victim->cl_lru_osc, &lru->ccl_list);
+               cfs_list_move_tail(&victim->cl_lru_osc, &cache->ccc_lru);
                if (cfs_atomic_read(&victim->cl_lru_in_list) > 0)
                        break;
        }
-       cfs_spin_unlock(&lru->ccl_lock);
+       spin_unlock(&cache->ccc_lru_lock);
        if (victim == cli) {
                CDEBUG(D_CACHE, "%s: can't get any free LRU slots.\n",
                        cli->cl_import->imp_obd->obd_name);
@@ -885,7 +884,7 @@ static int osc_lru_reserve(const struct lu_env *env, struct osc_object *obj,
        int rc = 0;
        ENTRY;
 
-       if (cli->cl_lru == NULL) /* shall not be in LRU */
+       if (cli->cl_cache == NULL) /* shall not be in LRU */
                RETURN(0);
 
        LASSERT(cfs_atomic_read(cli->cl_lru_left) >= 0);