Changeset 42031 in vbox for trunk/src/VBox

Timestamp:

Jul 5, 2012 8:02:43 PM (13 years ago)

Author:

vboxsync

Message:

Additions/solaris/vboxmouse: convert vboxmouse back to a driver again, and a number of fixes.

File:

• trunk/src/VBox/Additions/solaris/Mouse/vboxmouse.c (modified) (26 diffs)

trunk/src/VBox/Additions/solaris/Mouse/vboxmouse.c

@@ -25 +25 @@
  */
 
+#define LOG_GROUP LOG_GROUP_DRV_MOUSE
 
 /******************************************************************************
@@ -30 +31 @@
 ******************************************************************************/
 
+#include <VBox/VBoxGuestLib.h>
+#include <VBox/log.h>
+#include <VBox/version.h>
+#include <iprt/assert.h>
+#include <iprt/asm.h>
+
 #ifndef TESTCASE
-# include <sys/conf.h>
 # include <sys/modctl.h>
 # include <sys/msio.h>
-# include <sys/pci.h>
 # include <sys/stat.h>
 # include <sys/ddi.h>
-# include <sys/ddi_intr.h>
-# include <sys/open.h>
 # include <sys/strsun.h>
 # include <sys/stropts.h>
 # include <sys/sunddi.h>
-# include <sys/sunldi.h>
 # include <sys/vuid_event.h>
 # include <sys/vuid_wheel.h>
-# include <sys/file.h>
 #undef u /* /usr/include/sys/user.h:249:1 is where this is defined to (curproc->p_user). very cool. */
 #else  /* TESTCASE */
@@ -52 +53 @@
 #endif  /* TESTCASE */
 
-#include "../../common/VBoxGuestLib/SysHlp.h"
-#include <VBox/VBoxGuest.h>
-#include <VBox/VBoxGuestLib.h>
-#include <VBox/log.h>
-#include <VBox/version.h>
-#include <iprt/assert.h>
-#include <iprt/initterm.h>
-#include <iprt/process.h>
-#include <iprt/mem.h>
-#include <iprt/cdefs.h>
-#include <iprt/asm.h>
-#include <iprt/string.h>
-
 #ifdef TESTCASE  /* Include this last as we . */
 # include "testcase/solaris.h"
@@ -85 +73 @@
 ******************************************************************************/
 
+static int vbmsSolAttach(dev_info_t *pDip, ddi_attach_cmd_t enmCmd);
+static int vbmsSolDetach(dev_info_t *pDip, ddi_detach_cmd_t enmCmd);
+static int vbmsSolGetInfo(dev_info_t *pDip, ddi_info_cmd_t enmCmd, void *pvArg,
+                          void **ppvResult);
 static int vbmsSolOpen(queue_t *pReadQueue, dev_t *pDev, int fFlag,
                                 int fMode, cred_t *pCred);
