fiber.c File Reference

#include <k32.h>
#include <ndk/rtltypes.h>
#include <debug.h>

Include dependency graph for fiber.c:

Go to the source code of this file.

Macros
#define	NDEBUG

Functions
VOID WINAPI	BaseRundownFls (_In_ PVOID FlsData)
BOOL WINAPI	ConvertFiberToThread (VOID)
LPVOID WINAPI	ConvertThreadToFiberEx (_In_opt_ LPVOID lpParameter, _In_ DWORD dwFlags)
LPVOID WINAPI	ConvertThreadToFiber (_In_opt_ LPVOID lpParameter)
LPVOID WINAPI	CreateFiber (_In_ SIZE_T dwStackSize, _In_ LPFIBER_START_ROUTINE lpStartAddress, _In_opt_ LPVOID lpParameter)
LPVOID WINAPI	CreateFiberEx (_In_ SIZE_T dwStackCommitSize, _In_ SIZE_T dwStackReserveSize, _In_ DWORD dwFlags, _In_ LPFIBER_START_ROUTINE lpStartAddress, _In_opt_ LPVOID lpParameter)
VOID WINAPI	DeleteFiber (_In_ LPVOID lpFiber)
BOOL WINAPI	IsThreadAFiber (VOID)
DWORD WINAPI	FlsAlloc (PFLS_CALLBACK_FUNCTION lpCallback)
BOOL WINAPI	FlsFree (DWORD dwFlsIndex)
PVOID WINAPI	FlsGetValue (DWORD dwFlsIndex)
BOOL WINAPI	FlsSetValue (DWORD dwFlsIndex, PVOID lpFlsData)

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 13 of file fiber.c.

Function Documentation

BaseRundownFls()

VOID WINAPI BaseRundownFls

(

_In_ PVOID

FlsData

)

Definition at line 32 of file fiber.c.

{
    ULONG n, FlsHighIndex;
    PRTL_FLS_DATA pFlsData;
    PFLS_CALLBACK_FUNCTION lpCallback;
 
    pFlsData = FlsData;
 
    RtlAcquirePebLock();
    FlsHighIndex = NtCurrentPeb()->FlsHighIndex;
    RemoveEntryList(&pFlsData->ListEntry);
    RtlReleasePebLock();
 
    for (n = 1; n <= FlsHighIndex; ++n)
    {
        lpCallback = NtCurrentPeb()->FlsCallback[n];
        if (lpCallback && pFlsData->Data[n])
        {
            lpCallback(pFlsData->Data[n]);
        }
    }
 
    RtlFreeHeap(RtlGetProcessHeap(), 0, FlsData);
}

Referenced by DeleteFiber().

ConvertFiberToThread()

BOOL WINAPI ConvertFiberToThread

(

VOID

)

Definition at line 64 of file fiber.c.

{
    PTEB Teb;
    PFIBER FiberData;
    DPRINT1("Converting Fiber to Thread\n");
 
    /* Check if the thread is already not a fiber */
    Teb = NtCurrentTeb();
    if (!Teb->HasFiberData)
    {
        /* Fail */
        SetLastError(ERROR_ALREADY_THREAD);
        return FALSE;
    }
 
    /* This thread won't run a fiber anymore */
    Teb->HasFiberData = FALSE;
    FiberData = Teb->NtTib.FiberData;
    Teb->NtTib.FiberData = NULL;
 
    /* Free the fiber */
    ASSERT(FiberData != NULL);
    RtlFreeHeap(RtlGetProcessHeap(),
                0,
                FiberData);
 
    /* Success */
    return TRUE;
}

ConvertThreadToFiber()

LPVOID WINAPI ConvertThreadToFiber

(

_In_opt_ LPVOID

lpParameter

)

Definition at line 162 of file fiber.c.

{
    /* Call the newer function */
    return ConvertThreadToFiberEx(lpParameter,
                                  0);
}

Referenced by Fbt_CreateFiber(), and init_funcs().

ConvertThreadToFiberEx()

LPVOID WINAPI ConvertThreadToFiberEx	(	_In_opt_ LPVOID	lpParameter,
		_In_ DWORD	dwFlags
	)

Definition at line 99 of file fiber.c.

