* Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
* Use is subject to license terms.
*
- * Copyright (c) 2011, Whamcloud, Inc.
+ * Copyright (c) 2011, 2012, Intel Corporation.
*/
/*
* This file is part of Lustre, http://www.lustre.org/
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
break;
}
}
- cfs_spin_unlock(&hdr->coh_lock_guard);
+ spin_unlock(&hdr->coh_lock_guard);
}
return result;
}
struct osc_page *opg = cl2osc_page(slice);
CDEBUG(D_TRACE, "%p\n", opg);
LASSERT(opg->ops_lock == NULL);
- OBD_SLAB_FREE_PTR(opg, osc_page_kmem);
}
static void osc_page_transfer_get(struct osc_page *opg, const char *label)
* 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,
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;
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,
.cpo_flush = osc_page_flush
};
-struct cl_page *osc_page_init(const struct lu_env *env,
- struct cl_object *obj,
- struct cl_page *page, cfs_page_t *vmpage)
+int osc_page_init(const struct lu_env *env, struct cl_object *obj,
+ struct cl_page *page, cfs_page_t *vmpage)
{
- struct osc_object *osc = cl2osc(obj);
- struct osc_page *opg;
- int result;
+ struct osc_object *osc = cl2osc(obj);
+ struct osc_page *opg = cl_object_page_slice(obj, page);
+ int result;
- OBD_SLAB_ALLOC_PTR_GFP(opg, osc_page_kmem, CFS_ALLOC_IO);
- if (opg != NULL) {
- opg->ops_from = 0;
- opg->ops_to = CFS_PAGE_SIZE;
-
- result = osc_prep_async_page(osc, opg, vmpage,
- cl_offset(obj, page->cp_index));
- if (result == 0) {
- struct osc_io *oio = osc_env_io(env);
- opg->ops_srvlock = osc_io_srvlock(oio);
- cl_page_slice_add(page, &opg->ops_cl, obj,
- &osc_page_ops);
- }
- /*
- * Cannot assert osc_page_protected() here as read-ahead
- * creates temporary pages outside of a lock.
- */
+ opg->ops_from = 0;
+ opg->ops_to = CFS_PAGE_SIZE;
+
+ result = osc_prep_async_page(osc, opg, vmpage,
+ cl_offset(obj, page->cp_index));
+ if (result == 0) {
+ struct osc_io *oio = osc_env_io(env);
+ opg->ops_srvlock = osc_io_srvlock(oio);
+ cl_page_slice_add(page, &opg->ops_cl, obj,
+ &osc_page_ops);
+ }
+ /*
+ * Cannot assert osc_page_protected() here as read-ahead
+ * creates temporary pages outside of a lock.
+ */
#ifdef INVARIANT_CHECK
- opg->ops_temp = !osc_page_protected(env, opg, CLM_READ, 1);
+ opg->ops_temp = !osc_page_protected(env, opg, CLM_READ, 1);
#endif
- /* ops_inflight and ops_lru are the same field, but it doesn't
- * hurt to initialize it twice :-) */
- CFS_INIT_LIST_HEAD(&opg->ops_inflight);
- CFS_INIT_LIST_HEAD(&opg->ops_lru);
- } else
- result = -ENOMEM;
+ /* ops_inflight and ops_lru are the same field, but it doesn't
+ * hurt to initialize it twice :-) */
+ CFS_INIT_LIST_HEAD(&opg->ops_inflight);
+ CFS_INIT_LIST_HEAD(&opg->ops_lru);
/* reserve an LRU space for this page */
if (page->cp_type == CPT_CACHEABLE && result == 0)
result = osc_lru_reserve(env, osc, opg);
- return ERR_PTR(result);
+ return result;
}
/**
* 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;
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;
}
clobj = tmp;
io->ci_obj = clobj;
+ io->ci_ignore_layout = 1;
rc = cl_io_init(env, io, CIT_MISC, clobj);
+
+ client_obd_list_lock(&cli->cl_lru_list_lock);
+
if (rc != 0)
break;
++maxscan;
- client_obd_list_lock(&cli->cl_lru_list_lock);
continue;
}
}
client_obd_list_unlock(&cli->cl_lru_list_lock);
- if (wakeup)
+ if (wakeup) {
+ osc_lru_shrink(cli, osc_cache_too_much(cli));
cfs_waitq_broadcast(&osc_lru_waitq);
+ }
}
/* delete page from LRUlist. The page can be deleted from LRUlist for two
}
}
+static inline int max_to_shrink(struct client_obd *cli)
+{
+ return min(cfs_atomic_read(&cli->cl_lru_in_list) >> 1, lru_shrink_max);
+}
+
static int osc_lru_reclaim(struct client_obd *cli)
{
struct cl_client_cache *cache = cli->cl_cache;
- struct client_obd *victim;
- struct client_obd *tmp;
+ int max_scans;
int rc;
LASSERT(cache != NULL);
LASSERT(!cfs_list_empty(&cache->ccc_lru));
rc = osc_lru_shrink(cli, lru_shrink_min);
- if (rc > 0) {
+ if (rc != 0) {
CDEBUG(D_CACHE, "%s: Free %d pages from own LRU: %p.\n",
cli->cl_import->imp_obd->obd_name, rc, cli);
return rc;
/* Reclaim LRU slots from other client_obd as it can't free enough
* from its own. This should rarely happen. */
- cfs_spin_lock(&cache->ccc_lru_lock);
+ 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;
- CDEBUG(D_CACHE, "%s: cli %p LRU pages: %d, busy: %d.\n",
- victim->cl_import->imp_obd->obd_name, victim,
- cfs_atomic_read(&victim->cl_lru_in_list),
- cfs_atomic_read(&victim->cl_lru_busy));
+ max_scans = cfs_atomic_read(&cache->ccc_users);
+ while (--max_scans > 0 && !cfs_list_empty(&cache->ccc_lru)) {
+ cli = cfs_list_entry(cache->ccc_lru.next, struct client_obd,
+ cl_lru_osc);
- 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(&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);
- return 0;
- }
+ CDEBUG(D_CACHE, "%s: cli %p LRU pages: %d, busy: %d.\n",
+ cli->cl_import->imp_obd->obd_name, cli,
+ cfs_atomic_read(&cli->cl_lru_in_list),
+ cfs_atomic_read(&cli->cl_lru_busy));
- rc = osc_lru_shrink(victim,
- min(cfs_atomic_read(&victim->cl_lru_in_list) >> 1,
- lru_shrink_max));
+ cfs_list_move_tail(&cli->cl_lru_osc, &cache->ccc_lru);
+ if (cfs_atomic_read(&cli->cl_lru_in_list) > 0) {
+ spin_unlock(&cache->ccc_lru_lock);
- CDEBUG(D_CACHE, "%s: Free %d pages from other cli: %p.\n",
- cli->cl_import->imp_obd->obd_name, rc, victim);
+ rc = osc_lru_shrink(cli, max_to_shrink(cli));
+ spin_lock(&cache->ccc_lru_lock);
+ if (rc != 0)
+ break;
+ }
+ }
+ spin_unlock(&cache->ccc_lru_lock);
+ CDEBUG(D_CACHE, "%s: cli %p freed %d pages.\n",
+ cli->cl_import->imp_obd->obd_name, cli, rc);
return rc;
}
git://git.whamcloud.com / fs / lustre-release.git / blobdiff