LBUG();
return &export->exp_obd->u.cli;
}
-extern struct recovd_obd *ptlrpc_connmgr;
int client_obd_setup(struct obd_device *obddev, obd_count len, void *buf)
{
struct obd_ioctl_data* data = buf;
- int rq_portal = (obddev->obd_type->typ_ops->o_getattr) ? OST_REQUEST_PORTAL : MDS_REQUEST_PORTAL;
- int rp_portal = (obddev->obd_type->typ_ops->o_getattr) ? OSC_REPLY_PORTAL : MDC_REPLY_PORTAL;
- struct client_obd *mdc = &obddev->u.cli;
- char server_uuid[37];
- int rc;
+ int rq_portal, rp_portal;
+ char *name;
+ struct client_obd *cli = &obddev->u.cli;
+ obd_uuid_t server_uuid;
ENTRY;
+ if (obddev->obd_type->typ_ops->o_brw) {
+ rq_portal = OST_REQUEST_PORTAL;
+ rp_portal = OSC_REPLY_PORTAL;
+ name = "osc";
+ } else {
+ rq_portal = MDS_REQUEST_PORTAL;
+ rp_portal = MDC_REPLY_PORTAL;
+ name = "mdc";
+ }
+
if (data->ioc_inllen1 < 1) {
CERROR("requires a TARGET UUID\n");
RETURN(-EINVAL);
if (data->ioc_inllen2 < 1) {
CERROR("setup requires a SERVER UUID\n");
- RETURN(-EINVAL);
+ RETURN(-EINVAL);
}
if (data->ioc_inllen2 > 37) {
RETURN(-EINVAL);
}
- sema_init(&mdc->cl_sem, 1);
- mdc->cl_conn_count = 0;
- memcpy(mdc->cl_target_uuid, data->ioc_inlbuf1, data->ioc_inllen1);
+ sema_init(&cli->cl_sem, 1);
+ cli->cl_conn_count = 0;
+ memcpy(cli->cl_target_uuid, data->ioc_inlbuf1, data->ioc_inllen1);
memcpy(server_uuid, data->ioc_inlbuf2, MIN(data->ioc_inllen2,
sizeof(server_uuid)));
- mdc->cl_conn = ptlrpc_uuid_to_connection(server_uuid);
- if (!mdc->cl_conn)
+ cli->cl_import.imp_connection = ptlrpc_uuid_to_connection(server_uuid);
+ if (!cli->cl_import.imp_connection)
RETURN(-ENOENT);
- OBD_ALLOC(mdc->cl_client, sizeof(*mdc->cl_client));
- if (mdc->cl_client == NULL)
- GOTO(out_conn, rc = -ENOMEM);
+ ptlrpc_init_client(rq_portal, rp_portal, name,
+ &obddev->obd_ldlm_client);
+ cli->cl_import.imp_client = &obddev->obd_ldlm_client;
+ cli->cl_import.imp_obd = obddev;
- OBD_ALLOC(mdc->cl_ldlm_client, sizeof(*mdc->cl_ldlm_client));
- if (mdc->cl_ldlm_client == NULL)
- GOTO(out_client, rc = -ENOMEM);
-
- /* XXX get recovery hooked in here again */
- //ptlrpc_init_client(ptlrpc_connmgr, ll_recover,...
-
- ptlrpc_init_client(ptlrpc_connmgr, NULL, rq_portal, rp_portal,
- mdc->cl_client);
- /* XXXshaver Should the LDLM have its own recover function? Probably. */
- ptlrpc_init_client(ptlrpc_connmgr, NULL, LDLM_REQUEST_PORTAL,
- LDLM_REPLY_PORTAL, mdc->cl_ldlm_client);
- mdc->cl_client->cli_name = "mdc";
- mdc->cl_ldlm_client->cli_name = "ldlm";
- mdc->cl_max_mdsize = sizeof(struct lov_mds_md);
+ cli->cl_max_mds_easize = sizeof(struct lov_mds_md);
+ cli->cl_max_ost_easize = sizeof(struct lov_stripe_md);
MOD_INC_USE_COUNT;
RETURN(0);
-
- out_client:
- OBD_FREE(mdc->cl_client, sizeof(*mdc->cl_client));
- out_conn:
- ptlrpc_put_connection(mdc->cl_conn);
- return rc;
}
int client_obd_cleanup(struct obd_device * obddev)
{
struct client_obd *mdc = &obddev->u.cli;
- ptlrpc_cleanup_client(mdc->cl_client);
- OBD_FREE(mdc->cl_client, sizeof(*mdc->cl_client));
- ptlrpc_cleanup_client(mdc->cl_ldlm_client);
- OBD_FREE(mdc->cl_ldlm_client, sizeof(*mdc->cl_ldlm_client));
- ptlrpc_put_connection(mdc->cl_conn);
+ ptlrpc_cleanup_client(&mdc->cl_import);
+ ptlrpc_put_connection(mdc->cl_import.imp_connection);
MOD_DEC_USE_COUNT;
return 0;
}
int client_obd_connect(struct lustre_handle *conn, struct obd_device *obd,
- char *cluuid)
+ obd_uuid_t cluuid)
{
struct client_obd *cli = &obd->u.cli;
struct ptlrpc_request *request;
int rc, size[] = {sizeof(cli->cl_target_uuid),
sizeof(obd->obd_uuid) };
char *tmp[] = {cli->cl_target_uuid, obd->obd_uuid};
- int rq_opc = (obd->obd_type->typ_ops->o_getattr) ? OST_CONNECT : MDS_CONNECT;
+ int rq_opc = (obd->obd_type->typ_ops->o_brw) ? OST_CONNECT :MDS_CONNECT;
+ struct ptlrpc_connection *c;
ENTRY;
down(&cli->cl_sem);
MOD_DEC_USE_COUNT;
GOTO(out_sem, rc);
}
-
cli->cl_conn_count++;
if (cli->cl_conn_count > 1)
GOTO(out_sem, rc);
if (obd->obd_namespace == NULL)
GOTO(out_disco, rc = -ENOMEM);
- request = ptlrpc_prep_req(cli->cl_client, cli->cl_conn, rq_opc, 2, size,
- tmp);
+ request = ptlrpc_prep_req(&cli->cl_import, rq_opc, 2, size, tmp);
if (!request)
GOTO(out_ldlm, rc = -ENOMEM);
request->rq_level = LUSTRE_CONN_NEW;
request->rq_replen = lustre_msg_size(0, NULL);
- // This handle may be important if a callback needs
- // to find the mdc/osc
- // request->rq_reqmsg->addr = conn->addr;
- // request->rq_reqmsg->cookie = conn->cookie;
+ request->rq_reqmsg->addr = conn->addr;
+ request->rq_reqmsg->cookie = conn->cookie;
+ c = class_conn2export(conn)->exp_connection = request->rq_connection;
rc = ptlrpc_queue_wait(request);
rc = ptlrpc_check_status(request, rc);
if (rc)
GOTO(out_req, rc);
- request->rq_connection->c_level = LUSTRE_CONN_FULL;
- cli->cl_exporth = *(struct lustre_handle *)request->rq_repmsg;
+ list_add(&cli->cl_import.imp_chain, &c->c_imports);
+ c->c_level = LUSTRE_CONN_FULL;
+ cli->cl_import.imp_handle.addr = request->rq_repmsg->addr;
+ cli->cl_import.imp_handle.cookie = request->rq_repmsg->cookie;
+
+
+ recovd_conn_manage(c, ptlrpc_recovd, ll_recover);
EXIT;
out_req:
{
struct obd_device *obd = class_conn2obd(conn);
struct client_obd *cli = &obd->u.cli;
- int rq_opc = (obd->obd_type->typ_ops->o_getattr) ? OST_DISCONNECT : MDS_DISCONNECT;
+ int rq_opc = (obd->obd_type->typ_ops->o_brw) ? OST_DISCONNECT : MDS_DISCONNECT;
struct ptlrpc_request *request = NULL;
int rc, err;
ENTRY;
ldlm_namespace_free(obd->obd_namespace);
obd->obd_namespace = NULL;
- request = ptlrpc_prep_req2(conn, rq_opc, 0, NULL, NULL);
+ request = ptlrpc_prep_req(&cli->cl_import, rq_opc, 0, NULL, NULL);
if (!request)
GOTO(out_disco, rc = -ENOMEM);
err = class_disconnect(conn);
if (!rc && err)
rc = err;
+ list_del_init(&cli->cl_import.imp_chain);
MOD_DEC_USE_COUNT;
out_sem:
up(&cli->cl_sem);
{
struct obd_device *target;
struct obd_export *export;
+ struct obd_import *dlmimp;
struct lustre_handle conn;
char *tgtuuid, *cluuid;
int rc, i;
conn.addr = req->rq_reqmsg->addr;
conn.cookie = req->rq_reqmsg->cookie;
- rc = lustre_pack_msg(0,
- NULL, NULL, &req->rq_replen, &req->rq_repmsg);
+ rc = obd_connect(&conn, target, cluuid);
if (rc)
GOTO(out, rc);
- rc = obd_connect(&conn, target, cluuid);
+ rc = lustre_pack_msg(0, NULL, NULL, &req->rq_replen, &req->rq_repmsg);
if (rc)
GOTO(out, rc);
req->rq_repmsg->addr = conn.addr;
LASSERT(export);
req->rq_export = export;
- export->exp_connection = req->rq_connection;
+ export->exp_connection = ptlrpc_get_connection(&req->rq_peer, cluuid);
+ if (req->rq_connection != NULL)
+ ptlrpc_put_connection(req->rq_connection);
+ req->rq_connection = export->exp_connection;
+
+ spin_lock(&export->exp_connection->c_lock);
+ list_add(&export->exp_conn_chain, &export->exp_connection->c_exports);
+ spin_unlock(&export->exp_connection->c_lock);
+
+ recovd_conn_manage(export->exp_connection, ptlrpc_recovd,
+ target_revoke_connection);
+ dlmimp = &export->exp_ldlm_data.led_import;
+ dlmimp->imp_connection = req->rq_connection;
+ dlmimp->imp_client = &export->exp_obd->obd_ldlm_client;
+ dlmimp->imp_handle.addr = req->rq_reqmsg->addr;
+ dlmimp->imp_handle.cookie = req->rq_reqmsg->cookie;
+ dlmimp->imp_obd = /* LDLM! */ NULL;
+
#warning Peter: is this the right place to upgrade the server connection level?
req->rq_connection->c_level = LUSTRE_CONN_FULL;
out:
RETURN(rc);
req->rq_status = obd_disconnect(conn);
+
+ RETURN(0);
+}
+
+static int target_disconnect_client(struct ptlrpc_connection *conn)
+{
+ struct list_head *expiter, *n;
+ struct lustre_handle hdl;
+ struct obd_export *exp;
+ int rc;
+ ENTRY;
+
+ list_for_each_safe(expiter, n, &conn->c_exports) {
+ exp = list_entry(expiter, struct obd_export, exp_conn_chain);
+
+ hdl.addr = (__u64)(unsigned long)exp;
+ hdl.cookie = exp->exp_cookie;
+ rc = obd_disconnect(&hdl);
+ if (rc)
+ CERROR("disconnecting export %p failed: %d\n", exp, rc);
+ }
+ RETURN(0);
+}
+
+static int target_fence_failed_connection(struct ptlrpc_connection *conn)
+{
+ ENTRY;
+
+ conn->c_level = LUSTRE_CONN_RECOVD;
+ conn->c_recovd_data.rd_phase = RD_PREPARED;
+
RETURN(0);
}
+
+int target_revoke_connection(struct recovd_data *rd, int phase)
+{
+ struct ptlrpc_connection *conn = class_rd2conn(rd);
+
+ LASSERT(conn);
+ ENTRY;
+
+ switch (phase) {
+ case PTLRPC_RECOVD_PHASE_PREPARE:
+ RETURN(target_fence_failed_connection(conn));
+ case PTLRPC_RECOVD_PHASE_RECOVER:
+ RETURN(target_disconnect_client(conn));
+ case PTLRPC_RECOVD_PHASE_FAILURE:
+ LBUG();
+ RETURN(0);
+ }
+
+ LBUG();
+ RETURN(-ENOSYS);
+}
git://git.whamcloud.com / fs / lustre-release.git / blobdiff