[fireball] 38648: - Some 64bits syncs from Wine by Samuel Serapion.

Author: fireball
Date: Thu Jan  8 11:35:42 2009
New Revision: 38648

URL: http://svn.reactos.org/svn/reactos?rev=38648&view=rev
Log:
- Some 64bits syncs from Wine by Samuel Serapion.

Modified:
    trunk/reactos/lib/rtl/heap.c

Modified: trunk/reactos/lib/rtl/heap.c
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/lib/rtl/heap.c?rev=38648&a…
==============================================================================
--- trunk/reactos/lib/rtl/heap.c [iso-8859-1] (original)
+++ trunk/reactos/lib/rtl/heap.c [iso-8859-1] Thu Jan  8 11:35:42 2009
@@ -68,7 +68,7 @@
 
 typedef struct tagARENA_INUSE
 {
-    DWORD  size;                    /* Block size; must be the first field */
+    SIZE_T size;                    /* Block size; must be the first field */
     DWORD  magic : 23;              /* Magic number */
     DWORD  has_user_data : 1;       /* There is user data associated with this block */
     DWORD  unused_bytes : 8;        /* Number of bytes in the block not used by user data
(max value is HEAP_MIN_DATA_SIZE+HEAP_MIN_SHRINK_SIZE) */
@@ -76,7 +76,7 @@
 
 typedef struct tagARENA_FREE
 {
-    DWORD                 size;     /* Block size; must be the first field */
+    SIZE_T                size;     /* Block size; must be the first field */
     DWORD                 magic;    /* Magic number */
     struct list           entry;    /* Entry in free list */
 } ARENA_FREE;
@@ -90,14 +90,18 @@
 #define ARENA_INUSE_FILLER     0x55
 #define ARENA_FREE_FILLER      0xaa
 
-#define ALIGNMENT              8   /* everything is aligned on 8 byte boundaries */
-#define ROUND_SIZE(size)       (((size) + ALIGNMENT - 1) & ~(ALIGNMENT-1))
+/* everything is aligned on 8 byte boundaries (16 for Win64)*/
+#define ALIGNMENT              (2*sizeof(void*))
+#define ARENA_OFFSET (ALIGNMENT - sizeof(ARENA_INUSE))
+
+#define ROUND_SIZE(size)       ((((size) + ALIGNMENT - 1) & ~(ALIGNMENT-1)) +
ARENA_OFFSET)
+
 
 #define QUIET                  1           /* Suppress messages  */
 #define NOISY                  0           /* Report all errors  */
 
 /* minimum data size (without arenas) of an allocated block */
-#define HEAP_MIN_DATA_SIZE    16
+#define HEAP_MIN_DATA_SIZE    ROUND_SIZE(2 * sizeof(struct list))
 /* minimum size that must remain to shrink an allocated block */
 #define HEAP_MIN_SHRINK_SIZE  (HEAP_MIN_DATA_SIZE+sizeof(ARENA_FREE))
 
@@ -112,14 +116,15 @@
 typedef struct
 {
     ARENA_FREE  arena;
+    void        *aligment[4];
 } FREE_LIST_ENTRY;
 
 struct tagHEAP;
 
 typedef struct tagSUBHEAP
 {
-    DWORD               size;       /* Size of the whole sub-heap */
-    DWORD               commitSize; /* Committed size of the sub-heap */
+    SIZE_T              size;       /* Size of the whole sub-heap */
+    SIZE_T              commitSize; /* Committed size of the sub-heap */
     DWORD               headerSize; /* Size of the heap header */
     struct tagSUBHEAP  *next;       /* Next sub-heap */
     struct tagHEAP     *heap;       /* Main heap structure */
@@ -206,6 +211,12 @@
     size -= sizeof(ARENA_FREE);
     for (i = 0; i < HEAP_NB_FREE_LISTS - 1; i++) if (size <= HEAP_freeListSizes[i])
break;
     return i;
+}
+
+/* get the memory protection type to use for a given heap */
+static inline ULONG get_protection_type( DWORD flags )
+{
+    return (flags & HEAP_CREATE_ENABLE_EXECUTE) ? PAGE_EXECUTE_READWRITE :
PAGE_READWRITE;
 }
 
 static RTL_CRITICAL_SECTION_DEBUG process_heap_critsect_debug =
