rusefi
/
ChibiOS
mirror of https://github.com/rusefi/ChibiOS.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Integrated with the new OOP infrastructure, not finished. 

git-svn-id: svn://svn.code.sf.net/p/chibios/svn/trunk@15188 27425a3e-05d8-49a3-a47f-9c15f0e5edd8
This commit is contained in:
Giovanni Di Sirio 2021-12-04 12:30:13 +00:00
parent e8520182e0
commit 3702d67de4
13 changed files with 224 additions and 218 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
demos/STM32/RT-VFS-FATFS/main.c
View File

@ -113,12 +113,12 @@ static bool fs_ready = false;
/*===========================================================================*/
/* VFS overlay driver object representing the root directory.*/
static vfs_overlay_driver_t root_driver;
static vfs_overlay_driver_c root_driver;
vfs_driver_t *vfs_root = (vfs_driver_t *)&root_driver;
vfs_driver_c *vfs_root = (vfs_driver_c *)&root_driver;
/* VFS streams driver object representing the /dev directory.*/
static vfs_streams_driver_t vfs_dev;
static vfs_streams_driver_c vfs_dev;
static NullStream nullstream;
@ -134,7 +134,7 @@ static char pathbuf[1024];
static void scan_nodes(BaseSequentialStream *chp, char *path) {
msg_t res;
vfs_directory_node_t *dirp;
vfs_directory_node_c *dirp;
static vfs_node_info_t ni;
chprintf(chp, "%s\r\n", path);
@ -284,7 +284,7 @@ static THD_FUNCTION(Thread1, arg) {
*/
int main(void) {
msg_t msg;
vfs_file_node_t *file;
vfs_file_node_c *file;
static const evhandler_t evhndl[] = {
InsertHandler,
RemoveHandler,

2
demos/STM32/RT-VFS-FATFS/make/stm32g474re_nucleo64.make
View File

@ -96,6 +96,8 @@ DEPDIR := ./.dep/stm32g474re_nucleo64
# Licensing files.
include $(CHIBIOS)/os/license/license.mk
# Common files.
include $(CHIBIOS)/os/common/utils/utils.mk
# Startup files.
include $(CHIBIOS)/os/common/startup/ARMCMx/compilers/GCC/mk/startup_stm32g4xx.mk
# HAL-OSAL files (optional).

2
demos/STM32/RT-VFS-FATFS/make/stm32l4r9ai_discovery.make
View File

@ -96,6 +96,8 @@ DEPDIR := ./.dep/stm32l4r9ai_discovery
# Licensing files.
include $(CHIBIOS)/os/license/license.mk
# Common files.
include $(CHIBIOS)/os/common/utils/utils.mk
# Startup files.
include $(CHIBIOS)/os/common/startup/ARMCMx/compilers/GCC/mk/startup_stm32l4xx.mk
# HAL-OSAL files (optional).

74
os/vfs/drivers/fatfs/drvfatfs.c
View File

@ -49,11 +49,11 @@
static msg_t drv_open_dir(void *instance,
const char *path,
vfs_directory_node_t **vdnpp);
vfs_directory_node_c **vdnpp);
static msg_t drv_open_file(void *instance,
const char *path,
int oflag,
vfs_file_node_t **vfnpp);
vfs_file_node_c **vfnpp);
static const struct vfs_fatfs_driver_vmt driver_vmt = {
.open_dir = drv_open_dir,
@ -94,7 +94,7 @@ static msg_t file_stream_put(void *instance, uint8_t b);
static msg_t file_stream_get(void *instance);
static const struct BaseSequentialStreamVMT file_stream_vmt = {
.instance_offset = __CH_OFFSETOF(vfs_fatfs_file_node_t, stream.vmt),
.instance_offset = __CH_OFFSETOF(vfs_fatfs_file_node_c, stream.vmt),
.write = file_stream_write,
.read = file_stream_read,
.put = file_stream_put,
@ -104,7 +104,7 @@ static const struct BaseSequentialStreamVMT file_stream_vmt = {
/**
* @brief Single FatFS driver instance.
*/
vfs_fatfs_driver_t vfs_fatfs;
vfs_fatfs_driver_c vfs_fatfs;
/*===========================================================================*/
/* Module local functions. */
@ -180,12 +180,12 @@ static BYTE translate_oflag(int oflag) {
static msg_t drv_open_dir(void *instance,
const char *path,
vfs_directory_node_t **vdnpp) {
vfs_directory_node_c **vdnpp) {
msg_t err;
do {
vfs_fatfs_driver_t *drvp = (vfs_fatfs_driver_t *)instance;
vfs_fatfs_dir_node_t *ffdnp;
vfs_fatfs_driver_c *drvp = (vfs_fatfs_driver_c *)instance;
vfs_fatfs_dir_node_c *ffdnp;
FRESULT res;
ffdnp = chPoolAlloc(&drvp->dir_nodes_pool);
@ -194,11 +194,11 @@ static msg_t drv_open_dir(void *instance,
/* Node object initialization.*/
ffdnp->vmt = &dir_node_vmt;
ffdnp->refs = 1U;
ffdnp->driver = (vfs_driver_t *)drvp;
ffdnp->driver = (vfs_driver_c *)drvp;
res = f_opendir(&ffdnp->dir, (TCHAR *)path);
if (res == FR_OK) {
*vdnpp = (vfs_directory_node_t *)ffdnp;
*vdnpp = (vfs_directory_node_c *)ffdnp;
err = VFS_RET_SUCCESS;
break;
}
@ -216,12 +216,12 @@ static msg_t drv_open_dir(void *instance,
static msg_t drv_open_file(void *instance,
const char *path,
int oflag,
vfs_file_node_t **vfnpp) {
vfs_file_node_c **vfnpp) {
msg_t err;
do {
vfs_fatfs_driver_t *drvp = (vfs_fatfs_driver_t *)instance;
vfs_fatfs_file_node_t *fffnp;
vfs_fatfs_driver_c *drvp = (vfs_fatfs_driver_c *)instance;
vfs_fatfs_file_node_c *fffnp;
FRESULT res;
BYTE mode;
@ -237,12 +237,12 @@ static msg_t drv_open_file(void *instance,
/* Node object initialization.*/
fffnp->vmt = &file_node_vmt;
fffnp->refs = 1U;
fffnp->driver = (vfs_driver_t *)drvp;
fffnp->driver = (vfs_driver_c *)drvp;
fffnp->stream.vmt = &file_stream_vmt;
res = f_open(&fffnp->file, (TCHAR *)path, mode);
if (res == FR_OK) {
*vfnpp = (vfs_file_node_t *)fffnp;
*vfnpp = (vfs_file_node_c *)fffnp;
err = VFS_RET_SUCCESS;
break;
}
@ -258,17 +258,17 @@ static msg_t drv_open_file(void *instance,
}
static void node_dir_release(void *instance) {
vfs_fatfs_dir_node_t *ffdnp = (vfs_fatfs_dir_node_t *)instance;
vfs_fatfs_dir_node_c *ffdnp = (vfs_fatfs_dir_node_c *)instance;
if (--ffdnp->refs == 0U) {
chPoolFree(&((vfs_fatfs_driver_t *)ffdnp->driver)->dir_nodes_pool,
chPoolFree(&((vfs_fatfs_driver_c *)ffdnp->driver)->dir_nodes_pool,
(void *)ffdnp);
}
}
static msg_t node_dir_first(void *instance, vfs_node_info_t *nip) {
vfs_fatfs_dir_node_t *ffdnp = (vfs_fatfs_dir_node_t *)instance;
vfs_fatfs_dir_node_c *ffdnp = (vfs_fatfs_dir_node_c *)instance;
msg_t err;
FRESULT res;
@ -287,8 +287,8 @@ static msg_t node_dir_next(void *instance, vfs_node_info_t *nip) {
msg_t err;
do {
vfs_fatfs_dir_node_t *ffdnp = (vfs_fatfs_dir_node_t *)instance;
vfs_fatfs_driver_t *drvp = (vfs_fatfs_driver_t *)ffdnp->driver;
vfs_fatfs_dir_node_c *ffdnp = (vfs_fatfs_dir_node_c *)instance;
vfs_fatfs_driver_c *drvp = (vfs_fatfs_driver_c *)ffdnp->driver;
FRESULT res;
FILINFO *fip;
@ -321,23 +321,23 @@ static msg_t node_dir_next(void *instance, vfs_node_info_t *nip) {
}
static void node_file_release(void *instance) {
vfs_fatfs_file_node_t *fffnp = (vfs_fatfs_file_node_t *)instance;
vfs_fatfs_file_node_c *fffnp = (vfs_fatfs_file_node_c *)instance;
if (--fffnp->refs == 0U) {
chPoolFree(&((vfs_fatfs_driver_t *)fffnp->driver)->file_nodes_pool,
chPoolFree(&((vfs_fatfs_driver_c *)fffnp->driver)->file_nodes_pool,
(void *)fffnp);
}
}
static BaseSequentialStream *node_file_get_stream(void *instance) {
vfs_fatfs_file_node_t *fffnp = (vfs_fatfs_file_node_t *)instance;
vfs_fatfs_file_node_c *fffnp = (vfs_fatfs_file_node_c *)instance;
return &fffnp->stream;
}
static ssize_t node_file_read(void *instance, uint8_t *buf, size_t n) {
vfs_fatfs_file_node_t *fffnp = (vfs_fatfs_file_node_t *)instance;
vfs_fatfs_file_node_c *fffnp = (vfs_fatfs_file_node_c *)instance;
FRESULT res;
UINT br;
@ -351,7 +351,7 @@ static ssize_t node_file_read(void *instance, uint8_t *buf, size_t n) {
}
static ssize_t node_file_write(void *instance, const uint8_t *buf, size_t n) {
vfs_fatfs_file_node_t *fffnp = (vfs_fatfs_file_node_t *)instance;
vfs_fatfs_file_node_c *fffnp = (vfs_fatfs_file_node_c *)instance;
FRESULT res;
UINT bw;
@ -365,25 +365,25 @@ static ssize_t node_file_write(void *instance, const uint8_t *buf, size_t n) {
}
static msg_t node_file_setpos(void *instance, vfs_offset_t offset) {
vfs_fatfs_file_node_t *fffnp = (vfs_fatfs_file_node_t *)instance;
vfs_fatfs_file_node_c *fffnp = (vfs_fatfs_file_node_c *)instance;
return translate_error(f_lseek(&fffnp->file, (FSIZE_t)offset));
}
static vfs_offset_t node_file_getpos(void *instance) {
vfs_fatfs_file_node_t *fffnp = (vfs_fatfs_file_node_t *)instance;
vfs_fatfs_file_node_c *fffnp = (vfs_fatfs_file_node_c *)instance;
return (vfs_offset_t)f_tell(&fffnp->file);
}
static vfs_offset_t node_file_getsize(void *instance) {
vfs_fatfs_file_node_t *fffnp = (vfs_fatfs_file_node_t *)instance;
vfs_fatfs_file_node_c *fffnp = (vfs_fatfs_file_node_c *)instance;
return (vfs_offset_t)f_size(&fffnp->file);
}
static size_t file_stream_write(void *instance, const uint8_t *bp, size_t n) {
vfs_fatfs_file_node_t *fffnp = objGetInstance(vfs_fatfs_file_node_t *,
vfs_fatfs_file_node_c *fffnp = objGetInstance(vfs_fatfs_file_node_c *,
(BaseSequentialStream *)instance);
msg_t msg;
@ -397,7 +397,7 @@ static size_t file_stream_write(void *instance, const uint8_t *bp, size_t n) {
}
static size_t file_stream_read(void *instance, uint8_t *bp, size_t n) {
vfs_fatfs_file_node_t *fffnp = objGetInstance(vfs_fatfs_file_node_t *,
vfs_fatfs_file_node_c *fffnp = objGetInstance(vfs_fatfs_file_node_c *,
(BaseSequentialStream *)instance);
msg_t msg;
@ -411,7 +411,7 @@ static size_t file_stream_read(void *instance, uint8_t *bp, size_t n) {
}
static msg_t file_stream_put(void *instance, uint8_t b) {
vfs_fatfs_file_node_t *fffnp = objGetInstance(vfs_fatfs_file_node_t *,
vfs_fatfs_file_node_c *fffnp = objGetInstance(vfs_fatfs_file_node_c *,
(BaseSequentialStream *)instance);
msg_t msg;
@ -425,7 +425,7 @@ static msg_t file_stream_put(void *instance, uint8_t b) {
}
static msg_t file_stream_get(void *instance) {
vfs_fatfs_file_node_t *fffnp = objGetInstance(vfs_fatfs_file_node_t *,
vfs_fatfs_file_node_c *fffnp = objGetInstance(vfs_fatfs_file_node_c *,
(BaseSequentialStream *)instance);
msg_t msg;
uint8_t b;
@ -446,23 +446,23 @@ static msg_t file_stream_get(void *instance) {
/**
* @brief VFS FatFS object initialization.
*
* @param[out] ffdp pointer to a @p vfs_fatfs_driver_t structure
* @param[out] ffdp pointer to a @p vfs_fatfs_driver_c structure
* @param[in] rootname name to be attributed to this object
* @return A pointer to this initialized object.
*
* @api
*/
vfs_driver_t *drvFatFSInit(const char *rootname) {
vfs_driver_c *drvFatFSInit(const char *rootname) {
vfs_fatfs.vmt = &driver_vmt;
vfs_fatfs.rootname = rootname;
/* Initializing pools.*/
chPoolObjectInit(&vfs_fatfs.dir_nodes_pool,
sizeof (vfs_fatfs_dir_node_t),
sizeof (vfs_fatfs_dir_node_c),
chCoreAllocAlignedI);
chPoolObjectInit(&vfs_fatfs.file_nodes_pool,
sizeof (vfs_fatfs_file_node_t),
sizeof (vfs_fatfs_file_node_c),
chCoreAllocAlignedI);
chPoolObjectInit(&vfs_fatfs.info_nodes_pool,
sizeof (FILINFO),
@ -479,7 +479,7 @@ vfs_driver_t *drvFatFSInit(const char *rootname) {
&vfs_fatfs.drv_file_nodes[0],
DRV_CFG_FATFS_FILE_NODES_NUM);
return (vfs_driver_t *)&vfs_fatfs;
return (vfs_driver_c *)&vfs_fatfs;
}
/**
@ -510,7 +510,7 @@ msg_t drvFatFSMount(const char *name, bool mountnow) {
/**
* @brief Unmounts a FatFS volume.
*
* @param[in] ffdp pointer to a @p vfs_fatfs_driver_t structure
* @param[in] ffdp pointer to a @p vfs_fatfs_driver_c structure
* @return The operation result.
*
* @api

38
os/vfs/drivers/fatfs/drvfatfs.h
View File

@ -66,27 +66,27 @@
/*===========================================================================*/
/**
* @brief @p vfs_fatfs_dir_node_t specific methods.
* @brief @p vfs_fatfs_dir_node_c specific methods.
*/
#define __vfs_fatfs_dir_node_methods \
__vfs_directory_node_methods
/**
* @brief @p vfs_fatfs_dir_node_t specific data.
* @brief @p vfs_fatfs_dir_node_c specific data.
*/
#define __vfs_fatfs_dir_node_data \
__vfs_directory_node_data \
DIR dir;
/**
* @brief @p vfs_fatfs_dir_node_t virtual methods table.
* @brief @p vfs_fatfs_dir_node_c virtual methods table.
*/
struct vfs_fatfs_dir_node_vmt {
__vfs_fatfs_dir_node_methods
};
/**
* @brief Type of a structure representing a FatFS directory VFS node.
* @brief Type of a FatFS directory VFS node class.
*/
typedef struct vfs_fatfs_dir_node {
/**
@ -94,16 +94,16 @@ typedef struct vfs_fatfs_dir_node {
*/
const struct vfs_fatfs_dir_node_vmt *vmt;
__vfs_fatfs_dir_node_data
} vfs_fatfs_dir_node_t;
} vfs_fatfs_dir_node_c;
/**
* @brief @p vfs_fatfs_file_node_t specific methods.
* @brief @p vfs_fatfs_file_node_c specific methods.
*/
#define __vfs_fatfs_file_node_methods \
__vfs_file_node_methods
/**
* @brief @p vfs_fatfs_file_node_t specific data.
* @brief @p vfs_fatfs_file_node_c specific data.
*/
#define __vfs_fatfs_file_node_data \
__vfs_file_node_data \
@ -111,14 +111,14 @@ typedef struct vfs_fatfs_dir_node {
BaseSequentialStream stream;
/**
* @brief @p vfs_fatfs_file_node_t virtual methods table.
* @brief @p vfs_fatfs_file_node_c virtual methods table.
*/
struct vfs_fatfs_file_node_vmt {
__vfs_fatfs_file_node_methods
};
/**
* @brief Type of a structure representing a FatFS file VFS node.
* @brief Type of a FatFS file VFS node class.
*/
typedef struct vfs_fatfs_file_node {
/**
@ -126,16 +126,16 @@ typedef struct vfs_fatfs_file_node {
*/
const struct vfs_fatfs_file_node_vmt *vmt;
__vfs_fatfs_file_node_data
} vfs_fatfs_file_node_t;
} vfs_fatfs_file_node_c;
/**
* @brief @p vfs_fatfs_driver_t specific methods.
* @brief @p vfs_fatfs_driver_c specific methods.
*/
#define __vfs_fatfs_driver_methods \
__vfs_driver_methods
/**
* @brief @p vfs_fatfs_driver_t specific data.
* @brief @p vfs_fatfs_driver_c specific data.
*/
#define __vfs_fatfs_driver_data \
__vfs_driver_data \
@ -143,18 +143,18 @@ typedef struct vfs_fatfs_file_node {
memory_pool_t dir_nodes_pool; \
memory_pool_t info_nodes_pool; \
memory_pool_t fs_nodes_pool; \
vfs_fatfs_dir_node_t drv_dir_nodes[DRV_CFG_FATFS_DIR_NODES_NUM]; \
vfs_fatfs_file_node_t drv_file_nodes[DRV_CFG_FATFS_FILE_NODES_NUM];
vfs_fatfs_dir_node_c drv_dir_nodes[DRV_CFG_FATFS_DIR_NODES_NUM]; \
vfs_fatfs_file_node_c drv_file_nodes[DRV_CFG_FATFS_FILE_NODES_NUM];
/**
* @brief @p vfs_fatfs_driver_t virtual methods table.
* @brief @p vfs_fatfs_driver_c virtual methods table.
*/
struct vfs_fatfs_driver_vmt {
__vfs_fatfs_driver_methods
};
/**
* @brief Type of a structure representing a VFS FatFS driver.
* @brief Type of a VFS FatFS driver class.
*/
typedef struct vfs_fatfs_driver {
/**
@ -162,7 +162,7 @@ typedef struct vfs_fatfs_driver {
*/
const struct vfs_fatfs_driver_vmt *vmt;
__vfs_fatfs_driver_data
} vfs_fatfs_driver_t;
} vfs_fatfs_driver_c;
/*===========================================================================*/
/* Module macros. */
@ -172,12 +172,12 @@ typedef struct vfs_fatfs_driver {
/* External declarations. */
/*===========================================================================*/
extern vfs_fatfs_driver_t vfs_fatfs;
extern vfs_fatfs_driver_c vfs_fatfs;
#ifdef __cplusplus
extern "C" {
#endif
vfs_driver_t *drvFatFSInit(const char *rootname);
vfs_driver_c *drvFatFSInit(const char *rootname);
msg_t drvFatFSMount(const char *name, bool mountnow);
msg_t drvFatFSUnmount(const char *name);
#ifdef __cplusplus

54
os/vfs/drivers/overlay/drvoverlay.c
View File

@ -49,11 +49,11 @@
static msg_t drv_open_dir(void *instance,
const char *path,
vfs_directory_node_t **vdnpp);
vfs_directory_node_c **vdnpp);
static msg_t drv_open_file(void *instance,
const char *path,
int oflag,
vfs_file_node_t **vfnpp);
vfs_file_node_c **vfnpp);
static const struct vfs_overlay_driver_vmt driver_vmt = {
.open_dir = drv_open_dir,
@ -74,12 +74,12 @@ static const struct vfs_overlay_dir_node_vmt dir_node_vmt = {
/* Module local functions. */
/*===========================================================================*/
static msg_t match_driver(vfs_overlay_driver_t *odp,
static msg_t match_driver(vfs_overlay_driver_c *odp,
const char **pathp,
vfs_driver_t **vdpp) {
vfs_driver_c **vdpp) {
char fname[VFS_CFG_MAX_NAMELEN + 1];
msg_t err;
vfs_driver_t **pp;
vfs_driver_c **pp;
do {
err = vfs_parse_filename(pathp, fname);
@ -105,8 +105,8 @@ static msg_t match_driver(vfs_overlay_driver_t *odp,
static msg_t drv_open_dir(void *instance,
const char *path,
vfs_directory_node_t **vdnpp) {
vfs_overlay_driver_t *drvp = (vfs_overlay_driver_t *)instance;
vfs_directory_node_c **vdnpp) {
vfs_overlay_driver_c *drvp = (vfs_overlay_driver_c *)instance;
const char *scanpath = path;
msg_t err;
@ -117,13 +117,13 @@ static msg_t drv_open_dir(void *instance,
if (*scanpath == '\0') {
/* Creating a root directory node.*/
vfs_overlay_dir_node_t *odnp = chPoolAlloc(&drvp->dir_nodes_pool);
vfs_overlay_dir_node_c *odnp = chPoolAlloc(&drvp->dir_nodes_pool);
if (odnp != NULL) {
/* Node object initialization.*/
odnp->vmt = &dir_node_vmt;
odnp->refs = 1U;
odnp->driver = (vfs_driver_t *)instance;
odnp->driver = (vfs_driver_c *)instance;
odnp->index = 0U;
odnp->overlaid_root = NULL;
@ -135,12 +135,12 @@ static msg_t drv_open_dir(void *instance,
&odnp->overlaid_root);
}
*vdnpp = (vfs_directory_node_t *)odnp;
*vdnpp = (vfs_directory_node_c *)odnp;
return VFS_RET_SUCCESS;
}
}
else {
vfs_driver_t *dp;
vfs_driver_c *dp;
/* Searching for a match among registered overlays.*/
err = match_driver(drvp, &scanpath, &dp);
@ -169,8 +169,8 @@ static msg_t drv_open_dir(void *instance,
static msg_t drv_open_file(void *instance,
const char *path,
int oflag,
vfs_file_node_t **vfnpp) {
vfs_overlay_driver_t *drvp = (vfs_overlay_driver_t *)instance;
vfs_file_node_c **vfnpp) {
vfs_overlay_driver_c *drvp = (vfs_overlay_driver_c *)instance;
msg_t err;
do {
@ -184,7 +184,7 @@ static msg_t drv_open_file(void *instance,
err = VFS_RET_ENOENT;
}
else {
vfs_driver_t *dp;
vfs_driver_c *dp;
/* Delegating node creation to a registered driver.*/
err = match_driver(drvp, &path, &dp);
@ -199,8 +199,8 @@ static msg_t drv_open_file(void *instance,
}
static void node_dir_release(void *instance) {
vfs_overlay_dir_node_t *odnp = (vfs_overlay_dir_node_t *)instance;
vfs_overlay_driver_t *drvp = (vfs_overlay_driver_t *)odnp->driver;
vfs_overlay_dir_node_c *odnp = (vfs_overlay_dir_node_c *)instance;
vfs_overlay_driver_c *drvp = (vfs_overlay_driver_c *)odnp->driver;
if (--odnp->refs == 0U) {
@ -214,7 +214,7 @@ static void node_dir_release(void *instance) {
}
static msg_t node_dir_first(void *instance, vfs_node_info_t *nip) {
vfs_overlay_dir_node_t *odnp = (vfs_overlay_dir_node_t *)instance;
vfs_overlay_dir_node_c *odnp = (vfs_overlay_dir_node_c *)instance;
odnp->index = 0U;
@ -222,8 +222,8 @@ static msg_t node_dir_first(void *instance, vfs_node_info_t *nip) {
}
static msg_t node_dir_next(void *instance, vfs_node_info_t *nip) {
vfs_overlay_dir_node_t *odnp = (vfs_overlay_dir_node_t *)instance;
vfs_overlay_driver_t *drvp = (vfs_overlay_driver_t *)odnp->driver;
vfs_overlay_dir_node_c *odnp = (vfs_overlay_dir_node_c *)instance;
vfs_overlay_driver_c *drvp = (vfs_overlay_driver_c *)odnp->driver;
if (odnp->index < drvp->next_driver) {
nip->attr = VFS_NODE_ATTR_ISDIR | VFS_NODE_ATTR_READONLY;
@ -259,15 +259,15 @@ static msg_t node_dir_next(void *instance, vfs_node_info_t *nip) {
/**
* @brief VFS overlay object initialization.
*
* @param[out] vodp pointer to a @p vfs_overlay_driver_t structure
* @param[out] vodp pointer to a @p vfs_overlay_driver_c structure
* @param[out] overlaid_drv pointer to a driver to be overlaid
* @param[in] rootname name to be attributed to this object
* @return A pointer to this initialized object.
*
* @api
*/
vfs_driver_t *drvOverlayObjectInit(vfs_overlay_driver_t *vodp,
vfs_driver_t *overlaid_drv,
vfs_driver_c *drvOverlayObjectInit(vfs_overlay_driver_c *vodp,
vfs_driver_c *overlaid_drv,
const char *rootname) {
vodp->vmt = &driver_vmt;
@ -277,7 +277,7 @@ vfs_driver_t *drvOverlayObjectInit(vfs_overlay_driver_t *vodp,
/* Initializing pools.*/
chPoolObjectInit(&vodp->dir_nodes_pool,
sizeof (vfs_overlay_dir_node_t),
sizeof (vfs_overlay_dir_node_c),
chCoreAllocAlignedI);
/* Preloading pools.*/
@ -285,19 +285,19 @@ vfs_driver_t *drvOverlayObjectInit(vfs_overlay_driver_t *vodp,
&vodp->dir_nodes[0],
DRV_CFG_OVERLAY_DIR_NODES_NUM);
return (vfs_driver_t *)vodp;
return (vfs_driver_c *)vodp;
}
/**
* @brief Registers a VFS driver as an overlay.
*
* @param[in] vodp pointer to a @p vfs_overlay_driver_t structure
* @param[in] vodp pointer to a @p vfs_overlay_driver_c structure
* @return The operation result.
*
* @api
*/
msg_t drvOverlayRegisterDriver(vfs_overlay_driver_t *vodp,
vfs_driver_t *vdp) {
msg_t drvOverlayRegisterDriver(vfs_overlay_driver_c *vodp,
vfs_driver_c *vdp) {
msg_t err;
if (vodp->next_driver >= DRV_CFG_OVERLAY_DRV_MAX) {

36
os/vfs/drivers/overlay/drvoverlay.h
View File

@ -64,29 +64,29 @@
/*===========================================================================*/
/**
* @brief @p vfs_overlay_dir_node_t specific methods.
* @brief @p vfs_overlay_dir_node_c specific methods.
*/
#define __vfs_overlay_dir_node_methods \
__vfs_directory_node_methods
/**
* @brief @p vfs_overlay_dir_node_t specific data.
* @brief @p vfs_overlay_dir_node_c specific data.
*/
#define __vfs_overlay_dir_node_data \
__vfs_directory_node_data \
unsigned index; \
/* Root node of the overlaid driver or NULL.*/ \
vfs_directory_node_t *overlaid_root; \
vfs_directory_node_c *overlaid_root; \
/**
* @brief @p vfs_overlay_dir_node_t virtual methods table.
* @brief @p vfs_overlay_dir_node_c virtual methods table.
*/
struct vfs_overlay_dir_node_vmt {
__vfs_overlay_dir_node_methods
};
/**
* @brief Type of a structure representing a Overlay directory VFS node.
* @brief Type of an overlay directory VFS node class.
*/
typedef struct vfs_overlay_dir_node {
/**
@ -94,39 +94,39 @@ typedef struct vfs_overlay_dir_node {
*/
const struct vfs_overlay_dir_node_vmt *vmt;
__vfs_overlay_dir_node_data
} vfs_overlay_dir_node_t;
} vfs_overlay_dir_node_c;
/**
* @brief @p vfs_overlay_driver_t specific methods.
* @brief @p vfs_overlay_driver_c specific methods.
*/
#define __vfs_overlay_driver_methods \
__vfs_driver_methods
/**
* @brief @p vfs_overlay_driver_t specific data.
* @brief @p vfs_overlay_driver_c specific data.
*/
#define __vfs_overlay_driver_data \
__vfs_driver_data \
/* Pool of directory nodes.*/ \
memory_pool_t dir_nodes_pool; \
/* Driver to be overlaid or NULL.*/ \
vfs_driver_t *overlaid_drv; \
vfs_driver_c *overlaid_drv; \
/* Static storage of directory nodes.*/ \
vfs_overlay_dir_node_t dir_nodes[DRV_CFG_OVERLAY_DIR_NODES_NUM]; \
vfs_overlay_dir_node_c dir_nodes[DRV_CFG_OVERLAY_DIR_NODES_NUM]; \
/* Next registration slot.*/ \
unsigned next_driver; \
/* Registration slots.*/ \
vfs_driver_t *drivers[DRV_CFG_OVERLAY_DRV_MAX];
vfs_driver_c *drivers[DRV_CFG_OVERLAY_DRV_MAX];
/**
* @brief @p vfs_overlay_driver_t virtual methods table.
* @brief @p vfs_overlay_driver_c virtual methods table.
*/
struct vfs_overlay_driver_vmt {
__vfs_overlay_driver_methods
};
/**
* @brief Type of a structure representing a VFS Overlay driver.
* @brief Type of a VFS overlay driver class.
*/
typedef struct vfs_overlay_driver {
/**
@ -134,7 +134,7 @@ typedef struct vfs_overlay_driver {
*/
const struct vfs_overlay_driver_vmt *vmt;
__vfs_overlay_driver_data
} vfs_overlay_driver_t;
} vfs_overlay_driver_c;
/*===========================================================================*/
/* Module macros. */
@ -147,11 +147,11 @@ typedef struct vfs_overlay_driver {
#ifdef __cplusplus
extern "C" {
#endif
vfs_driver_t *drvOverlayObjectInit(vfs_overlay_driver_t *vodp,
vfs_driver_t *overlaid_drv,
vfs_driver_c *drvOverlayObjectInit(vfs_overlay_driver_c *vodp,
vfs_driver_c *overlaid_drv,
const char *rootname);
msg_t drvOverlayRegisterDriver(vfs_overlay_driver_t *vodp,
vfs_driver_t *vdp);
msg_t drvOverlayRegisterDriver(vfs_overlay_driver_c *vodp,
vfs_driver_c *vdp);
#ifdef __cplusplus
}
#endif

54
os/vfs/drivers/streams/drvstreams.c
View File

@ -49,11 +49,11 @@
static msg_t drv_open_dir(void *instance,
const char *path,
vfs_directory_node_t **vdnpp);
vfs_directory_node_c **vdnpp);
static msg_t drv_open_file(void *instance,
const char *path,
int oflag,
vfs_file_node_t **vfnpp);
vfs_file_node_c **vfnpp);
static const struct vfs_streams_driver_vmt driver_vmt = {
.open_dir = drv_open_dir,
@ -94,12 +94,12 @@ static const struct vfs_stream_file_node_vmt file_node_vmt = {
static msg_t drv_open_dir(void *instance,
const char *path,
vfs_directory_node_t **vdnpp) {
vfs_streams_driver_t *drvp = (vfs_streams_driver_t *)instance;
vfs_directory_node_c **vdnpp) {
vfs_streams_driver_c *drvp = (vfs_streams_driver_c *)instance;
msg_t err;
do {
vfs_stream_dir_node_t *sdnp;
vfs_stream_dir_node_c *sdnp;
err = vfs_parse_match_separator(&path);
VFS_BREAK_ON_ERROR(err);
@ -113,10 +113,10 @@ static msg_t drv_open_dir(void *instance,
/* Node object initialization.*/
sdnp->vmt = &dir_node_vmt;
sdnp->refs = 1U;
sdnp->driver = (vfs_driver_t *)drvp;
sdnp->driver = (vfs_driver_c *)drvp;
sdnp->index = 0U;
*vdnpp = (vfs_directory_node_t *)sdnp;
*vdnpp = (vfs_directory_node_c *)sdnp;
return VFS_RET_SUCCESS;
}
@ -130,8 +130,8 @@ static msg_t drv_open_dir(void *instance,
static msg_t drv_open_file(void *instance,
const char *path,
int oflag,
vfs_file_node_t **vfnpp) {
vfs_streams_driver_t *drvp = (vfs_streams_driver_t *)instance;
vfs_file_node_c **vfnpp) {
vfs_streams_driver_c *drvp = (vfs_streams_driver_c *)instance;
const drv_stream_element_t *dsep;
msg_t err;
@ -152,7 +152,7 @@ static msg_t drv_open_file(void *instance,
dsep = &drvp->streams[0];
while (dsep->name != NULL) {
if (strncmp(fname, dsep->name, VFS_CFG_MAX_NAMELEN) == 0) {
vfs_stream_file_node_t *sfnp;
vfs_stream_file_node_c *sfnp;
sfnp = chPoolAlloc(&drvp->file_nodes_pool);
if (sfnp != NULL) {
@ -160,10 +160,10 @@ static msg_t drv_open_file(void *instance,
/* Node object initialization.*/
sfnp->vmt = &file_node_vmt;
sfnp->refs = 1U;
sfnp->driver = (vfs_driver_t *)drvp;
sfnp->driver = (vfs_driver_c *)drvp;
sfnp->stream = dsep->stream;
*vfnpp = (vfs_file_node_t *)sfnp;
*vfnpp = (vfs_file_node_c *)sfnp;
return VFS_RET_SUCCESS;
}
@ -181,17 +181,17 @@ static msg_t drv_open_file(void *instance,
}
static void node_dir_release(void *instance) {
vfs_stream_dir_node_t *sdnp = (vfs_stream_dir_node_t *)instance;
vfs_stream_dir_node_c *sdnp = (vfs_stream_dir_node_c *)instance;
if (--sdnp->refs == 0U) {
chPoolFree(&((vfs_streams_driver_t *)sdnp->driver)->dir_nodes_pool,
chPoolFree(&((vfs_streams_driver_c *)sdnp->driver)->dir_nodes_pool,
(void *)sdnp);
}
}
static msg_t node_dir_first(void *instance, vfs_node_info_t *nip) {
vfs_stream_dir_node_t *sdnp = (vfs_stream_dir_node_t *)instance;
vfs_stream_dir_node_c *sdnp = (vfs_stream_dir_node_c *)instance;
sdnp->index = 0U;
@ -199,8 +199,8 @@ static msg_t node_dir_first(void *instance, vfs_node_info_t *nip) {
}
static msg_t node_dir_next(void *instance, vfs_node_info_t *nip) {
vfs_stream_dir_node_t *sdnp = (vfs_stream_dir_node_t *)instance;
vfs_streams_driver_t *vsdp = (vfs_streams_driver_t *)sdnp->driver;
vfs_stream_dir_node_c *sdnp = (vfs_stream_dir_node_c *)instance;
vfs_streams_driver_c *vsdp = (vfs_streams_driver_c *)sdnp->driver;
if (vsdp->streams[sdnp->index].name != NULL) {
@ -217,29 +217,29 @@ static msg_t node_dir_next(void *instance, vfs_node_info_t *nip) {
}
static void node_file_release(void *instance) {
vfs_stream_file_node_t *sfnp = (vfs_stream_file_node_t *)instance;
vfs_stream_file_node_c *sfnp = (vfs_stream_file_node_c *)instance;
if (--sfnp->refs == 0U) {
chPoolFree(&((vfs_streams_driver_t *)sfnp->driver)->file_nodes_pool,
chPoolFree(&((vfs_streams_driver_c *)sfnp->driver)->file_nodes_pool,
(void *)sfnp);
}
}
static BaseSequentialStream *node_file_get_stream(void *instance) {
vfs_stream_file_node_t *sfnp = (vfs_stream_file_node_t *)instance;
vfs_stream_file_node_c *sfnp = (vfs_stream_file_node_c *)instance;
return sfnp->stream;
}
static ssize_t node_file_read(void *instance, uint8_t *buf, size_t n) {
vfs_stream_file_node_t *sfnp = (vfs_stream_file_node_t *)instance;
vfs_stream_file_node_c *sfnp = (vfs_stream_file_node_c *)instance;
return streamRead(sfnp->stream, buf, n);
}
static ssize_t node_file_write(void *instance, const uint8_t *buf, size_t n) {
vfs_stream_file_node_t *sfnp = (vfs_stream_file_node_t *)instance;
vfs_stream_file_node_c *sfnp = (vfs_stream_file_node_c *)instance;
return streamWrite(sfnp->stream, buf, n);
}
@ -273,14 +273,14 @@ static vfs_offset_t node_file_getsize(void *instance) {
/**
* @brief VFS streams object initialization.
*
* @param[out] vsdp pointer to a @p vfs_streams_driver_t structure
* @param[out] vsdp pointer to a @p vfs_streams_driver_c structure
* @param[in] rootname name to be attributed to this object
* @param[in] streams pointer to an array of @p drv_stream_element_t objects
* @return A pointer to this initialized object.
*
* @api
*/
vfs_driver_t *drvStreamsObjectInit(vfs_streams_driver_t *vsdp,
vfs_driver_c *drvStreamsObjectInit(vfs_streams_driver_c *vsdp,
const char *rootname,
const drv_stream_element_t *streams) {
@ -290,10 +290,10 @@ vfs_driver_t *drvStreamsObjectInit(vfs_streams_driver_t *vsdp,
/* Initializing pools.*/
chPoolObjectInit(&vsdp->dir_nodes_pool,
sizeof (vfs_stream_dir_node_t),
sizeof (vfs_stream_dir_node_c),
chCoreAllocAlignedI);
chPoolObjectInit(&vsdp->file_nodes_pool,
sizeof (vfs_stream_file_node_t),
sizeof (vfs_stream_file_node_c),
chCoreAllocAlignedI);
/* Preloading pools.*/
@ -304,7 +304,7 @@ vfs_driver_t *drvStreamsObjectInit(vfs_streams_driver_t *vsdp,
&vsdp->file_nodes[0],
DRV_CFG_STREAMS_FILE_NODES_NUM);
return (vfs_driver_t *)vsdp;
return (vfs_driver_c *)vsdp;
}
#endif /* VFS_CFG_ENABLE_DRV_STREAMS == TRUE */

36
os/vfs/drivers/streams/drvstreams.h
View File

@ -78,27 +78,27 @@ typedef struct drv_stream_element {
} drv_stream_element_t;
/**
* @brief @p vfs_stream_dir_node_t specific methods.
* @brief @p vfs_stream_dir_node_c specific methods.
*/
#define __vfs_stream_dir_node_methods \
__vfs_directory_node_methods
/**
* @brief @p vfs_stream_dir_node_t specific data.
* @brief @p vfs_stream_dir_node_c specific data.
*/
#define __vfs_stream_dir_node_data \
__vfs_directory_node_data \
unsigned index;
/**
* @brief @p vfs_stream_dir_node_t virtual methods table.
* @brief @p vfs_stream_dir_node_c virtual methods table.
*/
struct vfs_stream_dir_node_vmt {
__vfs_stream_dir_node_methods
};
/**
* @brief Type of a structure representing a stream dir VFS node.
* @brief Type of a stream dir VFS node class.
*/
typedef struct vfs_stream_dir_node {
/**
@ -106,30 +106,30 @@ typedef struct vfs_stream_dir_node {
*/
const struct vfs_stream_dir_node_vmt *vmt;
__vfs_stream_dir_node_data
} vfs_stream_dir_node_t;
} vfs_stream_dir_node_c;
/**
* @brief @p vfs_stream_file_node_t specific methods.
* @brief @p vfs_stream_file_node_c specific methods.
*/
#define __vfs_stream_file_node_methods \
__vfs_file_node_methods
/**
* @brief @p vfs_stream_file_node_t specific data.
* @brief @p vfs_stream_file_node_c specific data.
*/
#define __vfs_stream_file_node_data \
__vfs_file_node_data \
BaseSequentialStream *stream;
/**
* @brief @p vfs_stream_file_node_t virtual methods table.
* @brief @p vfs_stream_file_node_c virtual methods table.
*/
struct vfs_stream_file_node_vmt {
__vfs_stream_file_node_methods
};
/**
* @brief Type of a structure representing a stream file VFS node.
* @brief Type of a stream file VFS node class.
*/
typedef struct vfs_stream_file_node {
/**
@ -137,34 +137,34 @@ typedef struct vfs_stream_file_node {
*/
const struct vfs_stream_file_node_vmt *vmt;
__vfs_stream_file_node_data
} vfs_stream_file_node_t;
} vfs_stream_file_node_c;
/**
* @brief @p vfs_streams_driver_t specific methods.
* @brief @p vfs_streams_driver_c specific methods.
*/
#define __vfs_streams_driver_methods \
__vfs_driver_methods
/**
* @brief @p vfs_streams_driver_t specific data.
* @brief @p vfs_streams_driver_c specific data.
*/
#define __vfs_streams_driver_data \
__vfs_driver_data \
const drv_stream_element_t *streams; \
memory_pool_t file_nodes_pool; \
memory_pool_t dir_nodes_pool; \
vfs_stream_dir_node_t dir_nodes[DRV_CFG_STREAMS_DIR_NODES_NUM]; \
vfs_stream_file_node_t file_nodes[DRV_CFG_STREAMS_FILE_NODES_NUM];
vfs_stream_dir_node_c dir_nodes[DRV_CFG_STREAMS_DIR_NODES_NUM]; \
vfs_stream_file_node_c file_nodes[DRV_CFG_STREAMS_FILE_NODES_NUM];
/**
* @brief @p vfs_streams_driver_t virtual methods table.
* @brief @p vfs_streams_driver_c virtual methods table.
*/
struct vfs_streams_driver_vmt {
__vfs_streams_driver_methods
};
/**
* @brief Type of a structure representing a VFS streams driver.
* @brief Type of a VFS streams driver class.
*/
typedef struct vfs_streams_driver {
/**
@ -172,7 +172,7 @@ typedef struct vfs_streams_driver {
*/
const struct vfs_streams_driver_vmt *vmt;
__vfs_streams_driver_data
} vfs_streams_driver_t;
} vfs_streams_driver_c;
/*===========================================================================*/
/* Module macros. */
@ -185,7 +185,7 @@ typedef struct vfs_streams_driver {
#ifdef __cplusplus
extern "C" {
#endif
vfs_driver_t *drvStreamsObjectInit(vfs_streams_driver_t *vsdp,
vfs_driver_c *drvStreamsObjectInit(vfs_streams_driver_c *vsdp,
const char *rootname,
const drv_stream_element_t *streams);
#ifdef __cplusplus

28
os/vfs/include/vfs.h
View File

@ -68,6 +68,8 @@
/* Dependencies.*/
#include "osal.h"
#include "oop_object.h"
#include "oop_referenced_object.h"
#include "hal_objects.h"
#include "hal_streams.h"
@ -99,28 +101,28 @@
/* Application code is suppored to export this symbol, it is expected to
exists.*/
extern vfs_driver_t *vfs_root;
extern vfs_driver_c *vfs_root;
#ifdef __cplusplus
extern "C" {
#endif
msg_t vfsOpenDirectory(const char *name,
vfs_directory_node_t **vdnpp);
void vfsCloseDirectory(vfs_directory_node_t *vdnp);
msg_t vfsReadDirectoryFirst(vfs_directory_node_t *vdnp,
vfs_directory_node_c **vdnpp);
void vfsCloseDirectory(vfs_directory_node_c *vdnp);
msg_t vfsReadDirectoryFirst(vfs_directory_node_c *vdnp,
vfs_node_info_t *nip);
msg_t vfsReadDirectoryNext(vfs_directory_node_t *vdnp,
msg_t vfsReadDirectoryNext(vfs_directory_node_c *vdnp,
vfs_node_info_t *nip);
msg_t vfsOpenFile(const char *name,
unsigned mode,
vfs_file_node_t **vfnpp);
void vfsCloseFile(vfs_file_node_t *vfnp);
ssize_t vfsReadFile(vfs_file_node_t *vfnp, uint8_t *buf, size_t n);
ssize_t vfsWriteFile(vfs_file_node_t *vfnp, const uint8_t *buf, size_t n);
msg_t vfsSetFilePosition(vfs_file_node_t *vfnp, vfs_offset_t offset);
vfs_offset_t vfsGetFilePosition(vfs_file_node_t *vfnp);
vfs_offset_t vfsGetFileSize(vfs_file_node_t *vfnp);
BaseSequentialStream *vfsGetFileStream(vfs_file_node_t *vfnp);
vfs_file_node_c **vfnpp);
void vfsCloseFile(vfs_file_node_c *vfnp);
ssize_t vfsReadFile(vfs_file_node_c *vfnp, uint8_t *buf, size_t n);
ssize_t vfsWriteFile(vfs_file_node_c *vfnp, const uint8_t *buf, size_t n);
msg_t vfsSetFilePosition(vfs_file_node_c *vfnp, vfs_offset_t offset);
vfs_offset_t vfsGetFilePosition(vfs_file_node_c *vfnp);
vfs_offset_t vfsGetFileSize(vfs_file_node_c *vfnp);
BaseSequentialStream *vfsGetFileStream(vfs_file_node_c *vfnp);
#ifdef __cplusplus
}
#endif

18
os/vfs/include/vfsdrivers.h
View File

@ -63,34 +63,34 @@
/*===========================================================================*/
/**
* @brief @p vfs_driver_t specific methods.
* @brief @p vfs_driver_c specific methods.
*/
#define __vfs_driver_methods \
_base_object_methods \
__base_object_methods \
msg_t (*open_dir)(void *instance, \
const char *path, \
vfs_directory_node_t **vdnpp); \
vfs_directory_node_c **vdnpp); \
msg_t (*open_file)(void *instance, \
const char *path, \
int oflag, \
vfs_file_node_t **vfnpp);
vfs_file_node_c **vfnpp);
/**
* @brief @p vfs_driver_t specific data.
* @brief @p vfs_driver_c specific data.
*/
#define __vfs_driver_data \
_base_object_data \
__base_object_data \
const char *rootname;
/**
* @brief @p vfs_driver_t virtual methods table.
* @brief @p vfs_driver_c virtual methods table.
*/
struct vfs_driver_vmt {
__vfs_driver_methods
};
/**
* @brief Type of a structure representing a VFS driver.
* @brief Type of a VFS driver class.
*/
typedef struct vfs_driver {
/**
@ -98,7 +98,7 @@ typedef struct vfs_driver {
*/
const struct vfs_driver_vmt *vmt;
__vfs_driver_data
} vfs_driver_t;
} vfs_driver_c;
/*===========================================================================*/
/* Module macros. */

38
os/vfs/include/vfsnodes.h
View File

@ -57,7 +57,7 @@
/*===========================================================================*/
/* Forward declaration because nodes holds references to drivers.*/
typedef struct vfs_driver vfs_driver_t;
typedef struct vfs_driver vfs_driver_c;
/**
* @brief Type of a file offset.
@ -89,30 +89,30 @@ typedef struct vfs_node_info {
} vfs_node_info_t;
/**
* @brief Type of a structure representing a generic VFS node.
* @brief Type of a generic VFS node class.
*/
typedef struct vfs_node vfs_node_t;
typedef struct vfs_node vfs_node_c;
/**
* @brief @p vfs_node_t specific methods.
* @brief @p vfs_node_c specific methods.
*/
#define __vfs_node_methods \
_base_object_methods \
__base_object_methods \
/* Node release, the object is disposed when the counter reaches zero.*/ \
void (*release)(void *instance);
/**
* @brief @p vfs_node_t specific data.
* @brief @p vfs_node_c specific data.
*/
#define __vfs_node_data \
_base_object_data \
__base_object_data \
/* Number of references to this node.*/ \
unsigned refs; \
/* Driver handling this node.*/ \
vfs_driver_t *driver;
vfs_driver_c *driver;
/**
* @brief @p vfs_node_t virtual methods table.
* @brief @p vfs_node_c virtual methods table.
*/
struct vfs_node_vmt {
__vfs_node_methods
@ -130,12 +130,12 @@ struct vfs_node {
};
/**
* @brief Type of a structure representing a directory VFS node.
* @brief Type of a directory VFS node class.
*/
typedef struct vfs_directory_node vfs_directory_node_t;
typedef struct vfs_directory_node vfs_directory_node_c;
/**
* @brief @p vfs_directory_node_t specific methods.
* @brief @p vfs_directory_node_c specific methods.
*/
#define __vfs_directory_node_methods \
__vfs_node_methods \
@ -143,13 +143,13 @@ typedef struct vfs_directory_node vfs_directory_node_t;
msg_t (*dir_next)(void *instance, vfs_node_info_t *nip);
/**
* @brief @p vfs_directory_node_t specific data.
* @brief @p vfs_directory_node_c specific data.
*/
#define __vfs_directory_node_data \
__vfs_node_data
/**
* @brief @p vfs_directory_node_t virtual methods table.
* @brief @p vfs_directory_node_c virtual methods table.
*/
struct vfs_directory_node_vmt {
__vfs_directory_node_methods
@ -167,12 +167,12 @@ struct vfs_directory_node {
};
/**
* @brief Type of a structure representing a file VFS node.
* @brief Type of a a file VFS node class.
*/
typedef struct vfs_file_node vfs_file_node_t;
typedef struct vfs_file_node vfs_file_node_c;
/**
* @brief @p vfs_file_node_t specific methods.
* @brief @p vfs_file_node_c specific methods.
*/
#define __vfs_file_node_methods \
__vfs_node_methods \
@ -184,13 +184,13 @@ typedef struct vfs_file_node vfs_file_node_t;
vfs_offset_t (*file_getsize)(void *instance);
/**
* @brief @p vfs_file_node_t specific data.
* @brief @p vfs_file_node_c specific data.
*/
#define __vfs_file_node_data \
__vfs_node_data
/**
* @brief @p vfs_file_node_t virtual methods table.
* @brief @p vfs_file_node_c virtual methods table.
*/
struct vfs_file_node_vmt {
__vfs_file_node_methods

52
os/vfs/src/vfs.c
View File

@ -58,26 +58,26 @@
*
* @param[in] path absolute path of the directory to be opened
* @param[out] vdnpp pointer to the pointer to the instantiated
* @p vfs_directory_node_t object
* @p vfs_directory_node_c object
* @return The operation result.
*
* @api
*/
msg_t vfsOpenDirectory(const char *path,
vfs_directory_node_t **vdnpp) {
vfs_directory_node_c **vdnpp) {
return vfs_root->vmt->open_dir(vfs_root, path, vdnpp);
}
/**
* @brief Releases a @p vfs_directory_node_t object.
* @brief Releases a @p vfs_directory_node_c object.
*
* @param[in] vdnp the pointer to the @p vfs_directory_node_t object
* @param[in] vdnp the pointer to the @p vfs_directory_node_c object
* to be released
*
* @api
*/
void vfsCloseDirectory(vfs_directory_node_t *vdnp) {
void vfsCloseDirectory(vfs_directory_node_c *vdnp) {
chDbgAssert(vdnp->refs > 0U, "zero count");
@ -87,13 +87,13 @@ void vfsCloseDirectory(vfs_directory_node_t *vdnp) {
/**
* @brief First directory entry.
*
* @param[in] vdnp the pointer to the @p vfs_directory_node_t object
* @param[in] vdnp the pointer to the @p vfs_directory_node_c object
* @param[out] nip pointer to a @p vfs_node_info_t structure
* @return The operation result.
*
* @api
*/
msg_t vfsReadDirectoryFirst(vfs_directory_node_t *vdnp,
msg_t vfsReadDirectoryFirst(vfs_directory_node_c *vdnp,
vfs_node_info_t *nip) {
chDbgAssert(vdnp->refs > 0U, "zero count");
@ -104,13 +104,13 @@ msg_t vfsReadDirectoryFirst(vfs_directory_node_t *vdnp,
/**
* @brief Next directory entry.
*
* @param[in] vdnp the pointer to the @p vfs_directory_node_t object
* @param[in] vdnp the pointer to the @p vfs_directory_node_c object
* @param[out] nip pointer to a @p vfs_node_info_t structure
* @return The operation result.
*
* @api
*/
msg_t vfsReadDirectoryNext(vfs_directory_node_t *vdnp,
msg_t vfsReadDirectoryNext(vfs_directory_node_c *vdnp,
vfs_node_info_t *nip) {
chDbgAssert(vdnp->refs > 0U, "zero count");
@ -124,27 +124,27 @@ msg_t vfsReadDirectoryNext(vfs_directory_node_t *vdnp,
* @param[in] path absolute path of the file to be opened
* @param[in] mode file open mode
* @param[out] vdnpp pointer to the pointer to the instantiated
* @p vfs_file_node_t object
* @p vfs_file_node_c object
* @return The operation result.
*
* @api
*/
msg_t vfsOpenFile(const char *path,
unsigned mode,
vfs_file_node_t **vfnpp) {
vfs_file_node_c **vfnpp) {
return vfs_root->vmt->open_file(vfs_root, path, mode, vfnpp);
}
/**
* @brief Releases a @p vfs_file_node_t object.
* @brief Releases a @p vfs_file_node_c object.
*
* @param[in] vfnp the pointer to the @p vfs_file_node_t object
* @param[in] vfnp the pointer to the @p vfs_file_node_c object
* to be released
*
* @api
*/
void vfsCloseFile(vfs_file_node_t *vfnp) {
void vfsCloseFile(vfs_file_node_c *vfnp) {
chDbgAssert(vfnp->refs > 0U, "zero count");
@ -155,14 +155,14 @@ void vfsCloseFile(vfs_file_node_t *vfnp) {
* @brief File node read.
* @details The function reads data from a file node into a buffer.
*
* @param[in] vfnp the pointer to the @p vfs_file_node_t object
* @param[in] vfnp the pointer to the @p vfs_file_node_c object
* @param[out] buf pointer to the data buffer
* @param[in] n the maximum amount of data to be transferred
* @return The transferred number of bytes or an error.
*
* @api
*/
ssize_t vfsReadFile(vfs_file_node_t *vfnp, uint8_t *buf, size_t n) {
ssize_t vfsReadFile(vfs_file_node_c *vfnp, uint8_t *buf, size_t n) {
chDbgAssert(vfnp->refs > 0U, "zero count");
@ -173,14 +173,14 @@ ssize_t vfsReadFile(vfs_file_node_t *vfnp, uint8_t *buf, size_t n) {
* @brief File node write.
* @details The function writes data from a buffer to a file node.
*
* @param[in] vfnp the pointer to the @p vfs_file_node_t object
* @param[in] vfnp the pointer to the @p vfs_file_node_c object
* @param[out] buf pointer to the data buffer
* @param[in] n the maximum amount of data to be transferred
* @return The transferred number of bytes or an error.
*
* @api
*/
ssize_t vfsWriteFile(vfs_file_node_t *vfnp, const uint8_t *buf, size_t n) {
ssize_t vfsWriteFile(vfs_file_node_c *vfnp, const uint8_t *buf, size_t n) {
chDbgAssert(vfnp->refs > 0U, "zero count");
@ -190,13 +190,13 @@ ssize_t vfsWriteFile(vfs_file_node_t *vfnp, const uint8_t *buf, size_t n) {
/**
* @brief Changes the current file position.
*
* @param[in] vfnp the pointer to the @p vfs_file_node_t object
* @param[in] vfnp the pointer to the @p vfs_file_node_c object
* @param[in] offset new absolute position
* @return The operation result.
*
* @api
*/
msg_t vfsSetFilePosition(vfs_file_node_t *vfnp, vfs_offset_t offset) {
msg_t vfsSetFilePosition(vfs_file_node_c *vfnp, vfs_offset_t offset) {
chDbgAssert(vfnp->refs > 0U, "zero count");
@ -206,12 +206,12 @@ msg_t vfsSetFilePosition(vfs_file_node_t *vfnp, vfs_offset_t offset) {
/**
* @brief Returns the current file position.
*
* @param[in] vfnp the pointer to the @p vfs_file_node_t object
* @param[in] vfnp the pointer to the @p vfs_file_node_c object
* @return The current file position.
*
* @api
*/
vfs_offset_t vfsGetFilePosition(vfs_file_node_t *vfnp) {
vfs_offset_t vfsGetFilePosition(vfs_file_node_c *vfnp) {
chDbgAssert(vfnp->refs > 0U, "zero count");
@ -221,12 +221,12 @@ vfs_offset_t vfsGetFilePosition(vfs_file_node_t *vfnp) {
/**
* @brief Returns the current file size.
*
* @param[in] vfnp the pointer to the @p vfs_file_node_t object
* @param[in] vfnp the pointer to the @p vfs_file_node_c object
* @return The current file size.
*
* @api
*/
vfs_offset_t vfsGetFileSize(vfs_file_node_t *vfnp) {
vfs_offset_t vfsGetFileSize(vfs_file_node_c *vfnp) {
chDbgAssert(vfnp->refs > 0U, "zero count");
@ -236,12 +236,12 @@ vfs_offset_t vfsGetFileSize(vfs_file_node_t *vfnp) {
/**
* @brief Returns the inner stream associated to the file.
*
* @param[in] vfnp the pointer to the @p vfs_file_node_t object
* @param[in] vfnp the pointer to the @p vfs_file_node_c object
* @return The current file size.
*
* @api
*/
BaseSequentialStream *vfsGetFileStream(vfs_file_node_t *vfnp) {
BaseSequentialStream *vfsGetFileStream(vfs_file_node_c *vfnp) {
chDbgAssert(vfnp->refs > 0U, "zero count");