file_win32_helpers Namespace Reference

Data Structures
struct	createFileData_t

Typedefs
typedef BOOL(WINAPI *	pCancelSynchronousIo_t) (HANDLE hThread)

Functions
HANDLE	createFile (LPCTSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode, LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes, HANDLE hTemplateFile, abort_callback &abort)
static unsigned CALLBACK	createFileProc (void *data)
void	fillOverlapped (OVERLAPPED &ol, HANDLE myEvent, t_filesize s)
t_filesize	get_size (HANDLE p_handle)
size_t	readOverlapped (HANDLE handle, HANDLE myEvent, t_filesize &position, void *out, size_t outBytes, abort_callback &abort)
DWORD	readOverlappedPass (HANDLE handle, HANDLE myEvent, t_filesize position, void *out, DWORD outBytes, abort_callback &abort)
size_t	readStreamOverlapped (HANDLE handle, HANDLE myEvent, void *out, size_t outBytes, abort_callback &abort)
void	seek (HANDLE p_handle, t_sfilesize p_position, file::t_seek_mode p_mode)
void	writeOverlapped (HANDLE handle, HANDLE myEvent, t_filesize &position, const void *in, size_t inBytes, abort_callback &abort)
void	writeOverlappedPass (HANDLE handle, HANDLE myEvent, t_filesize position, const void *in, DWORD inBytes, abort_callback &abort)
void	writeStreamOverlapped (HANDLE handle, HANDLE myEvent, const void *in, size_t inBytes, abort_callback &abort)

---

Data Structure Documentation

struct file_win32_helpers::createFileData_t

Definition at line 169 of file file_win32_wrapper.cpp.

Data Fields
DWORD	dwCreationDisposition
DWORD	dwDesiredAccess
DWORD	dwErrorCode
DWORD	dwFlagsAndAttributes
DWORD	dwShareMode
HANDLE	hResult
HANDLE	hTemplateFile
LPCTSTR	lpFileName
LPSECURITY_ATTRIBUTES	lpSecurityAttributes

Typedef Documentation

typedef BOOL(WINAPI * file_win32_helpers::pCancelSynchronousIo_t) (HANDLE hThread)

Definition at line 166 of file file_win32_wrapper.cpp.

Function Documentation

HANDLE file_win32_helpers::createFile	(	LPCTSTR	lpFileName,
		DWORD	dwDesiredAccess,
		DWORD	dwShareMode,
		LPSECURITY_ATTRIBUTES	lpSecurityAttributes,
		DWORD	dwCreationDisposition,
		DWORD	dwFlagsAndAttributes,
		HANDLE	hTemplateFile,
		abort_callback &	abort
	)

Definition at line 189 of file file_win32_wrapper.cpp.

                                                                                                                                                                                                                                       {
        abort.check();
        
        return CreateFile(lpFileName, dwDesiredAccess, dwShareMode, lpSecurityAttributes, dwCreationDisposition, dwFlagsAndAttributes, hTemplateFile);

        // CancelSynchronousIo() doesn't fucking work. Useless.
#if 0
        pCancelSynchronousIo_t pCancelSynchronousIo = (pCancelSynchronousIo_t) GetProcAddress(GetModuleHandle(TEXT("kernel32.dll")), "CancelSynchronousIo");
        if (pCancelSynchronousIo == NULL) {
#ifdef _DEBUG
            uDebugLog() << "Async CreateFile unavailable - using regular";
#endif
            return CreateFile(lpFileName, dwDesiredAccess, dwShareMode, lpSecurityAttributes, dwCreationDisposition, dwFlagsAndAttributes, hTemplateFile);
        } else {
#ifdef _DEBUG
            uDebugLog() << "Starting async CreateFile...";
            pfc::hires_timer t; t.start();
#endif
            createFileData_t data = {lpFileName, dwDesiredAccess, dwShareMode, lpSecurityAttributes, dwCreationDisposition, dwFlagsAndAttributes, hTemplateFile, NULL, 0};
            HANDLE hThread = (HANDLE) _beginthreadex(NULL, 0, createFileProc, &data, 0, NULL);
            HANDLE waitHandles[2] = {hThread, abort.get_abort_event()};
            switch(WaitForMultipleObjects(2, waitHandles, FALSE, INFINITE)) {
            case WAIT_OBJECT_0: // succeeded
                break;
            case WAIT_OBJECT_0 + 1: // abort
#ifdef _DEBUG
                uDebugLog() << "Aborting async CreateFile...";
#endif
                pCancelSynchronousIo(hThread);
                WaitForSingleObject(hThread, INFINITE);
                break;
            default:
                uBugCheck();
            }
            CloseHandle(hThread);
            SetLastError(data.dwErrorCode);
#ifdef _DEBUG
            uDebugLog() << "Async CreateFile completed in " << pfc::format_time_ex(t.query(), 6) << ", status: " << (uint32_t) data.dwErrorCode;
#endif
            if (abort.is_aborting()) {
                if (data.hResult != INVALID_HANDLE_VALUE) CloseHandle(data.hResult);
                throw exception_aborted();
            }
            return data.hResult;
        }
#endif
    }