@@ -282,8 +293,8 @@
             }
         }
         DPRINTF( "\nTotal: Size=%08lx Committed=%08lx Free=%08lx Used=%08lx
Arenas=%08lx (%ld%%)\n\n",
-	      subheap->size, subheap->commitSize, freeSize, usedSize,
-	      arenaSize, (arenaSize * 100) / subheap->size );
+          subheap->size, subheap->commitSize, freeSize, usedSize,
+          arenaSize, (arenaSize * 100) / subheap->size );
         subheap = subheap->next;
     }
 }
@@ -457,7 +468,7 @@
    else
    {
         Status = ZwAllocateVirtualMemory( NtCurrentProcess(), &ptr, 0,
-                                 &size, MEM_COMMIT, PAGE_READWRITE );
+                                 &size, MEM_COMMIT,
get_protection_type(subheap->heap->flags) );
    }
     if (!NT_SUCCESS(Status))
     {
@@ -649,7 +660,7 @@
     NTSTATUS Status;
 
     if (!address && ZwAllocateVirtualMemory( NtCurrentProcess(), &address,
0,
-                                 &commitSize, MEM_COMMIT, PAGE_READWRITE ))
+                                 &commitSize, MEM_COMMIT, get_protection_type(flags)
))
     {
         WARN("Could not commit %08lx bytes for sub-heap %p\n", commitSize,
address );
         return FALSE;
@@ -733,7 +744,7 @@
                                        0,
                                        &commitSize,
                                        MEM_COMMIT,
-                                       PAGE_EXECUTE_READWRITE);
+                                       get_protection_type(flags));
     }
     if (!NT_SUCCESS(Status))
     {
@@ -766,13 +777,14 @@
     totalSize  = (totalSize + 0xffff) & 0xffff0000;
     commitSize = (commitSize + 0xffff) & 0xffff0000;
     if (!commitSize) commitSize = 0x10000;
+    totalSize = min( totalSize, 0xffff0000 );  /* don't allow a heap larger than 4Gb
*/
     if (totalSize < commitSize) totalSize = commitSize;
 
     if (!address)
     {
         /* allocate the memory block */
         if (ZwAllocateVirtualMemory( NtCurrentProcess(), &address, 0,
&totalSize,
-                                     MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE ))
+                                     MEM_RESERVE | MEM_COMMIT, get_protection_type(flags)
))
         {
             WARN("Could not allocate %08lx bytes\n", totalSize );
             return NULL;
@@ -804,6 +816,7 @@
 {
     SUBHEAP *subheap;
     struct list *ptr;
+    SIZE_T total_size;
     FREE_LIST_ENTRY *pEntry = heap->freeList + get_freelist_index( size +
sizeof(ARENA_INUSE) );
 
     /* Find a suitable free list, and in it find a block large enough */
@@ -835,9 +848,11 @@
      * So just one heap struct, one first free arena which will eventually
      * get used, and a second free arena that might get assigned all remaining
      * free space in HEAP_ShrinkBlock() */
-    size += ROUND_SIZE(sizeof(SUBHEAP)) + sizeof(ARENA_INUSE) + sizeof(ARENA_FREE);
-    if (!(subheap = HEAP_CreateSubHeap( heap, NULL, heap->flags, size,
-                                        max( HEAP_DEF_SIZE, size ), NULL )))
+    total_size = size + ROUND_SIZE(sizeof(SUBHEAP)) + sizeof(ARENA_INUSE) +
sizeof(ARENA_FREE);
+    if (total_size < size) return NULL;  /* overflow */
+
+    if (!(subheap = HEAP_CreateSubHeap( heap, NULL, heap->flags, total_size,
+                                        max( HEAP_DEF_SIZE, total_size ), NULL )))
         return NULL;
 
     TRACE("created new sub-heap %p of %08lx bytes for heap %p\n",
@@ -874,7 +889,7 @@
     char *heapEnd = (char *)subheap + subheap->size;
 
     /* Check for unaligned pointers */
-    if ( (ULONG_PTR)pArena % ALIGNMENT != 0 )
+    if ( (ULONG_PTR)pArena % ALIGNMENT != ARENA_OFFSET )
     {
         ERR("Heap %p: unaligned arena pointer %p\n", subheap->heap, pArena
);
         return FALSE;
@@ -964,7 +979,7 @@
     const char *heapEnd = (const char *)subheap + subheap->size;
 
     /* Check for unaligned pointers */
-    if ( (ULONG_PTR)pArena % ALIGNMENT != 0 )
+    if ( (ULONG_PTR)pArena % ALIGNMENT != ARENA_OFFSET )
     {
         if ( quiet == NOISY )
         {
@@ -1169,6 +1184,7 @@
         {
             processHeap = subheap->heap;  /* assume the first heap we create is the
process main heap */
             list_init( &processHeap->entry );
+            assert( (ULONG_PTR)processHeap->freeList % ALIGNMENT == ARENA_OFFSET );
         }
    }
 
@@ -1252,13 +1268,16 @@
    //flags &= HEAP_GENERATE_EXCEPTIONS | HEAP_NO_SERIALIZE | HEAP_ZERO_MEMORY;
     flags |= heapPtr->flags;
     rounded_size = ROUND_SIZE(size);
+    if (rounded_size < size)  /* overflow */
+    {
+        if (flags & HEAP_GENERATE_EXCEPTIONS) RtlRaiseStatus( STATUS_NO_MEMORY );
+        return NULL;
+    }
+
     if (rounded_size < HEAP_MIN_DATA_SIZE) rounded_size = HEAP_MIN_DATA_SIZE;
 
     if (!(flags & HEAP_NO_SERIALIZE)) RtlEnterHeapLock( &heapPtr->critSection
);
     /* Locate a suitable free block */
-
-   /* Locate a suitable free block */
-
     if (!(pArena = HEAP_FindFreeBlock( heapPtr, rounded_size, &subheap )))
     {
         TRACE("(%p,%08lx,%08lx): returning NULL\n",
@@ -1288,7 +1307,10 @@
     pInUse->unused_bytes = (pInUse->size & ARENA_SIZE_MASK) - size;
 
     if (flags & HEAP_ZERO_MEMORY)
-        clear_block( pInUse + 1, pInUse->size & ARENA_SIZE_MASK );
+    {
+        clear_block( pInUse + 1, size );
+        mark_block_uninitialized( (char *)(pInUse + 1) + size, pInUse->unused_bytes
);
+    }
     else
         mark_block_uninitialized( pInUse + 1, pInUse->size & ARENA_SIZE_MASK );
 
@@ -1339,16 +1361,26 @@
         return FALSE;
     }
 
-    /* Turn the block into a free block */
-
+    /* Some sanity checks */
     pInUse  = (ARENA_INUSE *)ptr - 1;
     subheap = HEAP_FindSubHeap( heapPtr, pInUse );
+    if ((char *)pInUse < (char *)subheap + subheap->headerSize) goto error;
+    if (!HEAP_ValidateInUseArena( subheap, pInUse, QUIET )) goto error;
+
+    /* Turn the block into a free block */
+
     HEAP_MakeInUseBlockFree( subheap, pInUse );
 
     if (!(flags & HEAP_NO_SERIALIZE)) RtlLeaveHeapLock( &heapPtr->critSection
);
 
     TRACE("(%p,%08lx,%p): returning TRUE\n", heap, flags, ptr );
     return TRUE;
+
+error:
+    if (!(flags & HEAP_NO_SERIALIZE)) RtlLeaveHeapLock( &heapPtr->critSection
);
+    RtlSetLastWin32ErrorAndNtStatusFromNtStatus( STATUS_INVALID_PARAMETER );
+    TRACE("(%p,%08x,%p): returning FALSE\n", heap, flags, ptr );
+    return FALSE;
 }
 
 
@@ -1376,7 +1408,7 @@
     ARENA_INUSE *pArena;
     HEAP *heapPtr;
     SUBHEAP *subheap;
-    SIZE_T oldSize, rounded_size;
+    SIZE_T oldBlockSize, oldActualSize, rounded_size;
 
     if (!ptr) return NULL;
     if (!(heapPtr = HEAP_GetPtr( heap )))
@@ -1390,55 +1422,44 @@
    //Flags &= HEAP_GENERATE_EXCEPTIONS | HEAP_NO_SERIALIZE | HEAP_ZERO_MEMORY |
    //         HEAP_REALLOC_IN_PLACE_ONLY;
     flags |= heapPtr->flags;
+    if (!(flags & HEAP_NO_SERIALIZE)) RtlEnterHeapLock( &heapPtr->critSection
);
+
     rounded_size = ROUND_SIZE(size);
+    if (rounded_size < size) goto oom;  /* overflow */
     if (rounded_size < HEAP_MIN_DATA_SIZE) rounded_size = HEAP_MIN_DATA_SIZE;
 
-    if (!(flags & HEAP_NO_SERIALIZE)) RtlEnterHeapLock( &heapPtr->critSection
);
-    if (!HEAP_IsRealArena( heapPtr, HEAP_NO_SERIALIZE, ptr, QUIET ))
-    {
-        if (!(flags & HEAP_NO_SERIALIZE)) RtlLeaveHeapLock(
&heapPtr->critSection );
-        RtlSetLastWin32ErrorAndNtStatusFromNtStatus( STATUS_INVALID_PARAMETER );
-        TRACE("(%p,%08lx,%p,%08lx): returning NULL\n", heap, flags, ptr, size
);
-        return NULL;
-    }
-
     pArena = (ARENA_INUSE *)ptr - 1;
-    subheap = HEAP_FindSubHeap( heapPtr, pArena );
-    oldSize = (pArena->size & ARENA_SIZE_MASK);
-    if (rounded_size > oldSize)
-    {
-        char *pNext = (char *)(pArena + 1) + oldSize;
+    if(!(subheap = HEAP_FindSubHeap( heapPtr, pArena ))) goto done;
+    if ((char *)pArena < (char *)subheap + subheap->headerSize) goto error;
+    if (!HEAP_ValidateInUseArena( subheap, pArena, QUIET )) goto error;
+
+    oldBlockSize = (pArena->size & ARENA_SIZE_MASK);
+    oldActualSize = (pArena->size & ARENA_SIZE_MASK) - pArena->unused_bytes;
+
+    if (rounded_size > oldBlockSize)
+    {
+        char *pNext = (char *)(pArena + 1) + oldBlockSize;
         if ((pNext < (char *)subheap + subheap->size) &&
             (*(DWORD *)pNext & ARENA_FLAG_FREE) &&
-            (oldSize + (*(DWORD *)pNext & ARENA_SIZE_MASK) + sizeof(ARENA_FREE) >=
rounded_size))
+            (oldBlockSize + (*(DWORD *)pNext & ARENA_SIZE_MASK) + sizeof(ARENA_FREE)
>= rounded_size))
         {
-            /* The next block is free and large enough */
             ARENA_FREE *pFree = (ARENA_FREE *)pNext;
             list_remove( &pFree->entry );
             pArena->size += (pFree->size & ARENA_SIZE_MASK) + sizeof(*pFree);
-            if (!HEAP_Commit( subheap, pArena, rounded_size ))
-            {
-                if (!(flags & HEAP_NO_SERIALIZE)) RtlLeaveHeapLock(
&heapPtr->critSection );
-                if (flags & HEAP_GENERATE_EXCEPTIONS) RtlRaiseStatus(
STATUS_NO_MEMORY );
-                RtlSetLastWin32ErrorAndNtStatusFromNtStatus( STATUS_NO_MEMORY );
-                return NULL;
-            }
+
+            if (!HEAP_Commit( subheap, pArena, rounded_size )) goto oom;
+
             HEAP_ShrinkBlock( subheap, pArena, rounded_size );
+            mark_block_initialized( pArena + 1, oldActualSize );
         }
         else  /* Do it the hard way */
         {
             ARENA_FREE *pNew;
             ARENA_INUSE *pInUse;
             SUBHEAP *newsubheap;
-
             if ((flags & HEAP_REALLOC_IN_PLACE_ONLY) ||
                 !(pNew = HEAP_FindFreeBlock( heapPtr, rounded_size, &newsubheap )))
-            {
-                if (!(flags & HEAP_NO_SERIALIZE)) RtlLeaveHeapLock(
&heapPtr->critSection );
-                if (flags & HEAP_GENERATE_EXCEPTIONS) RtlRaiseStatus(
STATUS_NO_MEMORY );
-                RtlSetLastWin32ErrorAndNtStatusFromNtStatus( STATUS_NO_MEMORY );
-                return NULL;
-            }
+                goto oom;
 
             /* Build the in-use arena */
 
@@ -1448,8 +1469,9 @@
                            + sizeof(ARENA_FREE) - sizeof(ARENA_INUSE);
             pInUse->magic = ARENA_INUSE_MAGIC;
             HEAP_ShrinkBlock( newsubheap, pInUse, rounded_size );
-            mark_block_initialized( pInUse + 1, oldSize );
-            memcpy( pInUse + 1, pArena + 1, oldSize );
+
+            mark_block_initialized( pInUse + 1, oldActualSize );
+            memcpy( pInUse + 1, pArena + 1, oldActualSize );
 
             /* Free the previous block */
 
@@ -1458,28 +1480,47 @@
             pArena  = pInUse;
         }
     }
-    else HEAP_ShrinkBlock( subheap, pArena, rounded_size );  /* Shrink the block */
+    else
+    {
+        HEAP_ShrinkBlock( subheap, pArena, rounded_size );  /* Shrink the block */
+        mark_block_initialized( pArena + 1, size );
+    }
 
     pArena->unused_bytes = (pArena->size & ARENA_SIZE_MASK) - size;
 
     /* Clear the extra bytes if needed */
 
-    if (rounded_size > oldSize)
+    if (size > oldActualSize)
     {
         if (flags & HEAP_ZERO_MEMORY)
-            clear_block( (char *)(pArena + 1) + oldSize,
-                         (pArena->size & ARENA_SIZE_MASK) - oldSize );
+        {
+            clear_block( (char *)(pArena + 1) + oldActualSize, size - oldActualSize );
+            mark_block_uninitialized( (char *)(pArena + 1) + size,
+                                      (pArena->size & ARENA_SIZE_MASK) -
oldActualSize );
+        }
         else
-            mark_block_uninitialized( (char *)(pArena + 1) + oldSize,
-                                      (pArena->size & ARENA_SIZE_MASK) - oldSize
);
+            mark_block_uninitialized( (char *)(pArena + 1) + oldActualSize,
+                                      (pArena->size & ARENA_SIZE_MASK) -
oldActualSize );
     }
 
     /* Return the new arena */
-
+done:
     if (!(flags & HEAP_NO_SERIALIZE)) RtlLeaveHeapLock( &heapPtr->critSection
);
-
     TRACE("(%p,%08lx,%p,%08lx): returning %p\n", heap, flags, ptr, size, pArena
+ 1 );
     return (LPVOID)(pArena + 1);
+
+oom:
+     if (!(flags & HEAP_NO_SERIALIZE)) RtlLeaveHeapLock( &heapPtr->critSection
);
+     if (flags & HEAP_GENERATE_EXCEPTIONS) RtlRaiseStatus( STATUS_NO_MEMORY );
+     RtlSetLastWin32ErrorAndNtStatusFromNtStatus( STATUS_NO_MEMORY );
+     TRACE("(%p,%08x,%p,%08lx): returning oom\n", heap, flags, ptr, size );
+     return NULL;
+
+error:
+    if (!(flags & HEAP_NO_SERIALIZE)) RtlLeaveHeapLock( &heapPtr->critSection
);
+    RtlSetLastWin32ErrorAndNtStatusFromNtStatus( STATUS_INVALID_PARAMETER );
+    TRACE("(%p,%08x,%p,%08lx): returning error\n", heap, flags, ptr, size );
+    return NULL;
 }
 
 
@@ -1583,7 +1624,7 @@
     }
     else
     {
-        ARENA_INUSE *pArena = (ARENA_INUSE *)ptr - 1;
+        const ARENA_INUSE *pArena = (const ARENA_INUSE *)ptr - 1;
         ret = (pArena->size & ARENA_SIZE_MASK) - pArena->unused_bytes;
     }
     if (!(flags & HEAP_NO_SERIALIZE)) RtlLeaveHeapLock( &heapPtr->critSection
);