source: trunk/src/kernel32/hmmmap.cpp@ 675

Last change on this file since 675 was 675, checked in by phaller, 26 years ago

Fix: added debug info to hmmmap.cpp
File size: 10.2 KB
Line 
1/* $Id: hmmmap.cpp,v 1.3 1999-08-25 10:23:34 phaller Exp $ */
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"
33
34/*****************************************************************************
35 * Defines *
36 *****************************************************************************/
37
38/*****************************************************************************
39 * Structures *
40 *****************************************************************************/
41
42/*****************************************************************************
43 * Local Prototypes *
44 *****************************************************************************/
45
46//******************************************************************************
47//******************************************************************************
48DWORD HMDeviceMemMapClass::CreateFileMapping(PHMHANDLEDATA pHMHandleData,
49 HFILE hFile,
50 SECURITY_ATTRIBUTES *sa, /* [in] Optional security attributes*/
51 DWORD protect, /* [in] Protection for mapping object */
52 DWORD size_high, /* [in] High-order 32 bits of object size */
53 DWORD size_low, /* [in] Low-order 32 bits of object size */
54 LPCSTR name) /* [in] Name of file-mapping object */
55{
56 Win32MemMap *map;
57
58 dprintf(("KERNEL32::HMDeviceMemMapClass::CreateFileMapping(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh,%s)\n",
59 pHMHandleData,
60 hFile,
61 sa,
62 protect,
63 size_high,
64 size_low,
65 name));
66
67 if((hFile == -1 && size_low == 0) || size_high ||
68 protect & (PAGE_READONLY|PAGE_READWRITE|PAGE_WRITECOPY|SEC_COMMIT|SEC_IMAGE|SEC_RESERVE|SEC_NOCACHE) ||
69 ((protect & SEC_COMMIT) && (protect & SEC_RESERVE)))
70 {
71
72 dprintf(("CreateFileMappingA: invalid parameter (combination)!"));
73 SetLastError(ERROR_INVALID_PARAMETER);
74 return 0;
75 }
76
77 map = new Win32MemMap(hFile, size_low, protect, (LPSTR)name);
78 if(map == NULL) {
79 dprintf(("CreateFileMappingA: can't create Win32MemMap object!"));
80 return ERROR_OUTOFMEMORY;
81 }
82
83 if(map->Init(pHMHandleData->hHMHandle) == FALSE) {
84 delete map;
85 return ERROR_GEN_FAILURE;
86 }
87 map->AddRef();
88 pHMHandleData->dwUserData = (ULONG)this;
89 pHMHandleData->dwInternalType = HMTYPE_MEMMAP;
90 return NO_ERROR;
91}
92//******************************************************************************
93//******************************************************************************
94DWORD HMDeviceMemMapClass::OpenFileMapping(PHMHANDLEDATA pHMHandleData,
95 DWORD access, /* [in] Access mode */
96 BOOL inherit, /* [in] Inherit flag */
97 LPCSTR name ) /* [in] Name of file-mapping object */
98{
99 Win32MemMap *map;
100 DWORD protflags;
101
102 dprintf(("KERNEL32::HMDeviceMemMapClass::OpenFileMapping(%08xh,%08xh,%08xh,%08xh\n",
103 pHMHandleData,
104 access,
105 inherit,
106 name));
107
108
109 if(name == NULL)
110 return ERROR_INVALID_PARAMETER;
111
112 map = Win32MemMap::findMap((LPSTR)name);
113 if(map == NULL) {
114 dprintf(("OpenFileMapping: mapping %s not found", name));
115 return ERROR_FILE_NOT_FOUND;
116 }
117 protflags = map->getProtFlags();
118 switch(access) {
119 case FILE_MAP_WRITE:
120 case FILE_MAP_ALL_ACCESS:
121 if(!(protflags & PAGE_WRITECOPY))
122 return ERROR_INVALID_PARAMETER;
123 break;
124 case FILE_MAP_READ:
125 if(!(protflags & (PAGE_READWRITE | PAGE_READONLY)))
126 return ERROR_INVALID_PARAMETER;
127 break;
128 case FILE_MAP_COPY:
129 if(!(protflags & PAGE_WRITECOPY))
130 return ERROR_INVALID_PARAMETER;
131 break;
132 }
133 map->AddRef();
134 pHMHandleData->dwUserData = (ULONG)this;
135 pHMHandleData->dwInternalType = HMTYPE_MEMMAP;
136 return NO_ERROR;
137}
138//******************************************************************************
139//******************************************************************************
140LPVOID HMDeviceMemMapClass::MapViewOfFileEx(PHMHANDLEDATA pHMHandleData,
141 DWORD dwDesiredAccess,
142 DWORD dwFileOffsetHigh,
143 DWORD dwFileOffsetLow,
144 DWORD dwNumberOfBytesToMap,
145 LPVOID lpBaseAddress)
146{
147 Win32MemMap *map;
148
149 dprintf(("KERNEL32: HMDeviceMemMapClass::MapViewOfFile(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh)\n",
150 pHMHandleData->hHMHandle,
151 dwDesiredAccess,
152 dwFileOffsetHigh,
153 dwFileOffsetLow,
154 dwNumberOfBytesToMap, lpBaseAddress));
155
156 if(lpBaseAddress != NULL) {//No can do. Let us choose the address
157 dprintf(("Can't create view to virtual address %x", lpBaseAddress));
158 SetLastError(ERROR_OUTOFMEMORY);
159 return NULL;
160 }
161
162 if(pHMHandleData->dwUserData == NULL || pHMHandleData->dwInternalType != HMTYPE_MEMMAP) {
163 dprintf(("MapViewOfFileEx: invalid handle data!"));
164 SetLastError(ERROR_INVALID_HANDLE);
165 return NULL;
166 }
167 map = (Win32MemMap *)pHMHandleData->dwUserData;
168
169 return map->mapViewOfFile(dwNumberOfBytesToMap, dwFileOffsetLow, dwDesiredAccess);
170}
171//******************************************************************************
172//******************************************************************************
173LPVOID HMDeviceMemMapClass::MapViewOfFile(PHMHANDLEDATA pHMHandleData,
174 DWORD dwDesiredAccess,
175 DWORD dwFileOffsetHigh,
176 DWORD dwFileOffsetLow,
177 DWORD dwNumberOfBytesToMap)
178{
179 dprintf(("KERNEL32: HMDeviceMemMapClass::MapViewOfFile(%08xh,%08xh,%08xh,%08xh,%08xh)\n",
180 pHMHandleData->hHMHandle,
181 dwDesiredAccess,
182 dwFileOffsetHigh,
183 dwFileOffsetLow,
184 dwNumberOfBytesToMap));
185
186 return MapViewOfFileEx(pHMHandleData,
187 dwDesiredAccess,
188 dwFileOffsetHigh,
189 dwFileOffsetLow,
190 dwNumberOfBytesToMap,
191 NULL);
192}
193
194//******************************************************************************
195//******************************************************************************
196DWORD HMDeviceMemMapClass::CloseHandle(PHMHANDLEDATA pHMHandleData)
197{
198 Win32MemMap *map;
199
200 if(pHMHandleData->dwUserData == NULL || pHMHandleData->dwInternalType != HMTYPE_MEMMAP)
201 {
202 dprintf(("KERNEL32: HMDeviceMemMapClass:MapViewOfFileEx: invalid handle data!"));
203 return ERROR_INVALID_HANDLE;
204 }
205 map = (Win32MemMap *)pHMHandleData->dwUserData;
206 map->Release();
207
208 return NO_ERROR;
209}
210//******************************************************************************
211//******************************************************************************
212
213
214/*****************************************************************************
215 * Name : DWORD HMDeviceHandler::findByBaseAddress
216 * Purpose : identify a memmap object by its base address
217 * Parameters: LPVOID lpBaseAddress
218 * Variables :
219 * Result : PHMHANDLEDATA pHMHandleData
220 * Remark :
221 * Status :
222 *
223 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
224 *****************************************************************************/
225
226int HMDeviceMemMapClass::findByBaseAddress(LPVOID lpBaseAddress)
227{
228 dprintf(("KERNEL32: HMDeviceMemMapClass::findByBaseAddress(%08xh) not implemented\n",
229 lpBaseAddress));
230
231 return -1;
232}
233
234
235/*****************************************************************************
236 * Name : DWORD HMDeviceHandler::UnmapViewOfFile
237 * Purpose : map memory mapped file
238 * Parameters: PHMHANDLEDATA pHMHandleData
239 * LPVOID lpBaseAddress
240 * Variables :
241 * Result : address to memory mapped region
242 * Remark :
243 * Status :
244 *
245 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
246 *****************************************************************************/
247
248BOOL HMDeviceMemMapClass::UnmapViewOfFile(PHMHANDLEDATA pHMHandleData,
249 LPVOID lpBaseAddress)
250{
251 dprintf(("KERNEL32: HMDeviceMemMapClass::UnmapViewOfFile(%08xh,%08xh) not implemented\n",
252 pHMHandleData->hHMHandle,
253 lpBaseAddress));
254
255 return(FALSE);
256}
257
258
259/*****************************************************************************
260 * Name : DWORD HMDeviceHandler::FlushViewOfFile
261 * Purpose : map memory mapped file
262 * Parameters: PHMHANDLEDATA pHMHandleData
263 * LPVOID lpBaseAddress
264 * DWORD dwNumberOfBytesToFlush
265 * Variables :
266 * Result : address to memory mapped region
267 * Remark :
268 * Status :
269 *
270 * Author : Patrick Haller [Wed, 1999/06/17 20:44]
271 *****************************************************************************/
272
273BOOL HMDeviceMemMapClass::FlushViewOfFile(PHMHANDLEDATA pHMHandleData,
274 LPVOID lpBaseAddress,
275 DWORD dwNumberOfBytesToFlush)
276{
277 dprintf(("KERNEL32: HMDeviceMemMapClass::FlushViewOfFile(%08xh,%08xh,%08xh) not implemented\n",
278 pHMHandleData->hHMHandle,
279 lpBaseAddress,
280 dwNumberOfBytesToFlush));
281
282 return(FALSE);
283}
284
285
Note: See TracBrowser for help on using the repository browser.