reactos/ntoskrnl/rtl/libsupp.c

   1 /* $Id$
   2  *
   3  * COPYRIGHT:       See COPYING in the top level directory
   4  * PROJECT:         ReactOS kernel
   5  * FILE:            ntoskrnl/rtl/libsupp.c
   6  * PURPOSE:         Rtl library support routines
   7  *
   8  * PROGRAMMERS:     No programmer listed.
   9  */
  10
  11 /* INCLUDES ******************************************************************/
  12
  13 #include <ntoskrnl.h>
  14 #define NDEBUG
  15 #include <internal/debug.h>
  16
  17 /* FUNCTIONS *****************************************************************/
  18
  19
  20 KPROCESSOR_MODE
  21 STDCALL
  22 RtlpGetMode()
  23 {
  24    return KernelMode;
  25 }
  26
  27 PVOID
  28 STDCALL
  29 RtlpAllocateMemory(UINT Bytes,
  30                    ULONG Tag)
  31 {
  32     return ExAllocatePoolWithTag(PagedPool,
  33                                  (SIZE_T)Bytes,
  34                                  Tag);
  35 }
  36
  37
  38 VOID
  39 STDCALL
  40 RtlpFreeMemory(PVOID Mem,
  41                ULONG Tag)
  42 {
  43     ExFreePoolWithTag(Mem,
  44                       Tag);
  45 }
  46
  47 /*
  48  * @implemented
  49  */
  50 VOID STDCALL
  51 RtlAcquirePebLock(VOID)
  52 {
  53
  54 }
  55
  56 /*
  57  * @implemented
  58  */
  59 VOID STDCALL
  60 RtlReleasePebLock(VOID)
  61 {
  62
  63 }
  64
  65 NTSTATUS
  66 STDCALL
  67 LdrShutdownThread(VOID)
  68 {
  69     return STATUS_SUCCESS;
  70 }
  71
  72
  73 PPEB
  74 STDCALL
  75 RtlpCurrentPeb(VOID)
  76 {
  77    return ((PEPROCESS)(KeGetCurrentThread()->ApcState.Process))->Peb;
  78 }
  79
  80 NTSTATUS
  81 STDCALL
  82 RtlDeleteHeapLock(
  83     PRTL_CRITICAL_SECTION CriticalSection)
  84 {
  85     return STATUS_SUCCESS;
  86 }
  87
  88 NTSTATUS
  89 STDCALL
  90 RtlEnterHeapLock(
  91     PRTL_CRITICAL_SECTION CriticalSection)
  92 {
  93     ExAcquireFastMutex((PFAST_MUTEX) CriticalSection);
  94     return STATUS_SUCCESS;
  95 }
  96
  97 NTSTATUS
  98 STDCALL
  99 RtlInitializeHeapLock(
 100     PRTL_CRITICAL_SECTION CriticalSection)
 101 {
 102    ExInitializeFastMutex((PFAST_MUTEX)CriticalSection );
 103    return STATUS_SUCCESS;
 104 }
 105
 106 NTSTATUS
 107 STDCALL
 108 RtlLeaveHeapLock(
 109     PRTL_CRITICAL_SECTION CriticalSection)
 110 {
 111     ExReleaseFastMutex((PFAST_MUTEX) CriticalSection );
 112     return STATUS_SUCCESS;
 113 }
 114
 115 #ifdef DBG
 116 VOID FASTCALL
 117 CHECK_PAGED_CODE_RTL(char *file, int line)
 118 {
 119   if(KeGetCurrentIrql() > APC_LEVEL)
 120   {
 121     DbgPrint("%s:%i: Pagable code called at IRQL > APC_LEVEL (%d)\n", file, line, KeGetCurrentIrql());
 122     KEBUGCHECK(0);
 123   }
 124 }
 125 #endif
 126
 127 /* RTL Atom Tables ************************************************************/
 128
 129 NTSTATUS
 130 RtlpInitAtomTableLock(PRTL_ATOM_TABLE AtomTable)
 131 {
 132    ExInitializeFastMutex(&AtomTable->FastMutex);
 133
 134    return STATUS_SUCCESS;
 135 }
 136
 137
 138 VOID
 139 RtlpDestroyAtomTableLock(PRTL_ATOM_TABLE AtomTable)
 140 {
 141 }
 142
 143
 144 BOOLEAN
 145 RtlpLockAtomTable(PRTL_ATOM_TABLE AtomTable)
 146 {
 147    ExAcquireFastMutex(&AtomTable->FastMutex);
 148    return TRUE;
 149 }
 150
 151 VOID
 152 RtlpUnlockAtomTable(PRTL_ATOM_TABLE AtomTable)
 153 {
 154    ExReleaseFastMutex(&AtomTable->FastMutex);
 155 }
 156
 157 BOOLEAN
 158 RtlpCreateAtomHandleTable(PRTL_ATOM_TABLE AtomTable)
 159 {
 160    AtomTable->ExHandleTable = ExCreateHandleTable(NULL);
 161    return (AtomTable->ExHandleTable != NULL);
 162 }
 163
 164 static VOID STDCALL
 165 AtomDeleteHandleCallback(PHANDLE_TABLE HandleTable,
 166                          PVOID Object,
 167                          ULONG GrantedAccess,
 168                          PVOID Context)
 169 {
 170    return;
 171 }
 172
 173 VOID
 174 RtlpDestroyAtomHandleTable(PRTL_ATOM_TABLE AtomTable)
 175 {
 176    if (AtomTable->ExHandleTable)
 177    {
 178       ExDestroyHandleTable(AtomTable->ExHandleTable,
 179                            AtomDeleteHandleCallback,
 180                            AtomTable);
 181       AtomTable->ExHandleTable = NULL;
 182    }
 183 }
 184
 185 PRTL_ATOM_TABLE
 186 RtlpAllocAtomTable(ULONG Size)
 187 {
 188    PRTL_ATOM_TABLE Table = ExAllocatePool(NonPagedPool,
 189                                           Size);
 190    if (Table != NULL)
 191    {
 192       RtlZeroMemory(Table,
 193                     Size);
 194    }
 195
 196    return Table;
 197 }
 198
 199 VOID
 200 RtlpFreeAtomTable(PRTL_ATOM_TABLE AtomTable)
 201 {
 202    ExFreePool(AtomTable);
 203 }
 204
 205 PRTL_ATOM_TABLE_ENTRY
 206 RtlpAllocAtomTableEntry(ULONG Size)
 207 {
 208    PRTL_ATOM_TABLE_ENTRY Entry = ExAllocatePool(NonPagedPool,
 209                                                 Size);
 210    if (Entry != NULL)
 211    {
 212       RtlZeroMemory(Entry,
 213                     Size);
 214    }
 215
 216    return Entry;
 217 }
 218
 219 VOID
 220 RtlpFreeAtomTableEntry(PRTL_ATOM_TABLE_ENTRY Entry)
 221 {
 222    ExFreePool(Entry);
 223 }
 224
 225 VOID
 226 RtlpFreeAtomHandle(PRTL_ATOM_TABLE AtomTable, PRTL_ATOM_TABLE_ENTRY Entry)
 227 {
 228    ExDestroyHandle(AtomTable->ExHandleTable,
 229                    (HANDLE)((ULONG_PTR)Entry->HandleIndex << 2));
 230 }
 231
 232 BOOLEAN
 233 RtlpCreateAtomHandle(PRTL_ATOM_TABLE AtomTable, PRTL_ATOM_TABLE_ENTRY Entry)
 234 {
 235    HANDLE_TABLE_ENTRY ExEntry;
 236    HANDLE Handle;
 237    USHORT HandleIndex;
 238
 239    ExEntry.u1.Object = Entry;
 240    ExEntry.u2.GrantedAccess = 0x1; /* FIXME - valid handle */
 241
 242    Handle = ExCreateHandle(AtomTable->ExHandleTable,
 243                                 &ExEntry);
 244    if (Handle != NULL)
 245    {
 246       HandleIndex = (USHORT)((ULONG_PTR)Handle >> 2);
 247       /* FIXME - Handle Indexes >= 0xC000 ?! */
 248       if ((ULONG_PTR)HandleIndex >> 2 < 0xC000)
 249       {
 250          Entry->HandleIndex = HandleIndex;
 251          Entry->Atom = 0xC000 + HandleIndex;
 252
 253          return TRUE;
 254       }
 255       else
 256          ExDestroyHandle(AtomTable->ExHandleTable,
 257                          Handle);
 258    }
 259
 260    return FALSE;
 261 }
 262
 263 PRTL_ATOM_TABLE_ENTRY
 264 RtlpGetAtomEntry(PRTL_ATOM_TABLE AtomTable, ULONG Index)
 265 {
 266    PHANDLE_TABLE_ENTRY ExEntry;
 267    PRTL_ATOM_TABLE_ENTRY Entry = NULL;
 268
 269    /* NOTE: There's no need to explicitly enter a critical region because it's
 270             guaranteed that we're in a critical region right now (as we hold
 271             the atom table lock) */
 272
 273    ExEntry = ExMapHandleToPointer(AtomTable->ExHandleTable,
 274                                   (HANDLE)((ULONG_PTR)Index << 2));
 275    if (ExEntry != NULL)
 276    {
 277       Entry = ExEntry->u1.Object;
 278
 279       ExUnlockHandleTableEntry(AtomTable->ExHandleTable,
 280                                ExEntry);
 281    }
 282
 283    return Entry;
 284 }
 285
 286 /* FIXME - RtlpCreateUnicodeString is obsolete and should be removed ASAP! */
 287 BOOLEAN FASTCALL
 288 RtlpCreateUnicodeString(
 289    IN OUT PUNICODE_STRING UniDest,
 290    IN PCWSTR  Source,
 291    IN POOL_TYPE PoolType)
 292 {
 293    ULONG Length;
 294
 295    Length = (wcslen (Source) + 1) * sizeof(WCHAR);
 296    UniDest->Buffer = ExAllocatePoolWithTag(PoolType, Length, TAG('U', 'S', 'T', 'R'));
 297    if (UniDest->Buffer == NULL)
 298       return FALSE;
 299
 300    RtlCopyMemory (UniDest->Buffer,
 301                   Source,
 302                   Length);
 303
 304    UniDest->MaximumLength = Length;
 305    UniDest->Length = Length - sizeof (WCHAR);
 306
 307    return TRUE;
 308 }
 309
 310 /* EOF */