struct cl_object *obj,
const struct cl_lock_operations *ops)
{
- ENTRY;
- slice->cls_lock = lock;
- cfs_list_add_tail(&slice->cls_linkage, &lock->cll_layers);
- slice->cls_obj = obj;
- slice->cls_ops = ops;
- EXIT;
+ ENTRY;
+ slice->cls_lock = lock;
+ list_add_tail(&slice->cls_linkage, &lock->cll_layers);
+ slice->cls_obj = obj;
+ slice->cls_ops = ops;
+ EXIT;
}
EXPORT_SYMBOL(cl_lock_slice_add);
ENTRY;
cl_lock_trace(D_DLMTRACE, env, "free lock", lock);
- while (!cfs_list_empty(&lock->cll_layers)) {
+ while (!list_empty(&lock->cll_layers)) {
struct cl_lock_slice *slice;
- slice = cfs_list_entry(lock->cll_layers.next,
- struct cl_lock_slice, cls_linkage);
- cfs_list_del_init(lock->cll_layers.next);
+ slice = list_entry(lock->cll_layers.next,
+ struct cl_lock_slice, cls_linkage);
+ list_del_init(lock->cll_layers.next);
slice->cls_ops->clo_fini(env, slice);
}
CS_LOCK_DEC(obj, total);
if (atomic_dec_and_test(&lock->cll_ref)) {
if (lock->cll_state == CLS_FREEING) {
- LASSERT(cfs_list_empty(&lock->cll_linkage));
+ LASSERT(list_empty(&lock->cll_linkage));
cl_lock_free(env, lock);
}
CS_LOCK_DEC(obj, busy);
cl_object_get(obj);
lu_object_ref_add_at(&obj->co_lu, &lock->cll_obj_ref, "cl_lock",
lock);
- CFS_INIT_LIST_HEAD(&lock->cll_layers);
- CFS_INIT_LIST_HEAD(&lock->cll_linkage);
- CFS_INIT_LIST_HEAD(&lock->cll_inclosure);
+ INIT_LIST_HEAD(&lock->cll_layers);
+ INIT_LIST_HEAD(&lock->cll_linkage);
+ INIT_LIST_HEAD(&lock->cll_inclosure);
lu_ref_init(&lock->cll_reference);
lu_ref_init(&lock->cll_holders);
mutex_init(&lock->cll_guard);
CS_LOCK_INC(obj, total);
CS_LOCK_INC(obj, create);
cl_lock_lockdep_init(lock);
- cfs_list_for_each_entry(obj, &head->loh_layers,
- co_lu.lo_linkage) {
- int err;
-
- err = obj->co_ops->coo_lock_init(env, obj, lock, io);
- if (err != 0) {
- cl_lock_finish(env, lock);
- lock = ERR_PTR(err);
- break;
- }
- }
- } else
- lock = ERR_PTR(-ENOMEM);
- RETURN(lock);
+ list_for_each_entry(obj, &head->loh_layers, co_lu.lo_linkage) {
+ int err;
+
+ err = obj->co_ops->coo_lock_init(env, obj, lock, io);
+ if (err != 0) {
+ cl_lock_finish(env, lock);
+ lock = ERR_PTR(err);
+ break;
+ }
+ }
+ } else
+ lock = ERR_PTR(-ENOMEM);
+ RETURN(lock);
}
/**
LINVRNT(cl_lock_invariant_trusted(env, lock));
ENTRY;
- cfs_list_for_each_entry(slice, &lock->cll_layers, cls_linkage) {
+ list_for_each_entry(slice, &lock->cll_layers, cls_linkage) {
if (slice->cls_ops->clo_fits_into != NULL &&
!slice->cls_ops->clo_fits_into(env, slice, need, io))
RETURN(0);
head = cl_object_header(obj);
assert_spin_locked(&head->coh_lock_guard);
CS_LOCK_INC(obj, lookup);
- cfs_list_for_each_entry(lock, &head->coh_locks, cll_linkage) {
+ list_for_each_entry(lock, &head->coh_locks, cll_linkage) {
int matched;
matched = cl_lock_ext_match(&lock->cll_descr, need) &&
LINVRNT(cl_lock_invariant_trusted(NULL, lock));
ENTRY;
- cfs_list_for_each_entry(slice, &lock->cll_layers, cls_linkage) {
+ list_for_each_entry(slice, &lock->cll_layers, cls_linkage) {
if (slice->cls_obj->co_lu.lo_dev->ld_type == dtype)
RETURN(slice);
}
const struct cl_lock_slice *slice;
lock->cll_flags |= CLF_CANCELLED;
- cfs_list_for_each_entry_reverse(slice, &lock->cll_layers,
- cls_linkage) {
+ list_for_each_entry_reverse(slice, &lock->cll_layers,
+ cls_linkage) {
if (slice->cls_ops->clo_cancel != NULL)
slice->cls_ops->clo_cancel(env, slice);
}
if (in_cache) /* coh_locks cache holds a refcount. */
cl_lock_put(env, lock);
- /*
- * From now on, no new references to this lock can be acquired
- * by cl_lock_lookup().
- */
- cfs_list_for_each_entry_reverse(slice, &lock->cll_layers,
- cls_linkage) {
- if (slice->cls_ops->clo_delete != NULL)
- slice->cls_ops->clo_delete(env, slice);
- }
- /*
- * From now on, no new references to this lock can be acquired
- * by layer-specific means (like a pointer from struct
- * ldlm_lock in osc, or a pointer from top-lock to sub-lock in
- * lov).
- *
- * Lock will be finally freed in cl_lock_put() when last of
- * existing references goes away.
- */
- }
- EXIT;
+ /*
+ * From now on, no new references to this lock can be acquired
+ * by cl_lock_lookup().
+ */
+ list_for_each_entry_reverse(slice, &lock->cll_layers,
+ cls_linkage) {
+ if (slice->cls_ops->clo_delete != NULL)
+ slice->cls_ops->clo_delete(env, slice);
+ }
+ /*
+ * From now on, no new references to this lock can be acquired
+ * by layer-specific means (like a pointer from struct
+ * ldlm_lock in osc, or a pointer from top-lock to sub-lock in
+ * lov).
+ *
+ * Lock will be finally freed in cl_lock_put() when last of
+ * existing references goes away.
+ */
+ }
+ EXIT;
}
/**
LINVRNT(cl_lock_is_mutexed(lock));
LINVRNT(cl_lock_invariant(env, lock));
- cfs_list_for_each_entry(slice, &lock->cll_layers, cls_linkage)
+ list_for_each_entry(slice, &lock->cll_layers, cls_linkage)
if (slice->cls_ops->clo_state != NULL)
slice->cls_ops->clo_state(env, slice, state);
wake_up_all(&lock->cll_wq);
static int cl_unuse_try_internal(const struct lu_env *env, struct cl_lock *lock)
{
- const struct cl_lock_slice *slice;
- int result;
-
- do {
- result = 0;
+ const struct cl_lock_slice *slice;
+ int result;
- LINVRNT(cl_lock_is_mutexed(lock));
- LINVRNT(cl_lock_invariant(env, lock));
- LASSERT(lock->cll_state == CLS_INTRANSIT);
+ do {
+ result = 0;
- result = -ENOSYS;
- cfs_list_for_each_entry_reverse(slice, &lock->cll_layers,
- cls_linkage) {
- if (slice->cls_ops->clo_unuse != NULL) {
- result = slice->cls_ops->clo_unuse(env, slice);
- if (result != 0)
- break;
- }
- }
- LASSERT(result != -ENOSYS);
- } while (result == CLO_REPEAT);
+ LINVRNT(cl_lock_is_mutexed(lock));
+ LINVRNT(cl_lock_invariant(env, lock));
+ LASSERT(lock->cll_state == CLS_INTRANSIT);
+
+ result = -ENOSYS;
+ list_for_each_entry_reverse(slice, &lock->cll_layers,
+ cls_linkage) {
+ if (slice->cls_ops->clo_unuse != NULL) {
+ result = slice->cls_ops->clo_unuse(env, slice);
+ if (result != 0)
+ break;
+ }
+ }
+ LASSERT(result != -ENOSYS);
+ } while (result == CLO_REPEAT);
- return result;
+ return result;
}
/**
result = -ENOSYS;
state = cl_lock_intransit(env, lock);
- cfs_list_for_each_entry(slice, &lock->cll_layers, cls_linkage) {
+ list_for_each_entry(slice, &lock->cll_layers, cls_linkage) {
if (slice->cls_ops->clo_use != NULL) {
result = slice->cls_ops->clo_use(env, slice);
if (result != 0)
ENTRY;
result = -ENOSYS;
- cfs_list_for_each_entry(slice, &lock->cll_layers, cls_linkage) {
+ list_for_each_entry(slice, &lock->cll_layers, cls_linkage) {
if (slice->cls_ops->clo_enqueue != NULL) {
result = slice->cls_ops->clo_enqueue(env,
slice, io, flags);
break;
result = -ENOSYS;
- cfs_list_for_each_entry(slice, &lock->cll_layers, cls_linkage) {
+ list_for_each_entry(slice, &lock->cll_layers, cls_linkage) {
if (slice->cls_ops->clo_wait != NULL) {
result = slice->cls_ops->clo_wait(env, slice);
if (result != 0)
LINVRNT(cl_lock_invariant(env, lock));
pound = 0;
- cfs_list_for_each_entry_reverse(slice, &lock->cll_layers, cls_linkage) {
+ list_for_each_entry_reverse(slice, &lock->cll_layers, cls_linkage) {
if (slice->cls_ops->clo_weigh != NULL) {
ounce = slice->cls_ops->clo_weigh(env, slice);
pound += ounce;
LINVRNT(cl_lock_is_mutexed(lock));
LINVRNT(cl_lock_invariant(env, lock));
- cfs_list_for_each_entry_reverse(slice, &lock->cll_layers, cls_linkage) {
+ list_for_each_entry_reverse(slice, &lock->cll_layers, cls_linkage) {
if (slice->cls_ops->clo_modify != NULL) {
result = slice->cls_ops->clo_modify(env, slice, desc);
if (result != 0)
LINVRNT(cl_lock_is_mutexed(origin));
LINVRNT(cl_lock_invariant(env, origin));
- CFS_INIT_LIST_HEAD(&closure->clc_list);
+ INIT_LIST_HEAD(&closure->clc_list);
closure->clc_origin = origin;
closure->clc_wait = wait;
closure->clc_nr = 0;
result = cl_lock_enclosure(env, lock, closure);
if (result == 0) {
- cfs_list_for_each_entry(slice, &lock->cll_layers, cls_linkage) {
+ list_for_each_entry(slice, &lock->cll_layers, cls_linkage) {
if (slice->cls_ops->clo_closure != NULL) {
result = slice->cls_ops->clo_closure(env, slice,
closure);
* If lock->cll_inclosure is not empty, lock is already in
* this closure.
*/
- if (cfs_list_empty(&lock->cll_inclosure)) {
+ if (list_empty(&lock->cll_inclosure)) {
cl_lock_get_trust(lock);
lu_ref_add(&lock->cll_reference, "closure", closure);
- cfs_list_add(&lock->cll_inclosure, &closure->clc_list);
+ list_add(&lock->cll_inclosure, &closure->clc_list);
closure->clc_nr++;
} else
cl_lock_mutex_put(env, lock);
void cl_lock_disclosure(const struct lu_env *env,
struct cl_lock_closure *closure)
{
- struct cl_lock *scan;
- struct cl_lock *temp;
-
- cl_lock_trace(D_DLMTRACE, env, "disclosure lock", closure->clc_origin);
- cfs_list_for_each_entry_safe(scan, temp, &closure->clc_list,
- cll_inclosure){
- cfs_list_del_init(&scan->cll_inclosure);
- cl_lock_mutex_put(env, scan);
- lu_ref_del(&scan->cll_reference, "closure", closure);
- cl_lock_put(env, scan);
- closure->clc_nr--;
- }
- LASSERT(closure->clc_nr == 0);
+ struct cl_lock *scan;
+ struct cl_lock *temp;
+
+ cl_lock_trace(D_DLMTRACE, env, "disclosure lock", closure->clc_origin);
+ list_for_each_entry_safe(scan, temp, &closure->clc_list,
+ cll_inclosure){
+ list_del_init(&scan->cll_inclosure);
+ cl_lock_mutex_put(env, scan);
+ lu_ref_del(&scan->cll_reference, "closure", closure);
+ cl_lock_put(env, scan);
+ closure->clc_nr--;
+ }
+ LASSERT(closure->clc_nr == 0);
}
EXPORT_SYMBOL(cl_lock_disclosure);
void cl_lock_closure_fini(struct cl_lock_closure *closure)
{
LASSERT(closure->clc_nr == 0);
- LASSERT(cfs_list_empty(&closure->clc_list));
+ LASSERT(list_empty(&closure->clc_list));
}
EXPORT_SYMBOL(cl_lock_closure_fini);
spin_lock(&head->coh_lock_guard);
/* It is fine to match any group lock since there could be only one
* with a uniq gid and it conflicts with all other lock modes too */
- cfs_list_for_each_entry(scan, &head->coh_locks, cll_linkage) {
+ list_for_each_entry(scan, &head->coh_locks, cll_linkage) {
if (scan != except &&
(scan->cll_descr.cld_mode == CLM_GROUP ||
cl_lock_ext_match(&scan->cll_descr, need)) &&
head = cl_object_header(obj);
spin_lock(&head->coh_lock_guard);
- while (!cfs_list_empty(&head->coh_locks)) {
+ while (!list_empty(&head->coh_locks)) {
lock = container_of(head->coh_locks.next,
struct cl_lock, cll_linkage);
cl_lock_get_trust(lock);
cl_lock_descr_print(env, cookie, printer, &lock->cll_descr);
(*printer)(env, cookie, " {\n");
- cfs_list_for_each_entry(slice, &lock->cll_layers, cls_linkage) {
+ list_for_each_entry(slice, &lock->cll_layers, cls_linkage) {
(*printer)(env, cookie, " %s@%p: ",
slice->cls_obj->co_lu.lo_dev->ld_type->ldt_name,
slice);
git://git.whamcloud.com / fs / lustre-release.git / blobdiff