osfinfo.cpp File Reference

#include <corecrt_internal_lowio.h>

Include dependency graph for osfinfo.cpp:

Go to the source code of this file.

Functions
__crt_lowio_handle_data *__cdecl	__acrt_lowio_create_handle_array ()
void __cdecl	__acrt_lowio_destroy_handle_array (__crt_lowio_handle_data *const array)
errno_t __cdecl	__acrt_lowio_ensure_fh_exists (int const fh)
int __cdecl	_alloc_osfhnd ()
int __cdecl	__acrt_lowio_set_os_handle (int const fh, intptr_t const value)
int __cdecl	_free_osfhnd (int const fh)
intptr_t __cdecl	_get_osfhandle (int const fh)
int __cdecl	_open_osfhandle (intptr_t const osfhandle, int const source_flags)
void __cdecl	__acrt_lowio_lock_fh (int const fh)
void __cdecl	__acrt_lowio_unlock_fh (int const fh)

Function Documentation

__acrt_lowio_create_handle_array()

__crt_lowio_handle_data *__cdecl __acrt_lowio_create_handle_array

(

)

Definition at line 13 of file osfinfo.cpp.

{
    __crt_unique_heap_ptr<__crt_lowio_handle_data> array(_calloc_crt_t(
        __crt_lowio_handle_data,
        IOINFO_ARRAY_ELTS));
 
    if (!array)
        return nullptr;
 
    __crt_lowio_handle_data* const first = array.get();
    __crt_lowio_handle_data* const last  = first + IOINFO_ARRAY_ELTS;
    for (auto it = first; it != last; ++it)
    {
        __acrt_InitializeCriticalSectionEx(&it->lock, _CORECRT_SPINCOUNT, 0);
        it->osfhnd             = reinterpret_cast<intptr_t>(INVALID_HANDLE_VALUE);
        it->startpos           = 0;
        it->osfile             = 0;
        it->textmode           = __crt_lowio_text_mode::ansi;
        it->_pipe_lookahead[0] = LF;
        it->_pipe_lookahead[1] = LF;
        it->_pipe_lookahead[2] = LF;
        it->unicode            = false;
        it->utf8translations   = false;
        it->dbcsBufferUsed     = false;
        for (int i = 0; i < sizeof(it->mbBuffer); ++i)
        {
            it->mbBuffer[i] = '\0';
        }
    }
 
    return array.detach();
}

Referenced by __acrt_lowio_ensure_fh_exists(), and _alloc_osfhnd().

__acrt_lowio_destroy_handle_array()

void __cdecl __acrt_lowio_destroy_handle_array

(

__crt_lowio_handle_data *const

array

)

Definition at line 46 of file osfinfo.cpp.

{
    if (!array)
        return;
 
    __crt_lowio_handle_data* const first = array;
    __crt_lowio_handle_data* const last  = first + IOINFO_ARRAY_ELTS;
    for (auto it = first; it != last; ++it)
    {
        DeleteCriticalSection(&it->lock);
    }
 
    _free_crt(array);
}

__acrt_lowio_ensure_fh_exists()

errno_t __cdecl __acrt_lowio_ensure_fh_exists

(

int const

fh

)

Definition at line 66 of file osfinfo.cpp.

{
    _VALIDATE_RETURN_ERRCODE(static_cast<unsigned>(fh) < _NHANDLE_, EBADF);
 
    errno_t status = 0;
 
    __acrt_lock(__acrt_lowio_index_lock);
    __try
    {
        for (size_t i = 0; fh >= _nhandle; ++i)
        {
            if (__pioinfo[i])
            {
                continue;
            }
 
            __pioinfo[i] = __acrt_lowio_create_handle_array();
            if (!__pioinfo[i])
            {
                status = ENOMEM;
                __leave;
            }
 
            _nhandle += IOINFO_ARRAY_ELTS;
        }
    }
    __finally
    {
        __acrt_unlock(__acrt_lowio_index_lock);
    }
    __endtry
 
    return status;
}

__acrt_lowio_lock_fh()

void __cdecl __acrt_lowio_lock_fh

