- Significant simplification is starting to emerge now, as expected.
- Next is the locking subsystem.
- Added new terms to the glossary.
#include <linux/lustre_idl.h>
#ifdef __KERNEL__
+/* l_net.c */
+struct ptlrpc_request;
+int target_handle_connect(struct ptlrpc_request *req);
+int target_handle_disconnect(struct ptlrpc_request *req);
+
/* l_lock.c */
struct lustre_lock {
int l_depth;
struct mds_server_data;
struct mdc_obd {
+ struct lustre_handle mdc_connh;
struct ptlrpc_client *mdc_client;
struct ptlrpc_client *mdc_ldlm_client;
struct ptlrpc_connection *mdc_conn;
__u8 mdc_target_uuid[37];
};
+struct osc_obd {
+ struct lustre_handle osc_connh;
+ struct ptlrpc_client *osc_client;
+ struct ptlrpc_client *osc_ldlm_client;
+ struct ptlrpc_connection *osc_conn;
+ __u8 osc_target_uuid[37];
+};
+
struct mds_obd {
struct ldlm_namespace *mds_local_namespace;
struct ptlrpc_service *mds_service;
struct obd_conn ost_conn; /* the local connection to the OBD */
};
-struct osc_obd {
- struct lustre_handle osc_connh;
- struct ptlrpc_client *osc_client;
- struct ptlrpc_client *osc_ldlm_client;
- struct ptlrpc_connection *osc_conn;
- __u8 osc_target_uuid[37];
-};
typedef __u8 uuid_t[37];
#define DEBUG_SUBSYSTEM S_OST
#include <linux/obd_class.h>
+#include <linux/lustre_net.h>
#include <linux/lustre_lib.h>
/*
int rc, size = sizeof(*rec);
ENTRY;
- req = ptlrpc_prep_req(mdc->mdc_client, mdc->mdc_conn,
+ req = ptlrpc_prep_req2(mdc->mdc_client, mdc->mdc_conn, &mdc->mdc_connh,
MDS_REINT, 1, &size, NULL);
if (!req)
RETURN(-ENOMEM);
bufcount = 3;
}
- req = ptlrpc_prep_req(mdc->mdc_client, mdc->mdc_conn, MDS_REINT,
+ req = ptlrpc_prep_req2(mdc->mdc_client, mdc->mdc_conn, &mdc->mdc_connh,
+ MDS_REINT,
bufcount, size, bufs);
if (!req)
RETURN(-ENOMEM);
int rc, size[2] = {sizeof(struct mds_rec_unlink), namelen + 1};
ENTRY;
- req = ptlrpc_prep_req(mdc->mdc_client, mdc->mdc_conn, MDS_REINT, 2,
- size, NULL);
+ req = ptlrpc_prep_req2(mdc->mdc_client, mdc->mdc_conn, &mdc->mdc_connh,
+ MDS_REINT, 2, size, NULL);
if (!req)
RETURN(-ENOMEM);
int rc, size[2] = {sizeof(struct mds_rec_link), namelen + 1};
ENTRY;
- req = ptlrpc_prep_req(mdc->mdc_client, mdc->mdc_conn, MDS_REINT, 2,
- size, NULL);
+ req = ptlrpc_prep_req2(mdc->mdc_client, mdc->mdc_conn, &mdc->mdc_connh,
+ MDS_REINT, 2, size, NULL);
if (!req)
RETURN(-ENOMEM);
newlen + 1};
ENTRY;
- req = ptlrpc_prep_req(mdc->mdc_client, mdc->mdc_conn,
+ req = ptlrpc_prep_req2(mdc->mdc_client, mdc->mdc_conn, &mdc->mdc_connh,
MDS_REINT, 3, size, NULL);
if (!req)
RETURN(-ENOMEM);
int rc, size = sizeof(*body);
ENTRY;
- req = ptlrpc_prep_req(mdc->mdc_client, mdc->mdc_conn,
+ req = ptlrpc_prep_req2(mdc->mdc_client, mdc->mdc_conn, &mdc->mdc_connh,
MDS_GETSTATUS, 1, &size, NULL);
if (!req)
GOTO(out, rc = -ENOMEM);
int rc, size[2] = {sizeof(*body), 0}, bufcount = 1;
ENTRY;
- req = ptlrpc_prep_req(mdc->mdc_client, mdc->mdc_conn,
+ req = ptlrpc_prep_req2(mdc->mdc_client, mdc->mdc_conn, &mdc->mdc_connh,
MDS_GETATTR, 1, size, NULL);
if (!req)
GOTO(out, rc = -ENOMEM);
size[2] = sizeof(struct mds_rec_create);
size[3] = de->d_name.len + 1;
size[4] = tgtlen + 1;
- req = ptlrpc_prep_req(mdc->mdc_ldlm_client, mdc->mdc_conn,
+ req = ptlrpc_prep_req2(mdc->mdc_ldlm_client, mdc->mdc_conn,
+ &mdc->mdc_connh,
LDLM_ENQUEUE, 5, size, NULL);
if (!req)
RETURN(-ENOMEM);
size[2] = sizeof(struct mds_rec_rename);
size[3] = old_de->d_name.len + 1;
size[4] = de->d_name.len + 1;
- req = ptlrpc_prep_req(mdc->mdc_ldlm_client, mdc->mdc_conn,
- LDLM_ENQUEUE, 5, size, NULL);
+ req = ptlrpc_prep_req2(mdc->mdc_ldlm_client, mdc->mdc_conn,
+ &mdc->mdc_connh, LDLM_ENQUEUE, 5, size, NULL);
if (!req)
RETURN(-ENOMEM);
} else if ( it->it_op == IT_UNLINK ) {
size[2] = sizeof(struct mds_rec_unlink);
size[3] = de->d_name.len + 1;
- req = ptlrpc_prep_req(mdc->mdc_ldlm_client, mdc->mdc_conn,
- LDLM_ENQUEUE, 4, size, NULL);
+ req = ptlrpc_prep_req2(mdc->mdc_ldlm_client, mdc->mdc_conn,
+ &mdc->mdc_connh, LDLM_ENQUEUE, 4, size, NULL);
if (!req)
RETURN(-ENOMEM);
} else if ( it->it_op == IT_RMDIR ) {
size[2] = sizeof(struct mds_rec_unlink);
size[3] = de->d_name.len + 1;
- req = ptlrpc_prep_req(mdc->mdc_ldlm_client, mdc->mdc_conn,
- LDLM_ENQUEUE, 4, size, NULL);
+ req = ptlrpc_prep_req2(mdc->mdc_ldlm_client, mdc->mdc_conn,
+ &mdc->mdc_connh, LDLM_ENQUEUE, 4, size, NULL);
if (!req)
RETURN(-ENOMEM);
size[2] = sizeof(struct mds_body);
size[3] = de->d_name.len + 1;
- req = ptlrpc_prep_req(mdc->mdc_ldlm_client, mdc->mdc_conn,
- LDLM_ENQUEUE, 4, size, NULL);
+ req = ptlrpc_prep_req2(mdc->mdc_ldlm_client, mdc->mdc_conn,
+ &mdc->mdc_connh, LDLM_ENQUEUE, 4, size, NULL);
if (!req)
RETURN(-ENOMEM);
} else if ( it->it_op == IT_SETATTR) {
size[2] = sizeof(struct mds_rec_setattr);
size[3] = de->d_name.len + 1;
- req = ptlrpc_prep_req(mdc->mdc_ldlm_client, mdc->mdc_conn,
- LDLM_ENQUEUE, 5, size, NULL);
+ req = ptlrpc_prep_req2(mdc->mdc_ldlm_client, mdc->mdc_conn,
+ &mdc->mdc_connh, LDLM_ENQUEUE, 5, size, NULL);
if (!req)
RETURN(-ENOMEM);
size[1] = sizeof(struct mds_body);
req->rq_replen = lustre_msg_size(2, size);
} else if ( it->it_op == IT_READDIR ) {
- req = ptlrpc_prep_req(mdc->mdc_ldlm_client, mdc->mdc_conn,
- LDLM_ENQUEUE, 1, size, NULL);
+ req = ptlrpc_prep_req2(mdc->mdc_ldlm_client, mdc->mdc_conn,
+ &mdc->mdc_connh, LDLM_ENQUEUE, 1, size, NULL);
if (!req)
RETURN(-ENOMEM);
size[1] = sizeof(*obdo);
}
- req = ptlrpc_prep_req(mdc->mdc_client, mdc->mdc_conn,
+ req = ptlrpc_prep_req2(mdc->mdc_client, mdc->mdc_conn, &mdc->mdc_connh,
MDS_OPEN, bufcount, size, NULL);
if (!req)
GOTO(out, rc = -ENOMEM);
int rc, size = sizeof(*body);
struct ptlrpc_request *req;
- req = ptlrpc_prep_req(mdc->mdc_client, mdc->mdc_conn,
+ req = ptlrpc_prep_req2(mdc->mdc_client, mdc->mdc_conn, &mdc->mdc_connh,
MDS_CLOSE, 1, &size, NULL);
if (!req)
GOTO(out, rc = -ENOMEM);
if (desc == NULL)
GOTO(out, rc = -ENOMEM);
- req = ptlrpc_prep_req(mdc->mdc_client, mdc->mdc_conn,
+ req = ptlrpc_prep_req2(mdc->mdc_client, mdc->mdc_conn, &mdc->mdc_connh,
MDS_READPAGE, 1, &size, NULL);
if (!req)
GOTO(out2, rc = -ENOMEM);
int rc, size = sizeof(*osfs);
ENTRY;
- req = ptlrpc_prep_req(mdc->mdc_client, mdc->mdc_conn, MDS_STATFS,
- 0, NULL, NULL);
+ req = ptlrpc_prep_req2(mdc->mdc_client, mdc->mdc_conn, &mdc->mdc_connh,
+ MDS_STATFS, 0, NULL, NULL);
if (!req)
GOTO(out, rc = -ENOMEM);
req->rq_replen = lustre_msg_size(1, &size);
if (obd->obd_namespace == NULL)
RETURN(-ENOMEM);
- request = ptlrpc_prep_req(mdc->mdc_client, mdc->mdc_conn,
+ MOD_INC_USE_COUNT;
+ rc = gen_connect(conn, obd);
+ if (rc)
+ GOTO(out, rc);
+
+ request = ptlrpc_prep_req(mdc->mdc_client, mdc->mdc_conn,
MDS_CONNECT, 1, &size, &tmp);
if (!request)
RETURN(-ENOMEM);
request->rq_replen = lustre_msg_size(0, NULL);
rc = ptlrpc_queue_wait(request);
+ rc = ptlrpc_check_status(request, rc);
if (rc)
GOTO(out, rc);
- mdc->mdc_client->cli_target_devno = request->rq_repmsg->target_id;
- mdc->mdc_ldlm_client->cli_target_devno =
- mdc->mdc_client->cli_target_devno;
+ mdc->mdc_connh.addr = request->rq_repmsg->addr;
+ mdc->mdc_connh.cookie = request->rq_repmsg->cookie;
+
EXIT;
out:
ptlrpc_free_req(request);
+ if (rc)
+ MOD_DEC_USE_COUNT;
return rc;
}
struct mdc_obd *mdc = mdc_conn2mdc(conn);
struct obd_device *obd = gen_conn2obd(conn);
struct ptlrpc_request *request;
- struct mds_body *body;
- int rc, size = sizeof(*body);
+ int rc;
ENTRY;
ldlm_namespace_free(obd->obd_namespace);
- request = ptlrpc_prep_req(mdc->mdc_client, mdc->mdc_conn,
- MDS_DISCONNECT, 1, &size,
- NULL);
+ request = ptlrpc_prep_req2(mdc->mdc_client, mdc->mdc_conn,
+ &mdc->mdc_connh, MDS_DISCONNECT, 0, NULL, NULL);
if (!request)
RETURN(-ENOMEM);
- body = lustre_msg_buf(request->rq_reqmsg, 0);
- body->valid = conn->oc_id;
-
request->rq_replen = lustre_msg_size(0, NULL);
rc = ptlrpc_queue_wait(request);
modulefs_DATA = mds.o mds_extN.o # mds_ext2.o mds_ext3.o
EXTRA_PROGRAMS = mds mds_extN # mds_ext2 mds_ext3
-LINX=mds_updates.c simple.c ll_pack.c
+LINX=mds_updates.c simple.c ll_pack.c l_net.c
ll_pack.c:
test -e ll_pack.c || ln -sf $(top_srcdir)/lib/ll_pack.c
simple.c:
test -e simple.c || ln -sf $(top_srcdir)/lib/simple.c
+l_net.c:
+ test -e l_net.c || ln -sf $(top_srcdir)/lib/l_net.c
+
mds_SOURCES = handler.c mds_reint.c mds_fs.c $(LINX)
dist-hook:
struct ptlrpc_request *req);
static int mds_cleanup(struct obd_device * obddev);
+static struct mds_obd *mds_export2mds(struct obd_export *export)
+{
+ return &export->export_obd->u.mds;
+}
+
/* Assumes caller has already pushed into the kernel filesystem context */
static int mds_sendpage(struct ptlrpc_request *req, struct file *file,
__u64 offset)
return result;
}
-static int mds_connect(struct ptlrpc_request *req, struct mds_obd **mdsp)
+static int mds_connect(struct obd_conn *conn, struct obd_device *obd)
{
- struct mds_obd *mds;
- char *uuid;
- int rc, i;
- ENTRY;
+ int rc;
- uuid = lustre_msg_buf(req->rq_reqmsg, 0);
- if (req->rq_reqmsg->buflens[0] > 37) {
- /* Invalid UUID */
- req->rq_status = -EINVAL;
- RETURN(-EINVAL);
- }
+ MOD_INC_USE_COUNT;
+ rc = gen_connect(conn, obd);
- i = obd_class_name2dev(uuid);
- if (i == -1) {
- req->rq_status = -ENODEV;
- RETURN(-ENODEV);
- }
+ if (rc)
+ MOD_DEC_USE_COUNT;
- *mdsp = mds = &(obd_dev[i].u.mds);
- if (mds != &(req->rq_obd->u.mds)) {
- CERROR("device %d (%s) is not an mds\n", i, uuid);
- req->rq_status = -ENODEV;
- RETURN(-ENODEV);
- }
+ return rc;
+}
- CDEBUG(D_INFO, "MDS connect from UUID '%s'\n",
- ptlrpc_req_to_uuid(req));
- rc = lustre_pack_msg(0, NULL, NULL, &req->rq_replen, &req->rq_repmsg);
- if (rc || OBD_FAIL_CHECK(OBD_FAIL_MDS_CONNECT_PACK)) {
- req->rq_status = -ENOMEM;
- RETURN(-ENOMEM);
- }
- req->rq_repmsg->target_id = i;
+static int mds_disconnect(struct obd_conn *conn)
+{
+ int rc;
- RETURN(0);
+ rc = gen_disconnect(conn);
+ if (!rc)
+ MOD_DEC_USE_COUNT;
+
+ return rc;
}
/* FIXME: the error cases need fixing to avoid leaks */
-static int mds_getstatus(struct mds_obd *mds, struct ptlrpc_request *req)
+static int mds_getstatus(struct ptlrpc_request *req)
{
+ struct mds_obd *mds = mds_export2mds(req->rq_export);
struct mds_body *body;
struct mds_client_info *mci;
struct mds_client_data *mcd;
RETURN(0);
}
-static int mds_disconnect(struct mds_obd *mds, struct ptlrpc_request *req)
-{
- struct mds_body *body;
- int rc;
- ENTRY;
-
- body = lustre_msg_buf(req->rq_reqmsg, 0);
-
- rc = lustre_pack_msg(0, NULL, NULL, &req->rq_replen, &req->rq_repmsg);
- if (rc)
- RETURN(rc);
-
- RETURN(0);
-}
-
int mds_lock_callback(struct lustre_handle *lockh, struct ldlm_lock_desc *desc,
void *data, int data_len, struct ptlrpc_request **reqp)
{
RETURN(0);
}
-static int mds_readpage(struct mds_obd *mds, struct ptlrpc_request *req)
+static int mds_readpage(struct ptlrpc_request *req)
{
+ struct mds_obd *mds = mds_export2mds(req->rq_export);
struct vfsmount *mnt;
struct dentry *de;
struct file *file;
int mds_handle(struct ptlrpc_request *req)
{
- struct obd_device *dev = req->rq_obd;
- struct ptlrpc_service *svc = req->rq_svc;
- struct mds_obd *mds = NULL;
int rc;
ENTRY;
GOTO(out, rc = -EINVAL);
}
- if (req->rq_reqmsg->opc != MDS_CONNECT) {
- int id = req->rq_reqmsg->target_id;
- struct obd_device *obddev;
- if (id < 0 || id > MAX_OBD_DEVICES)
- GOTO(out, rc = -ENODEV);
- obddev = &obd_dev[id];
- if (strcmp(obddev->obd_type->typ_name, "mds") != 0)
- GOTO(out, rc = -EINVAL);
- mds = &obddev->u.mds;
- req->rq_obd = obddev;
- }
+ if (req->rq_reqmsg->opc != MDS_CONNECT &&
+ req->rq_export == NULL)
+ GOTO(out, rc = -ENOTCONN);
+
+ if (strcmp(req->rq_obd->obd_type->typ_name, "mds") != 0)
+ GOTO(out, rc = -EINVAL);
switch (req->rq_reqmsg->opc) {
case MDS_CONNECT:
CDEBUG(D_INODE, "connect\n");
OBD_FAIL_RETURN(OBD_FAIL_MDS_CONNECT_NET, 0);
- rc = mds_connect(req, &mds);
+ rc = target_handle_connect(req);
break;
case MDS_DISCONNECT:
CDEBUG(D_INODE, "disconnect\n");
OBD_FAIL_RETURN(OBD_FAIL_MDS_DISCONNECT_NET, 0);
- rc = mds_disconnect(mds, req);
+ rc = target_handle_disconnect(req);
break;
case MDS_GETSTATUS:
CDEBUG(D_INODE, "getstatus\n");
OBD_FAIL_RETURN(OBD_FAIL_MDS_GETSTATUS_NET, 0);
- rc = mds_getstatus(mds, req);
+ rc = mds_getstatus(req);
break;
case MDS_GETATTR:
case MDS_READPAGE:
CDEBUG(D_INODE, "readpage\n");
OBD_FAIL_RETURN(OBD_FAIL_MDS_READPAGE_NET, 0);
- rc = mds_readpage(mds, req);
+ rc = mds_readpage(req);
if (OBD_FAIL_CHECK(OBD_FAIL_MDS_SENDPAGE))
return 0;
break;
default:
- rc = ptlrpc_error(svc, req);
+ rc = ptlrpc_error(req->rq_svc, req);
RETURN(rc);
}
* and we are not supposed to allow transactions while in recovery.
*/
if (rc) {
- ptlrpc_error(svc, req);
+ CERROR("mds: processing error %d\n", rc);
+ ptlrpc_error(req->rq_svc, req);
} else {
+ struct mds_obd *mds = &req->rq_obd->u.mds;
req->rq_repmsg->last_rcvd = HTON__u64(mds->mds_last_rcvd);
req->rq_repmsg->last_committed =
HTON__u64(mds->mds_last_committed);
(unsigned long long)mds->mds_last_committed,
cpu_to_le32(req->rq_xid));
CDEBUG(D_NET, "sending reply\n");
- ptlrpc_reply(svc, req);
+ ptlrpc_reply(req->rq_svc, req);
}
return 0;
}
/* use obd ops to offer management infrastructure */
static struct obd_ops mds_obd_ops = {
+ o_connect: mds_connect,
+ o_disconnect: mds_disconnect,
o_setup: mds_setup,
o_cleanup: mds_cleanup,
};
struct ptlrpc_request *request;
struct ptlrpc_client *cl;
struct ptlrpc_connection *connection;
- struct ost_body *body;
char *tmp = osc->osc_target_uuid;
int rc, size = sizeof(osc->osc_target_uuid);
ENTRY;
GOTO(out, rc);
osc_obd2cl(obd, &cl, &connection);
- request = ptlrpc_prep_req(cl, connection, OST_CONNECT, 1, &size, &tmp);
+ request = ptlrpc_prep_req(osc->osc_client, osc->osc_conn,
+ OST_CONNECT, 1, &size, &tmp);
if (!request)
RETURN(-ENOMEM);
- size = sizeof(*body);
- request->rq_replen = lustre_msg_size(1, &size);
+ request->rq_replen = lustre_msg_size(0, NULL);
rc = ptlrpc_queue_wait(request);
rc = ptlrpc_check_status(request, rc);
GOTO(out, rc);
}
- body = lustre_msg_buf(request->rq_repmsg, 0);
- CDEBUG(D_INODE, "received connid %d\n", body->connid);
-
-
/* XXX: Make this a handle */
osc->osc_connh.addr = request->rq_repmsg->addr;
osc->osc_connh.cookie = request->rq_repmsg->cookie;
- /* This might be redundant. */
- cl->cli_target_devno = request->rq_repmsg->target_id;
- osc->osc_ldlm_client->cli_target_devno = cl->cli_target_devno;
- conn->oc_id = body->connid;
+
EXIT;
out:
ptlrpc_free_req(request);
struct ptlrpc_request *request;
struct ptlrpc_client *cl;
struct ptlrpc_connection *connection;
- struct ost_body *body;
struct osc_obd *osc = &gen_conn2obd(conn)->u.osc;
- int rc, size = sizeof(*body);
+ int rc;
ENTRY;
osc_con2cl(conn, &cl, &connection);
request = ptlrpc_prep_req2(cl, connection, &osc->osc_connh,
- OST_DISCONNECT, 1, &size, NULL);
+ OST_DISCONNECT, 0, NULL, NULL);
if (!request)
RETURN(-ENOMEM);
-
- body = lustre_msg_buf(request->rq_reqmsg, 0);
- body->connid = conn->oc_id;
-
request->rq_replen = lustre_msg_size(0, NULL);
rc = ptlrpc_queue_wait(request);
modulefs_DATA = ost.o
EXTRA_PROGRAMS = ost
-LINX=page.c obd_pack.c
+LINX=page.c obd_pack.c l_net.c
obd_pack.c:
test -e obd_pack.c || ln -sf $(top_srcdir)/lib/obd_pack.c
page.c:
test -e page.c || ln -sf $(top_srcdir)/lib/page.c
+l_net.c:
+ test -e l_net.c || ln -sf $(top_srcdir)/lib/l_net.c
+
ost_SOURCES = $(LINX) ost_handler.c
dist-hook:
list='$(LINX)'; for f in $$list; do rm -f $(distdir)/$$f; done
RETURN(0);
}
-static int ost_connect(struct ptlrpc_request *req)
-{
- struct ost_body *body;
- struct obd_device *target;
- struct obd_export *export;
- struct obd_conn conn;
- char *uuid;
- int rc, size = sizeof(*body), i;
- ENTRY;
-
- uuid = lustre_msg_buf(req->rq_reqmsg, 0);
- if (req->rq_reqmsg->buflens[0] > 37) {
- /* Invalid UUID */
- req->rq_status = -EINVAL;
- RETURN(0);
- }
-
- i = obd_class_uuid2dev(uuid);
- if (i == -1) {
- req->rq_status = -ENODEV;
- RETURN(0);
- }
-
- target = &obd_dev[i];
- if (!target) {
- req->rq_status = -ENODEV;
- RETURN(0);
- }
-
- conn.addr = req->rq_reqmsg->addr;
- conn.cookie = req->rq_reqmsg->cookie;
-
- rc = lustre_pack_msg(1, &size, NULL, &req->rq_replen, &req->rq_repmsg);
- if (rc)
- RETURN(rc);
-
- req->rq_status = obd_connect(&conn, target);
- req->rq_repmsg->addr = conn.addr;
- req->rq_repmsg->cookie = conn.cookie;
-
- export = gen_client(&conn);
- if (!export)
- LBUG();
-
- req->rq_export = export;
- export->export_connection = req->rq_connection;
- CDEBUG(D_IOCTL, "rep buffer %p, id %d\n", req->rq_repmsg, conn.oc_id);
- body = lustre_msg_buf(req->rq_repmsg, 0);
- body->connid = conn.oc_id;
- RETURN(0);
-}
-
-static int ost_disconnect(struct ptlrpc_request *req)
-{
- struct obd_conn *conn = (struct obd_conn *)req->rq_reqmsg;
- struct ost_body *body;
- int rc;
- ENTRY;
-
- body = lustre_msg_buf(req->rq_reqmsg, 0);
-
- rc = lustre_pack_msg(0, NULL, NULL, &req->rq_replen, &req->rq_repmsg);
- if (rc)
- RETURN(rc);
-
- req->rq_status = obd_disconnect(conn);
- RETURN(0);
-}
-
static int ost_get_info(struct ptlrpc_request *req)
{
struct obd_conn *conn = (struct obd_conn *)req->rq_reqmsg;
case OST_CONNECT:
CDEBUG(D_INODE, "connect\n");
OBD_FAIL_RETURN(OBD_FAIL_OST_CONNECT_NET, 0);
- rc = ost_connect(req);
+ rc = target_handle_connect(req);
break;
case OST_DISCONNECT:
CDEBUG(D_INODE, "disconnect\n");
OBD_FAIL_RETURN(OBD_FAIL_OST_DISCONNECT_NET, 0);
- rc = ost_disconnect(req);
+ rc = target_handle_disconnect(req);
break;
case OST_GET_INFO:
CDEBUG(D_INODE, "get_info\n");
$OBDCTL <<- EOF || return $?
newdev
- attach mds MDSDEV MDSUUID
+ attach mds MDSDEV MDSUUID
setup ${MDS} ${MDSFS}
quit
EOF
$OBDCTL <<- EOF || return $?
newdev
attach mdc $THEMDC
- setup MDSDEV $MDSNODE
+ setup MDSUUID $MDSNODE
quit
EOF
done