MapFile.cpp

Go to the documentation of this file.

/*
 *  MapFile.cxx
 *  ers
 *
 *  Created by Matthias Wiesmann on 07.01.05.
 *  Copyright 2005 CERN. All rights reserved.
 *
 */
 
#include <sys/types.h>
#include <sys/mman.h>
#include <iostream>
#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;
}