Changeset 40304 in vbox for trunk/src/VBox/Runtime/r0drv

Timestamp:

Feb 29, 2012 8:02:14 PM (13 years ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

76552

Message:

IPRT: fixed OS/2 'bitrot'.

Location:

trunk/src/VBox/Runtime/r0drv/os2

Files:

• memuserkernel-r0drv-os2.cpp (modified) (1 diff)
• semevent-r0drv-os2.cpp (modified) (6 diffs)
• semeventmulti-r0drv-os2.cpp (modified) (6 diffs)

trunk/src/VBox/Runtime/r0drv/os2/memuserkernel-r0drv-os2.cpp

@@ -46 +46 @@
 RTR0DECL(int) RTR0MemUserCopyTo(RTR3PTR R3PtrDst, void const *pvSrc, size_t cb)
 {
-    int rc = KernCopyOut((void *)R3PtrDst, pvSrc, cb);
+    int rc = KernCopyOut((void *)R3PtrDst, (void *)pvSrc, cb);
     if (RT_LIKELY(rc == 0))
         return VINF_SUCCESS;

trunk/src/VBox/Runtime/r0drv/os2/semevent-r0drv-os2.cpp

@@ -34 +34 @@
 *******************************************************************************/
 #include "the-os2-kernel.h"
+#include "internal/iprt.h"
 
 #include <iprt/semaphore.h>
-#include <iprt/alloc.h>
 #include <iprt/asm.h>
 #include <iprt/assert.h>
 #include <iprt/err.h>
+#include <iprt/mem.h>
+#include <iprt/lockvalidator.h>
 
 #include "internal/magics.h"
@@ -155 +157 @@
 
 
-static int rtSemEventWait(RTSEMEVENT hEventSem, RTMSINTERVAL cMillies, bool fInterruptible)
-{
-    PRTSEMEVENTINTERNAL pThis = (PRTSEMEVENTINTERNAL)hEventSem;
+/**
+ * Worker for RTSemEventWaitEx and RTSemEventWaitExDebug.
+ *
+ * @returns VBox status code.
+ * @param   pThis           The event semaphore.
+ * @param   fFlags          See RTSemEventWaitEx.
+ * @param   uTimeout        See RTSemEventWaitEx.
+ * @param   pSrcPos         The source code position of the wait.
+ */
+static int rtR0SemEventOs2Wait(PRTSEMEVENTINTERNAL pThis, uint32_t fFlags, uint64_t uTimeout,
+                               PCRTLOCKVALSRCPOS pSrcPos)
+{
+    /*
+     * Validate and convert input.
+     */
+    if (!pThis)
+        return VERR_INVALID_HANDLE;
     AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
     AssertMsgReturn(pThis->u32Magic == RTSEMEVENT_MAGIC, ("u32Magic=%RX32 pThis=%p\n", pThis->u32Magic, pThis), VERR_INVALID_HANDLE);
-
+    AssertReturn(RTSEMWAIT_FLAGS_ARE_VALID(fFlags), VERR_INVALID_PARAMETER);
+
+    ULONG cMsTimeout = rtR0SemWaitOs2ConvertTimeout(fFlags, uTimeout);
+    ULONG fBlock     = BLOCK_SPINLOCK;
+    if (!(fFlags & RTSEMWAIT_FLAGS_INTERRUPTIBLE))
+        fBlock |= BLOCK_UNINTERRUPTABLE;
+        
+    /* 
+     * Do the job.
+     */
     KernAcquireSpinLock(&pThis->Spinlock);
 
@@ -175 +200 @@
 
         ULONG ulData = (ULONG)VERR_INTERNAL_ERROR;
-        rc = KernBlock((ULONG)pThis,
-                       cMillies == RT_INDEFINITE_WAIT ? SEM_INDEFINITE_WAIT : cMillies,
-                       BLOCK_SPINLOCK | (!fInterruptible ? BLOCK_UNINTERRUPTABLE : 0),
+        rc = KernBlock((ULONG)pThis, cMsTimeout, fBlock,
                        &pThis->Spinlock,
                        &ulData);
@@ -199 +222 @@
 
             case ERROR_TIMEOUT:
-                Assert(cMillies != RT_INDEFINITE_WAIT);
+                Assert(cMsTimeout != SEM_INDEFINITE_WAIT);
                 ASMAtomicDecU32(&pThis->cWaiters);
                 rc = VERR_TIMEOUT;
@@ -205 +228 @@
 
             case ERROR_INTERRUPT:
-                Assert(fInterruptible);
+                Assert(fFlags & RTSEMWAIT_FLAGS_INTERRUPTIBLE);
                 ASMAtomicDecU32(&pThis->cWaiters);
                 rc = VERR_INTERRUPTED;
@@ -222 +245 @@
 
 
-RTDECL(int)  RTSemEventWait(RTSEMEVENT hEventSem, RTMSINTERVAL cMillies)
-{
-    return rtSemEventWait(hEventSem, cMillies, false /* not interruptible */);
-}
-
-
-RTDECL(int)  RTSemEventWaitNoResume(RTSEMEVENT hEventSem, RTMSINTERVAL cMillies)
-{
-    return rtSemEventWait(hEventSem, cMillies, true /* interruptible */);
+RTDECL(int)  RTSemEventWaitEx(RTSEMEVENT hEventSem, uint32_t fFlags, uint64_t uTimeout)
+{
+#ifndef RTSEMEVENT_STRICT
+    return rtR0SemEventOs2Wait(hEventSem, fFlags, uTimeout, NULL);
+#else
+    RTLOCKVALSRCPOS SrcPos = RTLOCKVALSRCPOS_INIT_NORMAL_API();
+    return rtR0SemEventOs2Wait(hEventSem, fFlags, uTimeout, &SrcPos);
+#endif
+}
+
+
+RTDECL(int)  RTSemEventWaitExDebug(RTSEMEVENT hEventSem, uint32_t fFlags, uint64_t uTimeout,
+                                   RTHCUINTPTR uId, RT_SRC_POS_DECL)
+{
+    RTLOCKVALSRCPOS SrcPos = RTLOCKVALSRCPOS_INIT_DEBUG_API();
+    return rtR0SemEventOs2Wait(hEventSem, fFlags, uTimeout, &SrcPos);
 }
 

trunk/src/VBox/Runtime/r0drv/os2/semeventmulti-r0drv-os2.cpp

@@ -34 +34 @@
 *******************************************************************************/
 #include "the-os2-kernel.h"
+#include "internal/iprt.h"
 
 #include <iprt/semaphore.h>
-#include <iprt/alloc.h>
 #include <iprt/asm.h>
 #include <iprt/assert.h>
 #include <iprt/err.h>
+#include <iprt/lockvalidator.h>
+#include <iprt/mem.h>
 #include "internal/magics.h"
 
@@ -164 +166 @@
 
 
-static int rtSemEventMultiWait(RTSEMEVENTMULTI hEventMultiSem, RTMSINTERVAL cMillies, bool fInterruptible)
-{
-    PRTSEMEVENTMULTIINTERNAL pThis = (PRTSEMEVENTMULTIINTERNAL)hEventMultiSem;
+/**
+ * Worker for RTSemEventWaitEx and RTSemEventWaitExDebug.
+ *
+ * @returns VBox status code.
+ * @param   pThis           The event semaphore.
+ * @param   fFlags          See RTSemEventWaitEx.
+ * @param   uTimeout        See RTSemEventWaitEx.
+ * @param   pSrcPos         The source code position of the wait.
+ */
+static int rtR0SemEventMultiOs2Wait(PRTSEMEVENTMULTIINTERNAL pThis, uint32_t fFlags, uint64_t uTimeout,
+                                    PCRTLOCKVALSRCPOS pSrcPos)
+{
+    /*
+     * Validate and convert the input.
+     */
+    if (!pThis)
+        return VERR_INVALID_HANDLE;
     AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
     AssertMsgReturn(pThis->u32Magic == RTSEMEVENTMULTI_MAGIC,
                     ("pThis=%p u32Magic=%#x\n", pThis, pThis->u32Magic),
                     VERR_INVALID_HANDLE);
-
+    AssertReturn(RTSEMWAIT_FLAGS_ARE_VALID(fFlags), VERR_INVALID_PARAMETER);
+
+    ULONG cMsTimeout = rtR0SemWaitOs2ConvertTimeout(fFlags, uTimeout);
+    ULONG fBlock     = BLOCK_SPINLOCK;
+    if (!(fFlags & RTSEMWAIT_FLAGS_INTERRUPTIBLE))
+        fBlock |= BLOCK_UNINTERRUPTABLE;
+        
+    /* 
+     * Do the job.
+     */
     KernAcquireSpinLock(&pThis->Spinlock);
 
@@ -182 +207 @@
 
         ULONG ulData = (ULONG)VERR_INTERNAL_ERROR;
-        rc = KernBlock((ULONG)pThis,
-                       cMillies == RT_INDEFINITE_WAIT ? SEM_INDEFINITE_WAIT : cMillies,
-                       BLOCK_SPINLOCK | (!fInterruptible ? BLOCK_UNINTERRUPTABLE : 0),
+        rc = KernBlock((ULONG)pThis, cMsTimeout, fBlock,
                        &pThis->Spinlock,
                        &ulData);
@@ -207 +230 @@
 
             case ERROR_TIMEOUT:
-                Assert(cMillies != RT_INDEFINITE_WAIT);
+                Assert(cMsTimeout != SEM_INDEFINITE_WAIT);
                 ASMAtomicDecU32(&pThis->cWaiters);
                 rc = VERR_TIMEOUT;
@@ -213 +236 @@
 
             case ERROR_INTERRUPT:
-                Assert(fInterruptible);
+                Assert(fFlags & RTSEMWAIT_FLAGS_INTERRUPTIBLE);
                 ASMAtomicDecU32(&pThis->cWaiters);
                 rc = VERR_INTERRUPTED;
@@ -230 +253 @@
 
 
-RTDECL(int)  RTSemEventMultiWait(RTSEMEVENTMULTI hEventMultiSem, RTMSINTERVAL cMillies)
-{
-    return rtSemEventMultiWait(hEventMultiSem, cMillies, false /* not interruptible */);
-}
-
-
-RTDECL(int)  RTSemEventMultiWaitNoResume(RTSEMEVENTMULTI hEventMultiSem, RTMSINTERVAL cMillies)
-{
-    return rtSemEventMultiWait(hEventMultiSem, cMillies, true /* interruptible */);
+RTDECL(int)  RTSemEventMultiWaitEx(RTSEMEVENTMULTI hEventMultiSem, uint32_t fFlags, uint64_t uTimeout)
+{
+#ifndef RTSEMEVENT_STRICT
+    return rtR0SemEventMultiOs2Wait(hEventMultiSem, fFlags, uTimeout, NULL);
+#else
+    RTLOCKVALSRCPOS SrcPos = RTLOCKVALSRCPOS_INIT_NORMAL_API();
+    return rtR0SemEventMultiOs2Wait(hEventMultiSem, fFlags, uTimeout, &SrcPos);
+#endif
+}
+
+
+RTDECL(int)  RTSemEventMultiWaitExDebug(RTSEMEVENTMULTI hEventMultiSem, uint32_t fFlags, uint64_t uTimeout,
+                                        RTHCUINTPTR uId, RT_SRC_POS_DECL)
+{
+    RTLOCKVALSRCPOS SrcPos = RTLOCKVALSRCPOS_INIT_DEBUG_API();
+    return rtR0SemEventMultiOs2Wait(hEventMultiSem, fFlags, uTimeout, &SrcPos);
 }