exit.cpp File Reference

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

Include dependency graph for exit.cpp:

Go to the source code of this file.

Typedefs
typedef void(WINAPI *	exit_process_pft) (UINT)

Functions
static bool __cdecl	is_managed_app () throw ()
static void __cdecl	try_cor_exit_process (UINT const return_code) throw ()
static bool __cdecl	should_call_terminate_process () throw ()
static void __cdecl	exit_or_terminate_process (UINT const return_code) throw ()
static int __cdecl	atexit_exception_filter (unsigned long const _exception_code) throw ()
void __cdecl	__acrt_initialize_thread_local_exit_callback (void *encoded_null)
void __cdecl	_register_thread_local_exe_atexit_callback (_In_ _tls_callback_type const _Callback)
static void __cdecl	common_exit (int const return_code, _crt_exit_cleanup_mode const cleanup_mode, _crt_exit_return_mode const return_mode) throw ()
int __cdecl	_is_c_termination_complete ()
void __cdecl	exit (int const return_code)
void __cdecl	_exit (int const return_code)
void __cdecl	_Exit (int const return_code)
void __cdecl	quick_exit (int const return_code)
void __cdecl	_cexit ()
void __cdecl	_c_exit ()

Variables
static long	c_termination_complete = FALSE
_onexit_table_t	__acrt_atexit_table
_onexit_table_t	__acrt_at_quick_exit_table
static _tls_callback_type	thread_local_exit_callback_func

Typedef Documentation

exit_process_pft

typedef void(WINAPI * exit_process_pft) (UINT)

Definition at line 46 of file exit.cpp.

Function Documentation

__acrt_initialize_thread_local_exit_callback()

void __cdecl __acrt_initialize_thread_local_exit_callback

(

void *

encoded_null

)

Definition at line 155 of file exit.cpp.

{
    thread_local_exit_callback_func = reinterpret_cast<_tls_callback_type>(encoded_null);
}

_c_exit()

void __cdecl _c_exit

(

void

)

Definition at line 315 of file exit.cpp.

{
    common_exit(0, _crt_exit_no_cleanup, _crt_exit_return_to_caller);
}

_cexit()

void __cdecl _cexit

(

void

)

Definition at line 310 of file exit.cpp.

{
    common_exit(0, _crt_exit_full_cleanup, _crt_exit_return_to_caller);
}

_exit()

void __cdecl _exit

(

int const

return_code

)

Definition at line 292 of file exit.cpp.

{
    common_exit(return_code, _crt_exit_no_cleanup, _crt_exit_terminate_process);
    UNREACHABLE;
}

_Exit()

void __cdecl _Exit

(

int const

return_code

)

Definition at line 298 of file exit.cpp.

{
    common_exit(return_code, _crt_exit_no_cleanup, _crt_exit_terminate_process);
    UNREACHABLE;
}

_is_c_termination_complete()

int __cdecl _is_c_termination_complete

(

void

)

Definition at line 279 of file exit.cpp.

{
    return static_cast<int>(__crt_interlocked_read(&c_termination_complete));
}

_register_thread_local_exe_atexit_callback()

void __cdecl _register_thread_local_exe_atexit_callback

(

_In_ _tls_callback_type const

_Callback

)

Definition at line 162 of file exit.cpp.

{
    // Can only set the callback once.
    if (thread_local_exit_callback_func != __crt_fast_encode_pointer(nullptr))
    {
        terminate();
    }
 
    thread_local_exit_callback_func = __crt_fast_encode_pointer(_Callback);
}

atexit_exception_filter()

static int __cdecl atexit_exception_filter ( unsigned long const  _exception_code ) throw ( )

static

Definition at line 143 of file exit.cpp.

{
    if (_exception_code == ('msc' | 0xE0000000))
    {
        return EXCEPTION_EXECUTE_HANDLER;
    }
 
    return EXCEPTION_CONTINUE_SEARCH;
}

Referenced by common_exit().

common_exit()

static void __cdecl common_exit ( int const  return_code, _crt_exit_cleanup_mode const  cleanup_mode, _crt_exit_return_mode const  return_mode  ) throw ( )

static

Definition at line 175 of file exit.cpp.

{
    // First, check to see if we're loaded in a managed app.  If we are, try to
    // call CorExitProcess to let the CLR handle the process termination.  If
    // the call to CorExitProcess is successful, then it will call back through
    // this function with a return mode of _crt_exit_return_to_caller, at which
    // point we will run the C termination routines.  It will then terminate the
    // process itself and not return.
    if (return_mode == _crt_exit_terminate_process && is_managed_app())
    {
        try_cor_exit_process(return_code);
    }
 
    // Run the C termination:
    bool crt_uninitialization_required = false;
 
    __acrt_lock_and_call(__acrt_select_exit_lock(), [&]
    {
        static bool c_exit_complete = false;
        if (c_exit_complete)
        {
            return;
        }
 
        _InterlockedExchange(&c_termination_complete, TRUE);
 
        __try
        {
            if (cleanup_mode == _crt_exit_full_cleanup)
            {
 
                // If this module has any dynamically initialized
                // __declspec(thread) variables, then we invoke their
                // destruction for the primary thread. All thread_local
                // destructors are sequenced before any atexit calls or static
                // object destructors (3.6.3/1)
                if (thread_local_exit_callback_func != __crt_fast_encode_pointer(nullptr))
                {
                    (__crt_fast_decode_pointer(thread_local_exit_callback_func))(nullptr, DLL_PROCESS_DETACH, nullptr);
                }
 
                _execute_onexit_table(&__acrt_atexit_table);
            }
            else if (cleanup_mode == _crt_exit_quick_cleanup)
            {
                _execute_onexit_table(&__acrt_at_quick_exit_table);
            }
        }
        __except (atexit_exception_filter(GetExceptionCode()))
        {
            terminate();
        }
        __endtry
 
        #ifndef CRTDLL
        // When the CRT is statically linked, we are responsible for executing
        // the terminators here, because the CRT code is present in this module.
        // When the CRT DLLs are used, the terminators will be executed when
        // the CRT DLLs are unloaded, after the call to ExitProcess.
        if (cleanup_mode == _crt_exit_full_cleanup)
        {
            _initterm(__xp_a, __xp_z);
        }
 
        _initterm(__xt_a, __xt_z);
        #endif // CRTDLL
 
        if (return_mode == _crt_exit_terminate_process)
        {
            c_exit_complete = true;
            crt_uninitialization_required = true;
        }
    });
 
    // Do NOT try to uninitialize the CRT while holding one of its locks.
    if (crt_uninitialization_required)
    {
        // If we are about to terminate the process, if the debug CRT is linked
        // statically into this module and this module is an EXE, we need to
        // ensure that we fully and correctly uninitialize the CRT so that the
        // debug on-exit() checks (e.g. debug heap leak detection) have a chance
        // to run.
        //
        // We do not need to uninitialize the CRT when it is statically linked
        // into a DLL because its DllMain will be called for DLL_PROCESS_DETACH
        // and we can uninitialize the CRT there.
        //
        // We never need to uninitialize the retail CRT during exit() because
        // the process is about to terminate.
        #if !CRTDLL && _DEBUG
        __scrt_uninitialize_crt(true, true);
        #endif
    }
 
    if (return_mode == _crt_exit_terminate_process)
    {
        exit_or_terminate_process(return_code);
    }
}

Referenced by _c_exit(), _cexit(), _exit(), _Exit(), exit(), and quick_exit().

exit()

void __cdecl exit

(

int const

return_code

)

Definition at line 286 of file exit.cpp.

{
    common_exit(return_code, _crt_exit_full_cleanup, _crt_exit_terminate_process);
    UNREACHABLE;
}

exit_or_terminate_process()

static void __cdecl exit_or_terminate_process ( UINT const  return_code ) throw ( )

