Changeset 5817 in vbox for trunk/src/VBox/Additions/linux

Timestamp:

Nov 22, 2007 5:57:32 PM (17 years ago)

Author:

vboxsync

Message:

Additions (Linux): added support for waiting for host events from guest R3 and cleaned up the coding style in the kernel module slightly (to Linux kernel coding style)

Location:

trunk/src/VBox/Additions/linux/module

Files:

• vboxmod.c (modified) (10 diffs)
• vboxmod.h (modified) (1 diff)

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

@@ -33 +33 @@
 MODULE_VERSION(VBOX_VERSION_STRING);
 #endif
+
+/*****************************************************************************
+* Macros                                                                     *
+*****************************************************************************/
+
+/* We need to define these ones here as they only exist in kernels 2.6 and up */
+
+#define __vbox_wait_event_interruptible_timeout(wq, condition, timeout, ret)   \
+do {                                                                      \
+        int __ret = 0;                                                    \
+        if (!(condition)) {                                               \
+          wait_queue_t __wait;                                            \
+          unsigned long expire;                                           \
+          init_waitqueue_entry(&__wait, current);                         \
+                                                                          \
+          expire = timeout + jiffies;                                     \
+          add_wait_queue(&wq, &__wait);                                   \
+          for (;;) {                                                      \
+                  set_current_state(TASK_INTERRUPTIBLE);                  \
+                  if (condition)                                          \
+                          break;                                          \
+                  if (jiffies > expire) {                                 \
+                          ret = jiffies - expire;                         \
+                          break;                                          \
+                  }                                                       \
+                  if (!signal_pending(current)) {                         \
+                          schedule_timeout(timeout);                      \
+                          continue;                                       \
+                  }                                                       \
+                  ret = -ERESTARTSYS;                                     \
+                  break;                                                  \
+          }                                                               \
+          current->state = TASK_RUNNING;                                  \
+          remove_wait_queue(&wq, &__wait);                                \
+        }                                                                 \
+} while (0)
+
+/*
+   retval == 0; condition met; we're good.
+   retval < 0; interrupted by signal.
+   retval > 0; timed out.
+*/
+#define vbox_wait_event_interruptible_timeout(wq, condition, timeout)   \
+({                                                                      \
+        int __ret = 0;                                                  \
+        if (!(condition))                                               \
+                __vbox_wait_event_interruptible_timeout(wq, condition,  \
+                                                timeout, __ret);        \
+        __ret;                                                          \
+})
+
 
 /* This is called by our assert macros to find out whether we want
@@ -100 +151 @@
                 if (ASMAtomicCmpXchgU32(&hgcm_connections[i].client_id, client_id, 0)) {
                         hgcm_connections[i].filp = filp;
+#ifdef DEBUG
+                        LogRelFunc(("Registered client ID %d, file pointer %p at position %d in the table.\n",
+                                    client_id, filp, i));
+#endif
                         found = true;
                 }
@@ -120 +175 @@
         for (i = 0; (i < MAX_HGCM_CONNECTIONS) && (false == found); ++i) {
                 if (hgcm_connections[i].client_id == client_id) {
+#ifdef DEBUG
+                        LogRelFunc(("Unregistered client ID %d, file pointer %p at position %d in the table.\n",
+                                    client_id, hgcm_connections[i].filp, i));
+#endif
+                        hgcm_connections[i].filp = NULL;
                         hgcm_connections[i].client_id = 0;
                         found = true;
@@ -144 +204 @@
         for (i = 0; i < MAX_HGCM_CONNECTIONS; ++i) {
                 if (hgcm_connections[i].filp == filp) {
+                        VBoxGuestHGCMDisconnectInfo infoDisconnect;
+#ifdef DEBUG
+                        LogRelFunc(("Unregistered client ID %d, file pointer %p at position %d in the table.\n",
+                                    hgcm_connections[i].client_id, filp, i));
+#endif
+                        infoDisconnect.u32ClientID = hgcm_connections[i].client_id;
+                        vboxadd_cmc_call(vboxDev, IOCTL_VBOXGUEST_HGCM_DISCONNECT,
+                                         &infoDisconnect);
+                        hgcm_connections[i].filp = NULL;
                         hgcm_connections[i].client_id = 0;
                 }
@@ -171 +240 @@
 }
 
-/**
- * Wait for event
- *
- */
-static void
-vboxadd_wait_for_event_helper (VBoxDevice *dev, long timeout,
-                               uint32_t in_mask, uint32_t * out_mask)
-{
-    BUG ();
-}
-
 static void
 vboxadd_wait_for_event (VBoxGuestWaitEventInfo * info)
 {
-    long timeout;
-
-    timeout = msecs_to_jiffies (info->u32TimeoutIn);
-    vboxadd_wait_for_event_helper (vboxDev, timeout,
-                                   info->u32EventMaskIn,
-                                   &info->u32EventFlagsOut);
-}
-
+    long timeleft;
+    uint32_t cInterruptions = vboxDev->u32GuestInterruptions;
+    uint32_t in_mask = info->u32EventMaskIn;
+
+    info->u32Result = VBOXGUEST_WAITEVENT_OK;
+    timeleft = vbox_wait_event_interruptible_timeout
+                            (vboxDev->eventq,
+                                (vboxDev->u32Events & in_mask)
+                             || (vboxDev->u32GuestInterruptions != cInterruptions),
+                             msecs_to_jiffies (info->u32TimeoutIn));
+    if (vboxDev->u32GuestInterruptions != cInterruptions) {
+            info->u32Result = VBOXGUEST_WAITEVENT_INTERRUPTED;
+    }
+    if (timeleft < 0) {
+            info->u32Result = VBOXGUEST_WAITEVENT_INTERRUPTED;
+    }
+    if (timeleft == 0) {
+            info->u32Result = VBOXGUEST_WAITEVENT_TIMEOUT;
+    }
+    info->u32EventFlagsOut = vboxDev->u32Events & in_mask;
+    vboxDev->u32Events &= ~in_mask;
+}
+
+/**
+ * IOCtl handler - wait for an event from the host.
+ *
+ * @returns Linux kernel return code
+ * @param ptr User space pointer to a structure describing the event
+ */
+static int vboxadd_wait_event(void *ptr)
+{
+        int rc = 0;
+        VBoxGuestWaitEventInfo info;
+
+        if (copy_from_user (&info, ptr, sizeof (info))) {
+                LogRelFunc (("IOCTL_VBOXGUEST_WAITEVENT: can not get event info\n"));
+                rc = -EFAULT;
+        }
+
+        if (0 == rc) {
+                vboxadd_wait_for_event (&info);
+
+                if (copy_to_user (ptr, &info, sizeof (info))) {
+                        LogRelFunc (("IOCTL_VBOXGUEST_WAITEVENT: can not put out_mask\n"));
+                        rc = -EFAULT;
+                }
+        }
+        return 0;
+}
 
 /**
@@ -222 +321 @@
         } 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) {
@@ -251 +351 @@
                          unsigned int cmd, unsigned long arg)
 {
-    switch (cmd)
-    {
+        int rc = 0;
+
+        switch (cmd) {
         case IOCTL_VBOXGUEST_WAITEVENT:
-        {
-            VBoxGuestWaitEventInfo info;
-            char *ptr = (void *) arg;
-
-            if (copy_from_user (&info, ptr, sizeof (info)))
-            {
-                LogRelFunc (("IOCTL_VBOXGUEST_WAITEVENT: can not get event info\n"));
-                return -EFAULT;
-            }
-
-            vboxadd_wait_for_event (&info);
-
-            ptr += offsetof (VBoxGuestWaitEventInfo, u32EventFlagsOut);
-            if (put_user (info.u32EventFlagsOut, (uint32_t*)ptr))
-            {
-                LogRelFunc (("IOCTL_VBOXGUEST_WAITEVENT: can not put out_mask\n"));
-                return -EFAULT;
-            }
-            return 0;
-        }
-
-        case IOCTL_VBOXGUEST_VMMREQUEST:
-        {
+                rc = vboxadd_wait_event((void *) arg);
+                break;
+
+        case VBOXGUEST_IOCTL_WAITEVENT_INTERRUPT_ALL:
+                ++vboxDev->u32GuestInterruptions;
+                break;
+
+        case IOCTL_VBOXGUEST_VMMREQUEST: {
             VMMDevRequestHeader reqHeader;
             VMMDevRequestHeader *reqFull = NULL;
@@ -283 +369 @@
             int rc;
 
-            if (_IOC_SIZE(cmd) != sizeof(VMMDevRequestHeader))
-            {
-                LogRelFunc(("IOCTL_VBOXGUEST_VMMREQUEST: invalid VMM request structure size: %d\n",
-                         _IOC_SIZE(cmd)));
-                return -EINVAL;
-            }
+            AssertCompileSize(VMMDevRequestHeader, _IOC_SIZE(cmd));
             if (copy_from_user(&reqHeader, (void*)arg, _IOC_SIZE(cmd)))
             {
@@ -361 +442 @@
 
         case IOCTL_VBOXGUEST_HGCM_CALL:
-        {
         /* 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
@@ -369 +449 @@
            passed to the call (which include pointers to other memory) inside the kernel's
            address space. */
-                return vbox_ioctl_hgcm_call(arg, vboxDev);
-        }
+                rc = vbox_ioctl_hgcm_call(arg, vboxDev);
+                break;
 
         case IOCTL_VBOXGUEST_HGCM_CONNECT:
-        {
-                return vboxadd_hgcm_connect(filp, arg);
-        }
+                rc = vboxadd_hgcm_connect(filp, arg);
+                break;
 
         default:
-        {
-            LogRelFunc(("unknown command: %x\n", cmd));
-            return -EINVAL;
-        }
-    }
-    return 0;
+                LogRelFunc(("unknown command: %x\n", cmd));
+                rc = -EINVAL;
+                break;
+        }
+        return rc;
 }
 

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

@@ -51 +51 @@
     /** event synchronization */
     wait_queue_head_t eventq;
+    /** number of times the guest has interrupted the event loop -
+        implemented as a counter to prevent one waiter swallowing the
+        event. */
+    uint32_t u32GuestInterruptions;
 };