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

Timestamp:

Jul 5, 1999, 11:58:14 AM (26 years ago)

Author:

phaller

Message:

Fix: streamlined Handlemanager

File:

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

trunk/src/kernel32/HandleManager.cpp

@@ -1 @@
-/* $Id: HandleManager.cpp,v 1.4 1999-06-17 21:52:00 phaller Exp $ */
+/* $Id: HandleManager.cpp,v 1.5 1999-07-05 09:58:14 phaller Exp $ */
 
 /*
@@ -59 +59 @@
 
                     /* this is the size of our currently static handle table */
-#define MAX_OS2_HMHANDLES 256
-
-        /* this is for the handle translation table, could by dynamic though */
-#define MAX_TRANSLATION_HANDLES 8192
-
+#define MAX_OS2_HMHANDLES 1024
 
 
@@ -129 +125 @@
   HMDeviceHandler *pHMOpen32;             /* default handle manager instance */
 
-
   ULONG         ulHandleLast;                   /* index of last used handle */
-  HMTRANSHANDLE TabTranslationHandles[MAX_TRANSLATION_HANDLES];
 } HMGlobals;
 
@@ -143 +137 @@
 
                                /* get next free handle from the handle table */
-static int              _HMHandleGetFree(void);
+static ULONG            _HMHandleGetFree(void);
 
                                        /* get handle table entry from handle */
-static int              _HMHandleQuery(HANDLE hHandle);
+static ULONG            _HMHandleQuery(HANDLE hHandle);
 
 
@@ -193 +187 @@
  *****************************************************************************/
 
