Changeset 6184 for trunk/src


Ignore:
Timestamp:
Jul 6, 2001, 3:47:19 PM (24 years ago)
Author:
sandervl
Message:

heap updates/fixes

Location:
trunk/src/kernel32
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/kernel32/heap.cpp

    r6176 r6184  
    1 /* $Id: heap.cpp,v 1.28 2001-07-05 18:10:08 sandervl Exp $ */
     1/* $Id: heap.cpp,v 1.29 2001-07-06 13:47:18 sandervl Exp $ */
    22
    33/*
    … …  
    202202#define HANDLE_TO_INTERN(h)  ((PGLOBAL32_INTERN)(((char *)(h))-2))
    203203#define INTERN_TO_HANDLE(i)  ((HGLOBAL) &((i)->Pointer))
    204 #define POINTER_TO_HANDLE(p) (*(((HGLOBAL *)(p))-1))
    205204#define ISHANDLE(h)          (((DWORD)(h)&2)!=0)
    206205#define ISPOINTER(h)         (((DWORD)(h)&2)==0)
     206
     207//SvL: -2 for 8 byte alignment
     208#define POINTER_TO_HANDLE(p) (*(((HGLOBAL *)(p))-2))
     209#define HGLOBAL_SIZE         2*sizeof(HGLOBAL)
    207210
    208211#pragma pack(1)
    … …  
    251254      if(size)
    252255      {
    253          if (!(palloc=HeapAlloc(GetProcessHeap(), hpflags, size+sizeof(HGLOBAL)))) {
     256         //SvL: 2*sizeof for 8 byte alignment
     257         if (!(palloc=HeapAlloc(GetProcessHeap(), hpflags, size+HGLOBAL_SIZE))) {
    254258            HeapFree(GetProcessHeap(), 0, pintern);
    255259            return 0;
    256260         }
    257261         *(HGLOBAL *)palloc=INTERN_TO_HANDLE(pintern);
    258          pintern->Pointer=(char *) palloc+sizeof(HGLOBAL);
     262         //SvL: 2*sizeof for 8 byte alignment
     263         pintern->Pointer=(char *) palloc+HGLOBAL_SIZE;
    259264      }
    260265      else
    … …  
    283288
    284289
    285    if(ISPOINTER(hmem)) {
     290   if(hmem == NULL || ISPOINTER(hmem)) {
    286291      dprintf(("KERNEL32: GlobalLock %x returned %x", hmem, hmem));
    287292      return (LPVOID) hmem;
    … …  
    324329   dprintf(("KERNEL32: GlobalUnlock %x", hmem));
    325330
    326    if(ISPOINTER(hmem))
     331   if(hmem == NULL || ISPOINTER(hmem))
    327332      return FALSE;
    328333
    … …  
    396401        if (maybe_intern->Magic == MAGIC_GLOBAL_USED) {
    397402            test = maybe_intern->Pointer;
    398             if (HeapValidate( GetProcessHeap(), 0, ((HGLOBAL *)test)-1 ) && /* obj(-handle) valid arena? */
     403            //SvL: -2 for 8 byte alignment
     404            if (HeapValidate( GetProcessHeap(), 0, ((HGLOBAL *)test)-2 ) && /* obj(-handle) valid arena? */
    399405                HeapValidate( GetProcessHeap(), 0, maybe_intern ))  /* intern valid arena? */
    400406            {
    … …  
    520526            {
    521527               if((palloc = HeapReAlloc(GetProcessHeap(), heap_flags,
    522                                    (char *) pintern->Pointer-sizeof(HGLOBAL),
    523                                    size+sizeof(HGLOBAL))) == NULL)
     528                                   (char *) pintern->Pointer-HGLOBAL_SIZE,
     529                                   size+HGLOBAL_SIZE)) == NULL)
    524530                   return 0; /* Block still valid */
    525                pintern->Pointer=(char *) palloc+sizeof(HGLOBAL);
     531               pintern->Pointer=(char *) palloc+HGLOBAL_SIZE;
    526532            }
    527533            else
    528534            {
    529                 if((palloc=HeapAlloc(GetProcessHeap(), heap_flags, size+sizeof(HGLOBAL)))
     535                if((palloc=HeapAlloc(GetProcessHeap(), heap_flags, size+HGLOBAL_SIZE))
    530536                   == NULL)
    531537                    return 0;
    532538               *(HGLOBAL *)palloc=hmem;
    533                pintern->Pointer=(char *) palloc+sizeof(HGLOBAL);
     539               pintern->Pointer=(char *) palloc+HGLOBAL_SIZE;
    534540            }
    535541         }
    … …  
    538544            if(pintern->Pointer)
    539545            {
    540                HeapFree(GetProcessHeap(), 0, (char *) pintern->Pointer-sizeof(HGLOBAL));
     546               HeapFree(GetProcessHeap(), 0, (char *) pintern->Pointer-HGLOBAL_SIZE);
    541547               pintern->Pointer=NULL;
    542548            }
    … …  
    581587
    582588         if(pintern->Pointer)
    583             if(!HeapFree(GetProcessHeap(), 0, (char *)(pintern->Pointer)-sizeof(HGLOBAL)))
     589            if(!HeapFree(GetProcessHeap(), 0, (char *)(pintern->Pointer)-HGLOBAL_SIZE))
    584590               hreturned=hmem;
    585591         if(!HeapFree(GetProcessHeap(), 0, pintern))
    … …  
    620626            return 0;
    621627         retval=HeapSize(GetProcessHeap(), 0,
    622                          (char *)(pintern->Pointer)-sizeof(HGLOBAL))-4;
    623          if (retval == 0xffffffff-4) retval = 0;
     628                         (char *)(pintern->Pointer)-HGLOBAL_SIZE)-HGLOBAL_SIZE;
     629         //SvL: ???
     630         if (retval == 0xffffffff-HGLOBAL_SIZE) retval = 0;
    624631      }
    625632      else
    … …  
    632639   /* HeapSize returns 0xffffffff on failure */
    633640   if (retval == 0xffffffff) retval = 0;
     641   dprintf(("KERNEL32: GlobalSize %x = %d", hmem, retval));
    634642   return retval;
    635643}
    … …  
    929937HLOCAL WIN32API LocalReAlloc(HLOCAL hMem, DWORD cbBytes, UINT fuFlags)
    930938{
    931   HLOCAL hLocalNew;
    932   LPVOID lpMem;
     939  HLOCAL hLocalNew, hLocalOld;
     940  LPVOID lpMem, lpMemOld;
    933941  DWORD  cbOldSize;
    934942
    935   dprintf(("KERNEL32: LocalReAlloc %X %d %X\n", hMem, cbBytes, fuFlags));
     943    dprintf(("KERNEL32: LocalReAlloc %X %d %X\n", hMem, cbBytes, fuFlags));
    936944
    937945    // Check flags
    … …  
    949957        return hMem;
    950958
    951     hLocalNew = LocalAlloc(fuFlags, cbBytes);
    952     if(hLocalNew != 0)
    953     {
    954         lpMem = LocalLock(hLocalNew);
    955 
    956         if (lpMem != NULL) /* copy memory if successful */
    957             memcpy(lpMem, (LPVOID)hMem, min(cbBytes, cbOldSize));
    958 
    959         LocalUnlock(hLocalNew);
    960         LocalFree(hMem);
    961     }
    962     return(hLocalNew);
     959    return GlobalReAlloc(hMem, cbBytes, fuFlags);
    963960}
    964961//******************************************************************************

  • trunk/src/kernel32/os2heap.cpp

    r6080 r6184  
    1 /* $Id: os2heap.cpp,v 1.18 2001-06-23 08:43:17 sandervl Exp $ */
     1/* $Id: os2heap.cpp,v 1.19 2001-07-06 13:47:19 sandervl Exp $ */
    22
    33/*
    … …  
    9393  while(heapelem) {
    9494    hnext = heapelem->next;
    95     free(heapelem);
     95    free(heapelem->lpMem);
    9696    heapelem = hnext;
    9797  }
    … …  
    122122LPVOID OS2Heap::Alloc(DWORD dwFlags, DWORD dwBytes)
    123123{
    124  LPVOID lpMem;
     124 HEAPELEM *lpHeapObj;
     125 LPVOID    lpMem;
    125126
    126127//  dprintf(("OS2Heap::Alloc\n"));
    127128  lpMem = malloc(dwBytes + HEAP_OVERHEAD);
    128129  if(lpMem == NULL) {
    129     dprintf(("OS2Heap::Alloc, lpMem == NULL"));
    130     return(NULL);
     130      dprintf(("OS2Heap::Alloc, lpMem == NULL"));
     131      return(NULL);
    131132  }
    132133  if(dwFlags & HEAP_ZERO_MEMORY) {
    133     memset((char *)lpMem, 0, dwBytes+HEAP_OVERHEAD);
     134      memset(lpMem, 0, dwBytes+HEAP_OVERHEAD);
    134135  }
    135136  totalAlloc += dwBytes;
    136137
     138  //align at 8 byte boundary
     139  lpHeapObj = (HEAPELEM *)(((ULONG)lpMem+7) & ~7);
     140  lpHeapObj->lpMem = lpMem;
     141
    137142  if(hmutex)
    138     hmutex->enter();
    139 
     143      hmutex->enter();
     144
     145  lpHeapObj->next    = heapelem;
     146  lpHeapObj->prev    = NULL;
     147  lpHeapObj->magic   = MAGIC_NR_HEAP;
    140148  if(heapelem) {
    141    HEAPELEM *hnext;
    142 
    143     hnext = heapelem;
    144 
    145     heapelem       = (HEAPELEM *)lpMem;
    146     hnext->prev    = heapelem;
    147     heapelem->next = hnext;
    148   }
    149   else {
    150     heapelem = (HEAPELEM *)lpMem;
    151     heapelem->next = NULL;
    152   }
    153   heapelem->prev    = NULL;
    154   heapelem->flags   = 0;    //only used when allocated with LocalAlloc
    155   heapelem->lockCnt = 0;    //..    ..
    156   heapelem->magic   = MAGIC_NR_HEAP;
     149      heapelem->prev = lpHeapObj;
     150  }
     151  heapelem           = lpHeapObj;
    157152
    158153  if(hmutex) {
    159     hmutex->leave();
    160   }
    161   return(LPVOID)((char *)lpMem+sizeof(HEAPELEM));
    162 }
    163 //******************************************************************************
    164 //******************************************************************************
    165 LPVOID OS2Heap::Alloc(DWORD dwFlags, DWORD dwBytes, DWORD LocalAllocFlags)
    166 {
    167  HEAPELEM *helem;
    168  LPVOID    lpMem = Alloc(dwFlags, dwBytes);
    169 
    170   if(lpMem == NULL)
    171     return(NULL);
    172 
    173   helem = (HEAPELEM *)((char *)lpMem - sizeof(HEAPELEM));
    174   helem->flags   = LocalAllocFlags;
    175   return(lpMem);
    176 }
    177 //******************************************************************************
    178 //******************************************************************************
    179 BOOL OS2Heap::Lock(LPVOID lpMem)
    180 {
    181  HEAPELEM *helem = (HEAPELEM *)((char *)lpMem - sizeof(HEAPELEM));
    182 
    183   if((ULONG)lpMem > ADDRESS_SPACE_LIMIT) {
    184         //SvL: Some apps lock and unlock gdi handles; just ignore this here
    185         dprintf(("Lock: invalid address %x", lpMem));
    186         return FALSE;
    187   }
    188 
    189   if(lpMem == NULL)
    190         return(FALSE);
    191 
    192   if(helem->magic != MAGIC_NR_HEAP)
    193   {
    194         dprintf(("OS2Heap::Lock ERROR BAD HEAP POINTER:%X\n", lpMem));
    195         return FALSE;
    196   }
    197 
    198   helem->lockCnt++;
    199 
    200   return(TRUE);
    201 }
    202 //******************************************************************************
    203 //******************************************************************************
    204 BOOL OS2Heap::Unlock(LPVOID lpMem)
    205 {
    206  HEAPELEM *helem = (HEAPELEM *)((char *)lpMem - sizeof(HEAPELEM));
    207 
    208   if((ULONG)lpMem > ADDRESS_SPACE_LIMIT) {
    209         //SvL: Some apps lock and unlock gdi handles; just ignore this here
    210         dprintf(("Unlock: invalid address %x", lpMem));
    211         return FALSE;
    212   }
    213 
    214   if(lpMem == NULL)
    215     return(FALSE);
    216 
    217   if(helem->lockCnt == 0)
    218     return(FALSE);
    219 
    220   if(helem->magic != MAGIC_NR_HEAP)
    221   {
    222     dprintf(("OS2Heap::UnLock ERROR BAD HEAP POINTER:%X\n", lpMem));
    223     return FALSE;
    224   }
    225 
    226   helem->lockCnt--;
    227 
    228   return(TRUE);
    229 }
    230 //******************************************************************************
    231 //******************************************************************************
    232 DWORD OS2Heap::GetFlags(LPVOID lpMem)
    233 {
    234  HEAPELEM *helem = (HEAPELEM *)((char *)lpMem - sizeof(HEAPELEM));
    235 
    236   if(lpMem == NULL)
    237     return(0);
    238 
    239   if(helem->magic != MAGIC_NR_HEAP)
    240   {
    241     dprintf(("OS2Heap::GetFlags ERROR BAD HEAP POINTER:%X\n", lpMem));
    242     return 0;
    243   }
    244 
    245   return(helem->lockCnt | (helem->flags << 8));
    246 }
    247 //******************************************************************************
    248 //******************************************************************************
    249 int OS2Heap::GetLockCnt(LPVOID lpMem)
    250 {
    251  HEAPELEM *helem = (HEAPELEM *)((char *)lpMem - sizeof(HEAPELEM));
    252 
    253   if((ULONG)lpMem > ADDRESS_SPACE_LIMIT) {
    254         //SvL: Some apps lock and unlock gdi handles; just ignore this here
    255         dprintf(("GetLockCnt: invalid address %x", lpMem));
    256         return FALSE;
    257   }
    258 
    259   if(lpMem == NULL)
    260         return(0);
    261 
    262   if(helem->magic != MAGIC_NR_HEAP)
    263   {
    264         dprintf(("OS2Heap::GetLockCnt ERROR BAD HEAP POINTER:%X\n", lpMem));
    265         return 0;
    266   }
    267 
    268   return(helem->lockCnt);
     154      hmutex->leave();
     155  }
     156  return(LPVOID)(lpHeapObj+1);
    269157}
    270158//******************************************************************************
    … …  
    272160DWORD OS2Heap::Size(DWORD dwFlags, PVOID lpMem)
    273161{
    274  HEAPELEM *helem = (HEAPELEM *)((char *)lpMem - sizeof(HEAPELEM));
     162 HEAPELEM *helem = GET_HEAPOBJ(lpMem);
    275163
    276164  if(lpMem == NULL) {
    … …  
    291179  }
    292180
    293   return(_msize((char *)lpMem - sizeof(HEAPELEM)) - HEAP_OVERHEAD);
     181  return(_msize(helem->lpMem) - HEAP_OVERHEAD);
    294182}
    295183//******************************************************************************
    … …  
    297185LPVOID OS2Heap::ReAlloc(DWORD dwFlags, LPVOID lpMem, DWORD dwBytes)
    298186{
    299   HEAPELEM *helem = (HEAPELEM *)((char *)lpMem - sizeof(HEAPELEM));
     187  HEAPELEM *helem = GET_HEAPOBJ(lpMem);
    300188  LPVOID lpNewMem;
    301189  int    i, oldSize;
    … …  
    334222BOOL OS2Heap::Free(DWORD dwFlags, LPVOID lpMem)
    335223{
    336  HEAPELEM *helem = (HEAPELEM *)((char *)lpMem - sizeof(HEAPELEM));
     224  HEAPELEM *helem = GET_HEAPOBJ(lpMem);
    337225
    338226  if(lpMem == NULL) {
    … …  
    372260  }
    373261
    374   free((void *)helem);
     262  free(helem->lpMem);
    375263  return(TRUE);
    376264}

  • trunk/src/kernel32/os2heap.h

    r1118 r6184  
    1 /* $Id: os2heap.h,v 1.4 1999-10-04 09:55:57 sandervl Exp $ */
     1/* $Id: os2heap.h,v 1.5 2001-07-06 13:47:19 sandervl Exp $ */
    22
    33/*
    … …  
    1818
    1919#define MAGIC_NR_HEAP  0x87654321
     20//must be a multiple of 8 bytes (alignment)
    2021typedef struct _tagHEAPELEM {
    2122  DWORD  magic;     //magic number
     23  LPVOID lpMem;     //pointer returned by malloc
    2224  struct _tagHEAPELEM *prev;
    2325  struct _tagHEAPELEM *next;
    24   DWORD  flags;     //set by LocalAlloc only
    25   DWORD  lockCnt;   //LocalLock/Unlock
    2626} HEAPELEM;
    2727
    28 #define HEAP_OVERHEAD (sizeof(HEAPELEM)+60)
    29 //#define HEAP_OVERHEAD sizeof(HEAPELEM)
     28//extra overhead needed for quake 2 or 3 (a long time ago...)
     29//#define HEAP_OVERHEAD (sizeof(HEAPELEM)+60)
     30//+8 to make sure we can align the pointer at 8 byte boundary
     31#define HEAP_OVERHEAD (sizeof(HEAPELEM)+8)
     32
     33#define GET_HEAPOBJ(ptr) (HEAPELEM *)((char *)ptr - sizeof(HEAPELEM));
    3034
    3135class OS2Heap
    … …  
    4448    BOOL   Validate(DWORD dwFlags, LPCVOID lpMem);
    4549    BOOL   Walk(void *lpEntry);
    46 
    47     LPVOID Alloc(DWORD dwFlags, DWORD dwBytes, DWORD LocalAllocFlags);
    48     BOOL   Lock(LPVOID lpMem);
    49     BOOL   Unlock(LPVOID lpMem);
    50     int    GetLockCnt(LPVOID lpMem);
    51     DWORD  GetFlags(LPVOID lpMem);
    5250
    5351   static OS2Heap *find(HANDLE hHeap);
Note: See TracChangeset for help on using the changeset viewer.