Changeset 673 for trunk/src


Ignore:
Timestamp:
Aug 25, 1999, 10:57:14 AM (26 years ago)
Author:
phaller
Message:

Add: HMDeviceMemMapClass fixed

Location:
trunk/src/kernel32
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/kernel32/HandleManager.cpp

    r664 r673  
    1 /* $Id: HandleManager.cpp,v 1.13 1999-08-24 18:46:38 sandervl Exp $ */
     1/* $Id: HandleManager.cpp,v 1.14 1999-08-25 08:55:17 phaller Exp $ */
    22
    33/*
    … …  
    22792279                                                  /* call the device handler */
    22802280  rc = pDeviceHandler->OpenFileMapping(&TabWin32Handles[iIndexNew].hmHandleData,
    2281                                        fdwAccess,
     2281                                       fdwAccess,
    22822282                                       fInherit,
    22832283                                       lpName);
    … …  
    22902290
    22912291  return iIndexNew;                                   /* return valid handle */
     2292}
     2293
     2294
     2295/*****************************************************************************
     2296 * Name      : HMMapViewOfFile
     2297 * Purpose   : router function for MapViewOfFile
     2298 * Parameters:
     2299 * Variables :
     2300 * Result    :
     2301 * Remark    :
     2302 * Status    :
     2303 *
     2304 * Author    : Patrick Haller [Wed, 1999/06/17 20:44]
     2305 *****************************************************************************/
     2306
     2307LPVOID HMMapViewOfFile(HANDLE hFileMappingObject,
     2308                       DWORD  dwDesiredAccess,
     2309                       DWORD  dwFileOffsetHigh,
     2310                       DWORD  dwFileOffsetLow,
     2311                       DWORD  dwNumberOfBytesToMap)
     2312{
     2313  int       iIndex;                           /* index into the handle table */
     2314  LPVOID    lpResult;                /* result from the device handler's API */
     2315  PHMHANDLE pHMHandle;       /* pointer to the handle structure in the table */
     2316
     2317                                                          /* validate handle */
     2318  iIndex = _HMHandleQuery(hFileMappingObject);              /* get the index */
     2319  if (-1 == iIndex)                                               /* error ? */
     2320  {
     2321    SetLastError(ERROR_INVALID_HANDLE);       /* set win32 error information */
     2322    return (NULL);                                         /* signal failure */
     2323  }
     2324
     2325  pHMHandle = &TabWin32Handles[iIndex];               /* call device handler */
     2326  lpResult = pHMHandle->pDeviceHandler->MapViewOfFile(&pHMHandle->hmHandleData,
     2327                                                      dwDesiredAccess,
     2328                                                      dwFileOffsetHigh,
     2329                                                      dwFileOffsetLow,
     2330                                                      dwNumberOfBytesToMap);
     2331
     2332  return (lpResult);                                  /* deliver return code */
    22922333}
    22932334
    … …  
    23352376}
    23362377
     2378
     2379/*****************************************************************************
     2380 * Name      : HMUnmapViewOfFile
     2381 * Purpose   : router function for UnmapViewOfFile
     2382 * Parameters:
     2383 * Variables :
     2384 * Result    :
     2385 * Remark    :
     2386 * Status    :
     2387 *
     2388 * Author    : Patrick Haller [Wed, 1999/06/17 20:44]
     2389 *****************************************************************************/
     2390
     2391BOOL HMUnmapViewOfFile(LPVOID lpBaseAddress)
     2392{
     2393  int       iIndex;                           /* index into the handle table */
     2394  BOOL      bResult;                 /* result from the device handler's API */
     2395  PHMHANDLE pHMHandle;       /* pointer to the handle structure in the table */
     2396
     2397                                                          /* validate handle */
     2398  iIndex = HMDeviceMemMapClass::findByBaseAddress(lpBaseAddress);
     2399  if (-1 == iIndex)                                               /* error ? */
     2400  {
     2401    SetLastError(ERROR_INVALID_HANDLE);       /* set win32 error information */
     2402    return (NULL);                                         /* signal failure */
     2403  }
     2404
     2405  bResult = pHMHandle->pDeviceHandler->UnmapViewOfFile(&pHMHandle->hmHandleData,
     2406                                                       lpBaseAddress);
     2407
     2408  return (bResult);                                   /* deliver return code */
     2409}
     2410
     2411
     2412/*****************************************************************************
     2413 * Name      : HMFlushViewOfFile
     2414 * Purpose   : router function for FlushViewOfFile
     2415 * Parameters:
     2416 * Variables :
     2417 * Result    :
     2418 * Remark    :
     2419 * Status    :
     2420 *
     2421 * Author    : Patrick Haller [Wed, 1999/06/17 20:44]
     2422 *****************************************************************************/
     2423
     2424BOOL HMFlushViewOfFile(LPVOID lpBaseAddress,
     2425                       DWORD  dwNumberOfBytesToFlush)
     2426{
     2427  int       iIndex;                           /* index into the handle table */
     2428  BOOL      bResult;                 /* result from the device handler's API */
     2429  PHMHANDLE pHMHandle;       /* pointer to the handle structure in the table */
     2430
     2431                                                          /* validate handle */
     2432  iIndex = HMDeviceMemMapClass::findByBaseAddress(lpBaseAddress);
     2433  if (-1 == iIndex)                                               /* error ? */
     2434  {
     2435    SetLastError(ERROR_INVALID_HANDLE);       /* set win32 error information */
     2436    return (NULL);                                         /* signal failure */
     2437  }
     2438
     2439  bResult = pHMHandle->pDeviceHandler->FlushViewOfFile(&pHMHandle->hmHandleData,
     2440                                                       lpBaseAddress,
     2441                                                       dwNumberOfBytesToFlush);
     2442
     2443  return (bResult);                                  /* deliver return code */
     2444}
     2445
     2446
     2447
    23372448/*****************************************************************************
    23382449 * Name      : HMWaitForMultipleObjects

  • trunk/src/kernel32/hmdevice.cpp

    r664 r673  
    1 /* $Id: hmdevice.cpp,v 1.4 1999-08-24 18:46:39 sandervl Exp $ */
     1/* $Id: hmdevice.cpp,v 1.5 1999-08-25 08:55:18 phaller Exp $ */
    22
    33/*
    … …  
    983983  dprintf(("KERNEL32: HandleManager::DeviceHandler::OpenFileMapping(%08xh,%08xh,%08xh,%08xh)\n",
    984984           pHMHandleData->hHMHandle,
    985            fdwAccess,
     985           fdwAccess,
    986986           fInherit,
    987987           lpName));
    … …  
    10061006 *****************************************************************************/
    10071007
    1008 LPVOID HMDeviceHandler::MapViewOfFileEx(PHMHANDLEDATA pHMHandleData,
     1008LPVOID HMDeviceHandler::MapViewOfFile(PHMHANDLEDATA pHMHandleData,
    10091009                                      DWORD         dwDesiredAccess,
    10101010                                      DWORD         dwFileOffsetHigh,
    10111011                                      DWORD         dwFileOffsetLow,
    1012                                       DWORD         dwNumberOfBytesToMap,
    1013                                       LPVOID        lpBaseAddress)
     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
     1042LPVOID HMDeviceHandler::MapViewOfFileEx(PHMHANDLEDATA pHMHandleData,
     1043                                        DWORD         dwDesiredAccess,
     1044                                        DWORD         dwFileOffsetHigh,
     1045                                        DWORD         dwFileOffsetLow,
     1046                                        DWORD         dwNumberOfBytesToMap,
     1047                                        LPVOID        lpBaseAddress)
    10141048{
    10151049  dprintf(("KERNEL32: HandleManager::DeviceHandler::MapViewOfFileEx(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh)\n",
    … …  
    10221056  return(NULL);
    10231057}
     1058
     1059
     1060/*****************************************************************************
     1061 * Name      : DWORD HMDeviceHandler::UnmapViewOfFile
     1062 * Purpose   : map memory mapped file
     1063 * Parameters: PHMHANDLEDATA pHMHandleData
     1064 *             LPVOID        lpBaseAddress
     1065 * Variables :
     1066 * Result    : address to memory mapped region
     1067 * Remark    :
     1068 * Status    :
     1069 *
     1070 * Author    : Patrick Haller [Wed, 1999/06/17 20:44]
     1071 *****************************************************************************/
     1072
     1073BOOL HMDeviceHandler::UnmapViewOfFile(PHMHANDLEDATA pHMHandleData,
     1074                                      LPVOID        lpBaseAddress)
     1075{
     1076  dprintf(("KERNEL32: HandleManager::DeviceHandler::UnmapViewOfFile(%08xh,%08xh)\n",
     1077           pHMHandleData->hHMHandle,
     1078           lpBaseAddress));
     1079
     1080  return(FALSE);
     1081}
     1082
     1083
     1084/*****************************************************************************
     1085 * Name      : DWORD HMDeviceHandler::FlushViewOfFile
     1086 * Purpose   : map memory mapped file
     1087 * Parameters: PHMHANDLEDATA pHMHandleData
     1088 *             LPVOID        lpBaseAddress
     1089 *             DWORD         dwNumberOfBytesToFlush
     1090 * Variables :
     1091 * Result    : address to memory mapped region
     1092 * Remark    :
     1093 * Status    :
     1094 *
     1095 * Author    : Patrick Haller [Wed, 1999/06/17 20:44]
     1096 *****************************************************************************/
     1097
     1098BOOL HMDeviceHandler::FlushViewOfFile(PHMHANDLEDATA pHMHandleData,
     1099                                      LPVOID        lpBaseAddress,
     1100                                      DWORD         dwNumberOfBytesToFlush)
     1101{
     1102  dprintf(("KERNEL32: HandleManager::DeviceHandler::FlushViewOfFile(%08xh,%08xh,%08xh)\n",
     1103           pHMHandleData->hHMHandle,
     1104           lpBaseAddress,
     1105           dwNumberOfBytesToFlush));
     1106
     1107  return(FALSE);
     1108}
     1109

  • trunk/src/kernel32/hmdevice.h

    r664 r673  
    1 /* $Id: hmdevice.h,v 1.5 1999-08-24 18:46:39 sandervl Exp $ */
     1/* $Id: hmdevice.h,v 1.6 1999-08-25 08:55:18 phaller Exp $ */
    22
    33/*
    … …  
    2525 *****************************************************************************/
    2626
    27 #define HMTYPE_UNKNOWN  0
    28 #define HMTYPE_MEMMAP   1
     27#define HMTYPE_UNKNOWN                   0
     28#define HMTYPE_MEMMAP                    1
    2929//.....
    3030
    … …  
    232232   ***************************************************************************/
    233233
    234                      /* this is a handler method for calls to CreateSemaphore() */
     234                  /* this is a handler method for calls to CreateSemaphore() */
    235235  virtual DWORD CreateSemaphore (PHMHANDLEDATA         pHMHandleData,
    236236                                 LPSECURITY_ATTRIBUTES lpsa,
    … …  
    239239                                 LPCSTR                lpszSemaphoreName);
    240240
    241                        /* this is a handler method for calls to OpenSemaphore() */
     241                    /* this is a handler method for calls to OpenSemaphore() */
    242242  virtual DWORD OpenSemaphore   (PHMHANDLEDATA         pHMHandleData,
    243243                                 BOOL                  fInheritHandle,
    244244                                 LPCSTR                lpszSemaphoreName);
    245245
    246                      /* this is a handle method for calls to ReleaseSemaphore() */
     246                  /* this is a handle method for calls to ReleaseSemaphore() */
    247247  virtual BOOL  ReleaseSemaphore(PHMHANDLEDATA pHMHandleData,
    248248                                 LONG          cReleaseCount,
    … …  
    260260                  /* this is a handler method for calls to OpenFileMapping() */
    261261  virtual DWORD OpenFileMapping     (PHMHANDLEDATA              pHMHandleData,
    262                                      DWORD access,   /* [in] Access mode */
     262                                     DWORD access,   /* [in] Access mode */
    263263                                     BOOL                       fInherit,
    264264                                     LPCSTR                     lpName);
    265265
    266                     /* this is a handler method for calls to MapViewOfFileEx() */
     266                    /* this is a handler method for calls to MapViewOfFile() */
     267  virtual LPVOID MapViewOfFile      (PHMHANDLEDATA              pHMHandleData,
     268                                     DWORD                      dwDesiredAccess,
     269                                     DWORD                      dwFileOffsetHigh,
     270                                     DWORD                      dwFileOffsetLow,
     271                                     DWORD                      dwNumberOfBytesToMap);
     272
     273                  /* this is a handler method for calls to MapViewOfFileEx() */
    267274  virtual LPVOID MapViewOfFileEx    (PHMHANDLEDATA              pHMHandleData,
    268275                                     DWORD                      dwDesiredAccess,
    … …  
    270277                                     DWORD                      dwFileOffsetLow,
    271278                                     DWORD                      dwNumberOfBytesToMap,
    272                                      LPVOID                     lpBaseAddress);
     279                                     LPVOID                     lpBaseAddress);
     280
     281                  /* this is a handler method for calls to UnmapViewOfFile() */
     282  virtual BOOL   UnmapViewOfFile    (PHMHANDLEDATA              pHMHandleData,
     283                                     LPVOID                     lpBaseAddress);
     284
     285                  /* this is a handler method for calls to FlushViewOfFile() */
     286  virtual BOOL   FlushViewOfFile    (PHMHANDLEDATA              pHMHandleData,
     287                                     LPVOID                     lpBaseAddress,
     288                                     DWORD                      dwNumberOfBytesToFlush);
    273289
    274290};

  • trunk/src/kernel32/hmmmap.cpp

    r664 r673  
    1 /* $Id: hmmmap.cpp,v 1.1 1999-08-24 18:47:33 sandervl Exp $ */
     1/* $Id: hmmmap.cpp,v 1.2 1999-08-25 08:55:18 phaller Exp $ */
    22
    33/*
    … …  
    4747//******************************************************************************
    4848DWORD HMDeviceMemMapClass::CreateFileMapping(PHMHANDLEDATA         pHMHandleData,
    49                                              HFILE hFile, 
     49                                             HFILE hFile,
    5050                                             SECURITY_ATTRIBUTES *sa, /* [in] Optional security attributes*/
    5151                                             DWORD protect,   /* [in] Protection for mapping object */
    5252                                             DWORD size_high, /* [in] High-order 32 bits of object size */
    5353                                             DWORD size_low,  /* [in] Low-order 32 bits of object size */
    54                                              LPCSTR name)     /* [in] Name of file-mapping object */ 
     54                                             LPCSTR name)     /* [in] Name of file-mapping object */
    5555{
    5656 Win32MemMap *map;
    … …  
    5858  if((hFile == -1 && size_low == 0) || size_high ||
    5959     protect & (PAGE_READONLY|PAGE_READWRITE|PAGE_WRITECOPY|SEC_COMMIT|SEC_IMAGE|SEC_RESERVE|SEC_NOCACHE) ||
    60      ((protect & SEC_COMMIT) && (protect & SEC_RESERVE))) 
     60     ((protect & SEC_COMMIT) && (protect & SEC_RESERVE)))
    6161  {
    6262
    … …  
    7070        dprintf(("CreateFileMappingA: can't create Win32MemMap object!"));
    7171        return ERROR_OUTOFMEMORY;
    72   } 
     72  }
    7373
    7474  if(map->Init(pHMHandleData->hHMHandle) == FALSE) {
    … …  
    155155//******************************************************************************
    156156//******************************************************************************
     157LPVOID HMDeviceMemMapClass::MapViewOfFile(PHMHANDLEDATA pHMHandleData,
     158                                      DWORD         dwDesiredAccess,
     159                                      DWORD         dwFileOffsetHigh,
     160                                      DWORD         dwFileOffsetLow,
     161                                      DWORD         dwNumberOfBytesToMap)
     162{
     163  dprintf(("KERNEL32: HMDeviceMemMapClass::MapViewOfFile(%08xh,%08xh,%08xh,%08xh,%08xh)\n",
     164           pHMHandleData->hHMHandle,
     165           dwDesiredAccess,
     166           dwFileOffsetHigh,
     167           dwFileOffsetLow,
     168           dwNumberOfBytesToMap));
     169
     170  return MapViewOfFileEx(pHMHandleData,
     171                         dwDesiredAccess,
     172                         dwFileOffsetHigh,
     173                         dwFileOffsetLow,
     174                         dwNumberOfBytesToMap,
     175                         NULL);
     176}
     177
     178//******************************************************************************
     179//******************************************************************************
    157180DWORD HMDeviceMemMapClass::CloseHandle(PHMHANDLEDATA pHMHandleData)
    158181{
    … …  
    170193//******************************************************************************
    171194//******************************************************************************
     195
     196
     197/*****************************************************************************
     198 * Name      : DWORD HMDeviceHandler::findByBaseAddress
     199 * Purpose   : identify a memmap object by its base address
     200 * Parameters: LPVOID        lpBaseAddress
     201 * Variables :
     202 * Result    : PHMHANDLEDATA pHMHandleData
     203 * Remark    :
     204 * Status    :
     205 *
     206 * Author    : Patrick Haller [Wed, 1999/06/17 20:44]
     207 *****************************************************************************/
     208
     209int HMDeviceMemMapClass::findByBaseAddress(LPVOID lpBaseAddress)
     210{
     211  dprintf(("KERNEL32: HandleManager::MemMap::findByBaseAddress(%08xh) not implemented\n",
     212           lpBaseAddress));
     213
     214  return -1;
     215}
     216
     217
     218/*****************************************************************************
     219 * Name      : DWORD HMDeviceHandler::UnmapViewOfFile
     220 * Purpose   : map memory mapped file
     221 * Parameters: PHMHANDLEDATA pHMHandleData
     222 *             LPVOID        lpBaseAddress
     223 * Variables :
     224 * Result    : address to memory mapped region
     225 * Remark    :
     226 * Status    :
     227 *
     228 * Author    : Patrick Haller [Wed, 1999/06/17 20:44]
     229 *****************************************************************************/
     230
     231BOOL HMDeviceMemMapClass::UnmapViewOfFile(PHMHANDLEDATA pHMHandleData,
     232                                          LPVOID        lpBaseAddress)
     233{
     234  dprintf(("KERNEL32: HandleManager::MemMap::UnmapViewOfFile(%08xh,%08xh) not implemented\n",
     235           pHMHandleData->hHMHandle,
     236           lpBaseAddress));
     237
     238  return(FALSE);
     239}
     240
     241
     242/*****************************************************************************
     243 * Name      : DWORD HMDeviceHandler::FlushViewOfFile
     244 * Purpose   : map memory mapped file
     245 * Parameters: PHMHANDLEDATA pHMHandleData
     246 *             LPVOID        lpBaseAddress
     247 *             DWORD         dwNumberOfBytesToFlush
     248 * Variables :
     249 * Result    : address to memory mapped region
     250 * Remark    :
     251 * Status    :
     252 *
     253 * Author    : Patrick Haller [Wed, 1999/06/17 20:44]
     254 *****************************************************************************/
     255
     256BOOL HMDeviceMemMapClass::FlushViewOfFile(PHMHANDLEDATA pHMHandleData,
     257                                          LPVOID        lpBaseAddress,
     258                                          DWORD         dwNumberOfBytesToFlush)
     259{
     260  dprintf(("KERNEL32: HandleManager::MemMap::FlushViewOfFile(%08xh,%08xh,%08xh) not implemented\n",
     261           pHMHandleData->hHMHandle,
     262           lpBaseAddress,
     263           dwNumberOfBytesToFlush));
     264
     265  return(FALSE);
     266}
     267
     268

  • trunk/src/kernel32/hmmmap.h

    r664 r673  
    1 /* $Id: hmmmap.h,v 1.1 1999-08-24 18:47:33 sandervl Exp $ */
     1/* $Id: hmmmap.h,v 1.2 1999-08-25 08:55:19 phaller Exp $ */
    22
    33/*
    … …  
    3434  HMDeviceMemMapClass(LPCSTR lpDeviceName) : HMDeviceKernelObjectClass(lpDeviceName) {}
    3535
     36  // identify a memmap object by its base address
     37  static int findByBaseAddress(LPVOID lpBaseAddress);
     38
     39
    3640  /* this is a handler method for calls to CreateFileMapping() */
    3741  virtual DWORD CreateFileMapping   (PHMHANDLEDATA              pHMHandleData,
    … …  
    4549  /* this is a handler method for calls to OpenFileMapping() */
    4650  virtual DWORD OpenFileMapping     (PHMHANDLEDATA              pHMHandleData,
    47                                      DWORD access,   /* [in] Access mode */
     51                                     DWORD access,   /* [in] Access mode */
    4852                                     BOOL                       fInherit,
    4953                                     LPCSTR                     lpName);
    5054
    5155  /* this is a handler method for calls to MapViewOfFile() */
     56  virtual LPVOID MapViewOfFile      (PHMHANDLEDATA              pHMHandleData,
     57                                     DWORD                      dwDesiredAccess,
     58                                     DWORD                      dwFileOffsetHigh,
     59                                     DWORD                      dwFileOffsetLow,
     60                                     DWORD                      dwNumberOfBytesToMap);
     61
     62  /* this is a handler method for calls to MapViewOfFileEx() */
    5263  virtual LPVOID MapViewOfFileEx    (PHMHANDLEDATA              pHMHandleData,
    5364                                     DWORD                      dwDesiredAccess,
    … …  
    5566                                     DWORD                      dwFileOffsetLow,
    5667                                     DWORD                      dwNumberOfBytesToMap,
    57                                      LPVOID                     lpBaseAddress);
     68                                     LPVOID                     lpBaseAddress);
    5869
     70                  /* this is a handler method for calls to UnmapViewOfFile() */
     71  virtual BOOL   UnmapViewOfFile    (PHMHANDLEDATA              pHMHandleData,
     72                                     LPVOID                     lpBaseAddress);
     73
     74                  /* this is a handler method for calls to FlushViewOfFile() */
     75  virtual BOOL   FlushViewOfFile    (PHMHANDLEDATA              pHMHandleData,
     76                                     LPVOID                     lpBaseAddress,
     77                                     DWORD                      dwNumberOfBytesToFlush);
     78
     79
     80                  /* this is a handler method for calls to CloseHandle() */
    5981  virtual DWORD  CloseHandle(PHMHANDLEDATA pHMHandleData);
    6082};

  • trunk/src/kernel32/os2native.cpp

    r657 r673  
    1 /* $Id: os2native.cpp,v 1.6 1999-08-24 12:23:24 sandervl Exp $ */
     1/* $Id: os2native.cpp,v 1.7 1999-08-25 08:57:14 phaller Exp $ */
    22
    33/*
    … …  
    2020#define INCL_DOSMEMMGR
    2121#define INCL_DOSPROCESS
    22 #include <os2wrap.h>    //Odin32 OS/2 api wrappers
     22#include <os2wrap.h>                     //Odin32 OS/2 api wrappers
    2323#include <stdlib.h>
    2424#include <stdio.h>
    … …  
    8080  if (cbSize > 0x7fc00000)  /* 2Gb - 4Mb */
    8181  {
    82         dprintf(("VirtualAlloc: size too large"));
     82   dprintf(("VirtualAlloc: size too large"));
    8383//        SetLastError( ERROR_OUTOFMEMORY );
    8484        return NULL;
    … …  
    8888       (fdwAllocationType & ~(MEM_COMMIT | MEM_RESERVE)))
    8989  {
    90         dprintf(("VirtualAlloc: Invalid parameter"));
     90   dprintf(("VirtualAlloc: Invalid parameter"));
    9191//        SetLastError( ERROR_INVALID_PARAMETER );
    9292        return NULL;
    … …  
    103103  if(fdwProtect & PAGE_EXECUTE_READWRITE) flag |= (PAG_EXECUTE | PAG_WRITE | PAG_READ);
    104104  if(fdwProtect & PAGE_EXECUTE_READ) flag |= (PAG_EXECUTE | PAG_READ);
    105   if(fdwProtect & PAGE_EXECUTE)      flag |= PAG_EXECUTE;
     105  if(fdwProtect & PAGE_EXECUTE)               flag |= PAG_EXECUTE;
    106106
    107107  if(fdwProtect & PAGE_GUARD)        flag |= PAG_GUARD;
    108108
    109109  //just do this if other options are used
    110   if(!(flag & (PAG_READ | PAG_WRITE | PAG_EXECUTE)) || flag == 0) {
    111         dprintf(("VirtualAlloc: Unknown protection flags, default to read/write"));
    112         flag |= PAG_READ | PAG_WRITE;
    113   }
    114 
    115   if(fdwAllocationType & MEM_COMMIT && lpvAddress != NULL) {
    116         Address = lpvAddress;
    117 
    118         rc = DosSetMem(lpvAddress, cbSize, flag);
     110  if(!(flag & (PAG_READ | PAG_WRITE | PAG_EXECUTE)) || flag == 0)
     111  {
     112    dprintf(("VirtualAlloc: Unknown protection flags, default to read/write"));
     113      flag |= PAG_READ | PAG_WRITE;
     114  }
     115
     116  if(fdwAllocationType & MEM_COMMIT && lpvAddress != NULL)
     117  {
     118    Address = lpvAddress;
     119
     120    rc = DosSetMem(lpvAddress, cbSize, flag);
    119121        //might try to commit larger part with same base address
    120         if(rc == ERROR_ACCESS_DENIED && cbSize > 4096 ) {//knut: AND more than one page
    121                 char *newbase = (char *)lpvAddress + ((cbSize-1) & 0xFFFFF000); //knut: lets not start after the last page!
    122                 ULONG size, os2flags;
    123 
    124                 while(newbase >= (char *)lpvAddress) {  //knut: should check first page to!!
    125                         size     = 4096;
    126                         os2flags = 0;
    127                         rc = DosQueryMem(newbase, &size, &os2flags);
    128                         if(rc)  break;
    129                         if(os2flags & PAG_COMMIT) {
    130                                 newbase += 4096;
    131                                 break;
    132                         }
    133                         newbase -= 4096;
    134                 }
    135                 if(rc == 0) {
    136                         //In case it wants to commit bytes that fall into the last
    137                         //page of the previous commit command
    138                         if(cbSize > ((int)newbase - (int)lpvAddress)) {
    139                                 rc = DosSetMem(newbase, cbSize - ((int)newbase - (int)lpvAddress), flag);
    140                         }
    141                 }
    142                 else    return(NULL);
     122    if(rc == ERROR_ACCESS_DENIED && cbSize > 4096 )
     123    { //knut: AND more than one page
     124      char *newbase = (char *)lpvAddress + ((cbSize-1) & 0xFFFFF000); //knut: lets not start after the last page!
     125      ULONG size, os2flags;
     126
     127      while(newbase >= (char *)lpvAddress)
     128      {  //knut: should check first page to!!
     129        size     = 4096;
     130        os2flags = 0;
     131        rc = DosQueryMem(newbase, &size, &os2flags);
     132        if(rc)
     133          break;
     134
     135        if(os2flags & PAG_COMMIT)
     136        {
     137          newbase += 4096;
     138          break;
    143139        }
    144         else
    145         {
    146                 if(rc == ERROR_INVALID_ADDRESS)
    147                 {
    148                         rc = DosAllocMem(&Address, cbSize, flag | flAllocMem );
    149                 }
    150                 else   
    151                 if(rc)  dprintf(("Unexpected DosSetMem error %x", rc));
    152         }
    153   }
    154   else {
     140        newbase -= 4096;
     141      }
     142
     143      if(rc == 0)
     144      {
     145        //In case it wants to commit bytes that fall into the last
     146        //page of the previous commit command
     147        if(cbSize > ((int)newbase - (int)lpvAddress))
     148          rc = DosSetMem(newbase, cbSize - ((int)newbase - (int)lpvAddress), flag);
     149      }
     150      else
     151        return(NULL);
     152
     153    }
     154    else
     155    {
     156      if(rc == ERROR_INVALID_ADDRESS)
     157        rc = DosAllocMem(&Address, cbSize, flag | flAllocMem );
     158      else
     159        if(rc)
     160          dprintf(("Unexpected DosSetMem error %x", rc));
     161    }
     162  }
     163  else
     164  {
    155165    /*knut: flAllocMem */
    156166    rc = DosAllocMem(&Address, cbSize, flag | flAllocMem );
    … …  
    158168
    159169  //TODO: Set last error in case rc != 0
    160   if(rc) {
    161         dprintf(("DosSetMem returned %d\n", rc));
     170  if(rc)
     171  {
     172    dprintf(("DosSetMem returned %d\n", rc));
    162173//        SetLastError( ERROR_OUTOFMEMORY );
    163         return(NULL);
     174    return(NULL);
    164175  }
    165176
    … …  
    265276
    266277  if(lpvAddress == NULL || pmbiBuffer == NULL || cbLength == 0) {
    267         return 0;
     278   return 0;
    268279  }
    269280  cbRangeSize = cbLength;
    270281  rc = DosQueryMem(lpvAddress, &cbRangeSize, &dAttr);
    271282  if(rc) {
    272         dprintf(("VirtualQuery - DosQueryMem %x %x returned %d\n", lpvAddress, cbLength, rc));
    273         return 0;
     283   dprintf(("VirtualQuery - DosQueryMem %x %x returned %d\n", lpvAddress, cbLength, rc));
     284   return 0;
    274285  }
    275286  memset(pmbiBuffer, 0, sizeof(MEMORY_BASIC_INFORMATION));
    … …  
    291302
    292303  if(dAttr & PAG_FREE)
    293         pmbiBuffer->State = MEM_FREE;
     304   pmbiBuffer->State = MEM_FREE;
    294305  else
    295306  if(dAttr & PAG_COMMIT)
    296         pmbiBuffer->State = MEM_COMMIT;
    297   else  pmbiBuffer->State = MEM_RESERVE;
    298  
     307   pmbiBuffer->State = MEM_COMMIT;
     308  else   pmbiBuffer->State = MEM_RESERVE;
     309
    299310  if(!(dAttr & PAG_SHARED))
    300         pmbiBuffer->Type = MEM_PRIVATE;
     311   pmbiBuffer->Type = MEM_PRIVATE;
    301312
    302313  //TODO: This is not correct: AllocationProtect should contain the protection
    … …  
    304315  pmbiBuffer->AllocationProtect = pmbiBuffer->Protect;
    305316  if(dAttr & PAG_BASE) {
    306         pmbiBuffer->AllocationBase = lpvAddress;
     317   pmbiBuffer->AllocationBase = lpvAddress;
    307318  }
    308319  else {
    309         while(lpvAddress > 0) {
    310                 rc = DosQueryMem(lpvAddress, &cbRangeSize, &dAttr);
    311                 if(rc) {
    312                         dprintf(("VirtualQuery - DosQueryMem %x %x returned %d\n", lpvAddress, cbLength, rc));
    313                         break;
    314                 }
    315                 if(dAttr & PAG_BASE) {
    316                         pmbiBuffer->AllocationBase = lpvAddress;
    317                         break;
    318                 }
    319                 lpvAddress = (LPVOID)((ULONG)lpvAddress - PAGE_SIZE);
    320         }
     320   while(lpvAddress > 0) {
     321      rc = DosQueryMem(lpvAddress, &cbRangeSize, &dAttr);
     322      if(rc) {
     323         dprintf(("VirtualQuery - DosQueryMem %x %x returned %d\n", lpvAddress, cbLength, rc));
     324         break;
     325      }
     326      if(dAttr & PAG_BASE) {
     327         pmbiBuffer->AllocationBase = lpvAddress;
     328         break;
     329      }
     330      lpvAddress = (LPVOID)((ULONG)lpvAddress - PAGE_SIZE);
     331   }
    321332  }
    322333  return sizeof(MEMORY_BASIC_INFORMATION);

  • trunk/src/kernel32/virtual.cpp

    r657 r673  
    1 /* $Id: virtual.cpp,v 1.2 1999-08-24 12:23:25 sandervl Exp $ */
     1/* $Id: virtual.cpp,v 1.3 1999-08-25 08:55:19 phaller Exp $ */
    22
    33/*
    … …  
    2020#include <heapstring.h>
    2121#include "mmap.h"
     22#include <handlemanager.h>
    2223
    2324/***********************************************************************
    … …  
    3839                LPCSTR name      /* [in] Name of file-mapping object */ )
    3940{
    40  HANDLE dupHandle;
    41 
    42    if((hFile == -1 && size_low == 0) || size_high ||
    43        protect & (PAGE_READONLY|PAGE_READWRITE|PAGE_WRITECOPY|SEC_COMMIT|SEC_IMAGE|SEC_RESERVE|SEC_NOCACHE) ||
    44        ((protect & SEC_COMMIT) && (protect & SEC_RESERVE)))
    45    {
    46 
    47         dprintf(("CreateFileMappingA: invalid parameter (combination)!"));
    48         SetLastError(ERROR_INVALID_PARAMETER);
    49         return 0;       
    50    }
    51    if(DuplicateHandle(GetCurrentProcess(), hFile, GetCurrentProcess(),
    52                         &dupHandle, 0, FALSE, DUPLICATE_SAME_ACCESS) == FALSE)
    53    {
    54         dprintf(("CreateFileMappingA: DuplicateHandle failed!"));
    55         return 0;
    56    }
    57    return dupHandle;
     41  return HMCreateFileMapping(hFile, sa, protect, size_high, size_low, name);
    5842}
    5943
    … …  
    6347 * See CreateFileMapping32A
    6448 */
    65 HANDLE WINAPI CreateFileMappingW( HFILE hFile, LPSECURITY_ATTRIBUTES attr, 
    66                                       DWORD protect, DWORD size_high, 
     49HANDLE WINAPI CreateFileMappingW( HFILE hFile, LPSECURITY_ATTRIBUTES attr,
     50                                      DWORD protect, DWORD size_high,
    6751                                      DWORD size_low, LPCWSTR name )
    6852{
    … …  
    8872                LPCSTR name )   /* [in] Name of file-mapping object */
    8973{
    90     dprintf(("OpenFileMappingA: NOT IMPLEMENTED"));
    91     return 0;
     74  return (HMOpenFileMapping(access, inherit, name));
    9275}
    9376
    … …  
    120103              DWORD offset_low,  /* [in] Low-order 32 bits of file offset */
    121104              DWORD count        /* [in] Number of bytes to map */
    122 ) 
    123 {
    124     return MapViewOfFileEx( mapping, access, offset_high,
    125                             offset_low, count, NULL );
     105)
     106{
     107  return HMMapViewOfFile( mapping, access, offset_high,
     108                          offset_low, count);
    126109}
    127110
    … …  
    142125              DWORD count,       /* [in] Number of bytes to map */
    143126              LPVOID addr        /* [in] Suggested starting address for mapped view */
    144 )
    145 {
    146  DWORD filesize, bytesread;
    147  LPSTR lpBuffer;
    148 
    149    filesize = GetFileSize(handle, 0);
    150    if(filesize == 0) {
    151         dprintf(("MapViewOfFileEx: filesize = 0!"));
    152         return 0;
    153    }
    154    lpBuffer = (LPSTR)VirtualAlloc(0, filesize, MEM_COMMIT, PAGE_READWRITE);
    155    if(lpBuffer == 0) {
    156         dprintf(("MapViewOfFileEx: VirtualAlloc failed (%d bytes)!", filesize));
    157         return 0;
    158    }
    159    if(ReadFile(handle, lpBuffer, filesize, &bytesread, NULL) == FALSE) {
    160         dprintf(("MapViewOfFileEx: ReadFile failed (%d bytes)!", filesize));
    161         VirtualFree(lpBuffer, 0, MEM_RELEASE);
    162         return 0;
    163    }
    164    return lpBuffer;
     127)
     128{
     129  return HMMapViewOfFileEx( handle, access, offset_high,
     130                            offset_low, count, addr);
    165131}
    166132
    … …  
    177143              LPCVOID base, /* [in] Start address of byte range to flush */
    178144              DWORD cbFlush /* [in] Number of bytes in range */
    179 )
    180 {
    181     dprintf(("FlushViewOfFile: NOT IMPLEMENTED"));
    182     return TRUE;
     145)
     146{
     147  return HMFlushViewOfFile( (LPVOID)base, cbFlush);
    183148}
    184149
    … …  
    196161 */
    197162BOOL WINAPI UnmapViewOfFile(LPVOID addr /* [in] Address where mapped view begins */
    198 )
    199 {
    200     if (!addr)
    201     {
    202         SetLastError( ERROR_INVALID_PARAMETER );
    203         return FALSE;
    204     }
    205     return VirtualFree(addr, 0, MEM_RELEASE);
    206 }
     163)
     164{
     165  return HMUnmapViewOfFile( addr );
     166}
     167
    207168
    208169/***********************************************************************
    … …  
    210171 *
    211172 * Helper function to map a file to memory:
    212  *  name                        -       file name 
     173 *  name                        -       file name
    213174 *  [RETURN] ptr                -       pointer to mapped file
    214175 */
    … …  
    218179    LPVOID ptr = NULL;
    219180
    220     hFile = CreateFileW( name, GENERIC_READ, FILE_SHARE_READ, NULL, 
     181    hFile = CreateFileW( name, GENERIC_READ, FILE_SHARE_READ, NULL,
    221182                           OPEN_EXISTING, FILE_FLAG_RANDOM_ACCESS, 0);
    222183    if (hFile != INVALID_HANDLE_VALUE)
    … …  
    237198 *
    238199 * Helper function to map a file to memory:
    239  *  name                        -       file name 
     200 *  name                        -       file name
    240201 *  [RETURN] ptr                -       pointer to mapped file
    241202 */
    … …  
    245206    LPVOID ptr = NULL;
    246207
    247     hFile = CreateFileA(name, GENERIC_READ, FILE_SHARE_READ, NULL, 
     208    hFile = CreateFileA(name, GENERIC_READ, FILE_SHARE_READ, NULL,
    248209                        OPEN_EXISTING, FILE_FLAG_RANDOM_ACCESS, 0);
    249210    if (hFile != INVALID_HANDLE_VALUE)
    … …  
    259220    return ptr;
    260221}
     222
Note: See TracChangeset for help on using the changeset viewer.