Changeset 712 for trunk/src

Timestamp:

Aug 27, 1999, 6:51:01 PM (26 years ago)

Author:

sandervl

Message:

Implemented multiple views of memory mapped files + some bugfixes to PE loader code

Location:

trunk/src/kernel32

Files:

• KERNEL32.DEF (modified) (2 diffs)
• exceptions.cpp (modified) (4 diffs)
• hmmmap.cpp (modified) (2 diffs)
• mmap.cpp (modified) (18 diffs)
• mmap.h (modified) (5 diffs)
• oslibdos.cpp (modified) (2 diffs)
• oslibdos.h (modified) (2 diffs)
• virtual.cpp (modified) (6 diffs)
• windll.cpp (modified) (5 diffs)
• winimage.cpp (modified) (7 diffs)
• wprocess.cpp (modified) (2 diffs)

trunk/src/kernel32/KERNEL32.DEF

@@ -1 @@
-; $Id: KERNEL32.DEF,v 1.30 1999-08-25 14:27:06 sandervl Exp $
+; $Id: KERNEL32.DEF,v 1.31 1999-08-27 16:51:00 sandervl Exp $
 
 ;Created by BLAST for IBM's compiler
@@ -16 +16 @@
   _DosQueryModFromEIP          =  DOSCALLS.360
    DosQueryModFromEIP          =  DOSCALLS.360
+   DosAliasMem                 =  DOSCALLS.298
+  _DosAliasMem                 =  DOSCALLS.298
 
 

trunk/src/kernel32/exceptions.cpp

@@ -1 @@
-/* $Id: exceptions.cpp,v 1.16 1999-08-27 10:44:21 phaller Exp $ */
+/* $Id: exceptions.cpp,v 1.17 1999-08-27 16:50:59 sandervl Exp $ */
 
 /*
@@ -868 +868 @@
                                    PVOID                        p)
 {
-  /*********************************
-   * Internally handled exceptions *
-   *********************************/
-
-  /* Access violation at a known location */
-  if (pERepRec->ExceptionNum == XCPT_ACCESS_VIOLATION)
-  {
-    Win32MemMap *map;
-    BOOL fWriteAccess = FALSE;
-
-    if(pERepRec->ExceptionInfo[1] == 0 &&
-       pERepRec->ExceptionInfo[1] == XCPT_DATA_UNKNOWN)
-      goto continueFail;
-
-    map = Win32MemMap::findMap(pERepRec->ExceptionInfo[1]);
-     if(map == NULL)
-      goto continueFail;
-
-    switch(pERepRec->ExceptionInfo[0])
-    {
-      case XCPT_READ_ACCESS:
-        if(map->hasReadAccess() == FALSE)
-          goto continueFail;
-      break;
-
-      case XCPT_WRITE_ACCESS:
-        if(map->hasWriteAccess() == FALSE)
-           goto continueFail;
-        fWriteAccess = TRUE;
-        break;
-
-      case XCPT_EXECUTE_ACCESS:
-        if(map->hasExecuteAccess() == FALSE)
-          goto continueFail;
-        break;
-
-     default:
-       goto continueFail;
-   }
-
-   //Might want to consider mapping more than one page if access is at
-   //a high offset in the page
-   //@@@PH: mapping 16k or 32k might be significally faster in terms of transfer speed
-   if(map->commitPage((LPVOID)pERepRec->ExceptionInfo[1], 1, fWriteAccess) == TRUE)
-      return (XCPT_CONTINUE_EXECUTION);
-
-   //no break;
-  }
-continueFail:
-
-
-  /************************
-   * Pass-thru exceptions *
-   ************************/
-
   //  pERegRec->prev_structure = 0;
   dprintfException(pERepRec, pERegRec, pCtxRec, p);