@@ -156 +148 @@
 
 /**
- * fmodsw: loadable module wrapper for streams drivers.
- */
-static struct fmodsw g_vbmsSolStrWrapper = {
-    "vboxms",
+ * cb_ops: for drivers that support char/block entry points
+ */
+static struct cb_ops g_vbmsSolCbOps =
+{
+    nodev,                  /* open */
+    nodev,                  /* close */
+    nodev,                  /* b strategy */
+    nodev,                  /* b dump */
+    nodev,                  /* b print */
+    nodev,                  /* c read */
+    nodev,                  /* c write */
+    nodev,                  /* c ioctl */
+    nodev,                  /* c devmap */
+    nodev,                  /* c mmap */
+    nodev,                  /* c segmap */
+    nochpoll,               /* c poll */
+    ddi_prop_op,            /* property ops */
     &g_vbmsSolStreamTab,
-    D_MP
+    D_MP,
+    CB_REV                  /* revision */
 };
 
 /**
- * modlstrmod: export stream modules specifics to the kernel.
- */
-static struct modlstrmod g_vbmsSolModule =
-{
-    &mod_strmodops,         /* extern from kernel */
+ * dev_ops: for driver device operations
+ */
+static struct dev_ops g_vbmsSolDevOps =
+{
+    DEVO_REV,               /* driver build revision */
+    0,                      /* ref count */
+    vbmsSolGetInfo,
+    nulldev,                /* identify */
+    nulldev,                /* probe */
+    vbmsSolAttach,
+    vbmsSolDetach,
+    nodev,                  /* reset */
+    &g_vbmsSolCbOps,
+    NULL,                   /* bus operations */
+    nodev                   /* power */
+};
+
+/**
+ * modldrv: export driver specifics to the kernel
+ */
+static struct modldrv g_vbmsSolModule =
+{
+    &mod_driverops,         /* extern from kernel */
     DEVICE_DESC " " VBOX_VERSION_STRING "r" RT_XSTR(VBOX_SVN_REV),
-    &g_vbmsSolStrWrapper
+    &g_vbmsSolDevOps
 };
 
@@ -193 +217 @@
 typedef struct
 {
+    /** Device handle. */
+    dev_info_t        *pDip;
+    /** Mutex protecting the guest library against multiple initialistation or
+     * uninitialisation. */
+    kmutex_t           InitMtx;
+    /** Initialisation counter for the guest library. */
+    size_t             cInits;
     /** The STREAMS write queue which we need for sending messages up to
      * user-space. */
@@ -222 +253 @@
 int _init(void)
 {
+    int rc;
+    LogRelFlow((DEVICE_NAME ": built on " __DATE__ " at " __TIME__ "\n"));
+    mutex_init(&g_OpenNodeState.InitMtx, NULL, MUTEX_DRIVER, NULL);
+    /*
+     * Prevent module autounloading.
+     */
+    modctl_t *pModCtl = mod_getctl(&g_vbmsSolModLinkage);
+    if (pModCtl)
+        pModCtl->mod_loadflags |= MOD_NOAUTOUNLOAD;
+    else
+        LogRel((DEVICE_NAME ": failed to disable autounloading!\n"));
+    rc = mod_install(&g_vbmsSolModLinkage);
+
+    LogRel((DEVICE_NAME ": initialisation returning %d.\n", rc));
+    return rc;
+}
+
+
+#ifdef TESTCASE
+/** Simple test of the flow through _init. */
+static void test_init(RTTEST hTest)
+{
+    RTTestSub(hTest, "Testing _init");
+    RTTEST_CHECK(hTest, _init() == 0);
+}
+#endif
+
+
+/** Driver cleanup. */
+int _fini(void)
+{
+    int rc;
+
+    LogRelFlow((DEVICE_NAME ":_fini\n"));
+    rc = mod_remove(&g_vbmsSolModLinkage);
+    mutex_destroy(&g_OpenNodeState.InitMtx);
+
+    return rc;
+}
+
+
+/** Driver identification. */
+int _info(struct modinfo *pModInfo)
+{
+    int rc;
+    LogRelFlow((DEVICE_NAME ":_info\n"));
+    rc = mod_info(&g_vbmsSolModLinkage, pModInfo);
+    LogRelFlow((DEVICE_NAME ":_info returning %d\n", rc));
+    return rc;
+}
+
+
+/******************************************************************************
+*   Initialisation entry points                                               *
+******************************************************************************/
+
+/**
+ * Attach entry point, to attach a device to the system or resume it.
+ *
+ * @param   pDip            The module structure instance.
+ * @param   enmCmd          Attach type (ddi_attach_cmd_t)
+ *
+ * @return  corresponding solaris error code.
+ */
+int vbmsSolAttach(dev_info_t *pDip, ddi_attach_cmd_t enmCmd)
+{
+    LogRelFlow((DEVICE_NAME "::Attach\n"));
+    switch (enmCmd)
+    {
+        case DDI_ATTACH:
+        {
+            int rc;
+            int instance = ddi_get_instance(pDip);
+            /* Only one instance supported. */
+            if (!ASMAtomicCmpXchgPtr(&g_OpenNodeState.pDip, pDip, NULL))
+                return DDI_FAILURE;
+            rc = ddi_create_minor_node(pDip, DEVICE_NAME, S_IFCHR, instance, DDI_PSEUDO, 0);
+            if (rc == DDI_SUCCESS)
+                return DDI_SUCCESS;
+            ASMAtomicWritePtr(&g_OpenNodeState.pDip, NULL);
+            return DDI_FAILURE;
+        }
+
+        case DDI_RESUME:
+        {
+            /** @todo implement resume for guest driver. */
+            return DDI_SUCCESS;
+        }
+
+        default:
+            return DDI_FAILURE;
+    }
+}
+
+
+/**
+ * Detach entry point, to detach a device to the system or suspend it.
+ *
+ * @param   pDip            The module structure instance.
+ * @param   enmCmd          Attach type (ddi_attach_cmd_t)
+ *
+ * @return  corresponding solaris error code.
+ */
+int vbmsSolDetach(dev_info_t *pDip, ddi_detach_cmd_t enmCmd)
+{
+    LogRelFlow((DEVICE_NAME "::Detach\n"));
+    switch (enmCmd)
+    {
+        case DDI_DETACH:
+        {
+            ddi_remove_minor_node(pDip, NULL);
+            ASMAtomicWritePtr(&g_OpenNodeState.pDip, NULL);
+            return DDI_SUCCESS;
+        }
+
+        case DDI_SUSPEND:
+        {
+            /** @todo implement suspend for guest driver. */
+            return DDI_SUCCESS;
+        }
+
+        default:
+            return DDI_FAILURE;
+    }
+}
+
+
+/**
+ * Info entry point, called by solaris kernel for obtaining driver info.
+ *
+ * @param   pDip            The module structure instance (do not use).
+ * @param   enmCmd          Information request type.
+ * @param   pvArg           Type specific argument.
+ * @param   ppvResult       Where to store the requested info.
+ *
+ * @return  corresponding solaris error code.
+ */
+int vbmsSolGetInfo(dev_info_t *pDip, ddi_info_cmd_t enmCmd, void *pvArg,
+                   void **ppvResult)
+{
+    LogRelFlow((DEVICE_NAME "::GetInfo\n"));
+
+    int rc = DDI_SUCCESS;
+    switch (enmCmd)
+    {
+        case DDI_INFO_DEVT2DEVINFO:
+            *ppvResult = (void *)g_OpenNodeState.pDip;
+            break;
+
+        case DDI_INFO_DEVT2INSTANCE:
+            *ppvResult = (void *)(uintptr_t)ddi_get_instance(g_OpenNodeState.pDip);
+            break;
+
+        default:
+            rc = DDI_FAILURE;
+            break;
+    }
+
+    NOREF(pvArg);
+    return rc;
+}
+
+
+/******************************************************************************
+*   Main code                                                                 *
+******************************************************************************/
+
+static void vbmsSolNotify(void *pvState);
+static void vbmsSolVUIDPutAbsEvent(PVBMSSTATE pState, ushort_t cEvent,
+                                   int cValue);
+
+/**
+ * Open callback for the read queue, which we use as a generic device open
+ * handler.
+ */
+int vbmsSolOpen(queue_t *pReadQueue, dev_t *pDev, int fFlag, int fMode,
+                 cred_t *pCred)
+{
+    PVBMSSTATE pState = NULL;
+    int rc = VINF_SUCCESS;
+
+    NOREF(fFlag);
+    NOREF(pCred);
+    LogRelFlow((DEVICE_NAME "::Open\n"));
+
     /*
      * Initialize IPRT R0 driver, which internally calls OS-specific r0 init.
      */
-    int rc = VbglInit();
-    if (RT_SUCCESS(rc))
-    {
-        /*
-         * Prevent module autounloading.
-         */
-        modctl_t *pModCtl = mod_getctl(&g_vbmsSolModLinkage);
-        if (pModCtl)
-            pModCtl->mod_loadflags |= MOD_NOAUTOUNLOAD;
-        else
-            LogRel((DEVICE_NAME ":failed to disable autounloading!\n"));
-        rc = mod_install(&g_vbmsSolModLinkage);
-    }
-    else
+    mutex_enter(&g_OpenNodeState.InitMtx);
+    if (!g_OpenNodeState.cInits)
+        rc = VbglInit();
+    ++g_OpenNodeState.cInits;
+    mutex_exit(&g_OpenNodeState.InitMtx);
+    if (RT_FAILURE(rc))
     {
         cmn_err(CE_NOTE, "_init: VbglInit failed. rc=%d\n", rc);
         return EINVAL;
     }
-
-    LogRel((DEVICE_NAME ": initialisation returning %d.\n", rc));
-    return rc;
-}
-
-
-#ifdef TESTCASE
-/** Simple test of the flow through _init. */
-static void test_init(RTTEST hTest)
-{
-    RTTestSub(hTest, "Testing _init");
-    RTTEST_CHECK(hTest, _init() == 0);
-}
-#endif
-
-
-/** Driver cleanup. */
-int _fini(void)
-{
-    int rc;
-
-    LogRelFlow((DEVICE_NAME ":_fini\n"));
-    rc = mod_remove(&g_vbmsSolModLinkage);
-
-    RTLogDestroy(RTLogRelSetDefaultInstance(NULL));
-    RTLogDestroy(RTLogSetDefaultInstance(NULL));
-
-    RTR0Term();
-    return rc;
-}
-
-
-/** Driver identification. */
-int _info(struct modinfo *pModInfo)
-{
-    LogFlow((DEVICE_NAME ":_info\n"));
-    return mod_info(&g_vbmsSolModLinkage, pModInfo);
-}
-
-
-/******************************************************************************
-*   Main code                                                                 *
-******************************************************************************/
-
-static void vbmsSolNotify(void *pvState);
-static void vbmsSolVUIDPutAbsEvent(PVBMSSTATE pState, ushort_t cEvent,
-                                   int cValue);
-
-/**
- * Open callback for the read queue, which we use as a generic device open
- * handler.
- */
-int vbmsSolOpen(queue_t *pReadQueue, dev_t *pDev, int fFlag, int fMode,
-                 cred_t *pCred)
-{
-    int                 rc;
-    PVBMSSTATE pState = NULL;
-
-    NOREF(fFlag);
-    NOREF(pCred);
-    LogRelFlow((DEVICE_NAME "::Open\n"));
-
     /*
      * Sanity check on the mode parameter - only open as a driver, not a
@@ -341 +487 @@
     ASMAtomicWriteNullPtr(&pState->pWriteQueue);
 
-    LogRel((DEVICE_NAME "::Open: VBoxGuestCreateUserSession failed. rc=%d\n", rc));
+    LogRel((DEVICE_NAME "::Open: VBoxGuestCreateUserSession failed. rc=EFAULT\n"));
     return EFAULT;
 }
@@ -357 +503 @@
     int rc;
     uint32_t x, y;
-    LogFlow((DEVICE_NAME "::NativeISRMousePollEvent:\n"));
+    LogRelFlow((DEVICE_NAME "::NativeISRMousePollEvent:\n"));
 
     rc = VbglGetMouseStatus(NULL, &x, &y);
@@ -408 +554 @@
     PVBMSSTATE pState = (PVBMSSTATE)pReadQueue->q_ptr;
 
-    LogFlow((DEVICE_NAME "::Close\n"));
+    LogRelFlow((DEVICE_NAME "::Close\n"));
     NOREF(fFlag);
     NOREF(pCred);
@@ -428 +574 @@
     ASMAtomicWriteNullPtr(&pState->pWriteQueue);
     pReadQueue->q_ptr = NULL;
+    mutex_enter(&g_OpenNodeState.InitMtx);
+    --g_OpenNodeState.cInits;
+    if (!g_OpenNodeState.cInits)
+        VbglTerminate();
+    mutex_exit(&g_OpenNodeState.InitMtx);
     return 0;
 }
@@ -899 +1050 @@
     enum IOCTLDIRECTION enmDirection;
 
-    LogFlowFunc((DEVICE_NAME "::iCmdType=%c, iCmd=%d\n",
-                 (char) (iCmdType >> 8), iCmd));
+    LogRelFlowFunc((DEVICE_NAME "::iCmdType=%c, iCmd=0x%x\n",
+                 (char) (iCmdType >> 8), (unsigned)iCmd));
     switch (iCmdType)
     {
@@ -967 +1118 @@
     struct iocblk *pIOCBlk = (struct iocblk *)pMBlk->b_rptr;
 
+    LogFlowFunc(("iCmd=0x%x, cbBuffer=%d, enmDirection=%d\n",
+                 (unsigned)iCmd, (int)cbTransparent, (int)enmDirection));
     if (pMBlk->b_datap->db_type == M_IOCDATA)
         return vbmsSolHandleIOCtlData(pWriteQueue, pMBlk, pfnHandler, iCmd,
@@ -995 +1148 @@
     PVBMSSTATE pState = (PVBMSSTATE)pWriteQueue->q_ptr;
 
+    LogFlowFunc(("iCmd=0x%x, cbBuffer=%d, enmDirection=%d, cp_rval=%d, cp_private=%p\n",
+                 (unsigned)iCmd, (int)cbTransparent, (int)enmDirection,
+                 (int)(uintptr_t)pCopyResp->cp_rval,
+                 (void *)pCopyResp->cp_private));
     if (pCopyResp->cp_rval)  /* cp_rval is a pointer used as a boolean. */
     {
@@ -1041 +1198 @@
     PVBMSSTATE pState = (PVBMSSTATE)pWriteQueue->q_ptr;
 
+    LogFlowFunc(("iCmd=0x%x, cbBuffer=%d, enmDirection=%d\n",
+                 (unsigned)iCmd, (int)cbTransparent, (int)enmDirection));
     if (   (enmDirection != NONE && !pMBlk->b_cont)
         || enmDirection == UNSPECIFIED)
@@ -1091 +1250 @@
     size_t cbData = 0;
     
+    LogFlowFunc(("iCmd=0x%x, cbBuffer=%u, b_cont=%p\n",
+                 (unsigned)iCmd, cbBuffer, (void *)pMBlk->b_cont));
     if (cbBuffer && !pMBlk->b_cont)
         return EINVAL;
@@ -1099 +1260 @@
         if (err)
             return err;
+    }
+    if (pMBlk->b_cont)  /* consms forgets to set ioc_count. */
+    {
         pvData = pMBlk->b_cont->b_rptr;
+        cbBuffer = pMBlk->b_cont->b_wptr - pMBlk->b_cont->b_rptr;
     }
     err = pfnHandler(pState, iCmd, pvData, cbBuffer, &cbData, &rc);
@@ -1115 +1280 @@
                              size_t cbBuffer, size_t *pcbData, int *prc)
 {
-    LogFlowFunc((DEVICE_NAME ":: " /* no '\n' */));
+    LogRelFlowFunc((DEVICE_NAME ":: " /* no '\n' */));
     switch (iCmd)
     {
         case VUIDGFORMAT:
         {
-            LogFlowFunc(("VUIDGFORMAT\n"));
+            LogRelFlowFunc(("VUIDGFORMAT\n"));
             if (cbBuffer < sizeof(int))
                 return EINVAL;
@@ -1128 +1293 @@
         }
         case VUIDSFORMAT:
-            LogFlowFunc(("VUIDSFORMAT\n"));
+            LogRelFlowFunc(("VUIDSFORMAT\n"));
             /* We define our native format to be VUID_FIRM_EVENT, so there
              * is nothing more to do and we exit here on success or on
@@ -1135 +1300 @@
         case VUIDGADDR:
         case VUIDSADDR:
-            LogFlowFunc(("VUIDGADDR/VUIDSADDR\n"));
+            LogRelFlowFunc(("VUIDGADDR/VUIDSADDR\n"));
             return ENOTTY;
         case MSIOGETPARMS:
@@ -1141 +1306 @@
             Ms_parms parms = { 0 };
 
-            LogFlowFunc(("MSIOGETPARMS\n"));
+            LogRelFlowFunc(("MSIOGETPARMS\n"));
             if (cbBuffer < sizeof(Ms_parms))
                 return EINVAL;
@@ -1149 +1314 @@
         }
         case MSIOSETPARMS:
-            LogFlowFunc(("MSIOSETPARMS\n"));
+            LogRelFlowFunc(("MSIOSETPARMS\n"));
             return 0;
         case MSIOSRESOLUTION:
@@ -1156 +1321 @@
             int rc;
 
-            LogFlowFunc(("MSIOSRESOLUTION\n"));
+            LogRelFlowFunc(("MSIOSRESOLUTION, cbBuffer=%d, sizeof(Ms_screen_resolution)=%d\n",
+                            (int) cbBuffer,
+                            (int) sizeof(Ms_screen_resolution)));
             if (cbBuffer < sizeof(Ms_screen_resolution))
                 return EINVAL;
+            LogRelFlowFunc(("%dx%d\n", pResolution->width,
+                            pResolution->height));
             pState->cMaxScreenX = pResolution->width  - 1;
             pState->cMaxScreenY = pResolution->height - 1;
@@ -1172 +1341 @@
         case MSIOBUTTONS:
         {
-            LogFlowFunc(("MSIOBUTTONS\n"));
+            LogRelFlowFunc(("MSIOBUTTONS\n"));
             if (cbBuffer < sizeof(int))
                 return EINVAL;
@@ -1181 +1350 @@
         case VUIDGWHEELCOUNT:
         {
-            LogFlowFunc(("VUIDGWHEELCOUNT\n"));
+            LogRelFlowFunc(("VUIDGWHEELCOUNT\n"));
             if (cbBuffer < sizeof(int))
                 return EINVAL;
@@ -1191 +1360 @@
         case VUIDGWHEELSTATE:
         case VUIDSWHEELSTATE:
-            LogFlowFunc(("VUIDGWHEELINFO/VUIDGWHEELSTATE/VUIDSWHEELSTATE\n"));
+            LogRelFlowFunc(("VUIDGWHEELINFO/VUIDGWHEELSTATE/VUIDSWHEELSTATE\n"));
             return EINVAL;
         default:
-            LogFlowFunc(("Invalid IOCtl command %x\n", iCmd));
+            LogRelFlowFunc(("Invalid IOCtl command %x\n", iCmd));
             return EINVAL;
     }