/Src/Dependencies/Boost/boost/interprocess/detail/xsi_shared_memory_device.hpp
C++ Header | 392 lines | 286 code | 63 blank | 43 comment | 45 complexity | 242a4bf50171c00ba94cbe312e992aa6 MD5 | raw file
1////////////////////////////////////////////////////////////////////////////// 2// 3// (C) Copyright Ion Gaztanaga 2009-2010. Distributed under the Boost 4// Software License, Version 1.0. (See accompanying file 5// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 6// 7// See http://www.boost.org/libs/interprocess for documentation. 8// 9////////////////////////////////////////////////////////////////////////////// 10 11#ifndef BOOST_INTERPROCESS_XSI_SHARED_MEMORY_DEVICE_HPP 12#define BOOST_INTERPROCESS_XSI_SHARED_MEMORY_DEVICE_HPP 13 14#include <boost/interprocess/detail/config_begin.hpp> 15#include <boost/interprocess/detail/workaround.hpp> 16#include <boost/detail/workaround.hpp> 17 18#if defined(BOOST_INTERPROCESS_WINDOWS) 19#error "This header can't be used in Windows operating systems" 20#endif 21 22#include <boost/interprocess/creation_tags.hpp> 23#include <boost/interprocess/exceptions.hpp> 24#include <boost/interprocess/detail/utilities.hpp> 25#include <boost/interprocess/detail/os_file_functions.hpp> 26#include <boost/interprocess/detail/tmp_dir_helpers.hpp> 27#include <boost/interprocess/interprocess_fwd.hpp> 28#include <boost/interprocess/exceptions.hpp> 29 30#include <boost/interprocess/xsi_shared_memory.hpp> 31#include <boost/interprocess/sync/xsi/xsi_named_mutex.hpp> 32#include <boost/interprocess/mapped_region.hpp> 33#include <boost/interprocess/sync/scoped_lock.hpp> 34#include <cstddef> 35#include <boost/cstdint.hpp> 36#include <string> 37#include <cstring> 38 39//!\file 40//!Describes a class representing a native xsi shared memory. 41 42namespace boost { 43namespace interprocess { 44 45class xsi_shared_memory_device 46{ 47 /// @cond 48 BOOST_INTERPROCESS_MOVABLE_BUT_NOT_COPYABLE(xsi_shared_memory_file_wrapper) 49 /// @endcond 50 51 public: 52 53 xsi_shared_memory_device(); 54 55 xsi_shared_memory_device(create_only_t, const char *name, mode_t mode, std::size_t size) 56 { this->priv_open_or_create_name_only(detail::DoCreate, name, mode, size); } 57 58 xsi_shared_memory_device(open_or_create_t, const char *name, mode_t mode, std::size_t size) 59 { this->priv_open_or_create_name_only(detail::DoOpenOrCreate, name, mode, size); } 60 61 xsi_shared_memory_device(open_only_t, const char *name, mode_t mode) 62 { this->priv_open_or_create_name_only(detail::DoOpen, name, mode, 0); } 63 64 xsi_shared_memory_device(create_only_t, const char *filepath, boost::uint8_t id, mode_t mode, std::size_t size) 65 { this->priv_open_or_create_name_id(detail::DoCreate, name, id, mode, size); } 66 67 xsi_shared_memory_device(open_or_create_t, const char *filepath, boost::uint8_t id, mode_t mode, std::size_t size) 68 { this->priv_open_or_create_name_id(detail::DoOpenOrCreate, id, name, mode, size); } 69 70 xsi_shared_memory_device(open_only_t, const char *filepath, boost::uint8_t id, mode_t mode) 71 { this->priv_open_or_create_name_id(detail::DoOpen, name, id, mode, 0); } 72 73 xsi_shared_memory_device(BOOST_INTERPROCESS_RV_REF(xsi_shared_memory_device) moved) 74 { this->swap(moved); } 75 76 xsi_shared_memory_device &operator=(BOOST_INTERPROCESS_RV_REF(xsi_shared_memory_device) moved) 77 { 78 xsi_shared_memory_device tmp(boost::interprocess::move(moved)); 79 this->swap(tmp); 80 return *this; 81 } 82 83 //!Swaps two xsi_shared_memory_device. Does not throw 84 void swap(xsi_shared_memory_device &other); 85 86 //!Destroys *this. The shared memory won't be destroyed, just 87 //!this connection to it. Use remove() to destroy the shared memory. 88 ~xsi_shared_memory_device(); 89 90 //!Returns the name of the 91 //!shared memory. 92 const char *get_name() const; 93 94 //!Returns the shared memory ID that 95 //!identifies the shared memory 96 int get_shmid() const; 97 98 //!Returns access 99 //!permissions 100 mode_t get_mode() const; 101 102 //!Returns the mapping handle. 103 //!Never throws 104 mapping_handle_t get_mapping_handle() const; 105 106 //!Erases a XSI shared memory object identified by shmname 107 //!from the system. 108 //!Returns false on error. Never throws 109 static bool remove(const char *shmname); 110 111 //!Erases the XSI shared memory object identified by shmid 112 //!from the system. 113 //!Returns false on error. Never throws 114 static bool remove(int shmid); 115 116 /// @cond 117 private: 118 template<int Dummy> 119 struct info_constants_t 120 { 121 static const std::size_t MaxName = 32; 122 static const std::size_t FirstID = 2; 123 static const std::size_t LastID = 256; 124 static const std::size_t NumID = LastID - FirstID; 125 }; 126 127 struct info_t 128 { 129 struct names_t 130 { 131 char buf[info_constants_t<0>::MaxName]; 132 } names[info_constants_t<0>::NumID]; 133 }; 134 135 static void priv_obtain_index(mapped_region &m, xsi_named_mutex &m, std::string &path); 136 static bool priv_remove_dead_memory(info_t *info, const char *path); 137 138 bool priv_open_or_create_name_only( detail::create_enum_t type 139 , const char *shmname 140 , mode_t mode 141 , std::size_t size); 142 bool priv_open_or_create_name_id( detail::create_enum_t type 143 , const char *shmname 144 , boost::uint8_t id 145 , mode_t mode 146 , std::size_t size); 147 xsi_shared_memory m_shm; 148 mode_t m_mode; 149 std::string m_name; 150 /// @endcond 151}; 152 153template<int Dummy> 154const std::size_t xsi_shared_memory_device::info_constants_t<Dummy>::MaxName; 155 156template<int Dummy> 157const std::size_t xsi_shared_memory_device::info_constants_t<Dummy>::FirstID; 158 159template<int Dummy> 160const std::size_t xsi_shared_memory_device::info_constants_t<Dummy>::LastID; 161 162template<int Dummy> 163const std::size_t xsi_shared_memory_device::info_constants_t<Dummy>::NumID; 164 165/// @cond 166 167inline xsi_shared_memory_device::xsi_shared_memory_device() 168 : m_shm(), m_mode(invalid_mode), m_name() 169{} 170 171inline xsi_shared_memory_device::~xsi_shared_memory_device() 172{} 173 174inline const char *xsi_shared_memory_device::get_name() const 175{ return m_name.c_str(); } 176 177inline void xsi_shared_memory_device::swap(xsi_shared_memory_device &other) 178{ 179 m_shm.swap(other.m_shm); 180 std::swap(m_mode, other.m_mode); 181 m_name.swap(other.m_name); 182} 183 184inline mapping_handle_t xsi_shared_memory_device::get_mapping_handle() const 185{ return m_shm.get_mapping_handle(); } 186 187inline mode_t xsi_shared_memory_device::get_mode() const 188{ return m_mode; } 189 190inline int xsi_shared_memory::get_shmid() const 191{ return m_shm.get_shmid(); } 192 193inline void xsi_shared_memory_device::priv_obtain_index 194 (mapped_region ®, xsi_named_mutex &mut, std::string &path) 195{ 196 const char *const filename = "xsi_shm_emulation_file"; 197 permissions p; 198 p.set_unrestricted(); 199 std::string xsi_shm_emulation_file_path; 200 detail::create_tmp_and_clean_old_and_get_filename(filename, xsi_shm_emulation_file_path); 201 detail::create_or_open_file(xsi_shm_emulation_file_path.c_str(), read_write, p); 202 const std::size_t MemSize = sizeof(info_t); 203 204 xsi_shared_memory index_shm(open_or_create, xsi_shm_emulation_file_path.c_str(), 1, MemSize, 0666); 205 mapped_region r(index_shm, read_write, 0, MemSize, 0); 206 xsi_named_mutex m(open_or_create, xsi_shm_emulation_file_path.c_str(), 2, 0666); 207 reg = boost::interprocess::move(r); 208 mut = boost::interprocess::move(m); 209 path.swap(xsi_shm_emulation_file_path); 210} 211 212inline bool xsi_shared_memory_device::priv_remove_dead_memory 213 (xsi_shared_memory_device::info_t *info, const char *path) 214{ 215 bool removed = false; 216 for(std::size_t i = 0; i != info_constants_t<0>::NumID; ++i){ 217 if(info->names[i].buf[0]){ 218 try{ 219 xsi_shared_memory temp( open_only, path, i+info_constants_t<0>::FirstID, 0600); 220 } 221 catch(interprocess_exception &e){ 222 if(e.get_error_code() == not_found_error){ 223 std::memset(info->names[i].buf, 0, info_constants_t<0>::MaxName); 224 removed = true; 225 } 226 } 227 } 228 } 229 return removed; 230} 231 232inline bool xsi_shared_memory_device::priv_open_or_create_name_id 233 (detail::create_enum_t type, const char *filepath, mode_t mode, std::size_t size) 234{ 235 //Set accesses 236 if (mode != read_write && mode != read_only){ 237 error_info err = other_error; 238 throw interprocess_exception(err); 239 } 240 241 int perm = (mode == read_only) ? (0444) : (0666); 242 243 if(type == detail::DoOpen){ 244 if(!found){ 245 error_info err = not_found_error; 246 throw interprocess_exception(err); 247 } 248 xsi_shared_memory temp(open_only, filepath, id, perm); 249 m_shm = boost::interprocess::move(temp); 250 } 251 else if(type == detail::DoCreate){ 252 //Try to reuse slot 253 xsi_shared_memory temp(create_only, filepath, id, size, perm); 254 std::strcpy(info->names[target_entry].buf, shmname); 255 m_shm = boost::interprocess::move(temp); 256 } 257 else{ // if(type == detail::DoOpenOrCreate){ 258 xsi_shared_memory temp(open_or_create, filepath, id, size, perm); 259 m_shm = boost::interprocess::move(temp); 260 } 261 262 m_mode = mode; 263 m_name.clear(); 264 return true; 265} 266 267inline bool xsi_shared_memory_device::priv_open_or_create_name_only 268 (detail::create_enum_t type, const char *shmname, mode_t mode, std::size_t size) 269{ 270 //Set accesses 271 if (mode != read_write && mode != read_only){ 272 error_info err = other_error; 273 throw interprocess_exception(err); 274 } 275 276 if (std::strlen(shmname) >= (info_constants_t<0>::MaxName)){ 277 error_info err = other_error; 278 throw interprocess_exception(err); 279 } 280 281 { 282 //Obtain index and index lock 283 mapped_region region; 284 xsi_named_mutex mut; 285 std::string xsi_shm_emulation_file_path; 286 priv_obtain_index(region, mut, xsi_shm_emulation_file_path); 287 info_t *info = static_cast<info_t *>(region.get_address()); 288 scoped_lock<xsi_named_mutex> lock(mut); 289 290 //Find the correct entry or the first empty index 291 bool found = false; 292 int target_entry = -1; 293 int tries = 2; 294 while(tries--){ 295 for(std::size_t i = 0; i != info_constants_t<0>::NumID; ++i){ 296 if(target_entry < 0 && !info->names[i].buf[0]){ 297 target_entry = static_cast<int>(i); 298 } 299 else if(0 == std::strcmp(info->names[i].buf, shmname)){ 300 found = true; 301 target_entry = static_cast<int>(i); 302 break; 303 } 304 } 305 if(target_entry < 0){ 306 if(!tries || !priv_remove_dead_memory(info, xsi_shm_emulation_file_path.c_str())){ 307 error_info err = out_of_resource_error; 308 throw interprocess_exception(err); 309 } 310 } 311 } 312 //Now handle the result 313 int perm = (mode == read_only) ? (0444) : (0666); 314 if(type == detail::DoOpen){ 315 if(!found){ 316 error_info err = not_found_error; 317 throw interprocess_exception(err); 318 } 319 xsi_shared_memory temp( open_only, xsi_shm_emulation_file_path.c_str() 320 , target_entry+info_constants_t<0>::FirstID, perm); 321 m_shm = boost::interprocess::move(temp); 322 } 323 else{ 324 325 if(type == detail::DoCreate){ 326 //Try to reuse slot 327 xsi_shared_memory temp( create_only, xsi_shm_emulation_file_path.c_str() 328 , target_entry+info_constants_t<0>::FirstID, size, perm); 329 std::strcpy(info->names[target_entry].buf, shmname); 330 m_shm = boost::interprocess::move(temp); 331 } 332 else{ // if(type == detail::DoOpenOrCreate){ 333 xsi_shared_memory temp( open_or_create, xsi_shm_emulation_file_path.c_str() 334 , target_entry+info_constants_t<0>::FirstID, size, perm); 335 if(!found){ 336 std::memset(info->names[target_entry].buf, 0, info_constants_t<0>::MaxName); 337 std::strcpy(info->names[target_entry].buf, shmname); 338 } 339 m_shm = boost::interprocess::move(temp); 340 } 341 } 342 } 343 344 m_mode = mode; 345 m_name = shmname; 346 return true; 347} 348 349inline bool xsi_shared_memory_device::remove(const char *shmname) 350{ 351 try{ 352 //Obtain index and index lockss 353 mapped_region region; 354 xsi_named_mutex mut; 355 std::string xsi_shm_emulation_file_path; 356 priv_obtain_index(region, mut, xsi_shm_emulation_file_path); 357 scoped_lock<xsi_named_mutex> lock(mut); 358 info_t *info = static_cast<info_t *>(region.get_address()); 359 360 //Now check and remove 361 bool removed = false; 362 363 for(std::size_t i = 0; i != info_constants_t<0>::NumID; ++i){ 364 if(0 == std::strcmp(info->names[i].buf, name)){ 365 xsi_shared_memory temp( open_only, xsi_shm_emulation_file_path.c_str() 366 , i+info_constants_t<0>::FirstID); 367 if(!xsi_shared_memory::remove(temp.get_shmid()) && (system_error_code() != invalid_argument)){ 368 return false; 369 } 370 std::memset(info->names[i].buf, 0, info_constants_t<0>::MaxName); 371 removed = true; 372 break; 373 } 374 } 375 return removed; 376 } 377 catch(...){ 378 return false; 379 } 380} 381 382inline bool xsi_shared_memory_device::remove(int shmid) 383{ return xsi_shared_memory::remove(shmid); } 384 385///@endcond 386 387} //namespace interprocess { 388} //namespace boost { 389 390#include <boost/interprocess/detail/config_end.hpp> 391 392#endif //BOOST_INTERPROCESS_XSI_SHARED_MEMORY_DEVICE_HPP