Changeset 6049 for trunk/src/kernel32/HandleManager.cpp

Timestamp:

Jun 19, 2001, 12:50:26 PM (24 years ago)

Author:

sandervl

Message:

semaphore rewrite (not activated)

File:

• trunk/src/kernel32/HandleManager.cpp (modified) (5 diffs)

trunk/src/kernel32/HandleManager.cpp

@@ -1 @@
-/* $Id: HandleManager.cpp,v 1.64 2001-05-24 08:19:17 sandervl Exp $ */
+/* $Id: HandleManager.cpp,v 1.65 2001-06-19 10:50:23 sandervl Exp $ */
 
 /*
@@ -2223 +2223 @@
 
 
+  if(lpName) { //check if shared event semaphore already exists
+      //TODO: No inheritance??
+      HANDLE handle = HMOpenEvent(EVENT_ALL_ACCESS, FALSE, lpName);
+      if(handle) {
+          dprintf(("CreateEvent: return handle of existing event semaphore %x", handle));
+          return handle;
+      }
+  }
+
   pDeviceHandler = HMGlobals.pHMEvent;               /* device is predefined */
+
+  iIndexNew = _HMHandleGetFree();                         /* get free handle */
+  if (-1 == iIndexNew)                            /* oops, no free handles ! */
+  {
+    SetLastError(ERROR_NOT_ENOUGH_MEMORY);      /* use this as error message */
+    return 0;                           /* signal error */
+  }
+
+  /* Initialize the complete HMHANDLEDATA structure */
+  pHMHandleData = &TabWin32Handles[iIndexNew].hmHandleData;
+  pHMHandleData->dwType     = FILE_TYPE_UNKNOWN;      /* unknown handle type */
+  pHMHandleData->dwAccess   = 0;
+  pHMHandleData->dwShare    = 0;
+  pHMHandleData->dwCreation = 0;
+  pHMHandleData->dwFlags    = 0;    
+  pHMHandleData->lpHandlerData = NULL;
+
+  /* we've got to mark the handle as occupied here, since another device */
+  /* could be created within the device handler -> deadlock */
+
+  /* write appropriate entry into the handle table if open succeeded */
+  TabWin32Handles[iIndexNew].hmHandleData.hHMHandle = iIndexNew;
+  TabWin32Handles[iIndexNew].pDeviceHandler         = pDeviceHandler;
+
+  /* call the device handler */
+  rc = pDeviceHandler->CreateEvent(&TabWin32Handles[iIndexNew].hmHandleData,
+                                   lpsa,
+                                   bManualReset,
+                                   bInitialState,
+                                   lpName);
+  if (rc != NO_ERROR)     /* oops, creation failed within the device handler */
+  {
+    TabWin32Handles[iIndexNew].hmHandleData.hHMHandle = INVALID_HANDLE_VALUE;
+    SetLastError(rc);          /* Hehe, OS/2 and NT are pretty compatible :) */
+    return 0;                           /* signal error */
+  }
+  else
+    SetLastError(ERROR_SUCCESS); //@@@PH 1999/10/27 rc5desg requires this?
+
+  return iIndexNew;                                   /* return valid handle */
+}
+
+
+/*****************************************************************************
+ * Name      : HANDLE  HMCreateMutex
+ * Purpose   : Wrapper for the CreateMutex() API
+ * Parameters:
+ * Variables :
+ * Result    :
+ * Remark    :
+ * Status    :
+ *
+ * Author    : Patrick Haller [Wed, 1998/02/11 20:44]
+ *****************************************************************************/
+
+HANDLE HMCreateMutex(LPSECURITY_ATTRIBUTES lpsa,
+                     BOOL                  bInitialOwner,
+                     LPCTSTR               lpName)
+{
+  int             iIndex;                     /* index into the handle table */
+  int             iIndexNew;                  /* index into the handle table */
+  HMDeviceHandler *pDeviceHandler;         /* device handler for this handle */
+  PHMHANDLEDATA   pHMHandleData;
+  DWORD           rc;                                     /* API return code */
+
+
+  if(lpName) { //check if shared mutex semaphore already exists
+      //TODO: No inheritance??
+      HANDLE handle = HMOpenMutex(MUTEX_ALL_ACCESS, FALSE, lpName);
+      if(handle) {
+          dprintf(("CreateMutex: return handle of existing mutex semaphore %x", handle));
+          return handle;
+      }
+  }
+
+  pDeviceHandler = HMGlobals.pHMMutex;               /* device is predefined */
 
   iIndexNew = _HMHandleGetFree();                         /* get free handle */
@@ -2251 +2336 @@
 
                                                   /* call the device handler */
-  rc = pDeviceHandler->CreateEvent(&TabWin32Handles[iIndexNew].hmHandleData,
-                                   lpsa,
-                                   bManualReset,
-                                   bInitialState,
-                                   lpName);
-  if (rc != NO_ERROR)     /* oops, creation failed within the device handler */
-  {
-    TabWin32Handles[iIndexNew].hmHandleData.hHMHandle = INVALID_HANDLE_VALUE;
-    SetLastError(rc);          /* Hehe, OS/2 and NT are pretty compatible :) */
-    return 0;                           /* signal error */
-  }
-  else
-    SetLastError(ERROR_SUCCESS); //@@@PH 1999/10/27 rc5desg requires this?
-
-  return iIndexNew;                                   /* return valid handle */
-}
-
-
-/*****************************************************************************
- * Name      : HANDLE  HMCreateMutex
- * Purpose   : Wrapper for the CreateMutex() API
- * Parameters:
- * Variables :
- * Result    :
- * Remark    :
- * Status    :
- *
- * Author    : Patrick Haller [Wed, 1998/02/11 20:44]
- *****************************************************************************/
-
-HANDLE HMCreateMutex(LPSECURITY_ATTRIBUTES lpsa,
-                     BOOL                  bInitialOwner,
-                     LPCTSTR               lpName)
-{
-  int             iIndex;                     /* index into the handle table */
-  int             iIndexNew;                  /* index into the handle table */
-  HMDeviceHandler *pDeviceHandler;         /* device handler for this handle */
-  PHMHANDLEDATA   pHMHandleData;
-  DWORD           rc;                                     /* API return code */
-
-
-  pDeviceHandler = HMGlobals.pHMMutex;               /* device is predefined */
-
-  iIndexNew = _HMHandleGetFree();                         /* get free handle */
-  if (-1 == iIndexNew)                            /* oops, no free handles ! */
-  {
-    SetLastError(ERROR_NOT_ENOUGH_MEMORY);      /* use this as error message */
-    return 0;                           /* signal error */
-  }
-
-
-                           /* initialize the complete HMHANDLEDATA structure */
-  pHMHandleData = &TabWin32Handles[iIndexNew].hmHandleData;
-  pHMHandleData->dwType     = FILE_TYPE_UNKNOWN;      /* unknown handle type */
-  pHMHandleData->dwAccess   = 0;
-  pHMHandleData->dwShare    = 0;
-  pHMHandleData->dwCreation = 0;
-  pHMHandleData->dwFlags    = 0;
-  pHMHandleData->lpHandlerData = NULL;
-
-
-      /* we've got to mark the handle as occupied here, since another device */
-                   /* could be created within the device handler -> deadlock */
-
-          /* write appropriate entry into the handle table if open succeeded */
-  TabWin32Handles[iIndexNew].hmHandleData.hHMHandle = iIndexNew;
-  TabWin32Handles[iIndexNew].pDeviceHandler         = pDeviceHandler;
-
-                                                  /* call the device handler */
   rc = pDeviceHandler->CreateMutex(&TabWin32Handles[iIndexNew].hmHandleData,
                                    lpsa,
@@ -2494 +2510 @@
   DWORD           rc;                                     /* API return code */
 
-
+  if(lpName) { //check if shared event semaphore already exists
+      //TODO: No inheritance??
+      HANDLE handle = HMOpenSemaphore(SEMAPHORE_ALL_ACCESS, FALSE, lpName);
+      if(handle) {
+          dprintf(("CreateSemaphore: return handle of existing semaphore %x", handle));
+          return handle;
+      }
+  }
+  
   pDeviceHandler = HMGlobals.pHMSemaphore;               /* device is predefined */
 
@@ -2984 +3008 @@
                                  pLoop2);
 
+    dprintf2(("MsgWaitForMultipleObjects handle %x->%x", *pLoop1, *pLoop2));
     // SvL: We still use Open32 handles for threads & processes -> don't fail here!
     if (rc != NO_ERROR)