dlls/msvcrt/heap.c

   1 /*
   2  * msvcrt.dll heap functions
   3  *
   4  * Copyright 2000 Jon Griffiths
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  *
  20  * Note: Win32 heap operations are MT safe. We only lock the new
  21  *       handler and non atomic heap operations
  22  */
  23
  24 #include "msvcrt.h"
  25 #include "mtdll.h"
  26 #include "wine/debug.h"
  27
  28 WINE_DEFAULT_DEBUG_CHANNEL(msvcrt);
  29
  30 /* MT */
  31 #define LOCK_HEAP   _mlock( _HEAP_LOCK )
  32 #define UNLOCK_HEAP _munlock( _HEAP_LOCK )
  33
  34
  35 typedef void (*MSVCRT_new_handler_func)(unsigned long size);
  36
  37 static MSVCRT_new_handler_func MSVCRT_new_handler;
  38 static int MSVCRT_new_mode;
  39
  40 /* FIXME - According to documentation it should be 8*1024, at runtime it returns 16 */
  41 static unsigned int MSVCRT_amblksiz = 16;
  42 /* FIXME - According to documentation it should be 480 bytes, at runtime default is 0 */
  43 static size_t MSVCRT_sbh_threshold = 0;
  44
  45 /*********************************************************************
  46  *              ??2@YAPAXI@Z (MSVCRT.@)
  47  */
  48 void* CDECL MSVCRT_operator_new(unsigned long size)
  49 {
  50   void *retval = HeapAlloc(GetProcessHeap(), 0, size);
  51   TRACE("(%ld) returning %p\n", size, retval);
  52   if(retval) return retval;
  53   LOCK_HEAP;
  54   if(MSVCRT_new_handler)
  55     (*MSVCRT_new_handler)(size);
  56   UNLOCK_HEAP;
  57   return retval;
  58 }
  59
  60 /*********************************************************************
  61  *              ??3@YAXPAX@Z (MSVCRT.@)
  62  */
  63 void CDECL MSVCRT_operator_delete(void *mem)
  64 {
  65   TRACE("(%p)\n", mem);
  66   HeapFree(GetProcessHeap(), 0, mem);
  67 }
  68
  69
  70 /*********************************************************************
  71  *              ?_query_new_handler@@YAP6AHI@ZXZ (MSVCRT.@)
  72  */
  73 MSVCRT_new_handler_func CDECL MSVCRT__query_new_handler(void)
  74 {
  75   return MSVCRT_new_handler;
  76 }
  77
  78
  79 /*********************************************************************
  80  *              ?_query_new_mode@@YAHXZ (MSVCRT.@)
  81  */
  82 int CDECL MSVCRT__query_new_mode(void)
  83 {
  84   return MSVCRT_new_mode;
  85 }
  86
  87 /*********************************************************************
  88  *              ?_set_new_handler@@YAP6AHI@ZP6AHI@Z@Z (MSVCRT.@)
  89  */
  90 MSVCRT_new_handler_func CDECL MSVCRT__set_new_handler(MSVCRT_new_handler_func func)
  91 {
  92   MSVCRT_new_handler_func old_handler;
  93   LOCK_HEAP;
  94   old_handler = MSVCRT_new_handler;
  95   MSVCRT_new_handler = func;
  96   UNLOCK_HEAP;
  97   return old_handler;
  98 }
  99
 100 /*********************************************************************
 101  *              ?set_new_handler@@YAP6AXXZP6AXXZ@Z (MSVCRT.@)
 102  */
 103 MSVCRT_new_handler_func CDECL MSVCRT_set_new_handler(void *func)
 104 {
 105   TRACE("(%p)\n",func);
 106   MSVCRT__set_new_handler(NULL);
 107   return NULL;
 108 }
 109
 110 /*********************************************************************
 111  *              ?_set_new_mode@@YAHH@Z (MSVCRT.@)
 112  */
 113 int CDECL MSVCRT__set_new_mode(int mode)
 114 {
 115   int old_mode;
 116   LOCK_HEAP;
 117   old_mode = MSVCRT_new_mode;
 118   MSVCRT_new_mode = mode;
 119   UNLOCK_HEAP;
 120   return old_mode;
 121 }
 122
 123 /*********************************************************************
 124  *              _callnewh (MSVCRT.@)
 125  */
 126 int CDECL _callnewh(unsigned long size)
 127 {
 128   if(MSVCRT_new_handler)
 129     (*MSVCRT_new_handler)(size);
 130   return 0;
 131 }
 132
 133 /*********************************************************************
 134  *              _expand (MSVCRT.@)
 135  */
 136 void* CDECL _expand(void* mem, MSVCRT_size_t size)
 137 {
 138   return HeapReAlloc(GetProcessHeap(), HEAP_REALLOC_IN_PLACE_ONLY, mem, size);
 139 }
 140
 141 /*********************************************************************
 142  *              _heapchk (MSVCRT.@)
 143  */
 144 int CDECL _heapchk(void)
 145 {
 146   if (!HeapValidate( GetProcessHeap(), 0, NULL))
 147   {
 148     msvcrt_set_errno(GetLastError());
 149     return MSVCRT__HEAPBADNODE;
 150   }
 151   return MSVCRT__HEAPOK;
 152 }
 153
 154 /*********************************************************************
 155  *              _heapmin (MSVCRT.@)
 156  */
 157 int CDECL _heapmin(void)
 158 {
 159   if (!HeapCompact( GetProcessHeap(), 0 ))
 160   {
 161     if (GetLastError() != ERROR_CALL_NOT_IMPLEMENTED)
 162       msvcrt_set_errno(GetLastError());
 163     return -1;
 164   }
 165   return 0;
 166 }
 167
 168 /*********************************************************************
 169  *              _heapwalk (MSVCRT.@)
 170  */
 171 int CDECL _heapwalk(struct MSVCRT__heapinfo* next)
 172 {
 173   PROCESS_HEAP_ENTRY phe;
 174
 175   LOCK_HEAP;
 176   phe.lpData = next->_pentry;
 177   phe.cbData = next->_size;
 178   phe.wFlags = next->_useflag == MSVCRT__USEDENTRY ? PROCESS_HEAP_ENTRY_BUSY : 0;
 179
 180   if (phe.lpData && phe.wFlags & PROCESS_HEAP_ENTRY_BUSY &&
 181       !HeapValidate( GetProcessHeap(), 0, phe.lpData ))
 182   {
 183     UNLOCK_HEAP;
 184     msvcrt_set_errno(GetLastError());
 185     return MSVCRT__HEAPBADNODE;
 186   }
 187
 188   do
 189   {
 190     if (!HeapWalk( GetProcessHeap(), &phe ))
 191     {
 192       UNLOCK_HEAP;
 193       if (GetLastError() == ERROR_NO_MORE_ITEMS)
 194          return MSVCRT__HEAPEND;
 195       msvcrt_set_errno(GetLastError());
 196       if (!phe.lpData)
 197         return MSVCRT__HEAPBADBEGIN;
 198       return MSVCRT__HEAPBADNODE;
 199     }
 200   } while (phe.wFlags & (PROCESS_HEAP_REGION|PROCESS_HEAP_UNCOMMITTED_RANGE));
 201
 202   UNLOCK_HEAP;
 203   next->_pentry = phe.lpData;
 204   next->_size = phe.cbData;
 205   next->_useflag = phe.wFlags & PROCESS_HEAP_ENTRY_BUSY ? MSVCRT__USEDENTRY : MSVCRT__FREEENTRY;
 206   return MSVCRT__HEAPOK;
 207 }
 208
 209 /*********************************************************************
 210  *              _heapset (MSVCRT.@)
 211  */
 212 int CDECL _heapset(unsigned int value)
 213 {
 214   int retval;
 215   struct MSVCRT__heapinfo heap;
 216
 217   memset( &heap, 0, sizeof(heap) );
 218   LOCK_HEAP;
 219   while ((retval = _heapwalk(&heap)) == MSVCRT__HEAPOK)
 220   {
 221     if (heap._useflag == MSVCRT__FREEENTRY)
 222       memset(heap._pentry, value, heap._size);
 223   }
 224   UNLOCK_HEAP;
 225   return retval == MSVCRT__HEAPEND? MSVCRT__HEAPOK : retval;
 226 }
 227
 228 /*********************************************************************
 229  *              _heapadd (MSVCRT.@)
 230  */
 231 int CDECL _heapadd(void* mem, MSVCRT_size_t size)
 232 {
 233   TRACE("(%p,%d) unsupported in Win32\n", mem,size);
 234   *MSVCRT__errno() = MSVCRT_ENOSYS;
 235   return -1;
 236 }
 237
 238 /*********************************************************************
 239  *              _msize (MSVCRT.@)
 240  */
 241 MSVCRT_size_t CDECL _msize(void* mem)
 242 {
 243   long size = HeapSize(GetProcessHeap(),0,mem);
 244   if (size == -1)
 245   {
 246     WARN(":Probably called with non wine-allocated memory, ret = -1\n");
 247     /* At least the Win32 crtdll/msvcrt also return -1 in this case */
 248   }
 249   return size;
 250 }
 251
 252 /*********************************************************************
 253  *              calloc (MSVCRT.@)
 254  */
 255 void* CDECL MSVCRT_calloc(MSVCRT_size_t size, MSVCRT_size_t count)
 256 {
 257   return HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, size * count );
 258 }
 259
 260 /*********************************************************************
 261  *              free (MSVCRT.@)
 262  */
 263 void CDECL MSVCRT_free(void* ptr)
 264 {
 265   HeapFree(GetProcessHeap(),0,ptr);
 266 }
 267
 268 /*********************************************************************
 269  *                  malloc (MSVCRT.@)
 270  */
 271 void* CDECL MSVCRT_malloc(MSVCRT_size_t size)
 272 {
 273   void *ret = HeapAlloc(GetProcessHeap(),0,size);
 274   if (!ret)
 275     msvcrt_set_errno(GetLastError());
 276   return ret;
 277 }
 278
 279 /*********************************************************************
 280  *              realloc (MSVCRT.@)
 281  */
 282 void* CDECL MSVCRT_realloc(void* ptr, MSVCRT_size_t size)
 283 {
 284   if (!ptr) return MSVCRT_malloc(size);
 285   if (size) return HeapReAlloc(GetProcessHeap(), 0, ptr, size);
 286   MSVCRT_free(ptr);
 287   return NULL;
 288 }
 289
 290 /*********************************************************************
 291  *              __p__amblksiz (MSVCRT.@)
 292  */
 293 unsigned int* CDECL __p__amblksiz(void)
 294 {
 295   return &MSVCRT_amblksiz;
 296 }
 297
 298 /*********************************************************************
 299  *              _get_sbh_threshold (MSVCRT.@)
 300  */
 301 size_t CDECL _get_sbh_threshold(void)
 302 {
 303   return MSVCRT_sbh_threshold;
 304 }
 305
 306 /*********************************************************************
 307  *              _set_sbh_threshold (MSVCRT.@)
 308  */
 309 int CDECL _set_sbh_threshold(size_t threshold)
 310 {
 311   if(threshold > 1016)
 312      return 0;
 313   else
 314      MSVCRT_sbh_threshold = threshold;
 315   return 1;
 316 }