/* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
* vim:expandtab:shiftwidth=8:tabstop=8:
*
- * Copyright (C) 2002-2004 Cluster File Systems, Inc.
- * Author: Peter Braam <braam@clusterfs.com>
- * Author: Phil Schwan <phil@clusterfs.com>
+ * GPL HEADER START
*
- * This file is part of the Lustre file system, http://www.lustre.org
- * Lustre is a trademark of Cluster File Systems, Inc.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
- * You may have signed or agreed to another license before downloading
- * this software. If so, you are bound by the terms and conditions
- * of that agreement, and the following does not apply to you. See the
- * LICENSE file included with this distribution for more information.
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 only,
+ * as published by the Free Software Foundation.
*
- * If you did not agree to a different license, then this copy of Lustre
- * is open source software; you can redistribute it and/or modify it
- * under the terms of version 2 of the GNU General Public License as
- * published by the Free Software Foundation.
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License version 2 for more details (a copy is included
+ * in the LICENSE file that accompanied this code).
*
- * In either case, Lustre is distributed in the hope that it will be
- * useful, but WITHOUT ANY WARRANTY; without even the implied warranty
- * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * license text for more details.
+ * You should have received a copy of the GNU General Public License
+ * version 2 along with this program; If not, see
+ * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
+ *
+ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ *
+ * GPL HEADER END
+ */
+/*
+ * Copyright 2008 Sun Microsystems, Inc. All rights reserved
+ * Use is subject to license terms.
+ */
+/*
+ * This file is part of Lustre, http://www.lustre.org/
+ * Lustre is a trademark of Sun Microsystems, Inc.
+ *
+ * lustre/ldlm/ldlm_lockd.c
+ *
+ * Author: Peter Braam <braam@clusterfs.com>
+ * Author: Phil Schwan <phil@clusterfs.com>
*/
#ifndef EXPORT_SYMTAB
return cfs_time_seconds((int)cfs_duration_sec(cfs_time_sub(timeout, 0)) + 1);
}
-/* timeout for initial callback (AST) reply */
-static inline unsigned int ldlm_get_rq_timeout(unsigned int ldlm_timeout,
- unsigned int obd_timeout)
+/* timeout for initial callback (AST) reply (bz10399) */
+static inline unsigned int ldlm_get_rq_timeout(void)
{
+ /* Non-AT value */
unsigned int timeout = min(ldlm_timeout, obd_timeout / 3);
return timeout < 1 ? 1 : timeout;
goto repeat;
}
- LDLM_ERROR(lock, "lock callback timer expired: evicting client "
- "%s@%s nid %s\n",
- lock->l_export->exp_client_uuid.uuid,
- lock->l_export->exp_connection->c_remote_uuid.uuid,
- libcfs_nid2str(lock->l_export->exp_connection->c_peer.nid));
+ LDLM_ERROR(lock, "lock callback timer expired after %lds: "
+ "evicting client at %s ",
+ cfs_time_current_sec()- lock->l_enqueued_time.tv_sec,
+ libcfs_nid2str(
+ lock->l_export->exp_connection->c_peer.nid));
last = lock;
*/
static int __ldlm_add_waiting_lock(struct ldlm_lock *lock)
{
+ int timeout;
cfs_time_t timeout_rounded;
if (!list_empty(&lock->l_pending_chain))
return 0;
- lock->l_callback_timeout =cfs_time_add(cfs_time_current(),
- cfs_time_seconds(obd_timeout)/2);
+ timeout = ldlm_get_enq_timeout(lock);
+
+ lock->l_callback_timeout = cfs_time_shift(timeout);
timeout_rounded = round_timeout(lock->l_callback_timeout);
- if (cfs_time_before(timeout_rounded, cfs_timer_deadline(&waiting_locks_timer)) ||
+ if (cfs_time_before(timeout_rounded,
+ cfs_timer_deadline(&waiting_locks_timer)) ||
!cfs_timer_is_armed(&waiting_locks_timer)) {
cfs_timer_arm(&waiting_locks_timer, timeout_rounded);
-
}
+ /* 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. */
list_add_tail(&lock->l_pending_chain, &waiting_locks_list); /* FIFO */
return 1;
}
if (obd_dump_on_timeout)
libcfs_debug_dumplog();
+#ifdef __KERNEL__
+ spin_lock_bh(&waiting_locks_spinlock);
+ list_add(&lock->l_pending_chain, &expired_lock_thread.elt_expired_locks);
+ cfs_waitq_signal(&expired_lock_thread.elt_waitq);
+ spin_unlock_bh(&waiting_locks_spinlock);
+#else
class_fail_export(lock->l_export);
+#endif
}
static int ldlm_handle_ast_error(struct ldlm_lock *lock,
return rc;
}
-static int ldlm_cb_interpret(struct ptlrpc_request *req, void *data, int rc)
+static int ldlm_cb_interpret(const struct lu_env *env,
+ struct ptlrpc_request *req, void *data, int rc)
{
struct ldlm_cb_set_arg *arg;
struct ldlm_lock *lock;
lock = req->rq_async_args.pointer_arg[1];
LASSERT(lock != NULL);
if (rc != 0) {
- /* If client canceled the lock but the cancel has not
+ /* If client canceled the lock but the cancel has not
* been recieved yet, we need to update lvbo to have the
* proper attributes cached. */
if (rc == -EINVAL && arg->type == LDLM_BL_CALLBACK)
- ldlm_res_lvbo_update(lock->l_resource, NULL,
+ ldlm_res_lvbo_update(lock->l_resource, NULL,
0, 1);
- rc = ldlm_handle_ast_error(lock, req, rc,
+ rc = ldlm_handle_ast_error(lock, req, rc,
arg->type == LDLM_BL_CALLBACK
? "blocking" : "completion");
- }
+ }
- LDLM_LOCK_PUT(lock);
+ LDLM_LOCK_RELEASE(lock);
if (rc == -ERESTART)
atomic_set(&arg->restart, 1);
} else {
LDLM_LOCK_GET(lock);
ptlrpc_set_add_req(arg->set, req);
- }
+ }
RETURN(rc);
}
}
req->rq_send_state = LUSTRE_IMP_FULL;
- req->rq_timeout = ldlm_get_rq_timeout(ldlm_timeout, obd_timeout);
+ /* ptlrpc_prep_req already set timeout */
+ if (AT_OFF)
+ req->rq_timeout = ldlm_get_rq_timeout();
- if (lock->l_export && lock->l_export->exp_ldlm_stats)
- lprocfs_counter_incr(lock->l_export->exp_ldlm_stats,
+ if (lock->l_export && lock->l_export->exp_nid_stats &&
+ lock->l_export->exp_nid_stats->nid_ldlm_stats)
+ lprocfs_counter_incr(lock->l_export->exp_nid_stats->nid_ldlm_stats,
LDLM_BL_CALLBACK - LDLM_FIRST_OPC);
rc = ldlm_bl_and_cp_ast_fini(req, arg, lock, instant_cancel);
total_enqueue_wait = cfs_timeval_sub(&granted_time,
&lock->l_enqueued_time, NULL);
- if (total_enqueue_wait / 1000000 > obd_timeout)
+ if (total_enqueue_wait / ONE_MILLION > obd_timeout)
+ /* non-fatal with AT - change to LDLM_DEBUG? */
LDLM_ERROR(lock, "enqueue wait took %luus from "CFS_TIME_T,
total_enqueue_wait, lock->l_enqueued_time.tv_sec);
- req = ptlrpc_request_alloc(lock->l_export->exp_imp_reverse,
+ req = ptlrpc_request_alloc(lock->l_export->exp_imp_reverse,
&RQF_LDLM_CP_CALLBACK);
- if (req == NULL)
- RETURN(-ENOMEM);
+ if (req == NULL)
+ RETURN(-ENOMEM);
lock_res_and_lock(lock);
if (lock->l_resource->lr_lvb_len)
LDLM_DEBUG(lock, "server preparing completion AST (after %ldus wait)",
total_enqueue_wait);
+ /* Server-side enqueue wait time estimate, used in
+ __ldlm_add_waiting_lock to set future enqueue timers */
+ at_add(&lock->l_resource->lr_namespace->ns_at_estimate,
+ total_enqueue_wait / ONE_MILLION);
+
ptlrpc_request_set_replen(req);
+
req->rq_send_state = LUSTRE_IMP_FULL;
- req->rq_timeout = ldlm_get_rq_timeout(ldlm_timeout, obd_timeout);
+ /* ptlrpc_prep_req already set timeout */
+ if (AT_OFF)
+ req->rq_timeout = ldlm_get_rq_timeout();
/* We only send real blocking ASTs after the lock is granted */
lock_res_and_lock(lock);
}
unlock_res_and_lock(lock);
- if (lock->l_export && lock->l_export->exp_ldlm_stats)
- lprocfs_counter_incr(lock->l_export->exp_ldlm_stats,
+ if (lock->l_export && lock->l_export->exp_nid_stats &&
+ lock->l_export->exp_nid_stats->nid_ldlm_stats)
+ lprocfs_counter_incr(lock->l_export->exp_nid_stats->nid_ldlm_stats,
LDLM_CP_CALLBACK - LDLM_FIRST_OPC);
rc = ldlm_bl_and_cp_ast_fini(req, arg, lock, instant_cancel);
req->rq_send_state = LUSTRE_IMP_FULL;
- req->rq_timeout = ldlm_get_rq_timeout(ldlm_timeout, obd_timeout);
+ /* ptlrpc_prep_req already set timeout */
+ if (AT_OFF)
+ req->rq_timeout = ldlm_get_rq_timeout();
- if (lock->l_export && lock->l_export->exp_ldlm_stats)
- lprocfs_counter_incr(lock->l_export->exp_ldlm_stats,
+ if (lock->l_export && lock->l_export->exp_nid_stats &&
+ lock->l_export->exp_nid_stats->nid_ldlm_stats)
+ lprocfs_counter_incr(lock->l_export->exp_nid_stats->nid_ldlm_stats,
LDLM_GL_CALLBACK - LDLM_FIRST_OPC);
rc = ptlrpc_queue_wait(req);
rc = ldlm_res_lvbo_update(res, req->rq_repmsg,
REPLY_REC_OFF, 1);
ptlrpc_req_finished(req);
- RETURN(rc);
-}
+ if (rc == -ERESTART)
+ ldlm_reprocess_all(res);
-static struct ldlm_lock *
-find_existing_lock(struct obd_export *exp,
- const struct lustre_handle *remote_hdl)
-{
- struct list_head *iter;
-
- spin_lock(&exp->exp_ldlm_data.led_lock);
- list_for_each(iter, &exp->exp_ldlm_data.led_held_locks) {
- struct ldlm_lock *lock;
- lock = list_entry(iter, struct ldlm_lock, l_export_chain);
- if (lock->l_remote_handle.cookie == remote_hdl->cookie) {
- LDLM_LOCK_GET(lock);
- spin_unlock(&exp->exp_ldlm_data.led_lock);
- return lock;
- }
- }
- spin_unlock(&exp->exp_ldlm_data.led_lock);
- return NULL;
+ RETURN(rc);
}
#ifdef __KERNEL__
ldlm_svc_get_eopc(dlm_req,
req->rq_rqbd->rqbd_service->srv_stats);
- if (req->rq_export->exp_ldlm_stats)
- lprocfs_counter_incr(req->rq_export->exp_ldlm_stats,
+ if (req->rq_export && req->rq_export->exp_nid_stats &&
+ req->rq_export->exp_nid_stats->nid_ldlm_stats)
+ lprocfs_counter_incr(req->rq_export->exp_nid_stats->nid_ldlm_stats,
LDLM_ENQUEUE - LDLM_FIRST_OPC);
if (unlikely(dlm_req->lock_desc.l_resource.lr_type < LDLM_MIN_TYPE ||
#endif
if (unlikely(flags & LDLM_FL_REPLAY)) {
- lock = find_existing_lock(req->rq_export,
- &dlm_req->lock_handle[0]);
+ /* Find an existing lock in the per-export lock hash */
+ lock = lustre_hash_lookup(req->rq_export->exp_lock_hash,
+ (void *)&dlm_req->lock_handle[0]);
if (lock != NULL) {
DEBUG_REQ(D_DLMTRACE, req, "found existing lock cookie "
LPX64, lock->l_handle.h_cookie);
lock = ldlm_lock_create(ns, &dlm_req->lock_desc.l_resource.lr_name,
dlm_req->lock_desc.l_resource.lr_type,
dlm_req->lock_desc.l_req_mode,
- cbs->lcs_blocking, cbs->lcs_completion,
- cbs->lcs_glimpse, NULL, 0);
+ cbs, NULL, 0);
if (!lock)
GOTO(out, rc = -ENOMEM);
GOTO(out, rc = -ENOTCONN);
}
lock->l_export = class_export_get(req->rq_export);
- spin_lock(&lock->l_export->exp_ldlm_data.led_lock);
- list_add(&lock->l_export_chain,
- &lock->l_export->exp_ldlm_data.led_held_locks);
- spin_unlock(&lock->l_export->exp_ldlm_data.led_lock);
+
+ if (lock->l_export->exp_lock_hash)
+ lustre_hash_add(lock->l_export->exp_lock_hash,
+ &lock->l_remote_handle,
+ &lock->l_exp_hash);
existing_lock:
EXIT;
out:
- req->rq_status = err;
- if (req->rq_reply_state == NULL) {
+ req->rq_status = rc ?: err; /* return either error - bug 11190 */
+ if (!req->rq_packed_final) {
err = lustre_pack_reply(req, 1, NULL, NULL);
if (rc == 0)
rc = err;
- req->rq_status = rc;
}
/* The LOCK_CHANGED code in ldlm_lock_enqueue depends on this
if (!err && dlm_req->lock_desc.l_resource.lr_type != LDLM_FLOCK)
ldlm_reprocess_all(lock->l_resource);
- LDLM_LOCK_PUT(lock);
+ LDLM_LOCK_RELEASE(lock);
}
LDLM_DEBUG_NOLOCK("server-side enqueue handler END (lock %p, rc %d)",
int rc;
ENTRY;
- if (req->rq_export && req->rq_export->exp_ldlm_stats)
- lprocfs_counter_incr(req->rq_export->exp_ldlm_stats,
+ if (req->rq_export && req->rq_export->exp_nid_stats &&
+ req->rq_export->exp_nid_stats->nid_ldlm_stats)
+ lprocfs_counter_incr(req->rq_export->exp_nid_stats->nid_ldlm_stats,
LDLM_CONVERT - LDLM_FIRST_OPC);
rc = req_capsule_server_pack(&req->rq_pill);
return rc;
}
-/* Cancel all the locks, which handles are packed into ldlm_request */
+/* Cancel all the locks whos handles are packed into ldlm_request */
int ldlm_request_cancel(struct ptlrpc_request *req,
const struct ldlm_request *dlm_req, int first)
{
if (res != pres) {
if (pres != NULL) {
ldlm_reprocess_all(pres);
+ LDLM_RESOURCE_DELREF(pres);
ldlm_resource_putref(pres);
}
if (res != NULL) {
ldlm_resource_getref(res);
+ LDLM_RESOURCE_ADDREF(res);
ldlm_res_lvbo_update(res, NULL, 0, 1);
}
pres = res;
}
if (pres != NULL) {
ldlm_reprocess_all(pres);
+ LDLM_RESOURCE_DELREF(pres);
ldlm_resource_putref(pres);
}
LDLM_DEBUG_NOLOCK("server-side cancel handler END");
RETURN(-EFAULT);
}
- if (req->rq_export && req->rq_export->exp_ldlm_stats)
- lprocfs_counter_incr(req->rq_export->exp_ldlm_stats,
+ if (req->rq_export && req->rq_export->exp_nid_stats &&
+ req->rq_export->exp_nid_stats->nid_ldlm_stats)
+ lprocfs_counter_incr(req->rq_export->exp_nid_stats->nid_ldlm_stats,
LDLM_CANCEL - LDLM_FIRST_OPC);
rc = req_capsule_server_pack(&req->rq_pill);
}
LDLM_DEBUG(lock, "client blocking callback handler END");
- LDLM_LOCK_PUT(lock);
+ LDLM_LOCK_RELEASE(lock);
EXIT;
}
if (OBD_FAIL_CHECK(OBD_FAIL_LDLM_CANCEL_BL_CB_RACE)) {
int to = cfs_time_seconds(1);
while (to > 0) {
- to = schedule_timeout(to);
+ cfs_schedule_timeout(CFS_TASK_INTERRUPTIBLE, to);
if (lock->l_granted_mode == lock->l_req_mode ||
lock->l_destroyed)
break;
/* bug 11300: the lock has already been granted */
unlock_res_and_lock(lock);
LDLM_DEBUG(lock, "Double grant race happened");
- LDLM_LOCK_PUT(lock);
+ LDLM_LOCK_RELEASE(lock);
EXIT;
return;
}
&lock->l_resource->lr_name,
sizeof(lock->l_resource->lr_name)) != 0) {
unlock_res_and_lock(lock);
- if (ldlm_lock_change_resource(ns, lock,
+ if (ldlm_lock_change_resource(ns, lock,
&dlm_req->lock_desc.l_resource.lr_name) != 0) {
LDLM_ERROR(lock, "Failed to allocate resource");
- LDLM_LOCK_PUT(lock);
+ LDLM_LOCK_RELEASE(lock);
EXIT;
return;
}
LDLM_DEBUG_NOLOCK("client completion callback handler END (lock %p)",
lock);
- LDLM_LOCK_PUT(lock);
+ LDLM_LOCK_RELEASE(lock);
EXIT;
}
return;
}
unlock_res_and_lock(lock);
- LDLM_LOCK_PUT(lock);
+ LDLM_LOCK_RELEASE(lock);
EXIT;
}
return 0;
req->rq_status = rc;
- if (req->rq_reply_state == NULL) {
+ if (!req->rq_packed_final) {
rc = lustre_pack_reply(req, 1, NULL, NULL);
if (rc)
return rc;
if (OBD_FAIL_CHECK(OBD_FAIL_OBD_LOG_CANCEL_NET))
RETURN(0);
rc = llog_origin_handle_cancel(req);
+ if (OBD_FAIL_CHECK(OBD_FAIL_OBD_LOG_CANCEL_REP))
+ RETURN(0);
ldlm_callback_reply(req, rc);
RETURN(0);
case OBD_QC_CALLBACK:
CERROR("ldlm_cli_cancel: %d\n", rc);
}
- lock = ldlm_handle2lock_ns(ns, &dlm_req->lock_handle[0]);
+ lock = ldlm_handle2lock_long(&dlm_req->lock_handle[0], 0);
if (!lock) {
CDEBUG(D_DLMTRACE, "callback on lock "LPX64" - lock "
"disappeared\n", dlm_req->lock_handle[0].cookie);
LPX64" - lock disappeared\n",
dlm_req->lock_handle[0].cookie);
unlock_res_and_lock(lock);
- LDLM_LOCK_PUT(lock);
+ LDLM_LOCK_RELEASE(lock);
ldlm_callback_reply(req, -EINVAL);
RETURN(0);
}
if (OBD_FAIL_CHECK(OBD_FAIL_OBD_LOG_CANCEL_NET))
RETURN(0);
rc = llog_origin_handle_cancel(req);
+ if (OBD_FAIL_CHECK(OBD_FAIL_OBD_LOG_CANCEL_REP))
+ RETURN(0);
ldlm_callback_reply(req, rc);
RETURN(0);
default:
RETURN(0);
}
-void ldlm_revoke_export_locks(struct obd_export *exp)
+void ldlm_revoke_lock_cb(void *obj, void *data)
{
- struct list_head *locklist = &exp->exp_ldlm_data.led_held_locks;
- struct list_head rpc_list;
- struct ldlm_lock *lock, *next;
+ struct list_head *rpc_list = data;
+ struct ldlm_lock *lock = obj;
- ENTRY;
- CFS_INIT_LIST_HEAD(&rpc_list);
+ lock_res_and_lock(lock);
- spin_lock(&exp->exp_ldlm_data.led_lock);
- list_for_each_entry_safe(lock, next, locklist, l_export_chain) {
- lock_res_and_lock(lock);
+ if (lock->l_req_mode != lock->l_granted_mode) {
+ unlock_res_and_lock(lock);
+ return;
+ }
- if (lock->l_req_mode != lock->l_granted_mode) {
- unlock_res_and_lock(lock);
- continue;
- }
+ LASSERT(lock->l_resource);
+ if (lock->l_resource->lr_type != LDLM_IBITS &&
+ lock->l_resource->lr_type != LDLM_PLAIN) {
+ unlock_res_and_lock(lock);
+ return;
+ }
- LASSERT(lock->l_resource);
- if (lock->l_resource->lr_type != LDLM_IBITS &&
- lock->l_resource->lr_type != LDLM_PLAIN) {
- unlock_res_and_lock(lock);
- continue;
- }
+ if (lock->l_flags & LDLM_FL_AST_SENT) {
+ unlock_res_and_lock(lock);
+ return;
+ }
- if (lock->l_flags & LDLM_FL_AST_SENT) {
- unlock_res_and_lock(lock);
- continue;
- }
+ LASSERT(lock->l_blocking_ast);
+ LASSERT(!lock->l_blocking_lock);
- LASSERT(lock->l_blocking_ast);
- LASSERT(!lock->l_blocking_lock);
+ lock->l_flags |= LDLM_FL_AST_SENT;
+ if (lock->l_export && lock->l_export->exp_lock_hash)
+ lustre_hash_del(lock->l_export->exp_lock_hash,
+ &lock->l_remote_handle, &lock->l_exp_hash);
+ list_add_tail(&lock->l_rk_ast, rpc_list);
+ LDLM_LOCK_GET(lock);
- lock->l_flags |= LDLM_FL_AST_SENT;
- list_move(&lock->l_export_chain, &rpc_list);
- LDLM_LOCK_GET(lock);
+ unlock_res_and_lock(lock);
+}
- unlock_res_and_lock(lock);
- }
- spin_unlock(&exp->exp_ldlm_data.led_lock);
+void ldlm_revoke_export_locks(struct obd_export *exp)
+{
+ struct list_head rpc_list;
+ ENTRY;
+ CFS_INIT_LIST_HEAD(&rpc_list);
+ lustre_hash_for_each_empty(exp->exp_lock_hash,
+ ldlm_revoke_lock_cb, &rpc_list);
ldlm_run_ast_work(&rpc_list, LDLM_WORK_REVOKE_AST);
EXIT;
#endif
static int ldlm_setup(void);
-static int ldlm_cleanup(int force);
+static int ldlm_cleanup(void);
int ldlm_get_ref(void)
{
RETURN(rc);
}
-void ldlm_put_ref(int force)
+void ldlm_put_ref(void)
{
ENTRY;
mutex_down(&ldlm_ref_sem);
if (ldlm_refcount == 1) {
- int rc = ldlm_cleanup(force);
+ int rc = ldlm_cleanup();
if (rc)
CERROR("ldlm_cleanup failed: %d\n", rc);
else
EXIT;
}
+/*
+ * Export handle<->lock hash operations.
+ */
+static unsigned
+ldlm_export_lock_hash(lustre_hash_t *lh, void *key, unsigned mask)
+{
+ return lh_u64_hash(((struct lustre_handle *)key)->cookie, mask);
+}
+
+static void *
+ldlm_export_lock_key(struct hlist_node *hnode)
+{
+ struct ldlm_lock *lock;
+ ENTRY;
+
+ lock = hlist_entry(hnode, struct ldlm_lock, l_exp_hash);
+ RETURN(&lock->l_remote_handle);
+}
+
+static int
+ldlm_export_lock_compare(void *key, struct hlist_node *hnode)
+{
+ ENTRY;
+ RETURN(lustre_handle_equal(ldlm_export_lock_key(hnode), key));
+}
+
+static void *
+ldlm_export_lock_get(struct hlist_node *hnode)
+{
+ struct ldlm_lock *lock;
+ ENTRY;
+
+ lock = hlist_entry(hnode, struct ldlm_lock, l_exp_hash);
+ LDLM_LOCK_GET(lock);
+
+ RETURN(lock);
+}
+
+static void *
+ldlm_export_lock_put(struct hlist_node *hnode)
+{
+ struct ldlm_lock *lock;
+ ENTRY;
+
+ lock = hlist_entry(hnode, struct ldlm_lock, l_exp_hash);
+ LDLM_LOCK_RELEASE(lock);
+
+ RETURN(lock);
+}
+
+static lustre_hash_ops_t ldlm_export_lock_ops = {
+ .lh_hash = ldlm_export_lock_hash,
+ .lh_key = ldlm_export_lock_key,
+ .lh_compare = ldlm_export_lock_compare,
+ .lh_get = ldlm_export_lock_get,
+ .lh_put = ldlm_export_lock_put
+};
+
+int ldlm_init_export(struct obd_export *exp)
+{
+ ENTRY;
+
+ exp->exp_lock_hash =
+ lustre_hash_init(obd_uuid2str(&exp->exp_client_uuid),
+ 128, 65536, &ldlm_export_lock_ops, LH_REHASH);
+
+ if (!exp->exp_lock_hash)
+ RETURN(-ENOMEM);
+
+ RETURN(0);
+}
+EXPORT_SYMBOL(ldlm_init_export);
+
+void ldlm_destroy_export(struct obd_export *exp)
+{
+ ENTRY;
+ lustre_hash_exit(exp->exp_lock_hash);
+ exp->exp_lock_hash = NULL;
+ EXIT;
+}
+EXPORT_SYMBOL(ldlm_destroy_export);
+
static int ldlm_setup(void)
{
struct ldlm_bl_pool *blp;
ldlm_state->ldlm_cb_service =
ptlrpc_init_svc(LDLM_NBUFS, LDLM_BUFSIZE, LDLM_MAXREQSIZE,
LDLM_MAXREPSIZE, LDLM_CB_REQUEST_PORTAL,
- LDLM_CB_REPLY_PORTAL, ldlm_timeout * 900,
+ LDLM_CB_REPLY_PORTAL, 1800,
ldlm_callback_handler, "ldlm_cbd",
ldlm_svc_proc_dir, NULL,
ldlm_min_threads, ldlm_max_threads,
ldlm_state->ldlm_cancel_service =
ptlrpc_init_svc(LDLM_NBUFS, LDLM_BUFSIZE, LDLM_MAXREQSIZE,
LDLM_MAXREPSIZE, LDLM_CANCEL_REQUEST_PORTAL,
- LDLM_CANCEL_REPLY_PORTAL, ldlm_timeout * 6000,
+ LDLM_CANCEL_REPLY_PORTAL, 6000,
ldlm_cancel_handler, "ldlm_canceld",
ldlm_svc_proc_dir, NULL,
ldlm_min_threads, ldlm_max_threads,
return rc;
}
-static int ldlm_cleanup(int force)
+static int ldlm_cleanup(void)
{
#ifdef __KERNEL__
struct ldlm_bl_pool *blp = ldlm_state->ldlm_bl_pool;
#endif
ENTRY;
- if (!list_empty(ldlm_namespace_list(LDLM_NAMESPACE_SERVER)) ||
+ 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);
EXPORT_SYMBOL(__ldlm_handle2lock);
EXPORT_SYMBOL(ldlm_lock_get);
EXPORT_SYMBOL(ldlm_lock_put);
+EXPORT_SYMBOL(ldlm_lock_fast_match);
+EXPORT_SYMBOL(ldlm_lock_fast_release);
EXPORT_SYMBOL(ldlm_lock_match);
EXPORT_SYMBOL(ldlm_lock_cancel);
EXPORT_SYMBOL(ldlm_lock_addref);
+EXPORT_SYMBOL(ldlm_lock_addref_try);
EXPORT_SYMBOL(ldlm_lock_decref);
EXPORT_SYMBOL(ldlm_lock_decref_and_cancel);
EXPORT_SYMBOL(ldlm_lock_change_resource);
EXPORT_SYMBOL(ldlm_lock_allow_match);
/* ldlm_request.c */
+EXPORT_SYMBOL(ldlm_completion_ast_async);
EXPORT_SYMBOL(ldlm_completion_ast);
EXPORT_SYMBOL(ldlm_blocking_ast);
EXPORT_SYMBOL(ldlm_glimpse_ast);
EXPORT_SYMBOL(ldlm_cli_cancel_unused);
EXPORT_SYMBOL(ldlm_cli_cancel_unused_resource);
EXPORT_SYMBOL(ldlm_cli_cancel_req);
-EXPORT_SYMBOL(ldlm_cli_join_lru);
EXPORT_SYMBOL(ldlm_replay_locks);
EXPORT_SYMBOL(ldlm_resource_foreach);
EXPORT_SYMBOL(ldlm_namespace_foreach);
/* l_lock.c */
EXPORT_SYMBOL(lock_res_and_lock);
EXPORT_SYMBOL(unlock_res_and_lock);
-