reactos/ntoskrnl/rtl/libsupp.c

   1 /*
   2  * COPYRIGHT:       See COPYING in the top level directory
   3  * PROJECT:         ReactOS kernel
   4  * FILE:            ntoskrnl/rtl/libsupp.c
   5  * PURPOSE:         RTL Support Routines
   6  * PROGRAMMERS:     Alex Ionescu (alex@relsoft.net)
   7  *                  Gunnar Dalsnes
   8  */
   9
  10 /* INCLUDES ******************************************************************/
  11
  12 #include <ntoskrnl.h>
  13 #define NDEBUG
  14 #include <internal/debug.h>
  15
  16 extern ULONG NtGlobalFlag;
  17
  18 typedef struct _RTL_RANGE_ENTRY
  19 {
  20     LIST_ENTRY Entry;
  21     RTL_RANGE Range;
  22 } RTL_RANGE_ENTRY, *PRTL_RANGE_ENTRY;
  23
  24 PAGED_LOOKASIDE_LIST RtlpRangeListEntryLookasideList;
  25 SIZE_T RtlpAllocDeallocQueryBufferSize = 128;
  26
  27 /* FUNCTIONS *****************************************************************/
  28
  29 VOID
  30 NTAPI
  31 RtlInitializeRangeListPackage(VOID)
  32 {
  33     /* Setup the lookaside list for allocations (not used yet) */
  34     ExInitializePagedLookasideList(&RtlpRangeListEntryLookasideList,
  35                                    NULL,
  36                                    NULL,
  37                                    POOL_COLD_ALLOCATION,
  38                                    sizeof(RTL_RANGE_ENTRY),
  39                                    TAG('R', 'R', 'l', 'e'),
  40                                    16);
  41 }
  42
  43 BOOLEAN
  44 NTAPI
  45 RtlpCheckForActiveDebugger(BOOLEAN Type)
  46 {
  47     /* This check is meaningless in kernel-mode */
  48     return Type;
  49 }
  50
  51 BOOLEAN
  52 NTAPI
  53 RtlpSetInDbgPrint(IN BOOLEAN NewValue)
  54 {
  55     /* This check is meaningless in kernel-mode */
  56     return FALSE;
  57 }
  58
  59 KPROCESSOR_MODE
  60 STDCALL
  61 RtlpGetMode()
  62 {
  63    return KernelMode;
  64 }
  65
  66 PVOID
  67 STDCALL
  68 RtlpAllocateMemory(ULONG Bytes,
  69                    ULONG Tag)
  70 {
  71     return ExAllocatePoolWithTag(PagedPool,
  72                                  (SIZE_T)Bytes,
  73                                  Tag);
  74 }
  75
  76
  77 VOID
  78 STDCALL
  79 RtlpFreeMemory(PVOID Mem,
  80                ULONG Tag)
  81 {
  82     ExFreePoolWithTag(Mem,
  83                       Tag);
  84 }
  85
  86 /*
  87  * @implemented
  88  */
  89 VOID STDCALL
  90 RtlAcquirePebLock(VOID)
  91 {
  92
  93 }
  94
  95 /*
  96  * @implemented
  97  */
  98 VOID STDCALL
  99 RtlReleasePebLock(VOID)
 100 {
 101
 102 }
 103
 104 NTSTATUS
 105 STDCALL
 106 LdrShutdownThread(VOID)
 107 {
 108     return STATUS_SUCCESS;
 109 }
 110
 111
 112 PPEB
 113 STDCALL
 114 RtlpCurrentPeb(VOID)
 115 {
 116    return ((PEPROCESS)(KeGetCurrentThread()->ApcState.Process))->Peb;
 117 }
 118
 119 NTSTATUS
 120 STDCALL
 121 RtlDeleteHeapLock(
 122     PRTL_CRITICAL_SECTION CriticalSection)
 123 {
 124     KEBUGCHECK(0);
 125     return STATUS_SUCCESS;
 126 }
 127
 128 NTSTATUS
 129 STDCALL
 130 RtlEnterHeapLock(
 131     PRTL_CRITICAL_SECTION CriticalSection)
 132 {
 133     KEBUGCHECK(0);
 134     return STATUS_SUCCESS;
 135 }
 136
 137 NTSTATUS
 138 STDCALL
 139 RtlInitializeHeapLock(
 140     PRTL_CRITICAL_SECTION CriticalSection)
 141 {
 142    KEBUGCHECK(0);
 143    return STATUS_SUCCESS;
 144 }
 145
 146 NTSTATUS
 147 STDCALL
 148 RtlLeaveHeapLock(
 149     PRTL_CRITICAL_SECTION CriticalSection)
 150 {
 151     KEBUGCHECK(0);
 152     return STATUS_SUCCESS;
 153 }
 154
 155 #ifdef DBG
 156 VOID FASTCALL
 157 CHECK_PAGED_CODE_RTL(char *file, int line)
 158 {
 159   if(KeGetCurrentIrql() > APC_LEVEL)
 160   {
 161     DbgPrint("%s:%i: Pagable code called at IRQL > APC_LEVEL (%d)\n", file, line, KeGetCurrentIrql());
 162     KEBUGCHECK(0);
 163   }
 164 }
 165 #endif
 166
 167 VOID
 168 NTAPI
 169 RtlpCheckLogException(IN PEXCEPTION_RECORD ExceptionRecord,
 170                       IN PCONTEXT ContextRecord,
 171                       IN PVOID ContextData,
 172                       IN ULONG Size)
 173 {
 174     /* Check the global flag */
 175     if (NtGlobalFlag & FLG_ENABLE_EXCEPTION_LOGGING)
 176     {
 177         /* FIXME: Log this exception */
 178     }
 179 }
 180
 181 BOOLEAN
 182 NTAPI
 183 RtlpHandleDpcStackException(IN PEXCEPTION_REGISTRATION_RECORD RegistrationFrame,
 184                             IN ULONG_PTR RegistrationFrameEnd,
 185                             IN OUT PULONG_PTR StackLow,
 186                             IN OUT PULONG_PTR StackHigh)
 187 {
 188     PKPRCB Prcb;
 189     ULONG_PTR DpcStack;
 190
 191     /* Check if we are at DISPATCH or higher */
 192     if (KeGetCurrentIrql() >= DISPATCH_LEVEL)
 193     {
 194         /* Get the PRCB and DPC Stack */
 195         Prcb = KeGetCurrentPrcb();
 196         DpcStack = (ULONG_PTR)Prcb->DpcStack;
 197
 198         /* Check if we are in a DPC and the stack matches */
 199         if ((Prcb->DpcRoutineActive) &&
 200             (RegistrationFrameEnd <= DpcStack) &&
 201             ((ULONG_PTR)RegistrationFrame >= DpcStack - KERNEL_STACK_SIZE))
 202         {
 203             /* Update the limits to the DPC Stack's */
 204             *StackHigh = DpcStack;
 205             *StackLow = DpcStack - KERNEL_STACK_SIZE;
 206             return TRUE;
 207         }
 208     }
 209
 210     /* Not in DPC stack */
 211     return FALSE;
 212 }
 213
 214 BOOLEAN
 215 NTAPI
 216 RtlpCaptureStackLimits(IN ULONG_PTR Ebp,
 217                        IN ULONG_PTR *StackBegin,
 218                        IN ULONG_PTR *StackEnd)
 219 {
 220     PKTHREAD Thread = KeGetCurrentThread();
 221
 222     /* Don't even try at ISR level or later */
 223     if (KeGetCurrentIrql() > DISPATCH_LEVEL) return FALSE;
 224
 225     /* Start with defaults */
 226     *StackBegin = Thread->StackLimit;
 227     *StackEnd = (ULONG_PTR)Thread->StackBase;
 228
 229     /* Check if EBP is inside the stack */
 230     if ((*StackBegin <= Ebp) && (Ebp <= *StackEnd))
 231     {
 232         /* Then make the stack start at EBP */
 233         *StackBegin = Ebp;
 234     }
 235     else
 236     {
 237         /* Now we're going to assume we're on the DPC stack */
 238         *StackEnd = (ULONG_PTR)(KeGetPcr()->Prcb->DpcStack);
 239         *StackBegin = *StackEnd - KERNEL_STACK_SIZE;
 240
 241         /* Check if we seem to be on the DPC stack */
 242         if ((*StackEnd) && (*StackBegin < Ebp) && (Ebp <= *StackEnd))
 243         {
 244             /* We're on the DPC stack */
 245             *StackBegin = Ebp;
 246         }
 247         else
 248         {
 249             /* We're somewhere else entirely... use EBP for safety */
 250             *StackBegin = Ebp;
 251             *StackEnd = (ULONG_PTR)PAGE_ALIGN(*StackBegin);
 252         }
 253     }
 254
 255     /* Return success */
 256     return TRUE;
 257 }
 258
 259 /*
 260  * @implemented
 261  */
 262 ULONG
 263 NTAPI
 264 RtlWalkFrameChain(OUT PVOID *Callers,
 265                   IN ULONG Count,
 266                   IN ULONG Flags)
 267 {
 268     ULONG_PTR Stack, NewStack, StackBegin, StackEnd = 0;
 269     ULONG Eip;
 270     BOOLEAN Result, StopSearch = FALSE;
 271     ULONG i = 0;
 272     PKTHREAD Thread = KeGetCurrentThread();
 273     PTEB Teb;
 274     PKTRAP_FRAME TrapFrame;
 275
 276     /* Get current EBP */
 277 #if defined(_M_IX86)
 278 #if defined __GNUC__
 279     __asm__("mov %%ebp, %0" : "=r" (Stack) : );
 280 #elif defined(_MSC_VER)
 281     __asm mov Stack, ebp
 282 #endif
 283 #elif defined(_M_MIPS)
 284         __asm__("move $sp, %0" : "=r" (Stack) : );
 285 #elif defined(_M_PPC)
 286     __asm__("mr %0,1" : "=r" (Stack) : );
 287 #else
 288 #error Unknown architecture
 289 #endif
 290
 291     /* Set it as the stack begin limit as well */
 292     StackBegin = (ULONG_PTR)Stack;
 293
 294     /* Check if we're called for non-logging mode */
 295     if (!Flags)
 296     {
 297         /* Get the actual safe limits */
 298         Result = RtlpCaptureStackLimits((ULONG_PTR)Stack,
 299                                         &StackBegin,
 300                                         &StackEnd);
 301         if (!Result) return 0;
 302     }
 303
 304     /* Use a SEH block for maximum protection */
 305     _SEH_TRY
 306     {
 307         /* Check if we want the user-mode stack frame */
 308         if (Flags == 1)
 309         {
 310             /* Get the trap frame and TEB */
 311             TrapFrame = Thread->TrapFrame;
 312             Teb = Thread->Teb;
 313
 314             /* Make sure we can trust the TEB and trap frame */
 315             if (!(Teb) ||
 316                 !((PVOID)((ULONG_PTR)TrapFrame & 0x80000000)) ||
 317                 ((PVOID)TrapFrame <= (PVOID)Thread->StackLimit) ||
 318                 ((PVOID)TrapFrame >= (PVOID)Thread->StackBase) ||
 319                 (KeIsAttachedProcess()) ||
 320                 (KeGetCurrentIrql() >= DISPATCH_LEVEL))
 321             {
 322                 /* Invalid or unsafe attempt to get the stack */
 323                 return 0;
 324             }
 325
 326             /* Get the stack limits */
 327             StackBegin = (ULONG_PTR)Teb->Tib.StackLimit;
 328             StackEnd = (ULONG_PTR)Teb->Tib.StackBase;
 329 #ifdef _M_IX86
 330             Stack = TrapFrame->Ebp;
 331 #elif defined(_M_PPC)
 332             Stack = TrapFrame->Gpr1;
 333 #endif
 334
 335             /* Validate them */
 336             if (StackEnd <= StackBegin) return 0;
 337             ProbeForRead((PVOID)StackBegin,
 338                          StackEnd - StackBegin,
 339                          sizeof(CHAR));
 340         }
 341
 342         /* Loop the frames */
 343         for (i = 0; i < Count; i++)
 344         {
 345             /*
 346              * Leave if we're past the stack,
 347              * if we're before the stack,
 348              * or if we've reached ourselves.
 349              */
 350             if ((Stack >= StackEnd) ||
 351                 (!i ? (Stack < StackBegin) : (Stack <= StackBegin)) ||
 352                 ((StackEnd - Stack) < (2 * sizeof(ULONG_PTR))))
 353             {
 354                 /* We're done or hit a bad address */
 355                 break;
 356             }
 357
 358             /* Get new stack and EIP */
 359             NewStack = *(PULONG_PTR)Stack;
 360             Eip = *(PULONG_PTR)(Stack + sizeof(ULONG_PTR));
 361
 362             /* Check if the new pointer is above the oldone and past the end */
 363             if (!((Stack < NewStack) && (NewStack < StackEnd)))
 364             {
 365                 /* Stop searching after this entry */
 366                 StopSearch = TRUE;
 367             }
 368
 369             /* Also make sure that the EIP isn't a stack address */
 370             if ((StackBegin < Eip) && (Eip < StackEnd)) break;
 371
 372             /* Check if we reached a user-mode address */
 373             if (!(Flags) && !(Eip & 0x80000000)) break;
 374
 375             /* Save this frame */
 376             Callers[i] = (PVOID)Eip;
 377
 378             /* Check if we should continue */
 379             if (StopSearch)
 380             {
 381                 /* Return the next index */
 382                 i++;
 383                 break;
 384             }
 385
 386             /* Move to the next stack */
 387             Stack = NewStack;
 388         }
 389     }
 390     _SEH_HANDLE
 391     {
 392         /* No index */
 393         i = 0;
 394     }
 395     _SEH_END;
 396
 397     /* Return frames parsed */
 398     return i;
 399 }
 400
 401 /* RTL Atom Tables ************************************************************/
 402
 403 NTSTATUS
 404 RtlpInitAtomTableLock(PRTL_ATOM_TABLE AtomTable)
 405 {
 406    ExInitializeFastMutex(&AtomTable->FastMutex);
 407
 408    return STATUS_SUCCESS;
 409 }
 410
 411
 412 VOID
 413 RtlpDestroyAtomTableLock(PRTL_ATOM_TABLE AtomTable)
 414 {
 415 }
 416
 417
 418 BOOLEAN
 419 RtlpLockAtomTable(PRTL_ATOM_TABLE AtomTable)
 420 {
 421    ExAcquireFastMutex(&AtomTable->FastMutex);
 422    return TRUE;
 423 }
 424
 425 VOID
 426 RtlpUnlockAtomTable(PRTL_ATOM_TABLE AtomTable)
 427 {
 428    ExReleaseFastMutex(&AtomTable->FastMutex);
 429 }
 430
 431 BOOLEAN
 432 RtlpCreateAtomHandleTable(PRTL_ATOM_TABLE AtomTable)
 433 {
 434    AtomTable->ExHandleTable = ExCreateHandleTable(NULL);
 435    return (AtomTable->ExHandleTable != NULL);
 436 }
 437
 438 VOID
 439 RtlpDestroyAtomHandleTable(PRTL_ATOM_TABLE AtomTable)
 440 {
 441    if (AtomTable->ExHandleTable)
 442    {
 443       ExSweepHandleTable(AtomTable->ExHandleTable,
 444                          NULL,
 445                          NULL);
 446       ExDestroyHandleTable(AtomTable->ExHandleTable, NULL);
 447       AtomTable->ExHandleTable = NULL;
 448    }
 449 }
 450
 451 PRTL_ATOM_TABLE
 452 RtlpAllocAtomTable(ULONG Size)
 453 {
 454    PRTL_ATOM_TABLE Table = ExAllocatePool(NonPagedPool,
 455                                           Size);
 456    if (Table != NULL)
 457    {
 458       RtlZeroMemory(Table,
 459                     Size);
 460    }
 461
 462    return Table;
 463 }
 464
 465 VOID
 466 RtlpFreeAtomTable(PRTL_ATOM_TABLE AtomTable)
 467 {
 468    ExFreePool(AtomTable);
 469 }
 470
 471 PRTL_ATOM_TABLE_ENTRY
 472 RtlpAllocAtomTableEntry(ULONG Size)
 473 {
 474    PRTL_ATOM_TABLE_ENTRY Entry = ExAllocatePool(NonPagedPool,
 475                                                 Size);
 476    if (Entry != NULL)
 477    {
 478       RtlZeroMemory(Entry,
 479                     Size);
 480    }
 481
 482    return Entry;
 483 }
 484
 485 VOID
 486 RtlpFreeAtomTableEntry(PRTL_ATOM_TABLE_ENTRY Entry)
 487 {
 488    ExFreePool(Entry);
 489 }
 490
 491 VOID
 492 RtlpFreeAtomHandle(PRTL_ATOM_TABLE AtomTable, PRTL_ATOM_TABLE_ENTRY Entry)
 493 {
 494    ExDestroyHandle(AtomTable->ExHandleTable,
 495                    (HANDLE)((ULONG_PTR)Entry->HandleIndex << 2),
 496                    NULL);
 497 }
 498
 499 BOOLEAN
 500 RtlpCreateAtomHandle(PRTL_ATOM_TABLE AtomTable, PRTL_ATOM_TABLE_ENTRY Entry)
 501 {
 502    HANDLE_TABLE_ENTRY ExEntry;
 503    HANDLE Handle;
 504    USHORT HandleIndex;
 505
 506    ExEntry.Object = Entry;
 507    ExEntry.GrantedAccess = 0x1; /* FIXME - valid handle */
 508
 509    Handle = ExCreateHandle(AtomTable->ExHandleTable,
 510                                 &ExEntry);
 511    if (Handle != NULL)
 512    {
 513       HandleIndex = (USHORT)((ULONG_PTR)Handle >> 2);
 514       /* FIXME - Handle Indexes >= 0xC000 ?! */
 515       if ((ULONG_PTR)HandleIndex >> 2 < 0xC000)
 516       {
 517          Entry->HandleIndex = HandleIndex;
 518          Entry->Atom = 0xC000 + HandleIndex;
 519
 520          return TRUE;
 521       }
 522       else
 523          ExDestroyHandle(AtomTable->ExHandleTable,
 524                          Handle,
 525                          NULL);
 526    }
 527
 528    return FALSE;
 529 }
 530
 531 PRTL_ATOM_TABLE_ENTRY
 532 RtlpGetAtomEntry(PRTL_ATOM_TABLE AtomTable, ULONG Index)
 533 {
 534    PHANDLE_TABLE_ENTRY ExEntry;
 535    PRTL_ATOM_TABLE_ENTRY Entry = NULL;
 536
 537    /* NOTE: There's no need to explicitly enter a critical region because it's
 538             guaranteed that we're in a critical region right now (as we hold
 539             the atom table lock) */
 540
 541    ExEntry = ExMapHandleToPointer(AtomTable->ExHandleTable,
 542                                   (HANDLE)((ULONG_PTR)Index << 2));
 543    if (ExEntry != NULL)
 544    {
 545       Entry = ExEntry->Object;
 546
 547       ExUnlockHandleTableEntry(AtomTable->ExHandleTable,
 548                                ExEntry);
 549    }
 550
 551    return Entry;
 552 }
 553
 554 /* FIXME - RtlpCreateUnicodeString is obsolete and should be removed ASAP! */
 555 BOOLEAN FASTCALL
 556 RtlpCreateUnicodeString(
 557    IN OUT PUNICODE_STRING UniDest,
 558    IN PCWSTR  Source,
 559    IN POOL_TYPE PoolType)
 560 {
 561    ULONG Length;
 562
 563    Length = (wcslen (Source) + 1) * sizeof(WCHAR);
 564    UniDest->Buffer = ExAllocatePoolWithTag(PoolType, Length, TAG('U', 'S', 'T', 'R'));
 565    if (UniDest->Buffer == NULL)
 566       return FALSE;
 567
 568    RtlCopyMemory (UniDest->Buffer,
 569                   Source,
 570                   Length);
 571
 572    UniDest->MaximumLength = (USHORT)Length;
 573    UniDest->Length = (USHORT)Length - sizeof (WCHAR);
 574
 575    return TRUE;
 576 }
 577
 578 /*
 579  * Ldr Resource support code
 580  */
 581
 582 IMAGE_RESOURCE_DIRECTORY *find_entry_by_name( IMAGE_RESOURCE_DIRECTORY *dir,
 583                                               LPCWSTR name, void *root,
 584                                               int want_dir );
 585 IMAGE_RESOURCE_DIRECTORY *find_entry_by_id( IMAGE_RESOURCE_DIRECTORY *dir,
 586                                             USHORT id, void *root, int want_dir );
 587 IMAGE_RESOURCE_DIRECTORY *find_first_entry( IMAGE_RESOURCE_DIRECTORY *dir,
 588                                             void *root, int want_dir );
 589
 590 /**********************************************************************
 591  *  find_entry
 592  *
 593  * Find a resource entry
 594  */
 595 NTSTATUS find_entry( PVOID BaseAddress, LDR_RESOURCE_INFO *info,
 596                      ULONG level, void **ret, int want_dir )
 597 {
 598     ULONG size;
 599     void *root;
 600     IMAGE_RESOURCE_DIRECTORY *resdirptr;
 601
 602     root = RtlImageDirectoryEntryToData( BaseAddress, TRUE, IMAGE_DIRECTORY_ENTRY_RESOURCE, &size );
 603     if (!root) return STATUS_RESOURCE_DATA_NOT_FOUND;
 604     resdirptr = root;
 605
 606     if (!level--) goto done;
 607     if (!(*ret = find_entry_by_name( resdirptr, (LPCWSTR)info->Type, root, want_dir || level )))
 608         return STATUS_RESOURCE_TYPE_NOT_FOUND;
 609     if (!level--) return STATUS_SUCCESS;
 610
 611     resdirptr = *ret;
 612     if (!(*ret = find_entry_by_name( resdirptr, (LPCWSTR)info->Name, root, want_dir || level )))
 613         return STATUS_RESOURCE_NAME_NOT_FOUND;
 614     if (!level--) return STATUS_SUCCESS;
 615     if (level) return STATUS_INVALID_PARAMETER;  /* level > 3 */
 616
 617     resdirptr = *ret;
 618
 619     if ((*ret = find_first_entry( resdirptr, root, want_dir ))) return STATUS_SUCCESS;
 620
 621     return STATUS_RESOURCE_DATA_NOT_FOUND;
 622
 623 done:
 624     *ret = resdirptr;
 625     return STATUS_SUCCESS;
 626 }
 627
 628
 629 /* EOF */