Changeset 14218 in vbox for trunk/src/VBox/Additions/linux/module

Timestamp:

Nov 14, 2008 2:53:05 PM (16 years ago)

Author:

vboxsync

Message:

Additions/Linux: remove Linux-specific guest R0 HGCM hack and add VBOXGUEST_IOCTL_CALL_TIMEOUT support for Linux

Location:

trunk/src/VBox/Additions/linux/module

Files:

• Makefile.kmk (modified) (1 diff)
• Makefile.module (modified) (2 diffs)
• cmc.c (modified) (1 diff)
• files_vboxadd (modified) (4 diffs)
• hgcmcall.c (deleted)
• vboxmod.c (modified) (3 diffs)
• vboxmod.h (modified) (2 diffs)

trunk/src/VBox/Additions/linux/module/Makefile.kmk

@@ -58 +58 @@
 vboxadd_SOURCES  = \
         vboxmod.c \
-        cmc.c \
-        hgcmcall.c
+        cmc.c
 vboxadd_LIBS     = \
         $(VBOX_LIB_VBGL_R0BASE) \

trunk/src/VBox/Additions/linux/module/Makefile.module

@@ -61 +61 @@
 OBJS   = \
         cmc.o \
-        hgcmcall.o \
         vboxmod.o \
         GenericRequest.o \
@@ -70 +69 @@
         VMMDev.o \
         r0drv/alloc-r0drv.o \
+        r0drv/memobj-r0drv.o \
         r0drv/linux/alloc-r0drv-linux.o \
         r0drv/linux/assert-r0drv-linux.o \
+        r0drv/linux/memobj-r0drv-linux.o \
+        r0drv/linux/process-r0drv-linux.o \
         r0drv/linux/semevent-r0drv-linux.o \
         r0drv/linux/semfastmutex-r0drv-linux.o \

trunk/src/VBox/Additions/linux/module/cmc.c

@@ -40 +40 @@
 }
 
+static DECLVBGL(void)
+vboxadd_hgcm_callback_timeout (VMMDevHGCMRequestHeader *pHeader, void *pvData, uint32_t u32Data)
+{
+    VBoxDevice *dev = pvData;
+    wait_event_interruptible_timeout (dev->eventq, pHeader->fu32Flags & VBOX_HGCM_REQ_DONE,
+                                      msecs_to_jiffies (u32Data));
+}
+
 DECLVBGL (int) vboxadd_cmc_call (void *opaque, uint32_t func, void *data)
 {
-    switch (func)
+    int rc = VINF_SUCCESS;
+
+    /* this function can handle cancelled requests */
+    if (   VBOXGUEST_IOCTL_STRIP_SIZE(func)
+        == VBOXGUEST_IOCTL_STRIP_SIZE(VBOXGUEST_IOCTL_HGCM_CALL(0)))
+        rc = VbglHGCMCall (data, vboxadd_hgcm_callback_interruptible, opaque, 0);
+    /* this function can handle cancelled requests */
+    else if (   VBOXGUEST_IOCTL_STRIP_SIZE(func)
+             == VBOXGUEST_IOCTL_STRIP_SIZE(VBOXGUEST_IOCTL_HGCM_CALL_TIMEOUT(0)))
+    {
+        VBoxGuestHGCMCallInfoTimeout *pCallInfo;
+        pCallInfo = (VBoxGuestHGCMCallInfoTimeout *) data;
+        rc = VbglHGCMCall (&pCallInfo->info, vboxadd_hgcm_callback_timeout,
+                           opaque, pCallInfo->u32Timeout);
+    }
+    else switch (func)
     {
         /* this function can NOT handle cancelled requests */
         case VBOXGUEST_IOCTL_HGCM_CONNECT:
-            return VbglHGCMConnect (data, vboxadd_hgcm_callback, opaque, 0);
+            rc = VbglHGCMConnect (data, vboxadd_hgcm_callback, opaque, 0);
+            break;
 
         /* this function can NOT handle cancelled requests */
         case VBOXGUEST_IOCTL_HGCM_DISCONNECT:
-            return VbglHGCMDisconnect (data, vboxadd_hgcm_callback, opaque, 0);
+            rc = VbglHGCMDisconnect (data, vboxadd_hgcm_callback, opaque, 0);
+            break;
 
-        /* this function can handle cancelled requests */
         default:
-            if (VBOXGUEST_IOCTL_STRIP_SIZE(func) != VBOXGUEST_IOCTL_STRIP_SIZE(VBOXGUEST_IOCTL_HGCM_CALL(0)))
-                return VERR_VBGL_IOCTL_FAILED;
-            /* fall thru */
-        case VBOXGUEST_IOCTL_STRIP_SIZE (VBOXGUEST_IOCTL_HGCM_CALL (0)):
-            return VbglHGCMCall (data, vboxadd_hgcm_callback_interruptible, opaque, 0);
+            rc = VERR_VBGL_IOCTL_FAILED;
     }
+    return rc;
 }
 

