sergiotarxz/nuttx
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
af5e479fb5
nuttx/fs/littlefs/lfs_vfs.c

1240 lines
32 KiB
C
Raw Blame History

/****************************************************************************
* fs/littlefs/lfs_vfs.c
*
* This file is a part of NuttX:
*
* Copyright (C) 2019 Gregory Nutt. All rights reserved.
*
* Ported by:
*
* Copyright (C) 2019 Pinecone Inc. All rights reserved.
* Author: lihaichen <li8303@163.com>
*
* This port derives from ARM mbed logic which has a compatible 3-clause
* BSD license:
*
* Copyright (c) 2017, Arm Limited. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* 3. Neither the names ARM, NuttX nor the names of its contributors may be
* used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
****************************************************************************/
/****************************************************************************
* Included Files
****************************************************************************/
#include <nuttx/config.h>
#include <errno.h>
#include <fcntl.h>
#include <string.h>
#include <nuttx/fs/dirent.h>
#include <nuttx/fs/fs.h>
#include <nuttx/mtd/mtd.h>
#include <nuttx/semaphore.h>
#include <sys/stat.h>
#include <sys/statfs.h>
#include "lfs.h"
/****************************************************************************
* Private Types
****************************************************************************/
/* This structure represents the overall mountpoint state. An instance of this
* structure is retained as inode private data on each mountpoint that is
* mounted with a littlefs filesystem.
*/
struct littlefs_mountpt_s
{
sem_t sem;
FAR struct inode *drv;
struct mtd_geometry_s geo;
struct lfs_config cfg;
lfs_t lfs;
};
/****************************************************************************
* Private Function Prototypes
****************************************************************************/
static void littlefs_semgive(FAR struct littlefs_mountpt_s *fs);
static void littlefs_semtake(FAR struct littlefs_mountpt_s *fs);
static int littlefs_open(FAR struct file *filep, FAR const char *relpath,
int oflags, mode_t mode);
static int littlefs_close(FAR struct file *filep);
static ssize_t littlefs_read(FAR struct file *filep, FAR char *buffer,
size_t buflen);
static ssize_t littlefs_write(FAR struct file *filep, FAR const char *buffer,
size_t buflen);
static off_t littlefs_seek(FAR struct file *filep, off_t offset,
int whence);
static int littlefs_ioctl(FAR struct file *filep, int cmd,
unsigned long arg);
static int littlefs_sync(FAR struct file *filep);
static int littlefs_dup(FAR const struct file *oldp,
FAR struct file *newp);
static int littlefs_fstat(FAR const struct file *filep,
FAR struct stat *buf);
static int littlefs_truncate(FAR struct file *filep,
off_t length);
static int littlefs_opendir(FAR struct inode *mountpt,
FAR const char *relpath,
FAR struct fs_dirent_s *dir);
static int littlefs_closedir(FAR struct inode *mountpt,
FAR struct fs_dirent_s *dir);
static int littlefs_readdir(FAR struct inode *mountpt,
FAR struct fs_dirent_s *dir);
static int littlefs_rewinddir(FAR struct inode *mountpt,
FAR struct fs_dirent_s *dir);
static int littlefs_bind(FAR struct inode *driver,
FAR const void *data, FAR void **handle);
static int littlefs_unbind(FAR void *handle, FAR struct inode **driver,
unsigned int flags);
static int littlefs_statfs(FAR struct inode *mountpt,
FAR struct statfs *buf);
static int littlefs_unlink(FAR struct inode *mountpt,
FAR const char *relpath);
static int littlefs_mkdir(FAR struct inode *mountpt,
FAR const char *relpath, mode_t mode);
static int littlefs_rmdir(FAR struct inode *mountpt,
FAR const char *relpath);
static int littlefs_rename(FAR struct inode *mountpt,
FAR const char *oldrelpath,
FAR const char *newrelpath);
static int littlefs_stat(FAR struct inode *mountpt,
FAR const char *relpath, FAR struct stat *buf);
/****************************************************************************
* Public Data
****************************************************************************/
/* See fs_mount.c -- this structure is explicitly extern'ed there.
* We use the old-fashioned kind of initializers so that this will compile
* with any compiler.
*/
const struct mountpt_operations littlefs_operations =
{
littlefs_open, /* open */
littlefs_close, /* close */
littlefs_read, /* read */
littlefs_write, /* write */
littlefs_seek, /* seek */
littlefs_ioctl, /* ioctl */
littlefs_sync, /* sync */
littlefs_dup, /* dup */
littlefs_fstat, /* fstat */
littlefs_truncate, /* truncate */
littlefs_opendir, /* opendir */
littlefs_closedir, /* closedir */
littlefs_readdir, /* readdir */
littlefs_rewinddir, /* rewinddir */
littlefs_bind, /* bind */
littlefs_unbind, /* unbind */
littlefs_statfs, /* statfs */
littlefs_unlink, /* unlink */
littlefs_mkdir, /* mkdir */
littlefs_rmdir, /* rmdir */
littlefs_rename, /* rename */
littlefs_stat /* stat */
};
/****************************************************************************
* Private Functions
****************************************************************************/
/****************************************************************************
* Name: littlefs_semtake
****************************************************************************/
static void littlefs_semtake(FAR struct littlefs_mountpt_s *fs)
{
int ret;
do
{
/* Take the semaphore (perhaps waiting) */
ret = nxsem_wait(&fs->sem);
/* The only case that an error should occur here is if the wait was
* awakened by a signal.
*/
DEBUGASSERT(ret == OK || ret == -EINTR);
}
while (ret == -EINTR);
}
/****************************************************************************
* Name: littlefs_semgive
****************************************************************************/
static void littlefs_semgive(FAR struct littlefs_mountpt_s *fs)
{
nxsem_post(&fs->sem);
}
/****************************************************************************
* Name: littlefs_convert_oflags
****************************************************************************/
static int littlefs_convert_oflags(int oflags)
{
int ret = 0;
if ((oflags & O_RDONLY) != 0)
{
ret |= LFS_O_RDONLY;
}
if ((oflags & O_WRONLY) != 0)
{
ret |= LFS_O_WRONLY;
}
if ((oflags & O_CREAT) != 0)
{
ret |= LFS_O_CREAT;
}
if ((oflags & O_EXCL) != 0)
{
ret |= LFS_O_EXCL;
}
if ((oflags & O_APPEND) != 0)
{
ret |= LFS_O_APPEND;
}
if ((oflags & O_TRUNC) != 0)
{
ret |= LFS_O_TRUNC;
}
return ret;
}
/****************************************************************************
* Name: littlefs_open
****************************************************************************/
static int littlefs_open(FAR struct file *filep, FAR const char *relpath,
int oflags, mode_t mode)
{
FAR struct littlefs_mountpt_s *fs;
FAR struct lfs_file *priv;
FAR struct inode *inode;
int ret;
/* Get the mountpoint inode reference from the file structure and the
* mountpoint private data from the inode structure
*/
inode = filep->f_inode;
fs = inode->i_private;
/* Allocate memory for the open file */
priv = kmm_malloc(sizeof(*priv));
if (priv == NULL)
{
return -ENOMEM;
}
/* Take the semaphore */
littlefs_semtake(fs);
/* Try to open the file */
oflags = littlefs_convert_oflags(oflags);
ret = lfs_file_open(&fs->lfs, priv, relpath, oflags);
if (ret < 0)
{
/* Error opening file */
goto errout;
}
/* In append mode, we need to set the file pointer to the end of the
* file.
*/
if (oflags & LFS_O_APPEND)
{
ret = lfs_file_seek(&fs->lfs, priv, 0, LFS_SEEK_END);
if (ret >= 0)
{
filep->f_pos = ret;
}
else
{
goto errout_with_file;
}
}
littlefs_semgive(fs);
/* Attach the private date to the struct file instance */
filep->f_priv = priv;
return OK;
errout_with_file:
lfs_file_close(&fs->lfs, priv);
errout:
littlefs_semgive(fs);
kmm_free(priv);
return ret;
}
/****************************************************************************
* Name: littlefs_close
****************************************************************************/
static int littlefs_close(FAR struct file *filep)
{
FAR struct littlefs_mountpt_s *fs;
FAR struct lfs_file *priv;
FAR struct inode *inode;
/* Recover our private data from the struct file instance */
priv = filep->f_priv;
inode = filep->f_inode;
fs = inode->i_private;
/* Close the file */
littlefs_semtake(fs);
lfs_file_close(&fs->lfs, priv);
littlefs_semgive(fs);
/* Now free the pointer */
kmm_free(priv);
return OK;
}
/****************************************************************************
* Name: littlefs_read
****************************************************************************/
static ssize_t littlefs_read(FAR struct file *filep, FAR char *buffer,
size_t buflen)
{
FAR struct littlefs_mountpt_s *fs;
FAR struct lfs_file *priv;
FAR struct inode *inode;
ssize_t ret;
/* Recover our private data from the struct file instance */
priv = filep->f_priv;
inode = filep->f_inode;
fs = inode->i_private;
/* Call LFS to perform the read */
littlefs_semtake(fs);
ret = lfs_file_read(&fs->lfs, priv, buffer, buflen);
if (ret > 0)
{
filep->f_pos += ret;
}
littlefs_semgive(fs);
return ret;
}
/****************************************************************************
* Name: littlefs_write
****************************************************************************/
static ssize_t littlefs_write(FAR struct file *filep, const char *buffer,
size_t buflen)
{
FAR struct littlefs_mountpt_s *fs;
FAR struct lfs_file *priv;
FAR struct inode *inode;
ssize_t ret;
/* Recover our private data from the struct file instance */
priv = filep->f_priv;
inode = filep->f_inode;
fs = inode->i_private;
/* Call LFS to perform the write */
littlefs_semtake(fs);
ret = lfs_file_write(&fs->lfs, priv, buffer, buflen);
if (ret > 0)
{
filep->f_pos += ret;
}
littlefs_semgive(fs);
return ret;
}
/****************************************************************************
* Name: littlefs_seek
****************************************************************************/
static off_t littlefs_seek(FAR struct file *filep, off_t offset, int whence)
{
FAR struct littlefs_mountpt_s *fs;
FAR struct lfs_file *priv;
FAR struct inode *inode;
off_t ret;
/* Recover our private data from the struct file instance */
priv = filep->f_priv;
inode = filep->f_inode;
fs = inode->i_private;
/* Call LFS to perform the seek */
littlefs_semtake(fs);
ret = lfs_file_seek(&fs->lfs, priv, offset, whence);
if (ret >= 0)
{
filep->f_pos = ret;
}
littlefs_semgive(fs);
return ret;
}
/****************************************************************************
* Name: littlefs_ioctl
****************************************************************************/
static int littlefs_ioctl(FAR struct file *filep, int cmd, unsigned long arg)
{
FAR struct littlefs_mountpt_s *fs;
FAR struct inode *inode;
FAR struct inode *drv;
/* Recover our private data from the struct file instance */
inode = filep->f_inode;
fs = inode->i_private;
drv = fs->drv;
if (INODE_IS_MTD(drv))
{
return MTD_IOCTL(drv->u.i_mtd, cmd, arg);
}
else
{
return drv->u.i_bops->ioctl(drv, cmd, arg);
}
}
/****************************************************************************
* Name: littlefs_sync
*
* Description: Synchronize the file state on disk to match internal, in-
* memory state.
*
****************************************************************************/
static int littlefs_sync(FAR struct file *filep)
{
FAR struct littlefs_mountpt_s *fs;
FAR struct lfs_file *priv;
FAR struct inode *inode;
int ret;
/* Recover our private data from the struct file instance */
priv = filep->f_priv;
inode = filep->f_inode;
fs = inode->i_private;
littlefs_semtake(fs);
ret = lfs_file_sync(&fs->lfs, priv);
littlefs_semgive(fs);
return ret;
}
/****************************************************************************
* Name: littlefs_dup
*
* Description: Duplicate open file data in the new file structure.
*
****************************************************************************/
static int littlefs_dup(FAR const struct file *oldp, FAR struct file *newp)
{
return -ENOSYS;
}
/****************************************************************************
* Name: littlefs_fstat
*
* Description:
* Obtain information about an open file associated with the file
* descriptor 'fd', and will write it to the area pointed to by 'buf'.
*
****************************************************************************/
static int littlefs_fstat(FAR const struct file *filep, FAR struct stat *buf)
{
FAR struct littlefs_mountpt_s *fs;
FAR struct lfs_file *priv;
FAR struct inode *inode;
memset(buf, 0, sizeof(*buf));
/* Recover our private data from the struct file instance */
priv = filep->f_priv;
inode = filep->f_inode;
fs = inode->i_private;
/* Call LFS to get file size */
littlefs_semtake(fs);
buf->st_size = lfs_file_size(&fs->lfs, priv);
littlefs_semgive(fs);
if (buf->st_size < 0)
{
return buf->st_size;
}
buf->st_mode = S_IRWXO | S_IRWXG | S_IRWXU | S_IFREG;
buf->st_blksize = fs->cfg.block_size;
buf->st_blocks = (buf->st_size + buf->st_blksize - 1) / buf->st_blksize;
return OK;
}
/****************************************************************************
* Name: littlefs_truncate
*
* Description:
* Set the length of the open, regular file associated with the file
* structure 'filep' to 'length'.
*
****************************************************************************/
static int littlefs_truncate(FAR struct file *filep, off_t length)
{
FAR struct littlefs_mountpt_s *fs;
FAR struct lfs_file *priv;
FAR struct inode *inode;
int ret;
/* Recover our private data from the struct file instance */
priv = filep->f_priv;
inode = filep->f_inode;
fs = inode->i_private;
/* Call LFS to perform the truncate */
littlefs_semtake(fs);
ret = lfs_file_truncate(&fs->lfs, priv, length);
littlefs_semgive(fs);
return ret;
}
/****************************************************************************
* Name: littlefs_opendir
*
* Description: Open a directory for read access
*
****************************************************************************/
static int littlefs_opendir(FAR struct inode *mountpt,
FAR const char *relpath,
FAR struct fs_dirent_s *dir)
{
FAR struct littlefs_mountpt_s *fs;
FAR struct lfs_dir *priv;
int ret;
/* Recover our private data from the inode instance */
fs = mountpt->i_private;
/* Allocate memory for the open directory */
priv = kmm_malloc(sizeof(*priv));
if (priv == NULL)
{
return -ENOMEM;
}
/* Take the semaphore */
littlefs_semtake(fs);
/* Call the LFS's opendir function */
ret = lfs_dir_open(&fs->lfs, priv, relpath);
if (ret < 0)
{
goto errout;
}
dir->fd_position = lfs_dir_tell(&fs->lfs, priv);
littlefs_semgive(fs);
dir->u.littlefs = priv;
return OK;
errout:
littlefs_semgive(fs);
kmm_free(priv);
return ret;
}
/****************************************************************************
* Name: littlefs_closedir
*
* Description: Close a directory
*
****************************************************************************/
static int littlefs_closedir(FAR struct inode *mountpt,
FAR struct fs_dirent_s *dir)
{
struct littlefs_mountpt_s *fs;
FAR struct lfs_dir *priv;
/* Recover our private data from the inode instance */
priv = dir->u.littlefs;
fs = mountpt->i_private;
/* Call the LFS's closedir function */
littlefs_semtake(fs);
lfs_dir_close(&fs->lfs, priv);
littlefs_semgive(fs);
kmm_free(priv);
return OK;
}
/****************************************************************************
* Name: littlefs_readdir
*
* Description: Read the next directory entry
*
****************************************************************************/
static int littlefs_readdir(FAR struct inode *mountpt,
FAR struct fs_dirent_s *dir)
{
FAR struct littlefs_mountpt_s *fs;
FAR struct lfs_dir *priv;
struct lfs_info info;
int ret;
/* Recover our private data from the inode instance */
priv = dir->u.littlefs;
fs = mountpt->i_private;
/* Call the LFS's readdir function */
littlefs_semtake(fs);
ret = lfs_dir_read(&fs->lfs, priv, &info);
if (ret > 0)
{
dir->fd_position = lfs_dir_tell(&fs->lfs, priv);
if (info.type == LFS_TYPE_REG)
{
dir->fd_dir.d_type = DTYPE_FILE;
}
else
{
dir->fd_dir.d_type = DTYPE_DIRECTORY;
}
strcpy(dir->fd_dir.d_name, info.name);
}
else if (ret == 0)
{
ret = -ENOENT;
}
littlefs_semgive(fs);
return ret;
}
/****************************************************************************
* Name: littlefs_rewindir
*
* Description: Reset directory read to the first entry
*
****************************************************************************/
static int littlefs_rewinddir(FAR struct inode *mountpt,
FAR struct fs_dirent_s *dir)
{
struct littlefs_mountpt_s *fs;
FAR struct lfs_dir *priv;
int ret;
/* Recover our private data from the inode instance */
priv = dir->u.littlefs;
fs = mountpt->i_private;
/* Call the LFS's rewinddir function */
littlefs_semtake(fs);
ret = lfs_dir_rewind(&fs->lfs, priv);
if (ret >= 0)
{
dir->fd_position = lfs_dir_tell(&fs->lfs, priv);
}
littlefs_semgive(fs);
return ret;
}
/****************************************************************************
* Name: littlefs_bind
*
* Description: This implements a portion of the mount operation. This
* function allocates and initializes the mountpoint private data and
* binds the driver inode to the filesystem private data. The final
* binding of the private data (containing the driver) to the
* mountpoint is performed by mount().
*
****************************************************************************/
static int littlefs_read_block(const struct lfs_config *c, lfs_block_t block,
lfs_off_t off, void *buffer, lfs_size_t size)
{
FAR struct littlefs_mountpt_s *fs = c->context;
FAR struct mtd_geometry_s *geo = &fs->geo;
FAR struct inode *drv = fs->drv;
int ret;
block = (block * c->block_size + off) / geo->blocksize;
size = size / geo->blocksize;
if (INODE_IS_MTD(drv))
{
ret = MTD_BREAD(drv->u.i_mtd, block, size, buffer);
}
else
{
ret = drv->u.i_bops->read(drv, buffer, block, size);
}
return ret >= 0 ? OK : ret;
}
/****************************************************************************
* Name: littlefs_write_block
****************************************************************************/
static int littlefs_write_block(const struct lfs_config *c, lfs_block_t block,
lfs_off_t off, const void *buffer,
lfs_size_t size)
{
FAR struct littlefs_mountpt_s *fs = c->context;
FAR struct mtd_geometry_s *geo = &fs->geo;
FAR struct inode *drv = fs->drv;
int ret;
block = (block * c->block_size + off) / geo->blocksize;
size = size / geo->blocksize;
if (INODE_IS_MTD(drv))
{
ret = MTD_BWRITE(drv->u.i_mtd, block, size, buffer);
}
else
{
ret = drv->u.i_bops->write(drv, buffer, block, size);
}
return ret >= 0 ? OK : ret;
}
/****************************************************************************
* Name: littlefs_erase_block
****************************************************************************/
static int littlefs_erase_block(const struct lfs_config *c, lfs_block_t block)
{
FAR struct littlefs_mountpt_s *fs = c->context;
FAR struct inode *drv = fs->drv;
int ret = OK;
if (INODE_IS_MTD(drv))
{
FAR struct mtd_geometry_s *geo = &fs->geo;
size_t size = c->block_size / geo->erasesize;
block = block * c->block_size / geo->erasesize;
ret = MTD_ERASE(drv->u.i_mtd, block, size);
}
return ret >= 0 ? OK : ret;
}
/****************************************************************************
* Name: littlefs_sync_block
****************************************************************************/
static int littlefs_sync_block(const struct lfs_config *c)
{
FAR struct littlefs_mountpt_s *fs = c->context;
FAR struct inode *drv = fs->drv;
int ret;
if (INODE_IS_MTD(drv))
{
ret = MTD_IOCTL(drv->u.i_mtd, BIOC_FLUSH, 0);
}
else
{
ret = drv->u.i_bops->ioctl(drv, BIOC_FLUSH, 0);
}
return ret == -ENOTTY ? OK : ret;
}
/****************************************************************************
* Name: littlefs_bind
****************************************************************************/
static int littlefs_bind(FAR struct inode *driver, FAR const void *data,
FAR void **handle)
{
FAR struct littlefs_mountpt_s *fs;
int ret;
/* Open the block driver */
if (INODE_IS_BLOCK(driver) && driver->u.i_bops->open)
{
ret = driver->u.i_bops->open(driver);
if (ret < 0)
{
return ret;
}
}
/* Create an instance of the mountpt state structure */
fs = kmm_zalloc(sizeof(*fs));
if (!fs)
{
ret = -ENOMEM;
goto errout_with_block;
}
/* Initialize the allocated mountpt state structure. The filesystem is
* responsible for one reference on the driver inode and does not
* have to addref() here (but does have to release in unbind().
*/
fs->drv = driver; /* Save the driver reference */
nxsem_init(&fs->sem, 0, 0); /* Initialize the access control semaphore */
if (INODE_IS_MTD(driver))
{
/* Get MTD geometry directly */
ret = MTD_IOCTL(driver->u.i_mtd, MTDIOC_GEOMETRY,
(unsigned long)&fs->geo);
}
else
{
/* Try to get FLT MTD geometry first */
ret = driver->u.i_bops->ioctl(driver, MTDIOC_GEOMETRY,
(unsigned long)&fs->geo);
if (ret < 0)
{
struct geometry geometry;
/* Not FLT MTD device, get normal block geometry */
ret = driver->u.i_bops->geometry(driver, &geometry);
if (ret >= 0)
{
/* And convert to MTD geometry */
fs->geo.blocksize = geometry.geo_sectorsize;
fs->geo.erasesize = geometry.geo_sectorsize;
fs->geo.neraseblocks = geometry.geo_nsectors;
}
}
}
if (ret < 0)
{
goto errout_with_fs;
}
/* Initialize lfs_config structure */
fs->cfg.context = fs;
fs->cfg.read = littlefs_read_block;
fs->cfg.prog = littlefs_write_block;
fs->cfg.erase = littlefs_erase_block;
fs->cfg.sync = littlefs_sync_block;
fs->cfg.read_size = fs->geo.blocksize;
fs->cfg.prog_size = fs->geo.blocksize;
fs->cfg.block_size = fs->geo.erasesize;
fs->cfg.block_count = fs->geo.neraseblocks;
fs->cfg.lookahead = 4 * ((fs->cfg.block_count + 31) / 32);
if (fs->cfg.lookahead > fs->cfg.read_size)
{
fs->cfg.lookahead = fs->cfg.read_size;
}
/* Then get information about the littlefs filesystem on the devices
* managed by this driver.
*/
/* Force format the device if -o forceformat */
if (data && strcmp(data, "forceformat") == 0)
{
ret = lfs_format(&fs->lfs, &fs->cfg);
if (ret < 0)
{
goto errout_with_fs;
}
}
ret = lfs_mount(&fs->lfs, &fs->cfg);
if (ret < 0)
{
/* Auto format the device if -o autoformat */
if (ret != LFS_ERR_CORRUPT ||
!data || strcmp(data, "autoformat"))
{
goto errout_with_fs;
}
ret = lfs_format(&fs->lfs, &fs->cfg);
if (ret < 0)
{
goto errout_with_fs;
}
/* Try to mount the device again */
ret = lfs_mount(&fs->lfs, &fs->cfg);
if (ret < 0)
{
goto errout_with_fs;
}
}
*handle = fs;
littlefs_semgive(fs);
return OK;
errout_with_fs:
nxsem_destroy(&fs->sem);
kmm_free(fs);
errout_with_block:
if (INODE_IS_BLOCK(driver) && driver->u.i_bops->close)
{
driver->u.i_bops->close(driver);
}
return ret;
}
/****************************************************************************
* Name: littlefs_unbind
*
* Description: This implements the filesystem portion of the umount
* operation.
*
****************************************************************************/
static int littlefs_unbind(FAR void *handle, FAR struct inode **driver,
unsigned int flags)
{
FAR struct littlefs_mountpt_s *fs = handle;
FAR struct inode *drv = fs->drv;
int ret;
/* Unmount */
littlefs_semtake(fs);
ret = lfs_unmount(&fs->lfs);
littlefs_semgive(fs);
if (ret >= 0)
{
/* Close the block driver */
if (INODE_IS_BLOCK(drv) && drv->u.i_bops->close)
{
drv->u.i_bops->close(drv);
}
/* We hold a reference to the driver but should not but
* mucking with inodes in this context. So, we will just return
* our contained reference to the driver inode and let the
* umount logic dispose of it.
*/
if (driver)
{
*driver = drv;
}
/* Release the mountpoint private data */
nxsem_destroy(&fs->sem);
kmm_free(fs);
}
return ret;
}
/****************************************************************************
* Name: littlefs_used_block
****************************************************************************/
static int littlefs_used_block(void *arg, lfs_block_t block)
{
FAR struct statfs *buf = arg;
buf->f_bfree--;
buf->f_bavail--;
return 0;
}
/****************************************************************************
* Name: littlefs_statfs
*
* Description: Return filesystem statistics
*
****************************************************************************/
static int littlefs_statfs(FAR struct inode *mountpt, FAR struct statfs *buf)
{
FAR struct littlefs_mountpt_s *fs;
int ret;
/* Get the mountpoint private data from the inode structure */
fs = mountpt->i_private;
/* Return something for the file system description */
memset(buf, 0, sizeof(*buf));
buf->f_type = LITTLEFS_MAGIC;
buf->f_namelen = LFS_NAME_MAX;
buf->f_bsize = fs->cfg.block_size;
buf->f_blocks = fs->cfg.block_count;
buf->f_bfree = fs->cfg.block_count;
buf->f_bavail = fs->cfg.block_count;
littlefs_semtake(fs);
ret = lfs_traverse(&fs->lfs, littlefs_used_block, buf);
littlefs_semgive(fs);
return ret;
}
/****************************************************************************
* Name: littlefs_unlink
*
* Description: Remove a file
*
****************************************************************************/
static int littlefs_unlink(FAR struct inode *mountpt,
FAR const char *relpath)
{
FAR struct littlefs_mountpt_s *fs;
int ret;
/* Get the mountpoint private data from the inode structure */
fs = mountpt->i_private;
/* Call the LFS to perform the unlink */
littlefs_semtake(fs);
ret = lfs_remove(&fs->lfs, relpath);
littlefs_semgive(fs);
return ret;
}
/****************************************************************************
* Name: littlefs_mkdir
*
* Description: Create a directory
*
****************************************************************************/
static int littlefs_mkdir(FAR struct inode *mountpt, FAR const char *relpath,
mode_t mode)
{
FAR struct littlefs_mountpt_s *fs;
int ret;
/* Get the mountpoint private data from the inode structure */
fs = mountpt->i_private;
/* Call LFS to do the mkdir */
littlefs_semtake(fs);
ret = lfs_mkdir(&fs->lfs, relpath);
littlefs_semgive(fs);
return ret;
}
/****************************************************************************
* Name: littlefs_rmdir
*
* Description: Remove a directory
*
****************************************************************************/
static int littlefs_rmdir(FAR struct inode *mountpt, FAR const char *relpath)
{
return littlefs_unlink(mountpt, relpath);
}
/****************************************************************************
* Name: littlefs_rename
*
* Description: Rename a file or directory
*
****************************************************************************/
static int littlefs_rename(FAR struct inode *mountpt,
FAR const char *oldrelpath,
FAR const char *newrelpath)
{
FAR struct littlefs_mountpt_s *fs;
int ret;
/* Get the mountpoint private data from the inode structure */
fs = mountpt->i_private;
/* Call LFS to do the rename */
littlefs_semtake(fs);
ret = lfs_rename(&fs->lfs, oldrelpath, newrelpath);
littlefs_semgive(fs);
return ret;
}
/****************************************************************************
* Name: littlefs_stat
*
* Description: Return information about a file or directory
*
****************************************************************************/
static int littlefs_stat(FAR struct inode *mountpt, FAR const char *relpath,
FAR struct stat *buf)
{
FAR struct littlefs_mountpt_s *fs;
struct lfs_info info;
int ret;
memset(buf, 0, sizeof(*buf));
/* Get the mountpoint private data from the inode structure */
fs = mountpt->i_private;
/* Call the LFS to do the stat operation */
littlefs_semtake(fs);
ret = lfs_stat(&fs->lfs, relpath, &info);
littlefs_semgive(fs);
if (ret >= 0)
{
/* Convert info to stat */
buf->st_mode = S_IRWXO | S_IRWXG | S_IRWXU;
if (info.type == LFS_TYPE_REG)
{
buf->st_mode |= S_IFREG;
}
else
{
buf->st_mode |= S_IFDIR;
}
buf->st_size = info.size;
buf->st_blksize = fs->cfg.block_size;
buf->st_blocks = (buf->st_size + buf->st_blksize - 1) /
buf->st_blksize;
}
return ret;
}
Reference in New Issue View Git Blame Copy Permalink