thread.cpp File Reference

#include <corecrt_internal.h>
#include <process.h>
#include <roapi.h>

Include dependency graph for thread.cpp:

Go to the source code of this file.

Classes
struct	anonymous_namespace{thread.cpp}::thread_parameter_free_policy

Namespaces
namespace	anonymous_namespace{thread.cpp}

Typedefs
using	anonymous_namespace{thread.cpp}::unique_thread_parameter = __crt_unique_heap_ptr< __acrt_thread_parameter, thread_parameter_free_policy >

Functions
template<typename ThreadProcedure , bool Ex>
static unsigned long WINAPI	thread_start (void *const parameter) throw ()
static __acrt_thread_parameter *__cdecl	create_thread_parameter (void *const procedure, void *const context) throw ()
uintptr_t __cdecl	_beginthread (_beginthread_proc_type const procedure, unsigned int const stack_size, void *const context)
uintptr_t __cdecl	_beginthreadex (void *const security_descriptor, unsigned int const stack_size, _beginthreadex_proc_type const procedure, void *const context, unsigned int const creation_flags, unsigned int *const thread_id_result)
static void __cdecl	common_end_thread (unsigned int const return_code) throw ()
void __cdecl	_endthread ()
void __cdecl	_endthreadex (unsigned int const return_code)

Function Documentation

_beginthread()

uintptr_t __cdecl _beginthread	(	_beginthread_proc_type const	procedure,
		unsigned int const	stack_size,
		void *const	context
	)

Definition at line 145 of file thread.cpp.

{
    _VALIDATE_RETURN(procedure != nullptr, EINVAL, reinterpret_cast<uintptr_t>(INVALID_HANDLE_VALUE));
 
    unique_thread_parameter parameter(create_thread_parameter(reinterpret_cast<void*>(procedure), context));
    if (!parameter)
    {
        return reinterpret_cast<uintptr_t>(INVALID_HANDLE_VALUE);
    }
 
    // We create the new thread in a suspended state so that we can update
    // the parameter structure with the thread handle.  The newly created
    // thread is responsible for closing this handle.
    DWORD thread_id{};
    HANDLE const thread_handle = CreateThread(
        nullptr,
        stack_size,
        thread_start<_beginthread_proc_type, false>,
        parameter.get(),
        CREATE_SUSPENDED,
        &thread_id);
 
    if (!thread_handle)
    {
        __acrt_errno_map_os_error(GetLastError());
        return reinterpret_cast<uintptr_t>(INVALID_HANDLE_VALUE);
    }
 
    parameter.get()->_thread_handle = thread_handle;
 
    // Now we can start the thread...
    if (ResumeThread(thread_handle) == static_cast<DWORD>(-1))
    {
        __acrt_errno_map_os_error(GetLastError());
        return reinterpret_cast<uintptr_t>(INVALID_HANDLE_VALUE);
    }
 
    // If we successfully created the thread, the thread now owns its parameter:
    parameter.detach();
 
    return reinterpret_cast<uintptr_t>(thread_handle);
}

_beginthreadex()

uintptr_t __cdecl _beginthreadex	(	void *const	security_descriptor,
		unsigned int const	stack_size,
		_beginthreadex_proc_type const	procedure,
		void *const	context,
		unsigned int const	creation_flags,
		unsigned int *const	thread_id_result
	)

Definition at line 192 of file thread.cpp.

{
    _VALIDATE_RETURN(procedure != nullptr, EINVAL, 0);
 
    unique_thread_parameter parameter(create_thread_parameter((void*)procedure, context));
    if (!parameter)
    {
        return 0;
    }
 
    DWORD thread_id;
    HANDLE const thread_handle = CreateThread(
        reinterpret_cast<LPSECURITY_ATTRIBUTES>(security_descriptor),
        stack_size,
        thread_start<_beginthreadex_proc_type, true>,
        parameter.get(),
        creation_flags,
        &thread_id);
 
    if (!thread_handle)
    {
        __acrt_errno_map_os_error(GetLastError());
        return 0;
    }
 
    if (thread_id_result)
    {
        *thread_id_result = thread_id;
    }
 
    // If we successfully created the thread, the thread now owns its parameter:
    parameter.detach();
 
    return reinterpret_cast<uintptr_t>(thread_handle);
}

