Changeset 2298 for trunk/src/emx/include/InnoTekLIBC/backend.h

Timestamp:

Aug 22, 2005, 2:14:50 AM (20 years ago)

Author:

bird

Message:

Tried to workaround the race conditions in libc_Back_safesemEvSleep/Wakeup.
These might affect SysV sems. (2nd try)

File:

• trunk/src/emx/include/InnoTekLIBC/backend.h (modified) (9 diffs, 1 prop)

trunk/src/emx/include/InnoTekLIBC/backend.h

@@ -967 +967 @@
  * @{ */
 
+/** 
+ * Safe Mutex Semaphore structure.
+ *
+ * For shared semaphores this structure must be in shared memory so all users 
+ * actually use the very same structure.
+ */
+typedef struct __LIBC_SAFESEMMTX
+{
+#ifdef __OS2__
+    /** Mutex handle. */
+    unsigned long hmtx;
+#endif 
+} __LIBC_SAFESEMMTX;
+/** Pointer to a SAFESEM Mutex structure. */
+typedef __LIBC_SAFESEMMTX *__LIBC_PSAFESEMMTX;
+
 /**
  * Creates a safe mutex sem.
@@ -972 +988 @@
  * @returns 0 on success.
  * @returns Negative error code (errno.h) on failure.
- * @param   phmtx       Where to store the semaphore handle.
+ * @param   pmtx        Pointer to the semaphore structure to initialize.
  * @param   fShared     Set if the semaphore should be sharable between processes.
  */
-int __libc_Back_safesemMtxCreate(uintptr_t *phmtx, int fShared);
+int __libc_Back_safesemMtxCreate(__LIBC_PSAFESEMMTX pmtx, int fShared);
 
 /**
@@ -982 +998 @@
  * @returns 0 on success.
  * @returns Negative error code (errno.h) on failure.
- * @param   hmtx        The semaphore handle.
- */
-int __libc_Back_safesemMtxOpen(uintptr_t hmtx);
+ * @param   pmtx        Pointer to the semaphore structure.
+ */
+int __libc_Back_safesemMtxOpen(__LIBC_PSAFESEMMTX pmtx);
 
 /**
@@ -991 +1007 @@
  * @returns 0 on success.
  * @returns Negative error code (errno.h) on failure.
- * @param   hmtx        The semaphore handle.
- */
-int __libc_Back_safesemMtxClose(uintptr_t hmtx);
+ * @param   pmtx        Pointer to the semaphore structure.
+ */
+int __libc_Back_safesemMtxClose(__LIBC_PSAFESEMMTX pmtx);
 
 /**
@@ -1000 +1016 @@
  * @returns 0 on success.
  * @returns Negative errno on failure.
- * @param   hmtx    Handle to the mutex.
- */
-int __libc_Back_safesemMtxLock(uintptr_t hmtx);
+ * @param   pmtx        Pointer to the semaphore structure.
+ */
+int __libc_Back_safesemMtxLock(__LIBC_PSAFESEMMTX pmtx);
 
 /**
@@ -1009 +1025 @@
  * @returns 0 on success.
  * @returns Negative errno on failure.
- * @param   hmtx    Handle to the mutex.
- */
-int __libc_Back_safesemMtxUnlock(uintptr_t hmtx);
+ * @param   pmtx        Pointer to the semaphore structure.
+ */
+int __libc_Back_safesemMtxUnlock(__LIBC_PSAFESEMMTX pmtx);
+
+
+/** 
+ * Safe Event Semaphore structure.
+ *
+ * For shared semaphores this structure must be in shared memory so all users 
+ * actually use the very same structure.
+ *
+ * @remark  The event semaphore business is difficult because the lack of 
+ *          atomic mutex release + event wait apis in OS/2. We have to 
+ *          jump around the place to get this working nearly safly...
+ */
+typedef struct __LIBC_SAFESEMEV
+{
+#ifdef __OS2__
+    /** The event semaphore. */
+    unsigned long       hev;
+#endif 
+    /** Number of threads which are supposed to be blocking on the above event semaphore. */
+    uint32_t volatile   cWaiters;
+    /** The mutex semaphore used to protect the event semaphore. */
+    __LIBC_PSAFESEMMTX  pmtx;
+    /** Set if the semaphore is shared. 
+     * If shared this structure is allocated from SPM, else it's from the heap. */
+    unsigned            fShared;
+} __LIBC_SAFESEMEV;
+/** Pointer to a SAFESEM Event structure. */
+typedef __LIBC_SAFESEMEV *__LIBC_PSAFESEMEV;
 
 /**
@@ -1018 +1062 @@
  * @returns 0 on success.
  * @returns Negative error code (errno.h) on failure.
- * @param   phev        Where to store the semaphore handle.
+ * @param   pev         Pointer to the semaphore structure to initialize.
+ * @param   pmtx        Pointer to the mutex semaphore which protects the event semaphore.
  * @param   fShared     Set if the semaphore should be sharable between processes.
  */
-int __libc_Back_safesemEvCreate(uintptr_t *phev, int fShared);
+int __libc_Back_safesemEvCreate(__LIBC_PSAFESEMEV pev, __LIBC_PSAFESEMMTX pmtx, int fShared);
 
 /**
  * Opens a shared safe event sem.
  *
- * @returns 0 on success.
- * @returns Negative error code (errno.h) on failure.
- * @param   hev         The semaphore handle.
- */
-int __libc_Back_safesemEvOpen(uintptr_t hev);
+ * The caller is responsible for opening the associated mutex 
+ * semaphore before calling this function.
+ *
+ * @returns 0 on success.
+ * @returns Negative error code (errno.h) on failure.
+ * @param   pev         Pointer to the semaphore structure to open.
+ */
+int __libc_Back_safesemEvOpen(__LIBC_PSAFESEMEV pev);
 
 /**
@@ -1037 +1085 @@
  * @returns 0 on success.
  * @returns Negative error code (errno.h) on failure.
- * @param   hev         The semaphore handle.
- */
-int __libc_Back_safesemEvClose(uintptr_t hev);
+ * @param   pev         Pointer to the semaphore structure to close.
+ */
+int __libc_Back_safesemEvClose(__LIBC_PSAFESEMEV pev);
 
 /**
  * Sleep on a semaphore.
  *
- * This is the most difficult thing we're doing in this file.
- *
- * @returns 0 on success.
- * @returns Negative error code (errno.h) on failure.
- *
- * @param   hev         The semaphore to sleep on.
- * @param   hmtx        The semaphore protecting hev and which is to be unlocked while
- *                      sleeping and reaquired upon waking up.
- * @param   pfnComplete Function to execute on signal and on wait completion.
+ * The caller must own the associated mutex semaphore. The mutex semaphore will 
+ * be released as we go to sleep and reclaimed when we wake up. 
+ *
+ * The pfnComplete callback is used to correct state before signals are handled. 
+ * It will always be called be for this function returns, and it'll either be under
+ * the protection of the signal mutex or the associated mutex (both safe sems).
+ *
+ * This is the most difficult thing we're doing in this API. On OS/2 we have 
+ * potential (at least theoretically) race conditions...
+ *
+ * @returns 0 on success.
+ * @returns Negative error code (errno.h) on failure.
+ *
+ * @param   pev         Pointer to the semaphore structure to sleep on.
+ * @param   pfnComplete Function to execute on signal or on wait completion.
  * @param   pvUser      User argument to pfnComplete.
  */
-int __libc_Back_safesemEvSleep(uintptr_t hev, uintptr_t hmtx, void (*pfnComplete)(void *pvUser), void *pvUser);
+int __libc_Back_safesemEvSleep(__LIBC_PSAFESEMEV pev, void (*pfnComplete)(void *pvUser), void *pvUser);
 
 /**
@@ -1062 +1116 @@
  * @returns 0 on success.
  * @returns Negative error code (errno.h) on failure.
- * @param   hev         Event semaphore to post.
- * @param   hmtx        The semaphore protecting hev (see __libc_Back_safesemEvSleep).
- *                      The caller should own this semaphore, it's purpose is debug strictness only!
- */
-int __libc_Back_safesemEvWakeup(uintptr_t hev, uintptr_t hmtx);
+ * @param   pev         Pointer to the semaphore structure to post.
+ */
+int __libc_Back_safesemEvWakeup(__LIBC_PSAFESEMEV pev);