{
    PTEB Teb;
    PFIBER Fiber;
    DPRINT1("Converting Thread to Fiber\n");
 
    /* Check for invalid flags */
    if (dwFlags & ~FIBER_FLAG_FLOAT_SWITCH)
    {
        /* Fail */
        SetLastError(ERROR_INVALID_PARAMETER);
        return NULL;
    }
 
    /* Are we already a fiber? */
    Teb = NtCurrentTeb();
    if (Teb->HasFiberData)
    {
        /* Fail */
        SetLastError(ERROR_ALREADY_FIBER);
        return NULL;
    }
 
    /* Allocate the fiber */
    Fiber = RtlAllocateHeap(RtlGetProcessHeap(),
                            0,
                            sizeof(FIBER));
    if (!Fiber)
    {
        /* Fail */
        SetLastError(ERROR_NOT_ENOUGH_MEMORY);
        return NULL;
    }
 
    /* Copy some contextual data from the thread to the fiber */
    Fiber->FiberData = lpParameter;
    Fiber->ExceptionList = Teb->NtTib.ExceptionList;
    Fiber->StackBase = Teb->NtTib.StackBase;
    Fiber->StackLimit = Teb->NtTib.StackLimit;
    Fiber->DeallocationStack = Teb->DeallocationStack;
    Fiber->FlsData = Teb->FlsData;
    Fiber->GuaranteedStackBytes = Teb->GuaranteedStackBytes;
    Fiber->ActivationContextStackPointer = Teb->ActivationContextStackPointer;
 
    /* Save FPU State if requested, otherwise just the basic registers */
    Fiber->FiberContext.ContextFlags = (dwFlags & FIBER_FLAG_FLOAT_SWITCH) ?
                                       (CONTEXT_FULL | CONTEXT_FLOATING_POINT) :
                                       CONTEXT_FULL;
 
    /* Associate the fiber to the current thread */
    Teb->NtTib.FiberData = Fiber;
    Teb->HasFiberData = TRUE;
 
    /* Return opaque fiber data */
    return (LPVOID)Fiber;
}

Referenced by ConvertThreadToFiber(), and init_funcs().

CreateFiber()

LPVOID WINAPI CreateFiber	(	_In_ SIZE_T	dwStackSize,
		_In_ LPFIBER_START_ROUTINE	lpStartAddress,
		_In_opt_ LPVOID	lpParameter
	)

Definition at line 174 of file fiber.c.

{
    /* Call the Newer Function */
    return CreateFiberEx(dwStackSize,
                         0,
                         0,
                         lpStartAddress,
                         lpParameter);
}

Referenced by Fbt_CreateFiber(), and init_funcs().

CreateFiberEx()

LPVOID WINAPI CreateFiberEx	(	_In_ SIZE_T	dwStackCommitSize,
		_In_ SIZE_T	dwStackReserveSize,
		_In_ DWORD	dwFlags,
		_In_ LPFIBER_START_ROUTINE	lpStartAddress,
		_In_opt_ LPVOID	lpParameter
	)

Definition at line 191 of file fiber.c.

{
    PFIBER Fiber;
    NTSTATUS Status;
    INITIAL_TEB InitialTeb;
    PACTIVATION_CONTEXT_STACK ActivationContextStackPointer;
    DPRINT("Creating Fiber\n");
 
    /* Check for invalid flags */
    if (dwFlags & ~FIBER_FLAG_FLOAT_SWITCH)
    {
        /* Fail */
        SetLastError(ERROR_INVALID_PARAMETER);
        return NULL;
    }
 
    /* Allocate the Activation Context Stack */
    ActivationContextStackPointer = NULL;
    Status = RtlAllocateActivationContextStack(&ActivationContextStackPointer);
    if (!NT_SUCCESS(Status))
    {
        /* Fail */
        BaseSetLastNTError(Status);
        return NULL;
    }
 
    /* Allocate the fiber */
    Fiber = RtlAllocateHeap(RtlGetProcessHeap(),
                            0,
                            sizeof(FIBER));
    if (!Fiber)
    {
        /* Free the activation context stack */
        RtlFreeActivationContextStack(ActivationContextStackPointer);
 
        /* Fail */
        SetLastError(ERROR_NOT_ENOUGH_MEMORY);
        return NULL;
    }
 
    /* Create the stack for the fiber */
    Status = BaseCreateStack(NtCurrentProcess(),
                              dwStackCommitSize,
                              dwStackReserveSize,
                              &InitialTeb);
    if (!NT_SUCCESS(Status))
    {
        /* Free the fiber */
        RtlFreeHeap(GetProcessHeap(),
                    0,
                    Fiber);
 
        /* Free the activation context stack */
        RtlFreeActivationContextStack(ActivationContextStackPointer);
 
        /* Failure */
        BaseSetLastNTError(Status);
        return NULL;
    }
 
    /* Clear the context */
    RtlZeroMemory(&Fiber->FiberContext,
                  sizeof(CONTEXT));
 
    /* Copy the data into the fiber */
    Fiber->StackBase = InitialTeb.StackBase;
    Fiber->StackLimit = InitialTeb.StackLimit;
    Fiber->DeallocationStack = InitialTeb.AllocatedStackBase;
    Fiber->FiberData = lpParameter;
    Fiber->ExceptionList = EXCEPTION_CHAIN_END;
    Fiber->GuaranteedStackBytes = 0;
    Fiber->FlsData = NULL;
    Fiber->ActivationContextStackPointer = ActivationContextStackPointer;
 
    /* Save FPU State if requested, otherwise just the basic registers */
    Fiber->FiberContext.ContextFlags = (dwFlags & FIBER_FLAG_FLOAT_SWITCH) ?
                                       (CONTEXT_FULL | CONTEXT_FLOATING_POINT) :
                                       CONTEXT_FULL;
 
    /* Initialize the context for the fiber */
    BaseInitializeContext(&Fiber->FiberContext,
                          lpParameter,
                          lpStartAddress,
                          InitialTeb.StackBase,
                          2);
 
    /* Return the Fiber */
    return Fiber;
}

