fflush.cpp File Reference

#include <corecrt_internal_stdio.h>
#include <corecrt_internal_ptd_propagation.h>

Include dependency graph for fflush.cpp:

Go to the source code of this file.

Functions
static bool __cdecl	is_stream_allocated (long const stream_flags) throw ()
static bool __cdecl	is_stream_flushable (long const stream_flags) throw ()
static bool __cdecl	is_stream_flushable_or_commitable (long const stream_flags) throw ()
static bool __cdecl	common_flush_all_should_try_to_flush_stream (_In_ __crt_stdio_stream const stream, _Inout_ int *const flushed_stream_count) throw ()
static int __cdecl	common_flush_all (bool const flush_read_mode_streams) throw ()
int __cdecl	fflush (FILE *const public_stream)
static int __cdecl	_fflush_nolock_internal (FILE *const public_stream, __crt_cached_ptd_host &ptd)
int __cdecl	_fflush_nolock (FILE *const public_stream)
int __cdecl	__acrt_stdio_flush_nolock (FILE *const public_stream, __crt_cached_ptd_host &ptd)
int __cdecl	_flushall ()

Function Documentation

__acrt_stdio_flush_nolock()

int __cdecl __acrt_stdio_flush_nolock	(	FILE *const	public_stream,
		__crt_cached_ptd_host &	ptd
	)

Definition at line 222 of file fflush.cpp.

{
    __crt_stdio_stream const stream(public_stream);
 
    if (!is_stream_flushable(stream.get_flags()))
    {
        return 0;
    }
 
    int const bytes_to_write = static_cast<int>(stream->_ptr - stream->_base);
 
    __acrt_stdio_reset_buffer(stream);
 
    if (bytes_to_write <= 0)
    {
        return 0;
    }
 
    int const bytes_written = _write_internal(_fileno(stream.public_stream()), stream->_base, bytes_to_write, ptd);
    if (bytes_to_write != bytes_written)
    {
        stream.set_flags(_IOERROR);
        return EOF;
    }
 
    // If this is a read/write file, clear _IOWRITE so that the next operation can
    // be a read:
    if (stream.has_all_of(_IOUPDATE))
    {
        stream.unset_flags(_IOWRITE);
    }
 
    return 0;
}

Referenced by __acrt_stdio_end_temporary_buffering_nolock(), __DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_0(), _fclose_nolock_internal(), _fflush_nolock_internal(), _fwrite_nolock_internal(), _rewind_internal(), and common_fseek_nolock().

_fflush_nolock()

int __cdecl _fflush_nolock

(

FILE *const

public_stream

)

Definition at line 213 of file fflush.cpp.

{
    __crt_cached_ptd_host ptd;
    return _fflush_nolock_internal(public_stream, ptd);
}

Referenced by common_flush_all().

_fflush_nolock_internal()

static int __cdecl _fflush_nolock_internal ( FILE *const  public_stream, __crt_cached_ptd_host &  ptd  )

static

Definition at line 185 of file fflush.cpp.

{
    __crt_stdio_stream const stream(public_stream);
 
    // If the stream is null, flush all the streams.
    if (!stream.valid())
    {
        return common_flush_all(false);
    }
 
    if (__acrt_stdio_flush_nolock(stream.public_stream(), ptd) != 0)
    {
        // If the flush fails, do not attempt to commit:
        return EOF;
    }
 
    // Perform the lowio commit to ensure data is written to disk:
    if (stream.has_all_of(_IOCOMMIT))
    {
        if (_commit(_fileno(public_stream)))
        {
            return EOF;
        }
    }
 
    return 0;
}

Referenced by _fflush_nolock().

_flushall()

int __cdecl _flushall

(

void

)

Definition at line 261 of file fflush.cpp.

{
    return common_flush_all(true);
}

Referenced by __acrt_uninitialize(), __acrt_uninitialize_stdio(), msvcrt_free_io(), test_fflush(), and wmain().

common_flush_all()

static int __cdecl common_flush_all ( bool const  flush_read_mode_streams ) throw ( )

static

Definition at line 101 of file fflush.cpp.