@@ -929 +874 @@
   switch(pERepRec->ExceptionNum)
   {
-    case XCPT_FLOAT_DENORMAL_OPERAND:
-    case XCPT_FLOAT_DIVIDE_BY_ZERO:
-    case XCPT_FLOAT_INEXACT_RESULT:
-    case XCPT_FLOAT_INVALID_OPERATION:
-    case XCPT_FLOAT_OVERFLOW:
-    case XCPT_FLOAT_STACK_CHECK:
-    case XCPT_FLOAT_UNDERFLOW:
-      dprintf(("KERNEL32: OS2ExceptionHandler: FPU exception, fix and continue\n"));
+  case XCPT_FLOAT_DENORMAL_OPERAND:
+  case XCPT_FLOAT_DIVIDE_BY_ZERO:
+  case XCPT_FLOAT_INEXACT_RESULT:
+  case XCPT_FLOAT_INVALID_OPERATION:
+  case XCPT_FLOAT_OVERFLOW:
+  case XCPT_FLOAT_STACK_CHECK:
+  case XCPT_FLOAT_UNDERFLOW:
+        dprintf(("KERNEL32: OS2ExceptionHandler: FPU exception, fix and continue\n"));
         pCtxRec->ctx_env[0] |= 0x1F;
         pCtxRec->ctx_stack[0].losig = 0;
         pCtxRec->ctx_stack[0].hisig = 0;
         pCtxRec->ctx_stack[0].signexp = 0;
-      return (XCPT_CONTINUE_EXECUTION);
-
-    case XCPT_PROCESS_TERMINATE:
-    case XCPT_ASYNC_PROCESS_TERMINATE:
-      SetExceptionChain((ULONG)0);
-      return (XCPT_CONTINUE_SEARCH);
-
-    case XCPT_ACCESS_VIOLATION:
-    case XCPT_BREAKPOINT:
-    case XCPT_ARRAY_BOUNDS_EXCEEDED:
-    case XCPT_DATATYPE_MISALIGNMENT:
-    case XCPT_ILLEGAL_INSTRUCTION:
-    case XCPT_PRIVILEGED_INSTRUCTION:
-    case XCPT_INVALID_LOCK_SEQUENCE:
-    case XCPT_INTEGER_DIVIDE_BY_ZERO:
-    case XCPT_INTEGER_OVERFLOW:
-    case XCPT_SINGLE_STEP:
-    case XCPT_GUARD_PAGE_VIOLATION:
-    case XCPT_UNABLE_TO_GROW_STACK:
-    case XCPT_IN_PAGE_ERROR:
-    case XCPT_SIGNAL:
-      dprintf(("KERNEL32: OS2ExceptionHandler: Continue and kill\n"));
-      pCtxRec->ctx_RegEip = (ULONG)KillWin32Process;
-      pCtxRec->ctx_RegEsp = pCtxRec->ctx_RegEsp + 0x10;
-      pCtxRec->ctx_RegEax = pERepRec->ExceptionNum;
-      pCtxRec->ctx_RegEbx = pCtxRec->ctx_RegEip;
-      return (XCPT_CONTINUE_EXECUTION);
-
-    default: //non-continuable exceptions
+
+        return (XCPT_CONTINUE_EXECUTION);
+
+  case XCPT_PROCESS_TERMINATE:
+  case XCPT_ASYNC_PROCESS_TERMINATE:
+        SetExceptionChain((ULONG)0);
+        return (XCPT_CONTINUE_SEARCH);
+
+  case XCPT_ACCESS_VIOLATION:
+  {     
+   Win32MemMap *map;
+   BOOL  fWriteAccess = FALSE;
+   ULONG offset, accessflag;
+
+        if(pERepRec->ExceptionInfo[1] == 0 && pERepRec->ExceptionInfo[1] == XCPT_DATA_UNKNOWN) {
+                goto continueFail;
+        }
+        switch(pERepRec->ExceptionInfo[0]) {
+        case XCPT_READ_ACCESS:
+                accessflag = MEMMAP_ACCESS_READ;
+                break;
+        case XCPT_WRITE_ACCESS:
+                accessflag = MEMMAP_ACCESS_WRITE;
+                fWriteAccess = TRUE;
+                break;
+        case XCPT_EXECUTE_ACCESS:
+                accessflag = MEMMAP_ACCESS_EXECUTE;
+                break;
+        default:
+                goto continueFail;
+        }
+
+        map = Win32MemMapView::findMapByView(pERepRec->ExceptionInfo[1], &offset, accessflag);
+        if(map == NULL) {
+                goto continueFail;
+        }
+        if(map->commitPage(offset, fWriteAccess) == TRUE)
+                return (XCPT_CONTINUE_EXECUTION);
+
+        //no break;
+  }
+continueFail:
+
+  case XCPT_BREAKPOINT:
+  case XCPT_ARRAY_BOUNDS_EXCEEDED:
+  case XCPT_DATATYPE_MISALIGNMENT:
+  case XCPT_ILLEGAL_INSTRUCTION:
+  case XCPT_PRIVILEGED_INSTRUCTION:
+  case XCPT_INVALID_LOCK_SEQUENCE:
+  case XCPT_INTEGER_DIVIDE_BY_ZERO:
+  case XCPT_INTEGER_OVERFLOW:
+  case XCPT_SINGLE_STEP:
+  case XCPT_GUARD_PAGE_VIOLATION:
+  case XCPT_UNABLE_TO_GROW_STACK:
+  case XCPT_IN_PAGE_ERROR:
+  case XCPT_SIGNAL:
+        dprintf(("KERNEL32: OS2ExceptionHandler: Continue and kill\n"));
+        pCtxRec->ctx_RegEip = (ULONG)KillWin32Process;
+        pCtxRec->ctx_RegEsp = pCtxRec->ctx_RegEsp + 0x10;
+        pCtxRec->ctx_RegEax = pERepRec->ExceptionNum;
+        pCtxRec->ctx_RegEbx = pCtxRec->ctx_RegEip;
+        return (XCPT_CONTINUE_EXECUTION);
+
+  default: //non-continuable exceptions
         return (XCPT_CONTINUE_SEARCH);
   }
@@ -1019 +999 @@
  USHORT sel = GetFS();
 
-    SetExceptionChain(val);
+    SetExceptionChain(val);    
     SetFS(sel);
 }

trunk/src/kernel32/hmmmap.cpp

