BlockDevice.h

Go to the documentation of this file.

/****
 * Sming Framework Project - Open Source framework for high efficiency native ESP8266 development.
 * Created 2015 by Skurydin Alexey
 * http://github.com/SmingHub/Sming
 * All files of the Sming Core are provided under the LGPL v3 license.
 *
 * BlockkDevice.h
 *
 ****/
#pragma once
 
#include <Storage/Device.h>
#include "Buffer.h"
#include <map>
 
namespace Storage::Disk
{
class BlockDevice : public Device
{
public:
    bool read(storage_size_t address, void* dst, size_t size) override
    {
        return transfer(address, dst, size, false);
    }
 
    bool write(storage_size_t address, const void* src, size_t size) override
    {
        return transfer(address, const_cast<void*>(src), size, true);
    }
 
    bool erase_range(storage_size_t address, storage_size_t size) override;
 
    size_t getBlockSize() const override
    {
        return sectorSize;
    }
 
    storage_size_t getSize() const override
    {
        return sectorCount << sectorSizeShift;
    }
 
    storage_size_t getSectorCount() const override
    {
        return sectorCount;
    }
 
    bool sync() override;
 
    bool allocateBuffers(unsigned numBuffers);
 
    struct Stat {
        enum Function { read, write, erase };
        struct Func {
            uint32_t count[2]{}; // Hit, Miss
 
            uint32_t totalCount() const
            {
                return count[0] + count[1];
            }
 
            size_t printTo(Print& p) const;
        };
        Func func[3];                     
        std::map<uint32_t, Func> sectors; 
 
        void update(Function fn, uint32_t sector, uint32_t cacheSector);
        size_t printTo(Print& p) const;
    };
    Stat stat;
 
protected:
    virtual bool raw_sector_read(storage_size_t address, void* dst, size_t size) = 0;
    virtual bool raw_sector_write(storage_size_t address, const void* src, size_t size) = 0;
    virtual bool raw_sector_erase_range(storage_size_t address, size_t size) = 0;
    virtual bool raw_sync() = 0;
 
    bool transfer(storage_size_t address, void* data, size_t size, bool isWrite);
    bool flushBuffer(Buffer& buf);
    bool flushBuffers();
 
    std::unique_ptr<BufferList> buffers;
    uint64_t sectorCount{0};
    uint16_t sectorSize{defaultSectorSize};
    uint8_t sectorSizeShift{getSizeBits(defaultSectorSize)};
};
 
} // namespace Storage::Disk