ShmFactory.h

Go to the documentation of this file.

// Copyright CERN 2012 - Developed in collaboration with GSI

#ifndef SHM_FACTORY_H
#define SHM_FACTORY_H

#include <fesa-core/DataStore/DeviceFactoryImp.h>
#include <fesa-core/DataStore/EquipmentData.h>
#include <fesa-core/Utilities/Semaphore.h>

#include <cmw-log/Logger.h>

#include <cstring>
#include <string>
#include <iostream>
#include <cerrno>
#include <sys/mman.h>
#include <fcntl.h>

namespace fesa
{

template<typename GlobalDeviceType, typename DomainStoreType, typename DevInstType> class DeviceFactoryImp;

typedef struct
{
    int32_t shmSize;
    int32_t globalDeviceSize;
    int32_t domainStoreSize;
    int32_t devicesSize;
    int32_t muxManagersSize;
    int32_t equipmentSize;
} ShmHeader_t;

template<typename GlobalDeviceType, typename DomainStoreType, typename DevInstType>
class ShmFactory : public DeviceFactoryImp<GlobalDeviceType, DomainStoreType, DevInstType>
{
  public:
    ShmFactory(const std::string& className);

    bool setUpMemory();

    void createSharedMemory();

    bool attachSharedMemory(int32_t fd);

    void removeSharedMemory();

    ShmHeader_t* pShmHeader_;

    int32_t shmSize_;

    std::string shmName_;

    char* pAddrMuxManagersSpace_;

    char* pAddrDeviceInstanceSpace_;

    char* pAddrGlobalDeviceSpace_;

    char* pAddrDomainStoreSpace_;


    char* pAddrEquipmentDataSpace_;

