#define DEBUG_SUBSYSTEM S_LDLM
-#ifdef __KERNEL__
-# include <libcfs/libcfs.h>
-#else
-# include <liblustre.h>
-#endif
-
+#include <libcfs/libcfs.h>
#include <lustre_dlm.h>
#include <obd_class.h>
#include <libcfs/list.h>
* as a priority. It is used for LDLM_FL_DISCARD_DATA requests.
* see bug 13843
*/
- cfs_list_t blp_prio_list;
+ struct list_head blp_prio_list;
/*
* blp_list is used for all other callbacks which are likely
* to take longer to process.
*/
- cfs_list_t blp_list;
+ struct list_head blp_list;
wait_queue_head_t blp_waitq;
struct completion blp_comp;
};
struct ldlm_bl_work_item {
- cfs_list_t blwi_entry;
+ struct list_head blwi_entry;
struct ldlm_namespace *blwi_ns;
struct ldlm_lock_desc blwi_ld;
struct ldlm_lock *blwi_lock;
- cfs_list_t blwi_head;
+ struct list_head blwi_head;
int blwi_count;
struct completion blwi_comp;
ldlm_cancel_flags_t blwi_flags;
int blwi_mem_pressure;
};
-#if defined(HAVE_SERVER_SUPPORT) && defined(__KERNEL__)
+#ifdef HAVE_SERVER_SUPPORT
/**
* Protects both waiting_locks_list and expired_lock_thread.
*
* All access to it should be under waiting_locks_spinlock.
*/
-static cfs_list_t waiting_locks_list;
+static struct list_head waiting_locks_list;
static struct timer_list waiting_locks_timer;
static struct expired_lock_thread {
wait_queue_head_t elt_waitq;
int elt_state;
int elt_dump;
- cfs_list_t elt_expired_locks;
+ struct list_head elt_expired_locks;
} expired_lock_thread;
static inline int have_expired_locks(void)
ENTRY;
spin_lock_bh(&waiting_locks_spinlock);
- need_to_run = !cfs_list_empty(&expired_lock_thread.elt_expired_locks);
+ need_to_run = !list_empty(&expired_lock_thread.elt_expired_locks);
spin_unlock_bh(&waiting_locks_spinlock);
RETURN(need_to_run);
*/
static int expired_lock_main(void *arg)
{
- cfs_list_t *expired = &expired_lock_thread.elt_expired_locks;
+ struct list_head *expired = &expired_lock_thread.elt_expired_locks;
struct l_wait_info lwi = { 0 };
int do_dump;
do_dump = 0;
- while (!cfs_list_empty(expired)) {
+ while (!list_empty(expired)) {
struct obd_export *export;
struct ldlm_lock *lock;
- lock = cfs_list_entry(expired->next, struct ldlm_lock,
+ lock = list_entry(expired->next, struct ldlm_lock,
l_pending_chain);
if ((void *)lock < LP_POISON + PAGE_CACHE_SIZE &&
(void *)lock >= LP_POISON) {
CERROR("free lock on elt list %p\n", lock);
LBUG();
}
- cfs_list_del_init(&lock->l_pending_chain);
+ list_del_init(&lock->l_pending_chain);
if ((void *)lock->l_export <
LP_POISON + PAGE_CACHE_SIZE &&
(void *)lock->l_export >= LP_POISON) {
return 0;
spin_lock_bh(&lock->l_export->exp_rpc_lock);
- cfs_list_for_each_entry(req, &lock->l_export->exp_hp_rpcs,
+ list_for_each_entry(req, &lock->l_export->exp_hp_rpcs,
rq_exp_list) {
if (req->rq_ops->hpreq_lock_match) {
match = req->rq_ops->hpreq_lock_match(req, lock);
int need_dump = 0;
spin_lock_bh(&waiting_locks_spinlock);
- while (!cfs_list_empty(&waiting_locks_list)) {
- lock = cfs_list_entry(waiting_locks_list.next, struct ldlm_lock,
+ while (!list_empty(&waiting_locks_list)) {
+ lock = list_entry(waiting_locks_list.next, struct ldlm_lock,
l_pending_chain);
if (cfs_time_after(lock->l_callback_timeout,
cfs_time_current()) ||
/* no needs to take an extra ref on the lock since it was in
* the waiting_locks_list and ldlm_add_waiting_lock()
* already grabbed a ref */
- cfs_list_del(&lock->l_pending_chain);
- cfs_list_add(&lock->l_pending_chain,
+ list_del(&lock->l_pending_chain);
+ list_add(&lock->l_pending_chain,
&expired_lock_thread.elt_expired_locks);
need_dump = 1;
}
- if (!cfs_list_empty(&expired_lock_thread.elt_expired_locks)) {
+ if (!list_empty(&expired_lock_thread.elt_expired_locks)) {
if (obd_dump_on_timeout && need_dump)
expired_lock_thread.elt_dump = __LINE__;
* Make sure the timer will fire again if we have any locks
* left.
*/
- if (!cfs_list_empty(&waiting_locks_list)) {
+ if (!list_empty(&waiting_locks_list)) {
cfs_time_t timeout_rounded;
- lock = cfs_list_entry(waiting_locks_list.next, struct ldlm_lock,
+ lock = list_entry(waiting_locks_list.next, struct ldlm_lock,
l_pending_chain);
timeout_rounded = (cfs_time_t)round_timeout(lock->l_callback_timeout);
cfs_timer_arm(&waiting_locks_timer, timeout_rounded);
cfs_time_t timeout;
cfs_time_t timeout_rounded;
- if (!cfs_list_empty(&lock->l_pending_chain))
+ if (!list_empty(&lock->l_pending_chain))
return 0;
if (OBD_FAIL_CHECK(OBD_FAIL_PTLRPC_HPREQ_NOTIMEOUT) ||
/* if the new lock has a shorter timeout than something earlier on
the list, we'll wait the longer amount of time; no big deal. */
/* FIFO */
- cfs_list_add_tail(&lock->l_pending_chain, &waiting_locks_list);
+ list_add_tail(&lock->l_pending_chain, &waiting_locks_list);
return 1;
}
if (ret) {
spin_lock_bh(&lock->l_export->exp_bl_list_lock);
- if (cfs_list_empty(&lock->l_exp_list))
- cfs_list_add(&lock->l_exp_list,
+ if (list_empty(&lock->l_exp_list))
+ list_add(&lock->l_exp_list,
&lock->l_export->exp_bl_list);
spin_unlock_bh(&lock->l_export->exp_bl_list_lock);
}
*/
static int __ldlm_del_waiting_lock(struct ldlm_lock *lock)
{
- cfs_list_t *list_next;
+ struct list_head *list_next;
- if (cfs_list_empty(&lock->l_pending_chain))
+ if (list_empty(&lock->l_pending_chain))
return 0;
list_next = lock->l_pending_chain.next;
cfs_timer_disarm(&waiting_locks_timer);
} else {
struct ldlm_lock *next;
- next = cfs_list_entry(list_next, struct ldlm_lock,
+ next = list_entry(list_next, struct ldlm_lock,
l_pending_chain);
cfs_timer_arm(&waiting_locks_timer,
round_timeout(next->l_callback_timeout));
}
}
- cfs_list_del_init(&lock->l_pending_chain);
+ list_del_init(&lock->l_pending_chain);
return 1;
}
/* remove the lock out of export blocking list */
spin_lock_bh(&lock->l_export->exp_bl_list_lock);
- cfs_list_del_init(&lock->l_exp_list);
+ list_del_init(&lock->l_exp_list);
spin_unlock_bh(&lock->l_export->exp_bl_list_lock);
if (ret) {
spin_lock_bh(&waiting_locks_spinlock);
- if (cfs_list_empty(&lock->l_pending_chain)) {
+ if (list_empty(&lock->l_pending_chain)) {
spin_unlock_bh(&waiting_locks_spinlock);
LDLM_DEBUG(lock, "wasn't waiting");
return 0;
}
EXPORT_SYMBOL(ldlm_refresh_waiting_lock);
-#else /* !HAVE_SERVER_SUPPORT || !__KERNEL__ */
+#else /* HAVE_SERVER_SUPPORT */
int ldlm_del_waiting_lock(struct ldlm_lock *lock)
{
RETURN(0);
}
-# ifdef HAVE_SERVER_SUPPORT
-static int ldlm_add_waiting_lock(struct ldlm_lock *lock)
-{
- LASSERT(ldlm_is_res_locked(lock) && !ldlm_is_cancel_on_block(lock));
- RETURN(1);
-}
-
-# endif
-#endif /* HAVE_SERVER_SUPPORT && __KERNEL__ */
+#endif /* !HAVE_SERVER_SUPPORT */
#ifdef HAVE_SERVER_SUPPORT
if (obd_dump_on_timeout)
libcfs_debug_dumplog();
-#ifdef __KERNEL__
spin_lock_bh(&waiting_locks_spinlock);
if (__ldlm_del_waiting_lock(lock) == 0)
/* the lock was not in any list, grab an extra ref before adding
* the lock to the expired list */
LDLM_LOCK_GET(lock);
- cfs_list_add(&lock->l_pending_chain,
+ list_add(&lock->l_pending_chain,
&expired_lock_thread.elt_expired_locks);
wake_up(&expired_lock_thread.elt_waitq);
spin_unlock_bh(&waiting_locks_spinlock);
-#else
- class_fail_export(lock->l_export);
-#endif
}
/**
}
spin_lock_bh(&lock->l_export->exp_rpc_lock);
- cfs_list_for_each_entry(req, &lock->l_export->exp_hp_rpcs,
- rq_exp_list) {
+ list_for_each_entry(req, &lock->l_export->exp_hp_rpcs,
+ rq_exp_list) {
/* Do not process requests that were not yet added to there
* incoming queue or were already removed from there for
* processing. We evaluate ptlrpc_nrs_req_can_move() without
}
EXPORT_SYMBOL(ldlm_server_glimpse_ast);
-int ldlm_glimpse_locks(struct ldlm_resource *res, cfs_list_t *gl_work_list)
+int ldlm_glimpse_locks(struct ldlm_resource *res,
+ struct list_head *gl_work_list)
{
int rc;
ENTRY;
&lock->l_remote_handle,
&lock->l_exp_hash);
+ /* Inherit the enqueue flags before the operation, because we do not
+ * keep the res lock on return and next operations (BL AST) may proceed
+ * without them. */
+ lock->l_flags |= ldlm_flags_from_wire(dlm_req->lock_flags &
+ LDLM_FL_INHERIT_MASK);
existing_lock:
if (flags & LDLM_FL_HAS_INTENT) {
}
dlm_rep = req_capsule_server_get(&req->rq_pill, &RMF_DLM_REP);
- dlm_rep->lock_flags = ldlm_flags_to_wire(flags);
ldlm_lock2desc(lock, &dlm_rep->lock_desc);
ldlm_lock2handle(lock, &dlm_rep->lock_handle);
/* Now take into account flags to be inherited from original lock
request both in reply to client and in our own lock flags. */
- dlm_rep->lock_flags |= dlm_req->lock_flags & LDLM_FL_INHERIT_MASK;
- lock->l_flags |= ldlm_flags_from_wire(dlm_req->lock_flags &
- LDLM_FL_INHERIT_MASK);
+ dlm_rep->lock_flags = ldlm_flags_to_wire(flags);
+ lock->l_flags |= flags & LDLM_FL_INHERIT_MASK;
/* Don't move a pending lock onto the export if it has already been
* disconnected due to eviction (bug 5683) or server umount (bug 24324).
struct ldlm_request *dlm_req,
struct ldlm_lock *lock)
{
+ struct list_head ast_list;
int lvb_len;
- CFS_LIST_HEAD(ast_list);
int rc = 0;
ENTRY;
LDLM_DEBUG(lock, "client completion callback handler START");
+ INIT_LIST_HEAD(&ast_list);
if (OBD_FAIL_CHECK(OBD_FAIL_LDLM_CANCEL_BL_CB_RACE)) {
int to = cfs_time_seconds(1);
while (to > 0) {
return ptlrpc_reply(req);
}
-#ifdef __KERNEL__
static int __ldlm_bl_to_thread(struct ldlm_bl_work_item *blwi,
ldlm_cancel_flags_t cancel_flags)
{
if (blwi->blwi_lock &&
ldlm_is_discard_data(blwi->blwi_lock)) {
/* add LDLM_FL_DISCARD_DATA requests to the priority list */
- cfs_list_add_tail(&blwi->blwi_entry, &blp->blp_prio_list);
+ list_add_tail(&blwi->blwi_entry, &blp->blp_prio_list);
} else {
/* other blocking callbacks are added to the regular list */
- cfs_list_add_tail(&blwi->blwi_entry, &blp->blp_list);
+ list_add_tail(&blwi->blwi_entry, &blp->blp_list);
}
spin_unlock(&blp->blp_lock);
static inline void init_blwi(struct ldlm_bl_work_item *blwi,
struct ldlm_namespace *ns,
struct ldlm_lock_desc *ld,
- cfs_list_t *cancels, int count,
+ struct list_head *cancels, int count,
struct ldlm_lock *lock,
ldlm_cancel_flags_t cancel_flags)
{
init_completion(&blwi->blwi_comp);
- CFS_INIT_LIST_HEAD(&blwi->blwi_head);
+ INIT_LIST_HEAD(&blwi->blwi_head);
if (memory_pressure_get())
blwi->blwi_mem_pressure = 1;
if (ld != NULL)
blwi->blwi_ld = *ld;
if (count) {
- cfs_list_add(&blwi->blwi_head, cancels);
- cfs_list_del_init(cancels);
+ list_add(&blwi->blwi_head, cancels);
+ list_del_init(cancels);
blwi->blwi_count = count;
} else {
blwi->blwi_lock = lock;
static int ldlm_bl_to_thread(struct ldlm_namespace *ns,
struct ldlm_lock_desc *ld,
struct ldlm_lock *lock,
- cfs_list_t *cancels, int count,
+ struct list_head *cancels, int count,
ldlm_cancel_flags_t cancel_flags)
{
ENTRY;
}
}
-#endif
int ldlm_bl_to_thread_lock(struct ldlm_namespace *ns, struct ldlm_lock_desc *ld,
struct ldlm_lock *lock)
{
-#ifdef __KERNEL__
return ldlm_bl_to_thread(ns, ld, lock, NULL, 0, LCF_ASYNC);
-#else
- return -ENOSYS;
-#endif
}
int ldlm_bl_to_thread_list(struct ldlm_namespace *ns, struct ldlm_lock_desc *ld,
- cfs_list_t *cancels, int count,
+ struct list_head *cancels, int count,
ldlm_cancel_flags_t cancel_flags)
{
-#ifdef __KERNEL__
return ldlm_bl_to_thread(ns, ld, NULL, cancels, count, cancel_flags);
-#else
- return -ENOSYS;
-#endif
}
/* Setinfo coming from Server (eg MDT) to Client (eg MDC)! */
}
int ldlm_revoke_lock_cb(cfs_hash_t *hs, cfs_hash_bd_t *bd,
- cfs_hlist_node_t *hnode, void *data)
+ struct hlist_node *hnode, void *data)
{
- cfs_list_t *rpc_list = data;
+ struct list_head *rpc_list = data;
struct ldlm_lock *lock = cfs_hash_object(hs, hnode);
lock_res_and_lock(lock);
&lock->l_remote_handle, &lock->l_exp_hash);
}
- cfs_list_add_tail(&lock->l_rk_ast, rpc_list);
+ list_add_tail(&lock->l_rk_ast, rpc_list);
LDLM_LOCK_GET(lock);
unlock_res_and_lock(lock);
void ldlm_revoke_export_locks(struct obd_export *exp)
{
- cfs_list_t rpc_list;
+ struct list_head rpc_list;
ENTRY;
- CFS_INIT_LIST_HEAD(&rpc_list);
+ INIT_LIST_HEAD(&rpc_list);
cfs_hash_for_each_empty(exp->exp_lock_hash,
ldlm_revoke_lock_cb, &rpc_list);
ldlm_run_ast_work(exp->exp_obd->obd_namespace, &rpc_list,
EXPORT_SYMBOL(ldlm_revoke_export_locks);
#endif /* HAVE_SERVER_SUPPORT */
-#ifdef __KERNEL__
static struct ldlm_bl_work_item *ldlm_bl_get_work(struct ldlm_bl_pool *blp)
{
struct ldlm_bl_work_item *blwi = NULL;
spin_lock(&blp->blp_lock);
/* process a request from the blp_list at least every blp_num_threads */
- if (!cfs_list_empty(&blp->blp_list) &&
- (cfs_list_empty(&blp->blp_prio_list) || num_bl == 0))
- blwi = cfs_list_entry(blp->blp_list.next,
- struct ldlm_bl_work_item, blwi_entry);
+ if (!list_empty(&blp->blp_list) &&
+ (list_empty(&blp->blp_prio_list) || num_bl == 0))
+ blwi = list_entry(blp->blp_list.next,
+ struct ldlm_bl_work_item, blwi_entry);
else
- if (!cfs_list_empty(&blp->blp_prio_list))
- blwi = cfs_list_entry(blp->blp_prio_list.next,
- struct ldlm_bl_work_item,
- blwi_entry);
+ if (!list_empty(&blp->blp_prio_list))
+ blwi = list_entry(blp->blp_prio_list.next,
+ struct ldlm_bl_work_item,
+ blwi_entry);
if (blwi) {
if (++num_bl >= atomic_read(&blp->blp_num_threads))
num_bl = 0;
- cfs_list_del(&blwi->blwi_entry);
+ list_del(&blwi->blwi_entry);
}
spin_unlock(&blp->blp_lock);
RETURN(0);
}
-#endif
static int ldlm_setup(void);
static int ldlm_cleanup(void);
}
static void *
-ldlm_export_lock_key(cfs_hlist_node_t *hnode)
+ldlm_export_lock_key(struct hlist_node *hnode)
{
struct ldlm_lock *lock;
- lock = cfs_hlist_entry(hnode, struct ldlm_lock, l_exp_hash);
+ lock = hlist_entry(hnode, struct ldlm_lock, l_exp_hash);
return &lock->l_remote_handle;
}
static void
-ldlm_export_lock_keycpy(cfs_hlist_node_t *hnode, void *key)
+ldlm_export_lock_keycpy(struct hlist_node *hnode, void *key)
{
struct ldlm_lock *lock;
- lock = cfs_hlist_entry(hnode, struct ldlm_lock, l_exp_hash);
+ lock = hlist_entry(hnode, struct ldlm_lock, l_exp_hash);
lock->l_remote_handle = *(struct lustre_handle *)key;
}
static int
-ldlm_export_lock_keycmp(const void *key, cfs_hlist_node_t *hnode)
+ldlm_export_lock_keycmp(const void *key, struct hlist_node *hnode)
{
return lustre_handle_equal(ldlm_export_lock_key(hnode), key);
}
static void *
-ldlm_export_lock_object(cfs_hlist_node_t *hnode)
+ldlm_export_lock_object(struct hlist_node *hnode)
{
- return cfs_hlist_entry(hnode, struct ldlm_lock, l_exp_hash);
+ return hlist_entry(hnode, struct ldlm_lock, l_exp_hash);
}
static void
-ldlm_export_lock_get(cfs_hash_t *hs, cfs_hlist_node_t *hnode)
+ldlm_export_lock_get(cfs_hash_t *hs, struct hlist_node *hnode)
{
struct ldlm_lock *lock;
- lock = cfs_hlist_entry(hnode, struct ldlm_lock, l_exp_hash);
+ lock = hlist_entry(hnode, struct ldlm_lock, l_exp_hash);
LDLM_LOCK_GET(lock);
}
static void
-ldlm_export_lock_put(cfs_hash_t *hs, cfs_hlist_node_t *hnode)
+ldlm_export_lock_put(cfs_hash_t *hs, struct hlist_node *hnode)
{
struct ldlm_lock *lock;
- lock = cfs_hlist_entry(hnode, struct ldlm_lock, l_exp_hash);
+ lock = hlist_entry(hnode, struct ldlm_lock, l_exp_hash);
LDLM_LOCK_RELEASE(lock);
}
{
static struct ptlrpc_service_conf conf;
struct ldlm_bl_pool *blp = NULL;
-#ifdef __KERNEL__
-# ifdef HAVE_SERVER_SUPPORT
+#ifdef HAVE_SERVER_SUPPORT
struct task_struct *task;
-# endif
+#endif /* HAVE_SERVER_SUPPORT */
int i;
-#endif
int rc = 0;
ENTRY;
rc = ldlm_proc_setup();
if (rc != 0)
GOTO(out, rc);
-#endif
+#endif /* LPROCFS */
memset(&conf, 0, sizeof(conf));
conf = (typeof(conf)) {
ldlm_state->ldlm_cancel_service = NULL;
GOTO(out, rc);
}
-#endif
+#endif /* HAVE_SERVER_SUPPORT */
OBD_ALLOC(blp, sizeof(*blp));
if (blp == NULL)
ldlm_state->ldlm_bl_pool = blp;
spin_lock_init(&blp->blp_lock);
- CFS_INIT_LIST_HEAD(&blp->blp_list);
- CFS_INIT_LIST_HEAD(&blp->blp_prio_list);
+ INIT_LIST_HEAD(&blp->blp_list);
+ INIT_LIST_HEAD(&blp->blp_prio_list);
init_waitqueue_head(&blp->blp_waitq);
atomic_set(&blp->blp_num_threads, 0);
atomic_set(&blp->blp_busy_threads, 0);
-#ifdef __KERNEL__
if (ldlm_num_threads == 0) {
blp->blp_min_threads = LDLM_NTHRS_INIT;
blp->blp_max_threads = LDLM_NTHRS_MAX;
GOTO(out, rc);
}
-# ifdef HAVE_SERVER_SUPPORT
- CFS_INIT_LIST_HEAD(&expired_lock_thread.elt_expired_locks);
+#ifdef HAVE_SERVER_SUPPORT
+ INIT_LIST_HEAD(&expired_lock_thread.elt_expired_locks);
expired_lock_thread.elt_state = ELT_STOPPED;
init_waitqueue_head(&expired_lock_thread.elt_waitq);
- CFS_INIT_LIST_HEAD(&waiting_locks_list);
+ INIT_LIST_HEAD(&waiting_locks_list);
spin_lock_init(&waiting_locks_spinlock);
cfs_timer_init(&waiting_locks_timer, waiting_locks_callback, 0);
wait_event(expired_lock_thread.elt_waitq,
expired_lock_thread.elt_state == ELT_READY);
-# endif /* HAVE_SERVER_SUPPORT */
+#endif /* HAVE_SERVER_SUPPORT */
rc = ldlm_pools_init();
if (rc) {
CERROR("Failed to initialize LDLM pools: %d\n", rc);
GOTO(out, rc);
}
-#endif
RETURN(0);
out:
{
ENTRY;
- if (!cfs_list_empty(ldlm_namespace_list(LDLM_NAMESPACE_SERVER)) ||
- !cfs_list_empty(ldlm_namespace_list(LDLM_NAMESPACE_CLIENT))) {
+ if (!list_empty(ldlm_namespace_list(LDLM_NAMESPACE_SERVER)) ||
+ !list_empty(ldlm_namespace_list(LDLM_NAMESPACE_CLIENT))) {
CERROR("ldlm still has namespaces; clean these up first.\n");
ldlm_dump_all_namespaces(LDLM_NAMESPACE_SERVER, D_DLMTRACE);
ldlm_dump_all_namespaces(LDLM_NAMESPACE_CLIENT, D_DLMTRACE);
RETURN(-EBUSY);
}
-#ifdef __KERNEL__
ldlm_pools_fini();
if (ldlm_state->ldlm_bl_pool != NULL) {
init_completion(&blp->blp_comp);
spin_lock(&blp->blp_lock);
- cfs_list_add_tail(&blwi.blwi_entry, &blp->blp_list);
+ list_add_tail(&blwi.blwi_entry, &blp->blp_list);
wake_up(&blp->blp_waitq);
spin_unlock(&blp->blp_lock);
OBD_FREE(blp, sizeof(*blp));
}
-#endif /* __KERNEL__ */
if (ldlm_state->ldlm_cb_service != NULL)
ptlrpc_unregister_service(ldlm_state->ldlm_cb_service);
-# ifdef HAVE_SERVER_SUPPORT
+#ifdef HAVE_SERVER_SUPPORT
if (ldlm_state->ldlm_cancel_service != NULL)
ptlrpc_unregister_service(ldlm_state->ldlm_cancel_service);
-# endif
+#endif
-#ifdef __KERNEL__
ldlm_proc_cleanup();
-# ifdef HAVE_SERVER_SUPPORT
+#ifdef HAVE_SERVER_SUPPORT
if (expired_lock_thread.elt_state != ELT_STOPPED) {
expired_lock_thread.elt_state = ELT_TERMINATE;
wake_up(&expired_lock_thread.elt_waitq);
wait_event(expired_lock_thread.elt_waitq,
expired_lock_thread.elt_state == ELT_STOPPED);
}
-# endif
-#endif /* __KERNEL__ */
+#endif
OBD_FREE(ldlm_state, sizeof(*ldlm_state));
ldlm_state = NULL;
mutex_init(&ldlm_ref_mutex);
mutex_init(ldlm_namespace_lock(LDLM_NAMESPACE_SERVER));
mutex_init(ldlm_namespace_lock(LDLM_NAMESPACE_CLIENT));
+
+ INIT_LIST_HEAD(&ldlm_srv_namespace_list);
+ INIT_LIST_HEAD(&ldlm_cli_active_namespace_list);
+ INIT_LIST_HEAD(&ldlm_cli_inactive_namespace_list);
+
ldlm_resource_slab = kmem_cache_create("ldlm_resources",
sizeof(struct ldlm_resource), 0,
SLAB_HWCACHE_ALIGN, NULL);
if (ldlm_refcount)
CERROR("ldlm_refcount is %d in ldlm_exit!\n", ldlm_refcount);
kmem_cache_destroy(ldlm_resource_slab);
-#ifdef __KERNEL__
/* ldlm_lock_put() use RCU to call ldlm_lock_free, so need call
* synchronize_rcu() to wait a grace period elapsed, so that
* ldlm_lock_free() get a chance to be called. */
synchronize_rcu();
-#endif
kmem_cache_destroy(ldlm_lock_slab);
kmem_cache_destroy(ldlm_interval_slab);
}
git://git.whamcloud.com / fs / lustre-release.git / blobdiff