dlls/msvcrt/heap.c

   1 /*
   2  * msvcrt.dll heap functions
   3  *
   4  * Copyright 2000 Jon Griffiths
   5  *
   6  * Note: Win32 heap operations are MT safe. We only lock the new
   7  *       handler and non atomic heap operations
   8  */
   9
  10 #include "msvcrt.h"
  11
  12 #include "msvcrt/stdlib.h"
  13
  14
  15 DEFAULT_DEBUG_CHANNEL(msvcrt);
  16
  17 /* MT */
  18 extern CRITICAL_SECTION MSVCRT_heap_cs;
  19 #define LOCK_HEAP      EnterCriticalSection(&MSVCRT_heap_cs)
  20 #define UNLOCK_HEAP    LeaveCriticalSection(&MSVCRT_heap_cs)
  21
  22 /* heap function constants */
  23 #define MSVCRT_HEAPEMPTY    -1
  24 #define MSVCRT_HEAPOK       -2
  25 #define MSVCRT_HEAPBADBEGIN -3
  26 #define MSVCRT_HEAPBADNODE  -4
  27 #define MSVCRT_HEAPEND      -5
  28 #define MSVCRT_HEAPBADPTR   -6
  29 #define MSVCRT_FREEENTRY    0
  30 #define MSVCRT_USEDENTRY    1
  31
  32 typedef struct MSVCRT_heapinfo
  33 {
  34   int * _pentry;
  35   size_t _size;
  36   int    _useflag;
  37 } MSVCRT_HEAPINFO;
  38
  39 typedef void (*MSVCRT_new_handler_func)(void);
  40
  41 static MSVCRT_new_handler_func MSVCRT_new_handler;
  42 static int MSVCRT_new_mode;
  43
  44 /*********************************************************************
  45  *              operator_new (MSVCRT.@)
  46  */
  47 void* MSVCRT_operator_new(unsigned long size)
  48 {
  49   void *retval = HeapAlloc(GetProcessHeap(), 0, size);
  50   TRACE("(%ld) returning %p\n", size, retval);
  51   LOCK_HEAP;
  52   if(retval && MSVCRT_new_handler)
  53     (*MSVCRT_new_handler)();
  54   UNLOCK_HEAP;
  55   return retval;
  56 }
  57
  58 /*********************************************************************
  59  *              operator_delete (MSVCRT.@)
  60  */
  61 void MSVCRT_operator_delete(void *mem)
  62 {
  63   TRACE("(%p)\n", mem);
  64   HeapFree(GetProcessHeap(), 0, mem);
  65 }
  66
  67
  68 /*********************************************************************
  69  *              ?_query_new_handler@@YAP6AHI@ZXZ (MSVCRT.@)
  70  */
  71 MSVCRT_new_handler_func MSVCRT__query_new_handler(void)
  72 {
  73   return MSVCRT_new_handler;
  74 }
  75
  76
  77 /*********************************************************************
  78  *              ?_query_new_mode@@YAHXZ (MSVCRT.@)
  79  */
  80 int MSVCRT__query_new_mode(void)
  81 {
  82   return MSVCRT_new_mode;
  83 }
  84
  85 /*********************************************************************
  86  *              ?_set_new_handler@@YAP6AHI@ZP6AHI@Z@Z (MSVCRT.@)
  87  */
  88 MSVCRT_new_handler_func MSVCRT__set_new_handler(MSVCRT_new_handler_func func)
  89 {
  90   MSVCRT_new_handler_func old_handler;
  91   LOCK_HEAP;
  92   old_handler = MSVCRT_new_handler;
  93   MSVCRT_new_handler = func;
  94   UNLOCK_HEAP;
  95   return old_handler;
  96 }
  97
  98 /*********************************************************************
  99  *              ?_set_new_mode@@YAHH@Z (MSVCRT.@)
 100  */
 101 int MSVCRT__set_new_mode(int mode)
 102 {
 103   int old_mode;
 104   LOCK_HEAP;
 105   old_mode = MSVCRT_new_mode;
 106   MSVCRT_new_mode = mode;
 107   UNLOCK_HEAP;
 108   return old_mode;
 109 }
 110
 111 /*********************************************************************
 112  *              _expand (MSVCRT.@)
 113  */
 114 void* _expand(void* mem, unsigned int size)
 115 {
 116   return HeapReAlloc(GetProcessHeap(), HEAP_REALLOC_IN_PLACE_ONLY, mem, size);
 117 }
 118
 119 /*********************************************************************
 120  *              _heapchk (MSVCRT.@)
 121  */
 122 int _heapchk(void)
 123 {
 124   if (!HeapValidate( GetProcessHeap(), 0, NULL))
 125   {
 126     MSVCRT__set_errno(GetLastError());
 127     return MSVCRT_HEAPBADNODE;
 128   }
 129   return MSVCRT_HEAPOK;
 130 }
 131
 132 /*********************************************************************
 133  *              _heapmin (MSVCRT.@)
 134  */
 135 int _heapmin(void)
 136 {
 137   if (!HeapCompact( GetProcessHeap(), 0 ))
 138   {
 139     if (GetLastError() != ERROR_CALL_NOT_IMPLEMENTED)
 140       MSVCRT__set_errno(GetLastError());
 141     return -1;
 142   }
 143   return 0;
 144 }
 145
 146 /*********************************************************************
 147  *              _heapwalk (MSVCRT.@)
 148  */
 149 int _heapwalk(MSVCRT_HEAPINFO* next)
 150 {
 151   PROCESS_HEAP_ENTRY phe;
 152
 153   LOCK_HEAP;
 154   phe.lpData = next->_pentry;
 155   phe.cbData = next->_size;
 156   phe.wFlags = next->_useflag == MSVCRT_USEDENTRY ? PROCESS_HEAP_ENTRY_BUSY : 0;
 157
 158   if (phe.lpData && phe.wFlags & PROCESS_HEAP_ENTRY_BUSY &&
 159       !HeapValidate( GetProcessHeap(), 0, phe.lpData ))
 160   {
 161     UNLOCK_HEAP;
 162     MSVCRT__set_errno(GetLastError());
 163     return MSVCRT_HEAPBADNODE;
 164   }
 165
 166   do
 167   {
 168     if (!HeapWalk( GetProcessHeap(), &phe ))
 169     {
 170       UNLOCK_HEAP;
 171       if (GetLastError() == ERROR_NO_MORE_ITEMS)
 172          return MSVCRT_HEAPEND;
 173       MSVCRT__set_errno(GetLastError());
 174       if (!phe.lpData)
 175         return MSVCRT_HEAPBADBEGIN;
 176       return MSVCRT_HEAPBADNODE;
 177     }
 178   } while (phe.wFlags & (PROCESS_HEAP_REGION|PROCESS_HEAP_UNCOMMITTED_RANGE));
 179
 180   UNLOCK_HEAP;
 181   next->_pentry = phe.lpData;
 182   next->_size = phe.cbData;
 183   next->_useflag = phe.wFlags & PROCESS_HEAP_ENTRY_BUSY ? MSVCRT_USEDENTRY : MSVCRT_FREEENTRY;
 184   return MSVCRT_HEAPOK;
 185 }
 186
 187 /*********************************************************************
 188  *              _heapset (MSVCRT.@)
 189  */
 190 int _heapset(unsigned int value)
 191 {
 192   int retval;
 193   MSVCRT_HEAPINFO heap;
 194
 195   memset( &heap, 0, sizeof(MSVCRT_HEAPINFO) );
 196   LOCK_HEAP;
 197   while ((retval = _heapwalk(&heap)) == MSVCRT_HEAPOK)
 198   {
 199     if (heap._useflag == MSVCRT_FREEENTRY)
 200       memset(heap._pentry, value, heap._size);
 201   }
 202   UNLOCK_HEAP;
 203   return retval == MSVCRT_HEAPEND? MSVCRT_HEAPOK : retval;
 204 }
 205
 206 /*********************************************************************
 207  *              _msize (MSVCRT.@)
 208  */
 209 long _msize(void* mem)
 210 {
 211   long size = HeapSize(GetProcessHeap(),0,mem);
 212   if (size == -1)
 213   {
 214     WARN(":Probably called with non wine-allocated memory, ret = -1\n");
 215     /* At least the Win32 crtdll/msvcrt also return -1 in this case */
 216   }
 217   return size;
 218 }
 219
 220 /*********************************************************************
 221  *              calloc (MSVCRT.@)
 222  */
 223 void* MSVCRT_calloc(unsigned int size, unsigned int count)
 224 {
 225   return HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, size * count );
 226 }
 227
 228 /*********************************************************************
 229  *              free (MSVCRT.@)
 230  */
 231 void MSVCRT_free(void* ptr)
 232 {
 233   HeapFree(GetProcessHeap(),0,ptr);
 234 }
 235
 236 /*********************************************************************
 237  *                  malloc (MSVCRT.@)
 238  */
 239 void* MSVCRT_malloc(unsigned int size)
 240 {
 241   void *ret = HeapAlloc(GetProcessHeap(),0,size);
 242   if (!ret)
 243     MSVCRT__set_errno(GetLastError());
 244   return ret;
 245 }
 246
 247 /*********************************************************************
 248  *              realloc (MSVCRT.@)
 249  */
 250 void* MSVCRT_realloc(void* ptr, unsigned int size)
 251 {
 252   return HeapReAlloc(GetProcessHeap(), 0, ptr, size);
 253 }