NtQueryInformationThread.c File Reference

#include "precomp.h"
#include <internal/ps_i.h>

Include dependency graph for NtQueryInformationThread.c:

Go to the source code of this file.

Macros
#define	ok_wchar(x, y)   ok_hex((unsigned)(unsigned short)(x), (unsigned)(unsigned short)(y))
#define	ok_nwstr(str1, str2, count)

Functions
static void	Test_ThreadBasicInformationClass (void)
static ULONG NTAPI	DummyThread (_In_ PVOID Parameter)
	Dummy thread used by the Test_ThreadHideFromDebuggerClass() and the Test_ThreadNameInformation() API tests.
static void	Test_ThreadHideFromDebuggerClass (void)
void	Test_ThreadQueryAlignmentProbe (void)
static NTSTATUS	ntGetThreadName (_In_ HANDLE hThread, _Outptr_ PTHREAD_NAME_INFORMATION *ppThreadNameInfo, _Out_ PULONG pLength, _In_ UCHAR Fill)
	An NT-equivalent of kernel32!GetThreadDescription().
static void	DoThreadNameTest (_In_ UINT i, _In_ HANDLE hThread, _In_opt_ PCWSTR TestName)
static void	Test_ThreadNameInformation (void)
static void	Test_ThreadAmILastThread (void)
static void	Test_InfoClass_Access (ULONG InfoClass, ULONG MinOsVer, ULONG MaxOsVer, ULONG InfoSize, ACCESS_MASK RequiredAccess, NTSTATUS AltStatus)
static void	Test_Access (void)
	START_TEST (NtQueryInformationThread)

Macro Definition Documentation

ok_nwstr

#define ok_nwstr	(		str1,
			str2,
			count
	)

Value:

    ok(wcsncmp((PWCHAR)(str1), (PWCHAR)(str2), (count)) == 0, \
       "Wrong string. Expected '%.*S', got '%.*S'\n", (count), (str1), (count), (str2))

Definition at line 14 of file NtQueryInformationThread.c.

ok_wchar

#define ok_wchar	(		x,
			y
	)		ok_hex((unsigned)(unsigned short)(x), (unsigned)(unsigned short)(y))

Definition at line 12 of file NtQueryInformationThread.c.

Function Documentation

DoThreadNameTest()

static void DoThreadNameTest ( _In_ UINT  i, _In_ HANDLE  hThread, _In_opt_ PCWSTR  TestName  )

static

Definition at line 371 of file NtQueryInformationThread.c.

{
    BOOL bEmptyName = ((TestName == (PCWSTR)(ULONG_PTR)-1) || !TestName || !*TestName);
    ULONG ExpectedNameLength = (ULONG)(bEmptyName ? 0 : wcslen(TestName) * sizeof(WCHAR));
    ULONG ExpectedLength = sizeof(UNICODE_STRING) + ExpectedNameLength;
 
    NTSTATUS Status;
    ULONG Length;
    PTHREAD_NAME_INFORMATION pNameInfo;
    /* IMPORTANT REMARK: The fixed Buffer is made large enough
     * to hold all the TestName's being tested in this file. */
    struct { THREAD_NAME_INFORMATION Info; WCHAR Buffer[MAX_PATH]; } NameInfo;
 
    ASSERT(sizeof(NameInfo.Buffer) >= ExpectedNameLength);
 
    winetest_push_context("Test %lu", i);
 
    /* Set a new thread name only if it's not '-1'; otherwise we
     * just query the existing name without setting it before. */
    if (TestName != (PCWSTR)(ULONG_PTR)-1)
    {
        /* Set a non-empty thread name, to reset it to something different
         * from the previous case and distinguish with the next one. */
        RtlFillMemory(&NameInfo, sizeof(NameInfo), 0xEF);
        NameInfo.Info.ThreadName.Length = NameInfo.Info.ThreadName.MaximumLength = sizeof(NameInfo.Buffer);
        NameInfo.Info.ThreadName.Buffer = NameInfo.Buffer;
        Status = NtSetInformationThread(hThread, ThreadNameInformation,
                                        &NameInfo.Info, sizeof(NameInfo.Info));
        ok_ntstatus(Status, STATUS_SUCCESS);
 
        /* Now set the thread name to be tested */
        RtlFillMemory(&NameInfo, sizeof(NameInfo), 0xAB);
        RtlInitUnicodeString(&NameInfo.Info.ThreadName, TestName);
        Status = NtSetInformationThread(hThread, ThreadNameInformation,
                                        &NameInfo.Info, sizeof(NameInfo.Info));
        ok_ntstatus(Status, STATUS_SUCCESS);
    }
 
    /* Verify that ThreadNameInformation call with NULL buffer returns the expected length */
    Length = 0;
    Status = NtQueryInformationThread(hThread, ThreadNameInformation, NULL, 0, &Length);
    ok_ntstatus(Status, STATUS_BUFFER_TOO_SMALL);
    ok_long(Length, ExpectedLength);
 
    pNameInfo = &NameInfo.Info;
 
    /* Test ThreadNameInformation call with minimally-sized buffer */
    RtlFillMemory(&NameInfo, sizeof(NameInfo), 0xAB);
    Length = 0;
    Status = NtQueryInformationThread(hThread, ThreadNameInformation,
                                      pNameInfo, sizeof(*pNameInfo), &Length);
    if (bEmptyName)
    {
        ok_ntstatus(Status, STATUS_SUCCESS);
        ok_long(Length, ExpectedLength); // == sizeof(UNICODE_STRING);
        ok_long((ULONG)pNameInfo->ThreadName.Length, 0);
    }
    else
    {
        ok_ntstatus(Status, STATUS_BUFFER_TOO_SMALL);
        ok_long(Length, ExpectedLength); // == sizeof(UNICODE_STRING) + ExpectedNameLength;
        ok_long((ULONG)pNameInfo->ThreadName.Length, 0xABAB);
    }
    ok_long((ULONG)pNameInfo->ThreadName.MaximumLength, (ULONG)pNameInfo->ThreadName.Length);
    if (bEmptyName)
    {
        ok(pNameInfo->ThreadName.Buffer == NULL || /* ReactOS will set the Buffer to NULL */
           /* All Win10+ versions erroneously point the Buffer past the end of the data */
           broken(pNameInfo->ThreadName.Buffer == (PVOID)(&pNameInfo->ThreadName + 1)),
           "Expected NULL pointer, got 0x%p\n", pNameInfo->ThreadName.Buffer);
        /* NOTE: pNameInfo->ThreadName.Buffer[0] is invalid */
    }
    else
    {
        ok_ptr(pNameInfo->ThreadName.Buffer, (PVOID)(ULONG_PTR)0xABABABABABABABABULL);
    }
 
    RtlFillMemory(&NameInfo, sizeof(NameInfo), 0xAB);
    Length = 0;
    if (bEmptyName)
    {
        /* Retest the same with a slightly-larger buffer */
        Status = NtQueryInformationThread(hThread, ThreadNameInformation,
                                          &NameInfo,
                                          sizeof(UNICODE_STRING) + sizeof(UNICODE_NULL),
                                          &Length);
    }
    else
    {
        /* Test direct ThreadNameInformation call with correctly-sized buffer */
        Status = NtQueryInformationThread(hThread, ThreadNameInformation,
                                          &NameInfo,
                                          ExpectedLength,
                                          &Length);
    }
    ok_ntstatus(Status, STATUS_SUCCESS);
    ok_long(Length, ExpectedLength);
    ok_long((ULONG)pNameInfo->ThreadName.Length, ExpectedNameLength);
    ok_long((ULONG)pNameInfo->ThreadName.MaximumLength, (ULONG)pNameInfo->ThreadName.Length);
    if (bEmptyName)
    {
        ok(pNameInfo->ThreadName.Buffer == NULL || /* ReactOS will set the Buffer to NULL */
           /* All Win10+ versions erroneously point the Buffer past the end of the data */
           broken(pNameInfo->ThreadName.Buffer == (PVOID)(&pNameInfo->ThreadName + 1)),
           "Expected NULL pointer, got 0x%p\n", pNameInfo->ThreadName.Buffer);
 
        /* NOTE: pNameInfo->ThreadName.Buffer[0] should be invalid, but let's
         * check past it to see what data there is (in the "broken" Windows case). */
        if (pNameInfo->ThreadName.Buffer == (PVOID)(&pNameInfo->ThreadName + 1))
            ok_wchar(pNameInfo->ThreadName.Buffer[0], 0xABAB);
    }
    else
    {
        ok_ptr(pNameInfo->ThreadName.Buffer, (PVOID)(&pNameInfo->ThreadName + 1));
        if (pNameInfo->ThreadName.Buffer == (PVOID)(&pNameInfo->ThreadName + 1))
            ok_nwstr(pNameInfo->ThreadName.Buffer, TestName, ExpectedNameLength / sizeof(WCHAR));
        else
            skip("pNameInfo->ThreadName.Buffer is invalid (0x%p)\n", pNameInfo->ThreadName.Buffer);
    }
 
    /* Test ThreadNameInformation with dynamically allocated buffer */
    pNameInfo = NULL;
    Length = 0;
    Status = ntGetThreadName(hThread, &pNameInfo, &Length, 0xCD);
    ok_ntstatus(Status, STATUS_SUCCESS);
    ok_long(Length, ExpectedLength);
    ok(pNameInfo != NULL, "Expected not NULL, got NULL\n");
    if (pNameInfo)
    {
        ok_long((ULONG)pNameInfo->ThreadName.Length, ExpectedNameLength);
        ok_long((ULONG)pNameInfo->ThreadName.MaximumLength, (ULONG)pNameInfo->ThreadName.Length);
        if (bEmptyName)
        {
            ok(pNameInfo->ThreadName.Buffer == NULL || /* ReactOS will set the Buffer to NULL */
               /* All Win10+ versions erroneously point the Buffer past the end of the data */
               broken(pNameInfo->ThreadName.Buffer == (PVOID)(&pNameInfo->ThreadName + 1)),
               "Expected NULL pointer, got 0x%p\n", pNameInfo->ThreadName.Buffer);
            /* NOTE: pNameInfo->ThreadName.Buffer[0] is invalid */
        }
        else
        {
            ok_ptr(pNameInfo->ThreadName.Buffer, (PVOID)(&pNameInfo->ThreadName + 1));
            if (pNameInfo->ThreadName.Buffer == (PVOID)(&pNameInfo->ThreadName + 1))
                ok_nwstr(pNameInfo->ThreadName.Buffer, TestName, ExpectedNameLength / sizeof(WCHAR));
            else
                skip("pNameInfo->ThreadName.Buffer is invalid (0x%p)\n", pNameInfo->ThreadName.Buffer);
        }
        RtlFreeHeap(RtlGetProcessHeap(), 0, pNameInfo);
    }
    else
    {
        skip("pNameInfo is NULL\n");
    }
 
    winetest_pop_context();
}

Referenced by Test_ThreadNameInformation().

DummyThread()

static ULONG NTAPI DummyThread ( _In_ PVOID  Parameter )

static

Dummy thread used by the Test_ThreadHideFromDebuggerClass() and the Test_ThreadNameInformation() API tests.

Parameters

[in]

Parameter

Handle to an event that tells the thread to terminate itself when signaled.

Definition at line 121 of file NtQueryInformationThread.c.

{
    HANDLE hWaitEvent = (HANDLE)Parameter;
    NTSTATUS Status;
 
    /* Indefinitely wait for the kill signal */
    Status = NtWaitForSingleObject(hWaitEvent, FALSE, NULL);
    ASSERT(NT_SUCCESS(Status));
 
    NtTerminateThread(NtCurrentThread(), Status);
    return Status;
}

Referenced by Test_ThreadHideFromDebuggerClass(), and Test_ThreadNameInformation().

ntGetThreadName()

static NTSTATUS ntGetThreadName ( _In_ HANDLE  hThread, _Outptr_ PTHREAD_NAME_INFORMATION *  ppThreadNameInfo, _Out_ PULONG  pLength, _In_ UCHAR  Fill  )

static

An NT-equivalent of kernel32!GetThreadDescription().

Definition at line 316 of file NtQueryInformationThread.c.

{
    PTHREAD_NAME_INFORMATION NameInfo = NULL;
    PVOID ptr;
    NTSTATUS Status;
    ULONG Length;
 
    *ppThreadNameInfo = NULL;
    *pLength = 0;
 
    /* Since there may be concurrent SetThreadDescription() invocations being
     * executed, we need to loop over the buffer allocation size until we can
     * successfully capture the thread name. */
    Length = 0;
    Status = NtQueryInformationThread(hThread, ThreadNameInformation, NULL, 0, &Length);
    if (Status != STATUS_BUFFER_TOO_SMALL)
        return Status;
 
    /* Loop again only if we get buffer-too-small types of errors;
     * otherwise, break the loop: any error will be handled below. */
    while (Status == STATUS_INFO_LENGTH_MISMATCH ||
           Status == STATUS_BUFFER_TOO_SMALL)
    {
        /* (Re-)allocate the information buffer */
        ptr = (NameInfo ? RtlReAllocateHeap(RtlGetProcessHeap(), 0, NameInfo, Length)
                        : RtlAllocateHeap(RtlGetProcessHeap(), 0, Length));
        if (!ptr)
        {
            Status = STATUS_NO_MEMORY;
            break;
        }
        RtlFillMemory(ptr, Length, Fill);
        NameInfo = ptr;
        Status = NtQueryInformationThread(hThread, ThreadNameInformation,
                                          NameInfo, Length, &Length);
        // Status should be STATUS_SUCCESS, unless concurrent SetThreadDescription() happens.
    }
    if (NT_SUCCESS(Status))
    {
        *ppThreadNameInfo = NameInfo;
        *pLength = Length;
    }
    else
    {
        RtlFreeHeap(RtlGetProcessHeap(), 0, NameInfo);
    }
 
    return Status;
}

Referenced by DoThreadNameTest().

START_TEST()

START_TEST

(

NtQueryInformationThread

)

Definition at line 814 of file NtQueryInformationThread.c.

{
    Test_ThreadBasicInformationClass();
    Test_ThreadAmILastThread();
    Test_ThreadHideFromDebuggerClass();
#if 0 // This test is too broken
    Test_ThreadQueryAlignmentProbe();
#endif
    Test_ThreadNameInformation();
    Test_Access();
}

Test_Access()

static void Test_Access ( void  )

static

Definition at line 742 of file NtQueryInformationThread.c.

{
    Test_InfoClass_Access(ThreadBasicInformation, NTDDI_WIN2K, MAXULONG, sizeof(THREAD_BASIC_INFORMATION), THREAD_QUERY_LIMITED_INFORMATION, 0);
    Test_InfoClass_Access(ThreadTimes, NTDDI_WIN2K, MAXULONG, sizeof(KERNEL_USER_TIMES), THREAD_QUERY_LIMITED_INFORMATION, 0);
    Test_InfoClass_Access(ThreadPriority, NTDDI_WIN2K, NTDDI_WINXP, sizeof(ULONG), 0, 0);
    Test_InfoClass_Access(ThreadBasePriority, NTDDI_WIN2K, NTDDI_WINXP, sizeof(ULONG), 0, 0);
    Test_InfoClass_Access(ThreadAffinityMask, NTDDI_WIN2K, NTDDI_WINXP, sizeof(ULONG_PTR), 0, 0);
    Test_InfoClass_Access(ThreadImpersonationToken, NTDDI_WIN2K, NTDDI_WINXP, sizeof(HANDLE), 0, 0);
#ifdef _M_IX86
    Test_InfoClass_Access(ThreadDescriptorTableEntry, NTDDI_WIN2K, MAXULONG, sizeof(THREAD_DESCRIPTOR_INFORMATION), THREAD_QUERY_INFORMATION, 0);
#endif
    Test_InfoClass_Access(ThreadEnableAlignmentFaultFixup, NTDDI_WIN2K, NTDDI_WINXP, sizeof(BOOLEAN), THREAD_QUERY_INFORMATION, 0);
    Test_InfoClass_Access(ThreadEventPair_Reusable, NTDDI_WIN2K, NTDDI_WINXP, sizeof(BOOLEAN), THREAD_QUERY_INFORMATION, 0);
    Test_InfoClass_Access(ThreadQuerySetWin32StartAddress, NTDDI_WIN2K, MAXULONG, sizeof(ULONG_PTR), THREAD_QUERY_INFORMATION, 0);
    Test_InfoClass_Access(ThreadZeroTlsCell, NTDDI_WIN2K, NTDDI_WINXP, sizeof(ULONG), THREAD_QUERY_INFORMATION, 0);
    Test_InfoClass_Access(ThreadPerformanceCount, NTDDI_WIN2K, MAXULONG, sizeof(LARGE_INTEGER), THREAD_QUERY_INFORMATION, 0);
    Test_InfoClass_Access(ThreadAmILastThread, NTDDI_WIN2K, MAXULONG, sizeof(ULONG), 0, 0);
    Test_InfoClass_Access(ThreadIdealProcessor, NTDDI_WIN2K, NTDDI_WINXP, sizeof(ULONG), 0, 0);
    Test_InfoClass_Access(ThreadPriorityBoost, NTDDI_WIN2K, MAXULONG, sizeof(ULONG), THREAD_QUERY_LIMITED_INFORMATION, 0);
    Test_InfoClass_Access(ThreadSetTlsArrayAddress, NTDDI_WIN2K, NTDDI_WINXP, sizeof(ULONG_PTR), 0, 0);
    Test_InfoClass_Access(ThreadIsIoPending, NTDDI_WIN2K, MAXULONG, sizeof(ULONG), THREAD_QUERY_INFORMATION, 0);
    Test_InfoClass_Access(ThreadHideFromDebugger, NTDDI_VISTA, MAXULONG, sizeof(BOOLEAN), THREAD_QUERY_INFORMATION, 0);
    Test_InfoClass_Access(ThreadBreakOnTermination, NTDDI_WIN2K, MAXULONG, sizeof(ULONG), THREAD_QUERY_INFORMATION, 0);
    Test_InfoClass_Access(ThreadSwitchLegacyState, NTDDI_WIN2K, NTDDI_WINXP, 0, 0, 0);
    Test_InfoClass_Access(ThreadIsTerminated, NTDDI_WIN2K, MAXULONG, sizeof(ULONG), THREAD_QUERY_LIMITED_INFORMATION, 0);
    //Test_InfoClass_Access(ThreadLastSystemCall, NTDDI_VISTA, MAXULONG, sizeof(THREAD_LAST_SYSCALL_INFORMATION), THREAD_GET_CONTEXT, 0);
    Test_InfoClass_Access(ThreadIoPriority, NTDDI_VISTA, MAXULONG, sizeof(ULONG), THREAD_QUERY_LIMITED_INFORMATION, 0);
    Test_InfoClass_Access(ThreadCycleTime, NTDDI_VISTA, MAXULONG, sizeof(THREAD_CYCLE_TIME_INFORMATION), THREAD_QUERY_LIMITED_INFORMATION, 0);
    Test_InfoClass_Access(ThreadPagePriority, NTDDI_VISTA, MAXULONG, sizeof(ULONG), THREAD_QUERY_LIMITED_INFORMATION, 0);
    Test_InfoClass_Access(ThreadActualBasePriority, NTDDI_WIN7, MAXULONG, sizeof(ULONG), THREAD_QUERY_LIMITED_INFORMATION, 0);
    //Test_InfoClass_Access(ThreadTebInformation, NTDDI_VISTA, MAXULONG, sizeof(THREAD_TEB_INFORMATION), THREAD_GET_CONTEXT | THREAD_SET_CONTEXT, 0);
    Test_InfoClass_Access(ThreadCSwitchMon, NTDDI_VISTA, NTDDI_WIN7, sizeof(BOOLEAN), THREAD_QUERY_INFORMATION, 0);
 
    // Windows 7
    Test_InfoClass_Access(ThreadCSwitchPmu, NTDDI_WIN7, NTDDI_WIN7, sizeof(ULONG), 0, 0);
    //Test_InfoClass_Access(ThreadWow64Context, NTDDI_WIN7, MAXULONG, sizeof(WOW64_CONTEXT), THREAD_GET_CONTEXT, 0);
    Test_InfoClass_Access(ThreadGroupInformation, NTDDI_WIN7, MAXULONG, sizeof(GROUP_AFFINITY), THREAD_QUERY_LIMITED_INFORMATION, 0);
    //Test_InfoClass_Access(ThreadUmsInformation, NTDDI_WIN7, MAXULONG, sizeof(THREAD_UMS_INFORMATION), 0, 0);
    //Test_InfoClass_Access(ThreadCounterProfiling, NTDDI_WIN7, MAXULONG, sizeof(THREAD_PROFILING_INFORMATION), 0, 0);
    Test_InfoClass_Access(ThreadIdealProcessorEx, NTDDI_WIN7, MAXULONG, sizeof(ULONG), THREAD_QUERY_LIMITED_INFORMATION, 0);
 
    // Windows 8
    Test_InfoClass_Access(ThreadCpuAccountingInformation, NTDDI_WIN8, MAXULONG, sizeof(ULONG), THREAD_QUERY_INFORMATION, 0);
 
    // Windows 8.1
    Test_InfoClass_Access(ThreadSuspendCount, NTDDI_WINBLUE, MAXULONG, sizeof(ULONG), THREAD_QUERY_LIMITED_INFORMATION, 0);
 
    // Windows 10
    Test_InfoClass_Access(ThreadHeterogeneousCpuPolicy, NTDDI_WIN10, MAXULONG, sizeof(ULONG), THREAD_QUERY_LIMITED_INFORMATION, 0);
    //Test_InfoClass_Access(ThreadContainerId, NTDDI_WIN10, MAXULONG, sizeof(GUID), THREAD_QUERY_LIMITED_INFORMATION, 0);
    Test_InfoClass_Access(ThreadNameInformation, NTDDI_WIN10, MAXULONG, sizeof(THREAD_NAME_INFORMATION), THREAD_QUERY_LIMITED_INFORMATION, STATUS_BUFFER_TOO_SMALL);
    Test_InfoClass_Access(ThreadSelectedCpuSets, NTDDI_WIN10, MAXULONG, 0, THREAD_QUERY_LIMITED_INFORMATION, 0);
    Test_InfoClass_Access(ThreadSystemThreadInformation, NTDDI_WIN10, MAXULONG, sizeof(SYSTEM_THREAD_INFORMATION), THREAD_QUERY_LIMITED_INFORMATION, 0);
    Test_InfoClass_Access(ThreadActualGroupAffinity, NTDDI_WIN10, MAXULONG, sizeof(GROUP_AFFINITY), THREAD_QUERY_LIMITED_INFORMATION, 0);
    Test_InfoClass_Access(ThreadDynamicCodePolicyInfo, NTDDI_WIN10, MAXULONG, sizeof(ULONG), THREAD_QUERY_LIMITED_INFORMATION, 0);
    Test_InfoClass_Access(ThreadExplicitCaseSensitivity, NTDDI_WIN10, MAXULONG, sizeof(ULONG), THREAD_QUERY_LIMITED_INFORMATION, 0);
    //Test_InfoClass_Access(ThreadWorkOnBehalfTicket, NTDDI_WIN10, MAXULONG, 16 /* sizeof(RTL_WORK_ON_BEHALF_TICKET_EX) */, THREAD_QUERY_LIMITED_INFORMATION, 0);
    Test_InfoClass_Access(ThreadSubsystemInformation, NTDDI_WIN10, MAXULONG, sizeof(ULONG), THREAD_QUERY_LIMITED_INFORMATION, 0);
 
    // Windows 11
    // ThreadDbgkWerReportActive is set only
    // ThreadAttachContainer is set only
    // ThreadManageWritesToExecutableMemory is set only
    //Test_InfoClass_Access(ThreadPowerThrottlingState, NTDDI_WIN11_ZN, MAXULONG, sizeof(POWER_THROTTLING_THREAD_STATE), THREAD_QUERY_LIMITED_INFORMATION, 0);
    //Test_InfoClass_Access(ThreadWorkloadClass, NTDDI_WIN11_ZN, MAXULONG, sizeof(ULONG), THREAD_QUERY_LIMITED_INFORMATION, 0);
    // ThreadCreateStateChange is set only
    // ThreadApplyStateChange is set only
    //Test_InfoClass_Access(ThreadStrongerBadHandleChecks, NTDDI_WIN11_ZN, MAXULONG, sizeof(ULONG), THREAD_QUERY_LIMITED_INFORMATION, 0);
    Test_InfoClass_Access(ThreadEffectiveIoPriority, NTDDI_WIN11_ZN, MAXULONG, sizeof(ULONG), THREAD_QUERY_LIMITED_INFORMATION, 0);
    Test_InfoClass_Access(ThreadEffectivePagePriority, NTDDI_WIN11_ZN, MAXULONG, sizeof(ULONG), THREAD_QUERY_LIMITED_INFORMATION, 0);
}

Referenced by START_TEST().

Test_InfoClass_Access()

static void Test_InfoClass_Access ( ULONG  InfoClass, ULONG  MinOsVer, ULONG  MaxOsVer, ULONG  InfoSize, ACCESS_MASK  RequiredAccess, NTSTATUS  AltStatus  )

static

Definition at line 651 of file NtQueryInformationThread.c.

{
    NTSTATUS Status;
    HANDLE hThread;
    CLIENT_ID ClientId;
    OBJECT_ATTRIBUTES ObjectAttributes;
    ULONG ReturnLength;
    PVOID Info;
 
    /* Open a thread handle with maximum access  */
    InitializeObjectAttributes(&ObjectAttributes, NULL, 0, NULL, NULL);
    ClientId.UniqueProcess = UlongToHandle(GetCurrentProcessId());
    ClientId.UniqueThread = UlongToHandle(GetCurrentThreadId());
    Status = NtOpenThread(&hThread, THREAD_ALL_ACCESS | 0xF00, &ObjectAttributes, &ClientId);
    ok_ntstatus(Status, STATUS_SUCCESS);
 
    /* Query the thread information */
    Status = NtQueryInformationThread(hThread, InfoClass, NULL, 0, &ReturnLength);
 
    NtClose(hThread);
 
    /* Check if this OS it outside of the supported range */
    ULONG CurrentNtDdiVersion = GetNTDDIVersion();
    if ((CurrentNtDdiVersion < MinOsVer) || (CurrentNtDdiVersion > MaxOsVer))
    {
        /* For Windows, expect failure, for ReactOS allow implementations outside of the supported range */
        if (!is_reactos() || (Status == STATUS_INVALID_INFO_CLASS))
        {
            ok(Status == STATUS_INVALID_INFO_CLASS, "[%u] Wrong Status, expected STATUS_INVALID_INFO_CLASS, got 0x%08lx\n", InfoClass, Status);
            return;
        }
    }
 
    ok(Status == STATUS_INFO_LENGTH_MISMATCH || Status == AltStatus,
       "[%u] Wrong Status, expected STATUS_INFO_LENGTH_MISMATCH or 0x%08x, got 0x%08lx\n", InfoClass, AltStatus, Status);
 
    if (InfoSize == 0)
        InfoSize = ReturnLength;
 
    Info = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, InfoSize);
    if (!Info)
    {
        ok(FALSE, "Failed to allocate memory for thread information!\n");
        return;
    }
 
    if (RequiredAccess != 0)
    {
        if (!is_reactos() && (GetNTVersion() < _WIN32_WINNT_VISTA) && (RequiredAccess == THREAD_QUERY_LIMITED_INFORMATION))
        {
            RequiredAccess = THREAD_QUERY_INFORMATION;
        }
 
        /* Query the thread information with the limited access */
        Status = NtOpenThread(&hThread, RequiredAccess, &ObjectAttributes, &ClientId);
        ok_ntstatus(Status, STATUS_SUCCESS);
        Status = NtQueryInformationThread(hThread, InfoClass, Info, InfoSize, &ReturnLength);
        ok(Status == STATUS_SUCCESS || Status == AltStatus,
           "[%u] Wrong Status, expected STATUS_SUCCESS or 0x%08x, got 0x%08lx\n", InfoClass, AltStatus, Status);
        NtClose(hThread);
 
        ACCESS_MASK DeniedAccess = (THREAD_ALL_ACCESS|0xFFF) & ~RequiredAccess;
        if (RequiredAccess & THREAD_QUERY_LIMITED_INFORMATION)
            DeniedAccess &= ~THREAD_QUERY_INFORMATION;
 
        Status = NtOpenThread(&hThread, DeniedAccess, &ObjectAttributes, &ClientId);
        ok_ntstatus(Status, STATUS_SUCCESS);
        Status = NtQueryInformationThread(hThread, InfoClass, Info, InfoSize, &ReturnLength);
        ok(Status == STATUS_ACCESS_DENIED, "[%u] Wrong Status, expected STATUS_ACCESS_DENIED, got 0x%08lx\n", InfoClass, Status);
        NtClose(hThread);
    }
    else
    {
        /* Query the thread information with SYNCHRONIZE access */
        Status = NtOpenThread(&hThread, SYNCHRONIZE, &ObjectAttributes, &ClientId);
        ok_ntstatus(Status, STATUS_SUCCESS);
        Status = NtQueryInformationThread(hThread, InfoClass, Info, InfoSize, &ReturnLength);
        ok(Status == STATUS_SUCCESS || Status == AltStatus,
           "[%u] Wrong Status, expected STATUS_SUCCESS or 0x%08x, got 0x%08lx\n", InfoClass, AltStatus, Status);
        NtClose(hThread);
    }
 
    HeapFree(GetProcessHeap(), 0, Info);
}

Referenced by Test_Access().

Test_ThreadAmILastThread()

static void Test_ThreadAmILastThread ( void  )

static

Definition at line 621 of file NtQueryInformationThread.c.

{
    NTSTATUS Status;
    HANDLE hThread;
    ULONG IsLastThread;
    ULONG ReturnLength;
    ULONG Buffer[2];
 
    /* This threadinfo class always refers to the current thread! */
    hThread = (HANDLE)(ULONG_PTR)0xDEADBEEFDEADBEEF;
    ReturnLength = 0xDEADBEEF;
    Status = NtQueryInformationThread(hThread, ThreadAmILastThread, &IsLastThread, sizeof(ULONG), &ReturnLength);
    ok_eq_hex(Status, STATUS_SUCCESS);
    ok_eq_hex(ReturnLength, sizeof(ULONG));
 
    /* Too small buffer */
    ReturnLength = 0xDEADBEEF;
    Status = NtQueryInformationThread(hThread, ThreadAmILastThread, &IsLastThread, sizeof(ULONG) - 1, &ReturnLength);
    ok_eq_hex(Status, STATUS_INFO_LENGTH_MISMATCH);
    ok_eq_hex(ReturnLength, 0xDEADBEEF);
 
    /* Unaligned buffer */
    ReturnLength = 0xDEADBEEF;
    Status = NtQueryInformationThread(hThread, ThreadAmILastThread, (PUCHAR)Buffer + 2, sizeof(ULONG), &ReturnLength);
    ok_eq_hex(Status, STATUS_DATATYPE_MISALIGNMENT);
    ok_eq_hex(ReturnLength, 0xDEADBEEF);
}

Referenced by START_TEST().

Test_ThreadBasicInformationClass()

static void Test_ThreadBasicInformationClass ( void  )

static

Definition at line 20 of file NtQueryInformationThread.c.

{
    NTSTATUS Status;
    PTHREAD_BASIC_INFORMATION ThreadInfoBasic;
    ULONG ReturnedLength;
 
    ThreadInfoBasic = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(THREAD_BASIC_INFORMATION));
    if (!ThreadInfoBasic)
    {
        skip("Failed to allocate memory for THREAD_BASIC_INFORMATION!\n");
        return;
    }
 
    /* Everything is NULL */
    Status = NtQueryInformationThread(NULL,
                                      ThreadBasicInformation,
                                      NULL,
                                      0,
                                      NULL);
    ok_hex(Status, STATUS_INFO_LENGTH_MISMATCH);
 
    /* Don't give a valid thread handle */
    Status = NtQueryInformationThread(NULL,
                                      ThreadBasicInformation,
                                      ThreadInfoBasic,
                                      sizeof(THREAD_BASIC_INFORMATION),
                                      NULL);
    ok_hex(Status, STATUS_INVALID_HANDLE);
 
    /* The information length is incorrect */
    Status = NtQueryInformationThread(GetCurrentThread(),
                                      ThreadBasicInformation,
                                      ThreadInfoBasic,
                                      0,
                                      NULL);
    ok_hex(Status, STATUS_INFO_LENGTH_MISMATCH);
 
    /* Don't query anything from the function */
    Status = NtQueryInformationThread(GetCurrentThread(),
                                      ThreadBasicInformation,
                                      NULL,
                                      sizeof(THREAD_BASIC_INFORMATION),
                                      NULL);
    ok_hex(Status, STATUS_ACCESS_VIOLATION);
 
    /* The buffer is misaligned and length information is wrong */
    Status = NtQueryInformationThread(GetCurrentThread(),
                                      ThreadBasicInformation,
                                      (PVOID)1,
                                      0,
                                      NULL);
    ok_hex(Status, STATUS_INFO_LENGTH_MISMATCH);
 
    /* The buffer is misaligned */
    Status = NtQueryInformationThread(GetCurrentThread(),
                                      ThreadBasicInformation,
                                      (PVOID)1,
                                      sizeof(THREAD_BASIC_INFORMATION),
                                      NULL);
    ok_hex(Status, STATUS_DATATYPE_MISALIGNMENT);
 
    /* The buffer is misaligned, try with an alignment size of 2 */
    Status = NtQueryInformationThread(GetCurrentThread(),
                                      ThreadBasicInformation,
                                      (PVOID)2,
                                      sizeof(THREAD_BASIC_INFORMATION),
                                      NULL);
    ok_hex(Status, STATUS_DATATYPE_MISALIGNMENT);
 
    /* Query the basic information we need from the thread */
    Status = NtQueryInformationThread(GetCurrentThread(),
                                      ThreadBasicInformation,
                                      ThreadInfoBasic,
                                      sizeof(THREAD_BASIC_INFORMATION),
                                      &ReturnedLength);
    ok_hex(Status, STATUS_SUCCESS);
    ok(ReturnedLength != 0, "The size of the buffer pointed by ThreadInformation shouldn't be 0!\n");
 
    /* Output the thread basic information details */
    trace("ReturnedLength = %lu\n", ReturnedLength);
    trace("ThreadInfoBasic->ExitStatus = 0x%08lx\n", ThreadInfoBasic->ExitStatus);
    trace("ThreadInfoBasic->TebBaseAddress = %p\n", ThreadInfoBasic->TebBaseAddress);
    trace("ThreadInfoBasic->ClientId.UniqueProcess = %p\n", ThreadInfoBasic->ClientId.UniqueProcess);
    trace("ThreadInfoBasic->ClientId.UniqueThread = %p\n", ThreadInfoBasic->ClientId.UniqueThread);
    trace("ThreadInfoBasic->AffinityMask = %lu\n", ThreadInfoBasic->AffinityMask);
    trace("ThreadInfoBasic->Priority = %li\n", ThreadInfoBasic->Priority);
    trace("ThreadInfoBasic->BasePriority = %li\n", ThreadInfoBasic->BasePriority);
 
    HeapFree(GetProcessHeap(), 0, ThreadInfoBasic);
}

Referenced by START_TEST().

Test_ThreadHideFromDebuggerClass()

static void Test_ThreadHideFromDebuggerClass ( void  )

static

Definition at line 137 of file NtQueryInformationThread.c.

{
    NTSTATUS Status;
    HANDLE hWaitEvent = NULL, hThread = NULL;
    BOOLEAN IsThreadHidden;
    ULONG UlongData;
    BOOL IsWow64 = FALSE;
 
    if (GetNTVersion() < _WIN32_WINNT_VISTA)
    {
        skip("Skipping test as NtQueryInformationThread(ThreadHideFromDebugger) isn't supported prior to Vista\n");
        return;
    }
    IsWow64Process(GetCurrentProcess(), &IsWow64);
 
    Status = NtCreateEvent(&hWaitEvent,
                           EVENT_ALL_ACCESS,
                           NULL,
                           NotificationEvent,
                           FALSE);
    ok_ntstatus(Status, STATUS_SUCCESS);
    ok(hWaitEvent != NULL, "Expected not NULL, got NULL\n");
    if (!NT_SUCCESS(Status))
    {
        skip("Could not create the stop event! (Status 0x%08lx)\n", Status);
        goto Quit;
    }
 
    /* Create the dummy thread and wait for it to start up */
    Status = RtlCreateUserThread(NtCurrentProcess(),
                                 NULL,
                                 FALSE,
                                 0,
                                 0,
                                 0,
                                 DummyThread,
                                 (PVOID)hWaitEvent,
                                 &hThread,
                                 NULL);
    ok_ntstatus(Status, STATUS_SUCCESS);
    ok(hThread != NULL, "Expected not NULL, got NULL\n");
    if (!NT_SUCCESS(Status))
    {
        skip("Failed to create the dummy thread (Status 0x%08lx)\n", Status);
        goto Quit;
    }
 
 
    /* Verify that the thread is debuggable by default */
    IsThreadHidden = 0xCC;
    Status = NtQueryInformationThread(hThread,
                                      ThreadHideFromDebugger,
                                      &IsThreadHidden,
                                      sizeof(IsThreadHidden),
                                      NULL);
    ok_ntstatus(Status, STATUS_SUCCESS);
    ok_bool_false(IsThreadHidden, "IsThreadHidden is");
 
    /* Make the thread hidden from the debugger -- The wrong way (1) */
    IsThreadHidden = TRUE;
    Status = NtSetInformationThread(hThread,
                                    ThreadHideFromDebugger,
                                    &IsThreadHidden,
                                    sizeof(IsThreadHidden));
    if (IsWow64)
        ok_ntstatus(Status, STATUS_DATATYPE_MISALIGNMENT);
    else
        ok_ntstatus(Status, STATUS_INFO_LENGTH_MISMATCH);
 
    /* The thread is still debuggable */
    IsThreadHidden = 0xCC;
    Status = NtQueryInformationThread(hThread,
                                      ThreadHideFromDebugger,
                                      &IsThreadHidden,
                                      sizeof(IsThreadHidden),
                                      NULL);
    ok_ntstatus(Status, STATUS_SUCCESS);
    ok_bool_false(IsThreadHidden, "IsThreadHidden is");
 
    /* Make the thread hidden from the debugger -- The wrong way (2) */
    UlongData = TRUE;
    Status = NtSetInformationThread(hThread,
                                    ThreadHideFromDebugger,
                                    &UlongData,
                                    sizeof(UlongData));
    ok_ntstatus(Status, STATUS_INFO_LENGTH_MISMATCH);
 
    /* The thread is still debuggable */
    IsThreadHidden = 0xCC;
    Status = NtQueryInformationThread(hThread,
                                      ThreadHideFromDebugger,
                                      &IsThreadHidden,
                                      sizeof(IsThreadHidden),
                                      NULL);
    ok_ntstatus(Status, STATUS_SUCCESS);
    ok_bool_false(IsThreadHidden, "IsThreadHidden is");
 
    /* Make the thread hidden from the debugger -- The wrong way (3) */
    UlongData = TRUE;
    Status = NtSetInformationThread(hThread,
                                    ThreadHideFromDebugger,
                                    &UlongData,
                                    sizeof(BOOLEAN));
    ok_ntstatus(Status, STATUS_INFO_LENGTH_MISMATCH);
 
    /* The thread is still debuggable */
    IsThreadHidden = 0xCC;
    Status = NtQueryInformationThread(hThread,
                                      ThreadHideFromDebugger,
                                      &IsThreadHidden,
                                      sizeof(IsThreadHidden),
                                      NULL);
    ok_ntstatus(Status, STATUS_SUCCESS);
    ok_bool_false(IsThreadHidden, "IsThreadHidden is");
 
    /* Make the thread hidden from the debugger -- This way works! */
    Status = NtSetInformationThread(hThread,
                                    ThreadHideFromDebugger,
                                    NULL, 0);
    ok_ntstatus(Status, STATUS_SUCCESS);
 
    /* Verify that the thread is now hidden from the debugger */
    IsThreadHidden = 0xCC;
    Status = NtQueryInformationThread(hThread,
                                      ThreadHideFromDebugger,
                                      &IsThreadHidden,
                                      sizeof(IsThreadHidden),
                                      NULL);
    ok_ntstatus(Status, STATUS_SUCCESS);
    ok_bool_true(IsThreadHidden, "IsThreadHidden is");
 
 
    /* Send the kill signal and wait for the thread to terminate */
    NtSetEvent(hWaitEvent, NULL);
    NtWaitForSingleObject(hThread, FALSE, NULL);
    /* Close the thread */
    NtTerminateThread(hThread, STATUS_SUCCESS);
    NtClose(hThread);
Quit:
    /* Close the event */
    if (hWaitEvent)
        NtClose(hWaitEvent);
}