  private:
    static CMW::Log::Logger& logger_; // we're in a template => can't have it file-scoped

};

//******************************************************************
template<typename GlobalDeviceType, typename DomainStoreType, typename DevInstType>
CMW::Log::Logger& ShmFactory<GlobalDeviceType, DomainStoreType, DevInstType>::logger_ = CMW::Log::LoggerFactory::getLogger("FESA.FWK.fesa-core.DataStore.ShmFactory"); // we're in a header => can't have it file-scoped

template<typename GlobalDeviceType, typename DomainStoreType, typename DevInstType>
inline ShmFactory<GlobalDeviceType, DomainStoreType, DevInstType>::ShmFactory(const std::string& className) :
    DeviceFactoryImp<GlobalDeviceType, DomainStoreType, DevInstType> (className)
{
    shmName_ = className + "EquipmentShm";
}

template<typename GlobalDeviceType, typename DomainStoreType, typename DevInstType>
inline void ShmFactory<GlobalDeviceType, DomainStoreType, DevInstType>::removeSharedMemory()
{
    try
    {
        if ((munmap(pShmHeader_, sizeof(shmSize_))) != -1)
        {
            shm_unlink(shmName_.c_str());
        }
    }
    catch (...)
    {
        throw FesaException(__FILE__, __LINE__, FesaErrorRemovingSharedMemory.c_str(), shmName_.c_str());
    }
    {
        std::ostringstream message;
        message << "\nShared Memory " << shmName_ << " destroyed!" << std::endl;
        LOG_TRACE_IF(logger_, message.str());
    }
}

template<typename GlobalDeviceType, typename DomainStoreType, typename DevInstType>
inline bool ShmFactory<GlobalDeviceType, DomainStoreType, DevInstType>::setUpMemory()
{
    // set up of the memory must be protected as Server and RT
    // part in mode split could run in parallel doing each one its own initialization.
    // Only one shared semaphore per equipment
    Semaphore sem("Shm" + AbstractEquipment::getInstance()->getEquipmentName(), 1);
    sem.wait();
    int32_t fd;
    bool shmHasBeenCreated = false;
    try
    {
        // Check if the shared memory exist
        if ((fd = shm_open(shmName_.c_str(), O_RDWR, S_IRWXU)) == -1)
        {
            // Check errno to see if it is not a question of permission
            if (errno == EACCES)
            {
                throw FesaException(__FILE__, __LINE__, FesaErrorOpeningSharedMemory.c_str(), shmName_.c_str());
            }

            createSharedMemory();
            this->mapFields(pAddrMuxManagersSpace_, true);
            shmHasBeenCreated = true;
            {
                std::ostringstream message;
                message << "Created shared-memory: " << shmName_ << std::endl;
                LOG_TRACE_IF(logger_, message.str());
            }
        }
        else // shm exists
        {
            if (attachSharedMemory(fd))
            {
                EquipmentData* eqData = EquipmentData::getInstance();

                // If it is the first time the current process check the shared memory
                // we need to check if we need to re-created
                bool checkProcessesAttachedShm = (eqData->isInitialize_ == NULL);
                this->mapFields(pAddrMuxManagersSpace_, false);
                shmHasBeenCreated = false;

                if (checkProcessesAttachedShm == true) // only checked once per process, no matter the number of DeviceClass it contains
                {
                    bool isRTProcessRegistered = (*(eqData->rtProcessID_ )!= 0);
                    bool isServerProcessRegistered = (*(eqData->serverProcessID_ )!= 0);
                    bool isRegisteredRTProcessUp = false;
                    bool isRegisteredServerProcessUp = false;
                    if (isRTProcessRegistered)
                    {
                        // is the rt process up?
                        if(kill(*(eqData->rtProcessID_), SIGFESA_CHECK_PROCESS_ALIVE) == 0) // if the signal is  successfully sent means that the process is  up
                        {
                            isRegisteredRTProcessUp = true;
                        }
                        else
                        {
                            if (errno != ESRCH)  // errno = ESRCH means that the process is not running
                            {
                                // If the error is different that ESRCH (i.e. no rights to send signal) we should abort
                                throw FesaException(__FILE__, __LINE__, FesaErrorNoPermissionToSendSignals.c_str());
                            }
                        }
                    }
                    if (isServerProcessRegistered)
                    {
                        // is the server process up?
                        if(kill(*(eqData->serverProcessID_), SIGFESA_CHECK_PROCESS_ALIVE) == 0) // if the signal is  successfully sent means that the process is  up
                        {
                            isRegisteredServerProcessUp = true;
                        }
                        else
                        {
                            if (errno != ESRCH)  // errno = ESRCH means that the process is not running
                            {
                                // If the error is different that ESRCH (i.e. no rights to send signal) we should abort
                                throw FesaException(__FILE__, __LINE__, FesaErrorNoPermissionToSendSignals.c_str());
                            }
                        }
                    }
                    if ( (!isRTProcessRegistered && !isServerProcessRegistered ) || // if shm created but no process registered
                         ( !isRegisteredServerProcessUp && !isRegisteredRTProcessUp) ) // if none of the registered process runs
                    {
                        this->unmapFields(); // as fields were mapped, we need to unmap them
                        removeSharedMemory();
                        createSharedMemory();
                        this->mapFields(pAddrMuxManagersSpace_, true);
                        shmHasBeenCreated = true;
                    }
                }
                {
                    std::ostringstream message;
                    message <<"Attached Shared Memory: " << shmName_<< std::endl;
                    LOG_TRACE_IF(logger_, message.str());
                }
            } 
            else 
            {
                removeSharedMemory();
                createSharedMemory();
                this->mapFields(pAddrMuxManagersSpace_, true);
                shmHasBeenCreated = true;
                {
                    std::ostringstream message;
                    message << "Remove and Created shared-memory: " << shmName_ << std::endl;
                    LOG_TRACE_IF(logger_, message.str());
                }
            }
        }
        if(logger_.isLoggable(CMW::Log::Level::LL_TRACE)) {
            std::ostringstream message;
            message <<"Space allocated for mux managers :" << this->muxManagersSize_<< std::endl;
            message <<"Space allocated for GlobalDevice :" << this->globalDeviceSize_<< std::endl;
            message <<"Space allocated for DomainStore :" << this->domainStoreSize_<< std::endl;
            message <<"Space allocated for devices :" << this->devicesSize_<< std::endl;
            message <<"Total size of the SHM: " << shmSize_<< std::endl;
            LOG_TRACE_IF(logger_, message.str());
        }
    }
    catch (FesaException& ex)
    {
        close(fd);
        sem.post();
        throw FesaException(ex.getFileName(), ex.getLineNumber(), FesaErrorShmFactorySettingUpMemory.c_str());
    }
    close(fd);
    sem.post();
    return (shmHasBeenCreated);
}

template<typename GlobalDeviceType, typename DomainStoreType, typename DevInstType>
inline void ShmFactory<GlobalDeviceType, DomainStoreType, DevInstType>::createSharedMemory()

{
    int32_t org_mask = umask(0); // set the user mask to 0 in order to create the semaphore with the wanted rights
    int32_t fd;
    if ((fd = shm_open(shmName_.c_str(), O_CREAT | O_RDWR, S_IRWXU | S_IRWXG | S_IRWXO)) == -1)
    {
        umask(org_mask); // restore the original umask
        throw FesaException(__FILE__, __LINE__, FesaErrorCreatingSharedMemory.c_str(), shmName_.c_str());
    }
    umask(org_mask); // restore the original umask

    this->computeMemorySize();

    // Compute the size: of static members
    shmSize_ = 0;
    shmSize_ += sizeof(ShmHeader_t);
    shmSize_ += this->muxManagersSize_;
    shmSize_ += this->globalDeviceSize_;
    shmSize_ += this->domainStoreSize_;
    shmSize_ += this->devicesSize_;
    shmSize_ += this->equimentDataSize_;

    // Resize it to fit the header and the requested space.
    if ((ftruncate(fd, shmSize_)) < 0)
    {
        throw FesaException(__FILE__, __LINE__, FesaErrorResizingSharedMemory.c_str(), shmName_.c_str());
    }

    // Map header space to the process
    if ((pShmHeader_ = (ShmHeader_t*) mmap(0, shmSize_, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0)) == 0)
    {
        throw FesaException(__FILE__, __LINE__, FesaErrorMappingSharedMemory.c_str(), shmName_.c_str());
    }

    // Reset the memory
    std::memset(pShmHeader_, 0, shmSize_);

    // Fill the requested size for later use by the link.
    pShmHeader_->shmSize = shmSize_;
    pShmHeader_->muxManagersSize = this->muxManagersSize_;
    pShmHeader_->globalDeviceSize = this->globalDeviceSize_;
    pShmHeader_->domainStoreSize = this->domainStoreSize_;
    pShmHeader_->devicesSize = this->devicesSize_;
    pShmHeader_->equipmentSize = this->equimentDataSize_;

    // Compute the userSpace address : address of the first device instance
    pAddrMuxManagersSpace_ = (char*) ((char*) pShmHeader_ + sizeof(ShmHeader_t));
    pAddrGlobalDeviceSpace_ = pAddrMuxManagersSpace_ + this->muxManagersSize_;
    pAddrDomainStoreSpace_ = pAddrGlobalDeviceSpace_ + this->globalDeviceSize_;
    pAddrDeviceInstanceSpace_ = pAddrDomainStoreSpace_ + this->domainStoreSize_;
    pAddrEquipmentDataSpace_ = pAddrDeviceInstanceSpace_ + this->devicesSize_;
    close(fd);
}

template<typename GlobalDeviceType, typename DomainStoreType, typename DevInstType>
inline bool ShmFactory<GlobalDeviceType, DomainStoreType, DevInstType>::attachSharedMemory(int32_t fd)

{
    // Map header space to the process *
    if ((pShmHeader_ = (ShmHeader_t *) mmap(0, sizeof(ShmHeader_t), PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0))
        == 0)
    {
        throw FesaException(__FILE__, __LINE__, FesaErrorMappingSharedMemory.c_str(), shmName_.c_str());
    }
    this->computeMemorySize();

    // Compute the size: of static members
    shmSize_ = 0;
    shmSize_ += sizeof(ShmHeader_t);
    shmSize_ += this->muxManagersSize_;
    shmSize_ += this->globalDeviceSize_;
    shmSize_ += this->domainStoreSize_;
    shmSize_ += this->devicesSize_;
    shmSize_ += this->equimentDataSize_;

    if (shmSize_ != pShmHeader_->shmSize || this->muxManagersSize_ != pShmHeader_->muxManagersSize
        || this->globalDeviceSize_ != pShmHeader_->globalDeviceSize || this->domainStoreSize_
        != pShmHeader_->domainStoreSize || this->devicesSize_ != pShmHeader_->devicesSize || this->equimentDataSize_ != pShmHeader_->equipmentSize)
    {
        // Unmap the header
        if ((munmap(pShmHeader_, sizeof(ShmHeader_t))) == -1)
        {
            throw FesaException(__FILE__, __LINE__, FesaErrorUnMappingSharedMemory.c_str(), shmName_.c_str());
        }
        return false;
    }

    // Unmap the header
    if ((munmap(pShmHeader_, sizeof(ShmHeader_t))) == -1)
    {
        throw FesaException(__FILE__, __LINE__, FesaErrorUnMappingSharedMemory.c_str(), shmName_.c_str());
    }

    // Map shared memory user space to the process
    char* pAddr;
    if ((pAddr = (char *) mmap(0, shmSize_, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0)) == 0)
    {
        throw FesaException(__FILE__, __LINE__, FesaErrorMappingSharedMemory.c_str(), shmName_.c_str());
    }

    // Set pointer to user space
    pAddrMuxManagersSpace_ = pAddr + sizeof(ShmHeader_t);
    pAddrGlobalDeviceSpace_ = pAddrMuxManagersSpace_ + this->muxManagersSize_;
    pAddrDomainStoreSpace_ = pAddrGlobalDeviceSpace_ + this->globalDeviceSize_;
    pAddrDeviceInstanceSpace_ = pAddrDomainStoreSpace_ + this->domainStoreSize_;
    pAddrEquipmentDataSpace_ = pAddrDeviceInstanceSpace_ + this->devicesSize_;

    return true;
}
} // fesa
#endif // SHM_FACTORY_H