trunk/src/VBox/Additions/linux/module/files_vboxadd

@@ -30 +30 @@
     ${PATH_ROOT}/include/iprt/log.h=>include/iprt/log.h \
     ${PATH_ROOT}/include/iprt/mem.h=>include/iprt/mem.h \
+    ${PATH_ROOT}/include/iprt/memobj.h=>include/iprt/memobj.h \
     ${PATH_ROOT}/include/iprt/param.h=>include/iprt/param.h \
+    ${PATH_ROOT}/include/iprt/process.h=>include/iprt/process.h \
     ${PATH_ROOT}/include/iprt/semaphore.h=>include/iprt/semaphore.h \
     ${PATH_ROOT}/include/iprt/spinlock.h=>include/iprt/spinlock.h \
@@ -56 +58 @@
     ${PATH_ROOT}/src/VBox/Additions/common/VBoxGuestLib/VMMDev.cpp=>VMMDev.c \
     ${PATH_ROOT}/src/VBox/Runtime/include/internal/magics.h=>include/internal/magics.h \
+    ${PATH_ROOT}/src/VBox/Runtime/include/internal/memobj.h=>include/internal/memobj.h \
     ${PATH_ROOT}/src/VBox/Runtime/include/internal/string.h=>include/internal/string.h \
     ${PATH_ROOT}/src/VBox/Runtime/common/alloc/heapsimple.cpp=>alloc/heapsimple.c \
@@ -73 +76 @@
     ${PATH_ROOT}/src/VBox/Runtime/r0drv/alloc-r0drv.cpp=>r0drv/alloc-r0drv.c \
     ${PATH_ROOT}/src/VBox/Runtime/r0drv/alloc-r0drv.h=>r0drv/alloc-r0drv.h \
+    ${PATH_ROOT}/src/VBox/Runtime/r0drv/memobj-r0drv.cpp=>r0drv/memobj-r0drv.c \
     ${PATH_ROOT}/src/VBox/Runtime/r0drv/linux/alloc-r0drv-linux.c=>r0drv/linux/alloc-r0drv-linux.c \
     ${PATH_ROOT}/src/VBox/Runtime/r0drv/linux/assert-r0drv-linux.c=>r0drv/linux/assert-r0drv-linux.c \
+    ${PATH_ROOT}/src/VBox/Runtime/r0drv/linux/memobj-r0drv-linux.c=>r0drv/linux/memobj-r0drv-linux.c \
+    ${PATH_ROOT}/src/VBox/Runtime/r0drv/linux/process-r0drv-linux.c=>r0drv/linux/process-r0drv-linux.c \
     ${PATH_ROOT}/src/VBox/Runtime/r0drv/linux/semevent-r0drv-linux.c=>r0drv/linux/semevent-r0drv-linux.c \
     ${PATH_ROOT}/src/VBox/Runtime/r0drv/linux/semeventmulti-r0drv-linux.c=>r0drv/linux/semeventmulti-r0drv-linux.c \
@@ -85 +91 @@
     ${PATH_ROOT}/src/VBox/Additions/linux/module/vboxmod.c=>vboxmod.c \
     ${PATH_ROOT}/src/VBox/Additions/linux/module/cmc.c=>cmc.c \
-    ${PATH_ROOT}/src/VBox/Additions/linux/module/hgcmcall.c=>hgcmcall.c \
     ${PATH_ROOT}/src/VBox/Additions/linux/module/vboxmod.h=>vboxmod.h \
     ${PATH_ROOT}/src/VBox/Additions/linux/module/waitcompat.h=>waitcompat.h \

trunk/src/VBox/Additions/linux/module/vboxmod.c

