FsCache.h

Go to the documentation of this file.

#ifndef FsCache_h
#define FsCache_h
#include "BlockDevice.h"
#include "SysCall.h"
class FsCache
{
  public:
    static const uint8_t CACHE_STATUS_DIRTY = 1;
    static const uint8_t CACHE_STATUS_MIRROR_FAT = 2;
    static const uint8_t CACHE_STATUS_MASK = CACHE_STATUS_DIRTY | CACHE_STATUS_MIRROR_FAT;
    static const uint8_t CACHE_OPTION_NO_READ = 4;
    static const uint8_t CACHE_FOR_READ = 0;
    static const uint8_t CACHE_FOR_WRITE = CACHE_STATUS_DIRTY;
    static const uint8_t CACHE_RESERVE_FOR_WRITE = CACHE_STATUS_DIRTY | CACHE_OPTION_NO_READ;
    //----------------------------------------------------------------------------
    uint8_t *cacheBuffer()
    {
        return m_buffer;
    }

    bool cacheSafeRead(uint32_t sector, uint8_t *dst)
    {
        if (isCached(sector))
        {
            memcpy(dst, m_buffer, 512);
            return true;
        }
        return m_blockDev->readSector(sector, dst);
    }

    bool cacheSafeRead(uint32_t sector, uint8_t *dst, size_t count)
    {
        if (isCached(sector, count) && !sync())
        {
            return false;
        }
        return m_blockDev->readSectors(sector, dst, count);
    }

    bool cacheSafeWrite(uint32_t sector, const uint8_t *src)
    {
        if (isCached(sector))
        {
            invalidate();
        }
        return m_blockDev->writeSector(sector, src);
    }

    bool cacheSafeWrite(uint32_t sector, const uint8_t *src, size_t count)
    {
        if (isCached(sector, count))
        {
            invalidate();
        }
        return m_blockDev->writeSectors(sector, src, count);
    }

    uint8_t *clear()
    {
        if (isDirty() && !sync())
        {
            return nullptr;
        }
        invalidate();
        return m_buffer;
    }

    void dirty()
    {
        m_status |= CACHE_STATUS_DIRTY;
    }

    void init(BlockDevice *blockDev)
    {
        m_blockDev = blockDev;
        invalidate();
    }

    void invalidate()
    {
        m_status = 0;
        m_sector = 0XFFFFFFFF;
    }

    bool isCached(uint32_t sector) const
    {
        return sector == m_sector;
    }

    bool isCached(uint32_t sector, size_t count)
    {
        return sector <= m_sector && m_sector < (sector + count);
    }

    bool isDirty()
    {
        return m_status & CACHE_STATUS_DIRTY;
    }

    uint32_t sector()
    {
        return m_sector;
    }

    void setMirrorOffset(uint32_t offset)
    {
        m_mirrorOffset = offset;
    }

    uint8_t *get(uint32_t sector, uint8_t option);
    bool sync();
 
  private:
    uint8_t m_status;
    BlockDevice *m_blockDev;
    uint32_t m_mirrorOffset;
    uint32_t m_sector;
    uint8_t m_buffer[512];
};
#endif // FsCache_h