ARMmbed
/
mbed-os
mirror of https://github.com/ARMmbed/mbed-os.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Merge pull request #5768 from deepikabhavnani/storage_stats 

Added statvfs API to get storage statistics
pull/5744/merge
Cruz Monrreal 2018-01-11 10:25:41 -06:00 committed by GitHub
parent 2c5fedc0b2 d5cf4a6a6a
commit c0c501c70f
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
10 changed files with 188 additions and 33 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
features/filesystem/FileSystem.cpp
View File

@ -51,6 +51,11 @@ int FileSystem::mkdir(const char *path, mode_t mode)
return -ENOSYS;
}
int FileSystem::statvfs(const char *path, struct statvfs *buf)
{
return -ENOSYS;
}
int FileSystem::file_sync(fs_file_t file)
{
return 0;

12
features/filesystem/FileSystem.h
View File

@ -109,6 +109,14 @@ public:
*/
virtual int mkdir(const char *path, mode_t mode);
/** Store information about the mounted filesystem in a statvfs structure
*
* @param path The name of the file to find information about
* @param buf The stat buffer to write to
* @return 0 on success, negative error code on failure
*/
virtual int statvfs(const char *path, struct statvfs *buf);
protected:
friend class File;
friend class Dir;
@ -143,7 +151,7 @@ protected:
*
* @param file File handle
* @param buffer The buffer to write from
* @param size The number of bytes to write
* @param size The number of bytes to write
* @return The number of bytes written, negative error on failure
*/
virtual ssize_t file_write(fs_file_t file, const void *buffer, size_t size) = 0;
@ -240,7 +248,7 @@ protected:
*/
virtual void dir_rewind(fs_dir_t dir);
/** Get the sizeof the directory
/** Get the sizeof the directory
*
* @param dir Dir handle
* @return Number of files in the directory

101
features/filesystem/fat/FATFileSystem.cpp
View File

@ -275,12 +275,14 @@ FATFileSystem::~FATFileSystem()
unmount();
}
int FATFileSystem::mount(BlockDevice *bd) {
int FATFileSystem::mount(BlockDevice *bd)
{
// requires duplicate definition to allow virtual overload to work
return mount(bd, true);
}
int FATFileSystem::mount(BlockDevice *bd, bool mount) {
int FATFileSystem::mount(BlockDevice *bd, bool mount)
{
lock();
if (_id != -1) {
unlock();
@ -322,7 +324,8 @@ int FATFileSystem::unmount()
/* See http://elm-chan.org/fsw/ff/en/mkfs.html for details of f_mkfs() and
* associated arguments. */
int FATFileSystem::format(BlockDevice *bd, bd_size_t cluster_size) {
int FATFileSystem::format(BlockDevice *bd, bd_size_t cluster_size)
{
FATFileSystem fs;
int err = fs.mount(bd, false);
if (err) {
@ -345,7 +348,8 @@ int FATFileSystem::format(BlockDevice *bd, bd_size_t cluster_size) {
return 0;
}
int FATFileSystem::reformat(BlockDevice *bd, int allocation_unit) {
int FATFileSystem::reformat(BlockDevice *bd, int allocation_unit)
{
lock();
if (_id != -1) {
if (!bd) {
@ -375,7 +379,8 @@ int FATFileSystem::reformat(BlockDevice *bd, int allocation_unit) {
return err;
}
int FATFileSystem::remove(const char *path) {
int FATFileSystem::remove(const char *path)
{
Deferred<const char*> fpath = fat_path_prefix(_id, path);
lock();
@ -388,7 +393,8 @@ int FATFileSystem::remove(const char *path) {
return fat_error_remap(res);
}
int FATFileSystem::rename(const char *oldpath, const char *newpath) {
int FATFileSystem::rename(const char *oldpath, const char *newpath)
{
Deferred<const char*> oldfpath = fat_path_prefix(_id, oldpath);
Deferred<const char*> newfpath = fat_path_prefix(_id, newpath);
@ -402,7 +408,8 @@ int FATFileSystem::rename(const char *oldpath, const char *newpath) {
return fat_error_remap(res);
}
int FATFileSystem::mkdir(const char *path, mode_t mode) {
int FATFileSystem::mkdir(const char *path, mode_t mode)
{
Deferred<const char*> fpath = fat_path_prefix(_id, path);
lock();
@ -415,7 +422,8 @@ int FATFileSystem::mkdir(const char *path, mode_t mode) {
return fat_error_remap(res);
}
int FATFileSystem::stat(const char *path, struct stat *st) {
int FATFileSystem::stat(const char *path, struct stat *st)
{
Deferred<const char*> fpath = fat_path_prefix(_id, path);
lock();
@ -442,17 +450,49 @@ int FATFileSystem::stat(const char *path, struct stat *st) {
return 0;
}
void FATFileSystem::lock() {
int FATFileSystem::statvfs(const char *path, struct statvfs *buf)
{
memset(buf, 0, sizeof(struct statvfs));
FATFS *fs;
DWORD fre_clust;
lock();
FRESULT res = f_getfree(_fsid, &fre_clust, &fs);
if (res != FR_OK) {
unlock();
return fat_error_remap(res);
}
buf->f_bsize = fs->ssize;
buf->f_frsize = fs->ssize;
buf->f_blocks = (fs->n_fatent - 2) * fs->csize;
buf->f_bfree = fre_clust * fs->csize;
buf->f_bavail = buf->f_bfree;
#if FF_USE_LFN
buf->f_namemax = FF_LFN_BUF;
#else
buf->f_namemax = FF_SFN_BUF;
#endif
unlock();
return 0;
}
void FATFileSystem::lock()
{
_ffs_mutex->lock();
}
void FATFileSystem::unlock() {
void FATFileSystem::unlock()
{
_ffs_mutex->unlock();
}
////// File operations //////
int FATFileSystem::file_open(fs_file_t *file, const char *path, int flags) {
int FATFileSystem::file_open(fs_file_t *file, const char *path, int flags)
{
debug_if(FFS_DBG, "open(%s) on filesystem [%s], drv [%s]\n", path, getName(), _id);
FIL *fh = new FIL;
@ -496,7 +536,8 @@ int FATFileSystem::file_open(fs_file_t *file, const char *path, int flags) {
return 0;
}
int FATFileSystem::file_close(fs_file_t file) {
int FATFileSystem::file_close(fs_file_t file)
{
FIL *fh = static_cast<FIL*>(file);
lock();
@ -507,7 +548,8 @@ int FATFileSystem::file_close(fs_file_t file) {
return fat_error_remap(res);
}
ssize_t FATFileSystem::file_read(fs_file_t file, void *buffer, size_t len) {
ssize_t FATFileSystem::file_read(fs_file_t file, void *buffer, size_t len)
{
FIL *fh = static_cast<FIL*>(file);
lock();
@ -523,7 +565,8 @@ ssize_t FATFileSystem::file_read(fs_file_t file, void *buffer, size_t len) {
}
}
ssize_t FATFileSystem::file_write(fs_file_t file, const void *buffer, size_t len) {
ssize_t FATFileSystem::file_write(fs_file_t file, const void *buffer, size_t len)
{
FIL *fh = static_cast<FIL*>(file);
lock();
@ -539,7 +582,8 @@ ssize_t FATFileSystem::file_write(fs_file_t file, const void *buffer, size_t len
}
}
int FATFileSystem::file_sync(fs_file_t file) {
int FATFileSystem::file_sync(fs_file_t file)
{
FIL *fh = static_cast<FIL*>(file);
lock();
@ -552,7 +596,8 @@ int FATFileSystem::file_sync(fs_file_t file) {
return fat_error_remap(res);
}
off_t FATFileSystem::file_seek(fs_file_t file, off_t offset, int whence) {
off_t FATFileSystem::file_seek(fs_file_t file, off_t offset, int whence)
{
FIL *fh = static_cast<FIL*>(file);
lock();
@ -574,7 +619,8 @@ off_t FATFileSystem::file_seek(fs_file_t file, off_t offset, int whence) {
}
}
off_t FATFileSystem::file_tell(fs_file_t file) {
off_t FATFileSystem::file_tell(fs_file_t file)
{
FIL *fh = static_cast<FIL*>(file);
lock();
@ -584,7 +630,8 @@ off_t FATFileSystem::file_tell(fs_file_t file) {
return res;
}
off_t FATFileSystem::file_size(fs_file_t file) {
off_t FATFileSystem::file_size(fs_file_t file)
{
FIL *fh = static_cast<FIL*>(file);
lock();
@ -596,7 +643,8 @@ off_t FATFileSystem::file_size(fs_file_t file) {
////// Dir operations //////
int FATFileSystem::dir_open(fs_dir_t *dir, const char *path) {
int FATFileSystem::dir_open(fs_dir_t *dir, const char *path)
{
FATFS_DIR *dh = new FATFS_DIR;
Deferred<const char*> fpath = fat_path_prefix(_id, path);
@ -614,7 +662,8 @@ int FATFileSystem::dir_open(fs_dir_t *dir, const char *path) {
return 0;
}
int FATFileSystem::dir_close(fs_dir_t dir) {
int FATFileSystem::dir_close(fs_dir_t dir)
{
FATFS_DIR *dh = static_cast<FATFS_DIR*>(dir);
lock();
@ -625,7 +674,8 @@ int FATFileSystem::dir_close(fs_dir_t dir) {
return fat_error_remap(res);
}
ssize_t FATFileSystem::dir_read(fs_dir_t dir, struct dirent *ent) {
ssize_t FATFileSystem::dir_read(fs_dir_t dir, struct dirent *ent)
{
FATFS_DIR *dh = static_cast<FATFS_DIR*>(dir);
FILINFO finfo;
@ -653,7 +703,8 @@ ssize_t FATFileSystem::dir_read(fs_dir_t dir, struct dirent *ent) {
return 1;
}
void FATFileSystem::dir_seek(fs_dir_t dir, off_t offset) {
void FATFileSystem::dir_seek(fs_dir_t dir, off_t offset)
{
FATFS_DIR *dh = static_cast<FATFS_DIR*>(dir);
lock();
@ -675,7 +726,8 @@ void FATFileSystem::dir_seek(fs_dir_t dir, off_t offset) {
unlock();
}
off_t FATFileSystem::dir_tell(fs_dir_t dir) {
off_t FATFileSystem::dir_tell(fs_dir_t dir)
{
FATFS_DIR *dh = static_cast<FATFS_DIR*>(dir);
lock();
@ -685,7 +737,8 @@ off_t FATFileSystem::dir_tell(fs_dir_t dir) {
return offset;
}
void FATFileSystem::dir_rewind(fs_dir_t dir) {
void FATFileSystem::dir_rewind(fs_dir_t dir)
{
FATFS_DIR *dh = static_cast<FATFS_DIR*>(dir);
lock();

16
features/filesystem/fat/FATFileSystem.h
View File

@ -43,7 +43,7 @@ public:
*/
FATFileSystem(const char *name = NULL, BlockDevice *bd = NULL);
virtual ~FATFileSystem();
/** Formats a logical drive, FDISK partitioning rule.
*
* The block device to format should be mounted when this function is called.
@ -57,7 +57,7 @@ public:
* cluster_size must be a multiple of the underlying device's allocation unit
* and is currently limited to a max of 32,768 bytes. If zero, a cluster size
* will be determined from the device's allocation unit. Defaults to zero.
*
*
* @return 0 on success, negative error code on failure
*/
static int format(BlockDevice *bd, bd_size_t cluster_size = 0);
@ -139,6 +139,14 @@ public:
*/
virtual int mkdir(const char *path, mode_t mode);
/** Store information about the mounted filesystem in a statvfs structure
*
* @param path The name of the file to find information about
* @param buf The stat buffer to write to
* @return 0 on success, negative error code on failure
*/
virtual int statvfs(const char *path, struct statvfs *buf);
protected:
/** Open a file on the filesystem
*
@ -170,7 +178,7 @@ protected:
*
* @param file File handle
* @param buffer The buffer to write from
* @param len The number of bytes to write
* @param len The number of bytes to write
* @return The number of bytes written, negative error on failure
*/
virtual ssize_t file_write(fs_file_t file, const void *buffer, size_t len);
@ -251,7 +259,7 @@ protected:
* @param dir Dir handle
*/
virtual void dir_rewind(fs_dir_t dir);
private:
FATFS _fs; // Work area (file system object) for logical drive
char _fsid[sizeof("0:")];

28
features/filesystem/littlefs/LittleFileSystem.cpp
View File

@ -336,6 +336,34 @@ int LittleFileSystem::stat(const char *name, struct stat *st)
return lfs_toerror(err);
}
static int lfs_statvfs_count(void *p, lfs_block_t b)
{
*(lfs_size_t *)p += 1;
return 0;
}
int LittleFileSystem::statvfs(const char *name, struct statvfs *st)
{
memset(st, 0, sizeof(struct statvfs));
lfs_size_t in_use = 0;
_mutex.lock();
LFS_INFO("statvfs(\"%s\", %p)", name, st);
int err = lfs_traverse(&_lfs, lfs_statvfs_count, &in_use);
LFS_INFO("statvfs -> %d", lfs_toerror(err));
_mutex.unlock();
if (err) {
return err;
}
st->f_bsize = _config.block_size;
st->f_frsize = _config.block_size;
st->f_blocks = _config.block_count;
st->f_bfree = _config.block_count - in_use;
st->f_bavail = _config.block_count - in_use;
st->f_namemax = LFS_NAME_MAX;
return 0;
}
////// File operations //////
int LittleFileSystem::file_open(fs_file_t *file, const char *path, int flags)

8
features/filesystem/littlefs/LittleFileSystem.h
View File

@ -143,6 +143,14 @@ public:
*/
virtual int mkdir(const char *path, mode_t mode);
/** Store information about the mounted filesystem in a statvfs structure
*
* @param path The name of the file to find information about
* @param buf The stat buffer to write to
* @return 0 on success, negative error code on failure
*/
virtual int statvfs(const char *path, struct statvfs *buf);
protected:
/** Open a file on the filesystem
*

5
platform/FileSystemHandle.cpp
View File

@ -42,3 +42,8 @@ int FileSystemHandle::mkdir(const char *path, mode_t mode)
{
return -ENOSYS;
}
int FileSystemHandle::statvfs(const char *path, struct statvfs *buf)
{
return -ENOSYS;
}

8
platform/FileSystemHandle.h
View File

@ -94,6 +94,14 @@ public:
* @return 0 on success, negative error code on failure
*/
virtual int mkdir(const char *path, mode_t mode);
/** Store information about the mounted filesystem in a statvfs structure
*
* @param path The name of the file to find information about
* @param buf The stat buffer to write to
* @return 0 on success, negative error code on failure
*/
virtual int statvfs(const char *path, struct statvfs *buf);
};
/**@}*/

17
platform/mbed_retarget.cpp
View File

@ -711,6 +711,23 @@ extern "C" int stat(const char *path, struct stat *st) {
}
}
extern "C" int statvfs(const char *path, struct statvfs *buf) {
FilePath fp(path);
FileSystemHandle *fs = fp.fileSystem();
if (fs == NULL) {
errno = ENODEV;
return -1;
}
int err = fs->statvfs(fp.fileName(), buf);
if (err < 0) {
errno = -err;
return -1;
} else {
return 0;
}
}
#if defined(TOOLCHAIN_GCC)
/* prevents the exception handling name demangling code getting pulled in */
#include "mbed_error.h"

21
platform/mbed_retarget.h
View File

@ -28,8 +28,9 @@
/* We can get the following standard types from sys/types for gcc, but we
* need to define the types ourselves for the other compilers that normally
* target embedded systems */
typedef signed int ssize_t; ///< Signed size type, usually encodes negative errors
typedef signed long off_t; ///< Offset in a data stream
typedef signed int ssize_t; ///< Signed size type, usually encodes negative errors
typedef signed long off_t; ///< Offset in a data stream
typedef unsigned long long fsblkcnt_t; ///< Count of file system blocks
#if defined(__ARMCC_VERSION) || !defined(__GNUC__)
typedef unsigned int mode_t; ///< Mode for opening files
typedef unsigned int dev_t; ///< Device ID type
@ -62,7 +63,7 @@ typedef unsigned int gid_t; ///< Group ID
/* DIR declarations must also be here */
#if __cplusplus
namespace mbed {
class FileHandle;
class DirHandle;
std::FILE *mbed_fdopen(FileHandle *fh, const char *mode);
@ -415,10 +416,24 @@ struct stat {
time_t st_ctime; ///< Time of last status change
};
struct statvfs {
unsigned long f_bsize; ///< Filesystem block size
unsigned long f_frsize; ///< Fragment size (block size)
fsblkcnt_t f_blocks; ///< Number of blocks
fsblkcnt_t f_bfree; ///< Number of free blocks
fsblkcnt_t f_bavail; ///< Number of free blocks for unprivileged users
unsigned long f_fsid; ///< Filesystem ID
unsigned long f_namemax; ///< Maximum filename length
};
#if __cplusplus
extern "C" {
#endif
int stat(const char *path, struct stat *st);
int statvfs(const char *path, struct statvfs *buf);
#if __cplusplus
};
#endif