static

Definition at line 126 of file exit.cpp.

{
    if (should_call_terminate_process())
    {
        TerminateProcess(GetCurrentProcess(), return_code);
    }
 
    try_cor_exit_process(return_code);
 
    // If that returned, then the exe for this process is not managed or we
    // failed to exit via a call to CorExitProcess.  Exit the normal way:
    ExitProcess(return_code);
}

Referenced by common_exit().

is_managed_app()

static bool __cdecl is_managed_app ( ) throw ( )

static

Definition at line 49 of file exit.cpp.

{
    PIMAGE_DOS_HEADER const dos_header = reinterpret_cast<PIMAGE_DOS_HEADER>(GetModuleHandleW(nullptr));
    if (dos_header == nullptr)
        return false;
 
    if (dos_header->e_magic != IMAGE_DOS_SIGNATURE)
        return false;
 
    PIMAGE_NT_HEADERS const pe_header = reinterpret_cast<PIMAGE_NT_HEADERS>(
        reinterpret_cast<BYTE*>(dos_header) + dos_header->e_lfanew);
 
    if (pe_header->Signature != IMAGE_NT_SIGNATURE)
        return false;
 
    if (pe_header->OptionalHeader.Magic != IMAGE_NT_OPTIONAL_HDR_MAGIC)
        return false;
 
    // prefast assumes we are overrunning __ImageBase
    #pragma warning(push)
    #pragma warning(disable: 26000)
 
    if (pe_header->OptionalHeader.NumberOfRvaAndSizes <= IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR)
        return false;
 
    #pragma warning(pop)
 
    if (pe_header->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR].VirtualAddress == 0)
        return false;
 
    return true;
}

Referenced by common_exit().

quick_exit()

void __cdecl quick_exit

(

int const

return_code

)

Definition at line 304 of file exit.cpp.

{
    common_exit(return_code, _crt_exit_quick_cleanup, _crt_exit_terminate_process);
    UNREACHABLE;
}

Referenced by test_call_quick_exit().

should_call_terminate_process()

static bool __cdecl should_call_terminate_process ( ) throw ( )

static

Definition at line 105 of file exit.cpp.

{
    if (__acrt_get_process_end_policy() == process_end_policy_exit_process)
    {
        return false;
    }
 
    // If application verifier is running, we still want to call ExitProcess,
    // to enable tools that require DLLs to be unloaded cleanly at process exit
    // to do their work.
    if (__acrt_app_verifier_enabled())
    {
        return false;
    }
 
    return true;
}

Referenced by exit_or_terminate_process().

try_cor_exit_process()

static void __cdecl try_cor_exit_process ( UINT const  return_code ) throw ( )

static

Definition at line 82 of file exit.cpp.

{
    __crt_unique_hmodule mscoree;
    if (!GetModuleHandleExW(0, L"mscoree.dll", mscoree.get_address_of()))
        return;
 
    auto const cor_exit_process = __crt_get_proc_address<exit_process_pft>(mscoree.get(), "CorExitProcess");
    if (!cor_exit_process)
        return;
 
    cor_exit_process(return_code);
}

Referenced by common_exit(), and exit_or_terminate_process().

Variable Documentation

__acrt_at_quick_exit_table

_onexit_table_t __acrt_at_quick_exit_table

Definition at line 15 of file exit.cpp.

Referenced by common_exit().

__acrt_atexit_table

_onexit_table_t __acrt_atexit_table

Definition at line 14 of file exit.cpp.

Referenced by common_exit().

c_termination_complete

long c_termination_complete = FALSE

static

Definition at line 12 of file exit.cpp.

Referenced by _is_c_termination_complete(), and common_exit().

thread_local_exit_callback_func

_tls_callback_type thread_local_exit_callback_func

static

Definition at line 21 of file exit.cpp.

Referenced by __acrt_initialize_thread_local_exit_callback(), _register_thread_local_exe_atexit_callback(), and common_exit().