Use share flags for all file operations on Windows

Some file operations provided by the Erlang file module
didn't open the target file with all the file share flags.
This made some concurrent file operations against the
same file fail on Windows, while on other platforms such
as GNU/Linux or Mac OS X they succeed. The operations will
fail only if they're performed concurrently by different
threads (async IO threads or scheduler threads).

For example, one Erlang process does a file:delete/1 call
while another Erlang process is doing a filelib:file_size/1
call. This made the former process get an eacces error from
the file:delete/1 call. On GNU/Linux or Mac OS X the call would
succeed. Another example is if one Erlang process attempts to
open a file for reading while another one is in the middle of
a file:read_file_info/1 call (after it opened the file and
before it closed the file).

It's easy to verify that if a file is not open with all the
share flags, it's impossible for other threads (even if they
belong to the same OS process) to open the file while the
file is not closed by the first thread.
The following test program shows this:

 #include <windows.h>
 #include <iostream>

// Must be an existing file
//#define SHARE_FLAGS (FILE_SHARE_READ)

static DWORD WINAPI MyThreadFunction(LPVOID lpParam);
static char *lastError();

int main(int argc, char *argv[])
{
    DWORD   threadId;
    HANDLE  threadHandle, hFile;

    hFile = CreateFile(FILENAME, GENERIC_READ, SHARE_FLAGS, NULL,
                       OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
    if (hFile == INVALID_HANDLE_VALUE) {
        std::cerr << "File open error from main: " <<
		lastError() << std::endl;
        return 1;
    }
    std::cout << "Main thread opened file successfully" << std::endl;

    threadHandle = CreateThread(NULL, 0, MyThreadFunction, NULL, 0, &threadId);
    if (threadHandle == INVALID_HANDLE_VALUE) {
        std::cerr << "Thread create error from main: " <<
		lastError() << std::endl;
        return 1;
    }
    WaitForSingleObject(threadHandle, INFINITE);
    CloseHandle(threadHandle);
    CloseHandle(hFile);
    return 0;
}

static DWORD WINAPI MyThreadFunction( LPVOID lpParam )
{
    HANDLE hFile;

    hFile = CreateFile(FILENAME, GENERIC_READ, SHARE_FLAGS, NULL,
                       OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
    if (hFile == INVALID_HANDLE_VALUE) {
        std::cerr << "File open error from second thread: " <<
		lastError() << std::endl;
        return 1;
    }
    std::cout << "Second thread opened file successfully" << std::endl;
    CloseHandle(hFile);
    return 0;
}

static char *lastError()
{
    static char *buf = NULL;
    DWORD dw = GetLastError();

    if (buf != NULL) {
        LocalFree((LPTSTR) &buf);
    }
    FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM |
                  FORMAT_MESSAGE_IGNORE_INSERTS,
                  NULL, dw, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
                  (LPTSTR) &buf, 0, NULL);
    return buf;
}

Rnning this program with SHARE_FLAGS set to 0 (as efile_fileinfo()
does for e.g.), shows that the second thread is unable to open the
file:

    C:\cygwin\home\fdmanana\tmp>touch foo.bar
    C:\cygwin\home\fdmanana\tmp>threads_fopen_test.exe
    Main thread opened file successfully
    File open error from second thread: The process cannot access the
    file because it is being used by another process.

Changing the program's SHARE_FLAGS to FILE_SHARE_READ, shows that
both threads are able to open the file:

    C:\cygwin\home\fdmanana\tmp>touch foo.bar
    C:\cygwin\home\fdmanana\tmp>threads_test.exe
    Main thread opened file successfully
    Second thread opened file successfully

Same logic applies to opening files for writing or deleting and
renaming files while they're open by some other thread that didn't
specify the flags FILE_SHARE_WRITE and FILE_SHARE_DELETE.

0 files changed, 0 insertions, 0 deletions