Changeset 664 for trunk/src/kernel32


Ignore:
Timestamp:
Aug 24, 1999, 8:48:10 PM (26 years ago)
Author:
sandervl
Message:

Memory mapped file changes

Location:
trunk/src/kernel32
Files:
2 added
2 deleted
6 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/kernel32/HandleManager.cpp

    r659 r664  
    1 /* $Id: HandleManager.cpp,v 1.12 1999-08-24 14:36:04 phaller Exp $ */
     1/* $Id: HandleManager.cpp,v 1.13 1999-08-24 18:46:38 sandervl Exp $ */
    22
    33/*
    … …  
    5656#include "HMMutex.h"
    5757#include "HMSemaphore.h"
    58 #include "HMFileMapping.h"
    59 
     58#include "HMMMap.h"
    6059
    6160/*****************************************************************************
    … …  
    122121  HMDeviceHandler        *pHMMutex;
    123122  HMDeviceHandler        *pHMSemaphore;
    124   HMDeviceHandler        *pHMFileMapping;
     123  HMDeviceHandler        *pHMFileMapping;        /* static instances of subsystems */
    125124
    126125  ULONG         ulHandleLast;                   /* index of last used handle */
    … …  
    197196  {
    198197                                                       /* free handle found ? */
    199     if (INVALID_HANDLE_VALUE == TabWin32Handles[ulLoop].hmHandleData.hHMHandle)
    200       return (ulLoop);                    /* OK, then return it to the caller */
     198    if (INVALID_HANDLE_VALUE == TabWin32Handles[ulLoop].hmHandleData.hHMHandle) {
     199        TabWin32Handles[ulLoop].hmHandleData.dwUserData     = 0;
     200        TabWin32Handles[ulLoop].hmHandleData.dwInternalType = HMTYPE_UNKNOWN;
     201        return (ulLoop);                    /* OK, then return it to the caller */
     202    }
    201203  }
    202204
    … …  
    313315
    314316                        /* create handle manager instance for Open32 handles */
    315     HMGlobals.pHMOpen32       = new HMDeviceOpen32Class("\\\\.\\");
    316     HMGlobals.pHMEvent        = new HMDeviceEventClass("\\\\EVENT\\");
    317     HMGlobals.pHMMutex        = new HMDeviceMutexClass("\\\\MUTEX\\");
    318     HMGlobals.pHMSemaphore    = new HMDeviceSemaphoreClass("\\\\SEM\\");
    319     HMGlobals.pHMFileMapping  = new HMDeviceFileMappingClass("\\\\FILEMAPPING\\");
     317    HMGlobals.pHMOpen32     = new HMDeviceOpen32Class("\\\\.\\");
     318    HMGlobals.pHMEvent      = new HMDeviceEventClass("\\\\EVENT\\");
     319    HMGlobals.pHMMutex      = new HMDeviceMutexClass("\\\\MUTEX\\");
     320    HMGlobals.pHMSemaphore  = new HMDeviceSemaphoreClass("\\\\SEM\\");
     321    HMGlobals.pHMFileMapping = new HMDeviceMemMapClass("\\\\MEMMAP\\");
    320322  }
    321323  return (NO_ERROR);
    … …  
    21512153
    21522154/*****************************************************************************
    2153  * Name      : HMWaitForMultipleObjects
    2154  * Purpose   : router function for WaitForMultipleObjects
    2155  * Parameters:
    2156  * Variables :
    2157  * Result    :
    2158  * Remark    :
    2159  * Status    :
    2160  *
    2161  * Author    : Patrick Haller [Wed, 1999/06/17 20:44]
    2162  *****************************************************************************/
    2163 
    2164 DWORD HMWaitForMultipleObjects (DWORD   cObjects,
    2165                                 PHANDLE lphObjects,
    2166                                 BOOL    fWaitAll,
    2167                                 DWORD   dwTimeout)
    2168 {
    2169   ULONG   ulIndex;
    2170   PHANDLE pArrayOfHandles;
    2171   PHANDLE pLoop1 = lphObjects;
    2172   PHANDLE pLoop2;
    2173   DWORD   rc;
    2174 
    2175   // allocate array for handle table
    2176   pArrayOfHandles = (PHANDLE)malloc(cObjects * sizeof(HANDLE));
    2177   if (pArrayOfHandles == NULL)
    2178   {
    2179     O32_SetLastError(ERROR_NOT_ENOUGH_MEMORY);
    2180     return WAIT_FAILED;
    2181   }
    2182   else
    2183     pLoop2 = pArrayOfHandles;
    2184 
    2185   // convert array to odin handles
    2186   for (ulIndex = 0;
    2187 
    2188        ulIndex < cObjects;
    2189 
    2190        ulIndex++,
    2191        pLoop1++,
    2192        pLoop2++)
    2193   {
    2194     rc = HMHandleTranslateToOS2 (*pLoop1, // translate handle
    2195                                  pLoop2);
    2196 
    2197     if (rc != NO_ERROR)
    2198     {
    2199       free (pArrayOfHandles);             // free memory
    2200       O32_SetLastError(ERROR_INVALID_HANDLE);
    2201       return (WAIT_FAILED);
    2202     }
    2203   }
    2204 
    2205   // OK, now forward to Open32.
    2206   // @@@PH: Note this will fail on handles that do NOT belong to Open32
    2207   //        but to i.e. the console subsystem!
    2208   rc = O32_WaitForMultipleObjects(cObjects,
    2209                                   pArrayOfHandles,
    2210                                   fWaitAll,
    2211                                   dwTimeout);
    2212 
    2213   free(pArrayOfHandles);                  // free memory
    2214   return (rc);                            // OK, done
    2215 }
    2216 
    2217 
    2218 /*****************************************************************************
    2219  * Name      : HMWaitForMultipleObjectsEx
    2220  * Purpose   : router function for WaitForMultipleObjectsEx
    2221  * Parameters:
    2222  * Variables :
    2223  * Result    :
    2224  * Remark    :
    2225  * Status    :
    2226  *
    2227  * Author    : Patrick Haller [Wed, 1999/06/17 20:44]
    2228  *****************************************************************************/
    2229 
    2230 DWORD HMWaitForMultipleObjectsEx (DWORD   cObjects,
    2231                                   PHANDLE lphObjects,
    2232                                   BOOL    fWaitAll,
    2233                                   DWORD   dwTimeout,
    2234                                   BOOL    fAlertable)
    2235 {
    2236   // @@@PH: Note: fAlertable is ignored !
    2237   return (HMWaitForMultipleObjects(cObjects,
    2238                                    lphObjects,
    2239                                    fWaitAll,
    2240                                    dwTimeout));
    2241 }
    2242 
    2243 
    2244 /*****************************************************************************
    22452155 * Name      : HANDLE  HMCreateFileMapping
    22462156 * Purpose   : Wrapper for the CreateFileMapping() API
    … …  
    23502260  }
    23512261
    2352 
    2353                            /* initialize the complete HMHANDLEDATA structure */
     2262  /* initialize the complete HMHANDLEDATA structure */
    23542263  pHMHandleData = &TabWin32Handles[iIndexNew].hmHandleData;
    23552264  pHMHandleData->dwType     = FILE_TYPE_UNKNOWN;      /* unknown handle type */
    … …  
    23612270
    23622271
    2363       /* we've got to mark the handle as occupied here, since another device */
    2364                    /* could be created within the device handler -> deadlock */
    2365 
    2366           /* write appropriate entry into the handle table if open succeeded */
     2272  /* we've got to mark the handle as occupied here, since another device */
     2273  /* could be created within the device handler -> deadlock */
     2274
     2275  /* write appropriate entry into the handle table if open succeeded */
    23672276  TabWin32Handles[iIndexNew].hmHandleData.hHMHandle = iIndexNew;
    23682277  TabWin32Handles[iIndexNew].pDeviceHandler         = pDeviceHandler;
    … …  
    23702279                                                  /* call the device handler */
    23712280  rc = pDeviceHandler->OpenFileMapping(&TabWin32Handles[iIndexNew].hmHandleData,
     2281                                       fdwAccess,
    23722282                                       fInherit,
    23732283                                       lpName);
    … …  
    23812291  return iIndexNew;                                   /* return valid handle */
    23822292}
    2383 
    2384 
    2385 /*****************************************************************************
    2386  * Name      : HMMapViewOfFile
    2387  * Purpose   : router function for MapViewOfFile
    2388  * Parameters:
    2389  * Variables :
    2390  * Result    :
    2391  * Remark    :
    2392  * Status    :
    2393  *
    2394  * Author    : Patrick Haller [Wed, 1999/06/17 20:44]
    2395  *****************************************************************************/
    2396 
    2397 LPVOID HMMapViewOfFile(HANDLE hFileMappingObject,
    2398                        DWORD  dwDesiredAccess,
    2399                        DWORD  dwFileOffsetHigh,
    2400                        DWORD  dwFileOffsetLow,
    2401                        DWORD  dwNumberOfBytesToMap)
    2402 {
    2403   int       iIndex;                           /* index into the handle table */
    2404   LPVOID    lpResult;                /* result from the device handler's API */
    2405   PHMHANDLE pHMHandle;       /* pointer to the handle structure in the table */
    2406 
    2407                                                           /* validate handle */
    2408   iIndex = _HMHandleQuery(hFileMappingObject);              /* get the index */
    2409   if (-1 == iIndex)                                               /* error ? */
    2410   {
    2411     SetLastError(ERROR_INVALID_HANDLE);       /* set win32 error information */
    2412     return (NULL);                                         /* signal failure */
    2413   }
    2414 
    2415   pHMHandle = &TabWin32Handles[iIndex];               /* call device handler */
    2416   lpResult = pHMHandle->pDeviceHandler->MapViewOfFile(&pHMHandle->hmHandleData,
    2417                                                       dwDesiredAccess,
    2418                                                       dwFileOffsetHigh,
    2419                                                       dwFileOffsetLow,
    2420                                                       dwNumberOfBytesToMap);
    2421 
    2422   return (lpResult);                                  /* deliver return code */
    2423 }
    2424 
    24252293
    24262294
    … …  
    24582326  pHMHandle = &TabWin32Handles[iIndex];               /* call device handler */
    24592327  lpResult = pHMHandle->pDeviceHandler->MapViewOfFileEx(&pHMHandle->hmHandleData,
    2460                                                         dwDesiredAccess,
    2461                                                         dwFileOffsetHigh,
    2462                                                         dwFileOffsetLow,
    2463                                                         dwNumberOfBytesToMap,
    2464                                                         lpBaseAddress);
     2328                                                      dwDesiredAccess,
     2329                                                      dwFileOffsetHigh,
     2330                                                      dwFileOffsetLow,
     2331                                                      dwNumberOfBytesToMap,
     2332                                                      lpBaseAddress);
    24652333
    24662334  return (lpResult);                                  /* deliver return code */
    24672335}
    24682336
    2469 
    2470 /*****************************************************************************
    2471  * Name      : HMUnmapViewOfFile
    2472  * Purpose   : router function for UnmapViewOfFile
    2473  * Parameters:
    2474  * Variables :
    2475  * Result    :
    2476  * Remark    : No handle is specified, that makes things a bit more difficult!
    2477  *             We've got to identify the object by the base address and check
    2478  *             back with HandleManager manually!
     2337/*****************************************************************************
     2338 * Name      : HMWaitForMultipleObjects
     2339 * Purpose   : router function for WaitForMultipleObjects
     2340 * Parameters:
     2341 * Variables :
     2342 * Result    :
     2343 * Remark    :
    24792344 * Status    :
    24802345 *
    … …  
    24822347 *****************************************************************************/
    24832348
    2484 BOOL HMUnmapViewOfFile(LPVOID lpBaseAddress)
    2485 {
    2486   int       iIndex;                           /* index into the handle table */
    2487   BOOL      flResult;                /* result from the device handler's API */
    2488   PHMHANDLE pHMHandle;       /* pointer to the handle structure in the table */
    2489 
    2490   // Identify the correct handle by the base address. Thus call a special
    2491   // static function within the FileMapping class.
    2492   iIndex = HMDeviceFileMappingClass::findByBaseAddress(lpBaseAddress);                                                          /* validate handle */
    2493   if (-1 == iIndex)                                               /* error ? */
    2494   {
    2495     SetLastError(ERROR_INVALID_HANDLE);       /* set win32 error information */
    2496     return (FALSE);                                        /* signal failure */
    2497   }
    2498 
    2499   flResult = pHMHandle->pDeviceHandler->UnmapViewOfFile(&pHMHandle->hmHandleData,
    2500                                                         lpBaseAddress);
    2501 
    2502   // @@@PH automatically call CloseHandle of no more references to the object
    2503   //       are active.
    2504 
    2505   return (flResult);                                  /* deliver return code */
    2506 }
    2507 
    2508 
    2509 /*****************************************************************************
    2510  * Name      : HMFlushViewOfFile
    2511  * Purpose   : router function for FlushViewOfFile
    2512  * Parameters:
    2513  * Variables :
    2514  * Result    :
    2515  * Remark    : No handle is specified, that makes things a bit more difficult!
    2516  *             We've got to identify the object by the base address and check
    2517  *             back with HandleManager manually!
     2349DWORD HMWaitForMultipleObjects (DWORD   cObjects,
     2350                                PHANDLE lphObjects,
     2351                                BOOL    fWaitAll,
     2352                                DWORD   dwTimeout)
     2353{
     2354  ULONG   ulIndex;
     2355  PHANDLE pArrayOfHandles;
     2356  PHANDLE pLoop1 = lphObjects;
     2357  PHANDLE pLoop2;
     2358  DWORD   rc;
     2359
     2360  // allocate array for handle table
     2361  pArrayOfHandles = (PHANDLE)malloc(cObjects * sizeof(HANDLE));
     2362  if (pArrayOfHandles == NULL)
     2363  {
     2364    O32_SetLastError(ERROR_NOT_ENOUGH_MEMORY);
     2365    return WAIT_FAILED;
     2366  }
     2367  else
     2368    pLoop2 = pArrayOfHandles;
     2369
     2370  // convert array to odin handles
     2371  for (ulIndex = 0;
     2372
     2373       ulIndex < cObjects;
     2374
     2375       ulIndex++,
     2376       pLoop1++,
     2377       pLoop2++)
     2378  {
     2379    rc = HMHandleTranslateToOS2 (*pLoop1, // translate handle
     2380                                 pLoop2);
     2381
     2382    if (rc != NO_ERROR)
     2383    {
     2384      free (pArrayOfHandles);             // free memory
     2385      O32_SetLastError(ERROR_INVALID_HANDLE);
     2386      return (WAIT_FAILED);
     2387    }
     2388  }
     2389
     2390  // OK, now forward to Open32.
     2391  // @@@PH: Note this will fail on handles that do NOT belong to Open32
     2392  //        but to i.e. the console subsystem!
     2393  rc = O32_WaitForMultipleObjects(cObjects,
     2394                                  pArrayOfHandles,
     2395                                  fWaitAll,
     2396                                  dwTimeout);
     2397
     2398  free(pArrayOfHandles);                  // free memory
     2399  return (rc);                            // OK, done
     2400}
     2401
     2402
     2403/*****************************************************************************
     2404 * Name      : HMWaitForMultipleObjectsEx
     2405 * Purpose   : router function for WaitForMultipleObjectsEx
     2406 * Parameters:
     2407 * Variables :
     2408 * Result    :
     2409 * Remark    :
    25182410 * Status    :
    25192411 *
    … …  
    25212413 *****************************************************************************/
    25222414
    2523 BOOL HMFlushViewOfFile(LPVOID lpBaseAddress,
    2524                        DWORD  dwNumberOfBytesToFlush)
    2525 {
    2526   int       iIndex;                           /* index into the handle table */
    2527   BOOL      flResult;                /* result from the device handler's API */
    2528   PHMHANDLE pHMHandle;       /* pointer to the handle structure in the table */
    2529 
    2530   // Identify the correct handle by the base address. Thus call a special
    2531   // static function within the FileMapping class.
    2532   iIndex = HMDeviceFileMappingClass::findByBaseAddress(lpBaseAddress);                                                          /* validate handle */
    2533   if (-1 == iIndex)                                               /* error ? */
    2534   {
    2535     SetLastError(ERROR_INVALID_HANDLE);       /* set win32 error information */
    2536     return (FALSE);                                        /* signal failure */
    2537   }
    2538 
    2539   flResult = pHMHandle->pDeviceHandler->FlushViewOfFile(&pHMHandle->hmHandleData,
    2540                                                         lpBaseAddress,
    2541                                                         dwNumberOfBytesToFlush);
    2542 
    2543   return (flResult);                                  /* deliver return code */
    2544 }
     2415DWORD HMWaitForMultipleObjectsEx (DWORD   cObjects,
     2416                                  PHANDLE lphObjects,
     2417                                  BOOL    fWaitAll,
     2418                                  DWORD   dwTimeout,
     2419                                  BOOL    fAlertable)
     2420{
     2421  // @@@PH: Note: fAlertable is ignored !
     2422  return (HMWaitForMultipleObjects(cObjects,
     2423                                   lphObjects,
     2424                                   fWaitAll,
     2425                                   dwTimeout));
     2426}
     2427

  • trunk/src/kernel32/hmdevice.cpp

    r659 r664  
    1 /* $Id: hmdevice.cpp,v 1.3 1999-08-24 14:36:05 phaller Exp $ */
     1/* $Id: hmdevice.cpp,v 1.4 1999-08-24 18:46:39 sandervl Exp $ */
    22
    33/*
    … …  
    890890           pHMHandleData->hHMHandle));
    891891
    892   return(FALSE);
     892  return(ERROR_INVALID_FUNCTION);
    893893}
    894894
    … …  
    920920           arg4));
    921921
    922   return(FALSE);
    923 }
    924 
     922  return(ERROR_INVALID_FUNCTION);
     923}
    925924
    926925/*****************************************************************************
    … …  
    978977
    979978DWORD HMDeviceHandler::OpenFileMapping(PHMHANDLEDATA pHMHandleData,
     979                                      DWORD         fdwAccess,
    980980                                      BOOL          fInherit,
    981981                                      LPCTSTR       lpName)
    982982{
    983   dprintf(("KERNEL32: HandleManager::DeviceHandler::OpenFileMapping(%08xh,%08xh,%08xh)\n",
     983  dprintf(("KERNEL32: HandleManager::DeviceHandler::OpenFileMapping(%08xh,%08xh,%08xh,%08xh)\n",
    984984           pHMHandleData->hHMHandle,
     985           fdwAccess,
    985986           fInherit,
    986987           lpName));
    … …  
    988989  return(ERROR_INVALID_FUNCTION);
    989990}
    990 
    991991
    992992/*****************************************************************************
    … …  
    10061006 *****************************************************************************/
    10071007
    1008 LPVOID HMDeviceHandler::MapViewOfFile(PHMHANDLEDATA pHMHandleData,
     1008LPVOID HMDeviceHandler::MapViewOfFileEx(PHMHANDLEDATA pHMHandleData,
    10091009                                      DWORD         dwDesiredAccess,
    10101010                                      DWORD         dwFileOffsetHigh,
    10111011                                      DWORD         dwFileOffsetLow,
    1012                                       DWORD         dwNumberOfBytesToMap)
    1013 {
    1014   dprintf(("KERNEL32: HandleManager::DeviceHandler::MapViewOfFile(%08xh,%08xh,%08xh,%08xh,%08xh)\n",
    1015            pHMHandleData->hHMHandle,
    1016            dwDesiredAccess,
    1017            dwFileOffsetHigh,
    1018            dwFileOffsetLow,
    1019            dwNumberOfBytesToMap));
    1020 
    1021   return(NULL);
    1022 }
    1023 
    1024 
    1025 /*****************************************************************************
    1026  * Name      : DWORD HMDeviceHandler::MapViewOfFileEx
    1027  * Purpose   : map memory mapped file
    1028  * Parameters: PHMHANDLEDATA pHMHandleData
    1029  *             DWORD         dwDesiredAccess,
    1030  *             DWORD         dwFileOffsetHigh,
    1031  *             DWORD         dwFileOffsetLow,
    1032  *             DWORD         dwNumberOfBytesToMap
    1033  *             LPVOID        lpBaseAddress
    1034  * Variables :
    1035  * Result    : address to memory mapped region
    1036  * Remark    :
    1037  * Status    :
    1038  *
    1039  * Author    : Patrick Haller [Wed, 1999/06/17 20:44]
    1040  *****************************************************************************/
    1041 
    1042 LPVOID HMDeviceHandler::MapViewOfFileEx(PHMHANDLEDATA pHMHandleData,
    1043                                         DWORD         dwDesiredAccess,
    1044                                         DWORD         dwFileOffsetHigh,
    1045                                         DWORD         dwFileOffsetLow,
    1046                                         DWORD         dwNumberOfBytesToMap,
    1047                                         LPVOID        lpBaseAddress)
     1012                                      DWORD         dwNumberOfBytesToMap,
     1013                                      LPVOID        lpBaseAddress)
    10481014{
    10491015  dprintf(("KERNEL32: HandleManager::DeviceHandler::MapViewOfFileEx(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh)\n",
    … …  
    10521018           dwFileOffsetHigh,
    10531019           dwFileOffsetLow,
    1054            dwNumberOfBytesToMap,
    1055            lpBaseAddress));
     1020           dwNumberOfBytesToMap, lpBaseAddress));
    10561021
    10571022  return(NULL);
    10581023}
    1059 
    1060 
    1061 /*****************************************************************************
    1062  * Name      : DWORD HMDeviceHandler::UnmapViewOfFile
    1063  * Purpose   : unmap memory mapped file
    1064  * Parameters: PHMHANDLEDATA pHMHandleData
    1065  *             LPVOID        lpBaseAddress
    1066  * Variables :
    1067  * Result    : TRUE / FALSE
    1068  * Remark    :
    1069  * Status    :
    1070  *
    1071  * Author    : Patrick Haller [Wed, 1999/06/17 20:44]
    1072  *****************************************************************************/
    1073 
    1074 BOOL HMDeviceHandler::UnmapViewOfFile(PHMHANDLEDATA pHMHandleData,
    1075                                       LPVOID        lpBaseAddress)
    1076 {
    1077   dprintf(("KERNEL32: HandleManager::DeviceHandler::UnmapViewOfFile(%08xh,%08xh)\n",
    1078            pHMHandleData->hHMHandle,
    1079            lpBaseAddress));
    1080 
    1081   return(FALSE);
    1082 }
    1083 
    1084 
    1085 /*****************************************************************************
    1086  * Name      : DWORD HMDeviceHandler::FlushViewOfFile
    1087  * Purpose   : flush memory mapped file
    1088  * Parameters: PHMHANDLEDATA pHMHandleData
    1089  *             LPVOID        lpBaseAddress
    1090  *             DWORD         dwNumberOfBytesToFlush
    1091  * Variables :
    1092  * Result    : TRUE / FALSE
    1093  * Remark    :
    1094  * Status    :
    1095  *
    1096  * Author    : Patrick Haller [Wed, 1999/06/17 20:44]
    1097  *****************************************************************************/
    1098 
    1099 BOOL HMDeviceHandler::FlushViewOfFile(PHMHANDLEDATA pHMHandleData,
    1100                                       LPVOID        lpBaseAddress,
    1101                                       DWORD         dwNumberOfBytesToFlush)
    1102 {
    1103   dprintf(("KERNEL32: HandleManager::DeviceHandler::FlushViewOfFile(%08xh,%08xh,%08xh)\n",
    1104            pHMHandleData->hHMHandle,
    1105            lpBaseAddress,
    1106            dwNumberOfBytesToFlush));
    1107 
    1108   return(FALSE);
    1109 }
    1110 

  • trunk/src/kernel32/hmdevice.h

    r659 r664  
    1 /* $Id: hmdevice.h,v 1.4 1999-08-24 14:36:05 phaller Exp $ */
     1/* $Id: hmdevice.h,v 1.5 1999-08-24 18:46:39 sandervl Exp $ */
    22
    33/*
    … …  
    2121 *****************************************************************************/
    2222
     23/*****************************************************************************
     24 * defines                                                                   *
     25 *****************************************************************************/
     26
     27#define HMTYPE_UNKNOWN  0
     28#define HMTYPE_MEMMAP   1
     29//.....
    2330
    2431/*****************************************************************************
    … …  
    3643  DWORD           dwCreation;                       /* dwCreationDisposition */
    3744  DWORD           dwFlags;                           /* flags and attributes */
     45
     46  DWORD           dwUserData;
     47  DWORD           dwInternalType;
    3848
    3949  LPVOID          lpHandlerData;    /* for private use of the device handler */
    … …  
    239249                                 LPLONG        lpPreviousCount);
    240250
    241 
    242   /***************************************************************************
    243    * File Mappings                                                           *
    244    ***************************************************************************/
    245 
    246251                /* this is a handler method for calls to CreateFileMapping() */
    247252  virtual DWORD CreateFileMapping   (PHMHANDLEDATA              pHMHandleData,
    … …  
    251256                                     DWORD                      dwMaximumSizeHigh,
    252257                                     DWORD                      dwMaximumSizeLow,
    253                                      LPCTSTR                    lpName);
     258                                     LPCSTR                     lpName);
    254259
    255260                  /* this is a handler method for calls to OpenFileMapping() */
    256261  virtual DWORD OpenFileMapping     (PHMHANDLEDATA              pHMHandleData,
     262                                     DWORD access,   /* [in] Access mode */
    257263                                     BOOL                       fInherit,
    258                                      LPCTSTR                    lpName);
    259 
    260                     /* this is a handler method for calls to MapViewOfFile() */
    261   virtual LPVOID MapViewOfFile      (PHMHANDLEDATA              pHMHandleData,
    262                                      DWORD                      dwDesiredAccess,
    263                                      DWORD                      dwFileOffsetHigh,
    264                                      DWORD                      dwFileOffsetLow,
    265                                      DWORD                      dwNumberOfBytesToMap);
    266 
    267                   /* this is a handler method for calls to MapViewOfFileEx() */
     264                                     LPCSTR                     lpName);
     265
     266                    /* this is a handler method for calls to MapViewOfFileEx() */
    268267  virtual LPVOID MapViewOfFileEx    (PHMHANDLEDATA              pHMHandleData,
    269268                                     DWORD                      dwDesiredAccess,
    … …  
    271270                                     DWORD                      dwFileOffsetLow,
    272271                                     DWORD                      dwNumberOfBytesToMap,
    273                                      LPVOID                     lpBaseAddress);
    274 
    275                   /* this is a handler method for calls to UnmapViewOfFile() */
    276   virtual BOOL UnmapViewOfFile      (PHMHANDLEDATA              pHMHandleData,
    277                                      LPVOID                     lpBaseAddress);
    278 
    279                   /* this is a handler method for calls to FlushViewOfFile() */
    280   virtual BOOL FlushViewOfFile      (PHMHANDLEDATA              pHMHandleData,
    281                                      LPVOID                     lpBaseAddress,
    282                                      DWORD                      dwNumberOfBytesToFlush);
     272                                     LPVOID                     lpBaseAddress);
    283273
    284274};

  • trunk/src/kernel32/makefile

    r659 r664  
    1 # $Id: makefile,v 1.28 1999-08-24 14:36:05 phaller Exp $
     1# $Id: makefile,v 1.29 1999-08-24 18:46:39 sandervl Exp $
    22
    33#
    … …  
    2727 WIN32UTIL.OBJ heap.OBJ heapstring.obj os2heap.OBJ \
    2828 vmutex.OBJ initterm.OBJ os2util.OBJ handlemanager.OBJ \
    29  hmdevice.obj hmopen32.obj hmobjects.obj hmevent.obj hmfilemapping.obj \
     29 hmdevice.obj hmopen32.obj hmobjects.obj hmevent.obj \
    3030 hmmutex.obj hmsemaphore.obj wprocess.OBJ conprop.OBJ \
    3131 winimage.OBJ windll.OBJ winexe.OBJ time.obj mmap.obj \
    3232 pefile.OBJ winimgres.OBJ wintls.obj async.OBJ fileio.obj \
    33  atom.obj disk.obj directory.obj cvtbitmap.obj \
     33 atom.obj disk.obj directory.obj cvtbitmap.obj hmmmap.obj \
    3434 cvtmenu.obj cvtaccel.obj cvticon.obj cvticongrp.obj \
    35  cvtcursor.obj cvtcursorgrp.obj stubs.obj
     35 cvtcursor.obj cvtcursorgrp.obj stubs.obj 
    3636
    3737
    … …  
    251251handlemanager.OBJ: \
    252252        .\handlemanager.cpp \
     253        .\hmevent.h \
     254        .\hmmutex.h \
     255        .\hmopen32.h \
     256        .\hmsemaphore.h \
     257        .\hmmmap.h \
    253258        $(PDWIN32_INCLUDE)\handlemanager.h
    254259
    … …  
    286291        .\hmopen32.h
    287292
    288 hmfilemapping.obj: \
    289         .\hmfilemapping.cpp \
    290         .\hmfilemapping.h \
    291         .\hmdevice.h
     293hmmmap.obj: hmmmap.cpp hmdevice.h hmopen32.h mmap.h
    292294
    293295conprop.OBJ: \
    … …  
    301303        $(PDWIN32_INCLUDE)\unicode.h
    302304
    303 virtual.obj:   virtual.cpp $(PDWIN32_INCLUDE)\win\virtual.h mmap.h
     305virtual.obj:   virtual.cpp $(PDWIN32_INCLUDE)\win\virtual.h $(PDWIN32_INCLUDE)\handlemanager.h
    304306mmap.obj:      mmap.cpp mmap.h $(PDWIN32_INCLUDE)\vmutex.h
    305307

  • trunk/src/kernel32/mmap.cpp

    r657 r664  
    1 /* $Id: mmap.cpp,v 1.7 1999-08-24 12:23:54 sandervl Exp $ */
     1/* $Id: mmap.cpp,v 1.8 1999-08-24 18:46:40 sandervl Exp $ */
    22
    33/*
    … …  
    3636//******************************************************************************
    3737Win32MemMap::Win32MemMap(HFILE hfile, ULONG size, ULONG fdwProtect, LPSTR lpszName)
    38                : fMapped(FALSE), pMapping(NULL), mMapAccess(0)
     38               : fMapped(FALSE), pMapping(NULL), mMapAccess(0), referenced(0)
    3939{
    4040  globalmapMutex.enter();
    … …  
    5656//******************************************************************************
    5757//******************************************************************************
    58 HANDLE Win32MemMap::Init()
     58BOOL Win32MemMap::Init(HANDLE hMemMap)
    5959{
    6060  mapMutex.enter();
    … …  
    6868        }
    6969  }
    70   if(HMHandleAllocate(&hMemMap, (ULONG)this) != 0)
    71   {
    72         dprintf(("Win32MemMap::Init HMHandleAllocate failed!!"));
    73         DebugInt3();
    74         goto fail;
    75   }
    76   mapMutex.leave();
    77   return hMemMap;
     70  this->hMemMap = hMemMap;
     71  mapMutex.leave();
     72  return TRUE;
    7873fail:
    7974  mapMutex.leave();
    80   return 0;
     75  return FALSE;
    8176}
    8277//******************************************************************************
    … …  
    8479Win32MemMap::~Win32MemMap()
    8580{
    86   unmapFileView();
     81  unmapViewOfFile();
    8782  if(lpszMapName) {
    8883        free(lpszMapName);
    … …  
    120115//******************************************************************************
    121116//******************************************************************************
    122 BOOL Win32MemMap::unmapFileView()
     117BOOL Win32MemMap::unmapViewOfFile()
    123118{
    124119  if(fMapped == FALSE)
    … …  
    137132//******************************************************************************
    138133//******************************************************************************
    139 LPVOID Win32MemMap::mapFileView(ULONG size, ULONG offset, ULONG fdwAccess)
     134LPVOID Win32MemMap::mapViewOfFile(ULONG size, ULONG offset, ULONG fdwAccess)
    140135{
    141136  mapMutex.enter();
    142137  ULONG memFlags = (mProtFlags & (PAGE_READONLY | PAGE_READWRITE | PAGE_WRITECOPY));
    143138  ULONG fAlloc   = 0;
    144 
    145   if(fdwAccess & FILE_MAP_WRITE && mProtFlags & (PAGE_READONLY|PAGE_WRITECOPY))
    146         goto parmfail;
    147   if(fdwAccess & FILE_MAP_READ && mProtFlags & PAGE_WRITECOPY)
    148         goto parmfail;
    149   if(fdwAccess & FILE_MAP_ALL_ACCESS && mProtFlags & (PAGE_READONLY|PAGE_WRITECOPY))
    150         goto parmfail;
    151   if(fdwAccess & FILE_MAP_COPY && mProtFlags & PAGE_WRITECOPY)
     139  LPVOID mapview;
     140
     141  if(fdwAccess & (FILE_MAP_WRITE|FILE_MAP_ALL_ACCESS) && !(mProtFlags & PAGE_READWRITE))
     142        goto parmfail;
     143  if(fdwAccess & FILE_MAP_READ && !(mProtFlags & (PAGE_READWRITE|PAGE_READONLY)))
     144        goto parmfail;
     145  if(fdwAccess & FILE_MAP_COPY && !(mProtFlags & PAGE_WRITECOPY))
    152146        goto parmfail;
    153147 
    … …  
    157151        fAlloc |= MEM_RESERVE;
    158152
    159   pMapping = VirtualAlloc(0, mSize, fAlloc, memFlags);
    160   if(pMapping == NULL) {
    161         dprintf(("Win32MemMap::mapFileView: VirtualAlloc %x %x %x failed!", mSize, fAlloc, memFlags));
    162         goto fail;
    163   }
    164   mapMutex.leave();
    165   return pMapping;
     153  if(fMapped == FALSE) {//if not mapped, reserve/commit entire view
     154        pMapping = VirtualAlloc(0, mSize, fAlloc, mProtFlags);
     155        if(pMapping == NULL) {
     156                dprintf(("Win32MemMap::mapFileView: VirtualAlloc %x %x %x failed!", mSize, fAlloc, memFlags));
     157                goto fail;
     158        }
     159        fMapped = TRUE;
     160  }
     161  mapview = (LPVOID)((ULONG)pMapping + offset);
     162  mapMutex.leave();
     163  return mapview;
    166164
    167165parmfail:

  • trunk/src/kernel32/mmap.h

    r657 r664  
    1 /* $Id: mmap.h,v 1.5 1999-08-24 12:23:54 sandervl Exp $ */
     1/* $Id: mmap.h,v 1.6 1999-08-24 18:46:40 sandervl Exp $ */
    22
    33/*
    … …  
    2525  ~Win32MemMap();
    2626
    27    HANDLE Init();
     27   BOOL   Init(HANDLE hMemMap);
    2828   BOOL   flushView(LPVOID lpvBase, ULONG cbFlush);
    29    LPVOID mapFileView(ULONG size, ULONG offset, ULONG fdwAccess);
    30    BOOL   unmapFileView();
     29   LPVOID mapViewOfFile(ULONG size, ULONG offset, ULONG fdwAccess);
     30   BOOL   unmapViewOfFile();
    3131
    3232   HFILE  getMapHandle()                 { return hMemMap; };
    3333   LPSTR  getMemName()                   { return lpszMapName; };
     34   DWORD  getProtFlags()                 { return mProtFlags; };
     35
     36   void   AddRef()                       { ++referenced; };
     37   void   Release()                      { if(--referenced == 0) delete this; };
    3438
    3539static Win32MemMap *findMap(LPSTR lpszName);
    … …  
    4549   BOOL   fMapped;
    4650
     51   ULONG  referenced;
     52
    4753   VMutex mapMutex;
    4854
Note: See TracChangeset for help on using the changeset viewer.