X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=lustre%2Fptlbd%2Fclient.c;h=c44f9552c3a314e7f7a231b1207e1f75fe7f7cb5;hb=9a34ef9171c846965685828cb0fe0812b00b1ced;hp=67d0b85b54b4784c92b0b38fc2fe181ab054d78d;hpb=040033cef24c5aca2967daf2da7a862abcd074cf;p=fs%2Flustre-release.git diff --git a/lustre/ptlbd/client.c b/lustre/ptlbd/client.c index 67d0b85..c44f955 100644 --- a/lustre/ptlbd/client.c +++ b/lustre/ptlbd/client.c @@ -32,104 +32,194 @@ #include #include -static int ptlbd_cl_setup(struct obd_device *obddev, obd_count len, void *buf) +static int ptlbd_cl_attach(struct obd_device *obd, obd_count len, void *buf) { - struct ptlbd_obd *ptlbd = &obddev->u.ptlbd; - struct obd_import *imp = &ptlbd->bd_import; - struct obd_ioctl_data* data = buf; - struct obd_uuid server_uuid; + 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; ENTRY; - if ( ptlbd->bd_import.imp_connection != NULL ) + 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(&server_uuid, data->ioc_inlbuf1); + obd_str2uuid(&ptlbd->bd_server_uuid, lustre_cfg_string(lcfg, 1)); - imp->imp_connection = ptlrpc_uuid_to_connection(&server_uuid); - if (!imp->imp_connection) - RETURN(-ENOENT); - - INIT_LIST_HEAD(&imp->imp_replay_list); - INIT_LIST_HEAD(&imp->imp_sending_list); - INIT_LIST_HEAD(&imp->imp_delayed_list); - spin_lock_init(&imp->imp_lock); /* * from client_obd_connect.. *shrug* */ - INIT_LIST_HEAD(&imp->imp_chain); - imp->imp_max_transno = 0; - imp->imp_peer_committed_transno = 0; - imp->imp_level = LUSTRE_CONN_FULL; + imp = ptlbd->bd_import = class_new_import(); + imp->imp_connection = ptlrpc_uuid_to_connection(&ptlbd->bd_server_uuid); + if (!imp->imp_connection) { + class_destroy_import(imp); + class_import_put(imp); + RETURN(-ENOENT); + } + 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 = obddev; - + imp->imp_obd = obd; + 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 *obddev) +static int ptlbd_cl_cleanup(struct obd_device *obd, int flags) { -// struct ptlbd_obd *ptlbd = &obddev->u.ptlbd; + struct ptlbd_obd *ptlbd = &obd->u.ptlbd; + struct obd_import *imp; ENTRY; - CERROR("I should be cleaning things up\n"); + if ((!ptlbd) || (!(imp = ptlbd->bd_import))) + RETURN(-ENOENT); + + if (!imp->imp_connection) + RETURN(-ENOENT); + + ptlrpc_cleanup_client(imp); + ptlrpc_put_connection(imp->imp_connection); + + class_destroy_import(imp); + class_import_put(imp); RETURN(0); } -#if 0 -static int ptlbd_cl_connect(struct lustre_handle *conn, struct obd_device *obd, - struct obd_uuid cluuid, struct recovd_obd *recovd, - ptlrpc_recovery_cb_t recover) +/* modelled after ptlrpc_import_connect() */ +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; + struct obd_import *imp = ptlbd->bd_import; + struct obd_export *exp; + struct ptlrpc_request *request; + int rc, size[] = {sizeof(imp->imp_target_uuid), + sizeof(obd->obd_uuid), + sizeof(*conn)}; + char *tmp[] = {imp->imp_target_uuid.uuid, + obd->obd_uuid.uuid, + (char*)conn}; ENTRY; - rc = class_connect(conn, obd, cluuid); + if (!conn || !obd || !target_uuid) + RETURN(-EINVAL); + + rc = class_connect(conn, obd, target_uuid); if (rc) RETURN(rc); + exp = class_conn2export(conn); - INIT_LIST_HEAD(&imp->imp_chain); - imp->imp_max_transno = 0; - imp->imp_peer_committed_transno = 0; - imp->imp_level = LUSTRE_CONN_FULL; + request = ptlrpc_prep_req(imp, LUSTRE_PBD_VERSION, PTLBD_CONNECT, + 3, size, tmp); + if (!request) + GOTO(out_disco, rc = -ENOMEM); - RETURN(0); + request->rq_send_state = LUSTRE_IMP_NEW; + request->rq_replen = lustre_msg_size(0, NULL); + + imp->imp_dlm_handle = *conn; + + imp->imp_state = LUSTRE_IMP_NEW; + rc = ptlrpc_queue_wait(request); + if (rc) + GOTO(out_req, rc); + + exp->exp_connection = ptlrpc_connection_addref(imp->imp_connection); + + 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(exp, 0); + class_export_put(exp); + RETURN(rc); +} + + +/* modelled after ptlrpc_import_disconnect() */ +int ptlbd_cl_disconnect(struct obd_export *exp, unsigned long flags) +{ + 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; + int rc, err; + ENTRY; + + if (!obd) + RETURN(-EINVAL); + + 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_send_state = LUSTRE_IMP_FULL; + + rc = ptlrpc_queue_wait(request); + +out_req: + if (request) + ptlrpc_req_finished(request); + err = class_disconnect(exp, 0); + memset(&imp->imp_remote_handle, 0, sizeof(imp->imp_remote_handle)); + if (!rc && err) + rc = err; + RETURN(rc); } -#endif + static struct obd_ops ptlbd_cl_obd_ops = { - o_owner: THIS_MODULE, - o_setup: ptlbd_cl_setup, - o_cleanup: ptlbd_cl_cleanup, -#if 0 - o_connect: ptlbd_cl_connect, - o_disconnect: class_disconnect -#endif + .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); } @@ -137,3 +227,29 @@ void ptlbd_cl_exit(void) { 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(&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 ptlbd_do_disconnect(struct ptlbd_obd *ptlbd) +{ + int rc; + ENTRY; + + rc = obd_disconnect(ptlbd->bd_exp, 0); + RETURN(rc); +} +