Referenced by CreateFiber(), and init_funcs().

DeleteFiber()

VOID WINAPI DeleteFiber

(

_In_ LPVOID

lpFiber

)

Definition at line 290 of file fiber.c.

{
    SIZE_T Size;
    PFIBER Fiber;
    PTEB Teb;
 
    /* Are we deleting ourselves? */
    Teb = NtCurrentTeb();
    Fiber = (PFIBER)lpFiber;
    if ((Teb->HasFiberData) &&
        (Teb->NtTib.FiberData == Fiber))
    {
        /* Just exit */
        ExitThread(1);
    }
 
    /* Not ourselves, de-allocate the stack */
    Size = 0 ;
    NtFreeVirtualMemory(NtCurrentProcess(),
                        &Fiber->DeallocationStack,
                        &Size,
                        MEM_RELEASE);
 
    /* Get rid of FLS */
    if (Fiber->FlsData) BaseRundownFls(Fiber->FlsData);
 
    /* Get rid of the activation context stack */
    RtlFreeActivationContextStack(Fiber->ActivationContextStackPointer);
 
    /* Free the fiber data */
    RtlFreeHeap(RtlGetProcessHeap(),
                0,
                lpFiber);
}

Referenced by Fbt_AfterSwitch(), Fbt_Dispatch(), init_funcs(), subtest_fiber_actctx_preservation(), and subtest_fiber_actctx_switch().

FlsAlloc()

DWORD WINAPI FlsAlloc

(

PFLS_CALLBACK_FUNCTION

lpCallback

)

Definition at line 341 of file fiber.c.

{
    DWORD dwFlsIndex;
    PPEB Peb = NtCurrentPeb();
    PRTL_FLS_DATA pFlsData;
 
    RtlAcquirePebLock();
 
    pFlsData = NtCurrentTeb()->FlsData;
 
    if (!Peb->FlsCallback &&
        !(Peb->FlsCallback = RtlAllocateHeap(RtlGetProcessHeap(), HEAP_ZERO_MEMORY,
                                             FLS_MAXIMUM_AVAILABLE * sizeof(PVOID))))
    {
        SetLastError(ERROR_NOT_ENOUGH_MEMORY);
        dwFlsIndex = FLS_OUT_OF_INDEXES;
    }
    else
    {
        dwFlsIndex = RtlFindClearBitsAndSet(Peb->FlsBitmap, 1, 1);
        if (dwFlsIndex != FLS_OUT_OF_INDEXES)
        {
            if (!pFlsData &&
                !(pFlsData = RtlAllocateHeap(RtlGetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(RTL_FLS_DATA))))
            {
                RtlClearBits(Peb->FlsBitmap, dwFlsIndex, 1);
                dwFlsIndex = FLS_OUT_OF_INDEXES;
                SetLastError(ERROR_NOT_ENOUGH_MEMORY);
            }
            else
            {
                if (!NtCurrentTeb()->FlsData)
                {
                    NtCurrentTeb()->FlsData = pFlsData;
                    InsertTailList(&Peb->FlsListHead, &pFlsData->ListEntry);
                }
 
                pFlsData->Data[dwFlsIndex] = NULL; /* clear the value */
                Peb->FlsCallback[dwFlsIndex] = lpCallback;
 
                if (dwFlsIndex > Peb->FlsHighIndex)
                    Peb->FlsHighIndex = dwFlsIndex;
            }
        }
        else
        {
            SetLastError(ERROR_NO_MORE_ITEMS);
        }
    }
    RtlReleasePebLock();
    return dwFlsIndex;
}

