#include <linux/lprocfs_status.h>
#include <linux/obd_ptlbd.h>
+static int ptlbd_cl_attach(struct obd_device *obd, obd_count len, void *buf)
+{
+ struct lprocfs_static_vars lvars;
+
+ lprocfs_init_vars(ptlbd_cl, &lvars);
+ return lprocfs_obd_attach(obd, lvars.obd_vars);
+}
+
+static int ptlbd_cl_detach(struct obd_device *obd)
+{
+ return lprocfs_obd_detach(obd);
+}
+
static int ptlbd_cl_setup(struct obd_device *obd, obd_count len, void *buf)
{
struct ptlbd_obd *ptlbd = &obd->u.ptlbd;
+ struct lustre_cfg* lcfg = buf;
struct obd_import *imp;
- struct obd_ioctl_data* data = buf;
ENTRY;
if (ptlbd->bd_import != NULL)
RETURN(-EALREADY);
- if (data->ioc_inllen1 < 1) {
+ if (LUSTRE_CFG_BUFLEN(lcfg, 1) < 1) {
CERROR("requires a PTLBD server UUID\n");
RETURN(-EINVAL);
}
- if (data->ioc_inllen1 > 37) {
+ if (LUSTRE_CFG_BUFLEN(lcfg, 1) > 37) {
CERROR("PTLBD server UUID must be less than 38 characters\n");
RETURN(-EINVAL);
}
- obd_str2uuid(&ptlbd->bd_server_uuid, data->ioc_inlbuf1);
+ obd_str2uuid(&ptlbd->bd_server_uuid, lustre_cfg_string(lcfg, 1));
/*
* from client_obd_connect.. *shrug*
class_import_put(imp);
RETURN(-ENOENT);
}
- imp->imp_level = LUSTRE_CONN_FULL;
+ imp->imp_state = LUSTRE_IMP_FULL;
- ptlrpc_init_client(PTLBD_REQUEST_PORTAL, PTLBD_REPLY_PORTAL,
+ ptlrpc_init_client(PTLBD_REQUEST_PORTAL, PTLBD_REPLY_PORTAL,
"ptlbd", &ptlbd->bd_client);
imp->imp_client = &ptlbd->bd_client;
imp->imp_obd = obd;
- memcpy(imp->imp_target_uuid.uuid, data->ioc_inlbuf1, data->ioc_inllen1);
+ memcpy(imp->imp_target_uuid.uuid, lustre_cfg_string(lcfg, 1),
+ LUSTRE_CFG_BUFLEN(lcfg, 1));
ptlbd_blk_register(ptlbd);
RETURN(0);
}
-static int ptlbd_cl_cleanup(struct obd_device *obd, int force, int failover)
+static int ptlbd_cl_cleanup(struct obd_device *obd, int flags)
{
struct ptlbd_obd *ptlbd = &obd->u.ptlbd;
struct obd_import *imp;
RETURN(0);
}
-
/* modelled after ptlrpc_import_connect() */
-int ptlbd_cl_connect(struct lustre_handle *conn,
- struct obd_device *obd,
- struct obd_uuid *target_uuid)
+int ptlbd_cl_connect(struct lustre_handle *conn, struct obd_device *obd,
+ struct obd_uuid *target_uuid, unsigned long connect_flags)
{
struct ptlbd_obd *ptlbd = &obd->u.ptlbd;
struct obd_import *imp = ptlbd->bd_import;
int rc, size[] = {sizeof(imp->imp_target_uuid),
sizeof(obd->obd_uuid),
sizeof(*conn)};
- char *tmp[] = {imp->imp_target_uuid.uuid,
+ char *tmp[] = {imp->imp_target_uuid.uuid,
obd->obd_uuid.uuid,
(char*)conn};
ENTRY;
rc = class_connect(conn, obd, target_uuid);
if (rc)
RETURN(rc);
+ exp = class_conn2export(conn);
- request = ptlrpc_prep_req(imp, PTLBD_CONNECT, 3, size, tmp);
+ request = ptlrpc_prep_req(imp, LUSTRE_PBD_VERSION, PTLBD_CONNECT,
+ 3, size, tmp);
if (!request)
GOTO(out_disco, rc = -ENOMEM);
- request->rq_level = LUSTRE_CONN_NEW;
+
+ request->rq_send_state = LUSTRE_IMP_NEW;
request->rq_replen = lustre_msg_size(0, NULL);
imp->imp_dlm_handle = *conn;
- imp->imp_level = LUSTRE_CONN_CON;
+ imp->imp_state = LUSTRE_IMP_NEW;
rc = ptlrpc_queue_wait(request);
if (rc)
GOTO(out_req, rc);
- exp = class_conn2export(conn);
- exp->exp_connection = ptlrpc_connection_addref(request->rq_connection);
- class_export_put(exp);
+ exp->exp_connection = ptlrpc_connection_addref(imp->imp_connection);
- imp->imp_level = LUSTRE_CONN_FULL;
+ imp->imp_state = LUSTRE_IMP_FULL;
imp->imp_remote_handle = request->rq_repmsg->handle;
-
+
out_req:
ptlrpc_req_finished(request);
out_disco:
if (rc)
- class_disconnect(conn, 0);
+ class_disconnect(exp, 0);
+ class_export_put(exp);
RETURN(rc);
}
/* modelled after ptlrpc_import_disconnect() */
-int ptlbd_cl_disconnect(struct lustre_handle *conn, int failover)
+int ptlbd_cl_disconnect(struct obd_export *exp, unsigned long flags)
{
- struct obd_device *obd = class_conn2obd(conn);
+ struct obd_device *obd = exp->exp_obd;
struct ptlbd_obd *ptlbd = &obd->u.ptlbd;
struct obd_import *imp = ptlbd->bd_import;
struct ptlrpc_request *request;
if (!obd)
RETURN(-EINVAL);
- request = ptlrpc_prep_req(imp, PTLBD_DISCONNECT, 0, NULL, NULL);
+ request = ptlrpc_prep_req(imp, LUSTRE_PBD_VERSION,
+ PTLBD_DISCONNECT,
+ 0, NULL, NULL);
if (!request)
GOTO(out_req, rc = -ENOMEM);
request->rq_replen = lustre_msg_size(0, NULL);
- request->rq_level = LUSTRE_CONN_RECOVD;
+ request->rq_send_state = LUSTRE_IMP_FULL;
rc = ptlrpc_queue_wait(request);
out_req:
if (request)
ptlrpc_req_finished(request);
- err = class_disconnect(conn, 0);
+ err = class_disconnect(exp, 0);
memset(&imp->imp_remote_handle, 0, sizeof(imp->imp_remote_handle));
if (!rc && err)
rc = err;
static struct obd_ops ptlbd_cl_obd_ops = {
- o_owner: THIS_MODULE,
- o_setup: ptlbd_cl_setup,
- o_cleanup: ptlbd_cl_cleanup,
- o_connect: ptlbd_cl_connect,
- o_disconnect: ptlbd_cl_disconnect,
+ .o_owner = THIS_MODULE,
+ .o_attach = ptlbd_cl_attach,
+ .o_detach = ptlbd_cl_detach,
+ .o_setup = ptlbd_cl_setup,
+ .o_cleanup = ptlbd_cl_cleanup,
+ .o_connect = ptlbd_cl_connect,
+ .o_disconnect = ptlbd_cl_disconnect,
};
+static struct lprocfs_vars lprocfs_obd_vars[] = { {0} };
+static struct lprocfs_vars lprocfs_module_vars[] = { {0} };
+LPROCFS_INIT_VARS(ptlbd_cl, lprocfs_module_vars, lprocfs_obd_vars)
+
int ptlbd_cl_init(void)
{
struct lprocfs_static_vars lvars;
- lprocfs_init_vars(&lvars);
- return class_register_type(&ptlbd_cl_obd_ops, lvars.module_vars,
+ lprocfs_init_vars(ptlbd_cl,&lvars);
+ return class_register_type(&ptlbd_cl_obd_ops, NULL, lvars.module_vars,
OBD_PTLBD_CL_DEVICENAME);
}
class_unregister_type(OBD_PTLBD_CL_DEVICENAME);
}
-
-
int ptlbd_do_connect(struct ptlbd_obd *ptlbd)
{
int rc;
struct obd_device *obd = ptlbd->bd_import->imp_obd;
+ struct lustre_handle conn;
ENTRY;
- memset(&ptlbd->bd_connect_handle, 0, sizeof(ptlbd->bd_connect_handle));
- rc = obd_connect(&ptlbd->bd_connect_handle, obd,
- &ptlbd->bd_server_uuid);
+ memset(&conn, 0, sizeof(conn));
+ rc = obd_connect(&conn, obd, &ptlbd->bd_server_uuid, NULL, 0);
+ if (rc < 0)
+ RETURN(rc);
+ ptlbd->bd_exp = class_conn2export(&conn);
RETURN(rc);
}
int rc;
ENTRY;
- rc = obd_disconnect(&ptlbd->bd_connect_handle, 0);
+ rc = obd_disconnect(ptlbd->bd_exp, 0);
RETURN(rc);
}
git://git.whamcloud.com / fs / lustre-release.git / blobdiff