/* Establish a connection to the MGS.*/
-static int mgs_connect(struct lustre_handle *conn, struct obd_device *obd,
+static int mgs_connect(const struct lu_env *env,
+ struct lustre_handle *conn, struct obd_device *obd,
struct obd_uuid *cluuid, struct obd_connect_data *data)
{
struct obd_export *exp;
static int mgs_handle(struct ptlrpc_request *req);
/* Start the MGS obd */
-static int mgs_setup(struct obd_device *obd, obd_count len, void *buf)
+static int mgs_setup(struct obd_device *obd, struct lustre_cfg *lcfg)
{
struct lprocfs_static_vars lvars;
struct mgs_obd *mgs = &obd->u.mgs;
/* Find our disk */
lmi = server_get_mount(obd->obd_name);
- if (!lmi)
+ if (!lmi)
RETURN(rc = -EINVAL);
mnt = lmi->lmi_mnt;
GOTO(err_put, rc = PTR_ERR(obd->obd_fsops));
/* namespace for mgs llog */
- obd->obd_namespace = ldlm_namespace_new("MGS", LDLM_NAMESPACE_SERVER);
- if (obd->obd_namespace == NULL) {
- mgs_cleanup(obd);
+ obd->obd_namespace = ldlm_namespace_new("MGS", LDLM_NAMESPACE_SERVER,
+ LDLM_NAMESPACE_MODEST);
+ if (obd->obd_namespace == NULL)
GOTO(err_ops, rc = -ENOMEM);
- }
/* ldlm setup */
ptlrpc_init_client(LDLM_CB_REQUEST_PORTAL, LDLM_CB_REPLY_PORTAL,
if (rc < 0)
GOTO(err_fs, rc);
- rc = llog_setup(obd, LLOG_CONFIG_ORIG_CTXT, obd, 0, NULL,
+ rc = llog_setup(obd, NULL, LLOG_CONFIG_ORIG_CTXT, obd, 0, NULL,
&llog_lvfs_ops);
if (rc)
GOTO(err_fs, rc);
mgs_handle, LUSTRE_MGS_NAME,
obd->obd_proc_entry, NULL,
MGS_THREADS_AUTO_MIN, MGS_THREADS_AUTO_MAX,
- "ll_mgs");
+ "ll_mgs", LCT_MD_THREAD);
if (!mgs->mgs_service) {
CERROR("failed to start service\n");
GOTO(err_thread, rc);
/* Setup proc */
- lprocfs_init_vars(mgs, &lvars);
+ lprocfs_mgs_init_vars(&lvars);
if (lprocfs_obd_setup(obd, lvars.obd_vars) == 0) {
lproc_mgs_setup(obd);
}
struct mgs_obd *mgs = &obd->u.mgs;
ENTRY;
- ping_evictor_stop();
-
if (mgs->mgs_sb == NULL)
RETURN(0);
-
+
+ ping_evictor_stop();
+
ptlrpc_unregister_service(mgs->mgs_service);
mgs_cleanup_fsdb_list(obd);
server_put_mount(obd->obd_name, mgs->mgs_vfsmnt);
mgs->mgs_sb = NULL;
- /* Free the namespace in it's own thread, so that if the
- ldlm_cancel_handler put the last mgs obd ref, we won't
+ /* Free the namespace in it's own thread, so that if the
+ ldlm_cancel_handler put the last mgs obd ref, we won't
deadlock here. */
- cfs_kernel_thread(mgs_ldlm_nsfree, obd->obd_namespace,
+ cfs_kernel_thread(mgs_ldlm_nsfree, obd->obd_namespace,
CLONE_VM | CLONE_FILES);
+
fsfilt_put_ops(obd->obd_fsops);
LCONSOLE_INFO("%s has stopped.\n", obd->obd_name);
int rc, flags = 0;
ENTRY;
- rc = mgc_logname2resid(fsname, &res_id);
- if (!rc)
- rc = ldlm_cli_enqueue_local(obd->obd_namespace, res_id,
+ rc = mgc_fsname2resid(fsname, &res_id);
+ if (!rc)
+ rc = ldlm_cli_enqueue_local(obd->obd_namespace, &res_id,
LDLM_PLAIN, NULL, LCK_EX,
&flags, ldlm_blocking_ast,
ldlm_completion_ast, NULL,
fsname, 0, NULL, lockh);
- if (rc)
+ if (rc)
CERROR("can't take cfg lock for %s (%d)\n", fsname, rc);
-
+
RETURN(rc);
}
rc = mgs_check_index(obd, mti);
if (rc == 0) {
- LCONSOLE_ERROR("%s claims to have registered, but this MGS "
- "does not know about it. Assuming writeconf.\n",
- mti->mti_svname);
+ LCONSOLE_ERROR_MSG(0x13b, "%s claims to have registered, but "
+ "this MGS does not know about it. Assuming"
+ " writeconf.\n", mti->mti_svname);
mti->mti_flags |= LDD_F_WRITECONF;
rc = 1;
} else if (rc == -1) {
- LCONSOLE_ERROR("Client log %s-client has disappeared! "
- "Regenerating all logs.\n",
- mti->mti_fsname);
+ LCONSOLE_ERROR_MSG(0x13c, "Client log %s-client has "
+ "disappeared! Regenerating all logs.\n",
+ mti->mti_fsname);
mti->mti_flags |= LDD_F_WRITECONF;
rc = 1;
} else {
/* Index is correctly marked as used */
- /* If the logs don't contain the mti_nids then add
+ /* If the logs don't contain the mti_nids then add
them as failover nids */
rc = mgs_check_failnid(obd, mti);
}
/* Called whenever a target starts up. Flags indicate first connect, etc. */
static int mgs_handle_target_reg(struct ptlrpc_request *req)
-{
+{
struct obd_device *obd = req->rq_export->exp_obd;
struct lustre_handle lockh;
struct mgs_target_info *mti, *rep_mti;
mti = lustre_swab_reqbuf(req, REQ_REC_OFF, sizeof(*mti),
lustre_swab_mgs_target_info);
-
+
if (!(mti->mti_flags & (LDD_F_WRITECONF | LDD_F_UPGRADE14 |
LDD_F_UPDATE))) {
/* We're just here as a startup ping. */
mti->mti_svname, obd_export_nid2str(req->rq_export));
rc = mgs_check_target(obd, mti);
/* above will set appropriate mti flags */
- if (rc <= 0)
+ if (rc <= 0)
/* Nothing wrong, or fatal error */
GOTO(out_nolock, rc);
}
/* Revoke the config lock to make sure nobody is reading. */
/* Although actually I think it should be alright if
- someone was reading while we were updating the logs - if we
+ someone was reading while we were updating the logs - if we
revoke at the end they will just update from where they left off. */
lockrc = mgs_get_cfg_lock(obd, mti->mti_fsname, &lockh);
if (lockrc != ELDLM_OK) {
- LCONSOLE_ERROR("%s: Can't signal other nodes to update "
- "their configuration (%d). Updating local logs "
- "anyhow; you might have to manually restart "
- "other nodes to get the latest configuration.\n",
- obd->obd_name, lockrc);
+ LCONSOLE_ERROR_MSG(0x13d, "%s: Can't signal other nodes to "
+ "update their configuration (%d). Updating "
+ "local logs anyhow; you might have to "
+ "manually restart other nodes to get the "
+ "latest configuration.\n",
+ obd->obd_name, lockrc);
}
OBD_FAIL_TIMEOUT(OBD_FAIL_MGS_SLOW_TARGET_REG, 10);
/* Log writing contention is handled by the fsdb_sem */
if (mti->mti_flags & LDD_F_WRITECONF) {
- if (mti->mti_flags & LDD_F_SV_TYPE_MDT) {
+ if (mti->mti_flags & LDD_F_SV_TYPE_MDT &&
+ mti->mti_stripe_index == 0) {
rc = mgs_erase_logs(obd, mti->mti_fsname);
LCONSOLE_WARN("%s: Logs for fs %s were removed by user "
"request. All servers must be restarted "
"in order to regenerate the logs."
"\n", obd->obd_name, mti->mti_fsname);
- } else if (mti->mti_flags & LDD_F_SV_TYPE_OST) {
+ } else if (mti->mti_flags &
+ (LDD_F_SV_TYPE_OST | LDD_F_SV_TYPE_MDT)) {
rc = mgs_erase_log(obd, mti->mti_svname);
LCONSOLE_WARN("%s: Regenerating %s log by user "
"request.\n",
/* end COMPAT_146 */
if (mti->mti_flags & LDD_F_UPDATE) {
- CDEBUG(D_MGS, "updating %s, index=%d\n", mti->mti_svname,
+ CDEBUG(D_MGS, "updating %s, index=%d\n", mti->mti_svname,
mti->mti_stripe_index);
-
- /* create or update the target log
+
+ /* create or update the target log
and update the client/mdt logs */
rc = mgs_write_log_target(obd, mti);
if (rc) {
- CERROR("Failed to write %s log (%d)\n",
+ CERROR("Failed to write %s log (%d)\n",
mti->mti_svname, rc);
GOTO(out, rc);
}
- mti->mti_flags &= ~(LDD_F_VIRGIN | LDD_F_UPDATE |
- LDD_F_NEED_INDEX | LDD_F_WRITECONF);
+ mti->mti_flags &= ~(LDD_F_VIRGIN | LDD_F_UPDATE |
+ LDD_F_NEED_INDEX | LDD_F_WRITECONF |
+ LDD_F_UPGRADE14);
mti->mti_flags |= LDD_F_REWRITE_LDD;
}
if (lockrc == ELDLM_OK)
mgs_put_cfg_lock(&lockh);
out_nolock:
- CDEBUG(D_MGS, "replying with %s, index=%d, rc=%d\n", mti->mti_svname,
+ CDEBUG(D_MGS, "replying with %s, index=%d, rc=%d\n", mti->mti_svname,
mti->mti_stripe_index, rc);
- lustre_pack_reply(req, 2, rep_size, NULL);
+ lustre_pack_reply(req, 2, rep_size, NULL);
/* send back the whole mti in the reply */
rep_mti = lustre_msg_buf(req->rq_repmsg, REPLY_REC_OFF,
sizeof(*rep_mti));
RETURN(rc);
}
+static int mgs_set_info_rpc(struct ptlrpc_request *req)
+{
+ struct obd_device *obd = req->rq_export->exp_obd;
+ struct mgs_send_param *msp, *rep_msp;
+ struct lustre_handle lockh;
+ int rep_size[] = { sizeof(struct ptlrpc_body), sizeof(*msp) };
+ int lockrc, rc;
+ struct lustre_cfg_bufs bufs;
+ struct lustre_cfg *lcfg;
+ char fsname[MTI_NAME_MAXLEN];
+ ENTRY;
+
+ msp = lustre_swab_reqbuf(req, REQ_REC_OFF, sizeof(*msp), NULL);
+
+ /* Construct lustre_cfg structure to pass to function mgs_setparam */
+ lustre_cfg_bufs_reset(&bufs, NULL);
+ lustre_cfg_bufs_set_string(&bufs, 1, msp->mgs_param);
+ lcfg = lustre_cfg_new(LCFG_PARAM, &bufs);
+ rc = mgs_setparam(obd, lcfg, fsname);
+ if (rc) {
+ CERROR("Error %d in setting the parameter %s for fs %s\n",
+ rc, msp->mgs_param, fsname);
+ RETURN(rc);
+ }
+
+ /* Revoke lock so everyone updates. Should be alright if
+ * someone was already reading while we were updating the logs,
+ * so we don't really need to hold the lock while we're
+ * writing.
+ */
+ if (fsname[0]) {
+ lockrc = mgs_get_cfg_lock(obd, fsname, &lockh);
+ if (lockrc != ELDLM_OK)
+ CERROR("lock error %d for fs %s\n", lockrc,
+ fsname);
+ else
+ mgs_put_cfg_lock(&lockh);
+ }
+ lustre_cfg_free(lcfg);
+
+ lustre_pack_reply(req, 2, rep_size, NULL);
+ rep_msp = lustre_msg_buf(req->rq_repmsg, REPLY_REC_OFF,
+ sizeof(*rep_msp));
+ memcpy(rep_msp, msp, sizeof(*rep_msp));
+
+ RETURN(rc);
+}
+
int mgs_handle(struct ptlrpc_request *req)
{
int fail = OBD_FAIL_MGS_ALL_REPLY_NET;
ENTRY;
OBD_FAIL_TIMEOUT(OBD_FAIL_MGS_SLOW_REQUEST_NET, 2);
- OBD_FAIL_RETURN(OBD_FAIL_MGS_ALL_REQUEST_NET | OBD_FAIL_ONCE, 0);
LASSERT(current->journal_info == NULL);
opc = lustre_msg_get_opc(req->rq_reqmsg);
switch (opc) {
case MGS_CONNECT:
DEBUG_REQ(D_MGS, req, "connect");
- rc = target_handle_connect(req, mgs_handle);
+ rc = target_handle_connect(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 */
req->rq_status = rc; /* superfluous? */
break;
case MGS_TARGET_REG:
- DEBUG_REQ(D_MGS, req, "target add\n");
+ DEBUG_REQ(D_MGS, req, "target add");
rc = mgs_handle_target_reg(req);
break;
case MGS_TARGET_DEL:
- DEBUG_REQ(D_MGS, req, "target del\n");
+ DEBUG_REQ(D_MGS, req, "target del");
//rc = mgs_handle_target_del(req);
break;
+ case MGS_SET_INFO:
+ rc = mgs_set_info_rpc(req);
+ break;
case LDLM_ENQUEUE:
DEBUG_REQ(D_MGS, req, "enqueue");
rc = target_handle_ping(req);
break;
case OBD_LOG_CANCEL:
- DEBUG_REQ(D_MGS, req, "log cancel\n");
+ DEBUG_REQ(D_MGS, req, "log cancel");
rc = -ENOTSUPP; /* la la la */
break;
}
LASSERT(current->journal_info == NULL);
-
- if (rc)
+
+ if (rc)
CERROR("MGS handle cmd=%d rc=%d\n", opc, rc);
- out:
+out:
target_send_reply(req, rc, fail);
RETURN(0);
}
if (lcfg == NULL)
RETURN(-ENOMEM);
rc = copy_from_user(lcfg, data->ioc_pbuf1, data->ioc_plen1);
- if (rc)
+ if (rc)
GOTO(out_free, rc);
if (lcfg->lcfg_bufcount < 1)
writing (above). */
if (fsname[0]) {
lockrc = mgs_get_cfg_lock(obd, fsname, &lockh);
- if (lockrc != ELDLM_OK)
- CERROR("lock error %d for fs %s\n", lockrc,
+ if (lockrc != ELDLM_OK)
+ CERROR("lock error %d for fs %s\n", lockrc,
fsname);
else
mgs_put_cfg_lock(&lockh);
{
struct lprocfs_static_vars lvars;
- lprocfs_init_vars(mgs, &lvars);
- class_register_type(&mgs_obd_ops, lvars.module_vars, LUSTRE_MGS_NAME);
+ lprocfs_mgs_init_vars(&lvars);
+ class_register_type(&mgs_obd_ops, NULL,
+ lvars.module_vars, LUSTRE_MGS_NAME, NULL);
return 0;
}
git://git.whamcloud.com / fs / lustre-release.git / blobdiff