shared_mem.hpp

Go to the documentation of this file.

/******************************************************************************
** Copyright © 2019 by J.M.McGuiness, coder@hussar.me.uk
**
** This library is free software; you can redistribute it and/or
** modify it under the terms of the GNU Lesser General Public
** License as published by the Free Software Foundation; either
** version 2.1 of the License, or (at your option) any later version.
**
** This library is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
** Lesser General Public License for more details.
**
** You should have received a copy of the GNU Lesser General Public
** License along with this library; if not, write to the Free Software
** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
 
#include "core/exception.hpp"
#include "core/sizeof_void.hpp"
#include "core/syscall_wrapper.hpp"
 
#include <sys/mman.h>
#include <sys/stat.h>   /* For mode constants */
#include <fcntl.h>
 
namespace jmmcg { namespace LIBJMMCG_VER_NAMESPACE {
 
/// A class to wrap POSIX (inter-process) shared-memory.
class shared_mem {
public:
   using exception_type=crt_exception<ppd::platform_api, ppd::heavyweight_threading>;
   using handle_t=int;
 
   enum oflags_t : int {
      oflags_read_only=O_RDONLY,
      oflags_read_write=O_RDWR,
      oflags_create_if_not_exists=O_CREAT,
      oflags_exclusive_or_error=O_EXCL,
      oflags_truncate_if_exists=O_TRUNC
   };
   using oflags_type=std::underlying_type<oflags_t>::type;
   enum flags_t : int {
      /// Requires kernel support and configuration.
      /**
         <a href="https://www.kernel.org/doc/html/latest/admin-guide/mm/hugetlbpage.html"/>
      */
      flags_use_hugetlb=MAP_HUGETLB
   };
   enum mode_type : mode_t {
      mode_rwxrwxrwx=ACCESSPERMS,
      mode_srwxrwxrwx=ALLPERMS,
      mode_rwrwrw=DEFFILEMODE
   };
   enum protection_type : int {
      protection_read_only=PROT_READ,
      protection_read_write=PROT_READ|PROT_WRITE,
      protection_read_write_execte=PROT_READ|PROT_WRITE|PROT_EXEC
   };
   enum sync_flags_t : int {
      schedule_updates_return_immed=MS_ASYNC,
      req_update_wait=MS_SYNC
   };
 
   shared_mem(std::string const &name, std::size_t length, oflags_type oflags=oflags_create_if_not_exists|oflags_read_write, mode_type mode=mode_rwrwrw, protection_type prot=protection_read_write) noexcept(false);
   ~shared_mem() noexcept(true);
 
   template<
      class T  ///< If one wishes to obtain an anonymous pointer (a "void *"), suitable for placement-new, simply used "void" as the template-argument.
   >
   T *get() noexcept(false);
   template<
      class T  ///< If one wishes to obtain an anonymous pointer (a "void *"), suitable for placement-new, simply used "void" as the template-argument.
   >
   T const *get() const noexcept(false);
 
   void sync(void *addr, std::size_t length, sync_flags_t sync_flags=schedule_updates_return_immed) noexcept(false);
   template<class T>
   void sync(T *addr, sync_flags_t sync_flags=schedule_updates_return_immed) noexcept(false);
 
private:
   const std::string name_;
   const std::size_t length_;
   handle_t fd;
   void *addr_;
 
   static handle_t open_fd(std::string const &name, oflags_type oflags, mode_type mode) noexcept(false);
   static void *map_fd(handle_t fd, std::size_t length, protection_type prot) noexcept(false);
};
 
template<class T>
inline T *
shared_mem::get() noexcept(false) {
   if (private_::give_void_a_size_of<T>::value<=length_) {
      return reinterpret_cast<T *>(addr_);
   } else {
      info::function fun(__LINE__, __PRETTY_FUNCTION__, typeid(this), info::function::argument(_T("sizeof(T)"), private_::give_void_a_size_of<T>::value));
      fun.add_arg(info::function::argument(_T("std::size_t length_"), length_));
      throw exception_type(_T("Requested size too large."), std::move(fun), JMMCG_REVISION_HDR(_T(LIBJMMCG_VERSION_NUMBER)));
   }
}
 
template<class T>
inline T const *
shared_mem::get() const noexcept(false) {
   if (private_::give_void_a_size_of<T>::value<=length_) {
      return reinterpret_cast<T const *>(addr_);
   } else {
      info::function fun(__LINE__, __PRETTY_FUNCTION__, typeid(this), info::function::argument(_T("sizeof(T)"), private_::give_void_a_size_of<T>::value));
      fun.add_arg(info::function::argument(_T("std::size_t length_"), length_));
      throw exception_type(_T("Requested size too large."), std::move(fun), JMMCG_REVISION_HDR(_T(LIBJMMCG_VERSION_NUMBER)));
   }
}
 
template<class T>
inline void
shared_mem::sync(T *addr, sync_flags_t sync_flags) noexcept(false) {
   constexpr std::size_t length=sizeof(T);
   if (addr<addr_) {
      info::function fun(__LINE__, __PRETTY_FUNCTION__, typeid(this), info::function::argument(_T("T *addr"), addr));
      fun.add_args(
         info::function::argument(_T("std::size_t length"), length),
         info::function::argument(_T("sync_flags_t sync_flags"), sync_flags),
         info::function::argument(_T("void *addr_"), addr_)
      );
      throw exception_type(_T("Requested address less than mapped address."), std::move(fun), JMMCG_REVISION_HDR(_T(LIBJMMCG_VERSION_NUMBER)));
   }
   if ((reinterpret_cast<std::uint8_t const *>(addr)+length)>(reinterpret_cast<std::uint8_t const *>(addr_)+length_)) {
      info::function fun(__LINE__, __PRETTY_FUNCTION__, typeid(this), info::function::argument(_T("T *addr"), addr));
      fun.add_args(
         info::function::argument(_T("std::size_t length"), length),
         info::function::argument(_T("sync_flags_t sync_flags"), sync_flags),
         info::function::argument(_T("std::size_t length_"), length_),
         info::function::argument(_T("void *addr_"), addr_)
      );
      throw exception_type(_T("Requested address plus length less than mapped address ."), std::move(fun), JMMCG_REVISION_HDR(_T(LIBJMMCG_VERSION_NUMBER)));
   }
   JMMCG_SYSCALL_WRAPPER("Unable sync the portion of the mapped memory.", _T(LIBJMMCG_VERSION_NUMBER), ::msync, addr, length, sync_flags);
}
 
} }