Force write of a file to disk

Question

I\'m currently implementing a ping/pong buffering scheme to safely write a file to disk. I\'m using C++/Boost on a Linux/CentOS machine. Now I\'m facing the problem to force

Answer 1

fflush (for FILE*), std::flush (for IOStream) to force your program to send to the OS.

POSIX has

• sync(2) to ask to schedule writing its buffers, but can return before the writing is done (Linux is waiting that the data is send to the hardware before returning).

• fsync(2) which is guaranteed to wait for the data to be send to the hardware, but needs a file descriptor (you can get one from a FILE* with fileno(3), I know of no standard way to get one from an IOStream).

• O_SYNC as a flag to open(2).

In all cases, the hardware may have it's own buffers (but if it has control on it, a good implementation will try to flush them also and ISTR that some disks are using capacitors so that they are able to flush whatever happens to the power) and network file systems have their own caveat.

Answer 2

You can use fsync()/fdatasync() to force(Note 1) the data onto the storage. Those requres a file descriptor, as given by e.g. open(). The linux manpage have more linux specific info, particularly on the difference of fsync and fdatasync.

If you don't use file desciptors directly, many abstractions will contain internal buffers residing in your process.

e.g. if you use a FILE*, you first have to flush the data out of your application.

//... open and write data to a FILE *myfile
fflush(myfile);
fsync(fileno(myfile));

• Note 1: These calls force the OS to ensure that any data in any OS cache is written to the drive, and the drive acknowledges that fact. Many hard-drives lie to the OS about this, and might stuff the data in cache memory on the drive.

Answer 3

Not in standard C++. You'll have to use some sort of system specific IO, like open with the O_SYNC flag under Unix, and then write.

Note that this is partially implicit by the fact that ostream (and in C, FILE*) are buffered. If you don't know exactly when something is written to disk, then it doesn't make much sense to insist on the transactional integrity of the write. (It wouldn't be too hard to design a streambuf which only writes when you do an explicit flush, however.)

EDIT:

As a simple example:

class SynchronizedStreambuf : public std::streambuf
{
    int myFd;
    std::vector<char> myBuffer;

protected:
    virtual int overflow( int ch );
    virtual int sync();

public:
    SynchronizedStreambuf( std::string const& filename );
    ~SynchronizedStreambuf();
};

int SynchronizedStreambuf::overflow( int ch )
{
    if ( myFd == -1 ) {
        return traits_type::eof();
    } else if ( ch == traits_type::eof() ) {
        return sync() == -1 ? traits_type::eof() : 0;
    } else {
        myBuffer.push_back( ch );
        size_t nextPos = myBuffer.size();
        myBuffer.resize( 1000 );
        setp( &myBuffer[0] + nextPos, &myBuffer[0] + myBuffer.size() );
        return ch;
    }
}

int SynchronizedStreambuf::sync()
{
    size_t toWrite = pptr() - &myBuffer[0];
    int result = (toWrite == 0 || write( myFd, &myBuffer[0], toWrite ) == toWrite ? 0 : -1);
    if ( result == -1 ) {
        close( myFd );
        setp( NULL, NULL );
        myFd = -1;
    } else {
        setp( &myBuffer[0], &myBuffer[0] + myBuffer.size() );
    }
    return result;
}

SynchronizedStreambuf::SynchronizedStreambuf( std::string const& filename )
    : myFd( open( filename.c_str(), O_WRONLY | O_CREAT | O_SYNC, 0664 ) )
{
}

SynchronizedStreambuf::~SynchronizedStreambuf()
{
    sync();
    close( myFd );
}

(This has only been superficially tested, but the basic idea is there.)