Referenced by __acrt_FlsAlloc(), fls_exit_deadlock_child(), and init_funcs().

FlsFree()

BOOL WINAPI FlsFree

(

DWORD

dwFlsIndex

)

Definition at line 400 of file fiber.c.

{
    BOOL ret;
    PPEB Peb = NtCurrentPeb();
 
    if (dwFlsIndex >= FLS_MAXIMUM_AVAILABLE)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    RtlAcquirePebLock();
 
    _SEH2_TRY
    {
        ret = RtlAreBitsSet(Peb->FlsBitmap, dwFlsIndex, 1);
        if (ret)
        {
            PLIST_ENTRY Entry;
            PFLS_CALLBACK_FUNCTION lpCallback;
 
            RtlClearBits(Peb->FlsBitmap, dwFlsIndex, 1);
            lpCallback = Peb->FlsCallback[dwFlsIndex];
 
            for (Entry = Peb->FlsListHead.Flink; Entry != &Peb->FlsListHead; Entry = Entry->Flink)
            {
                PRTL_FLS_DATA pFlsData;
 
                pFlsData = CONTAINING_RECORD(Entry, RTL_FLS_DATA, ListEntry);
                if (pFlsData->Data[dwFlsIndex])
                {
                    if (lpCallback)
                    {
                        lpCallback(pFlsData->Data[dwFlsIndex]);
                    }
                    pFlsData->Data[dwFlsIndex] = NULL;
                }
            }
            Peb->FlsCallback[dwFlsIndex] = NULL;
        }
        else
        {
            SetLastError(ERROR_INVALID_PARAMETER);
        }
    }
    _SEH2_FINALLY
    {
        RtlReleasePebLock();
    }
    _SEH2_END;
 
    return ret;
}

Referenced by __acrt_FlsFree(), and init_funcs().

FlsGetValue()

PVOID WINAPI FlsGetValue

(

DWORD

dwFlsIndex

)

Definition at line 460 of file fiber.c.

{
    PRTL_FLS_DATA pFlsData;
 
    pFlsData = NtCurrentTeb()->FlsData;
    if (!dwFlsIndex || dwFlsIndex >= FLS_MAXIMUM_AVAILABLE || !pFlsData)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return NULL;
    }
 
    SetLastError(ERROR_SUCCESS);
    return pFlsData->Data[dwFlsIndex];
}

Referenced by __acrt_FlsGetValue(), and init_funcs().

FlsSetValue()

BOOL WINAPI FlsSetValue	(	DWORD	dwFlsIndex,
		PVOID	lpFlsData
	)

Definition at line 481 of file fiber.c.

{
    PRTL_FLS_DATA pFlsData;
 
    if (!dwFlsIndex || dwFlsIndex >= FLS_MAXIMUM_AVAILABLE)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    pFlsData = NtCurrentTeb()->FlsData;
 
    if (!NtCurrentTeb()->FlsData &&
        !(NtCurrentTeb()->FlsData = RtlAllocateHeap(RtlGetProcessHeap(), HEAP_ZERO_MEMORY,
                                                    sizeof(RTL_FLS_DATA))))
    {
        SetLastError(ERROR_NOT_ENOUGH_MEMORY);
        return FALSE;
    }
    if (!pFlsData)
    {
        pFlsData = NtCurrentTeb()->FlsData;
        RtlAcquirePebLock();
        InsertTailList(&NtCurrentPeb()->FlsListHead, &pFlsData->ListEntry);
        RtlReleasePebLock();
    }
    pFlsData->Data[dwFlsIndex] = lpFlsData;
    return TRUE;
}

Referenced by __acrt_FlsSetValue(), fls_exit_deadlock_child(), fls_exit_deadlock_thread(), and init_funcs().

IsThreadAFiber()

BOOL WINAPI IsThreadAFiber

(

VOID

)

Definition at line 330 of file fiber.c.

{
    /* Return flag in the TEB */
    return NtCurrentTeb()->HasFiberData;
}