Changeset 8866 for trunk/src


Ignore:
Timestamp:
Jul 13, 2002, 6:30:40 PM (23 years ago)
Author:
sandervl
Message:

Disabled 64kb alignment in VirtualAlloc for now

Location:
trunk/src/kernel32
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/kernel32/oslibmem.cpp

    r8864 r8866  
    1 /* $Id: oslibmem.cpp,v 1.1 2002-07-13 15:58:21 sandervl Exp $ */
     1/* $Id: oslibmem.cpp,v 1.2 2002-07-13 16:30:40 sandervl Exp $ */
    22/*
    33 * Wrappers for OS/2 Dos* API
    44 *
    5  * Copyright 1998-2000 Sander van Leeuwen (sandervl@xs4all.nl)
     5 * Copyright 1998-2002 Sander van Leeuwen (sandervl@xs4all.nl)
    66 * Copyright 2000 knut st. osmundsen (knut.stange.osmundsen@mynd.no)
    77 *
    … …  
    4747DWORD OSLibDosAliasMem(LPVOID pb, ULONG cb, LPVOID *ppbAlias, ULONG fl)
    4848{
    49  DWORD rc;
    50  DWORD attr;
    51  DWORD size = cb;
    52 
    53   cb = (cb-1) & ~0xfff;
    54   cb+= PAGE_SIZE;
    55 
    56   rc = DosQueryMem(pb, &size, &attr);
    57   if(rc) {
     49    DWORD rc;
     50    DWORD attr;
     51    DWORD size = cb;
     52
     53    cb = (cb-1) & ~0xfff;
     54    cb+= PAGE_SIZE;
     55
     56    rc = DosQueryMem(pb, &size, &attr);
     57    if(rc) {
    5858        dprintf(("OSLibDosAliasMem: DosQueryMem %x %x return %d", pb, size, rc));
    5959        return rc;
    60   }
    61   size = (size-1) & ~0xfff;
    62   size+= PAGE_SIZE;
    63   if(size != cb) {
     60    }
     61    size = (size-1) & ~0xfff;
     62    size+= PAGE_SIZE;
     63    if(size != cb) {
    6464        dprintf(("ERROR: OSLibDosAliasMem: size != cb (%x!=%x)!!!!!!!!", size, cb));
    6565        //ignore this and continue return 5;
    6666        attr = fl; //just use original protection flags (NOT CORRECT)
    67   }
    68   attr &= (PAG_READ|PAG_WRITE|PAG_EXECUTE|PAG_GUARD|PAG_DEFAULT);
    69   if(attr != fl) {
     67    }
     68    attr &= (PAG_READ|PAG_WRITE|PAG_EXECUTE|PAG_GUARD|PAG_DEFAULT);
     69    if(attr != fl) {
    7070        rc = DosSetMem(pb, size, fl);
    7171        if(rc) {
    … …  
    7575                //return rc;
    7676        }
    77   }
    78   rc = DosAliasMem(pb, cb, ppbAlias, 2);
    79   if(rc) {
     77    }
     78    rc = DosAliasMem(pb, cb, ppbAlias, 2);
     79    if(rc) {
    8080        dprintf(("OSLibDosAliasMem: DosAliasMem %x %x returned %d", pb, cb, rc));
    8181        return rc;
    82   }
    83   if(attr != fl) {
     82    }
     83    if(attr != fl) {
    8484        rc = DosSetMem(pb, size, attr);
    8585        if(rc) {
    86                 dprintf(("OSLibDosAliasMem: DosSetMem (2) %x %x return %d", pb, size, rc));
    87                 return rc;
    88         }
    89   }
    90   return 0;
    91 }
    92 //******************************************************************************
    93 //NT returns addresses aligned at 64k, so we do too.
    94 //******************************************************************************
    95 // tries to retrieve an aligned block recursivly
    96 APIRET OdinAlignMemR(LPVOID *lpMemAddr, DWORD size, DWORD offset, DWORD flags)
    97 {
    98   LPVOID memaddr;
    99   APIRET rc, rc2;
    100 
    101   DosEnterCritSec();
    102   DosFreeMem(*lpMemAddr);
    103   rc2 = DosAllocMem(&memaddr, 64 * 1024 - offset, PAG_READ | flAllocMem);
    104   rc  = DosAllocMem(lpMemAddr, size, flags | flAllocMem);
    105   DosExitCritSec();
    106 
    107   dprintf2(("OdinAlignMem: DosAllocMem returned %d, %d  and pointers %x, %x for size %x and offset %x", rc, rc2, *lpMemAddr, memaddr, size, offset ));
    108 
    109   if(rc2) {
    110     // giving up - return as received
    111     return rc;
    112   }
    113 
    114   if(rc) {
    115     // seems to be out of memory
    116     DosFreeMem(memaddr);
    117     return rc;
    118   }
    119 
    120   if((DWORD) *lpMemAddr & 0xFFFF)
    121     rc = OdinAlignMemR(lpMemAddr, size, (DWORD) *lpMemAddr & 0xFFFF, flags);
    122 
    123   DosFreeMem(memaddr);
    124   return rc;
     86            dprintf(("OSLibDosAliasMem: DosSetMem (2) %x %x return %d", pb, size, rc));
     87            return rc;
     88        }
     89    }
     90    return 0;
    12591}
    12692//******************************************************************************
    … …  
    148114    rc = DosAllocMem(&pvMemAddr, cbSize, flFlags | flAllocMem);
    149115    if(rc) {
    150         return rc;
    151     }
    152 
     116        dprintf(("DosAllocMem failed with rc %d", rc));
     117        return rc;
     118    }
     119    //TODO!!!!!!!!!!!!
     120#if 0
    153121    // already 64k aligned ?
    154 //    if((DWORD) pvMemAddr & 0xFFFF)
    155 //        rc = OdinAlignMemR(&pvMemAddr, cbSize, (DWORD) pvMemAddr & 0xFFFF, flFlags);
    156 
     122    if((DWORD) pvMemAddr & 0xFFFF)
     123    {
     124        DWORD addr64kb;
     125
     126        //Allocate 64kb more so we can round the address to a 64kb aligned value
     127        rc = DosAllocMem((PPVOID)&addr64kb, cbSize + 64*1024,  PAG_READ | flAllocMem);
     128        if(rc) {
     129            dprintf(("DosAllocMem failed with rc %d", rc));
     130            return rc;
     131        }
     132        if(addr64kb & 0xFFFF) {
     133            addr64kb = (addr64kb + 0xFFFF) & 0xFFFF;
     134        }
     135        pvMemAddr = (PVOID)addr64kb;
     136
     137        //and set the correct page flags for the request range
     138        rc = DosSetMem(pvMemAddr, cbSize, flFlags | flAllocMem);
     139    }
     140#endif
    157141    if(!rc)
    158142        *lplpMemAddr = pvMemAddr;
    … …  
    164148DWORD OSLibDosFreeMem(LPVOID lpMemAddr)
    165149{
    166   return DosFreeMem(lpMemAddr);
     150    return DosFreeMem(lpMemAddr);
    167151}
    168152//******************************************************************************
    … …  
    173157DWORD OSLibDosAllocSharedMem(LPVOID *lplpMemAddr, DWORD size, DWORD flags, LPSTR name)
    174158{
    175  APIRET rc;
    176  char  *sharedmemname = NULL, *tmp;
    177 
    178   if(name) {
    179         sharedmemname = (char *)malloc(strlen(name) + 16);
    180         strcpy(sharedmemname, "\\SHAREMEM\\");
    181         strcat(sharedmemname, name);
    182   }
    183   else flags |= OBJ_GETTABLE;
    184 
    185   //SvL: Colons are unacceptable in shared memory names (for whatever reason)
    186   tmp = sharedmemname;
    187   while(*tmp != 0) {
     159    APIRET rc;
     160    char  *sharedmemname = NULL, *tmp;
     161
     162    if(name) {
     163         sharedmemname = (char *)malloc(strlen(name) + 16);
     164         strcpy(sharedmemname, "\\SHAREMEM\\");
     165         strcat(sharedmemname, name);
     166    }
     167    else flags |= OBJ_GETTABLE;
     168
     169    //SvL: Colons are unacceptable in shared memory names (for whatever reason)
     170    tmp = sharedmemname;
     171    while(*tmp != 0) {
    188172        if(*tmp == ':') {
    189173            *tmp = '_';
    190174        }
    191175        tmp++;
    192   }
    193 
    194   rc = DosAllocSharedMem(lplpMemAddr, sharedmemname, size, flags);
    195   if(name) {
     176    }
     177
     178    rc = DosAllocSharedMem(lplpMemAddr, sharedmemname, size, flags);
     179    if(name) {
    196180        free(sharedmemname);
    197   }
    198   return rc;
     181    }
     182    return rc;
    199183}
    200184//******************************************************************************
    … …  
    203187DWORD OSLibDosGetNamedSharedMem(LPVOID *lplpMemAddr, LPSTR name)
    204188{
    205  APIRET rc;
    206  char  *sharedmemname = NULL, *tmp;
    207 
    208   if(name) {
     189    APIRET rc;
     190    char  *sharedmemname = NULL, *tmp;
     191
     192    if(name) {
    209193        sharedmemname = (char *)malloc(strlen(name) + 16);
    210194        strcpy(sharedmemname, "\\SHAREMEM\\");
    … …  
    223207                free(sharedmemname);
    224208        }
    225   }
    226   else  rc = DosGetSharedMem((LPVOID)*(DWORD *)lplpMemAddr, PAG_READ|PAG_WRITE);
    227 
    228   return rc;
     209    }
     210    else  rc = DosGetSharedMem((LPVOID)*(DWORD *)lplpMemAddr, PAG_READ|PAG_WRITE);
     211
     212    return rc;
    229213}
    230214//******************************************************************************
    … …  
    232216DWORD OSLibDosQueryMem(LPVOID lpMemAddr, DWORD *lpRangeSize, DWORD *lpAttr)
    233217{
    234   return DosQueryMem(lpMemAddr, lpRangeSize, lpAttr);
     218    return DosQueryMem(lpMemAddr, lpRangeSize, lpAttr);
    235219}
    236220//******************************************************************************
    … …  
    238222DWORD OSLibDosSetMem(LPVOID lpMemAddr, DWORD size, DWORD flags)
    239223{
    240  APIRET rc;
    241 
    242   rc = DosSetMem(lpMemAddr, size, flags);
    243   switch(rc) {
    244         case ERROR_INVALID_ADDRESS:
    245                 return OSLIB_ERROR_INVALID_ADDRESS;
    246         case ERROR_ACCESS_DENIED:
    247                 return OSLIB_ERROR_ACCESS_DENIED;
    248         default:
    249                 return rc;
    250   }
    251 }
    252 //******************************************************************************
    253 //******************************************************************************
     224    APIRET rc;
     225
     226    rc = DosSetMem(lpMemAddr, size, flags);
     227    switch(rc) {
     228    case ERROR_INVALID_ADDRESS:
     229        return OSLIB_ERROR_INVALID_ADDRESS;
     230    case ERROR_ACCESS_DENIED:
     231        return OSLIB_ERROR_ACCESS_DENIED;
     232    default:
     233        return rc;
     234    }
     235}
     236//******************************************************************************
     237//******************************************************************************

  • trunk/src/kernel32/virtual.cpp

    r8864 r8866  
    1 /* $Id: virtual.cpp,v 1.46 2002-07-13 15:58:21 sandervl Exp $ */
     1/* $Id: virtual.cpp,v 1.47 2002-07-13 16:30:40 sandervl Exp $ */
    22
    33/*
    … …  
    329329  if(lpvAddress)
    330330  {
    331    Win32MemMap *map;
    332    ULONG offset, nrpages, accessflags = 0;
    333 
     331    Win32MemMap *map;
     332    ULONG offset, nrpages, accessflags = 0;
     333   
    334334    nrpages = cbSize >> PAGE_SHIFT;
    335335    if(cbSize & 0xFFF)
    … …  
    519519                             DWORD* pfdwOldProtect)
    520520{
    521   DWORD rc;
    522   DWORD  cb = cbSize;
    523   ULONG  pageFlags = 0;
    524   int npages;
    525 
    526   if(pfdwOldProtect == NULL) {
     521    DWORD rc;
     522    DWORD  cb = cbSize;
     523    ULONG  pageFlags = 0;
     524    int npages;
     525
     526    if(pfdwOldProtect == NULL) {
    527527        dprintf(("WARNING: pfdwOldProtect == NULL"));
    528528        SetLastError(ERROR_INVALID_PARAMETER);
    529529        return(FALSE);
    530   }
    531 
    532   SetLastError(ERROR_SUCCESS);
    533 
    534   rc = OSLibDosQueryMem(lpvAddress, &cb, &pageFlags);
    535   if(rc) {
     530    }
     531
     532    SetLastError(ERROR_SUCCESS);
     533
     534    rc = OSLibDosQueryMem(lpvAddress, &cb, &pageFlags);
     535    if(rc) {
    536536        dprintf(("DosQueryMem returned %d\n", rc));
    537537        return(FALSE);
    538   }
    539   dprintf(("Old memory flags %X\n", pageFlags));
    540   *pfdwOldProtect = 0;
    541   if(pageFlags & PAG_READ && !(pageFlags & PAG_WRITE))
     538    }
     539    dprintf(("Old memory flags %X\n", pageFlags));
     540    *pfdwOldProtect = 0;
     541    if(pageFlags & PAG_READ && !(pageFlags & PAG_WRITE))
    542542        *pfdwOldProtect |= PAGE_READONLY;
    543   if(pageFlags & (PAG_WRITE))
     543    if(pageFlags & (PAG_WRITE))
    544544        *pfdwOldProtect |= PAGE_READWRITE;
    545545
    546   if((pageFlags & (PAG_WRITE | PAG_EXECUTE)) == (PAG_WRITE | PAG_EXECUTE))
     546    if((pageFlags & (PAG_WRITE | PAG_EXECUTE)) == (PAG_WRITE | PAG_EXECUTE))
    547547        *pfdwOldProtect |= PAGE_EXECUTE_READWRITE;
    548   else
    549   if(pageFlags & PAG_EXECUTE)
     548    else
     549    if(pageFlags & PAG_EXECUTE)
    550550        *pfdwOldProtect |= PAGE_EXECUTE_READ;
    551551
    552   if(pageFlags & PAG_GUARD)
     552    if(pageFlags & PAG_GUARD)
    553553        *pfdwOldProtect |= PAGE_GUARD;
    554   pageFlags = 0;
    555 
    556   if(fdwNewProtect & PAGE_READONLY)     pageFlags |= PAG_READ;
    557   if(fdwNewProtect & PAGE_READWRITE)    pageFlags |= (PAG_READ | PAG_WRITE);
    558   if(fdwNewProtect & PAGE_WRITECOPY)    pageFlags |= (PAG_READ | PAG_WRITE);
    559   if(fdwNewProtect & PAGE_EXECUTE_READ) pageFlags |= (PAG_EXECUTE | PAG_READ);
    560   if(fdwNewProtect & PAGE_EXECUTE_READWRITE)
     554    pageFlags = 0;
     555
     556    if(fdwNewProtect & PAGE_READONLY)     pageFlags |= PAG_READ;
     557    if(fdwNewProtect & PAGE_READWRITE)    pageFlags |= (PAG_READ | PAG_WRITE);
     558    if(fdwNewProtect & PAGE_WRITECOPY)    pageFlags |= (PAG_READ | PAG_WRITE);
     559    if(fdwNewProtect & PAGE_EXECUTE_READ) pageFlags |= (PAG_EXECUTE | PAG_READ);
     560    if(fdwNewProtect & PAGE_EXECUTE_READWRITE)
    561561        pageFlags |= (PAG_EXECUTE | PAG_WRITE | PAG_READ);
    562   if(fdwNewProtect & PAGE_EXECUTE_WRITECOPY)
     562    if(fdwNewProtect & PAGE_EXECUTE_WRITECOPY)
    563563        pageFlags |= (PAG_EXECUTE | PAG_WRITE | PAG_READ);
    564   if(fdwNewProtect & PAGE_GUARD)        pageFlags |= PAG_GUARD;
     564    if(fdwNewProtect & PAGE_GUARD)        pageFlags |= PAG_GUARD;
    565565//Not supported in OS/2??
    566566//  if(fdwNewProtect & PAGE_NOACCESS)
    567567
    568   dprintf(("New memory flags %X\n", pageFlags));
    569   if(pageFlags == 0) {
     568    dprintf(("New memory flags %X\n", pageFlags));
     569    if(pageFlags == 0) {
    570570        dprintf(("pageFlags == 0\n"));
    571571        return(TRUE);   //nothing to do
    572   }
    573   ULONG offset = ((ULONG)lpvAddress & 0xFFF);
    574   npages = (cbSize >> 12);
    575 
    576   cb = (cbSize & 0xFFF) + offset; // !!! added, some optimization :)
    577   if( cb > 0 ) { // changed
    578     npages++;
    579   }
    580   if( cb > 4096 ) { // changed, note '>' sign ( not '>=' ) 4096 is exactly one page
    581     npages++;
    582   }
    583 
    584   lpvAddress = (LPVOID)((int)lpvAddress & ~0xFFF);
    585   cbSize     = npages*4096;
    586   dprintf(("lpvAddress = %X, cbSize = %d\n", lpvAddress, cbSize));
    587 
    588   rc = OSLibDosSetMem(lpvAddress, cbSize, pageFlags);
    589   if(rc) {
     572    }
     573    ULONG offset = ((ULONG)lpvAddress & 0xFFF);
     574    npages = (cbSize >> 12);
     575
     576    cb = (cbSize & 0xFFF) + offset; // !!! added, some optimization :)
     577    if( cb > 0 ) { // changed
     578        npages++;
     579    }
     580    if( cb > 4096 ) { // changed, note '>' sign ( not '>=' ) 4096 is exactly one page
     581        npages++;
     582    }
     583
     584    lpvAddress = (LPVOID)((int)lpvAddress & ~0xFFF);
     585    cbSize     = npages*4096;
     586    dprintf(("lpvAddress = %X, cbSize = %d\n", lpvAddress, cbSize));
     587
     588    rc = OSLibDosSetMem(lpvAddress, cbSize, pageFlags);
     589    if(rc) {
    590590        dprintf(("DosSetMem returned %d\n", rc));
    591591        return(FALSE);
    592   }
    593   return(TRUE);
     592    }
     593    return(TRUE);
    594594}
    595595//******************************************************************************
    … …  
    670670    else
    671671    {
     672        pmbiBuffer->AllocationBase = 0;
    672673        while(lpBase > 0)
    673674        {
    … …  
    685686        }
    686687    }
     688#if 0
     689    //TODO!!!!!!!!!!!!
     690    //NOTE: !!!!!!!!!!!!!!!!!!!!!!!
     691    //Allocation base is always aligned at 64kb
     692    //the page with the PAG_BASE attribute might not be the real allocation base
     693    //(due to extra alloc + rounding (see oslibmem.cpp)
     694    //Only exception to this rule is the stack
     695    TEB *teb = GetThreadTEB();
     696    if(teb) {
     697        if(pmbiBuffer->AllocationBase >= teb->stack_low && pmbiBuffer->AllocationBase < teb->stack_top) {
     698             pmbiBuffer->AllocationBase = pmbiBuffer->AllocationBase;
     699        }
     700        else pmbiBuffer->AllocationBase = (LPVOID)(((DWORD)pmbiBuffer->AllocationBase + 0xFFFF) & 0xFFFF);
     701    }
     702    else pmbiBuffer->AllocationBase = (LPVOID)(((DWORD)pmbiBuffer->AllocationBase + 0xFFFF) & 0xFFFF);
     703    //END NOTE: !!!!!!!!!!!!!!!!!!!
     704#endif
     705
    687706    dprintf(("Memory region alloc base          0x%08x", pmbiBuffer->AllocationBase));
    688707    dprintf(("Memory region alloc protect flags %x", pmbiBuffer->AllocationProtect));
Note: See TracChangeset for help on using the changeset viewer.