#include <pinnable_mapped_file.hpp>

Public Types
enum	map_mode { mapped , heap , locked }

typedef bip::managed_mapped_file::segment_manager	segment_manager

Public Member Functions
	pinnable_mapped_file (const bfs::path &dir, bool writable, uint64_t shared_file_size, bool allow_dirty, map_mode mode)

	pinnable_mapped_file (pinnable_mapped_file &&o)

pinnable_mapped_file &	operator= (pinnable_mapped_file &&)

	pinnable_mapped_file (const pinnable_mapped_file &)=delete

pinnable_mapped_file &	operator= (const pinnable_mapped_file &)=delete

	~pinnable_mapped_file ()

segment_manager *	get_segment_manager () const

Detailed Description

Definition at line 40 of file pinnable_mapped_file.hpp.

Member Typedef Documentation

◆ segment_manager

bip::managed_mapped_file::segment_manager chainbase::pinnable_mapped_file::segment_manager

Definition at line 42 of file pinnable_mapped_file.hpp.

Member Enumeration Documentation

◆ map_mode

enum chainbase::pinnable_mapped_file::map_mode

Enumerator
mapped
heap
locked

Definition at line 44 of file pinnable_mapped_file.hpp.

                    {
         mapped,
         heap,
         locked
      };

Constructor & Destructor Documentation

◆ pinnable_mapped_file() [1/3]

chainbase::pinnable_mapped_file::pinnable_mapped_file	(	const bfs::path &	dir,
		bool	writable,
		uint64_t	shared_file_size,
		bool	allow_dirty,
		map_mode	mode )

Definition at line 53 of file pinnable_mapped_file.cpp.

                                                                                                                                        :
   _data_file_path(bfs::absolute(dir/"shared_memory.bin")),
   _database_name(dir.filename().string()),
   _writable(writable)
{
   if(shared_file_size % _db_size_multiple_requirement) {
      std::string what_str("Database must be mulitple of " + std::to_string(_db_size_multiple_requirement) + " bytes");
      BOOST_THROW_EXCEPTION(std::system_error(make_error_code(db_error_code::bad_size), what_str));
   }
#ifdef _WIN32
   if(mode != mapped)
      BOOST_THROW_EXCEPTION(std::system_error(make_error_code(db_error_code::unsupported_win32_mode)));
#endif
   if(!_writable && !bfs::exists(_data_file_path)){
      std::string what_str("database file not found at " + _data_file_path.string());
      BOOST_THROW_EXCEPTION(std::system_error(make_error_code(db_error_code::not_found), what_str));
   }
 
   bfs::create_directories(dir);
 
   if(bfs::exists(_data_file_path)) {
      char header[header_size];
      std::ifstream hs(_data_file_path.generic_string(), std::ifstream::binary);
      hs.read(header, header_size);
      if(hs.fail())
         BOOST_THROW_EXCEPTION(std::system_error(make_error_code(db_error_code::bad_header)));
 
      db_header* dbheader = reinterpret_cast<db_header*>(header);
      if(dbheader->id != header_id) {
         std::string what_str("\"" + _database_name + "\" database format not compatible with this version of chainbase.");
         BOOST_THROW_EXCEPTION(std::system_error(make_error_code(db_error_code::incorrect_db_version), what_str));
      }
      if(!allow_dirty && dbheader->dirty) {
         std::string what_str("\"" + _database_name + "\" database dirty flag set");
         BOOST_THROW_EXCEPTION(std::system_error(make_error_code(db_error_code::dirty)));
      }
      if(dbheader->dbenviron != environment()) {
         std::cerr << "CHAINBASE: \"" << _database_name << "\" database was created with a chainbase from a different environment" << std::endl;
         std::cerr << "Current compiler environment:" << std::endl;
         std::cerr << environment();
         std::cerr << "DB created with compiler environment:" << std::endl;
         std::cerr << dbheader->dbenviron;
         BOOST_THROW_EXCEPTION(std::system_error(make_error_code(db_error_code::incompatible)));
      }
   }
 
   segment_manager* file_mapped_segment_manager = nullptr;
   if(!bfs::exists(_data_file_path)) {
      std::ofstream ofs(_data_file_path.generic_string(), std::ofstream::trunc);
      //win32 impl of bfs::resize_file() doesn't like the file being open
      ofs.close();
      bfs::resize_file(_data_file_path, shared_file_size);
      _file_mapping = bip::file_mapping(_data_file_path.generic_string().c_str(), bip::read_write);
      _file_mapped_region = bip::mapped_region(_file_mapping, bip::read_write);
      file_mapped_segment_manager = new ((char*)_file_mapped_region.get_address()+header_size) segment_manager(shared_file_size-header_size);
      new (_file_mapped_region.get_address()) db_header;
   }
   else if(_writable) {
         auto existing_file_size = bfs::file_size(_data_file_path);
         size_t grow = 0;
         if(shared_file_size > existing_file_size) {
            grow = shared_file_size - existing_file_size;
            bfs::resize_file(_data_file_path, shared_file_size);
         }
         else if(shared_file_size < existing_file_size) {
             std::cerr << "CHAINBASE: \"" << _database_name << "\" requested size of " << shared_file_size << " is less than "
                "existing size of " << existing_file_size << ". This database will not be shrunk and will "
                "remain at " << existing_file_size << std::endl;
         }
         _file_mapping = bip::file_mapping(_data_file_path.generic_string().c_str(), bip::read_write);
         _file_mapped_region = bip::mapped_region(_file_mapping, bip::read_write);
         file_mapped_segment_manager = reinterpret_cast<segment_manager*>((char*)_file_mapped_region.get_address()+header_size);
         if(grow)
            file_mapped_segment_manager->grow(grow);
   }
   else {
         _file_mapping = bip::file_mapping(_data_file_path.generic_string().c_str(), bip::read_only);
         _file_mapped_region = bip::mapped_region(_file_mapping, bip::read_only);
         file_mapped_segment_manager = reinterpret_cast<segment_manager*>((char*)_file_mapped_region.get_address()+header_size);
   }
 
   if(_writable) {
      //remove meta file created in earlier versions
      boost::system::error_code ec;
      bfs::remove(bfs::absolute(dir/"shared_memory.meta"), ec);
 
      _mapped_file_lock = bip::file_lock(_data_file_path.generic_string().c_str());
      if(!_mapped_file_lock.try_lock())
         BOOST_THROW_EXCEPTION(std::system_error(make_error_code(db_error_code::no_access)));
 
      set_mapped_file_db_dirty(true);
   }
 
   if(mode == mapped) {
      _segment_manager = file_mapped_segment_manager;
   }
   else {
      boost::asio::io_service sig_ios;
      boost::asio::signal_set sig_set(sig_ios, SIGINT, SIGTERM);
#ifdef SIGPIPE
      sig_set.add(SIGPIPE);
#endif
      sig_set.async_wait([](const boost::system::error_code&, int) {
         BOOST_THROW_EXCEPTION(std::system_error(make_error_code(db_error_code::aborted)));
      });
 
      try {
         setup_non_file_mapping();
         load_database_file(sig_ios);
 
#ifndef _WIN32
         if(mode == locked) {
            if(mlock(_non_file_mapped_mapping, _non_file_mapped_mapping_size)) {
               std::string what_str("Failed to mlock database \"" + _database_name + "\"");
               BOOST_THROW_EXCEPTION(std::system_error(make_error_code(db_error_code::no_mlock), what_str));
            }
            std::cerr << "CHAINBASE: Database \"" << _database_name << "\" has been successfully locked in memory" << std::endl;
         }
#endif
 
         _file_mapped_region = bip::mapped_region();
      }
      catch(...) {
         if(_writable)
            set_mapped_file_db_dirty(false);
         throw;
      }
 
      _segment_manager = reinterpret_cast<segment_manager*>((char*)_non_file_mapped_mapping+header_size);
   }
}

