source: flair-src/trunk/lib/FlairCore/src/SharedMem_impl.cpp@ 55

// %flair:license{
// This file is part of the Flair framework distributed under the
// CECILL-C License, Version 1.0.
// %flair:license}
//  created:    2014/02/10
//  filename:   SharedMem_impl.cpp
//
//  author:     Guillaume Sanahuja
//              Copyright Heudiasyc UMR UTC/CNRS 7253
//
//  version:    $Id: $
//
//  purpose:    Class defining a shared memory
//
//
/*********************************************************************/

#include "SharedMem_impl.h"
#include "SharedMem.h"
#include <fcntl.h>
#include <unistd.h>
#include <sys/mman.h>
#include <string.h>

using std::string;
using namespace flair::core;

SharedMem_impl::SharedMem_impl(const SharedMem *self, string name,
                               size_t size) {
  this->size = size;
  this->self = self;

#ifdef __XENO__
  heap_binded = false;
  int status = rt_heap_create(&heap, name.c_str(), size,
                              H_SHARED | H_FIFO | H_NONCACHED);
  if (status == -EEXIST) {
    heap_binded = true;
    status = rt_heap_bind(&heap, name.c_str(), TM_INFINITE);
  }
  if (status != 0) {
    self->Err("rt_heap_create error (%s)\n", strerror(-status));
    return;
  }

  void *ptr;
  status = rt_heap_alloc(&heap, 0, TM_NONBLOCK, &ptr);
  if (status != 0) {
    self->Err("rt_heap_alloc error (%s)\n", strerror(-status));
  }
  mem_segment = (char *)ptr;

  mutex_binded = false;
  string mutex_name = "mutex_" + name;
  status = rt_mutex_create(&mutex, mutex_name.c_str());
  if (status == -EEXIST) {
    mutex_binded = true;
    status = rt_mutex_bind(&mutex, mutex_name.c_str(), TM_INFINITE);
  }
  if (status != 0) {
    self->Err("rt_mutex_create error (%s)\n", strerror(-status));
    return;
  }

#else
  shm_name = "/" + name;
  fd = shm_open(shm_name.c_str(), O_RDWR | O_CREAT, 0666);
  if (fd == -1) {
    self->Err("Error creating shared memory\n");
  }
  ftruncate(fd, size);

  sem_name = "/" + name;
  sem = sem_open(sem_name.c_str(), O_CREAT, 0666, 1);
  if (sem == SEM_FAILED) {
    self->Err("Error creating semaphore\n");
  }

  mem_segment =
      (char *)mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
  if (mem_segment == MAP_FAILED) {
    self->Err("Failed to map memory\n");
  }
#endif
}

SharedMem_impl::~SharedMem_impl() {
  int status;
#ifdef __XENO__
  /* unnecessary because heap is opened in H_SINGLE mode
  status=rt_heap_free(&heap,mem_segment);
  if(status!=0)
  {
      self->Err("rt_heap_free error (%s)\n",strerror(-status));
  }
  */

  if (heap_binded == false) {
    status = rt_heap_delete(&heap);
    if (status != 0) {
      self->Err("rt_heap_delete error (%s)\n", strerror(-status));
    }
  }

  if (mutex_binded == false) {
    status = rt_mutex_delete(&mutex);
    if (status != 0) {
      self->Err("error destroying mutex (%s)\n", strerror(-status));
    }
  }
#else
  status = munmap(mem_segment, size);
  if (status != 0) {
    self->Err("Failed to unmap memory (%s)\n", strerror(-status));
  }

  status = close(fd);
  if (status != 0) {
    self->Err("Failed to close file (%s)\n", strerror(-status));
  }

  // do not check erros as it can be done by another process
  status = shm_unlink(shm_name.c_str()); /*
   if(status!=0)
   {
       self->Err("Failed to unlink memory (%s)\n",strerror(-status));
   }
*/
  // do not check erros as it can be done by another process
  status = sem_unlink(sem_name.c_str()); /*
   if(status!=0)
   {
       self->Err("Failed to unlink semaphore (%s)\n",strerror(-status));
   }*/

  status = sem_close(sem);
  if (status != 0) {
    self->Err("Failed to close semaphore (%s)\n", strerror(-status));
  }
#endif
}

void SharedMem_impl::Write(const char *buf, size_t size) {
#ifdef __XENO__
  int status = rt_mutex_acquire(&mutex, TM_INFINITE);
  if (status != 0)
    self->Err("error (%s)\n", strerror(-status));
  memcpy(mem_segment, buf, size);
  status = rt_mutex_release(&mutex);
  if (status != 0)
    self->Err("error (%s)\n", strerror(-status));
#else
  sem_wait(sem);
  memcpy(mem_segment, buf, size);
  sem_post(sem);
#endif
}

void SharedMem_impl::Read(char *buf, size_t size) {
#ifdef __XENO__
  int status = rt_mutex_acquire(&mutex, TM_INFINITE);
  if (status != 0)
    self->Err("error (%s)\n", strerror(-status));
  memcpy(buf, mem_segment, size);
  status = rt_mutex_release(&mutex);
  if (status != 0)
    self->Err("error (%s)\n", strerror(-status));
#else
  sem_wait(sem);
  memcpy(buf, mem_segment, size);
  sem_post(sem);
#endif
}