win32ss/gdi/ntgdi/gdipool.c

   1 /*
   2  * PROJECT:         ReactOS win32 kernel mode subsystem
   3  * LICENSE:         GPL - See COPYING in the top level directory
   4  * FILE:            win32ss/gdi/ntgdi/gdipool.c
   5  * PURPOSE:         Static size allocator for user mode object attributes
   6  * PROGRAMMERS:     Timo Kreuzer
   7  */
   8
   9 /* INCLUDES ******************************************************************/
  10
  11 #include <win32k.h>
  12 #define NDEBUG
  13 #include <debug.h>
  14
  15 typedef struct _GDI_POOL_SECTION
  16 {
  17     LIST_ENTRY leInUseLink;
  18     LIST_ENTRY leReadyLink;
  19
  20     PVOID pvBaseAddress;
  21
  22     ULONG ulCommitBitmap;
  23     ULONG cAllocCount;
  24
  25     RTL_BITMAP bitmap;
  26     ULONG aulBits[1];
  27 } GDI_POOL_SECTION, *PGDI_POOL_SECTION;
  28
  29 typedef struct _GDI_POOL
  30 {
  31     ULONG ulTag;
  32     ULONG cjAllocSize;
  33     ULONG cjSectionSize; // 32 * cjAllocSize, rounded up to pages
  34     ULONG cSlotsPerSection;
  35     ULONG cEmptySections;
  36     EX_PUSH_LOCK pushlock; // For pool growth
  37 #if DBG_ENABLE_EVENT_LOGGING
  38     SLIST_HEADER slhLog;
  39 #endif
  40
  41     LIST_ENTRY leInUseList;
  42     LIST_ENTRY leEmptyList;
  43     LIST_ENTRY leReadyList;
  44 } GDI_POOL;
  45
  46 #define GDI_POOL_ALLOCATION_GRANULARITY 64 * 1024
  47
  48 static
  49 PGDI_POOL_SECTION
  50 GdiPoolAllocateSection(PGDI_POOL pPool)
  51 {
  52     PGDI_POOL_SECTION pSection;
  53     PVOID pvBaseAddress;
  54     SIZE_T cjSize;
  55     NTSTATUS status;
  56
  57     /* Allocate a section object */
  58     cjSize = sizeof(GDI_POOL_SECTION) + pPool->cSlotsPerSection / sizeof(ULONG);
  59     pSection = EngAllocMem(0, cjSize, pPool->ulTag);
  60     if (!pSection)
  61     {
  62         return NULL;
  63     }
  64
  65     /* Reserve user mode memory */
  66     cjSize = GDI_POOL_ALLOCATION_GRANULARITY;
  67     pvBaseAddress = NULL;
  68     status = ZwAllocateVirtualMemory(NtCurrentProcess(),
  69                                      &pvBaseAddress,
  70                                      0,
  71                                      &cjSize,
  72                                      MEM_RESERVE,
  73                                      PAGE_READWRITE);
  74     if (!NT_SUCCESS(status))
  75     {
  76         EngFreeMem(pSection);
  77         return NULL;
  78     }
  79
  80     /* Initialize the section */
  81     pSection->pvBaseAddress = pvBaseAddress;
  82     pSection->ulCommitBitmap = 0;
  83     pSection->cAllocCount = 0;
  84     RtlInitializeBitMap(&pSection->bitmap,
  85                         pSection->aulBits,
  86                         pPool->cSlotsPerSection);
  87     RtlClearAllBits(&pSection->bitmap);
  88
  89     /* Return the section */
  90     return pSection;
  91 }
  92
  93 static
  94 VOID
  95 GdiPoolDeleteSection(PGDI_POOL pPool, PGDI_POOL_SECTION pSection)
  96 {
  97     NTSTATUS status;
  98     SIZE_T cjSize = 0;
  99
 100     /* Should not have any allocations */
 101     if (pSection->cAllocCount != 0)
 102     {
 103         DPRINT1("There are %lu allocations left, section=%p, pool=%p\n",
 104                 pSection->cAllocCount, pSection, pPool);
 105         DBG_DUMP_EVENT_LIST(&pPool->slhLog);
 106         ASSERT(FALSE);
 107     }
 108
 109     /* Release the virtual memory */
 110     status = ZwFreeVirtualMemory(NtCurrentProcess(),
 111                                  &pSection->pvBaseAddress,
 112                                  &cjSize,
 113                                  MEM_RELEASE);
 114     ASSERT(NT_SUCCESS(status));
 115
 116     /* Free the section object */
 117     EngFreeMem(pSection);
 118 }
 119
 120 PVOID
 121 NTAPI
 122 GdiPoolAllocate(
 123     PGDI_POOL pPool)
 124 {
 125     PGDI_POOL_SECTION pSection;
 126     ULONG ulIndex, cjOffset, ulPageBit;
 127     PLIST_ENTRY ple;
 128     PVOID pvAlloc, pvBaseAddress;
 129     SIZE_T cjSize;
 130     NTSTATUS status;
 131
 132     /* Disable APCs and acquire the pool lock */
 133     KeEnterCriticalRegion();
 134     ExAcquirePushLockExclusive(&pPool->pushlock);
 135
 136     /* Check if we have a ready section */
 137     if (!IsListEmpty(&pPool->leReadyList))
 138     {
 139         /* Get a free section */
 140         ple = pPool->leReadyList.Flink;
 141         pSection = CONTAINING_RECORD(ple, GDI_POOL_SECTION, leReadyLink);
 142         if (pSection->cAllocCount >= pPool->cSlotsPerSection)
 143         {
 144             DPRINT1("pSection->cAllocCount=%lu, pPool->cSlotsPerSection=%lu\n",
 145                     pSection->cAllocCount, pPool->cSlotsPerSection);
 146             DBG_DUMP_EVENT_LIST(&pPool->slhLog);
 147             ASSERT(FALSE);
 148         }
 149         ASSERT(pSection->cAllocCount < pPool->cSlotsPerSection);
 150     }
 151     else
 152     {
 153         /* No, check if we have something on the empty list */
 154         if (!IsListEmpty(&pPool->leEmptyList))
 155         {
 156             /* Yes, remove it from the empty list */
 157             ple = RemoveHeadList(&pPool->leEmptyList);
 158             pSection = CONTAINING_RECORD(ple, GDI_POOL_SECTION, leInUseLink);
 159             pPool->cEmptySections--;
 160             ASSERT(pSection->cAllocCount == 0);
 161         }
 162         else
 163         {
 164             /* No, allocate a new section */
 165             pSection = GdiPoolAllocateSection(pPool);
 166             if (!pSection)
 167             {
 168                 DPRINT1("Couldn't allocate a section\n");
 169                 pvAlloc = NULL;
 170                 goto done;
 171             }
 172         }
 173
 174         /* Insert it into the in-use and ready list */
 175         InsertHeadList(&pPool->leInUseList, &pSection->leInUseLink);
 176         InsertHeadList(&pPool->leReadyList, &pSection->leReadyLink);
 177     }
 178
 179     /* Find and set a single bit */
 180     ulIndex = RtlFindClearBitsAndSet(&pSection->bitmap, 1, 0);
 181     ASSERT(ulIndex != MAXULONG);
 182
 183     /* Calculate the allocation address */
 184     cjOffset = ulIndex * pPool->cjAllocSize;
 185     pvAlloc = (PVOID)((ULONG_PTR)pSection->pvBaseAddress + cjOffset);
 186
 187     /* Check if memory is comitted */
 188     ulPageBit = 1 << (cjOffset / PAGE_SIZE);
 189     ulPageBit |= 1 << ((cjOffset + pPool->cjAllocSize - 1) / PAGE_SIZE);
 190     if ((pSection->ulCommitBitmap & ulPageBit) != ulPageBit)
 191     {
 192         /* Commit the pages */
 193         pvBaseAddress = PAGE_ALIGN(pvAlloc);
 194         cjSize = ADDRESS_AND_SIZE_TO_SPAN_PAGES(pvAlloc, pPool->cjAllocSize) * PAGE_SIZE;
 195         status = ZwAllocateVirtualMemory(NtCurrentProcess(),
 196                                          &pvBaseAddress,
 197                                          0,
 198                                          &cjSize,
 199                                          MEM_COMMIT,
 200                                          PAGE_READWRITE);
 201         if (!NT_SUCCESS(status))
 202         {
 203             pvAlloc = NULL;
 204             goto done;
 205         }
 206
 207         pSection->ulCommitBitmap |= ulPageBit;
 208     }
 209
 210     /* Increase alloc count */
 211     pSection->cAllocCount++;
 212     ASSERT(RtlNumberOfSetBits(&pSection->bitmap) == pSection->cAllocCount);
 213     DBG_LOGEVENT(&pPool->slhLog, EVENT_ALLOCATE, pvAlloc);
 214
 215     /* Check if section is now busy */
 216     if (pSection->cAllocCount == pPool->cSlotsPerSection)
 217     {
 218         /* Remove the section from the ready list */
 219         RemoveEntryList(&pSection->leReadyLink);
 220     }
 221
 222 done:
 223     /* Release the pool lock and enable APCs */
 224     ExReleasePushLockExclusive(&pPool->pushlock);
 225     KeLeaveCriticalRegion();
 226
 227     DPRINT("GdiPoolallocate: %p\n", pvAlloc);
 228     return pvAlloc;
 229 }
 230
 231 VOID
 232 NTAPI
 233 GdiPoolFree(
 234     PGDI_POOL pPool,
 235     PVOID pvAlloc)
 236 {
 237     PLIST_ENTRY ple;
 238     PGDI_POOL_SECTION pSection = NULL;
 239     ULONG_PTR cjOffset;
 240     ULONG ulIndex;
 241     DPRINT("GdiPoolFree: %p\n", pvAlloc);
 242
 243     /* Disable APCs and acquire the pool lock */
 244     KeEnterCriticalRegion();
 245     ExAcquirePushLockExclusive(&pPool->pushlock);
 246
 247     /* Loop all used sections */
 248     for (ple = pPool->leInUseList.Flink;
 249          ple != &pPool->leInUseList;
 250          ple = ple->Flink)
 251     {
 252         /* Get the pointer to the section */
 253         pSection = CONTAINING_RECORD(ple, GDI_POOL_SECTION, leInUseLink);
 254
 255         /* Calculate offset */
 256         cjOffset = (ULONG_PTR)pvAlloc - (ULONG_PTR)pSection->pvBaseAddress;
 257
 258         /* Check if the allocation is from this section */
 259         if (cjOffset < pPool->cjSectionSize)
 260         {
 261             /* Calculate the index of the allocation */
 262             ulIndex = cjOffset / pPool->cjAllocSize;
 263
 264             /* Mark it as free */
 265             ASSERT(RtlTestBit(&pSection->bitmap, ulIndex) == TRUE);
 266             RtlClearBit(&pSection->bitmap, ulIndex);
 267
 268             /* Decrease allocation count */
 269             pSection->cAllocCount--;
 270             ASSERT(RtlNumberOfSetBits(&pSection->bitmap) == pSection->cAllocCount);
 271             DBG_LOGEVENT(&pPool->slhLog, EVENT_FREE, pvAlloc);
 272
 273             /* Check if the section got valid now */
 274             if (pSection->cAllocCount == pPool->cSlotsPerSection - 1)
 275             {
 276                 /* Insert it into the ready list */
 277                 InsertTailList(&pPool->leReadyList, &pSection->leReadyLink);
 278             }
 279             /* Check if it got empty now */
 280             else if (pSection->cAllocCount == 0)
 281             {
 282                 /* Remove the section from the lists */
 283                 RemoveEntryList(&pSection->leInUseLink);
 284                 RemoveEntryList(&pSection->leReadyLink);
 285
 286                 if (pPool->cEmptySections >= 1)
 287                 {
 288                     /* Delete the section */
 289                     GdiPoolDeleteSection(pPool, pSection);
 290                 }
 291                 else
 292                 {
 293                     /* Insert it into the empty list */
 294                     InsertHeadList(&pPool->leEmptyList, &pSection->leInUseLink);
 295                     pPool->cEmptySections++;
 296                 }
 297             }
 298
 299             goto done;
 300         }
 301     }
 302
 303     DbgPrint("failed to free. pvAlloc=%p, base=%p, size=%lx\n",
 304              pvAlloc, pSection ? pSection->pvBaseAddress : NULL, pPool->cjSectionSize);
 305     ASSERT(FALSE);
 306     // KeBugCheck()
 307
 308 done:
 309     /* Release the pool lock and enable APCs */
 310     ExReleasePushLockExclusive(&pPool->pushlock);
 311     KeLeaveCriticalRegion();
 312 }
 313
 314 PGDI_POOL
 315 NTAPI
 316 GdiPoolCreate(
 317     ULONG cjAllocSize,
 318     ULONG ulTag)
 319 {
 320     PGDI_POOL pPool;
 321
 322     /* Allocate a pool object */
 323     pPool = EngAllocMem(0, sizeof(GDI_POOL), 'lopG');
 324     if (!pPool) return NULL;
 325
 326     /* Initialize the object */
 327     ExInitializePushLock(&pPool->pushlock);
 328     InitializeListHead(&pPool->leInUseList);
 329     InitializeListHead(&pPool->leReadyList);
 330     InitializeListHead(&pPool->leEmptyList);
 331     pPool->cEmptySections = 0;
 332     pPool->cjAllocSize = cjAllocSize;
 333     pPool->ulTag = ulTag;
 334     pPool->cjSectionSize = GDI_POOL_ALLOCATION_GRANULARITY;
 335     pPool->cSlotsPerSection = pPool->cjSectionSize / cjAllocSize;
 336     DBG_INITLOG(&pPool->slhLog);
 337
 338     return pPool;
 339 }
 340
 341 VOID
 342 NTAPI
 343 GdiPoolDestroy(PGDI_POOL pPool)
 344 {
 345     PGDI_POOL_SECTION pSection;
 346     PLIST_ENTRY ple;
 347
 348     /* Loop all empty sections, removing them */
 349     while (!IsListEmpty(&pPool->leEmptyList))
 350     {
 351         /* Delete the section */
 352         ple = RemoveHeadList(&pPool->leEmptyList);
 353         pSection = CONTAINING_RECORD(ple, GDI_POOL_SECTION, leInUseLink);
 354         GdiPoolDeleteSection(pPool, pSection);
 355     }
 356
 357     /* Loop all ready sections, removing them */
 358     while (!IsListEmpty(&pPool->leInUseList))
 359     {
 360         /* Delete the section */
 361         ple = RemoveHeadList(&pPool->leInUseList);
 362         pSection = CONTAINING_RECORD(ple, GDI_POOL_SECTION, leInUseLink);
 363         GdiPoolDeleteSection(pPool, pSection);
 364     }
 365
 366     DBG_CLEANUP_EVENT_LIST(&pPool->slhLog);
 367
 368     EngFreeMem(pPool);
 369 }