- The same changes made to the OST are now working in the MDS

- Significant simplification is starting to emerge now, as expected.
- Next is the locking subsystem.

- Added new terms to the glossary.

diff --git a/lustre/include/linux/lustre_lib.h b/lustre/include/linux/lustre_lib.h
index 8997f28..e9c6070 100644 (file)
--- a/lustre/include/linux/lustre_lib.h
+++ b/lustre/include/linux/lustre_lib.h
@@ -36,6 +36,11 @@
 #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;

diff --git a/lustre/include/linux/obd.h b/lustre/include/linux/obd.h
index 2b9c633..ce5fdec 100644 (file)
--- a/lustre/include/linux/obd.h
+++ b/lustre/include/linux/obd.h
@@ -67,12 +67,21 @@ struct mds_client_info;
 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;
@@ -149,13 +158,6 @@ struct ost_obd {
         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];
 

diff --git a/lustre/lib/page.c b/lustre/lib/page.c
index 1f83801..a949a3b 100644 (file)
--- a/lustre/lib/page.c
+++ b/lustre/lib/page.c
@@ -46,6 +46,7 @@
 #define DEBUG_SUBSYSTEM S_OST
 
 #include <linux/obd_class.h>
+#include <linux/lustre_net.h>
 #include <linux/lustre_lib.h>
 
 /*

diff --git a/lustre/mdc/mdc_reint.c b/lustre/mdc/mdc_reint.c
index c7447b0..61713b8 100644 (file)
--- a/lustre/mdc/mdc_reint.c
+++ b/lustre/mdc/mdc_reint.c
@@ -55,7 +55,7 @@ int mdc_setattr(struct obd_conn *conn,
         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);
@@ -96,7 +96,8 @@ int mdc_create(struct obd_conn *conn,
                 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);
@@ -142,8 +143,8 @@ int mdc_unlink(struct obd_conn *conn,
         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);
 
@@ -169,8 +170,8 @@ int mdc_link(struct obd_conn *conn,
         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);
 
@@ -198,7 +199,7 @@ int mdc_rename(struct obd_conn *conn,
                            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);

diff --git a/lustre/mdc/mdc_request.c b/lustre/mdc/mdc_request.c
index 27e4488..7d52db1 100644 (file)
--- a/lustre/mdc/mdc_request.c
+++ b/lustre/mdc/mdc_request.c
@@ -44,7 +44,7 @@ int mdc_getstatus(struct obd_conn *conn, struct ll_fid *rootfid,
         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);
@@ -90,7 +90,7 @@ int mdc_getattr(struct obd_conn *conn,
         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);
@@ -199,7 +199,8 @@ int mdc_enqueue(struct obd_conn *conn, int lock_type, struct lookup_intent *it,
                 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);
@@ -223,8 +224,8 @@ int mdc_enqueue(struct obd_conn *conn, int lock_type, struct lookup_intent *it,
                 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);
 
@@ -244,8 +245,8 @@ int mdc_enqueue(struct obd_conn *conn, int lock_type, struct lookup_intent *it,
         } 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);
 
@@ -262,8 +263,8 @@ int mdc_enqueue(struct obd_conn *conn, int lock_type, struct lookup_intent *it,
         } 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);
 
@@ -281,8 +282,8 @@ int mdc_enqueue(struct obd_conn *conn, int lock_type, struct lookup_intent *it,
                 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);
 
@@ -301,8 +302,8 @@ int mdc_enqueue(struct obd_conn *conn, int lock_type, struct lookup_intent *it,
         } 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);
 
@@ -318,8 +319,8 @@ int mdc_enqueue(struct obd_conn *conn, int lock_type, struct lookup_intent *it,
                 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);
 
@@ -367,7 +368,7 @@ int mdc_open(struct obd_conn *conn, ino_t ino, int type, int flags,
                 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);
@@ -408,7 +409,7 @@ int mdc_close(struct obd_conn *conn,
         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);
@@ -446,7 +447,7 @@ int mdc_readpage(struct obd_conn *conn, ino_t ino, int type, __u64 offset,
         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);
@@ -497,8 +498,8 @@ int mdc_statfs(struct obd_conn *conn, struct statfs *sfs,
         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);
@@ -739,7 +740,12 @@ static int mdc_connect(struct obd_conn *conn, struct obd_device *obd)
         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);
@@ -747,15 +753,18 @@ static int mdc_connect(struct obd_conn *conn, struct obd_device *obd)
         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;
 }
 
@@ -764,20 +773,15 @@ static int mdc_disconnect(struct obd_conn *conn)
         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);

diff --git a/lustre/mds/Makefile.am b/lustre/mds/Makefile.am
index 1f66d82..1654b36 100644 (file)
--- a/lustre/mds/Makefile.am
+++ b/lustre/mds/Makefile.am
@@ -9,7 +9,7 @@ MODULE = mds
 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
 
@@ -19,6 +19,9 @@ mds_updates.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:

diff --git a/lustre/mds/handler.c b/lustre/mds/handler.c
index 4dfe364..fdd413e 100644 (file)
--- a/lustre/mds/handler.c
+++ b/lustre/mds/handler.c
@@ -27,6 +27,11 @@ extern int mds_update_last_rcvd(struct mds_obd *mds, void *handle,
                                 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)
@@ -146,48 +151,34 @@ struct dentry *mds_fid2dentry(struct mds_obd *mds, struct ll_fid *fid,
         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;
@@ -242,21 +233,6 @@ static int mds_getstatus(struct mds_obd *mds, struct ptlrpc_request *req)
         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)
 {
@@ -630,8 +606,9 @@ static int mds_close(struct ptlrpc_request *req)
         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;
@@ -690,9 +667,6 @@ int mds_reint(int offset, struct ptlrpc_request *req)
 
 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;
 
@@ -708,35 +682,30 @@ int mds_handle(struct ptlrpc_request *req)
                 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:
@@ -754,7 +723,7 @@ int mds_handle(struct ptlrpc_request *req)
         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;
@@ -789,7 +758,7 @@ int mds_handle(struct ptlrpc_request *req)
                 break;
 
         default:
-                rc = ptlrpc_error(svc, req);
+                rc = ptlrpc_error(req->rq_svc, req);
                 RETURN(rc);
         }
 
@@ -801,8 +770,10 @@ out:
          * 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);
@@ -811,7 +782,7 @@ out:
                        (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;
 }
@@ -1026,6 +997,8 @@ static int mds_cleanup(struct obd_device * obddev)
 
 /* 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,
 };

diff --git a/lustre/osc/osc_request.c b/lustre/osc/osc_request.c
index 3c85846..daba0ce 100644 (file)
--- a/lustre/osc/osc_request.c
+++ b/lustre/osc/osc_request.c
@@ -56,7 +56,6 @@ static int osc_connect(struct obd_conn *conn, struct obd_device *obd)
         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;
@@ -71,12 +70,12 @@ static int osc_connect(struct obd_conn *conn, struct obd_device *obd)
                 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);
@@ -85,17 +84,10 @@ static int osc_connect(struct obd_conn *conn, struct obd_device *obd)
                 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);
@@ -109,20 +101,15 @@ static int osc_disconnect(struct obd_conn *conn)
         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);

diff --git a/lustre/ost/Makefile.am b/lustre/ost/Makefile.am
index 4189e5f..132480b 100644 (file)
--- a/lustre/ost/Makefile.am
+++ b/lustre/ost/Makefile.am
@@ -8,13 +8,16 @@ MODULE = ost
 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

diff --git a/lustre/ost/ost_handler.c b/lustre/ost/ost_handler.c
index 4e9ef59..1962279 100644 (file)
--- a/lustre/ost/ost_handler.c
+++ b/lustre/ost/ost_handler.c
@@ -170,75 +170,6 @@ static int ost_setattr(struct ptlrpc_request *req)
         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;
@@ -504,12 +435,12 @@ static int ost_handle(struct ptlrpc_request *req)
         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");

diff --git a/lustre/tests/common.sh b/lustre/tests/common.sh
index 377eb40..2b53629 100644 (file)
--- a/lustre/tests/common.sh
+++ b/lustre/tests/common.sh
@@ -288,7 +288,7 @@ setup_mds() {
 
        $OBDCTL <<- EOF || return $?
        newdev
-       attach mds MDSDEV MDSUUID
+       attach mds MDSDEV MDSUUID  
        setup ${MDS} ${MDSFS}
        quit
        EOF
@@ -393,7 +393,7 @@ setup_mdc() {
        $OBDCTL <<- EOF || return $?
        newdev
        attach mdc $THEMDC
-       setup MDSDEV $MDSNODE
+       setup MDSUUID $MDSNODE
        quit
        EOF
         done