sdk/lib/rtl/heapdbg.c

   1 /*
   2  * PROJECT:         ReactOS Runtime Library
   3  * LICENSE:         GPL - See COPYING in the top level directory
   4  * FILE:            lib/rtl/heapdbg.c
   5  * PURPOSE:         Heap manager debug heap
   6  * PROGRAMMERS:     Copyright 2010 Aleksey Bragin
   7  */
   8
   9 /* INCLUDES ******************************************************************/
  10
  11 #include <rtl.h>
  12 #include <heap.h>
  13
  14 #define NDEBUG
  15 #include <debug.h>
  16
  17 /* FUNCTIONS ******************************************************************/
  18
  19 HANDLE NTAPI
  20 RtlDebugCreateHeap(ULONG Flags,
  21                    PVOID Addr,
  22                    SIZE_T ReserveSize,
  23                    SIZE_T CommitSize,
  24                    PVOID Lock,
  25                    PRTL_HEAP_PARAMETERS Parameters)
  26 {
  27     MEMORY_BASIC_INFORMATION MemoryInfo;
  28     NTSTATUS Status;
  29     PHEAP Heap;
  30
  31     /* Validate parameters */
  32     if (ReserveSize <= HEAP_ENTRY_SIZE)
  33     {
  34         DPRINT1("HEAP: Incorrect ReserveSize %x\n", ReserveSize);
  35         return NULL;
  36     }
  37
  38     if (ReserveSize < CommitSize)
  39     {
  40         DPRINT1("HEAP: Incorrect CommitSize %x\n", CommitSize);
  41         return NULL;
  42     }
  43
  44     if (Flags & HEAP_NO_SERIALIZE && Lock)
  45     {
  46         DPRINT1("HEAP: Can't specify Lock routine and have HEAP_NO_SERIALIZE flag set\n");
  47         return NULL;
  48     }
  49
  50     /* If the address is specified, check it's virtual memory */
  51     if (Addr)
  52     {
  53         Status = ZwQueryVirtualMemory(NtCurrentProcess(),
  54                                       Addr,
  55                                       MemoryBasicInformation,
  56                                       &MemoryInfo,
  57                                       sizeof(MemoryInfo),
  58                                       NULL);
  59
  60         if (!NT_SUCCESS(Status))
  61         {
  62             DPRINT1("HEAP: Specified heap base address %p is invalid, Status 0x%08X\n", Addr, Status);
  63             return NULL;
  64         }
  65
  66         if (MemoryInfo.BaseAddress != Addr)
  67         {
  68             DPRINT1("HEAP: Specified heap base address %p is not really a base one %p\n", Addr, MemoryInfo.BaseAddress);
  69             return NULL;
  70         }
  71
  72         if (MemoryInfo.State == MEM_FREE)
  73         {
  74             DPRINT1("HEAP: Specified heap base address %p is free\n", Addr);
  75             return NULL;
  76         }
  77     }
  78
  79     /* All validation performed, now call the real routine with skip validation check flag */
  80     Flags |= HEAP_SKIP_VALIDATION_CHECKS |
  81              HEAP_TAIL_CHECKING_ENABLED |
  82              HEAP_FREE_CHECKING_ENABLED;
  83
  84     Heap = RtlCreateHeap(Flags, Addr, ReserveSize, CommitSize, Lock, Parameters);
  85     if (!Heap) return NULL;
  86
  87     // FIXME: Capture stack backtrace
  88
  89     RtlpValidateHeapHeaders(Heap, TRUE);
  90
  91     return Heap;
  92 }
  93
  94 BOOLEAN NTAPI
  95 RtlDebugDestroyHeap(HANDLE HeapPtr)
  96 {
  97     SIZE_T Size = 0;
  98     PHEAP Heap = (PHEAP)HeapPtr;
  99
 100     if (Heap == RtlGetCurrentPeb()->ProcessHeap)
 101     {
 102         DPRINT1("HEAP: It's forbidden delete process heap!");
 103         return FALSE;
 104     }
 105
 106     if (Heap->Signature != HEAP_SIGNATURE)
 107     {
 108         DPRINT1("HEAP: Invalid heap %p signature 0x%x\n", Heap, Heap->Signature);
 109         return FALSE;
 110     }
 111
 112     if (!RtlpValidateHeap(Heap, FALSE)) return FALSE;
 113
 114     /* Make heap invalid by zeroing its signature */
 115     Heap->Signature = 0;
 116
 117     /* Free validate headers copy if it was existing */
 118     if (Heap->HeaderValidateCopy)
 119     {
 120         ZwFreeVirtualMemory(NtCurrentProcess(),
 121                             &Heap->HeaderValidateCopy,
 122                             &Size,
 123                             MEM_RELEASE);
 124     }
 125
 126     return TRUE;
 127 }
 128
 129 PVOID NTAPI
 130 RtlDebugAllocateHeap(PVOID HeapPtr,
 131                      ULONG Flags,
 132                      SIZE_T Size)
 133 {
 134     PHEAP Heap = (PHEAP)HeapPtr;
 135     SIZE_T AllocSize = 1;
 136     BOOLEAN HeapLocked = FALSE;
 137     PVOID Result;
 138
 139     if (Heap->ForceFlags & HEAP_FLAG_PAGE_ALLOCS)
 140         return RtlpPageHeapAllocate(HeapPtr, Flags, Size);
 141
 142     if (Heap->Signature != HEAP_SIGNATURE)
 143     {
 144         DPRINT1("HEAP: Invalid heap %p signature 0x%x\n", Heap, Heap->Signature);
 145         return NULL;
 146     }
 147
 148     /* Add settable user value flag */
 149     Flags |= Heap->ForceFlags | HEAP_SETTABLE_USER_VALUE | HEAP_SKIP_VALIDATION_CHECKS;
 150
 151     /* Calculate size */
 152     if (Size) AllocSize = Size;
 153     AllocSize = ((AllocSize + Heap->AlignRound) & Heap->AlignMask) + sizeof(HEAP_ENTRY_EXTRA);
 154
 155     /* Check if size didn't exceed max one */
 156     if (AllocSize < Size ||
 157         AllocSize > Heap->MaximumAllocationSize)
 158     {
 159         DPRINT1("HEAP: Too big allocation size %x (max allowed %x)\n", Size, Heap->MaximumAllocationSize);
 160         return NULL;
 161     }
 162
 163     /* Lock the heap ourselves */
 164     if (!(Flags & HEAP_NO_SERIALIZE))
 165     {
 166         RtlEnterHeapLock(Heap->LockVariable, TRUE);
 167         HeapLocked = TRUE;
 168
 169         /* Add no serialize flag so that the main routine won't try to acquire the lock again */
 170         Flags |= HEAP_NO_SERIALIZE;
 171     }
 172
 173     /* Validate the heap if necessary */
 174     RtlpValidateHeap(Heap, FALSE);
 175
 176     /* Call main routine to do the stuff */
 177     Result = RtlAllocateHeap(HeapPtr, Flags, Size);
 178
 179     /* Validate heap headers */
 180     RtlpValidateHeapHeaders(Heap, TRUE);
 181
 182     if (Result)
 183     {
 184         if (Heap->Flags & HEAP_VALIDATE_ALL_ENABLED)
 185             RtlpValidateHeap(Heap, FALSE);
 186     }
 187
 188     /* Release the lock */
 189     if (HeapLocked) RtlLeaveHeapLock(Heap->LockVariable);
 190
 191     return Result;
 192 }
 193
 194 PVOID NTAPI
 195 RtlDebugReAllocateHeap(HANDLE HeapPtr,
 196                        ULONG Flags,
 197                        PVOID Ptr,
 198                        SIZE_T Size)
 199 {
 200     PHEAP Heap = (PHEAP)HeapPtr;
 201     SIZE_T AllocSize = 1;
 202     BOOLEAN HeapLocked = FALSE;
 203     PVOID Result = NULL;
 204     PHEAP_ENTRY HeapEntry;
 205
 206     if (Heap->ForceFlags & HEAP_FLAG_PAGE_ALLOCS)
 207         return RtlpPageHeapReAllocate(HeapPtr, Flags, Ptr, Size);
 208
 209     if (Heap->Signature != HEAP_SIGNATURE)
 210     {
 211         DPRINT1("HEAP: Invalid heap %p signature 0x%x\n", Heap, Heap->Signature);
 212         return NULL;
 213     }
 214
 215     /* Add settable user value flag */
 216     Flags |= Heap->ForceFlags | HEAP_SETTABLE_USER_VALUE | HEAP_SKIP_VALIDATION_CHECKS;
 217
 218     /* Calculate size */
 219     if (Size) AllocSize = Size;
 220     AllocSize = ((AllocSize + Heap->AlignRound) & Heap->AlignMask) + sizeof(HEAP_ENTRY_EXTRA);
 221
 222     /* Check if size didn't exceed max one */
 223     if (AllocSize < Size ||
 224         AllocSize > Heap->MaximumAllocationSize)
 225     {
 226         DPRINT1("HEAP: Too big allocation size %x (max allowed %x)\n", Size, Heap->MaximumAllocationSize);
 227         return NULL;
 228     }
 229
 230     /* Lock the heap ourselves */
 231     if (!(Flags & HEAP_NO_SERIALIZE))
 232     {
 233         RtlEnterHeapLock(Heap->LockVariable, TRUE);
 234         HeapLocked = TRUE;
 235
 236         /* Add no serialize flag so that the main routine won't try to acquire the lock again */
 237         Flags |= HEAP_NO_SERIALIZE;
 238     }
 239
 240     /* Validate the heap if necessary */
 241     RtlpValidateHeap(Heap, FALSE);
 242
 243     /* Get the existing heap entry */
 244     HeapEntry = (PHEAP_ENTRY)Ptr - 1;
 245
 246     /* Validate it */
 247     if (RtlpValidateHeapEntry(Heap, HeapEntry))
 248     {
 249         /* Call main routine to do the stuff */
 250         Result = RtlReAllocateHeap(HeapPtr, Flags, Ptr, Size);
 251
 252         if (Result)
 253         {
 254             /* Validate heap headers and then heap itself */
 255             RtlpValidateHeapHeaders(Heap, TRUE);
 256             RtlpValidateHeap(Heap, FALSE);
 257         }
 258     }
 259
 260     /* Release the lock */
 261     if (HeapLocked) RtlLeaveHeapLock(Heap->LockVariable);
 262
 263     return Result;
 264 }
 265
 266 BOOLEAN NTAPI
 267 RtlDebugFreeHeap(HANDLE HeapPtr,
 268                  ULONG Flags,
 269                  PVOID Ptr)
 270 {
 271     PHEAP Heap = (PHEAP)HeapPtr;
 272     BOOLEAN HeapLocked = FALSE;
 273     PHEAP_ENTRY HeapEntry;
 274     BOOLEAN Result = FALSE;
 275
 276     if (Heap->ForceFlags & HEAP_FLAG_PAGE_ALLOCS)
 277         return RtlpPageHeapFree(HeapPtr, Flags, Ptr);
 278
 279     if (Heap->Signature != HEAP_SIGNATURE)
 280     {
 281         DPRINT1("HEAP: Invalid heap %p signature 0x%x\n", Heap, Heap->Signature);
 282         return FALSE;
 283     }
 284
 285     /* Add skip validation flag */
 286     Flags |= Heap->ForceFlags | HEAP_SKIP_VALIDATION_CHECKS;
 287
 288     /* Lock the heap ourselves */
 289     if (!(Flags & HEAP_NO_SERIALIZE))
 290     {
 291         RtlEnterHeapLock(Heap->LockVariable, TRUE);
 292         HeapLocked = TRUE;
 293
 294         /* Add no serialize flag so that the main routine won't try to acquire the lock again */
 295         Flags |= HEAP_NO_SERIALIZE;
 296     }
 297
 298     /* Validate the heap if necessary */
 299     RtlpValidateHeap(Heap, FALSE);
 300
 301     /* Get the existing heap entry */
 302     HeapEntry = (PHEAP_ENTRY)Ptr - 1;
 303
 304     /* Validate it */
 305     if (RtlpValidateHeapEntry(Heap, HeapEntry))
 306     {
 307         /* If it succeeded - call the main routine */
 308         Result = RtlFreeHeap(HeapPtr, Flags, Ptr);
 309
 310         /* Validate heap headers and then heap itself */
 311         RtlpValidateHeapHeaders(Heap, TRUE);
 312         RtlpValidateHeap(Heap, FALSE);
 313     }
 314
 315     /* Release the lock */
 316     if (HeapLocked) RtlLeaveHeapLock(Heap->LockVariable);
 317
 318     return Result;
 319 }
 320
 321 BOOLEAN NTAPI
 322 RtlDebugGetUserInfoHeap(PVOID HeapHandle,
 323                         ULONG Flags,
 324                         PVOID BaseAddress,
 325                         PVOID *UserValue,
 326                         PULONG UserFlags)
 327 {
 328     PHEAP Heap = (PHEAP)HeapHandle;
 329     BOOLEAN HeapLocked = FALSE;
 330     PHEAP_ENTRY HeapEntry;
 331     BOOLEAN Result = FALSE;
 332
 333     if (Heap->ForceFlags & HEAP_FLAG_PAGE_ALLOCS)
 334         return RtlpPageHeapGetUserInfo(HeapHandle, Flags, BaseAddress, UserValue, UserFlags);
 335
 336     if (Heap->Signature != HEAP_SIGNATURE)
 337     {
 338         DPRINT1("HEAP: Invalid heap %p signature 0x%x\n", Heap, Heap->Signature);
 339         return FALSE;
 340     }
 341
 342     /* Add skip validation flag */
 343     Flags |= Heap->ForceFlags | HEAP_SKIP_VALIDATION_CHECKS;
 344
 345     /* Lock the heap ourselves */
 346     if (!(Flags & HEAP_NO_SERIALIZE))
 347     {
 348         RtlEnterHeapLock(Heap->LockVariable, TRUE);
 349         HeapLocked = TRUE;
 350
 351         /* Add no serialize flag so that the main routine won't try to acquire the lock again */
 352         Flags |= HEAP_NO_SERIALIZE;
 353     }
 354
 355     /* Validate the heap if necessary */
 356     RtlpValidateHeap(Heap, FALSE);
 357
 358     /* Get the existing heap entry */
 359     HeapEntry = (PHEAP_ENTRY)BaseAddress - 1;
 360
 361     /* Validate it */
 362     if (RtlpValidateHeapEntry(Heap, HeapEntry))
 363     {
 364         /* If it succeeded - call the main routine */
 365         Result = RtlGetUserInfoHeap(HeapHandle, Flags, BaseAddress, UserValue, UserFlags);
 366     }
 367
 368     /* Release the lock */
 369     if (HeapLocked) RtlLeaveHeapLock(Heap->LockVariable);
 370
 371     return Result;
 372 }
 373
 374 BOOLEAN NTAPI
 375 RtlDebugSetUserValueHeap(PVOID HeapHandle,
 376                          ULONG Flags,
 377                          PVOID BaseAddress,
 378                          PVOID UserValue)
 379 {
 380     PHEAP Heap = (PHEAP)HeapHandle;
 381     BOOLEAN HeapLocked = FALSE;
 382     PHEAP_ENTRY HeapEntry;
 383     BOOLEAN Result = FALSE;
 384
 385     if (Heap->ForceFlags & HEAP_FLAG_PAGE_ALLOCS)
 386         return RtlpPageHeapSetUserValue(HeapHandle, Flags, BaseAddress, UserValue);
 387
 388     if (Heap->Signature != HEAP_SIGNATURE)
 389     {
 390         DPRINT1("HEAP: Invalid heap %p signature 0x%x\n", Heap, Heap->Signature);
 391         return FALSE;
 392     }
 393
 394     /* Add skip validation flag */
 395     Flags |= Heap->ForceFlags | HEAP_SKIP_VALIDATION_CHECKS;
 396
 397     /* Lock the heap ourselves */
 398     if (!(Flags & HEAP_NO_SERIALIZE))
 399     {
 400         RtlEnterHeapLock(Heap->LockVariable, TRUE);
 401         HeapLocked = TRUE;
 402
 403         /* Add no serialize flag so that the main routine won't try to acquire the lock again */
 404         Flags |= HEAP_NO_SERIALIZE;
 405     }
 406
 407     /* Validate the heap if necessary */
 408     RtlpValidateHeap(Heap, FALSE);
 409
 410     /* Get the existing heap entry */
 411     HeapEntry = (PHEAP_ENTRY)BaseAddress - 1;
 412
 413     /* Validate it */
 414     if (RtlpValidateHeapEntry(Heap, HeapEntry))
 415     {
 416         /* If it succeeded - call the main routine */
 417         Result = RtlSetUserValueHeap(HeapHandle, Flags, BaseAddress, UserValue);
 418
 419         /* Validate the heap */
 420         RtlpValidateHeap(Heap, FALSE);
 421     }
 422
 423     /* Release the lock */
 424     if (HeapLocked) RtlLeaveHeapLock(Heap->LockVariable);
 425
 426     return Result;
 427 }
 428
 429 BOOLEAN
 430 NTAPI
 431 RtlDebugSetUserFlagsHeap(PVOID HeapHandle,
 432                          ULONG Flags,
 433                          PVOID BaseAddress,
 434                          ULONG UserFlagsReset,
 435                          ULONG UserFlagsSet)
 436 {
 437     PHEAP Heap = (PHEAP)HeapHandle;
 438     BOOLEAN HeapLocked = FALSE;
 439     PHEAP_ENTRY HeapEntry;
 440     BOOLEAN Result = FALSE;
 441
 442     if (Heap->ForceFlags & HEAP_FLAG_PAGE_ALLOCS)
 443         return RtlpPageHeapSetUserFlags(HeapHandle, Flags, BaseAddress, UserFlagsReset, UserFlagsSet);
 444
 445     /* Check if this heap allows flags to be set at all */
 446     if (UserFlagsSet & ~HEAP_SETTABLE_USER_FLAGS ||
 447         UserFlagsReset & ~HEAP_SETTABLE_USER_FLAGS)
 448     {
 449         return FALSE;
 450     }
 451
 452     if (Heap->Signature != HEAP_SIGNATURE)
 453     {
 454         DPRINT1("HEAP: Invalid heap %p signature 0x%x\n", Heap, Heap->Signature);
 455         return FALSE;
 456     }
 457
 458     /* Add skip validation flag */
 459     Flags |= Heap->ForceFlags | HEAP_SKIP_VALIDATION_CHECKS;
 460
 461     /* Lock the heap ourselves */
 462     if (!(Flags & HEAP_NO_SERIALIZE))
 463     {
 464         RtlEnterHeapLock(Heap->LockVariable, TRUE);
 465         HeapLocked = TRUE;
 466
 467         /* Add no serialize flag so that the main routine won't try to acquire the lock again */
 468         Flags |= HEAP_NO_SERIALIZE;
 469     }
 470
 471     /* Validate the heap if necessary */
 472     RtlpValidateHeap(Heap, FALSE);
 473
 474     /* Get the existing heap entry */
 475     HeapEntry = (PHEAP_ENTRY)BaseAddress - 1;
 476
 477     /* Validate it */
 478     if (RtlpValidateHeapEntry(Heap, HeapEntry))
 479     {
 480         /* If it succeeded - call the main routine */
 481         Result = RtlSetUserFlagsHeap(HeapHandle, Flags, BaseAddress, UserFlagsReset, UserFlagsSet);
 482
 483         /* Validate the heap */
 484         RtlpValidateHeap(Heap, FALSE);
 485     }
 486
 487     /* Release the lock */
 488     if (HeapLocked) RtlLeaveHeapLock(Heap->LockVariable);
 489
 490     return Result;
 491 }
 492
 493 SIZE_T NTAPI
 494 RtlDebugSizeHeap(HANDLE HeapPtr,
 495                  ULONG Flags,
 496                  PVOID Ptr)
 497 {
 498     PHEAP Heap = (PHEAP)HeapPtr;
 499     BOOLEAN HeapLocked = FALSE;
 500     PHEAP_ENTRY HeapEntry;
 501     SIZE_T Result = ~(SIZE_T)0;
 502
 503     if (Heap->ForceFlags & HEAP_FLAG_PAGE_ALLOCS)
 504         return RtlpPageHeapSize(HeapPtr, Flags, Ptr);
 505
 506     /* Check heap signature */
 507     if (Heap->Signature != HEAP_SIGNATURE)
 508     {
 509         DPRINT1("HEAP: Invalid heap %p signature 0x%x\n", Heap, Heap->Signature);
 510         return FALSE;
 511     }
 512
 513     /* Add skip validation flag */
 514     Flags |= Heap->ForceFlags | HEAP_SKIP_VALIDATION_CHECKS;
 515
 516     /* Lock the heap ourselves */
 517     if (!(Flags & HEAP_NO_SERIALIZE))
 518     {
 519         RtlEnterHeapLock(Heap->LockVariable, TRUE);
 520         HeapLocked = TRUE;
 521
 522         /* Add no serialize flag so that the main routine won't try to acquire the lock again */
 523         Flags |= HEAP_NO_SERIALIZE;
 524     }
 525
 526     /* Validate the heap if necessary */
 527     RtlpValidateHeap(Heap, FALSE);
 528
 529     /* Get the existing heap entry */
 530     HeapEntry = (PHEAP_ENTRY)Ptr - 1;
 531
 532     /* Validate it */
 533     if (RtlpValidateHeapEntry(Heap, HeapEntry))
 534     {
 535         /* If it succeeded - call the main routine */
 536         Result = RtlSizeHeap(HeapPtr, Flags, Ptr);
 537     }
 538
 539     /* Release the lock */
 540     if (HeapLocked) RtlLeaveHeapLock(Heap->LockVariable);
 541
 542     return Result;
 543 }
 544
 545 /* EOF */