Hi - I am having problems porting some boost::interprocess code from Win32 to Linux (rhel4). I am using boost-1.55. Here's the setup: I need to find if there is an existing instance of the process already running. When the process starts up, it checks the shared memory for a bIsProcessingRunning flag. If it is true, the process dumps some data into the shared memory and then exits. If not true, then the process starts up normally and then checks the shared memory for any updates. The class I use to wrap the boost::interprocess is below. Note: I needed the shared memory location to only be initialized the first time it was created so the only way I saw how to do it was through the src code was to use the initialization_func_t(). This approach works fine on Win32 but on Linux, it doesn't work. Thanks in advance for any suggestions or hints. ------------------------------------------------------------- #pragma once #include <boost/interprocess/shared_memory_object.hpp> #include <boost/interprocess/detail/managed_open_or_create_impl.hpp> #include <boost/interprocess/mapped_region.hpp> #include <boost/interprocess/sync/scoped_lock.hpp> #include <boost/interprocess/sync/interprocess_mutex.hpp> //---------------------------------------------------------------- // SSharedData // Structure of shared memory data contents //---------------------------------------------------------------- struct SSharedData { SSharedData() : bIsProcessRunning( false ), bIsData( false ), argc( 0 ) { } //Mutex to protect access to the queue boost::interprocess::interprocess_mutex mutex; bool bIsProcessRunning; bool bIsData; int argc; char argv[100][100]; }; //---------------------------------------------------------------- // CSharedMemory // Wrapper class to boost::interprocess for shared memory //---------------------------------------------------------------- class CSharedMemory { public: //---------------------------------------------------------------- // initialization_func_t // helper class to initialize shared memory to SSharedData //---------------------------------------------------------------- class initialization_func_t { public: initialization_func_t() {} bool operator()( void *pAddress, std::size_t nSize, bool bCreated ) { char *mptr; if( bCreated ) { mptr = reinterpret_cast<char*>(pAddress); // construct shared data structure BOOST_TRY { new (mptr) SSharedData(); } BOOST_CATCH( ... ) { return false; } BOOST_CATCH_END } return true; } }; public: CSharedMemory( std::string sName ) : m_pData( NULL ) { try { // erase previous shared memory boost::interprocess::shared_memory_object::remove( sName.c_str() ); // open a tempory shared memory object m_pShmem = new boost::interprocess::detail::managed_open_or_create_impl<boost::interprocess::s hared_memory_object>( boost::interprocess::open_or_create, sName.c_str() , sizeof( SSharedData ), boost::interprocess::read_write, (void*)0, //Prepare initialization functor initialization_func_t() ); // get the address of the mapped region void *pAddr = m_pShmem->get_address(); // construct the shared structure in memory m_pData = static_cast<SSharedData*>(pAddr); } catch( boost::interprocess::interprocess_exception &ex ) { std::cout << ex.what() << std::endl; } } ~CSharedMemory() { delete m_pShmem; } SSharedData *GetData() { return m_pData; } protected: SSharedData *m_pData; boost::interprocess::detail::managed_open_or_create_impl< boost::interprocess::shared_memory_object > *m_pShmem; };