nuttx/nuttx-update
1
2
Fork 1
Code Issues 1 Pull requests 1 Projects Releases Packages Wiki Activity Actions

fs/littlefs: revert fstat and use lfs_file_attr function

Browse source 
Signed-off-by: zhouliang3 <zhouliang3@xiaomi.com>
This commit is contained in:
zhouliang3 2021-09-09 20:48:04 +08:00 committed by GUIDINGLI
parent c5779297cf
commit 8f6ea8896f
4 changed files with 177 additions and 29 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
fs/littlefs/CMakeLists.txt
View file

@ -31,8 +31,10 @@ if(CONFIG_FS_LITTLEFS)
${CMAKE_BINARY_DIR}/fs/littlefs/littlefs
PATCH_COMMAND
patch -p2 -d ${CMAKE_CURRENT_LIST_DIR} <
${CMAKE_CURRENT_LIST_DIR}/lfs_util.patch COMMAND patch -p2 -d
${CMAKE_CURRENT_LIST_DIR} < ${CMAKE_CURRENT_LIST_DIR}/lfs_getpath.patch)
${CMAKE_CURRENT_LIST_DIR}/lfs_util.patch && patch -p2 -d
${CMAKE_CURRENT_LIST_DIR} < ${CMAKE_CURRENT_LIST_DIR}/lfs_getpath.patch
&& patch -p2 -d ${CMAKE_CURRENT_LIST_DIR} <
${CMAKE_CURRENT_LIST_DIR}/lfs_getsetattr.patch)
FetchContent_MakeAvailable(littlefs)
endif()

1
fs/littlefs/Make.defs
View file

@ -56,6 +56,7 @@ $(LITTLEFS_TARBALL):
$(Q) mv littlefs/littlefs-$(LITTLEFS_VERSION) littlefs/littlefs
$(Q) git apply littlefs/lfs_util.patch
$(Q) git apply littlefs/lfs_getpath.patch
$(Q) git apply littlefs/lfs_getsetattr.patch
$(Q) touch littlefs/.littlefsunpack
# Download and unpack tarball if no git repo found

80
fs/littlefs/lfs_getsetattr.patch Normal file
View file