_endthread()

void __cdecl _endthread

(

void

)

Definition at line 271 of file thread.cpp.

{
    return common_end_thread(0);
}

Referenced by DefragThread(), init(), internal_thread_proc(), processRequest(), test_thread_func(), and test_thread_func_ex().

_endthreadex()

void __cdecl _endthreadex

(

unsigned int const

return_code

)

Definition at line 276 of file thread.cpp.

{
    return common_end_thread(return_code);
}

Referenced by ActionThread(), internal_thread_proc(), test_thread_func(), and thread_start().

common_end_thread()

static void __cdecl common_end_thread ( unsigned int const  return_code ) throw ( )

static

Definition at line 237 of file thread.cpp.

{
    __acrt_ptd* const ptd = __acrt_getptd_noexit();
    if (!ptd)
    {
        ExitThread(return_code);
    }
 
    __acrt_thread_parameter* const parameter = ptd->_beginthread_context;
    if (!parameter)
    {
        ExitThread(return_code);
    }
 
    if (parameter->_initialized_apartment)
    {
        __acrt_RoUninitialize();
    }
 
    if (parameter->_thread_handle != INVALID_HANDLE_VALUE && parameter->_thread_handle != nullptr)
    {
        CloseHandle(parameter->_thread_handle);
    }
 
    if (parameter->_module_handle != INVALID_HANDLE_VALUE && parameter->_module_handle != nullptr)
    {
        FreeLibraryAndExitThread(parameter->_module_handle, return_code);
    }
    else
    {
        ExitThread(return_code);
    }
}

Referenced by _endthread(), and _endthreadex().

create_thread_parameter()

static __acrt_thread_parameter *__cdecl create_thread_parameter ( void *const  procedure, void *const  context  ) throw ( )

static

Definition at line 119 of file thread.cpp.

{
    unique_thread_parameter parameter(_calloc_crt_t(__acrt_thread_parameter, 1).detach());
    if (!parameter)
    {
        return nullptr;
    }
 
    parameter.get()->_procedure = reinterpret_cast<void*>(procedure);
    parameter.get()->_context   = context;
 
    // Attempt to bump the reference count of the module in which the user's
    // thread procedure is defined, to ensure that the module will stay loaded
    // as long as the thread is executing.  We will release this HMDOULE when
    // the thread procedure returns or _endthreadex is called.
    GetModuleHandleExW(
        GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS,
        reinterpret_cast<LPCWSTR>(procedure),
        &parameter.get()->_module_handle);
 
    return parameter.detach();
}

Referenced by _beginthread(), and _beginthreadex().

thread_start()

template<typename ThreadProcedure , bool Ex>

static unsigned long WINAPI thread_start ( void *const  parameter ) throw ( )

static

Definition at line 76 of file thread.cpp.

{
    if (!parameter)
    {
        ExitThread(GetLastError());
    }
 
    __acrt_thread_parameter* const context = static_cast<__acrt_thread_parameter*>(parameter);
 
    __acrt_getptd()->_beginthread_context = context;
 
    if (__acrt_get_begin_thread_init_policy() == begin_thread_init_policy_ro_initialize)
    {
        context->_initialized_apartment = __acrt_RoInitialize(RO_INIT_MULTITHREADED) == S_OK;
    }
 
    __try
    {
        ThreadProcedure const procedure = reinterpret_cast<ThreadProcedure>(context->_procedure);
        if constexpr (Ex)
        {
            _endthreadex(procedure(context->_context));
        }
        else
        {
            procedure(context->_context);
            _endthreadex(0);
        }
    }
    __except (_seh_filter_exe(GetExceptionCode(), GetExceptionInformation()))
    {
        // Execution should never reach here:
        _exit(GetExceptionCode());
    }
    __endtry
 
    // This return statement will never be reached.  All execution paths result
    // in the thread or process exiting.
    return 0;
}