?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
New debug scheme with explicit debug channels declaration.
[wine/testsucceed.git] / memory / heap.c
blobdfd174c3fefa2e323cdb0d52a49d1e1a6648121c
1 /*
2 * Win32 heap functions
3 *
4 * Copyright 1996 Alexandre Julliard
5 * Copyright 1998 Ulrich Weigand
6 */
7
8 #include <assert.h>
9 #include <stdlib.h>
10 #include <string.h>
11 #include "wine/winbase16.h"
12 #include "wine/winestring.h"
13 #include "selectors.h"
14 #include "global.h"
15 #include "winbase.h"
16 #include "winerror.h"
17 #include "winnt.h"
18 #include "heap.h"
19 #include "toolhelp.h"
20 #include "debug.h"
21
22 DEFAULT_DEBUG_CHANNEL(heap)
23
24 /* Note: the heap data structures are based on what Pietrek describes in his
25 * book 'Windows 95 System Programming Secrets'. The layout is not exactly
26 * the same, but could be easily adapted if it turns out some programs
27 * require it.
28 */
29
30 typedef struct tagARENA_INUSE
31 {
32 DWORD size; /* Block size; must be the first field */
33 WORD threadId; /* Allocating thread id */
34 WORD magic; /* Magic number */
35 DWORD callerEIP; /* EIP of caller upon allocation */
36 } ARENA_INUSE;
37
38 typedef struct tagARENA_FREE
39 {
40 DWORD size; /* Block size; must be the first field */
41 WORD threadId; /* Freeing thread id */
42 WORD magic; /* Magic number */
43 struct tagARENA_FREE *next; /* Next free arena */
44 struct tagARENA_FREE *prev; /* Prev free arena */
45 } ARENA_FREE;
46
47 #define ARENA_FLAG_FREE 0x00000001 /* flags OR'ed with arena size */
48 #define ARENA_FLAG_PREV_FREE 0x00000002
49 #define ARENA_SIZE_MASK 0xfffffffc
50 #define ARENA_INUSE_MAGIC 0x4842 /* Value for arena 'magic' field */
51 #define ARENA_FREE_MAGIC 0x4846 /* Value for arena 'magic' field */
52
53 #define ARENA_INUSE_FILLER 0x55
54 #define ARENA_FREE_FILLER 0xaa
55
56 #define HEAP_NB_FREE_LISTS 4 /* Number of free lists */
57
58 /* Max size of the blocks on the free lists */
59 static const DWORD HEAP_freeListSizes[HEAP_NB_FREE_LISTS] =
60 {
61 0x20, 0x80, 0x200, 0xffffffff
62 };
63
64 typedef struct
65 {
66 DWORD size;
67 ARENA_FREE arena;
68 } FREE_LIST_ENTRY;
69
70 struct tagHEAP;
71
72 typedef struct tagSUBHEAP
73 {
74 DWORD size; /* Size of the whole sub-heap */
75 DWORD commitSize; /* Committed size of the sub-heap */
76 DWORD headerSize; /* Size of the heap header */
77 struct tagSUBHEAP *next; /* Next sub-heap */
78 struct tagHEAP *heap; /* Main heap structure */
79 DWORD magic; /* Magic number */
80 WORD selector; /* Selector for HEAP_WINE_SEGPTR heaps */
81 } SUBHEAP;
82
83 #define SUBHEAP_MAGIC ((DWORD)('S' | ('U'<<8) | ('B'<<16) | ('H'<<24)))
84
85 typedef struct tagHEAP
86 {
87 SUBHEAP subheap; /* First sub-heap */
88 struct tagHEAP *next; /* Next heap for this process */
89 FREE_LIST_ENTRY freeList[HEAP_NB_FREE_LISTS]; /* Free lists */
90 CRITICAL_SECTION critSection; /* Critical section for serialization */
91 DWORD flags; /* Heap flags */
92 DWORD magic; /* Magic number */
93 } HEAP;
94
95 #define HEAP_MAGIC ((DWORD)('H' | ('E'<<8) | ('A'<<16) | ('P'<<24)))
96
97 #define HEAP_DEF_SIZE 0x110000 /* Default heap size = 1Mb + 64Kb */
98 #define HEAP_MIN_BLOCK_SIZE (8+sizeof(ARENA_FREE)) /* Min. heap block size */
99
100 HANDLE SystemHeap = 0;
101 HANDLE SegptrHeap = 0;
102
103
104 /***********************************************************************
105 * HEAP_Dump
106 */
107 void HEAP_Dump( HEAP *heap )
108 {
109 int i;
110 SUBHEAP *subheap;
111 char *ptr;
112
113 DUMP( "Heap: %08lx\n", (DWORD)heap );
114 DUMP( "Next: %08lx Sub-heaps: %08lx",
115 (DWORD)heap->next, (DWORD)&heap->subheap );
116 subheap = &heap->subheap;
117 while (subheap->next)
118 {
119 DUMP( " -> %08lx", (DWORD)subheap->next );
120 subheap = subheap->next;
121 }
122
123 DUMP( "\nFree lists:\n Block Stat Size Id\n" );
124 for (i = 0; i < HEAP_NB_FREE_LISTS; i++)
125 DUMP( "%08lx free %08lx %04x prev=%08lx next=%08lx\n",
126 (DWORD)&heap->freeList[i].arena, heap->freeList[i].arena.size,
127 heap->freeList[i].arena.threadId,
128 (DWORD)heap->freeList[i].arena.prev,
129 (DWORD)heap->freeList[i].arena.next );
130
131 subheap = &heap->subheap;
132 while (subheap)
133 {
134 DWORD freeSize = 0, usedSize = 0, arenaSize = subheap->headerSize;
135 DUMP( "\n\nSub-heap %08lx: size=%08lx committed=%08lx\n",
136 (DWORD)subheap, subheap->size, subheap->commitSize );
137
138 DUMP( "\n Block Stat Size Id\n" );
139 ptr = (char*)subheap + subheap->headerSize;
140 while (ptr < (char *)subheap + subheap->size)
141 {
142 if (*(DWORD *)ptr & ARENA_FLAG_FREE)
143 {
144 ARENA_FREE *pArena = (ARENA_FREE *)ptr;
145 DUMP( "%08lx free %08lx %04x prev=%08lx next=%08lx\n",
146 (DWORD)pArena, pArena->size & ARENA_SIZE_MASK,
147 pArena->threadId, (DWORD)pArena->prev,
148 (DWORD)pArena->next);
149 ptr += sizeof(*pArena) + (pArena->size & ARENA_SIZE_MASK);
150 arenaSize += sizeof(ARENA_FREE);
151 freeSize += pArena->size & ARENA_SIZE_MASK;
152 }
153 else if (*(DWORD *)ptr & ARENA_FLAG_PREV_FREE)
154 {
155 ARENA_INUSE *pArena = (ARENA_INUSE *)ptr;
156 DUMP( "%08lx Used %08lx %04x back=%08lx EIP=%08lx\n",
157 (DWORD)pArena, pArena->size & ARENA_SIZE_MASK,
158 pArena->threadId, *((DWORD *)pArena - 1),
159 pArena->callerEIP );
160 ptr += sizeof(*pArena) + (pArena->size & ARENA_SIZE_MASK);
161 arenaSize += sizeof(ARENA_INUSE);
162 usedSize += pArena->size & ARENA_SIZE_MASK;
163 }
164 else
165 {
166 ARENA_INUSE *pArena = (ARENA_INUSE *)ptr;
167 DUMP( "%08lx used %08lx %04x EIP=%08lx\n",
168 (DWORD)pArena, pArena->size & ARENA_SIZE_MASK,
169 pArena->threadId, pArena->callerEIP );
170 ptr += sizeof(*pArena) + (pArena->size & ARENA_SIZE_MASK);
171 arenaSize += sizeof(ARENA_INUSE);
172 usedSize += pArena->size & ARENA_SIZE_MASK;
173 }
174 }
175 DUMP( "\nTotal: Size=%08lx Committed=%08lx Free=%08lx Used=%08lx Arenas=%08lx (%ld%%)\n\n",
176 subheap->size, subheap->commitSize, freeSize, usedSize,
177 arenaSize, (arenaSize * 100) / subheap->size );
178 subheap = subheap->next;
179 }
180 }
181
182
183 /***********************************************************************
184 * HEAP_GetPtr
185 * RETURNS
186 * Pointer to the heap
187 * NULL: Failure
188 */
189 static HEAP *HEAP_GetPtr(
190 HANDLE heap /* [in] Handle to the heap */
191 ) {
192 HEAP *heapPtr = (HEAP *)heap;
193 if (!heapPtr || (heapPtr->magic != HEAP_MAGIC))
194 {
195 ERR(heap, "Invalid heap %08x!\n", heap );
196 SetLastError( ERROR_INVALID_HANDLE );
197 return NULL;
198 }
199 if (TRACE_ON(heap) && !HeapValidate( heap, 0, NULL ))
200 {
201 HEAP_Dump( heapPtr );
202 assert( FALSE );
203 SetLastError( ERROR_INVALID_HANDLE );
204 return NULL;
205 }
206 return heapPtr;
207 }
208
209
210 /***********************************************************************
211 * HEAP_InsertFreeBlock
212 *
213 * Insert a free block into the free list.
214 */
215 static void HEAP_InsertFreeBlock( HEAP *heap, ARENA_FREE *pArena )
216 {
217 FREE_LIST_ENTRY *pEntry = heap->freeList;
218 while (pEntry->size < pArena->size) pEntry++;
219 pArena->size |= ARENA_FLAG_FREE;
220 pArena->next = pEntry->arena.next;
221 pArena->next->prev = pArena;
222 pArena->prev = &pEntry->arena;
223 pEntry->arena.next = pArena;
224 }
225
226
227 /***********************************************************************
228 * HEAP_FindSubHeap
229 * Find the sub-heap containing a given address.
230 *
231 * RETURNS
232 * Pointer: Success
233 * NULL: Failure
234 */
235 static SUBHEAP *HEAP_FindSubHeap(
236 HEAP *heap, /* [in] Heap pointer */
237 LPCVOID ptr /* [in] Address */
238 ) {
239 SUBHEAP *sub = &heap->subheap;
240 while (sub)
241 {
242 if (((char *)ptr >= (char *)sub) &&
243 ((char *)ptr < (char *)sub + sub->size)) return sub;
244 sub = sub->next;
245 }
246 return NULL;
247 }
248
249
250 /***********************************************************************
251 * HEAP_Commit
252 *
253 * Make sure the heap storage is committed up to (not including) ptr.
254 */
255 static BOOL HEAP_Commit( SUBHEAP *subheap, void *ptr )
256 {
257 DWORD size = (DWORD)((char *)ptr - (char *)subheap);
258 size = (size + 0xfff) & 0xfffff000; /* Align size on a page boundary */
259 if (size > subheap->size) size = subheap->size;
260 if (size <= subheap->commitSize) return TRUE;
261 if (!VirtualAlloc( (char *)subheap + subheap->commitSize,
262 size - subheap->commitSize, MEM_COMMIT,
263 PAGE_EXECUTE_READWRITE))
264 {
265 WARN(heap, "Could not commit %08lx bytes at %08lx for heap %08lx\n",
266 size - subheap->commitSize,
267 (DWORD)((char *)subheap + subheap->commitSize),
268 (DWORD)subheap->heap );
269 return FALSE;
270 }
271 subheap->commitSize = size;
272 return TRUE;
273 }
274
275
276 /***********************************************************************
277 * HEAP_Decommit
278 *
279 * If possible, decommit the heap storage from (including) 'ptr'.
280 */
281 static BOOL HEAP_Decommit( SUBHEAP *subheap, void *ptr )
282 {
283 DWORD size = (DWORD)((char *)ptr - (char *)subheap);
284 size = (size + 0xfff) & 0xfffff000; /* Align size on a page boundary */
285 if (size >= subheap->commitSize) return TRUE;
286 if (!VirtualFree( (char *)subheap + size,
287 subheap->commitSize - size, MEM_DECOMMIT ))
288 {
289 WARN(heap, "Could not decommit %08lx bytes at %08lx for heap %08lx\n",
290 subheap->commitSize - size,
291 (DWORD)((char *)subheap + size),
292 (DWORD)subheap->heap );
293 return FALSE;
294 }
295 subheap->commitSize = size;
296 return TRUE;
297 }
298
299
300 /***********************************************************************
301 * HEAP_CreateFreeBlock
302 *
303 * Create a free block at a specified address. 'size' is the size of the
304 * whole block, including the new arena.
305 */
306 static void HEAP_CreateFreeBlock( SUBHEAP *subheap, void *ptr, DWORD size )
307 {
308 ARENA_FREE *pFree;
309
310 /* Create a free arena */
311
312 pFree = (ARENA_FREE *)ptr;
313 pFree->threadId = GetCurrentTask();
314 pFree->magic = ARENA_FREE_MAGIC;
315
316 /* If debugging, erase the freed block content */
317
318 if (TRACE_ON(heap))
319 {
320 char *pEnd = (char *)ptr + size;
321 if (pEnd > (char *)subheap + subheap->commitSize)
322 pEnd = (char *)subheap + subheap->commitSize;
323 if (pEnd > (char *)(pFree + 1))
324 memset( pFree + 1, ARENA_FREE_FILLER, pEnd - (char *)(pFree + 1) );
325 }
326
327 /* Check if next block is free also */
328
329 if (((char *)ptr + size < (char *)subheap + subheap->size) &&
330 (*(DWORD *)((char *)ptr + size) & ARENA_FLAG_FREE))
331 {
332 /* Remove the next arena from the free list */
333 ARENA_FREE *pNext = (ARENA_FREE *)((char *)ptr + size);
334 pNext->next->prev = pNext->prev;
335 pNext->prev->next = pNext->next;
336 size += (pNext->size & ARENA_SIZE_MASK) + sizeof(*pNext);
337 if (TRACE_ON(heap))
338 memset( pNext, ARENA_FREE_FILLER, sizeof(ARENA_FREE) );
339 }
340
341 /* Set the next block PREV_FREE flag and pointer */
342
343 if ((char *)ptr + size < (char *)subheap + subheap->size)
344 {
345 DWORD *pNext = (DWORD *)((char *)ptr + size);
346 *pNext |= ARENA_FLAG_PREV_FREE;
347 *(ARENA_FREE **)(pNext - 1) = pFree;
348 }
349
350 /* Last, insert the new block into the free list */
351
352 pFree->size = size - sizeof(*pFree);
353 HEAP_InsertFreeBlock( subheap->heap, pFree );
354 }
355
356
357 /***********************************************************************
358 * HEAP_MakeInUseBlockFree
359 *
360 * Turn an in-use block into a free block. Can also decommit the end of
361 * the heap, and possibly even free the sub-heap altogether.
362 */
363 static void HEAP_MakeInUseBlockFree( SUBHEAP *subheap, ARENA_INUSE *pArena )
364 {
365 ARENA_FREE *pFree;
366 DWORD size = (pArena->size & ARENA_SIZE_MASK) + sizeof(*pArena);
367
368 /* Check if we can merge with previous block */
369
370 if (pArena->size & ARENA_FLAG_PREV_FREE)
371 {
372 pFree = *((ARENA_FREE **)pArena - 1);
373 size += (pFree->size & ARENA_SIZE_MASK) + sizeof(ARENA_FREE);
374 /* Remove it from the free list */
375 pFree->next->prev = pFree->prev;
376 pFree->prev->next = pFree->next;
377 }
378 else pFree = (ARENA_FREE *)pArena;
379
380 /* Create a free block */
381
382 HEAP_CreateFreeBlock( subheap, pFree, size );
383 size = (pFree->size & ARENA_SIZE_MASK) + sizeof(ARENA_FREE);
384 if ((char *)pFree + size < (char *)subheap + subheap->size)
385 return; /* Not the last block, so nothing more to do */
386
387 /* Free the whole sub-heap if it's empty and not the original one */
388
389 if (((char *)pFree == (char *)subheap + subheap->headerSize) &&
390 (subheap != &subheap->heap->subheap))
391 {
392 SUBHEAP *pPrev = &subheap->heap->subheap;
393 /* Remove the free block from the list */
394 pFree->next->prev = pFree->prev;
395 pFree->prev->next = pFree->next;
396 /* Remove the subheap from the list */
397 while (pPrev && (pPrev->next != subheap)) pPrev = pPrev->next;
398 if (pPrev) pPrev->next = subheap->next;
399 /* Free the memory */
400 subheap->magic = 0;
401 if (subheap->selector) FreeSelector16( subheap->selector );
402 VirtualFree( subheap, 0, MEM_RELEASE );
403 return;
404 }
405
406 /* Decommit the end of the heap */
407
408 HEAP_Decommit( subheap, pFree + 1 );
409 }
410
411
412 /***********************************************************************
413 * HEAP_ShrinkBlock
414 *
415 * Shrink an in-use block.
416 */
417 static void HEAP_ShrinkBlock(SUBHEAP *subheap, ARENA_INUSE *pArena, DWORD size)
418 {
419 if ((pArena->size & ARENA_SIZE_MASK) >= size + HEAP_MIN_BLOCK_SIZE)
420 {
421 HEAP_CreateFreeBlock( subheap, (char *)(pArena + 1) + size,
422 (pArena->size & ARENA_SIZE_MASK) - size );
423 pArena->size = (pArena->size & ~ARENA_SIZE_MASK) | size;
424 }
425 else
426 {
427 /* Turn off PREV_FREE flag in next block */
428 char *pNext = (char *)(pArena + 1) + (pArena->size & ARENA_SIZE_MASK);
429 if (pNext < (char *)subheap + subheap->size)
430 *(DWORD *)pNext &= ~ARENA_FLAG_PREV_FREE;
431 }
432 }
433
434 /***********************************************************************
435 * HEAP_InitSubHeap
436 */
437 static BOOL HEAP_InitSubHeap( HEAP *heap, LPVOID address, DWORD flags,
438 DWORD commitSize, DWORD totalSize )
439 {
440 SUBHEAP *subheap = (SUBHEAP *)address;
441 WORD selector = 0;
442 FREE_LIST_ENTRY *pEntry;
443 int i;
444
445 /* Commit memory */
446
447 if (!VirtualAlloc(address, commitSize, MEM_COMMIT, PAGE_EXECUTE_READWRITE))
448 {
449 WARN(heap, "Could not commit %08lx bytes for sub-heap %08lx\n",
450 commitSize, (DWORD)address );
451 return FALSE;
452 }
453
454 /* Allocate a selector if needed */
455
456 if (flags & HEAP_WINE_SEGPTR)
457 {
458 selector = SELECTOR_AllocBlock( address, totalSize,
459 (flags & (HEAP_WINE_CODESEG|HEAP_WINE_CODE16SEG))
460 ? SEGMENT_CODE : SEGMENT_DATA,
461 (flags & HEAP_WINE_CODESEG) != 0, FALSE );
462 if (!selector)
463 {
464 ERR(heap, "Could not allocate selector\n" );
465 return FALSE;
466 }
467 }
468
469 /* Fill the sub-heap structure */
470
471 subheap->heap = heap;
472 subheap->selector = selector;
473 subheap->size = totalSize;
474 subheap->commitSize = commitSize;
475 subheap->magic = SUBHEAP_MAGIC;
476
477 if ( subheap != (SUBHEAP *)heap )
478 {
479 /* If this is a secondary subheap, insert it into list */
480
481 subheap->headerSize = sizeof(SUBHEAP);
482 subheap->next = heap->subheap.next;
483 heap->subheap.next = subheap;
484 }
485 else
486 {
487 /* If this is a primary subheap, initialize main heap */
488
489 subheap->headerSize = sizeof(HEAP);
490 subheap->next = NULL;
491 heap->next = NULL;
492 heap->flags = flags;
493 heap->magic = HEAP_MAGIC;
494
495 /* Build the free lists */
496
497 for (i = 0, pEntry = heap->freeList; i < HEAP_NB_FREE_LISTS; i++, pEntry++)
498 {
499 pEntry->size = HEAP_freeListSizes[i];
500 pEntry->arena.size = 0 | ARENA_FLAG_FREE;
501 pEntry->arena.next = i < HEAP_NB_FREE_LISTS-1 ?
502 &heap->freeList[i+1].arena : &heap->freeList[0].arena;
503 pEntry->arena.prev = i ? &heap->freeList[i-1].arena :
504 &heap->freeList[HEAP_NB_FREE_LISTS-1].arena;
505 pEntry->arena.threadId = 0;
506 pEntry->arena.magic = ARENA_FREE_MAGIC;
507 }
508
509 /* Initialize critical section */
510
511 InitializeCriticalSection( &heap->critSection );
512 if (!SystemHeap) /* System heap critical section has to be global */
513 MakeCriticalSectionGlobal( &heap->critSection );
514 }
515
516 /* Create the first free block */
517
518 HEAP_CreateFreeBlock( subheap, (LPBYTE)subheap + subheap->headerSize,
519 subheap->size - subheap->headerSize );
520
521 return TRUE;
522 }
523
524 /***********************************************************************
525 * HEAP_CreateSubHeap
526 *
527 * Create a sub-heap of the given size.
528 * If heap == NULL, creates a main heap.
529 */
530 static SUBHEAP *HEAP_CreateSubHeap( HEAP *heap, DWORD flags,
531 DWORD commitSize, DWORD totalSize )
532 {
533 LPVOID address;
534
535 /* Round-up sizes on a 64K boundary */
536
537 if (flags & HEAP_WINE_SEGPTR)
538 {
539 totalSize = commitSize = 0x10000; /* Only 64K at a time for SEGPTRs */
540 }
541 else
542 {
543 totalSize = (totalSize + 0xffff) & 0xffff0000;
544 commitSize = (commitSize + 0xffff) & 0xffff0000;
545 if (!commitSize) commitSize = 0x10000;
546 if (totalSize < commitSize) totalSize = commitSize;
547 }
548
549 /* Allocate the memory block */
550
551 if (!(address = VirtualAlloc( NULL, totalSize,
552 MEM_RESERVE, PAGE_EXECUTE_READWRITE )))
553 {
554 WARN(heap, "Could not VirtualAlloc %08lx bytes\n",
555 totalSize );
556 return NULL;
557 }
558
559 /* Initialize subheap */
560
561 if (!HEAP_InitSubHeap( heap? heap : (HEAP *)address,
562 address, flags, commitSize, totalSize ))
563 {
564 VirtualFree( address, 0, MEM_RELEASE );
565 return NULL;
566 }
567
568 return (SUBHEAP *)address;
569 }
570
571
572 /***********************************************************************
573 * HEAP_FindFreeBlock
574 *
575 * Find a free block at least as large as the requested size, and make sure
576 * the requested size is committed.
577 */
578 static ARENA_FREE *HEAP_FindFreeBlock( HEAP *heap, DWORD size,
579 SUBHEAP **ppSubHeap )
580 {
581 SUBHEAP *subheap;
582 ARENA_FREE *pArena;
583 FREE_LIST_ENTRY *pEntry = heap->freeList;
584
585 /* Find a suitable free list, and in it find a block large enough */
586
587 while (pEntry->size < size) pEntry++;
588 pArena = pEntry->arena.next;
589 while (pArena != &heap->freeList[0].arena)
590 {
591 if (pArena->size > size)
592 {
593 subheap = HEAP_FindSubHeap( heap, pArena );
594 if (!HEAP_Commit( subheap, (char *)pArena + sizeof(ARENA_INUSE)
595 + size + HEAP_MIN_BLOCK_SIZE))
596 return NULL;
597 *ppSubHeap = subheap;
598 return pArena;
599 }
600
601 pArena = pArena->next;
602 }
603
604 /* If no block was found, attempt to grow the heap */
605
606 if (!(heap->flags & HEAP_GROWABLE))
607 {
608 WARN(heap, "Not enough space in heap %08lx for %08lx bytes\n",
609 (DWORD)heap, size );
610 return NULL;
611 }
612 size += sizeof(SUBHEAP) + sizeof(ARENA_FREE);
613 if (!(subheap = HEAP_CreateSubHeap( heap, heap->flags, size,
614 MAX( HEAP_DEF_SIZE, size ) )))
615 return NULL;
616
617 TRACE(heap, "created new sub-heap %08lx of %08lx bytes for heap %08lx\n",
618 (DWORD)subheap, size, (DWORD)heap );
619
620 *ppSubHeap = subheap;
621 return (ARENA_FREE *)(subheap + 1);
622 }
623
624
625 /***********************************************************************
626 * HEAP_IsValidArenaPtr
627 *
628 * Check that the pointer is inside the range possible for arenas.
629 */
630 static BOOL HEAP_IsValidArenaPtr( HEAP *heap, void *ptr )
631 {
632 int i;
633 SUBHEAP *subheap = HEAP_FindSubHeap( heap, ptr );
634 if (!subheap) return FALSE;
635 if ((char *)ptr >= (char *)subheap + subheap->headerSize) return TRUE;
636 if (subheap != &heap->subheap) return FALSE;
637 for (i = 0; i < HEAP_NB_FREE_LISTS; i++)
638 if (ptr == (void *)&heap->freeList[i].arena) return TRUE;
639 return FALSE;
640 }
641
642
643 /***********************************************************************
644 * HEAP_ValidateFreeArena
645 */
646 static BOOL HEAP_ValidateFreeArena( SUBHEAP *subheap, ARENA_FREE *pArena )
647 {
648 char *heapEnd = (char *)subheap + subheap->size;
649
650 /* Check magic number */
651 if (pArena->magic != ARENA_FREE_MAGIC)
652 {
653 ERR(heap, "Heap %08lx: invalid free arena magic for %08lx\n",
654 (DWORD)subheap->heap, (DWORD)pArena );
655 return FALSE;
656 }
657 /* Check size flags */
658 if (!(pArena->size & ARENA_FLAG_FREE) ||
659 (pArena->size & ARENA_FLAG_PREV_FREE))
660 {
661 ERR(heap, "Heap %08lx: bad flags %lx for free arena %08lx\n",
662 (DWORD)subheap->heap, pArena->size & ~ARENA_SIZE_MASK, (DWORD)pArena );
663 }
664 /* Check arena size */
665 if ((char *)(pArena + 1) + (pArena->size & ARENA_SIZE_MASK) > heapEnd)
666 {
667 ERR(heap, "Heap %08lx: bad size %08lx for free arena %08lx\n",
668 (DWORD)subheap->heap, (DWORD)pArena->size & ARENA_SIZE_MASK, (DWORD)pArena );
669 return FALSE;
670 }
671 /* Check that next pointer is valid */
672 if (!HEAP_IsValidArenaPtr( subheap->heap, pArena->next ))
673 {
674 ERR(heap, "Heap %08lx: bad next ptr %08lx for arena %08lx\n",
675 (DWORD)subheap->heap, (DWORD)pArena->next, (DWORD)pArena );
676 return FALSE;
677 }
678 /* Check that next arena is free */
679 if (!(pArena->next->size & ARENA_FLAG_FREE) ||
680 (pArena->next->magic != ARENA_FREE_MAGIC))
681 {
682 ERR(heap, "Heap %08lx: next arena %08lx invalid for %08lx\n",
683 (DWORD)subheap->heap, (DWORD)pArena->next, (DWORD)pArena );
684 return FALSE;
685 }
686 /* Check that prev pointer is valid */
687 if (!HEAP_IsValidArenaPtr( subheap->heap, pArena->prev ))
688 {
689 ERR(heap, "Heap %08lx: bad prev ptr %08lx for arena %08lx\n",
690 (DWORD)subheap->heap, (DWORD)pArena->prev, (DWORD)pArena );
691 return FALSE;
692 }
693 /* Check that prev arena is free */
694 if (!(pArena->prev->size & ARENA_FLAG_FREE) ||
695 (pArena->prev->magic != ARENA_FREE_MAGIC))
696 {
697 ERR(heap, "Heap %08lx: prev arena %08lx invalid for %08lx\n",
698 (DWORD)subheap->heap, (DWORD)pArena->prev, (DWORD)pArena );
699 return FALSE;
700 }
701 /* Check that next block has PREV_FREE flag */
702 if ((char *)(pArena + 1) + (pArena->size & ARENA_SIZE_MASK) < heapEnd)
703 {
704 if (!(*(DWORD *)((char *)(pArena + 1) +
705 (pArena->size & ARENA_SIZE_MASK)) & ARENA_FLAG_PREV_FREE))
706 {
707 ERR(heap, "Heap %08lx: free arena %08lx next block has no PREV_FREE flag\n",
708 (DWORD)subheap->heap, (DWORD)pArena );
709 return FALSE;
710 }
711 /* Check next block back pointer */
712 if (*((ARENA_FREE **)((char *)(pArena + 1) +
713 (pArena->size & ARENA_SIZE_MASK)) - 1) != pArena)
714 {
715 ERR(heap, "Heap %08lx: arena %08lx has wrong back ptr %08lx\n",
716 (DWORD)subheap->heap, (DWORD)pArena,
717 *((DWORD *)((char *)(pArena+1)+ (pArena->size & ARENA_SIZE_MASK)) - 1));
718 return FALSE;
719 }
720 }
721 return TRUE;
722 }
723
724
725 /***********************************************************************
726 * HEAP_ValidateInUseArena
727 */
728 static BOOL HEAP_ValidateInUseArena( SUBHEAP *subheap, ARENA_INUSE *pArena )
729 {
730 char *heapEnd = (char *)subheap + subheap->size;
731
732 /* Check magic number */
733 if (pArena->magic != ARENA_INUSE_MAGIC)
734 {
735 ERR(heap, "Heap %08lx: invalid in-use arena magic for %08lx\n",
736 (DWORD)subheap->heap, (DWORD)pArena );
737 return FALSE;
738 }
739 /* Check size flags */
740 if (pArena->size & ARENA_FLAG_FREE)
741 {
742 ERR(heap, "Heap %08lx: bad flags %lx for in-use arena %08lx\n",
743 (DWORD)subheap->heap, pArena->size & ~ARENA_SIZE_MASK, (DWORD)pArena );
744 }
745 /* Check arena size */
746 if ((char *)(pArena + 1) + (pArena->size & ARENA_SIZE_MASK) > heapEnd)
747 {
748 ERR(heap, "Heap %08lx: bad size %08lx for in-use arena %08lx\n",
749 (DWORD)subheap->heap, (DWORD)pArena->size & ARENA_SIZE_MASK, (DWORD)pArena );
750 return FALSE;
751 }
752 /* Check next arena PREV_FREE flag */
753 if (((char *)(pArena + 1) + (pArena->size & ARENA_SIZE_MASK) < heapEnd) &&
754 (*(DWORD *)((char *)(pArena + 1) + (pArena->size & ARENA_SIZE_MASK)) & ARENA_FLAG_PREV_FREE))
755 {
756 ERR(heap, "Heap %08lx: in-use arena %08lx next block has PREV_FREE flag\n",
757 (DWORD)subheap->heap, (DWORD)pArena );
758 return FALSE;
759 }
760 /* Check prev free arena */
761 if (pArena->size & ARENA_FLAG_PREV_FREE)
762 {
763 ARENA_FREE *pPrev = *((ARENA_FREE **)pArena - 1);
764 /* Check prev pointer */
765 if (!HEAP_IsValidArenaPtr( subheap->heap, pPrev ))
766 {
767 ERR(heap, "Heap %08lx: bad back ptr %08lx for arena %08lx\n",
768 (DWORD)subheap->heap, (DWORD)pPrev, (DWORD)pArena );
769 return FALSE;
770 }
771 /* Check that prev arena is free */
772 if (!(pPrev->size & ARENA_FLAG_FREE) ||
773 (pPrev->magic != ARENA_FREE_MAGIC))
774 {
775 ERR(heap, "Heap %08lx: prev arena %08lx invalid for in-use %08lx\n",
776 (DWORD)subheap->heap, (DWORD)pPrev, (DWORD)pArena );
777 return FALSE;
778 }
779 /* Check that prev arena is really the previous block */
780 if ((char *)(pPrev + 1) + (pPrev->size & ARENA_SIZE_MASK) != (char *)pArena)
781 {
782 ERR(heap, "Heap %08lx: prev arena %08lx is not prev for in-use %08lx\n",
783 (DWORD)subheap->heap, (DWORD)pPrev, (DWORD)pArena );
784 return FALSE;
785 }
786 }
787 return TRUE;
788 }
789
790
791 /***********************************************************************
792 * HEAP_IsInsideHeap
793 * Checks whether the pointer points to a block inside a given heap.
794 *
795 * NOTES
796 * Should this return BOOL32?
797 *
798 * RETURNS
799 * !0: Success
800 * 0: Failure
801 */
802 int HEAP_IsInsideHeap(
803 HANDLE heap, /* [in] Heap */
804 DWORD flags, /* [in] Flags */
805 LPCVOID ptr /* [in] Pointer */
806 ) {
807 HEAP *heapPtr = HEAP_GetPtr( heap );
808 SUBHEAP *subheap;
809 int ret;
810
811 /* Validate the parameters */
812
813 if (!heapPtr) return 0;
814 flags |= heapPtr->flags;
815 if (!(flags & HEAP_NO_SERIALIZE)) HeapLock( heap );
816 ret = (((subheap = HEAP_FindSubHeap( heapPtr, ptr )) != NULL) &&
817 (((char *)ptr >= (char *)subheap + subheap->headerSize
818 + sizeof(ARENA_INUSE))));
819 if (!(flags & HEAP_NO_SERIALIZE)) HeapUnlock( heap );
820 return ret;
821 }
822
823
824 /***********************************************************************
825 * HEAP_GetSegptr
826 *
827 * Transform a linear pointer into a SEGPTR. The pointer must have been
828 * allocated from a HEAP_WINE_SEGPTR heap.
829 */
830 SEGPTR HEAP_GetSegptr( HANDLE heap, DWORD flags, LPCVOID ptr )
831 {
832 HEAP *heapPtr = HEAP_GetPtr( heap );
833 SUBHEAP *subheap;
834 SEGPTR ret;
835
836 /* Validate the parameters */
837
838 if (!heapPtr) return 0;
839 flags |= heapPtr->flags;
840 if (!(flags & HEAP_WINE_SEGPTR))
841 {
842 ERR(heap, "Heap %08x is not a SEGPTR heap\n",
843 heap );
844 return 0;
845 }
846 if (!(flags & HEAP_NO_SERIALIZE)) HeapLock( heap );
847
848 /* Get the subheap */
849
850 if (!(subheap = HEAP_FindSubHeap( heapPtr, ptr )))
851 {
852 ERR(heap, "%p is not inside heap %08x\n",
853 ptr, heap );
854 if (!(flags & HEAP_NO_SERIALIZE)) HeapUnlock( heap );
855 return 0;
856 }
857
858 /* Build the SEGPTR */
859
860 ret = PTR_SEG_OFF_TO_SEGPTR(subheap->selector, (DWORD)ptr-(DWORD)subheap);
861 if (!(flags & HEAP_NO_SERIALIZE)) HeapUnlock( heap );
862 return ret;
863 }
864
865
866 /***********************************************************************
867 * HeapCreate (KERNEL32.336)
868 * RETURNS
869 * Handle of heap: Success
870 * NULL: Failure
871 */
872 HANDLE WINAPI HeapCreate(
873 DWORD flags, /* [in] Heap allocation flag */
874 DWORD initialSize, /* [in] Initial heap size */
875 DWORD maxSize /* [in] Maximum heap size */
876 ) {
877 SUBHEAP *subheap;
878
879 /* Allocate the heap block */
880
881 if (!maxSize)
882 {
883 maxSize = HEAP_DEF_SIZE;
884 flags |= HEAP_GROWABLE;
885 }
886 if (!(subheap = HEAP_CreateSubHeap( NULL, flags, initialSize, maxSize )))
887 {
888 SetLastError( ERROR_OUTOFMEMORY );
889 return 0;
890 }
891
892 return (HANDLE)subheap;
893 }
894
895 /***********************************************************************
896 * HeapDestroy (KERNEL32.337)
897 * RETURNS
898 * TRUE: Success
899 * FALSE: Failure
900 */
901 BOOL WINAPI HeapDestroy(
902 HANDLE heap /* [in] Handle of heap */
903 ) {
904 HEAP *heapPtr = HEAP_GetPtr( heap );
905 SUBHEAP *subheap;
906
907 TRACE(heap, "%08x\n", heap );
908 if (!heapPtr) return FALSE;
909
910 DeleteCriticalSection( &heapPtr->critSection );
911 subheap = &heapPtr->subheap;
912 while (subheap)
913 {
914 SUBHEAP *next = subheap->next;
915 if (subheap->selector) FreeSelector16( subheap->selector );
916 VirtualFree( subheap, 0, MEM_RELEASE );
917 subheap = next;
918 }
919 return TRUE;
920 }
921
922
923 /***********************************************************************
924 * HeapAlloc (KERNEL32.334)
925 * RETURNS
926 * Pointer to allocated memory block
927 * NULL: Failure
928 */
929 LPVOID WINAPI HeapAlloc(
930 HANDLE heap, /* [in] Handle of private heap block */
931 DWORD flags, /* [in] Heap allocation control flags */
932 DWORD size /* [in] Number of bytes to allocate */
933 ) {
934 ARENA_FREE *pArena;
935 ARENA_INUSE *pInUse;
936 SUBHEAP *subheap;
937 HEAP *heapPtr = HEAP_GetPtr( heap );
938
939 /* Validate the parameters */
940
941 if (!heapPtr) return NULL;
942 flags &= HEAP_GENERATE_EXCEPTIONS | HEAP_NO_SERIALIZE | HEAP_ZERO_MEMORY;
943 flags |= heapPtr->flags;
944 if (!(flags & HEAP_NO_SERIALIZE)) HeapLock( heap );
945 size = (size + 3) & ~3;
946 if (size < HEAP_MIN_BLOCK_SIZE) size = HEAP_MIN_BLOCK_SIZE;
947
948 /* Locate a suitable free block */
949
950 if (!(pArena = HEAP_FindFreeBlock( heapPtr, size, &subheap )))
951 {
952 TRACE(heap, "(%08x,%08lx,%08lx): returning NULL\n",
953 heap, flags, size );
954 if (!(flags & HEAP_NO_SERIALIZE)) HeapUnlock( heap );
955 SetLastError( ERROR_COMMITMENT_LIMIT );
956 return NULL;
957 }
958
959 /* Remove the arena from the free list */
960
961 pArena->next->prev = pArena->prev;
962 pArena->prev->next = pArena->next;
963
964 /* Build the in-use arena */
965
966 pInUse = (ARENA_INUSE *)pArena;
967 pInUse->size = (pInUse->size & ~ARENA_FLAG_FREE)
968 + sizeof(ARENA_FREE) - sizeof(ARENA_INUSE);
969 pInUse->callerEIP = *((DWORD *)&heap - 1); /* hack hack */
970 pInUse->threadId = GetCurrentTask();
971 pInUse->magic = ARENA_INUSE_MAGIC;
972
973 /* Shrink the block */
974
975 HEAP_ShrinkBlock( subheap, pInUse, size );
976
977 if (flags & HEAP_ZERO_MEMORY) memset( pInUse + 1, 0, size );
978 else if (TRACE_ON(heap)) memset( pInUse + 1, ARENA_INUSE_FILLER, size );
979
980 if (!(flags & HEAP_NO_SERIALIZE)) HeapUnlock( heap );
981
982 TRACE(heap, "(%08x,%08lx,%08lx): returning %08lx\n",
983 heap, flags, size, (DWORD)(pInUse + 1) );
984 return (LPVOID)(pInUse + 1);
985 }
986
987
988 /***********************************************************************
989 * HeapFree (KERNEL32.338)
990 * RETURNS
991 * TRUE: Success
992 * FALSE: Failure
993 */
994 BOOL WINAPI HeapFree(
995 HANDLE heap, /* [in] Handle of heap */
996 DWORD flags, /* [in] Heap freeing flags */
997 LPVOID ptr /* [in] Address of memory to free */
998 ) {
999 ARENA_INUSE *pInUse;
1000 SUBHEAP *subheap;
1001 HEAP *heapPtr = HEAP_GetPtr( heap );
1002
1003 /* Validate the parameters */
1004
1005 if (!heapPtr) return FALSE;
1006 flags &= HEAP_NO_SERIALIZE;
1007 flags |= heapPtr->flags;
1008 if (!(flags & HEAP_NO_SERIALIZE)) HeapLock( heap );
1009 if (!ptr)
1010 {
1011 WARN(heap, "(%08x,%08lx,%08lx): asked to free NULL\n",
1012 heap, flags, (DWORD)ptr );
1013 }
1014 if (!ptr || !HeapValidate( heap, HEAP_NO_SERIALIZE, ptr ))
1015 {
1016 if (!(flags & HEAP_NO_SERIALIZE)) HeapUnlock( heap );
1017 SetLastError( ERROR_INVALID_PARAMETER );
1018 TRACE(heap, "(%08x,%08lx,%08lx): returning FALSE\n",
1019 heap, flags, (DWORD)ptr );
1020 return FALSE;
1021 }
1022
1023 /* Turn the block into a free block */
1024
1025 pInUse = (ARENA_INUSE *)ptr - 1;
1026 subheap = HEAP_FindSubHeap( heapPtr, pInUse );
1027 HEAP_MakeInUseBlockFree( subheap, pInUse );
1028
1029 if (!(flags & HEAP_NO_SERIALIZE)) HeapUnlock( heap );
1030 /* SetLastError( 0 ); */
1031
1032 TRACE(heap, "(%08x,%08lx,%08lx): returning TRUE\n",
1033 heap, flags, (DWORD)ptr );
1034 return TRUE;
1035 }
1036
1037
1038 /***********************************************************************
1039 * HeapReAlloc (KERNEL32.340)
1040 * RETURNS
1041 * Pointer to reallocated memory block
1042 * NULL: Failure
1043 */
1044 LPVOID WINAPI HeapReAlloc(
1045 HANDLE heap, /* [in] Handle of heap block */
1046 DWORD flags, /* [in] Heap reallocation flags */
1047 LPVOID ptr, /* [in] Address of memory to reallocate */
1048 DWORD size /* [in] Number of bytes to reallocate */
1049 ) {
1050 ARENA_INUSE *pArena;
1051 DWORD oldSize;
1052 HEAP *heapPtr;
1053 SUBHEAP *subheap;
1054
1055 if (!ptr) return HeapAlloc( heap, flags, size ); /* FIXME: correct? */
1056 if (!(heapPtr = HEAP_GetPtr( heap ))) return FALSE;
1057
1058 /* Validate the parameters */
1059
1060 flags &= HEAP_GENERATE_EXCEPTIONS | HEAP_NO_SERIALIZE | HEAP_ZERO_MEMORY |
1061 HEAP_REALLOC_IN_PLACE_ONLY;
1062 flags |= heapPtr->flags;
1063 size = (size + 3) & ~3;
1064 if (size < HEAP_MIN_BLOCK_SIZE) size = HEAP_MIN_BLOCK_SIZE;
1065
1066 if (!(flags & HEAP_NO_SERIALIZE)) HeapLock( heap );
1067 if (!HeapValidate( heap, HEAP_NO_SERIALIZE, ptr ))
1068 {
1069 if (!(flags & HEAP_NO_SERIALIZE)) HeapUnlock( heap );
1070 SetLastError( ERROR_INVALID_PARAMETER );
1071 TRACE(heap, "(%08x,%08lx,%08lx,%08lx): returning NULL\n",
1072 heap, flags, (DWORD)ptr, size );
1073 return NULL;
1074 }
1075
1076 /* Check if we need to grow the block */
1077
1078 pArena = (ARENA_INUSE *)ptr - 1;
1079 pArena->threadId = GetCurrentTask();
1080 subheap = HEAP_FindSubHeap( heapPtr, pArena );
1081 oldSize = (pArena->size & ARENA_SIZE_MASK);
1082 if (size > oldSize)
1083 {
1084 char *pNext = (char *)(pArena + 1) + oldSize;
1085 if ((pNext < (char *)subheap + subheap->size) &&
1086 (*(DWORD *)pNext & ARENA_FLAG_FREE) &&
1087 (oldSize + (*(DWORD *)pNext & ARENA_SIZE_MASK) + sizeof(ARENA_FREE) >= size))
1088 {
1089 /* The next block is free and large enough */
1090 ARENA_FREE *pFree = (ARENA_FREE *)pNext;
1091 pFree->next->prev = pFree->prev;
1092 pFree->prev->next = pFree->next;
1093 pArena->size += (pFree->size & ARENA_SIZE_MASK) + sizeof(*pFree);
1094 if (!HEAP_Commit( subheap, (char *)pArena + sizeof(ARENA_INUSE)
1095 + size + HEAP_MIN_BLOCK_SIZE))
1096 {
1097 if (!(flags & HEAP_NO_SERIALIZE)) HeapUnlock( heap );
1098 SetLastError( ERROR_OUTOFMEMORY );
1099 return NULL;
1100 }
1101 HEAP_ShrinkBlock( subheap, pArena, size );
1102 }
1103 else /* Do it the hard way */
1104 {
1105 ARENA_FREE *pNew;
1106 ARENA_INUSE *pInUse;
1107 SUBHEAP *newsubheap;
1108
1109 if ((flags & HEAP_REALLOC_IN_PLACE_ONLY) ||
1110 !(pNew = HEAP_FindFreeBlock( heapPtr, size, &newsubheap )))
1111 {
1112 if (!(flags & HEAP_NO_SERIALIZE)) HeapUnlock( heap );
1113 SetLastError( ERROR_OUTOFMEMORY );
1114 return NULL;
1115 }
1116
1117 /* Build the in-use arena */
1118
1119 pNew->next->prev = pNew->prev;
1120 pNew->prev->next = pNew->next;
1121 pInUse = (ARENA_INUSE *)pNew;
1122 pInUse->size = (pInUse->size & ~ARENA_FLAG_FREE)
1123 + sizeof(ARENA_FREE) - sizeof(ARENA_INUSE);
1124 pInUse->threadId = GetCurrentTask();
1125 pInUse->magic = ARENA_INUSE_MAGIC;
1126 HEAP_ShrinkBlock( newsubheap, pInUse, size );
1127 memcpy( pInUse + 1, pArena + 1, oldSize );
1128
1129 /* Free the previous block */
1130
1131 HEAP_MakeInUseBlockFree( subheap, pArena );
1132 subheap = newsubheap;
1133 pArena = pInUse;
1134 }
1135 }
1136 else HEAP_ShrinkBlock( subheap, pArena, size ); /* Shrink the block */
1137
1138 /* Clear the extra bytes if needed */
1139
1140 if (size > oldSize)
1141 {
1142 if (flags & HEAP_ZERO_MEMORY)
1143 memset( (char *)(pArena + 1) + oldSize, 0,
1144 (pArena->size & ARENA_SIZE_MASK) - oldSize );
1145 else if (TRACE_ON(heap))
1146 memset( (char *)(pArena + 1) + oldSize, ARENA_INUSE_FILLER,
1147 (pArena->size & ARENA_SIZE_MASK) - oldSize );
1148 }
1149
1150 /* Return the new arena */
1151
1152 pArena->callerEIP = *((DWORD *)&heap - 1); /* hack hack */
1153 if (!(flags & HEAP_NO_SERIALIZE)) HeapUnlock( heap );
1154
1155 TRACE(heap, "(%08x,%08lx,%08lx,%08lx): returning %08lx\n",
1156 heap, flags, (DWORD)ptr, size, (DWORD)(pArena + 1) );
1157 return (LPVOID)(pArena + 1);
1158 }
1159
1160
1161 /***********************************************************************
1162 * HeapCompact (KERNEL32.335)
1163 */
1164 DWORD WINAPI HeapCompact( HANDLE heap, DWORD flags )
1165 {
1166 return 0;
1167 }
1168
1169
1170 /***********************************************************************
1171 * HeapLock (KERNEL32.339)
1172 * Attempts to acquire the critical section object for a specified heap.
1173 *
1174 * RETURNS
1175 * TRUE: Success
1176 * FALSE: Failure
1177 */
1178 BOOL WINAPI HeapLock(
1179 HANDLE heap /* [in] Handle of heap to lock for exclusive access */
1180 ) {
1181 HEAP *heapPtr = HEAP_GetPtr( heap );
1182 if (!heapPtr) return FALSE;
1183 EnterCriticalSection( &heapPtr->critSection );
1184 return TRUE;
1185 }
1186
1187
1188 /***********************************************************************
1189 * HeapUnlock (KERNEL32.342)
1190 * Releases ownership of the critical section object.
1191 *
1192 * RETURNS
1193 * TRUE: Success
1194 * FALSE: Failure
1195 */
1196 BOOL WINAPI HeapUnlock(
1197 HANDLE heap /* [in] Handle to the heap to unlock */
1198 ) {
1199 HEAP *heapPtr = HEAP_GetPtr( heap );
1200 if (!heapPtr) return FALSE;
1201 LeaveCriticalSection( &heapPtr->critSection );
1202 return TRUE;
1203 }
1204
1205
1206 /***********************************************************************
1207 * HeapSize (KERNEL32.341)
1208 * RETURNS
1209 * Size in bytes of allocated memory
1210 * 0xffffffff: Failure
1211 */
1212 DWORD WINAPI HeapSize(
1213 HANDLE heap, /* [in] Handle of heap */
1214 DWORD flags, /* [in] Heap size control flags */
1215 LPVOID ptr /* [in] Address of memory to return size for */
1216 ) {
1217 DWORD ret;
1218 HEAP *heapPtr = HEAP_GetPtr( heap );
1219
1220 if (!heapPtr) return FALSE;
1221 flags &= HEAP_NO_SERIALIZE;
1222 flags |= heapPtr->flags;
1223 if (!(flags & HEAP_NO_SERIALIZE)) HeapLock( heap );
1224 if (!HeapValidate( heap, HEAP_NO_SERIALIZE, ptr ))
1225 {
1226 SetLastError( ERROR_INVALID_PARAMETER );
1227 ret = 0xffffffff;
1228 }
1229 else
1230 {
1231 ARENA_INUSE *pArena = (ARENA_INUSE *)ptr - 1;
1232 ret = pArena->size & ARENA_SIZE_MASK;
1233 }
1234 if (!(flags & HEAP_NO_SERIALIZE)) HeapUnlock( heap );
1235
1236 TRACE(heap, "(%08x,%08lx,%08lx): returning %08lx\n",
1237 heap, flags, (DWORD)ptr, ret );
1238 return ret;
1239 }
1240
1241
1242 /***********************************************************************
1243 * HeapValidate (KERNEL32.343)
1244 * Validates a specified heap.
1245 *
1246 * NOTES
1247 * Flags is ignored.
1248 *
1249 * RETURNS
1250 * TRUE: Success
1251 * FALSE: Failure
1252 */
1253 BOOL WINAPI HeapValidate(
1254 HANDLE heap, /* [in] Handle to the heap */
1255 DWORD flags, /* [in] Bit flags that control access during operation */
1256 LPCVOID block /* [in] Optional pointer to memory block to validate */
1257 ) {
1258 SUBHEAP *subheap;
1259 HEAP *heapPtr = (HEAP *)(heap);
1260
1261 if (!heapPtr || (heapPtr->magic != HEAP_MAGIC))
1262 {
1263 ERR(heap, "Invalid heap %08x!\n", heap );
1264 return FALSE;
1265 }
1266
1267 if (block)
1268 {
1269 /* Only check this single memory block */
1270 if (!(subheap = HEAP_FindSubHeap( heapPtr, block )) ||
1271 ((char *)block < (char *)subheap + subheap->headerSize
1272 + sizeof(ARENA_INUSE)))
1273 {
1274 ERR(heap, "Heap %08lx: block %08lx is not inside heap\n",
1275 (DWORD)heap, (DWORD)block );
1276 return FALSE;
1277 }
1278 return HEAP_ValidateInUseArena( subheap, (ARENA_INUSE *)block - 1 );
1279 }
1280
1281 subheap = &heapPtr->subheap;
1282 while (subheap)
1283 {
1284 char *ptr = (char *)subheap + subheap->headerSize;
1285 while (ptr < (char *)subheap + subheap->size)
1286 {
1287 if (*(DWORD *)ptr & ARENA_FLAG_FREE)
1288 {
1289 if (!HEAP_ValidateFreeArena( subheap, (ARENA_FREE *)ptr ))
1290 return FALSE;
1291 ptr += sizeof(ARENA_FREE) + (*(DWORD *)ptr & ARENA_SIZE_MASK);
1292 }
1293 else
1294 {
1295 if (!HEAP_ValidateInUseArena( subheap, (ARENA_INUSE *)ptr ))
1296 return FALSE;
1297 ptr += sizeof(ARENA_INUSE) + (*(DWORD *)ptr & ARENA_SIZE_MASK);
1298 }
1299 }
1300 subheap = subheap->next;
1301 }
1302 return TRUE;
1303 }
1304
1305
1306 /***********************************************************************
1307 * HeapWalk (KERNEL32.344)
1308 * Enumerates the memory blocks in a specified heap.
1309 *
1310 * RETURNS
1311 * TRUE: Success
1312 * FALSE: Failure
1313 */
1314 BOOL WINAPI HeapWalk(
1315 HANDLE heap, /* [in] Handle to heap to enumerate */
1316 LPPROCESS_HEAP_ENTRY *entry /* [out] Pointer to structure of enumeration info */
1317 ) {
1318 FIXME(heap, "(%08x): stub.\n", heap );
1319 return FALSE;
1320 }
1321
1322
1323 /***********************************************************************
1324 * HEAP_xalloc
1325 *
1326 * Same as HeapAlloc(), but die on failure.
1327 */
1328 LPVOID HEAP_xalloc( HANDLE heap, DWORD flags, DWORD size )
1329 {
1330 LPVOID p = HeapAlloc( heap, flags, size );
1331 if (!p)
1332 {
1333 MSG("Virtual memory exhausted.\n" );
1334 exit(1);
1335 }
1336 return p;
1337 }
1338
1339
1340 /***********************************************************************
1341 * HEAP_strdupA
1342 */
1343 LPSTR HEAP_strdupA( HANDLE heap, DWORD flags, LPCSTR str )
1344 {
1345 LPSTR p = HEAP_xalloc( heap, flags, strlen(str) + 1 );
1346 strcpy( p, str );
1347 return p;
1348 }
1349
1350
1351 /***********************************************************************
1352 * HEAP_strdupW
1353 */
1354 LPWSTR HEAP_strdupW( HANDLE heap, DWORD flags, LPCWSTR str )
1355 {
1356 INT len = lstrlenW(str) + 1;
1357 LPWSTR p = HEAP_xalloc( heap, flags, len * sizeof(WCHAR) );
1358 lstrcpyW( p, str );
1359 return p;
1360 }
1361
1362
1363 /***********************************************************************
1364 * HEAP_strdupAtoW
1365 */
1366 LPWSTR HEAP_strdupAtoW( HANDLE heap, DWORD flags, LPCSTR str )
1367 {
1368 LPWSTR ret;
1369
1370 if (!str) return NULL;
1371 ret = HEAP_xalloc( heap, flags, (strlen(str)+1) * sizeof(WCHAR) );
1372 lstrcpyAtoW( ret, str );
1373 return ret;
1374 }
1375
1376
1377 /***********************************************************************
1378 * HEAP_strdupWtoA
1379 */
1380 LPSTR HEAP_strdupWtoA( HANDLE heap, DWORD flags, LPCWSTR str )
1381 {
1382 LPSTR ret;
1383
1384 if (!str) return NULL;
1385 ret = HEAP_xalloc( heap, flags, lstrlenW(str) + 1 );
1386 lstrcpyWtoA( ret, str );
1387 return ret;
1388 }
1389
1390
1391
1392 /***********************************************************************
1393 * 32-bit local heap functions (Win95; undocumented)
1394 */
1395
1396 #define HTABLE_SIZE 0x10000
1397 #define HTABLE_PAGESIZE 0x1000
1398 #define HTABLE_NPAGES (HTABLE_SIZE / HTABLE_PAGESIZE)
1399
1400 #pragma pack(1)
1401 typedef struct _LOCAL32HEADER
1402 {
1403 WORD freeListFirst[HTABLE_NPAGES];
1404 WORD freeListSize[HTABLE_NPAGES];
1405 WORD freeListLast[HTABLE_NPAGES];
1406
1407 DWORD selectorTableOffset;
1408 WORD selectorTableSize;
1409 WORD selectorDelta;
1410
1411 DWORD segment;
1412 LPBYTE base;
1413
1414 DWORD limit;
1415 DWORD flags;
1416
1417 DWORD magic;
1418 HANDLE heap;
1419
1420 } LOCAL32HEADER;
1421 #pragma pack(4)
1422
1423 #define LOCAL32_MAGIC ((DWORD)('L' | ('H'<<8) | ('3'<<16) | ('2'<<24)))
1424
1425 /***********************************************************************
1426 * Local32Init (KERNEL.208)
1427 */
1428 HANDLE WINAPI Local32Init16( WORD segment, DWORD tableSize,
1429 DWORD heapSize, DWORD flags )
1430 {
1431 DWORD totSize, segSize = 0;
1432 LPBYTE base;
1433 LOCAL32HEADER *header;
1434 HEAP *heap;
1435 WORD *selectorTable;
1436 WORD selectorEven, selectorOdd;
1437 int i, nrBlocks;
1438
1439 /* Determine new heap size */
1440
1441 if ( segment )
1442 {
1443 if ( (segSize = GetSelectorLimit16( segment )) == 0 )
1444 return 0;
1445 else
1446 segSize++;
1447 }
1448
1449 if ( heapSize == -1L )
1450 heapSize = 1024L*1024L; /* FIXME */
1451
1452 heapSize = (heapSize + 0xffff) & 0xffff0000;
1453 segSize = (segSize + 0x0fff) & 0xfffff000;
1454 totSize = segSize + HTABLE_SIZE + heapSize;
1455
1456
1457 /* Allocate memory and initialize heap */
1458
1459 if ( !(base = VirtualAlloc( NULL, totSize, MEM_RESERVE, PAGE_READWRITE )) )
1460 return 0;
1461
1462 if ( !VirtualAlloc( base, segSize + HTABLE_PAGESIZE,
1463 MEM_COMMIT, PAGE_READWRITE ) )
1464 {
1465 VirtualFree( base, 0, MEM_RELEASE );
1466 return 0;
1467 }
1468
1469 heap = (HEAP *)(base + segSize + HTABLE_SIZE);
1470 if ( !HEAP_InitSubHeap( heap, (LPVOID)heap, 0, 0x10000, heapSize ) )
1471 {
1472 VirtualFree( base, 0, MEM_RELEASE );
1473 return 0;
1474 }
1475
1476
1477 /* Set up header and handle table */
1478
1479 header = (LOCAL32HEADER *)(base + segSize);
1480 header->base = base;
1481 header->limit = HTABLE_PAGESIZE-1;
1482 header->flags = 0;
1483 header->magic = LOCAL32_MAGIC;
1484 header->heap = (HANDLE)heap;
1485
1486 header->freeListFirst[0] = sizeof(LOCAL32HEADER);
1487 header->freeListLast[0] = HTABLE_PAGESIZE - 4;
1488 header->freeListSize[0] = (HTABLE_PAGESIZE - sizeof(LOCAL32HEADER)) / 4;
1489
1490 for (i = header->freeListFirst[0]; i < header->freeListLast[0]; i += 4)
1491 *(DWORD *)((LPBYTE)header + i) = i+4;
1492
1493 header->freeListFirst[1] = 0xffff;
1494
1495
1496 /* Set up selector table */
1497
1498 nrBlocks = (totSize + 0x7fff) >> 15;
1499 selectorTable = (LPWORD) HeapAlloc( header->heap, 0, nrBlocks * 2 );
1500 selectorEven = SELECTOR_AllocBlock( base, totSize,
1501 SEGMENT_DATA, FALSE, FALSE );
1502 selectorOdd = SELECTOR_AllocBlock( base + 0x8000, totSize - 0x8000,
1503 SEGMENT_DATA, FALSE, FALSE );
1504
1505 if ( !selectorTable || !selectorEven || !selectorOdd )
1506 {
1507 if ( selectorTable ) HeapFree( header->heap, 0, selectorTable );
1508 if ( selectorEven ) SELECTOR_FreeBlock( selectorEven, totSize >> 16 );
1509 if ( selectorOdd ) SELECTOR_FreeBlock( selectorOdd, (totSize-0x8000) >> 16 );
1510 HeapDestroy( header->heap );
1511 VirtualFree( base, 0, MEM_RELEASE );
1512 return 0;
1513 }
1514
1515 header->selectorTableOffset = (LPBYTE)selectorTable - header->base;
1516 header->selectorTableSize = nrBlocks * 4; /* ??? Win95 does it this way! */
1517 header->selectorDelta = selectorEven - selectorOdd;
1518 header->segment = segment? segment : selectorEven;
1519
1520 for (i = 0; i < nrBlocks; i++)
1521 selectorTable[i] = (i & 1)? selectorOdd + ((i >> 1) << __AHSHIFT)
1522 : selectorEven + ((i >> 1) << __AHSHIFT);
1523
1524 /* Move old segment */
1525
1526 if ( segment )
1527 {
1528 /* FIXME: This is somewhat ugly and relies on implementation
1529 details about 16-bit global memory handles ... */
1530
1531 LPBYTE oldBase = (LPBYTE)GetSelectorBase( segment );
1532 memcpy( base, oldBase, segSize );
1533 GLOBAL_MoveBlock( segment, base, totSize );
1534 HeapFree( SystemHeap, 0, oldBase );
1535 }
1536
1537 return (HANDLE)header;
1538 }
1539
1540 /***********************************************************************
1541 * Local32_SearchHandle
1542 */
1543 static LPDWORD Local32_SearchHandle( LOCAL32HEADER *header, DWORD addr )
1544 {
1545 LPDWORD handle;
1546
1547 for ( handle = (LPDWORD)((LPBYTE)header + sizeof(LOCAL32HEADER));
1548 handle < (LPDWORD)((LPBYTE)header + header->limit);
1549 handle++)
1550 {
1551 if (*handle == addr)
1552 return handle;
1553 }
1554
1555 return NULL;
1556 }
1557
1558 /***********************************************************************
1559 * Local32_ToHandle
1560 */
1561 static VOID Local32_ToHandle( LOCAL32HEADER *header, INT16 type,
1562 DWORD addr, LPDWORD *handle, LPBYTE *ptr )
1563 {
1564 *handle = NULL;
1565 *ptr = NULL;
1566
1567 switch (type)
1568 {
1569 case -2: /* 16:16 pointer, no handles */
1570 *ptr = PTR_SEG_TO_LIN( addr );
1571 *handle = (LPDWORD)*ptr;
1572 break;
1573
1574 case -1: /* 32-bit offset, no handles */
1575 *ptr = header->base + addr;
1576 *handle = (LPDWORD)*ptr;
1577 break;
1578
1579 case 0: /* handle */
1580 if ( addr >= sizeof(LOCAL32HEADER)
1581 && addr < header->limit && !(addr & 3)
1582 && *(LPDWORD)((LPBYTE)header + addr) >= HTABLE_SIZE )
1583 {
1584 *handle = (LPDWORD)((LPBYTE)header + addr);
1585 *ptr = header->base + **handle;
1586 }
1587 break;
1588
1589 case 1: /* 16:16 pointer */
1590 *ptr = PTR_SEG_TO_LIN( addr );
1591 *handle = Local32_SearchHandle( header, *ptr - header->base );
1592 break;
1593
1594 case 2: /* 32-bit offset */
1595 *ptr = header->base + addr;
1596 *handle = Local32_SearchHandle( header, *ptr - header->base );
1597 break;
1598 }
1599 }
1600
1601 /***********************************************************************
1602 * Local32_FromHandle
1603 */
1604 static VOID Local32_FromHandle( LOCAL32HEADER *header, INT16 type,
1605 DWORD *addr, LPDWORD handle, LPBYTE ptr )
1606 {
1607 switch (type)
1608 {
1609 case -2: /* 16:16 pointer */
1610 case 1:
1611 {
1612 WORD *selTable = (LPWORD)(header->base + header->selectorTableOffset);
1613 DWORD offset = (LPBYTE)ptr - header->base;
1614 *addr = MAKELONG( offset & 0x7fff, selTable[offset >> 15] );
1615 }
1616 break;
1617
1618 case -1: /* 32-bit offset */
1619 case 2:
1620 *addr = ptr - header->base;
1621 break;
1622
1623 case 0: /* handle */
1624 *addr = (LPBYTE)handle - (LPBYTE)header;
1625 break;
1626 }
1627 }
1628
1629 /***********************************************************************
1630 * Local32Alloc (KERNEL.209)
1631 */
1632 DWORD WINAPI Local32Alloc16( HANDLE heap, DWORD size, INT16 type, DWORD flags )
1633 {
1634 LOCAL32HEADER *header = (LOCAL32HEADER *)heap;
1635 LPDWORD handle;
1636 LPBYTE ptr;
1637 DWORD addr;
1638
1639 /* Allocate memory */
1640 ptr = HeapAlloc( header->heap,
1641 (flags & LMEM_MOVEABLE)? HEAP_ZERO_MEMORY : 0, size );
1642 if (!ptr) return 0;
1643
1644
1645 /* Allocate handle if requested */
1646 if (type >= 0)
1647 {
1648 int page, i;
1649
1650 /* Find first page of handle table with free slots */
1651 for (page = 0; page < HTABLE_NPAGES; page++)
1652 if (header->freeListFirst[page] != 0)
1653 break;
1654 if (page == HTABLE_NPAGES)
1655 {
1656 WARN( heap, "Out of handles!\n" );
1657 HeapFree( header->heap, 0, ptr );
1658 return 0;
1659 }
1660
1661 /* If virgin page, initialize it */
1662 if (header->freeListFirst[page] == 0xffff)
1663 {
1664 if ( !VirtualAlloc( (LPBYTE)header + (page << 12),
1665 0x1000, MEM_COMMIT, PAGE_READWRITE ) )
1666 {
1667 WARN( heap, "Cannot grow handle table!\n" );
1668 HeapFree( header->heap, 0, ptr );
1669 return 0;
1670 }
1671
1672 header->limit += HTABLE_PAGESIZE;
1673
1674 header->freeListFirst[page] = 0;
1675 header->freeListLast[page] = HTABLE_PAGESIZE - 4;
1676 header->freeListSize[page] = HTABLE_PAGESIZE / 4;
1677
1678 for (i = 0; i < HTABLE_PAGESIZE; i += 4)
1679 *(DWORD *)((LPBYTE)header + i) = i+4;
1680
1681 if (page < HTABLE_NPAGES-1)
1682 header->freeListFirst[page+1] = 0xffff;
1683 }
1684
1685 /* Allocate handle slot from page */
1686 handle = (LPDWORD)((LPBYTE)header + header->freeListFirst[page]);
1687 if (--header->freeListSize[page] == 0)
1688 header->freeListFirst[page] = header->freeListLast[page] = 0;
1689 else
1690 header->freeListFirst[page] = *handle;
1691
1692 /* Store 32-bit offset in handle slot */
1693 *handle = ptr - header->base;
1694 }
1695 else
1696 {
1697 handle = (LPDWORD)ptr;
1698 header->flags |= 1;
1699 }
1700
1701
1702 /* Convert handle to requested output type */
1703 Local32_FromHandle( header, type, &addr, handle, ptr );
1704 return addr;
1705 }
1706
1707 /***********************************************************************
1708 * Local32ReAlloc (KERNEL.210)
1709 */
1710 DWORD WINAPI Local32ReAlloc16( HANDLE heap, DWORD addr, INT16 type,
1711 DWORD size, DWORD flags )
1712 {
1713 LOCAL32HEADER *header = (LOCAL32HEADER *)heap;
1714 LPDWORD handle;
1715 LPBYTE ptr;
1716
1717 if (!addr)
1718 return Local32Alloc16( heap, size, type, flags );
1719
1720 /* Retrieve handle and pointer */
1721 Local32_ToHandle( header, type, addr, &handle, &ptr );
1722 if (!handle) return FALSE;
1723
1724 /* Reallocate memory block */
1725 ptr = HeapReAlloc( header->heap,
1726 (flags & LMEM_MOVEABLE)? HEAP_ZERO_MEMORY : 0,
1727 ptr, size );
1728 if (!ptr) return 0;
1729
1730 /* Modify handle */
1731 if (type >= 0)
1732 *handle = ptr - header->base;
1733 else
1734 handle = (LPDWORD)ptr;
1735
1736 /* Convert handle to requested output type */
1737 Local32_FromHandle( header, type, &addr, handle, ptr );
1738 return addr;
1739 }
1740
1741 /***********************************************************************
1742 * Local32Free (KERNEL.211)
1743 */
1744 BOOL WINAPI Local32Free16( HANDLE heap, DWORD addr, INT16 type )
1745 {
1746 LOCAL32HEADER *header = (LOCAL32HEADER *)heap;
1747 LPDWORD handle;
1748 LPBYTE ptr;
1749
1750 /* Retrieve handle and pointer */
1751 Local32_ToHandle( header, type, addr, &handle, &ptr );
1752 if (!handle) return FALSE;
1753
1754 /* Free handle if necessary */
1755 if (type >= 0)
1756 {
1757 int offset = (LPBYTE)handle - (LPBYTE)header;
1758 int page = offset >> 12;
1759
1760 /* Return handle slot to page free list */
1761 if (header->freeListSize[page]++ == 0)
1762 header->freeListFirst[page] = header->freeListLast[page] = offset;
1763 else
1764 *(LPDWORD)((LPBYTE)header + header->freeListLast[page]) = offset,
1765 header->freeListLast[page] = offset;
1766
1767 *handle = 0;
1768
1769 /* Shrink handle table when possible */
1770 while (page > 0 && header->freeListSize[page] == HTABLE_PAGESIZE / 4)
1771 {
1772 if ( VirtualFree( (LPBYTE)header +
1773 (header->limit & ~(HTABLE_PAGESIZE-1)),
1774 HTABLE_PAGESIZE, MEM_DECOMMIT ) )
1775 break;
1776
1777 header->limit -= HTABLE_PAGESIZE;
1778 header->freeListFirst[page] = 0xffff;
1779 page--;
1780 }
1781 }
1782
1783 /* Free memory */
1784 return HeapFree( header->heap, 0, ptr );
1785 }
1786
1787 /***********************************************************************
1788 * Local32Translate (KERNEL.213)
1789 */
1790 DWORD WINAPI Local32Translate16( HANDLE heap, DWORD addr, INT16 type1, INT16 type2 )
1791 {
1792 LOCAL32HEADER *header = (LOCAL32HEADER *)heap;
1793 LPDWORD handle;
1794 LPBYTE ptr;
1795
1796 Local32_ToHandle( header, type1, addr, &handle, &ptr );
1797 if (!handle) return 0;
1798
1799 Local32_FromHandle( header, type2, &addr, handle, ptr );
1800 return addr;
1801 }
1802
1803 /***********************************************************************
1804 * Local32Size (KERNEL.214)
1805 */
1806 DWORD WINAPI Local32Size16( HANDLE heap, DWORD addr, INT16 type )
1807 {
1808 LOCAL32HEADER *header = (LOCAL32HEADER *)heap;
1809 LPDWORD handle;
1810 LPBYTE ptr;
1811
1812 Local32_ToHandle( header, type, addr, &handle, &ptr );
1813 if (!handle) return 0;
1814
1815 return HeapSize( header->heap, 0, ptr );
1816 }
1817
1818 /***********************************************************************
1819 * Local32ValidHandle (KERNEL.215)
1820 */
1821 BOOL WINAPI Local32ValidHandle16( HANDLE heap, WORD addr )
1822 {
1823 LOCAL32HEADER *header = (LOCAL32HEADER *)heap;
1824 LPDWORD handle;
1825 LPBYTE ptr;
1826
1827 Local32_ToHandle( header, 0, addr, &handle, &ptr );
1828 return handle != NULL;
1829 }
1830
1831 /***********************************************************************
1832 * Local32GetSegment (KERNEL.229)
1833 */
1834 WORD WINAPI Local32GetSegment16( HANDLE heap )
1835 {
1836 LOCAL32HEADER *header = (LOCAL32HEADER *)heap;
1837 return header->segment;
1838 }
1839
1840 /***********************************************************************
1841 * Local32_GetHeap
1842 */
1843 static LOCAL32HEADER *Local32_GetHeap( HGLOBAL16 handle )
1844 {
1845 WORD selector = GlobalHandleToSel16( handle );
1846 DWORD base = GetSelectorBase( selector );
1847 DWORD limit = GetSelectorLimit16( selector );
1848
1849 /* Hmmm. This is a somewhat stupid heuristic, but Windows 95 does
1850 it this way ... */
1851
1852 if ( limit > 0x10000 && ((LOCAL32HEADER *)base)->magic == LOCAL32_MAGIC )
1853 return (LOCAL32HEADER *)base;
1854
1855 base += 0x10000;
1856 limit -= 0x10000;
1857
1858 if ( limit > 0x10000 && ((LOCAL32HEADER *)base)->magic == LOCAL32_MAGIC )
1859 return (LOCAL32HEADER *)base;
1860
1861 return NULL;
1862 }
1863
1864 /***********************************************************************
1865 * Local32Info (KERNEL.444) (TOOLHELP.84)
1866 */
1867 BOOL16 WINAPI Local32Info16( LOCAL32INFO *pLocal32Info, HGLOBAL16 handle )
1868 {
1869 SUBHEAP *heapPtr;
1870 LPBYTE ptr;
1871 int i;
1872
1873 LOCAL32HEADER *header = Local32_GetHeap( handle );
1874 if ( !header ) return FALSE;
1875
1876 if ( !pLocal32Info || pLocal32Info->dwSize < sizeof(LOCAL32INFO) )
1877 return FALSE;
1878
1879 heapPtr = (SUBHEAP *)HEAP_GetPtr( header->heap );
1880 pLocal32Info->dwMemReserved = heapPtr->size;
1881 pLocal32Info->dwMemCommitted = heapPtr->commitSize;
1882 pLocal32Info->dwTotalFree = 0L;
1883 pLocal32Info->dwLargestFreeBlock = 0L;
1884
1885 /* Note: Local32 heaps always have only one subheap! */
1886 ptr = (LPBYTE)heapPtr + heapPtr->headerSize;
1887 while ( ptr < (LPBYTE)heapPtr + heapPtr->size )
1888 {
1889 if (*(DWORD *)ptr & ARENA_FLAG_FREE)
1890 {
1891 ARENA_FREE *pArena = (ARENA_FREE *)ptr;
1892 DWORD size = (pArena->size & ARENA_SIZE_MASK);
1893 ptr += sizeof(*pArena) + size;
1894
1895 pLocal32Info->dwTotalFree += size;
1896 if ( size > pLocal32Info->dwLargestFreeBlock )
1897 pLocal32Info->dwLargestFreeBlock = size;
1898 }
1899 else
1900 {
1901 ARENA_INUSE *pArena = (ARENA_INUSE *)ptr;
1902 DWORD size = (pArena->size & ARENA_SIZE_MASK);
1903 ptr += sizeof(*pArena) + size;
1904 }
1905 }
1906
1907 pLocal32Info->dwcFreeHandles = 0;
1908 for ( i = 0; i < HTABLE_NPAGES; i++ )
1909 {
1910 if ( header->freeListFirst[i] == 0xffff ) break;
1911 pLocal32Info->dwcFreeHandles += header->freeListSize[i];
1912 }
1913 pLocal32Info->dwcFreeHandles += (HTABLE_NPAGES - i) * HTABLE_PAGESIZE/4;
1914
1915 return TRUE;
1916 }
1917
1918 /***********************************************************************
1919 * Local32First (KERNEL.445) (TOOLHELP.85)
1920 */
1921 BOOL16 WINAPI Local32First16( LOCAL32ENTRY *pLocal32Entry, HGLOBAL16 handle )
1922 {
1923 FIXME( heap, "(%p, %04X): stub!\n", pLocal32Entry, handle );
1924 return FALSE;
1925 }
1926
1927 /***********************************************************************
1928 * Local32Next (KERNEL.446) (TOOLHELP.86)
1929 */
1930 BOOL16 WINAPI Local32Next16( LOCAL32ENTRY *pLocal32Entry )
1931 {
1932 FIXME( heap, "(%p): stub!\n", pLocal32Entry );
1933 return FALSE;
1934 }
1935
Quick hack tree for wine patches julliard doesn't want to commit