From 41f1b17a025b2b34e0a1018ab95763e7bc99034b Mon Sep 17 00:00:00 2001 From: pschwan Date: Tue, 11 Feb 2003 23:45:51 +0000 Subject: [PATCH] b=850 Call LDLM_DEBUG0 instead of LDLM_DEBUG when there are no arguments. This is a temporary workaround for gcc 3.2 that I really hate. --- lustre/ChangeLog | 2 +- lustre/include/linux/lustre_dlm.h | 3 +++ lustre/ldlm/ldlm_lock.c | 10 +++++----- lustre/ldlm/ldlm_lockd.c | 30 ++++++++++++++-------------- lustre/ldlm/ldlm_request.c | 41 ++++++++++++++++++++------------------- lustre/ldlm/ldlm_resource.c | 4 ++-- lustre/mdc/mdc_request.c | 2 +- lustre/mds/handler.c | 8 ++++---- 8 files changed, 52 insertions(+), 48 deletions(-) diff --git a/lustre/ChangeLog b/lustre/ChangeLog index 120deef..3c13843 100644 --- a/lustre/ChangeLog +++ b/lustre/ChangeLog @@ -1,4 +1,4 @@ -TBD +2003-02-11 Phil Schwan * version v0_5_20 * bug fixes - Fix ldlm_lock_match on the MDS to avoid matching remote locks (592) diff --git a/lustre/include/linux/lustre_dlm.h b/lustre/include/linux/lustre_dlm.h index 8c05041..9fad75f 100644 --- a/lustre/include/linux/lustre_dlm.h +++ b/lustre/include/linux/lustre_dlm.h @@ -295,6 +295,9 @@ do { \ } \ } while (0) +/* I hate hate hate hate hate this. This cannot stay. bug 850. -phil */ +#define LDLM_DEBUG0(lock, format) __LDLM_DEBUG(D_DLMTRACE, lock, format"%s","") + #define LDLM_DEBUG(lock, format, a...) __LDLM_DEBUG(D_DLMTRACE, lock, format, a) #define LDLM_ERROR(lock, format, a...) __LDLM_DEBUG(D_ERROR, lock, format, a) diff --git a/lustre/ldlm/ldlm_lock.c b/lustre/ldlm/ldlm_lock.c index b1ba4ef..e08ddb4 100644 --- a/lustre/ldlm/ldlm_lock.c +++ b/lustre/ldlm/ldlm_lock.c @@ -136,7 +136,7 @@ void ldlm_lock_put(struct ldlm_lock *lock) if (atomic_dec_and_test(&lock->l_refc)) { l_lock(&ns->ns_lock); - LDLM_DEBUG(lock, "final lock_put on destroyed lock, freeing"); + LDLM_DEBUG0(lock, "final lock_put on destroyed lock, freeing"); LASSERT(lock->l_destroyed); LASSERT(list_empty(&lock->l_res_link)); @@ -479,7 +479,7 @@ void ldlm_lock_decref_internal(struct ldlm_lock *lock, __u32 mode) CERROR("FL_CBPENDING set on non-local lock--just a " "warning\n"); - LDLM_DEBUG(lock, "final decref done on cbpending lock"); + LDLM_DEBUG0(lock, "final decref done on cbpending lock"); l_unlock(&ns->ns_lock); /* FIXME: need a real 'desc' here */ @@ -710,7 +710,7 @@ int ldlm_lock_match(struct ldlm_namespace *ns, int flags, lock->l_completion_ast(lock, LDLM_FL_WAIT_NOREPROC, NULL); } if (rc) - LDLM_DEBUG(lock, "matched"); + LDLM_DEBUG0(lock, "matched"); else LDLM_DEBUG_NOLOCK("not matched"); @@ -974,7 +974,7 @@ void ldlm_cancel_callback(struct ldlm_lock *lock) lock->l_blocking_ast(lock, NULL, lock->l_data, LDLM_CB_CANCELING); else - LDLM_DEBUG(lock, "no blocking ast"); + LDLM_DEBUG0(lock, "no blocking ast"); } l_unlock(&lock->l_resource->lr_namespace->ns_lock); } @@ -994,7 +994,7 @@ void ldlm_lock_cancel(struct ldlm_lock *lock) /* Please do not, no matter how tempting, remove this LBUG without * talking to me first. -phik */ if (lock->l_readers || lock->l_writers) { - LDLM_DEBUG(lock, "lock still has references"); + LDLM_DEBUG0(lock, "lock still has references"); ldlm_lock_dump(D_OTHER, lock); LBUG(); } diff --git a/lustre/ldlm/ldlm_lockd.c b/lustre/ldlm/ldlm_lockd.c index 803e59d..61bb91e 100644 --- a/lustre/ldlm/ldlm_lockd.c +++ b/lustre/ldlm/ldlm_lockd.c @@ -170,7 +170,7 @@ int ldlm_server_blocking_ast(struct ldlm_lock *lock, sizeof(body->lock_handle1)); memcpy(&body->lock_desc, desc, sizeof(*desc)); - LDLM_DEBUG(lock, "server preparing blocking AST"); + LDLM_DEBUG0(lock, "server preparing blocking AST"); req->rq_replen = lustre_msg_size(0, NULL); ldlm_add_waiting_lock(lock); @@ -220,7 +220,7 @@ int ldlm_server_completion_ast(struct ldlm_lock *lock, int flags, void *data) body->lock_flags = flags; ldlm_lock2desc(lock, &body->lock_desc); - LDLM_DEBUG(lock, "server preparing completion AST"); + LDLM_DEBUG0(lock, "server preparing completion AST"); req->rq_replen = lustre_msg_size(0, NULL); req->rq_level = LUSTRE_CONN_RECOVD; @@ -291,7 +291,7 @@ int ldlm_handle_enqueue(struct ptlrpc_request *req, memcpy(&lock->l_remote_handle, &dlm_req->lock_handle1, sizeof(lock->l_remote_handle)); - LDLM_DEBUG(lock, "server-side enqueue handler, new lock created"); + LDLM_DEBUG0(lock, "server-side enqueue handler, new lock created"); LASSERT(req->rq_export); lock->l_export = req->rq_export; @@ -358,7 +358,7 @@ int ldlm_handle_convert(struct ptlrpc_request *req) if (!lock) { req->rq_status = EINVAL; } else { - LDLM_DEBUG(lock, "server-side convert handler START"); + LDLM_DEBUG0(lock, "server-side convert handler START"); ldlm_lock_convert(lock, dlm_req->lock_desc.l_req_mode, &dlm_rep->lock_flags); if (ldlm_del_waiting_lock(lock)) @@ -368,7 +368,7 @@ int ldlm_handle_convert(struct ptlrpc_request *req) if (lock) { ldlm_reprocess_all(lock->l_resource); - LDLM_DEBUG(lock, "server-side convert handler END"); + LDLM_DEBUG0(lock, "server-side convert handler END"); LDLM_LOCK_PUT(lock); } else LDLM_DEBUG_NOLOCK("server-side convert handler END"); @@ -403,7 +403,7 @@ int ldlm_handle_cancel(struct ptlrpc_request *req) dlm_req->lock_handle1.cookie); req->rq_status = ESTALE; } else { - LDLM_DEBUG(lock, "server-side cancel handler START"); + LDLM_DEBUG0(lock, "server-side cancel handler START"); ldlm_lock_cancel(lock); if (ldlm_del_waiting_lock(lock)) CDEBUG(D_DLMTRACE, "cancelled waiting lock %p\n", lock); @@ -415,7 +415,7 @@ int ldlm_handle_cancel(struct ptlrpc_request *req) if (lock) { ldlm_reprocess_all(lock->l_resource); - LDLM_DEBUG(lock, "server-side cancel handler END"); + LDLM_DEBUG0(lock, "server-side cancel handler END"); LDLM_LOCK_PUT(lock); } @@ -444,7 +444,7 @@ static int ldlm_handle_bl_callback(struct ptlrpc_request *req, RETURN(-EINVAL); } - LDLM_DEBUG(lock, "client blocking AST callback handler START"); + LDLM_DEBUG0(lock, "client blocking AST callback handler START"); l_lock(&lock->l_resource->lr_namespace->ns_lock); lock->l_flags |= LDLM_FL_CBPENDING; @@ -459,10 +459,10 @@ static int ldlm_handle_bl_callback(struct ptlrpc_request *req, lock->l_data, LDLM_CB_BLOCKING); } } else - LDLM_DEBUG(lock, "Lock still has references, will be" - " cancelled later"); + LDLM_DEBUG0(lock, "Lock still has references, will be" + " cancelled later"); - LDLM_DEBUG(lock, "client blocking callback handler END"); + LDLM_DEBUG0(lock, "client blocking callback handler END"); LDLM_LOCK_PUT(lock); RETURN(0); } @@ -486,7 +486,7 @@ static int ldlm_handle_cp_callback(struct ptlrpc_request *req, RETURN(-EINVAL); } - LDLM_DEBUG(lock, "client completion callback handler START"); + LDLM_DEBUG0(lock, "client completion callback handler START"); l_lock(&ns->ns_lock); @@ -494,7 +494,7 @@ static int ldlm_handle_cp_callback(struct ptlrpc_request *req, * then we might need to switch lock modes, resources, or extents. */ if (dlm_req->lock_desc.l_granted_mode != lock->l_req_mode) { lock->l_req_mode = dlm_req->lock_desc.l_granted_mode; - LDLM_DEBUG(lock, "completion AST, new lock mode"); + LDLM_DEBUG0(lock, "completion AST, new lock mode"); } if (lock->l_resource->lr_type == LDLM_EXTENT) memcpy(&lock->l_extent, &dlm_req->lock_desc.l_extent, @@ -505,13 +505,13 @@ static int ldlm_handle_cp_callback(struct ptlrpc_request *req, sizeof(lock->l_resource->lr_name)) != 0) { ldlm_lock_change_resource(ns, lock, dlm_req->lock_desc.l_resource.lr_name); - LDLM_DEBUG(lock, "completion AST, new resource"); + LDLM_DEBUG0(lock, "completion AST, new resource"); } lock->l_resource->lr_tmp = &ast_list; ldlm_grant_lock(lock, req, sizeof(*req)); lock->l_resource->lr_tmp = NULL; l_unlock(&ns->ns_lock); - LDLM_DEBUG(lock, "callback handler finished, about to run_ast_work"); + LDLM_DEBUG0(lock, "callback handler finished, about to run_ast_work"); LDLM_LOCK_PUT(lock); ldlm_run_ast_work(&ast_list); diff --git a/lustre/ldlm/ldlm_request.c b/lustre/ldlm/ldlm_request.c index 44122f5..a4d91e9 100644 --- a/lustre/ldlm/ldlm_request.c +++ b/lustre/ldlm/ldlm_request.c @@ -45,7 +45,7 @@ int ldlm_expired_completion_wait(void *data) else if (!(conn = obd->u.cli.cl_import.imp_connection)) CERROR("lock %p has NULL connection\n", lock); else { - LDLM_DEBUG(lock, "timed out waiting for completion"); + LDLM_DEBUG0(lock, "timed out waiting for completion"); CERROR("lock %p timed out from %s\n", lock, conn->c_remote_uuid.uuid); ldlm_lock_dump(D_ERROR, lock); @@ -74,8 +74,8 @@ int ldlm_completion_ast(struct ldlm_lock *lock, int flags, void *data) LDLM_FL_BLOCK_CONV))) RETURN(0); - LDLM_DEBUG(lock, "client-side enqueue returned a blocked lock, " - "sleeping"); + LDLM_DEBUG0(lock, "client-side enqueue returned a blocked lock, " + "sleeping"); ldlm_lock_dump(D_OTHER, lock); ldlm_reprocess_all(lock->l_resource); @@ -86,7 +86,7 @@ int ldlm_completion_ast(struct ldlm_lock *lock, int flags, void *data) lock->l_destroyed), &lwi); if (lock->l_destroyed) { - LDLM_DEBUG(lock, "client-side enqueue waking up: destroyed"); + LDLM_DEBUG0(lock, "client-side enqueue waking up: destroyed"); RETURN(-EIO); } @@ -96,7 +96,7 @@ int ldlm_completion_ast(struct ldlm_lock *lock, int flags, void *data) RETURN(rc); } - LDLM_DEBUG(lock, "client-side enqueue waking up: granted"); + LDLM_DEBUG0(lock, "client-side enqueue waking up: granted"); RETURN(0); } @@ -126,7 +126,8 @@ static int ldlm_cli_enqueue_local(struct ldlm_namespace *ns, data, cp_data); if (!lock) GOTO(out_nolock, err = -ENOMEM); - LDLM_DEBUG(lock, "client-side local enqueue handler, new lock created"); + LDLM_DEBUG0(lock, + "client-side local enqueue handler, new lock created"); ldlm_lock_addref_internal(lock, mode); ldlm_lock2handle(lock, lockh); @@ -148,7 +149,7 @@ static int ldlm_cli_enqueue_local(struct ldlm_namespace *ns, if (lock->l_completion_ast) lock->l_completion_ast(lock, *flags, NULL); - LDLM_DEBUG(lock, "client-side local enqueue END"); + LDLM_DEBUG0(lock, "client-side local enqueue END"); EXIT; out: LDLM_LOCK_PUT(lock); @@ -192,7 +193,7 @@ int ldlm_cli_enqueue(struct lustre_handle *connh, * If we're creating a new lock, get everything all setup nice. */ if (is_replay) { lock = ldlm_handle2lock(lockh); - LDLM_DEBUG(lock, "client-side enqueue START"); + LDLM_DEBUG0(lock, "client-side enqueue START"); LASSERT(connh == lock->l_connh); } else { lock = ldlm_lock_create(ns, parent_lock_handle, res_id, type, @@ -204,7 +205,7 @@ int ldlm_cli_enqueue(struct lustre_handle *connh, * (in just this one case) to run the completion_cb even if it * arrives before the reply. */ lock->l_completion_ast = completion; - LDLM_DEBUG(lock, "client-side enqueue START"); + LDLM_DEBUG0(lock, "client-side enqueue START"); /* for the local lock, add the reference */ ldlm_lock_addref_internal(lock, mode); ldlm_lock2handle(lock, lockh); @@ -240,7 +241,7 @@ int ldlm_cli_enqueue(struct lustre_handle *connh, lock->l_connh = connh; lock->l_export = NULL; - LDLM_DEBUG(lock, "sending request"); + LDLM_DEBUG0(lock, "sending request"); rc = ptlrpc_queue_wait(req); if (rc != ELDLM_OK) { @@ -299,7 +300,7 @@ int ldlm_cli_enqueue(struct lustre_handle *connh, LBUG(); GOTO(out_req, rc = -ENOMEM); } - LDLM_DEBUG(lock, "client-side enqueue, new resource"); + LDLM_DEBUG0(lock, "client-side enqueue, new resource"); } } @@ -313,7 +314,7 @@ int ldlm_cli_enqueue(struct lustre_handle *connh, lock->l_completion_ast(lock, *flags, NULL); } - LDLM_DEBUG(lock, "client-side enqueue END"); + LDLM_DEBUG0(lock, "client-side enqueue END"); EXIT; out_req: if (!req_passed_in) @@ -381,12 +382,12 @@ static int ldlm_cli_convert_local(struct ldlm_lock *lock, int new_mode, CERROR("Trying to cancel local lock\n"); LBUG(); } - LDLM_DEBUG(lock, "client-side local convert"); + LDLM_DEBUG0(lock, "client-side local convert"); ldlm_lock_convert(lock, new_mode, flags); ldlm_reprocess_all(lock->l_resource); - LDLM_DEBUG(lock, "client-side local convert handler END"); + LDLM_DEBUG0(lock, "client-side local convert handler END"); LDLM_LOCK_PUT(lock); RETURN(0); } @@ -415,7 +416,7 @@ int ldlm_cli_convert(struct lustre_handle *lockh, int new_mode, int *flags) if (!connh) RETURN(ldlm_cli_convert_local(lock, new_mode, flags)); - LDLM_DEBUG(lock, "client-side convert"); + LDLM_DEBUG0(lock, "client-side convert"); req = ptlrpc_prep_req(class_conn2cliimp(connh), LDLM_CONVERT, 1, &size, NULL); @@ -467,7 +468,7 @@ int ldlm_cli_cancel(struct lustre_handle *lockh) if (lock->l_connh) { int local_only; - LDLM_DEBUG(lock, "client-side cancel"); + LDLM_DEBUG0(lock, "client-side cancel"); /* Set this flag to prevent others from getting new references*/ l_lock(&lock->l_resource->lr_namespace->ns_lock); lock->l_flags |= LDLM_FL_CBPENDING; @@ -508,14 +509,14 @@ int ldlm_cli_cancel(struct lustre_handle *lockh) local_cancel: ldlm_lock_cancel(lock); } else { - LDLM_DEBUG(lock, "client-side local cancel"); + LDLM_DEBUG0(lock, "client-side local cancel"); if (lock->l_resource->lr_namespace->ns_client) { CERROR("Trying to cancel local lock\n"); LBUG(); } ldlm_lock_cancel(lock); ldlm_reprocess_all(lock->l_resource); - LDLM_DEBUG(lock, "client-side local cancel handler END"); + LDLM_DEBUG0(lock, "client-side local cancel handler END"); } EXIT; @@ -830,7 +831,7 @@ static int replay_one_lock(struct obd_import *imp, struct ldlm_lock *lock) size = sizeof(*reply); req->rq_replen = lustre_msg_size(1, &size); - LDLM_DEBUG(lock, "replaying lock:"); + LDLM_DEBUG0(lock, "replaying lock:"); rc = ptlrpc_queue_wait(req); if (rc != ELDLM_OK) GOTO(out, rc); @@ -838,7 +839,7 @@ static int replay_one_lock(struct obd_import *imp, struct ldlm_lock *lock) reply = lustre_msg_buf(req->rq_repmsg, 0); memcpy(&lock->l_remote_handle, &reply->lock_handle, sizeof(lock->l_remote_handle)); - LDLM_DEBUG(lock, "replayed lock:"); + LDLM_DEBUG0(lock, "replayed lock:"); out: ptlrpc_req_finished(req); RETURN(rc); diff --git a/lustre/ldlm/ldlm_resource.c b/lustre/ldlm/ldlm_resource.c index 9e757a6..f927307 100644 --- a/lustre/ldlm/ldlm_resource.c +++ b/lustre/ldlm/ldlm_resource.c @@ -193,8 +193,8 @@ static void cleanup_resource(struct ldlm_resource *res, struct list_head *q, if (local_only || rc != ELDLM_OK) ldlm_lock_cancel(lock); } else { - LDLM_DEBUG(lock, "Freeing a lock still held by a " - "client node"); + LDLM_DEBUG0(lock, "Freeing a lock still held by a " + "client node"); ldlm_resource_unlink_lock(lock); ldlm_lock_destroy(lock); diff --git a/lustre/mdc/mdc_request.c b/lustre/mdc/mdc_request.c index 101e63d..43bf5e8 100644 --- a/lustre/mdc/mdc_request.c +++ b/lustre/mdc/mdc_request.c @@ -417,7 +417,7 @@ int mdc_enqueue(struct lustre_handle *conn, int lock_type, /* The server almost certainly gave us a lock other than the * one that we asked for. If we already have a matching lock, * then cancel this one--we don't need two. */ - LDLM_DEBUG(lock, "matching against this"); + LDLM_DEBUG0(lock, "matching against this"); memcpy(&lockh2, lockh, sizeof(lockh2)); if (ldlm_lock_match(NULL, LDLM_FL_BLOCK_GRANTED, NULL, diff --git a/lustre/mds/handler.c b/lustre/mds/handler.c index e700a7a..2be4362 100644 --- a/lustre/mds/handler.c +++ b/lustre/mds/handler.c @@ -481,14 +481,14 @@ int mds_blocking_ast(struct ldlm_lock *lock, struct ldlm_lock_desc *desc, struct lustre_handle lockh; int rc; - LDLM_DEBUG(lock, "already unused, calling ldlm_cli_cancel"); + LDLM_DEBUG0(lock, "already unused, calling ldlm_cli_cancel"); ldlm_lock2handle(lock, &lockh); rc = ldlm_cli_cancel(&lockh); if (rc < 0) CERROR("ldlm_cli_cancel: %d\n", rc); } else { - LDLM_DEBUG(lock, "Lock still has references, will be " - "cancelled later"); + LDLM_DEBUG0(lock, "Lock still has references, will be " + "cancelled later"); } RETURN(0); } @@ -1691,7 +1691,7 @@ static int ldlm_intent_policy(struct ldlm_namespace *ns, } if (flags & LDLM_FL_INTENT_ONLY) { - LDLM_DEBUG(lock, "INTENT_ONLY, aborting lock"); + LDLM_DEBUG0(lock, "INTENT_ONLY, aborting lock"); RETURN(ELDLM_LOCK_ABORTED); } -- 1.8.3.1