(

int const

fh

)

Definition at line 340 of file osfinfo.cpp.

{
    EnterCriticalSection(&_pioinfo(fh)->lock);
}

Referenced by _alloc_osfhnd().

__acrt_lowio_set_os_handle()

int __cdecl __acrt_lowio_set_os_handle	(	int const	fh,
		intptr_t const	value
	)

Definition at line 195 of file osfinfo.cpp.

{
    if (fh >= 0 &&
        static_cast<unsigned>(fh) < static_cast<unsigned>(_nhandle) &&
        _osfhnd(fh) == reinterpret_cast<intptr_t>(INVALID_HANDLE_VALUE))
    {
        if (_query_app_type() == _crt_console_app)
        {
            HANDLE const handle_value = reinterpret_cast<HANDLE>(value);
            switch (fh)
            {
            case 0: SetStdHandle(STD_INPUT_HANDLE,  handle_value); break;
            case 1: SetStdHandle(STD_OUTPUT_HANDLE, handle_value); break;
            case 2: SetStdHandle(STD_ERROR_HANDLE,  handle_value); break;
            }
        }
 
        _osfhnd(fh) = value;
        return 0 ;
    }
    else
    {
        errno = EBADF; // Bad handle
        _doserrno = 0; // This is not an OS error
        return -1;
    }
}

Referenced by _dup2_nolock_internal(), _open_osfhandle(), _pipe(), _wsopen_nolock(), and duplicate_osfhnd().

__acrt_lowio_unlock_fh()

void __cdecl __acrt_lowio_unlock_fh

(

int const

fh

)

Definition at line 348 of file osfinfo.cpp.

{
    LeaveCriticalSection(&_pioinfo(fh)->lock);
}

Referenced by _open_osfhandle().

_alloc_osfhnd()

int __cdecl _alloc_osfhnd

(

void

)

Definition at line 116 of file osfinfo.cpp.

{
    __acrt_lock(__acrt_lowio_index_lock);
    int result = -1;
    __try
    {
        // Search the arrays of file objects, in order, looking for the first
        // free entry.  The compound index of this free entry is the return
        // value.
        //
        // The compound index of the file object entry *(__pioinfo[i] + j) is
        // k = i * IOINFO_ARRAY_ELTS + j.
        for (int i = 0; i < IOINFO_ARRAYS; ++i)
        {
            // If this __crt_lowio_handle_data array does not yet exist, create a new one:
            if (!__pioinfo[i])
            {
                __pioinfo[i] = __acrt_lowio_create_handle_array();
                if (!__pioinfo[i])
                    __leave;
 
                _nhandle += IOINFO_ARRAY_ELTS;
 
                // The first element of the newly allocated array of handle data
                // objects is our first free entry.  Note that since we hold the
                // index lock, no one else can allocate this handle.
                int const fh = i * IOINFO_ARRAY_ELTS;
 
                __acrt_lowio_lock_fh(fh);
                _osfile(fh) = FOPEN;
                result = fh;
                __leave;
            }
 
            // Otherwise, this file object array already exists.  Search it looking
            // for the first free entry:
            __crt_lowio_handle_data* const first = __pioinfo[i];
            __crt_lowio_handle_data* const last  = first + IOINFO_ARRAY_ELTS;
            for (__crt_lowio_handle_data* pio = first; pio != last; ++pio)
            {
                if (pio->osfile & FOPEN)
                    continue;
 
                // Another thread may have grabbed this file handle out from
                // under us while we waited for the lock.  If so, continue on
                // searching through the array.
                //
                // CRT_REFACTOR TODO:  Resolve lowio synchronization issues.
                EnterCriticalSection(&pio->lock);
                if ((pio->osfile & FOPEN) != 0)
                {
                    LeaveCriticalSection(&pio->lock);
                    continue;
                }
 
                // Otherwise, this entry is ours:  we hold the lock, so we can
                // initialize it and return its handle:
                int const fh = i * IOINFO_ARRAY_ELTS + static_cast<int>(pio - first);
                _osfile(fh) = FOPEN;
                _osfhnd(fh) = reinterpret_cast<intptr_t>(INVALID_HANDLE_VALUE);
                result = fh;
                __leave;
            }
        }
 
        // All entries are in use if we fall out of the loop.  return -1 in this case (which result is already set to)
    }
    __finally
    {
        __acrt_unlock(__acrt_lowio_index_lock);
    }
    __endtry
    return result;
}