@ -0,0 +1,80 @@
--- ./littlefs/littlefs/lfs.c
+++ ./littlefs/littlefs/lfs.c
@@ -5717,6 +5717,41 @@ int lfs_file_path(lfs_t *lfs, lfs_file_t *file, char *path, lfs_size_t size) {
return err < 0 ? err : 0;
}
+lfs_ssize_t lfs_file_getattr(lfs_t *lfs, lfs_file_t *file,
+ uint8_t type, void *buffer, lfs_size_t size)
+{
+ int err = LFS_LOCK(lfs->cfg);
+ if (err) {
+ return err;
+ }
+ LFS_TRACE("lfs_file_setattr(%p, %p)", (void*)lfs, (void*)file);
+ LFS_TRACE("lfs_file_setattr(%"PRIu8", %p, %"PRIu32")",
+ type, buffer, size);
+ LFS_ASSERT(lfs_mlist_isopen(lfs->mlist, (struct lfs_mlist*)file));
+
+ return lfs_dir_get(lfs, &file->m, LFS_MKTAG(0x7ff, 0x3ff, 0),
+ LFS_MKTAG(LFS_TYPE_USERATTR + type,
+ file->id, lfs_min(size, lfs->attr_max)), buffer);
+}
+
+#ifndef LFS_READONLY
+int lfs_file_setattr(lfs_t *lfs, lfs_file_t *file,
+ uint8_t type, const void *buffer, lfs_size_t size)
+{
+ int err = LFS_LOCK(lfs->cfg);
+ if (err) {
+ return err;
+ }
+ LFS_TRACE("lfs_file_getattr(%p, %p)", (void*)lfs, (void*)file);
+ LFS_TRACE("lfs_file_getattr(%"PRIu8", %p, %"PRIu32")",
+ type, buffer, size);
+ LFS_ASSERT(lfs_mlist_isopen(lfs->mlist, (struct lfs_mlist*)file));
+
+ return lfs_dir_commit(lfs, &file->m, LFS_MKATTRS(
+ {LFS_MKTAG(LFS_TYPE_USERATTR + type, file->id, size), buffer}));
+}
+#endif
+
#ifndef LFS_READONLY
int lfs_mkdir(lfs_t *lfs, const char *path) {
int err = LFS_LOCK(lfs->cfg);
--- ./littlefs/littlefs/lfs.h
+++ ./littlefs/littlefs/lfs.h
@@ -611,6 +611,33 @@ lfs_soff_t lfs_file_size(lfs_t *lfs, lfs_file_t *file);
// Returns a negative error code on failure.
int lfs_file_path(lfs_t *lfs, lfs_file_t *file, char *path, lfs_size_t size);
+// Get a custom attribute of file
+//
+// Custom attributes are uniquely identified by an 8-bit type and limited
+// to LFS_ATTR_MAX bytes. When read, if the stored attribute is smaller than
+// the buffer, it will be padded with zeros. If the stored attribute is larger,
+// then it will be silently truncated. If no attribute is found, the error
+// LFS_ERR_NOATTR is returned and the buffer is filled with zeros.
+//
+// Returns the size of the attribute, or a negative error code on failure.
+// Note, the returned size is the size of the attribute on disk, irrespective
+// of the size of the buffer. This can be used to dynamically allocate a buffer
+// or check for existance.
+lfs_ssize_t lfs_file_getattr(lfs_t *lfs, lfs_file_t *file,
+ uint8_t type, void *buffer, lfs_size_t size);
+
+// Set custom attributes of file
+//
+// Custom attributes are uniquely identified by an 8-bit type and limited
+// to LFS_ATTR_MAX bytes. If an attribute is not found, it will be
+// implicitly created.
+//
+// Returns a negative error code on failure.
+#ifndef LFS_READONLY
+int lfs_file_setattr(lfs_t *lfs, lfs_file_t *file,
+ uint8_t type, const void *buffer, lfs_size_t size);
+#endif
+
/// Directory operations ///
#ifndef LFS_READONLY

119
fs/littlefs/lfs_vfs.c
View file

@ -726,6 +726,7 @@ static int littlefs_fstat(FAR const struct file *filep, FAR struct stat *buf)
FAR struct littlefs_mountpt_s *fs;
FAR struct littlefs_file_s *priv;
FAR struct inode *inode;
struct littlefs_attr_s attr;
char path[LFS_NAME_MAX];
int ret;
@ -745,20 +746,43 @@ static int littlefs_fstat(FAR const struct file *filep, FAR struct stat *buf)
return ret;
}
ret = lfs_file_path(&fs->lfs, &priv->file, path, sizeof(path));
buf->st_size = lfs_file_size(&fs->lfs, &priv->file);
if (buf->st_size < 0)
{
ret = littlefs_convert_result(buf->st_size);
goto errout;
}
ret = littlefs_convert_result(lfs_file_getattr(&fs->lfs, &priv->file, 0,
&attr, sizeof(attr)));
if (ret < 0)
{
if (ret != -ENODATA)
{
goto errout;
}
memset(&attr, 0, sizeof(attr));
attr.at_mode = S_IRWXG | S_IRWXU | S_IRWXO;
}
ret = 0;
buf->st_mode = attr.at_mode | S_IFREG;
buf->st_uid = attr.at_uid;
buf->st_gid = attr.at_gid;
buf->st_atim.tv_sec = attr.at_atim / 1000000000ull;
buf->st_atim.tv_nsec = attr.at_atim % 1000000000ull;
buf->st_mtim.tv_sec = attr.at_mtim / 1000000000ull;
buf->st_mtim.tv_nsec = attr.at_mtim % 1000000000ull;
buf->st_ctim.tv_sec = attr.at_ctim / 1000000000ull;
buf->st_ctim.tv_nsec = attr.at_ctim % 1000000000ull;
buf->st_blksize = fs->cfg.block_size;
buf->st_blocks = (buf->st_size + buf->st_blksize - 1) /
buf->st_blksize;
errout:
nxmutex_unlock(&fs->lock);
if (ret < 0)
{
return ret;
}
ret = littlefs_stat(inode, path, buf);
if (ret < 0)
{
return ret;
}
return OK;
return ret;
}
static int littlefs_fchstat(FAR const struct file *filep,
@ -767,6 +791,7 @@ static int littlefs_fchstat(FAR const struct file *filep,
FAR struct littlefs_mountpt_s *fs;
FAR struct littlefs_file_s *priv;
FAR struct inode *inode;
struct littlefs_attr_s attr;
char path[LFS_NAME_MAX];
int ret;
@ -784,20 +809,59 @@ static int littlefs_fchstat(FAR const struct file *filep,
return ret;
}
ret = lfs_file_path(&fs->lfs, &priv->file, path, sizeof(path));
ret = littlefs_convert_result(lfs_file_getattr(&fs->lfs, &priv->file,
0, &attr, sizeof(attr)));
if (ret < 0)
{
if (ret != -ENODATA)
{
goto errout;
}
memset(&attr, 0, sizeof(attr));
attr.at_mode = S_IRWXG | S_IRWXU | S_IRWXO;
}
if ((CH_STAT_MODE & flags) == CH_STAT_MODE)
{
attr.at_mode = buf->st_mode;
}
if ((CH_STAT_UID & flags) == CH_STAT_UID)
{
attr.at_uid = buf->st_uid;
}
if ((CH_STAT_GID & flags) == CH_STAT_GID)
{
attr.at_gid = buf->st_gid;
}
attr.at_ctim = 1000000000ull * buf->st_ctim.tv_sec +
buf->st_ctim.tv_nsec;
if ((CH_STAT_ATIME & flags) == CH_STAT_ATIME)
{
attr.at_atim = 1000000000ull * buf->st_atim.tv_sec +
buf->st_atim.tv_nsec;
}
if ((CH_STAT_MTIME & flags) == CH_STAT_MTIME)
{
attr.at_mtim = 1000000000ull * buf->st_mtim.tv_sec +
buf->st_mtim.tv_nsec;
}
ret = littlefs_convert_result(lfs_file_setattr(&fs->lfs, &priv->file, 0,
&attr, sizeof(attr)));
if (ret < 0)
{
goto errout;
}
errout:
nxmutex_unlock(&fs->lock);
if (ret < 0)
{
return ret;
}
ret = littlefs_chstat(inode, path, buf, flags);
if (ret < 0)
{
return ret;
}
return OK;
return ret;
}
/****************************************************************************
@ -1587,7 +1651,6 @@ static int littlefs_stat(FAR struct inode *mountpt, FAR const char *relpath,
buf->st_mtim.tv_nsec = attr.at_mtim % 1000000000ull;
buf->st_ctim.tv_sec = attr.at_ctim / 1000000000ull;
buf->st_ctim.tv_nsec = attr.at_ctim % 1000000000ull;
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;
@ -1595,10 +1658,12 @@ static int littlefs_stat(FAR struct inode *mountpt, FAR const char *relpath,
if (info.type == LFS_TYPE_REG)
{
buf->st_mode |= S_IFREG;
buf->st_size = info.size;
}
else
{
buf->st_mode |= S_IFDIR;
buf->st_size = 0;
}
errout: