fiber.c File Reference

#include <stdarg.h>
#include <ntstatus.h>
#include <winternl.h>
#include "wine/test.h"
#include <winuser.h>

Include dependency graph for fiber.c:

Go to the source code of this file.

Macros
#define	WIN32_NO_STATUS
#define	X(f)   p##f = (void*)GetProcAddress(hKernel32, #f);
#define	X(f)   p##f = (void*)GetProcAddress(hntdll, #f);
#define	FLS_TEST_INDEX_COUNT   4096
#define	check_current_actctx_is(e, t)   check_current_actctx_is_(__LINE__, e, t)

Functions
static	LPVOID (WINAPI *pCreateFiber)(SIZE_T
static	BOOL (WINAPI *pConvertFiberToThread)(void)
static	void (WINAPI *pSwitchToFiber)(LPVOID)
static	DWORD (WINAPI *pFlsAlloc)(PFLS_CALLBACK_FUNCTION)
static	PVOID (WINAPI *pFlsGetValue)(DWORD)
static	NTSTATUS (WINAPI *pRtlFlsAlloc)(PFLS_CALLBACK_FUNCTION
static VOID	init_funcs (void)
static VOID WINAPI	FiberLocalStorageProc (PVOID lpFlsData)
static VOID WINAPI	FiberMainProc (LPVOID lpFiberParameter)
static void	test_ConvertThreadToFiber (void)
static void	test_ConvertThreadToFiberEx (void)
static void	test_ConvertFiberToThread (void)
static void	test_FiberHandling (void)
static unsigned int	check_linked_list (const LIST_ENTRY *le, const LIST_ENTRY *search_entry, unsigned int *index_found)
static void WINAPI	test_fls_callback (void *data)
static unsigned int	test_fls_chunk_size (unsigned int chunk_index)
static unsigned int	test_fls_chunk_index_from_index (unsigned int index, unsigned int *index_in_chunk)
static DWORD WINAPI	test_FiberLocalStorage_thread (void *arg)
static void	test_FiberLocalStorage (void)
static void	test_FiberLocalStorageCallback (PFLS_CALLBACK_FUNCTION cbfunc)
static void	test_FiberLocalStorageWithFibers (PFLS_CALLBACK_FUNCTION cbfunc)
static void	check_current_actctx_is_ (int line, HANDLE expected_actctx, BOOL todo)
static DWORD WINAPI	subthread_actctx_func (void *actctx)
static void WINAPI	fiber_actctx_func (void *actctx)
static void	subtest_fiber_actctx_switch (HANDLE current_actctx, HANDLE child_actctx)
static void WINAPI	exit_thread_fiber_func (void *unused)
static DWORD WINAPI	thread_actctx_func_early_exit (void *actctx)
static void	subtest_fiber_actctx_preservation (HANDLE current_actctx, HANDLE child_actctx)
static HANDLE	create_actctx_from_module_manifest (void)
static void	test_fiber_actctx (void)
static void WINAPI	fls_exit_deadlock_callback (void *arg)
static DWORD CALLBACK	fls_exit_deadlock_thread (void *arg)
static void	fls_exit_deadlock_child (void)
static void	test_fls_exit_deadlock (void)
	START_TEST (fiber)

Variables
static	LPFIBER_START_ROUTINE
static	LPVOID
static	DWORD
static	SIZE_T
static	PVOID
static void *static void **static ULONG	flags
static void *	fibers [3]
static BYTE	testparam = 185
static DWORD	fls_index_to_set = FLS_OUT_OF_INDEXES
static void *	fls_value_to_set
static int	fiberCount = 0
static int	cbCount = 0
static unsigned int	test_fls_callback_call_count
static HANDLE	test_fiberlocalstorage_peb_locked_event
static HANDLE	test_fiberlocalstorage_done_event

Macro Definition Documentation

check_current_actctx_is

#define check_current_actctx_is	(		e,
			t
	)		check_current_actctx_is_(__LINE__, e, t)

Definition at line 805 of file fiber.c.

FLS_TEST_INDEX_COUNT

#define FLS_TEST_INDEX_COUNT   4096

Definition at line 220 of file fiber.c.

WIN32_NO_STATUS

#define WIN32_NO_STATUS

Definition at line 24 of file fiber.c.

X [1/2]

#define X

(

f

)

p##f = (void*)GetProcAddress(hKernel32, #f);

X [2/2]

#define X

(

f

)

p##f = (void*)GetProcAddress(hntdll, #f);

Function Documentation

BOOL()

static BOOL ( WINAPI *  pConvertFiberToThread )

static

check_current_actctx_is_()

static void check_current_actctx_is_ ( int  line, HANDLE  expected_actctx, BOOL  todo  )

static

Definition at line 806 of file fiber.c.

{
    HANDLE cur_actctx;
    BOOL ret;
 
    cur_actctx = (void*)0xdeadbeef;
    ret = GetCurrentActCtx(&cur_actctx);
    ok_(__FILE__, line)(ret, "thread GetCurrentActCtx failed, %lu\n", GetLastError());
 
    todo_wine_if(todo)
    ok_(__FILE__, line)(cur_actctx == expected_actctx, "got %p, expected %p\n", cur_actctx, expected_actctx);
 
    ReleaseActCtx(cur_actctx);
}

check_linked_list()

static unsigned int check_linked_list ( const LIST_ENTRY *  le, const LIST_ENTRY *  search_entry, unsigned int *  index_found  )

static

Definition at line 222 of file fiber.c.

{
    unsigned int count = 0;
    LIST_ENTRY *entry;
 
    *index_found = ~0;
 
    for (entry = le->Flink; entry != le; entry = entry->Flink)
    {
        if (entry == search_entry)
        {
            ok(*index_found == ~0, "Duplicate list entry.\n");
            *index_found = count;
        }
        ++count;
    }
    return count;
}

Referenced by test_FiberLocalStorage().

create_actctx_from_module_manifest()

static HANDLE create_actctx_from_module_manifest ( void  )

static

Definition at line 966 of file fiber.c.

{
    ACTCTXW actctx;
 
    memset(&actctx, 0, sizeof(ACTCTXW));
    actctx.cbSize = sizeof(actctx);
    actctx.dwFlags = ACTCTX_FLAG_HMODULE_VALID | ACTCTX_FLAG_RESOURCE_NAME_VALID;
    actctx.lpResourceName = MAKEINTRESOURCEW(124);
    actctx.hModule = GetModuleHandleW(NULL);
 
    return CreateActCtxW(&actctx);
}

Referenced by test_fiber_actctx().

DWORD()

static DWORD ( WINAPI *  pFlsAlloc )

static

exit_thread_fiber_func()

static void WINAPI exit_thread_fiber_func ( void *  unused )

static

Definition at line 898 of file fiber.c.

{
    BOOL ret;
 
    ret = pConvertFiberToThread();
    ok(ret, "ConvertFiberToThread returned error %lu\n", GetLastError());
 
    ExitThread(16);
}

Referenced by thread_actctx_func_early_exit().

fiber_actctx_func()

static void WINAPI fiber_actctx_func ( void *  actctx )

static

Definition at line 845 of file fiber.c.

{
    ULONG_PTR cookie;
    DWORD tid, wait;
    HANDLE thread;
    BOOL ret;
 
    check_current_actctx_is(NULL, FALSE);
 
    ret = ActivateActCtx(actctx, &cookie);
    ok(ret, "ActivateActCtx returned error %lu\n", GetLastError());
    check_current_actctx_is(actctx, FALSE);
 
    SwitchToFiber(fibers[0]);
    check_current_actctx_is(actctx, FALSE);
 
    thread = CreateThread(NULL, 0, subthread_actctx_func, actctx, 0, &tid);
    ok(thread != NULL, "CreateThread returned error %lu\n", GetLastError());
 
    wait = WaitForSingleObject(thread, INFINITE);
    ok(wait == WAIT_OBJECT_0, "WaitForSingleObject returned %lu (last error: %lu)\n",
       wait, GetLastError());
    CloseHandle(thread);
 
    ret = DeactivateActCtx(0, cookie);
    ok(ret, "DeactivateActCtx returned error %lu\n", GetLastError());
    check_current_actctx_is(NULL, FALSE);
 
    SwitchToFiber(fibers[0]);
    ok(0, "unreachable\n");
}

Referenced by subtest_fiber_actctx_switch().

FiberLocalStorageProc()

static VOID WINAPI FiberLocalStorageProc ( PVOID  lpFlsData )

static

Definition at line 88 of file fiber.c.

{
    ok(lpFlsData == fls_value_to_set,
       "FlsData expected not to be changed, value is %p, expected %p\n",
       lpFlsData, fls_value_to_set);
    cbCount++;
}

Referenced by START_TEST().

FiberMainProc()

static VOID WINAPI FiberMainProc ( LPVOID  lpFiberParameter )

static

Definition at line 96 of file fiber.c.

{
    BYTE *tparam = (BYTE *)lpFiberParameter;
    TEB *teb = NtCurrentTeb();
 
    ok(!teb->FlsSlots, "Got unexpected FlsSlots %p.\n", teb->FlsSlots);
 
    fiberCount++;
    ok(*tparam == 185, "Parameterdata expected not to be changed\n");
    if (fls_index_to_set != FLS_OUT_OF_INDEXES)
    {
        void* ret;
        BOOL bret;
 
        SetLastError( 0xdeadbeef );
        ret = pFlsGetValue(fls_index_to_set);
        ok(ret == NULL, "FlsGetValue returned %p, expected NULL\n", ret);
        ok(GetLastError() == ERROR_INVALID_PARAMETER, "Got unexpected error %lu.\n", GetLastError());
 
        /* Set the FLS value */
        bret = pFlsSetValue(fls_index_to_set, fls_value_to_set);
        ok(bret, "FlsSetValue failed with error %lu\n", GetLastError());
 
        ok(!!teb->FlsSlots, "Got unexpected FlsSlots %p.\n", teb->FlsSlots);
 
        /* Verify that FlsGetValue retrieves the value set by FlsSetValue */
        SetLastError( 0xdeadbeef );
        ret = pFlsGetValue(fls_index_to_set);
        ok(ret == fls_value_to_set, "FlsGetValue returned %p, expected %p\n", ret, fls_value_to_set);
        ok(GetLastError() == ERROR_SUCCESS, "FlsGetValue error %lu\n", GetLastError());
    }
    pSwitchToFiber(fibers[0]);
}

Referenced by test_FiberHandling(), and test_FiberLocalStorageWithFibers().

fls_exit_deadlock_callback()

static void WINAPI fls_exit_deadlock_callback ( void *  arg )

static

Definition at line 1034 of file fiber.c.

{
    if (arg == (void *)1)
        Sleep(INFINITE);
    if (arg == (void *)2)
        /* Unfortunately this test won't affect the exit code if it fails, but
         * at least it will print a failure message. */
        ok(RtlDllShutdownInProgress(), "expected DLL shutdown\n");
}

Referenced by fls_exit_deadlock_child().

fls_exit_deadlock_child()

static void fls_exit_deadlock_child ( void  )

static

Definition at line 1050 of file fiber.c.

{
    DWORD index = FlsAlloc(fls_exit_deadlock_callback);
    FlsSetValue(index, (void *)2);
    CreateThread(NULL, 0, fls_exit_deadlock_thread, (void *)(DWORD_PTR)index, 0, NULL);
    Sleep(100);
    ExitProcess(0);
}

Referenced by START_TEST().

fls_exit_deadlock_thread()

static DWORD CALLBACK fls_exit_deadlock_thread ( void *  arg )

static

Definition at line 1044 of file fiber.c.

{
    FlsSetValue((DWORD_PTR)arg, (void *)1);
    return 0;
}

Referenced by fls_exit_deadlock_child().

init_funcs()

static VOID init_funcs ( void  )

static

Definition at line 56 of file fiber.c.

{
    HMODULE hKernel32 = GetModuleHandleA("kernel32.dll");
    HMODULE hntdll = GetModuleHandleA("ntdll.dll");
 
#define X(f) p##f = (void*)GetProcAddress(hKernel32, #f);
    X(CreateFiber);
    X(ConvertThreadToFiber);
    X(ConvertFiberToThread);
    X(SwitchToFiber);
    X(DeleteFiber);
    X(ConvertThreadToFiberEx);
    X(CreateFiberEx);
    X(IsThreadAFiber);
    X(FlsAlloc);
    X(FlsFree);
    X(FlsGetValue);
    X(FlsSetValue);
#undef X
 
#define X(f) p##f = (void*)GetProcAddress(hntdll, #f);
    X(RtlFlsAlloc);
    X(RtlFlsFree);
    X(RtlFlsSetValue);
    X(RtlFlsGetValue);
    X(RtlProcessFlsData);
    X(RtlAcquirePebLock);
    X(RtlReleasePebLock);
#undef X
 
}

Referenced by START_TEST().

LPVOID()

static LPVOID ( WINAPI *  pCreateFiber )

static

NTSTATUS()

static NTSTATUS ( WINAPI *  pRtlFlsAlloc )

static

PVOID()

static PVOID ( WINAPI *  pFlsGetValue )

static

START_TEST()

START_TEST

(

fiber

)

Definition at line 1091 of file fiber.c.

{
    char **argv;
    int argc;
 
    argc = winetest_get_mainargs(&argv);
 
    if (argc == 3 && !strcmp(argv[2], "fls_exit_deadlock"))
    {
        fls_exit_deadlock_child();
        return;
    }
 
    init_funcs();
 
    if (!pCreateFiber)
    {
        win_skip( "Fibers not supported by win95\n" );
        return;
    }
 
    test_FiberHandling();
    test_FiberLocalStorage();
    test_FiberLocalStorageCallback(FiberLocalStorageProc);
    test_FiberLocalStorageWithFibers(FiberLocalStorageProc);
    test_fiber_actctx();
    test_fls_exit_deadlock();
}

subtest_fiber_actctx_preservation()

static void subtest_fiber_actctx_preservation ( HANDLE  current_actctx, HANDLE  child_actctx  )

static

Definition at line 931 of file fiber.c.

{
    ULONG_PTR cookie;
    DWORD tid, wait;
    HANDLE thread;
    BOOL ret;
 
    ret = ActivateActCtx(child_actctx, &cookie);
    ok(ret, "ActivateActCtx returned error %lu\n", GetLastError());
    check_current_actctx_is(child_actctx, FALSE);
 
    thread = CreateThread(NULL, 0, thread_actctx_func_early_exit, child_actctx, 0, &tid);
    ok(thread != NULL, "CreateThread returned error %lu\n", GetLastError());
 
    ret = DeactivateActCtx(0, cookie);
    ok(ret, "DeactivateActCtx returned error %lu\n", GetLastError());
    check_current_actctx_is(current_actctx, FALSE);
 
    wait = WaitForSingleObject(thread, INFINITE);
    ok(wait == WAIT_OBJECT_0, "WaitForSingleObject returned %lu (last error: %lu)\n",
       wait, GetLastError());
    CloseHandle(thread);
 
    /* The exited thread has been converted to a fiber */
#if defined(__REACTOS__) && defined(_M_AMD64)
    skip("FIXME: SwitchToFiber() is unimplemented on AMD64 ReactOS\n");
#else
    SwitchToFiber(fibers[1]);
    check_current_actctx_is(current_actctx, FALSE);
 
    DeleteFiber(fibers[1]);
    fibers[1] = NULL;
#endif
}

Referenced by test_fiber_actctx().

subtest_fiber_actctx_switch()

static void subtest_fiber_actctx_switch ( HANDLE  current_actctx, HANDLE  child_actctx  )

static

Definition at line 878 of file fiber.c.

{
    fibers[1] = pCreateFiber(0, fiber_actctx_func, child_actctx);
    ok(fibers[1] != NULL, "CreateFiber returned error %lu\n", GetLastError());
    check_current_actctx_is(current_actctx, FALSE);
 
    SwitchToFiber(fibers[1]);
    check_current_actctx_is(current_actctx, FALSE);
 
    SwitchToFiber(fibers[1]);
    check_current_actctx_is(current_actctx, FALSE);
 
    SwitchToFiber(fibers[2]);
    check_current_actctx_is(current_actctx, FALSE);
    ok(fibers[2] == NULL, "expected fiber to be deleted (got %p)\n", fibers[2]);
 
    DeleteFiber(fibers[1]);
    fibers[1] = NULL;
}

Referenced by test_fiber_actctx().

subthread_actctx_func()

static DWORD WINAPI subthread_actctx_func ( void *  actctx )

static

Definition at line 821 of file fiber.c.

{
    HANDLE fiber;
    BOOL ret;
 
    check_current_actctx_is(actctx, FALSE);
 
    fiber = pConvertThreadToFiber(NULL);
    ok(fiber != NULL, "ConvertThreadToFiber returned error %lu\n", GetLastError());
    check_current_actctx_is(actctx, FALSE);
    fibers[2] = fiber;
 
    SwitchToFiber(fibers[0]);
    check_current_actctx_is(actctx, FALSE);
 
    ok(fibers[2] == fiber, "fibers[2]: expected %p, got %p\n", fiber, fibers[2]);
    fibers[2] = NULL;
    ret = pConvertFiberToThread();
    ok(ret, "ConvertFiberToThread returned error %lu\n", GetLastError());
    check_current_actctx_is(actctx, FALSE);
 
    return 0;
}

Referenced by fiber_actctx_func().

test_ConvertFiberToThread()

static void test_ConvertFiberToThread ( void  )

static

Definition at line 170 of file fiber.c.

{
    if (pConvertFiberToThread)
    {
        BOOL ret = pConvertFiberToThread();
        ok(ret, "ConvertFiberToThread failed with error %lu\n", GetLastError());
    }
    else
    {
        win_skip( "ConvertFiberToThread not present\n" );
    }
}

Referenced by test_fiber_actctx(), test_FiberHandling(), and test_FiberLocalStorageWithFibers().

test_ConvertThreadToFiber()

static void test_ConvertThreadToFiber ( void  )

static

Definition at line 130 of file fiber.c.

{
    void *ret;
 
    if (pConvertThreadToFiber)
    {
        fibers[0] = pConvertThreadToFiber(&testparam);
        ok(fibers[0] != NULL, "ConvertThreadToFiber failed with error %lu\n", GetLastError());
 
        SetLastError(0xdeadbeef);
        ret = pConvertThreadToFiber(&testparam);
        ok(!ret, "Got non NULL ret.\n");
        ok(GetLastError() == ERROR_ALREADY_FIBER, "Got unexpected error %lu.\n", GetLastError());
    }
    else
    {
        win_skip( "ConvertThreadToFiber not present\n" );
    }
}

Referenced by test_fiber_actctx(), test_FiberHandling(), and test_FiberLocalStorageWithFibers().

test_ConvertThreadToFiberEx()

static void test_ConvertThreadToFiberEx ( void  )

static

Definition at line 150 of file fiber.c.

{
    void *ret;
 
    if (pConvertThreadToFiberEx)
    {
        fibers[0] = pConvertThreadToFiberEx(&testparam, 0);
        ok(fibers[0] != NULL, "ConvertThreadToFiberEx failed with error %lu\n", GetLastError());
 
        SetLastError(0xdeadbeef);
        ret = pConvertThreadToFiberEx(&testparam, 0);
        ok(!ret, "Got non NULL ret.\n");
        ok(GetLastError() == ERROR_ALREADY_FIBER, "Got unexpected error %lu.\n", GetLastError());
    }
    else
    {
        win_skip( "ConvertThreadToFiberEx not present\n" );
    }
}

Referenced by test_FiberHandling().

test_fiber_actctx()

static void test_fiber_actctx ( void  )

static

Definition at line 979 of file fiber.c.

{
    ULONG_PTR cookies[3];
    HANDLE actctxs[3];
    size_t i, j;
    BOOL ret;
 
#ifdef __REACTOS__
    if (GetNTVersion() < _WIN32_WINNT_VISTA && !is_reactos()) {
        skip("test_fiber_actctx() crashes and isn't valid on WS03.\n");
        return;
    }
#endif
    for (i = 0; i < ARRAY_SIZE(actctxs); i++)
    {
        actctxs[i] = create_actctx_from_module_manifest();
        ok(actctxs[i] != INVALID_HANDLE_VALUE, "failed to create context, error %lu\n", GetLastError());
        for (j = 0; j < i; j++)
        {
            ok(actctxs[i] != actctxs[j],
               "actctxs[%Iu] (%p) and actctxs[%Iu] (%p) should not alias\n",
               i, actctxs[i], j, actctxs[j]);
        }
    }
 
    ret = ActivateActCtx(actctxs[0], &cookies[0]);
    ok(ret, "ActivateActCtx returned error %lu\n", GetLastError());
    check_current_actctx_is(actctxs[0], FALSE);
 
    test_ConvertThreadToFiber();
    check_current_actctx_is(actctxs[0], FALSE);
 
    ret = ActivateActCtx(actctxs[1], &cookies[1]);
    ok(ret, "ActivateActCtx returned error %lu\n", GetLastError());
    check_current_actctx_is(actctxs[1], FALSE);
 
    subtest_fiber_actctx_switch(actctxs[1], actctxs[2]);
    subtest_fiber_actctx_preservation(actctxs[1], actctxs[2]);
 
    ret = DeactivateActCtx(0, cookies[1]);
    ok(ret, "DeactivateActCtx returned error %lu\n", GetLastError());
    check_current_actctx_is(actctxs[0], FALSE);
 
    test_ConvertFiberToThread();
    check_current_actctx_is(actctxs[0], FALSE);
 
    ret = DeactivateActCtx(0, cookies[0]);
    ok(ret, "DeactivateActCtx returned error %lu\n", GetLastError());
    check_current_actctx_is(NULL, FALSE);
 
    for (i = ARRAY_SIZE(actctxs); i > 0; )
        ReleaseActCtx(actctxs[--i]);
}

Referenced by START_TEST().

test_FiberHandling()

static void test_FiberHandling ( void  )

static

Definition at line 183 of file fiber.c.

{
    fiberCount = 0;
    fibers[0] = pCreateFiber(0,FiberMainProc,&testparam);
    ok(fibers[0] != NULL, "CreateFiber failed with error %lu\n", GetLastError());
    pDeleteFiber(fibers[0]);
 
    test_ConvertThreadToFiber();
    test_ConvertFiberToThread();
    if (pConvertThreadToFiberEx)
        test_ConvertThreadToFiberEx();
    else
        test_ConvertThreadToFiber();
 
    fibers[1] = pCreateFiber(0,FiberMainProc,&testparam);
    ok(fibers[1] != NULL, "CreateFiber failed with error %lu\n", GetLastError());
 
    pSwitchToFiber(fibers[1]);
    ok(fiberCount == 1, "Wrong fiber count: %d\n", fiberCount);
    pDeleteFiber(fibers[1]);
 
    if (pCreateFiberEx)
    {
        fibers[1] = pCreateFiberEx(0,0,0,FiberMainProc,&testparam);
        ok(fibers[1] != NULL, "CreateFiberEx failed with error %lu\n", GetLastError());
 
        pSwitchToFiber(fibers[1]);
        ok(fiberCount == 2, "Wrong fiber count: %d\n", fiberCount);
        pDeleteFiber(fibers[1]);
    }
    else win_skip( "CreateFiberEx not present\n" );
 
    if (pIsThreadAFiber) ok(pIsThreadAFiber(), "IsThreadAFiber reported FALSE\n");
    test_ConvertFiberToThread();
    if (pIsThreadAFiber) ok(!pIsThreadAFiber(), "IsThreadAFiber reported TRUE\n");
}

Referenced by START_TEST().

test_FiberLocalStorage()

static void test_FiberLocalStorage ( void  )

static

Definition at line 277 of file fiber.c.

{
    static DWORD fls_indices[FLS_TEST_INDEX_COUNT];
    unsigned int i, j, count, entry_count, index;
    LIST_ENTRY *fls_list_head, saved_entry;
    TEB_FLS_DATA *fls_data, *new_fls_data;
    GLOBAL_FLS_DATA *g_fls_data;
    DWORD fls, fls_2, result;
    TEB *teb = NtCurrentTeb();
    PEB *peb = teb->Peb;
    NTSTATUS status;
    HANDLE hthread;
    ULONG index2;
    SIZE_T size;
    void* val;
    BOOL ret;
 
    if (!pFlsAlloc || !pFlsSetValue || !pFlsGetValue || !pFlsFree)
    {
        win_skip( "Fiber Local Storage not supported\n" );
        return;
    }
 
    if (pRtlFlsAlloc)
    {
        if (pRtlFlsGetValue)
        {
            status = pRtlFlsGetValue(0, NULL);
            ok(status == STATUS_INVALID_PARAMETER, "Got unexpected status %#lx.\n", status);
        }
        else
        {
            win_skip("RtlFlsGetValue is not available.\n");
        }
 
        for (i = 0; i < FLS_TEST_INDEX_COUNT; ++i)
        {
            fls_indices[i] = 0xdeadbeef;
            status = pRtlFlsAlloc(test_fls_callback, &fls_indices[i]);
            ok(!status || status == STATUS_NO_MEMORY, "Got unexpected status %#lx.\n", status);
            if (status)
            {
                ok(fls_indices[i] == 0xdeadbeef, "Got unexpected index %#lx.\n", fls_indices[i]);
                break;
            }
            if (pRtlFlsSetValue)
            {
                status = pRtlFlsSetValue(fls_indices[i], (void *)(ULONG_PTR)(i + 1));
                ok(!status, "Got unexpected status %#lx.\n", status);
            }
        }
        count = i;
 
        fls_data = teb->FlsSlots;
 
        /* FLS limits are increased since Win10 18312. */
        ok(count && (count <= 127 || (count > 4000 && count < 4096)), "Got unexpected count %u.\n", count);
 
#if defined(__REACTOS__) && defined(_WIN64)
        /* peb layout is different on ReactOS x64 */
        if (!is_reactos() && !peb->FlsCallback)
#else
        if (!peb->FlsCallback)
#endif
        {
            ok(pRtlFlsSetValue && pRtlFlsGetValue, "Missing RtlFlsGetValue / RtlFlsSetValue.\n");
            ok(!peb->FlsBitmap, "Got unexpected FlsBitmap %p.\n", peb->FlsBitmap);
            ok(!peb->FlsListHead.Flink && !peb->FlsListHead.Blink, "Got nonzero FlsListHead.\n");
            ok(!peb->FlsHighIndex, "Got unexpected FlsHighIndex %lu.\n", peb->FlsHighIndex);
 
            fls_list_head = fls_data->fls_list_entry.Flink;
 
            entry_count = check_linked_list(fls_list_head, &fls_data->fls_list_entry, &index);
            ok(entry_count == 1, "Got unexpected count %u.\n", entry_count);
            ok(!index, "Got unexpected index %u.\n", index);
 
            g_fls_data = CONTAINING_RECORD(fls_list_head, GLOBAL_FLS_DATA, fls_list_head);
 
            ok(g_fls_data->fls_high_index == 0xfef, "Got unexpected fls_high_index %#lx.\n", g_fls_data->fls_high_index);
 
            for (i = 0; i < 8; ++i)
            {
                ok(!!g_fls_data->fls_callback_chunks[i], "Got zero fls_callback_chunks[%u].\n", i);
                ok(g_fls_data->fls_callback_chunks[i]->count == test_fls_chunk_size(i),
                        "Got unexpected g_fls_data->fls_callback_chunks[%u]->count %lu.\n",
                        i, g_fls_data->fls_callback_chunks[i]->count);
 
                size = HeapSize(GetProcessHeap(), 0, g_fls_data->fls_callback_chunks[i]);
                ok(size == sizeof(ULONG_PTR) + sizeof(FLS_CALLBACK) * test_fls_chunk_size(i),
                        "Got unexpected size %p.\n", (void *)size);
 
                ok(!!fls_data->fls_data_chunks[i], "Got zero fls_data->fls_data_chunks[%u].\n", i);
                ok(!fls_data->fls_data_chunks[i][0], "Got unexpected fls_data->fls_data_chunks[%u][0] %p.\n",
                        i, fls_data->fls_data_chunks[i][0]);
                size = HeapSize(GetProcessHeap(), 0, fls_data->fls_data_chunks[i]);
                ok(size == sizeof(void *) * (test_fls_chunk_size(i) + 1), "Got unexpected size %p.\n", (void *)size);
 
                if (!i)
                {
                    ok(g_fls_data->fls_callback_chunks[0]->callbacks[0].callback == (void *)~(ULONG_PTR)0,
                            "Got unexpected callback %p.\n",
                            g_fls_data->fls_callback_chunks[0]->callbacks[0].callback);
                }
 
                for (j = i ? 0 : fls_indices[0]; j < test_fls_chunk_size(i); ++j)
                {
                    ok(!g_fls_data->fls_callback_chunks[i]->callbacks[j].unknown,
                            "Got unexpected unknown %p, i %u, j %u.\n",
                            g_fls_data->fls_callback_chunks[i]->callbacks[j].unknown, i, j);
                    ok(g_fls_data->fls_callback_chunks[i]->callbacks[j].callback == test_fls_callback,
                            "Got unexpected callback %p, i %u, j %u.\n",
                            g_fls_data->fls_callback_chunks[i]->callbacks[j].callback, i, j);
                }
            }
            for (i = 0; i < count; ++i)
            {
                j = test_fls_chunk_index_from_index(fls_indices[i], &index);
                ok(fls_data->fls_data_chunks[j][index + 1] == (void *)(ULONG_PTR)(i + 1),
                        "Got unexpected FLS value %p, i %u, j %u, index %u.\n",
                        fls_data->fls_data_chunks[j][index + 1], i, j, index);
            }
            j = test_fls_chunk_index_from_index(fls_indices[0x10], &index);
            g_fls_data->fls_callback_chunks[j]->callbacks[index].callback = NULL;
            status = pRtlFlsFree(fls_indices[0x10]);
            ok(status == STATUS_INVALID_PARAMETER, "Got unexpected status %#lx.\n", status);
 
            g_fls_data->fls_callback_chunks[j]->callbacks[index].callback = test_fls_callback;
            test_fls_callback_call_count = 0;
            status = pRtlFlsFree(fls_indices[0x10]);
            ok(!status, "Got unexpected status %#lx.\n", status);
            ok(test_fls_callback_call_count == 1, "Got unexpected callback call count %u.\n",
                    test_fls_callback_call_count);
 
            ok(!fls_data->fls_data_chunks[j][0], "Got unexpected fls_data->fls_data_chunks[%u][0] %p.\n",
                    j, fls_data->fls_data_chunks[j][0]);
            ok(!g_fls_data->fls_callback_chunks[j]->callbacks[index].callback,
                    "Got unexpected callback %p.\n",
                    g_fls_data->fls_callback_chunks[j]->callbacks[index].callback);
 
            fls_data->fls_data_chunks[j][index + 1] = (void *)(ULONG_PTR)0x28;
            status = pRtlFlsAlloc(test_fls_callback, &index2);
            ok(!status, "Got unexpected status %#lx.\n", status);
            ok(index2 == fls_indices[0x10], "Got unexpected index %lu.\n", index2);
            ok(fls_data->fls_data_chunks[j][index + 1] == (void *)(ULONG_PTR)0x28, "Got unexpected data %p.\n",
                    fls_data->fls_data_chunks[j][index + 1]);
 
            status = pRtlFlsSetValue(index2, (void *)(ULONG_PTR)0x11);
            ok(!status, "Got unexpected status %#lx.\n", status);
 
            teb->FlsSlots = NULL;
 
            val = (void *)0xdeadbeef;
            status = pRtlFlsGetValue(fls_indices[1], &val);
            new_fls_data = teb->FlsSlots;
            ok(status == STATUS_INVALID_PARAMETER, "Got unexpected status %#lx.\n", status);
            ok(val == (void *)0xdeadbeef, "Got unexpected val %p.\n", val);
            ok(!new_fls_data, "Got unexpected teb->FlsSlots %p.\n", new_fls_data);
 
            status = pRtlFlsSetValue(fls_indices[1], (void *)(ULONG_PTR)0x28);
            new_fls_data = teb->FlsSlots;
            ok(!status, "Got unexpected status %#lx.\n", status);
            ok(!!new_fls_data, "Got unexpected teb->FlsSlots %p.\n", new_fls_data);
 
            entry_count = check_linked_list(fls_list_head, &fls_data->fls_list_entry, &index);
            ok(entry_count == 2, "Got unexpected count %u.\n", entry_count);
            ok(!index, "Got unexpected index %u.\n", index);
            check_linked_list(fls_list_head, &new_fls_data->fls_list_entry, &index);
            ok(index == 1, "Got unexpected index %u.\n", index);
 
            val = (void *)0xdeadbeef;
            status = pRtlFlsGetValue(fls_indices[2], &val);
            ok(!status, "Got unexpected status %#lx.\n", status);
            ok(!val, "Got unexpected val %p.\n", val);
 
 
            /* With bit 0 of flags set RtlProcessFlsData is removing FLS data from the linked list
             * and calls FLS callbacks. With bit 1 set the memory is freed. The remaining bits do not seem
             * to have any obvious effect. */
            for (i = 2; i < 32; ++i)
            {
                pRtlProcessFlsData(new_fls_data, 1 << i);
                size = HeapSize(GetProcessHeap(), 0, new_fls_data);
                ok(size == sizeof(*new_fls_data), "Got unexpected size %p.\n", (void *)size);
            }
 
            if (0)
            {
                pRtlProcessFlsData(new_fls_data, 2);
                entry_count = check_linked_list(fls_list_head, &fls_data->fls_list_entry, &index);
                ok(entry_count == 2, "Got unexpected count %u.\n", entry_count);
 
                /* Crashes on Windows. */
                HeapSize(GetProcessHeap(), 0, new_fls_data);
            }
 
            test_fiberlocalstorage_peb_locked_event = CreateEventA(NULL, FALSE, FALSE, NULL);
            test_fiberlocalstorage_done_event = CreateEventA(NULL, FALSE, FALSE, NULL);
            hthread = CreateThread(NULL, 0, test_FiberLocalStorage_thread, NULL, 0, NULL);
            ok(!!hthread, "CreateThread failed.\n");
            result = WaitForSingleObject(test_fiberlocalstorage_peb_locked_event, INFINITE);
            ok(result == WAIT_OBJECT_0, "Got unexpected result %lu.\n", result);
            teb->FlsSlots = NULL;
 
            test_fls_callback_call_count = 0;
            saved_entry = new_fls_data->fls_list_entry;
            pRtlProcessFlsData(new_fls_data, 1);
            ok(!teb->FlsSlots, "Got unexpected teb->FlsSlots %p.\n", teb->FlsSlots);
 
            teb->FlsSlots = fls_data;
            ok(test_fls_callback_call_count == 1, "Got unexpected callback call count %u.\n",
                    test_fls_callback_call_count);
 
            SetEvent(test_fiberlocalstorage_done_event);
            WaitForSingleObject(hthread, INFINITE);
            CloseHandle(hthread);
            CloseHandle(test_fiberlocalstorage_peb_locked_event);
            CloseHandle(test_fiberlocalstorage_done_event);
 
            ok(new_fls_data->fls_list_entry.Flink == saved_entry.Flink, "Got unexpected Flink %p.\n",
                    saved_entry.Flink);
            ok(new_fls_data->fls_list_entry.Blink == saved_entry.Blink, "Got unexpected Flink %p.\n",
                    saved_entry.Blink);
            size = HeapSize(GetProcessHeap(), 0, new_fls_data);
            ok(size == sizeof(*new_fls_data), "Got unexpected size %p.\n", (void *)size);
            test_fls_callback_call_count = 0;
            i = test_fls_chunk_index_from_index(fls_indices[1], &index);
            new_fls_data->fls_data_chunks[i][index + 1] = (void *)(ULONG_PTR)0x28;
            pRtlProcessFlsData(new_fls_data, 2);
            ok(!test_fls_callback_call_count, "Got unexpected callback call count %u.\n",
                    test_fls_callback_call_count);
 
            if (0)
            {
                /* crashes on Windows. */
                HeapSize(GetProcessHeap(), 0, new_fls_data);
            }
 
            entry_count = check_linked_list(fls_list_head, &fls_data->fls_list_entry, &index);
            ok(entry_count == 1, "Got unexpected count %u.\n", entry_count);
            ok(!index, "Got unexpected index %u.\n", index);
        }
        else
        {
            win_skip("Old FLS data storage layout, skipping test.\n");
            g_fls_data = NULL;
        }
 
        if (0)
        {
            /* crashes on Windows. */
            pRtlFlsGetValue(fls_indices[0], NULL);
        }
 
        for (i = 0; i < count; ++i)
        {
            if (pRtlFlsGetValue)
            {
                status = pRtlFlsGetValue(fls_indices[i], &val);
                ok(!status, "Got unexpected status %#lx.\n", status);
                ok(val == (void *)(ULONG_PTR)(i + 1), "Got unexpected val %p, i %u.\n", val, i);
            }
 
            status = pRtlFlsFree(fls_indices[i]);
            ok(!status, "Got unexpected status %#lx, i %u.\n", status, i);
        }
 
#if defined(__REACTOS__) && defined(_WIN64)
        /* peb layout is different on ReactOS x64 */
        if (!is_reactos() && !peb->FlsCallback)
#else
        if (!peb->FlsCallback)
#endif
        {
            ok(g_fls_data->fls_high_index == 0xfef, "Got unexpected fls_high_index %#lx.\n",
                    g_fls_data->fls_high_index);
 
            for (i = 0; i < 8; ++i)
            {
                ok(!!g_fls_data->fls_callback_chunks[i], "Got zero fls_callback_chunks[%u].\n", i);
                ok(!!fls_data->fls_data_chunks[i], "Got zero fls_data->fls_data_chunks[%u].\n", i);
            }
        }
    }
    else
    {
        win_skip("RtlFlsAlloc is not available.\n");
    }
 
    /* Test an unallocated index
     * FlsFree should fail
     * FlsGetValue and FlsSetValue should succeed
     */
    SetLastError( 0xdeadbeef );
    ret = pFlsFree( 127 );
    ok( !ret, "freeing fls index 127 (unallocated) succeeded\n" );
    ok( GetLastError() == ERROR_INVALID_PARAMETER,
        "freeing fls index 127 (unallocated) wrong error %lu\n", GetLastError() );
 
    val = pFlsGetValue( 127 );
    ok( val == NULL,
        "getting fls index 127 (unallocated) failed with error %lu\n", GetLastError() );
 
    if (pRtlFlsGetValue)
    {
        val = (void *)0xdeadbeef;
        status = pRtlFlsGetValue(127, &val);
        ok( !status, "Got unexpected status %#lx.\n", status );
        ok( !val, "Got unexpected val %p.\n", val );
    }
 
    ret = pFlsSetValue( 127, (void*) 0x217 );
    ok( ret, "setting fls index 127 (unallocated) failed with error %lu\n", GetLastError() );
 
    SetLastError( 0xdeadbeef );
    val = pFlsGetValue( 127 );
    ok( val == (void*) 0x217, "fls index 127 (unallocated) wrong value %p\n", val );
    ok( GetLastError() == ERROR_SUCCESS,
        "getting fls index 127 (unallocated) failed with error %lu\n", GetLastError() );
 
    if (pRtlFlsGetValue)
    {
        val = (void *)0xdeadbeef;
        status = pRtlFlsGetValue(127, &val);
        ok( !status, "Got unexpected status %#lx.\n", status );
        ok( val == (void*)0x217, "Got unexpected val %p.\n", val );
    }
 
    /* FlsFree, FlsGetValue, and FlsSetValue out of bounds should return
     * ERROR_INVALID_PARAMETER
     */
    SetLastError( 0xdeadbeef );
    ret = pFlsFree( 128 );
    ok( !ret, "freeing fls index 128 (out of bounds) succeeded\n" );
    ok( GetLastError() == ERROR_INVALID_PARAMETER,
        "freeing fls index 128 (out of bounds) wrong error %lu\n", GetLastError() );
 
    SetLastError( 0xdeadbeef );
    ret = pFlsSetValue( 128, (void*) 0x217 );
    ok( ret || GetLastError() == ERROR_INVALID_PARAMETER,
        "setting fls index 128 (out of bounds) wrong error %lu\n", GetLastError() );
 
    SetLastError( 0xdeadbeef );
    val = pFlsGetValue( 128 );
    ok( GetLastError() == ERROR_INVALID_PARAMETER || val == (void *)0x217,
        "getting fls index 128 (out of bounds) wrong error %lu\n", GetLastError() );
 
    /* Test index 0 */
    SetLastError( 0xdeadbeef );
    val = pFlsGetValue( 0 );
    ok( !val, "fls index 0 set to %p\n", val );
    ok( GetLastError() == ERROR_INVALID_PARAMETER, "setting fls index wrong error %lu\n", GetLastError() );
    if (pRtlFlsGetValue)
    {
        val = (void *)0xdeadbeef;
        status = pRtlFlsGetValue(0, &val);
        ok( status == STATUS_INVALID_PARAMETER, "Got unexpected status %#lx.\n", status );
        ok( val == (void*)0xdeadbeef, "Got unexpected val %p.\n", val );
    }
 
    SetLastError( 0xdeadbeef );
    ret = pFlsSetValue( 0, (void *)0xdeadbeef );
    ok( !ret, "setting fls index 0 succeeded\n" );
    ok( GetLastError() == ERROR_INVALID_PARAMETER, "setting fls index wrong error %lu\n", GetLastError() );
    if (pRtlFlsSetValue)
    {
        status = pRtlFlsSetValue( 0, (void *)0xdeadbeef );
        ok( status == STATUS_INVALID_PARAMETER, "Got unexpected status %#lx.\n", status );
    }
    SetLastError( 0xdeadbeef );
    val = pFlsGetValue( 0 );
    ok( !val, "fls index 0 wrong value %p\n", val );
    ok( GetLastError() == ERROR_INVALID_PARAMETER, "setting fls index wrong error %lu\n", GetLastError() );
 
    /* Test creating an FLS index */
    fls = pFlsAlloc( NULL );
    ok( fls != FLS_OUT_OF_INDEXES, "FlsAlloc failed\n" );
    ok( fls != 0, "fls index 0 allocated\n" );
    val = pFlsGetValue( fls );
    ok( !val, "fls index %lu wrong value %p\n", fls, val );
    SetLastError( 0xdeadbeef );
    ret = pFlsSetValue( fls, (void *)0xdeadbeef );
    ok( ret, "setting fls index %lu failed\n", fls );
    ok( GetLastError() == 0xdeadbeef, "setting fls index wrong error %lu\n", GetLastError() );
    SetLastError( 0xdeadbeef );
    val = pFlsGetValue( fls );
    ok( val == (void *)0xdeadbeef, "fls index %lu wrong value %p\n", fls, val );
    ok( GetLastError() == ERROR_SUCCESS,
        "getting fls index %lu failed with error %lu\n", fls, GetLastError() );
    pFlsFree( fls );
 
    /* Undefined behavior: verify the value is NULL after it the slot is freed */
    SetLastError( 0xdeadbeef );
    val = pFlsGetValue( fls );
    ok( val == NULL, "fls index %lu wrong value %p\n", fls, val );
    ok( GetLastError() == ERROR_SUCCESS,
        "getting fls index %lu failed with error %lu\n", fls, GetLastError() );
 
    /* Undefined behavior: verify the value is settable after the slot is freed */
    ret = pFlsSetValue( fls, (void *)0xdeadbabe );
    ok( ret, "setting fls index %lu failed\n", fls );
    val = pFlsGetValue( fls );
    ok( val == (void *)0xdeadbabe, "fls index %lu wrong value %p\n", fls, val );
 
    /* Try to create the same FLS index again, and verify that is initialized to NULL */
    fls_2 = pFlsAlloc( NULL );
    ok( fls != FLS_OUT_OF_INDEXES, "FlsAlloc failed with error %lu\n", GetLastError() );
    /* If this fails it is not an API error, but the test will be inconclusive */
    ok( fls_2 == fls, "different FLS index allocated, was %lu, now %lu\n", fls, fls_2 );
 
    SetLastError( 0xdeadbeef );
    val = pFlsGetValue( fls_2 );
    ok( val == NULL || val == (void *)0xdeadbabe, "fls index %lu wrong value %p\n", fls, val );
    ok( GetLastError() == ERROR_SUCCESS,
        "getting fls index %lu failed with error %lu\n", fls_2, GetLastError() );
    pFlsFree( fls_2 );
}

Referenced by START_TEST().

test_FiberLocalStorage_thread()

static DWORD WINAPI test_FiberLocalStorage_thread ( void *  arg )

static

Definition at line 268 of file fiber.c.

{
    pRtlAcquirePebLock();
    SetEvent(test_fiberlocalstorage_peb_locked_event);
    WaitForSingleObject(test_fiberlocalstorage_done_event, INFINITE);
    pRtlReleasePebLock();
    return 0;
}

Referenced by test_FiberLocalStorage().

test_FiberLocalStorageCallback()

static void test_FiberLocalStorageCallback ( PFLS_CALLBACK_FUNCTION  cbfunc )

static

Definition at line 694 of file fiber.c.

{
    DWORD fls;
    BOOL ret;
    void* val, *val2;
 
    if (!pFlsAlloc || !pFlsSetValue || !pFlsGetValue || !pFlsFree)
    {
        win_skip( "Fiber Local Storage not supported\n" );
        return;
    }
 
    /* Test that the callback is executed */
    cbCount = 0;
    fls = pFlsAlloc( cbfunc );
    ok( fls != FLS_OUT_OF_INDEXES, "FlsAlloc failed with error %lu\n", GetLastError() );
 
    val = (void*) 0x1587;
    fls_value_to_set = val;
    ret = pFlsSetValue( fls, val );
    ok(ret, "FlsSetValue failed with error %lu\n", GetLastError() );
 
    val2 = pFlsGetValue( fls );
    ok(val == val2, "FlsGetValue returned %p, expected %p\n", val2, val);
 
    ret = pFlsFree( fls );
    ok(ret, "FlsFree failed with error %lu\n", GetLastError() );
    ok( cbCount == 1, "Wrong callback count: %d\n", cbCount );
 
    /* Test that callback is not executed if value is NULL */
    cbCount = 0;
    fls = pFlsAlloc( cbfunc );
    ok( fls != FLS_OUT_OF_INDEXES, "FlsAlloc failed with error %lu\n", GetLastError() );
 
    ret = pFlsSetValue( fls, NULL );
    ok( ret, "FlsSetValue failed with error %lu\n", GetLastError() );
 
    pFlsFree( fls );
    ok( ret, "FlsFree failed with error %lu\n", GetLastError() );
    ok( cbCount == 0, "Wrong callback count: %d\n", cbCount );
}

Referenced by START_TEST().

test_FiberLocalStorageWithFibers()

static void test_FiberLocalStorageWithFibers ( PFLS_CALLBACK_FUNCTION  cbfunc )

static

Definition at line 736 of file fiber.c.

{
    void* val1 = (void*) 0x314;
    void* val2 = (void*) 0x152;
    BOOL ret;
 
    if (!pFlsAlloc || !pFlsFree || !pFlsSetValue || !pFlsGetValue)
    {
        win_skip( "Fiber Local Storage not supported\n" );
        return;
    }
 
    fls_index_to_set = pFlsAlloc(cbfunc);
    ok(fls_index_to_set != FLS_OUT_OF_INDEXES, "FlsAlloc failed with error %lu\n", GetLastError());
 
    test_ConvertThreadToFiber();
 
    fiberCount = 0;
    cbCount = 0;
    fibers[1] = pCreateFiber(0,FiberMainProc,&testparam);
    fibers[2] = pCreateFiber(0,FiberMainProc,&testparam);
    ok(fibers[1] != NULL, "CreateFiber failed with error %lu\n", GetLastError());
    ok(fibers[2] != NULL, "CreateFiber failed with error %lu\n", GetLastError());
    ok(fiberCount == 0, "Wrong fiber count: %d\n", fiberCount);
    ok(cbCount == 0, "Wrong callback count: %d\n", cbCount);
 
    fiberCount = 0;
    cbCount = 0;
    fls_value_to_set = val1;
    pSwitchToFiber(fibers[1]);
    ok(fiberCount == 1, "Wrong fiber count: %d\n", fiberCount);
    ok(cbCount == 0, "Wrong callback count: %d\n", cbCount);
 
    fiberCount = 0;
    cbCount = 0;
    fls_value_to_set = val2;
    pSwitchToFiber(fibers[2]);
    ok(fiberCount == 1, "Wrong fiber count: %d\n", fiberCount);
    ok(cbCount == 0, "Wrong callback count: %d\n", cbCount);
 
    fls_value_to_set = val2;
    ret = pFlsSetValue(fls_index_to_set, fls_value_to_set);
    ok(ret, "FlsSetValue failed\n");
    ok(val2 == pFlsGetValue(fls_index_to_set), "FlsGetValue failed\n");
 
    fiberCount = 0;
    cbCount = 0;
    fls_value_to_set = val1;
    pDeleteFiber(fibers[1]);
    ok(fiberCount == 0, "Wrong fiber count: %d\n", fiberCount);
    ok(cbCount == 1, "Wrong callback count: %d\n", cbCount);
 
    fiberCount = 0;
    cbCount = 0;
    fls_value_to_set = val2;
    pFlsFree(fls_index_to_set);
    ok(fiberCount == 0, "Wrong fiber count: %d\n", fiberCount);
    ok(cbCount == 2, "Wrong callback count: %d\n", cbCount);
 
    fiberCount = 0;
    cbCount = 0;
    fls_value_to_set = val1;
    pDeleteFiber(fibers[2]);
    ok(fiberCount == 0, "Wrong fiber count: %d\n", fiberCount);
    ok(cbCount == 0, "Wrong callback count: %d\n", cbCount);
 
    test_ConvertFiberToThread();
}

Referenced by START_TEST().

test_fls_callback()

static void WINAPI test_fls_callback ( void *  data )

static

Definition at line 243 of file fiber.c.

{
    ++test_fls_callback_call_count;
}

Referenced by test_FiberLocalStorage().

test_fls_chunk_index_from_index()

static unsigned int test_fls_chunk_index_from_index ( unsigned int  index, unsigned int *  index_in_chunk  )

static

Definition at line 253 of file fiber.c.

{
    unsigned int chunk_index = 0;
 
    while (index >= test_fls_chunk_size(chunk_index))
        index -= test_fls_chunk_size(chunk_index++);
 
    *index_in_chunk = index;
    return chunk_index;
}

Referenced by test_FiberLocalStorage().

test_fls_chunk_size()

static unsigned int test_fls_chunk_size ( unsigned int  chunk_index )

static

Definition at line 248 of file fiber.c.

{
    return 0x10 << chunk_index;
}

Referenced by test_FiberLocalStorage(), and test_fls_chunk_index_from_index().

test_fls_exit_deadlock()

static void test_fls_exit_deadlock ( void  )

static

Definition at line 1059 of file fiber.c.

{
    char **argv, cmdline[MAX_PATH];
    PROCESS_INFORMATION pi;
    STARTUPINFOA si = {0};
    BOOL ret;
 
    /* Regression test for the following deadlock:
     *
     * Thread A             Thread B
     * -----------------------------
     * ExitThread
     * acquire FLS lock
     * call FLS callback
     *                      ExitProcess
     *                      terminate thread A
     *                      acquire FLS lock
     *
     * Thread B deadlocks on acquiring the FLS lock (in order to itself call its
     * FLS callbacks.)
     */
 
    winetest_get_mainargs(&argv);
    sprintf(cmdline, "%s %s fls_exit_deadlock", argv[0], argv[1]);
    ret = CreateProcessA(NULL, cmdline, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi);
    ok(ret, "failed to create child, error %lu\n", GetLastError());
    ret = WaitForSingleObject(pi.hProcess, 1000);
    ok(!ret, "wait failed\n");
    CloseHandle(pi.hProcess);
    CloseHandle(pi.hThread);
}

Referenced by START_TEST().

thread_actctx_func_early_exit()

static DWORD WINAPI thread_actctx_func_early_exit ( void *  actctx )

static

Definition at line 908 of file fiber.c.

{
    HANDLE exit_thread_fiber;
 
    check_current_actctx_is(actctx, FALSE);
 
    fibers[1] = pConvertThreadToFiber(NULL);
    ok(fibers[1] != NULL, "ConvertThreadToFiber returned error %lu\n", GetLastError());
    check_current_actctx_is(actctx, FALSE);
 
    exit_thread_fiber = pCreateFiber(0, exit_thread_fiber_func, NULL);
    ok(exit_thread_fiber != NULL, "CreateFiber returned error %lu\n", GetLastError());
 
    /* exit thread, but keep current fiber */
    SwitchToFiber(exit_thread_fiber);
    check_current_actctx_is(actctx, FALSE);
 
    SwitchToFiber(fibers[0]);
    ok(0, "unreachable\n");
    return 17;
}

Referenced by subtest_fiber_actctx_preservation().

void()

static void ( WINAPI *  pSwitchToFiber )

static

Variable Documentation

cbCount

int cbCount = 0

static

Definition at line 54 of file fiber.c.

Referenced by FiberLocalStorageProc(), GreGetObject(), LoadStringFromRegistry(), PALETTE_GetObject(), PEN_GetObject(), test_FiberLocalStorageCallback(), and test_FiberLocalStorageWithFibers().

DWORD

DWORD

Definition at line 34 of file fiber.c.

fiberCount

int fiberCount = 0

static

Definition at line 53 of file fiber.c.

Referenced by FiberMainProc(), test_FiberHandling(), and test_FiberLocalStorageWithFibers().

fibers

void* fibers[3]

static

Definition at line 48 of file fiber.c.

Referenced by fiber_actctx_func(), FiberMainProc(), subtest_fiber_actctx_preservation(), subtest_fiber_actctx_switch(), subthread_actctx_func(), test_ConvertThreadToFiber(), test_ConvertThreadToFiberEx(), test_FiberHandling(), test_FiberLocalStorageWithFibers(), and thread_actctx_func_early_exit().

flags

void *static void **static ULONG flags

Definition at line 47 of file fiber.c.

fls_index_to_set

DWORD fls_index_to_set = FLS_OUT_OF_INDEXES

static

Definition at line 50 of file fiber.c.

Referenced by FiberMainProc(), and test_FiberLocalStorageWithFibers().

fls_value_to_set

void* fls_value_to_set

static

Definition at line 51 of file fiber.c.

Referenced by FiberLocalStorageProc(), FiberMainProc(), test_FiberLocalStorageCallback(), and test_FiberLocalStorageWithFibers().

LPFIBER_START_ROUTINE

LPFIBER_START_ROUTINE

Definition at line 29 of file fiber.c.

LPVOID

LPVOID

Definition at line 29 of file fiber.c.

PVOID

PVOID

Definition at line 40 of file fiber.c.

SIZE_T

SIZE_T

Definition at line 35 of file fiber.c.

test_fiberlocalstorage_done_event

HANDLE test_fiberlocalstorage_done_event

static

Definition at line 265 of file fiber.c.

Referenced by test_FiberLocalStorage(), and test_FiberLocalStorage_thread().

test_fiberlocalstorage_peb_locked_event

HANDLE test_fiberlocalstorage_peb_locked_event

static

Definition at line 264 of file fiber.c.

Referenced by test_FiberLocalStorage(), and test_FiberLocalStorage_thread().

test_fls_callback_call_count

unsigned int test_fls_callback_call_count

static

Definition at line 241 of file fiber.c.

Referenced by test_FiberLocalStorage(), and test_fls_callback().

testparam

BYTE testparam = 185

static

Definition at line 49 of file fiber.c.

Referenced by test_ConvertThreadToFiber(), test_ConvertThreadToFiberEx(), test_FiberHandling(), and test_FiberLocalStorageWithFibers().