SPIFFS.hxx

Go to the documentation of this file.

 
#ifndef _FREERTOS_DRIVERS_SPIFFS_SPIFFS_HXX_
#define _FREERTOS_DRIVERS_SPIFFS_SPIFFS_HXX_
 
#include <functional>
 
#include "Devtab.hxx"
#include "utils/Atomic.hxx"
 
extern "C" {
struct spiffs_t;
typedef struct spiffs_t spiffs;
};
 
class SPIFFS : public FileSystem, private Atomic
{
public:
    void mount(const char *mount_point) override
    {
        int result = do_mount();
        if (result != 0)
        {
            // mounting failed, try reformatting
            format();
            result = do_mount();
        }
 
        if (result == 0)
        {
            name = mount_point;
            if (postFormatHook_ && formatted_)
            {
                postFormatHook_();
            }
            formatted_ = false;
        }
    }
 
    void format() override;
 
    bool is_any_dirty()
    {
        bool ret = false;
        {
            AtomicHolder h(this);
            ret = anyDirty_;
            anyDirty_ = false;
        }
        return ret;
    }
 
    void flush_cache()
    {
        mutex.lock();
        for (unsigned int i = 0; i < numOpenFiles; i++)
        {
            if (files[i].inuse && files[i].dev == this && files[i].dirty)
            {
                this->fsync(&files[i]);
            }
        }
        mutex.unlock();
    }
 
    inline static void extern_lock(struct spiffs_t *fs);
 
    inline static void extern_unlock(struct spiffs_t *fs);
 
protected:
    SPIFFS(size_t physical_address, size_t size_on_disk,
           size_t erase_block_size, size_t logical_block_size,
           size_t logical_page_size, size_t max_num_open_descriptors = 16,
           size_t cache_pages = 8,
           std::function<void()> post_format_hook = nullptr);
 
    ~SPIFFS();
 
    void unmount();
 
    static int flash_read(
        struct spiffs_t *fs, unsigned addr, unsigned size, uint8_t *dst);
 
    static int flash_write(
        struct spiffs_t *fs, unsigned addr, unsigned size, uint8_t *src);
 
    static int flash_erase(
        struct spiffs_t *fs, unsigned addr, unsigned size);
 
    virtual int32_t flash_read(uint32_t addr, uint32_t size, uint8_t *dst) = 0;
 
    virtual int32_t flash_write(uint32_t addr, uint32_t size, uint8_t *src) = 0;
 
    virtual int32_t flash_erase(uint32_t addr, uint32_t size) = 0;
 
    spiffs *fs_;
 
private:
    struct OpenDir;
 
    int open(File *file, const char *path, int flags, int mode) override;
 
    int close(File *file) override;
 
    int unlink(const char *path) override;
 
    ssize_t read(File *file, void *buf, size_t count) override;
 
    ssize_t write(File *file, const void *buf, size_t count) override;
 
    off_t lseek(File* f, off_t offset, int whence) override;
 
    int fstat(File* file, struct stat *stat) override;
 
    int stat(const char *path, struct stat *stat) override;
 
    int fsync(File *file) override;
 
 
    int closedir(File *file) override;
 
    File *opendir(File *file, const char *name) override;
 
    struct dirent *readdir(File *file) override;
 
    int errno_translate(int spiffs_error);
 
    int do_mount();
 
    std::function<void()> postFormatHook_;
 
    OSMutex lock_;
 
    uint8_t *workBuffer_;
 
    uint32_t fdSpaceSize_;
 
    uint8_t *fdSpace_;
 
    uint32_t cacheSize_;
 
    void *cache_;
 
    bool formatted_ : 1;
 
    bool anyDirty_ : 1;
    
    DISALLOW_COPY_AND_ASSIGN(SPIFFS);
};
 
#endif // _FREERTOS_DRIVERS_SPIFFS_SPIFFS_HXX_