| //===- llvm/Support/Windows/MSFileSystemBasic.cpp DXComplier Impl *- C++ |
| //-*-===// |
| /////////////////////////////////////////////////////////////////////////////// |
| // // |
| // MSFileSystemBasic.cpp // |
| // Copyright (C) Microsoft Corporation. All rights reserved. // |
| // This file is distributed under the University of Illinois Open Source // |
| // License. See LICENSE.TXT for details. // |
| // // |
| // This file implements the DXCompiler specific implementation of the Path |
| // API.// |
| // // |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| #ifdef _WIN32 |
| |
| #include "dxc/Support/WinIncludes.h" |
| |
| #include <assert.h> |
| #include <d3dcommon.h> |
| #include <errno.h> |
| #include <fcntl.h> |
| #include <io.h> |
| #include <new> |
| #include <stdint.h> |
| #include <sys/stat.h> |
| #include <sys/types.h> |
| #include <unordered_map> |
| |
| #include "dxc/Support/Global.h" |
| #include "llvm/Support/MSFileSystem.h" |
| |
| #include "dxc/dxcapi.internal.h" |
| |
| /////////////////////////////////////////////////////////////////////////////////////////////////// |
| // Externally visible functions. |
| |
| /// <summary>Creates an implementation based on IDxcSystemAccess.</summary> |
| HRESULT |
| CreateMSFileSystemForIface(IUnknown *pService, |
| ::llvm::sys::fs::MSFileSystem **pResult) throw(); |
| |
| /// <summary>Creates an implementation with no access to system |
| /// resources.</summary> |
| HRESULT |
| CreateMSFileSystemBlocked(::llvm::sys::fs::MSFileSystem **pResult) throw(); |
| |
| /////////////////////////////////////////////////////////////////////////////////////////////////// |
| // Helper functions. |
| |
| static DWORD WIN32_FROM_HRESULT(HRESULT hr) { |
| if (SUCCEEDED(hr)) |
| return ERROR_SUCCESS; |
| if ((HRESULT)(hr & 0xFFFF0000) == |
| MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, 0)) { |
| // Could have come from many values, but we choose this one |
| return HRESULT_CODE(hr); |
| } |
| if (hr == E_OUTOFMEMORY) |
| return ERROR_OUTOFMEMORY; |
| if (hr == E_NOTIMPL) |
| return ERROR_CALL_NOT_IMPLEMENTED; |
| return ERROR_FUNCTION_FAILED; |
| } |
| |
| static HRESULT CopyStatStg(const STATSTG *statStg, |
| LPWIN32_FIND_DATAW lpFindFileData) { |
| HRESULT hr = S_OK; |
| lpFindFileData->dwFileAttributes = FILE_ATTRIBUTE_NORMAL; |
| lpFindFileData->ftCreationTime = statStg->ctime; |
| lpFindFileData->ftLastAccessTime = statStg->atime; |
| lpFindFileData->ftLastWriteTime = statStg->mtime; |
| lpFindFileData->nFileSizeLow = statStg->cbSize.LowPart; |
| lpFindFileData->nFileSizeHigh = statStg->cbSize.HighPart; |
| if (statStg->pwcsName != nullptr) { |
| IFC(StringCchCopyW(lpFindFileData->cFileName, |
| _countof(lpFindFileData->cFileName), statStg->pwcsName)); |
| } |
| |
| Cleanup: |
| return hr; |
| } |
| |
| static void ClearStatStg(STATSTG *statStg) { |
| DXASSERT_NOMSG(statStg != nullptr); |
| if (statStg->pwcsName != nullptr) { |
| CoTaskMemFree(statStg->pwcsName); |
| statStg->pwcsName = nullptr; |
| } |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////////////////////////// |
| // IDxcSystemAccess-based MSFileSystem implementation. |
| |
| struct MSFileSystemHandle { |
| enum MSFileSystemHandleKind { |
| MSFileSystemHandleKind_FindHandle, |
| MSFileSystemHandleKind_FileHandle, |
| MSFileSystemHandleKind_FileMappingHandle |
| }; |
| |
| MSFileSystemHandleKind kind; |
| CComPtr<IUnknown> |
| storage; // For a file handle, the stream or directory handle. |
| // For a find handle, the IEnumSTATSTG associated. |
| CComPtr<IStream> |
| stream; // For a file or console file handle, the stream interface. |
| int fd; // For a file handle, its file descriptor. |
| |
| explicit MSFileSystemHandle(int knownFD) |
| : kind(MSFileSystemHandleKind_FileHandle), fd(knownFD) {} |
| |
| explicit MSFileSystemHandle(IUnknown *pMapping) |
| : kind(MSFileSystemHandleKind_FileMappingHandle), storage(pMapping), |
| fd(0) {} |
| |
| MSFileSystemHandle(IUnknown *pStorage, IStream *pStream) |
| : kind(MSFileSystemHandleKind_FileHandle), storage(pStorage), |
| stream(pStream), fd(0) {} |
| |
| explicit MSFileSystemHandle(IEnumSTATSTG *pEnumSTATG) |
| : kind(MSFileSystemHandleKind_FindHandle), storage(pEnumSTATG) {} |
| |
| MSFileSystemHandle(MSFileSystemHandle &&other) { |
| kind = other.kind; |
| storage.p = other.storage.Detach(); |
| stream.p = other.stream.Detach(); |
| } |
| |
| HANDLE GetHandle() const { return (HANDLE)this; } |
| |
| IEnumSTATSTG *GetEnumStatStg() { |
| DXASSERT(kind == MSFileSystemHandleKind_FindHandle, |
| "otherwise caller didn't check"); |
| return (IEnumSTATSTG *)storage.p; |
| } |
| }; |
| |
| namespace llvm { |
| namespace sys { |
| namespace fs { |
| |
| class MSFileSystemForIface : public MSFileSystem { |
| private: |
| CComPtr<IDxcSystemAccess> m_system; |
| typedef std::unordered_multimap<LPCVOID, ID3D10Blob *> TViewMap; |
| TViewMap m_mappingViews; |
| MSFileSystemHandle m_knownHandle0; |
| MSFileSystemHandle m_knownHandle1; |
| MSFileSystemHandle m_knownHandle2; |
| |
| HRESULT AddFindHandle(IEnumSTATSTG *enumStatStg, HANDLE *pResult) throw(); |
| HRESULT AddFileHandle(IUnknown *storage, IStream *stream, |
| HANDLE *pResult) throw(); |
| HRESULT AddMappingHandle(IUnknown *mapping, HANDLE *pResult) throw(); |
| HRESULT AddMappingView(ID3D10Blob *blob) throw(); |
| HRESULT EnsureFDAvailable(int fd); |
| HANDLE GetHandleForFD(int fd) throw(); |
| void GetFindHandle(HANDLE findHandle, IEnumSTATSTG **enumStatStg) throw(); |
| int GetHandleFD(HANDLE fileHandle) throw(); |
| void GetHandleMapping(HANDLE fileHandle, IUnknown **pResult) throw(); |
| void GetHandleStorage(HANDLE fileHandle, IUnknown **pResult) throw(); |
| void GetHandleStream(HANDLE fileHandle, IStream **pResult) throw(); |
| void CloseInternalHandle(HANDLE findHandle) throw(); |
| void RemoveMappingView(LPCVOID address) throw(); |
| |
| public: |
| MSFileSystemForIface(IDxcSystemAccess *access); |
| |
| virtual BOOL |
| FindNextFileW(HANDLE hFindFile, |
| LPWIN32_FIND_DATAW lpFindFileData) throw() override; |
| virtual HANDLE |
| FindFirstFileW(LPCWSTR lpFileName, |
| LPWIN32_FIND_DATAW lpFindFileData) throw() override; |
| virtual void FindClose(HANDLE findHandle) throw() override; |
| virtual HANDLE CreateFileW(LPCWSTR lpFileName, DWORD dwDesiredAccess, |
| DWORD dwShareMode, DWORD dwCreationDisposition, |
| DWORD dwFlagsAndAttributes) throw() override; |
| virtual BOOL SetFileTime(HANDLE hFile, const FILETIME *lpCreationTime, |
| const FILETIME *lpLastAccessTime, |
| const FILETIME *lpLastWriteTime) throw() override; |
| virtual BOOL GetFileInformationByHandle( |
| HANDLE hFile, |
| LPBY_HANDLE_FILE_INFORMATION lpFileInformation) throw() override; |
| virtual DWORD GetFileType(HANDLE hFile) throw() override; |
| virtual BOOL CreateHardLinkW(LPCWSTR lpFileName, |
| LPCWSTR lpExistingFileName) throw() override; |
| virtual BOOL MoveFileExW(LPCWSTR lpExistingFileName, LPCWSTR lpNewFileName, |
| DWORD dwFlags) throw() override; |
| virtual DWORD GetFileAttributesW(LPCWSTR lpFileName) throw() override; |
| virtual BOOL CloseHandle(HANDLE hObject) throw() override; |
| virtual BOOL DeleteFileW(LPCWSTR lpFileName) throw() override; |
| virtual BOOL RemoveDirectoryW(LPCWSTR lpFileName) throw() override; |
| virtual BOOL CreateDirectoryW(LPCWSTR lpPathName) throw() override; |
| virtual DWORD GetCurrentDirectoryW(DWORD nBufferLength, |
| LPWSTR lpBuffer) throw() override; |
| virtual DWORD GetMainModuleFileNameW(LPWSTR lpFilename, |
| DWORD nSize) throw() override; |
| virtual DWORD GetTempPathW(DWORD nBufferLength, |
| LPWSTR lpBuffer) throw() override; |
| virtual BOOLEAN CreateSymbolicLinkW(LPCWSTR lpSymlinkFileName, |
| LPCWSTR lpTargetFileName, |
| DWORD dwFlags) throw() override; |
| virtual bool SupportsCreateSymbolicLink() throw() override; |
| virtual BOOL ReadFile(HANDLE hFile, LPVOID lpBuffer, |
| DWORD nNumberOfBytesToRead, |
| LPDWORD lpNumberOfBytesRead) throw() override; |
| virtual HANDLE CreateFileMappingW(HANDLE hFile, DWORD flProtect, |
| DWORD dwMaximumSizeHigh, |
| DWORD dwMaximumSizeLow) throw() override; |
| virtual LPVOID MapViewOfFile(HANDLE hFileMappingObject, DWORD dwDesiredAccess, |
| DWORD dwFileOffsetHigh, DWORD dwFileOffsetLow, |
| SIZE_T dwNumberOfBytesToMap) throw() override; |
| virtual BOOL UnmapViewOfFile(LPCVOID lpBaseAddress) throw() override; |
| |
| // Console APIs. |
| virtual bool FileDescriptorIsDisplayed(int fd) throw() override; |
| virtual unsigned GetColumnCount(DWORD nStdHandle) throw() override; |
| virtual unsigned GetConsoleOutputTextAttributes() throw() override; |
| virtual void |
| SetConsoleOutputTextAttributes(unsigned attributes) throw() override; |
| virtual void ResetConsoleOutputTextAttributes() throw() override; |
| |
| // CRT APIs. |
| virtual int open_osfhandle(intptr_t osfhandle, int flags) throw() override; |
| virtual intptr_t get_osfhandle(int fd) throw() override; |
| virtual int close(int fd) throw() override; |
| virtual long lseek(int fd, long offset, int origin) throw() override; |
| virtual int setmode(int fd, int mode) throw() override; |
| virtual errno_t resize_file(LPCWSTR path, uint64_t size) throw() override; |
| virtual int Read(int fd, void *buffer, unsigned int count) throw() override; |
| virtual int Write(int fd, const void *buffer, |
| unsigned int count) throw() override; |
| #ifndef _WIN32 |
| virtual int Open(const char *lpFileName, int flags, |
| mode_t mode) throw() override; |
| virtual int Stat(const char *lpFileName, |
| struct stat *Status) throw() override; |
| virtual int Fstat(int FD, struct stat *Status) throw() override; |
| #endif |
| }; |
| |
| MSFileSystemForIface::MSFileSystemForIface(IDxcSystemAccess *systemAccess) |
| : m_system(systemAccess), m_knownHandle0(0), m_knownHandle1(1), |
| m_knownHandle2(2) {} |
| |
| HRESULT MSFileSystemForIface::AddMappingHandle(IUnknown *mapping, |
| HANDLE *pResult) throw() { |
| DXASSERT_NOMSG(mapping != nullptr); |
| DXASSERT_NOMSG(pResult != nullptr); |
| |
| HRESULT hr = S_OK; |
| MSFileSystemHandle *handle = nullptr; |
| *pResult = INVALID_HANDLE_VALUE; |
| handle = new (std::nothrow) MSFileSystemHandle(mapping); |
| IFCOOM(handle); |
| *pResult = handle->GetHandle(); |
| |
| Cleanup: |
| return hr; |
| } |
| |
| HRESULT MSFileSystemForIface::AddMappingView(ID3D10Blob *blob) throw() { |
| DXASSERT_NOMSG(blob != nullptr); |
| LPVOID address = blob->GetBufferPointer(); |
| try { |
| m_mappingViews.insert(std::pair<LPVOID, ID3D10Blob *>(address, blob)); |
| } catch (std::bad_alloc &) { |
| return E_OUTOFMEMORY; |
| } |
| blob->AddRef(); |
| return S_OK; |
| } |
| |
| HRESULT MSFileSystemForIface::AddFindHandle(IEnumSTATSTG *enumStatStg, |
| HANDLE *pResult) throw() { |
| DXASSERT_NOMSG(enumStatStg != nullptr); |
| DXASSERT_NOMSG(pResult != nullptr); |
| |
| HRESULT hr = S_OK; |
| MSFileSystemHandle *handle = nullptr; |
| *pResult = INVALID_HANDLE_VALUE; |
| handle = new (std::nothrow) MSFileSystemHandle(enumStatStg); |
| IFCOOM(handle); |
| *pResult = handle->GetHandle(); |
| |
| Cleanup: |
| return hr; |
| } |
| |
| HRESULT MSFileSystemForIface::AddFileHandle(IUnknown *storage, IStream *stream, |
| HANDLE *pResult) throw() { |
| DXASSERT_NOMSG(storage != nullptr); |
| DXASSERT_NOMSG(pResult != nullptr); |
| |
| HRESULT hr = S_OK; |
| MSFileSystemHandle *handle = nullptr; |
| *pResult = INVALID_HANDLE_VALUE; |
| handle = new (std::nothrow) MSFileSystemHandle(storage, stream); |
| IFCOOM(handle); |
| *pResult = handle->GetHandle(); |
| |
| Cleanup: |
| return hr; |
| } |
| |
| void MSFileSystemForIface::CloseInternalHandle(HANDLE handle) throw() { |
| DXASSERT_NOMSG(handle != nullptr); |
| DXASSERT_NOMSG(handle != INVALID_HANDLE_VALUE); |
| MSFileSystemHandle *fsHandle = reinterpret_cast<MSFileSystemHandle *>(handle); |
| if (fsHandle == &m_knownHandle0 || fsHandle == &m_knownHandle1 || |
| fsHandle == &m_knownHandle2) { |
| fsHandle->stream.Release(); |
| fsHandle->storage.Release(); |
| } else { |
| delete fsHandle; |
| } |
| } |
| |
| void MSFileSystemForIface::RemoveMappingView(LPCVOID address) throw() { |
| TViewMap::iterator i = m_mappingViews.find(address); |
| DXASSERT(i != m_mappingViews.end(), "otherwise pointer to view isn't in map"); |
| DXASSERT(i->second != nullptr, |
| "otherwise blob is null and should not have been added"); |
| i->second->Release(); |
| m_mappingViews.erase(i); |
| } |
| |
| void MSFileSystemForIface::GetFindHandle(HANDLE findHandle, |
| IEnumSTATSTG **enumStatStg) throw() { |
| DXASSERT_NOMSG(findHandle != nullptr); |
| DXASSERT_NOMSG(enumStatStg != nullptr); |
| |
| MSFileSystemHandle *fsHandle = |
| reinterpret_cast<MSFileSystemHandle *>(findHandle); |
| DXASSERT(fsHandle->kind == |
| MSFileSystemHandle::MSFileSystemHandleKind_FindHandle, |
| "otherwise caller is passing wrong handle to API"); |
| |
| *enumStatStg = fsHandle->GetEnumStatStg(); |
| DXASSERT(*enumStatStg != nullptr, |
| "otherwise it should not have been added to handle entry"); |
| |
| (*enumStatStg)->AddRef(); |
| } |
| |
| int MSFileSystemForIface::GetHandleFD(HANDLE fileHandle) throw() { |
| DXASSERT_NOMSG(fileHandle != nullptr); |
| |
| MSFileSystemHandle *fsHandle = |
| reinterpret_cast<MSFileSystemHandle *>(fileHandle); |
| DXASSERT(fsHandle->kind == |
| MSFileSystemHandle::MSFileSystemHandleKind_FileHandle, |
| "otherwise caller is passing wrong handle to API"); |
| |
| return fsHandle->fd; |
| } |
| |
| void MSFileSystemForIface::GetHandleMapping(HANDLE mapping, |
| IUnknown **pResult) throw() { |
| DXASSERT_NOMSG(mapping != nullptr); |
| DXASSERT_NOMSG(pResult != nullptr); |
| |
| MSFileSystemHandle *fsHandle = |
| reinterpret_cast<MSFileSystemHandle *>(mapping); |
| DXASSERT(fsHandle->kind == |
| MSFileSystemHandle::MSFileSystemHandleKind_FileMappingHandle, |
| "otherwise caller is passing wrong handle to API"); |
| |
| *pResult = fsHandle->storage.p; |
| DXASSERT(*pResult != nullptr, |
| "otherwise it should not be requested through GetHandleMapping"); |
| |
| (*pResult)->AddRef(); |
| } |
| |
| void MSFileSystemForIface::GetHandleStorage(HANDLE fileHandle, |
| IUnknown **pResult) throw() { |
| DXASSERT_NOMSG(fileHandle != nullptr); |
| DXASSERT_NOMSG(pResult != nullptr); |
| |
| MSFileSystemHandle *fsHandle = |
| reinterpret_cast<MSFileSystemHandle *>(fileHandle); |
| DXASSERT(fsHandle->kind == |
| MSFileSystemHandle::MSFileSystemHandleKind_FileHandle, |
| "otherwise caller is passing wrong handle to API"); |
| |
| *pResult = fsHandle->storage.p; |
| DXASSERT(*pResult != nullptr, |
| "otherwise it should not be requested through GetHandleStorage"); |
| |
| (*pResult)->AddRef(); |
| } |
| |
| void MSFileSystemForIface::GetHandleStream(HANDLE fileHandle, |
| IStream **pResult) throw() { |
| DXASSERT_NOMSG(fileHandle != nullptr); |
| DXASSERT_NOMSG(pResult != nullptr); |
| |
| MSFileSystemHandle *fsHandle = |
| reinterpret_cast<MSFileSystemHandle *>(fileHandle); |
| DXASSERT(fsHandle->kind == |
| MSFileSystemHandle::MSFileSystemHandleKind_FileHandle, |
| "otherwise caller is passing wrong handle to API"); |
| |
| *pResult = fsHandle->stream.p; |
| DXASSERT(*pResult != nullptr, |
| "otherwise it should not be requested through GetHandleStream"); |
| |
| (*pResult)->AddRef(); |
| } |
| |
| HANDLE MSFileSystemForIface::FindFirstFileW( |
| LPCWSTR lpFileName, LPWIN32_FIND_DATAW lpFindFileData) throw() { |
| HRESULT hr = S_OK; |
| CComPtr<IEnumSTATSTG> enumStatStg; |
| HANDLE resultValue = INVALID_HANDLE_VALUE; |
| STATSTG elt; |
| ULONG fetched; |
| |
| ZeroMemory(&elt, sizeof(elt)); |
| ZeroMemory(lpFindFileData, sizeof(*lpFindFileData)); |
| fetched = 0; |
| |
| IFC(m_system->EnumFiles(lpFileName, &enumStatStg)); |
| IFC(enumStatStg->Next(1, &elt, &fetched)); |
| if (fetched == 0) { |
| IFC(HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND)); |
| } else { |
| IFC(CopyStatStg(&elt, lpFindFileData)); |
| IFC(AddFindHandle(enumStatStg, &resultValue)); |
| } |
| |
| Cleanup: |
| ClearStatStg(&elt); |
| if (FAILED(hr)) { |
| SetLastError(WIN32_FROM_HRESULT(hr)); |
| return INVALID_HANDLE_VALUE; |
| } |
| |
| DXASSERT(resultValue != INVALID_HANDLE_VALUE, |
| "otherwise AddFindHandle failed to return a valid handle"); |
| return resultValue; |
| } |
| |
| BOOL MSFileSystemForIface::FindNextFileW( |
| HANDLE hFindFile, LPWIN32_FIND_DATAW lpFindFileData) throw() { |
| HRESULT hr = S_OK; |
| CComPtr<IEnumSTATSTG> enumStatStg; |
| STATSTG elt; |
| ULONG fetched; |
| |
| ZeroMemory(&elt, sizeof(elt)); |
| ZeroMemory(lpFindFileData, sizeof(*lpFindFileData)); |
| fetched = 0; |
| |
| GetFindHandle(hFindFile, &enumStatStg); |
| IFC(enumStatStg->Next(1, &elt, &fetched)); |
| if (fetched == 0) { |
| IFC(HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND)); |
| } else { |
| IFC(CopyStatStg(&elt, lpFindFileData)); |
| } |
| |
| Cleanup: |
| if (FAILED(hr)) { |
| SetLastError(WIN32_FROM_HRESULT(hr)); |
| return FALSE; |
| } |
| |
| return TRUE; |
| } |
| |
| void MSFileSystemForIface::FindClose(HANDLE findHandle) throw() { |
| CloseInternalHandle(findHandle); |
| } |
| |
| HANDLE MSFileSystemForIface::CreateFileW(LPCWSTR lpFileName, |
| DWORD dwDesiredAccess, |
| DWORD dwShareMode, |
| DWORD dwCreationDisposition, |
| DWORD dwFlagsAndAttributes) throw() { |
| HRESULT hr = S_OK; |
| CComPtr<IUnknown> storage; |
| CComPtr<IStream> stream; |
| HANDLE resultHandle = INVALID_HANDLE_VALUE; |
| |
| IFC(m_system->OpenStorage(lpFileName, dwDesiredAccess, dwShareMode, |
| dwCreationDisposition, dwFlagsAndAttributes, |
| &storage)); |
| IFC(storage.QueryInterface(&stream)); |
| IFC(AddFileHandle(storage, stream, &resultHandle)); |
| |
| Cleanup: |
| if (FAILED(hr)) { |
| SetLastError(WIN32_FROM_HRESULT(hr)); |
| return INVALID_HANDLE_VALUE; |
| } |
| |
| return resultHandle; |
| } |
| |
| BOOL MSFileSystemForIface::SetFileTime( |
| HANDLE hFile, const FILETIME *lpCreationTime, |
| const FILETIME *lpLastAccessTime, const FILETIME *lpLastWriteTime) throw() { |
| HRESULT hr = S_OK; |
| CComPtr<IUnknown> storage; |
| |
| GetHandleStorage(hFile, &storage); |
| IFC(m_system->SetStorageTime(storage, lpCreationTime, lpLastAccessTime, |
| lpLastWriteTime)); |
| |
| Cleanup: |
| if (FAILED(hr)) { |
| SetLastError(WIN32_FROM_HRESULT(hr)); |
| return FALSE; |
| } |
| |
| return TRUE; |
| } |
| |
| BOOL MSFileSystemForIface::GetFileInformationByHandle( |
| HANDLE hFile, LPBY_HANDLE_FILE_INFORMATION lpFileInformation) throw() { |
| HRESULT hr = S_OK; |
| CComPtr<IUnknown> storage; |
| |
| GetHandleStorage(hFile, &storage); |
| IFC(m_system->GetFileInformationForStorage(storage, lpFileInformation)); |
| |
| Cleanup: |
| if (FAILED(hr)) { |
| SetLastError(WIN32_FROM_HRESULT(hr)); |
| return FALSE; |
| } |
| |
| return TRUE; |
| } |
| |
| DWORD MSFileSystemForIface::GetFileType(HANDLE hFile) throw() { |
| HRESULT hr = S_OK; |
| CComPtr<IUnknown> storage; |
| DWORD fileType; |
| |
| GetHandleStorage(hFile, &storage); |
| IFC(m_system->GetFileTypeForStorage(storage, &fileType)); |
| if (fileType == FILE_TYPE_UNKNOWN) { |
| SetLastError(NO_ERROR); |
| } |
| |
| Cleanup: |
| if (FAILED(hr)) { |
| SetLastError(WIN32_FROM_HRESULT(hr)); |
| fileType = FILE_TYPE_UNKNOWN; |
| } |
| |
| return fileType; |
| } |
| |
| BOOL MSFileSystemForIface::CreateHardLinkW(LPCWSTR lpFileName, |
| LPCWSTR lpExistingFileName) throw() { |
| SetLastError(ERROR_FUNCTION_NOT_CALLED); |
| return FALSE; |
| } |
| |
| BOOL MSFileSystemForIface::MoveFileExW(LPCWSTR lpExistingFileName, |
| LPCWSTR lpNewFileName, |
| DWORD dwFlags) throw() { |
| SetLastError(ERROR_FUNCTION_NOT_CALLED); |
| return FALSE; |
| } |
| |
| DWORD MSFileSystemForIface::GetFileAttributesW(LPCWSTR lpFileName) throw() { |
| HRESULT hr = S_OK; |
| DWORD attributes; |
| |
| IFC(m_system->GetFileAttributesForStorage(lpFileName, &attributes)); |
| |
| Cleanup: |
| if (FAILED(hr)) { |
| SetLastError(WIN32_FROM_HRESULT(hr)); |
| attributes = INVALID_FILE_ATTRIBUTES; |
| } |
| |
| return attributes; |
| } |
| |
| BOOL MSFileSystemForIface::CloseHandle(HANDLE hObject) throw() { |
| this->CloseInternalHandle(hObject); |
| return TRUE; |
| } |
| |
| BOOL MSFileSystemForIface::DeleteFileW(LPCWSTR lpFileName) throw() { |
| SetLastError(ERROR_FUNCTION_NOT_CALLED); |
| return FALSE; |
| } |
| |
| BOOL MSFileSystemForIface::RemoveDirectoryW(LPCWSTR lpFileName) throw() { |
| SetLastError(ERROR_FUNCTION_NOT_CALLED); |
| return FALSE; |
| } |
| |
| BOOL MSFileSystemForIface::CreateDirectoryW(LPCWSTR lpPathName) throw() { |
| SetLastError(ERROR_FUNCTION_NOT_CALLED); |
| return FALSE; |
| } |
| |
| DWORD MSFileSystemForIface::GetCurrentDirectoryW(DWORD nBufferLength, |
| LPWSTR lpBuffer) throw() { |
| DWORD written = 0; |
| HRESULT hr = S_OK; |
| |
| IFC(m_system->GetCurrentDirectoryForStorage(nBufferLength, lpBuffer, |
| &written)); |
| |
| Cleanup: |
| if (FAILED(hr)) { |
| SetLastError(WIN32_FROM_HRESULT(hr)); |
| return 0; |
| } |
| |
| return written; |
| } |
| |
| DWORD MSFileSystemForIface::GetMainModuleFileNameW(LPWSTR lpFilename, |
| DWORD nSize) throw() { |
| DWORD written = 0; |
| HRESULT hr = S_OK; |
| |
| IFC(m_system->GetMainModuleFileNameW(nSize, lpFilename, &written)); |
| |
| Cleanup: |
| if (FAILED(hr)) { |
| SetLastError(WIN32_FROM_HRESULT(hr)); |
| return 0; |
| } |
| |
| return written; |
| } |
| |
| DWORD MSFileSystemForIface::GetTempPathW(DWORD nBufferLength, |
| LPWSTR lpBuffer) throw() { |
| DWORD written = 0; |
| HRESULT hr = S_OK; |
| |
| IFC(m_system->GetTempStoragePath(nBufferLength, lpBuffer, &written)); |
| |
| Cleanup: |
| if (FAILED(hr)) { |
| SetLastError(WIN32_FROM_HRESULT(hr)); |
| return 0; |
| } |
| |
| return written; |
| } |
| |
| BOOLEAN MSFileSystemForIface::CreateSymbolicLinkW(LPCWSTR lpSymlinkFileName, |
| LPCWSTR lpTargetFileName, |
| DWORD dwFlags) throw() { |
| SetLastError(ERROR_FUNCTION_NOT_CALLED); |
| return FALSE; |
| } |
| |
| bool MSFileSystemForIface::SupportsCreateSymbolicLink() throw() { |
| return false; |
| } |
| |
| BOOL MSFileSystemForIface::ReadFile(HANDLE hFile, LPVOID lpBuffer, |
| DWORD nNumberOfBytesToRead, |
| LPDWORD lpNumberOfBytesRead) throw() { |
| HRESULT hr = S_OK; |
| CComPtr<IStream> stream; |
| GetHandleStream(hFile, &stream); |
| ULONG cbRead; |
| IFC(stream->Read(lpBuffer, nNumberOfBytesToRead, &cbRead)); |
| if (lpNumberOfBytesRead != nullptr) { |
| *lpNumberOfBytesRead = cbRead; |
| } |
| |
| Cleanup: |
| if (FAILED(hr)) { |
| SetLastError(WIN32_FROM_HRESULT(hr)); |
| return FALSE; |
| } |
| |
| return TRUE; |
| } |
| |
| HANDLE |
| MSFileSystemForIface::CreateFileMappingW(HANDLE hFile, DWORD flProtect, |
| DWORD dwMaximumSizeHigh, |
| DWORD dwMaximumSizeLow) throw() { |
| HRESULT hr = S_OK; |
| HANDLE result = INVALID_HANDLE_VALUE; |
| CComPtr<IUnknown> storage; |
| CComPtr<IUnknown> mapping; |
| |
| GetHandleStorage(hFile, &storage); |
| IFC(m_system->CreateStorageMapping(storage, flProtect, dwMaximumSizeHigh, |
| dwMaximumSizeLow, &mapping)); |
| IFC(AddMappingHandle(mapping, &result)); |
| |
| Cleanup: |
| if (FAILED(hr)) { |
| SetLastError(WIN32_FROM_HRESULT(hr)); |
| return INVALID_HANDLE_VALUE; |
| } |
| |
| return result; |
| } |
| |
| LPVOID MSFileSystemForIface::MapViewOfFile( |
| HANDLE hFileMappingObject, DWORD dwDesiredAccess, DWORD dwFileOffsetHigh, |
| DWORD dwFileOffsetLow, SIZE_T dwNumberOfBytesToMap) throw() { |
| HRESULT hr = S_OK; |
| CComPtr<IUnknown> mapping; |
| CComPtr<ID3D10Blob> blob; |
| |
| GetHandleMapping(hFileMappingObject, &mapping); |
| IFC(m_system->MapViewOfFile(mapping, dwDesiredAccess, dwFileOffsetHigh, |
| dwFileOffsetLow, dwNumberOfBytesToMap, &blob)); |
| IFC(AddMappingView(blob)); |
| |
| Cleanup: |
| if (FAILED(hr)) { |
| SetLastError(WIN32_FROM_HRESULT(hr)); |
| return INVALID_HANDLE_VALUE; |
| } |
| |
| return blob->GetBufferPointer(); |
| } |
| |
| BOOL MSFileSystemForIface::UnmapViewOfFile(LPCVOID lpBaseAddress) throw() { |
| RemoveMappingView(lpBaseAddress); |
| return TRUE; |
| } |
| |
| bool MSFileSystemForIface::FileDescriptorIsDisplayed(int fd) throw() { |
| return false; |
| } |
| |
| unsigned MSFileSystemForIface::GetColumnCount(DWORD nStdHandle) throw() { |
| return 0; |
| } |
| |
| unsigned MSFileSystemForIface::GetConsoleOutputTextAttributes() throw() { |
| return 0; |
| } |
| |
| void MSFileSystemForIface::SetConsoleOutputTextAttributes( |
| unsigned attributes) throw() { |
| return; |
| } |
| |
| void MSFileSystemForIface::ResetConsoleOutputTextAttributes() throw() {} |
| |
| int MSFileSystemForIface::open_osfhandle(intptr_t osfhandle, |
| int flags) throw() { |
| return GetHandleFD((HANDLE)osfhandle); |
| } |
| |
| HRESULT MSFileSystemForIface::EnsureFDAvailable(int fd) { |
| MSFileSystemHandle *ptr; |
| switch (fd) { |
| case 0: |
| ptr = &m_knownHandle0; |
| break; |
| case 1: |
| ptr = &m_knownHandle1; |
| break; |
| case 2: |
| ptr = &m_knownHandle2; |
| break; |
| default: |
| return S_OK; |
| } |
| |
| HRESULT hr = S_OK; |
| if (ptr->storage == nullptr) { |
| CComPtr<IUnknown> storage; |
| CComPtr<IStream> stream; |
| |
| IFC(m_system->OpenStdStorage(fd, &storage)); |
| IFC(storage.QueryInterface(&stream)); |
| |
| ptr->storage = storage; |
| ptr->stream = stream; |
| } |
| |
| DXASSERT(ptr->storage != nullptr, |
| "otherwise we should have failed to initialize"); |
| DXASSERT(ptr->stream != nullptr, |
| "otherwise we should have failed to initialize - input/output/error " |
| "should support streams"); |
| |
| Cleanup: |
| return hr; |
| } |
| |
| HANDLE MSFileSystemForIface::GetHandleForFD(int fd) throw() { |
| MSFileSystemHandle *ptr; |
| switch (fd) { |
| case 0: |
| ptr = &m_knownHandle0; |
| break; |
| case 1: |
| ptr = &m_knownHandle1; |
| break; |
| case 2: |
| ptr = &m_knownHandle2; |
| break; |
| default: |
| ptr = (MSFileSystemHandle *)(uintptr_t)fd; |
| break; |
| } |
| return ptr->GetHandle(); |
| } |
| |
| intptr_t MSFileSystemForIface::get_osfhandle(int fd) throw() { |
| if (FAILED(EnsureFDAvailable(fd))) { |
| errno = EBADF; |
| return -1; |
| } |
| |
| return (intptr_t)GetHandleForFD(fd); |
| } |
| |
| int MSFileSystemForIface::close(int fd) throw() { |
| HANDLE h = GetHandleForFD(fd); |
| this->CloseInternalHandle(h); |
| return 0; |
| } |
| |
| long MSFileSystemForIface::lseek(int fd, long offset, int origin) throw() { |
| HRESULT hr = S_OK; |
| CComPtr<IStream> stream; |
| LARGE_INTEGER li; |
| ULARGE_INTEGER uli; |
| if (FAILED(EnsureFDAvailable(fd))) { |
| errno = EBADF; |
| return -1; |
| } |
| |
| GetHandleStream(GetHandleForFD(fd), &stream); |
| li.HighPart = 0; |
| li.LowPart = offset; |
| IFC(stream->Seek(li, origin, &uli)); |
| |
| Cleanup: |
| if (FAILED(hr)) { |
| errno = EINVAL; |
| return -1; |
| } |
| |
| if (uli.HighPart > 0) { |
| errno = EOVERFLOW; |
| return -1; |
| } |
| |
| return uli.LowPart; |
| } |
| |
| int MSFileSystemForIface::setmode(int fd, int mode) throw() { return 0; } |
| |
| errno_t MSFileSystemForIface::resize_file(LPCWSTR path, uint64_t size) throw() { |
| return EBADF; |
| } |
| |
| int MSFileSystemForIface::Read(int fd, void *buffer, |
| unsigned int count) throw() { |
| HRESULT hr = S_OK; |
| CComPtr<IStream> stream; |
| ULONG cbRead = 0; |
| if (FAILED(EnsureFDAvailable(fd))) { |
| errno = EBADF; |
| return -1; |
| } |
| |
| GetHandleStream(GetHandleForFD(fd), &stream); |
| IFC(stream->Read(buffer, count, &cbRead)); |
| |
| Cleanup: |
| if (FAILED(hr)) { |
| errno = EINVAL; |
| return -1; |
| } |
| |
| return (int)cbRead; |
| } |
| |
| int MSFileSystemForIface::Write(int fd, const void *buffer, |
| unsigned int count) throw() { |
| HRESULT hr = S_OK; |
| CComPtr<IStream> stream; |
| ULONG cbWritten = 0; |
| if (FAILED(EnsureFDAvailable(fd))) { |
| errno = EBADF; |
| return -1; |
| } |
| |
| GetHandleStream(GetHandleForFD(fd), &stream); |
| IFC(stream->Write(buffer, count, &cbWritten)); |
| |
| Cleanup: |
| if (FAILED(hr)) { |
| errno = EINVAL; |
| return -1; |
| } |
| |
| return (int)cbWritten; |
| } |
| |
| #ifndef _WIN32 |
| int MSFileSystemForIface::Open(const char *lpFileName, int flags, |
| mode_t mode) throw() { |
| SetLastError(ERROR_FUNCTION_NOT_CALLED); |
| return FALSE; |
| } |
| |
| int MSFileSystemForIface::Stat(const char *lpFileName, |
| struct stat *Status) throw() { |
| SetLastError(ERROR_FUNCTION_NOT_CALLED); |
| return FALSE; |
| } |
| |
| int MSFileSystemForIface::Fstat(int FD, struct stat *Status) throw() { |
| SetLastError(ERROR_FUNCTION_NOT_CALLED); |
| return FALSE; |
| } |
| #endif |
| |
| } // end namespace fs |
| } // end namespace sys |
| } // end namespace llvm |
| |
| /////////////////////////////////////////////////////////////////////////////////////////////////// |
| // Blocked MSFileSystem implementation. |
| |
| #ifndef NDEBUG |
| static void MSFileSystemBlockedCalled() { DebugBreak(); } |
| #else |
| static void MSFileSystemBlockedCalled() {} |
| #endif |
| |
| static BOOL MSFileSystemBlockedErrWin32() { |
| MSFileSystemBlockedCalled(); |
| SetLastError(ERROR_FUNCTION_NOT_CALLED); |
| return FALSE; |
| } |
| |
| static HANDLE MSFileSystemBlockedHandle() { |
| MSFileSystemBlockedCalled(); |
| SetLastError(ERROR_FUNCTION_NOT_CALLED); |
| return INVALID_HANDLE_VALUE; |
| } |
| |
| static int MSFileSystemBlockedErrno() { |
| MSFileSystemBlockedCalled(); |
| errno = EBADF; |
| return -1; |
| } |
| |
| static int MSFileSystemBlockedErrnoT() { |
| MSFileSystemBlockedCalled(); |
| return EBADF; |
| } |
| |
| namespace llvm { |
| namespace sys { |
| namespace fs { |
| |
| class MSFileSystemBlocked : public MSFileSystem { |
| private: |
| public: |
| MSFileSystemBlocked(); |
| |
| virtual BOOL FindNextFileW(HANDLE, LPWIN32_FIND_DATAW) throw() override { |
| return MSFileSystemBlockedErrWin32(); |
| } |
| |
| virtual HANDLE |
| FindFirstFileW(LPCWSTR lpFileName, |
| LPWIN32_FIND_DATAW lpFindFileData) throw() override { |
| return MSFileSystemBlockedHandle(); |
| } |
| |
| virtual void FindClose(HANDLE findHandle) throw() override { |
| MSFileSystemBlockedCalled(); |
| } |
| |
| virtual HANDLE CreateFileW(LPCWSTR lpFileName, DWORD dwDesiredAccess, |
| DWORD dwShareMode, DWORD dwCreationDisposition, |
| DWORD dwFlagsAndAttributes) throw() override { |
| return MSFileSystemBlockedHandle(); |
| } |
| |
| virtual BOOL SetFileTime(HANDLE hFile, const FILETIME *lpCreationTime, |
| const FILETIME *lpLastAccessTime, |
| const FILETIME *lpLastWriteTime) throw() override { |
| return MSFileSystemBlockedErrWin32(); |
| } |
| |
| virtual BOOL GetFileInformationByHandle( |
| HANDLE hFile, |
| LPBY_HANDLE_FILE_INFORMATION lpFileInformation) throw() override { |
| return MSFileSystemBlockedErrWin32(); |
| } |
| |
| virtual DWORD GetFileType(HANDLE hFile) throw() override { |
| MSFileSystemBlockedErrWin32(); |
| return FILE_TYPE_UNKNOWN; |
| } |
| |
| virtual BOOL CreateHardLinkW(LPCWSTR lpFileName, |
| LPCWSTR lpExistingFileName) throw() override { |
| return MSFileSystemBlockedErrWin32(); |
| } |
| |
| virtual BOOL MoveFileExW(LPCWSTR lpExistingFileName, LPCWSTR lpNewFileName, |
| DWORD dwFlags) throw() override { |
| return MSFileSystemBlockedErrWin32(); |
| } |
| |
| virtual DWORD GetFileAttributesW(LPCWSTR lpFileName) throw() override { |
| MSFileSystemBlockedErrWin32(); |
| return 0; |
| } |
| |
| virtual BOOL CloseHandle(HANDLE hObject) throw() override { |
| return MSFileSystemBlockedErrWin32(); |
| } |
| |
| virtual BOOL DeleteFileW(LPCWSTR lpFileName) throw() override { |
| return MSFileSystemBlockedErrWin32(); |
| } |
| |
| virtual BOOL RemoveDirectoryW(LPCWSTR lpFileName) throw() override { |
| return MSFileSystemBlockedErrWin32(); |
| } |
| |
| virtual BOOL CreateDirectoryW(LPCWSTR lpPathName) throw() override { |
| return MSFileSystemBlockedErrWin32(); |
| } |
| |
| virtual DWORD GetCurrentDirectoryW(DWORD nBufferLength, |
| LPWSTR lpBuffer) throw() override; |
| virtual DWORD GetMainModuleFileNameW(LPWSTR lpFilename, |
| DWORD nSize) throw() override; |
| virtual DWORD GetTempPathW(DWORD nBufferLength, |
| LPWSTR lpBuffer) throw() override; |
| |
| virtual BOOLEAN CreateSymbolicLinkW(LPCWSTR lpSymlinkFileName, |
| LPCWSTR lpTargetFileName, |
| DWORD dwFlags) throw() override { |
| return MSFileSystemBlockedErrWin32(); |
| } |
| |
| virtual bool SupportsCreateSymbolicLink() throw() override { |
| MSFileSystemBlockedErrWin32(); |
| return false; |
| } |
| |
| virtual BOOL ReadFile(HANDLE hFile, LPVOID lpBuffer, |
| DWORD nNumberOfBytesToRead, |
| LPDWORD lpNumberOfBytesRead) throw() override { |
| return MSFileSystemBlockedErrWin32(); |
| } |
| |
| virtual HANDLE CreateFileMappingW(HANDLE hFile, DWORD flProtect, |
| DWORD dwMaximumSizeHigh, |
| DWORD dwMaximumSizeLow) throw() override { |
| return MSFileSystemBlockedHandle(); |
| } |
| |
| virtual LPVOID MapViewOfFile(HANDLE hFileMappingObject, DWORD dwDesiredAccess, |
| DWORD dwFileOffsetHigh, DWORD dwFileOffsetLow, |
| SIZE_T dwNumberOfBytesToMap) throw() override { |
| MSFileSystemBlockedErrWin32(); |
| return nullptr; |
| } |
| |
| virtual BOOL UnmapViewOfFile(LPCVOID lpBaseAddress) throw() override { |
| return MSFileSystemBlockedErrWin32(); |
| } |
| |
| // Console APIs. |
| virtual bool FileDescriptorIsDisplayed(int fd) throw() override { |
| MSFileSystemBlockedCalled(); |
| return false; |
| } |
| |
| virtual unsigned GetColumnCount(DWORD nStdHandle) throw() override { |
| MSFileSystemBlockedCalled(); |
| return 80; |
| } |
| |
| virtual unsigned GetConsoleOutputTextAttributes() throw() override { |
| MSFileSystemBlockedCalled(); |
| return 0; |
| } |
| |
| virtual void |
| SetConsoleOutputTextAttributes(unsigned attributes) throw() override { |
| MSFileSystemBlockedCalled(); |
| } |
| |
| virtual void ResetConsoleOutputTextAttributes() throw() override { |
| MSFileSystemBlockedCalled(); |
| } |
| |
| // CRT APIs. |
| virtual int open_osfhandle(intptr_t osfhandle, int flags) throw() override { |
| return MSFileSystemBlockedErrno(); |
| } |
| |
| virtual intptr_t get_osfhandle(int fd) throw() override { |
| MSFileSystemBlockedErrno(); |
| return 0; |
| } |
| |
| virtual int close(int fd) throw() override { |
| return MSFileSystemBlockedErrno(); |
| } |
| |
| virtual long lseek(int fd, long offset, int origin) throw() override { |
| return MSFileSystemBlockedErrno(); |
| } |
| |
| virtual int setmode(int fd, int mode) throw() override { |
| return MSFileSystemBlockedErrno(); |
| } |
| |
| virtual errno_t resize_file(LPCWSTR path, uint64_t size) throw() override { |
| return MSFileSystemBlockedErrnoT(); |
| } |
| |
| virtual int Read(int fd, void *buffer, unsigned int count) throw() override { |
| return MSFileSystemBlockedErrno(); |
| } |
| |
| virtual int Write(int fd, const void *buffer, |
| unsigned int count) throw() override { |
| return MSFileSystemBlockedErrno(); |
| } |
| |
| // Unix interface |
| #ifndef _WIN32 |
| virtual int Open(const char *lpFileName, int flags, |
| mode_t mode) throw() override { |
| return MSFileSystemBlockedErrno(); |
| } |
| |
| virtual int Stat(const char *lpFileName, |
| struct stat *Status) throw() override { |
| return MSFileSystemBlockedErrno(); |
| } |
| |
| virtual int Fstat(int FD, struct stat *Status) throw() override { |
| return MSFileSystemBlockedErrno(); |
| } |
| #endif |
| }; |
| |
| MSFileSystemBlocked::MSFileSystemBlocked() {} |
| |
| DWORD MSFileSystemBlocked::GetCurrentDirectoryW(DWORD nBufferLength, |
| LPWSTR lpBuffer) throw() { |
| if (nBufferLength > 1) { |
| lpBuffer[0] = L'.'; |
| lpBuffer[1] = L'\0'; |
| } |
| return 1; |
| } |
| |
| DWORD MSFileSystemBlocked::GetMainModuleFileNameW(LPWSTR lpFilename, |
| DWORD nSize) throw() { |
| SetLastError(NO_ERROR); |
| return 0; |
| } |
| |
| DWORD MSFileSystemBlocked::GetTempPathW(DWORD nBufferLength, |
| LPWSTR lpBuffer) throw() { |
| if (nBufferLength > 1) { |
| lpBuffer[0] = L'.'; |
| lpBuffer[1] = L'\0'; |
| } |
| return 1; |
| } |
| |
| } // end namespace fs |
| } // end namespace sys |
| } // end namespace llvm |
| |
| /////////////////////////////////////////////////////////////////////////////////////////////////// |
| // Externally visible functions. |
| |
| HRESULT |
| CreateMSFileSystemForIface(IUnknown *pService, |
| ::llvm::sys::fs::MSFileSystem **pResult) throw() { |
| DXASSERT_NOMSG(pService != nullptr); |
| DXASSERT_NOMSG(pResult != nullptr); |
| CComPtr<IDxcSystemAccess> systemAccess; |
| |
| HRESULT hr = pService->QueryInterface(__uuidof(IDxcSystemAccess), |
| (void **)&systemAccess); |
| if (FAILED(hr)) |
| return hr; |
| |
| *pResult = |
| new (std::nothrow)::llvm::sys::fs::MSFileSystemForIface(systemAccess); |
| return (*pResult != nullptr) ? S_OK : E_OUTOFMEMORY; |
| } |
| |
| HRESULT |
| CreateMSFileSystemBlocked(::llvm::sys::fs::MSFileSystem **pResult) throw() { |
| DXASSERT_NOMSG(pResult != nullptr); |
| *pResult = new (std::nothrow)::llvm::sys::fs::MSFileSystemBlocked(); |
| return (*pResult != nullptr) ? S_OK : E_OUTOFMEMORY; |
| } |
| |
| #endif // _WIN32 |
