Index: trunk/src/VBox/Additions/common/VBoxGuest/VBoxGuest.cpp
===================================================================
--- trunk/src/VBox/Additions/common/VBoxGuest/VBoxGuest.cpp	(revision 32443)
+++ trunk/src/VBox/Additions/common/VBoxGuest/VBoxGuest.cpp	(revision 32449)
@@ -682,12 +682,13 @@
     pDevExt->pIrqAckEvents = NULL;
     pDevExt->PhysIrqAckEvents = NIL_RTCCPHYS;
-    pDevExt->WaitList.pHead = NULL;
-    pDevExt->WaitList.pTail = NULL;
+    RTListInit(&pDevExt->WaitList);
 #ifdef VBOX_WITH_HGCM
-    pDevExt->HGCMWaitList.pHead = NULL;
-    pDevExt->HGCMWaitList.pTail = NULL;
+    RTListInit(&pDevExt->HGCMWaitList);
 #endif
-    pDevExt->FreeList.pHead = NULL;
-    pDevExt->FreeList.pTail = NULL;
+#ifdef VBOXGUEST_USE_DEFERRED_WAKE_UP
+    RTListInit(&pDevExt->WakeUpList);
+#endif
+    RTListInit(&pDevExt->WokenUpList);
+    RTListInit(&pDevExt->FreeList);
     pDevExt->f32PendingEvents = 0;
     pDevExt->u32MousePosChangedSeq = 0;
@@ -807,16 +808,14 @@
 /**
  * Deletes all the items in a wait chain.
- * @param   pWait       The head of the chain.
- */
-static void VBoxGuestDeleteWaitList(PVBOXGUESTWAITLIST pList)
-{
-    while (pList->pHead)
+ * @param   pList       The head of the chain.
+ */
+static void VBoxGuestDeleteWaitList(PRTLISTNODE pList)
+{
+    while (!RTListIsEmpty(pList))
     {
         int             rc2;
-        PVBOXGUESTWAIT  pWait = pList->pHead;
-        pList->pHead = pWait->pNext;
-
-        pWait->pNext = NULL;
-        pWait->pPrev = NULL;
+        PVBOXGUESTWAIT  pWait = RTListNodeGetFirst(pList, VBOXGUESTWAIT, ListNode);
+        RTListNodeRemove(&pWait->ListNode);
+
         rc2 = RTSemEventMultiDestroy(pWait->Event); AssertRC(rc2);
         pWait->Event = NIL_RTSEMEVENTMULTI;
@@ -824,6 +823,4 @@
         RTMemFree(pWait);
     }
-    pList->pHead = NULL;
-    pList->pTail = NULL;
 }
 
@@ -862,4 +859,8 @@
     VBoxGuestDeleteWaitList(&pDevExt->HGCMWaitList);
 #endif
+#ifdef VBOXGUEST_USE_DEFERRED_WAKE_UP
+    VBoxGuestDeleteWaitList(&pDevExt->WakeUpList);
+#endif
+    VBoxGuestDeleteWaitList(&pDevExt->WokenUpList);
     VBoxGuestDeleteWaitList(&pDevExt->FreeList);
 
@@ -968,45 +969,5 @@
 
 /**
- * Links the wait-for-event entry into the tail of the given list.
- *
- * @param   pList           The list to link it into.
- * @param   pWait           The wait for event entry to append.
- */
-DECLINLINE(void) VBoxGuestWaitAppend(PVBOXGUESTWAITLIST pList, PVBOXGUESTWAIT pWait)
-{
-    const PVBOXGUESTWAIT pTail = pList->pTail;
-    pWait->pNext = NULL;
-    pWait->pPrev = pTail;
-    if (pTail)
-        pTail->pNext = pWait;
-    else
-        pList->pHead = pWait;
-    pList->pTail = pWait;
-}
-
-
-/**
- * Unlinks the wait-for-event entry.
- *
- * @param   pList           The list to unlink it from.
- * @param   pWait           The wait for event entry to unlink.
- */
-DECLINLINE(void) VBoxGuestWaitUnlink(PVBOXGUESTWAITLIST pList, PVBOXGUESTWAIT pWait)
-{
-    const PVBOXGUESTWAIT pPrev = pWait->pPrev;
-    const PVBOXGUESTWAIT pNext = pWait->pNext;
-    if (pNext)
-        pNext->pPrev = pPrev;
-    else
-        pList->pTail = pPrev;
-    if (pPrev)
-        pPrev->pNext = pNext;
-    else
-        pList->pHead = pNext;
-}
-
-
-/**
- * Allocates a wiat-for-event entry.
+ * Allocates a wait-for-event entry.
  *
  * @returns The wait-for-event entry.
@@ -1019,5 +980,5 @@
      * Allocate it one way or the other.
      */
-    PVBOXGUESTWAIT pWait = pDevExt->FreeList.pTail;
+    PVBOXGUESTWAIT pWait = RTListNodeGetFirst(&pDevExt->FreeList, VBOXGUESTWAIT, ListNode);
     if (pWait)
     {
@@ -1025,7 +986,7 @@
         RTSpinlockAcquireNoInts(pDevExt->EventSpinlock, &Tmp);
 
-        pWait = pDevExt->FreeList.pTail;
+        pWait = RTListNodeGetFirst(&pDevExt->FreeList, VBOXGUESTWAIT, ListNode);
         if (pWait)
-            VBoxGuestWaitUnlink(&pDevExt->FreeList, pWait);
+            RTListNodeRemove(&pWait->ListNode);
 
         RTSpinlockReleaseNoInts(pDevExt->EventSpinlock, &Tmp);
@@ -1052,4 +1013,7 @@
             return NULL;
         }
+
+        pWait->ListNode.pNext = NULL;
+        pWait->ListNode.pPrev = NULL;
     }
 