-static int _HMHandleGetFree(void)
-{
-  int iLoop;
-
-  for (iLoop = 0;
-       iLoop < MAX_OS2_HMHANDLES;
-       iLoop++)
-  {
-                                                      /* free handle found ? */
-    if (0 == TabWin32Handles[iLoop].hmHandleData.hHMHandle)
-      return (iLoop);                    /* OK, then return it to the caller */
-  }
-
-  return (-1);                              /* haven't found any free handle */
+static ULONG _HMHandleGetFree(void)
+{
+  register ULONG ulLoop;
+
+  for (ulLoop = 0;
+       ulLoop < MAX_OS2_HMHANDLES;
+       ulLoop++)
+  {
+                                                       /* free handle found ? */
+    if (INVALID_HANDLE_VALUE == TabWin32Handles[ulLoop].hmHandleData.hHMHandle)
+      return (ulLoop);                    /* OK, then return it to the caller */
+  }
+
+  return (INVALID_HANDLE_VALUE);             /* haven't found any free handle */
 }
 
@@ -223 +217 @@
  *****************************************************************************/
 
-static int _HMHandleQuery(HANDLE hHandle)
-{
-  ULONG ulIndex;                              /* index into the handle table */
-
-                                                         /* check the handle */
-  ulIndex = hHandle & ~HM_HANDLE_MASK;        /* mask out the signature bits */
-  if (ulIndex != HM_HANDLE_ID)                       /* one of our handles ? */
-    return (-1);                               /* nope, ERROR_INVALID_HANDLE */
-
-  ulIndex = hHandle & HM_HANDLE_MASK;               /* get the relevant bits */
-  if (ulIndex > MAX_OS2_HMHANDLES)                  /* check the table range */
-    return (-1);                               /* nope, ERROR_INVALID_HANDLE */
+static ULONG _HMHandleQuery(HANDLE hHandle)
+{
+  if (hHandle > MAX_OS2_HMHANDLES)                  /* check the table range */
+    return (INVALID_HANDLE_VALUE);             /* nope, ERROR_INVALID_HANDLE */
 
                                                    /* Oops, invalid handle ! */
-  if (TabWin32Handles[ulIndex].hmHandleData.hHMHandle != hHandle)
-    return (-1);                               /* nope, ERROR_INVALID_HANDLE */
-
-  return ( (int) ulIndex);                 /* OK, we've got our handle index */
+  if (INVALID_HANDLE_VALUE == TabWin32Handles[hHandle].hmHandleData.hHMHandle)
+    return (INVALID_HANDLE_VALUE);              /* nope, ERROR_INVALID_HANDLE */
+
+  return ( hHandle);                       /* OK, we've got our handle index */
 }
 
@@ -258 +244 @@
 
 DWORD   HMDeviceRegister(PSZ             pszDeviceName,
-                                 HMDeviceHandler *pDeviceHandler)
+                         HMDeviceHandler *pDeviceHandler)
 {
   PHMDEVICE pHMDevice;                     /* our new device to be allocated */
@@ -302 +288 @@
 DWORD HMInitialize(void)
 {
+  ULONG ulIndex;
+
   if (HMGlobals.fIsInitialized != TRUE)
   {
     HMGlobals.fIsInitialized = TRUE;                             /* OK, done */
+
+    // fill handle table
+    for (ulIndex = 0;
+         ulIndex < MAX_OS2_HMHANDLES;
+         ulIndex++)
+      TabWin32Handles[ulIndex].hmHandleData.hHMHandle = INVALID_HANDLE_VALUE;
 
     dprintf(("KERNEL32:HandleManager:HMInitialize() storing handles.\n"));
@@ -369 +363 @@
 
 DWORD  HMHandleAllocate (PULONG phHandle16,
-                                 ULONG  hHandle32)
+                         ULONG  hHandleOS2)
 {
   register ULONG ulHandle;
@@ -376 +370 @@
   dprintf(("KERNEL32: HMHandleAllocate (%08xh,%08xh)\n",
            phHandle16,
-           hHandle32));
+           hHandleOS2));
 #endif
 
@@ -384 +378 @@
   {
                                                   /* check if handle is free */
-    if (HMGlobals.TabTranslationHandles[ulHandle].hHandle32 == 0)
+    if (TabWin32Handles[ulHandle].hmHandleData.hHMHandle == INVALID_HANDLE_VALUE)
     {
       *phHandle16 = ulHandle;
-      HMGlobals.TabTranslationHandles[ulHandle].hHandle32 = hHandle32;
+      TabWin32Handles[ulHandle].hmHandleData.hHMHandle = hHandleOS2;
       HMGlobals.ulHandleLast = ulHandle;          /* to shorten search times */
 
@@ -395 +389 @@
     ulHandle++;                                        /* skip to next entry */
 
-    if (ulHandle >= MAX_TRANSLATION_HANDLES)               /* check boundary */
+    if (ulHandle >= MAX_OS2_HMHANDLES)                     /* check boundary */
       ulHandle = 0;
   }
@@ -430 +424 @@
     return (rc);                                    /* raise error condition */
 
-  HMGlobals.TabTranslationHandles[hHandle16].hHandle32 = 0;      /* OK, done */
+  TabWin32Handles[hHandle16].hmHandleData.hHMHandle = INVALID_HANDLE_VALUE;
+                                                                 /* OK, done */
 
   return (NO_ERROR);
@@ -455 +450 @@
 #endif
 
-  if (hHandle16 >= MAX_TRANSLATION_HANDLES)                /* check boundary */
+  if (hHandle16 >= MAX_OS2_HMHANDLES)                      /* check boundary */
     return (ERROR_INVALID_HANDLE);                  /* raise error condition */
 
-  if (HMGlobals.TabTranslationHandles[hHandle16].hHandle32 == 0)  /* valid ? */
+  if (TabWin32Handles[hHandle16].hmHandleData.hHMHandle == INVALID_HANDLE_VALUE)
+                                                                  /* valid ? */
     return (ERROR_INVALID_HANDLE);                  /* raise error condition */
 
@@ -478 +474 @@
  *****************************************************************************/
 
-DWORD  HMHandleTranslateToWin (ULONG  hHandle32,
-                                       PULONG phHandle16)
+DWORD  HMHandleTranslateToWin (ULONG  hHandleOS2,
+                               PULONG phHandle16)
 {
            ULONG rc;                                       /* API returncode */
@@ -486 +482 @@
 #ifdef DEBUG_LOCAL
   dprintf(("KERNEL32: HMHandleTranslateToWin (%08xh, %08xh)\n",
-           hHandle32,
+           hHandleOS2,
            phHandle16));
 #endif
 
   for (ulIndex = 0;
-       ulIndex < MAX_TRANSLATION_HANDLES;
+       ulIndex < MAX_OS2_HMHANDLES;
        ulIndex++)
   {
                                                       /* look for the handle */
-    if (HMGlobals.TabTranslationHandles[ulIndex].hHandle32 == hHandle32)
+    if (TabWin32Handles[ulIndex].hmHandleData.hHMHandle == hHandleOS2)
     {
       *phHandle16 = ulIndex;                               /* deliver result */
@@ -520 +516 @@
 
 DWORD  HMHandleTranslateToOS2 (ULONG  hHandle16,
-                                       PULONG phHandle32)
+                               PULONG phHandleOS2)
 {
 #ifdef DEBUG_LOCAL
   dprintf(("KERNEL32: HMHandleTranslateToOS2 (%08xh, %08xh)\n",
            hHandle16,
-           phHandle32));
+           phHandleOS2));
 #endif
 
   if (HMHandleValidate(hHandle16) == NO_ERROR)              /* verify handle */
   {
-    *phHandle32 = HMGlobals.TabTranslationHandles[hHandle16].hHandle32;
+    *phHandleOS2 = TabWin32Handles[hHandle16].hmHandleData.hHMHandle;
     return (NO_ERROR);
   }
@@ -557 +553 @@
 #endif
 
-  return(HMGlobals.TabTranslationHandles[hHandle16].hHandle32);
+  return(TabWin32Handles[hHandle16].hmHandleData.hHMHandle);
 }
 
@@ -708 +704 @@
 
           /* write appropriate entry into the handle table if open succeeded */
-  hResult = (ULONG)iIndexNew | HM_HANDLE_ID;
-  HMHandleTemp.hHMHandle                      = hResult;
+  HMHandleTemp.hHMHandle                    = iIndexNew;
   TabWin32Handles[iIndexNew].pDeviceHandler = pDeviceHandler;
 
@@ -746 +741 @@
   dprintf(("KERNEL32/HandleManager: CreateFile(%s)=%08xh\n",
            lpFileName,
-           hResult));
+           iIndexNew));
 #endif
 
-  return hResult;                                     /* return valid handle */
+  return (HFILE)iIndexNew;                             /* return valid handle */
 }
 
