文件系统层

struct vfs_operations {
    const char *fs_type;                       // 文件系统类型名，如 "fat" / "norfs" / "freefs"
    void (*init)(void);                        // 驱动初始化
    u32(*mount)(void **ppfs, void *p_device);  // 挂载
    u32(*openbypath)(void *pfs, void **ppfile, const char *path);
    u32(*openbyindex)(void *pfs, void **ppfile, u32 index);
    u32(*createfile)(void *pfs, void **ppfile, u32 *pindex);
    u32(*read)(void *pfile, void *buff, u32 len);
    u32(*write)(void *pfile, void *buff, u32 len);
    u32(*seek)(void *pfile, u32 offset, u32 mode);
    u32(*close_fs)(void **ppfs);
    u32(*close_file)(void **ppfile);
    u32(*fdelete)(void *);
    int (*fget_attr)(void *, void *attr);
    int (*flen)(void *, u32 *parm);
    int (*ftell)(void *, u32 *parm);
    u32(*name)(void *, void *name, u32 len);
    int (*ioctl)(void *, int cmd, int arg);
    int (*fscan_interrupt)(struct vfscan *, void *, const char *path, u8 max_deepth, int (*callback)(void));
    void (*fscan_release)(struct vfscan *);
    int (*fsel)(struct vfscan *, void *, int sel_mode, void **, int);
    int (*file_crc)(void *pfile);
    int (*format)(void **p_fs_hdl, void *device, u32 clust_size, u8 create_new);
};

#define REGISTER_VFS_OPERATIONS(ops) \
	const struct vfs_operations ops SEC(.vfs_operations)

void vfs_init(void)
{
    struct vfs_operations *ops;
    list_for_each_vfs_operation(ops) {
        if (NULL != ops->init) {
            log_info("ops_init!!!\n");
            ops->init();
        }
    }
}

u32 vfs_mount(void **ppvfs, void *device, void *type)
{
    if ((void *)NULL == *ppvfs) {
        *ppvfs = vfs_hdl_malloc();
        if ((void *)NULL == *ppvfs) {
            return E_NO_VFS;          // 句柄资源不足
        }
    }

    struct imount *pvfs = *ppvfs;
    struct vfs_operations *ops;
    list_for_each_vfs_operation(ops) {
        if (NULL != ops->mount) {
            if (NULL != type) {
                if (0 != strcmp(ops->fs_type, type)) {
                    continue;          // 指定类型时精确匹配
                }
            } else {
                // 未指定类型时跳过 norfs / freefs，优先尝试 FAT
                if (0 == strcmp(ops->fs_type, "norfs")) { continue; }
                if (0 == strcmp(ops->fs_type, "freefs")) { continue; }
            }
            if (0 == ops->mount(&(pvfs->pfs), device)) {
                pvfs->ops = ops;       // 绑定成功，保存操作表
                return 0;
            } else {
                if (NULL != ops->close_fs) {
                    ops->close_fs(&(pvfs->pfs));   // 挂载失败需清理
                }
            }
        }
    }
    *ppvfs = vfs_fhdl_free(*ppvfs);    // 全部失败则释放句柄
    return E_NO_FS;
}

u32 vfs_openbypath(void *pvfs, void **ppvfile, const char *path)
{
    if ((void *)NULL == *ppvfile) {
        *ppvfile = vfs_hdl_malloc();
        if ((void *)NULL == *ppvfile) {
            return E_NO_VFS;
        }
    }
    ...
    p_vfile->ops = p_vfs->ops;              // 文件句柄继承文件系统句柄的 ops
    ops = p_vfs->ops;

    if (NULL != ops->openbypath) {
        err = ops->openbypath(p_vfs->pfs, &p_vfile->pfile, path);
    } else {
        err = E_VFS_OPS;                    // 驱动未实现该操作
    }
__vfs_openbypath:
    if (0 != err) {
        vfs_file_close(ppvfile);            // 失败自动回收文件句柄
    }
    return err;
}

u32 vfs_file_delete(void *pvfile)
{
    struct imount *p_vfile = pvfile;
    if ((void *)NULL == p_vfile) {
        return E_FS_PFILE;                // 非法句柄
    }
    struct vfs_operations *ops;
    ops = p_vfile->ops;
    if (((void *)NULL != ops)  && ((void *)NULL !=  ops->fdelete)) {
        u32 res = E_VFS_OPS;
        if (NULL != (p_vfile->pfile)) {
            res = ops->fdelete(p_vfile->pfile);
            if (0 != res) {
                return E_FS_PFILE;
            }
        }
        return res;
    }
    return  E_VFS_OPS;                    // 驱动未实现删除
}

/*
 * -t  文件类型
 * -r  包含子目录
 * -d  扫描文件夹
 * -a  文件属性 r: 读， /: 非
 * -s  排序方式， t:按时间排序， n:按文件号排序
 */
static void __fscan_arg_handler(struct vfscan *fs, const char *arg)
{
    int step = 0;
    char *p;

    /*
     * fs->attr = F_ATTR_RO: 搜索只读文件
     * fs->attr = F_ATTR_ARC: 搜索非读文件
     * fs->attr = F_ATTR_ARC | F_ATTR_RO: 搜索所有文件
     */
    fs->attr = F_ATTR_ARC | F_ATTR_RO;      // 默认扫描所有属性

    while (*arg) {
        switch (step) {
        case 0:
            if (*arg == '-') { step = 1; }
            break;
        case 1:
            if (*arg == 't') { step = 2; p = fs->ftype; fs->scan_file = 1; }
            ...
        }
    }
}

void *vfs_type_name(void *p_vfs)
{
    if (NULL == p_vfs) {
        return NULL;
    }
    log_info("p_vfs 0x%x", (u32)p_vfs);
    struct imount *pvfs = p_vfs;
    struct vfs_operations *ops = pvfs->ops;
    log_info("ops 0x%x", (u32)ops);
    if (NULL == ops) {
        return NULL;
    }
    return (void *)ops->fs_type;
}

const struct vfs_operations my_fs_ops SEC(.vfs_operations) = {
    .fs_type = "myfs",
    .init = my_fs_init,
    .mount = my_fs_mount,
    .openbypath = my_fs_open,
    .read = my_fs_read,
    .write = my_fs_write,
    .close_file = my_fs_close,
};

u32 fsize = 0;
vfs_get_fsize(pfile, &fsize);       // 经 ops->flen 分发

u32 err = vfs_file_delete(pfile);    // 经 ops->fdelete 分发，删除失败返回 E_FS_PFILE