| ////////////////////////////////////////////////////////////////////////////// |
| // |
| // (C) Copyright Ion Gaztanaga 2005-2009. Distributed under the Boost |
| // Software License, Version 1.0. (See accompanying file |
| // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) |
| // |
| // See http://www.boost.org/libs/interprocess for documentation. |
| // |
| ////////////////////////////////////////////////////////////////////////////// |
| |
| #ifndef BOOST_INTERPROCESS_MAPPED_REGION_HPP |
| #define BOOST_INTERPROCESS_MAPPED_REGION_HPP |
| |
| #include <boost/interprocess/detail/config_begin.hpp> |
| #include <boost/interprocess/detail/workaround.hpp> |
| |
| #include <boost/interprocess/interprocess_fwd.hpp> |
| #include <boost/interprocess/exceptions.hpp> |
| #include <boost/interprocess/detail/move.hpp> |
| #include <boost/interprocess/detail/utilities.hpp> |
| #include <boost/interprocess/detail/os_file_functions.hpp> |
| #include <string> |
| #include <limits> |
| |
| #if (defined BOOST_INTERPROCESS_WINDOWS) |
| # include <boost/interprocess/detail/win32_api.hpp> |
| #else |
| # ifdef BOOST_HAS_UNISTD_H |
| # include <fcntl.h> |
| # include <sys/mman.h> //mmap |
| # include <unistd.h> |
| # include <sys/stat.h> |
| # include <sys/types.h> |
| # if defined(BOOST_INTERPROCESS_XSI_SHARED_MEMORY_OBJECTS) |
| # include <sys/shm.h> //System V shared memory... |
| # endif |
| # include <boost/assert.hpp> |
| # else |
| # error Unknown platform |
| # endif |
| |
| #endif //#if (defined BOOST_INTERPROCESS_WINDOWS) |
| |
| //!\file |
| //!Describes mapped region class |
| |
| namespace boost { |
| namespace interprocess { |
| |
| /// @cond |
| namespace detail{ class interprocess_tester; } |
| namespace detail{ class raw_mapped_region_creator; } |
| |
| /// @endcond |
| |
| //!The mapped_region class represents a portion or region created from a |
| //!memory_mappable object. |
| class mapped_region |
| { |
| /// @cond |
| //Non-copyable |
| BOOST_INTERPROCESS_MOVABLE_BUT_NOT_COPYABLE(mapped_region) |
| /// @endcond |
| |
| public: |
| |
| //!Creates a mapping region of the mapped memory "mapping", starting in |
| //!offset "offset", and the mapping's size will be "size". The mapping |
| //!can be opened for read-only "read_only" or read-write |
| //!"read_write. |
| template<class MemoryMappable> |
| mapped_region(const MemoryMappable& mapping |
| ,mode_t mode |
| ,offset_t offset = 0 |
| ,std::size_t size = 0 |
| ,const void *address = 0); |
| |
| //!Default constructor. Address and size and offset will be 0. |
| //!Does not throw |
| mapped_region(); |
| |
| //!Move constructor. *this will be constructed taking ownership of "other"'s |
| //!region and "other" will be left in default constructor state. |
| mapped_region(BOOST_INTERPROCESS_RV_REF(mapped_region) other) |
| #if defined (BOOST_INTERPROCESS_WINDOWS) |
| : m_base(0), m_size(0), m_offset(0) |
| , m_extra_offset(0) |
| , m_mode(read_only) |
| , m_file_mapping_hnd(detail::invalid_file()) |
| #else |
| : m_base(MAP_FAILED), m_size(0), m_offset(0), m_extra_offset(0), m_mode(read_only), m_is_xsi(false) |
| #endif |
| { this->swap(other); } |
| |
| |
| //!Destroys the mapped region. |
| //!Does not throw |
| ~mapped_region(); |
| |
| //!Move assignment. If *this owns a memory mapped region, it will be |
| //!destroyed and it will take ownership of "other"'s memory mapped region. |
| mapped_region &operator=(BOOST_INTERPROCESS_RV_REF(mapped_region) other) |
| { |
| mapped_region tmp(boost::interprocess::move(other)); |
| this->swap(tmp); |
| return *this; |
| } |
| |
| //!Returns the size of the mapping. Note for windows users: If |
| //!windows_shared_memory is mapped using 0 as the size, it returns 0 |
| //!because the size is unknown. Never throws. |
| std::size_t get_size() const; |
| |
| //!Returns the base address of the mapping. |
| //!Never throws. |
| void* get_address() const; |
| |
| //!Returns the offset of the mapping from the beginning of the |
| //!mapped memory. Never throws. |
| offset_t get_offset() const; |
| |
| //!Returns the mode of the mapping used to construct the mapped file. |
| //!Never throws. |
| mode_t get_mode() const; |
| |
| //!Flushes to the disk a byte range within the mapped memory. |
| //!Never throws |
| bool flush(std::size_t mapping_offset = 0, std::size_t numbytes = 0); |
| |
| //!Swaps the mapped_region with another |
| //!mapped region |
| void swap(mapped_region &other); |
| |
| //!Returns the size of the page. This size is the minimum memory that |
| //!will be used by the system when mapping a memory mappable source. |
| static std::size_t get_page_size(); |
| |
| /// @cond |
| private: |
| //!Closes a previously opened memory mapping. Never throws |
| void priv_close(); |
| |
| template<int dummy> |
| struct page_size_holder |
| { |
| static const std::size_t PageSize; |
| static std::size_t get_page_size(); |
| }; |
| |
| void* m_base; |
| std::size_t m_size; |
| offset_t m_offset; |
| offset_t m_extra_offset; |
| mode_t m_mode; |
| #if (defined BOOST_INTERPROCESS_WINDOWS) |
| file_handle_t m_file_mapping_hnd; |
| #else |
| bool m_is_xsi; |
| #endif |
| |
| friend class detail::interprocess_tester; |
| friend class detail::raw_mapped_region_creator; |
| void dont_close_on_destruction(); |
| /// @endcond |
| }; |
| |
| ///@cond |
| |
| inline void swap(mapped_region &x, mapped_region &y) |
| { x.swap(y); } |
| |
| inline mapped_region::~mapped_region() |
| { this->priv_close(); } |
| |
| inline std::size_t mapped_region::get_size() const |
| { return m_size; } |
| |
| inline offset_t mapped_region::get_offset() const |
| { return m_offset; } |
| |
| inline mode_t mapped_region::get_mode() const |
| { return m_mode; } |
| |
| inline void* mapped_region::get_address() const |
| { return m_base; } |
| |
| #if defined (BOOST_INTERPROCESS_WINDOWS) |
| |
| inline mapped_region::mapped_region() |
| : m_base(0), m_size(0), m_offset(0), m_extra_offset(0), m_mode(read_only) |
| , m_file_mapping_hnd(detail::invalid_file()) |
| {} |
| |
| template<int dummy> |
| inline std::size_t mapped_region::page_size_holder<dummy>::get_page_size() |
| { |
| winapi::system_info info; |
| get_system_info(&info); |
| return std::size_t(info.dwAllocationGranularity); |
| } |
| |
| template<class MemoryMappable> |
| inline mapped_region::mapped_region |
| (const MemoryMappable &mapping |
| ,mode_t mode |
| ,offset_t offset |
| ,std::size_t size |
| ,const void *address) |
| : m_base(0), m_size(0), m_offset(0), m_extra_offset(0), m_mode(mode) |
| , m_file_mapping_hnd(detail::invalid_file()) |
| { |
| mapping_handle_t mhandle = mapping.get_mapping_handle(); |
| file_handle_t native_mapping_handle = 0; |
| |
| //Set accesses |
| unsigned long file_map_access = 0; |
| unsigned long map_access = 0; |
| |
| switch(mode) |
| { |
| case read_only: |
| case read_private: |
| file_map_access |= winapi::page_readonly; |
| map_access |= winapi::file_map_read; |
| break; |
| case read_write: |
| file_map_access |= winapi::page_readwrite; |
| map_access |= winapi::file_map_write; |
| break; |
| case copy_on_write: |
| file_map_access |= winapi::page_writecopy; |
| map_access |= winapi::file_map_copy; |
| break; |
| default: |
| { |
| error_info err(mode_error); |
| throw interprocess_exception(err); |
| } |
| break; |
| } |
| |
| if(!mhandle.is_shm){ |
| //Update mapping size if the user does not specify it |
| if(size == 0){ |
| __int64 total_size; |
| if(!winapi::get_file_size |
| (detail::file_handle_from_mapping_handle |
| (mapping.get_mapping_handle()), total_size)){ |
| error_info err(winapi::get_last_error()); |
| throw interprocess_exception(err); |
| } |
| |
| if(static_cast<unsigned __int64>(total_size) > |
| (std::numeric_limits<std::size_t>::max)()){ |
| error_info err(size_error); |
| throw interprocess_exception(err); |
| } |
| size = static_cast<std::size_t>(total_size - offset); |
| } |
| |
| //Create file mapping |
| native_mapping_handle = |
| winapi::create_file_mapping |
| (detail::file_handle_from_mapping_handle(mapping.get_mapping_handle()), file_map_access, 0, 0, 0, 0); |
| |
| //Check if all is correct |
| if(!native_mapping_handle){ |
| error_info err = winapi::get_last_error(); |
| this->priv_close(); |
| throw interprocess_exception(err); |
| } |
| } |
| |
| //We can't map any offset so we have to obtain system's |
| //memory granularity |
| unsigned long granularity = 0; |
| unsigned long foffset_low; |
| unsigned long foffset_high; |
| |
| winapi::system_info info; |
| get_system_info(&info); |
| granularity = info.dwAllocationGranularity; |
| |
| //Now we calculate valid offsets |
| foffset_low = (unsigned long)(offset / granularity) * granularity; |
| foffset_high = (unsigned long)(((offset / granularity) * granularity) >> 32); |
| |
| //We calculate the difference between demanded and valid offset |
| m_extra_offset = (offset - (offset / granularity) * granularity); |
| |
| //Store user values in memory |
| m_offset = offset; |
| m_size = size; |
| |
| //Update the mapping address |
| if(address){ |
| address = static_cast<const char*>(address) - m_extra_offset; |
| } |
| |
| if(mhandle.is_shm){ |
| //Windows shared memory needs the duplication of the handle if we want to |
| //make mapped_region independent from the mappable device |
| if(!winapi::duplicate_current_process_handle(mhandle.handle, &m_file_mapping_hnd)){ |
| error_info err = winapi::get_last_error(); |
| this->priv_close(); |
| throw interprocess_exception(err); |
| } |
| native_mapping_handle = m_file_mapping_hnd; |
| } |
| |
| //Map with new offsets and size |
| m_base = winapi::map_view_of_file_ex |
| (native_mapping_handle, |
| map_access, |
| foffset_high, |
| foffset_low, |
| m_size ? static_cast<std::size_t>(m_extra_offset + m_size) : 0, |
| const_cast<void*>(address)); |
| |
| if(!mhandle.is_shm){ |
| //For files we don't need the file mapping anymore |
| winapi::close_handle(native_mapping_handle); |
| } |
| |
| //Check error |
| if(!m_base){ |
| error_info err = winapi::get_last_error(); |
| this->priv_close(); |
| throw interprocess_exception(err); |
| } |
| |
| //Calculate new base for the user |
| m_base = static_cast<char*>(m_base) + m_extra_offset; |
| } |
| |
| inline bool mapped_region::flush(std::size_t mapping_offset, std::size_t numbytes) |
| { |
| //Check some errors |
| if(m_base == 0) |
| return false; |
| |
| if(mapping_offset >= m_size || (mapping_offset + numbytes) > m_size){ |
| return false; |
| } |
| |
| //Update flush size if the user does not provide it |
| if(m_size == 0){ |
| numbytes = 0; |
| } |
| else if(numbytes == 0){ |
| numbytes = m_size - mapping_offset; |
| } |
| |
| //Flush it all |
| return winapi::flush_view_of_file |
| (static_cast<char*>(m_base)+mapping_offset, |
| static_cast<std::size_t>(numbytes)); |
| } |
| |
| inline void mapped_region::priv_close() |
| { |
| if(m_base){ |
| winapi::unmap_view_of_file(static_cast<char*>(m_base) - m_extra_offset); |
| m_base = 0; |
| } |
| #if (defined BOOST_INTERPROCESS_WINDOWS) |
| if(m_file_mapping_hnd != detail::invalid_file()){ |
| winapi::close_handle(m_file_mapping_hnd); |
| m_file_mapping_hnd = detail::invalid_file(); |
| } |
| #endif |
| } |
| |
| inline void mapped_region::dont_close_on_destruction() |
| {} |
| |
| #else //#if (defined BOOST_INTERPROCESS_WINDOWS) |
| |
| inline mapped_region::mapped_region() |
| : m_base(MAP_FAILED), m_size(0), m_offset(0), m_extra_offset(0), m_mode(read_only), m_is_xsi(false) |
| {} |
| |
| template<int dummy> |
| inline std::size_t mapped_region::page_size_holder<dummy>::get_page_size() |
| { return std::size_t(sysconf(_SC_PAGESIZE)); } |
| |
| template<class MemoryMappable> |
| inline mapped_region::mapped_region |
| (const MemoryMappable &mapping, |
| mode_t mode, |
| offset_t offset, |
| std::size_t size, |
| const void *address) |
| : m_base(MAP_FAILED), m_size(0), m_offset(0), m_extra_offset(0), m_mode(mode), m_is_xsi(false) |
| { |
| mapping_handle_t map_hnd = mapping.get_mapping_handle(); |
| |
| //Some systems dont' support XSI shared memory |
| #ifdef BOOST_INTERPROCESS_XSI_SHARED_MEMORY_OBJECTS |
| if(map_hnd.is_xsi){ |
| //Get the size |
| ::shmid_ds xsi_ds; |
| int ret = ::shmctl(map_hnd.handle, IPC_STAT, &xsi_ds); |
| if(ret == -1){ |
| error_info err(system_error_code()); |
| throw interprocess_exception(err); |
| } |
| //Compare sizess |
| if(size == 0){ |
| size = (std::size_t)xsi_ds.shm_segsz; |
| } |
| else if(size != (std::size_t)xsi_ds.shm_segsz){ |
| error_info err(size_error); |
| throw interprocess_exception(err); |
| } |
| //Calculate flag |
| int flag = 0; |
| if(m_mode == read_only){ |
| flag |= SHM_RDONLY; |
| } |
| else if(m_mode != read_write){ |
| error_info err(mode_error); |
| throw interprocess_exception(err); |
| } |
| //Attach memory |
| void *base = ::shmat(map_hnd.handle, (void*)address, flag); |
| if(base == (void*)-1){ |
| error_info err(system_error_code()); |
| throw interprocess_exception(err); |
| } |
| //Update members |
| m_base = base; |
| m_offset = offset; |
| m_size = size; |
| m_mode = mode; |
| m_extra_offset = 0; |
| m_is_xsi = true; |
| return; |
| } |
| #endif //ifdef BOOST_INTERPROCESS_XSI_SHARED_MEMORY_OBJECTS |
| if(size == 0){ |
| struct ::stat buf; |
| if(0 != fstat(map_hnd.handle, &buf)){ |
| error_info err(system_error_code()); |
| throw interprocess_exception(err); |
| } |
| std::size_t filesize = (std::size_t)buf.st_size; |
| if((std::size_t)offset >= filesize){ |
| error_info err(size_error); |
| throw interprocess_exception(err); |
| } |
| |
| filesize -= offset; |
| size = filesize; |
| } |
| |
| //Create new mapping |
| int prot = 0; |
| int flags = 0; |
| |
| switch(mode) |
| { |
| case read_only: |
| prot |= PROT_READ; |
| flags |= MAP_SHARED; |
| break; |
| |
| case read_private: |
| prot |= (PROT_READ); |
| flags |= MAP_PRIVATE; |
| break; |
| |
| case read_write: |
| prot |= (PROT_WRITE | PROT_READ); |
| flags |= MAP_SHARED; |
| break; |
| |
| case copy_on_write: |
| prot |= (PROT_WRITE | PROT_READ); |
| flags |= MAP_PRIVATE; |
| break; |
| |
| default: |
| { |
| error_info err(mode_error); |
| throw interprocess_exception(err); |
| } |
| break; |
| } |
| |
| //We calculate the difference between demanded and valid offset |
| std::size_t page_size = this->get_page_size(); |
| m_extra_offset = (offset - (offset / page_size) * page_size); |
| |
| //Store user values in memory |
| m_offset = offset; |
| m_size = size; |
| |
| //Update the mapping address |
| if(address){ |
| address = static_cast<const char*>(address) - m_extra_offset; |
| } |
| |
| //Map it to the address space |
| m_base = mmap ( const_cast<void*>(address) |
| , static_cast<std::size_t>(m_extra_offset + m_size) |
| , prot |
| , flags |
| , mapping.get_mapping_handle().handle |
| , offset - m_extra_offset); |
| |
| //Check if mapping was successful |
| if(m_base == MAP_FAILED){ |
| error_info err = system_error_code(); |
| this->priv_close(); |
| throw interprocess_exception(err); |
| } |
| |
| //Calculate new base for the user |
| const void *old_base = m_base; |
| m_base = static_cast<char*>(m_base) + m_extra_offset; |
| m_offset = offset; |
| m_size = size; |
| |
| //Check for fixed mapping error |
| if(address && (old_base != address)){ |
| error_info err = system_error_code(); |
| this->priv_close(); |
| throw interprocess_exception(err); |
| } |
| } |
| |
| inline bool mapped_region::flush(std::size_t mapping_offset, std::size_t numbytes) |
| { |
| if(mapping_offset >= m_size || (mapping_offset+numbytes)> m_size){ |
| return false; |
| } |
| |
| if(numbytes == 0){ |
| numbytes = m_size - mapping_offset; |
| } |
| //Flush it all |
| return msync(static_cast<char*>(m_base)+mapping_offset, |
| numbytes, MS_ASYNC) == 0; |
| } |
| |
| inline void mapped_region::priv_close() |
| { |
| if(m_base != MAP_FAILED){ |
| #ifdef BOOST_INTERPROCESS_XSI_SHARED_MEMORY_OBJECTS |
| if(m_is_xsi){ |
| int ret = ::shmdt(m_base); |
| BOOST_ASSERT(ret == 0); |
| (void)ret; |
| return; |
| } |
| #endif //#ifdef BOOST_INTERPROCESS_XSI_SHARED_MEMORY_OBJECTS |
| munmap(static_cast<char*>(m_base) - m_extra_offset, m_size + m_extra_offset); |
| m_base = MAP_FAILED; |
| } |
| } |
| |
| inline void mapped_region::dont_close_on_destruction() |
| { m_base = MAP_FAILED; } |
| |
| #endif //##if (defined BOOST_INTERPROCESS_WINDOWS) |
| |
| template<int dummy> |
| const std::size_t mapped_region::page_size_holder<dummy>::PageSize |
| = mapped_region::page_size_holder<dummy>::get_page_size(); |
| |
| inline std::size_t mapped_region::get_page_size() |
| { |
| if(!page_size_holder<0>::PageSize) |
| return page_size_holder<0>::get_page_size(); |
| else |
| return page_size_holder<0>::PageSize; |
| } |
| |
| inline void mapped_region::swap(mapped_region &other) |
| { |
| detail::do_swap(this->m_base, other.m_base); |
| detail::do_swap(this->m_size, other.m_size); |
| detail::do_swap(this->m_offset, other.m_offset); |
| detail::do_swap(this->m_extra_offset, other.m_extra_offset); |
| detail::do_swap(this->m_mode, other.m_mode); |
| #if (defined BOOST_INTERPROCESS_WINDOWS) |
| detail::do_swap(this->m_file_mapping_hnd, other.m_file_mapping_hnd); |
| #else |
| detail::do_swap(this->m_is_xsi, other.m_is_xsi); |
| #endif |
| } |
| |
| //!No-op functor |
| struct null_mapped_region_function |
| { |
| bool operator()(void *, std::size_t , bool) const |
| { return true; } |
| }; |
| |
| /// @endcond |
| |
| } //namespace interprocess { |
| } //namespace boost { |
| |
| #include <boost/interprocess/detail/config_end.hpp> |
| |
| #endif //BOOST_INTERPROCESS_MAPPED_REGION_HPP |
| |