static unsigned CALLBACK file_win32_helpers::createFileProc ( void *  data )

static

Definition at line 181 of file file_win32_wrapper.cpp.

                                                         {
        createFileData_t * cfd = (createFileData_t*)data;
        SetLastError(0);
        cfd->hResult = CreateFile(cfd->lpFileName, cfd->dwDesiredAccess, cfd->dwShareMode, cfd->lpSecurityAttributes, cfd->dwCreationDisposition, cfd->dwFlagsAndAttributes, cfd->hTemplateFile);
        cfd->dwErrorCode = GetLastError();
        return 0;
    }

void file_win32_helpers::fillOverlapped	(	OVERLAPPED &	ol,
		HANDLE	myEvent,
		t_filesize	s
	)

Definition at line 32 of file file_win32_wrapper.cpp.

                                                                       {
        ol.hEvent = myEvent;
        ol.Offset = (DWORD)( s & 0xFFFFFFFF );
        ol.OffsetHigh = (DWORD)(s >> 32);
    }

t_filesize file_win32_helpers::get_size

(

HANDLE

p_handle

)

Definition at line 5 of file file_win32_wrapper.cpp.

                                         {
        union {
            t_uint64 val64;
            t_uint32 val32[2];
        } u;

        u.val64 = 0;
        SetLastError(NO_ERROR);
        u.val32[0] = GetFileSize(p_handle,reinterpret_cast<DWORD*>(&u.val32[1]));
        if (GetLastError()!=NO_ERROR) exception_io_from_win32(GetLastError());
        return u.val64;
    }

size_t file_win32_helpers::readOverlapped	(	HANDLE	handle,
		HANDLE	myEvent,
		t_filesize &	position,
		void *	out,
		size_t	outBytes,
		abort_callback &	abort
	)

Definition at line 139 of file file_win32_wrapper.cpp.

                                                                                                                                     {
        const enum {readMAX = 16*1024*1024};
        size_t done = 0;
        while(done < outBytes) {
            size_t delta = outBytes - done;
            if (delta > readMAX) delta = readMAX;
            delta = readOverlappedPass(handle, myEvent, position, (BYTE*) out + done, (DWORD) delta, abort);
            if (delta == 0) break;
            done += delta;
            position += delta;
        }
        return done;
    }

DWORD file_win32_helpers::readOverlappedPass	(	HANDLE	handle,
		HANDLE	myEvent,
		t_filesize	position,
		void *	out,
		DWORD	outBytes,
		abort_callback &	abort
	)

Definition at line 95 of file file_win32_wrapper.cpp.

                                                                                                                                     {
        abort.check();
        if (outBytes == 0) return 0;
        OVERLAPPED ol = {};
        fillOverlapped(ol, myEvent, position);
        ResetEvent(myEvent);
        DWORD bytesDone;
        SetLastError(NO_ERROR);
        if (ReadFile( handle, out, outBytes, &bytesDone, &ol)) {
            // succeeded already?
            return bytesDone;
        }

        {
            const DWORD code = GetLastError();
            switch(code) {
            case ERROR_HANDLE_EOF:
            case ERROR_BROKEN_PIPE:
                return 0;
            case ERROR_IO_PENDING:
                break; // continue
            default:
                exception_io_from_win32(code);
            };
        }

        const HANDLE handles[] = {myEvent, abort.get_abort_event()};
        SetLastError(NO_ERROR);
        DWORD state = WaitForMultipleObjects(_countof(handles), handles, FALSE, INFINITE);
        if (state == WAIT_OBJECT_0) {
            SetLastError(NO_ERROR);
            if (!GetOverlappedResult(handle,&ol,&bytesDone,TRUE)) {
                const DWORD code = GetLastError();
                if (code == ERROR_HANDLE_EOF || code == ERROR_BROKEN_PIPE) bytesDone = 0;
                else {
                    CancelIo(handle);
                    exception_io_from_win32(code);
                }
            }
            return bytesDone;
        }
        CancelIo(handle);
        throw exception_aborted();
    }

