source: trunk/src/kernel32/hmmmap.cpp

Last change on this file was 21302, checked in by ydario, 16 years ago

Kernel32 updates.
File size: 10.9 KB
RevLine 
[9971]1/* $Id: hmmmap.cpp,v 1.24 2003-04-02 11:03:31 sandervl Exp $ */
[664]2
3/*
4 * Project Odin Software License can be found in LICENSE.TXT
5 * Win32 Unified Handle Manager for OS/2
6 * Copyright 1999 Patrick Haller (haller@zebra.fh-weingarten.de)
7 */
8
9#undef DEBUG_LOCAL
10//#define DEBUG_LOCAL
11
12
13/*****************************************************************************
14 * Remark *
15 *****************************************************************************
16
17 */
18
19
20/*****************************************************************************
21 * Includes *
22 *****************************************************************************/
23
24#include <os2win.h>
25#include <stdlib.h>
26#include <string.h>
27#include "unicode.h"
28#include "misc.h"
29
30#include "HandleManager.H"
31#include "HMMMap.h"
32#include "mmap.h"
[1432]33#include "heapshared.h"
[664]34
[2802]35#define DBG_LOCALLOG DBG_hmmmap
36#include "dbglocal.h"
37
[664]38/*****************************************************************************
39 * Defines *
40 *****************************************************************************/
41
42/*****************************************************************************
43 * Structures *
44 *****************************************************************************/
45
46/*****************************************************************************
47 * Local Prototypes *
48 *****************************************************************************/
49
50//******************************************************************************
51//******************************************************************************
52DWORD HMDeviceMemMapClass::CreateFileMapping(PHMHANDLEDATA pHMHandleData,
[9971]53 HANDLE hFile,
[664]54 SECURITY_ATTRIBUTES *sa, /* [in] Optional security attributes*/
55 DWORD protect, /* [in] Protection for mapping object */
56 DWORD size_high, /* [in] High-order 32 bits of object size */
57 DWORD size_low, /* [in] Low-order 32 bits of object size */
[8456]58 LPCSTR name) /* [in] Name of file-mapping object */
[664]59{
[9948]60 Win32MemMap *map;
[664]61
62 if((hFile == -1 && size_low == 0) || size_high ||
[690]63 protect & ~(PAGE_READONLY|PAGE_READWRITE|PAGE_WRITECOPY|SEC_COMMIT|SEC_IMAGE|SEC_RESERVE|SEC_NOCACHE) ||
[678]64 (protect & (PAGE_READONLY|PAGE_READWRITE|PAGE_WRITECOPY)) == 0 ||
[1914]65// (hFile == -1 && (protect & SEC_COMMIT)) ||
[8456]66 ((protect & SEC_COMMIT) && (protect & SEC_RESERVE)))
[664]67 {
68
69 dprintf(("CreateFileMappingA: invalid parameter (combination)!"));
[1432]70 dprintf(("Parameters: %x %x %x %x %s", hFile, protect, size_high, size_low, name));
[690]71 return ERROR_INVALID_PARAMETER;
[664]72 }
73
[9948]74 //It's not allowed to map a file of length 0 according to MSDN. This time
75 //the docs are correct. (verified in NT4 SP6)
[21302]76 //bird: It's not allowed to create a non-file based mapping with size 0.
[9948]77 //TODO: also need to verify access rights of the file handle (write maps need
78 // write access obviously)
79 if(hFile != -1) {
80 DWORD dwFileSizeLow = 0, dwFileSizeHigh = 0;
81
82 dwFileSizeLow = ::GetFileSize(hFile, &dwFileSizeHigh);
83 if(dwFileSizeHigh == 0 && dwFileSizeLow == 0) {
[21302]84 /*
85 * Two actions, if we can grow the file we should if not fail.
86 */
87 if (!(protect & PAGE_READWRITE)) /* TODO: check this and verify flags */
88 {
[9948]89 dprintf(("CreateFileMappingA: not allowed to map a file with length 0!!"));
[21302]90 return ERROR_NOT_ENOUGH_MEMORY; /* XP returns this if the mapping is readonly, odd.. */
91 }
92 /*
93 * Try extend the file.
94 * (Not sure if we need to preserve the filepointer, but it doesn't hurt I think.)
95 */
96 LONG lFilePosHigh = 0;
97 DWORD dwFilePosLow = ::SetFilePointer(hFile, 0, &lFilePosHigh, FILE_CURRENT);
98 LONG lFileSizeHigh = size_high;
99 if ( ::SetFilePointer(hFile, size_low, &lFileSizeHigh, FILE_BEGIN) == INVALID_SET_FILE_POINTER
100 || !::SetEndOfFile(hFile))
101 {
102 ::SetFilePointer(hFile, dwFilePosLow, &lFilePosHigh, FILE_BEGIN);
103 dprintf(("CreateFileMappingA: unable to grow file to 0x%#08x%08x bytes.\n", size_high, size_low));
104 return ERROR_DISK_FULL;
105 }
106 ::SetFilePointer(hFile, dwFilePosLow, &lFilePosHigh, FILE_BEGIN);
[9948]107 }
108 }
109
[712]110 map = Win32MemMap::findMap((LPSTR)name);
111 if(map != NULL) {
[9824]112 dprintf(("CreateFileMappingA: duplicating map %s!", name));
[664]113
[712]114 DWORD protflags = map->getProtFlags();
115 switch(protect) {
116 case FILE_MAP_WRITE:
117 if(!(protflags & PAGE_WRITECOPY))
118 dprintf(("Different flags for duplicate!"));
119 break;
120 case FILE_MAP_READ:
121 if(!(protflags & (PAGE_READWRITE | PAGE_READONLY)))
122 dprintf(("Different flags for duplicate!"));
123 break;
124 case FILE_MAP_COPY:
125 if(!(protflags & PAGE_WRITECOPY))
126 dprintf(("Different flags for duplicate!"));
127 break;
128 }
129 //TODO:
130 //Is it allowed to open an existing view with different flags?
131 //(i.e. write access to readonly object)
[9824]132 // -> for the same file handle, yes
[5011]133
134 //if map already exists, we must create a new handle to the existing
135 //map object and return ERROR_ALREADY_EXISTS
136 pHMHandleData->dwUserData = (ULONG)map;
137 pHMHandleData->dwInternalType = HMTYPE_MEMMAP;
[9824]138
139 //findMap already incremented the reference count, so we simply don't
140 //release it here
[5011]141 return ERROR_ALREADY_EXISTS;
[664]142 }
[9948]143
[9824]144 //We reuse the original memory map object if another one is created for
145 //the same file handle
146 //TODO: different file handles can exist for the same file (DuplicateHandle)
147 map = Win32MemMap::findMapByFile(hFile);
148 if(map) {
[9948]149 Win32MemMapDup *dupmap;
[9824]150
[9948]151 dprintf(("CreateFileMappingA: duplicating map with file %x!", hFile));
[9824]152
[9948]153 dupmap = new Win32MemMapDup(map, hFile, size_low, protect, (LPSTR)name);
154
155 if(dupmap == NULL) {
156 dprintf(("CreateFileMappingA: can't create Win32MemMap object!"));
157 return ERROR_OUTOFMEMORY;
158 }
159 map->Release(); //findMapByFile increases the refcount, so decrease it here
160 map = dupmap;
[9824]161 }
[712]162 else {
[9948]163 map = new Win32MemMap(hFile, size_low, protect, (LPSTR)name);
[712]164
[9948]165 if(map == NULL) {
166 dprintf(("CreateFileMappingA: can't create Win32MemMap object!"));
167 return ERROR_OUTOFMEMORY;
168 }
[712]169 }
[9948]170 if(map->Init(size_low) == FALSE) {
171 dprintf(("CreateFileMappingA: init failed!"));
172 delete map;
173 return ERROR_GEN_FAILURE;
174 }
[690]175 pHMHandleData->dwUserData = (ULONG)map;
[664]176 pHMHandleData->dwInternalType = HMTYPE_MEMMAP;
177 return NO_ERROR;
178}
179//******************************************************************************
180//******************************************************************************
181DWORD HMDeviceMemMapClass::OpenFileMapping(PHMHANDLEDATA pHMHandleData,
182 DWORD access, /* [in] Access mode */
183 BOOL inherit, /* [in] Inherit flag */
184 LPCSTR name ) /* [in] Name of file-mapping object */
185{
[678]186 Win32MemMap *map;
187 DWORD protflags;
[9824]188 DWORD ret;
[664]189
190 if(name == NULL)
191 return ERROR_INVALID_PARAMETER;
192
193 map = Win32MemMap::findMap((LPSTR)name);
194 if(map == NULL) {
195 dprintf(("OpenFileMapping: mapping %s not found", name));
196 return ERROR_FILE_NOT_FOUND;
197 }
198 protflags = map->getProtFlags();
199 switch(access) {
200 case FILE_MAP_WRITE:
201 case FILE_MAP_ALL_ACCESS:
[9824]202 if(!(protflags & (PAGE_WRITECOPY|PAGE_READWRITE))) {
203 ret = ERROR_INVALID_PARAMETER;
204 goto fail;
205 }
[664]206 break;
207 case FILE_MAP_READ:
[9824]208 if(!(protflags & (PAGE_READWRITE | PAGE_READONLY))) {
209 ret = ERROR_INVALID_PARAMETER;
210 goto fail;
211 }
[664]212 break;
213 case FILE_MAP_COPY:
[9824]214 if(!(protflags & PAGE_WRITECOPY)) {
215 ret = ERROR_INVALID_PARAMETER;
216 goto fail;
217 }
[664]218 break;
219 }
[9824]220 //findMap already incremented the reference count, so we simply don't
221 //release it here
[690]222 pHMHandleData->dwUserData = (ULONG)map;
[664]223 pHMHandleData->dwInternalType = HMTYPE_MEMMAP;
224 return NO_ERROR;
[9824]225
226fail:
227 map->Release();
228 return ret;
[664]229}
230//******************************************************************************
231//******************************************************************************
232LPVOID HMDeviceMemMapClass::MapViewOfFileEx(PHMHANDLEDATA pHMHandleData,
233 DWORD dwDesiredAccess,
234 DWORD dwFileOffsetHigh,
235 DWORD dwFileOffsetLow,
236 DWORD dwNumberOfBytesToMap,
237 LPVOID lpBaseAddress)
238{
239 Win32MemMap *map;
240
[3599]241 dprintf(("KERNEL32: HMDeviceMemMapClass::MapViewOfFileEx(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh)\n",
[664]242 pHMHandleData->hHMHandle,
243 dwDesiredAccess,
244 dwFileOffsetHigh,
245 dwFileOffsetLow,
[8456]246 dwNumberOfBytesToMap,
[3599]247 lpBaseAddress));
[664]248
[8456]249 if(lpBaseAddress != NULL)
[3599]250 {
251#if 0
252 //No can do. Let us choose the address
253 dprintf(("Can't create view to virtual address %x", lpBaseAddress));
254 SetLastError(ERROR_OUTOFMEMORY);
255 return NULL;
256#else
257 // PH 2000/05/24 IBM VAJ3 uses this function.
258 // I don't think we'll ever succeed in EXACTLY copying the original
259 // behaviour of the function. Maybe ignoring the base address helps?
260 dprintf(("WARNING: suggested virtual address %x IGNORED! (experimental API violation)",
261 lpBaseAddress));
262#endif
[664]263 }
264
265 if(pHMHandleData->dwUserData == NULL || pHMHandleData->dwInternalType != HMTYPE_MEMMAP) {
266 dprintf(("MapViewOfFileEx: invalid handle data!"));
267 SetLastError(ERROR_INVALID_HANDLE);
268 return NULL;
269 }
270 map = (Win32MemMap *)pHMHandleData->dwUserData;
271
272 return map->mapViewOfFile(dwNumberOfBytesToMap, dwFileOffsetLow, dwDesiredAccess);
273}
274//******************************************************************************
275//******************************************************************************
[5587]276BOOL HMDeviceMemMapClass::CloseHandle(PHMHANDLEDATA pHMHandleData)
[664]277{
278 Win32MemMap *map;
279
[2973]280 dprintf(("HMDeviceMemMapClass::CloseHandle %x", pHMHandleData->dwUserData));
[678]281 if(pHMHandleData->dwUserData == NULL || pHMHandleData->dwInternalType != HMTYPE_MEMMAP) {
[6468]282 dprintf(("HMDeviceMemMapClass::CloseHandle: invalid handle data!"));
[5587]283 return FALSE;
[664]284 }
[3609]285 //Although an application may close the file handle used to create a file
[4230]286 //mapping object, the system keeps the corresponding file open until the last
[3609]287 //view of the file is unmapped.
[664]288 map = (Win32MemMap *)pHMHandleData->dwUserData;
[5011]289 map->Release();
[664]290
[5587]291 return TRUE;
[664]292}
293//******************************************************************************
294//******************************************************************************
Note: See TracBrowser for help on using the repository browser.