memory_image.hpp

#if !defined(__MEMORY_IMAGE_HPP__)
#define __MEMORY_IMAGE_HPP__

//
// local includes
//
#include "block_driver_base.hpp"

struct memory_image : public block_driver_base, private noncopyable
{
  protected:
    const l4_sector_t size;
    uint8_t * const data;

  public:
    //
    // constructor & destructor
    //
    inline memory_image(l4_sector_t size=MIN_SECTOR_NUMBER, const state_flags flags=0)
        : block_driver_base(L4VMM_DRIVER" memory image", flags),
          size((size < MIN_SECTOR_NUMBER) ? MIN_SECTOR_NUMBER : size),
          data(new uint8_t[this->size * SECTOR_SIZE])
    {
        if (data) memset(data, 0, this->size * SECTOR_SIZE);
        else log::error("%s:\n  cannot allocate memory for "l4_sector_fmt" sectors\n",
                        name(), size);

        this->flags.clear(FLUSHABLE);
        this->flags.set(READY, data != nullptr);
    }

    virtual inline ~memory_image(void)
    {
        delete[] data;
    }

    //
    // medium functions
    //
    virtual inline l4_sector_t sectors(void) const
    {
        return is(READY) ? size : 0;
    }

    virtual inline int read_sectors(uint8_t *buffer, l4_sector_t sector, l4_sector_t number)
    {
        if (!is(READY)) return -L4_ENOTAVAIL;
        if (sector+number > size) return -L4_EINVAL;
        memcpy(buffer, data + sector * SECTOR_SIZE, number * SECTOR_SIZE);
        return 0;
    }

    virtual inline int write_sectors(uint8_t *buffer, l4_sector_t sector, l4_sector_t number)
    {
        if (!is(READY)) return -L4_ENOTAVAIL;
        if (sector+number > size) return -L4_EINVAL;
        memcpy(data + sector * SECTOR_SIZE, buffer, number * SECTOR_SIZE);
        return 0;
    }
};

#endif

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