@@ -1057,8 +1021,10 @@
      * Zero members just as an precaution.
      */
-    pWait->pNext = NULL;
-    pWait->pPrev = NULL;
     pWait->fReqEvents = 0;
     pWait->fResEvents = 0;
+#ifdef VBOXGUEST_USE_DEFERRED_WAKE_UP
+    pWait->fPendingWakeUp = false;
+    pWait->fFreeMe = false;
+#endif
     pWait->pSession = pSession;
 #ifdef VBOX_WITH_HGCM
@@ -1072,5 +1038,7 @@
 /**
  * Frees the wait-for-event entry.
- * The caller must own the wait spinlock!
+ *
+ * The caller must own the wait spinlock !
+ * The entry must be in a list!
  *
  * @param   pDevExt         The device extension.
@@ -1084,5 +1052,14 @@
     pWait->pHGCMReq = NULL;
 #endif
-    VBoxGuestWaitAppend(&pDevExt->FreeList, pWait);
+#ifdef VBOXGUEST_USE_DEFERRED_WAKE_UP
+    Assert(!pWait->fFreeMe);
+    if (pWait->fPendingWakeUp)
+        pWait->fFreeMe = true;
+    else
+#endif
+    {
+        RTListNodeRemove(&pWait->ListNode);
+        RTListAppend(&pDevExt->FreeList, &pWait->ListNode);
+    }
 }
 
@@ -1101,4 +1078,50 @@
     RTSpinlockReleaseNoInts(pDevExt->EventSpinlock, &Tmp);
 }
+
+
+#ifdef VBOXGUEST_USE_DEFERRED_WAKE_UP
+/**
+ * Processes the wake-up list.
+ *
+ * All entries in the wake-up list gets signalled and moved to the woken-up
+ * list.
+ *
+ * @param   pDevExt         The device extension.
+ */
+void VBoxGuestWaitDoWakeUps(PVBOXGUESTDEVEXT pDevExt)
+{
+    if (!RTListIsEmpty(&pDevExt->WakeUpList))
+    {
+        RTSPINLOCKTMP Tmp = RTSPINLOCKTMP_INITIALIZER;
+        RTSpinlockAcquireNoInts(pDevExt->EventSpinlock, &Tmp);
+        for (;;)
+        {
+            int            rc;
+            PVBOXGUESTWAIT pWait = RTListNodeGetFirst(&pDevExt->WakeUpList, VBOXGUESTWAIT, ListNode);
+            if (!pWait)
+                break;
+            pWait->fPendingWakeUp = true;
+            RTSpinlockReleaseNoInts(pDevExt->EventSpinlock, &Tmp);
+
+            rc = RTSemEventMultiSignal(pWait->Event);
+            AssertRC(rc);
+
+            RTSpinlockAcquireNoInts(pDevExt->EventSpinlock, &Tmp);
+            pWait->fPendingWakeUp = false;
+            if (!pWait->fFreeMe)
+            {
+                RTListNodeRemove(&pWait->ListNode);
+                RTListAppend(&pDevExt->WokenUpList, &pWait->ListNode);
+            }
+            else
+            {
+                pWait->fFreeMe = false;
+                VBoxGuestWaitFreeLocked(pDevExt, pWait);
+            }
+        }
+        RTSpinlockReleaseNoInts(pDevExt->EventSpinlock, &Tmp);
+    }
+}
+#endif /* VBOXGUEST_USE_DEFERRED_WAKE_UP */
 
 
@@ -1177,5 +1200,6 @@
 /**
  * Worker VBoxGuestCommonIOCtl_WaitEvent.
- * The caller enters the spinlock, we may or may not leave it.
+ *
+ * The caller enters the spinlock, we leave it.
  *
  * @returns VINF_SUCCESS if we've left the spinlock and can return immediately.
@@ -1198,4 +1222,5 @@
         return VINF_SUCCESS;
     }
+    RTSpinlockReleaseNoInts(pDevExt->EventSpinlock, pTmp);
     return VERR_TIMEOUT;
 }
@@ -1234,5 +1259,4 @@
     if (rc == VINF_SUCCESS)
         return rc;
-    RTSpinlockReleaseNoInts(pDevExt->EventSpinlock, &Tmp);
 
     if (!pInfo->u32TimeoutIn)
@@ -1254,4 +1278,5 @@
      */
     RTSpinlockAcquireNoInts(pDevExt->EventSpinlock, &Tmp);
