reactos/lib/ntdll/rtl/libsupp.c

   1 /* $Id$
   2  *
   3  * COPYRIGHT:       See COPYING in the top level directory
   4  * PROJECT:         ReactOS kernel
   5  * FILE:            lib/ntdll/rtl/libsup.c
   6  * PURPOSE:         Rtl library support routines
   7  * PROGRAMMER:      Gunnar Dalsnes
   8  * UPDATE HISTORY:
   9  *
  10  */
  11
  12 #include <ntdll.h>
  13 #define NDEBUG
  14 #include <debug.h>
  15
  16 /* FUNCTIONS ***************************************************************/
  17
  18 KPROCESSOR_MODE
  19 RtlpGetMode()
  20 {
  21    return UserMode;
  22 }
  23
  24
  25 PVOID
  26 STDCALL
  27 ExAllocatePool(
  28    IN POOL_TYPE   PoolType,
  29    IN SIZE_T      Bytes
  30 )
  31 {
  32    return RtlAllocateHeap (
  33       RtlGetProcessHeap (),
  34       0,
  35       Bytes);
  36 }
  37
  38 PVOID
  39 STDCALL
  40 ExAllocatePoolWithTag(
  41    IN POOL_TYPE   PoolType,
  42    IN SIZE_T      Bytes,
  43    IN ULONG       Tag
  44 )
  45 {
  46    return RtlAllocateHeap (
  47       RtlGetProcessHeap (),
  48       0,
  49       Bytes);
  50 }
  51
  52 VOID
  53 STDCALL
  54 ExFreePool(IN PVOID Mem)
  55 {
  56    RtlFreeHeap (
  57       RtlGetProcessHeap (),
  58       0,
  59       Mem);
  60 }
  61
  62 VOID
  63 STDCALL
  64 ExFreePoolWithTag(IN PVOID Mem, IN ULONG Tag)
  65 {
  66    RtlFreeHeap (
  67       RtlGetProcessHeap (),
  68       0,
  69       Mem);
  70 }
  71
  72
  73 #ifdef DBG
  74 VOID FASTCALL
  75 CHECK_PAGED_CODE_RTL(char *file, int line)
  76 {
  77   /* meaningless in user mode */
  78 }
  79 #endif
  80
  81 /* RTL Atom Tables ************************************************************/
  82
  83 typedef struct _RTL_ATOM_HANDLE
  84 {
  85    RTL_HANDLE_TABLE_ENTRY Handle;
  86    PRTL_ATOM_TABLE_ENTRY AtomEntry;
  87 } RTL_ATOM_HANDLE, *PRTL_ATOM_HANDLE;
  88
  89 NTSTATUS
  90 RtlpInitAtomTableLock(PRTL_ATOM_TABLE AtomTable)
  91 {
  92    RtlInitializeCriticalSection(&AtomTable->CriticalSection);
  93    return STATUS_SUCCESS;
  94 }
  95
  96
  97 VOID
  98 RtlpDestroyAtomTableLock(PRTL_ATOM_TABLE AtomTable)
  99 {
 100    RtlDeleteCriticalSection(&AtomTable->CriticalSection);
 101 }
 102
 103
 104 BOOLEAN
 105 RtlpLockAtomTable(PRTL_ATOM_TABLE AtomTable)
 106 {
 107    RtlEnterCriticalSection(&AtomTable->CriticalSection);
 108    return TRUE;
 109 }
 110
 111
 112 VOID
 113 RtlpUnlockAtomTable(PRTL_ATOM_TABLE AtomTable)
 114 {
 115    RtlLeaveCriticalSection(&AtomTable->CriticalSection);
 116 }
 117
 118
 119 /* handle functions */
 120
 121 BOOLEAN
 122 RtlpCreateAtomHandleTable(PRTL_ATOM_TABLE AtomTable)
 123 {
 124    RtlInitializeHandleTable(0xCFFF,
 125                             sizeof(RTL_ATOM_HANDLE),
 126                             &AtomTable->RtlHandleTable);
 127
 128    return TRUE;
 129 }
 130
 131 VOID
 132 RtlpDestroyAtomHandleTable(PRTL_ATOM_TABLE AtomTable)
 133 {
 134    RtlDestroyHandleTable(&AtomTable->RtlHandleTable);
 135 }
 136
 137 PRTL_ATOM_TABLE
 138 RtlpAllocAtomTable(ULONG Size)
 139 {
 140    return (PRTL_ATOM_TABLE)RtlAllocateHeap(RtlGetProcessHeap(),
 141                                            HEAP_ZERO_MEMORY,
 142                                            Size);
 143 }
 144
 145 VOID
 146 RtlpFreeAtomTable(PRTL_ATOM_TABLE AtomTable)
 147 {
 148    RtlFreeHeap(RtlGetProcessHeap(),
 149                0,
 150                AtomTable);
 151 }
 152
 153 PRTL_ATOM_TABLE_ENTRY
 154 RtlpAllocAtomTableEntry(ULONG Size)
 155 {
 156    return (PRTL_ATOM_TABLE_ENTRY)RtlAllocateHeap(RtlGetProcessHeap(),
 157                                                  HEAP_ZERO_MEMORY,
 158                                                  Size);
 159 }
 160
 161 VOID
 162 RtlpFreeAtomTableEntry(PRTL_ATOM_TABLE_ENTRY Entry)
 163 {
 164    RtlFreeHeap(RtlGetProcessHeap(),
 165                0,
 166                Entry);
 167 }
 168
 169 VOID
 170 RtlpFreeAtomHandle(PRTL_ATOM_TABLE AtomTable, PRTL_ATOM_TABLE_ENTRY Entry)
 171 {
 172    PRTL_HANDLE_TABLE_ENTRY RtlHandleEntry;
 173
 174    if (RtlIsValidIndexHandle(&AtomTable->RtlHandleTable,
 175                              &RtlHandleEntry,
 176                              (ULONG)Entry->HandleIndex))
 177    {
 178       RtlFreeHandle(&AtomTable->RtlHandleTable,
 179                     RtlHandleEntry);
 180    }
 181 }
 182
 183 BOOLEAN
 184 RtlpCreateAtomHandle(PRTL_ATOM_TABLE AtomTable, PRTL_ATOM_TABLE_ENTRY Entry)
 185 {
 186    ULONG HandleIndex;
 187    PRTL_HANDLE_TABLE_ENTRY RtlHandle;
 188
 189    RtlHandle = RtlAllocateHandle(&AtomTable->RtlHandleTable,
 190                                  &HandleIndex);
 191    if (RtlHandle != NULL)
 192    {
 193       PRTL_ATOM_HANDLE AtomHandle = (PRTL_ATOM_HANDLE)RtlHandle;
 194
 195       /* FIXME - Handle Indexes >= 0xC000 ?! */
 196       if (HandleIndex < 0xC000)
 197       {
 198          Entry->HandleIndex = (USHORT)HandleIndex;
 199          Entry->Atom = 0xC000 + (USHORT)HandleIndex;
 200
 201          AtomHandle->AtomEntry = Entry;
 202          AtomHandle->Handle.Flags = RTL_HANDLE_VALID;
 203
 204          return TRUE;
 205       }
 206       else
 207       {
 208          /* set the valid flag, otherwise RtlFreeHandle will fail! */
 209          AtomHandle->Handle.Flags = RTL_HANDLE_VALID;
 210
 211          RtlFreeHandle(&AtomTable->RtlHandleTable,
 212                        RtlHandle);
 213       }
 214    }
 215
 216    return FALSE;
 217 }
 218
 219 PRTL_ATOM_TABLE_ENTRY
 220 RtlpGetAtomEntry(PRTL_ATOM_TABLE AtomTable, ULONG Index)
 221 {
 222    PRTL_HANDLE_TABLE_ENTRY RtlHandle;
 223
 224    if (RtlIsValidIndexHandle(&AtomTable->RtlHandleTable,
 225                              &RtlHandle,
 226                              Index))
 227    {
 228       PRTL_ATOM_HANDLE AtomHandle = (PRTL_ATOM_HANDLE)RtlHandle;
 229
 230       return AtomHandle->AtomEntry;
 231    }
 232
 233    return NULL;
 234 }
 235