#define LDLM_FL_BLOCK_WAIT (1 << 3)
#define LDLM_FL_CBPENDING (1 << 4)
#define LDLM_FL_AST_SENT (1 << 5)
-#define LDLM_FL_DESTROYED (1 << 6)
+#define LDLM_FL_DESTROYED (1 << 6)
#define L2B(c) (1 << c)
/* ldlm_lock.c */
struct ldlm_lock *ldlm_handle2lock(struct lustre_handle *handle);
+void ldlm_lock2handle(struct ldlm_lock *lock, struct lustre_handle *lockh);
void ldlm_lock_put(struct ldlm_lock *lock);
void ldlm_lock_free(struct ldlm_lock *lock);
void ldlm_lock2desc(struct ldlm_lock *lock, struct ldlm_lock_desc *desc);
void ldlm_lock_addref(struct ldlm_lock *lock, __u32 mode);
void ldlm_lock_decref(struct ldlm_lock *lock, __u32 mode);
void ldlm_grant_lock(struct ldlm_lock *lock);
-int ldlm_match(struct ldlm_namespace *ns, __u64 *res_id, __u32 type,
- void *cookie, int cookielen, ldlm_mode_t mode,
- struct lustre_handle *lockh);
+int ldlm_lock_match(struct ldlm_namespace *ns, __u64 *res_id, __u32 type,
+ void *cookie, int cookielen, ldlm_mode_t mode,
+ struct lustre_handle *lockh);
struct ldlm_lock *
ldlm_lock_create(struct ldlm_namespace *ns,
struct lustre_handle *parent_lock_handle,
void *data,
__u32 data_len,
struct lustre_handle *lockh);
-int ldlm_cli_callback(struct ldlm_lock *lock, struct ldlm_lock *new,
+int ldlm_cli_callback(struct ldlm_lock *lock, struct ldlm_lock_desc *new,
void *data, __u32 data_len, struct ptlrpc_request **reqp);
int ldlm_cli_convert(struct ptlrpc_client *, struct lustre_handle *,
int new_mode, int *flags);
-int ldlm_cli_cancel(struct ptlrpc_client *, struct ldlm_lock *);
+int ldlm_cli_cancel(struct ptlrpc_client *, struct lustre_handle *);
#endif /* __KERNEL__ */
}
}
- lock = ldlm_local_lock_create(obddev->obd_namespace,
- &dlm_req->lock_handle2,
- dlm_req->lock_desc.l_resource.lr_name,
- dlm_req->lock_desc.l_resource.lr_type,
- dlm_req->lock_desc.l_req_mode,
- NULL, 0);
+ lock = ldlm_lock_create(obddev->obd_namespace,
+ &dlm_req->lock_handle2,
+ dlm_req->lock_desc.l_resource.lr_name,
+ dlm_req->lock_desc.l_resource.lr_type,
+ dlm_req->lock_desc.l_req_mode, NULL, 0);
if (!lock)
GOTO(out, -ENOMEM);
flags = dlm_req->lock_flags;
err = ldlm_lock_enqueue(lock, cookie, cookielen, &flags,
- ldlm_cli_callback, ldlm_cli_callback);
+ ldlm_cli_callback, ldlm_cli_callback);
if (err != ELDLM_OK)
GOTO(out, err);
req->rq_status = EINVAL;
} else {
LDLM_DEBUG(lock, "server-side convert handler START");
- ldlm_lock_convert(&dlm_req->lock_handle1,
- dlm_req->lock_desc.l_req_mode,
+ ldlm_lock_convert(lock, dlm_req->lock_desc.l_req_mode,
&dlm_rep->lock_flags);
req->rq_status = 0;
}
req->rq_status = ESTALE;
} else {
LDLM_DEBUG(lock, "server-side cancel handler START");
- ldlm_local_lock_cancel(lock);
+ ldlm_lock_cancel(lock);
req->rq_status = 0;
}
}
LDLM_DEBUG_NOLOCK("client %s callback handler END (lock: %p)",
- new == NULL ? "completion" : "blocked", lock);
+ is_blocking_ast ? "blocked" : "completion", lock);
RETURN(0);
}
CERROR("couldn't free ldlm lock slab\n");
}
-EXPORT_SYMBOL(ldlm_local_lock_match);
+EXPORT_SYMBOL(ldlm_lock_match);
EXPORT_SYMBOL(ldlm_lock_addref);
EXPORT_SYMBOL(ldlm_lock_decref);
EXPORT_SYMBOL(ldlm_cli_convert);
ENTRY;
*flags = 0;
- lock = ldlm_local_lock_create(ns, parent_lock_handle, res_id, type,
- mode, data, data_len);
+ lock = ldlm_lock_create(ns, parent_lock_handle, res_id, type, mode,
+ data, data_len);
if (lock == NULL)
GOTO(out, rc = -ENOMEM);
return rc;
}
-int ldlm_cli_callback(struct ldlm_lock *lock, struct ldlm_lock *new,
+int ldlm_cli_callback(struct ldlm_lock *lock, struct ldlm_lock_desc *new,
void *data, __u32 data_len, struct ptlrpc_request **reqp)
{
struct ldlm_request *body;
ldlm_lock2desc(lock, &body->lock_desc);
} else {
CDEBUG(D_NET, "Sending blocked AST\n");
- ldlm_lock2desc(new, &body->lock_desc);
- ldlm_object2handle(new, &body->lock_handle2);
+ memcpy(&body->lock_desc, new, sizeof(*new));
}
LDLM_DEBUG(lock, "server preparing %s AST",
GOTO(out, rc);
reply = lustre_msg_buf(req->rq_repmsg, 0);
- res = ldlm_local_lock_convert(lockh, new_mode, &reply->lock_flags);
+ res = ldlm_lock_convert(lock, new_mode, &reply->lock_flags);
if (res != NULL)
ldlm_reprocess_all(res);
if (lock->l_req_mode != lock->l_granted_mode) {
lock->l_granted_mode);
CDEBUG(D_NET, "waking up, the lock must be granted.\n");
}
- ldlm_put_lock(lock);
+ ldlm_lock_put(lock);
EXIT;
out:
ptlrpc_free_req(req);
lock = list_entry(tmp, struct ldlm_lock, l_res_link);
if (client) {
- rc = ldlm_cli_cancel(lock->l_client, lock);
+ struct lustre_handle lockh;
+ ldlm_lock2handle(lock, &lockh);
+ rc = ldlm_cli_cancel(lock->l_client, &lockh);
if (rc < 0) {
CERROR("ldlm_cli_cancel: %d\n", rc);
LBUG();
/* Convert/cancel blocking locks */
flags = 0;
- res = ldlm_convert(lock1, LCK_NL, &flags);
+ res = ldlm_lock_convert(lock1, LCK_NL, &flags);
if (res != NULL)
ldlm_reprocess_all(res);
- res = ldlm_cancel(lock2);
+ ldlm_lock_cancel(lock2);
if (res != NULL)
ldlm_reprocess_all(res);
struct ptlrpc_request **reqp)
{
struct inode *inode = lock->l_data;
+ struct lustre_handle lockh;
ENTRY;
if (new == NULL) {
invalidate_inode_pages(inode);
up(&inode->i_sem);
- if (ldlm_cli_cancel(lock->l_client, lock) < 0)
+ ldlm_lock2handle(lock, &lockh);
+ if (ldlm_cli_cancel(lock->l_client, &lockh) < 0)
LBUG();
RETURN(0);
}