module_param(ldlm_num_threads, int, 0444);
MODULE_PARM_DESC(ldlm_num_threads, "number of DLM service threads to start");
+static unsigned int ldlm_cpu_bind = 1;
+module_param(ldlm_cpu_bind, uint, 0444);
+MODULE_PARM_DESC(ldlm_cpu_bind,
+ "bind DLM service threads to particular CPU partitions");
+
static char *ldlm_cpts;
module_param(ldlm_cpts, charp, 0444);
MODULE_PARM_DESC(ldlm_cpts, "CPU partitions ldlm threads should run on");
* All access to it should be under waiting_locks_spinlock.
*/
static LIST_HEAD(waiting_locks_list);
-static void waiting_locks_callback(cfs_timer_cb_arg_t unused);
+static void waiting_locks_callback(TIMER_DATA_TYPE unused);
static CFS_DEFINE_TIMER(waiting_locks_timer, waiting_locks_callback, 0, 0);
enum elt_state {
}
/* This is called from within a timer interrupt and cannot schedule */
-static void waiting_locks_callback(cfs_timer_cb_arg_t unused)
+static void waiting_locks_callback(TIMER_DATA_TYPE unused)
{
struct ldlm_lock *lock;
int need_dump = 0;
/**
* Perform lock cleanup if AST reply came with error.
*/
-static int ldlm_handle_ast_error(struct ldlm_lock *lock,
+static int ldlm_handle_ast_error(const struct lu_env *env,
+ struct ldlm_lock *lock,
struct ptlrpc_request *req, int rc,
const char *ast_type)
{
/* update lvbo to return proper attributes.
* see bug 23174 */
ldlm_resource_getref(res);
- ldlm_lvbo_update(res, lock, NULL, 1);
+ ldlm_lvbo_update(env, res, lock, NULL, 1);
ldlm_resource_putref(res);
}
ldlm_lock_cancel(lock);
} else if (rc == -ELDLM_NO_LOCK_DATA) {
LDLM_DEBUG(lock, "lost race - client has a lock but no "
"inode");
- ldlm_lvbo_update(lock->l_resource, lock, NULL, 1);
+ ldlm_lvbo_update(env, lock->l_resource, lock, NULL, 1);
} else if (rc != 0) {
- rc = ldlm_handle_ast_error(lock, req, rc, "glimpse");
+ rc = ldlm_handle_ast_error(env, lock, req,
+ rc, "glimpse");
} else {
- rc = ldlm_lvbo_update(lock->l_resource, lock, req, 1);
+ rc = ldlm_lvbo_update(env, lock->l_resource,
+ lock, req, 1);
}
break;
case LDLM_BL_CALLBACK:
if (rc != 0)
- rc = ldlm_handle_ast_error(lock, req, rc, "blocking");
+ rc = ldlm_handle_ast_error(env, lock, req,
+ rc, "blocking");
break;
case LDLM_CP_CALLBACK:
if (rc != 0)
- rc = ldlm_handle_ast_error(lock, req, rc, "completion");
+ rc = ldlm_handle_ast_error(env, lock, req,
+ rc, "completion");
break;
default:
LDLM_ERROR(lock, "invalid opcode for lock callback %d",
ldlm_lock2desc(lock, &body->lock_desc);
if (lvb_len > 0) {
void *lvb = req_capsule_client_get(&req->rq_pill, &RMF_DLM_LVB);
+ const struct lu_env *env = NULL;
+
+ if (req->rq_svc_thread)
+ env = req->rq_svc_thread->t_env;
- lvb_len = ldlm_lvbo_fill(lock, lvb, lvb_len);
+ lvb_len = ldlm_lvbo_fill(env, lock, lvb, &lvb_len);
if (lvb_len < 0) {
/* We still need to send the RPC to wake up the blocked
* enqueue thread on the client.
void *cookie = NULL;
int rc = 0;
struct ldlm_resource *res = NULL;
+ const struct lu_env *env = req->rq_svc_thread->t_env;
ENTRY;
LDLM_DEBUG_NOLOCK("server-side enqueue handler START");
res = lock->l_resource;
if (!(flags & LDLM_FL_REPLAY)) {
/* non-replayed lock, delayed lvb init may need to be done */
- rc = ldlm_lvbo_init(res);
+ rc = ldlm_lvbo_init(env, res);
if (rc < 0) {
LDLM_DEBUG(lock, "delayed lvb init failed (rc %d)", rc);
GOTO(out, rc);
req_capsule_set_size(&req->rq_pill, &RMF_DLM_LVB,
RCL_SERVER, ldlm_lvbo_size(lock));
- if (OBD_FAIL_CHECK(OBD_FAIL_LDLM_ENQUEUE_EXTENT_ERR))
- GOTO(out, rc = -ENOMEM);
+ if (OBD_FAIL_CHECK(OBD_FAIL_LDLM_ENQUEUE_EXTENT_ERR))
+ GOTO(out, rc = -ENOMEM);
- rc = req_capsule_server_pack(&req->rq_pill);
- if (rc)
- GOTO(out, rc);
- }
+ rc = req_capsule_server_pack(&req->rq_pill);
+ if (rc)
+ GOTO(out, rc);
+ }
- err = ldlm_lock_enqueue(ns, &lock, cookie, &flags);
+ err = ldlm_lock_enqueue(env, ns, &lock, cookie, &flags);
if (err) {
if ((int)err < 0)
rc = (int)err;
GOTO(out, err);
}
- dlm_rep = req_capsule_server_get(&req->rq_pill, &RMF_DLM_REP);
+ dlm_rep = req_capsule_server_get(&req->rq_pill, &RMF_DLM_REP);
- ldlm_lock2desc(lock, &dlm_rep->lock_desc);
- ldlm_lock2handle(lock, &dlm_rep->lock_handle);
+ ldlm_lock2desc(lock, &dlm_rep->lock_desc);
+ ldlm_lock2handle(lock, &dlm_rep->lock_handle);
if (lock && lock->l_resource->lr_type == LDLM_EXTENT)
OBD_FAIL_TIMEOUT(OBD_FAIL_LDLM_BL_EVICT, 6);
LDLM_DEBUG(lock, "server-side enqueue handler, sending reply"
"(err=%d, rc=%d)", err, rc);
- if (rc == 0) {
- if (req_capsule_has_field(&req->rq_pill, &RMF_DLM_LVB,
- RCL_SERVER) &&
- ldlm_lvbo_size(lock) > 0) {
- void *buf;
- int buflen;
-
- buf = req_capsule_server_get(&req->rq_pill,
- &RMF_DLM_LVB);
- LASSERTF(buf != NULL, "req %p, lock %p\n",
- req, lock);
- buflen = req_capsule_get_size(&req->rq_pill,
- &RMF_DLM_LVB, RCL_SERVER);
- /* non-replayed lock, delayed lvb init may
- * need to be occur now */
- if ((buflen > 0) && !(flags & LDLM_FL_REPLAY)) {
- buflen = ldlm_lvbo_fill(lock, buf,
- buflen);
- if (buflen >= 0)
- req_capsule_shrink(
+ if (rc == 0 &&
+ req_capsule_has_field(&req->rq_pill, &RMF_DLM_LVB,
+ RCL_SERVER) &&
+ ldlm_lvbo_size(lock) > 0) {
+ void *buf;
+ int buflen;
+
+retry:
+ buf = req_capsule_server_get(&req->rq_pill,
+ &RMF_DLM_LVB);
+ LASSERTF(buf != NULL, "req %p, lock %p\n", req, lock);
+ buflen = req_capsule_get_size(&req->rq_pill,
+ &RMF_DLM_LVB, RCL_SERVER);
+ /* non-replayed lock, delayed lvb init may
+ * need to be occur now
+ */
+ if ((buflen > 0) && !(flags & LDLM_FL_REPLAY)) {
+ int rc2;
+
+ rc2 = ldlm_lvbo_fill(env, lock, buf, &buflen);
+ if (rc2 >= 0) {
+ req_capsule_shrink(&req->rq_pill,
+ &RMF_DLM_LVB,
+ rc2, RCL_SERVER);
+ } else if (rc2 == -ERANGE) {
+ rc2 = req_capsule_server_grow(
&req->rq_pill,
- &RMF_DLM_LVB,
- buflen, RCL_SERVER);
- else
- rc = buflen;
- } else if (flags & LDLM_FL_REPLAY) {
- /* no LVB resend upon replay */
- if (buflen > 0)
+ &RMF_DLM_LVB, buflen);
+ if (!rc2) {
+ goto retry;
+ } else {
+ /* if we can't grow the buffer,
+ * it's ok to return empty lvb
+ * to client.
+ */
req_capsule_shrink(
&req->rq_pill,
- &RMF_DLM_LVB,
- 0, RCL_SERVER);
- else
- rc = buflen;
+ &RMF_DLM_LVB, 0,
+ RCL_SERVER);
+ }
} else {
- rc = buflen;
+ rc = rc2;
}
+ } else if (flags & LDLM_FL_REPLAY) {
+ /* no LVB resend upon replay */
+ if (buflen > 0)
+ req_capsule_shrink(&req->rq_pill,
+ &RMF_DLM_LVB,
+ 0, RCL_SERVER);
+ else
+ rc = buflen;
+ } else {
+ rc = buflen;
}
}
if (ldlm_is_cancel(lock)) {
LDLM_ERROR(lock, "convert on canceled lock!");
- req->rq_status = LUSTRE_EINVAL;
+ rc = ELDLM_NO_LOCK_DATA;
} else if (dlm_req->lock_desc.l_req_mode !=
lock->l_granted_mode) {
LDLM_ERROR(lock, "lock mode differs!");
- req->rq_status = LUSTRE_EINVAL;
+ rc = ELDLM_NO_LOCK_DATA;
} else if (bits == new) {
/* This can be valid situation if CONVERT RPCs are
- * re-ordered. Just finish silently*/
+ * re-ordered. Just finish silently */
LDLM_DEBUG(lock, "lock is converted already!");
- req->rq_status = 0;
+ rc = ELDLM_OK;
} else {
lock_res_and_lock(lock);
if (ldlm_is_waited(lock))
ldlm_clear_cbpending(lock);
lock->l_policy_data.l_inodebits.cancel_bits = 0;
ldlm_inodebits_drop(lock, bits & ~new);
- lock->l_bl_ast_run = 0;
- ldlm_clear_ast_sent(lock);
+ /* if lock is in a bl_ast list, remove it from the list
+ * here before reprocessing.
+ */
+ if (!list_empty(&lock->l_bl_ast)) {
+ ldlm_discard_bl_lock(lock);
+ } else {
+ /* in this case lock was taken from bl_ast list
+ * already by ldlm_work_bl_ast_lock() and lock
+ * must clear only some remaining states.
+ */
+ ldlm_clear_ast_sent(lock);
+ lock->l_bl_ast_run = 0;
+ ldlm_clear_blocking_lock(lock);
+ }
unlock_res_and_lock(lock);
- req->rq_status = 0;
+ ldlm_reprocess_all(lock->l_resource);
+ rc = ELDLM_OK;
+ }
+
+ if (rc == ELDLM_OK) {
dlm_rep->lock_handle = lock->l_remote_handle;
ldlm_ibits_policy_local_to_wire(&lock->l_policy_data,
&dlm_rep->lock_desc.l_policy_data);
-
- ldlm_reprocess_all(lock->l_resource);
}
- LDLM_DEBUG(lock, "server-side convert handler END");
+
+ LDLM_DEBUG(lock, "server-side convert handler END, rc = %d",
+ rc);
LDLM_LOCK_PUT(lock);
} else {
- req->rq_status = LUSTRE_EINVAL;
- LDLM_DEBUG_NOLOCK("server-side convert handler END");
+ rc = ELDLM_NO_LOCK_DATA;
+ LDLM_DEBUG_NOLOCK("server-side convert handler END, rc = %d",
+ rc);
}
+ req->rq_status = rc;
+
RETURN(0);
}
const struct ldlm_request *dlm_req,
int first, enum lustre_at_flags flags)
{
+ const struct lu_env *env = req->rq_svc_thread->t_env;
struct ldlm_resource *res, *pres = NULL;
struct ldlm_lock *lock;
int i, count, done = 0;
LDLM_RESOURCE_DELREF(pres);
ldlm_resource_putref(pres);
}
- if (res != NULL) {
- ldlm_resource_getref(res);
- LDLM_RESOURCE_ADDREF(res);
+ if (res != NULL) {
+ ldlm_resource_getref(res);
+ LDLM_RESOURCE_ADDREF(res);
if (!ldlm_is_discard_data(lock))
- ldlm_lvbo_update(res, lock, NULL, 1);
- }
- pres = res;
- }
+ ldlm_lvbo_update(env, res, lock,
+ NULL, 1);
+ }
+ pres = res;
+ }
if ((flags & LATF_STATS) && ldlm_is_ast_sent(lock) &&
lock->l_blast_sent != 0) {
}
lock_res_and_lock(lock);
+
+ if (!ldlm_res_eq(&dlm_req->lock_desc.l_resource.lr_name,
+ &lock->l_resource->lr_name)) {
+ ldlm_resource_unlink_lock(lock);
+ unlock_res_and_lock(lock);
+ rc = ldlm_lock_change_resource(ns, lock,
+ &dlm_req->lock_desc.l_resource.lr_name);
+ if (rc < 0) {
+ LDLM_ERROR(lock, "Failed to allocate resource");
+ GOTO(out, rc);
+ }
+ LDLM_DEBUG(lock, "completion AST, new resource");
+ lock_res_and_lock(lock);
+ }
+
if (ldlm_is_destroyed(lock) ||
lock->l_granted_mode == lock->l_req_mode) {
/* bug 11300: the lock has already been granted */
LDLM_DEBUG(lock, "completion AST, new policy data");
}
- ldlm_resource_unlink_lock(lock);
- if (memcmp(&dlm_req->lock_desc.l_resource.lr_name,
- &lock->l_resource->lr_name,
- sizeof(lock->l_resource->lr_name)) != 0) {
- unlock_res_and_lock(lock);
- rc = ldlm_lock_change_resource(ns, lock,
- &dlm_req->lock_desc.l_resource.lr_name);
- if (rc < 0) {
- LDLM_ERROR(lock, "Failed to allocate resource");
- GOTO(out, rc);
- }
- LDLM_DEBUG(lock, "completion AST, new resource");
- CERROR("change resource!\n");
- lock_res_and_lock(lock);
- }
+ ldlm_resource_unlink_lock(lock);
if (dlm_req->lock_flags & LDLM_FL_AST_SENT) {
/* BL_AST locks are not needed in LRU.
rc = ldlm_handle_setinfo(req);
ldlm_callback_reply(req, rc);
RETURN(0);
- case LLOG_ORIGIN_HANDLE_CREATE:
- req_capsule_set(&req->rq_pill, &RQF_LLOG_ORIGIN_HANDLE_CREATE);
- if (OBD_FAIL_CHECK(OBD_FAIL_OBD_LOGD_NET))
- RETURN(0);
- rc = llog_origin_handle_open(req);
- ldlm_callback_reply(req, rc);
- RETURN(0);
- case LLOG_ORIGIN_HANDLE_NEXT_BLOCK:
- req_capsule_set(&req->rq_pill,
- &RQF_LLOG_ORIGIN_HANDLE_NEXT_BLOCK);
- if (OBD_FAIL_CHECK(OBD_FAIL_OBD_LOGD_NET))
- RETURN(0);
- rc = llog_origin_handle_next_block(req);
- ldlm_callback_reply(req, rc);
- RETURN(0);
- case LLOG_ORIGIN_HANDLE_READ_HEADER:
- req_capsule_set(&req->rq_pill,
- &RQF_LLOG_ORIGIN_HANDLE_READ_HEADER);
- if (OBD_FAIL_CHECK(OBD_FAIL_OBD_LOGD_NET))
- RETURN(0);
- rc = llog_origin_handle_read_header(req);
- ldlm_callback_reply(req, rc);
- RETURN(0);
- case LLOG_ORIGIN_HANDLE_CLOSE:
- if (OBD_FAIL_CHECK(OBD_FAIL_OBD_LOGD_NET))
- RETURN(0);
- rc = llog_origin_handle_close(req);
- ldlm_callback_reply(req, rc);
- RETURN(0);
default:
CERROR("unknown opcode %u\n",
lustre_msg_get_opc(req->rq_reqmsg));
*/
static int ldlm_cancel_handler(struct ptlrpc_request *req)
{
- int rc;
- ENTRY;
+ int rc;
- /* Requests arrive in sender's byte order. The ptlrpc service
- * handler has already checked and, if necessary, byte-swapped the
- * incoming request message body, but I am responsible for the
- * message buffers. */
+ ENTRY;
- req_capsule_init(&req->rq_pill, req, RCL_SERVER);
+ /* Requests arrive in sender's byte order. The ptlrpc service
+ * handler has already checked and, if necessary, byte-swapped the
+ * incoming request message body, but I am responsible for the
+ * message buffers. */
- if (req->rq_export == NULL) {
- struct ldlm_request *dlm_req;
+ req_capsule_init(&req->rq_pill, req, RCL_SERVER);
- CERROR("%s from %s arrived at %lu with bad export cookie "
- "%llu\n",
- ll_opcode2str(lustre_msg_get_opc(req->rq_reqmsg)),
- libcfs_nid2str(req->rq_peer.nid),
- req->rq_arrival_time.tv_sec,
- lustre_msg_get_handle(req->rq_reqmsg)->cookie);
-
- if (lustre_msg_get_opc(req->rq_reqmsg) == LDLM_CANCEL) {
- req_capsule_set(&req->rq_pill, &RQF_LDLM_CALLBACK);
- dlm_req = req_capsule_client_get(&req->rq_pill,
- &RMF_DLM_REQ);
- if (dlm_req != NULL)
- ldlm_lock_dump_handle(D_ERROR,
- &dlm_req->lock_handle[0]);
- }
- ldlm_callback_reply(req, -ENOTCONN);
- RETURN(0);
- }
+ if (req->rq_export == NULL) {
+ struct ldlm_request *dlm_req;
- switch (lustre_msg_get_opc(req->rq_reqmsg)) {
+ CERROR("%s from %s arrived at %lu with bad export cookie "
+ "%llu\n",
+ ll_opcode2str(lustre_msg_get_opc(req->rq_reqmsg)),
+ libcfs_nid2str(req->rq_peer.nid),
+ req->rq_arrival_time.tv_sec,
+ lustre_msg_get_handle(req->rq_reqmsg)->cookie);
+
+ if (lustre_msg_get_opc(req->rq_reqmsg) == LDLM_CANCEL) {
+ req_capsule_set(&req->rq_pill, &RQF_LDLM_CALLBACK);
+ dlm_req = req_capsule_client_get(&req->rq_pill,
+ &RMF_DLM_REQ);
+ if (dlm_req != NULL)
+ ldlm_lock_dump_handle(D_ERROR,
+ &dlm_req->lock_handle[0]);
+ }
+ ldlm_callback_reply(req, -ENOTCONN);
+ RETURN(0);
+ }
- /* XXX FIXME move this back to mds/handler.c, bug 249 */
- case LDLM_CANCEL:
- req_capsule_set(&req->rq_pill, &RQF_LDLM_CANCEL);
- CDEBUG(D_INODE, "cancel\n");
+ switch (lustre_msg_get_opc(req->rq_reqmsg)) {
+ /* XXX FIXME move this back to mds/handler.c, bug 249 */
+ case LDLM_CANCEL:
+ req_capsule_set(&req->rq_pill, &RQF_LDLM_CANCEL);
+ CDEBUG(D_INODE, "cancel\n");
if (CFS_FAIL_CHECK(OBD_FAIL_LDLM_CANCEL_NET) ||
CFS_FAIL_CHECK(OBD_FAIL_PTLRPC_CANCEL_RESEND) ||
CFS_FAIL_CHECK(OBD_FAIL_LDLM_BL_EVICT))
RETURN(0);
- rc = ldlm_handle_cancel(req);
- if (rc)
- break;
- RETURN(0);
- default:
- CERROR("invalid opcode %d\n",
- lustre_msg_get_opc(req->rq_reqmsg));
- req_capsule_set(&req->rq_pill, &RQF_LDLM_CALLBACK);
- ldlm_callback_reply(req, -EINVAL);
- }
+ rc = ldlm_handle_cancel(req);
+ break;
+ case LDLM_CONVERT:
+ {
+ struct ldlm_request *dlm_req;
- RETURN(0);
+ req_capsule_set(&req->rq_pill, &RQF_LDLM_CONVERT);
+ CDEBUG(D_INODE, "convert\n");
+
+ dlm_req = req_capsule_client_get(&req->rq_pill, &RMF_DLM_REQ);
+ if (dlm_req == NULL) {
+ CDEBUG(D_INFO, "bad request buffer for cancel\n");
+ rc = ldlm_callback_reply(req, -EPROTO);
+ } else {
+ req->rq_status = ldlm_handle_convert0(req, dlm_req);
+ rc = ptlrpc_reply(req);
+ }
+ break;
+ }
+ default:
+ CERROR("invalid opcode %d\n",
+ lustre_msg_get_opc(req->rq_reqmsg));
+ req_capsule_set(&req->rq_pill, &RQF_LDLM_CALLBACK);
+ rc = ldlm_callback_reply(req, -EINVAL);
+ }
+
+ RETURN(rc);
}
static int ldlm_cancel_hpreq_lock_match(struct ptlrpc_request *req,
- struct ldlm_lock *lock)
+ struct ldlm_lock *lock)
{
- struct ldlm_request *dlm_req;
- struct lustre_handle lockh;
- int rc = 0;
- int i;
- ENTRY;
-
- dlm_req = req_capsule_client_get(&req->rq_pill, &RMF_DLM_REQ);
- if (dlm_req == NULL)
- RETURN(0);
+ struct ldlm_request *dlm_req;
+ struct lustre_handle lockh;
+ int rc = 0;
+ int i;
- ldlm_lock2handle(lock, &lockh);
- for (i = 0; i < dlm_req->lock_count; i++) {
- if (lustre_handle_equal(&dlm_req->lock_handle[i],
- &lockh)) {
- DEBUG_REQ(D_RPCTRACE, req,
- "Prio raised by lock %#llx.", lockh.cookie);
+ ENTRY;
- rc = 1;
- break;
- }
- }
+ dlm_req = req_capsule_client_get(&req->rq_pill, &RMF_DLM_REQ);
+ if (dlm_req == NULL)
+ RETURN(0);
- RETURN(rc);
+ ldlm_lock2handle(lock, &lockh);
+ for (i = 0; i < dlm_req->lock_count; i++) {
+ if (lustre_handle_equal(&dlm_req->lock_handle[i],
+ &lockh)) {
+ DEBUG_REQ(D_RPCTRACE, req,
+ "Prio raised by lock %#llx.", lockh.cookie);
+ rc = 1;
+ break;
+ }
+ }
+ RETURN(rc);
}
static int ldlm_cancel_hpreq_check(struct ptlrpc_request *req)
{
- struct ldlm_request *dlm_req;
- int rc = 0;
- int i;
- ENTRY;
+ struct ldlm_request *dlm_req;
+ int rc = 0;
+ int i;
- /* no prolong in recovery */
- if (lustre_msg_get_flags(req->rq_reqmsg) & MSG_REPLAY)
- RETURN(0);
+ ENTRY;
- dlm_req = req_capsule_client_get(&req->rq_pill, &RMF_DLM_REQ);
- if (dlm_req == NULL)
- RETURN(-EFAULT);
+ /* no prolong in recovery */
+ if (lustre_msg_get_flags(req->rq_reqmsg) & MSG_REPLAY)
+ RETURN(0);
- for (i = 0; i < dlm_req->lock_count; i++) {
- struct ldlm_lock *lock;
+ dlm_req = req_capsule_client_get(&req->rq_pill, &RMF_DLM_REQ);
+ if (dlm_req == NULL)
+ RETURN(-EFAULT);
- lock = ldlm_handle2lock(&dlm_req->lock_handle[i]);
- if (lock == NULL)
- continue;
+ for (i = 0; i < dlm_req->lock_count; i++) {
+ struct ldlm_lock *lock;
+
+ lock = ldlm_handle2lock(&dlm_req->lock_handle[i]);
+ if (lock == NULL)
+ continue;
rc = ldlm_is_ast_sent(lock) ? 1 : 0;
- if (rc)
- LDLM_DEBUG(lock, "hpreq cancel lock");
- LDLM_LOCK_PUT(lock);
+ if (rc)
+ LDLM_DEBUG(lock, "hpreq cancel/convert lock");
+ LDLM_LOCK_PUT(lock);
- if (rc)
- break;
- }
+ if (rc)
+ break;
+ }
- RETURN(rc);
+ RETURN(rc);
}
static struct ptlrpc_hpreq_ops ldlm_cancel_hpreq_ops = {
- .hpreq_lock_match = ldlm_cancel_hpreq_lock_match,
+ .hpreq_lock_match = ldlm_cancel_hpreq_lock_match,
.hpreq_check = ldlm_cancel_hpreq_check,
.hpreq_fini = NULL,
};
static int ldlm_hpreq_handler(struct ptlrpc_request *req)
{
- ENTRY;
+ ENTRY;
- req_capsule_init(&req->rq_pill, req, RCL_SERVER);
+ req_capsule_init(&req->rq_pill, req, RCL_SERVER);
- if (req->rq_export == NULL)
- RETURN(0);
+ if (req->rq_export == NULL)
+ RETURN(0);
- if (LDLM_CANCEL == lustre_msg_get_opc(req->rq_reqmsg)) {
- req_capsule_set(&req->rq_pill, &RQF_LDLM_CANCEL);
- req->rq_ops = &ldlm_cancel_hpreq_ops;
- }
- RETURN(0);
+ if (LDLM_CANCEL == lustre_msg_get_opc(req->rq_reqmsg)) {
+ req_capsule_set(&req->rq_pill, &RQF_LDLM_CANCEL);
+ req->rq_ops = &ldlm_cancel_hpreq_ops;
+ } else if (LDLM_CONVERT == lustre_msg_get_opc(req->rq_reqmsg)) {
+ req_capsule_set(&req->rq_pill, &RQF_LDLM_CONVERT);
+ req->rq_ops = &ldlm_cancel_hpreq_ops;
+ }
+ RETURN(0);
}
static int ldlm_revoke_lock_cb(struct cfs_hash *hs, struct cfs_hash_bd *bd,
.tc_nthrs_base = LDLM_NTHRS_BASE,
.tc_nthrs_max = LDLM_NTHRS_MAX,
.tc_nthrs_user = ldlm_num_threads,
- .tc_cpu_affinity = 1,
+ .tc_cpu_bind = ldlm_cpu_bind,
.tc_ctx_tags = LCT_MD_THREAD | LCT_DT_THREAD,
},
.psc_cpt = {
.cc_pattern = ldlm_cpts,
+ .cc_affinity = true,
},
.psc_ops = {
.so_req_handler = ldlm_callback_handler,
.tc_nthrs_base = LDLM_NTHRS_BASE,
.tc_nthrs_max = LDLM_NTHRS_MAX,
.tc_nthrs_user = ldlm_num_threads,
- .tc_cpu_affinity = 1,
+ .tc_cpu_bind = ldlm_cpu_bind,
.tc_ctx_tags = LCT_MD_THREAD | \
LCT_DT_THREAD | \
LCT_CL_THREAD,
},
.psc_cpt = {
.cc_pattern = ldlm_cpts,
+ .cc_affinity = true,
},
.psc_ops = {
.so_req_handler = ldlm_cancel_handler,