| ////////////////////////////////////////////////////////////////////////////// |
| // |
| // (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_WINDOWS_SHARED_MEMORY_HPP |
| #define BOOST_INTERPROCESS_WINDOWS_SHARED_MEMORY_HPP |
| |
| #include <boost/interprocess/detail/config_begin.hpp> |
| #include <boost/interprocess/detail/workaround.hpp> |
| #include <boost/detail/workaround.hpp> |
| #include <boost/interprocess/permissions.hpp> |
| |
| #if !defined(BOOST_INTERPROCESS_WINDOWS) |
| #error "This header can only be used in Windows operating systems" |
| #endif |
| |
| #include <boost/interprocess/creation_tags.hpp> |
| #include <boost/interprocess/exceptions.hpp> |
| #include <boost/interprocess/detail/utilities.hpp> |
| #include <boost/interprocess/detail/os_file_functions.hpp> |
| #include <boost/interprocess/interprocess_fwd.hpp> |
| #include <boost/interprocess/exceptions.hpp> |
| #include <boost/interprocess/detail/win32_api.hpp> |
| #include <cstddef> |
| #include <boost/cstdint.hpp> |
| #include <string> |
| |
| //!\file |
| //!Describes a class representing a native windows shared memory. |
| |
| namespace boost { |
| namespace interprocess { |
| |
| //!A class that wraps the native Windows shared memory |
| //!that is implemented as a file mapping of the paging file. |
| //!Unlike shared_memory_object, windows_shared_memory has |
| //!no kernel persistence and the shared memory is destroyed |
| //!when all processes destroy all their windows_shared_memory |
| //!objects and mapped regions for the same shared memory |
| //!or the processes end/crash. |
| //! |
| //!Warning: Windows native shared memory and interprocess portable |
| //!shared memory (boost::interprocess::shared_memory_object) |
| //!can't communicate between them. |
| class windows_shared_memory |
| { |
| /// @cond |
| //Non-copyable and non-assignable |
| BOOST_INTERPROCESS_MOVABLE_BUT_NOT_COPYABLE(windows_shared_memory) |
| /// @endcond |
| |
| public: |
| //!Default constructor. |
| //!Represents an empty windows_shared_memory. |
| windows_shared_memory(); |
| |
| //!Creates a new native shared memory with name "name" and mode "mode", |
| //!with the access mode "mode". |
| //!If the file previously exists, throws an error. |
| windows_shared_memory(create_only_t, const char *name, mode_t mode, std::size_t size, const permissions& perm = permissions()) |
| { this->priv_open_or_create(detail::DoCreate, name, mode, size, perm); } |
| |
| //!Tries to create a shared memory object with name "name" and mode "mode", with the |
| //!access mode "mode". If the file previously exists, it tries to open it with mode "mode". |
| //!Otherwise throws an error. |
| windows_shared_memory(open_or_create_t, const char *name, mode_t mode, std::size_t size, const permissions& perm = permissions()) |
| { this->priv_open_or_create(detail::DoOpenOrCreate, name, mode, size, perm); } |
| |
| //!Tries to open a shared memory object with name "name", with the access mode "mode". |
| //!If the file does not previously exist, it throws an error. |
| windows_shared_memory(open_only_t, const char *name, mode_t mode) |
| { this->priv_open_or_create(detail::DoOpen, name, mode, 0, permissions()); } |
| |
| //!Moves the ownership of "moved"'s shared memory object to *this. |
| //!After the call, "moved" does not represent any shared memory object. |
| //!Does not throw |
| windows_shared_memory(BOOST_INTERPROCESS_RV_REF(windows_shared_memory) moved) |
| : m_handle(0) |
| { this->swap(moved); } |
| |
| //!Moves the ownership of "moved"'s shared memory to *this. |
| //!After the call, "moved" does not represent any shared memory. |
| //!Does not throw |
| windows_shared_memory &operator=(BOOST_INTERPROCESS_RV_REF(windows_shared_memory) moved) |
| { |
| windows_shared_memory tmp(boost::interprocess::move(moved)); |
| this->swap(tmp); |
| return *this; |
| } |
| |
| //!Swaps to shared_memory_objects. Does not throw |
| void swap(windows_shared_memory &other); |
| |
| //!Destroys *this. All mapped regions are still valid after |
| //!destruction. When all mapped regions and windows_shared_memory |
| //!objects referring the shared memory are destroyed, the |
| //!operating system will destroy the shared memory. |
| ~windows_shared_memory(); |
| |
| //!Returns the name of the shared memory. |
| const char *get_name() const; |
| |
| //!Returns access mode |
| mode_t get_mode() const; |
| |
| //!Returns the mapping handle. Never throws |
| mapping_handle_t get_mapping_handle() const; |
| |
| /// @cond |
| private: |
| |
| //!Closes a previously opened file mapping. Never throws. |
| void priv_close(); |
| |
| //!Closes a previously opened file mapping. Never throws. |
| bool priv_open_or_create(detail::create_enum_t type, const char *filename, mode_t mode, std::size_t size, const permissions& perm = permissions()); |
| |
| void * m_handle; |
| mode_t m_mode; |
| std::string m_name; |
| /// @endcond |
| }; |
| |
| /// @cond |
| |
| inline windows_shared_memory::windows_shared_memory() |
| : m_handle(0) |
| {} |
| |
| inline windows_shared_memory::~windows_shared_memory() |
| { this->priv_close(); } |
| |
| inline const char *windows_shared_memory::get_name() const |
| { return m_name.c_str(); } |
| |
| inline void windows_shared_memory::swap(windows_shared_memory &other) |
| { |
| std::swap(m_handle, other.m_handle); |
| std::swap(m_mode, other.m_mode); |
| m_name.swap(other.m_name); |
| } |
| |
| inline mapping_handle_t windows_shared_memory::get_mapping_handle() const |
| { mapping_handle_t mhnd = { m_handle, true}; return mhnd; } |
| |
| inline mode_t windows_shared_memory::get_mode() const |
| { return m_mode; } |
| |
| inline bool windows_shared_memory::priv_open_or_create |
| (detail::create_enum_t type, const char *filename, mode_t mode, std::size_t size, const permissions& perm) |
| { |
| m_name = filename ? filename : ""; |
| |
| unsigned long file_map_access = 0; |
| unsigned long map_access = 0; |
| |
| switch(mode) |
| { |
| case read_only: |
| 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; |
| } |
| |
| switch(type){ |
| case detail::DoOpen: |
| m_handle = winapi::open_file_mapping |
| (map_access, filename); |
| break; |
| case detail::DoCreate: |
| case detail::DoOpenOrCreate: |
| { |
| __int64 s = size; |
| unsigned long high_size(s >> 32), low_size((boost::uint32_t)s); |
| m_handle = winapi::create_file_mapping |
| ( winapi::invalid_handle_value, file_map_access, high_size, low_size, filename |
| , (winapi::interprocess_security_attributes*)perm.get_permissions()); |
| } |
| break; |
| default: |
| { |
| error_info err = other_error; |
| throw interprocess_exception(err); |
| } |
| } |
| |
| if(!m_handle || (type == detail::DoCreate && winapi::get_last_error() == winapi::error_already_exists)){ |
| error_info err = system_error_code(); |
| this->priv_close(); |
| throw interprocess_exception(err); |
| } |
| |
| m_mode = mode; |
| return true; |
| } |
| |
| inline void windows_shared_memory::priv_close() |
| { |
| if(m_handle){ |
| winapi::close_handle(m_handle); |
| m_handle = 0; |
| } |
| } |
| |
| ///@endcond |
| |
| } //namespace interprocess { |
| } //namespace boost { |
| |
| #include <boost/interprocess/detail/config_end.hpp> |
| |
| #endif //BOOST_INTERPROCESS_WINDOWS_SHARED_MEMORY_HPP |