@@ -1 @@
-/* $Id: hmmmap.cpp,v 1.5 1999-08-25 14:27:06 sandervl Exp $ */
+/* $Id: hmmmap.cpp,v 1.6 1999-08-27 16:51:00 sandervl Exp $ */
 
 /*
@@ -67 +67 @@
   }
 
-  map = new Win32MemMap(hFile, size_low, protect, (LPSTR)name);
-  if(map == NULL) {
-        dprintf(("CreateFileMappingA: can't create Win32MemMap object!"));
-        return ERROR_OUTOFMEMORY;
-  }  
+  map = Win32MemMap::findMap((LPSTR)name);
+  if(map != NULL) {
+        dprintf(("CreateFileMappingA: duplicating map %s!", name));
 
-  if(map->Init(pHMHandleData->hHMHandle) == FALSE) {
-        delete map;
-        return ERROR_GEN_FAILURE;
+        DWORD protflags = map->getProtFlags();
+        switch(protect) {
+        case FILE_MAP_WRITE:
+                if(!(protflags & PAGE_WRITECOPY))
+                        dprintf(("Different flags for duplicate!"));
+                break;
+        case FILE_MAP_READ:
+                if(!(protflags & (PAGE_READWRITE | PAGE_READONLY)))
+                        dprintf(("Different flags for duplicate!"));
+                break;
+        case FILE_MAP_COPY:
+                if(!(protflags & PAGE_WRITECOPY))
+                        dprintf(("Different flags for duplicate!"));
+                break;
+        }
+        //TODO:
+        //Is it allowed to open an existing view with different flags?
+        //(i.e. write access to readonly object)
+  }
+  else {
+        map = new Win32MemMap(hFile, size_low, protect, (LPSTR)name);
+
+        if(map == NULL) {
+                dprintf(("CreateFileMappingA: can't create Win32MemMap object!"));
+                return ERROR_OUTOFMEMORY;
+        } 
+
+        if(map->Init(pHMHandleData->hHMHandle) == FALSE) {
+                delete map;
+                return ERROR_GEN_FAILURE;
+        }
   }
   map->AddRef();

trunk/src/kernel32/mmap.cpp

@@ -1 @@
-/* $Id: mmap.cpp,v 1.16 1999-08-26 17:56:25 sandervl Exp $ */
+/* $Id: mmap.cpp,v 1.17 1999-08-27 16:51:00 sandervl Exp $ */
 
 /*
- * Win32 Memory mapped file class
+ * Win32 Memory mapped file & view classes
  *
  * Copyright 1999 Sander van Leeuwen (sandervl@xs4all.nl)
@@ -28 +28 @@
 #include <handlemanager.h>
 #include "mmap.h"
+#include "oslibdos.h"
 
 VMutex globalmapMutex;
+VMutex globalviewMutex;
 
 //******************************************************************************
@@ -35 +37 @@
 //******************************************************************************
 Win32MemMap::Win32MemMap(HFILE hfile, ULONG size, ULONG fdwProtect, LPSTR lpszName)
-               : fMapped(FALSE), pMapping(NULL), mMapAccess(0), referenced(0)
+               : nrMappings(0), pMapping(NULL), mMapAccess(0), referenced(0)
 {
   globalmapMutex.enter();
@@ -72 +74 @@
         }
   }
+
+  dprintf(("CreateFileMappingA for file %x, prot %x size %d, name %s", hMemFile, mProtFlags, mSize, lpszMapName));
   this->hMemMap = hMemMap;
   mapMutex.leave();
@@ -83 +87 @@
 Win32MemMap::~Win32MemMap()
 {
-  unmapViewOfFile();
+  for(int i=0;i<nrMappings;i++) {
+        Win32MemMapView::deleteView(this); //delete all views of our memory mapped file
+  }
+  mapMutex.enter();
   if(lpszMapName) {
         free(lpszMapName);
   }
-  mapMutex.enter();
   if(pMapping) {
         VirtualFree(pMapping, mSize, MEM_RELEASE);
@@ -118 +124 @@
 }
 //******************************************************************************
-//******************************************************************************
-BOOL Win32MemMap::hasReadAccess()
-{
-  return TRUE; //should have at least this
-}
-//******************************************************************************
-//******************************************************************************
-BOOL Win32MemMap::hasWriteAccess()
-{
-  return !(mProtFlags & PAGE_READONLY);
-}
-//******************************************************************************
-//Might want to add this feature for memory mapping executable & dll files in 
-//the loader (done in Win32 with the SEC_IMAGE flag?)
-//******************************************************************************
-BOOL Win32MemMap::hasExecuteAccess()
-{
-  return FALSE;
-}
-//******************************************************************************
 //We determine whether a page has been modified by checking it's protection flags
 //If the write flag is set, this means commitPage had to enable this due to a pagefault
 //(all pages are readonly until the app tries to write to it)
 //******************************************************************************
-BOOL Win32MemMap::commitPage(LPVOID lpPageFaultAddr, ULONG nrpages, BOOL fWriteAccess)
+BOOL Win32MemMap::commitPage(ULONG offset, BOOL fWriteAccess)
 {
  MEMORY_BASIC_INFORMATION memInfo;
- DWORD pageAddr = (DWORD)lpPageFaultAddr & ~0xFFF;
- DWORD oldProt, newProt, nrBytesRead, offset, size;
- 
+ LPVOID lpPageFaultAddr = (LPVOID)((ULONG)pMapping + offset);
+ DWORD pageAddr         = (DWORD)lpPageFaultAddr & ~0xFFF;
+ DWORD oldProt, newProt, nrBytesRead, size;
+
 //  mapMutex.enter();
+  
   newProt  = mProtFlags & (PAGE_READONLY | PAGE_READWRITE | PAGE_WRITECOPY);
 
-  dprintf(("Win32MemMap::commitPage %x (faultaddr %x), nr of pages %d", pageAddr, lpPageFaultAddr, nrpages));
+  dprintf(("Win32MemMap::commitPage %x (faultaddr %x)", pageAddr, lpPageFaultAddr));
   if(hMemFile != -1) {
-        if(VirtualQuery((LPSTR)pageAddr, &memInfo, nrpages*PAGE_SIZE) == 0) {
-                dprintf(("Win32MemMap::commitPage: VirtualQuery (%x,%x) failed for %x", pageAddr, nrpages*PAGE_SIZE));
-                goto fail;
-        }
+        if(VirtualQuery((LPSTR)pageAddr, &memInfo, NRPAGES_TOCOMMIT*PAGE_SIZE) == 0) {
+                dprintf(("Win32MemMap::commitPage: VirtualQuery (%x,%x) failed for %x", pageAddr, NRPAGES_TOCOMMIT*PAGE_SIZE));
+                goto fail;
+        }
+        //Only changes the state of the pages with the same attribute flags
+        //(returned in memInfo.RegionSize)
+        //If it's smaller than the mNrPages, it simply means one or more of the
+        //other pages have already been committed
         if(memInfo.State & MEM_COMMIT)
         {//if it's already committed, then the app tried to write to it
                 if(!fWriteAccess) {
-                        dprintf(("Win32MemMap::commitPage: Huh? Already committed and not trying to write (%x,%x) failed for %x", pageAddr, nrpages*PAGE_SIZE));
-                        goto fail;
-                }
-                if(VirtualProtect((LPVOID)pageAddr, nrpages*PAGE_SIZE, newProt, &oldProt) == FALSE) {
-                        dprintf(("Win32MemMap::commitPage: Failed to set write flag on page (%x,%x) failed for %x", pageAddr, nrpages*PAGE_SIZE));
+                        dprintf(("Win32MemMap::commitPage: Huh? Already committed and not trying to write (%x,%x) failed for %x", pageAddr, memInfo.RegionSize));
+                        goto fail;
+                }
+                if(VirtualProtect((LPVOID)pageAddr, memInfo.RegionSize, newProt, &oldProt) == FALSE) {
+                        dprintf(("Win32MemMap::commitPage: Failed to set write flag on page (%x,%x) failed for %x", pageAddr, memInfo.RegionSize));
                         goto fail;
                 }
         }
         else {
-                if(VirtualAlloc((LPVOID)pageAddr, nrpages*PAGE_SIZE, MEM_COMMIT, PAGE_READWRITE) == FALSE) {
+                if(VirtualAlloc((LPVOID)pageAddr, memInfo.RegionSize, MEM_COMMIT, PAGE_READWRITE) == FALSE) {
                         goto fail;
                 }
                 offset = pageAddr - (ULONG)pMapping;
-                size   = nrpages*PAGE_SIZE;
+                size   = memInfo.RegionSize;
                 if(offset + size > mSize) {
+                        dprintf(("Adjusting size from %d to %d", size, mSize - offset));
                         size = mSize - offset;
                 }
@@ -190 +183 @@
                 }
                 if(mProtFlags & PAGE_READONLY) {
-                        if(VirtualProtect((LPVOID)pageAddr, nrpages*PAGE_SIZE, newProt, &oldProt) == FALSE) {
+                        if(VirtualProtect((LPVOID)pageAddr, memInfo.RegionSize, newProt, &oldProt) == FALSE) {
                                 goto fail;
                         }
@@ -197 +190 @@
   }
   else {
-        if(VirtualAlloc((LPVOID)pageAddr, nrpages*PAGE_SIZE, MEM_COMMIT, newProt) == FALSE) {
+        if(VirtualQuery((LPSTR)pageAddr, &memInfo, NRPAGES_TOCOMMIT*PAGE_SIZE) == 0) {
+                dprintf(("Win32MemMap::commitPage: VirtualQuery (%x,%x) failed for %x", pageAddr, NRPAGES_TOCOMMIT*PAGE_SIZE));
+                goto fail;
+        }
+        if(VirtualAlloc((LPVOID)pageAddr, memInfo.RegionSize, MEM_COMMIT, newProt) == FALSE) {
                 goto fail;
         }
@@ -209 +206 @@
 }
 //******************************************************************************
-//******************************************************************************
-BOOL Win32MemMap::unmapViewOfFile()
-{
-  if(fMapped == FALSE)
-        return FALSE;
-
-  flushView(pMapping, mSize);
+//todo: unalias memory
+//******************************************************************************
+BOOL Win32MemMap::unmapViewOfFile(Win32MemMapView *view)
+{
   mapMutex.enter();
-  if(pMapping) {
+
+  if(nrMappings == 0)
+        goto fail;
+
+  delete view;
+
+  if(--nrMappings) {
         VirtualFree(pMapping, mSize, MEM_RELEASE);
-  }
-  pMapping = NULL;
-  fMapped = FALSE;
+        pMapping = NULL;
+  }
   mapMutex.leave();
   return TRUE;
+fail:
+  mapMutex.leave();
+  return FALSE;
 }
 //******************************************************************************
@@ -232 +234 @@
   ULONG memFlags = (mProtFlags & (PAGE_READONLY | PAGE_READWRITE | PAGE_WRITECOPY));
   ULONG fAlloc   = 0;
-  LPVOID mapview;
-
+  Win32MemMapView *mapview;
+
+  if(fdwAccess & ~(FILE_MAP_WRITE|FILE_MAP_READ|FILE_MAP_COPY)) 
+        goto parmfail;
   if((fdwAccess & FILE_MAP_WRITE) && !(mProtFlags & PAGE_READWRITE)) 
         goto parmfail;
@@ -240 +244 @@
   if((fdwAccess & FILE_MAP_COPY) && !(mProtFlags & PAGE_WRITECOPY)) 
         goto parmfail;
+  if(offset+size > mSize)
+        goto parmfail;
 
 //TODO: If committed, read file into memory
-#if 0  
+#if 0
   if(mProtFlags & SEC_COMMIT)
         fAlloc |= MEM_COMMIT;
@@ -252 +258 @@
 #endif
 
-  if(fMapped == FALSE) {//if not mapped, reserve/commit entire view
+  if(nrMappings == 0) {//if not mapped, reserve/commit entire view
         //SvL: Always read/write access or else ReadFile will crash once we
-        //     start decommitting pages. 
+        //     start committing pages. 
         //     This is most likely an OS/2 bug and doesn't happen in Aurora
         //     when allocating memory with the PAG_ANY bit set. (without this
@@ -263 +269 @@
                 goto fail;
         }
-        fMapped = TRUE;
-  }
-  mapview = (LPVOID)((ULONG)pMapping + offset);
-  mapMutex.leave();
-  return mapview;
+  }
+  mapview = new Win32MemMapView(this, offset, (size == 0) ? mSize : size, fdwAccess);
+  if(mapview == NULL) {
+        goto fail;
+  }
+  if(mapview->everythingOk() == FALSE) {
+        delete mapview;
+        goto fail;
+  }
+  nrMappings++;
+  mapMutex.leave();
+  return mapview->getViewAddr();
 
 parmfail:
@@ -279 +292 @@
 //We determine whether a page has been modified by checking it's protection flags
 //If the write flag is set, this means commitPage had to enable this due to a pagefault
-//(all pages are readonly until the app tries to modify it)
+//(all pages are readonly until the app tries to modify the contents of the page)
 //
 //TODO: Are apps allowed to change the protection flags of memory mapped pages?
 //      I'm assuming they aren't for now.
 //******************************************************************************
-BOOL Win32MemMap::flushView(LPVOID lpvBase, ULONG cbFlush)
-{
+BOOL Win32MemMap::flushView(ULONG offset, ULONG cbFlush)
+{
+ LPVOID lpvBase = (LPVOID)((ULONG)pMapping+offset);
  MEMORY_BASIC_INFORMATION memInfo;
- ULONG nrpages, nrBytesWritten, offset, size;
+ ULONG nrBytesWritten, size;
  int   i;
 
-//  mapMutex.enter();
   dprintf(("Win32MemMap::flushView: %x %x", lpvBase, cbFlush));
-  if(fMapped == FALSE)
+  if(nrMappings == 0)
         goto parmfail;
 
@@ -307 +320 @@
         goto success; //TODO: Return an error here?
 
-  nrpages = cbFlush/PAGE_SIZE;
-  if(cbFlush & 0xFFF)  nrpages++;
-
-  for(i=0;i<nrpages;i++) {
-        if(VirtualQuery((LPSTR)lpvBase+i*PAGE_SIZE, &memInfo, PAGE_SIZE) == 0) {
+  while(cbFlush) {
+        if(VirtualQuery((LPSTR)lpvBase, &memInfo, cbFlush) == 0) {
                 dprintf(("Win32MemMap::flushView: VirtualQuery (%x,%x) failed for %x", lpvBase, cbFlush, (ULONG)lpvBase+i*PAGE_SIZE));
                 goto fail;
         }
-        //If a page is reserved or write protected, we won't bother flushing it to disk
+        //If a page (or range of pages) is reserved or write protected, we 
+        //won't bother flushing it to disk
         if(memInfo.State & MEM_COMMIT && 
            memInfo.AllocationProtect & (PAGE_READWRITE|PAGE_WRITECOPY|PAGE_EXECUTE_READWRITE|PAGE_EXECUTE_WRITECOPY)) 
         {//committed and allowed for writing?
-                offset = (ULONG)lpvBase+i*PAGE_SIZE - (ULONG)pMapping;
-                size   = PAGE_SIZE;
-                if(offset + size > mSize) {
-                        size = mSize - offset;
+                offset = (ULONG)lpvBase - (ULONG)pMapping;
+                size   = memInfo.RegionSize;
+                if(size > cbFlush) {
+                        size = cbFlush;
                 }
                 dprintf(("Win32MemMap::flushView for offset %x, size %d", offset, size));
@@ -330 +341 @@
                         goto fail;
                 }
-                if(WriteFile(hMemFile, (LPSTR)lpvBase+i*PAGE_SIZE, size, &nrBytesWritten, NULL) == FALSE) {
-                        dprintf(("Win32MemMap::flushView: WriteFile failed for %x", (ULONG)lpvBase+i*PAGE_SIZE));
+                if(WriteFile(hMemFile, (LPSTR)lpvBase, size, &nrBytesWritten, NULL) == FALSE) {
+                        dprintf(("Win32MemMap::flushView: WriteFile failed for %x", (ULONG)lpvBase));
                         goto fail;
                 }
                 if(nrBytesWritten != size) {
-                        dprintf(("Win32MemMap::flushView: WriteFile didn't write all bytes for %x", (ULONG)lpvBase+i*PAGE_SIZE));
-                        goto fail;
-                }
-        }
+                        dprintf(("Win32MemMap::flushView: WriteFile didn't write all bytes for %x", (ULONG)lpvBase));
+                        goto fail;
+                }
+        }
+        lpvBase = (LPVOID)((ULONG)lpvBase + memInfo.RegionSize);
+
+        if(cbFlush < memInfo.RegionSize)
+                break;
+
+        cbFlush -= memInfo.RegionSize;
   }
 success:
-//  mapMutex.leave();
   return TRUE;
 parmfail:
   SetLastError(ERROR_INVALID_PARAMETER);
-//  mapMutex.leave();
   return FALSE;
 fail:
-//  mapMutex.leave();
   return FALSE;
 }
@@ -390 +404 @@
 }
 //******************************************************************************
+//Assumes mutex has been acquired
 //******************************************************************************
 void Win32MemMap::deleteAll()
@@ -400 +415 @@
 //******************************************************************************
 Win32MemMap *Win32MemMap::memmaps = NULL;
+
+//******************************************************************************
+//******************************************************************************
+Win32MemMapView::Win32MemMapView(Win32MemMap *map, ULONG offset, ULONG size, 
+                                 ULONG fdwAccess)
+{
+ LPVOID           viewaddr = (LPVOID)((ULONG)map->getMappingAddr()+offset);
+ ULONG            accessAttr = 0;
+ Win32MemMapView *tmpview  = mapviews;
+
+  errorState = 0;
+  mParentMap = map;
+  mSize    = size;
+  mOffset  = offset;
+
+  switch(fdwAccess) {
+  case FILE_MAP_READ:
+        accessAttr = PAG_READ;
+        mfAccess   = MEMMAP_ACCESS_READ;
+        break;
+  case FILE_MAP_WRITE:
+  case FILE_MAP_COPY:
+        accessAttr = (PAG_READ|PAG_WRITE);
+        mfAccess   = MEMMAP_ACCESS_WRITE;
+        break;
+  }
+  if(OSLibDosAliasMem(viewaddr, size, &pMapView, accessAttr) != OSLIB_NOERROR) {
+        dprintf(("new OSLibDosAliasMem FAILED"));
+        SetLastError(ERROR_NOT_ENOUGH_MEMORY);
+        errorState = 1;
+        return;
+  }
+
+  dprintf(("Win32MemMapView::Win32MemMapView: created %x (alias for %x), size %d", pMapView, viewaddr, size));
+
+  globalviewMutex.enter();
+  if(tmpview == NULL || tmpview->getViewAddr() > pMapView) {
+        next     = mapviews;
+        mapviews = this;
+  }
+  else {
+        while(tmpview->next) {
+                if(tmpview->next->getViewAddr() > pMapView) {
+                        break;
+                }
+                tmpview = tmpview->next;
+        }
+        next          = tmpview->next;
+        tmpview->next = this;
+  }
+  globalviewMutex.leave();
+}
+//******************************************************************************
+//******************************************************************************
+Win32MemMapView::~Win32MemMapView()
+{
+  if(errorState != 0)
+        return;
+
+  if(mfAccess != MEMMAP_ACCESS_READ)
+        mParentMap->flushView(mOffset, mSize);
+
+  OSLibDosFreeMem(pMapView);
+
+  globalviewMutex.enter();
+  Win32MemMapView *view = mapviews;
+
+  if(view == this) {
+        mapviews = next;
+  }
+  else {
+        while(view->next) {
+                if(view->next == this)
+                        break;
+                view = view->next;
+        }
+        if(view->next) {
+                view->next = next;
+        }
+        else    dprintf(("Win32MemMapView::~Win32MemMapView: map not found!! (%x)", this));
+  }
+  globalviewMutex.leave();
+}
+//******************************************************************************
+//******************************************************************************
+void Win32MemMapView::deleteView(Win32MemMap *map)
+{
+  globalviewMutex.enter();
+  Win32MemMapView *view = mapviews;
+
+  if(view != NULL) {
+        while(view) {
+                if(view->getParentMap() == map)
+                {
+                        globalviewMutex.leave();
+                        delete view;
+                        return;
+                }
+                view = view->next;
+        }
+  }
+  globalviewMutex.leave();
+}
+//******************************************************************************
+//******************************************************************************
+Win32MemMap *Win32MemMapView::findMapByView(ULONG address, ULONG *offset, 
+                                            ULONG accessType,
+                                            Win32MemMapView **pView)
+{
+  globalviewMutex.enter();
+  Win32MemMapView *view = mapviews;
+
+  *offset = 0;
+
+  if(view != NULL) {
+        while(view && (ULONG)view->getViewAddr() <= address) {
+                if((ULONG)view->getViewAddr() <= address && 
+                   (ULONG)view->getViewAddr() + view->getSize() >= address &&
+                   view->getAccessFlags() >= accessType)
+                {
+                        *offset = view->getOffset() + (address - (ULONG)view->getViewAddr());
+                        goto success;
+                }
+                view = view->next;
+        }
+        //failure if we get here
+        view = NULL;
+  }
+success:
+  globalviewMutex.leave();
+  if(pView) *pView = view;
+  return (view) ? view->getParentMap() : NULL;
+}
+//******************************************************************************
+//******************************************************************************
+Win32MemMapView *Win32MemMapView::findView(LPVOID address)
+{
+  Win32MemMapView *view = mapviews;
+
+  if(view != NULL) {
+        while(view) {
+                if(view->getViewAddr() == address)
+                {
+                        break;
+                }
+                view = view->next;
+        }
+  }
+  return view;
+}
+//******************************************************************************
+//******************************************************************************
+Win32MemMapView *Win32MemMapView::mapviews = NULL;
+

trunk/src/kernel32/mmap.h

@@ -1 @@
-/* $Id: mmap.h,v 1.8 1999-08-25 17:05:57 sandervl Exp $ */
+/* $Id: mmap.h,v 1.9 1999-08-27 16:51:00 sandervl Exp $ */
 
 /*
@@ -19 +19 @@
 #endif
 
+//commit 4 pages at once when the app accesses it
+#define NRPAGES_TOCOMMIT        200
+
+#define MEMMAP_ACCESS_READ      1
+#define MEMMAP_ACCESS_WRITE     2
+#define MEMMAP_ACCESS_EXECUTE   4
+
+class Win32MemMapView;
+
+//******************************************************************************
+//******************************************************************************
 class Win32MemMap
 {
@@ -26 +37 @@
 
    BOOL   Init(HANDLE hMemMap);
-   BOOL   flushView(LPVOID lpvBase, ULONG cbFlush);
+   BOOL   flushView(ULONG offset, ULONG cbFlush);
    LPVOID mapViewOfFile(ULONG size, ULONG offset, ULONG fdwAccess);
-   BOOL   unmapViewOfFile();
+   BOOL   unmapViewOfFile(Win32MemMapView *view);
 
    HFILE  getMapHandle()                 { return hMemMap; };
    LPSTR  getMemName()                   { return lpszMapName; };
    DWORD  getProtFlags()                 { return mProtFlags; };
+   LPVOID getMappingAddr()               { return pMapping; };
 
    void   AddRef()                       { ++referenced; };
    void   Release()                      { if(--referenced == 0) delete this; };
 
-   BOOL   hasReadAccess();
-   BOOL   hasWriteAccess();
-   BOOL   hasExecuteAccess();
- 
-   BOOL   commitPage(LPVOID lpPageFaultAddr, ULONG nrpages, BOOL fWriteAccess);
+   BOOL   commitPage(ULONG offset, BOOL fWriteAccess);
 
 static Win32MemMap *findMap(LPSTR lpszName);
@@ -56 +64 @@
    LPSTR  lpszMapName;
    void  *pMapping;
-   BOOL   fMapped;
+
+   ULONG  nrMappings;
 
    ULONG  referenced;
@@ -66 +75 @@
           Win32MemMap *next;
 };
+//******************************************************************************
+//Memory mapped file View Class
+//******************************************************************************
+class Win32MemMapView
+{
+public:
+   Win32MemMapView(Win32MemMap *map, ULONG offset, ULONG size, ULONG fdwAccess);
+  ~Win32MemMapView();
+
+   DWORD  getAccessFlags()               { return mfAccess; };
+   DWORD  getSize()                      { return mSize;    };
+   LPVOID getViewAddr()                  { return pMapView; };
+   ULONG  getOffset()                    { return mOffset;  };
+
+   BOOL   everythingOk()                 { return errorState == 0; };
+
+Win32MemMap *getParentMap()              { return mParentMap;};
+
+static void             deleteView(Win32MemMap *map);
+static Win32MemMap     *findMapByView(ULONG address, ULONG *offset, ULONG accessType, Win32MemMapView **pView=NULL);
+static Win32MemMapView *findView(LPVOID address);
+
+protected:
+   ULONG  mSize, errorState;
+   ULONG  mfAccess, mOffset;
+   void  *pMapView;
+
+   Win32MemMap *mParentMap;
+
+private:
+   static Win32MemMapView *mapviews;
+          Win32MemMapView *next;
+
+   friend class Win32MemMap;
+};
+//******************************************************************************
+//******************************************************************************
 
 #endif //__MMAP_H__

trunk/src/kernel32/oslibdos.cpp

@@ -1 @@
-/* $Id: oslibdos.cpp,v 1.2 1999-08-26 15:05:14 sandervl Exp $ */
+/* $Id: oslibdos.cpp,v 1.3 1999-08-27 16:51:00 sandervl Exp $ */
 
 /*
@@ -23 +23 @@
 #include "oslibdos.h"
 
+APIRET APIENTRY DosAliasMem(PVOID pb, ULONG cb, PPVOID ppbAlias, ULONG fl);
+
+//******************************************************************************
+//******************************************************************************
+DWORD OSLibDosAliasMem(LPVOID pb, ULONG cb, LPVOID *ppbAlias, ULONG fl)
+{
+  return DosAliasMem(pb, cb, ppbAlias, fl);
+}
 //******************************************************************************
 //******************************************************************************
 DWORD OSLibDosAllocMem(LPVOID *lplpMemAddr, DWORD size, DWORD flags)
 {
-//  return DosAllocMem(lplpMemAddr, size, flags | flAllocMem);
-  return DosAllocMem(lplpMemAddr, size, flags);
+  return DosAllocMem(lplpMemAddr, size, flags | flAllocMem);
 }
 //******************************************************************************

trunk/src/kernel32/oslibdos.h

@@ -1 @@
-/* $Id: oslibdos.h,v 1.2 1999-08-26 15:05:14 sandervl Exp $ */
+/* $Id: oslibdos.h,v 1.3 1999-08-27 16:51:00 sandervl Exp $ */
 
 /*
@@ -14 +14 @@
 
 
+DWORD OSLibDosAliasMem(LPVOID pb, ULONG cb, LPVOID *ppbAlias, ULONG fl);
 DWORD OSLibDosAllocMem(LPVOID *lplpMemAddr, DWORD size, DWORD flags);
 DWORD OSLibDosFreeMem(LPVOID lpMemAddr);

trunk/src/kernel32/virtual.cpp

@@ -1 @@
-/* $Id: virtual.cpp,v 1.10 1999-08-26 17:56:26 sandervl Exp $ */
+/* $Id: virtual.cpp,v 1.11 1999-08-27 16:51:01 sandervl Exp $ */
 
 /*
@@ -149 +149 @@
 {
  Win32MemMap *map;
+ DWORD offset;
 
     if (!base)
@@ -155 +156 @@
         return FALSE;
     }
-    map = Win32MemMap::findMap((ULONG)base);
+    map = Win32MemMapView::findMapByView((ULONG)base, &offset, MEMMAP_ACCESS_READ);
     if(map == NULL) {
         SetLastError( ERROR_FILE_NOT_FOUND );
         return FALSE;
     }
-    return map->flushView((LPVOID)base, cbFlush);
+    return map->flushView(offset, cbFlush);
 }
 
@@ -179 +180 @@
 {
  Win32MemMap *map;
+ Win32MemMapView *view;
+
+ DWORD offset;
 
     if (!addr)
@@ -185 +189 @@
         return FALSE;
     }
-    map = Win32MemMap::findMap((ULONG)addr);
+    map = Win32MemMapView::findMapByView((ULONG)addr, &offset, MEMMAP_ACCESS_READ, &view);
     if(map == NULL) {
         SetLastError( ERROR_FILE_NOT_FOUND );
         return FALSE;
     }
-    return map->unmapViewOfFile();
+    return map->unmapViewOfFile(view);
 }
 
@@ -461 +465 @@
         return 0;
   }
-  cbRangeSize = cbLength;
+  
+  cbRangeSize = cbLength & ~0xFFF;
+  if(cbLength & 0xFFF) {
+        cbRangeSize += PAGE_SIZE;
+  }
   rc = OSLibDosQueryMem((LPVOID)lpvAddress, &cbRangeSize, &dAttr);
   if(rc) {

trunk/src/kernel32/windll.cpp

@@ -1 @@
-/* $Id: windll.cpp,v 1.16 1999-08-26 12:55:37 sandervl Exp $ */
+/* $Id: windll.cpp,v 1.17 1999-08-27 16:51:01 sandervl Exp $ */
 
 /*
@@ -32 +32 @@
 #include "vmutex.h"
 #include "oslibmisc.h"
+#include "oslibdos.h"
 
 VMutex dlllistmutex;   //protects linked lists of heaps
@@ -165 +166 @@
  char   modname[CCHMAXPATH];
  char  *syspath;
- FILE  *dllfile;
+ HFILE  dllfile;
  APIRET rc;
  BOOL   fRet;
@@ -175 +176 @@
                 strcat(szFileName,".DLL");
         }
-        dllfile = fopen(szFileName, "r");
+        dllfile = OSLibDosOpen(szFileName, OSLIB_ACCESS_READONLY|OSLIB_ACCESS_SHAREDENYNONE);
         if(dllfile == NULL) {//search in libpath for dll
                 syspath = getenv("WIN32LIBPATH");
@@ -187 +188 @@
                 }
         }
-        else    fclose(dllfile);
+        else    OSLibDosClose(dllfile);
         if(isPEImage(szFileName) == TRUE) {
                 fRet = Win32Image::init(0);

trunk/src/kernel32/winimage.cpp

@@ -1 @@
-/* $Id: winimage.cpp,v 1.17 1999-08-26 12:55:37 sandervl Exp $ */
+/* $Id: winimage.cpp,v 1.18 1999-08-27 16:51:01 sandervl Exp $ */
 
 /*
@@ -200 +200 @@
  IMAGE_TLS_DIRECTORY *tlsDir = NULL;
  int    nSections, i;
+ char   szFullPath[CCHMAXPATH] = "";
 
   fImgMapping = VIRTUAL_MapFileA(szFileName, &win32file);
@@ -207 +208 @@
         WinMessageBox(HWND_DESKTOP, HWND_DESKTOP, szErrorMsg, szErrorTitle, 0, MB_OK | MB_ERROR | MB_MOVEABLE);
         goto failure;
+  }
+
+  if(DosQueryPathInfo(szFileName, FIL_QUERYFULLNAME, szFullPath, sizeof(szFullPath)) == 0) {
+        setFullPath(szFullPath);
   }
 
@@ -425 +430 @@
         }
   }
-
-  if(processImports((char *)win32file) == FALSE) {
-        fout << "Failed to process imports!" << endl;
-        goto failure;
-  }
-
   if(fh.Characteristics & IMAGE_FILE_DLL) {
         if(processExports((char *)win32file) == FALSE) {
@@ -437 +436 @@
         }
   }
+
+  if(processImports((char *)win32file) == FALSE) {
+        fout << "Failed to process imports!" << endl;
+        goto failure;
+  }
+
   IMAGE_SECTION_HEADER sh;
   if(GetSectionHdrByName (win32file, &sh, ".rsrc")) {
@@ -797 +802 @@
   apiaddr = WinDll->getApi(ordinal);
   if(apiaddr == 0) {
-    fout << "--->>> NOT FOUND!";
-    *import = (ULONG)MissingApi;
+        fout << "--->>> NOT FOUND!";
+        *import = (ULONG)MissingApi;
   }
   else  *import = apiaddr;
@@ -812 +817 @@
   apiaddr = WinDll->getApi(impname);
   if(apiaddr == 0) {
-    fout << "--->>> NOT FOUND!";
-    *import = (ULONG)MissingApi;
+        fout << "--->>> NOT FOUND!";
+        *import = (ULONG)MissingApi;
   }
   else  *import = apiaddr;

trunk/src/kernel32/wprocess.cpp

@@ -1 @@
-/* $Id: wprocess.cpp,v 1.29 1999-08-26 12:55:38 sandervl Exp $ */
+/* $Id: wprocess.cpp,v 1.30 1999-08-27 16:51:01 sandervl Exp $ */
 
 /*
@@ -234 +234 @@
         winexe->setTLSCallBackAddr(TlsCallbackAddr);
 
-        char *modname = getenv("WIN32MODULE");
-
-        if(modname != NULL)
-        {
-                dprintf(("Set full path for exe to %s", modname));
-                winexe->setFullPath(modname);
-        }
         winexe->start();
   }