fs.h

Go to the documentation of this file.

/*
 * Copyright (c) 2016 Intel Corporation.
 * Copyright (c) 2020-2024 Nordic Semiconductor ASA
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef ZEPHYR_INCLUDE_FS_FS_H_
#define ZEPHYR_INCLUDE_FS_FS_H_
 
#include <sys/types.h>
 
#include <zephyr/sys/dlist.h>
#include <zephyr/fs/fs_interface.h>
 
#ifdef __cplusplus
extern "C" {
#endif

struct fs_file_system_t;

enum fs_dir_entry_type {
        FS_DIR_ENTRY_FILE = 0,
        FS_DIR_ENTRY_DIR
};

enum {
        FS_FATFS = 0,

        FS_LITTLEFS,

        FS_EXT2,

        FS_VIRTIOFS,

        FS_TYPE_EXTERNAL_BASE,
};

#define FS_MOUNT_FLAG_NO_FORMAT BIT(0)
#define FS_MOUNT_FLAG_READ_ONLY BIT(1)
#define FS_MOUNT_FLAG_AUTOMOUNT BIT(2)
#define FS_MOUNT_FLAG_USE_DISK_ACCESS BIT(3)

struct fs_mount_t {
        sys_dnode_t node;
        int type;
        const char *mnt_point;
        void *fs_data;
        void *storage_dev;
        /* The following fields are filled by file system core */
        size_t mountp_len;
        const struct fs_file_system_t *fs;
        uint8_t flags;
};

struct fs_dirent {
        enum fs_dir_entry_type type;
        char name[MAX_FILE_NAME + 1];
        size_t size;
};

struct fs_statvfs {
        unsigned long f_bsize;
        unsigned long f_frsize;
        unsigned long f_blocks;
        unsigned long f_bfree;
};
 

#define FS_O_READ       0x01
#define FS_O_WRITE      0x02
#define FS_O_RDWR       (FS_O_READ | FS_O_WRITE)
#define FS_O_MODE_MASK  0x03

#define FS_O_CREATE     0x10
#define FS_O_APPEND     0x20
#define FS_O_TRUNC      0x40
#define FS_O_FLAGS_MASK 0x70
 

#define FS_O_MASK       (FS_O_MODE_MASK | FS_O_FLAGS_MASK)

#ifndef FS_SEEK_SET
#define FS_SEEK_SET     0
#endif
#ifndef FS_SEEK_CUR
#define FS_SEEK_CUR     1
#endif
#ifndef FS_SEEK_END
#define FS_SEEK_END     2
#endif

#define FSTAB_ENTRY_DT_MOUNT_FLAGS(node_id)                             \
        ((DT_PROP(node_id, automount) ? FS_MOUNT_FLAG_AUTOMOUNT : 0)    \
         | (DT_PROP(node_id, read_only) ? FS_MOUNT_FLAG_READ_ONLY : 0)  \
         | (DT_PROP(node_id, no_format) ? FS_MOUNT_FLAG_NO_FORMAT : 0)  \
         | (DT_PROP(node_id, disk_access) ? FS_MOUNT_FLAG_USE_DISK_ACCESS : 0))

#define FSTAB_ENTRY_DT_MOUNT_POINT(node_id) \
        DT_PROP(node_id, mount_point)

#define FSTAB_ENTRY_DT_INST_MOUNT_POINT(inst) \
        DT_INST_PROP(inst, mount_point)

#define FS_FSTAB_ENTRY(node_id) _CONCAT(z_fsmp_, node_id)

#define FS_FSTAB_DECLARE_ENTRY(node_id)         \
        extern struct fs_mount_t FS_FSTAB_ENTRY(node_id)

static inline void fs_file_t_init(struct fs_file_t *zfp)
{
        zfp->filep = NULL;
        zfp->mp = NULL;
        zfp->flags = 0;
}

static inline void fs_dir_t_init(struct fs_dir_t *zdp)
{
        zdp->dirp = NULL;
        zdp->mp = NULL;
}

int fs_open(struct fs_file_t *zfp, const char *file_name, fs_mode_t flags);

int fs_close(struct fs_file_t *zfp);

int fs_unlink(const char *path);

int fs_rename(const char *from, const char *to);

ssize_t fs_read(struct fs_file_t *zfp, void *ptr, size_t size);

ssize_t fs_write(struct fs_file_t *zfp, const void *ptr, size_t size);

int fs_seek(struct fs_file_t *zfp, off_t offset, int whence);

off_t fs_tell(struct fs_file_t *zfp);

int fs_truncate(struct fs_file_t *zfp, off_t length);

int fs_sync(struct fs_file_t *zfp);

int fs_mkdir(const char *path);

int fs_opendir(struct fs_dir_t *zdp, const char *path);

int fs_readdir(struct fs_dir_t *zdp, struct fs_dirent *entry);

int fs_closedir(struct fs_dir_t *zdp);

int fs_mount(struct fs_mount_t *mp);

int fs_unmount(struct fs_mount_t *mp);

int fs_readmount(int *index, const char **name);

int fs_stat(const char *path, struct fs_dirent *entry);

int fs_statvfs(const char *path, struct fs_statvfs *stat);

int fs_mkfs(int fs_type, uintptr_t dev_id, void *cfg, int flags);

int fs_register(int type, const struct fs_file_system_t *fs);

int fs_unregister(int type, const struct fs_file_system_t *fs);

int fs_gc(struct fs_mount_t *mp);

 
 
#ifdef __cplusplus
}
#endif
 
#endif /* ZEPHYR_INCLUDE_FS_FS_H_ */