Fixed a bug in RtlDestroyHeap, that will cause a page fault, if more than one subheap...
[reactos.git] / reactos / lib / ntdll / rtl / heap.c
1 /*
2 * Win32 heap functions
3 *
4 * Copyright 1996 Alexandre Julliard
5 * Copyright 1998 Ulrich Weigand
6 */
7
8
9 /* Note: the heap data structures are based on what Pietrek describes in his
10 * book 'Windows 95 System Programming Secrets'. The layout is not exactly
11 * the same, but could be easily adapted if it turns out some programs
12 * require it.
13 */
14
15 #include <string.h>
16 #include <ddk/ntddk.h>
17 #include <ntdll/rtl.h>
18 #include <ntos/heap.h>
19 #include <ntos/minmax.h>
20
21 #define NDEBUG
22 #include <ntdll/ntdll.h>
23
24 #define DPRINTF DPRINT
25 #define ERR DPRINT
26 #define SetLastError(x)
27 #define WARN DPRINT
28 #define TRACE DPRINT
29 #define WARN_ON(x) (1)
30
31 #undef assert
32 #ifdef NDEBUG
33 #define TRACE_ON(x) (0)
34 #define assert(x)
35 #else
36 #define TRACE_ON(x) (1)
37 #define assert(x)
38 #endif
39
40
41 static CRITICAL_SECTION RtlpProcessHeapsListLock;
42
43
44 typedef struct tagARENA_INUSE
45 {
46 DWORD size; /* Block size; must be the first field */
47 WORD threadId; /* Allocating thread id */
48 WORD magic; /* Magic number */
49 void *callerEIP; /* EIP of caller upon allocation */
50 } ARENA_INUSE;
51
52 typedef struct tagARENA_FREE
53 {
54 DWORD size; /* Block size; must be the first field */
55 WORD threadId; /* Freeing thread id */
56 WORD magic; /* Magic number */
57 struct tagARENA_FREE *next; /* Next free arena */
58 struct tagARENA_FREE *prev; /* Prev free arena */
59 } ARENA_FREE;
60
61 #define ARENA_FLAG_FREE 0x00000001 /* flags OR'ed with arena size */
62 #define ARENA_FLAG_PREV_FREE 0x00000002
63 #define ARENA_SIZE_MASK 0xfffffffc
64 #define ARENA_INUSE_MAGIC 0x4842 /* Value for arena 'magic' field */
65 #define ARENA_FREE_MAGIC 0x4846 /* Value for arena 'magic' field */
66
67 #define ARENA_INUSE_FILLER 0x55
68 #define ARENA_FREE_FILLER 0xaa
69
70 #define QUIET 1 /* Suppress messages */
71 #define NOISY 0 /* Report all errors */
72
73 #define HEAP_NB_FREE_LISTS 4 /* Number of free lists */
74
75 /* Max size of the blocks on the free lists */
76 static const DWORD HEAP_freeListSizes[HEAP_NB_FREE_LISTS] =
77 {
78 0x20, 0x80, 0x200, 0xffffffff
79 };
80
81 typedef struct
82 {
83 DWORD size;
84 ARENA_FREE arena;
85 } FREE_LIST_ENTRY;
86
87 struct tagHEAP;
88
89 typedef struct tagSUBHEAP
90 {
91 DWORD size; /* Size of the whole sub-heap */
92 DWORD commitSize; /* Committed size of the sub-heap */
93 DWORD headerSize; /* Size of the heap header */
94 struct tagSUBHEAP *next; /* Next sub-heap */
95 struct tagHEAP *heap; /* Main heap structure */
96 DWORD magic; /* Magic number */
97 WORD selector; /* Selector for HEAP_WINE_SEGPTR heaps */
98 } SUBHEAP, *PSUBHEAP;
99
100 #define SUBHEAP_MAGIC ((DWORD)('S' | ('U'<<8) | ('B'<<16) | ('H'<<24)))
101
102 typedef struct tagHEAP
103 {
104 SUBHEAP subheap; /* First sub-heap */
105 struct tagHEAP *next; /* Next heap for this process */
106 FREE_LIST_ENTRY freeList[HEAP_NB_FREE_LISTS]; /* Free lists */
107 CRITICAL_SECTION critSection; /* Critical section for serialization */
108 DWORD flags; /* Heap flags */
109 DWORD magic; /* Magic number */
110 void *private; /* Private pointer for the user of the heap */
111 } HEAP, *PHEAP;
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
120 static BOOL HEAP_IsRealArena( HANDLE heap, DWORD flags, LPCVOID block, BOOL quiet );
121
122 #ifdef __GNUC__
123 #define GET_EIP() (__builtin_return_address(0))
124 #define SET_EIP(ptr) ((ARENA_INUSE*)(ptr) - 1)->callerEIP = GET_EIP()
125 #else
126 #define GET_EIP() 0
127 #define SET_EIP(ptr) /* nothing */
128 #endif /* __GNUC__ */
129
130
131 /***********************************************************************
132 * HEAP_Dump
133 */
134 void
135 HEAP_Dump(PHEAP heap)
136 {
137 int i;
138 SUBHEAP *subheap;
139 char *ptr;
140
141 DPRINTF( "Heap: %08lx\n", (DWORD)heap );
142 DPRINTF( "Next: %08lx Sub-heaps: %08lx",
143 (DWORD)heap->next, (DWORD)&heap->subheap );
144 subheap = &heap->subheap;
145 while (subheap->next)
146 {
147 DPRINTF( " -> %08lx", (DWORD)subheap->next );
148 subheap = subheap->next;
149 }
150
151 DPRINTF( "\nFree lists:\n Block Stat Size Id\n" );
152 for (i = 0; i < HEAP_NB_FREE_LISTS; i++)
153 DPRINTF( "%08lx free %08lx %04x prev=%08lx next=%08lx\n",
154 (DWORD)&heap->freeList[i].arena, heap->freeList[i].arena.size,
155 heap->freeList[i].arena.threadId,
156 (DWORD)heap->freeList[i].arena.prev,
157 (DWORD)heap->freeList[i].arena.next );
158
159 subheap = &heap->subheap;
160 while (subheap)
161 {
162 DWORD freeSize = 0, usedSize = 0, arenaSize = subheap->headerSize;
163 DPRINTF( "\n\nSub-heap %08lx: size=%08lx committed=%08lx\n",
164 (DWORD)subheap, subheap->size, subheap->commitSize );
165
166 DPRINTF( "\n Block Stat Size Id\n" );
167 ptr = (char*)subheap + subheap->headerSize;
168 while (ptr < (char *)subheap + subheap->size)
169 {
170 if (*(DWORD *)ptr & ARENA_FLAG_FREE)
171 {
172 ARENA_FREE *pArena = (ARENA_FREE *)ptr;
173 DPRINTF( "%08lx free %08lx %04x prev=%08lx next=%08lx\n",
174 (DWORD)pArena, pArena->size & ARENA_SIZE_MASK,
175 pArena->threadId, (DWORD)pArena->prev,
176 (DWORD)pArena->next);
177 ptr += sizeof(*pArena) + (pArena->size & ARENA_SIZE_MASK);
178 arenaSize += sizeof(ARENA_FREE);
179 freeSize += pArena->size & ARENA_SIZE_MASK;
180 }
181 else if (*(DWORD *)ptr & ARENA_FLAG_PREV_FREE)
182 {
183 ARENA_INUSE *pArena = (ARENA_INUSE *)ptr;
184 DPRINTF( "%08lx Used %08lx %04x back=%08lx EIP=%p\n",
185 (DWORD)pArena, pArena->size & ARENA_SIZE_MASK,
186 pArena->threadId, *((DWORD *)pArena - 1),
187 pArena->callerEIP );
188 ptr += sizeof(*pArena) + (pArena->size & ARENA_SIZE_MASK);
189 arenaSize += sizeof(ARENA_INUSE);
190 usedSize += pArena->size & ARENA_SIZE_MASK;
191 }
192 else
193 {
194 ARENA_INUSE *pArena = (ARENA_INUSE *)ptr;
195 DPRINTF( "%08lx used %08lx %04x EIP=%p\n",
196 (DWORD)pArena, pArena->size & ARENA_SIZE_MASK,
197 pArena->threadId, pArena->callerEIP );
198 ptr += sizeof(*pArena) + (pArena->size & ARENA_SIZE_MASK);
199 arenaSize += sizeof(ARENA_INUSE);
200 usedSize += pArena->size & ARENA_SIZE_MASK;
201 }
202 }
203 DPRINTF( "\nTotal: Size=%08lx Committed=%08lx Free=%08lx Used=%08lx Arenas=%08lx (%ld%%)\n\n",
204 subheap->size, subheap->commitSize, freeSize, usedSize,
205 arenaSize, (arenaSize * 100) / subheap->size );
206 subheap = subheap->next;
207 }
208 }
209
210
211 /***********************************************************************
212 * HEAP_GetPtr
213 * RETURNS
214 * Pointer to the heap
215 * NULL: Failure
216 */
217 static PHEAP
218 HEAP_GetPtr(HANDLE heap) /* [in] Handle to the heap */
219 {
220 HEAP *heapPtr = (HEAP *)heap;
221 if (!heapPtr || (heapPtr->magic != HEAP_MAGIC))
222 {
223 ERR("Invalid heap %08x!\n", heap );
224 return NULL;
225 }
226 if (TRACE_ON(heap) && !HEAP_IsRealArena( heap, 0, NULL, NOISY ))
227 {
228 HEAP_Dump( heapPtr );
229 assert( FALSE );
230 return NULL;
231 }
232 return heapPtr;
233 }
234
235
236 /***********************************************************************
237 * HEAP_InsertFreeBlock
238 *
239 * Insert a free block into the free list.
240 */
241 static VOID
242 HEAP_InsertFreeBlock(PHEAP heap,
243 ARENA_FREE *pArena)
244 {
245 FREE_LIST_ENTRY *pEntry = heap->freeList;
246 while (pEntry->size < pArena->size) pEntry++;
247 pArena->size |= ARENA_FLAG_FREE;
248 pArena->next = pEntry->arena.next;
249 pArena->next->prev = pArena;
250 pArena->prev = &pEntry->arena;
251 pEntry->arena.next = pArena;
252 }
253
254
255 /***********************************************************************
256 * HEAP_FindSubHeap
257 * Find the sub-heap containing a given address.
258 *
259 * RETURNS
260 * Pointer: Success
261 * NULL: Failure
262 */
263 static PSUBHEAP
264 HEAP_FindSubHeap(HEAP *heap, /* [in] Heap pointer */
265 LPCVOID ptr) /* [in] Address */
266 {
267 SUBHEAP *sub = &heap->subheap;
268 while (sub)
269 {
270 if (((char *)ptr >= (char *)sub) &&
271 ((char *)ptr < (char *)sub + sub->size)) return sub;
272 sub = sub->next;
273 }
274 return NULL;
275 }
276
277
278 /***********************************************************************
279 * HEAP_Commit
280 *
281 * Make sure the heap storage is committed up to (not including) ptr.
282 */
283 static inline BOOL
284 HEAP_Commit(SUBHEAP *subheap,
285 void *ptr,
286 DWORD flags)
287 {
288 DWORD size = (DWORD)((char *)ptr - (char *)subheap);
289 NTSTATUS Status;
290 PVOID address;
291 ULONG commitsize;
292
293 size = (size + COMMIT_MASK) & ~COMMIT_MASK;
294 if (size > subheap->size) size = subheap->size;
295 if (size <= subheap->commitSize) return TRUE;
296
297 address = (PVOID)((char *)subheap + subheap->commitSize);
298 commitsize = size - subheap->commitSize;
299
300 if (!(flags & HEAP_NO_VALLOC))
301 {
302 Status = NtAllocateVirtualMemory(NtCurrentProcess(),
303 &address,
304 0,
305 &commitsize,
306 MEM_COMMIT,
307 PAGE_EXECUTE_READWRITE);
308 if (!NT_SUCCESS(Status))
309 {
310 WARN("Could not commit %08lx bytes at %08lx for heap %08lx\n",
311 size - subheap->commitSize,
312 (DWORD)((char *)subheap + subheap->commitSize),
313 (DWORD)subheap->heap );
314 return FALSE;
315 }
316 }
317 subheap->commitSize = size;
318 return TRUE;
319 }
320
321
322 /***********************************************************************
323 * HEAP_Decommit
324 *
325 * If possible, decommit the heap storage from (including) 'ptr'.
326 */
327 static inline BOOL HEAP_Decommit( SUBHEAP *subheap, void *ptr, DWORD flags )
328 {
329 DWORD size = (DWORD)((char *)ptr - (char *)subheap);
330 PVOID address;
331 ULONG decommitsize;
332 NTSTATUS Status;
333 /* round to next block and add one full block */
334 size = ((size + COMMIT_MASK) & ~COMMIT_MASK) + COMMIT_MASK + 1;
335 if (size >= subheap->commitSize) return TRUE;
336
337 address = (PVOID)((char *)subheap + size);
338 decommitsize = subheap->commitSize - size;
339
340 if (!(flags & HEAP_NO_VALLOC))
341 {
342 Status = ZwFreeVirtualMemory(NtCurrentProcess(),
343 &address,
344 &decommitsize,
345 MEM_DECOMMIT);
346 if (!NT_SUCCESS(Status));
347 {
348 WARN("Could not decommit %08lx bytes at %08lx for heap %08lx\n",
349 subheap->commitSize - size,
350 (DWORD)((char *)subheap + size),
351 (DWORD)subheap->heap );
352 return FALSE;
353 }
354 }
355 subheap->commitSize = size;
356 return TRUE;
357 }
358
359
360 /***********************************************************************
361 * HEAP_CreateFreeBlock
362 *
363 * Create a free block at a specified address. 'size' is the size of the
364 * whole block, including the new arena.
365 */
366 static void HEAP_CreateFreeBlock( SUBHEAP *subheap, void *ptr, DWORD size )
367 {
368 ARENA_FREE *pFree;
369
370 /* Create a free arena */
371
372 pFree = (ARENA_FREE *)ptr;
373 pFree->threadId = (DWORD)NtCurrentTeb()->Cid.UniqueThread;
374 pFree->magic = ARENA_FREE_MAGIC;
375
376 /* If debugging, erase the freed block content */
377
378 if (TRACE_ON(heap))
379 {
380 char *pEnd = (char *)ptr + size;
381 if (pEnd > (char *)subheap + subheap->commitSize)
382 pEnd = (char *)subheap + subheap->commitSize;
383 if (pEnd > (char *)(pFree + 1))
384 memset( pFree + 1, ARENA_FREE_FILLER, pEnd - (char *)(pFree + 1) );
385 }
386
387 /* Check if next block is free also */
388
389 if (((char *)ptr + size < (char *)subheap + subheap->size) &&
390 (*(DWORD *)((char *)ptr + size) & ARENA_FLAG_FREE))
391 {
392 /* Remove the next arena from the free list */
393 ARENA_FREE *pNext = (ARENA_FREE *)((char *)ptr + size);
394 pNext->next->prev = pNext->prev;
395 pNext->prev->next = pNext->next;
396 size += (pNext->size & ARENA_SIZE_MASK) + sizeof(*pNext);
397 if (TRACE_ON(heap))
398 memset( pNext, ARENA_FREE_FILLER, sizeof(ARENA_FREE) );
399 }
400
401 /* Set the next block PREV_FREE flag and pointer */
402
403 if ((char *)ptr + size < (char *)subheap + subheap->size)
404 {
405 DWORD *pNext = (DWORD *)((char *)ptr + size);
406 *pNext |= ARENA_FLAG_PREV_FREE;
407 *(ARENA_FREE **)(pNext - 1) = pFree;
408 }
409
410 /* Last, insert the new block into the free list */
411
412 pFree->size = size - sizeof(*pFree);
413 HEAP_InsertFreeBlock( subheap->heap, pFree );
414 }
415
416
417 /***********************************************************************
418 * HEAP_MakeInUseBlockFree
419 *
420 * Turn an in-use block into a free block. Can also decommit the end of
421 * the heap, and possibly even free the sub-heap altogether.
422 */
423 static void HEAP_MakeInUseBlockFree( SUBHEAP *subheap, ARENA_INUSE *pArena,
424 DWORD flags)
425 {
426 ARENA_FREE *pFree;
427 DWORD size = (pArena->size & ARENA_SIZE_MASK) + sizeof(*pArena);
428
429 /* Check if we can merge with previous block */
430
431 if (pArena->size & ARENA_FLAG_PREV_FREE)
432 {
433 pFree = *((ARENA_FREE **)pArena - 1);
434 size += (pFree->size & ARENA_SIZE_MASK) + sizeof(ARENA_FREE);
435 /* Remove it from the free list */
436 pFree->next->prev = pFree->prev;
437 pFree->prev->next = pFree->next;
438 }
439 else pFree = (ARENA_FREE *)pArena;
440
441 /* Create a free block */
442
443 HEAP_CreateFreeBlock( subheap, pFree, size );
444 size = (pFree->size & ARENA_SIZE_MASK) + sizeof(ARENA_FREE);
445 if ((char *)pFree + size < (char *)subheap + subheap->size)
446 return; /* Not the last block, so nothing more to do */
447
448 /* Free the whole sub-heap if it's empty and not the original one */
449
450 if (((char *)pFree == (char *)subheap + subheap->headerSize) &&
451 (subheap != &subheap->heap->subheap))
452 {
453 SUBHEAP *pPrev = &subheap->heap->subheap;
454 /* Remove the free block from the list */
455 pFree->next->prev = pFree->prev;
456 pFree->prev->next = pFree->next;
457 /* Remove the subheap from the list */
458 while (pPrev && (pPrev->next != subheap)) pPrev = pPrev->next;
459 if (pPrev) pPrev->next = subheap->next;
460 /* Free the memory */
461 subheap->magic = 0;
462 if (!(flags & HEAP_NO_VALLOC))
463 {
464 ULONG dummySize = 0;
465 ZwFreeVirtualMemory(NtCurrentProcess(),
466 (PVOID*)&subheap,
467 &dummySize,
468 MEM_RELEASE);
469 }
470 return;
471 }
472
473 /* Decommit the end of the heap */
474 }
475
476
477 /***********************************************************************
478 * HEAP_ShrinkBlock
479 *
480 * Shrink an in-use block.
481 */
482 static void HEAP_ShrinkBlock(SUBHEAP *subheap, ARENA_INUSE *pArena, DWORD size)
483 {
484 if ((pArena->size & ARENA_SIZE_MASK) >= size + HEAP_MIN_BLOCK_SIZE)
485 {
486 HEAP_CreateFreeBlock( subheap, (char *)(pArena + 1) + size,
487 (pArena->size & ARENA_SIZE_MASK) - size );
488 pArena->size = (pArena->size & ~ARENA_SIZE_MASK) | size;
489 }
490 else
491 {
492 /* Turn off PREV_FREE flag in next block */
493 char *pNext = (char *)(pArena + 1) + (pArena->size & ARENA_SIZE_MASK);
494 if (pNext < (char *)subheap + subheap->size)
495 *(DWORD *)pNext &= ~ARENA_FLAG_PREV_FREE;
496 }
497 }
498
499 /***********************************************************************
500 * HEAP_InitSubHeap
501 */
502 static BOOL HEAP_InitSubHeap( HEAP *heap, LPVOID address, DWORD flags,
503 DWORD commitSize, DWORD totalSize )
504 {
505 SUBHEAP *subheap = (SUBHEAP *)address;
506 WORD selector = 0;
507 FREE_LIST_ENTRY *pEntry;
508 int i;
509 NTSTATUS Status;
510
511 /* Commit memory */
512 if (!(flags & HEAP_NO_VALLOC))
513 {
514 Status = ZwAllocateVirtualMemory(NtCurrentProcess(),
515 &address,
516 0,
517 (PULONG)&commitSize,
518 MEM_COMMIT,
519 PAGE_EXECUTE_READWRITE);
520 if (!NT_SUCCESS(Status))
521 {
522 WARN("Could not commit %08lx bytes for sub-heap %08lx\n",
523 commitSize, (DWORD)address );
524 return FALSE;
525 }
526 }
527
528 /* Fill the sub-heap structure */
529
530 subheap->heap = heap;
531 subheap->selector = selector;
532 subheap->size = totalSize;
533 subheap->commitSize = commitSize;
534 subheap->magic = SUBHEAP_MAGIC;
535
536 if ( subheap != (SUBHEAP *)heap )
537 {
538 /* If this is a secondary subheap, insert it into list */
539
540 subheap->headerSize = sizeof(SUBHEAP);
541 subheap->next = heap->subheap.next;
542 heap->subheap.next = subheap;
543 }
544 else
545 {
546 /* If this is a primary subheap, initialize main heap */
547
548 subheap->headerSize = sizeof(HEAP);
549 subheap->next = NULL;
550 heap->next = NULL;
551 heap->flags = flags;
552 heap->magic = HEAP_MAGIC;
553
554 /* Build the free lists */
555
556 for (i = 0, pEntry = heap->freeList; i < HEAP_NB_FREE_LISTS; i++, pEntry++)
557 {
558 pEntry->size = HEAP_freeListSizes[i];
559 pEntry->arena.size = 0 | ARENA_FLAG_FREE;
560 pEntry->arena.next = i < HEAP_NB_FREE_LISTS-1 ?
561 &heap->freeList[i+1].arena : &heap->freeList[0].arena;
562 pEntry->arena.prev = i ? &heap->freeList[i-1].arena :
563 &heap->freeList[HEAP_NB_FREE_LISTS-1].arena;
564 pEntry->arena.threadId = 0;
565 pEntry->arena.magic = ARENA_FREE_MAGIC;
566 }
567
568 /* Initialize critical section */
569
570 RtlInitializeCriticalSection( &heap->critSection );
571 }
572
573 /* Create the first free block */
574
575 HEAP_CreateFreeBlock( subheap, (LPBYTE)subheap + subheap->headerSize,
576 subheap->size - subheap->headerSize );
577
578 return TRUE;
579 }
580
581 /***********************************************************************
582 * HEAP_CreateSubHeap
583 *
584 * Create a sub-heap of the given size.
585 * If heap == NULL, creates a main heap.
586 */
587 static SUBHEAP *HEAP_CreateSubHeap(PVOID BaseAddress,
588 HEAP *heap, DWORD flags,
589 DWORD commitSize, DWORD totalSize )
590 {
591 LPVOID address;
592 NTSTATUS Status;
593
594 /* Round-up sizes on a 64K boundary */
595
596 totalSize = (totalSize + 0xffff) & 0xffff0000;
597 commitSize = (commitSize + 0xffff) & 0xffff0000;
598 if (!commitSize) commitSize = 0x10000;
599 if (totalSize < commitSize) totalSize = commitSize;
600
601 /* Allocate the memory block */
602 address = BaseAddress;
603 if (!(flags & HEAP_NO_VALLOC))
604 {
605 Status = ZwAllocateVirtualMemory(NtCurrentProcess(),
606 &address,
607 0,
608 (PULONG)&totalSize,
609 MEM_RESERVE | MEM_COMMIT,
610 PAGE_EXECUTE_READWRITE);
611 if (!NT_SUCCESS(Status))
612 {
613 WARN("Could not VirtualAlloc %08lx bytes\n",
614 totalSize );
615 return NULL;
616 }
617 }
618
619 /* Initialize subheap */
620
621 if (!HEAP_InitSubHeap( heap? heap : (HEAP *)address,
622 address, flags, commitSize, totalSize ))
623 {
624 if (!(flags & HEAP_NO_VALLOC))
625 {
626 ULONG dummySize = 0;
627 ZwFreeVirtualMemory(NtCurrentProcess(),
628 address,
629 &dummySize,
630 MEM_RELEASE);
631 return NULL;
632 }
633 }
634
635 return (SUBHEAP *)address;
636 }
637
638
639 /***********************************************************************
640 * HEAP_FindFreeBlock
641 *
642 * Find a free block at least as large as the requested size, and make sure
643 * the requested size is committed.
644 */
645 static ARENA_FREE *HEAP_FindFreeBlock( HEAP *heap, DWORD size,
646 SUBHEAP **ppSubHeap )
647 {
648 SUBHEAP *subheap;
649 ARENA_FREE *pArena;
650 FREE_LIST_ENTRY *pEntry = heap->freeList;
651
652 /* Find a suitable free list, and in it find a block large enough */
653
654 while (pEntry->size < size) pEntry++;
655 pArena = pEntry->arena.next;
656 while (pArena != &heap->freeList[0].arena)
657 {
658 if (pArena->size > size)
659 {
660 subheap = HEAP_FindSubHeap( heap, pArena );
661 if (!HEAP_Commit( subheap, (char *)pArena + sizeof(ARENA_INUSE)
662 + size + HEAP_MIN_BLOCK_SIZE,
663 heap->flags))
664 return NULL;
665 *ppSubHeap = subheap;
666 return pArena;
667 }
668
669 pArena = pArena->next;
670 }
671
672 /* If no block was found, attempt to grow the heap */
673
674 if (!(heap->flags & HEAP_GROWABLE))
675 {
676 WARN("Not enough space in heap %08lx for %08lx bytes\n",
677 (DWORD)heap, size );
678 return NULL;
679 }
680 size += sizeof(SUBHEAP) + sizeof(ARENA_FREE);
681 if (!(subheap = HEAP_CreateSubHeap( NULL, heap, heap->flags, size,
682 max( HEAP_DEF_SIZE, size ) )))
683 return NULL;
684
685 TRACE("created new sub-heap %08lx of %08lx bytes for heap %08lx\n",
686 (DWORD)subheap, size, (DWORD)heap );
687
688 *ppSubHeap = subheap;
689 return (ARENA_FREE *)(subheap + 1);
690 }
691
692
693 /***********************************************************************
694 * HEAP_IsValidArenaPtr
695 *
696 * Check that the pointer is inside the range possible for arenas.
697 */
698 static BOOL HEAP_IsValidArenaPtr( HEAP *heap, void *ptr )
699 {
700 int i;
701 SUBHEAP *subheap = HEAP_FindSubHeap( heap, ptr );
702 if (!subheap) return FALSE;
703 if ((char *)ptr >= (char *)subheap + subheap->headerSize) return TRUE;
704 if (subheap != &heap->subheap) return FALSE;
705 for (i = 0; i < HEAP_NB_FREE_LISTS; i++)
706 if (ptr == (void *)&heap->freeList[i].arena) return TRUE;
707 return FALSE;
708 }
709
710
711 /***********************************************************************
712 * HEAP_ValidateFreeArena
713 */
714 static BOOL HEAP_ValidateFreeArena( SUBHEAP *subheap, ARENA_FREE *pArena )
715 {
716 char *heapEnd = (char *)subheap + subheap->size;
717
718 /* Check magic number */
719 if (pArena->magic != ARENA_FREE_MAGIC)
720 {
721 ERR("Heap %08lx: invalid free arena magic for %08lx\n",
722 (DWORD)subheap->heap, (DWORD)pArena );
723 return FALSE;
724 }
725 /* Check size flags */
726 if (!(pArena->size & ARENA_FLAG_FREE) ||
727 (pArena->size & ARENA_FLAG_PREV_FREE))
728 {
729 ERR("Heap %08lx: bad flags %lx for free arena %08lx\n",
730 (DWORD)subheap->heap, pArena->size & ~ARENA_SIZE_MASK, (DWORD)pArena );
731 }
732 /* Check arena size */
733 if ((char *)(pArena + 1) + (pArena->size & ARENA_SIZE_MASK) > heapEnd)
734 {
735 ERR("Heap %08lx: bad size %08lx for free arena %08lx\n",
736 (DWORD)subheap->heap, (DWORD)pArena->size & ARENA_SIZE_MASK, (DWORD)pArena );
737 return FALSE;
738 }
739 /* Check that next pointer is valid */
740 if (!HEAP_IsValidArenaPtr( subheap->heap, pArena->next ))
741 {
742 ERR("Heap %08lx: bad next ptr %08lx for arena %08lx\n",
743 (DWORD)subheap->heap, (DWORD)pArena->next, (DWORD)pArena );
744 return FALSE;
745 }
746 /* Check that next arena is free */
747 if (!(pArena->next->size & ARENA_FLAG_FREE) ||
748 (pArena->next->magic != ARENA_FREE_MAGIC))
749 {
750 ERR("Heap %08lx: next arena %08lx invalid for %08lx\n",
751 (DWORD)subheap->heap, (DWORD)pArena->next, (DWORD)pArena );
752 return FALSE;
753 }
754 /* Check that prev pointer is valid */
755 if (!HEAP_IsValidArenaPtr( subheap->heap, pArena->prev ))
756 {
757 ERR("Heap %08lx: bad prev ptr %08lx for arena %08lx\n",
758 (DWORD)subheap->heap, (DWORD)pArena->prev, (DWORD)pArena );
759 return FALSE;
760 }
761 /* Check that prev arena is free */
762 if (!(pArena->prev->size & ARENA_FLAG_FREE) ||
763 (pArena->prev->magic != ARENA_FREE_MAGIC))
764 {
765 ERR("Heap %08lx: prev arena %08lx invalid for %08lx\n",
766 (DWORD)subheap->heap, (DWORD)pArena->prev, (DWORD)pArena );
767 return FALSE;
768 }
769 /* Check that next block has PREV_FREE flag */
770 if ((char *)(pArena + 1) + (pArena->size & ARENA_SIZE_MASK) < heapEnd)
771 {
772 if (!(*(DWORD *)((char *)(pArena + 1) +
773 (pArena->size & ARENA_SIZE_MASK)) & ARENA_FLAG_PREV_FREE))
774 {
775 ERR("Heap %08lx: free arena %08lx next block has no PREV_FREE flag\n",
776 (DWORD)subheap->heap, (DWORD)pArena );
777 return FALSE;
778 }
779 /* Check next block back pointer */
780 if (*((ARENA_FREE **)((char *)(pArena + 1) +
781 (pArena->size & ARENA_SIZE_MASK)) - 1) != pArena)
782 {
783 ERR("Heap %08lx: arena %08lx has wrong back ptr %08lx\n",
784 (DWORD)subheap->heap, (DWORD)pArena,
785 *((DWORD *)((char *)(pArena+1)+ (pArena->size & ARENA_SIZE_MASK)) - 1));
786 return FALSE;
787 }
788 }
789 return TRUE;
790 }
791
792
793 /***********************************************************************
794 * HEAP_ValidateInUseArena
795 */
796 static BOOL HEAP_ValidateInUseArena( SUBHEAP *subheap, ARENA_INUSE *pArena, BOOL quiet )
797 {
798 char *heapEnd = (char *)subheap + subheap->size;
799
800 /* Check magic number */
801 if (pArena->magic != ARENA_INUSE_MAGIC)
802 {
803 if (quiet == NOISY) {
804 ERR("Heap %08lx: invalid in-use arena magic for %08lx\n",
805 (DWORD)subheap->heap, (DWORD)pArena );
806 if (TRACE_ON(heap))
807 HEAP_Dump( subheap->heap );
808 } else if (WARN_ON(heap)) {
809 WARN("Heap %08lx: invalid in-use arena magic for %08lx\n",
810 (DWORD)subheap->heap, (DWORD)pArena );
811 if (TRACE_ON(heap))
812 HEAP_Dump( subheap->heap );
813 }
814 return FALSE;
815 }
816 /* Check size flags */
817 if (pArena->size & ARENA_FLAG_FREE)
818 {
819 ERR("Heap %08lx: bad flags %lx for in-use arena %08lx\n",
820 (DWORD)subheap->heap, pArena->size & ~ARENA_SIZE_MASK, (DWORD)pArena );
821 }
822 /* Check arena size */
823 if ((char *)(pArena + 1) + (pArena->size & ARENA_SIZE_MASK) > heapEnd)
824 {
825 ERR("Heap %08lx: bad size %08lx for in-use arena %08lx\n",
826 (DWORD)subheap->heap, (DWORD)pArena->size & ARENA_SIZE_MASK, (DWORD)pArena );
827 return FALSE;
828 }
829 /* Check next arena PREV_FREE flag */
830 if (((char *)(pArena + 1) + (pArena->size & ARENA_SIZE_MASK) < heapEnd) &&
831 (*(DWORD *)((char *)(pArena + 1) + (pArena->size & ARENA_SIZE_MASK)) & ARENA_FLAG_PREV_FREE))
832 {
833 ERR("Heap %08lx: in-use arena %08lx next block has PREV_FREE flag\n",
834 (DWORD)subheap->heap, (DWORD)pArena );
835 return FALSE;
836 }
837 /* Check prev free arena */
838 if (pArena->size & ARENA_FLAG_PREV_FREE)
839 {
840 ARENA_FREE *pPrev = *((ARENA_FREE **)pArena - 1);
841 /* Check prev pointer */
842 if (!HEAP_IsValidArenaPtr( subheap->heap, pPrev ))
843 {
844 ERR("Heap %08lx: bad back ptr %08lx for arena %08lx\n",
845 (DWORD)subheap->heap, (DWORD)pPrev, (DWORD)pArena );
846 return FALSE;
847 }
848 /* Check that prev arena is free */
849 if (!(pPrev->size & ARENA_FLAG_FREE) ||
850 (pPrev->magic != ARENA_FREE_MAGIC))
851 {
852 ERR("Heap %08lx: prev arena %08lx invalid for in-use %08lx\n",
853 (DWORD)subheap->heap, (DWORD)pPrev, (DWORD)pArena );
854 return FALSE;
855 }
856 /* Check that prev arena is really the previous block */
857 if ((char *)(pPrev + 1) + (pPrev->size & ARENA_SIZE_MASK) != (char *)pArena)
858 {
859 ERR("Heap %08lx: prev arena %08lx is not prev for in-use %08lx\n",
860 (DWORD)subheap->heap, (DWORD)pPrev, (DWORD)pArena );
861 return FALSE;
862 }
863 }
864 return TRUE;
865 }
866
867
868 /***********************************************************************
869 * HEAP_IsInsideHeap
870 * Checks whether the pointer points to a block inside a given heap.
871 *
872 * NOTES
873 * Should this return BOOL32?
874 *
875 * RETURNS
876 * !0: Success
877 * 0: Failure
878 */
879 int HEAP_IsInsideHeap(
880 HANDLE heap, /* [in] Heap */
881 DWORD flags, /* [in] Flags */
882 LPCVOID ptr /* [in] Pointer */
883 ) {
884 HEAP *heapPtr = HEAP_GetPtr( heap );
885 SUBHEAP *subheap;
886 int ret;
887
888 /* Validate the parameters */
889
890 if (!heapPtr) return 0;
891 flags |= heapPtr->flags;
892 if (!(flags & HEAP_NO_SERIALIZE)) RtlEnterCriticalSection( &heapPtr->critSection );
893 ret = (((subheap = HEAP_FindSubHeap( heapPtr, ptr )) != NULL) &&
894 (((char *)ptr >= (char *)subheap + subheap->headerSize
895 + sizeof(ARENA_INUSE))));
896 if (!(flags & HEAP_NO_SERIALIZE)) RtlLeaveCriticalSection( &heapPtr->critSection );
897 return ret;
898 }
899
900
901
902
903 /***********************************************************************
904 * HEAP_IsRealArena [Internal]
905 * Validates a block is a valid arena.
906 *
907 * RETURNS
908 * TRUE: Success
909 * FALSE: Failure
910 */
911 static BOOL HEAP_IsRealArena(
912 HANDLE heap, /* [in] Handle to the heap */
913 DWORD flags, /* [in] Bit flags that control access during operation */
914 LPCVOID block, /* [in] Optional pointer to memory block to validate */
915 BOOL quiet /* [in] Flag - if true, HEAP_ValidateInUseArena
916 * does not complain */
917 ) {
918 SUBHEAP *subheap;
919 HEAP *heapPtr = (HEAP *)(heap);
920 BOOL ret = TRUE;
921
922 if (!heapPtr || (heapPtr->magic != HEAP_MAGIC))
923 {
924 ERR("Invalid heap %08x!\n", heap );
925 return FALSE;
926 }
927
928 flags &= HEAP_NO_SERIALIZE;
929 flags |= heapPtr->flags;
930 /* calling HeapLock may result in infinite recursion, so do the critsect directly */
931 if (!(flags & HEAP_NO_SERIALIZE))
932 RtlEnterCriticalSection( &heapPtr->critSection );
933
934 if (block)
935 {
936 /* Only check this single memory block */
937
938 /* The following code is really HEAP_IsInsideHeap *
939 * with serialization already done. */
940 if (!(subheap = HEAP_FindSubHeap( heapPtr, block )) ||
941 ((char *)block < (char *)subheap + subheap->headerSize
942 + sizeof(ARENA_INUSE)))
943 {
944 if (quiet == NOISY)
945 {
946 ERR("Heap %08lx: block %08lx is not inside heap\n",
947 (DWORD)heap, (DWORD)block );
948 }
949 else if (WARN_ON(heap))
950 {
951 WARN("Heap %08lx: block %08lx is not inside heap\n",
952 (DWORD)heap, (DWORD)block );
953 }
954 ret = FALSE;
955 } else
956 ret = HEAP_ValidateInUseArena( subheap, (ARENA_INUSE *)block - 1, quiet );
957
958 if (!(flags & HEAP_NO_SERIALIZE))
959 RtlLeaveCriticalSection( &heapPtr->critSection );
960 return ret;
961 }
962
963 subheap = &heapPtr->subheap;
964 while (subheap && ret)
965 {
966 char *ptr = (char *)subheap + subheap->headerSize;
967 while (ptr < (char *)subheap + subheap->size)
968 {
969 if (*(DWORD *)ptr & ARENA_FLAG_FREE)
970 {
971 if (!HEAP_ValidateFreeArena( subheap, (ARENA_FREE *)ptr )) {
972 ret = FALSE;
973 break;
974 }
975 ptr += sizeof(ARENA_FREE) + (*(DWORD *)ptr & ARENA_SIZE_MASK);
976 }
977 else
978 {
979 if (!HEAP_ValidateInUseArena( subheap, (ARENA_INUSE *)ptr, NOISY )) {
980 ret = FALSE;
981 break;
982 }
983 ptr += sizeof(ARENA_INUSE) + (*(DWORD *)ptr & ARENA_SIZE_MASK);
984 }
985 }
986 subheap = subheap->next;
987 }
988
989 if (!(flags & HEAP_NO_SERIALIZE))
990 RtlLeaveCriticalSection( &heapPtr->critSection );
991 return ret;
992 }
993
994
995 /***********************************************************************
996 * HeapCreate (KERNEL32.336)
997 * RETURNS
998 * Handle of heap: Success
999 * NULL: Failure
1000 */
1001 HANDLE STDCALL
1002 RtlCreateHeap(ULONG flags,
1003 PVOID BaseAddress,
1004 ULONG initialSize,
1005 ULONG maxSize,
1006 PVOID Unknown,
1007 PRTL_HEAP_DEFINITION Definition)
1008 {
1009 SUBHEAP *subheap;
1010 ULONG i;
1011
1012 /* Allocate the heap block */
1013
1014 if (!maxSize)
1015 {
1016 maxSize = HEAP_DEF_SIZE;
1017 flags |= HEAP_GROWABLE;
1018 }
1019 if (!(subheap = HEAP_CreateSubHeap( BaseAddress, NULL, flags, initialSize, maxSize )))
1020 {
1021 return 0;
1022 }
1023
1024 RtlEnterCriticalSection (&RtlpProcessHeapsListLock);
1025 for (i = 0; i < NtCurrentPeb ()->NumberOfHeaps; i++)
1026 {
1027 if (NtCurrentPeb ()->ProcessHeaps[i] == NULL)
1028 {
1029 NtCurrentPeb()->ProcessHeaps[i] = (PVOID)subheap;
1030 break;
1031 }
1032 }
1033 RtlLeaveCriticalSection (&RtlpProcessHeapsListLock);
1034
1035 return (HANDLE)subheap;
1036 }
1037
1038 /***********************************************************************
1039 * HeapDestroy (KERNEL32.337)
1040 * RETURNS
1041 * TRUE: Success
1042 * FALSE: Failure
1043 */
1044 BOOL STDCALL
1045 RtlDestroyHeap(HANDLE heap) /* [in] Handle of heap */
1046 {
1047 HEAP *heapPtr = HEAP_GetPtr( heap );
1048 SUBHEAP *subheap;
1049 ULONG i, flags;
1050
1051 TRACE("%08x\n", heap );
1052 if (!heapPtr) return FALSE;
1053
1054 RtlEnterCriticalSection (&RtlpProcessHeapsListLock);
1055 for (i = 0; i < NtCurrentPeb ()->NumberOfHeaps; i++)
1056 {
1057 if (NtCurrentPeb ()->ProcessHeaps[i] == heap)
1058 {
1059 NtCurrentPeb()->ProcessHeaps[i] = NULL;
1060 break;
1061 }
1062 }
1063 RtlLeaveCriticalSection (&RtlpProcessHeapsListLock);
1064
1065 RtlDeleteCriticalSection( &heapPtr->critSection );
1066 subheap = &heapPtr->subheap;
1067 // We must save the flags. The first subheap is located after
1068 // the heap structure. If we release the first subheap,
1069 // we release also the heap structure.
1070 flags = heapPtr->flags;
1071 while (subheap)
1072 {
1073 SUBHEAP *next = subheap->next;
1074
1075 if (!(flags & HEAP_NO_VALLOC))
1076 {
1077 ULONG dummySize = 0;
1078 ZwFreeVirtualMemory(NtCurrentProcess(),
1079 (PVOID*)&subheap,
1080 &dummySize,
1081 MEM_RELEASE);
1082 }
1083 subheap = next;
1084 }
1085 return TRUE;
1086 }
1087
1088
1089 /***********************************************************************
1090 * HeapAlloc (KERNEL32.334)
1091 * RETURNS
1092 * Pointer to allocated memory block
1093 * NULL: Failure
1094 */
1095 PVOID STDCALL
1096 RtlAllocateHeap(HANDLE heap, /* [in] Handle of private heap block */
1097 ULONG flags, /* [in] Heap allocation control flags */
1098 ULONG size) /* [in] Number of bytes to allocate */
1099 {
1100 ARENA_FREE *pArena;
1101 ARENA_INUSE *pInUse;
1102 SUBHEAP *subheap;
1103 HEAP *heapPtr = HEAP_GetPtr( heap );
1104
1105 /* Validate the parameters */
1106
1107 if (!heapPtr) return NULL;
1108 flags &= HEAP_GENERATE_EXCEPTIONS | HEAP_NO_SERIALIZE | HEAP_ZERO_MEMORY;
1109 flags |= heapPtr->flags;
1110 if (!(flags & HEAP_NO_SERIALIZE)) RtlEnterCriticalSection( &heapPtr->critSection );
1111 size = (size + 3) & ~3;
1112 if (size < HEAP_MIN_BLOCK_SIZE) size = HEAP_MIN_BLOCK_SIZE;
1113
1114 /* Locate a suitable free block */
1115
1116 if (!(pArena = HEAP_FindFreeBlock( heapPtr, size, &subheap )))
1117 {
1118 TRACE("(%08x,%08lx,%08lx): returning NULL\n",
1119 heap, flags, size );
1120 if (!(flags & HEAP_NO_SERIALIZE)) RtlLeaveCriticalSection( &heapPtr->critSection );
1121 return NULL;
1122 }
1123
1124 /* Remove the arena from the free list */
1125
1126 pArena->next->prev = pArena->prev;
1127 pArena->prev->next = pArena->next;
1128
1129 /* Build the in-use arena */
1130
1131 pInUse = (ARENA_INUSE *)pArena;
1132 pInUse->size = (pInUse->size & ~ARENA_FLAG_FREE)
1133 + sizeof(ARENA_FREE) - sizeof(ARENA_INUSE);
1134 pInUse->callerEIP = GET_EIP();
1135 pInUse->threadId = (DWORD)NtCurrentTeb()->Cid.UniqueThread;
1136 pInUse->magic = ARENA_INUSE_MAGIC;
1137
1138 /* Shrink the block */
1139
1140 HEAP_ShrinkBlock( subheap, pInUse, size );
1141
1142 if (flags & HEAP_ZERO_MEMORY)
1143 memset( pInUse + 1, 0, pInUse->size & ARENA_SIZE_MASK );
1144 else if (TRACE_ON(heap))
1145 memset( pInUse + 1, ARENA_INUSE_FILLER, pInUse->size & ARENA_SIZE_MASK );
1146
1147 if (!(flags & HEAP_NO_SERIALIZE)) RtlLeaveCriticalSection( &heapPtr->critSection );
1148
1149 TRACE("(%08x,%08lx,%08lx): returning %08lx\n",
1150 heap, flags, size, (DWORD)(pInUse + 1) );
1151 return (LPVOID)(pInUse + 1);
1152 }
1153
1154
1155 /***********************************************************************
1156 * HeapFree (KERNEL32.338)
1157 * RETURNS
1158 * TRUE: Success
1159 * FALSE: Failure
1160 */
1161 BOOLEAN STDCALL RtlFreeHeap(
1162 HANDLE heap, /* [in] Handle of heap */
1163 ULONG flags, /* [in] Heap freeing flags */
1164 PVOID ptr /* [in] Address of memory to free */
1165 ) {
1166 ARENA_INUSE *pInUse;
1167 SUBHEAP *subheap;
1168 HEAP *heapPtr = HEAP_GetPtr( heap );
1169
1170 /* Validate the parameters */
1171
1172 if (!heapPtr) return FALSE;
1173 if (!ptr) /* Freeing a NULL ptr is doesn't indicate an error in Win2k */
1174 {
1175 WARN("(%08x,%08lx,%08lx): asked to free NULL\n",
1176 heap, flags, (DWORD)ptr );
1177 return TRUE;
1178 }
1179
1180 flags &= HEAP_NO_SERIALIZE;
1181 flags |= heapPtr->flags;
1182 if (!(flags & HEAP_NO_SERIALIZE)) RtlEnterCriticalSection( &heapPtr->critSection );
1183 if (!HEAP_IsRealArena( heap, HEAP_NO_SERIALIZE, ptr, QUIET ))
1184 {
1185 if (!(flags & HEAP_NO_SERIALIZE)) RtlLeaveCriticalSection( &heapPtr->critSection );
1186 TRACE("(%08x,%08lx,%08lx): returning FALSE\n",
1187 heap, flags, (DWORD)ptr );
1188 return FALSE;
1189 }
1190
1191 /* Turn the block into a free block */
1192
1193 pInUse = (ARENA_INUSE *)ptr - 1;
1194 subheap = HEAP_FindSubHeap( heapPtr, pInUse );
1195 HEAP_MakeInUseBlockFree( subheap, pInUse, heapPtr->flags );
1196
1197 if (!(flags & HEAP_NO_SERIALIZE)) RtlLeaveCriticalSection( &heapPtr->critSection );
1198
1199 TRACE("(%08x,%08lx,%08lx): returning TRUE\n",
1200 heap, flags, (DWORD)ptr );
1201 return TRUE;
1202 }
1203
1204
1205 /***********************************************************************
1206 * HeapReAlloc (KERNEL32.340)
1207 * RETURNS
1208 * Pointer to reallocated memory block
1209 * NULL: Failure
1210 */
1211 LPVOID STDCALL RtlReAllocateHeap(
1212 HANDLE heap, /* [in] Handle of heap block */
1213 DWORD flags, /* [in] Heap reallocation flags */
1214 LPVOID ptr, /* [in] Address of memory to reallocate */
1215 DWORD size /* [in] Number of bytes to reallocate */
1216 ) {
1217 ARENA_INUSE *pArena;
1218 DWORD oldSize;
1219 HEAP *heapPtr;
1220 SUBHEAP *subheap;
1221
1222 if (!ptr) return RtlAllocateHeap( heap, flags, size ); /* FIXME: correct? */
1223 if (!(heapPtr = HEAP_GetPtr( heap ))) return FALSE;
1224
1225 /* Validate the parameters */
1226
1227 flags &= HEAP_GENERATE_EXCEPTIONS | HEAP_NO_SERIALIZE | HEAP_ZERO_MEMORY |
1228 HEAP_REALLOC_IN_PLACE_ONLY;
1229 flags |= heapPtr->flags;
1230 size = (size + 3) & ~3;
1231 if (size < HEAP_MIN_BLOCK_SIZE) size = HEAP_MIN_BLOCK_SIZE;
1232
1233 if (!(flags & HEAP_NO_SERIALIZE)) RtlEnterCriticalSection( &heapPtr->critSection );
1234 if (!HEAP_IsRealArena( heap, HEAP_NO_SERIALIZE, ptr, QUIET ))
1235 {
1236 if (!(flags & HEAP_NO_SERIALIZE)) RtlLeaveCriticalSection( &heapPtr->critSection );
1237 TRACE("(%08x,%08lx,%08lx,%08lx): returning NULL\n",
1238 heap, flags, (DWORD)ptr, size );
1239 return NULL;
1240 }
1241
1242 /* Check if we need to grow the block */
1243
1244 pArena = (ARENA_INUSE *)ptr - 1;
1245 pArena->threadId = (DWORD)NtCurrentTeb()->Cid.UniqueThread;
1246
1247 subheap = HEAP_FindSubHeap( heapPtr, pArena );
1248 oldSize = (pArena->size & ARENA_SIZE_MASK);
1249 if (size > oldSize)
1250 {
1251 char *pNext = (char *)(pArena + 1) + oldSize;
1252 if ((pNext < (char *)subheap + subheap->size) &&
1253 (*(DWORD *)pNext & ARENA_FLAG_FREE) &&
1254 (oldSize + (*(DWORD *)pNext & ARENA_SIZE_MASK) + sizeof(ARENA_FREE) >= size))
1255 {
1256 /* The next block is free and large enough */
1257 ARENA_FREE *pFree = (ARENA_FREE *)pNext;
1258 pFree->next->prev = pFree->prev;
1259 pFree->prev->next = pFree->next;
1260 pArena->size += (pFree->size & ARENA_SIZE_MASK) + sizeof(*pFree);
1261 if (!HEAP_Commit( subheap, (char *)pArena + sizeof(ARENA_INUSE)
1262 + size + HEAP_MIN_BLOCK_SIZE,
1263 heapPtr->flags))
1264 {
1265 if (!(flags & HEAP_NO_SERIALIZE)) RtlLeaveCriticalSection( &heapPtr->critSection );
1266 return NULL;
1267 }
1268 HEAP_ShrinkBlock( subheap, pArena, size );
1269 }
1270 else /* Do it the hard way */
1271 {
1272 ARENA_FREE *pNew;
1273 ARENA_INUSE *pInUse;
1274 SUBHEAP *newsubheap;
1275
1276 if ((flags & HEAP_REALLOC_IN_PLACE_ONLY) ||
1277 !(pNew = HEAP_FindFreeBlock( heapPtr, size, &newsubheap )))
1278 {
1279 if (!(flags & HEAP_NO_SERIALIZE)) RtlLeaveCriticalSection( &heapPtr->critSection );
1280 return NULL;
1281 }
1282
1283 /* Build the in-use arena */
1284
1285 pNew->next->prev = pNew->prev;
1286 pNew->prev->next = pNew->next;
1287 pInUse = (ARENA_INUSE *)pNew;
1288 pInUse->size = (pInUse->size & ~ARENA_FLAG_FREE)
1289 + sizeof(ARENA_FREE) - sizeof(ARENA_INUSE);
1290 pInUse->threadId = (DWORD)NtCurrentTeb()->Cid.UniqueThread;
1291 pInUse->magic = ARENA_INUSE_MAGIC;
1292 HEAP_ShrinkBlock( newsubheap, pInUse, size );
1293 memcpy( pInUse + 1, pArena + 1, oldSize );
1294
1295 /* Free the previous block */
1296
1297 HEAP_MakeInUseBlockFree( subheap, pArena, flags );
1298 subheap = newsubheap;
1299 pArena = pInUse;
1300 }
1301 }
1302 else HEAP_ShrinkBlock( subheap, pArena, size ); /* Shrink the block */
1303
1304 /* Clear the extra bytes if needed */
1305
1306 if (size > oldSize)
1307 {
1308 if (flags & HEAP_ZERO_MEMORY)
1309 memset( (char *)(pArena + 1) + oldSize, 0,
1310 (pArena->size & ARENA_SIZE_MASK) - oldSize );
1311 else if (TRACE_ON(heap))
1312 memset( (char *)(pArena + 1) + oldSize, ARENA_INUSE_FILLER,
1313 (pArena->size & ARENA_SIZE_MASK) - oldSize );
1314 }
1315
1316 /* Return the new arena */
1317
1318 pArena->callerEIP = GET_EIP();
1319 if (!(flags & HEAP_NO_SERIALIZE)) RtlLeaveCriticalSection( &heapPtr->critSection );
1320
1321 TRACE("(%08x,%08lx,%08lx,%08lx): returning %08lx\n",
1322 heap, flags, (DWORD)ptr, size, (DWORD)(pArena + 1) );
1323 return (LPVOID)(pArena + 1);
1324 }
1325
1326
1327 /***********************************************************************
1328 * HeapCompact (KERNEL32.335)
1329 */
1330 DWORD STDCALL RtlCompactHeap( HANDLE heap, DWORD flags )
1331 {
1332 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1333 return 0;
1334 }
1335
1336
1337 /***********************************************************************
1338 * HeapLock (KERNEL32.339)
1339 * Attempts to acquire the critical section object for a specified heap.
1340 *
1341 * RETURNS
1342 * TRUE: Success
1343 * FALSE: Failure
1344 */
1345 BOOL STDCALL RtlLockHeap(
1346 HANDLE heap /* [in] Handle of heap to lock for exclusive access */
1347 ) {
1348 HEAP *heapPtr = HEAP_GetPtr( heap );
1349 if (!heapPtr) return FALSE;
1350 RtlEnterCriticalSection( &heapPtr->critSection );
1351 return TRUE;
1352 }
1353
1354
1355 /***********************************************************************
1356 * HeapUnlock (KERNEL32.342)
1357 * Releases ownership of the critical section object.
1358 *
1359 * RETURNS
1360 * TRUE: Success
1361 * FALSE: Failure
1362 */
1363 BOOL STDCALL RtlUnlockHeap(
1364 HANDLE heap /* [in] Handle to the heap to unlock */
1365 ) {
1366 HEAP *heapPtr = HEAP_GetPtr( heap );
1367 if (!heapPtr) return FALSE;
1368 RtlLeaveCriticalSection( &heapPtr->critSection );
1369 return TRUE;
1370 }
1371
1372
1373 /***********************************************************************
1374 * HeapSize (KERNEL32.341)
1375 * RETURNS
1376 * Size in bytes of allocated memory
1377 * 0xffffffff: Failure
1378 */
1379 DWORD STDCALL RtlSizeHeap(
1380 HANDLE heap, /* [in] Handle of heap */
1381 DWORD flags, /* [in] Heap size control flags */
1382 LPVOID ptr /* [in] Address of memory to return size for */
1383 ) {
1384 DWORD ret;
1385 HEAP *heapPtr = HEAP_GetPtr( heap );
1386
1387 if (!heapPtr) return FALSE;
1388 flags &= HEAP_NO_SERIALIZE;
1389 flags |= heapPtr->flags;
1390 if (!(flags & HEAP_NO_SERIALIZE)) RtlEnterCriticalSection( &heapPtr->critSection );
1391 if (!HEAP_IsRealArena( heap, HEAP_NO_SERIALIZE, ptr, QUIET ))
1392 {
1393 SetLastError( ERROR_INVALID_PARAMETER );
1394 ret = 0xffffffff;
1395 }
1396 else
1397 {
1398 ARENA_INUSE *pArena = (ARENA_INUSE *)ptr - 1;
1399 ret = pArena->size & ARENA_SIZE_MASK;
1400 }
1401 if (!(flags & HEAP_NO_SERIALIZE)) RtlLeaveCriticalSection( &heapPtr->critSection );
1402
1403 TRACE("(%08x,%08lx,%08lx): returning %08lx\n",
1404 heap, flags, (DWORD)ptr, ret );
1405 return ret;
1406 }
1407
1408
1409 /***********************************************************************
1410 * HeapValidate (KERNEL32.343)
1411 * Validates a specified heap.
1412 *
1413 * NOTES
1414 * Flags is ignored.
1415 *
1416 * RETURNS
1417 * TRUE: Success
1418 * FALSE: Failure
1419 */
1420 BOOL STDCALL RtlValidateHeap(
1421 HANDLE heap, /* [in] Handle to the heap */
1422 DWORD flags, /* [in] Bit flags that control access during operation */
1423 PVOID block /* [in] Optional pointer to memory block to validate */
1424 ) {
1425
1426 return HEAP_IsRealArena( heap, flags, block, QUIET );
1427 }
1428
1429
1430 /***********************************************************************
1431 * HeapWalk (KERNEL32.344)
1432 * Enumerates the memory blocks in a specified heap.
1433 * See HEAP_Dump() for info on heap structure.
1434 *
1435 * TODO
1436 * - handling of PROCESS_HEAP_ENTRY_MOVEABLE and
1437 * PROCESS_HEAP_ENTRY_DDESHARE (needs heap.c support)
1438 *
1439 * RETURNS
1440 * TRUE: Success
1441 * FALSE: Failure
1442 */
1443 #if 0
1444 BOOL STDCALL HeapWalk(
1445 HANDLE heap, /* [in] Handle to heap to enumerate */
1446 LPPROCESS_HEAP_ENTRY entry /* [out] Pointer to structure of enumeration info */
1447 ) {
1448 HEAP *heapPtr = HEAP_GetPtr(heap);
1449 SUBHEAP *sub, *currentheap = NULL;
1450 BOOL ret = FALSE;
1451 char *ptr;
1452 int region_index = 0;
1453
1454 if (!heapPtr || !entry)
1455 {
1456 SetLastError(ERROR_INVALID_PARAMETER);
1457 return FALSE;
1458 }
1459
1460 if (!(heapPtr->flags & HEAP_NO_SERIALIZE)) RtlEnterCriticalSection( &heapPtr->critSection );
1461
1462 /* set ptr to the next arena to be examined */
1463
1464 if (!entry->lpData) /* first call (init) ? */
1465 {
1466 TRACE("begin walking of heap 0x%08x.\n", heap);
1467 /*HEAP_Dump(heapPtr);*/
1468 currentheap = &heapPtr->subheap;
1469 ptr = (char*)currentheap + currentheap->headerSize;
1470 }
1471 else
1472 {
1473 ptr = entry->lpData;
1474 sub = &heapPtr->subheap;
1475 while (sub)
1476 {
1477 if (((char *)ptr >= (char *)sub) &&
1478 ((char *)ptr < (char *)sub + sub->size))
1479 {
1480 currentheap = sub;
1481 break;
1482 }
1483 sub = sub->next;
1484 region_index++;
1485 }
1486 if (currentheap == NULL)
1487 {
1488 ERR("no matching subheap found, shouldn't happen !\n");
1489 SetLastError(ERROR_NO_MORE_ITEMS);
1490 goto HW_end;
1491 }
1492
1493 ptr += entry->cbData; /* point to next arena */
1494 if (ptr > (char *)currentheap + currentheap->size - 1)
1495 { /* proceed with next subheap */
1496 if (!(currentheap = currentheap->next))
1497 { /* successfully finished */
1498 TRACE("end reached.\n");
1499 SetLastError(ERROR_NO_MORE_ITEMS);
1500 goto HW_end;
1501 }
1502 ptr = (char*)currentheap + currentheap->headerSize;
1503 }
1504 }
1505
1506 entry->wFlags = 0;
1507 if (*(DWORD *)ptr & ARENA_FLAG_FREE)
1508 {
1509 ARENA_FREE *pArena = (ARENA_FREE *)ptr;
1510
1511 /*TRACE("free, magic: %04x\n", pArena->magic);*/
1512
1513 entry->lpData = pArena + 1;
1514 entry->cbData = pArena->size & ARENA_SIZE_MASK;
1515 entry->cbOverhead = sizeof(ARENA_FREE);
1516 entry->wFlags = PROCESS_HEAP_UNCOMMITTED_RANGE;
1517 }
1518 else
1519 {
1520 ARENA_INUSE *pArena = (ARENA_INUSE *)ptr;
1521
1522 /*TRACE("busy, magic: %04x\n", pArena->magic);*/
1523
1524 entry->lpData = pArena + 1;
1525 entry->cbData = pArena->size & ARENA_SIZE_MASK;
1526 entry->cbOverhead = sizeof(ARENA_INUSE);
1527 entry->wFlags = PROCESS_HEAP_ENTRY_BUSY;
1528 /* FIXME: can't handle PROCESS_HEAP_ENTRY_MOVEABLE
1529 and PROCESS_HEAP_ENTRY_DDESHARE yet */
1530 }
1531
1532 entry->iRegionIndex = region_index;
1533
1534 /* first element of heap ? */
1535 if (ptr == (char *)(currentheap + currentheap->headerSize))
1536 {
1537 entry->wFlags |= PROCESS_HEAP_REGION;
1538 entry->Foo.Region.dwCommittedSize = currentheap->commitSize;
1539 entry->Foo.Region.dwUnCommittedSize =
1540 currentheap->size - currentheap->commitSize;
1541 entry->Foo.Region.lpFirstBlock = /* first valid block */
1542 currentheap + currentheap->headerSize;
1543 entry->Foo.Region.lpLastBlock = /* first invalid block */
1544 currentheap + currentheap->size;
1545 }
1546 ret = TRUE;
1547
1548 HW_end:
1549 if (!(heapPtr->flags & HEAP_NO_SERIALIZE)) RtlLeaveCriticalSection( &heapPtr->critSection );
1550
1551 return ret;
1552 }
1553 #endif
1554
1555
1556 HANDLE STDCALL
1557 RtlGetProcessHeap(VOID)
1558 {
1559 DPRINT("RtlGetProcessHeap()\n");
1560 return (HANDLE)NtCurrentPeb()->ProcessHeap;
1561 }
1562
1563 VOID
1564 RtlInitializeHeapManager(VOID)
1565 {
1566 PPEB Peb;
1567
1568 Peb = NtCurrentPeb();
1569
1570 Peb->NumberOfHeaps = 0;
1571 Peb->MaximumNumberOfHeaps = (PAGESIZE - sizeof(PEB)) / sizeof(HANDLE);
1572 Peb->ProcessHeaps = (PVOID)Peb + sizeof(PEB);
1573
1574 RtlInitializeCriticalSection(&RtlpProcessHeapsListLock);
1575 }
1576
1577
1578 NTSTATUS STDCALL
1579 RtlEnumProcessHeaps(DWORD STDCALL(*func)(void*,LONG),
1580 LONG lParam)
1581 {
1582 NTSTATUS Status = STATUS_SUCCESS;
1583 ULONG i;
1584
1585 RtlEnterCriticalSection(&RtlpProcessHeapsListLock);
1586
1587 for (i = 0; i < NtCurrentPeb()->NumberOfHeaps; i++)
1588 {
1589 Status = func(NtCurrentPeb()->ProcessHeaps[i],lParam);
1590 if (!NT_SUCCESS(Status))
1591 break;
1592 }
1593
1594 RtlLeaveCriticalSection(&RtlpProcessHeapsListLock);
1595
1596 return Status;
1597 }
1598
1599
1600 ULONG STDCALL
1601 RtlGetProcessHeaps(ULONG HeapCount,
1602 HANDLE *HeapArray)
1603 {
1604 ULONG Result = 0;
1605
1606 RtlEnterCriticalSection(&RtlpProcessHeapsListLock);
1607
1608 if (NtCurrentPeb()->NumberOfHeaps <= HeapCount)
1609 {
1610 Result = NtCurrentPeb()->NumberOfHeaps;
1611 memmove(HeapArray,
1612 NtCurrentPeb()->ProcessHeaps,
1613 Result * sizeof(HANDLE));
1614 }
1615
1616 RtlLeaveCriticalSection (&RtlpProcessHeapsListLock);
1617
1618 return Result;
1619 }
1620
1621
1622 BOOLEAN STDCALL
1623 RtlValidateProcessHeaps(VOID)
1624 {
1625 HANDLE Heaps[128];
1626 BOOLEAN Result = TRUE;
1627 ULONG HeapCount;
1628 ULONG i;
1629
1630 HeapCount = RtlGetProcessHeaps(128, Heaps);
1631 for (i = 0; i < HeapCount; i++)
1632 {
1633 if (!RtlValidateHeap(Heaps[i], 0, NULL))
1634 Result = FALSE;
1635 }
1636
1637 return Result;
1638 }
1639
1640 /* EOF */