ntoskrnl/mm/pool.c

   1 /* $Id$
   2  *
   3  * COPYRIGHT:    See COPYING in the top level directory
   4  * PROJECT:      ReactOS kernel
   5  * FILE:         ntoskrnl/mm/pool.c
   6  * PURPOSE:      Implements the kernel memory pool
   7  * PROGRAMMER:   David Welch (welch@mcmail.com)
   8  */
   9
  10 /* INCLUDES ****************************************************************/
  11
  12 #include <ddk/ntddk.h>
  13 #include <internal/ntoskrnl.h>
  14 #include <internal/pool.h>
  15
  16 #define NDEBUG
  17 #include <internal/debug.h>
  18
  19 /* GLOBALS *****************************************************************/
  20
  21 #define TAG_NONE (ULONG)(('N'<<0) + ('o'<<8) + ('n'<<16) + ('e'<<24))
  22
  23 /* FUNCTIONS ***************************************************************/
  24
  25 PVOID STDCALL STATIC
  26 EiAllocatePool(POOL_TYPE PoolType,
  27                ULONG NumberOfBytes,
  28                ULONG Tag,
  29                PVOID Caller)
  30 {
  31    PVOID Block;
  32
  33    if (PoolType == NonPagedPoolCacheAligned ||
  34        PoolType == NonPagedPoolCacheAlignedMustS)
  35      {
  36         UNIMPLEMENTED;
  37      }
  38
  39    switch(PoolType)
  40      {
  41       case NonPagedPool:
  42       case NonPagedPoolMustSucceed:
  43       case NonPagedPoolCacheAligned:
  44       case NonPagedPoolCacheAlignedMustS:
  45         Block =
  46           ExAllocateNonPagedPoolWithTag(PoolType,
  47                                         NumberOfBytes,
  48                                         Tag,
  49                                         Caller);
  50         break;
  51
  52       case PagedPool:
  53       case PagedPoolCacheAligned:
  54         Block = ExAllocatePagedPoolWithTag(PoolType,NumberOfBytes,Tag);
  55         break;
  56
  57       default:
  58         return(NULL);
  59      };
  60
  61    if ((PoolType==NonPagedPoolMustSucceed ||
  62         PoolType==NonPagedPoolCacheAlignedMustS) && Block==NULL)
  63      {
  64         KeBugCheck(MUST_SUCCEED_POOL_EMPTY);
  65      }
  66    return(Block);
  67 }
  68
  69 PVOID STDCALL
  70 ExAllocatePool (POOL_TYPE PoolType, ULONG NumberOfBytes)
  71 /*
  72  * FUNCTION: Allocates pool memory of a specified type and returns a pointer
  73  * to the allocated block. This routine is used for general purpose allocation
  74  * of memory
  75  * ARGUMENTS:
  76  *        PoolType
  77  *               Specifies the type of memory to allocate which can be one
  78  *               of the following:
  79  *
  80  *               NonPagedPool
  81  *               NonPagedPoolMustSucceed
  82  *               NonPagedPoolCacheAligned
  83  *               NonPagedPoolCacheAlignedMustS
  84  *               PagedPool
  85  *               PagedPoolCacheAligned
  86  *
  87  *        NumberOfBytes
  88  *               Specifies the number of bytes to allocate
  89  * RETURNS: The allocated block on success
  90  *          NULL on failure
  91  */
  92 {
  93    PVOID Block;
  94    Block = EiAllocatePool(PoolType,
  95                           NumberOfBytes,
  96                           TAG_NONE,
  97                           (PVOID)__builtin_return_address(0));
  98    return(Block);
  99 }
 100
 101
 102 PVOID STDCALL
 103 ExAllocatePoolWithTag (ULONG PoolType, ULONG NumberOfBytes, ULONG Tag)
 104 {
 105    PVOID Block;
 106    Block = EiAllocatePool(PoolType,
 107                           NumberOfBytes,
 108                           Tag,
 109                           (PVOID)__builtin_return_address(0));
 110    return(Block);
 111 }
 112
 113
 114 PVOID STDCALL
 115 ExAllocatePoolWithQuota (POOL_TYPE PoolType, ULONG NumberOfBytes)
 116 {
 117   return(ExAllocatePoolWithQuotaTag(PoolType, NumberOfBytes, TAG_NONE));
 118 }
 119
 120
 121 PVOID STDCALL
 122 ExAllocatePoolWithQuotaTag (IN  POOL_TYPE       PoolType,
 123                             IN  ULONG           NumberOfBytes,
 124                             IN  ULONG           Tag)
 125 {
 126 #if 0
 127   PVOID Block;
 128   Block = EiAllocatePool(PoolType,
 129                          NumberOfBytes,
 130                          Tag,
 131                          (PVOID)__builtin_return_address(0));
 132   return(Block);
 133 #endif
 134   UNIMPLEMENTED;
 135 }
 136
 137 VOID STDCALL
 138 ExFreePool(IN PVOID Block)
 139 {
 140   if (Block >= MmPagedPoolBase && Block < (MmPagedPoolBase + MmPagedPoolSize))
 141     {
 142       ExFreePagedPool(Block);
 143     }
 144   else
 145     {
 146       ExFreeNonPagedPool(Block);
 147     }
 148 }
 149
 150 /* EOF */
 151
 152
 153
 154