RamDisk.hxx

Go to the documentation of this file.

 
#ifndef _FREERTOS_DRIVERS_COMMON_RAMDISK_HXX_
#define _FREERTOS_DRIVERS_COMMON_RAMDISK_HXX_
 
#include <fcntl.h>
#include "Devtab.hxx"
 
class RamDiskBase : public Node
{
public:
    RamDiskBase(const char *path, void *data, unsigned size, bool read_only)
        : Node(path)
        , data_((uint8_t *)data)
        , size_(size)
        , readOnly_(read_only ? 1 : 0)
        , owned_(0)
    {
    }
 
private:
    void enable() OVERRIDE {}
    void disable() OVERRIDE {}
    void flush_buffers() OVERRIDE {}
 
    int open(File *file, const char * name, int flags, int mode) OVERRIDE
    {
        Node::open(file, name, flags, mode);
        if ((flags & O_TRUNC) && !readOnly_)
        {
            actualSize_ = 0;
        }
        return 0;
    }
 
    ssize_t read(File *file, void *buf, size_t count) OVERRIDE
    {
        if (file->offset >= file_size())
        {
            return 0;
        }
        size_t left = file_size() - file->offset;
        count = std::min(count, left);
        memcpy(buf, data_ + file->offset, count);
        file->offset += count;
        return count;
    }
 
    ssize_t write(File *file, const void *buf, size_t count) OVERRIDE
    {
        if (readOnly_)
        {
            return -EPERM;
        }
        if (file->offset >= size_)
        {
            return 0;
        }
        size_t left = size_ - file->offset;
        count = std::min(count, left);
        memcpy(data_ + file->offset, buf, count);
        file->offset += count;
        if (file->offset > (off_t)actualSize_)
        {
            actualSize_ = file->offset;
        }
        return count;
    }
 
protected:
    off_t file_size()
    {
        if (readOnly_)
        {
            return size_;
        }
        else
        {
            return actualSize_;
        }
    }
 
    uint8_t *data_;
    unsigned actualSize_ = 0;
    unsigned size_ : 30;
    unsigned readOnly_ : 1;
    unsigned owned_ : 1;
};
 
class RamDisk : public RamDiskBase
{
public:
    RamDisk(const char *path, size_t size)
        : RamDiskBase(path, new uint8_t[size], size, false)
    {
        memset(data_, 0, size_);
        owned_ = 1;
    }
 
    template<class T>
    RamDisk(const char* path, T* data, bool read_only = false)
        : RamDiskBase(path, data, sizeof(T), read_only) {
        owned_ = 0;
        actualSize_ = sizeof(T);
    }
 
    ~RamDisk()
    {
        if (owned_) {
            delete[] data_;
        }
    }
};
 
#endif // _FREERTOS_DRIVERS_COMMON_RAMDISK_HXX_