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.
-TBD
+2003-02-11 Phil Schwan <phil@clusterfs.com>
* version v0_5_20
* bug fixes
- Fix ldlm_lock_match on the MDS to avoid matching remote locks (592)
} \
} 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)
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));
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 */
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");
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);
}
/* 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();
}
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);
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;
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;
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))
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");
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);
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);
}
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;
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);
}
RETURN(-EINVAL);
}
- LDLM_DEBUG(lock, "client completion callback handler START");
+ LDLM_DEBUG0(lock, "client completion callback handler START");
l_lock(&ns->ns_lock);
* 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,
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);
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);
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);
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);
}
RETURN(rc);
}
- LDLM_DEBUG(lock, "client-side enqueue waking up: granted");
+ LDLM_DEBUG0(lock, "client-side enqueue waking up: granted");
RETURN(0);
}
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);
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);
* 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,
* (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);
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) {
LBUG();
GOTO(out_req, rc = -ENOMEM);
}
- LDLM_DEBUG(lock, "client-side enqueue, new resource");
+ LDLM_DEBUG0(lock, "client-side enqueue, new resource");
}
}
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)
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);
}
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);
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;
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;
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);
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);
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);
/* 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,
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);
}
}
if (flags & LDLM_FL_INTENT_ONLY) {
- LDLM_DEBUG(lock, "INTENT_ONLY, aborting lock");
+ LDLM_DEBUG0(lock, "INTENT_ONLY, aborting lock");
RETURN(ELDLM_LOCK_ABORTED);
}
git://git.whamcloud.com / fs / lustre-release.git / commitdiff