+    RTListAppend(&pDevExt->WaitList, &pWait->ListNode);
     rc = WaitEventCheckCondition(pDevExt, pInfo, iEvent, fReqEvents, &Tmp);
     if (rc == VINF_SUCCESS)
@@ -1260,6 +1285,4 @@
         return rc;
     }
-    VBoxGuestWaitAppend(&pDevExt->WaitList, pWait);
-    RTSpinlockReleaseNoInts(pDevExt->EventSpinlock, &Tmp);
 
     if (fInterruptible)
@@ -1282,5 +1305,4 @@
      */
     RTSpinlockAcquireNoInts(pDevExt->EventSpinlock, &Tmp);
-    VBoxGuestWaitUnlink(&pDevExt->WaitList, pWait);
     fResEvents = pWait->fResEvents;
     VBoxGuestWaitFreeLocked(pDevExt, pWait);
@@ -1333,51 +1355,34 @@
 {
     RTSPINLOCKTMP           Tmp   = RTSPINLOCKTMP_INITIALIZER;
-#if defined(RT_OS_SOLARIS)
-    RTTHREADPREEMPTSTATE    State = RTTHREADPREEMPTSTATE_INITIALIZER;
+    PVBOXGUESTWAIT          pWait;
+    PVBOXGUESTWAIT          pSafe;
+    int                     rc = 0;
+
+    Log(("VBoxGuestCommonIOCtl: CANCEL_ALL_WAITEVENTS\n"));
+
+    /*
+     * Walk the event list and wake up anyone with a matching session.
+     */
+    RTSpinlockAcquireNoInts(pDevExt->EventSpinlock, &Tmp);
+    RTListForEachSafe(&pDevExt->WaitList, pWait, pSafe, VBOXGUESTWAIT, ListNode)
+    {
+        if (pWait->pSession == pSession)
+        {
+            pWait->fResEvents = UINT32_MAX;
+            RTListNodeRemove(&pWait->ListNode);
+#ifdef VBOXGUEST_USE_DEFERRED_WAKE_UP
+            RTListAppend(&pDevExt->WakeUpList, &pWait->ListNode);
+#else
+            rc |= RTSemEventMultiSignal(pWait->Event);
+            RTListAppend(&pDevExt->WokenUpList, &pWait->ListNode);
 #endif
-    PVBOXGUESTWAIT          pWait;
-    int                     rc = 0;
-
-    Log(("VBoxGuestCommonIOCtl: CANCEL_ALL_WAITEVENTS\n"));
-
-    /*
-     * Walk the event list and wake up anyone with a matching session.
-     *
-     * Note! On Solaris we have to do really ugly stuff here because
-     *       RTSemEventMultiSignal cannot be called with interrupts disabled.
-     *       The hack is racy, but what we can we do... (Eliminate this
-     *       termination hack, perhaps?)
-     */
-#if defined(RT_OS_SOLARIS)
-    RTThreadPreemptDisable(&State);
-    RTSpinlockAcquireNoInts(pDevExt->EventSpinlock, &Tmp);
-    do
-    {
-        for (pWait = pDevExt->WaitList.pHead; pWait; pWait = pWait->pNext)
-            if (    pWait->pSession   == pSession
-                &&  pWait->fResEvents != UINT32_MAX)
-            {
-                RTSEMEVENTMULTI hEvent = pWait->Event;
-                pWait->fResEvents = UINT32_MAX;
-                RTSpinlockReleaseNoInts(pDevExt->EventSpinlock, &Tmp);
-                /* HACK ALRET! This races wakeup + reuse! */
-                rc |= RTSemEventMultiSignal(hEvent);
-                RTSpinlockAcquireNoInts(pDevExt->EventSpinlock, &Tmp);
-                break;
-            }
-    } while (pWait);
+        }
+    }
     RTSpinlockReleaseNoInts(pDevExt->EventSpinlock, &Tmp);
-    RTThreadPreemptDisable(&State);
-#else
-    RTSpinlockAcquireNoInts(pDevExt->EventSpinlock, &Tmp);
-    for (pWait = pDevExt->WaitList.pHead; pWait; pWait = pWait->pNext)
-        if (pWait->pSession == pSession)
-        {
-            pWait->fResEvents = UINT32_MAX;
-            rc |= RTSemEventMultiSignal(pWait->Event);
-        }
-    RTSpinlockReleaseNoInts(pDevExt->EventSpinlock, &Tmp);
+    Assert(rc == 0);
+
+#ifdef VBOXGUEST_USE_DEFERRED_WAKE_UP
+    VBoxGuestWaitDoWakeUps(pDevExt);
 #endif
-    Assert(rc == 0);
 
     return VINF_SUCCESS;
@@ -1530,4 +1535,5 @@
      */
     RTSpinlockAcquireNoInts(pDevExt->EventSpinlock, &Tmp);
+    RTListAppend(&pDevExt->HGCMWaitList, &pWait->ListNode);
     if ((pHdr->fu32Flags & VBOX_HGCM_REQ_DONE) != 0)
     {
@@ -1536,5 +1542,4 @@
         return VINF_SUCCESS;
     }
-    VBoxGuestWaitAppend(&pDevExt->HGCMWaitList, pWait);
     RTSpinlockReleaseNoInts(pDevExt->EventSpinlock, &Tmp);
 
@@ -1555,8 +1560,5 @@
         LogRel(("VBoxGuestHGCMAsyncWaitCallback: wait failed! %Rrc\n", rc));
 
-    RTSpinlockAcquireNoInts(pDevExt->EventSpinlock, &Tmp);
-    VBoxGuestWaitUnlink(&pDevExt->HGCMWaitList, pWait);
-    VBoxGuestWaitFreeLocked(pDevExt, pWait);
-    RTSpinlockReleaseNoInts(pDevExt->EventSpinlock, &Tmp);
+    VBoxGuestWaitFreeUnlocked(pDevExt, pWait);
     return rc;
 }
