MapFile.cpp

Go to the documentation of this file.

// DUNE DAQ modification notice:
// This file has been modified from the original ATLAS system source for the DUNE DAQ project.
// Fork baseline commit: system-00-00-20 (2020-09-25).
// Renamed since fork: yes (from src/MapFile.cxx to src/MapFile.cpp).
 
/*
 *  MapFile.cxx
 *  ers
 *
 *  Created by Matthias Wiesmann on 07.01.05.
 *  Copyright 2005 CERN. All rights reserved.
 *
 */
 
#include <iostream>
#include <sys/mman.h>
#include <sys/types.h>
#include <unistd.h>
 
#include "okssystem/Descriptor.hpp"
#include "okssystem/MapFile.hpp"
#include "okssystem/exceptions.hpp"
 
#include "ers/Assertion.hpp"

 
OksSystem::MapFile::MapFile(const std::string& name, size_t s, size_t o, bool read_mode, bool write_mode, mode_t perm)
  : File(name)
{
  ERS_PRECONDITION((read_mode || write_mode));
  const int page_size = getpagesize();
  ERS_PRECONDITION((s % page_size) == 0);
  ERS_PRECONDITION((o % page_size) == 0);
  (void)page_size; // to suppress warning when asserts are disabled
  m_map_read = read_mode;
  m_map_write = write_mode;
  m_map_permission = perm;
  m_map_size = s;
  m_map_offset = o;
  m_map_address = 0;
  m_map_descriptor = 0;
  m_is_mapped = false;
} // MapFile

 
OksSystem::MapFile::~MapFile()
{
  if (m_map_descriptor != 0) {
    close_fd();
  } // file descriptor open
} // ~MapFile

 
void
OksSystem::MapFile::open_fd()
{
  const int flags = OksSystem::Descriptor::flags(m_map_read, m_map_write);
  m_map_descriptor = new OksSystem::Descriptor(this, flags, m_map_permission);
} // open_fd

 
void
OksSystem::MapFile::close_fd()
{
  m_map_descriptor->close();
  delete (m_map_descriptor);
  m_map_descriptor = 0;
} // close_fd

 
void
OksSystem::MapFile::map_mem()
{
  ERS_PRECONDITION(m_map_descriptor);
  int prot = 0;
  int flags = MAP_FILE | MAP_SHARED;
  if (m_map_read) {
    prot |= PROT_READ;
  }
  if (m_map_write) {
    prot |= PROT_WRITE;
  }
  m_map_address = ::mmap(0, m_map_size, prot, flags, *m_map_descriptor, m_map_offset);
  if (m_map_address == MAP_FAILED || m_map_address == 0) {
    m_is_mapped = false;
    std::string message = "on file " + this->full_name();
    throw OksSystem::OksSystemCallIssue(ERS_HERE, errno, "mmap", message.c_str());
  } /* map_failed */ else {
    m_is_mapped = true;
  }
} // map_mem

 
void
OksSystem::MapFile::unmap_mem()
{
  ERS_PRECONDITION(m_map_address != 0);
  const int status = munmap(m_map_address, m_map_size);
  if (status < 0) {
    m_is_mapped = true;
    std::string message = "on file " + this->full_name();
    throw OksSystem::OksSystemCallIssue(ERS_HERE, errno, "munmap", message.c_str());
  } else {
    m_is_mapped = false;
  }
} // unmap_mem

 
void
OksSystem::MapFile::zero() const
{
  ERS_ASSERT(m_map_write == true);
  const int flags = OksSystem::Descriptor::flags(false, true);
  OksSystem::Descriptor fd(this, flags, m_map_permission);
  const int page_size = ::getpagesize();
  const int page_num = (m_map_size + m_map_offset) / page_size;
  void* buffer = calloc(1, page_size);
  for (int i = 0; i < page_num; i++) {
    fd.write(buffer, page_size);
  } // for
  free(buffer);
  fd.close();
} // zero

 
void
OksSystem::MapFile::map()
{
  open_fd();
  map_mem();
} // map

 
void
OksSystem::MapFile::unmap()
{
  unmap_mem();
  close_fd();
} // unmap
 
bool
OksSystem::MapFile::is_loaded() const throw()
{
  return (m_map_address != 0);
} // is_loaded

 
void*
OksSystem::MapFile::address() const throw()
{
  return m_map_address;
} // address

 
size_t
OksSystem::MapFile::memory_size() const throw()
{
  return m_map_size;
} // memory_size

 
bool
OksSystem::MapFile::is_mapped() const
{
  return m_is_mapped;
}
 
OksSystem::Descriptor*
OksSystem::MapFile::fd() const throw()
{
  return m_map_descriptor;
}