From 540630f637c14d27eadc1c79e93fbc2360715206 Mon Sep 17 00:00:00 2001 From: Chris Lattner Date: Tue, 1 Apr 2008 00:53:25 +0000 Subject: cleanup the MappedFile API and comments. This removes and updates tons of out of date comments (really nothing throws here!) and fixes some other fairly glaring issues: "size" used to return the size of the file *and* change it, depending on how you called it. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@49009 91177308-0d34-0410-b5e6-96231b3b80d8 --- lib/System/Unix/MappedFile.inc | 133 ++++++++++++++++++++-------------------- lib/System/Win32/MappedFile.inc | 104 +++++++++++++++---------------- 2 files changed, 119 insertions(+), 118 deletions(-) (limited to 'lib/System') diff --git a/lib/System/Unix/MappedFile.inc b/lib/System/Unix/MappedFile.inc index 546a226..dcfd189 100644 --- a/lib/System/Unix/MappedFile.inc +++ b/lib/System/Unix/MappedFile.inc @@ -31,105 +31,109 @@ #include #endif -namespace llvm { +using namespace llvm; using namespace sys; -struct sys::MappedFileInfo { - int FD; - off_t Size; -}; +namespace llvm { + namespace sys { + struct MappedFileInfo { + int FD; + off_t Size; + }; + } +} bool MappedFile::initialize(std::string* ErrMsg) { int mode = 0; - if (options_ & READ_ACCESS) - if (options_ & WRITE_ACCESS) + if (Options & READ_ACCESS) + if (Options & WRITE_ACCESS) mode = O_RDWR; else mode = O_RDONLY; - else if (options_ & WRITE_ACCESS) + else if (Options & WRITE_ACCESS) mode = O_WRONLY; - int FD = ::open(path_.c_str(), mode); + int FD = ::open(Path.c_str(), mode); if (FD < 0) { - MakeErrMsg(ErrMsg, "can't open file '" + path_.toString() + "'"); + MakeErrMsg(ErrMsg, "can't open file '" + Path.toString() + "'"); return true; } - const FileStatus *Status = path_.getFileStatus(false, ErrMsg); + const FileStatus *Status = Path.getFileStatus(false, ErrMsg); if (!Status) { ::close(FD); return true; } - info_ = new MappedFileInfo; - info_->FD = FD; - info_->Size = Status->getSize(); + MapInfo = new MappedFileInfo(); + MapInfo->FD = FD; + MapInfo->Size = Status->getSize(); return false; } void MappedFile::terminate() { - assert(info_ && "MappedFile not initialized"); - ::close(info_->FD); - delete info_; - info_ = 0; + assert(MapInfo && "MappedFile not initialized"); + ::close(MapInfo->FD); + delete MapInfo; + MapInfo = 0; } void MappedFile::unmap() { - assert(info_ && "MappedFile not initialized"); - if (isMapped()) { - if (options_ & WRITE_ACCESS) - ::msync(base_, info_->Size, MS_SYNC); - ::munmap(base_, info_->Size); - base_ = 0; // Mark this as non-mapped. - } + assert(MapInfo && "MappedFile not initialized"); + if (!isMapped()) return; + + if (Options & WRITE_ACCESS) + ::msync(BasePtr, MapInfo->Size, MS_SYNC); + ::munmap(BasePtr, MapInfo->Size); + BasePtr = 0; // Mark this as non-mapped. } void* MappedFile::map(std::string* ErrMsg) { - assert(info_ && "MappedFile not initialized"); - if (!isMapped()) { - int prot = PROT_NONE; - int flags = 0; + assert(MapInfo && "MappedFile not initialized"); + if (isMapped()) return BasePtr; + + int prot = PROT_NONE; + int flags = 0; #ifdef MAP_FILE - flags |= MAP_FILE; + flags |= MAP_FILE; #endif - if (options_ == 0) { - prot = PROT_READ; - flags = MAP_PRIVATE; - } else { - if (options_ & READ_ACCESS) - prot |= PROT_READ; - if (options_ & WRITE_ACCESS) - prot |= PROT_WRITE; - if (options_ & EXEC_ACCESS) - prot |= PROT_EXEC; - if (options_ & SHARED_MAPPING) - flags |= MAP_SHARED; - else - flags |= MAP_PRIVATE; - } - size_t map_size = ((info_->Size / Process::GetPageSize())+1) * - Process::GetPageSize(); - - base_ = ::mmap(0, map_size, prot, flags, info_->FD, 0); - if (base_ == MAP_FAILED) { - MakeErrMsg(ErrMsg, "Can't map file:" + path_.toString()); - return 0; - } + if (Options == 0) { + prot = PROT_READ; + flags = MAP_PRIVATE; + } else { + if (Options & READ_ACCESS) + prot |= PROT_READ; + if (Options & WRITE_ACCESS) + prot |= PROT_WRITE; + if (Options & EXEC_ACCESS) + prot |= PROT_EXEC; + if (Options & SHARED_MAPPING) + flags |= MAP_SHARED; + else + flags |= MAP_PRIVATE; } - return base_; + size_t map_size = ((MapInfo->Size / Process::GetPageSize())+1) * + Process::GetPageSize(); + + BasePtr = ::mmap(0, map_size, prot, flags, MapInfo->FD, 0); + if (BasePtr == MAP_FAILED) { + MakeErrMsg(ErrMsg, "Can't map file:" + Path.toString()); + return 0; + } + return BasePtr; } size_t MappedFile::size() const { - assert(info_ && "MappedFile not initialized"); - return info_->Size; + assert(MapInfo && "MappedFile not initialized"); + return MapInfo->Size; } -bool MappedFile::size(size_t new_size, std::string* ErrMsg) { - assert(info_ && "MappedFile not initialized"); +bool MappedFile::resize(size_t new_size, std::string* ErrMsg) { + assert(MapInfo && "MappedFile not initialized"); // Take the mapping out of memory - this->unmap(); + unmap(); // Adjust the current size to a page boundary - size_t cur_size = ((info_->Size / Process::GetPageSize())+1) * + size_t cur_size = ((MapInfo->Size / Process::GetPageSize())+1) * Process::GetPageSize(); // Adjust the new_size to a page boundary @@ -140,15 +144,12 @@ bool MappedFile::size(size_t new_size, std::string* ErrMsg) { if (new_size > cur_size) { // Ensure we can allocate at least the idodes necessary to handle the // file size requested. - if ((off_t)-1 == ::lseek(info_->FD, new_size, SEEK_SET)) + if ((off_t)-1 == ::lseek(MapInfo->FD, new_size, SEEK_SET)) return MakeErrMsg(ErrMsg, "Can't lseek: "); - if (-1 == ::write(info_->FD, "\0", 1)) + if (-1 == ::write(MapInfo->FD, "\0", 1)) return MakeErrMsg(ErrMsg, "Can't write: "); } // Put the mapping back into memory. - return this->map(ErrMsg); + return map(ErrMsg); } - -} - diff --git a/lib/System/Win32/MappedFile.inc b/lib/System/Win32/MappedFile.inc index 28dbb98..de8eec3 100644 --- a/lib/System/Win32/MappedFile.inc +++ b/lib/System/Win32/MappedFile.inc @@ -28,32 +28,32 @@ struct sys::MappedFileInfo { }; bool MappedFile::initialize(std::string* ErrMsg) { - assert(!info_); - info_ = new MappedFileInfo; - info_->hFile = INVALID_HANDLE_VALUE; - info_->hMapping = NULL; - - DWORD mode = options_ & WRITE_ACCESS ? GENERIC_WRITE : GENERIC_READ; - DWORD disposition = options_ & WRITE_ACCESS ? OPEN_ALWAYS : OPEN_EXISTING; - DWORD share = options_ & WRITE_ACCESS ? FILE_SHARE_WRITE : FILE_SHARE_READ; - share = options_ & SHARED_MAPPING ? share : 0; - info_->hFile = CreateFile(path_.c_str(), mode, share, NULL, disposition, + assert(!MapInfo); + MapInfo = new MappedFileInfo; + MapInfo->hFile = INVALID_HANDLE_VALUE; + MapInfo->hMapping = NULL; + + DWORD mode = Options & WRITE_ACCESS ? GENERIC_WRITE : GENERIC_READ; + DWORD disposition = Options & WRITE_ACCESS ? OPEN_ALWAYS : OPEN_EXISTING; + DWORD share = Options & WRITE_ACCESS ? FILE_SHARE_WRITE : FILE_SHARE_READ; + share = Options & SHARED_MAPPING ? share : 0; + MapInfo->hFile = CreateFile(Path.c_str(), mode, share, NULL, disposition, FILE_ATTRIBUTE_NORMAL, NULL); - if (info_->hFile == INVALID_HANDLE_VALUE) { - delete info_; - info_ = NULL; + if (MapInfo->hFile == INVALID_HANDLE_VALUE) { + delete MapInfo; + MapInfo = NULL; return MakeErrMsg(ErrMsg, - std::string("Can't open file: ") + path_.toString()); + std::string("Can't open file: ") + Path.toString()); } LARGE_INTEGER size; - if (!GetFileSizeEx(info_->hFile, &size) || - (info_->size = size_t(size.QuadPart), info_->size != size.QuadPart)) { - CloseHandle(info_->hFile); - delete info_; - info_ = NULL; + if (!GetFileSizeEx(MapInfo->hFile, &size) || + (MapInfo->size = size_t(size.QuadPart), MapInfo->size != size.QuadPart)) { + CloseHandle(MapInfo->hFile); + delete MapInfo; + MapInfo = NULL; return MakeErrMsg(ErrMsg, - std::string("Can't get size of file: ") + path_.toString()); + std::string("Can't get size of file: ") + Path.toString()); } return false; @@ -61,56 +61,56 @@ bool MappedFile::initialize(std::string* ErrMsg) { void MappedFile::terminate() { unmap(); - if (info_->hFile != INVALID_HANDLE_VALUE) - CloseHandle(info_->hFile); - delete info_; - info_ = NULL; + if (MapInfo->hFile != INVALID_HANDLE_VALUE) + CloseHandle(MapInfo->hFile); + delete MapInfo; + MapInfo = NULL; } void MappedFile::unmap() { - assert(info_ && "MappedFile not initialized"); + assert(MapInfo && "MappedFile not initialized"); if (isMapped()) { - UnmapViewOfFile(base_); - base_ = NULL; + UnmapViewOfFile(BasePtr); + BasePtr = NULL; } - if (info_->hMapping != INVALID_HANDLE_VALUE) { - CloseHandle(info_->hMapping); - info_->hMapping = NULL; + if (MapInfo->hMapping != INVALID_HANDLE_VALUE) { + CloseHandle(MapInfo->hMapping); + MapInfo->hMapping = NULL; } } void* MappedFile::map(std::string* ErrMsg) { if (!isMapped()) { DWORD prot = PAGE_READONLY; - if (options_ & EXEC_ACCESS) + if (Options & EXEC_ACCESS) prot = SEC_IMAGE; - else if (options_ & WRITE_ACCESS) + else if (Options & WRITE_ACCESS) prot = PAGE_READWRITE; - info_->hMapping = CreateFileMapping(info_->hFile, NULL, prot, 0, 0, NULL); - if (info_->hMapping == NULL) { - MakeErrMsg(ErrMsg, std::string("Can't map file: ") + path_.toString()); + MapInfo->hMapping = CreateFileMapping(MapInfo->hFile, NULL, prot, 0, 0, NULL); + if (MapInfo->hMapping == NULL) { + MakeErrMsg(ErrMsg, std::string("Can't map file: ") + Path.toString()); return 0; } - prot = (options_ & WRITE_ACCESS) ? FILE_MAP_WRITE : FILE_MAP_READ; - base_ = MapViewOfFileEx(info_->hMapping, prot, 0, 0, 0, NULL); - if (base_ == NULL) { - CloseHandle(info_->hMapping); - info_->hMapping = NULL; - MakeErrMsg(ErrMsg, std::string("Can't map file: ") + path_.toString()); + prot = (Options & WRITE_ACCESS) ? FILE_MAP_WRITE : FILE_MAP_READ; + BasePtr = MapViewOfFileEx(MapInfo->hMapping, prot, 0, 0, 0, NULL); + if (BasePtr == NULL) { + CloseHandle(MapInfo->hMapping); + MapInfo->hMapping = NULL; + MakeErrMsg(ErrMsg, std::string("Can't map file: ") + Path.toString()); return 0; } } - return base_; + return BasePtr; } size_t MappedFile::size() const { - assert(info_ && "MappedFile not initialized"); - return info_->size; + assert(MapInfo && "MappedFile not initialized"); + return MapInfo->size; } -bool MappedFile::size(size_t new_size, std::string* ErrMsg) { - assert(info_ && "MappedFile not initialized"); +bool MappedFile::resize(size_t new_size, std::string* ErrMsg) { + assert(MapInfo && "MappedFile not initialized"); // Take the mapping out of memory. unmap(); @@ -120,16 +120,16 @@ bool MappedFile::size(size_t new_size, std::string* ErrMsg) { new_size = (new_size + pagesizem1) & ~pagesizem1; // If the file needs to be extended, do so. - if (new_size > info_->size) { + if (new_size > MapInfo->size) { LARGE_INTEGER eof; eof.QuadPart = new_size; - if (!SetFilePointerEx(info_->hFile, eof, NULL, FILE_BEGIN)) + if (!SetFilePointerEx(MapInfo->hFile, eof, NULL, FILE_BEGIN)) return MakeErrMsg(ErrMsg, - std::string("Can't set end of file: ") + path_.toString()); - if (!SetEndOfFile(info_->hFile)) + std::string("Can't set end of file: ") + Path.toString()); + if (!SetEndOfFile(MapInfo->hFile)) return MakeErrMsg(ErrMsg, - std::string("Can't set end of file: ") + path_.toString()); - info_->size = new_size; + std::string("Can't set end of file: ") + Path.toString()); + MapInfo->size = new_size; } // Remap the file. -- cgit v1.1