@@ -2261,14 +2263,6 @@
     /*
      * Enter the spinlock and check if it's our IRQ or not.
-     *
-     * Note! Solaris cannot do RTSemEventMultiSignal with interrupts disabled
-     *       so we're entering the spinlock without disabling them.  This works
-     *       fine as long as we never called in a nested fashion.
-     */
-#if defined(RT_OS_SOLARIS)
-    RTSpinlockAcquire(pDevExt->EventSpinlock, &Tmp);
-#else
+     */
     RTSpinlockAcquireNoInts(pDevExt->EventSpinlock, &Tmp);
-#endif
     fOurIrq = pDevExt->pVMMDevMemory->V.V1_04.fHaveEvents;
     if (fOurIrq)
@@ -2287,4 +2281,5 @@
             uint32_t        fEvents = pReq->events;
             PVBOXGUESTWAIT  pWait;
+            PVBOXGUESTWAIT  pSafe;
 
             Log(("VBoxGuestCommonISR: acknowledge events succeeded %#RX32\n", fEvents));
@@ -2305,11 +2300,18 @@
             if (fEvents & VMMDEV_EVENT_HGCM)
             {
-                for (pWait = pDevExt->HGCMWaitList.pHead; pWait; pWait = pWait->pNext)
-                    if (    !pWait->fResEvents
-                        &&  (pWait->pHGCMReq->fu32Flags & VBOX_HGCM_REQ_DONE))
+                RTListForEachSafe(&pDevExt->HGCMWaitList, pWait, pSafe, VBOXGUESTWAIT, ListNode)
+                {
+                    if (pWait->pHGCMReq->fu32Flags & VBOX_HGCM_REQ_DONE)
                     {
                         pWait->fResEvents = VMMDEV_EVENT_HGCM;
+                        RTListNodeRemove(&pWait->ListNode);
+# ifdef VBOXGUEST_USE_DEFERRED_WAKE_UP
+                        RTListAppend(&pDevExt->WakeUpList, &pWait->ListNode);
+# else
+                        RTListAppend(&pDevExt->WokenUpList, &pWait->ListNode);
                         rc |= RTSemEventMultiSignal(pWait->Event);
+# endif
                     }
+                }
                 fEvents &= ~VMMDEV_EVENT_HGCM;
             }
