/* lock types */
char *ldlm_lockname[] = {
- [0] "--",
- [LCK_EX] "EX",
- [LCK_PW] "PW",
- [LCK_PR] "PR",
- [LCK_CW] "CW",
- [LCK_CR] "CR",
- [LCK_NL] "NL",
- [LCK_GROUP] "GROUP",
- [LCK_COS] "COS"
+ [0] = "--",
+ [LCK_EX] = "EX",
+ [LCK_PW] = "PW",
+ [LCK_PR] = "PR",
+ [LCK_CW] = "CW",
+ [LCK_CR] = "CR",
+ [LCK_NL] = "NL",
+ [LCK_GROUP] = "GROUP",
+ [LCK_COS] = "COS"
};
EXPORT_SYMBOL(ldlm_lockname);
char *ldlm_typename[] = {
- [LDLM_PLAIN] "PLN",
- [LDLM_EXTENT] "EXT",
- [LDLM_FLOCK] "FLK",
- [LDLM_IBITS] "IBT",
+ [LDLM_PLAIN] = "PLN",
+ [LDLM_EXTENT] = "EXT",
+ [LDLM_FLOCK] = "FLK",
+ [LDLM_IBITS] = "IBT",
};
EXPORT_SYMBOL(ldlm_typename);
static ldlm_policy_wire_to_local_t ldlm_policy_wire18_to_local[] = {
- [LDLM_PLAIN - LDLM_MIN_TYPE] ldlm_plain_policy_wire_to_local,
- [LDLM_EXTENT - LDLM_MIN_TYPE] ldlm_extent_policy_wire_to_local,
- [LDLM_FLOCK - LDLM_MIN_TYPE] ldlm_flock_policy_wire18_to_local,
- [LDLM_IBITS - LDLM_MIN_TYPE] ldlm_ibits_policy_wire_to_local,
+ [LDLM_PLAIN - LDLM_MIN_TYPE] = ldlm_plain_policy_wire_to_local,
+ [LDLM_EXTENT - LDLM_MIN_TYPE] = ldlm_extent_policy_wire_to_local,
+ [LDLM_FLOCK - LDLM_MIN_TYPE] = ldlm_flock_policy_wire18_to_local,
+ [LDLM_IBITS - LDLM_MIN_TYPE] = ldlm_ibits_policy_wire_to_local,
};
static ldlm_policy_wire_to_local_t ldlm_policy_wire21_to_local[] = {
- [LDLM_PLAIN - LDLM_MIN_TYPE] ldlm_plain_policy_wire_to_local,
- [LDLM_EXTENT - LDLM_MIN_TYPE] ldlm_extent_policy_wire_to_local,
- [LDLM_FLOCK - LDLM_MIN_TYPE] ldlm_flock_policy_wire21_to_local,
- [LDLM_IBITS - LDLM_MIN_TYPE] ldlm_ibits_policy_wire_to_local,
+ [LDLM_PLAIN - LDLM_MIN_TYPE] = ldlm_plain_policy_wire_to_local,
+ [LDLM_EXTENT - LDLM_MIN_TYPE] = ldlm_extent_policy_wire_to_local,
+ [LDLM_FLOCK - LDLM_MIN_TYPE] = ldlm_flock_policy_wire21_to_local,
+ [LDLM_IBITS - LDLM_MIN_TYPE] = ldlm_ibits_policy_wire_to_local,
};
static ldlm_policy_local_to_wire_t ldlm_policy_local_to_wire[] = {
- [LDLM_PLAIN - LDLM_MIN_TYPE] ldlm_plain_policy_local_to_wire,
- [LDLM_EXTENT - LDLM_MIN_TYPE] ldlm_extent_policy_local_to_wire,
- [LDLM_FLOCK - LDLM_MIN_TYPE] ldlm_flock_policy_local_to_wire,
- [LDLM_IBITS - LDLM_MIN_TYPE] ldlm_ibits_policy_local_to_wire,
+ [LDLM_PLAIN - LDLM_MIN_TYPE] = ldlm_plain_policy_local_to_wire,
+ [LDLM_EXTENT - LDLM_MIN_TYPE] = ldlm_extent_policy_local_to_wire,
+ [LDLM_FLOCK - LDLM_MIN_TYPE] = ldlm_flock_policy_local_to_wire,
+ [LDLM_IBITS - LDLM_MIN_TYPE] = ldlm_ibits_policy_local_to_wire,
};
/**
#ifdef HAVE_SERVER_SUPPORT
static ldlm_processing_policy ldlm_processing_policy_table[] = {
- [LDLM_PLAIN] ldlm_process_plain_lock,
- [LDLM_EXTENT] ldlm_process_extent_lock,
+ [LDLM_PLAIN] = ldlm_process_plain_lock,
+ [LDLM_EXTENT] = ldlm_process_extent_lock,
# ifdef __KERNEL__
- [LDLM_FLOCK] ldlm_process_flock_lock,
+ [LDLM_FLOCK] = ldlm_process_flock_lock,
# endif
- [LDLM_IBITS] ldlm_process_inodebits_lock,
+ [LDLM_IBITS] = ldlm_process_inodebits_lock,
};
ldlm_processing_policy ldlm_get_processing_policy(struct ldlm_resource *res)
*/
struct ldlm_lock *ldlm_lock_get(struct ldlm_lock *lock)
{
- cfs_atomic_inc(&lock->l_refc);
+ atomic_inc(&lock->l_refc);
return lock;
}
EXPORT_SYMBOL(ldlm_lock_get);
ENTRY;
LASSERT(lock->l_resource != LP_POISON);
- LASSERT(cfs_atomic_read(&lock->l_refc) > 0);
- if (cfs_atomic_dec_and_test(&lock->l_refc)) {
+ LASSERT(atomic_read(&lock->l_refc) > 0);
+ if (atomic_dec_and_test(&lock->l_refc)) {
struct ldlm_resource *res;
LDLM_DEBUG(lock,
*/
int ldlm_lock_remove_from_lru_nolock(struct ldlm_lock *lock)
{
- int rc = 0;
- if (!cfs_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);
- ldlm_clear_skipped(lock);
- LASSERT(ns->ns_nr_unused > 0);
- ns->ns_nr_unused--;
- rc = 1;
- }
- return rc;
+ int rc = 0;
+ if (!cfs_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);
+ LASSERT(ns->ns_nr_unused > 0);
+ ns->ns_nr_unused--;
+ rc = 1;
+ }
+ return rc;
}
/**
*/
void ldlm_lock_add_to_lru_nolock(struct ldlm_lock *lock)
{
- struct ldlm_namespace *ns = ldlm_lock_to_ns(lock);
+ struct ldlm_namespace *ns = ldlm_lock_to_ns(lock);
- lock->l_last_used = cfs_time_current();
- LASSERT(cfs_list_empty(&lock->l_lru));
- LASSERT(lock->l_resource->lr_type != LDLM_FLOCK);
- cfs_list_add_tail(&lock->l_lru, &ns->ns_unused_list);
- LASSERT(ns->ns_nr_unused >= 0);
- ns->ns_nr_unused++;
+ lock->l_last_used = cfs_time_current();
+ LASSERT(cfs_list_empty(&lock->l_lru));
+ LASSERT(lock->l_resource->lr_type != LDLM_FLOCK);
+ cfs_list_add_tail(&lock->l_lru, &ns->ns_unused_list);
+ ldlm_clear_skipped(lock);
+ LASSERT(ns->ns_nr_unused >= 0);
+ ns->ns_nr_unused++;
}
/**
*/
static struct ldlm_lock *ldlm_lock_new(struct ldlm_resource *resource)
{
- struct ldlm_lock *lock;
- ENTRY;
+ struct ldlm_lock *lock;
+ ENTRY;
- if (resource == NULL)
- LBUG();
+ if (resource == NULL)
+ LBUG();
- OBD_SLAB_ALLOC_PTR_GFP(lock, ldlm_lock_slab, __GFP_IO);
- if (lock == NULL)
- RETURN(NULL);
+ OBD_SLAB_ALLOC_PTR_GFP(lock, ldlm_lock_slab, GFP_NOFS);
+ if (lock == NULL)
+ RETURN(NULL);
spin_lock_init(&lock->l_lock);
- lock->l_resource = resource;
- lu_ref_add(&resource->lr_reference, "lock", lock);
+ lock->l_resource = resource;
+ lu_ref_add(&resource->lr_reference, "lock", lock);
- cfs_atomic_set(&lock->l_refc, 2);
+ 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);
type = oldres->lr_type;
unlock_res_and_lock(lock);
- newres = ldlm_resource_get(ns, NULL, new_resid, type, 1);
- if (newres == NULL)
- RETURN(-ENOMEM);
+ newres = ldlm_resource_get(ns, NULL, new_resid, type, 1);
+ if (IS_ERR(newres))
+ RETURN(PTR_ERR(newres));
lu_ref_add(&newres->lr_reference, "lock", lock);
/*
check_res_locked(res);
lock->l_granted_mode = lock->l_req_mode;
+
+ if (work_list && lock->l_completion_ast != NULL)
+ ldlm_add_ast_work_item(lock, NULL, work_list);
+
+ /* We should not add locks to granted list in the following cases:
+ * - this is an UNLOCK but not a real lock;
+ * - this is a TEST lock;
+ * - this is a F_CANCELLK lock (async flock has req_mode == 0)
+ * - this is a deadlock (flock cannot be granted) */
+ if (lock->l_req_mode == 0 ||
+ lock->l_req_mode == LCK_NL ||
+ ldlm_is_test_lock(lock) ||
+ ldlm_is_flock_deadlock(lock))
+ RETURN_EXIT;
+
if (res->lr_type == LDLM_PLAIN || res->lr_type == LDLM_IBITS)
ldlm_grant_lock_with_skiplist(lock);
else if (res->lr_type == LDLM_EXTENT)
if (lock->l_granted_mode < res->lr_most_restr)
res->lr_most_restr = lock->l_granted_mode;
- if (work_list && lock->l_completion_ast != NULL)
- ldlm_add_ast_work_item(lock, NULL, work_list);
-
ldlm_pool_add(&ldlm_res_to_ns(res)->ns_pool, lock);
EXIT;
}
mode = old_lock->l_req_mode;
}
- res = ldlm_resource_get(ns, NULL, res_id, type, 0);
- if (res == NULL) {
- LASSERT(old_lock == NULL);
- RETURN(0);
- }
+ res = ldlm_resource_get(ns, NULL, res_id, type, 0);
+ if (IS_ERR(res)) {
+ LASSERT(old_lock == NULL);
+ RETURN(0);
+ }
LDLM_RESOURCE_ADDREF(res);
lock_res(res);
* Returns a referenced lock
*/
struct ldlm_lock *ldlm_lock_create(struct ldlm_namespace *ns,
- const struct ldlm_res_id *res_id,
- ldlm_type_t type,
- ldlm_mode_t mode,
- const struct ldlm_callback_suite *cbs,
+ const struct ldlm_res_id *res_id,
+ ldlm_type_t type,
+ ldlm_mode_t mode,
+ const struct ldlm_callback_suite *cbs,
void *data, __u32 lvb_len,
enum lvb_type lvb_type)
{
- struct ldlm_lock *lock;
- struct ldlm_resource *res;
- ENTRY;
-
- res = ldlm_resource_get(ns, NULL, res_id, type, 1);
- if (res == NULL)
- RETURN(NULL);
+ struct ldlm_lock *lock;
+ struct ldlm_resource *res;
+ int rc;
+ ENTRY;
- lock = ldlm_lock_new(res);
+ res = ldlm_resource_get(ns, NULL, res_id, type, 1);
+ if (IS_ERR(res))
+ RETURN(ERR_CAST(res));
- if (lock == NULL)
- RETURN(NULL);
+ lock = ldlm_lock_new(res);
+ if (lock == NULL)
+ RETURN(ERR_PTR(-ENOMEM));
lock->l_req_mode = mode;
lock->l_ast_data = data;
lock->l_pid = current_pid();
if (ns_is_server(ns))
ldlm_set_ns_srv(lock);
- if (cbs) {
- lock->l_blocking_ast = cbs->lcs_blocking;
- lock->l_completion_ast = cbs->lcs_completion;
- lock->l_glimpse_ast = cbs->lcs_glimpse;
- }
-
- lock->l_tree_node = NULL;
- /* if this is the extent lock, allocate the interval tree node */
- if (type == LDLM_EXTENT) {
- if (ldlm_interval_alloc(lock) == NULL)
- GOTO(out, 0);
- }
+ if (cbs) {
+ lock->l_blocking_ast = cbs->lcs_blocking;
+ lock->l_completion_ast = cbs->lcs_completion;
+ lock->l_glimpse_ast = cbs->lcs_glimpse;
+ }
- if (lvb_len) {
- lock->l_lvb_len = lvb_len;
- OBD_ALLOC_LARGE(lock->l_lvb_data, lvb_len);
- if (lock->l_lvb_data == NULL)
- GOTO(out, 0);
- }
+ lock->l_tree_node = NULL;
+ /* if this is the extent lock, allocate the interval tree node */
+ if (type == LDLM_EXTENT)
+ if (ldlm_interval_alloc(lock) == NULL)
+ GOTO(out, rc = -ENOMEM);
+
+ if (lvb_len) {
+ lock->l_lvb_len = lvb_len;
+ OBD_ALLOC_LARGE(lock->l_lvb_data, lvb_len);
+ if (lock->l_lvb_data == NULL)
+ GOTO(out, rc = -ENOMEM);
+ }
lock->l_lvb_type = lvb_type;
- if (OBD_FAIL_CHECK(OBD_FAIL_LDLM_NEW_LOCK))
- GOTO(out, 0);
+ if (OBD_FAIL_CHECK(OBD_FAIL_LDLM_NEW_LOCK))
+ GOTO(out, rc = -ENOENT);
- RETURN(lock);
+ RETURN(lock);
out:
- ldlm_lock_destroy(lock);
- LDLM_LOCK_RELEASE(lock);
- return NULL;
+ ldlm_lock_destroy(lock);
+ LDLM_LOCK_RELEASE(lock);
+ RETURN(ERR_PTR(rc));
}
/**
}
}
- /* For a replaying lock, it might be already in granted list. So
- * unlinking the lock will cause the interval node to be freed, we
- * have to allocate the interval node early otherwise we can't regrant
- * this lock in the future. - jay */
- if (!local && (*flags & LDLM_FL_REPLAY) && res->lr_type == LDLM_EXTENT)
- OBD_SLAB_ALLOC_PTR_GFP(node, ldlm_interval_slab, __GFP_IO);
+ /* For a replaying lock, it might be already in granted list. So
+ * unlinking the lock will cause the interval node to be freed, we
+ * have to allocate the interval node early otherwise we can't regrant
+ * this lock in the future. - jay */
+ if (!local && (*flags & LDLM_FL_REPLAY) && res->lr_type == LDLM_EXTENT)
+ OBD_SLAB_ALLOC_PTR_GFP(node, ldlm_interval_slab, GFP_NOFS);
lock_res_and_lock(lock);
if (local && lock->l_req_mode == lock->l_granted_mode) {
* need to do anything else. */
*flags &= ~(LDLM_FL_BLOCK_GRANTED |
LDLM_FL_BLOCK_CONV | LDLM_FL_BLOCK_WAIT);
- GOTO(out, ELDLM_OK);
+ GOTO(out, rc = ELDLM_OK);
}
ldlm_resource_unlink_lock(lock);
* lock's l_flags. */
if (*flags & LDLM_FL_AST_DISCARD_DATA)
ldlm_set_ast_discard_data(lock);
+ if (*flags & LDLM_FL_TEST_LOCK)
+ ldlm_set_test_lock(lock);
/* This distinction between local lock trees is very important; a client
* namespace only has information about locks taken by that client, and
ldlm_resource_add_lock(res, &res->lr_waiting, lock);
else
ldlm_grant_lock(lock, NULL);
- GOTO(out, ELDLM_OK);
+ GOTO(out, rc = ELDLM_OK);
#ifdef HAVE_SERVER_SUPPORT
+ } else if (*flags & LDLM_FL_RESENT) {
+ GOTO(out, rc = ELDLM_OK);
} else if (*flags & LDLM_FL_REPLAY) {
if (*flags & LDLM_FL_BLOCK_CONV) {
ldlm_resource_add_lock(res, &res->lr_converting, lock);
- GOTO(out, ELDLM_OK);
+ GOTO(out, rc = ELDLM_OK);
} else if (*flags & LDLM_FL_BLOCK_WAIT) {
ldlm_resource_add_lock(res, &res->lr_waiting, lock);
- GOTO(out, ELDLM_OK);
+ GOTO(out, rc = ELDLM_OK);
} else if (*flags & LDLM_FL_BLOCK_GRANTED) {
ldlm_grant_lock(lock, NULL);
- GOTO(out, ELDLM_OK);
+ GOTO(out, rc = ELDLM_OK);
}
/* If no flags, fall through to normal enqueue path. */
}
if (arg == NULL)
RETURN(-ENOMEM);
- cfs_atomic_set(&arg->restart, 0);
+ atomic_set(&arg->restart, 0);
arg->list = rpc_list;
switch (ast_type) {
ptlrpc_set_wait(arg->set);
ptlrpc_set_destroy(arg->set);
- rc = cfs_atomic_read(&arg->restart) ? -ERESTART : 0;
+ rc = atomic_read(&arg->restart) ? -ERESTART : 0;
GOTO(out, rc);
out:
OBD_FREE_PTR(arg);
"Cancel lock %p for export %p (loop %d), still have "
"%d locks left on hash table.\n",
lock, exp, ecl->ecl_loop,
- cfs_atomic_read(&hs->hs_count));
+ atomic_read(&hs->hs_count));
}
return 0;
* pages on a file.
*/
struct ldlm_resource *ldlm_lock_convert(struct ldlm_lock *lock, int new_mode,
- __u32 *flags)
+ __u32 *flags)
{
- CFS_LIST_HEAD(rpc_list);
- struct ldlm_resource *res;
- struct ldlm_namespace *ns;
- int granted = 0;
+ CFS_LIST_HEAD(rpc_list);
+ struct ldlm_resource *res;
+ struct ldlm_namespace *ns;
+ int granted = 0;
#ifdef HAVE_SERVER_SUPPORT
int old_mode;
struct sl_insert_point prev;
#endif
- struct ldlm_interval *node;
- ENTRY;
+ struct ldlm_interval *node;
+ ENTRY;
/* Just return if mode is unchanged. */
if (new_mode == lock->l_granted_mode) {
- *flags |= LDLM_FL_BLOCK_GRANTED;
- RETURN(lock->l_resource);
- }
+ *flags |= LDLM_FL_BLOCK_GRANTED;
+ RETURN(lock->l_resource);
+ }
- /* I can't check the type of lock here because the bitlock of lock
- * is not held here, so do the allocation blindly. -jay */
- OBD_SLAB_ALLOC_PTR_GFP(node, ldlm_interval_slab, __GFP_IO);
+ /* I can't check the type of lock here because the bitlock of lock
+ * is not held here, so do the allocation blindly. -jay */
+ OBD_SLAB_ALLOC_PTR_GFP(node, ldlm_interval_slab, GFP_NOFS);
if (node == NULL) /* Actually, this causes EDEADLOCK to be returned */
- RETURN(NULL);
+ RETURN(NULL);
- LASSERTF((new_mode == LCK_PW && lock->l_granted_mode == LCK_PR),
- "new_mode %u, granted %u\n", new_mode, lock->l_granted_mode);
+ LASSERTF((new_mode == LCK_PW && lock->l_granted_mode == LCK_PR),
+ "new_mode %u, granted %u\n", new_mode, lock->l_granted_mode);
- lock_res_and_lock(lock);
+ lock_res_and_lock(lock);
- res = lock->l_resource;
- ns = ldlm_res_to_ns(res);
+ res = lock->l_resource;
+ ns = ldlm_res_to_ns(res);
#ifdef HAVE_SERVER_SUPPORT
old_mode = lock->l_req_mode;
"remote: "LPX64" expref: %d pid: %u timeout: %lu "
"lvb_type: %d\n",
lock,
- lock->l_handle.h_cookie, cfs_atomic_read(&lock->l_refc),
+ lock->l_handle.h_cookie, atomic_read(&lock->l_refc),
lock->l_readers, lock->l_writers,
ldlm_lockname[lock->l_granted_mode],
ldlm_lockname[lock->l_req_mode],
lock->l_flags, nid, lock->l_remote_handle.cookie,
- exp ? cfs_atomic_read(&exp->exp_refcount) : -99,
+ exp ? atomic_read(&exp->exp_refcount) : -99,
lock->l_pid, lock->l_callback_timeout, lock->l_lvb_type);
va_end(args);
return;
"(req "LPU64"->"LPU64") flags: "LPX64" nid: %s remote: "
LPX64" expref: %d pid: %u timeout: %lu lvb_type: %d\n",
ldlm_lock_to_ns_name(lock), lock,
- lock->l_handle.h_cookie, cfs_atomic_read(&lock->l_refc),
+ lock->l_handle.h_cookie, atomic_read(&lock->l_refc),
lock->l_readers, lock->l_writers,
ldlm_lockname[lock->l_granted_mode],
ldlm_lockname[lock->l_req_mode],
PLDLMRES(resource),
- cfs_atomic_read(&resource->lr_refcount),
+ atomic_read(&resource->lr_refcount),
ldlm_typename[resource->lr_type],
lock->l_policy_data.l_extent.start,
lock->l_policy_data.l_extent.end,
lock->l_req_extent.start, lock->l_req_extent.end,
lock->l_flags, nid, lock->l_remote_handle.cookie,
- exp ? cfs_atomic_read(&exp->exp_refcount) : -99,
+ exp ? atomic_read(&exp->exp_refcount) : -99,
lock->l_pid, lock->l_callback_timeout,
lock->l_lvb_type);
break;
"["LPU64"->"LPU64"] flags: "LPX64" nid: %s "
"remote: "LPX64" expref: %d pid: %u timeout: %lu\n",
ldlm_lock_to_ns_name(lock), lock,
- lock->l_handle.h_cookie, cfs_atomic_read(&lock->l_refc),
+ lock->l_handle.h_cookie, atomic_read(&lock->l_refc),
lock->l_readers, lock->l_writers,
ldlm_lockname[lock->l_granted_mode],
ldlm_lockname[lock->l_req_mode],
PLDLMRES(resource),
- cfs_atomic_read(&resource->lr_refcount),
+ atomic_read(&resource->lr_refcount),
ldlm_typename[resource->lr_type],
lock->l_policy_data.l_flock.pid,
lock->l_policy_data.l_flock.start,
lock->l_policy_data.l_flock.end,
lock->l_flags, nid, lock->l_remote_handle.cookie,
- exp ? cfs_atomic_read(&exp->exp_refcount) : -99,
+ exp ? atomic_read(&exp->exp_refcount) : -99,
lock->l_pid, lock->l_callback_timeout);
break;
"pid: %u timeout: %lu lvb_type: %d\n",
ldlm_lock_to_ns_name(lock),
lock, lock->l_handle.h_cookie,
- cfs_atomic_read(&lock->l_refc),
+ atomic_read(&lock->l_refc),
lock->l_readers, lock->l_writers,
ldlm_lockname[lock->l_granted_mode],
ldlm_lockname[lock->l_req_mode],
PLDLMRES(resource),
lock->l_policy_data.l_inodebits.bits,
- cfs_atomic_read(&resource->lr_refcount),
+ atomic_read(&resource->lr_refcount),
ldlm_typename[resource->lr_type],
lock->l_flags, nid, lock->l_remote_handle.cookie,
- exp ? cfs_atomic_read(&exp->exp_refcount) : -99,
+ exp ? atomic_read(&exp->exp_refcount) : -99,
lock->l_pid, lock->l_callback_timeout,
lock->l_lvb_type);
break;
"timeout: %lu lvb_type: %d\n",
ldlm_lock_to_ns_name(lock),
lock, lock->l_handle.h_cookie,
- cfs_atomic_read(&lock->l_refc),
+ atomic_read(&lock->l_refc),
lock->l_readers, lock->l_writers,
ldlm_lockname[lock->l_granted_mode],
ldlm_lockname[lock->l_req_mode],
PLDLMRES(resource),
- cfs_atomic_read(&resource->lr_refcount),
+ atomic_read(&resource->lr_refcount),
ldlm_typename[resource->lr_type],
lock->l_flags, nid, lock->l_remote_handle.cookie,
- exp ? cfs_atomic_read(&exp->exp_refcount) : -99,
+ exp ? atomic_read(&exp->exp_refcount) : -99,
lock->l_pid, lock->l_callback_timeout,
lock->l_lvb_type);
break;
git://git.whamcloud.com / fs / lustre-release.git / blobdiff