fs.h

Go to the documentation of this file.

/*
 * Copyright (c) 2016 Intel Corporation.
 * Copyright (c) 2020-2021 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_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;
        /* fields 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_FLAGS_MASK 0x30
 
#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
/*
 * @brief Get the common mount flags for an fstab entry.
 
 * @param node_id the node identifier for a child entry in a
 * zephyr,fstab node.
 * @return a value suitable for initializing an fs_mount_t flags
 * member.
 */
#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 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 = (struct fs_file_t){ 0 };
}
 
static inline void fs_dir_t_init(struct fs_dir_t *zdp)
{
        *zdp = (struct fs_dir_t){ 0 };
}
 
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);
 
#ifdef __cplusplus
}
#endif
 
#endif /* ZEPHYR_INCLUDE_FS_FS_H_ */