@@ -2320,5 +2322,6 @@
              */
             fEvents |= pDevExt->f32PendingEvents;
-            for (pWait = pDevExt->WaitList.pHead; pWait; pWait = pWait->pNext)
+            RTListForEachSafe(&pDevExt->HGCMWaitList, pWait, pSafe, VBOXGUESTWAIT, ListNode)
+            {
                 if (    (pWait->fReqEvents & fEvents)
                     &&  !pWait->fResEvents)
@@ -2326,8 +2329,15 @@
                     pWait->fResEvents = pWait->fReqEvents & fEvents;
                     fEvents &= ~pWait->fResEvents;
+                    RTListNodeRemove(&pWait->ListNode);
+#ifdef VBOXGUEST_USE_DEFERRED_WAKE_UP
+                    RTListAppend(&pDevExt->WakeUpList, &pWait->ListNode);
+#else
+                    RTListAppend(&pDevExt->WokenUpList, &pWait->ListNode);
                     rc |= RTSemEventMultiSignal(pWait->Event);
+#endif
                     if (!fEvents)
                         break;
                 }
+            }
             ASMAtomicWriteU32(&pDevExt->f32PendingEvents, fEvents);
         }
@@ -2339,14 +2349,19 @@
         LogFlow(("VBoxGuestCommonISR: not ours\n"));
 
