res = lock->l_resource;
LASSERT(ldlm_is_destroyed(lock));
- LASSERT(cfs_list_empty(&lock->l_res_link));
- LASSERT(cfs_list_empty(&lock->l_pending_chain));
+ LASSERT(list_empty(&lock->l_res_link));
+ LASSERT(list_empty(&lock->l_pending_chain));
lprocfs_counter_decr(ldlm_res_to_ns(res)->ns_stats,
LDLM_NSS_LOCKS);
int ldlm_lock_remove_from_lru_nolock(struct ldlm_lock *lock)
{
int rc = 0;
- if (!cfs_list_empty(&lock->l_lru)) {
+ if (!list_empty(&lock->l_lru)) {
struct ldlm_namespace *ns = ldlm_lock_to_ns(lock);
LASSERT(lock->l_resource->lr_type != LDLM_FLOCK);
- cfs_list_del_init(&lock->l_lru);
+ list_del_init(&lock->l_lru);
LASSERT(ns->ns_nr_unused > 0);
ns->ns_nr_unused--;
rc = 1;
ENTRY;
if (ldlm_is_ns_srv(lock)) {
- LASSERT(cfs_list_empty(&lock->l_lru));
+ LASSERT(list_empty(&lock->l_lru));
RETURN(0);
}
struct ldlm_namespace *ns = ldlm_lock_to_ns(lock);
lock->l_last_used = cfs_time_current();
- LASSERT(cfs_list_empty(&lock->l_lru));
+ LASSERT(list_empty(&lock->l_lru));
LASSERT(lock->l_resource->lr_type != LDLM_FLOCK);
- cfs_list_add_tail(&lock->l_lru, &ns->ns_unused_list);
+ list_add_tail(&lock->l_lru, &ns->ns_unused_list);
ldlm_clear_skipped(lock);
LASSERT(ns->ns_nr_unused >= 0);
ns->ns_nr_unused++;
ENTRY;
if (ldlm_is_ns_srv(lock)) {
- LASSERT(cfs_list_empty(&lock->l_lru));
+ LASSERT(list_empty(&lock->l_lru));
EXIT;
return;
}
spin_lock(&ns->ns_lock);
- if (!cfs_list_empty(&lock->l_lru)) {
+ if (!list_empty(&lock->l_lru)) {
ldlm_lock_remove_from_lru_nolock(lock);
ldlm_lock_add_to_lru_nolock(lock);
}
LBUG();
}
- if (!cfs_list_empty(&lock->l_res_link)) {
+ if (!list_empty(&lock->l_res_link)) {
LDLM_ERROR(lock, "lock still on resource");
LBUG();
}
if (ldlm_is_destroyed(lock)) {
- LASSERT(cfs_list_empty(&lock->l_lru));
+ LASSERT(list_empty(&lock->l_lru));
EXIT;
return 0;
}
lu_ref_add(&resource->lr_reference, "lock", lock);
atomic_set(&lock->l_refc, 2);
- CFS_INIT_LIST_HEAD(&lock->l_res_link);
- CFS_INIT_LIST_HEAD(&lock->l_lru);
- CFS_INIT_LIST_HEAD(&lock->l_pending_chain);
- CFS_INIT_LIST_HEAD(&lock->l_bl_ast);
- CFS_INIT_LIST_HEAD(&lock->l_cp_ast);
- CFS_INIT_LIST_HEAD(&lock->l_rk_ast);
+ INIT_LIST_HEAD(&lock->l_res_link);
+ INIT_LIST_HEAD(&lock->l_lru);
+ INIT_LIST_HEAD(&lock->l_pending_chain);
+ INIT_LIST_HEAD(&lock->l_bl_ast);
+ INIT_LIST_HEAD(&lock->l_cp_ast);
+ INIT_LIST_HEAD(&lock->l_rk_ast);
init_waitqueue_head(&lock->l_waitq);
lock->l_blocking_lock = NULL;
- CFS_INIT_LIST_HEAD(&lock->l_sl_mode);
- CFS_INIT_LIST_HEAD(&lock->l_sl_policy);
- CFS_INIT_HLIST_NODE(&lock->l_exp_hash);
- CFS_INIT_HLIST_NODE(&lock->l_exp_flock_hash);
+ INIT_LIST_HEAD(&lock->l_sl_mode);
+ INIT_LIST_HEAD(&lock->l_sl_policy);
+ INIT_HLIST_NODE(&lock->l_exp_hash);
+ INIT_HLIST_NODE(&lock->l_exp_flock_hash);
lprocfs_counter_incr(ldlm_res_to_ns(resource)->ns_stats,
LDLM_NSS_LOCKS);
- CFS_INIT_LIST_HEAD(&lock->l_handle.h_link);
+ INIT_LIST_HEAD(&lock->l_handle.h_link);
class_handle_hash(&lock->l_handle, &lock_handle_ops);
lu_ref_init(&lock->l_reference);
lock->l_callback_timeout = 0;
#if LUSTRE_TRACKS_LOCK_EXP_REFS
- CFS_INIT_LIST_HEAD(&lock->l_exp_refs_link);
+ INIT_LIST_HEAD(&lock->l_exp_refs_link);
lock->l_exp_refs_nr = 0;
lock->l_exp_refs_target = NULL;
#endif
- CFS_INIT_LIST_HEAD(&lock->l_exp_list);
+ INIT_LIST_HEAD(&lock->l_exp_list);
RETURN(lock);
}
LASSERT(new_resid->name[0] != 0);
/* This function assumes that the lock isn't on any lists */
- LASSERT(cfs_list_empty(&lock->l_res_link));
+ LASSERT(list_empty(&lock->l_res_link));
type = oldres->lr_type;
unlock_res_and_lock(lock);
* Only add if we have not sent a blocking AST to the lock yet.
*/
void ldlm_add_bl_work_item(struct ldlm_lock *lock, struct ldlm_lock *new,
- cfs_list_t *work_list)
+ struct list_head *work_list)
{
if (!ldlm_is_ast_sent(lock)) {
LDLM_DEBUG(lock, "lock incompatible; sending blocking AST.");
* discard dirty data, rather than writing back. */
if (ldlm_is_ast_discard_data(new))
ldlm_set_discard_data(lock);
- LASSERT(cfs_list_empty(&lock->l_bl_ast));
- cfs_list_add(&lock->l_bl_ast, work_list);
+ LASSERT(list_empty(&lock->l_bl_ast));
+ list_add(&lock->l_bl_ast, work_list);
LDLM_LOCK_GET(lock);
LASSERT(lock->l_blocking_lock == NULL);
lock->l_blocking_lock = LDLM_LOCK_GET(new);
/**
* Add a lock to list of just granted locks to send completion AST to.
*/
-void ldlm_add_cp_work_item(struct ldlm_lock *lock, cfs_list_t *work_list)
+void ldlm_add_cp_work_item(struct ldlm_lock *lock, struct list_head *work_list)
{
if (!ldlm_is_cp_reqd(lock)) {
ldlm_set_cp_reqd(lock);
LDLM_DEBUG(lock, "lock granted; sending completion AST.");
- LASSERT(cfs_list_empty(&lock->l_cp_ast));
- cfs_list_add(&lock->l_cp_ast, work_list);
+ LASSERT(list_empty(&lock->l_cp_ast));
+ list_add(&lock->l_cp_ast, work_list);
LDLM_LOCK_GET(lock);
}
}
* Must be called with lr_lock held.
*/
void ldlm_add_ast_work_item(struct ldlm_lock *lock, struct ldlm_lock *new,
- cfs_list_t *work_list)
+ struct list_head *work_list)
{
ENTRY;
check_res_locked(lock->l_resource);
EXPORT_SYMBOL(ldlm_lock_decref_and_cancel);
struct sl_insert_point {
- cfs_list_t *res_link;
- cfs_list_t *mode_link;
- cfs_list_t *policy_link;
+ struct list_head *res_link;
+ struct list_head *mode_link;
+ struct list_head *policy_link;
};
/**
* NOTE: called by
* - ldlm_grant_lock_with_skiplist
*/
-static void search_granted_lock(cfs_list_t *queue,
+static void search_granted_lock(struct list_head *queue,
struct ldlm_lock *req,
struct sl_insert_point *prev)
{
- cfs_list_t *tmp;
+ struct list_head *tmp;
struct ldlm_lock *lock, *mode_end, *policy_end;
ENTRY;
- cfs_list_for_each(tmp, queue) {
- lock = cfs_list_entry(tmp, struct ldlm_lock, l_res_link);
+ list_for_each(tmp, queue) {
+ lock = list_entry(tmp, struct ldlm_lock, l_res_link);
- mode_end = cfs_list_entry(lock->l_sl_mode.prev,
+ mode_end = list_entry(lock->l_sl_mode.prev,
struct ldlm_lock, l_sl_mode);
if (lock->l_req_mode != req->l_req_mode) {
} else if (lock->l_resource->lr_type == LDLM_IBITS) {
for (;;) {
policy_end =
- cfs_list_entry(lock->l_sl_policy.prev,
+ list_entry(lock->l_sl_policy.prev,
struct ldlm_lock,
l_sl_policy);
/* go to next policy group within mode group */
tmp = policy_end->l_res_link.next;
- lock = cfs_list_entry(tmp, struct ldlm_lock,
+ lock = list_entry(tmp, struct ldlm_lock,
l_res_link);
} /* loop over policy groups within the mode group */
return;
}
- LASSERT(cfs_list_empty(&lock->l_res_link));
- LASSERT(cfs_list_empty(&lock->l_sl_mode));
- LASSERT(cfs_list_empty(&lock->l_sl_policy));
+ LASSERT(list_empty(&lock->l_res_link));
+ LASSERT(list_empty(&lock->l_sl_mode));
+ LASSERT(list_empty(&lock->l_sl_policy));
/*
* lock->link == prev->link means lock is first starting the group.
* Don't re-add to itself to suppress kernel warnings.
*/
if (&lock->l_res_link != prev->res_link)
- cfs_list_add(&lock->l_res_link, prev->res_link);
+ list_add(&lock->l_res_link, prev->res_link);
if (&lock->l_sl_mode != prev->mode_link)
- cfs_list_add(&lock->l_sl_mode, prev->mode_link);
+ list_add(&lock->l_sl_mode, prev->mode_link);
if (&lock->l_sl_policy != prev->policy_link)
- cfs_list_add(&lock->l_sl_policy, prev->policy_link);
+ list_add(&lock->l_sl_policy, prev->policy_link);
EXIT;
}
*
* must be called with lr_lock held
*/
-void ldlm_grant_lock(struct ldlm_lock *lock, cfs_list_t *work_list)
+void ldlm_grant_lock(struct ldlm_lock *lock, struct list_head *work_list)
{
struct ldlm_resource *res = lock->l_resource;
ENTRY;
* \retval a referenced lock or NULL. See the flag descriptions below, in the
* comment above ldlm_lock_match
*/
-static struct ldlm_lock *search_queue(cfs_list_t *queue,
+static struct ldlm_lock *search_queue(struct list_head *queue,
ldlm_mode_t *mode,
ldlm_policy_data_t *policy,
struct ldlm_lock *old_lock,
__u64 flags, int unref)
{
struct ldlm_lock *lock;
- cfs_list_t *tmp;
+ struct list_head *tmp;
- cfs_list_for_each(tmp, queue) {
+ list_for_each(tmp, queue) {
ldlm_mode_t match;
- lock = cfs_list_entry(tmp, struct ldlm_lock, l_res_link);
+ lock = list_entry(tmp, struct ldlm_lock, l_res_link);
if (lock == old_lock)
break;
GOTO(out, rc = -ENOMEM);
}
- CFS_INIT_LIST_HEAD(&node->li_group);
+ INIT_LIST_HEAD(&node->li_group);
ldlm_interval_attach(node, lock);
node = NULL;
}
*
* Must be called with resource lock held.
*/
-int ldlm_reprocess_queue(struct ldlm_resource *res, cfs_list_t *queue,
- cfs_list_t *work_list)
+int ldlm_reprocess_queue(struct ldlm_resource *res, struct list_head *queue,
+ struct list_head *work_list)
{
- cfs_list_t *tmp, *pos;
+ struct list_head *tmp, *pos;
ldlm_processing_policy policy;
__u64 flags;
int rc = LDLM_ITER_CONTINUE;
policy = ldlm_processing_policy_table[res->lr_type];
LASSERT(policy);
- cfs_list_for_each_safe(tmp, pos, queue) {
+ list_for_each_safe(tmp, pos, queue) {
struct ldlm_lock *pending;
- pending = cfs_list_entry(tmp, struct ldlm_lock, l_res_link);
+ pending = list_entry(tmp, struct ldlm_lock, l_res_link);
CDEBUG(D_INFO, "Reprocessing lock %p\n", pending);
struct ldlm_lock *lock;
ENTRY;
- if (cfs_list_empty(arg->list))
+ if (list_empty(arg->list))
RETURN(-ENOENT);
- lock = cfs_list_entry(arg->list->next, struct ldlm_lock, l_bl_ast);
+ lock = list_entry(arg->list->next, struct ldlm_lock, l_bl_ast);
/* nobody should touch l_bl_ast */
lock_res_and_lock(lock);
- cfs_list_del_init(&lock->l_bl_ast);
+ list_del_init(&lock->l_bl_ast);
LASSERT(ldlm_is_ast_sent(lock));
LASSERT(lock->l_bl_ast_run == 0);
ldlm_completion_callback completion_callback;
ENTRY;
- if (cfs_list_empty(arg->list))
+ if (list_empty(arg->list))
RETURN(-ENOENT);
- lock = cfs_list_entry(arg->list->next, struct ldlm_lock, l_cp_ast);
+ lock = list_entry(arg->list->next, struct ldlm_lock, l_cp_ast);
/* It's possible to receive a completion AST before we've set
* the l_completion_ast pointer: either because the AST arrived
/* nobody should touch l_cp_ast */
lock_res_and_lock(lock);
- cfs_list_del_init(&lock->l_cp_ast);
+ list_del_init(&lock->l_cp_ast);
LASSERT(ldlm_is_cp_reqd(lock));
/* save l_completion_ast since it can be changed by
* mds_intent_policy(), see bug 14225 */
struct ldlm_lock *lock;
ENTRY;
- if (cfs_list_empty(arg->list))
+ if (list_empty(arg->list))
RETURN(-ENOENT);
- lock = cfs_list_entry(arg->list->next, struct ldlm_lock, l_rk_ast);
- cfs_list_del_init(&lock->l_rk_ast);
+ lock = list_entry(arg->list->next, struct ldlm_lock, l_rk_ast);
+ list_del_init(&lock->l_rk_ast);
/* the desc just pretend to exclusive */
ldlm_lock2desc(lock, &desc);
int rc = 0;
ENTRY;
- if (cfs_list_empty(arg->list))
+ if (list_empty(arg->list))
RETURN(-ENOENT);
- gl_work = cfs_list_entry(arg->list->next, struct ldlm_glimpse_work,
+ gl_work = list_entry(arg->list->next, struct ldlm_glimpse_work,
gl_list);
- cfs_list_del_init(&gl_work->gl_list);
+ list_del_init(&gl_work->gl_list);
lock = gl_work->gl_lock;
* Used on server to send multiple ASTs together instead of sending one by
* one.
*/
-int ldlm_run_ast_work(struct ldlm_namespace *ns, cfs_list_t *rpc_list,
+int ldlm_run_ast_work(struct ldlm_namespace *ns, struct list_head *rpc_list,
ldlm_desc_ast_t ast_type)
{
struct ldlm_cb_set_arg *arg;
set_producer_func work_ast_lock;
int rc;
- if (cfs_list_empty(rpc_list))
+ if (list_empty(rpc_list))
RETURN(0);
OBD_ALLOC_PTR(arg);
}
static int ldlm_reprocess_res(cfs_hash_t *hs, cfs_hash_bd_t *bd,
- cfs_hlist_node_t *hnode, void *arg)
+ struct hlist_node *hnode, void *arg)
{
struct ldlm_resource *res = cfs_hash_object(hs, hnode);
int rc;
*/
void ldlm_reprocess_all(struct ldlm_resource *res)
{
- CFS_LIST_HEAD(rpc_list);
-
+ struct list_head rpc_list;
#ifdef HAVE_SERVER_SUPPORT
int rc;
ENTRY;
+
+ INIT_LIST_HEAD(&rpc_list);
/* Local lock trees don't get reprocessed. */
if (ns_is_client(ldlm_res_to_ns(res))) {
EXIT;
rc = ldlm_run_ast_work(ldlm_res_to_ns(res), &rpc_list,
LDLM_WORK_CP_AST);
if (rc == -ERESTART) {
- LASSERT(cfs_list_empty(&rpc_list));
+ LASSERT(list_empty(&rpc_list));
goto restart;
}
#else
ENTRY;
+
+ INIT_LIST_HEAD(&rpc_list);
if (!ns_is_client(ldlm_res_to_ns(res))) {
CERROR("This is client-side-only module, cannot handle "
"LDLM_NAMESPACE_SERVER resource type lock.\n");
req->l_resource->lr_type != LDLM_IBITS)
return;
- cfs_list_del_init(&req->l_sl_policy);
- cfs_list_del_init(&req->l_sl_mode);
+ list_del_init(&req->l_sl_policy);
+ list_del_init(&req->l_sl_mode);
}
/**
* Cancels passed locks.
*/
int ldlm_cancel_locks_for_export_cb(cfs_hash_t *hs, cfs_hash_bd_t *bd,
- cfs_hlist_node_t *hnode, void *data)
+ struct hlist_node *hnode, void *data)
{
struct export_cl_data *ecl = (struct export_cl_data *)data;
struct ldlm_resource *ldlm_lock_convert(struct ldlm_lock *lock, int new_mode,
__u32 *flags)
{
- CFS_LIST_HEAD(rpc_list);
+ struct list_head rpc_list;
struct ldlm_resource *res;
struct ldlm_namespace *ns;
int granted = 0;
struct ldlm_interval *node;
ENTRY;
+ INIT_LIST_HEAD(&rpc_list);
/* Just return if mode is unchanged. */
if (new_mode == lock->l_granted_mode) {
*flags |= LDLM_FL_BLOCK_GRANTED;
/* FIXME: ugly code, I have to attach the lock to a
* interval node again since perhaps it will be granted
* soon */
- CFS_INIT_LIST_HEAD(&node->li_group);
+ INIT_LIST_HEAD(&node->li_group);
ldlm_interval_attach(node, lock);
node = NULL;
}