Here is the call graph for this function:

◆ pinnable_mapped_file() [2/3]

chainbase::pinnable_mapped_file::pinnable_mapped_file ( pinnable_mapped_file && o )

Definition at line 284 of file pinnable_mapped_file.cpp.

                                                                   :
   _mapped_file_lock(std::move(o._mapped_file_lock)),
   _data_file_path(std::move(o._data_file_path)),
   _database_name(std::move(o._database_name)),
   _file_mapped_region(std::move(o._file_mapped_region))
{
   _segment_manager = o._segment_manager;
   _writable = o._writable;
   _non_file_mapped_mapping = o._non_file_mapped_mapping;
   o._non_file_mapped_mapping = nullptr;
   o._writable = false; //prevent dtor from doing anything interesting
}

◆ pinnable_mapped_file() [3/3]

chainbase::pinnable_mapped_file::pinnable_mapped_file ( const pinnable_mapped_file & )

delete

◆ ~pinnable_mapped_file()

chainbase::pinnable_mapped_file::~pinnable_mapped_file ( )

Definition at line 310 of file pinnable_mapped_file.cpp.

                                            {
   if(_writable) {
      if(_non_file_mapped_mapping) { //in heap or locked mode
         _file_mapped_region = bip::mapped_region(_file_mapping, bip::read_write);
         save_database_file();
#ifndef _WIN32
         if(munmap(_non_file_mapped_mapping, _non_file_mapped_mapping_size))
            std::cerr << "CHAINBASE: ERROR: unmapping failed: " << strerror(errno) << std::endl;
#endif
      }
      else
         if(_file_mapped_region.flush(0, 0, false) == false)
            std::cerr << "CHAINBASE: ERROR: syncing buffers failed" << std::endl;
      set_mapped_file_db_dirty(false);
   }
}

Member Function Documentation

◆ get_segment_manager()

segment_manager * chainbase::pinnable_mapped_file::get_segment_manager ( ) const

inline

Definition at line 57 of file pinnable_mapped_file.hpp.

57{ return _segment_manager;}

Here is the caller graph for this function:

◆ operator=() [1/2]

pinnable_mapped_file & chainbase::pinnable_mapped_file::operator= ( const pinnable_mapped_file & )