off_t LittleFileSystem::file_seek(fs_file_t file, off_t offset, int whence)
{
lfs_file_t *f = (lfs_file_t *)file;
_mutex.lock();
LFS_INFO("file_seek(%p, %ld, %d)", file, offset, whence);
off_t res = lfs_file_seek(&_lfs, f, offset, lfs_fromwhence(whence));
LFS_INFO("file_seek -> %d", lfs_toerror(res));
_mutex.unlock();
return lfs_toerror(res);
}
off_t LittleFileSystem::file_tell(fs_file_t file)
{
lfs_file_t *f = (lfs_file_t *)file;
_mutex.lock();
LFS_INFO("file_tell(%p)", file);
off_t res = lfs_file_tell(&_lfs, f);
LFS_INFO("file_tell -> %d", lfs_toerror(res));
_mutex.unlock();
return lfs_toerror(res);
}
ssize_t LittleFileSystem::file_write(fs_file_t file, const void *buffer, size_t len)
{
lfs_file_t *f = (lfs_file_t *)file;
_mutex.lock();
LFS_INFO("file_write(%p, %p, %d)", file, buffer, len);
lfs_ssize_t res = lfs_file_write(&_lfs, f, buffer, len);
LFS_INFO("file_write -> %d", lfs_toerror(res));
_mutex.unlock();
return lfs_toerror(res);
}
int LittleFileSystem::file_sync(fs_file_t file)
{
lfs_file_t *f = (lfs_file_t *)file;
_mutex.lock();
LFS_INFO("file_sync(%p)", file);
int err = lfs_file_sync(&_lfs, f);
LFS_INFO("file_sync -> %d", lfs_toerror(err));
_mutex.unlock();
return lfs_toerror(err);
}
off_t LittleFileSystem::dir_tell(fs_dir_t dir)
{
lfs_dir_t *d = (lfs_dir_t *)dir;
_mutex.lock();
LFS_INFO("dir_tell(%p)", dir);
lfs_soff_t res = lfs_dir_tell(&_lfs, d);
LFS_INFO("dir_tell -> %d", lfs_toerror(res));
_mutex.unlock();
return lfs_toerror(res);
}
int LittleFileSystem::dir_close(fs_dir_t dir)
{
lfs_dir_t *d = (lfs_dir_t *)dir;
_mutex.lock();
LFS_INFO("dir_close(%p)", dir);
int err = lfs_dir_close(&_lfs, d);
LFS_INFO("dir_close -> %d", lfs_toerror(err));
_mutex.unlock();
delete d;
return lfs_toerror(err);
}
int LittleFileSystem::stat(const char *name, struct stat *st)
{
struct lfs_info info;
_mutex.lock();
LFS_INFO("stat(\"%s\", %p)", name, st);
int err = lfs_stat(&_lfs, name, &info);
LFS_INFO("stat -> %d", lfs_toerror(err));
_mutex.unlock();
st->st_size = info.size;
st->st_mode = lfs_tomode(info.type);
return lfs_toerror(err);
}
int LittleFileSystem::format(BlockDevice *bd,
lfs_size_t read_size, lfs_size_t prog_size,
lfs_size_t block_size, lfs_size_t lookahead) {
LFS_INFO("format(%p, %ld, %ld, %ld, %ld)",
bd, read_size, prog_size, block_size, lookahead);
int err = bd->init();
if (err) {
LFS_INFO("format -> %d", err);
return err;
}
lfs_t _lfs;
struct lfs_config _config;
memset(&_config, 0, sizeof(_config));
_config.context = bd;
_config.read = lfs_bd_read;
_config.prog = lfs_bd_prog;
_config.erase = lfs_bd_erase;
_config.sync = lfs_bd_sync;
_config.read_size = bd->get_read_size();
if (_config.read_size < read_size) {
_config.read_size = read_size;
}
_config.prog_size = bd->get_program_size();
if (_config.prog_size < prog_size) {
_config.prog_size = prog_size;
}
_config.block_size = bd->get_erase_size();
if (_config.block_size < block_size) {
_config.block_size = block_size;
}
_config.block_count = bd->size() / _config.block_size;
_config.lookahead = 32 * ((_config.block_count+31)/32);
if (_config.lookahead > lookahead) {
_config.lookahead = lookahead;
}
err = lfs_format(&_lfs, &_config);
if (err) {
LFS_INFO("format -> %d", lfs_toerror(err));
return lfs_toerror(err);
}
err = bd->deinit();
if (err) {
LFS_INFO("format -> %d", err);
return err;
}
LFS_INFO("format -> %d", 0);
return 0;
}
ssize_t LittleFileSystem::dir_read(fs_dir_t dir, struct dirent *ent)
{
lfs_dir_t *d = (lfs_dir_t *)dir;
struct lfs_info info;
_mutex.lock();
LFS_INFO("dir_read(%p, %p)", dir, ent);
int res = lfs_dir_read(&_lfs, d, &info);
LFS_INFO("dir_read -> %d", lfs_toerror(res));
_mutex.unlock();
if (res == 1) {
ent->d_type = lfs_totype(info.type);
strcpy(ent->d_name, info.name);
}
return lfs_toerror(res);
}
////// Dir operations //////
int LittleFileSystem::dir_open(fs_dir_t *dir, const char *path)
{
lfs_dir_t *d = new lfs_dir_t;
_mutex.lock();
LFS_INFO("dir_open(%p, \"%s\")", *dir, path);
int err = lfs_dir_open(&_lfs, d, path);
LFS_INFO("dir_open -> %d", lfs_toerror(err));
_mutex.unlock();
if (!err) {
*dir = d;
} else {
delete d;
}
return lfs_toerror(err);
}
////// File operations //////
int LittleFileSystem::file_open(fs_file_t *file, const char *path, int flags)
{
lfs_file_t *f = new lfs_file_t;
_mutex.lock();
LFS_INFO("file_open(%p, \"%s\", 0x%x)", *file, path, flags);
int err = lfs_file_open(&_lfs, f, path, lfs_fromflags(flags));
LFS_INFO("file_open -> %d", lfs_toerror(err));
_mutex.unlock();
if (!err) {
*file = f;
} else {
delete f;
}
return lfs_toerror(err);
}
int LittleFileSystem::mount(BlockDevice *bd)
{
_mutex.lock();
LFS_INFO("mount(%p)", bd);
_bd = bd;
int err = _bd->init();
if (err) {
LFS_INFO("mount -> %d", err);
_mutex.unlock();
return err;
}
memset(&_config, 0, sizeof(_config));
_config.context = bd;
_config.read = lfs_bd_read;
_config.prog = lfs_bd_prog;
_config.erase = lfs_bd_erase;
_config.sync = lfs_bd_sync;
_config.read_size = bd->get_read_size();
if (_config.read_size < _read_size) {
_config.read_size = _read_size;
}
_config.prog_size = bd->get_program_size();
if (_config.prog_size < _prog_size) {
_config.prog_size = _prog_size;
}
_config.block_size = bd->get_erase_size();
if (_config.block_size < _block_size) {
_config.block_size = _block_size;
}
_config.block_count = bd->size() / _config.block_size;
_config.lookahead = 32 * ((_config.block_count+31)/32);
if (_config.lookahead > _lookahead) {
_config.lookahead = _lookahead;
}
err = lfs_mount(&_lfs, &_config);
LFS_INFO("mount -> %d", lfs_toerror(err));
_mutex.unlock();
return lfs_toerror(err);
}
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;
}
int LittleFileSystem::reformat(BlockDevice *bd)
{
_mutex.lock();
LFS_INFO("reformat(%p)", bd);
if (_bd) {
if (!bd) {
bd = _bd;
}
int err = unmount();
if (err) {
LFS_INFO("reformat -> %d", err);
_mutex.unlock();
return err;
}
}
if (!bd) {
LFS_INFO("reformat -> %d", -ENODEV);
_mutex.unlock();
return -ENODEV;
}
int err = LittleFileSystem::format(bd,
_read_size, _prog_size, _block_size, _lookahead);
if (err) {
LFS_INFO("reformat -> %d", err);
_mutex.unlock();
return err;
}
err = mount(bd);
if (err) {
LFS_INFO("reformat -> %d", err);
_mutex.unlock();
return err;
}
LFS_INFO("reformat -> %d", 0);
_mutex.unlock();
return 0;
}
