?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fixed some issues found by winapi_check.
[wine/dcerpc.git] / dlls / ntdll / heap.c
blobf9eb76b7a96b72784151ba3189b8b5865394fcae
1 /*
2 * Win32 heap functions
3 *
4 * Copyright 1996 Alexandre Julliard
5 * Copyright 1998 Ulrich Weigand
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 */
21
22 #include "config.h"
23
24 #include <assert.h>
25 #include <stdlib.h>
26 #include <stdio.h>
27 #include <string.h>
28
29 #include "ntddk.h"
30 #include "wine/winbase16.h"
31 #include "winbase.h"
32 #include "winerror.h"
33 #include "winnt.h"
34 #include "heap.h"
35 #include "thread.h"
36 #include "wine/debug.h"
37
38 WINE_DEFAULT_DEBUG_CHANNEL(heap);
39
40 /* Note: the heap data structures are based on what Pietrek describes in his
41 * book 'Windows 95 System Programming Secrets'. The layout is not exactly
42 * the same, but could be easily adapted if it turns out some programs
43 * require it.
44 */
45
46 typedef struct tagARENA_INUSE
47 {
48 DWORD size; /* Block size; must be the first field */
49 DWORD magic; /* Magic number */
50 } ARENA_INUSE;
51
52 typedef struct tagARENA_FREE
53 {
54 DWORD size; /* Block size; must be the first field */
55 DWORD magic; /* Magic number */
56 struct tagARENA_FREE *next; /* Next free arena */
57 struct tagARENA_FREE *prev; /* Prev free arena */
58 } ARENA_FREE;
59
60 #define ARENA_FLAG_FREE 0x00000001 /* flags OR'ed with arena size */
61 #define ARENA_FLAG_PREV_FREE 0x00000002
62 #define ARENA_SIZE_MASK (~3)
63 #define ARENA_INUSE_MAGIC 0x44455355 /* Value for arena 'magic' field */
64 #define ARENA_FREE_MAGIC 0x45455246 /* Value for arena 'magic' field */
65
66 #define ARENA_INUSE_FILLER 0x55
67 #define ARENA_FREE_FILLER 0xaa
68
69 #define ALIGNMENT 8 /* everything is aligned on 8 byte boundaries */
70 #define ROUND_SIZE(size) (((size) + ALIGNMENT - 1) & ~(ALIGNMENT-1))
71
72 #define QUIET 1 /* Suppress messages */
73 #define NOISY 0 /* Report all errors */
74
75 #define HEAP_NB_FREE_LISTS 4 /* Number of free lists */
76
77 /* Max size of the blocks on the free lists */
78 static const DWORD HEAP_freeListSizes[HEAP_NB_FREE_LISTS] =
79 {
80 0x20, 0x80, 0x200, ~0UL
81 };
82
83 typedef struct
84 {
85 DWORD size;
86 ARENA_FREE arena;
87 } FREE_LIST_ENTRY;
88
89 struct tagHEAP;
90
91 typedef struct tagSUBHEAP
92 {
93 DWORD size; /* Size of the whole sub-heap */
94 DWORD commitSize; /* Committed size of the sub-heap */
95 DWORD headerSize; /* Size of the heap header */
96 struct tagSUBHEAP *next; /* Next sub-heap */
97 struct tagHEAP *heap; /* Main heap structure */
98 DWORD magic; /* Magic number */
99 } SUBHEAP;
100
101 #define SUBHEAP_MAGIC ((DWORD)('S' | ('U'<<8) | ('B'<<16) | ('H'<<24)))
102
103 typedef struct tagHEAP
104 {
105 SUBHEAP subheap; /* First sub-heap */
106 struct tagHEAP *next; /* Next heap for this process */
107 CRITICAL_SECTION critSection; /* Critical section for serialization */
108 FREE_LIST_ENTRY freeList[HEAP_NB_FREE_LISTS]; /* Free lists */
109 DWORD flags; /* Heap flags */
110 DWORD magic; /* Magic number */
111 } HEAP;
112
113 #define HEAP_MAGIC ((DWORD)('H' | ('E'<<8) | ('A'<<16) | ('P'<<24)))
114
115 #define HEAP_DEF_SIZE 0x110000 /* Default heap size = 1Mb + 64Kb */
116 #define HEAP_MIN_BLOCK_SIZE (8+sizeof(ARENA_FREE)) /* Min. heap block size */
117 #define COMMIT_MASK 0xffff /* bitmask for commit/decommit granularity */
118
119 static HANDLE processHeap; /* main process heap */
120
121 static HEAP *firstHeap; /* head of secondary heaps list */
122
123 static BOOL HEAP_IsRealArena( HEAP *heapPtr, DWORD flags, LPCVOID block, BOOL quiet );
124
125 /* SetLastError for ntdll */
126 inline static void set_status( NTSTATUS status )
127 {
128 #if defined(__i386__) && defined(__GNUC__)
129 /* in this case SetLastError is an inline function so we can use it */
130 SetLastError( RtlNtStatusToDosError( status ) );
131 #else
132 /* cannot use SetLastError, do it manually */
133 NtCurrentTeb()->last_error = RtlNtStatusToDosError( status );
134 #endif
135 }
136
137 /* set the process main heap */
138 static void set_process_heap( HANDLE heap )
139 {
140 HANDLE *pdb = (HANDLE *)NtCurrentTeb()->process;
141 pdb[0x18 / sizeof(HANDLE)] = heap; /* heap is at offset 0x18 in pdb */
142 processHeap = heap;
143 }
144
145
146 /***********************************************************************
147 * HEAP_Dump
148 */
149 void HEAP_Dump( HEAP *heap )
150 {
151 int i;
152 SUBHEAP *subheap;
153 char *ptr;
154
155 DPRINTF( "Heap: %08lx\n", (DWORD)heap );
156 DPRINTF( "Next: %08lx Sub-heaps: %08lx",
157 (DWORD)heap->next, (DWORD)&heap->subheap );
158 subheap = &heap->subheap;
159 while (subheap->next)
160 {
161 DPRINTF( " -> %08lx", (DWORD)subheap->next );
162 subheap = subheap->next;
163 }
164
165 DPRINTF( "\nFree lists:\n Block Stat Size Id\n" );
166 for (i = 0; i < HEAP_NB_FREE_LISTS; i++)
167 DPRINTF( "%08lx free %08lx prev=%08lx next=%08lx\n",
168 (DWORD)&heap->freeList[i].arena, heap->freeList[i].arena.size,
169 (DWORD)heap->freeList[i].arena.prev,
170 (DWORD)heap->freeList[i].arena.next );
171
172 subheap = &heap->subheap;
173 while (subheap)
174 {
175 DWORD freeSize = 0, usedSize = 0, arenaSize = subheap->headerSize;
176 DPRINTF( "\n\nSub-heap %08lx: size=%08lx committed=%08lx\n",
177 (DWORD)subheap, subheap->size, subheap->commitSize );
178
179 DPRINTF( "\n Block Stat Size Id\n" );
180 ptr = (char*)subheap + subheap->headerSize;
181 while (ptr < (char *)subheap + subheap->size)
182 {
183 if (*(DWORD *)ptr & ARENA_FLAG_FREE)
184 {
185 ARENA_FREE *pArena = (ARENA_FREE *)ptr;
186 DPRINTF( "%08lx free %08lx prev=%08lx next=%08lx\n",
187 (DWORD)pArena, pArena->size & ARENA_SIZE_MASK,
188 (DWORD)pArena->prev, (DWORD)pArena->next);
189 ptr += sizeof(*pArena) + (pArena->size & ARENA_SIZE_MASK);
190 arenaSize += sizeof(ARENA_FREE);
191 freeSize += pArena->size & ARENA_SIZE_MASK;
192 }
193 else if (*(DWORD *)ptr & ARENA_FLAG_PREV_FREE)
194 {
195 ARENA_INUSE *pArena = (ARENA_INUSE *)ptr;
196 DPRINTF( "%08lx Used %08lx back=%08lx\n",
197 (DWORD)pArena, pArena->size & ARENA_SIZE_MASK, *((DWORD *)pArena - 1) );
198 ptr += sizeof(*pArena) + (pArena->size & ARENA_SIZE_MASK);
199 arenaSize += sizeof(ARENA_INUSE);
200 usedSize += pArena->size & ARENA_SIZE_MASK;
201 }
202 else
203 {
204 ARENA_INUSE *pArena = (ARENA_INUSE *)ptr;
205 DPRINTF( "%08lx used %08lx\n",
206 (DWORD)pArena, pArena->size & ARENA_SIZE_MASK );
207 ptr += sizeof(*pArena) + (pArena->size & ARENA_SIZE_MASK);
208 arenaSize += sizeof(ARENA_INUSE);
209 usedSize += pArena->size & ARENA_SIZE_MASK;
210 }
211 }
212 DPRINTF( "\nTotal: Size=%08lx Committed=%08lx Free=%08lx Used=%08lx Arenas=%08lx (%ld%%)\n\n",
213 subheap->size, subheap->commitSize, freeSize, usedSize,
214 arenaSize, (arenaSize * 100) / subheap->size );
215 subheap = subheap->next;
216 }
217 }
218
219
220 /***********************************************************************
221 * HEAP_GetPtr
222 * RETURNS
223 * Pointer to the heap
224 * NULL: Failure
225 */
226 static HEAP *HEAP_GetPtr(
227 HANDLE heap /* [in] Handle to the heap */
228 ) {
229 HEAP *heapPtr = (HEAP *)heap;
230 if (!heapPtr || (heapPtr->magic != HEAP_MAGIC))
231 {
232 ERR("Invalid heap %08x!\n", heap );
233 return NULL;
234 }
235 if (TRACE_ON(heap) && !HEAP_IsRealArena( heapPtr, 0, NULL, NOISY ))
236 {
237 HEAP_Dump( heapPtr );
238 assert( FALSE );
239 return NULL;
240 }
241 return heapPtr;
242 }
243
244
245 /***********************************************************************
246 * HEAP_InsertFreeBlock
247 *
248 * Insert a free block into the free list.
249 */
250 static void HEAP_InsertFreeBlock( HEAP *heap, ARENA_FREE *pArena )
251 {
252 FREE_LIST_ENTRY *pEntry = heap->freeList;
253 while (pEntry->size < pArena->size) pEntry++;
254 pArena->size |= ARENA_FLAG_FREE;
255 pArena->next = pEntry->arena.next;
256 pArena->next->prev = pArena;
257 pArena->prev = &pEntry->arena;
258 pEntry->arena.next = pArena;
259 }
260
261
262 /***********************************************************************
263 * HEAP_FindSubHeap
264 * Find the sub-heap containing a given address.
265 *
266 * RETURNS
267 * Pointer: Success
268 * NULL: Failure
269 */
270 static SUBHEAP *HEAP_FindSubHeap(
271 HEAP *heap, /* [in] Heap pointer */
272 LPCVOID ptr /* [in] Address */
273 ) {
274 SUBHEAP *sub = &heap->subheap;
275 while (sub)
276 {
277 if (((char *)ptr >= (char *)sub) &&
278 ((char *)ptr < (char *)sub + sub->size)) return sub;
279 sub = sub->next;
280 }
281 return NULL;
282 }
283
284
285 /***********************************************************************
286 * HEAP_Commit
287 *
288 * Make sure the heap storage is committed up to (not including) ptr.
289 */
290 static inline BOOL HEAP_Commit( SUBHEAP *subheap, void *ptr )
291 {
292 DWORD size = (DWORD)((char *)ptr - (char *)subheap);
293 size = (size + COMMIT_MASK) & ~COMMIT_MASK;
294 if (size > subheap->size) size = subheap->size;
295 if (size <= subheap->commitSize) return TRUE;
296 if (!VirtualAlloc( (char *)subheap + subheap->commitSize,
297 size - subheap->commitSize, MEM_COMMIT,
298 PAGE_EXECUTE_READWRITE))
299 {
300 WARN("Could not commit %08lx bytes at %08lx for heap %08lx\n",
301 size - subheap->commitSize,
302 (DWORD)((char *)subheap + subheap->commitSize),
303 (DWORD)subheap->heap );
304 return FALSE;
305 }
306 subheap->commitSize = size;
307 return TRUE;
308 }
309
310
311 /***********************************************************************
312 * HEAP_Decommit
313 *
314 * If possible, decommit the heap storage from (including) 'ptr'.
315 */
316 static inline BOOL HEAP_Decommit( SUBHEAP *subheap, void *ptr )
317 {
318 DWORD size = (DWORD)((char *)ptr - (char *)subheap);
319 /* round to next block and add one full block */
320 size = ((size + COMMIT_MASK) & ~COMMIT_MASK) + COMMIT_MASK + 1;
321 if (size >= subheap->commitSize) return TRUE;
322 if (!VirtualFree( (char *)subheap + size,
323 subheap->commitSize - size, MEM_DECOMMIT ))
324 {
325 WARN("Could not decommit %08lx bytes at %08lx for heap %08lx\n",
326 subheap->commitSize - size,
327 (DWORD)((char *)subheap + size),
328 (DWORD)subheap->heap );
329 return FALSE;
330 }
331 subheap->commitSize = size;
332 return TRUE;
333 }
334
335
336 /***********************************************************************
337 * HEAP_CreateFreeBlock
338 *
339 * Create a free block at a specified address. 'size' is the size of the
340 * whole block, including the new arena.
341 */
342 static void HEAP_CreateFreeBlock( SUBHEAP *subheap, void *ptr, DWORD size )
343 {
344 ARENA_FREE *pFree;
345
346 /* Create a free arena */
347
348 pFree = (ARENA_FREE *)ptr;
349 pFree->magic = ARENA_FREE_MAGIC;
350
351 /* If debugging, erase the freed block content */
352
353 if (TRACE_ON(heap))
354 {
355 char *pEnd = (char *)ptr + size;
356 if (pEnd > (char *)subheap + subheap->commitSize)
357 pEnd = (char *)subheap + subheap->commitSize;
358 if (pEnd > (char *)(pFree + 1))
359 memset( pFree + 1, ARENA_FREE_FILLER, pEnd - (char *)(pFree + 1) );
360 }
361
362 /* Check if next block is free also */
363
364 if (((char *)ptr + size < (char *)subheap + subheap->size) &&
365 (*(DWORD *)((char *)ptr + size) & ARENA_FLAG_FREE))
366 {
367 /* Remove the next arena from the free list */
368 ARENA_FREE *pNext = (ARENA_FREE *)((char *)ptr + size);
369 pNext->next->prev = pNext->prev;
370 pNext->prev->next = pNext->next;
371 size += (pNext->size & ARENA_SIZE_MASK) + sizeof(*pNext);
372 if (TRACE_ON(heap))
373 memset( pNext, ARENA_FREE_FILLER, sizeof(ARENA_FREE) );
374 }
375
376 /* Set the next block PREV_FREE flag and pointer */
377
378 if ((char *)ptr + size < (char *)subheap + subheap->size)
379 {
380 DWORD *pNext = (DWORD *)((char *)ptr + size);
381 *pNext |= ARENA_FLAG_PREV_FREE;
382 *(ARENA_FREE **)(pNext - 1) = pFree;
383 }
384
385 /* Last, insert the new block into the free list */
386
387 pFree->size = size - sizeof(*pFree);
388 HEAP_InsertFreeBlock( subheap->heap, pFree );
389 }
390
391
392 /***********************************************************************
393 * HEAP_MakeInUseBlockFree
394 *
395 * Turn an in-use block into a free block. Can also decommit the end of
396 * the heap, and possibly even free the sub-heap altogether.
397 */
398 static void HEAP_MakeInUseBlockFree( SUBHEAP *subheap, ARENA_INUSE *pArena )
399 {
400 ARENA_FREE *pFree;
401 DWORD size = (pArena->size & ARENA_SIZE_MASK) + sizeof(*pArena);
402
403 /* Check if we can merge with previous block */
404
405 if (pArena->size & ARENA_FLAG_PREV_FREE)
406 {
407 pFree = *((ARENA_FREE **)pArena - 1);
408 size += (pFree->size & ARENA_SIZE_MASK) + sizeof(ARENA_FREE);
409 /* Remove it from the free list */
410 pFree->next->prev = pFree->prev;
411 pFree->prev->next = pFree->next;
412 }
413 else pFree = (ARENA_FREE *)pArena;
414
415 /* Create a free block */
416
417 HEAP_CreateFreeBlock( subheap, pFree, size );
418 size = (pFree->size & ARENA_SIZE_MASK) + sizeof(ARENA_FREE);
419 if ((char *)pFree + size < (char *)subheap + subheap->size)
420 return; /* Not the last block, so nothing more to do */
421
422 /* Free the whole sub-heap if it's empty and not the original one */
423
424 if (((char *)pFree == (char *)subheap + subheap->headerSize) &&
425 (subheap != &subheap->heap->subheap))
426 {
427 SUBHEAP *pPrev = &subheap->heap->subheap;
428 /* Remove the free block from the list */
429 pFree->next->prev = pFree->prev;
430 pFree->prev->next = pFree->next;
431 /* Remove the subheap from the list */
432 while (pPrev && (pPrev->next != subheap)) pPrev = pPrev->next;
433 if (pPrev) pPrev->next = subheap->next;
434 /* Free the memory */
435 subheap->magic = 0;
436 VirtualFree( subheap, 0, MEM_RELEASE );
437 return;
438 }
439
440 /* Decommit the end of the heap */
441
442 if (!(subheap->heap->flags & HEAP_SHARED)) HEAP_Decommit( subheap, pFree + 1 );
443 }
444
445
446 /***********************************************************************
447 * HEAP_ShrinkBlock
448 *
449 * Shrink an in-use block.
450 */
451 static void HEAP_ShrinkBlock(SUBHEAP *subheap, ARENA_INUSE *pArena, DWORD size)
452 {
453 if ((pArena->size & ARENA_SIZE_MASK) >= size + HEAP_MIN_BLOCK_SIZE)
454 {
455 HEAP_CreateFreeBlock( subheap, (char *)(pArena + 1) + size,
456 (pArena->size & ARENA_SIZE_MASK) - size );
457 /* assign size plus previous arena flags */
458 pArena->size = size | (pArena->size & ~ARENA_SIZE_MASK);
459 }
460 else
461 {
462 /* Turn off PREV_FREE flag in next block */
463 char *pNext = (char *)(pArena + 1) + (pArena->size & ARENA_SIZE_MASK);
464 if (pNext < (char *)subheap + subheap->size)
465 *(DWORD *)pNext &= ~ARENA_FLAG_PREV_FREE;
466 }
467 }
468
469 /***********************************************************************
470 * HEAP_InitSubHeap
471 */
472 static BOOL HEAP_InitSubHeap( HEAP *heap, LPVOID address, DWORD flags,
473 DWORD commitSize, DWORD totalSize )
474 {
475 SUBHEAP *subheap = (SUBHEAP *)address;
476 FREE_LIST_ENTRY *pEntry;
477 int i;
478
479 /* Commit memory */
480
481 if (flags & HEAP_SHARED)
482 commitSize = totalSize; /* always commit everything in a shared heap */
483 if (!VirtualAlloc(address, commitSize, MEM_COMMIT, PAGE_EXECUTE_READWRITE))
484 {
485 WARN("Could not commit %08lx bytes for sub-heap %08lx\n",
486 commitSize, (DWORD)address );
487 return FALSE;
488 }
489
490 /* Fill the sub-heap structure */
491
492 subheap->heap = heap;
493 subheap->size = totalSize;
494 subheap->commitSize = commitSize;
495 subheap->magic = SUBHEAP_MAGIC;
496
497 if ( subheap != (SUBHEAP *)heap )
498 {
499 /* If this is a secondary subheap, insert it into list */
500
501 subheap->headerSize = ROUND_SIZE( sizeof(SUBHEAP) );
502 subheap->next = heap->subheap.next;
503 heap->subheap.next = subheap;
504 }
505 else
506 {
507 /* If this is a primary subheap, initialize main heap */
508
509 subheap->headerSize = ROUND_SIZE( sizeof(HEAP) );
510 subheap->next = NULL;
511 heap->next = NULL;
512 heap->flags = flags;
513 heap->magic = HEAP_MAGIC;
514
515 /* Build the free lists */
516
517 for (i = 0, pEntry = heap->freeList; i < HEAP_NB_FREE_LISTS; i++, pEntry++)
518 {
519 pEntry->size = HEAP_freeListSizes[i];
520 pEntry->arena.size = 0 | ARENA_FLAG_FREE;
521 pEntry->arena.next = i < HEAP_NB_FREE_LISTS-1 ?
522 &heap->freeList[i+1].arena : &heap->freeList[0].arena;
523 pEntry->arena.prev = i ? &heap->freeList[i-1].arena :
524 &heap->freeList[HEAP_NB_FREE_LISTS-1].arena;
525 pEntry->arena.magic = ARENA_FREE_MAGIC;
526 }
527
528 /* Initialize critical section */
529
530 RtlInitializeCriticalSection( &heap->critSection );
531 if (flags & HEAP_SHARED)
532 MakeCriticalSectionGlobal( &heap->critSection ); /* FIXME: dll separation */
533 }
534
535 /* Create the first free block */
536
537 HEAP_CreateFreeBlock( subheap, (LPBYTE)subheap + subheap->headerSize,
538 subheap->size - subheap->headerSize );
539
540 return TRUE;
541 }
542
543 /***********************************************************************
544 * HEAP_CreateSubHeap
545 *
546 * Create a sub-heap of the given size.
547 * If heap == NULL, creates a main heap.
548 */
549 static SUBHEAP *HEAP_CreateSubHeap( HEAP *heap, void *base, DWORD flags,
550 DWORD commitSize, DWORD totalSize )
551 {
552 LPVOID address = base;
553
554 /* round-up sizes on a 64K boundary */
555 totalSize = (totalSize + 0xffff) & 0xffff0000;
556 commitSize = (commitSize + 0xffff) & 0xffff0000;
557 if (!commitSize) commitSize = 0x10000;
558 if (totalSize < commitSize) totalSize = commitSize;
559
560 if (!address)
561 {
562 /* allocate the memory block */
563 if (!(address = VirtualAlloc( NULL, totalSize, MEM_RESERVE, PAGE_EXECUTE_READWRITE )))
564 {
565 WARN("Could not VirtualAlloc %08lx bytes\n",
566 totalSize );
567 return NULL;
568 }
569 }
570
571 /* Initialize subheap */
572
573 if (!HEAP_InitSubHeap( heap ? heap : (HEAP *)address,
574 address, flags, commitSize, totalSize ))
575 {
576 if (!base) VirtualFree( address, 0, MEM_RELEASE );
577 return NULL;
578 }
579
580 return (SUBHEAP *)address;
581 }
582
583
584 /***********************************************************************
585 * HEAP_FindFreeBlock
586 *
587 * Find a free block at least as large as the requested size, and make sure
588 * the requested size is committed.
589 */
590 static ARENA_FREE *HEAP_FindFreeBlock( HEAP *heap, DWORD size,
591 SUBHEAP **ppSubHeap )
592 {
593 SUBHEAP *subheap;
594 ARENA_FREE *pArena;
595 FREE_LIST_ENTRY *pEntry = heap->freeList;
596
597 /* Find a suitable free list, and in it find a block large enough */
598
599 while (pEntry->size < size) pEntry++;
600 pArena = pEntry->arena.next;
601 while (pArena != &heap->freeList[0].arena)
602 {
603 DWORD arena_size = (pArena->size & ARENA_SIZE_MASK) +
604 sizeof(ARENA_FREE) - sizeof(ARENA_INUSE);
605 if (arena_size >= size)
606 {
607 subheap = HEAP_FindSubHeap( heap, pArena );
608 if (!HEAP_Commit( subheap, (char *)pArena + sizeof(ARENA_INUSE)
609 + size + HEAP_MIN_BLOCK_SIZE))
610 return NULL;
611 *ppSubHeap = subheap;
612 return pArena;
613 }
614 pArena = pArena->next;
615 }
616
617 /* If no block was found, attempt to grow the heap */
618
619 if (!(heap->flags & HEAP_GROWABLE))
620 {
621 WARN("Not enough space in heap %08lx for %08lx bytes\n",
622 (DWORD)heap, size );
623 return NULL;
624 }
625 /* make sure that we have a big enough size *committed* to fit another
626 * last free arena in !
627 * So just one heap struct, one first free arena which will eventually
628 * get inuse, and HEAP_MIN_BLOCK_SIZE for the second free arena that
629 * might get assigned all remaining free space in HEAP_ShrinkBlock() */
630 size += ROUND_SIZE(sizeof(SUBHEAP)) + sizeof(ARENA_INUSE) + HEAP_MIN_BLOCK_SIZE;
631 if (!(subheap = HEAP_CreateSubHeap( heap, NULL, heap->flags, size,
632 max( HEAP_DEF_SIZE, size ) )))
633 return NULL;
634
635 TRACE("created new sub-heap %08lx of %08lx bytes for heap %08lx\n",
636 (DWORD)subheap, size, (DWORD)heap );
637
638 *ppSubHeap = subheap;
639 return (ARENA_FREE *)(subheap + 1);
640 }
641
642
643 /***********************************************************************
644 * HEAP_IsValidArenaPtr
645 *
646 * Check that the pointer is inside the range possible for arenas.
647 */
648 static BOOL HEAP_IsValidArenaPtr( HEAP *heap, void *ptr )
649 {
650 int i;
651 SUBHEAP *subheap = HEAP_FindSubHeap( heap, ptr );
652 if (!subheap) return FALSE;
653 if ((char *)ptr >= (char *)subheap + subheap->headerSize) return TRUE;
654 if (subheap != &heap->subheap) return FALSE;
655 for (i = 0; i < HEAP_NB_FREE_LISTS; i++)
656 if (ptr == (void *)&heap->freeList[i].arena) return TRUE;
657 return FALSE;
658 }
659
660
661 /***********************************************************************
662 * HEAP_ValidateFreeArena
663 */
664 static BOOL HEAP_ValidateFreeArena( SUBHEAP *subheap, ARENA_FREE *pArena )
665 {
666 char *heapEnd = (char *)subheap + subheap->size;
667
668 /* Check for unaligned pointers */
669 if ( (long)pArena % ALIGNMENT != 0 )
670 {
671 ERR( "Heap %08lx: unaligned arena pointer %08lx\n",
672 (DWORD)subheap->heap, (DWORD)pArena );
673 return FALSE;
674 }
675
676 /* Check magic number */
677 if (pArena->magic != ARENA_FREE_MAGIC)
678 {
679 ERR("Heap %08lx: invalid free arena magic for %08lx\n",
680 (DWORD)subheap->heap, (DWORD)pArena );
681 return FALSE;
682 }
683 /* Check size flags */
684 if (!(pArena->size & ARENA_FLAG_FREE) ||
685 (pArena->size & ARENA_FLAG_PREV_FREE))
686 {
687 ERR("Heap %08lx: bad flags %lx for free arena %08lx\n",
688 (DWORD)subheap->heap, pArena->size & ~ARENA_SIZE_MASK, (DWORD)pArena );
689 }
690 /* Check arena size */
691 if ((char *)(pArena + 1) + (pArena->size & ARENA_SIZE_MASK) > heapEnd)
692 {
693 ERR("Heap %08lx: bad size %08lx for free arena %08lx\n",
694 (DWORD)subheap->heap, (DWORD)pArena->size & ARENA_SIZE_MASK, (DWORD)pArena );
695 return FALSE;
696 }
697 /* Check that next pointer is valid */
698 if (!HEAP_IsValidArenaPtr( subheap->heap, pArena->next ))
699 {
700 ERR("Heap %08lx: bad next ptr %08lx for arena %08lx\n",
701 (DWORD)subheap->heap, (DWORD)pArena->next, (DWORD)pArena );
702 return FALSE;
703 }
704 /* Check that next arena is free */
705 if (!(pArena->next->size & ARENA_FLAG_FREE) ||
706 (pArena->next->magic != ARENA_FREE_MAGIC))
707 {
708 ERR("Heap %08lx: next arena %08lx invalid for %08lx\n",
709 (DWORD)subheap->heap, (DWORD)pArena->next, (DWORD)pArena );
710 return FALSE;
711 }
712 /* Check that prev pointer is valid */
713 if (!HEAP_IsValidArenaPtr( subheap->heap, pArena->prev ))
714 {
715 ERR("Heap %08lx: bad prev ptr %08lx for arena %08lx\n",
716 (DWORD)subheap->heap, (DWORD)pArena->prev, (DWORD)pArena );
717 return FALSE;
718 }
719 /* Check that prev arena is free */
720 if (!(pArena->prev->size & ARENA_FLAG_FREE) ||
721 (pArena->prev->magic != ARENA_FREE_MAGIC))
722 {
723 /* this often means that the prev arena got overwritten
724 * by a memory write before that prev arena */
725 ERR("Heap %08lx: prev arena %08lx invalid for %08lx\n",
726 (DWORD)subheap->heap, (DWORD)pArena->prev, (DWORD)pArena );
727 return FALSE;
728 }
729 /* Check that next block has PREV_FREE flag */
730 if ((char *)(pArena + 1) + (pArena->size & ARENA_SIZE_MASK) < heapEnd)
731 {
732 if (!(*(DWORD *)((char *)(pArena + 1) +
733 (pArena->size & ARENA_SIZE_MASK)) & ARENA_FLAG_PREV_FREE))
734 {
735 ERR("Heap %08lx: free arena %08lx next block has no PREV_FREE flag\n",
736 (DWORD)subheap->heap, (DWORD)pArena );
737 return FALSE;
738 }
739 /* Check next block back pointer */
740 if (*((ARENA_FREE **)((char *)(pArena + 1) +
741 (pArena->size & ARENA_SIZE_MASK)) - 1) != pArena)
742 {
743 ERR("Heap %08lx: arena %08lx has wrong back ptr %08lx\n",
744 (DWORD)subheap->heap, (DWORD)pArena,
745 *((DWORD *)((char *)(pArena+1)+ (pArena->size & ARENA_SIZE_MASK)) - 1));
746 return FALSE;
747 }
748 }
749 return TRUE;
750 }
751
752
753 /***********************************************************************
754 * HEAP_ValidateInUseArena
755 */
756 static BOOL HEAP_ValidateInUseArena( SUBHEAP *subheap, ARENA_INUSE *pArena, BOOL quiet )
757 {
758 char *heapEnd = (char *)subheap + subheap->size;
759
760 /* Check for unaligned pointers */
761 if ( (long)pArena % ALIGNMENT != 0 )
762 {
763 if ( quiet == NOISY )
764 {
765 ERR( "Heap %08lx: unaligned arena pointer %08lx\n",
766 (DWORD)subheap->heap, (DWORD)pArena );
767 if ( TRACE_ON(heap) )
768 HEAP_Dump( subheap->heap );
769 }
770 else if ( WARN_ON(heap) )
771 {
772 WARN( "Heap %08lx: unaligned arena pointer %08lx\n",
773 (DWORD)subheap->heap, (DWORD)pArena );
774 if ( TRACE_ON(heap) )
775 HEAP_Dump( subheap->heap );
776 }
777 return FALSE;
778 }
779
780 /* Check magic number */
781 if (pArena->magic != ARENA_INUSE_MAGIC)
782 {
783 if (quiet == NOISY) {
784 ERR("Heap %08lx: invalid in-use arena magic for %08lx\n",
785 (DWORD)subheap->heap, (DWORD)pArena );
786 if (TRACE_ON(heap))
787 HEAP_Dump( subheap->heap );
788 } else if (WARN_ON(heap)) {
789 WARN("Heap %08lx: invalid in-use arena magic for %08lx\n",
790 (DWORD)subheap->heap, (DWORD)pArena );
791 if (TRACE_ON(heap))
792 HEAP_Dump( subheap->heap );
793 }
794 return FALSE;
795 }
796 /* Check size flags */
797 if (pArena->size & ARENA_FLAG_FREE)
798 {
799 ERR("Heap %08lx: bad flags %lx for in-use arena %08lx\n",
800 (DWORD)subheap->heap, pArena->size & ~ARENA_SIZE_MASK, (DWORD)pArena );
801 }
802 /* Check arena size */
803 if ((char *)(pArena + 1) + (pArena->size & ARENA_SIZE_MASK) > heapEnd)
804 {
805 ERR("Heap %08lx: bad size %08lx for in-use arena %08lx\n",
806 (DWORD)subheap->heap, (DWORD)pArena->size & ARENA_SIZE_MASK, (DWORD)pArena );
807 return FALSE;
808 }
809 /* Check next arena PREV_FREE flag */
810 if (((char *)(pArena + 1) + (pArena->size & ARENA_SIZE_MASK) < heapEnd) &&
811 (*(DWORD *)((char *)(pArena + 1) + (pArena->size & ARENA_SIZE_MASK)) & ARENA_FLAG_PREV_FREE))
812 {
813 ERR("Heap %08lx: in-use arena %08lx next block has PREV_FREE flag\n",
814 (DWORD)subheap->heap, (DWORD)pArena );
815 return FALSE;
816 }
817 /* Check prev free arena */
818 if (pArena->size & ARENA_FLAG_PREV_FREE)
819 {
820 ARENA_FREE *pPrev = *((ARENA_FREE **)pArena - 1);
821 /* Check prev pointer */
822 if (!HEAP_IsValidArenaPtr( subheap->heap, pPrev ))
823 {
824 ERR("Heap %08lx: bad back ptr %08lx for arena %08lx\n",
825 (DWORD)subheap->heap, (DWORD)pPrev, (DWORD)pArena );
826 return FALSE;
827 }
828 /* Check that prev arena is free */
829 if (!(pPrev->size & ARENA_FLAG_FREE) ||
830 (pPrev->magic != ARENA_FREE_MAGIC))
831 {
832 ERR("Heap %08lx: prev arena %08lx invalid for in-use %08lx\n",
833 (DWORD)subheap->heap, (DWORD)pPrev, (DWORD)pArena );
834 return FALSE;
835 }
836 /* Check that prev arena is really the previous block */
837 if ((char *)(pPrev + 1) + (pPrev->size & ARENA_SIZE_MASK) != (char *)pArena)
838 {
839 ERR("Heap %08lx: prev arena %08lx is not prev for in-use %08lx\n",
840 (DWORD)subheap->heap, (DWORD)pPrev, (DWORD)pArena );
841 return FALSE;
842 }
843 }
844 return TRUE;
845 }
846
847
848 /***********************************************************************
849 * HEAP_IsRealArena [Internal]
850 * Validates a block is a valid arena.
851 *
852 * RETURNS
853 * TRUE: Success
854 * FALSE: Failure
855 */
856 static BOOL HEAP_IsRealArena( HEAP *heapPtr, /* [in] ptr to the heap */
857 DWORD flags, /* [in] Bit flags that control access during operation */
858 LPCVOID block, /* [in] Optional pointer to memory block to validate */
859 BOOL quiet ) /* [in] Flag - if true, HEAP_ValidateInUseArena
860 * does not complain */
861 {
862 SUBHEAP *subheap;
863 BOOL ret = TRUE;
864
865 if (!heapPtr || (heapPtr->magic != HEAP_MAGIC))
866 {
867 ERR("Invalid heap %p!\n", heapPtr );
868 return FALSE;
869 }
870
871 flags &= HEAP_NO_SERIALIZE;
872 flags |= heapPtr->flags;
873 /* calling HeapLock may result in infinite recursion, so do the critsect directly */
874 if (!(flags & HEAP_NO_SERIALIZE))
875 RtlEnterCriticalSection( &heapPtr->critSection );
876
877 if (block)
878 {
879 /* Only check this single memory block */
880
881 if (!(subheap = HEAP_FindSubHeap( heapPtr, block )) ||
882 ((char *)block < (char *)subheap + subheap->headerSize
883 + sizeof(ARENA_INUSE)))
884 {
885 if (quiet == NOISY)
886 ERR("Heap %p: block %p is not inside heap\n", heapPtr, block );
887 else if (WARN_ON(heap))
888 WARN("Heap %p: block %p is not inside heap\n", heapPtr, block );
889 ret = FALSE;
890 } else
891 ret = HEAP_ValidateInUseArena( subheap, (ARENA_INUSE *)block - 1, quiet );
892
893 if (!(flags & HEAP_NO_SERIALIZE))
894 RtlLeaveCriticalSection( &heapPtr->critSection );
895 return ret;
896 }
897
898 subheap = &heapPtr->subheap;
899 while (subheap && ret)
900 {
901 char *ptr = (char *)subheap + subheap->headerSize;
902 while (ptr < (char *)subheap + subheap->size)
903 {
904 if (*(DWORD *)ptr & ARENA_FLAG_FREE)
905 {
906 if (!HEAP_ValidateFreeArena( subheap, (ARENA_FREE *)ptr )) {
907 ret = FALSE;
908 break;
909 }
910 ptr += sizeof(ARENA_FREE) + (*(DWORD *)ptr & ARENA_SIZE_MASK);
911 }
912 else
913 {
914 if (!HEAP_ValidateInUseArena( subheap, (ARENA_INUSE *)ptr, NOISY )) {
915 ret = FALSE;
916 break;
917 }
918 ptr += sizeof(ARENA_INUSE) + (*(DWORD *)ptr & ARENA_SIZE_MASK);
919 }
920 }
921 subheap = subheap->next;
922 }
923
924 if (!(flags & HEAP_NO_SERIALIZE)) RtlLeaveCriticalSection( &heapPtr->critSection );
925 return ret;
926 }
927
928
929 /***********************************************************************
930 * RtlCreateHeap (NTDLL.@)
931 */
932 HANDLE WINAPI RtlCreateHeap( ULONG flags, PVOID addr, ULONG totalSize, ULONG commitSize,
933 PVOID unknown, PRTL_HEAP_DEFINITION definition )
934 {
935 SUBHEAP *subheap;
936
937 /* Allocate the heap block */
938
939 if (!totalSize)
940 {
941 totalSize = HEAP_DEF_SIZE;
942 flags |= HEAP_GROWABLE;
943 }
944
945 if (!(subheap = HEAP_CreateSubHeap( NULL, addr, flags, commitSize, totalSize ))) return 0;
946
947 /* link it into the per-process heap list */
948 if (processHeap)
949 {
950 HEAP *heapPtr = subheap->heap;
951 RtlLockHeap( processHeap );
952 heapPtr->next = firstHeap;
953 firstHeap = heapPtr;
954 RtlUnlockHeap( processHeap );
955 }
956 else /* assume the first heap we create is the process main heap */
957 {
958 set_process_heap( (HANDLE)subheap->heap );
959 }
960 return (HANDLE)subheap;
961 }
962
963
964 /***********************************************************************
965 * RtlDestroyHeap (NTDLL.@)
966 */
967 HANDLE WINAPI RtlDestroyHeap( HANDLE heap )
968 {
969 HEAP *heapPtr = HEAP_GetPtr( heap );
970 SUBHEAP *subheap;
971
972 TRACE("%08x\n", heap );
973 if (!heapPtr) return heap;
974
975 if (heap == processHeap) return heap; /* cannot delete the main process heap */
976 else /* remove it from the per-process list */
977 {
978 HEAP **pptr;
979 RtlLockHeap( processHeap );
980 pptr = &firstHeap;
981 while (*pptr && *pptr != heapPtr) pptr = &(*pptr)->next;
982 if (*pptr) *pptr = (*pptr)->next;
983 RtlUnlockHeap( processHeap );
984 }
985
986 RtlDeleteCriticalSection( &heapPtr->critSection );
987 subheap = &heapPtr->subheap;
988 while (subheap)
989 {
990 SUBHEAP *next = subheap->next;
991 VirtualFree( subheap, 0, MEM_RELEASE );
992 subheap = next;
993 }
994 return 0;
995 }
996
997
998 /***********************************************************************
999 * RtlAllocateHeap (NTDLL.@)
1000 *
1001 * NOTE: does not set last error.
1002 */
1003 PVOID WINAPI RtlAllocateHeap( HANDLE heap, ULONG flags, ULONG size )
1004 {
1005 ARENA_FREE *pArena;
1006 ARENA_INUSE *pInUse;
1007 SUBHEAP *subheap;
1008 HEAP *heapPtr = HEAP_GetPtr( heap );
1009
1010 /* Validate the parameters */
1011
1012 if (!heapPtr) return NULL;
1013 flags &= HEAP_GENERATE_EXCEPTIONS | HEAP_NO_SERIALIZE | HEAP_ZERO_MEMORY;
1014 flags |= heapPtr->flags;
1015 size = ROUND_SIZE(size);
1016 if (size < HEAP_MIN_BLOCK_SIZE) size = HEAP_MIN_BLOCK_SIZE;
1017
1018 if (!(flags & HEAP_NO_SERIALIZE)) RtlEnterCriticalSection( &heapPtr->critSection );
1019 /* Locate a suitable free block */
1020
1021 if (!(pArena = HEAP_FindFreeBlock( heapPtr, size, &subheap )))
1022 {
1023 TRACE("(%08x,%08lx,%08lx): returning NULL\n",
1024 heap, flags, size );
1025 if (!(flags & HEAP_NO_SERIALIZE)) RtlLeaveCriticalSection( &heapPtr->critSection );
1026 if (flags & HEAP_GENERATE_EXCEPTIONS) RtlRaiseStatus( STATUS_NO_MEMORY );
1027 return NULL;
1028 }
1029
1030 /* Remove the arena from the free list */
1031
1032 pArena->next->prev = pArena->prev;
1033 pArena->prev->next = pArena->next;
1034
1035 /* Build the in-use arena */
1036
1037 pInUse = (ARENA_INUSE *)pArena;
1038
1039 /* in-use arena is smaller than free arena,
1040 * so we have to add the difference to the size */
1041 pInUse->size = (pInUse->size & ~ARENA_FLAG_FREE) + sizeof(ARENA_FREE) - sizeof(ARENA_INUSE);
1042 pInUse->magic = ARENA_INUSE_MAGIC;
1043
1044 /* Shrink the block */
1045
1046 HEAP_ShrinkBlock( subheap, pInUse, size );
1047
1048 if (flags & HEAP_ZERO_MEMORY)
1049 memset( pInUse + 1, 0, pInUse->size & ARENA_SIZE_MASK );
1050 else if (TRACE_ON(heap))
1051 memset( pInUse + 1, ARENA_INUSE_FILLER, pInUse->size & ARENA_SIZE_MASK );
1052
1053 if (!(flags & HEAP_NO_SERIALIZE)) RtlLeaveCriticalSection( &heapPtr->critSection );
1054
1055 TRACE("(%08x,%08lx,%08lx): returning %08lx\n",
1056 heap, flags, size, (DWORD)(pInUse + 1) );
1057 return (LPVOID)(pInUse + 1);
1058 }
1059
1060
1061 /***********************************************************************
1062 * RtlFreeHeap (NTDLL.@)
1063 */
1064 BOOLEAN WINAPI RtlFreeHeap( HANDLE heap, ULONG flags, PVOID ptr )
1065 {
1066 ARENA_INUSE *pInUse;
1067 SUBHEAP *subheap;
1068 HEAP *heapPtr = HEAP_GetPtr( heap );
1069
1070 /* Validate the parameters */
1071
1072 if (!ptr) return TRUE; /* freeing a NULL ptr isn't an error in Win2k */
1073 if (!heapPtr)
1074 {
1075 set_status( STATUS_INVALID_HANDLE );
1076 return FALSE;
1077 }
1078
1079 flags &= HEAP_NO_SERIALIZE;
1080 flags |= heapPtr->flags;
1081 if (!(flags & HEAP_NO_SERIALIZE)) RtlEnterCriticalSection( &heapPtr->critSection );
1082 if (!HEAP_IsRealArena( heapPtr, HEAP_NO_SERIALIZE, ptr, QUIET ))
1083 {
1084 if (!(flags & HEAP_NO_SERIALIZE)) RtlLeaveCriticalSection( &heapPtr->critSection );
1085 set_status( STATUS_INVALID_PARAMETER );
1086 TRACE("(%08x,%08lx,%08lx): returning FALSE\n",
1087 heap, flags, (DWORD)ptr );
1088 return FALSE;
1089 }
1090
1091 /* Turn the block into a free block */
1092
1093 pInUse = (ARENA_INUSE *)ptr - 1;
1094 subheap = HEAP_FindSubHeap( heapPtr, pInUse );
1095 HEAP_MakeInUseBlockFree( subheap, pInUse );
1096
1097 if (!(flags & HEAP_NO_SERIALIZE)) RtlLeaveCriticalSection( &heapPtr->critSection );
1098
1099 TRACE("(%08x,%08lx,%08lx): returning TRUE\n",
1100 heap, flags, (DWORD)ptr );
1101 return TRUE;
1102 }
1103
1104
1105 /***********************************************************************
1106 * RtlReAllocateHeap (NTDLL.@)
1107 */
1108 PVOID WINAPI RtlReAllocateHeap( HANDLE heap, ULONG flags, PVOID ptr, ULONG size )
1109 {
1110 ARENA_INUSE *pArena;
1111 DWORD oldSize;
1112 HEAP *heapPtr;
1113 SUBHEAP *subheap;
1114
1115 if (!ptr) return RtlAllocateHeap( heap, flags, size ); /* FIXME: correct? */
1116 if (!(heapPtr = HEAP_GetPtr( heap )))
1117 {
1118 set_status( STATUS_INVALID_HANDLE );
1119 return FALSE;
1120 }
1121
1122 /* Validate the parameters */
1123
1124 flags &= HEAP_GENERATE_EXCEPTIONS | HEAP_NO_SERIALIZE | HEAP_ZERO_MEMORY |
1125 HEAP_REALLOC_IN_PLACE_ONLY;
1126 flags |= heapPtr->flags;
1127 size = ROUND_SIZE(size);
1128 if (size < HEAP_MIN_BLOCK_SIZE) size = HEAP_MIN_BLOCK_SIZE;
1129
1130 if (!(flags & HEAP_NO_SERIALIZE)) RtlEnterCriticalSection( &heapPtr->critSection );
1131 if (!HEAP_IsRealArena( heapPtr, HEAP_NO_SERIALIZE, ptr, QUIET ))
1132 {
1133 if (!(flags & HEAP_NO_SERIALIZE)) RtlLeaveCriticalSection( &heapPtr->critSection );
1134 set_status( STATUS_INVALID_PARAMETER );
1135 TRACE("(%08x,%08lx,%08lx,%08lx): returning NULL\n",
1136 heap, flags, (DWORD)ptr, size );
1137 return NULL;
1138 }
1139
1140 /* Check if we need to grow the block */
1141
1142 pArena = (ARENA_INUSE *)ptr - 1;
1143 subheap = HEAP_FindSubHeap( heapPtr, pArena );
1144 oldSize = (pArena->size & ARENA_SIZE_MASK);
1145 if (size > oldSize)
1146 {
1147 char *pNext = (char *)(pArena + 1) + oldSize;
1148 if ((pNext < (char *)subheap + subheap->size) &&
1149 (*(DWORD *)pNext & ARENA_FLAG_FREE) &&
1150 (oldSize + (*(DWORD *)pNext & ARENA_SIZE_MASK) + sizeof(ARENA_FREE) >= size))
1151 {
1152 /* The next block is free and large enough */
1153 ARENA_FREE *pFree = (ARENA_FREE *)pNext;
1154 pFree->next->prev = pFree->prev;
1155 pFree->prev->next = pFree->next;
1156 pArena->size += (pFree->size & ARENA_SIZE_MASK) + sizeof(*pFree);
1157 if (!HEAP_Commit( subheap, (char *)pArena + sizeof(ARENA_INUSE)
1158 + size + HEAP_MIN_BLOCK_SIZE))
1159 {
1160 if (!(flags & HEAP_NO_SERIALIZE)) RtlLeaveCriticalSection( &heapPtr->critSection );
1161 if (flags & HEAP_GENERATE_EXCEPTIONS) RtlRaiseStatus( STATUS_NO_MEMORY );
1162 set_status( STATUS_NO_MEMORY );
1163 return NULL;
1164 }
1165 HEAP_ShrinkBlock( subheap, pArena, size );
1166 }
1167 else /* Do it the hard way */
1168 {
1169 ARENA_FREE *pNew;
1170 ARENA_INUSE *pInUse;
1171 SUBHEAP *newsubheap;
1172
1173 if ((flags & HEAP_REALLOC_IN_PLACE_ONLY) ||
1174 !(pNew = HEAP_FindFreeBlock( heapPtr, size, &newsubheap )))
1175 {
1176 if (!(flags & HEAP_NO_SERIALIZE)) RtlLeaveCriticalSection( &heapPtr->critSection );
1177 if (flags & HEAP_GENERATE_EXCEPTIONS) RtlRaiseStatus( STATUS_NO_MEMORY );
1178 set_status( STATUS_NO_MEMORY );
1179 return NULL;
1180 }
1181
1182 /* Build the in-use arena */
1183
1184 pNew->next->prev = pNew->prev;
1185 pNew->prev->next = pNew->next;
1186 pInUse = (ARENA_INUSE *)pNew;
1187 pInUse->size = (pInUse->size & ~ARENA_FLAG_FREE)
1188 + sizeof(ARENA_FREE) - sizeof(ARENA_INUSE);
1189 pInUse->magic = ARENA_INUSE_MAGIC;
1190 HEAP_ShrinkBlock( newsubheap, pInUse, size );
1191 memcpy( pInUse + 1, pArena + 1, oldSize );
1192
1193 /* Free the previous block */
1194
1195 HEAP_MakeInUseBlockFree( subheap, pArena );
1196 subheap = newsubheap;
1197 pArena = pInUse;
1198 }
1199 }
1200 else HEAP_ShrinkBlock( subheap, pArena, size ); /* Shrink the block */
1201
1202 /* Clear the extra bytes if needed */
1203
1204 if (size > oldSize)
1205 {
1206 if (flags & HEAP_ZERO_MEMORY)
1207 memset( (char *)(pArena + 1) + oldSize, 0,
1208 (pArena->size & ARENA_SIZE_MASK) - oldSize );
1209 else if (TRACE_ON(heap))
1210 memset( (char *)(pArena + 1) + oldSize, ARENA_INUSE_FILLER,
1211 (pArena->size & ARENA_SIZE_MASK) - oldSize );
1212 }
1213
1214 /* Return the new arena */
1215
1216 if (!(flags & HEAP_NO_SERIALIZE)) RtlLeaveCriticalSection( &heapPtr->critSection );
1217
1218 TRACE("(%08x,%08lx,%08lx,%08lx): returning %08lx\n",
1219 heap, flags, (DWORD)ptr, size, (DWORD)(pArena + 1) );
1220 return (LPVOID)(pArena + 1);
1221 }
1222
1223
1224 /***********************************************************************
1225 * RtlCompactHeap (NTDLL.@)
1226 */
1227 ULONG WINAPI RtlCompactHeap( HANDLE heap, ULONG flags )
1228 {
1229 FIXME( "stub\n" );
1230 return 0;
1231 }
1232
1233
1234 /***********************************************************************
1235 * RtlLockHeap (NTDLL.@)
1236 */
1237 BOOLEAN WINAPI RtlLockHeap( HANDLE heap )
1238 {
1239 HEAP *heapPtr = HEAP_GetPtr( heap );
1240 if (!heapPtr) return FALSE;
1241 RtlEnterCriticalSection( &heapPtr->critSection );
1242 return TRUE;
1243 }
1244
1245
1246 /***********************************************************************
1247 * RtlUnlockHeap (NTDLL.@)
1248 */
1249 BOOLEAN WINAPI RtlUnlockHeap( HANDLE heap )
1250 {
1251 HEAP *heapPtr = HEAP_GetPtr( heap );
1252 if (!heapPtr) return FALSE;
1253 RtlLeaveCriticalSection( &heapPtr->critSection );
1254 return TRUE;
1255 }
1256
1257
1258 /***********************************************************************
1259 * RtlSizeHeap (NTDLL.@)
1260 */
1261 ULONG WINAPI RtlSizeHeap( HANDLE heap, ULONG flags, PVOID ptr )
1262 {
1263 DWORD ret;
1264 HEAP *heapPtr = HEAP_GetPtr( heap );
1265
1266 if (!heapPtr)
1267 {
1268 set_status( STATUS_INVALID_HANDLE );
1269 return (ULONG)-1;
1270 }
1271 flags &= HEAP_NO_SERIALIZE;
1272 flags |= heapPtr->flags;
1273 if (!(flags & HEAP_NO_SERIALIZE)) RtlEnterCriticalSection( &heapPtr->critSection );
1274 if (!HEAP_IsRealArena( heapPtr, HEAP_NO_SERIALIZE, ptr, QUIET ))
1275 {
1276 set_status( STATUS_INVALID_PARAMETER );
1277 ret = (ULONG)-1;
1278 }
1279 else
1280 {
1281 ARENA_INUSE *pArena = (ARENA_INUSE *)ptr - 1;
1282 ret = pArena->size & ARENA_SIZE_MASK;
1283 }
1284 if (!(flags & HEAP_NO_SERIALIZE)) RtlLeaveCriticalSection( &heapPtr->critSection );
1285
1286 TRACE("(%08x,%08lx,%08lx): returning %08lx\n",
1287 heap, flags, (DWORD)ptr, ret );
1288 return ret;
1289 }
1290
1291
1292 /***********************************************************************
1293 * RtlValidateHeap (NTDLL.@)
1294 */
1295 BOOLEAN WINAPI RtlValidateHeap( HANDLE heap, ULONG flags, PCVOID block )
1296 {
1297 HEAP *heapPtr = HEAP_GetPtr( heap );
1298 if (!heapPtr) return FALSE;
1299 return HEAP_IsRealArena( heapPtr, flags, block, QUIET );
1300 }
1301
1302
1303 /***********************************************************************
1304 * RtlWalkHeap (NTDLL.@)
1305 *
1306 * FIXME: the PROCESS_HEAP_ENTRY flag values seem different between this
1307 * function and HeapWalk. To be checked.
1308 */
1309 NTSTATUS WINAPI RtlWalkHeap( HANDLE heap, PVOID entry_ptr )
1310 {
1311 LPPROCESS_HEAP_ENTRY entry = entry_ptr; /* FIXME */
1312 HEAP *heapPtr = HEAP_GetPtr(heap);
1313 SUBHEAP *sub, *currentheap = NULL;
1314 NTSTATUS ret;
1315 char *ptr;
1316 int region_index = 0;
1317
1318 FIXME( "not fully compatible\n" );
1319
1320 if (!heapPtr || !entry) return STATUS_INVALID_PARAMETER;
1321
1322 if (!(heapPtr->flags & HEAP_NO_SERIALIZE)) RtlEnterCriticalSection( &heapPtr->critSection );
1323
1324 /* set ptr to the next arena to be examined */
1325
1326 if (!entry->lpData) /* first call (init) ? */
1327 {
1328 TRACE("begin walking of heap 0x%08x.\n", heap);
1329 currentheap = &heapPtr->subheap;
1330 ptr = (char*)currentheap + currentheap->headerSize;
1331 }
1332 else
1333 {
1334 ptr = entry->lpData;
1335 sub = &heapPtr->subheap;
1336 while (sub)
1337 {
1338 if (((char *)ptr >= (char *)sub) &&
1339 ((char *)ptr < (char *)sub + sub->size))
1340 {
1341 currentheap = sub;
1342 break;
1343 }
1344 sub = sub->next;
1345 region_index++;
1346 }
1347 if (currentheap == NULL)
1348 {
1349 ERR("no matching subheap found, shouldn't happen !\n");
1350 ret = STATUS_NO_MORE_ENTRIES;
1351 goto HW_end;
1352 }
1353
1354 ptr += entry->cbData; /* point to next arena */
1355 if (ptr > (char *)currentheap + currentheap->size - 1)
1356 { /* proceed with next subheap */
1357 if (!(currentheap = currentheap->next))
1358 { /* successfully finished */
1359 TRACE("end reached.\n");
1360 ret = STATUS_NO_MORE_ENTRIES;
1361 goto HW_end;
1362 }
1363 ptr = (char*)currentheap + currentheap->headerSize;
1364 }
1365 }
1366
1367 entry->wFlags = 0;
1368 if (*(DWORD *)ptr & ARENA_FLAG_FREE)
1369 {
1370 ARENA_FREE *pArena = (ARENA_FREE *)ptr;
1371
1372 /*TRACE("free, magic: %04x\n", pArena->magic);*/
1373
1374 entry->lpData = pArena + 1;
1375 entry->cbData = pArena->size & ARENA_SIZE_MASK;
1376 entry->cbOverhead = sizeof(ARENA_FREE);
1377 entry->wFlags = PROCESS_HEAP_UNCOMMITTED_RANGE;
1378 }
1379 else
1380 {
1381 ARENA_INUSE *pArena = (ARENA_INUSE *)ptr;
1382
1383 /*TRACE("busy, magic: %04x\n", pArena->magic);*/
1384
1385 entry->lpData = pArena + 1;
1386 entry->cbData = pArena->size & ARENA_SIZE_MASK;
1387 entry->cbOverhead = sizeof(ARENA_INUSE);
1388 entry->wFlags = PROCESS_HEAP_ENTRY_BUSY;
1389 /* FIXME: can't handle PROCESS_HEAP_ENTRY_MOVEABLE
1390 and PROCESS_HEAP_ENTRY_DDESHARE yet */
1391 }
1392
1393 entry->iRegionIndex = region_index;
1394
1395 /* first element of heap ? */
1396 if (ptr == (char *)(currentheap + currentheap->headerSize))
1397 {
1398 entry->wFlags |= PROCESS_HEAP_REGION;
1399 entry->u.Region.dwCommittedSize = currentheap->commitSize;
1400 entry->u.Region.dwUnCommittedSize =
1401 currentheap->size - currentheap->commitSize;
1402 entry->u.Region.lpFirstBlock = /* first valid block */
1403 currentheap + currentheap->headerSize;
1404 entry->u.Region.lpLastBlock = /* first invalid block */
1405 currentheap + currentheap->size;
1406 }
1407 ret = STATUS_SUCCESS;
1408
1409 HW_end:
1410 if (!(heapPtr->flags & HEAP_NO_SERIALIZE)) RtlLeaveCriticalSection( &heapPtr->critSection );
1411 return ret;
1412 }
1413
1414
1415 /***********************************************************************
1416 * RtlGetProcessHeaps (NTDLL.@)
1417 */
1418 ULONG WINAPI RtlGetProcessHeaps( ULONG count, HANDLE *heaps )
1419 {
1420 DWORD total;
1421 HEAP *ptr;
1422
1423 if (!processHeap) return 0; /* should never happen */
1424 total = 1; /* main heap */
1425 RtlLockHeap( processHeap );
1426 for (ptr = firstHeap; ptr; ptr = ptr->next) total++;
1427 if (total <= count)
1428 {
1429 *heaps++ = (HANDLE)processHeap;
1430 for (ptr = firstHeap; ptr; ptr = ptr->next) *heaps++ = (HANDLE)ptr;
1431 }
1432 RtlUnlockHeap( processHeap );
1433 return total;
1434 }
widl and rpcrt4 development