@@ -287 +287 @@
 {
         VBoxGuestHGCMConnectInfo info;
-        VBoxGuestHGCMDisconnectInfo infoDisconnect;
-        int rc = 0, rcVBox;
-
-        if (0 != copy_from_user ((void *)&info, (void *)userspace_info, sizeof (info))) {
-                LogRelFunc (("VBOXGUEST_IOCTL_HGCM_CONNECT: can not get connection info\n"));
-                return -EFAULT;
-        }
-        rcVBox = vboxadd_cmc_call(vboxDev, VBOXGUEST_IOCTL_HGCM_CONNECT, &info);
-        if (RT_FAILURE(rcVBox) || (RT_FAILURE(info.result))) {
-                LogRelFunc(("VBOXGUEST_IOCTL_HGCM_CONNECT: hgcm connection failed.  internal ioctl result %Rrc, hgcm result %Rrc\n", rcVBox, info.result));
-                rc = RT_FAILURE(rcVBox) ?   -RTErrConvertToErrno(rcVBox)
-                                          : -RTErrConvertToErrno(info.result);
-        } else {
-                /* Register that the connection is associated with this file pointer. */
-                LogRelFunc(("Connected, client ID %u\n", info.u32ClientID));
-                rc = vboxadd_register_hgcm_connection(info.u32ClientID, filp);
-                if (0 != rc) {
-                        LogRelFunc(("VBOXGUEST_IOCTL_HGCM_CONNECT: failed to register the HGCM connection\n"));
-                } else {
-                        if (copy_to_user ((void *)userspace_info, (void *)&info,
-                                          sizeof(info))) {
-                                LogRelFunc (("VBOXGUEST_IOCTL_HGCM_CONNECT: failed to return the connection structure\n"));
-                                rc = -EFAULT;
-                        } else {
-                                return 0;
-                        }
-                        /* Unregister again, as we didn't get as far as informing userspace. */
-                        vboxadd_unregister_hgcm_connection_no_close(info.u32ClientID);
-                }
-                /* And disconnect the hgcm connection again, as we told userspace it failed. */
-                infoDisconnect.u32ClientID = info.u32ClientID;
-                vboxadd_cmc_call(vboxDev, VBOXGUEST_IOCTL_HGCM_DISCONNECT,
-                                  &infoDisconnect);
+        int rc = 0;
+
+        if (copy_from_user ((void *)&info, (void *)userspace_info,
+                            sizeof (info)) != 0) {
+            LogFunc (("VBOXGUEST_IOCTL_HGCM_CONNECT: can not get connection info\n"));
+            rc = -EFAULT;
+        }
+        info.u32ClientID = 0;
+        if (rc >= 0) {
+            int vrc = vboxadd_cmc_call(vboxDev, VBOXGUEST_IOCTL_HGCM_CONNECT,
+                                       &info);
+            rc = RT_FAILURE(vrc) ?   -RTErrConvertToErrno(vrc)
+                                   : -RTErrConvertToErrno(info.result);
+            if (rc < 0)
+                LogFunc(("hgcm connection failed.  internal ioctl result %Rrc, hgcm result %Rrc\n",
+                         vrc, info.result));
+        }
+        if (rc >= 0) {
+            /* Register that the connection is associated with this file pointer. */
+            LogFunc(("Connected, client ID %u\n", info.u32ClientID));
+            rc = vboxadd_register_hgcm_connection(info.u32ClientID, filp);
+            if (rc < 0)
+                LogFunc(("failed to register the HGCM connection\n"));
+        }
+        if (   rc >= 0
+            && copy_to_user ((void *)userspace_info, (void *)&info,
+                             sizeof(info)) != 0) {
+            LogFunc (("failed to return the connection structure\n"));
+            rc = -EFAULT;
+        }
+        if (rc < 0)
+            /* Unregister again, as we didn't get as far as informing userspace. */
+            vboxadd_unregister_hgcm_connection_no_close(info.u32ClientID);
+        if (rc < 0 && info.u32ClientID != 0) {
+            /* Disconnect the hgcm connection again, as we told userspace it failed. */
+            VBoxGuestHGCMDisconnectInfo infoDisconnect;
+            infoDisconnect.u32ClientID = info.u32ClientID;
+            vboxadd_cmc_call(vboxDev, VBOXGUEST_IOCTL_HGCM_DISCONNECT,
+                             &infoDisconnect);
         }
         return rc;
@@ -335 +341 @@
 static int vboxadd_hgcm_disconnect(struct file *filp, unsigned long userspace_info)
 {
+        int rc = 0, vrc = VINF_SUCCESS;
+
         VBoxGuestHGCMDisconnectInfo info;
-        if (0 != copy_from_user ((void *)&info, (void *)userspace_info, sizeof (info))) {
-                LogRelFunc (("VBOXGUEST_IOCTL_HGCM_DISCONNECT: can not get info\n"));
-                return -EFAULT;
-        }
-        LogRelFunc(("client ID %u\n", info.u32ClientID));
-        vboxadd_cmc_call(vboxDev, VBOXGUEST_IOCTL_HGCM_DISCONNECT, &info);
-        if (copy_to_user ((void *)userspace_info, (void *)&info, sizeof(info))) {
+        if (copy_from_user ((void *)&info, (void *)userspace_info,
+                            sizeof (info)) != 0) {
+            LogRelFunc (("VBOXGUEST_IOCTL_HGCM_DISCONNECT: can not get info\n"));
+            rc = -EFAULT;
+        }
+        if (rc >= 0) {
+            LogRelFunc(("client ID %u\n", info.u32ClientID));
+            vrc = vboxadd_cmc_call(vboxDev, VBOXGUEST_IOCTL_HGCM_DISCONNECT,
+                                   &info);
+            rc = -RTErrConvertToErrno(vrc);
+        }
+        if (   rc >= 0
+            && copy_to_user ((void *)userspace_info, (void *)&info,
+                             sizeof(info)) != 0) {
                 LogRelFunc (("VBOXGUEST_IOCTL_HGCM_DISCONNECT: failed to return the connection structure\n"));
-                return -EFAULT;
-        }
-        return 0;
+                rc = -EFAULT;
+        }
+        return rc;
+}
+
+/**
+ * IOCTL handler.  Make an HGCM call.
+ *
+ * @returns 0 on success, or a Linux kernel errno value
+ * @param  userspace_info userspace pointer to the hgcm connection information
+ *                        (VBoxGuestHGCMConnectInfo structure).  This will be
+ *                        updated on success.
+ * @param  u32Size        the size of the userspace structure
+ */
+static int vboxadd_hgcm_call(unsigned long userspace_info, uint32_t u32Size)
+{
+        VBoxGuestHGCMCallInfo *pInfo = NULL;
+        int rc = 0;
+        
+        pInfo = kmalloc(u32Size, GFP_KERNEL);
+        if (pInfo == NULL)
+                rc = -ENOMEM;
+        if (rc >= 0 &&
+            0 != copy_from_user ((void *)pInfo, (void *)userspace_info, u32Size)) {
+                LogRelFunc (("can not get info from user space\n"));
+                rc = -EFAULT;
+        }
+        if (rc >= 0 &&
+            sizeof(*pInfo) + pInfo->cParms * sizeof(HGCMFunctionParameter) != u32Size) {
+                LogRelFunc (("bad parameter size, structure says %d, ioctl says %d\n",
+                             sizeof(*pInfo) + pInfo->cParms * sizeof(HGCMFunctionParameter),
+                             u32Size));
+            rc = -EINVAL;
+        }
+        if (rc >= 0) {
+                int vrc;
+                LogRelFunc(("client ID %u\n", pInfo->u32ClientID));
+                vrc = vboxadd_cmc_call(vboxDev,
+                              VBOXGUEST_IOCTL_HGCM_CALL(u32Size), pInfo);
+                rc = -RTErrConvertToErrno(vrc);
+                if (   rc >= 0
+                    && copy_to_user ((void *)userspace_info, (void *)pInfo,
+                                     u32Size)) {
+                        LogRelFunc (("failed to return the information to user space\n"));
+                        rc = -EFAULT;
+                }
+        }
+        if (pInfo != NULL)
+            kfree(pInfo);
+        return rc;
+}
+
+/**
+ * IOCTL handler.  Make an HGCM call with timeout.
+ *
+ * @returns 0 on success, or a Linux kernel errno value
+ * @param  userspace_info userspace pointer to the hgcm connection information
+ *                        (VBoxGuestHGCMConnectInfo structure).  This will be
+ *                        updated on success.
+ * @param  u32Size        the size of the userspace structure
+ */
+static int vboxadd_hgcm_call_timeout(unsigned long userspace_info,
+                                     uint32_t u32Size)
+{
+        VBoxGuestHGCMCallInfoTimeout *pInfo = NULL;
+        int rc = 0;
+        
+        pInfo = kmalloc(u32Size, GFP_KERNEL);
+        if (pInfo == NULL)
+                rc = -ENOMEM;
+        if (rc >= 0 &&
+            0 != copy_from_user ((void *)pInfo, (void *)userspace_info, u32Size)) {
+                LogRelFunc (("can not get info from user space\n"));
+                rc = -EFAULT;
+        }
+        if (rc >= 0 &&
+            sizeof(*pInfo) + pInfo->info.cParms * sizeof(HGCMFunctionParameter) != u32Size) {
+                LogRelFunc (("bad parameter size, structure says %d, ioctl says %d\n",
+                             sizeof(*pInfo) + pInfo->info.cParms * sizeof(HGCMFunctionParameter),
+                             u32Size));
+            rc = -EINVAL;
+        }
+        if (rc >= 0) {
+                int vrc;
+                LogRelFunc(("client ID %u\n", pInfo->info.u32ClientID));
+                vrc = vboxadd_cmc_call(vboxDev,
+                              VBOXGUEST_IOCTL_HGCM_CALL_TIMEOUT(u32Size), pInfo);
+                rc = -RTErrConvertToErrno(vrc);
+                if (   rc >= 0
+                    && copy_to_user ((void *)userspace_info, (void *)pInfo,
+                                     u32Size)) {
+                        LogRelFunc (("failed to return the information to user space\n"));
+                        rc = -EFAULT;
+                }
+        }
+        if (pInfo != NULL)
+            kfree(pInfo);
+        return rc;
 }
 
@@ -509 +619 @@
                  == VBOXGUEST_IOCTL_STRIP_SIZE(cmd))
         {
-        /* This IOCTL allows the guest to make an HGCM call from user space.  The
-           OS-independant part of the Guest Additions already contain code for making an
-           HGCM call from the guest, but this code assumes that the call is made from the
-           kernel's address space.  So before calling it, we have to copy all parameters
-           to the HGCM call from user space to kernel space and reconstruct the structures
-           passed to the call (which include pointers to other memory) inside the kernel's
-           address space. */
+        /* Do the HGCM call using the Vbgl bits */
                 IOCTL_ENTRY("VBOXGUEST_IOCTL_HGCM_CALL", arg);
-                rc = vbox_ioctl_hgcm_call(arg, vboxDev);
+                rc = vboxadd_hgcm_call(arg, _IOC_SIZE(cmd));
                 IOCTL_EXIT("VBOXGUEST_IOCTL_HGCM_CALL", arg);
+        }
+        else if (   VBOXGUEST_IOCTL_STRIP_SIZE(VBOXGUEST_IOCTL_HGCM_CALL_TIMEOUT(0))
+                 == VBOXGUEST_IOCTL_STRIP_SIZE(cmd))
+        {
+        /* Do the HGCM call using the Vbgl bits */
+                IOCTL_ENTRY("VBOXGUEST_IOCTL_HGCM_CALL_TIMEOUT", arg);
+                rc = vboxadd_hgcm_call_timeout(arg, _IOC_SIZE(cmd));
+                IOCTL_EXIT("VBOXGUEST_IOCTL_HGCM_CALL_TIMEOUT", arg);
         }
         else

trunk/src/VBox/Additions/linux/module/vboxmod.h

@@ -77 +77 @@
 DECLVBGL (int) vboxadd_cmc_call (void *opaque, uint32_t func, void *data);
 
+#if 0
 /**
  * This IOCTL wrapper allows the guest to make an HGCM call from user space.  The
@@ -91 +92 @@
 extern int vbox_ioctl_hgcm_call(unsigned long arg, VBoxDevice *vboxDev);
 
+/**
+ * This call is similar to vbox_ioctl_hgcm_call, but for the _TIMEOUT variant
+ * of the ioctl.
+ *
+ * @returns   0 on success or Linux error code on failure
+ * @param arg      User space pointer to the call data structure
+ */
+extern int vbox_ioctl_hgcm_call_timeout(unsigned long arg, VBoxDevice *vboxDev);
+#endif
+
 #endif /* !VBOXMOD_H */