{
    int count = 0;
    int error = 0;
 
    __acrt_lock_and_call(__acrt_stdio_index_lock, [&]
    {
        __crt_stdio_stream_data** const first_file = __piob;
        __crt_stdio_stream_data** const last_file  = first_file + _nstream;
 
        for (__crt_stdio_stream_data** it = first_file; it != last_file; ++it)
        {
            __crt_stdio_stream const stream(*it);
 
            // Before we acquire the stream lock, check to see if flushing the
            // stream would be a no-op.  If it would be, then skip this stream.
            if (!common_flush_all_should_try_to_flush_stream(stream, &count))
            {
                continue;
            }
 
            __acrt_lock_stream_and_call(stream.public_stream(), [&]
            {
                // Re-verify the state of the stream.  Another thread may have
                // closed the stream, reopened it into a different mode, or
                // otherwise altered the state of the stream such that this
                // flush would be a no-op.
                if (!common_flush_all_should_try_to_flush_stream(stream, &count))
                {
                    return;
                }
 
                if (!flush_read_mode_streams && !stream.has_all_of(_IOWRITE))
                {
                    return;
                }
 
                if (_fflush_nolock(stream.public_stream()) != EOF)
                {
                    ++count;
                }
                else
                {
                    error = EOF;
                }
            });
        }
    });
 
    return flush_read_mode_streams ? count : error;
}

Referenced by _fflush_nolock_internal(), _flushall(), and fflush().

common_flush_all_should_try_to_flush_stream()

static bool __cdecl common_flush_all_should_try_to_flush_stream ( _In_ __crt_stdio_stream const  stream, _Inout_ int *const  flushed_stream_count  ) throw ( )

static

Definition at line 56 of file fflush.cpp.

{
    if (!stream.valid())
    {
        return false;
    }
 
    long const stream_flags = stream.get_flags();
    if (!is_stream_allocated(stream_flags))
    {
        return false;
    }
 
    if (!is_stream_flushable_or_commitable(stream_flags))
    {
        ++*flushed_stream_count;
        return false;
    }
 
    return true;
}

Referenced by common_flush_all().

fflush()

int __cdecl fflush

(

FILE *const

public_stream

)

Definition at line 158 of file fflush.cpp.

{
    __crt_stdio_stream const stream(public_stream);
 
    // If the stream is null, flush all the streams:
    if (!stream.valid())
    {
        return common_flush_all(false);
    }
 
    // Before acquiring the stream lock, inspect the stream to see if the flush
    // is a no-op.  If it will be a no-op then we can return without attempting
    // to acquire the lock (this can help prevent locking conflicts; see the
    // common_flush_all implementation for more information).
    if (!is_stream_flushable_or_commitable(stream.get_flags()))
    {
        return 0;
    }
 
    return __acrt_lock_stream_and_call(stream.public_stream(), [&]
    {
        return _fflush_nolock(stream.public_stream());
    });
}

is_stream_allocated()

static bool __cdecl is_stream_allocated ( long const  stream_flags ) throw ( )

static

Definition at line 13 of file fflush.cpp.

{
    return (stream_flags & _IOALLOCATED) != 0;
}

Referenced by common_flush_all_should_try_to_flush_stream().

is_stream_flushable()

static bool __cdecl is_stream_flushable ( long const  stream_flags ) throw ( )

static

Definition at line 18 of file fflush.cpp.

{
    if ((stream_flags & (_IOREAD | _IOWRITE)) != _IOWRITE)
    {
        return false;
    }
 
    if ((stream_flags & (_IOBUFFER_CRT | _IOBUFFER_USER)) == 0)
    {
        return false;
    }
 
    return true;
}

Referenced by __acrt_stdio_flush_nolock(), and is_stream_flushable_or_commitable().

is_stream_flushable_or_commitable()

static bool __cdecl is_stream_flushable_or_commitable ( long const  stream_flags ) throw ( )

static

Definition at line 33 of file fflush.cpp.

{
    if (is_stream_flushable(stream_flags))
    {
        return true;
    }
 
    if (stream_flags & _IOCOMMIT)
    {
        return true;
    }
 
    return false;
}

Referenced by common_flush_all_should_try_to_flush_stream(), and fflush().