Referenced by START_TEST().

Test_ThreadNameInformation()

static void Test_ThreadNameInformation ( void  )

static

Definition at line 533 of file NtQueryInformationThread.c.

{
    ULONG NTDDIVersion;
    NTSTATUS Status;
    HANDLE hWaitEvent = NULL, hThread = NULL;
 
    OSVERSIONINFOEXW osVerInfo;
    osVerInfo.dwOSVersionInfoSize = sizeof(osVerInfo);
    GetVersionExW((LPOSVERSIONINFOW)&osVerInfo);
    trace("osVerInfo: %lu.%lu.%lu ('%S')\n",
          osVerInfo.dwMajorVersion,
          osVerInfo.dwMinorVersion,
          osVerInfo.dwBuildNumber,
          osVerInfo.szCSDVersion);
 
    NTDDIVersion = GetNTDDIVersion();
    trace("NTDDIVersion: 0x%08lx\n", NTDDIVersion);
    if (!is_reactos() && NTDDIVersion < NTDDI_WIN10_RS1)
    {
        skip("Skipping %s on NT %hu.%hu(.%hu), because it is not supported.\n",
              __FUNCTION__,
              (NTDDIVersion & 0xFF000000) >> 24,
              (NTDDIVersion & 0x00FF0000) >> 16,
              (NTDDIVersion & 0x000000FF));
        return;
    }
 
    Status = NtCreateEvent(&hWaitEvent,
                           EVENT_ALL_ACCESS,
                           NULL,
                           NotificationEvent,
                           FALSE);
    ok_ntstatus(Status, STATUS_SUCCESS);
    ok(hWaitEvent != NULL, "Expected not NULL, got NULL\n");
    if (!NT_SUCCESS(Status))
    {
        skip("Could not create the stop event! (Status 0x%08lx)\n", Status);
        goto Quit;
    }
 
    /* Create the dummy thread and wait for it to start up */
    Status = RtlCreateUserThread(NtCurrentProcess(),
                                 NULL,
                                 FALSE,
                                 0,
                                 0,
                                 0,
                                 DummyThread,
                                 (PVOID)hWaitEvent,
                                 &hThread,
                                 NULL);
    ok_ntstatus(Status, STATUS_SUCCESS);
    ok(hThread != NULL, "Expected not NULL, got NULL\n");
    if (!NT_SUCCESS(Status))
    {
        skip("Failed to create the dummy thread (Status 0x%08lx)\n", Status);
        goto Quit;
    }
 
    /* EXPECTATION: Initial thread name is empty. */
    DoThreadNameTest(1, hThread, (PCWSTR)(ULONG_PTR)-1);
 
    /* Set a non-empty thread name.
     * EXPECTATION: Thread name is what we have set. */
    DoThreadNameTest(2, hThread, L"Hello World!");
 
    /* Set an empty-string thread name.
     * EXPECTATION: Thread name is empty. */
    DoThreadNameTest(3, hThread, L"");
 
    /* Set a NULL-pointer empty-string thread name.
     * EXPECTATION: Thread name is empty. */
    DoThreadNameTest(4, hThread, NULL);
 
    /* Send the kill signal and wait for the thread to terminate */
    NtSetEvent(hWaitEvent, NULL);
    NtWaitForSingleObject(hThread, FALSE, NULL);
    /* Close the thread */
    NtTerminateThread(hThread, STATUS_SUCCESS);
    NtClose(hThread);
Quit:
    /* Close the event */
    if (hWaitEvent)
        NtClose(hWaitEvent);
}

Referenced by START_TEST().

Test_ThreadQueryAlignmentProbe()

void Test_ThreadQueryAlignmentProbe

(

void

)

Definition at line 282 of file NtQueryInformationThread.c.

{
    ULONG InfoClass;
 
    /* Iterate over the process info classes and begin the tests */
    for (InfoClass = 0; InfoClass < _countof(PsThreadInfoClass); InfoClass++)
    {
        /* The buffer is misaligned */
        QuerySetThreadValidator(QUERY,
                                InfoClass,
                                (PVOID)(ULONG_PTR)1,
                                PsThreadInfoClass[InfoClass].RequiredSizeQUERY,
                                STATUS_DATATYPE_MISALIGNMENT);
 
        /* We query an invalid buffer address */
        QuerySetThreadValidator(QUERY,
                                InfoClass,
                                (PVOID)(ULONG_PTR)PsThreadInfoClass[InfoClass].AlignmentQUERY,
                                PsThreadInfoClass[InfoClass].RequiredSizeQUERY,
                                STATUS_ACCESS_VIOLATION);
 
        /* The information length is wrong */
        QuerySetThreadValidator(QUERY,
                                InfoClass,
                                (PVOID)(ULONG_PTR)PsThreadInfoClass[InfoClass].AlignmentQUERY,
                                PsThreadInfoClass[InfoClass].RequiredSizeQUERY - 1,
                                STATUS_INFO_LENGTH_MISMATCH);
    }
}

Referenced by START_TEST().