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 RtlDeleteCriticalSection(
  83     PRTL_CRITICAL_SECTION CriticalSection)
  84 {
  85     return STATUS_SUCCESS;
  86 }
  87
  88 DWORD
  89 STDCALL
  90 RtlSetCriticalSectionSpinCount(
  91    PRTL_CRITICAL_SECTION CriticalSection,
  92    DWORD SpinCount
  93    )
  94 {
  95    return 0;
  96 }
  97
  98 NTSTATUS
  99 STDCALL
 100 RtlEnterCriticalSection(
 101     PRTL_CRITICAL_SECTION CriticalSection)
 102 {
 103     ExAcquireFastMutex((PFAST_MUTEX) CriticalSection);
 104     return STATUS_SUCCESS;
 105 }
 106
 107 NTSTATUS
 108 STDCALL
 109 RtlInitializeCriticalSection(
 110     PRTL_CRITICAL_SECTION CriticalSection)
 111 {
 112    ExInitializeFastMutex((PFAST_MUTEX)CriticalSection );
 113    return STATUS_SUCCESS;
 114 }
 115
 116 NTSTATUS
 117 STDCALL
 118 RtlLeaveCriticalSection(
 119     PRTL_CRITICAL_SECTION CriticalSection)
 120 {
 121     ExReleaseFastMutex((PFAST_MUTEX) CriticalSection );
 122     return STATUS_SUCCESS;
 123 }
 124
 125 BOOLEAN
 126 STDCALL
 127 RtlTryEnterCriticalSection(
 128     PRTL_CRITICAL_SECTION CriticalSection)
 129 {
 130     return ExTryToAcquireFastMutex((PFAST_MUTEX) CriticalSection );
 131 }
 132
 133
 134 NTSTATUS
 135 STDCALL
 136 RtlInitializeCriticalSectionAndSpinCount(
 137     PRTL_CRITICAL_SECTION CriticalSection,
 138     ULONG SpinCount)
 139 {
 140     ExInitializeFastMutex((PFAST_MUTEX)CriticalSection );
 141     return STATUS_SUCCESS;
 142 }
 143
 144
 145 #ifdef DBG
 146 VOID FASTCALL
 147 CHECK_PAGED_CODE_RTL(char *file, int line)
 148 {
 149   if(KeGetCurrentIrql() > APC_LEVEL)
 150   {
 151     DbgPrint("%s:%i: Pagable code called at IRQL > APC_LEVEL (%d)\n", file, line, KeGetCurrentIrql());
 152     KEBUGCHECK(0);
 153   }
 154 }
 155 #endif
 156
 157 /* RTL Atom Tables ************************************************************/
 158
 159 NTSTATUS
 160 RtlpInitAtomTableLock(PRTL_ATOM_TABLE AtomTable)
 161 {
 162    ExInitializeFastMutex(&AtomTable->FastMutex);
 163
 164    return STATUS_SUCCESS;
 165 }
 166
 167
 168 VOID
 169 RtlpDestroyAtomTableLock(PRTL_ATOM_TABLE AtomTable)
 170 {
 171 }
 172
 173
 174 BOOLEAN
 175 RtlpLockAtomTable(PRTL_ATOM_TABLE AtomTable)
 176 {
 177    ExAcquireFastMutex(&AtomTable->FastMutex);
 178    return TRUE;
 179 }
 180
 181 VOID
 182 RtlpUnlockAtomTable(PRTL_ATOM_TABLE AtomTable)
 183 {
 184    ExReleaseFastMutex(&AtomTable->FastMutex);
 185 }
 186
 187 BOOLEAN
 188 RtlpCreateAtomHandleTable(PRTL_ATOM_TABLE AtomTable)
 189 {
 190    AtomTable->ExHandleTable = ExCreateHandleTable(NULL);
 191    return (AtomTable->ExHandleTable != NULL);
 192 }
 193
 194 static VOID STDCALL
 195 AtomDeleteHandleCallback(PHANDLE_TABLE HandleTable,
 196                          PVOID Object,
 197                          ULONG GrantedAccess,
 198                          PVOID Context)
 199 {
 200    return;
 201 }
 202
 203 VOID
 204 RtlpDestroyAtomHandleTable(PRTL_ATOM_TABLE AtomTable)
 205 {
 206    if (AtomTable->ExHandleTable)
 207    {
 208       ExDestroyHandleTable(AtomTable->ExHandleTable,
 209                            AtomDeleteHandleCallback,
 210                            AtomTable);
 211       AtomTable->ExHandleTable = NULL;
 212    }
 213 }
 214
 215 PRTL_ATOM_TABLE
 216 RtlpAllocAtomTable(ULONG Size)
 217 {
 218    PRTL_ATOM_TABLE Table = ExAllocatePool(NonPagedPool,
 219                                           Size);
 220    if (Table != NULL)
 221    {
 222       RtlZeroMemory(Table,
 223                     Size);
 224    }
 225
 226    return Table;
 227 }
 228
 229 VOID
 230 RtlpFreeAtomTable(PRTL_ATOM_TABLE AtomTable)
 231 {
 232    ExFreePool(AtomTable);
 233 }
 234
 235 PRTL_ATOM_TABLE_ENTRY
 236 RtlpAllocAtomTableEntry(ULONG Size)
 237 {
 238    PRTL_ATOM_TABLE_ENTRY Entry = ExAllocatePool(NonPagedPool,
 239                                                 Size);
 240    if (Entry != NULL)
 241    {
 242       RtlZeroMemory(Entry,
 243                     Size);
 244    }
 245
 246    return Entry;
 247 }
 248
 249 VOID
 250 RtlpFreeAtomTableEntry(PRTL_ATOM_TABLE_ENTRY Entry)
 251 {
 252    ExFreePool(Entry);
 253 }
 254
 255 VOID
 256 RtlpFreeAtomHandle(PRTL_ATOM_TABLE AtomTable, PRTL_ATOM_TABLE_ENTRY Entry)
 257 {
 258    ExDestroyHandle(AtomTable->ExHandleTable,
 259                    (HANDLE)((ULONG_PTR)Entry->HandleIndex << 2));
 260 }
 261
 262 BOOLEAN
 263 RtlpCreateAtomHandle(PRTL_ATOM_TABLE AtomTable, PRTL_ATOM_TABLE_ENTRY Entry)
 264 {
 265    HANDLE_TABLE_ENTRY ExEntry;
 266    HANDLE Handle;
 267    USHORT HandleIndex;
 268
 269    ExEntry.u1.Object = Entry;
 270    ExEntry.u2.GrantedAccess = 0x1; /* FIXME - valid handle */
 271
 272    Handle = ExCreateHandle(AtomTable->ExHandleTable,
 273                                 &ExEntry);
 274    if (Handle != NULL)
 275    {
 276       HandleIndex = (USHORT)((ULONG_PTR)Handle >> 2);
 277       /* FIXME - Handle Indexes >= 0xC000 ?! */
 278       if ((ULONG_PTR)HandleIndex >> 2 < 0xC000)
 279       {
 280          Entry->HandleIndex = HandleIndex;
 281          Entry->Atom = 0xC000 + HandleIndex;
 282
 283          return TRUE;
 284       }
 285       else
 286          ExDestroyHandle(AtomTable->ExHandleTable,
 287                          Handle);
 288    }
 289
 290    return FALSE;
 291 }
 292
 293 PRTL_ATOM_TABLE_ENTRY
 294 RtlpGetAtomEntry(PRTL_ATOM_TABLE AtomTable, ULONG Index)
 295 {
 296    PHANDLE_TABLE_ENTRY ExEntry;
 297    PRTL_ATOM_TABLE_ENTRY Entry = NULL;
 298
 299    /* NOTE: There's no need to explicitly enter a critical region because it's
 300             guaranteed that we're in a critical region right now (as we hold
 301             the atom table lock) */
 302
 303    ExEntry = ExMapHandleToPointer(AtomTable->ExHandleTable,
 304                                   (HANDLE)((ULONG_PTR)Index << 2));
 305    if (ExEntry != NULL)
 306    {
 307       Entry = ExEntry->u1.Object;
 308
 309       ExUnlockHandleTableEntry(AtomTable->ExHandleTable,
 310                                ExEntry);
 311    }
 312
 313    return Entry;
 314 }
 315
 316 /* FIXME - RtlpCreateUnicodeString is obsolete and should be removed ASAP! */
 317 BOOLEAN FASTCALL
 318 RtlpCreateUnicodeString(
 319    IN OUT PUNICODE_STRING UniDest,
 320    IN PCWSTR  Source,
 321    IN POOL_TYPE PoolType)
 322 {
 323    ULONG Length;
 324
 325    Length = (wcslen (Source) + 1) * sizeof(WCHAR);
 326    UniDest->Buffer = ExAllocatePoolWithTag(PoolType, Length, TAG('U', 'S', 'T', 'R'));
 327    if (UniDest->Buffer == NULL)
 328       return FALSE;
 329
 330    RtlCopyMemory (UniDest->Buffer,
 331                   Source,
 332                   Length);
 333
 334    UniDest->MaximumLength = Length;
 335    UniDest->Length = Length - sizeof (WCHAR);
 336
 337    return TRUE;
 338 }
 339
 340 /* EOF */