Referenced by _dup_nolock_internal(), _open_osfhandle(), _pipe(), and _wsopen_nolock().

_free_osfhnd()

int __cdecl _free_osfhnd

(

int const

fh

)

Definition at line 227 of file osfinfo.cpp.

{
    if (fh >= 0 &&
        static_cast<unsigned>(fh) < static_cast<unsigned>(_nhandle) &&
        (_osfile(fh) & FOPEN) &&
        _osfhnd(fh) != reinterpret_cast<intptr_t>(INVALID_HANDLE_VALUE))
    {
        if (_query_app_type() == _crt_console_app)
        {
            switch (fh)
            {
            case 0: SetStdHandle(STD_INPUT_HANDLE,  nullptr); break;
            case 1: SetStdHandle(STD_OUTPUT_HANDLE, nullptr); break;
            case 2: SetStdHandle(STD_ERROR_HANDLE,  nullptr); break;
            }
        }
 
        _osfhnd(fh) = reinterpret_cast<intptr_t>(INVALID_HANDLE_VALUE);
        return 0;
    }
    else
    {
        errno = EBADF; // Bad handle
        _doserrno = 0; // This is not an OS error
        return -1;
    }
}

Referenced by _close_nolock_internal(), and _wsopen_nolock().

_get_osfhandle()

intptr_t __cdecl _get_osfhandle

(

int const

fh

)

Definition at line 259 of file osfinfo.cpp.

{
    _CHECK_FH_CLEAR_OSSERR_RETURN(fh, EBADF, -1 );
    _VALIDATE_CLEAR_OSSERR_RETURN(fh >= 0 && (unsigned)fh < (unsigned)_nhandle, EBADF, -1);
    _VALIDATE_CLEAR_OSSERR_RETURN(_osfile(fh) & FOPEN, EBADF, -1);
 
    return _osfhnd(fh);
}

_open_osfhandle()

int __cdecl _open_osfhandle	(	intptr_t const	osfhandle,
		int const	source_flags
	)

Definition at line 273 of file osfinfo.cpp.

{
    // Copy relevant source_flags from second parameter
    unsigned char file_flags = 0;
 
    if (source_flags & _O_APPEND)
        file_flags |= FAPPEND;
 
    if (source_flags & _O_TEXT)
        file_flags |= FTEXT;
 
    if (source_flags & _O_NOINHERIT)
        file_flags |= FNOINHERIT;
 
    // Find out what type of file (file/device/pipe):
    DWORD const file_type = GetFileType(reinterpret_cast<HANDLE>(osfhandle));
    if (file_type == FILE_TYPE_UNKNOWN)
    {
        __acrt_errno_map_os_error(GetLastError());
        return -1;
    }
 
    if (file_type == FILE_TYPE_CHAR)
        file_flags |= FDEV;
 
    else if (file_type == FILE_TYPE_PIPE)
        file_flags |= FPIPE;
 
    // Attempt to allocate a CRT file handle:
    int const fh = _alloc_osfhnd();
    if (fh == -1)
    {
        errno = EMFILE; // Too many open files
        _doserrno = 0L; // This is not an OS error
        return -1;
    }
 
    bool success = false;
    __try
    {
        // The file is open. now set the info in _osfhnd array:
        __acrt_lowio_set_os_handle(fh, osfhandle);
 
        file_flags |= FOPEN;
 
        _osfile(fh) = file_flags;
        _textmode(fh) = __crt_lowio_text_mode::ansi;
        _tm_unicode(fh) = false;
 
        success = true;
    }
    __finally
    {
        if (!success)
        {
            _osfile(fh) &= ~FOPEN;
        }
 
        __acrt_lowio_unlock_fh(fh);
    }
    __endtry
    return fh;
}