SmartPDCode/f407/applications/fs.c

#include <rtdbg.h>
#include <stdio.h>
#include <unistd.h>
#include <rtthread.h>
#include <dfs_posix.h>
#include "fs.h"


#if 0
    #define LOGE  LOG_E
    #define LOGW  LOG_W
    #define LOGD  LOG_D
#else
    #define LOGD  rt_kprintf
    #define LOGW  rt_kprintf
    #define LOGE  rt_kprintf
#endif

#define FS_TYPE   "elm"
//#define FS_TYPE   "lfs"

typedef struct {
    uint8_t  mounted[FS_DEV_MAX];
    
}fs_handle_t;
static fs_handle_t fsHandle={0};

typedef struct {
    uint8_t id;
    char *dev;
    char *mpath;
    char *ftype;
}mnt_info_t;


static mnt_info_t MNT_INFO[FS_DEV_MAX]={
    //{FS_DEV_SD, "sd",  "/mnt/sd",  "elm"},
    {FS_DEV_SD, "sd",  "/",  "elm"},
    //{FS_DEV_NOR, "nor", "/mnt/nor", "lfs"},
};


static int is_mounted(fs_handle_t *h, char *dev, char *path)
{
    int i;
    for(i=0; i<FS_DEV_MAX; i++) {
        if(dev) {
            if(strcmp(dev, MNT_INFO[i].dev)==0) {
                return h->mounted[i];
            }
        }
        
        if(path) {
            if(strstr(path, MNT_INFO[i].mpath)) {
                return h->mounted[i];
            }
        }
    }
    return 0;
}
static mnt_info_t* get_info(fs_handle_t *h, char *dev)
{
    int i;
    for(i=0; i<FS_DEV_MAX; i++) {
        if(strcmp(dev, MNT_INFO[i].dev)==0) {
            return &MNT_INFO[i];
        }
    }
    return NULL;
}
static int do_mount(fs_handle_t *h, char *dev, int flag)
{
    int r=0;
    mnt_info_t *info=NULL;
    rt_device_t devid=NULL;
    
    info = get_info(h, dev);
    if(!info) {
        return -1;
    }
    
    if(flag && h->mounted[info->id]) {
        return 0;
    }
    
    if(!flag && !h->mounted[info->id]) {
        return 0;
    }
        
    devid = rt_device_find(info->dev);
    if(devid) {
        if(flag) {
            r = dfs_mount(info->dev, info->mpath, info->ftype, 0, 0);
            if (r) {
                if(rt_get_errno()==EPERM) {
                    r = dfs_mkfs(info->dev, info->ftype);
                    if(r==0) {
                        r = dfs_mount(info->dev, info->mpath, info->ftype, 0, 0);
                        if(r==0) {
                            h->mounted[info->id] = 1;
                        }
                    }
                }
            }
            else {
                LOGD("%s fs inited\n");
            }
        }
        else {
            r = dfs_umount(info->mpath, 0);
        }
    }
    
    return r;
}

int fs_mount(char *dev, int flag)
{
    fs_handle_t *h=&fsHandle;
    return do_mount(h, dev, flag);
}

int fs_test(void)
{
    int r;
    buf_t fbuf;
    char *dev="sd";
    #define MNT_PATH "/"
    char *fpath=MNT_PATH"text.txt";
    char *ttt="hello every one!";
    rt_device_t devid=NULL;
    static int mounted=0;
    
    if(!fs_exist(fpath)) {
        r = fs_save(fpath, ttt, strlen(ttt)+1);
        r = fs_load(fpath, &fbuf);
        if(r==0) {
            rt_kprintf("_____\n");
        }
    }
    
    return 0;
}



int fs_length(char* path)
{
    int r;
    struct stat st;
    fs_handle_t *h=&fsHandle;

    r = stat(path, &st);
    if (r) {
        return -1;
    }

    return st.st_size;
}


int fs_exist(char* path)
{
    int r;
    struct stat st;

    r = stat(path, &st);
    if (r) {
        return 0;
    }

    return 1;
}


int fs_save(char *path, void *buf, int len)
{
    int r;
    FILE *fp;
    
    fp = fopen(path, "w");
    if(!fp) {
        LOGE("file_save, fopen %s failed\n", path);
        return -1;
    }
    r = fwrite(buf, 1, len, fp);
    if(r!=len) {
        LOGE("file_save %s failed, %d, %d\n", path, r, len);
        r = -1;
    }
    else {
        r = 0;
    }
    fclose(fp);

    return r;
}

int fs_load(char* path, buf_t *fbuf)
{
    int r,flen,blen;
    FILE* fp;

    flen = fs_length(path);
    if(flen<=0) {
        LOGE("____ file_load, %s failed\n", path);
        return -1;
    }

    blen = flen+1;
    fbuf->buf = (char*)malloc(blen);
    if(!fbuf->buf) {
        LOGE("____ file_load, %s malloc %d failed\n", path, flen);
        return -1;
    }
    fbuf->dlen = flen;
    fbuf->blen = blen;

    fp = fopen(path, "r");
    if (!fp) {
        LOGE("file_load, fopen %s failed\n", path);;
        free(fbuf->buf);
        return -1;
    }
    r = fread(fbuf->buf, 1, flen, fp);
    if (r != flen) {
        LOGE("file_load %s failed, %d, %d\n", path, r, flen);
        fclose(fp); free(fbuf->buf);
        r = -1;
    }
    else {
        fbuf->buf[flen] = 0; r = 0;
    }
    fclose(fp);

    return r;
}


char* fs_load2(char* path, int add0)
{
    FILE* fp=NULL;
    int r,flen,blen;
    char *fbuf=NULL;

    flen = fs_length(path);
    if(flen<=0) {
        LOGE("____ file_load2, %s failed\n", path);
        return NULL;
    }

    blen = flen+(add0?1:0);
    fbuf = (char*)malloc(blen);
    if(!fbuf) {
        LOGE("____ file_load2, %s malloc %d failed\n", path, flen);
        return NULL;
    }

    fp = fopen(path, "r");
    if (!fp) {
        LOGE("file_load2, fopen %s failed\n", path);;
        free(fbuf);
        return NULL;
    }
    r = fread(fbuf, 1, flen, fp);
    if (r != flen) {
        LOGE("file_load2 %s failed, %d, %d\n", path, r, flen);
        fclose(fp); free(fbuf);
        fbuf = NULL;
    }
    if(add0) fbuf[flen] = 0;
    fclose(fp);

    return fbuf;
}


int fs_copy(char *dst, char *src)
{
    int r;
    buf_t fbuf;

    remove(dst);
    r = fs_load(src, &fbuf);
    if(r==0) {
        r = fs_save(dst, fbuf.buf, fbuf.dlen);
        free(fbuf.buf);
    }

    return r;
}


int fs_remove(char *path)
{
    return remove(path);
}


int fs_append(char *path, void *data, int datalen)
{
    int r=-1;
    FILE* fp;

    fp = fopen(path, "a");
    if(!fp) {
        LOGE("file_append, fopen %s failed\n", path);
        return -1;
    }
    r = fwrite(data, 1, datalen, fp);
    if(r==datalen) {
        r = 0;
    }
    else {
        LOGE("file_append %s failed, %d, %d\n", path, r, datalen);
    }
    fclose(fp);

    return r;
}