[29] | 1 | // (C) Copyright Craig Henderson 2002 'boost/memmap.hpp' from sandbox |
---|
| 2 | // (C) Copyright Jonathan Turkanis 2004. |
---|
| 3 | // (C) Copyright Jonathan Graehl 2004. |
---|
| 4 | |
---|
| 5 | // Distributed under the Boost Software License, Version 1.0. (See accompanying |
---|
| 6 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt.) |
---|
| 7 | |
---|
| 8 | // See http://www.boost.org/libs/iostreams for documentation. |
---|
| 9 | |
---|
| 10 | // Define BOOST_IOSTREAMS_SOURCE so that <boost/iostreams/detail/config.hpp> |
---|
| 11 | // knows that we are building the library (possibly exporting code), rather |
---|
| 12 | // than using it (possibly importing code). |
---|
| 13 | #define BOOST_IOSTREAMS_SOURCE |
---|
| 14 | |
---|
| 15 | #include <cassert> |
---|
| 16 | #include <boost/iostreams/detail/config/dyn_link.hpp> |
---|
| 17 | #include <boost/iostreams/detail/config/windows_posix.hpp> |
---|
| 18 | #include <boost/iostreams/detail/ios.hpp> // failure. |
---|
| 19 | #include <boost/iostreams/detail/system_failure.hpp> |
---|
| 20 | #include <boost/iostreams/device/mapped_file.hpp> |
---|
| 21 | |
---|
| 22 | #ifdef BOOST_IOSTREAMS_WINDOWS |
---|
| 23 | # define WIN32_LEAN_AND_MEAN // Exclude rarely-used stuff from Windows headers |
---|
| 24 | # include <windows.h> |
---|
| 25 | #else |
---|
| 26 | # include <errno.h> |
---|
| 27 | # include <fcntl.h> |
---|
| 28 | # include <sys/mman.h> // mmap, munmap. |
---|
| 29 | # include <sys/stat.h> |
---|
| 30 | # include <sys/types.h> // struct stat. |
---|
| 31 | # include <unistd.h> // sysconf. |
---|
| 32 | #endif |
---|
| 33 | |
---|
| 34 | #include <boost/iostreams/detail/config/disable_warnings.hpp> |
---|
| 35 | |
---|
| 36 | namespace boost { namespace iostreams { |
---|
| 37 | |
---|
| 38 | namespace detail { |
---|
| 39 | |
---|
| 40 | struct mapped_file_impl { |
---|
| 41 | mapped_file_impl() { clear(false); } |
---|
| 42 | ~mapped_file_impl() { try { close(); } catch (std::exception&) { } } |
---|
| 43 | void clear(bool error) |
---|
| 44 | { |
---|
| 45 | data_ = 0; |
---|
| 46 | size_ = 0; |
---|
| 47 | mode_ = BOOST_IOS::openmode(); |
---|
| 48 | error_ = error; |
---|
| 49 | #ifdef BOOST_IOSTREAMS_WINDOWS |
---|
| 50 | handle_ = INVALID_HANDLE_VALUE; |
---|
| 51 | mapped_handle_ = NULL; |
---|
| 52 | #else |
---|
| 53 | handle_ = 0; |
---|
| 54 | #endif |
---|
| 55 | } |
---|
| 56 | void close() |
---|
| 57 | { |
---|
| 58 | bool error = false; |
---|
| 59 | #ifdef BOOST_IOSTREAMS_WINDOWS |
---|
| 60 | if (handle_ == INVALID_HANDLE_VALUE) |
---|
| 61 | return; |
---|
| 62 | error = !::UnmapViewOfFile(data_) || error; |
---|
| 63 | error = !::CloseHandle(mapped_handle_) || error; |
---|
| 64 | error = !::CloseHandle(handle_) || error; |
---|
| 65 | handle_ = INVALID_HANDLE_VALUE; |
---|
| 66 | mapped_handle_ = NULL; |
---|
| 67 | #else |
---|
| 68 | if (!handle_) |
---|
| 69 | return; |
---|
| 70 | error = ::munmap(reinterpret_cast<char*>(data_), size_) != 0 || error; |
---|
| 71 | error = ::close(handle_) != 0 || error; |
---|
| 72 | handle_ = 0; |
---|
| 73 | #endif |
---|
| 74 | data_ = 0; |
---|
| 75 | size_ = 0; |
---|
| 76 | mode_ = BOOST_IOS::openmode(); |
---|
| 77 | if (error) |
---|
| 78 | throw_system_failure("error closing mapped file"); |
---|
| 79 | } |
---|
| 80 | char* data_; |
---|
| 81 | std::size_t size_; |
---|
| 82 | BOOST_IOS::openmode mode_; |
---|
| 83 | bool error_; |
---|
| 84 | #ifdef BOOST_IOSTREAMS_WINDOWS |
---|
| 85 | HANDLE handle_; |
---|
| 86 | HANDLE mapped_handle_; |
---|
| 87 | #else |
---|
| 88 | int handle_; |
---|
| 89 | #endif |
---|
| 90 | }; |
---|
| 91 | |
---|
| 92 | } // End namespace detail. |
---|
| 93 | |
---|
| 94 | //------------------Definition of mapped_file_source--------------------------// |
---|
| 95 | |
---|
| 96 | mapped_file_source::mapped_file_source(mapped_file_params p) { open(p); } |
---|
| 97 | |
---|
| 98 | mapped_file_source::mapped_file_source( const std::string& path, |
---|
| 99 | mapped_file_source::size_type length, |
---|
| 100 | boost::intmax_t offset ) |
---|
| 101 | { open(path, length, offset); } |
---|
| 102 | |
---|
| 103 | void mapped_file_source::open(mapped_file_params p) |
---|
| 104 | { |
---|
| 105 | p.mode &= ~BOOST_IOS::out; |
---|
| 106 | open_impl(p); |
---|
| 107 | } |
---|
| 108 | |
---|
| 109 | void mapped_file_source::open( const std::string& path, |
---|
| 110 | mapped_file_source::size_type length, |
---|
| 111 | boost::intmax_t offset ) |
---|
| 112 | { |
---|
| 113 | mapped_file_params p(path); |
---|
| 114 | p.mode = BOOST_IOS::in; |
---|
| 115 | p.length = length; |
---|
| 116 | p.offset = offset; |
---|
| 117 | open_impl(p); |
---|
| 118 | } |
---|
| 119 | |
---|
| 120 | mapped_file_source::size_type mapped_file_source::size() const |
---|
| 121 | { return pimpl_->size_; } |
---|
| 122 | |
---|
| 123 | bool mapped_file_source::is_open() const |
---|
| 124 | { return !!pimpl_ && pimpl_->handle_ != 0; } |
---|
| 125 | |
---|
| 126 | void mapped_file_source::close() { pimpl_->close(); } |
---|
| 127 | |
---|
| 128 | mapped_file_source::operator mapped_file_source::safe_bool() const |
---|
| 129 | { |
---|
| 130 | return !!pimpl_ && pimpl_->error_ == false ? |
---|
| 131 | &safe_bool_helper::x : 0; |
---|
| 132 | } |
---|
| 133 | |
---|
| 134 | bool mapped_file_source::operator!() const |
---|
| 135 | { return !!pimpl_ || pimpl_->error_; } |
---|
| 136 | |
---|
| 137 | BOOST_IOS::openmode mapped_file_source::mode() const { return pimpl_->mode_; } |
---|
| 138 | |
---|
| 139 | const char* mapped_file_source::data() const { return pimpl_->data_; } |
---|
| 140 | |
---|
| 141 | const char* mapped_file_source::begin() const { return data(); } |
---|
| 142 | |
---|
| 143 | const char* mapped_file_source::end() const { return data() + size(); } |
---|
| 144 | |
---|
| 145 | #ifdef BOOST_IOSTREAMS_WINDOWS //---------------------------------------------// |
---|
| 146 | |
---|
| 147 | namespace detail { |
---|
| 148 | |
---|
| 149 | void cleanup_and_throw(detail::mapped_file_impl& impl, const char* msg) |
---|
| 150 | { |
---|
| 151 | if (impl.mapped_handle_ != INVALID_HANDLE_VALUE) |
---|
| 152 | ::CloseHandle(impl.mapped_handle_); |
---|
| 153 | if (impl.handle_ != NULL) |
---|
| 154 | ::CloseHandle(impl.handle_); |
---|
| 155 | impl.clear(true); |
---|
| 156 | throw_system_failure(msg); |
---|
| 157 | } |
---|
| 158 | |
---|
| 159 | } // End namespace detail. |
---|
| 160 | |
---|
| 161 | void mapped_file_source::open_impl(mapped_file_params p) |
---|
| 162 | { |
---|
| 163 | using namespace std; |
---|
| 164 | |
---|
| 165 | if (is_open()) |
---|
| 166 | throw BOOST_IOSTREAMS_FAILURE("file already open"); |
---|
| 167 | if (!pimpl_) |
---|
| 168 | pimpl_.reset(new impl_type); |
---|
| 169 | else |
---|
| 170 | pimpl_->clear(false); |
---|
| 171 | bool readonly = (p.mode & BOOST_IOS::out) == 0; |
---|
| 172 | pimpl_->mode_ = readonly ? BOOST_IOS::in : (BOOST_IOS::in | BOOST_IOS::out); |
---|
| 173 | |
---|
| 174 | //--------------Open underlying file--------------------------------------// |
---|
| 175 | |
---|
| 176 | pimpl_->handle_ = |
---|
| 177 | ::CreateFileA( p.path.c_str(), |
---|
| 178 | readonly ? GENERIC_READ : GENERIC_ALL, |
---|
| 179 | FILE_SHARE_READ, |
---|
| 180 | NULL, |
---|
| 181 | (p.new_file_size != 0 && !readonly) ? |
---|
| 182 | CREATE_ALWAYS : |
---|
| 183 | OPEN_EXISTING, |
---|
| 184 | readonly ? |
---|
| 185 | FILE_ATTRIBUTE_READONLY : |
---|
| 186 | FILE_ATTRIBUTE_TEMPORARY, |
---|
| 187 | NULL ); |
---|
| 188 | |
---|
| 189 | if (pimpl_->handle_ == INVALID_HANDLE_VALUE) |
---|
| 190 | detail::cleanup_and_throw(*pimpl_, "failed opening file"); |
---|
| 191 | |
---|
| 192 | //--------------Set file size---------------------------------------------// |
---|
| 193 | |
---|
| 194 | if (p.new_file_size != 0 && !readonly) { |
---|
| 195 | LONG sizehigh = (p.new_file_size >> (sizeof(LONG) * 8)); |
---|
| 196 | LONG sizelow = (p.new_file_size & 0xffffffff); |
---|
| 197 | ::SetFilePointer(pimpl_->handle_, sizelow, &sizehigh, FILE_BEGIN); |
---|
| 198 | if (::GetLastError() != NO_ERROR || !::SetEndOfFile(pimpl_->handle_)) |
---|
| 199 | detail::cleanup_and_throw(*pimpl_, "failed setting file size"); |
---|
| 200 | } |
---|
| 201 | |
---|
| 202 | //--------------Create mapping--------------------------------------------// |
---|
| 203 | |
---|
| 204 | try_again: // Target of goto in following section. |
---|
| 205 | |
---|
| 206 | pimpl_->mapped_handle_ = |
---|
| 207 | ::CreateFileMappingA( pimpl_->handle_, NULL, |
---|
| 208 | readonly ? PAGE_READONLY : PAGE_READWRITE, |
---|
| 209 | 0, 0, NULL ); |
---|
| 210 | if (pimpl_->mapped_handle_ == NULL) { |
---|
| 211 | detail::cleanup_and_throw(*pimpl_, "couldn't create mapping"); |
---|
| 212 | } |
---|
| 213 | |
---|
| 214 | //--------------Access data-----------------------------------------------// |
---|
| 215 | |
---|
| 216 | void* data = |
---|
| 217 | ::MapViewOfFileEx( pimpl_->mapped_handle_, |
---|
| 218 | readonly ? FILE_MAP_READ : FILE_MAP_WRITE, |
---|
| 219 | (DWORD) (p.offset >> 32), |
---|
| 220 | (DWORD) (p.offset & 0xffffffff), |
---|
| 221 | p.length != max_length ? p.length : 0, (LPVOID) p.hint ); |
---|
| 222 | if (!data) { |
---|
| 223 | if (p.hint != 0) { |
---|
| 224 | p.hint = 0; |
---|
| 225 | goto try_again; |
---|
| 226 | } |
---|
| 227 | detail::cleanup_and_throw(*pimpl_, "failed mapping view"); |
---|
| 228 | } |
---|
| 229 | |
---|
| 230 | //--------------Determing file size---------------------------------------// |
---|
| 231 | |
---|
| 232 | // Dynamically locate GetFileSizeEx (thanks to Pavel Vozenilik). |
---|
| 233 | typedef BOOL (WINAPI *func)(HANDLE, PLARGE_INTEGER); |
---|
| 234 | HMODULE hmod = ::GetModuleHandleA("kernel32.dll"); |
---|
| 235 | func get_size = |
---|
| 236 | reinterpret_cast<func>(::GetProcAddress(hmod, "GetFileSizeEx")); |
---|
| 237 | |
---|
| 238 | if (get_size) { |
---|
| 239 | LARGE_INTEGER info; |
---|
| 240 | if (get_size(pimpl_->handle_, &info)) { |
---|
| 241 | boost::intmax_t size = |
---|
| 242 | ( (static_cast<boost::intmax_t>(info.HighPart) << 32) | |
---|
| 243 | info.LowPart ); |
---|
| 244 | pimpl_->size_ = |
---|
| 245 | static_cast<std::size_t>( |
---|
| 246 | p.length != max_length ? |
---|
| 247 | std::min<boost::intmax_t>(p.length, size) : |
---|
| 248 | size |
---|
| 249 | ); |
---|
| 250 | } else { |
---|
| 251 | detail::cleanup_and_throw(*pimpl_, "failed getting file size"); |
---|
| 252 | return; |
---|
| 253 | } |
---|
| 254 | } else { |
---|
| 255 | DWORD hi; |
---|
| 256 | DWORD low; |
---|
| 257 | if ( (low = ::GetFileSize(pimpl_->handle_, &hi)) |
---|
| 258 | != |
---|
| 259 | INVALID_FILE_SIZE ) |
---|
| 260 | { |
---|
| 261 | boost::intmax_t size = |
---|
| 262 | (static_cast<boost::intmax_t>(hi) << 32) | low; |
---|
| 263 | pimpl_->size_ = |
---|
| 264 | static_cast<std::size_t>( |
---|
| 265 | p.length != max_length ? |
---|
| 266 | std::min<boost::intmax_t>(p.length, size) : |
---|
| 267 | size |
---|
| 268 | ); |
---|
| 269 | } else { |
---|
| 270 | detail::cleanup_and_throw(*pimpl_, "failed getting file size"); |
---|
| 271 | return; |
---|
| 272 | } |
---|
| 273 | } |
---|
| 274 | |
---|
| 275 | pimpl_->data_ = reinterpret_cast<char*>(data); |
---|
| 276 | } |
---|
| 277 | |
---|
| 278 | int mapped_file_source::alignment() |
---|
| 279 | { |
---|
| 280 | SYSTEM_INFO info; |
---|
| 281 | ::GetSystemInfo(&info); |
---|
| 282 | return static_cast<int>(info.dwAllocationGranularity); |
---|
| 283 | } |
---|
| 284 | |
---|
| 285 | #else // #ifdef BOOST_IOSTREAMS_WINDOWS //------------------------------------// |
---|
| 286 | |
---|
| 287 | namespace detail { |
---|
| 288 | |
---|
| 289 | void cleanup_and_throw(detail::mapped_file_impl& impl, const char* msg) |
---|
| 290 | { |
---|
| 291 | if (impl.handle_ != 0) |
---|
| 292 | ::close(impl.handle_); |
---|
| 293 | impl.clear(true); |
---|
| 294 | throw_system_failure(msg); |
---|
| 295 | } |
---|
| 296 | |
---|
| 297 | } // End namespace detail. |
---|
| 298 | |
---|
| 299 | |
---|
| 300 | void mapped_file_source::open_impl(mapped_file_params p) |
---|
| 301 | { |
---|
| 302 | using namespace std; |
---|
| 303 | |
---|
| 304 | if (is_open()) |
---|
| 305 | throw BOOST_IOSTREAMS_FAILURE("file already open"); |
---|
| 306 | if (!pimpl_) |
---|
| 307 | pimpl_.reset(new impl_type); |
---|
| 308 | else |
---|
| 309 | pimpl_->clear(false); |
---|
| 310 | bool readonly = (p.mode & BOOST_IOS::out) == 0; |
---|
| 311 | pimpl_->mode_ = readonly ? BOOST_IOS::in : (BOOST_IOS::in | BOOST_IOS::out); |
---|
| 312 | |
---|
| 313 | //--------------Open underlying file--------------------------------------// |
---|
| 314 | |
---|
| 315 | int flags = (readonly ? O_RDONLY : O_RDWR); |
---|
| 316 | if (p.new_file_size != 0 && !readonly) |
---|
| 317 | flags |= (O_CREAT | O_TRUNC); |
---|
| 318 | errno = 0; |
---|
| 319 | pimpl_->handle_ = ::open(p.path.c_str(), flags, S_IRWXU); |
---|
| 320 | if (errno != 0) |
---|
| 321 | detail::cleanup_and_throw(*pimpl_, "failed opening file"); |
---|
| 322 | |
---|
| 323 | //--------------Set file size---------------------------------------------// |
---|
| 324 | |
---|
| 325 | if (p.new_file_size != 0 && !readonly) |
---|
| 326 | if (ftruncate(pimpl_->handle_, p.new_file_size) == -1) |
---|
| 327 | detail::cleanup_and_throw(*pimpl_, "failed setting file size"); |
---|
| 328 | |
---|
| 329 | //--------------Determine file size---------------------------------------// |
---|
| 330 | |
---|
| 331 | bool success = true; |
---|
| 332 | struct stat info; |
---|
| 333 | if (p.length != max_length) |
---|
| 334 | pimpl_->size_ = p.length; |
---|
| 335 | else { |
---|
| 336 | success = ::fstat(pimpl_->handle_, &info) != -1; |
---|
| 337 | pimpl_->size_ = info.st_size; |
---|
| 338 | } |
---|
| 339 | if (!success) |
---|
| 340 | detail::cleanup_and_throw(*pimpl_, "failed getting file size"); |
---|
| 341 | |
---|
| 342 | //--------------Create mapping--------------------------------------------// |
---|
| 343 | |
---|
| 344 | try_again: // Target of goto in following section. |
---|
| 345 | |
---|
| 346 | char* hint = const_cast<char*>(p.hint); |
---|
| 347 | void* data = ::mmap( hint, pimpl_->size_, |
---|
| 348 | readonly ? PROT_READ : (PROT_READ | PROT_WRITE), |
---|
| 349 | readonly ? MAP_PRIVATE : MAP_SHARED, |
---|
| 350 | pimpl_->handle_, p.offset ); |
---|
| 351 | if (data == MAP_FAILED) { |
---|
| 352 | if (hint != 0) { |
---|
| 353 | hint = 0; |
---|
| 354 | goto try_again; |
---|
| 355 | } |
---|
| 356 | detail::cleanup_and_throw(*pimpl_, "failed mapping file"); |
---|
| 357 | } |
---|
| 358 | pimpl_->data_ = reinterpret_cast<char*>(data); |
---|
| 359 | |
---|
| 360 | return; |
---|
| 361 | } |
---|
| 362 | |
---|
| 363 | int mapped_file_source::alignment() |
---|
| 364 | { return static_cast<int>(sysconf(_SC_PAGESIZE)); } |
---|
| 365 | |
---|
| 366 | #endif // #ifdef BOOST_IOSTREAMS_WINDOWS //-----------------------------------// |
---|
| 367 | |
---|
| 368 | //------------------Implementation of mapped_file-----------------------------// |
---|
| 369 | |
---|
| 370 | mapped_file::mapped_file(mapped_file_params p) { delegate_.open_impl(p); } |
---|
| 371 | |
---|
| 372 | mapped_file::mapped_file( const std::string& path, BOOST_IOS::openmode mode, |
---|
| 373 | size_type length, stream_offset offset ) |
---|
| 374 | { open(path, mode, length, offset); } |
---|
| 375 | |
---|
| 376 | void mapped_file::open(mapped_file_params p) |
---|
| 377 | { delegate_.open_impl(p); } |
---|
| 378 | |
---|
| 379 | void mapped_file::open( const std::string& path, BOOST_IOS::openmode mode, |
---|
| 380 | size_type length, stream_offset offset ) |
---|
| 381 | { |
---|
| 382 | mapped_file_params p(path); |
---|
| 383 | p.mode = mode; |
---|
| 384 | p.length = length; |
---|
| 385 | p.offset = offset; |
---|
| 386 | open(p); |
---|
| 387 | } |
---|
| 388 | |
---|
| 389 | //------------------Implementation of mapped_file_sink------------------------// |
---|
| 390 | |
---|
| 391 | mapped_file_sink::mapped_file_sink(mapped_file_params p) { open(p); } |
---|
| 392 | |
---|
| 393 | mapped_file_sink::mapped_file_sink( const std::string& path, |
---|
| 394 | size_type length, stream_offset offset ) |
---|
| 395 | { open(path, length, offset); } |
---|
| 396 | |
---|
| 397 | void mapped_file_sink::open(mapped_file_params p) |
---|
| 398 | { |
---|
| 399 | p.mode |= BOOST_IOS::out; |
---|
| 400 | p.mode &= ~BOOST_IOS::in; |
---|
| 401 | mapped_file::open(p); |
---|
| 402 | } |
---|
| 403 | |
---|
| 404 | void mapped_file_sink::open( const std::string& path, size_type length, |
---|
| 405 | stream_offset offset ) |
---|
| 406 | { |
---|
| 407 | mapped_file_params p(path); |
---|
| 408 | p.mode = BOOST_IOS::out; |
---|
| 409 | p.length = length; |
---|
| 410 | p.offset = offset; |
---|
| 411 | open(p); |
---|
| 412 | } |
---|
| 413 | |
---|
| 414 | //----------------------------------------------------------------------------// |
---|
| 415 | |
---|
| 416 | } } // End namespaces iostreams, boost. |
---|
| 417 | |
---|
| 418 | #include <boost/iostreams/detail/config/enable_warnings.hpp> |
---|