Changeset 4496 for trunk/src/kernel32


Ignore:
Timestamp:
Oct 18, 2000, 7:09:34 PM (25 years ago)
Author:
sandervl
Message:

LoadLibraryExA + memory map close fix, added new registry keys for installation, don't log guard page violation

Location:
trunk/src/kernel32
Files:
10 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/kernel32/exceptions.cpp

    r4433 r4496  
    1 /* $Id: exceptions.cpp,v 1.46 2000-10-05 18:36:49 sandervl Exp $ */
     1/* $Id: exceptions.cpp,v 1.47 2000-10-18 17:09:31 sandervl Exp $ */
    22
    33/* WARNING: Compiling this module with ICC with optimizations turned on   */
    … …  
    10481048#endif
    10491049
    1050 //in misc.cpp
    1051 void CheckLogException();
    1052 
    10531050ULONG APIENTRY OS2ExceptionHandler(PEXCEPTIONREPORTRECORD       pERepRec,
    10541051                                   PEXCEPTIONREGISTRATIONRECORD pERegRec,
    … …  
    10581055  //SvL: Check if exception inside debug fprintf -> if so, clear lock so
    10591056  //     next dprintf won't wait forever
    1060   CheckLogException();
    1061 
     1057  LogException(ENTER_EXCEPTION);
    10621058
    10631059  /* Access violation at a known location */
    … …  
    10831079                }
    10841080                dprintf(("KERNEL32: OS2ExceptionHandler: fix and continue\n"));
    1085                 return (XCPT_CONTINUE_EXECUTION);
     1081                goto continueexecution;
    10861082        }
    10871083        else
    10881084        {
    10891085                dprintf(("KERNEL32: OS2ExceptionHandler: continue search\n"));
    1090                 return (XCPT_CONTINUE_SEARCH);
     1086                goto continuesearch;
    10911087        }
    10921088
    … …  
    10951091        dprintfException(pERepRec, pERegRec, pCtxRec, p);
    10961092        SetExceptionChain((ULONG)-1);
    1097         return (XCPT_CONTINUE_SEARCH);
     1093        goto continuesearch;
    10981094
    10991095  case XCPT_ACCESS_VIOLATION:
    … …  
    11261122        }
    11271123        if(map->commitPage(offset, fWriteAccess) == TRUE)
    1128                 return (XCPT_CONTINUE_EXECUTION);
     1124                goto continueexecution;
    11291125
    11301126        //no break;
    … …  
    11771173        //    recurse infinitely until we run out of stack space!!
    11781174        if (pERepRec->fHandlerFlags & EH_NESTED_CALL)
    1179                 return XCPT_CONTINUE_SEARCH;
     1175                goto continuesearch;
    11801176
    11811177#ifdef DEBUG
    … …  
    11891185                if(OSLibDispatchException(pERepRec, pERegRec, pCtxRec, p) == TRUE)
    11901186                {
    1191                         return (XCPT_CONTINUE_EXECUTION);
     1187                        goto continueexecution;
    11921188                }
    11931189        }
    1194         else    return XCPT_CONTINUE_SEARCH; //pass on to OS/2 RTL or app exception handler
     1190        else    goto continuesearch; //pass on to OS/2 RTL or app exception handler
    11951191
    11961192        dprintf(("KERNEL32: OS2ExceptionHandler: Continue and kill\n"));
    … …  
    11991195        pCtxRec->ctx_RegEax = pERepRec->ExceptionNum;
    12001196        pCtxRec->ctx_RegEbx = pCtxRec->ctx_RegEip;
    1201         return (XCPT_CONTINUE_EXECUTION);
     1197        goto continueexecution;
    12021198
    12031199  //@@@PH: growing thread stacks might need special treatment
    12041200  case XCPT_GUARD_PAGE_VIOLATION:
    1205     dprintf(("KERNEL32: OS2ExceptionHandler: trying to grow stack (continue search)"));
    1206     return (XCPT_CONTINUE_SEARCH);
     1201        //SvL: don't print anything here -> fatal hang if happens inside fprintf
     1202        //dprintf(("KERNEL32: OS2ExceptionHandler: trying to grow stack (continue search)"));
     1203        goto continuesearch;
    12071204
    12081205  case XCPT_SIGNAL:
    1209       if(pERepRec->ExceptionInfo[0] == XCPT_SIGNAL_KILLPROC)          /* resolve signal information */
    1210       {
    1211         SetExceptionChain((ULONG)-1);
    1212         return (XCPT_CONTINUE_SEARCH);
    1213       }
    1214       goto CrashAndBurn;
     1206        if(pERepRec->ExceptionInfo[0] == XCPT_SIGNAL_KILLPROC)          /* resolve signal information */
     1207        {
     1208            SetExceptionChain((ULONG)-1);
     1209            goto continuesearch;
     1210        }
     1211        goto CrashAndBurn;
    12151212
    12161213  default: //non-continuable exceptions
    12171214        dprintfException(pERepRec, pERegRec, pCtxRec, p);
    1218         return (XCPT_CONTINUE_SEARCH);
    1219   }
    1220   return (XCPT_CONTINUE_SEARCH);
     1215        goto continuesearch;
     1216  }
     1217continuesearch:
     1218  LogException(LEAVE_EXCEPTION);
     1219  return XCPT_CONTINUE_SEARCH;
     1220
     1221continueexecution:
     1222  LogException(LEAVE_EXCEPTION);
     1223  return XCPT_CONTINUE_EXECUTION;
    12211224}
    12221225

  • trunk/src/kernel32/exceptutil.h

    r4189 r4496  
    1 /* $Id: exceptutil.h,v 1.9 2000-09-04 18:24:42 sandervl Exp $ */
     1/* $Id: exceptutil.h,v 1.10 2000-10-18 17:09:32 sandervl Exp $ */
    22
    33/*
    … …  
    4949#endif
    5050
     51#define ENTER_EXCEPTION 0
     52#define LEAVE_EXCEPTION 1
     53void LogException(int state);
     54
    5155#endif

  • trunk/src/kernel32/hmfile.cpp

    r4474 r4496  
    1 /* $Id: hmfile.cpp,v 1.22 2000-10-10 17:14:03 sandervl Exp $ */
     1/* $Id: hmfile.cpp,v 1.23 2000-10-18 17:09:32 sandervl Exp $ */
    22
    33/*
    … …  
    597597//  }
    598598
    599 //testestest!!!!
    600     dprintf(("%s", lpRealBuf));
    601 //testestest!!!!
    602 
    603 
    604599  dprintf(("KERNEL32: HMDeviceFileClass::WriteFile returned %08xh\n",
    605600           bRC));

  • trunk/src/kernel32/initsystem.cpp

    r4474 r4496  
    1 /* $Id: initsystem.cpp,v 1.18 2000-10-10 17:14:04 sandervl Exp $ */
     1/* $Id: initsystem.cpp,v 1.19 2000-10-18 17:09:32 sandervl Exp $ */
    22/*
    33 * Odin system initialization (registry, directories & environment)
    … …  
    568568*/
    569569
     570   //[HKEY_LOCAL_MACHINE\SYSTEM\ControlSet002\Control\FileSystem]
     571   //"Win31FileSystem"=dword:00000000
     572   //"NtfsDisable8dot3NameCreation"=dword:00000000
     573   //"Win95TruncatedExtensions"=dword:00000001
     574   if(RegCreateKeyA(HKEY_LOCAL_MACHINE,"SYSTEM\\CurrentControlSet\\Control\\FileSystem",&hkey)!=ERROR_SUCCESS) {
     575        goto initreg_error;
     576   }
     577   val = 0x0;
     578   RegSetValueExA(hkey, "Win31FileSystem",0,REG_DWORD, (LPBYTE)&val, sizeof(DWORD));
     579   val = 0x0;
     580   RegSetValueExA(hkey, "NtfsDisable8dot3NameCreation",0,REG_DWORD, (LPBYTE)&val, sizeof(DWORD));
     581   val = 0x1;
     582   RegSetValueExA(hkey, "Win95TruncatedExtensions",0,REG_DWORD, (LPBYTE)&val, sizeof(DWORD));
     583   RegCloseKey(hkey);
     584
    570585   return TRUE;
    571586

  • trunk/src/kernel32/misc.cpp

    r4431 r4496  
    1 /* $Id: misc.cpp,v 1.26 2000-10-05 13:48:09 sandervl Exp $ */
     1/* $Id: misc.cpp,v 1.27 2000-10-18 17:09:33 sandervl Exp $ */
    22
    33/*
    … …  
    2929#include "initterm.h"
    3030#include "logging.h"
     31#include "exceptutil.h"
    3132#include <wprocess.h>
    3233#include <versionos2.h>
    … …  
    251252#if defined(DEBUG) && defined(CHECK_ODINHEAP)
    252253int checkOdinHeap = 1;
    253 #define ODIN_HEAPCHECK()        if(checkOdinHeap)       _heap_check();
     254#define ODIN_HEAPCHECK()    if(checkOdinHeap)   _heap_check();
    254255#else
    255256#define ODIN_HEAPCHECK()
    … …  
    272273    if(!getenv("NOWIN32LOG")) {
    273274#endif
    274         char logname[CCHMAXPATH];
    275 
    276         sprintf(logname, "odin32_%d.log", loadNr);
    277         flog = fopen(logname, "w");
    278         if(flog == NULL) {//probably running exe on readonly device
    279                 sprintf(logname, "%sodin32_%d.log", kernel32Path, loadNr);
    280                 flog = fopen(logname, "w");
    281         }
     275        char logname[CCHMAXPATH];
     276
     277        sprintf(logname, "odin32_%d.log", loadNr);
     278        flog = fopen(logname, "w");
     279        if(flog == NULL) {//probably running exe on readonly device
     280            sprintf(logname, "%sodin32_%d.log", kernel32Path, loadNr);
     281            flog = fopen(logname, "w");
     282        }
    282283        oldcrtmsghandle = _set_crt_msg_handle(fileno(flog));
    283284    }
    … …  
    291292
    292293    va_start(argptr, tekst);
    293     if(thdb) { 
    294         thdb->logfile = (DWORD)flog;
     294    if(thdb) {
     295    thdb->logfile = (DWORD)flog;
    295296        if(sel == 0x150b && !fIsOS2Image) {
    296                 fprintf(flog, "t%d: (FS=150B) ", thdb->threadId);
    297         }
    298         else    fprintf(flog, "t%d: ", thdb->threadId);
     297        fprintf(flog, "t%d: (FS=150B) ", thdb->threadId);
     298    }
     299    else    fprintf(flog, "t%d: ", thdb->threadId);
    299300    }
    300301    vfprintf(flog, tekst, argptr);
    … …  
    326327    if(!getenv("NOWIN32LOG")) {
    327328#endif
    328         char logname[CCHMAXPATH];
    329 
    330         sprintf(logname, "odin32_%d.log", loadNr);
    331         flog = fopen(logname, "w");
    332         if(flog == NULL) {//probably running exe on readonly device
    333                 sprintf(logname, "%sodin32_%d.log", kernel32Path, loadNr);
    334                 flog = fopen(logname, "w");
    335         }
     329        char logname[CCHMAXPATH];
     330
     331        sprintf(logname, "odin32_%d.log", loadNr);
     332        flog = fopen(logname, "w");
     333        if(flog == NULL) {//probably running exe on readonly device
     334            sprintf(logname, "%sodin32_%d.log", kernel32Path, loadNr);
     335            flog = fopen(logname, "w");
     336        }
    336337    }
    337338    else
    … …  
    344345
    345346    va_start(argptr, tekst);
    346     if(thdb) { 
    347         thdb->logfile = (DWORD)flog;
     347    if(thdb) {
     348        thdb->logfile = (DWORD)flog;
    348349    }
    349350    vfprintf(flog, tekst, argptr);
    … …  
    378379
    379380    va_start(argptr, tekst);
     381    if(thdb) {
     382        thdb->logfile = (DWORD)flog;
     383    }
    380384    vfprintf((FILE *)logfile, tekst, argptr);
    381385    if(thdb) thdb->logfile = 0;
    … …  
    390394}
    391395//******************************************************************************
    392 //Check if the exception occurred inside a fprintf (logging THDB member set)
    393 //If true, decrease the lock count for that file stream
    394 //NOTE: HACK: DEPENDS ON COMPILER VERSION!!!!
    395 //******************************************************************************
    396 void CheckLogException()
     396//WriteLog has to take special care to handle dprintfs inside our os/2 exception
     397//handler; if an exception occurs inside a dprintf, using dprintf in the exception
     398//handler will hang the process
     399//******************************************************************************
     400void LogException(int state)
    397401{
    398402  THDB *thdb = GetThreadTHDB();
    … …  
    402406
    403407  if(thdb->logfile) {
    404         //oops, exception in vfprintf; let's clear the lock count
     408    if(state == ENTER_EXCEPTION) {
    405409#if (__IBMCPP__ == 300) || (__IBMC__ == 300)
    406         lock = (USHORT *)(thdb->logfile+0x1C);
     410        lock = (USHORT *)(thdb->logfile+0x1C);
    407411#else
    408412#error Check the offset of the lock count word in the file stream structure for this compiler revision!!!!!
    409413#endif
    410         (*lock)--;
     414        (*lock)--;
     415    }
     416    else { //LEAVE_EXCEPTION
     417#if (__IBMCPP__ == 300) || (__IBMC__ == 300)
     418        lock = (USHORT *)(thdb->logfile+0x1C);
     419#else
     420#error Check the offset of the lock count word in the file stream structure for this compiler revision!!!!!
     421#endif
     422        (*lock)++;
     423    }
     424  }
     425}
     426//******************************************************************************
     427//Check if the exception occurred inside a fprintf (logging THDB member set)
     428//If true, decrease the lock count for that file stream
     429//NOTE: HACK: DEPENDS ON COMPILER VERSION!!!!
     430//******************************************************************************
     431void CheckLogException()
     432{
     433  THDB *thdb = GetThreadTHDB();
     434  USHORT *lock;
     435
     436  if(!thdb) return;
     437
     438  if(thdb->logfile) {
     439    //oops, exception in vfprintf; let's clear the lock count
     440#if (__IBMCPP__ == 300) || (__IBMC__ == 300)
     441    lock = (USHORT *)(thdb->logfile+0x1C);
     442#else
     443#error Check the offset of the lock count word in the file stream structure for this compiler revision!!!!!
     444#endif
     445    (*lock)--;
    411446  }
    412447}
    … …  
    418453{
    419454  if(oldcrtmsghandle)
    420         _set_crt_msg_handle(oldcrtmsghandle);
     455    _set_crt_msg_handle(oldcrtmsghandle);
    421456
    422457  fclose(flog);
    … …  
    433468    if(!getenv("NOWIN32LOG")) {
    434469#endif
    435         OpenPrivateLogFilePE();
     470    OpenPrivateLogFilePE();
    436471    }
    437472}
    … …  
    446481    if(!getenv("NOWIN32LOG")) {
    447482#endif
    448         ClosePrivateLogFilePE();
     483        ClosePrivateLogFilePE();
    449484    }
    450485}

  • trunk/src/kernel32/mmap.cpp

    r4230 r4496  
    1 /* $Id: mmap.cpp,v 1.44 2000-09-10 21:54:07 sandervl Exp $ */
     1/* $Id: mmap.cpp,v 1.45 2000-10-18 17:09:33 sandervl Exp $ */
    22
    33/*
    … …  
    3434#include <winimagepeldr.h>
    3535
    36 #define DBG_LOCALLOG    DBG_mmap
     36#define DBG_LOCALLOG    DBG_mmap
    3737#include "dbglocal.h"
    3838
    … …  
    6969
    7070  if(lpszName) {
    71         lpszMapName = (char *)_smalloc(strlen(lpszName)+1);
    72         strcpy(lpszMapName, lpszName);
    73   }
    74   else  lpszMapName = NULL;
     71    lpszMapName = (char *)_smalloc(strlen(lpszName)+1);
     72    strcpy(lpszMapName, lpszName);
     73  }
     74  else  lpszMapName = NULL;
    7575}
    7676//******************************************************************************
    … …  
    105105  {
    106106#if 0
    107         if(DuplicateHandle(mProcessId, hMemFile, GetCurrentProcess(),
     107        if(DuplicateHandle(mProcessId, hMemFile, GetCurrentProcess(),
    108108                           &hMemFile, 0, FALSE, DUPLICATE_SAME_ACCESS) == FALSE)
    109109#else
    110         DWORD dwOdinOptions;
    111 
    112         if(!(mProtFlags & PAGE_READWRITE)) {
    113                 dwOdinOptions = DUPLICATE_ACCESS_READ | DUPLICATE_SHARE_DENYNONE;
    114         }
    115         else    dwOdinOptions = DUPLICATE_ACCESS_READWRITE | DUPLICATE_SHARE_DENYNONE;
    116 
    117         if(HMDuplicateHandleOdin(mProcessId, hMemFile, GetCurrentProcess(),
     110    DWORD dwOdinOptions;
     111
     112    if(!(mProtFlags & PAGE_READWRITE)) {
     113        dwOdinOptions = DUPLICATE_ACCESS_READ | DUPLICATE_SHARE_DENYNONE;
     114    }
     115    else    dwOdinOptions = DUPLICATE_ACCESS_READWRITE | DUPLICATE_SHARE_DENYNONE;
     116
     117        if(HMDuplicateHandleOdin(mProcessId, hMemFile, GetCurrentProcess(),
    118118                           &hMemFile, 0, FALSE, DUPLICATE_SAME_ACCESS, dwOdinOptions) == FALSE)
    119119#endif
    120         {
    121                 dprintf(("Win32MemMap::Init: DuplicateHandle failed!"));
    122                 goto fail;
    123         }
    124         mSize = SetFilePointer(hMemFile, 0, NULL, FILE_BEGIN);
    125         mSize = SetFilePointer(hMemFile, 0, NULL, FILE_END);
    126         if(mSize == -1) {
    127                 dprintf(("Win32MemMap::init: SetFilePointer failed to set pos end"));
    128                 goto fail;
    129         }
    130         //SvL: Temporary limitation of size (Warp Server Advanced doesn't allow
     120        {
     121        dprintf(("Win32MemMap::Init: DuplicateHandle failed!"));
     122        goto fail;
     123        }
     124    mSize = SetFilePointer(hMemFile, 0, NULL, FILE_BEGIN);
     125    mSize = SetFilePointer(hMemFile, 0, NULL, FILE_END);
     126    if(mSize == -1) {
     127        dprintf(("Win32MemMap::init: SetFilePointer failed to set pos end"));
     128        goto fail;
     129    }
     130    //SvL: Temporary limitation of size (Warp Server Advanced doesn't allow
    131131        //     one to reserve more than 450 MB (unless you override the virtual
    132132        //     memory max limit) of continuous memory; (Warp 4 much less))
    133         if(mSize > 64*1024*1024) {
    134                 mSize = 64*1024*1024;
    135         }
     133    if(mSize > 64*1024*1024) {
     134        mSize = 64*1024*1024;
     135    }
    136136  }
    137137
    … …  
    154154  mapMutex.enter();
    155155  if(lpszMapName) {
    156         free(lpszMapName);
     156    free(lpszMapName);
    157157  }
    158158  if(pMapping && !image) {
    159         if(lpszMapName) {
    160                 OSLibDosFreeMem(pMapping);
    161         }
    162         else    VirtualFree(pMapping, mSize, MEM_RELEASE);
    163 
    164         pMapping = NULL;
     159    if(lpszMapName) {
     160        OSLibDosFreeMem(pMapping);
     161    }
     162    else    VirtualFree(pMapping, mSize, MEM_RELEASE);
     163
     164    pMapping = NULL;
    165165  }
    166166  if(hMemFile != -1) {
    167         CloseHandle(hMemFile);
    168         hMemFile = -1;
     167    dprintf(("Win32MemMap dtor: closing memory file %x", hMemFile));
     168    CloseHandle(hMemFile);
     169    hMemFile = -1;
    169170  }
    170171  mapMutex.leave();
    … …  
    174175
    175176  if(map == this) {
    176         memmaps = next;
     177    memmaps = next;
    177178  }
    178179  else {
    179         while(map->next) {
    180                 if(map->next == this)
    181                         break;
    182                 map = map->next;
    183         }
    184         if(map->next) {
    185                 map->next = next;
    186         }
    187         else    dprintf(("Win32MemMap::~Win32MemMap: map not found!! (%x)", this));
     180    while(map->next) {
     181        if(map->next == this)
     182            break;
     183        map = map->next;
     184    }
     185    if(map->next) {
     186         map->next = next;
     187    }
     188    else dprintf(("Win32MemMap::~Win32MemMap: map not found!! (%x)", this));
    188189  }
    189190  globalmapMutex.leave(&hGlobalMapMutex);
     191}
     192//******************************************************************************
     193//If memory map has no more views left, then we can safely delete it when
     194//it's handle is closed
     195//******************************************************************************
     196void Win32MemMap::close()
     197{
     198  fClosed = TRUE;
     199  if(nrMappings == 0) {
     200        delete this;
     201  }
    190202}
    191203//******************************************************************************
    … …  
    205217
    206218  if(image) {
    207         return image->commitPage(pageAddr, fWriteAccess);
     219    return image->commitPage(pageAddr, fWriteAccess);
    208220  }
    209221  newProt  = mProtFlags & (PAGE_READONLY | PAGE_READWRITE | PAGE_WRITECOPY);
    210222
    211223  dprintf(("Win32MemMap::commitPage %x (faultaddr %x)", pageAddr, lpPageFaultAddr));
    212   if(hMemFile != -1) 
     224  if(hMemFile != -1)
    213225  {
    214         int faultsize = nrpages*PAGE_SIZE;
    215 
    216         offset = pageAddr - (ULONG)pMapping;
    217         if(offset + faultsize > mSize) {
    218                 faultsize = mSize - offset;
    219         }
    220 
    221         while(faultsize) {
    222                 if(VirtualQuery((LPSTR)pageAddr, &memInfo, sizeof(MEMORY_BASIC_INFORMATION)) == 0) {
    223                         dprintf(("Win32MemMap::commitPage: VirtualQuery (%x,%x) failed for %x", pageAddr, nrpages*PAGE_SIZE));
    224                         goto fail;
    225                 }
    226                 memInfo.RegionSize = min(memInfo.RegionSize, faultsize);
    227                 //Only changes the state of the pages with the same attribute flags
    228                 //(returned in memInfo.RegionSize)
    229                 //If it's smaller than the mNrPages, it simply means one or more of the
    230                 //other pages have already been committed
    231                 if(!(memInfo.State & MEM_COMMIT))
    232                 {
    233                         if(VirtualAlloc((LPVOID)pageAddr, memInfo.RegionSize, MEM_COMMIT, PAGE_READWRITE) == FALSE) {
    234                                 goto fail;
    235                         }
    236                         if(!fWriteAccess) {
    237                                 offset = pageAddr - (ULONG)pMapping;
    238                                 size   = memInfo.RegionSize;
    239                                 if(offset + size > mSize) {
    240                                         dprintf(("Adjusting size from %d to %d", size, mSize - offset));
    241                                         size = mSize - offset;
    242                                 }
    243                                 if(SetFilePointer(hMemFile, offset, NULL, FILE_BEGIN) != offset) {
    244                                         dprintf(("Win32MemMap::commitPage: SetFilePointer failed to set pos to %x", offset));
    245                                         goto fail;
    246                                 }
    247                                 if(ReadFile(hMemFile, (LPSTR)pageAddr, size, &nrBytesRead, NULL) == FALSE) {
    248                                         dprintf(("Win32MemMap::commitPage: ReadFile failed for %x", pageAddr));
    249                                         goto fail;
    250                                 }
    251                                 if(nrBytesRead != size) {
    252                                         dprintf(("Win32MemMap::commitPage: ReadFile didn't read all bytes for %x", pageAddr));
    253                                         goto fail;
    254                                 }
    255                         }
    256                         if(newProt != PAGE_READWRITE) {
    257                                 if(VirtualProtect((LPVOID)pageAddr, memInfo.RegionSize, newProt, &oldProt) == FALSE) {
    258                                         goto fail;
    259                                 }
    260                         }
    261                 }
    262                 faultsize -= memInfo.RegionSize;
    263                 pageAddr  += memInfo.RegionSize;
    264         }
     226    int faultsize = nrpages*PAGE_SIZE;
     227
     228    offset = pageAddr - (ULONG)pMapping;
     229    if(offset + faultsize > mSize) {
     230        faultsize = mSize - offset;
     231    }
     232
     233    while(faultsize) {
     234        if(VirtualQuery((LPSTR)pageAddr, &memInfo, sizeof(MEMORY_BASIC_INFORMATION)) == 0) {
     235            dprintf(("Win32MemMap::commitPage: VirtualQuery (%x,%x) failed for %x", pageAddr, nrpages*PAGE_SIZE));
     236            goto fail;
     237        }
     238        memInfo.RegionSize = min(memInfo.RegionSize, faultsize);
     239        //Only changes the state of the pages with the same attribute flags
     240        //(returned in memInfo.RegionSize)
     241        //If it's smaller than the mNrPages, it simply means one or more of the
     242            //other pages have already been committed
     243        if(!(memInfo.State & MEM_COMMIT))
     244        {
     245            if(VirtualAlloc((LPVOID)pageAddr, memInfo.RegionSize, MEM_COMMIT, PAGE_READWRITE) == FALSE) {
     246                goto fail;
     247            }
     248            if(!fWriteAccess) {
     249                offset = pageAddr - (ULONG)pMapping;
     250                size   = memInfo.RegionSize;
     251                if(offset + size > mSize) {
     252                    dprintf(("Adjusting size from %d to %d", size, mSize - offset));
     253                    size = mSize - offset;
     254                }
     255                if(SetFilePointer(hMemFile, offset, NULL, FILE_BEGIN) != offset) {
     256                    dprintf(("Win32MemMap::commitPage: SetFilePointer failed to set pos to %x", offset));
     257                    goto fail;
     258                }
     259                if(ReadFile(hMemFile, (LPSTR)pageAddr, size, &nrBytesRead, NULL) == FALSE) {
     260                    dprintf(("Win32MemMap::commitPage: ReadFile failed for %x", pageAddr));
     261                    goto fail;
     262                }
     263                if(nrBytesRead != size) {
     264                    dprintf(("Win32MemMap::commitPage: ReadFile didn't read all bytes for %x", pageAddr));
     265                    goto fail;
     266                }
     267            }
     268            if(newProt != PAGE_READWRITE) {
     269                if(VirtualProtect((LPVOID)pageAddr, memInfo.RegionSize, newProt, &oldProt) == FALSE) {
     270                    goto fail;
     271                }
     272            }
     273        }
     274        faultsize -= memInfo.RegionSize;
     275        pageAddr  += memInfo.RegionSize;
     276    }
    265277  }
    266278  else {
    267         ULONG sizeleft = nrpages*PAGE_SIZE;
    268         while(sizeleft)
    269         {
    270                 if(VirtualQuery((LPSTR)pageAddr, &memInfo, sizeof(MEMORY_BASIC_INFORMATION)) == 0) {
    271                         dprintf(("Win32MemMap::commitPage: VirtualQuery (%x,%x) failed", pageAddr, sizeleft));
    272                         goto fail;
    273                 }
    274                 memInfo.RegionSize = min(memInfo.RegionSize, sizeleft);
    275 
    276                 if(!(memInfo.State & MEM_COMMIT))
    277                 {//if it's already committed, then the app tried to write to it
    278                         if(VirtualAlloc((LPVOID)pageAddr, memInfo.RegionSize, MEM_COMMIT, newProt) == FALSE)
    279                                 goto fail;
    280                 }
    281                 memInfo.RegionSize = (memInfo.RegionSize+PAGE_SIZE-1) & ~0xfff;
    282                 pageAddr += memInfo.RegionSize;
    283                 sizeleft -= memInfo.RegionSize;
    284         }
     279    ULONG sizeleft = nrpages*PAGE_SIZE;
     280    while(sizeleft)
     281    {
     282        if(VirtualQuery((LPSTR)pageAddr, &memInfo, sizeof(MEMORY_BASIC_INFORMATION)) == 0) {
     283            dprintf(("Win32MemMap::commitPage: VirtualQuery (%x,%x) failed", pageAddr, sizeleft));
     284            goto fail;
     285        }
     286        memInfo.RegionSize = min(memInfo.RegionSize, sizeleft);
     287
     288        if(!(memInfo.State & MEM_COMMIT))
     289            {//if it's already committed, then the app tried to write to it
     290            if(VirtualAlloc((LPVOID)pageAddr, memInfo.RegionSize, MEM_COMMIT, newProt) == FALSE)
     291                goto fail;
     292        }
     293        memInfo.RegionSize = (memInfo.RegionSize+PAGE_SIZE-1) & ~0xfff;
     294        pageAddr += memInfo.RegionSize;
     295        sizeleft -= memInfo.RegionSize;
     296    }
    285297  }
    286298
    … …  
    299311
    300312  if(nrMappings == 0)
    301         goto fail;
     313    goto fail;
    302314
    303315  delete view;
    304316
    305317  if(--nrMappings == 0) {
    306         VirtualFree(pMapping, mSize, MEM_RELEASE);
    307         pMapping = NULL;
     318    VirtualFree(pMapping, mSize, MEM_RELEASE);
     319    pMapping = NULL;
    308320  }
    309321  mapMutex.leave();
    310  
     322
    311323  //if there are no more mappings left and the memory map's handle has been
    312324  //closed, then delete the object
    313325  if(nrMappings == 0 && fClosed) {
    314         delete this;
     326    delete this;
    315327  }
    316328  return TRUE;
    317329fail:
    318330  mapMutex.leave();
     331  if(nrMappings == 0 && fClosed) {
     332    delete this;
     333  }
    319334  return FALSE;
    320335}
    … …  
    333348  // Docs say FILE_MAP_ALL_ACCESS is same as FILE_MAP_WRITE. Doesn't match reality though.
    334349  if(fdwAccess & ~FILE_MAP_ALL_ACCESS)
    335         goto parmfail;
     350    goto parmfail;
    336351  if((fdwAccess & FILE_MAP_WRITE) && !(mProtFlags & PAGE_READWRITE))
    337         goto parmfail;
     352    goto parmfail;
    338353  if((fdwAccess & FILE_MAP_READ) && !(mProtFlags & (PAGE_READWRITE|PAGE_READONLY)))
    339         goto parmfail;
     354    goto parmfail;
    340355
    341356  //@@@PH
    … …  
    345360
    346361  if(offset+size > mSize && (!(fdwAccess & FILE_MAP_WRITE) || hMemFile == -1))
    347         goto parmfail;
     362    goto parmfail;
    348363
    349364  //SvL: TODO: Doesn't work for multiple views
    350365  if(offset+size > mSize) {
    351         mSize = offset+size;
     366    mSize = offset+size;
    352367  }
    353368
    … …  
    355370#if 0
    356371  if(mProtFlags & SEC_COMMIT)
    357         fAlloc |= MEM_COMMIT;
     372    fAlloc |= MEM_COMMIT;
    358373  else
    359374  if(mProtFlags & SEC_RESERVE)
    360         fAlloc |= MEM_RESERVE;
     375    fAlloc |= MEM_RESERVE;
    361376#else
    362377  fAlloc = MEM_RESERVE;
    … …  
    365380  //Memory has already been allocated for executable image maps (only used internally)
    366381  if(!pMapping && nrMappings == 0) {//if not mapped, reserve/commit entire view
    367         //SvL: Always read/write access or else ReadFile will crash once we
    368         //     start committing pages.
    369         //     This is most likely an OS/2 bug and doesn't happen in Aurora
     382    //SvL: Always read/write access or else ReadFile will crash once we
     383    //     start committing pages.
     384    //     This is most likely an OS/2 bug and doesn't happen in Aurora
    370385        //     when allocating memory with the PAG_ANY bit set. (without this
    371386        //     flag it will also crash)
    372         if(hMemFile == -1 && lpszMapName) {
    373                 pMapping = VirtualAllocShared(mSize, fAlloc, PAGE_READWRITE, lpszMapName);
    374         }
    375         else {
    376                 pMapping = VirtualAlloc(0, mSize, fAlloc, PAGE_READWRITE);
    377         }
    378         if(pMapping == NULL) {
    379                 dprintf(("Win32MemMap::mapFileView: VirtualAlloc %x %x %x failed!", mSize, fAlloc, memFlags));
    380                 goto fail;
    381         }
    382         //Windows NT seems to commit memory for memory maps, regardsless of the SEC_COMMIT flag
    383         if((hMemFile == -1 && !image)) {//commit memory
    384                 VirtualAlloc(pMapping, mSize, MEM_COMMIT, PAGE_READWRITE);
    385         }
    386         if(hMemFile != -1 && (mProtFlags & SEC_COMMIT)) {
    387                 DWORD nrPages = mSize >> PAGE_SHIFT;
    388                 if(mSize & 0xFFF)
    389                         nrPages++;
    390 
    391                 commitPage(0, FALSE, nrPages);
    392         }
     387    if(hMemFile == -1 && lpszMapName) {
     388        pMapping = VirtualAllocShared(mSize, fAlloc, PAGE_READWRITE, lpszMapName);
     389    }
     390    else {
     391        pMapping = VirtualAlloc(0, mSize, fAlloc, PAGE_READWRITE);
     392    }
     393    if(pMapping == NULL) {
     394        dprintf(("Win32MemMap::mapFileView: VirtualAlloc %x %x %x failed!", mSize, fAlloc, memFlags));
     395        goto fail;
     396    }
     397    //Windows NT seems to commit memory for memory maps, regardsless of the SEC_COMMIT flag
     398    if((hMemFile == -1 && !image)) {//commit memory
     399        VirtualAlloc(pMapping, mSize, MEM_COMMIT, PAGE_READWRITE);
     400    }
     401    if(hMemFile != -1 && (mProtFlags & SEC_COMMIT)) {
     402        DWORD nrPages = mSize >> PAGE_SHIFT;
     403        if(mSize & 0xFFF)
     404            nrPages++;
     405
     406        commitPage(0, FALSE, nrPages);
     407    }
    393408  }
    394409  mapview = new Win32MemMapView(this, offset, (size == 0) ? mSize : size, fdwAccess);
    395410  if(mapview == NULL) {
    396         goto fail;
     411    goto fail;
    397412  }
    398413  if(mapview->everythingOk() == FALSE) {
    399         dprintf(("Win32MemMap::mapFileView: !mapview->everythingOk"));
    400         delete mapview;
    401         goto fail;
     414    dprintf(("Win32MemMap::mapFileView: !mapview->everythingOk"));
     415    delete mapview;
     416    goto fail;
    402417  }
    403418  nrMappings++;
    … …  
    428443
    429444  if(image) //no flushing for image maps
    430         return TRUE;
     445    return TRUE;
    431446
    432447  dprintf(("Win32MemMap::flushView: %x %x", lpvBase, cbFlush));
    433448  if(nrMappings == 0)
    434         goto parmfail;
     449    goto parmfail;
    435450
    436451  if(cbFlush == 0)
    437         cbFlush = mSize;
     452    cbFlush = mSize;
    438453
    439454  if(lpvBase < pMapping || (ULONG)lpvBase+cbFlush > (ULONG)pMapping+mSize)
    440         goto parmfail;
     455    goto parmfail;
    441456
    442457  if(mProtFlags & PAGE_READONLY)
    443         goto parmfail;
     458    goto parmfail;
    444459
    445460  if(hMemFile == -1)
    446         goto success; //TODO: Return an error here?
     461    goto success; //TODO: Return an error here?
    447462
    448463  while(cbFlush) {
    449         if(VirtualQuery((LPSTR)lpvBase, &memInfo, sizeof(MEMORY_BASIC_INFORMATION)) == 0) {
    450                 dprintf(("Win32MemMap::flushView: VirtualQuery (%x,%x) failed for %x", lpvBase, cbFlush, (ULONG)lpvBase+i*PAGE_SIZE));
    451                 goto fail;
    452         }
    453         //If a page (or range of pages) is reserved or write protected, we
     464    if(VirtualQuery((LPSTR)lpvBase, &memInfo, sizeof(MEMORY_BASIC_INFORMATION)) == 0) {
     465        dprintf(("Win32MemMap::flushView: VirtualQuery (%x,%x) failed for %x", lpvBase, cbFlush, (ULONG)lpvBase+i*PAGE_SIZE));
     466        goto fail;
     467    }
     468    //If a page (or range of pages) is reserved or write protected, we
    454469        //won't bother flushing it to disk
    455         if(memInfo.State & MEM_COMMIT &&
     470    if(memInfo.State & MEM_COMMIT &&
    456471           memInfo.AllocationProtect & (PAGE_READWRITE|PAGE_WRITECOPY|PAGE_EXECUTE_READWRITE|PAGE_EXECUTE_WRITECOPY))
    457472        {//committed and allowed for writing?
    458                 offset = (ULONG)lpvBase - (ULONG)pMapping;
    459                 size   = memInfo.RegionSize;
    460                 if(size > cbFlush) {
    461                         size = cbFlush;
    462                 }
    463                 dprintf(("Win32MemMap::flushView for offset %x, size %d", offset, size));
    464 
    465                 if(SetFilePointer(hMemFile, offset, NULL, FILE_BEGIN) != offset) {
    466                         dprintf(("Win32MemMap::flushView: SetFilePointer failed to set pos to %x", offset));
    467                         goto fail;
    468                 }
    469                 if(WriteFile(hMemFile, (LPSTR)lpvBase, size, &nrBytesWritten, NULL) == FALSE) {
    470                         dprintf(("Win32MemMap::flushView: WriteFile failed for %x", (ULONG)lpvBase));
    471                         goto fail;
    472                 }
    473                 if(nrBytesWritten != size) {
    474                         dprintf(("Win32MemMap::flushView: WriteFile didn't write all bytes for %x", (ULONG)lpvBase));
    475                         goto fail;
    476                 }
    477         }
    478         lpvBase = (LPVOID)((ULONG)lpvBase + memInfo.RegionSize);
    479 
    480         if(cbFlush < memInfo.RegionSize)
    481                 break;
    482 
    483         cbFlush -= memInfo.RegionSize;
     473        offset = (ULONG)lpvBase - (ULONG)pMapping;
     474        size   = memInfo.RegionSize;
     475        if(size > cbFlush) {
     476            size = cbFlush;
     477        }
     478        dprintf(("Win32MemMap::flushView for offset %x, size %d", offset, size));
     479
     480        if(SetFilePointer(hMemFile, offset, NULL, FILE_BEGIN) != offset) {
     481            dprintf(("Win32MemMap::flushView: SetFilePointer failed to set pos to %x", offset));
     482            goto fail;
     483        }
     484        if(WriteFile(hMemFile, (LPSTR)lpvBase, size, &nrBytesWritten, NULL) == FALSE) {
     485            dprintf(("Win32MemMap::flushView: WriteFile failed for %x", (ULONG)lpvBase));
     486            goto fail;
     487        }
     488        if(nrBytesWritten != size) {
     489            dprintf(("Win32MemMap::flushView: WriteFile didn't write all bytes for %x", (ULONG)lpvBase));
     490            goto fail;
     491        }
     492    }
     493    lpvBase = (LPVOID)((ULONG)lpvBase + memInfo.RegionSize);
     494
     495    if(cbFlush < memInfo.RegionSize)
     496        break;
     497
     498    cbFlush -= memInfo.RegionSize;
    484499  }
    485500success:
    … …  
    496511{
    497512  if(lpszName == NULL)
    498         return NULL;
     513    return NULL;
    499514
    500515  globalmapMutex.enter(VMUTEX_WAIT_FOREVER, &hGlobalMapMutex);
    … …  
    502517
    503518  if(map != NULL) {
    504         while(map) {
    505                 if(map->lpszMapName && !strcmp(map->lpszMapName, lpszName))
    506                         break;
    507                 map = map->next;
    508         }
     519    while(map) {
     520        if(map->lpszMapName && !strcmp(map->lpszMapName, lpszName))
     521            break;
     522        map = map->next;
     523    }
    509524  }
    510525  globalmapMutex.leave(&hGlobalMapMutex);
    … …  
    520535
    521536  if(map != NULL) {
    522         while(map) {
    523                 if(map->pMapping && (ULONG)map->pMapping <= address &&
     537    while(map) {
     538        if(map->pMapping && (ULONG)map->pMapping <= address &&
    524539                   (ULONG)map->pMapping + map->mSize > address)
    525                 {
    526                         break;
    527                 }
    528                 map = map->next;
    529         }
     540        {
     541            break;
     542        }
     543        map = map->next;
     544    }
    530545  }
    531546  globalmapMutex.leave(&hGlobalMapMutex);
    … …  
    542557  globalviewMutex.enter();
    543558  while(map) {
    544         nextmap = map->next;
    545         if(map->getProcessId() == processId) {
    546                 //Delete map directly for executable images (only used internally)
    547                 if(map->getImage()) {
    548                         delete map;
    549                 }
    550                 else {
    551                         if(!map->isClosed())
    552                                 CloseHandle(memmaps->hMemMap);
    553                         delete map;
    554                 }
    555         }
    556         else {
    557                 //delete all views created by this process for this map
    558                 Win32MemMapView::deleteViews(map);
    559         }
    560         map = nextmap;
     559    nextmap = map->next;
     560    if(map->getProcessId() == processId) {
     561        //Delete map directly for executable images (only used internally)
     562        if(map->getImage()) {
     563            delete map;
     564        }
     565        else {
     566            if(!map->isClosed())
     567                 CloseHandle(memmaps->hMemMap);
     568            else delete map;
     569        }
     570    }
     571    else {
     572        //delete all views created by this process for this map
     573        Win32MemMapView::deleteViews(map);
     574    }
     575    map = nextmap;
    561576  }
    562577  globalviewMutex.leave();
    … …  
    579594  switch(fdwAccess) {
    580595  case FILE_MAP_READ:
    581         accessAttr = PAG_READ;
    582         mfAccess   = MEMMAP_ACCESS_READ;
    583         break;
     596    accessAttr = PAG_READ;
     597    mfAccess   = MEMMAP_ACCESS_READ;
     598    break;
    584599  case FILE_MAP_ALL_ACCESS:
    585600  case FILE_MAP_WRITE:
    586601  case FILE_MAP_WRITE|FILE_MAP_READ:
    587602  case FILE_MAP_COPY:
    588         accessAttr = (PAG_READ|PAG_WRITE);
    589         mfAccess   = MEMMAP_ACCESS_READ | MEMMAP_ACCESS_WRITE;
    590         break;
     603    accessAttr = (PAG_READ|PAG_WRITE);
     604    mfAccess   = MEMMAP_ACCESS_READ | MEMMAP_ACCESS_WRITE;
     605    break;
    591606  }
    592607  if(map->getMemName() != NULL && map->getFileHandle() == -1) {
    593         //shared memory map, so map it into our address space
    594         if(OSLibDosGetNamedSharedMem((LPVOID *)&viewaddr, map->getMemName()) != OSLIB_NOERROR) {
    595                 dprintf(("new OSLibDosGetNamedSharedMem FAILED"));
    596                 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
    597                 errorState = 1;
    598                 return;
    599         }
    600   }
    601  
     608    //shared memory map, so map it into our address space
     609    if(OSLibDosGetNamedSharedMem((LPVOID *)&viewaddr, map->getMemName()) != OSLIB_NOERROR) {
     610        dprintf(("new OSLibDosGetNamedSharedMem FAILED"));
     611        SetLastError(ERROR_NOT_ENOUGH_MEMORY);
     612        errorState = 1;
     613        return;
     614    }
     615  }
     616
    602617  //view == memory mapping for executable images (only used internally)
    603618  if(map->getImage()) {
    604         pMapView = map->getMappingAddr();
     619    pMapView = map->getMappingAddr();
    605620  }
    606621  else {
    607         if(OSLibDosAliasMem(viewaddr, size, &pMapView, accessAttr) != OSLIB_NOERROR) {
    608                 dprintf(("new OSLibDosAliasMem FAILED"));
    609                 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
    610                 errorState = 1;
    611                 return;
    612         }
     622    if(OSLibDosAliasMem(viewaddr, size, &pMapView, accessAttr) != OSLIB_NOERROR) {
     623        dprintf(("new OSLibDosAliasMem FAILED"));
     624        SetLastError(ERROR_NOT_ENOUGH_MEMORY);
     625        errorState = 1;
     626        return;
     627    }
    613628  }
    614629
    … …  
    617632  globalviewMutex.enter();
    618633  if(tmpview == NULL || tmpview->getViewAddr() > pMapView) {
    619         next     = mapviews;
    620         mapviews = this;
     634    next     = mapviews;
     635    mapviews = this;
    621636  }
    622637  else {
    623         while(tmpview->next) {
    624                 if(tmpview->next->getViewAddr() > pMapView) {
    625                         break;
    626                 }
    627                 tmpview = tmpview->next;
    628         }
    629         next          = tmpview->next;
    630         tmpview->next = this;
     638    while(tmpview->next) {
     639        if(tmpview->next->getViewAddr() > pMapView) {
     640            break;
     641        }
     642        tmpview = tmpview->next;
     643    }
     644    next          = tmpview->next;
     645    tmpview->next = this;
    631646  }
    632647  globalviewMutex.leave();
    … …  
    637652{
    638653  if(errorState != 0)
    639         return;
     654    return;
    640655
    641656  dprintf(("Win32MemMapView dtor: deleting view %x %x", mOffset, mSize));
    642657
    643658  if(mfAccess & MEMMAP_ACCESS_WRITE)
    644         mParentMap->flushView(mOffset, mSize);
     659    mParentMap->flushView(mOffset, mSize);
    645660
    646661  //Don't free memory for executable image map views (only used internally)
    647662  if(!mParentMap->getImage())
    648         OSLibDosFreeMem(pMapView);
     663    OSLibDosFreeMem(pMapView);
    649664
    650665  globalviewMutex.enter();
    … …  
    652667
    653668  if(view == this) {
    654         mapviews = next;
     669    mapviews = next;
    655670  }
    656671  else {
    657         while(view->next) {
    658                 if(view->next == this)
    659                         break;
    660                 view = view->next;
    661         }
    662         if(view->next) {
    663                 view->next = next;
    664         }
    665         else    dprintf(("Win32MemMapView::~Win32MemMapView: map not found!! (%x)", this));
     672    while(view->next) {
     673        if(view->next == this)
     674            break;
     675        view = view->next;
     676    }
     677    if(view->next) {
     678        view->next = next;
     679    }
     680    else    dprintf(("Win32MemMapView::~Win32MemMapView: map not found!! (%x)", this));
    666681  }
    667682  globalviewMutex.leave();
    … …  
    675690
    676691  if(view != NULL) {
    677         while(view) {
    678                 nextview = view->next;
    679                 if(view->getParentMap() == map)
    680                 {
    681                         globalviewMutex.leave();
    682                         delete view;
    683                         globalviewMutex.enter();
    684                 }
    685                 view = nextview;
    686         }
     692    while(view) {
     693        nextview = view->next;
     694        if(view->getParentMap() == map)
     695        {
     696            globalviewMutex.leave();
     697            delete view;
     698            globalviewMutex.enter();
     699        }
     700        view = nextview;
     701    }
    687702  }
    688703  globalviewMutex.leave();
    … …  
    700715
    701716  if(view != NULL) {
    702         while(view && (ULONG)view->getViewAddr() <= address) {
    703                 if((ULONG)view->getViewAddr() <= address &&
     717    while(view && (ULONG)view->getViewAddr() <= address) {
     718        if((ULONG)view->getViewAddr() <= address &&
    704719                   (ULONG)view->getViewAddr() + view->getSize() > address &&
    705720                   view->getAccessFlags() >= accessType)
    706                 {
    707                         *offset = view->getOffset() + (address - (ULONG)view->getViewAddr());
    708                         goto success;
    709                 }
    710                 view = view->next;
    711         }
    712         //failure if we get here
    713         view = NULL;
     721        {
     722            *offset = view->getOffset() + (address - (ULONG)view->getViewAddr());
     723            goto success;
     724        }
     725        view = view->next;
     726    }
     727    //failure if we get here
     728    view = NULL;
    714729  }
    715730success:
    716731  if(view && !view->getParentMap()->isImageMap())
    717         dprintf(("findMapByView %x %x -> %x off %x", address, accessType, view->getViewAddr(), *offset));
     732    dprintf(("findMapByView %x %x -> %x off %x", address, accessType, view->getViewAddr(), *offset));
    718733
    719734  globalviewMutex.leave();
    … …  
    729744  globalviewMutex.enter();
    730745  if(view != NULL) {
    731         while(view) {
    732                 if(view->getViewAddr() == address)
    733                 {
    734                         break;
    735                 }
    736                 view = view->next;
    737         }
     746    while(view) {
     747        if(view->getViewAddr() == address)
     748        {
     749            break;
     750        }
     751        view = view->next;
     752    }
    738753  }
    739754  globalviewMutex.leave();

  • trunk/src/kernel32/mmap.h

    r3609 r4496  
    1 /* $Id: mmap.h,v 1.16 2000-05-26 18:42:56 sandervl Exp $ */
     1/* $Id: mmap.h,v 1.17 2000-10-18 17:09:33 sandervl Exp $ */
    22
    33/*
    … …  
    6161   void   Release()                      { if(--referenced == 0) delete this; };
    6262
    63    void   close()                        { fClosed = TRUE; };
     63   void   close();
    6464   BOOL   isClosed()                     { return fClosed; };
    6565

  • trunk/src/kernel32/process.cpp

    r3074 r4496  
    1 /* $Id: process.cpp,v 1.6 2000-03-10 16:12:00 sandervl Exp $ */
     1/* $Id: process.cpp,v 1.7 2000-10-18 17:09:33 sandervl Exp $ */
    22
    33/*
    … …  
    6969//******************************************************************************
    7070//******************************************************************************
    71 BOOL WIN32API GetExitCodeProcess(HANDLE arg1, LPDWORD  arg2)
     71BOOL WIN32API GetExitCodeProcess(HANDLE hProcess, LPDWORD  arg2)
    7272{
    7373 BOOL rc;
    7474
    75     rc = O32_GetExitCodeProcess(arg1, arg2);
    76     dprintf(("KERNEL32:  GetExitCodeProcess returned %d (%x)", rc, (arg2) ? *arg2 : 0));
     75    rc = O32_GetExitCodeProcess(hProcess, arg2);
     76    dprintf(("KERNEL32:  GetExitCodeProcess %x returned %d (%x)", hProcess, rc, (arg2) ? *arg2 : 0));
    7777    return rc;
    7878}

  • trunk/src/kernel32/registry.cpp

    r4398 r4496  
    1 /* $Id: registry.cpp,v 1.4 2000-10-02 22:17:33 sandervl Exp $ */
     1/* $Id: registry.cpp,v 1.5 2000-10-18 17:09:33 sandervl Exp $ */
    22
    33/*
    … …  
    644644  LONG  rc;
    645645
    646   rc = O32_RegOpenKeyEx(ConvertKey(arg1),
    647                         astring,
    648                         arg3,
    649                         arg4,
    650                         arg5);
     646  rc = CALL_ODINFUNC(RegOpenKeyExA)(ConvertKey(arg1),
     647                                    astring,
     648                                    arg3,
     649                                    arg4,
     650                                    arg5);
    651651  //SvL: This fixes crashes in pmwinx.dll. (if an app doesn't check the
    652652  //     return value and uses the whatever *arg5 contains)
    … …  
    800800  LONG  rc;
    801801
    802   rc = O32_RegQueryValue(ConvertKey(hkey),
    803                          astring1,
    804                          (char *)lpszValue,
    805                          pcbValue);
     802  rc = CALL_ODINFUNC(RegQueryValueA)(ConvertKey(hkey),
     803                                     astring1,
     804                                     (char *)lpszValue,
     805                                     pcbValue);
    806806  if(rc == ERROR_SUCCESS)
    807807  {
    … …  
    837837                                    LPDWORD,arg6)
    838838{
    839   dprintf(("ADVAPI32:Registry key=%s\n",
    840            arg2));
     839  dprintf(("ADVAPI32:Registry key=%s", arg2));
     840
    841841  return O32_RegQueryValueEx(ConvertKey(arg1),
    842842                             arg2,
    … …  
    870870  LONG  rc;
    871871
    872   rc = O32_RegQueryValueEx(ConvertKey(arg1),
    873                            astring,
    874                            arg3,
    875                            arg4,
    876                            arg5,
    877                            arg6);
     872  rc = CALL_ODINFUNC(RegQueryValueExA)(ConvertKey(arg1),
     873                                       astring,
     874                                       arg3,
     875                                       arg4,
     876                                       arg5,
     877                                       arg6);
    878878  FreeAsciiString(astring);
    879879  return(rc);

  • trunk/src/kernel32/wprocess.cpp

    r4486 r4496  
    1 /* $Id: wprocess.cpp,v 1.104 2000-10-16 11:05:15 sandervl Exp $ */
     1/* $Id: wprocess.cpp,v 1.105 2000-10-18 17:09:34 sandervl Exp $ */
    22
    33/*
    … …  
    792792     *  Endif
    793793     */
    794     //only call Open32 if dwFlags == 0 and (LX binary or win32k process)
    795     if(dwFlags == 0 && (!fPeLoader || fPE != ERROR_SUCCESS))
     794    //only call Open32 if LX binary or win32k process
     795    if(!fPeLoader || fPE != ERROR_SUCCESS)
    796796    {
    797797        hDll = O32_LoadLibrary(szModname);
    … …  
    806806                        ((Win32LxDll *)pModule)->setDllHandleOS2(hDll);
    807807                        if(fPeLoader)
    808             {
     808                        {
    809809                            if(pModule->AddRef() == -1) {//-1 -> load failed (attachProcess)
    810                     dprintf(("Dll %s refused to be loaded; aborting", szModname));
    811                     delete pModule;
    812                     return 0;
    813                 }
     810                                dprintf(("Dll %s refused to be loaded; aborting", szModname));
     811                                delete pModule;
     812                                return 0;
     813                            }
    814814                        }
    815815                }
    … …  
    924924                SetLastError(ERROR_DLL_INIT_FAILED);
    925925                delete peldrDll;
    926         return NULL;
     926                return NULL;
    927927            }
    928928        }
    … …  
    933933            SetLastError(ERROR_INVALID_EXE_SIGNATURE);
    934934            delete peldrDll;
    935         return NULL;
     935            return NULL;
    936936        }
    937937    }
    … …  
    941941                 lpszLibFile, hFile, dwFlags, szModname, fPE));
    942942        SetLastError(fPE);
    943     return NULL;
     943        return NULL;
    944944    }
    945945
Note: See TracChangeset for help on using the changeset viewer.