size_t file_win32_helpers::readStreamOverlapped	(	HANDLE	handle,
		HANDLE	myEvent,
		void *	out,
		size_t	outBytes,
		abort_callback &	abort
	)

Definition at line 153 of file file_win32_wrapper.cpp.

                                                                                                                    {
        const enum {readMAX = 16*1024*1024};
        size_t done = 0;
        while(done < outBytes) {
            size_t delta = outBytes - done;
            if (delta > readMAX) delta = readMAX;
            delta = readOverlappedPass(handle, myEvent, 0, (BYTE*) out + done, (DWORD) delta, abort);
            if (delta == 0) break;
            done += delta;
        }
        return done;
    }

void file_win32_helpers::seek	(	HANDLE	p_handle,
		t_sfilesize	p_position,
		file::t_seek_mode	p_mode
	)

Definition at line 17 of file file_win32_wrapper.cpp.

                                                                             {
        union  {
            t_int64 temp64;
            struct {
                DWORD temp_lo;
                LONG temp_hi;
            };
        };

        temp64 = p_position;
        SetLastError(ERROR_SUCCESS);        
        temp_lo = SetFilePointer(p_handle,temp_lo,&temp_hi,(DWORD)p_mode);
        if (GetLastError() != ERROR_SUCCESS) exception_io_from_win32(GetLastError());
    }

void file_win32_helpers::writeOverlapped	(	HANDLE	handle,
		HANDLE	myEvent,
		t_filesize &	position,
		const void *	in,
		size_t	inBytes,
		abort_callback &	abort
	)

Definition at line 73 of file file_win32_wrapper.cpp.

                                                                                                                                        {
        const enum {writeMAX = 16*1024*1024};
        size_t done = 0;
        while(done < inBytes) {
            size_t delta = inBytes - done;
            if (delta > writeMAX) delta = writeMAX;
            writeOverlappedPass(handle, myEvent, position, (const BYTE*)in + done, (DWORD) delta, abort);
            done += delta;
            position += delta;
        }
    }

void file_win32_helpers::writeOverlappedPass	(	HANDLE	handle,
		HANDLE	myEvent,
		t_filesize	position,
		const void *	in,
		DWORD	inBytes,
		abort_callback &	abort
	)

Definition at line 38 of file file_win32_wrapper.cpp.

                                                                                                                                        {
        abort.check();
        if (inBytes == 0) return;
        OVERLAPPED ol = {};
        fillOverlapped(ol, myEvent, position);
        ResetEvent(myEvent);
        DWORD bytesWritten;
        SetLastError(NO_ERROR);
        if (WriteFile( handle, in, inBytes, &bytesWritten, &ol)) {
            // succeeded already?
            if (bytesWritten != inBytes) throw exception_io();
            return;
        }
        
        {
            const DWORD code = GetLastError();
            if (code != ERROR_IO_PENDING) exception_io_from_win32(code);
        }
        const HANDLE handles[] = {myEvent, abort.get_abort_event()};
        SetLastError(NO_ERROR);
        DWORD state = WaitForMultipleObjects(_countof(handles), handles, FALSE, INFINITE);
        if (state == WAIT_OBJECT_0) {
            try {
                WIN32_IO_OP( GetOverlappedResult(handle,&ol,&bytesWritten,TRUE) );
            } catch(...) {
                CancelIo(handle);
                throw;
            }
            if (bytesWritten != inBytes) throw exception_io();
            return;
        }
        CancelIo(handle);
        throw exception_aborted();
    }

void file_win32_helpers::writeStreamOverlapped	(	HANDLE	handle,
		HANDLE	myEvent,
		const void *	in,
		size_t	inBytes,
		abort_callback &	abort
	)

Definition at line 84 of file file_win32_wrapper.cpp.

                                                                                                                       {
        const enum {writeMAX = 16*1024*1024};
        size_t done = 0;
        while(done < inBytes) {
            size_t delta = inBytes - done;
            if (delta > writeMAX) delta = writeMAX;
            writeOverlappedPass(handle, myEvent, 0, (const BYTE*)in + done, (DWORD) delta, abort);
            done += delta;
        }
    }