+    RTSpinlockReleaseNoInts(pDevExt->EventSpinlock, &Tmp);
+
+#if defined(VBOXGUEST_USE_DEFERRED_WAKE_UP) && !defined(RT_OS_WINDOWS)
+    /*
+     * Do wake-ups.
+     * Note. On Windows this isn't possible at this IRQL, so a DPC will take
+     *       care of it.
+     */
+    VBoxGuestWaitDoWakeUps(pDevExt);
+#endif
+
     /*
      * Work the poll and async notification queues on OSes that implements that.
-     * Do this outside the spinlock to prevent some recursive spinlocking.
-     */
-#if defined(RT_OS_SOLARIS)
-    RTSpinlockRelease(pDevExt->EventSpinlock, &Tmp);
-#else
-    RTSpinlockReleaseNoInts(pDevExt->EventSpinlock, &Tmp);
-#endif
-
+     * (Do this outside the spinlock to prevent some recursive spinlocking.)
+     */
     if (fMousePositionChanged)
     {
Index: trunk/src/VBox/Additions/common/VBoxGuest/VBoxGuestInternal.h
===================================================================
--- trunk/src/VBox/Additions/common/VBoxGuest/VBoxGuestInternal.h	(revision 32443)
+++ trunk/src/VBox/Additions/common/VBoxGuest/VBoxGuestInternal.h	(revision 32449)
@@ -20,4 +20,5 @@
 
 #include <iprt/types.h>
+#include <iprt/list.h>
 #include <iprt/semaphore.h>
 #include <iprt/spinlock.h>
@@ -26,4 +27,10 @@
 #include <VBox/VBoxGuestLib.h>
 
+/** @def VBOXGUEST_USE_WAKE_UP_LIST
+ * Defer wake-up of waiting thread when defined. */
+#if defined(RT_OS_SOLARIS) || defined(RT_OS_WINDOWS) || defined(DOXYGEN_RUNNING)
+# define VBOXGUEST_USE_DEFERRED_WAKE_UP
+#endif
+
 
 /** Pointer to the VBoxGuest per session data. */
@@ -41,14 +48,20 @@
 typedef struct VBOXGUESTWAIT
 {
-    /** The next entry in the list. */
-    PVBOXGUESTWAIT volatile     pNext;
-    /** The previous entry in the list. */
-    PVBOXGUESTWAIT volatile     pPrev;
-    /** The event semaphore. */
-    RTSEMEVENTMULTI             Event;
+    /** The list node. */
+    RTLISTNODE                  ListNode;
     /** The events we are waiting on. */
     uint32_t                    fReqEvents;
     /** The events we received. */
     uint32_t volatile           fResEvents;
+#ifdef VBOXGUEST_USE_DEFERRED_WAKE_UP
+    /** Set by VBoxGuestWaitDoWakeUps before leaving the spinlock to call
+     *  RTSemEventMultiSignal. */
+    bool volatile               fPendingWakeUp;
+    /** Set by the requestor thread if it got the spinlock before the
+     * signaller.  Deals with the race in VBoxGuestWaitDoWakeUps. */
+    bool volatile               fFreeMe;
+#endif
+    /** The event semaphore. */
+    RTSEMEVENTMULTI             Event;
     /** The session that's waiting. */
     PVBOXGUESTSESSION           pSession;
@@ -58,17 +71,4 @@
 #endif
 } VBOXGUESTWAIT;
-
-/**
- * VBox guest wait for event list.
- */
-typedef struct VBOXGUESTWAITLIST
-{
-    /** The head. */
-    PVBOXGUESTWAIT volatile     pHead;
-    /** The tail. */
-    PVBOXGUESTWAIT volatile     pTail;
-} VBOXGUESTWAITLIST;
-/** Pointer to a wait list. */
-typedef VBOXGUESTWAITLIST *PVBOXGUESTWAITLIST;
 
 
@@ -122,13 +122,19 @@
     RTCCPHYS                    PhysIrqAckEvents;
     /** Wait-for-event list for threads waiting for multiple events. */
-    VBOXGUESTWAITLIST           WaitList;
+    RTLISTNODE                  WaitList;
 #ifdef VBOX_WITH_HGCM
     /** Wait-for-event list for threads waiting on HGCM async completion.
      * The entire list is evaluated upon the arrival of an HGCM event, unlike
      * the other lists which are only evaluated till the first thread has been woken up. */
-    VBOXGUESTWAITLIST           HGCMWaitList;
-#endif
+    RTLISTNODE                  HGCMWaitList;
+#endif
+#ifdef VBOXGUEST_USE_DEFERRED_WAKE_UP
+    /** List of wait-for-event entries that needs waking up. */
+    RTLISTNODE                  WakeUpList;
+#endif
+    /** List of wait-for-event entries that has been woken up. */
+    RTLISTNODE                  WokenUpList;
     /** List of free wait-for-event entries. */
-    VBOXGUESTWAITLIST           FreeList;
+    RTLISTNODE                  FreeList;
     /** Mask of pending events. */
     uint32_t volatile           f32PendingEvents;
@@ -217,4 +223,7 @@
 int  VBoxGuestReinitDevExtAfterHibernation(PVBOXGUESTDEVEXT pDevExt, VBOXOSTYPE enmOSType);
 int  VBoxGuestSetGuestCapabilities(uint32_t fOr, uint32_t fNot);
+#ifdef VBOXGUEST_USE_DEFERRED_WAKE_UP
+void VBoxGuestWaitDoWakeUps(PVBOXGUESTDEVEXT pDevExt);
+#endif
 
 int  VBoxGuestCreateUserSession(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION *ppSession);
Index: trunk/src/VBox/Additions/common/VBoxGuest/freebsd/files_vboxguest
===================================================================
--- trunk/src/VBox/Additions/common/VBoxGuest/freebsd/files_vboxguest	(revision 32443)
+++ trunk/src/VBox/Additions/common/VBoxGuest/freebsd/files_vboxguest	(revision 32449)
@@ -32,4 +32,5 @@
     ${PATH_ROOT}/include/iprt/handletable.h=>include/iprt/handletable.h \
     ${PATH_ROOT}/include/iprt/initterm.h=>include/iprt/initterm.h \
+    ${PATH_ROOT}/include/iprt/list.h=>include/iprt/list.h \
     ${PATH_ROOT}/include/iprt/lockvalidator.h=>include/iprt/lockvalidator.h \
     ${PATH_ROOT}/include/iprt/log.h=>include/iprt/log.h \
Index: trunk/src/VBox/Additions/common/VBoxGuest/linux/files_vboxguest
===================================================================
--- trunk/src/VBox/Additions/common/VBoxGuest/linux/files_vboxguest	(revision 32443)
+++ trunk/src/VBox/Additions/common/VBoxGuest/linux/files_vboxguest	(revision 32449)
@@ -32,4 +32,5 @@
     ${PATH_ROOT}/include/iprt/heap.h=>include/iprt/heap.h \
     ${PATH_ROOT}/include/iprt/initterm.h=>include/iprt/initterm.h \
+    ${PATH_ROOT}/include/iprt/list.h=>include/iprt/list.h \
     ${PATH_ROOT}/include/iprt/lockvalidator.h=>include/iprt/lockvalidator.h \
     ${PATH_ROOT}/include/iprt/log.h=>include/iprt/log.h \