@@ -786 +781 @@
       case OF_SHARE_DENY_WRITE: *sharing = FILE_SHARE_READ; break;
       case OF_SHARE_DENY_READ:  *sharing = FILE_SHARE_WRITE; break;
-       case OF_SHARE_DENY_NONE:
+      case OF_SHARE_DENY_NONE:
       case OF_SHARE_COMPAT:
       default:                  *sharing = FILE_SHARE_READ | FILE_SHARE_WRITE; break;
@@ -799 +794 @@
   int             iIndexNew;                  /* index into the handle table */
   HMDeviceHandler *pDeviceHandler;         /* device handler for this handle */
-  HANDLE          hResult;
   PHMHANDLEDATA   pHMHandleData;
   DWORD           rc;                                     /* API return code */
@@ -839 +833 @@
 
           /* write appropriate entry into the handle table if open succeeded */
-  hResult = (ULONG)iIndexNew | HM_HANDLE_ID;
-  TabWin32Handles[iIndexNew].hmHandleData.hHMHandle = hResult;
+  TabWin32Handles[iIndexNew].hmHandleData.hHMHandle = iIndexNew;
   TabWin32Handles[iIndexNew].pDeviceHandler       = pDeviceHandler;
 
@@ -849 +842 @@
 
 #ifdef DEBUG_LOCAL
-    dprintf(("KERNEL32/HandleManager:CheckPoint3: %s lpHandlerData=%08xh\n",
+    dprintf(("KERNEL32/HandleManager:CheckPoint3: %s lpHandlerData=%08xh rc=%08xh\n",
              lpFileName,
-             HMHandleTemp.lpHandlerData));
+             &TabWin32Handles[iIndexNew].hmHandleData.lpHandlerData,
+             rc));
 #endif
 
@@ -867 +861 @@
 #endif
 
-  return hResult;                                     /* return valid handle */
+  return iIndexNew;                                   /* return valid handle */
 }