More HGFS-over-VMCI backouts.

Signed-off-by: Marcelo Vanzin <mvanzin@vmware.com>

diff --git a/open-vm-tools/modules/freebsd/vmhgfs/request.c b/open-vm-tools/modules/freebsd/vmhgfs/request.c
index 6e5accfd448fcb6d0c54460ed9300810b4c40b94..5d3eea68efbaecc591399ca017e3941c951f97f9 100644 (file)
--- a/open-vm-tools/modules/freebsd/vmhgfs/request.c
+++ b/open-vm-tools/modules/freebsd/vmhgfs/request.c
@@ -62,10 +62,10 @@ OS_CV_T hgfsKReqWorkItemCv;
  * Local functions (prototypes)
  */
 
-static int   HgfsKReqZCtor(void *mem, int size, void *arg, int flags);
-static void  HgfsKReqZDtor(void *mem, int size, void *arg);
-static int   HgfsKReqZInit(void *mem, int size, int flags);
-static void  HgfsKReqZFini(void *mem, int size);
+   static int   HgfsKReqZCtor(void *mem, int size, void *arg, int flags);
+   static void  HgfsKReqZDtor(void *mem, int size, void *arg);
+   static int   HgfsKReqZInit(void *mem, int size, int flags);
+   static void  HgfsKReqZFini(void *mem, int size);
 
 /*
  * Global functions (definitions)
@@ -719,7 +719,10 @@ HgfsKReqZInit(void *mem,     // IN: Pointer to the allocated object
    HgfsKReqObject *req = (HgfsKReqObject *)mem;
    ASSERT(size == sizeof *req);
 
-   /* Zero out the object. */
+   /*
+    * Zero out the object.  (Do NOT pass UMA_ZEROINIT to uma_zcreate, as
+    * that will override this routine and zero everything -after- us.)
+    */
    bzero(req, sizeof *req);
 
    /*
@@ -743,6 +746,8 @@ HgfsKReqZInit(void *mem,     // IN: Pointer to the allocated object
 
    /* Clear packet of request before allocating to clients. */
    bzero(&req->__rpc_packet, sizeof req->__rpc_packet);
+   bcopy(HGFS_SYNC_REQREP_CLIENT_CMD, req->__rpc_packet._command,
+         HGFS_SYNC_REQREP_CLIENT_CMD_LEN);
 
    return 0;
 }
@@ -812,6 +817,9 @@ HgfsKReqZCtor(void *mem,     // IN: Pointer to memory allocated to user
    /* Initialize state & reference count. */
    req->state = HGFS_REQ_ALLOCATED;
    req->refcnt = 1;
+
+   ASSERT(!strncmp(req->__rpc_packet._command, HGFS_SYNC_REQREP_CLIENT_CMD, HGFS_SYNC_REQREP_CLIENT_CMD_LEN));
+
    return 0;
 }
 

diff --git a/open-vm-tools/modules/freebsd/vmhgfs/worker.c b/open-vm-tools/modules/freebsd/vmhgfs/worker.c
index 750b49bd0f45331eef0206d406833a51821842cd..48b26231e930e85c8acde9acf89bd896180bbf88 100644 (file)
--- a/open-vm-tools/modules/freebsd/vmhgfs/worker.c
+++ b/open-vm-tools/modules/freebsd/vmhgfs/worker.c
@@ -30,7 +30,8 @@
 #include "request.h"
 #include "requestInt.h"
 #include "os.h"
-#include "channel.h"
+
+#include "hgfsBd.h"
 
 
 /*
@@ -46,7 +47,6 @@ OS_THREAD_T hgfsKReqWorkerThread;
  * See requestInt.h.
  */
 HgfsKReqWState hgfsKReqWorkerState;
-HgfsTransportChannel *gHgfsChannel;
 
 
 /*
@@ -77,12 +77,12 @@ HgfsKReqWorker(void *arg)
    DblLnkLst_Links *currNode, *nextNode;
    HgfsKReqWState *ws = (HgfsKReqWState *)arg;
    HgfsKReqObject *req;
+   RpcOut *hgfsRpcOut = NULL;
+   char const *replyPacket;
    int ret = 0;
 
    ws->running = TRUE;
 
-   gHgfsChannel = HgfsGetBdChannel();
-
    for (;;) {
       /*
        * This loop spends most of its time sleeping until signalled by another
@@ -93,7 +93,7 @@ HgfsKReqWorker(void *arg)
       os_mutex_lock(hgfsKReqWorkItemLock);
 
       while (!ws->exit && !DblLnkLst_IsLinked(&hgfsKReqWorkItemList)) {
-         os_cv_wait(&hgfsKReqWorkItemCv, hgfsKReqWorkItemLock);
+        os_cv_wait(&hgfsKReqWorkItemCv, hgfsKReqWorkItemLock);
       }
 
       if (ws->exit) {
@@ -126,14 +126,12 @@ HgfsKReqWorker(void *arg)
       os_mutex_lock(req->stateLock);
       switch (req->state) {
       case HGFS_REQ_SUBMITTED:
-         if (gHgfsChannel->status != HGFS_CHANNEL_CONNECTED) {
-            if (!gHgfsChannel->ops.open(gHgfsChannel)) {
-               req->state = HGFS_REQ_ERROR;
-               os_cv_signal(&req->stateCv);
-               os_mutex_unlock(req->stateLock);
-               os_mutex_unlock(hgfsKReqWorkItemLock);
-               goto done;
-            }
+         if (!HgfsBd_OpenBackdoor(&hgfsRpcOut)) {
+            req->state = HGFS_REQ_ERROR;
+            os_cv_signal(&req->stateCv);
+            os_mutex_unlock(req->stateLock);
+           os_mutex_unlock(hgfsKReqWorkItemLock);
+            goto done;
          }
          break;
       case HGFS_REQ_ABANDONED:
@@ -152,7 +150,25 @@ HgfsKReqWorker(void *arg)
        */
       os_mutex_unlock(hgfsKReqWorkItemLock);
 
-      ret = gHgfsChannel->ops.send(gHgfsChannel, req);
+      ret = HgfsBd_Dispatch(hgfsRpcOut, req->payload, &req->payloadSize,
+                            &replyPacket);
+
+      /*
+       * We have a response.  (Maybe.)  Re-lock the request, update its state,
+       * etc.
+       */
+
+      os_mutex_lock(req->stateLock);
+
+      if ((ret == 0) && (req->state == HGFS_REQ_SUBMITTED)) {
+         bcopy(replyPacket, req->payload, req->payloadSize);
+         req->state = HGFS_REQ_COMPLETED;
+      } else {
+         req->state = HGFS_REQ_ERROR;
+      }
+
+      os_cv_signal(&req->stateCv);
+      os_mutex_unlock(req->stateLock);
 
       if (ret != 0) {
          /*
@@ -160,7 +176,7 @@ HgfsKReqWorker(void *arg)
           * now. We do this because subsequent requests deserve a chance to
           * reopen it.
           */
-         gHgfsChannel->ops.close(gHgfsChannel);
+         HgfsBd_CloseBackdoor(&hgfsRpcOut);
       }
 
 done:
@@ -197,6 +213,9 @@ done:
 
    ws->running = FALSE;
 
-   gHgfsChannel->ops.close(gHgfsChannel);
+   if (hgfsRpcOut != NULL ) {
+      HgfsBd_CloseBackdoor(&hgfsRpcOut);
+   }
+
    os_thread_exit(0);
 }