openharmony/third_party_NuttX
1
0
Fork 0
mirror of https://github.com/openharmony/third_party_NuttX.git synced 2026-07-01 08:17:34 -04:00
Code Issues Packages Projects Releases Wiki Activity

update openharmony 1.0.1

Browse Source
This commit is contained in:
mamingshuai
2021-03-11 18:44:56 +08:00
parent 97b2c97ee6
commit 54c75c3b6f
22 changed files with 596 additions and 207 deletions
Download Patch File Download Diff File Expand all files Collapse all files
.gitee/ISSUE_TEMPLATE.zh-CN.md
-13
View File
@@ -1,13 +0,0 @@
### 该问题是怎么引起的？
### 重现步骤
### 报错信息
.gitee/PULL_REQUEST_TEMPLATE.zh-CN.md
-15
View File
@@ -1,15 +0,0 @@
### 相关的Issue
### 原因（目的、解决的问题等）
### 描述（做了什么，变更了什么）
### 测试用例（新增、改动、可能影响的功能）
.gitignore
Executable → Regular
View File
README.OpenSource
Executable
+11
View File
@@ -0,0 +1,11 @@
[
{
"Name" : "NuttX",
"License" : "BSD 3-Clause License",
"License File" : "COPYING",
"Version Number" : "8.2",
"Owner" : "tonghaoyang1@huawei.com",
"Upstream URL" : "http://www.nuttx.org",
"Description" : "Apache NuttX is a mature, real-time embedded operating system (RTOS)."
}
]
drivers/pipes/pipe_common.c
+41 -21
View File
@@ -395,6 +395,7 @@ ssize_t pipecommon_read(FAR struct file *filep, FAR char *buffer, size_t len)
ssize_t nread = 0;
int sval;
int ret;
volatile int num;
if (dev == NULL)
{
@@ -472,24 +473,48 @@ ssize_t pipecommon_read(FAR struct file *filep, FAR char *buffer, size_t len)
nread++;
}
/* If O_NONBLOCK was set, then break */
if (filep->f_oflags & O_NONBLOCK)
{
break;
}
/* Is the read complete? */
/* Is the read complete? */
if ((size_t)nread >= len)
{
break;
}
/* wait for something to be written to the pipe */
/* Notify all waiting writers that bytes have been read from the buffer */
sem_post(&dev->d_wrsem);
num = 0;
while (sem_getvalue(&dev->d_wrsem, &sval) == 0 && sval == 0)
{
sem_post(&dev->d_wrsem);
num++;
}
/* If there are no writers be awakened, then return */
if (num == 0 || num == 1)
{
pipecommon_pollnotify(dev, POLLOUT);
sem_post(&dev->d_bfsem);
return nread;
}
/* If there are no writers on the pipe, then return the number of read bytes */
if (dev->d_nwriters <= 0)
{
sem_post(&dev->d_wrsem);
pipecommon_pollnotify(dev, POLLOUT);
sem_post(&dev->d_bfsem);
return nread;
}
/* wait for something to be written to the pipe */
pipecommon_pollnotify(dev, POLLOUT);
while (sem_getvalue(&dev->d_rdsem, &sval) == 0 && sval != 0)
{
sem_wait(&dev->d_rdsem);
}
sem_post(&dev->d_bfsem);
ret = sem_wait(&dev->d_rdsem);
@@ -503,16 +528,6 @@ ssize_t pipecommon_read(FAR struct file *filep, FAR char *buffer, size_t len)
{
return ret;
}
/* If there are no writers on the pipe, then return end of file */
if (dev->d_nwriters <= 0)
{
sem_post(&dev->d_wrsem);
pipecommon_pollnotify(dev, POLLOUT);
sem_post(&dev->d_bfsem);
return nread;
}
}
/* Notify all waiting writers that bytes have been removed from the buffer */
@@ -679,7 +694,12 @@ ssize_t pipecommon_write(FAR struct file *filep, FAR const char *buffer,
/* There is more to be written.. wait for data to be removed from the pipe */
while (sem_getvalue(&dev->d_wrsem, &sval) == 0 && sval != 0)
{
pipecommon_semtake(&dev->d_wrsem);
}
sem_post(&dev->d_bfsem);
pipecommon_semtake(&dev->d_wrsem);
pipecommon_semtake(&dev->d_bfsem);
}
fs/dirent/fs_readdir.c
+112 -32
View File
@@ -49,6 +49,7 @@
#include "fs/dirent_fs.h"
#include "inode/inode.h"
#include "sys/statfs.h"
#include "user_copy.h"
/****************************************************************************
@@ -77,8 +78,7 @@ static inline int readpseudodir(struct fs_dirent_s *idir)
}
/* Copy the inode name into the dirent structure */
ret = strncpy_s(idir->fd_dir.d_name, NAME_MAX + 1, idir->u.pseudo.fd_next->i_name, NAME_MAX);
ret = strncpy_s(idir->fd_dir[0].d_name, NAME_MAX + 1, idir->u.pseudo.fd_next->i_name, NAME_MAX);
if (ret != EOK)
{
return -ENAMETOOLONG;
@@ -86,24 +86,22 @@ static inline int readpseudodir(struct fs_dirent_s *idir)
/* If the node has file operations, we will say that it is a file. */
idir->fd_dir.d_type = 0;
idir->fd_dir.d_off = idir->fd_position;
idir->fd_dir.d_reclen = sizeof(struct dirent);
idir->fd_dir[0].d_type = 0;
if (idir->u.pseudo.fd_next->u.i_ops)
{
#ifndef CONFIG_DISABLE_MOUNTPOINT
if (INODE_IS_BLOCK(idir->u.pseudo.fd_next))
{
idir->fd_dir.d_type |= DT_BLK;
idir->fd_dir[0].d_type |= DT_BLK;
}
if (INODE_IS_MOUNTPT(idir->u.pseudo.fd_next))
{
idir->fd_dir.d_type |= DT_DIR;
idir->fd_dir[0].d_type |= DT_DIR;
}
else
#endif
{
idir->fd_dir.d_type |= DT_CHR;
idir->fd_dir[0].d_type |= DT_CHR;
}
}
@@ -114,7 +112,7 @@ static inline int readpseudodir(struct fs_dirent_s *idir)
if (idir->u.pseudo.fd_next->i_child || !idir->u.pseudo.fd_next->u.i_ops)
{
idir->fd_dir.d_type |= DT_DIR;
idir->fd_dir[0].d_type |= DT_DIR;
}
/* Now get the inode to vist next time that readdir() is called */
@@ -141,6 +139,47 @@ static inline int readpseudodir(struct fs_dirent_s *idir)
return OK;
}
/****************************************************************************
* Private Functions
****************************************************************************/
/****************************************************************************
* Name: handlezpfsdir
* Description:
* The handlezpfsdir() function handle with the inode with zpfs magic
*
* Input Parameters:
* idir -- the pointer of one dir
*
* Returned Value:
* none
****************************************************************************/
#ifdef LOSCFG_FS_ZPFS
static inline void handlezpfsdir(struct fs_dirent_s *idir)
{
struct statfs buf;
int ret;
/* Maybe there are two or more zpfs nodes together, so we need one loop */
do
{
if (!idir->u.pseudo.fd_next || !INODE_IS_MOUNTPT(idir->u.pseudo.fd_next) ||
!idir->u.pseudo.fd_next->u.i_mops || !idir->u.pseudo.fd_next->u.i_mops->statfs)
{
return;
}
ret = idir->u.pseudo.fd_next->u.i_mops->statfs(idir->u.pseudo.fd_next, &buf);
if (ret != OK || buf.f_type != ZPFS_MAGIC)
{
return;
}
if (readpseudodir(idir) == OK)
{
idir->fd_position++;
}
} while (1);
}
#endif
/****************************************************************************
* Public Functions
****************************************************************************/
@@ -165,12 +204,12 @@ static inline int readpseudodir(struct fs_dirent_s *idir)
* EBADF - Invalid directory stream descriptor dir
*
****************************************************************************/
static struct dirent *__readdir(DIR *dirp)
static struct dirent *__readdir(DIR *dirp, int *lencnt)
{
FAR struct fs_dirent_s *idir = (struct fs_dirent_s *)dirp;
struct inode *inode_ptr = NULL;
int ret = 0;
int file_cnt = 0;
/* Verify that we were provided with a valid directory structure */
if (!idir || idir->fd_status != DIRENT_MAGIC)
@@ -200,13 +239,20 @@ static struct dirent *__readdir(DIR *dirp)
*/
if (DIRENT_ISPSEUDONODE(idir->fd_flags))
{
#ifdef LOSCFG_FS_ZPFS
/* if the current node has the zpfs magic, we continue to skip the node */
handlezpfsdir(idir);
#endif
/* The node is part of the root pseudo file system */
ret = readpseudodir(idir);
if (!ret)
if (ret == OK)
{
idir->fd_position++;
return &idir->fd_dir;
idir->fd_position++;
idir->fd_dir[0].d_off = idir->fd_position;
idir->fd_dir[0].d_reclen = (uint16_t)sizeof(struct dirent);
*lencnt = sizeof(struct dirent);
return &(idir->fd_dir[0]);
}
}
@@ -223,23 +269,33 @@ static struct dirent *__readdir(DIR *dirp)
}
/* Perform the readdir() operation */
ret = inode_ptr->u.i_mops->readdir(inode_ptr, idir);
if (!ret)
#ifdef LOSCFG_ENABLE_READ_BUFFER
idir->read_cnt = MAX_DIRENT_NUM;
#else
idir->read_cnt = 1;
#endif
file_cnt = inode_ptr->u.i_mops->readdir(inode_ptr, idir);
if (file_cnt > 0)
{
idir->fd_position++;
return &idir->fd_dir;
*lencnt = file_cnt * sizeof(struct dirent);
return &(idir->fd_dir[0]);
}
}
#endif
ret = -ret;
errout:
if (ret != OK)
{
if (ret < 0)
{
ret = -ret;
}
set_errno(ret);
}
else if (file_cnt <= 0)
{
set_errno(ENOENT);
}
return (struct dirent *)NULL;
}
@@ -272,16 +328,40 @@ FAR struct dirent *readdir(DIR *dirp)
{
int ret;
int old_err = get_errno();
struct dirent *de = __readdir(dirp);
int lencnt = 0;
struct dirent *de = NULL;
FAR struct fs_dirent_s *idir = (struct fs_dirent_s *)dirp;
int dirlen;
if (de == NULL)
#ifdef LOSCFG_ENABLE_READ_BUFFER
dirlen = MAX_DIRENT_NUM;
#else
dirlen = 1;
#endif
if (idir->cur_pos != 0 && idir->cur_pos < dirlen && idir->cur_pos < idir->end_pos)
{
ret = get_errno();
/* Special case: ret = -ENOENT is end of file */
if (ret == ENOENT)
de = &(idir->fd_dir[idir->cur_pos]);
if (idir->cur_pos == dirlen)
{
set_errno(old_err);
idir->cur_pos = 0;
}
idir->cur_pos++;
return de;
} else {
de = __readdir(dirp, &lencnt);
idir->end_pos = lencnt / sizeof(struct dirent);
idir->cur_pos = 1;
if (de == NULL)
{
idir->cur_pos = 0;
ret = get_errno();
/* Special case: ret = -ENOENT is end of file */
if (ret == ENOENT)
{
set_errno(old_err);
}
}
}
return de;
@@ -292,7 +372,7 @@ FAR struct dirent *readdir(DIR *dirp)
int do_readdir(int fd, struct dirent **de, unsigned int count)
{
struct dirent *de_src = NULL;
int lencnt = 0;
/* Did we get a valid file descriptor? */
#if CONFIG_NFILE_DESCRIPTORS > 0
@@ -321,8 +401,7 @@ int do_readdir(int fd, struct dirent **de, unsigned int count)
}
/* Then let do_readdir do all of the work */
de_src = __readdir(filep->f_dir);
de_src = __readdir(filep->f_dir, &lencnt);
if (de_src == NULL)
{
/* Special case: ret = -ENOENT is end of file */
@@ -330,7 +409,8 @@ int do_readdir(int fd, struct dirent **de, unsigned int count)
}
*de = de_src;
return sizeof(*de_src);
lencnt = (lencnt != 0) ? lencnt : sizeof(*de_src);
return lencnt;
}
#endif
fs/dirent/fs_seekdir.c
+4 -3
View File
@@ -71,7 +71,7 @@ static inline void seekpseudodir(struct fs_dirent_s *idir, off_t offset)
if (offset < idir->fd_position)
{
pos = 0;
curr = idir->fd_root;
curr = idir->fd_root->i_child;
}
else
{
@@ -153,10 +153,12 @@ static inline void seekmountptdir(struct fs_dirent_s *idir, off_t offset)
* directory entries until we are at the desired position.
*/
idir->read_cnt = 1;
while (pos < offset)
{
if (!inode->u.i_mops || !inode->u.i_mops->readdir ||
inode->u.i_mops->readdir(inode, idir) < 0)
inode->u.i_mops->readdir(inode, idir) <= 0)
{
/* We can't read the next entry and there is no way to return
* an error indication.
@@ -171,7 +173,6 @@ static inline void seekmountptdir(struct fs_dirent_s *idir, off_t offset)
}
/* If we get here the directory position has been successfully set */
idir->fd_position = pos;
}
#endif
fs/inode/fs_files.c
+36 -58
View File
@@ -59,6 +59,7 @@
#endif
#include "los_process_pri.h"
#include "los_vm_filemap.h"
#include "mqueue.h"
#define ferr PRINTK
#if CONFIG_NFILE_DESCRIPTORS > 0
@@ -176,6 +177,10 @@ static int _files_close(FAR struct file *filep)
}
}
/* Drop file caches */
(void)remove_mapping_nolock(filep->f_path, filep);
/* And release the inode */
inode_release(inode);
@@ -483,11 +488,7 @@ int files_allocate(FAR struct inode *inode_ptr, int oflags, off_t pos,void* priv
list->fl_files[i].f_dir = NULL;
list->fl_files[i].f_magicnum = files_magic_generate();
process_files = OsCurrProcessGet()->files;
if (process_files)
{
FD_SET(i, process_files->fdt->open_fds);
}
else
if (process_files == NULL)
{
PRINT_ERR("process files is NULL, %s %d\n", __FUNCTION__ ,__LINE__);
_files_semgive(list);
@@ -535,11 +536,7 @@ static int files_close_internal(int fd, LosProcessCB *processCB)
_files_semtake(list);
process_files = processCB->files;
if (process_files)
{
FD_CLR(fd, process_files->fdt->open_fds);
}
else
if (process_files == NULL)
{
PRINT_ERR("process files is NULL, %s %d\n", __FUNCTION__ ,__LINE__);
_files_semgive(list);
@@ -598,7 +595,6 @@ int files_close(int fd)
void files_release(int fd)
{
FAR struct filelist *list = NULL;
struct files_struct *process_files = NULL;
list = sched_getfiles();
DEBUGASSERT(list);
@@ -618,11 +614,6 @@ void files_release(int fd)
list->fl_files[fd].f_mapping = NULL;
list->fl_files[fd].f_dir = NULL;
process_files = OsCurrProcessGet()->files;
if (process_files)
{
FD_CLR(fd, process_files->fdt->open_fds);
}
clear_bit(fd, bitmap);
_files_semgive(list);
}
@@ -722,6 +713,16 @@ void files_refer(int fd)
_files_semgive(list);
}
void alloc_std_fd(struct fd_table_s *fdt)
{
fdt->ft_fds[STDIN_FILENO].sysFd = STDIN_FILENO;
fdt->ft_fds[STDOUT_FILENO].sysFd = STDOUT_FILENO;
fdt->ft_fds[STDERR_FILENO].sysFd = STDERR_FILENO;
FD_SET(STDIN_FILENO, fdt->proc_fds);
FD_SET(STDOUT_FILENO, fdt->proc_fds);
FD_SET(STDERR_FILENO, fdt->proc_fds);
}
static void copy_fds(const struct fd_table_s *new_fdt, const struct fd_table_s *old_fdt)
{
unsigned int sz;
@@ -731,7 +732,6 @@ static void copy_fds(const struct fd_table_s *new_fdt, const struct fd_table_s *
{
(void)memcpy_s(new_fdt->ft_fds, sz, old_fdt->ft_fds, sz);
}
(void)memcpy_s(new_fdt->open_fds, sizeof(fd_set), old_fdt->open_fds, sizeof(fd_set));
(void)memcpy_s(new_fdt->proc_fds, sizeof(fd_set), old_fdt->proc_fds, sizeof(fd_set));
}
@@ -740,20 +740,27 @@ static void copy_fd_table(struct fd_table_s *new_fdt, struct fd_table_s *old_fdt
copy_fds((const struct fd_table_s *)new_fdt, (const struct fd_table_s *)old_fdt);
for (int i = 0; i < new_fdt->max_fds; i++)
{
if (FD_ISSET(i, new_fdt->open_fds))
{
files_refer(i);
}
#if defined(LOSCFG_NET_LWIP_SACK)
if (FD_ISSET(i, new_fdt->proc_fds))
{
int sysFd = GetAssociatedSystemFd(i);
if (sysFd >= CONFIG_NFILE_DESCRIPTORS && sysFd < (CONFIG_NFILE_DESCRIPTORS + CONFIG_NSOCKET_DESCRIPTORS))
if ((sysFd >= 0) && (sysFd < CONFIG_NFILE_DESCRIPTORS))
{
files_refer(sysFd);
}
#if defined(LOSCFG_NET_LWIP_SACK)
if ((sysFd >= CONFIG_NFILE_DESCRIPTORS) && (sysFd < (CONFIG_NFILE_DESCRIPTORS + CONFIG_NSOCKET_DESCRIPTORS)))
{
socks_refer(sysFd);
}
}
#endif
#if defined(LOSCFG_COMPAT_POSIX)
if ((sysFd >= MQUEUE_FD_OFFSET) && (sysFd < (MQUEUE_FD_OFFSET + CONFIG_NQUEUE_DESCRIPTORS)))
{
mqueue_refer(sysFd);
}
#endif
}
}
}
@@ -771,7 +778,6 @@ static struct fd_table_s * alloc_fd_table(unsigned int numbers)
if (!numbers)
{
fdt->ft_fds = NULL;
fdt->open_fds = NULL;
fdt->proc_fds = NULL;
return fdt;
}
@@ -782,10 +788,6 @@ static struct fd_table_s * alloc_fd_table(unsigned int numbers)
}
fdt->ft_fds = data;
/* 0,1,2 be distributed to stdin,stdout,stderr default */
fdt->ft_fds[STDIN_FILENO].sysFd = STDIN_FILENO;
fdt->ft_fds[STDOUT_FILENO].sysFd = STDOUT_FILENO;
fdt->ft_fds[STDERR_FILENO].sysFd = STDERR_FILENO;
for (int i = STDERR_FILENO + 1; i < numbers; i++)
{
fdt->ft_fds[i].sysFd = -1;
@@ -797,28 +799,14 @@ static struct fd_table_s * alloc_fd_table(unsigned int numbers)
goto out_arr;
}
(VOID)memset_s(data, sizeof(fd_set), 0, sizeof(fd_set));
fdt->open_fds = data;
FD_SET(STDIN_FILENO, fdt->open_fds);
FD_SET(STDOUT_FILENO, fdt->open_fds);
FD_SET(STDERR_FILENO, fdt->open_fds);
data = LOS_MemAlloc(m_aucSysMem0, sizeof(fd_set));
if (!data)
{
goto out_all;
}
(VOID)memset_s(data, sizeof(fd_set), 0, sizeof(fd_set));
fdt->proc_fds = data;
FD_SET(STDIN_FILENO, fdt->proc_fds);
FD_SET(STDOUT_FILENO, fdt->proc_fds);
FD_SET(STDERR_FILENO, fdt->proc_fds);
alloc_std_fd(fdt);
(void)sem_init(&fdt->ft_sem, 0, 1);
return fdt;
out_all:
(VOID)LOS_MemFree(m_aucSysMem0, fdt->open_fds);
out_arr:
(VOID)LOS_MemFree(m_aucSysMem0, fdt->ft_fds);
out_fdt:
@@ -915,25 +903,16 @@ void delete_files(LosProcessCB *processCB, struct files_struct *files)
for (int i = 0; i < files->fdt->max_fds; i++)
{
if (FD_ISSET(i, files->fdt->open_fds))
{
files_close_internal(i, processCB);
}
#if defined(LOSCFG_NET_LWIP_SACK)
if (FD_ISSET(i, files->fdt->proc_fds))
{
int sysFd = GetAssociatedSystemFd(i);
if (sysFd >= CONFIG_NFILE_DESCRIPTORS && sysFd < (CONFIG_NFILE_DESCRIPTORS + CONFIG_NSOCKET_DESCRIPTORS))
{
close(sysFd);
}
int sysFd = DisassociateProcessFd(i);
close(sysFd);
FreeProcessFd(i);
}
#endif
}
(VOID)sem_destroy(&files->fdt->ft_sem);
(VOID)LOS_MemFree(m_aucSysMem0, files->fdt->ft_fds);
(VOID)LOS_MemFree(m_aucSysMem0, files->fdt->open_fds);
(VOID)LOS_MemFree(m_aucSysMem0, files->fdt->proc_fds);
(VOID)LOS_MemFree(m_aucSysMem0, files->fdt);
out_file:
@@ -992,7 +971,6 @@ void delete_files_snapshot(struct files_struct *files)
(VOID)sem_destroy(&files->fdt->ft_sem);
(VOID)LOS_MemFree(m_aucSysMem0, files->fdt->ft_fds);
(VOID)LOS_MemFree(m_aucSysMem0, files->fdt->open_fds);
(VOID)LOS_MemFree(m_aucSysMem0, files->fdt->proc_fds);
(VOID)LOS_MemFree(m_aucSysMem0, files->fdt);
out_file:
fs/inode/fs_foreachinode.c
+1 -2
View File
@@ -95,7 +95,6 @@ static int foreach_inodelevel(FAR struct inode *node, struct inode_path_s *info)
for (; node; node = node->i_peer)
{
/* Give the next inode to the callback */
ret = info->handler(node, info->path, info->arg);
/* Break out of the loop early if the handler returns a non-zero
@@ -129,7 +128,7 @@ static int foreach_inodelevel(FAR struct inode *node, struct inode_path_s *info)
/* Append the path segment to this inode and recurse */
ret = snprintf_s(&info->path[pathlen], CONFIG_PATH_MAX - pathlen,
CONFIG_PATH_MAX - pathlen - 1, "/%s", node->i_name);
CONFIG_PATH_MAX - pathlen - 1, "%s/", node->i_name);
if (ret < 0)
{
ret = -ENAMETOOLONG;
fs/inode/fs_inodereserve.c
Executable → Regular
+40 -6
View File
@@ -190,7 +190,7 @@ static void inode_insert(FAR struct inode *node,
****************************************************************************/
/****************************************************************************
* Name: inode_reserve
* Name: inode_reserve_rootdir
*
* Description:
* Reserve an (initialized) inode the pseudo file system. The initial
@@ -199,6 +199,7 @@ static void inode_insert(FAR struct inode *node,
* Input Parameters:
* path - The path to the inode to create
* inode - The location to return the inode pointer
* force - force to reserve the inode if the value is true
*
* Returned Value:
* Zero on success (with the inode point in 'inode'); A negated errno
@@ -213,7 +214,10 @@ static void inode_insert(FAR struct inode *node,
*
****************************************************************************/
int inode_reserve(FAR const char *path, FAR struct inode **inode_ptr)
#ifndef LOSCFG_FS_ZPFS
static inline
#endif
int inode_reserve_rootdir(FAR const char *path, FAR struct inode **inode_ptr, bool force)
{
FAR const char *name = path;
FAR const char *relpath;
@@ -247,7 +251,8 @@ int inode_reserve(FAR const char *path, FAR struct inode **inode_ptr)
#ifndef CONFIG_DISABLE_MOUNTPOINT
else if (INODE_IS_MOUNTPT(pathnode))
{
if ((pathnode != g_root_inode) || IsInRootfs(relpath))
if ((pathnode != g_root_inode) ||
(force ? false : IsInRootfs(relpath)))
{
/* The node cannot be a child of a mounted point, except the root node. */
@@ -266,10 +271,9 @@ int inode_reserve(FAR const char *path, FAR struct inode **inode_ptr)
}
}
if (check_name(name) == false)
if ((force == false) && (check_name(name) == false))
{
/* check the path has no '/' symbol, prevent to create multilevel directory */
return -EINVAL;
}
@@ -317,4 +321,34 @@ int inode_reserve(FAR const char *path, FAR struct inode **inode_ptr)
return -ENOMEM;
}
}
}
/****************************************************************************
* Name: inode_reserve
*
* Description:
* Reserve an (initialized) inode the pseudo file system. The initial
* reference count on the new inode is zero.
*
* Input Parameters:
* path - The path to the inode to create
* inode - The location to return the inode pointer
*
* Returned Value:
* Zero on success (with the inode point in 'inode'); A negated errno
* value is returned on failure:
*
* EINVAL - 'path' is invalid for this operation
* EEXIST - An inode already exists at 'path'
* ENOMEM - Failed to allocate in-memory resources for the operation
*
* Assumptions:
* Caller must hold the inode semaphore
*
****************************************************************************/
int inode_reserve(FAR const char *path, FAR struct inode **inode_ptr)
{
return inode_reserve_rootdir(path, inode_ptr, false);
}
fs/inode/inode.h
+3
View File
@@ -355,6 +355,9 @@ bool IsInRootfs(const char *relpath);
****************************************************************************/
int inode_reserve(FAR const char *path, FAR struct inode **inode);
#ifdef LOSCFG_FS_ZPFS
int inode_reserve_rootdir(FAR const char *path, FAR struct inode **inode, bool force);
#endif
/****************************************************************************
* Name: inode_unlink
fs/mount/fs_foreachmountpoint.c
+5 -1
View File
@@ -110,7 +110,7 @@ static int mountpoint_filter(FAR struct inode *node,
/* Append the inode name to the directory path */
ret = snprintf_s(&dirpath[pathlen], PATH_MAX - pathlen, PATH_MAX - pathlen - 1, "/%s", node->i_name);
ret = snprintf_s(&dirpath[pathlen], PATH_MAX - pathlen, PATH_MAX - pathlen - 1, "%s/", node->i_name);
if (ret < 0)
{
return -ENAMETOOLONG;
@@ -123,6 +123,10 @@ static int mountpoint_filter(FAR struct inode *node,
{
/* And pass the full path and file system status to the handler */
if (strlen(dirpath) > 1) {
dirpath[strlen(dirpath) - 1] = '\0';
}
ret = info->handler(dirpath, &statbuf, info->arg);
}
fs/mount/fs_mount.c
+25 -5
View File
@@ -51,7 +51,7 @@
#include "inode/inode.h"
#include "stdlib.h"
#include "driver/driver.h"
#if defined(LOSCFG_FS_JFFS)
#ifdef LOSCFG_DRIVERS_MTD
#include "mtd_partition.h"
#endif
#ifdef LOSCFG_FS_FAT_VIRTUAL_PARTITION
@@ -59,6 +59,10 @@
#endif
#include "los_tables.h"
#ifdef LOSCFG_FS_ZPFS
#include "vfs_zpfs.h"
#endif
/* At least one filesystem must be defined, or this file will not compile.
* It may be desire-able to make filesystems dynamically registered at
* some time in the future, but at present, this file needs to know about
@@ -161,7 +165,7 @@ int mount(const char *source, const char *target,
const struct fsmap_t *fsmap = NULL;
const struct mountpt_operations *mops = NULL;
#if defined(LOSCFG_FS_JFFS)
#ifdef LOSCFG_DRIVERS_MTD
mtd_partition *partition = NULL;
#endif
@@ -220,7 +224,20 @@ int mount(const char *source, const char *target,
*/
inode_semtake();
#ifdef LOSCFG_FS_ZPFS
if (strcmp(filesystemtype, ZPFS_NAME) == 0)
{
ret = ZpfsPrepare(source, fullpath, &mountpt_inode, true);
if (ret < 0)
{
errcode = -ret;
goto errout_with_semaphore;
}
data = (const void *)mountpt_inode->i_private;
}
else
{
#endif
mountpt_inode = inode_search((const char **)&fullpath, (struct inode **)NULL, (struct inode **)NULL, \
(const char **)NULL);
@@ -244,6 +261,9 @@ int mount(const char *source, const char *target,
errcode = EINVAL;
goto errout_with_semaphore;
}
#ifdef LOSCFG_FS_ZPFS
}
#endif
mountpt_inode ->mountflags = mountflags;
@@ -277,7 +297,7 @@ int mount(const char *source, const char *target,
goto errout_with_mountpt;
}
}
#if defined(LOSCFG_FS_JFFS)
#ifdef LOSCFG_DRIVERS_MTD
if (fsmap->is_mtd_support && (blkdrvr_inode != NULL))
{
partition = (mtd_partition *)blkdrvr_inode->i_private;
@@ -316,7 +336,7 @@ int mount(const char *source, const char *target,
}
errcode = -ret;
#if defined(LOSCFG_FS_JFFS)
#ifdef LOSCFG_DRIVERS_MTD
if (fsmap->is_mtd_support && (blkdrvr_inode != NULL) && (partition != NULL))
{
free(partition->mountpoint_name);
fs/mount/fs_umount.c
Executable → Regular
+26
View File
@@ -49,6 +49,9 @@
#include "string.h"
#include "disk.h"
#ifdef LOSCFG_FS_ZPFS
#include "vfs_zpfs.h"
#endif
/****************************************************************************
* Pre-processor Definitions
****************************************************************************/
@@ -101,6 +104,11 @@ int umount(const char *target)
const char *relpath = NULL;
struct inode_search_s desc;
int ret;
#ifdef LOSCFG_FS_ZPFS
bool isZpfs = false;
struct inode zpfsInode;
#endif
/* Verify required pointer arguments */
if (target == NULL)
@@ -159,6 +167,17 @@ int umount(const char *target)
}
inode_semtake(); /* Hold the semaphore through the unbind logic */
#ifdef LOSCFG_FS_ZPFS
if (IsZpfsFileSystem(mountpt_inode))
{
isZpfs = true;
zpfsInode.i_private = mountpt_inode->i_private;
zpfsInode.u.i_ops = mountpt_inode->u.i_ops;
zpfsInode.i_flags = mountpt_inode->i_flags;
}
#endif
if (mountpt_inode->i_crefs == 1)
{
status = mountpt_inode->u.i_mops->unbind(mountpt_inode->i_private, &blkdrvr_inode);
@@ -207,6 +226,13 @@ int umount(const char *target)
inode_release(blkdrvr_inode);
}
#ifdef LOSCFG_FS_ZPFS
if (isZpfs)
{
ZpfsCleanUp((void*)&zpfsInode, fullpath);
}
#endif
free(fullpath);
return OK;
fs/nfs/nfs_vfsops.c
+73 -36
View File
@@ -253,6 +253,30 @@ const struct mountpt_operations nfs_operations =
FSMAP_ENTRY(nfs_fsmap, "nfs", nfs_operations, FALSE, FALSE);
static int nfs_2_vfs(int result)
{
int status;
if ((result < NFS_OK) || (result > NFSERR_NOTEMPTY)) {
return result;
}
/* Nfs errno to Libc errno */
switch (result) {
case NFSERR_NAMETOL:
status = ENAMETOOLONG;
break;
case NFSERR_NOTEMPTY:
status = ENOTEMPTY;
break;
default:
status = result;
break;
}
return status;
}
/****************************************************************************
* Public Functions
****************************************************************************/
@@ -875,14 +899,6 @@ static int nfs_close(FAR struct file *filep)
nfs_mux_release(nmp);
/* Drop the NFS file page cache if no one, except me, is working on it, to ensure
* the close-to-open cache consistency for NFS files.
* And because the outer "files_close" has locked the global file list already,
* we use the nolock version here.
*/
(void)remove_mapping_nolock(filep->f_path, filep);
return ret;
}
@@ -1072,6 +1088,7 @@ static ssize_t nfs_write(FAR struct file *filep, const char *buffer,
uint32_t tmp;
int committed = NFSV3WRITE_UNSTABLE;
int error;
char *temp_buffer;
/* Sanity checks */
@@ -1121,6 +1138,16 @@ static ssize_t nfs_write(FAR struct file *filep, const char *buffer,
fvdbg("Write %d bytes to offset %d\n", buflen, np->n_fpos);
/* Allocate memory for data */
bufsize = (buflen < nmp->nm_wsize) ? buflen : nmp->nm_wsize;
temp_buffer = malloc(bufsize);
if (temp_buffer == NULL)
{
error = ENOMEM;
goto errout_with_mutex;
}
/* Now loop until we send the entire user buffer */
writesize = 0;
@@ -1146,6 +1173,14 @@ static ssize_t nfs_write(FAR struct file *filep, const char *buffer,
writesize -= (bufsize - nmp->nm_buflen);
}
/* Copy a chunk of the user data into the temporary buffer */
if (LOS_CopyToKernel(temp_buffer, writesize, buffer, writesize) != 0)
{
error = EINVAL;
goto errout_with_memfree;
}
/* Initialize the request. Here we need an offset pointer to the write
* arguments, skipping over the RPC header. Write is unique among the
* RPC calls in that the entry RPC calls messasge lies in the I/O buffer
@@ -1176,16 +1211,16 @@ static ssize_t nfs_write(FAR struct file *filep, const char *buffer,
*ptr++ = txdr_unsigned((uint32_t)committed);
reqlen += 2*sizeof(uint32_t);
/* Copy a chunk of the user data into the I/O buffer */
/* Copy a chunk of the user data into the I/O buffer from temporary buffer */
*ptr++ = txdr_unsigned(writesize);
reqlen += sizeof(uint32_t);
if (LOS_CopyToKernel(ptr, writesize, buffer, writesize) != 0)
error = memcpy_s(ptr, writesize, temp_buffer, writesize);
if (error != EOK)
{
error = EINVAL;
goto errout_with_mutex;
error = ENOBUFS;
goto errout_with_memfree;
}
reqlen += uint32_alignup(writesize);
/* Perform the write */
@@ -1198,7 +1233,7 @@ static ssize_t nfs_write(FAR struct file *filep, const char *buffer,
if (error)
{
ferr("ERROR: nfs_request failed: %d\n", error);
goto errout_with_mutex;
goto errout_with_memfree;
}
/* Get a pointer to the WRITE reply data */
@@ -1234,7 +1269,7 @@ static ssize_t nfs_write(FAR struct file *filep, const char *buffer,
if (tmp < 1 || tmp > writesize)
{
error = EIO;
goto errout_with_mutex;
goto errout_with_memfree;
}
writesize = tmp;
@@ -1252,9 +1287,11 @@ static ssize_t nfs_write(FAR struct file *filep, const char *buffer,
buffer += writesize;
}
free(temp_buffer);
nfs_mux_release(nmp);
return byteswritten;
errout_with_memfree:
free(temp_buffer);
errout_with_mutex:
nfs_mux_release(nmp);
return -error;
@@ -1668,7 +1705,6 @@ static int nfs_readdir(struct inode *mountpt, struct fs_dirent_s *dir)
size_t d_name_size;
int reqlen;
int error = 0;
finfo("Entry\n");
/* Sanity checks */
@@ -1824,7 +1860,7 @@ static int nfs_readdir(struct inode *mountpt, struct fs_dirent_s *dir)
/* Get the length and point to the name */
tmp = *ptr++; /*lint !e662 !e661*/
tmp = *ptr++; /*lint !e662 !e661*/
entry->name_len = fxdr_unsigned(uint32_t, tmp);
entry->contents = (uint8_t *)malloc(entry->name_len + 1);
if (!entry->contents)
@@ -1919,8 +1955,8 @@ static int nfs_readdir(struct inode *mountpt, struct fs_dirent_s *dir)
goto errout_with_mutex;
}
d_name_size = sizeof(dir->fd_dir.d_name);
error = memcpy_s(dir->fd_dir.d_name, d_name_size, (const char *)entry_pos->contents, (size_t)entry_pos->name_len);
d_name_size = sizeof(dir->fd_dir[0].d_name);
error = memcpy_s(dir->fd_dir[0].d_name, d_name_size, (const char *)entry_pos->contents, (size_t)entry_pos->name_len);
if (error != EOK)
{
error = ENOBUFS;
@@ -1928,21 +1964,21 @@ static int nfs_readdir(struct inode *mountpt, struct fs_dirent_s *dir)
}
if (entry_pos->name_len >= d_name_size)
{
dir->fd_dir.d_name[d_name_size - 1] = '\0';
dir->fd_dir[0].d_name[d_name_size - 1] = '\0';
}
else
{
dir->fd_dir.d_name[entry_pos->name_len] = '\0';
dir->fd_dir[0].d_name[entry_pos->name_len] = '\0';
}
nfs_dir->nfs_entries = entry_pos->next;
NFS_DIR_ENTRY_FREE(entry_pos);
fvdbg("name: \"%s\"\n", dir->fd_dir.d_name);
fvdbg("name: \"%s\"\n", dir->fd_dir[0].d_name);
fhandle.length = (uint32_t)nfs_dir->nfs_fhsize;
(void)memcpy_s(&fhandle.handle, DIRENT_NFS_MAXHANDLE, nfs_dir->nfs_fhandle, DIRENT_NFS_MAXHANDLE);
error = nfs_lookup(nmp, dir->fd_dir.d_name, &fhandle, &obj_attributes, NULL);
error = nfs_lookup(nmp, dir->fd_dir[0].d_name, &fhandle, &obj_attributes, NULL);
if (error != OK)
{
ferr("ERROR: nfs_lookup failed: %d\n", error);
@@ -1961,28 +1997,29 @@ static int nfs_readdir(struct inode *mountpt, struct fs_dirent_s *dir)
break;
case NFREG: /* Regular file */
dir->fd_dir.d_type = DT_REG;
dir->fd_dir[0].d_type = DT_REG;
break;
case NFDIR: /* Directory */
dir->fd_dir.d_type = DT_DIR;
dir->fd_dir[0].d_type = DT_DIR;
break;
case NFBLK: /* Block special device file */
dir->fd_dir.d_type = DT_BLK;
dir->fd_dir[0].d_type = DT_BLK;
break;
case NFFIFO: /* Named FIFO */
case NFCHR: /* Character special device file */
dir->fd_dir.d_type = DT_CHR;
dir->fd_dir[0].d_type = DT_CHR;
break;
}
dir->fd_dir.d_off = dir->fd_position;
dir->fd_dir.d_reclen = (uint16_t)sizeof(struct dirent);
finfo("type: %d->%d\n", (int)tmp, dir->fd_dir.d_type);
finfo("type: %d->%d\n", (int)tmp, dir->fd_dir[0].d_type);
dir->fd_position++;
dir->fd_dir[0].d_off = dir->fd_position;
dir->fd_dir[0].d_reclen = (uint16_t)sizeof(struct dirent);
nfs_mux_release(nmp);
return OK;
return 1;
errout_with_memory:
for (entry_pos = nfs_dir->nfs_entries; entry_pos != NULL; entry_pos = nfs_dir->nfs_entries)
@@ -2970,7 +3007,7 @@ static int nfs_rmdir(struct inode *mountpt, const char *relpath)
errout_with_mutex:
nfs_mux_release(nmp);
return -error;
return -nfs_2_vfs(error);
}
static int nfs_getfilename(char *dstpath, unsigned int dstpathLen, const char *srcpath, unsigned int maxlen)
@@ -3119,7 +3156,7 @@ static int nfs_rename(struct inode *mountpt, const char *oldrelpath,
for (nd = nmp->nm_dir; nd; nd = nd->nfs_next)
{
char filename[FILENAME_MAX_LEN] = {};
error = nfs_getfilename(filename, sizeof(filename), nd->nfs_dir->fd_dir.d_name, NAME_MAX);
error = nfs_getfilename(filename, sizeof(filename), nd->nfs_dir->fd_dir[0].d_name, NAME_MAX);
if (error != OK)
{
goto errout_with_mutex;
@@ -3257,7 +3294,7 @@ static int nfs_rename(struct inode *mountpt, const char *oldrelpath,
}
else if (nd)
{
error = memcpy_s(nd->nfs_dir->fd_dir.d_name, strlen(to_name) + 1, to_name, strlen(to_name) + 1);
error = memcpy_s(nd->nfs_dir->fd_dir[0].d_name, strlen(to_name) + 1, to_name, strlen(to_name) + 1);
if (error != EOK)
{
error = ENOBUFS;
@@ -3427,7 +3464,7 @@ static int nfs_stat(struct inode *mountpt, const char *relpath,
errout_with_mutex:
nfs_mux_release(nmp);
return -error;
return -nfs_2_vfs(error);
}
int nfs_mount(const char *server_ip_and_path, const char *mount_path,
fs/tmpfs/fs_tmpfs.c
+12 -10
View File
@@ -1366,8 +1366,7 @@ static ssize_t tmpfs_write(FAR struct file *filep, FAR const char *buffer,
ret = -ENOSPC;
goto errout_with_lock;
}
(void)memset_s(data, startpos + alloc, 0, startpos + alloc);
if (tfo->tfo_data)
if (tfo->tfo_size)
{
ret = memcpy_s(data, startpos + alloc, tfo->tfo_data, tfo->tfo_size);
if (ret != EOK)
@@ -1378,6 +1377,10 @@ static ssize_t tmpfs_write(FAR struct file *filep, FAR const char *buffer,
}
free(tfo->tfo_data);
}
if (startpos > tfo->tfo_size)
{
(void)memset_s(data + tfo->tfo_size, startpos + alloc - tfo->tfo_size, 0, startpos - tfo->tfo_size);
}
tfo->tfo_data = data;
tfo->tfo_size = startpos + alloc;
@@ -1675,25 +1678,24 @@ static int tmpfs_readdir(FAR struct inode *mountpt,
{
/* A directory */
dir->fd_dir.d_type = DT_DIR;
dir->fd_dir[0].d_type = DT_DIR;
}
else /* to->to_type == TMPFS_REGULAR) */
{
/* A regular file */
dir->fd_dir.d_type = DT_REG;
dir->fd_dir[0].d_type = DT_REG;
}
/* Copy the entry name */
(void)strncpy_s(dir->fd_dir.d_name, NAME_MAX + 1, tde->tde_name, NAME_MAX);
(void)strncpy_s(dir->fd_dir[0].d_name, NAME_MAX + 1, tde->tde_name, NAME_MAX);
/* Increment the index for next time */
dir->fd_position++;
dir->fd_dir[0].d_off = dir->fd_position;
dir->fd_dir[0].d_reclen = (uint16_t)sizeof(struct dirent);
dir->fd_dir.d_off = dir->fd_position;
dir->fd_dir.d_reclen = (uint16_t)sizeof(struct dirent);
ret = OK;
ret = 1; // 1 means current file num is 1
}
tmpfs_unlock_directory(tdo);
fs/vfs/fs_close.c
+9
View File
@@ -49,6 +49,7 @@
#endif
#include "inode/inode.h"
#include "mqueue.h"
/****************************************************************************
* Public Functions
@@ -97,6 +98,14 @@ int close(int fd)
}
else
#endif
#if defined(LOSCFG_COMPAT_POSIX)
if ((unsigned int)fd >= MQUEUE_FD_OFFSET && \
(unsigned int)fd < (unsigned int)(MQUEUE_FD_OFFSET + CONFIG_NQUEUE_DESCRIPTORS))
{
return mq_close((mqd_t)fd);
}
#endif
else
{
err = EBADF;
goto errout;
fs/vfs/fs_stat.c
+5
View File
@@ -229,6 +229,11 @@ int stat(FAR const char *path, FAR struct stat *buf)
else
#endif
{
if (strlen(relpath) > 0)
{
ret = ENOENT;
goto errout_with_inode;
}
/* The node is part of the root pseudo file system */
if (VfsPermissionCheck(desc.parent->i_uid, desc.parent->i_gid, desc.parent->i_mode, EXEC_OP))
fs/vfs/fs_statfs.c
+25 -3
View File
@@ -131,11 +131,27 @@ int statfs(FAR const char *path, FAR struct statfs *buf)
* supports the statfs() method
*/
if (inode->u.i_mops && inode->u.i_mops->statfs)
if (inode->u.i_mops && inode->u.i_mops->stat && inode->u.i_mops->statfs)
{
/* Perform the statfs() operation */
struct stat *statbuf = LOS_MemAlloc(m_aucSysMem0, sizeof(struct stat));
if (statbuf == NULL)
{
ret = ENOMEM;
}
else
{
/* Check whether the path is available or not */
ret = inode->u.i_mops->statfs(inode, buf);
ret = inode->u.i_mops->stat(inode, desc.relpath, statbuf);
if (ret == 0)
{
/* Perform the statfs() operation */
(void)memset_s((void *)buf, sizeof(struct statfs), 0, sizeof(struct statfs));
ret = inode->u.i_mops->statfs(inode, buf);
}
(VOID)LOS_MemFree(m_aucSysMem0, statbuf);
}
}
}
else
@@ -143,6 +159,12 @@ int statfs(FAR const char *path, FAR struct statfs *buf)
{
/* The node is part of the root pseudo file system */
if (strlen(desc.relpath) > 0)
{
ret = ENOENT;
goto errout_with_inode;
}
ret = statpseudofs(inode, buf);
}
include/nuttx/fs/dirent_fs.h
+12 -2
View File
@@ -308,11 +308,21 @@ struct fs_dirent_s
#ifdef CONFIG_FS_HOSTFS
struct fs_hostfsdir_s hostfs;
#endif
#ifdef LOSCFG_FS_ZPFS
void *zpfs;
#endif
} u;
/* In any event, this the actual struct dirent that is returned by readdir */
struct dirent fd_dir; /* Populated when readdir is called */
#ifdef LOSCFG_ENABLE_READ_BUFFER
struct dirent fd_dir[MAX_DIRENT_NUM]; /* Populated when readdir is called */
#else
struct dirent fd_dir[1]; /* Populated when readdir is called */
#endif
int16_t cur_pos;
int16_t end_pos;
int32_t read_cnt;
int fd_status; /* Express the dirent is been opened or no */
};
include/nuttx/fs/fs.h
+1
View File
@@ -78,6 +78,7 @@ extern "C" {
#undef OK
#define OK 0
#define MAX_DIRENT_NUM 14 // 14 means 4096 length buffer can store 14 dirent, see struct DIR
#define MS_RDONLY 1
#define MS_NOSYNC 2
#define PROCFS_MOUNT_POINT "/proc"
include/sys/statfs.h
Executable
+155
View File
@@ -0,0 +1,155 @@
/****************************************************************************
* include/sys/statfs.h
*
* Copyright (C) 2007-2009, 2011-2013 Gregory Nutt. All rights reserved.
* Author: Gregory Nutt <gnutt@nuttx.org>
*
* 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 name 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.
*
****************************************************************************/
#ifndef __INCLUDE_SYS_STATFS_H
#define __INCLUDE_SYS_STATFS_H
/****************************************************************************
* Included Files
****************************************************************************/
#include <nuttx/config.h>
#include <sys/types.h>
#include <stdint.h>
/****************************************************************************
* Pre-processor Definitions
****************************************************************************/
/* struct statfs file system types. */
#define ADFS_SUPER_MAGIC 0xadf5
#define AFFS_SUPER_MAGIC 0xadff
#define BEFS_SUPER_MAGIC 0x42465331
#define BFS_MAGIC 0x1badface
#define CIFS_MAGIC_NUMBER 0xff534d42
#define CODA_SUPER_MAGIC 0x73757245
#define COH_SUPER_MAGIC 0x012ff7b7
#define CRAMFS_MAGIC 0x28cd3d45
#define DEVFS_SUPER_MAGIC 0x1373
#define EFS_SUPER_MAGIC 0x00414a53
#define EXT_SUPER_MAGIC 0x137d
#define EXT2_OLD_SUPER_MAGIC 0xef51
#define EXT2_SUPER_MAGIC 0xef53
#define EXT3_SUPER_MAGIC 0xef53
#define HFS_SUPER_MAGIC 0x4244
#define HPFS_SUPER_MAGIC 0xf995e849
#define HUGETLBFS_MAGIC 0x958458f6
#define ISOFS_SUPER_MAGIC 0x9660
#define JFFS2_SUPER_MAGIC 0x72b6
#define JFS_SUPER_MAGIC 0x3153464a
#define MINIX_SUPER_MAGIC 0x137f /* orig. minix */
#define MINIX_SUPER_MAGIC2 0x138f /* 30 char minix */
#define MINIX2_SUPER_MAGIC 0x2468 /* minix V2 */
#define MINIX2_SUPER_MAGIC2 0x2478 /* minix V2, 30 char names */
#define MSDOS_SUPER_MAGIC 0x4d44
#define NCP_SUPER_MAGIC 0x564c
#define NFS_SUPER_MAGIC 0x6969
#define NTFS_SB_MAGIC 0x5346544e
#define OPENPROM_SUPER_MAGIC 0x9fa1
#define PROC_SUPER_MAGIC 0x9fa0
#define QNX4_SUPER_MAGIC 0x002f
#define REISERFS_SUPER_MAGIC 0x52654973
#define ROMFS_MAGIC 0x7275
#define SMB_SUPER_MAGIC 0x517B
#define SYSV2_SUPER_MAGIC 0x012ff7b6
#define SYSV4_SUPER_MAGIC 0x012FF7B5
#define TMPFS_MAGIC 0x01021994
#define UDF_SUPER_MAGIC 0x15013346
#define UFS_MAGIC 0x00011954
#define USBDEVICE_SUPER_MAGIC 0x9fa2
#define VXFS_SUPER_MAGIC 0xa501fcf5
#define XENIX_SUPER_MAGIC 0x012ff7b4
#define XFS_SUPER_MAGIC 0x58465342
#define _XIAFS_SUPER_MAGIC 0x012fd16d
#define SPIFFS_SUPER_MAGIC 0x20090315
#define LITTLEFS_SUPER_MAGIC 0x0a732923
#define ZPFS_MAGIC 0xa000e93
/* NuttX specific file-systems */
#define BINFS_MAGIC 0x4242
#define PROCFS_MAGIC 0x434f5250
#define NXFFS_MAGIC 0x4747
#define SMARTFS_MAGIC 0x54524D53
#define UNIONFS_MAGIC 0x53464e55
#define HOSTFS_MAGIC 0x54534f48
#define USERFS_MAGIC 0x52455355
#define CROMFS_MAGIC 0x4d4f5243
/****************************************************************************
* Type Definitions
****************************************************************************/
struct statfs
{
uint32_t f_type; /* Type of filesystem (see definitions above) */
size_t f_namelen; /* Maximum length of filenames */
size_t f_bsize; /* Optimal block size for transfers */
off_t f_blocks; /* Total data blocks in the file system of this size */
off_t f_bfree; /* Free blocks in the file system */
off_t f_bavail; /* Free blocks avail to non-superuser */
off_t f_files; /* Total file nodes in the file system */
off_t f_ffree; /* Free file nodes in the file system */
};
/****************************************************************************
* Public Function Prototypes
****************************************************************************/
#undef EXTERN
#if defined(__cplusplus)
#define EXTERN extern "C"
extern "C"
{
#else
#define EXTERN extern
#endif
/* Inspired by Linux statfs() which was, in turn, inspired by
* the BSD statfs(). None of these implementations agree in the
* form of the struct statfs.
*/
int statfs(FAR const char *path, FAR struct statfs *buf);
int fstatfs(int fd, FAR struct statfs *buf);
#undef EXTERN
#if defined(__cplusplus)
}
#endif
#endif /* __INCLUDE_SYS_STATFS_H */