source: trunk/src/kernel32/mmap.cpp@ 2007

Last change on this file since 2007 was 2007, checked in by sandervl, 26 years ago

memory map + string resource fixes
File size: 20.0 KB
Line 
1/* $Id: mmap.cpp,v 1.25 1999-12-07 12:28:41 sandervl Exp $ */
2
3/*
4 * Win32 Memory mapped file & view classes
5 *
6 * Copyright 1999 Sander van Leeuwen (sandervl@xs4all.nl)
7 *
8 * NOTE: Memory mapping DOES NOT work when kernel-mode code causes
9 * a pagefault in the memory mapped object. (exceptions aren't
10 * dispatched to our exception handler until after the kernel mode
11 * call returns (too late))
12 *
13 * NOTE: Are apps allowed to change the protection flags of memory mapped pages?
14 * I'm assuming they aren't for now.
15 *
16 * TODO: Handles returned should be usable by all apis that accept file handles
17 * TODO: Sharing memory mapped files between multiple processes
18 *
19 * Project Odin Software License can be found in LICENSE.TXT
20 *
21 */
22#include <os2win.h>
23#include <stdio.h>
24#include <stdlib.h>
25#include <string.h>
26#include <win\virtual.h>
27#include <vmutex.h>
28#include <handlemanager.h>
29#include "mmap.h"
30#include "oslibdos.h"
31#include <winimagepeldr.h>
32
33//Global DLL Data
34#pragma data_seg(_GLOBALDATA)
35Win32MemMap *Win32MemMap::memmaps = NULL;
36VMutex globalmapMutex(VMUTEX_SHARED);
37#pragma data_seg()
38VMutex globalviewMutex;
39Win32MemMapView *Win32MemMapView::mapviews = NULL;
40
41//******************************************************************************
42//TODO: sharing between processes
43//******************************************************************************
44Win32MemMap::Win32MemMap(HFILE hfile, ULONG size, ULONG fdwProtect, LPSTR lpszName)
45 : nrMappings(0), pMapping(NULL), mMapAccess(0), referenced(0), image(0)
46{
47 globalmapMutex.enter();
48 next = memmaps;
49 memmaps = this;
50 globalmapMutex.leave();
51
52 hMemFile = hfile;
53
54 mSize = size;
55 mProtFlags = fdwProtect;
56 mProcessId = GetCurrentProcess();
57
58 if(lpszName) {
59 lpszMapName = (char *)_smalloc(strlen(lpszName)+1);
60 strcpy(lpszMapName, lpszName);
61 }
62 else lpszMapName = NULL;
63}
64//******************************************************************************
65//Map constructor used for executable image maps (only used internally)
66//******************************************************************************
67Win32MemMap::Win32MemMap(Win32PeLdrImage *pImage, ULONG baseAddress, ULONG size)
68 : nrMappings(0), pMapping(NULL), mMapAccess(0), referenced(0)
69{
70 globalmapMutex.enter();
71 next = memmaps;
72 memmaps = this;
73 globalmapMutex.leave();
74
75 hMemFile = -1;
76
77 mSize = size;
78 mProtFlags = PAGE_READWRITE;
79 mProcessId = GetCurrentProcess();
80
81 pMapping = (LPVOID)baseAddress;
82
83 image = pImage;
84 lpszMapName= NULL;
85}
86//******************************************************************************
87//******************************************************************************
88BOOL Win32MemMap::Init(HANDLE hMemMap)
89{
90 mapMutex.enter();
91 if(hMemFile != -1)
92 {
93 if(DuplicateHandle(mProcessId, hMemFile, GetCurrentProcess(),
94 &hMemFile, 0, FALSE, DUPLICATE_SAME_ACCESS) == FALSE)
95 {
96 dprintf(("Win32MemMap::Init: DuplicateHandle failed!"));
97 goto fail;
98 }
99 mSize = SetFilePointer(hMemFile, 0, NULL, FILE_END);
100 if(mSize == -1) {
101 dprintf(("Win32MemMap::init: SetFilePointer failed to set pos end"));
102 goto fail;
103 }
104 //SvL: Temporary limitation of size (Warp Server Advanced doesn't allow
105 // one to reserve more than 450 MB of continuous memory; (Warp 4
106 // much less))
107 if(mSize > 64*1024*1024) {
108 mSize = 64*1024*1024;
109 }
110 }
111
112 dprintf(("CreateFileMappingA for file %x, prot %x size %d, name %s", hMemFile, mProtFlags, mSize, lpszMapName));
113 this->hMemMap = hMemMap;
114 mapMutex.leave();
115 return TRUE;
116fail:
117 mapMutex.leave();
118 return FALSE;
119}
120//******************************************************************************
121//******************************************************************************
122Win32MemMap::~Win32MemMap()
123{
124 Win32MemMapView::deleteViews(this); //delete all views of our memory mapped file
125
126 dprintf(("Win32MemMap dtor: deleting view %x %x", pMapping, mSize));
127
128 mapMutex.enter();
129 if(lpszMapName) {
130 free(lpszMapName);
131 }
132 if(pMapping && !image) {
133 if(lpszMapName) {
134 OSLibDosFreeMem(pMapping);
135 }
136 else VirtualFree(pMapping, mSize, MEM_RELEASE);
137
138 pMapping = NULL;
139 }
140 if(hMemFile != -1) {
141 CloseHandle(hMemFile);
142 hMemFile = -1;
143 }
144 mapMutex.leave();
145
146 globalmapMutex.enter();
147 Win32MemMap *map = memmaps;
148
149 if(map == this) {
150 memmaps = next;
151 }
152 else {
153 while(map->next) {
154 if(map->next == this)
155 break;
156 map = map->next;
157 }
158 if(map->next) {
159 map->next = next;
160 }
161 else dprintf(("Win32MemMap::~Win32MemMap: map not found!! (%x)", this));
162 }
163 globalmapMutex.leave();
164}
165//******************************************************************************
166//We determine whether a page has been modified by checking it's protection flags
167//If the write flag is set, this means commitPage had to enable this due to a pagefault
168//(all pages are readonly until the app tries to write to it)
169//******************************************************************************
170BOOL Win32MemMap::commitPage(ULONG offset, BOOL fWriteAccess, int nrpages)
171{
172 MEMORY_BASIC_INFORMATION memInfo;
173 LPVOID lpPageFaultAddr = (LPVOID)((ULONG)pMapping + offset);
174 DWORD pageAddr = (DWORD)lpPageFaultAddr & ~0xFFF;
175 DWORD oldProt, newProt, nrBytesRead, size;
176
177// mapMutex.enter();
178
179 if(image) {
180 return image->commitPage(pageAddr, fWriteAccess);
181 }
182 newProt = mProtFlags & (PAGE_READONLY | PAGE_READWRITE | PAGE_WRITECOPY);
183
184 dprintf(("Win32MemMap::commitPage %x (faultaddr %x)", pageAddr, lpPageFaultAddr));
185 if(hMemFile != -1) {
186 if(VirtualQuery((LPSTR)pageAddr, &memInfo, nrpages*PAGE_SIZE) == 0) {
187 dprintf(("Win32MemMap::commitPage: VirtualQuery (%x,%x) failed for %x", pageAddr, nrpages*PAGE_SIZE));
188 goto fail;
189 }
190 //Only changes the state of the pages with the same attribute flags
191 //(returned in memInfo.RegionSize)
192 //If it's smaller than the mNrPages, it simply means one or more of the
193 //other pages have already been committed
194 if(memInfo.State & MEM_COMMIT)
195 {//if it's already committed, then the app tried to write to it
196 if(!fWriteAccess) {
197 dprintf(("Win32MemMap::commitPage: Huh? Already committed and not trying to write (%x,%x) failed for %x", pageAddr, memInfo.RegionSize));
198 goto fail;
199 }
200 if(VirtualProtect((LPVOID)pageAddr, memInfo.RegionSize, newProt, &oldProt) == FALSE) {
201 dprintf(("Win32MemMap::commitPage: Failed to set write flag on page (%x,%x) failed for %x", pageAddr, memInfo.RegionSize));
202 goto fail;
203 }
204 }
205 else {
206 if(VirtualAlloc((LPVOID)pageAddr, memInfo.RegionSize, MEM_COMMIT, PAGE_READWRITE) == FALSE) {
207 goto fail;
208 }
209 offset = pageAddr - (ULONG)pMapping;
210 size = memInfo.RegionSize;
211 if(offset + size > mSize) {
212 dprintf(("Adjusting size from %d to %d", size, mSize - offset));
213 size = mSize - offset;
214 }
215 if(SetFilePointer(hMemFile, offset, NULL, FILE_BEGIN) != offset) {
216 dprintf(("Win32MemMap::commitPage: SetFilePointer failed to set pos to %x", offset));
217 goto fail;
218 }
219 if(ReadFile(hMemFile, (LPSTR)pageAddr, size, &nrBytesRead, NULL) == FALSE) {
220 dprintf(("Win32MemMap::commitPage: ReadFile failed for %x", pageAddr));
221 goto fail;
222 }
223 if(nrBytesRead != size) {
224 dprintf(("Win32MemMap::commitPage: ReadFile didn't read all bytes for %x", pageAddr));
225 goto fail;
226 }
227 if(mProtFlags != PAGE_READWRITE) {
228 if(VirtualProtect((LPVOID)pageAddr, memInfo.RegionSize, newProt, &oldProt) == FALSE) {
229 goto fail;
230 }
231 }
232 }
233 }
234 else {
235 if(VirtualQuery((LPSTR)pageAddr, &memInfo, nrpages*PAGE_SIZE) == 0) {
236 dprintf(("Win32MemMap::commitPage: VirtualQuery (%x,%x) failed for %x", pageAddr, nrpages*PAGE_SIZE));
237 goto fail;
238 }
239 if(!(memInfo.State & MEM_COMMIT))
240 {//if it's already committed, then the app tried to write to it
241 if(VirtualAlloc((LPVOID)pageAddr, memInfo.RegionSize, MEM_COMMIT, newProt) == FALSE)
242 goto fail;
243 }
244 }
245
246// mapMutex.leave();
247 return TRUE;
248fail:
249// mapMutex.leave();
250 return FALSE;
251}
252//******************************************************************************
253//******************************************************************************
254BOOL Win32MemMap::unmapViewOfFile(Win32MemMapView *view)
255{
256 mapMutex.enter();
257
258 if(nrMappings == 0)
259 goto fail;
260
261 delete view;
262
263 if(--nrMappings) {
264 VirtualFree(pMapping, mSize, MEM_RELEASE);
265 pMapping = NULL;
266 }
267 mapMutex.leave();
268 return TRUE;
269fail:
270 mapMutex.leave();
271 return FALSE;
272}
273//******************************************************************************
274//******************************************************************************
275LPVOID Win32MemMap::mapViewOfFile(ULONG size, ULONG offset, ULONG fdwAccess)
276{
277 DWORD processId = GetCurrentProcess();
278
279 mapMutex.enter();
280 ULONG memFlags = (mProtFlags & (PAGE_READONLY | PAGE_READWRITE | PAGE_WRITECOPY));
281 ULONG fAlloc = 0;
282 Win32MemMapView *mapview;
283
284 //@@@PH: if(fdwAccess & ~(FILE_MAP_WRITE|FILE_MAP_READ|FILE_MAP_COPY))
285 // Docs say FILE_MAP_ALL_ACCESS is same as FILE_MAP_WRITE. Doesn't match reality though.
286 if(fdwAccess & ~FILE_MAP_ALL_ACCESS)
287 goto parmfail;
288 if((fdwAccess & FILE_MAP_WRITE) && !(mProtFlags & PAGE_READWRITE))
289 goto parmfail;
290 if((fdwAccess & FILE_MAP_READ) && !(mProtFlags & (PAGE_READWRITE|PAGE_READONLY)))
291 goto parmfail;
292
293 //@@@PH
294 if (fdwAccess != FILE_MAP_ALL_ACCESS)
295 if((fdwAccess & FILE_MAP_COPY) && !(mProtFlags & PAGE_WRITECOPY))
296 goto parmfail;
297
298 if(offset+size > mSize)
299 goto parmfail;
300
301//TODO: If committed, read file into memory
302#if 0
303 if(mProtFlags & SEC_COMMIT)
304 fAlloc |= MEM_COMMIT;
305 else
306 if(mProtFlags & SEC_RESERVE)
307 fAlloc |= MEM_RESERVE;
308#else
309 fAlloc = MEM_RESERVE;
310#endif
311
312 //Memory has already been allocated for executable image maps (only used internally)
313 if(!pMapping && nrMappings == 0) {//if not mapped, reserve/commit entire view
314 //SvL: Always read/write access or else ReadFile will crash once we
315 // start committing pages.
316 // This is most likely an OS/2 bug and doesn't happen in Aurora
317 // when allocating memory with the PAG_ANY bit set. (without this
318 // flag it will also crash)
319 if(lpszMapName) {
320 pMapping = VirtualAllocShared(mSize, fAlloc, PAGE_READWRITE, lpszMapName);
321 }
322 else {
323 pMapping = VirtualAlloc(0, mSize, fAlloc, PAGE_READWRITE);
324 }
325 if(pMapping == NULL) {
326 dprintf(("Win32MemMap::mapFileView: VirtualAlloc %x %x %x failed!", mSize, fAlloc, memFlags));
327 goto fail;
328 }
329 if(hMemFile == -1 && !image) {//commit memory
330 VirtualAlloc(pMapping, mSize, MEM_COMMIT, PAGE_READWRITE);
331 }
332 }
333 mapview = new Win32MemMapView(this, offset, (size == 0) ? mSize : size, fdwAccess);
334 if(mapview == NULL) {
335 goto fail;
336 }
337 if(mapview->everythingOk() == FALSE) {
338 delete mapview;
339 goto fail;
340 }
341 nrMappings++;
342 mapMutex.leave();
343 return mapview->getViewAddr();
344
345parmfail:
346 dprintf(("Win32MemMap::mapFileView: ERROR_INVALID_PARAMETER"));
347 SetLastError(ERROR_INVALID_PARAMETER);
348fail:
349 mapMutex.leave();
350 return 0;
351}
352//******************************************************************************
353//We determine whether a page has been modified by checking it's protection flags
354//If the write flag is set, this means commitPage had to enable this due to a pagefault
355//(all pages are readonly until the app tries to modify the contents of the page)
356//
357//TODO: Are apps allowed to change the protection flags of memory mapped pages?
358// I'm assuming they aren't for now.
359//******************************************************************************
360BOOL Win32MemMap::flushView(ULONG offset, ULONG cbFlush)
361{
362 LPVOID lpvBase = (LPVOID)((ULONG)pMapping+offset);
363 MEMORY_BASIC_INFORMATION memInfo;
364 ULONG nrBytesWritten, size;
365 int i;
366
367 if(image) //no flushing for image maps
368 return TRUE;
369
370 dprintf(("Win32MemMap::flushView: %x %x", lpvBase, cbFlush));
371 if(nrMappings == 0)
372 goto parmfail;
373
374 if(cbFlush == 0)
375 cbFlush = mSize;
376
377 if(lpvBase < pMapping || (ULONG)lpvBase+cbFlush > (ULONG)pMapping+mSize)
378 goto parmfail;
379
380 if(mProtFlags & PAGE_READONLY)
381 goto parmfail;
382
383 if(hMemFile == -1)
384 goto success; //TODO: Return an error here?
385
386 while(cbFlush) {
387 if(VirtualQuery((LPSTR)lpvBase, &memInfo, cbFlush) == 0) {
388 dprintf(("Win32MemMap::flushView: VirtualQuery (%x,%x) failed for %x", lpvBase, cbFlush, (ULONG)lpvBase+i*PAGE_SIZE));
389 goto fail;
390 }
391 //If a page (or range of pages) is reserved or write protected, we
392 //won't bother flushing it to disk
393 if(memInfo.State & MEM_COMMIT &&
394 memInfo.AllocationProtect & (PAGE_READWRITE|PAGE_WRITECOPY|PAGE_EXECUTE_READWRITE|PAGE_EXECUTE_WRITECOPY))
395 {//committed and allowed for writing?
396 offset = (ULONG)lpvBase - (ULONG)pMapping;
397 size = memInfo.RegionSize;
398 if(size > cbFlush) {
399 size = cbFlush;
400 }
401 dprintf(("Win32MemMap::flushView for offset %x, size %d", offset, size));
402
403 if(SetFilePointer(hMemFile, offset, NULL, FILE_BEGIN) != offset) {
404 dprintf(("Win32MemMap::flushView: SetFilePointer failed to set pos to %x", offset));
405 goto fail;
406 }
407 if(WriteFile(hMemFile, (LPSTR)lpvBase, size, &nrBytesWritten, NULL) == FALSE) {
408 dprintf(("Win32MemMap::flushView: WriteFile failed for %x", (ULONG)lpvBase));
409 goto fail;
410 }
411 if(nrBytesWritten != size) {
412 dprintf(("Win32MemMap::flushView: WriteFile didn't write all bytes for %x", (ULONG)lpvBase));
413 goto fail;
414 }
415 }
416 lpvBase = (LPVOID)((ULONG)lpvBase + memInfo.RegionSize);
417
418 if(cbFlush < memInfo.RegionSize)
419 break;
420
421 cbFlush -= memInfo.RegionSize;
422 }
423success:
424 return TRUE;
425parmfail:
426 SetLastError(ERROR_INVALID_PARAMETER);
427 return FALSE;
428fail:
429 return FALSE;
430}
431//******************************************************************************
432//******************************************************************************
433Win32MemMap *Win32MemMap::findMap(LPSTR lpszName)
434{
435 if(lpszName == NULL)
436 return NULL;
437
438 globalmapMutex.enter();
439 Win32MemMap *map = memmaps;
440
441 if(map != NULL) {
442 while(map) {
443 if(map->lpszMapName && !strcmp(map->lpszMapName, lpszName))
444 break;
445 map = map->next;
446 }
447 }
448 globalmapMutex.leave();
449 if(!map) dprintf(("Win32MemMap::findMap: couldn't find map %s", lpszName));
450 return map;
451}
452//******************************************************************************
453//******************************************************************************
454Win32MemMap *Win32MemMap::findMap(ULONG address)
455{
456 globalmapMutex.enter();
457 Win32MemMap *map = memmaps;
458
459 if(map != NULL) {
460 while(map) {
461 if(map->pMapping && (ULONG)map->pMapping <= address &&
462 (ULONG)map->pMapping + map->mSize > address)
463 {
464 break;
465 }
466 map = map->next;
467 }
468 }
469 globalmapMutex.leave();
470 return map;
471}
472//******************************************************************************
473//Assumes mutex has been acquired
474//******************************************************************************
475void Win32MemMap::deleteAll()
476{
477 Win32MemMap *map = memmaps, *nextmap;
478 DWORD processId = GetCurrentProcess();
479
480 //delete all maps created by this process
481 while(map) {
482 nextmap = map->next;
483 if(map->getProcessId() == processId) {
484 //Delete map directly for executable images (only used internally)
485 if(map->getImage()) {
486 delete map;
487 }
488 else CloseHandle(memmaps->hMemMap);
489 }
490 else {
491 //delete all views created by this process for this map
492 Win32MemMapView::deleteViews(map);
493 }
494 map = nextmap;
495 }
496}
497//******************************************************************************
498//******************************************************************************
499Win32MemMapView::Win32MemMapView(Win32MemMap *map, ULONG offset, ULONG size,
500 ULONG fdwAccess)
501{
502 LPVOID viewaddr = (LPVOID)((ULONG)map->getMappingAddr()+offset);
503 ULONG accessAttr = 0;
504 Win32MemMapView *tmpview = mapviews;
505
506 errorState = 0;
507 mParentMap = map;
508 mSize = size;
509 mOffset = offset;
510 mProcessId = GetCurrentProcess();
511
512 switch(fdwAccess) {
513 case FILE_MAP_READ:
514 accessAttr = PAG_READ;
515 mfAccess = MEMMAP_ACCESS_READ;
516 break;
517 case FILE_MAP_ALL_ACCESS:
518 case FILE_MAP_WRITE:
519 case FILE_MAP_COPY:
520 accessAttr = (PAG_READ|PAG_WRITE);
521 mfAccess = MEMMAP_ACCESS_READ | MEMMAP_ACCESS_WRITE;
522 break;
523 }
524 if(map->getMemName() != NULL) {
525 //shared memory map, so map it into our address space
526 if(OSLibDosGetNamedSharedMem((LPVOID *)&viewaddr, map->getMemName()) != OSLIB_NOERROR) {
527 dprintf(("new OSLibDosGetNamedSharedMem FAILED"));
528 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
529 errorState = 1;
530 return;
531 }
532 }
533
534 //view == memory mapping for executable images (only used internally)
535 if(map->getImage()) {
536 pMapView = map->getMappingAddr();
537 }
538 else {
539 if(OSLibDosAliasMem(viewaddr, size, &pMapView, accessAttr) != OSLIB_NOERROR) {
540 dprintf(("new OSLibDosAliasMem FAILED"));
541 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
542 errorState = 1;
543 return;
544 }
545 }
546
547 dprintf(("Win32MemMapView::Win32MemMapView: created %x (alias for %x), size %d", pMapView, viewaddr, size));
548
549 globalviewMutex.enter();
550 if(tmpview == NULL || tmpview->getViewAddr() > pMapView) {
551 next = mapviews;
552 mapviews = this;
553 }
554 else {
555 while(tmpview->next) {
556 if(tmpview->next->getViewAddr() > pMapView) {
557 break;
558 }
559 tmpview = tmpview->next;
560 }
561 next = tmpview->next;
562 tmpview->next = this;
563 }
564 globalviewMutex.leave();
565}
566//******************************************************************************
567//******************************************************************************
568Win32MemMapView::~Win32MemMapView()
569{
570 if(errorState != 0)
571 return;
572
573 dprintf(("Win32MemMapView dtor: deleting view %x %x", mOffset, mSize));
574
575 if(mfAccess & MEMMAP_ACCESS_WRITE)
576 mParentMap->flushView(mOffset, mSize);
577
578 //Don't free memory for executable image map views (only used internally)
579 if(!mParentMap->getImage())
580 OSLibDosFreeMem(pMapView);
581
582 globalviewMutex.enter();
583 Win32MemMapView *view = mapviews;
584
585 if(view == this) {
586 mapviews = next;
587 }
588 else {
589 while(view->next) {
590 if(view->next == this)
591 break;
592 view = view->next;
593 }
594 if(view->next) {
595 view->next = next;
596 }
597 else dprintf(("Win32MemMapView::~Win32MemMapView: map not found!! (%x)", this));
598 }
599 globalviewMutex.leave();
600}
601//******************************************************************************
602//******************************************************************************
603void Win32MemMapView::deleteViews(Win32MemMap *map)
604{
605 globalviewMutex.enter();
606 Win32MemMapView *view = mapviews, *nextview;
607
608 if(view != NULL) {
609 while(view) {
610 nextview = view->next;
611 if(view->getParentMap() == map)
612 {
613 globalviewMutex.leave();
614 delete view;
615 globalviewMutex.enter();
616 }
617 view = nextview;
618 }
619 }
620 globalviewMutex.leave();
621}
622//******************************************************************************
623//******************************************************************************
624Win32MemMap *Win32MemMapView::findMapByView(ULONG address, ULONG *offset,
625 ULONG accessType,
626 Win32MemMapView **pView)
627{
628 globalviewMutex.enter();
629 Win32MemMapView *view = mapviews;
630
631 *offset = 0;
632
633 if(view != NULL) {
634 while(view && (ULONG)view->getViewAddr() <= address) {
635 if((ULONG)view->getViewAddr() <= address &&
636 (ULONG)view->getViewAddr() + view->getSize() > address &&
637 view->getAccessFlags() >= accessType)
638 {
639 *offset = view->getOffset() + (address - (ULONG)view->getViewAddr());
640 goto success;
641 }
642 view = view->next;
643 }
644 //failure if we get here
645 view = NULL;
646 }
647success:
648 if(view)
649 dprintf(("findMapByView %x %x -> %x off %x", address, accessType, view->getViewAddr(), *offset));
650
651 globalviewMutex.leave();
652 if(pView) *pView = view;
653 return (view) ? view->getParentMap() : NULL;
654}
655//******************************************************************************
656//******************************************************************************
657Win32MemMapView *Win32MemMapView::findView(LPVOID address)
658{
659 Win32MemMapView *view = mapviews;
660
661 if(view != NULL) {
662 while(view) {
663 if(view->getViewAddr() == address)
664 {
665 break;
666 }
667 view = view->next;
668 }
669 }
670 return view;
671}
672//******************************************************************************
673//******************************************************************************
674
Note: See TracBrowser for help on using the repository browser.