/**
* Callback handler for receiving incoming glimpse ASTs.
*
* This only can happen on client side. After handling the glimpse AST
* we also consider dropping the lock here if it is unused locally for a
* long time.
*/
static void ldlm_handle_gl_callback(struct ptlrpc_request *req,
struct ldlm_namespace *ns,
struct ldlm_request *dlm_req,
struct ldlm_lock *lock)
{
int rc = -ENOSYS;
LDLM_DEBUG(lock, "client glimpse AST callback handler");
if (lock->l_glimpse_ast != NULL)
rc = lock->l_glimpse_ast(lock, req);
if (req->rq_repmsg != NULL) {
ptlrpc_reply(req);
} else {
req->rq_status = rc;
ptlrpc_error(req);
}
lock_res_and_lock(lock);
if (lock->l_granted_mode == LCK_PW &&
!lock->l_readers && !lock->l_writers &&
cfs_time_after(cfs_time_current(),
cfs_time_add(lock->l_last_used,
cfs_time_seconds(10)))) {
unlock_res_and_lock(lock);
if (ldlm_bl_to_thread_lock(ns, NULL, lock))
ldlm_handle_bl_callback(ns, NULL, lock);
return;
}
unlock_res_and_lock(lock);
LDLM_LOCK_RELEASE(lock);
}
/* TODO: handle requests in a similar way as MDT: see mdt_handle_common() */
int mgs_handle(struct ptlrpc_request *req)
{
int fail = OBD_FAIL_MGS_ALL_REPLY_NET;
int opc, rc = 0;
ENTRY;
req_capsule_init(&req->rq_pill, req, RCL_SERVER);
CFS_FAIL_TIMEOUT_MS(OBD_FAIL_MGS_PAUSE_REQ, cfs_fail_val);
if (CFS_FAIL_CHECK(OBD_FAIL_MGS_ALL_REQUEST_NET))
RETURN(0);
LASSERT(current->journal_info == NULL);
opc = lustre_msg_get_opc(req->rq_reqmsg);
if (opc == SEC_CTX_INIT ||
opc == SEC_CTX_INIT_CONT ||
opc == SEC_CTX_FINI)
GOTO(out, rc = 0);
if (opc != MGS_CONNECT) {
if (!class_connected_export(req->rq_export)) {
DEBUG_REQ(D_MGS, req, "operation on unconnected MGS\n");
req->rq_status = -ENOTCONN;
GOTO(out, rc = -ENOTCONN);
}
}
switch (opc) {
case MGS_CONNECT:
DEBUG_REQ(D_MGS, req, "connect");
/* MGS and MDS have same request format for connect */
req_capsule_set(&req->rq_pill, &RQF_MDS_CONNECT);
rc = target_handle_connect(req);
if (rc == 0)
rc = mgs_connect_check_sptlrpc(req);
if (!rc && (lustre_msg_get_conn_cnt(req->rq_reqmsg) > 1))
/* Make clients trying to reconnect after a MGS restart
happy; also requires obd_replayable */
lustre_msg_add_op_flags(req->rq_repmsg,
MSG_CONNECT_RECONNECT);
break;
case MGS_DISCONNECT:
DEBUG_REQ(D_MGS, req, "disconnect");
/* MGS and MDS have same request format for disconnect */
req_capsule_set(&req->rq_pill, &RQF_MDS_DISCONNECT);
rc = target_handle_disconnect(req);
req->rq_status = rc; /* superfluous? */
break;
case MGS_EXCEPTION:
DEBUG_REQ(D_MGS, req, "exception");
rc = mgs_handle_exception(req);
break;
case MGS_TARGET_REG:
DEBUG_REQ(D_MGS, req, "target add");
req_capsule_set(&req->rq_pill, &RQF_MGS_TARGET_REG);
rc = mgs_handle_target_reg(req);
break;
case MGS_TARGET_DEL:
DEBUG_REQ(D_MGS, req, "target del");
rc = mgs_handle_target_del(req);
break;
case MGS_SET_INFO:
DEBUG_REQ(D_MGS, req, "set_info");
req_capsule_set(&req->rq_pill, &RQF_MGS_SET_INFO);
rc = mgs_set_info_rpc(req);
break;
case MGS_CONFIG_READ:
DEBUG_REQ(D_MGS, req, "read config");
req_capsule_set(&req->rq_pill, &RQF_MGS_CONFIG_READ);
rc = mgs_config_read(req);
break;
case LDLM_ENQUEUE:
DEBUG_REQ(D_MGS, req, "enqueue");
req_capsule_set(&req->rq_pill, &RQF_LDLM_ENQUEUE);
rc = ldlm_handle_enqueue(req, ldlm_server_completion_ast,
ldlm_server_blocking_ast, NULL);
break;
case LDLM_BL_CALLBACK:
case LDLM_CP_CALLBACK:
DEBUG_REQ(D_MGS, req, "callback");
CERROR("callbacks should not happen on MGS\n");
LBUG();
break;
case OBD_PING:
DEBUG_REQ(D_INFO, req, "ping");
req_capsule_set(&req->rq_pill, &RQF_OBD_PING);
rc = target_handle_ping(req);
break;
case OBD_LOG_CANCEL:
DEBUG_REQ(D_MGS, req, "log cancel");
rc = -ENOTSUPP; /* la la la */
break;
case LLOG_ORIGIN_HANDLE_CREATE:
DEBUG_REQ(D_MGS, req, "llog_init");
req_capsule_set(&req->rq_pill, &RQF_LLOG_ORIGIN_HANDLE_CREATE);
rc = llog_origin_handle_create(req);
if (rc == 0)
(void)mgs_handle_fslog_hack(req);
break;
case LLOG_ORIGIN_HANDLE_NEXT_BLOCK:
DEBUG_REQ(D_MGS, req, "llog next block");
req_capsule_set(&req->rq_pill,
&RQF_LLOG_ORIGIN_HANDLE_NEXT_BLOCK);
rc = llog_origin_handle_next_block(req);
break;
case LLOG_ORIGIN_HANDLE_READ_HEADER:
DEBUG_REQ(D_MGS, req, "llog read header");
req_capsule_set(&req->rq_pill,
&RQF_LLOG_ORIGIN_HANDLE_READ_HEADER);
rc = llog_origin_handle_read_header(req);
break;
case LLOG_ORIGIN_HANDLE_CLOSE:
DEBUG_REQ(D_MGS, req, "llog close");
rc = llog_origin_handle_close(req);
break;
case LLOG_CATINFO:
DEBUG_REQ(D_MGS, req, "llog catinfo");
req_capsule_set(&req->rq_pill, &RQF_LLOG_CATINFO);
rc = llog_catinfo(req);
break;
default:
req->rq_status = -ENOTSUPP;
rc = ptlrpc_error(req);
RETURN(rc);
}
LASSERT(current->journal_info == NULL);
if (rc)
CERROR("MGS handle cmd=%d rc=%d\n", opc, rc);
out:
target_send_reply(req, rc, fail);
RETURN(0);
}
