dataspace.hpp

#if !defined(__DATASPACE_HPP__)
#define __DATASPACE_HPP__

//
// standard includes
//
#include <stdint.h>
#include <string>

//
// L4 includes
//
#include <l4/dm_phys/dm_phys.h>

//
// local includes
//
#include "core/util/noncopyable.hpp"
#include "core/util/c++0x.hpp"

struct dataspace : private noncopyable
{
    std::string      ds_name;
    l4dm_dataspace_t id;
    l4_size_t        size;
    uint8_t          *base;

    //
    // constructors & destructor
    //
    inline dataspace(const std::string &name="", const l4_size_t size=0)
        : ds_name(name), id(L4DM_INVALID_DATASPACE), size(size), base(nullptr)
    {
        // assume the dataspace is not yet opened. store its intended name & size.
    }

    inline dataspace(const std::string &name, const l4dm_dataspace_t &id, const l4_size_t size)
        : ds_name(name), id(id), size(size), base(nullptr)
    {
        // assume the dataspace is opened, but not attached. initialize object and attach.
        attach();
    }

    inline dataspace(const std::string &name, const l4dm_dataspace_t &id,
                     const l4_size_t size, void *base)
        : ds_name(name), id(id), size(size), base(reinterpret_cast<uint8_t *>(base))
    {
        // assume the dataspace is already attached. only initialize object.
    }

    virtual inline ~dataspace(void)
    {
        detach_close();
    }

    //
    // set functions
    //
    inline dataspace &operator()(const std::string &name, const l4dm_dataspace_t &id,
                                 const l4_size_t size, void *base=nullptr)
    {
        detach_close();
        this->ds_name=name;
        this->id=id;
        this->size=size;
        this->base=reinterpret_cast<uint8_t *>(base);
        return *this;
    }

    //
    // query functions
    //
    inline const char *name(void) const
    {
        return ds_name.c_str();
    }

    inline bool is_open(void) const
    {
        return !l4dm_is_invalid_ds(id);
    }

    inline bool is_attached(void) const
    {
        return base;
    }

    inline uint8_t *data(void) const
    {
        return base;
    }

    //
    // L4DM: helper functions: share
    //
    virtual int share(l4_threadid_t client, uint32_t flags=L4DM_RW);

    //
    // L4RM: helper functions: attach / detach
    //
    virtual int attach(uint32_t flags=L4DM_RW);
    virtual int detach(void);
    virtual int detach_close(void);
};

#endif

// ***** end of source ***** //