libs/rt-thread
libs
/
rt-thread
4
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

add full path options (DFS_FS_FLAG_FULLPATH) to the file system. 

git-svn-id: https://rt-thread.googlecode.com/svn/trunk@1904 bbd45198-f89e-11dd-88c7-29a3b14d5316
This commit is contained in:
bernard.xiong@gmail.com 2012-01-01 13:37:21 +00:00
parent 76e81a9977
commit beaf51ff82
8 changed files with 677 additions and 651 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
components/dfs/filesystems/devfs/devfs.c
View File

@ -248,6 +248,7 @@ int dfs_device_fs_getdents(struct dfs_fd* file, struct dirent* dirp, rt_uint32_t
static const struct dfs_filesystem_operation _device_fs =
{
"devfs",
DFS_FS_FLAG_DEFAULT,
dfs_device_fs_mount,
RT_NULL,
RT_NULL,

1
components/dfs/filesystems/elmfat/dfs_elm.c
View File

@ -647,6 +647,7 @@ int dfs_elm_stat(struct dfs_filesystem *fs, const char *path, struct stat *st)
static const struct dfs_filesystem_operation dfs_elm =
{
"elm",
DFS_FS_FLAG_DEFAULT,
dfs_elm_mount,
dfs_elm_unmount,
dfs_elm_mkfs,

3
components/dfs/filesystems/nfs/dfs_nfs.c
View File

@ -1056,7 +1056,8 @@ int nfs_getdents(struct dfs_fd *file, struct dirent *dirp, rt_uint32_t count)
static const struct dfs_filesystem_operation _nfs =
{
"nfs",
"nfs",
DFS_FS_FLAG_DEFAULT,
nfs_mount,
nfs_unmount,
RT_NULL, /* mkfs */

583
components/dfs/filesystems/romfs/dfs_romfs.c
View File

@ -1,291 +1,292 @@
/*
* File : dfs_romfs.c
* This file is part of Device File System in RT-Thread RTOS
* COPYRIGHT (C) 2004-2011, RT-Thread Development Team
*
* The license and distribution terms for this file may be
* found in the file LICENSE in this distribution or at
* http://www.rt-thread.org/license/LICENSE.
*
* Change Logs:
* Date Author Notes
*/
#include <rtthread.h>
#include <dfs.h>
#include <dfs_fs.h>
#include "dfs_romfs.h"
int dfs_romfs_mount(struct dfs_filesystem *fs, unsigned long rwflag, const void *data)
{
struct romfs_dirent *root_dirent;
if (data == RT_NULL)
return -DFS_STATUS_EIO;
root_dirent = (struct romfs_dirent *)data;
fs->data = root_dirent;
return DFS_STATUS_OK;
}
int dfs_romfs_unmount(struct dfs_filesystem *fs)
{
return DFS_STATUS_OK;
}
int dfs_romfs_ioctl(struct dfs_fd *file, int cmd, void *args)
{
return -DFS_STATUS_EIO;
}
struct romfs_dirent *dfs_romfs_lookup(struct romfs_dirent *root_dirent, const char *path, rt_size_t *size)
{
rt_size_t index, found;
const char *subpath, *subpath_end;
struct romfs_dirent *dirent;
rt_size_t dirent_size;
if (path[0] == '/' && path[1] == '\0')
{
*size = root_dirent->size;
return root_dirent;
}
/* goto root directy entries */
dirent = (struct romfs_dirent *)root_dirent->data;
dirent_size = root_dirent->size;
/* get the end position of this subpath */
subpath_end = path;
/* skip /// */
while (*subpath_end && *subpath_end == '/')
subpath_end ++;
subpath = subpath_end;
while ((*subpath_end != '/') && *subpath_end)
subpath_end ++;
while (dirent != RT_NULL)
{
found = 0;
/* search in folder */
for (index = 0; index < dirent_size; index ++)
{
if (rt_strncmp(dirent[index].name, subpath, (subpath_end - subpath)) == 0)
{
dirent_size = dirent[index].size;
/* skip /// */
while (*subpath_end && *subpath_end == '/')
subpath_end ++;
subpath = subpath_end;
while ((*subpath_end != '/') && *subpath_end)
subpath_end ++;
if (!(*subpath))
{
*size = dirent_size;
return &dirent[index];
}
if (dirent[index].type == ROMFS_DIRENT_DIR)
{
/* enter directory */
dirent = (struct romfs_dirent*)dirent[index].data;
found = 1;
break;
}
else
{
/* return file dirent */
if (subpath != RT_NULL)
break; /* not the end of path */
return &dirent[index];
}
}
}
if (!found)
break; /* not found */
}
/* not found */
return RT_NULL;
}
int dfs_romfs_read(struct dfs_fd *file, void *buf, rt_size_t count)
{
rt_size_t length;
struct romfs_dirent *dirent;
dirent = (struct romfs_dirent *)file->data;
RT_ASSERT(dirent != RT_NULL);
if (count < file->size - file->pos)
length = count;
else
length = file->size - file->pos;
if (length > 0)
memcpy(buf, &(dirent->data[file->pos]), length);
/* update file current position */
file->pos += length;
return length;
}
int dfs_romfs_lseek(struct dfs_fd *file, rt_off_t offset)
{
if (offset <= file->size)
{
file->pos = offset;
return file->pos;
}
return -DFS_STATUS_EIO;
}
int dfs_romfs_close(struct dfs_fd *file)
{
file->data = RT_NULL;
return DFS_STATUS_OK;
}
int dfs_romfs_open(struct dfs_fd *file)
{
rt_size_t size;
struct romfs_dirent *dirent;
struct romfs_dirent *root_dirent;
root_dirent = (struct romfs_dirent *)file->fs->data;
if (file->flags & (DFS_O_CREAT | DFS_O_WRONLY | DFS_O_APPEND | DFS_O_TRUNC | DFS_O_RDWR))
return -DFS_STATUS_EINVAL;
dirent = dfs_romfs_lookup(root_dirent, file->path, &size);
if (dirent == RT_NULL)
return -DFS_STATUS_ENOENT;
/* entry is a directory file type */
if (dirent->type == ROMFS_DIRENT_DIR)
{
if (!(file->flags & DFS_O_DIRECTORY))
return -DFS_STATUS_ENOENT;
}
else
{
/* entry is a file, but open it as a directory */
if (file->flags & DFS_O_DIRECTORY)
return -DFS_STATUS_ENOENT;
}
file->data = dirent;
file->size = size;
file->pos = 0;
return DFS_STATUS_OK;
}
int dfs_romfs_stat(struct dfs_filesystem *fs, const char *path, struct stat *st)
{
rt_size_t size;
struct romfs_dirent *dirent;
struct romfs_dirent *root_dirent;
root_dirent = (struct romfs_dirent *)fs->data;
dirent = dfs_romfs_lookup(root_dirent, path, &size);
if (dirent == RT_NULL)
return -DFS_STATUS_ENOENT;
st->st_dev = 0;
st->st_mode = DFS_S_IFREG | DFS_S_IRUSR | DFS_S_IRGRP | DFS_S_IROTH |
DFS_S_IWUSR | DFS_S_IWGRP | DFS_S_IWOTH;
if (dirent->type == ROMFS_DIRENT_DIR)
{
st->st_mode &= ~DFS_S_IFREG;
st->st_mode |= DFS_S_IFDIR | DFS_S_IXUSR | DFS_S_IXGRP | DFS_S_IXOTH;
}
st->st_size = dirent->size;
st->st_mtime = 0;
st->st_blksize = 512;
return DFS_STATUS_OK;
}
int dfs_romfs_getdents(struct dfs_fd *file, struct dirent *dirp, rt_uint32_t count)
{
rt_size_t index;
const char *name;
struct dirent *d;
struct romfs_dirent *dirent, *sub_dirent;
dirent = (struct romfs_dirent *)file->data;
RT_ASSERT(dirent->type == ROMFS_DIRENT_DIR);
/* enter directory */
dirent = (struct romfs_dirent *)dirent->data;
/* make integer count */
count = (count / sizeof(struct dirent));
if (count == 0)
return -DFS_STATUS_EINVAL;
index = 0;
for (index = 0; index < count && file->pos < file->size; index ++)
{
d = dirp + index;
sub_dirent = &dirent[file->pos];
name = sub_dirent->name;
/* fill dirent */
if (sub_dirent->type == ROMFS_DIRENT_DIR)
d->d_type = DFS_DT_DIR;
else
d->d_type = DFS_DT_REG;
d->d_namlen = rt_strlen(name);
d->d_reclen = (rt_uint16_t)sizeof(struct dirent);
rt_strncpy(d->d_name, name, rt_strlen(name) + 1);
/* move to next position */
++ file->pos;
}
return index * sizeof(struct dirent);
}
static const struct dfs_filesystem_operation _romfs =
{
"rom",
dfs_romfs_mount,
dfs_romfs_unmount,
RT_NULL,
RT_NULL,
dfs_romfs_open,
dfs_romfs_close,
dfs_romfs_ioctl,
dfs_romfs_read,
RT_NULL,
RT_NULL,
dfs_romfs_lseek,
dfs_romfs_getdents,
RT_NULL,
dfs_romfs_stat,
RT_NULL,
};
int dfs_romfs_init(void)
{
/* register rom file system */
dfs_register(&_romfs);
return 0;
}
/*
* File : dfs_romfs.c
* This file is part of Device File System in RT-Thread RTOS
* COPYRIGHT (C) 2004-2011, RT-Thread Development Team
*
* The license and distribution terms for this file may be
* found in the file LICENSE in this distribution or at
* http://www.rt-thread.org/license/LICENSE.
*
* Change Logs:
* Date Author Notes
*/
#include <rtthread.h>
#include <dfs.h>
#include <dfs_fs.h>
#include "dfs_romfs.h"
int dfs_romfs_mount(struct dfs_filesystem *fs, unsigned long rwflag, const void *data)
{
struct romfs_dirent *root_dirent;
if (data == RT_NULL)
return -DFS_STATUS_EIO;
root_dirent = (struct romfs_dirent *)data;
fs->data = root_dirent;
return DFS_STATUS_OK;
}
int dfs_romfs_unmount(struct dfs_filesystem *fs)
{
return DFS_STATUS_OK;
}
int dfs_romfs_ioctl(struct dfs_fd *file, int cmd, void *args)
{
return -DFS_STATUS_EIO;
}
struct romfs_dirent *dfs_romfs_lookup(struct romfs_dirent *root_dirent, const char *path, rt_size_t *size)
{
rt_size_t index, found;
const char *subpath, *subpath_end;
struct romfs_dirent *dirent;
rt_size_t dirent_size;
if (path[0] == '/' && path[1] == '\0')
{
*size = root_dirent->size;
return root_dirent;
}
/* goto root directy entries */
dirent = (struct romfs_dirent *)root_dirent->data;
dirent_size = root_dirent->size;
/* get the end position of this subpath */
subpath_end = path;
/* skip /// */
while (*subpath_end && *subpath_end == '/')
subpath_end ++;
subpath = subpath_end;
while ((*subpath_end != '/') && *subpath_end)
subpath_end ++;
while (dirent != RT_NULL)
{
found = 0;
/* search in folder */
for (index = 0; index < dirent_size; index ++)
{
if (rt_strncmp(dirent[index].name, subpath, (subpath_end - subpath)) == 0)
{
dirent_size = dirent[index].size;
/* skip /// */
while (*subpath_end && *subpath_end == '/')
subpath_end ++;
subpath = subpath_end;
while ((*subpath_end != '/') && *subpath_end)
subpath_end ++;
if (!(*subpath))
{
*size = dirent_size;
return &dirent[index];
}
if (dirent[index].type == ROMFS_DIRENT_DIR)
{
/* enter directory */
dirent = (struct romfs_dirent*)dirent[index].data;
found = 1;
break;
}
else
{
/* return file dirent */
if (subpath != RT_NULL)
break; /* not the end of path */
return &dirent[index];
}
}
}
if (!found)
break; /* not found */
}
/* not found */
return RT_NULL;
}
int dfs_romfs_read(struct dfs_fd *file, void *buf, rt_size_t count)
{
rt_size_t length;
struct romfs_dirent *dirent;
dirent = (struct romfs_dirent *)file->data;
RT_ASSERT(dirent != RT_NULL);
if (count < file->size - file->pos)
length = count;
else
length = file->size - file->pos;
if (length > 0)
memcpy(buf, &(dirent->data[file->pos]), length);
/* update file current position */
file->pos += length;
return length;
}
int dfs_romfs_lseek(struct dfs_fd *file, rt_off_t offset)
{
if (offset <= file->size)
{
file->pos = offset;
return file->pos;
}
return -DFS_STATUS_EIO;
}
int dfs_romfs_close(struct dfs_fd *file)
{
file->data = RT_NULL;
return DFS_STATUS_OK;
}
int dfs_romfs_open(struct dfs_fd *file)
{
rt_size_t size;
struct romfs_dirent *dirent;
struct romfs_dirent *root_dirent;
root_dirent = (struct romfs_dirent *)file->fs->data;
if (file->flags & (DFS_O_CREAT | DFS_O_WRONLY | DFS_O_APPEND | DFS_O_TRUNC | DFS_O_RDWR))
return -DFS_STATUS_EINVAL;
dirent = dfs_romfs_lookup(root_dirent, file->path, &size);
if (dirent == RT_NULL)
return -DFS_STATUS_ENOENT;
/* entry is a directory file type */
if (dirent->type == ROMFS_DIRENT_DIR)
{
if (!(file->flags & DFS_O_DIRECTORY))
return -DFS_STATUS_ENOENT;
}
else
{
/* entry is a file, but open it as a directory */
if (file->flags & DFS_O_DIRECTORY)
return -DFS_STATUS_ENOENT;
}
file->data = dirent;
file->size = size;
file->pos = 0;
return DFS_STATUS_OK;
}
int dfs_romfs_stat(struct dfs_filesystem *fs, const char *path, struct stat *st)
{
rt_size_t size;
struct romfs_dirent *dirent;
struct romfs_dirent *root_dirent;
root_dirent = (struct romfs_dirent *)fs->data;
dirent = dfs_romfs_lookup(root_dirent, path, &size);
if (dirent == RT_NULL)
return -DFS_STATUS_ENOENT;
st->st_dev = 0;
st->st_mode = DFS_S_IFREG | DFS_S_IRUSR | DFS_S_IRGRP | DFS_S_IROTH |
DFS_S_IWUSR | DFS_S_IWGRP | DFS_S_IWOTH;
if (dirent->type == ROMFS_DIRENT_DIR)
{
st->st_mode &= ~DFS_S_IFREG;
st->st_mode |= DFS_S_IFDIR | DFS_S_IXUSR | DFS_S_IXGRP | DFS_S_IXOTH;
}
st->st_size = dirent->size;
st->st_mtime = 0;
st->st_blksize = 512;
return DFS_STATUS_OK;
}
int dfs_romfs_getdents(struct dfs_fd *file, struct dirent *dirp, rt_uint32_t count)
{
rt_size_t index;
const char *name;
struct dirent *d;
struct romfs_dirent *dirent, *sub_dirent;
dirent = (struct romfs_dirent *)file->data;
RT_ASSERT(dirent->type == ROMFS_DIRENT_DIR);
/* enter directory */
dirent = (struct romfs_dirent *)dirent->data;
/* make integer count */
count = (count / sizeof(struct dirent));
if (count == 0)
return -DFS_STATUS_EINVAL;
index = 0;
for (index = 0; index < count && file->pos < file->size; index ++)
{
d = dirp + index;
sub_dirent = &dirent[file->pos];
name = sub_dirent->name;
/* fill dirent */
if (sub_dirent->type == ROMFS_DIRENT_DIR)
d->d_type = DFS_DT_DIR;
else
d->d_type = DFS_DT_REG;
d->d_namlen = rt_strlen(name);
d->d_reclen = (rt_uint16_t)sizeof(struct dirent);
rt_strncpy(d->d_name, name, rt_strlen(name) + 1);
/* move to next position */
++ file->pos;
}
return index * sizeof(struct dirent);
}
static const struct dfs_filesystem_operation _romfs =
{
"rom",
DFS_FS_FLAG_DEFAULT,
dfs_romfs_mount,
dfs_romfs_unmount,
RT_NULL,
RT_NULL,
dfs_romfs_open,
dfs_romfs_close,
dfs_romfs_ioctl,
dfs_romfs_read,
RT_NULL,
RT_NULL,
dfs_romfs_lseek,
dfs_romfs_getdents,
RT_NULL,
dfs_romfs_stat,
RT_NULL,
};
int dfs_romfs_init(void)
{
/* register rom file system */
dfs_register(&_romfs);
return 0;
}

1
components/dfs/filesystems/skeleton/skeleton.c
View File

@ -55,6 +55,7 @@ int dfs_skt_getdents(struct dfs_fd* file, struct dirent* dirp, rt_uint32_t count
static const struct dfs_filesystem_operation _skt_fs =
{
"skt",
DFS_FS_FLAG_DEFAULT,
dfs_skt_mount,
dfs_skt_unmount,
RT_NULL,

699
components/dfs/filesystems/uffs/dfs_uffs.c
View File

@ -1,354 +1,355 @@
#include <rtthread.h>
#include <dfs_def.h>
#include <dfs_fs.h>
#include "uffs/uffs_fs.h"
#include "uffs/uffs_mtb.h"
#include "uffs/uffs_fd.h"
#include "uffs_ext.h"
/* mount and unmount file system */
int dfs_uffs_mount(struct dfs_filesystem* fs, unsigned long rwflag, const void* data)
{
return ((uffs_InitMountTable() == U_SUCC) ? 0 : -1);
}
int dfs_uffs_unmount(struct dfs_filesystem* fs)
{
uffs_ReleaseObjectBuf();
return uffs_ReleaseMountTable();
}
int dfs_uffs_mkfs(const char* device_name)
{
return uffs_format(NULL);
}
int dfs_uffs_statfs(struct dfs_filesystem* fs, struct statfs *buf)
{
int ret = U_SUCC;
uffs_MountTable *entry = (uffs_MountTable*)(fs->dev_id->user_data);
struct uffs_StorageAttrSt *attr = entry->dev->attr;
#include <rtthread.h>
#include <dfs_def.h>
#include <dfs_fs.h>
#include "uffs/uffs_fs.h"
#include "uffs/uffs_mtb.h"
#include "uffs/uffs_fd.h"
#include "uffs_ext.h"
/* mount and unmount file system */
int dfs_uffs_mount(struct dfs_filesystem* fs, unsigned long rwflag, const void* data)
{
return ((uffs_InitMountTable() == U_SUCC) ? 0 : -1);
}
int dfs_uffs_unmount(struct dfs_filesystem* fs)
{
uffs_ReleaseObjectBuf();
return uffs_ReleaseMountTable();
}
int dfs_uffs_mkfs(const char* device_name)
{
return uffs_format(NULL);
}
int dfs_uffs_statfs(struct dfs_filesystem* fs, struct statfs *buf)
{
int ret = U_SUCC;
uffs_MountTable *entry = (uffs_MountTable*)(fs->dev_id->user_data);
struct uffs_StorageAttrSt *attr = entry->dev->attr;
buf->f_bsize = attr->page_data_size * attr->pages_per_block;
buf->f_blocks = attr->total_blocks;
buf->f_bfree = 0;
return ret;
}
int dfs_uffs_open(struct dfs_fd* fd)
{
if (fd->flags & DFS_O_DIRECTORY)
{ /* directory */
uffs_DIR* dirp;
int oflag = UO_DIR;
if (fd->flags & DFS_O_CREAT) oflag |= UO_CREATE;
if (fd->flags & DFS_O_RDONLY) oflag |= UO_RDONLY;
if (fd->flags & DFS_O_WRONLY) oflag |= UO_WRONLY;
if (oflag & UO_CREATE)
{ /* create directory right now */
uffs_Object* fp = uffs_GetObject();
if(fp == NULL)
{
uffs_set_error(-UEMFILE);
return U_FAIL;
}
if(uffs_OpenObject(fp, fd->path, oflag) != U_SUCC)
{
return U_FAIL;
}
/* release object hander */
uffs_PutObject(fp);
}
/* use directory handler */
dirp = uffs_opendir(fd->path);
if(dirp == NULL)
{
uffs_set_error(-UEMFILE);
return U_FAIL;
}
fd->data = dirp;
return U_SUCC;
}
else
{/* file */
uffs_Object *fp;
int mode = UO_RDONLY;
if (fd->flags & DFS_O_WRONLY) mode |= UO_WRONLY;
if ((fd->flags & DFS_O_ACCMODE) & DFS_O_RDWR) mode |= UO_WRONLY;
/* Opens the file, if it is existing. If not, a new file is created. */
if (fd->flags & DFS_O_CREAT) mode |= UO_CREATE;
/* Creates a new file. If the file is existing, it is truncated and overwritten. */
if (fd->flags & DFS_O_TRUNC) mode |= UO_TRUNC;
/* Creates a new file. The function fails if the file is already existing. */
if (fd->flags & DFS_O_EXCL) mode |= UO_EXCL;
/* get an object hander */
fp = uffs_GetObject();
if(fp == NULL)
{
uffs_set_error(-UEMFILE);
return U_FAIL;
}
if(uffs_OpenObject(fp, fd->path, mode) == U_SUCC)
{
struct uffs_stat stat_buf;
uffs_stat(fd->path, &stat_buf);
fd->pos = fp->pos;
fd->size = stat_buf.st_size;
fd->data = fp;
if(fd->flags & DFS_O_APPEND)
{
fd->pos = uffs_SeekObject(fp, 0, USEEK_END);
}
return U_SUCC;
}
else
{
/* open failed, return */
uffs_set_error(-uffs_GetObjectErr(fp));
/* release object hander */
uffs_PutObject(fp);
return U_FAIL;
}
}
}
int dfs_uffs_close(struct dfs_fd* fd)
{
int ret=U_SUCC;
if (fd->type == FT_DIRECTORY)
{
uffs_DIR* dirp;
dirp = (uffs_DIR*)(fd->data);
RT_ASSERT(dirp != RT_NULL);
ret = uffs_closedir(dirp);
}
else if (fd->type == FT_REGULAR)
{
uffs_Object* fp = (uffs_Object*)(fd->data);
RT_ASSERT(fd != RT_NULL);
ret = uffs_CloseObject(fp);
/* release object hander */
uffs_PutObject(fp);
}
return ret;
}
int dfs_uffs_ioctl(struct dfs_fd* fd, int cmd, void *args)
{
return -DFS_STATUS_ENOSYS;
}
int dfs_uffs_read(struct dfs_fd* fd, void* buf, rt_size_t count)
{
uffs_Object* fp;
uffs_DIR* dirp;
if (fd->type == FT_DIRECTORY)
{
dirp = (uffs_DIR*)(fd->data);
fp = dirp->obj;
}
else
{
fp = (uffs_Object*)(fd->data);
}
RT_ASSERT(fd != RT_NULL);
/* update position */
fd->pos = fp->pos;
return uffs_ReadObject(fp, buf, count);
}
int dfs_uffs_write(struct dfs_fd* fd, const void* buf, rt_size_t count)
{
uffs_Object* fp;
u32 byte_write;
struct uffs_stat stat_buf;
rt_kprintf("count=%d\n",count);
if(fd->type == FT_DIRECTORY)
{
return -DFS_STATUS_EISDIR;
}
fp = (uffs_Object*)(fd->data);
RT_ASSERT(fp != RT_NULL);
byte_write = uffs_WriteObject(fp, buf, count);
/* update position and file size */
fd->pos = fp->pos;
uffs_stat(fp->name, &stat_buf);
fd->size = stat_buf.st_size;
return byte_write;
}
int dfs_uffs_flush(struct dfs_fd* fd)
{
uffs_Object* fp;
fp = (uffs_Object*)(fd->data);
RT_ASSERT(fp != RT_NULL);
return uffs_FlushObject(fp);
}
int dfs_uffs_lseek(struct dfs_fd* fd, rt_off_t offset)
{
uffs_Object* fp;
fp = (uffs_Object*)(fd->data);
RT_ASSERT(fp != RT_NULL);
return uffs_SeekObject(fp, offset, USEEK_SET);
}
int dfs_uffs_getdents(struct dfs_fd* fd, struct dirent* dir, rt_uint32_t count)
{
uffs_DIR* dirp;
struct uffs_dirent *ent;
rt_uint32_t index;
struct dirent* d;
if(fd->type != FT_DIRECTORY)
{
return -DFS_STATUS_EISDIR;
}
dirp = (uffs_DIR*)(fd->data);
RT_ASSERT(dirp != RT_NULL);
/* make integer count */
count = (count / sizeof(struct dirent)) * sizeof(struct dirent);
if ( count == 0 ) return -DFS_STATUS_EINVAL;
index = 0;
while (1)
{
d = dir + index;
ent = uffs_readdir(dirp);
if(ent == RT_NULL)break;
d->d_type = DFS_DT_DIR;
d->d_namlen = ent->d_namelen;
d->d_reclen = (rt_uint16_t)sizeof(struct dirent);
rt_strncpy(d->d_name, ent->d_name, rt_strlen(ent->d_name) + 1);
index ++;
if ( index * sizeof(struct dirent) >= count )
break;
}
return index * sizeof(struct dirent);
}
//Delete a File or Directory
int dfs_uffs_unlink(struct dfs_filesystem* fs, const char* path)
{
int ret;
int err = 0;
ret = uffs_DeleteObject(path, &err);
uffs_set_error(-err);
return ret;
}
int dfs_uffs_stat(struct dfs_filesystem* fs, const char* path, struct stat* st)
{
int ret=U_SUCC;
struct uffs_stat stat_buf;
ret = uffs_stat(path, &stat_buf);
if (ret == U_SUCC)
{
rt_uint32_t mode=0;
st->st_dev = 0;
if(stat_buf.st_mode & US_IFREG) mode |= DFS_S_IFREG;
if(stat_buf.st_mode & US_IFDIR) mode |= DFS_S_IFDIR;
if(stat_buf.st_mode & US_IRWXU) mode |= DFS_S_IRWXU;
if(stat_buf.st_mode & US_IRUSR) mode |= DFS_S_IRUSR;
if(stat_buf.st_mode & US_IWUSR) mode |= DFS_S_IWUSR;
if(stat_buf.st_mode & US_IXUSR) mode |= DFS_S_IXUSR;
if(stat_buf.st_mode & US_IRWXG) mode |= DFS_S_IRWXG;
if(stat_buf.st_mode & US_IRGRP) mode |= DFS_S_IRGRP;
if(stat_buf.st_mode & US_IWGRP) mode |= DFS_S_IWGRP;
if(stat_buf.st_mode & US_IXGRP) mode |= DFS_S_IXGRP;
if(stat_buf.st_mode & US_IRWXO) mode |= DFS_S_IRWXO;
if(stat_buf.st_mode & US_IROTH) mode |= DFS_S_IROTH;
if(stat_buf.st_mode & US_IWOTH) mode |= DFS_S_IWOTH;
if(stat_buf.st_mode & US_IXOTH) mode |= DFS_S_IXOTH;
buf->f_bfree = 0;
return ret;
}
int dfs_uffs_open(struct dfs_fd* fd)
{
if (fd->flags & DFS_O_DIRECTORY)
{ /* directory */
uffs_DIR* dirp;
int oflag = UO_DIR;
if (fd->flags & DFS_O_CREAT) oflag |= UO_CREATE;
if (fd->flags & DFS_O_RDONLY) oflag |= UO_RDONLY;
if (fd->flags & DFS_O_WRONLY) oflag |= UO_WRONLY;
if (oflag & UO_CREATE)
{ /* create directory right now */
uffs_Object* fp = uffs_GetObject();
if(fp == NULL)
{
uffs_set_error(-UEMFILE);
return U_FAIL;
}
if(uffs_OpenObject(fp, fd->path, oflag) != U_SUCC)
{
return U_FAIL;
}
/* release object hander */
uffs_PutObject(fp);
}
/* use directory handler */
dirp = uffs_opendir(fd->path);
if(dirp == NULL)
{
uffs_set_error(-UEMFILE);
return U_FAIL;
}
fd->data = dirp;
return U_SUCC;
}
else
{/* file */
uffs_Object *fp;
int mode = UO_RDONLY;
if (fd->flags & DFS_O_WRONLY) mode |= UO_WRONLY;
if ((fd->flags & DFS_O_ACCMODE) & DFS_O_RDWR) mode |= UO_WRONLY;
/* Opens the file, if it is existing. If not, a new file is created. */
if (fd->flags & DFS_O_CREAT) mode |= UO_CREATE;
/* Creates a new file. If the file is existing, it is truncated and overwritten. */
if (fd->flags & DFS_O_TRUNC) mode |= UO_TRUNC;
/* Creates a new file. The function fails if the file is already existing. */
if (fd->flags & DFS_O_EXCL) mode |= UO_EXCL;
/* get an object hander */
fp = uffs_GetObject();
if(fp == NULL)
{
uffs_set_error(-UEMFILE);
return U_FAIL;
}
if(uffs_OpenObject(fp, fd->path, mode) == U_SUCC)
{
struct uffs_stat stat_buf;
uffs_stat(fd->path, &stat_buf);
fd->pos = fp->pos;
fd->size = stat_buf.st_size;
fd->data = fp;
if(fd->flags & DFS_O_APPEND)
{
fd->pos = uffs_SeekObject(fp, 0, USEEK_END);
}
return U_SUCC;
}
else
{
/* open failed, return */
uffs_set_error(-uffs_GetObjectErr(fp));
/* release object hander */
uffs_PutObject(fp);
return U_FAIL;
}
}
}
int dfs_uffs_close(struct dfs_fd* fd)
{
int ret=U_SUCC;
if (fd->type == FT_DIRECTORY)
{
uffs_DIR* dirp;
dirp = (uffs_DIR*)(fd->data);
RT_ASSERT(dirp != RT_NULL);
ret = uffs_closedir(dirp);
}
else if (fd->type == FT_REGULAR)
{
uffs_Object* fp = (uffs_Object*)(fd->data);
RT_ASSERT(fd != RT_NULL);
ret = uffs_CloseObject(fp);
/* release object hander */
uffs_PutObject(fp);
}
return ret;
}
int dfs_uffs_ioctl(struct dfs_fd* fd, int cmd, void *args)
{
return -DFS_STATUS_ENOSYS;
}
int dfs_uffs_read(struct dfs_fd* fd, void* buf, rt_size_t count)
{
uffs_Object* fp;
uffs_DIR* dirp;
if (fd->type == FT_DIRECTORY)
{
dirp = (uffs_DIR*)(fd->data);
fp = dirp->obj;
}
else
{
fp = (uffs_Object*)(fd->data);
}
RT_ASSERT(fd != RT_NULL);
/* update position */
fd->pos = fp->pos;
return uffs_ReadObject(fp, buf, count);
}
int dfs_uffs_write(struct dfs_fd* fd, const void* buf, rt_size_t count)
{
uffs_Object* fp;
u32 byte_write;
struct uffs_stat stat_buf;
rt_kprintf("count=%d\n",count);
if(fd->type == FT_DIRECTORY)
{
return -DFS_STATUS_EISDIR;
}
fp = (uffs_Object*)(fd->data);
RT_ASSERT(fp != RT_NULL);
byte_write = uffs_WriteObject(fp, buf, count);
/* update position and file size */
fd->pos = fp->pos;
uffs_stat(fp->name, &stat_buf);
fd->size = stat_buf.st_size;
return byte_write;
}
int dfs_uffs_flush(struct dfs_fd* fd)
{
uffs_Object* fp;
fp = (uffs_Object*)(fd->data);
RT_ASSERT(fp != RT_NULL);
return uffs_FlushObject(fp);
}
int dfs_uffs_lseek(struct dfs_fd* fd, rt_off_t offset)
{
uffs_Object* fp;
fp = (uffs_Object*)(fd->data);
RT_ASSERT(fp != RT_NULL);
return uffs_SeekObject(fp, offset, USEEK_SET);
}
int dfs_uffs_getdents(struct dfs_fd* fd, struct dirent* dir, rt_uint32_t count)
{
uffs_DIR* dirp;
struct uffs_dirent *ent;
rt_uint32_t index;
struct dirent* d;
if(fd->type != FT_DIRECTORY)
{
return -DFS_STATUS_EISDIR;
}
dirp = (uffs_DIR*)(fd->data);
RT_ASSERT(dirp != RT_NULL);
/* make integer count */
count = (count / sizeof(struct dirent)) * sizeof(struct dirent);
if ( count == 0 ) return -DFS_STATUS_EINVAL;
index = 0;
while (1)
{
d = dir + index;
ent = uffs_readdir(dirp);
if(ent == RT_NULL)break;
d->d_type = DFS_DT_DIR;
d->d_namlen = ent->d_namelen;
d->d_reclen = (rt_uint16_t)sizeof(struct dirent);
rt_strncpy(d->d_name, ent->d_name, rt_strlen(ent->d_name) + 1);
index ++;
if ( index * sizeof(struct dirent) >= count )
break;
}
return index * sizeof(struct dirent);
}
//Delete a File or Directory
int dfs_uffs_unlink(struct dfs_filesystem* fs, const char* path)
{
int ret;
int err = 0;
ret = uffs_DeleteObject(path, &err);
uffs_set_error(-err);
return ret;
}
int dfs_uffs_stat(struct dfs_filesystem* fs, const char* path, struct stat* st)
{
int ret=U_SUCC;
struct uffs_stat stat_buf;
ret = uffs_stat(path, &stat_buf);
if (ret == U_SUCC)
{
rt_uint32_t mode=0;
st->st_dev = 0;
if(stat_buf.st_mode & US_IFREG) mode |= DFS_S_IFREG;
if(stat_buf.st_mode & US_IFDIR) mode |= DFS_S_IFDIR;
if(stat_buf.st_mode & US_IRWXU) mode |= DFS_S_IRWXU;
if(stat_buf.st_mode & US_IRUSR) mode |= DFS_S_IRUSR;
if(stat_buf.st_mode & US_IWUSR) mode |= DFS_S_IWUSR;
if(stat_buf.st_mode & US_IXUSR) mode |= DFS_S_IXUSR;
if(stat_buf.st_mode & US_IRWXG) mode |= DFS_S_IRWXG;
if(stat_buf.st_mode & US_IRGRP) mode |= DFS_S_IRGRP;
if(stat_buf.st_mode & US_IWGRP) mode |= DFS_S_IWGRP;
if(stat_buf.st_mode & US_IXGRP) mode |= DFS_S_IXGRP;
if(stat_buf.st_mode & US_IRWXO) mode |= DFS_S_IRWXO;
if(stat_buf.st_mode & US_IROTH) mode |= DFS_S_IROTH;
if(stat_buf.st_mode & US_IWOTH) mode |= DFS_S_IWOTH;
if(stat_buf.st_mode & US_IXOTH) mode |= DFS_S_IXOTH;
st->st_mode = mode;
st->st_size = stat_buf.st_size;
st->st_mtime= stat_buf.st_mtime;
st->st_blksize= stat_buf.st_blksize;
return U_SUCC;
}
return U_FAIL;
}
int dfs_uffs_rename(struct dfs_filesystem* fs, const char* oldpath, const char* newpath)
{
int ret;
int err = 0;
ret = uffs_RenameObject(oldpath, newpath, &err);
uffs_set_error(-err);
return ret;
}
struct dfs_filesystem_operation _uffs =
{
"uffs",
dfs_uffs_mount,
dfs_uffs_unmount,
dfs_uffs_mkfs,
dfs_uffs_statfs,
dfs_uffs_open,
dfs_uffs_close,
dfs_uffs_ioctl,
dfs_uffs_read,
dfs_uffs_write,
dfs_uffs_flush,
dfs_uffs_lseek,
dfs_uffs_getdents,
dfs_uffs_unlink,
dfs_uffs_stat,
dfs_uffs_rename,
};
int dfs_uffs_init(void)
{
/* register UFFS file system */
return dfs_register(&_uffs);
}
st->st_blksize= stat_buf.st_blksize;
return U_SUCC;
}
return U_FAIL;
}
int dfs_uffs_rename(struct dfs_filesystem* fs, const char* oldpath, const char* newpath)
{
int ret;
int err = 0;
ret = uffs_RenameObject(oldpath, newpath, &err);
uffs_set_error(-err);
return ret;
}
struct dfs_filesystem_operation _uffs =
{
"uffs",
DFS_FS_FLAG_DEFAULT,
dfs_uffs_mount,
dfs_uffs_unmount,
dfs_uffs_mkfs,
dfs_uffs_statfs,
dfs_uffs_open,
dfs_uffs_close,
dfs_uffs_ioctl,
dfs_uffs_read,
dfs_uffs_write,
dfs_uffs_flush,
dfs_uffs_lseek,
dfs_uffs_getdents,
dfs_uffs_unlink,
dfs_uffs_stat,
dfs_uffs_rename,
};
int dfs_uffs_init(void)
{
/* register UFFS file system */
return dfs_register(&_uffs);
}

4
components/dfs/include/dfs_fs.h
View File

@ -17,6 +17,9 @@
#include <dfs_def.h>
#define DFS_FS_FLAG_DEFAULT 0x00 /* default flag */
#define DFS_FS_FLAG_FULLPATH 0x01 /* set full path to underlaying file system */
/* Pre-declaration */
struct dfs_filesystem;
struct dfs_fd;
@ -25,6 +28,7 @@ struct dfs_fd;
struct dfs_filesystem_operation
{
char *name;
rt_uint32_t flags; /* flags for file system operations */
/* mount and unmount file system */
int (*mount) (struct dfs_filesystem *fs, unsigned long rwflag, const void *data);

36
components/dfs/src/dfs_file.c
View File

@ -66,13 +66,20 @@ int dfs_file_open(struct dfs_fd *fd, const char *path, int flags)
fd->size = 0;
fd->pos = 0;
if (dfs_subdir(fs->path, fullpath) == RT_NULL)
fd->path = rt_strdup("/");
if (!(fs->ops->flags & DFS_FS_FLAG_FULLPATH))
{
if (dfs_subdir(fs->path, fullpath) == RT_NULL)
fd->path = rt_strdup("/");
else
fd->path = rt_strdup(dfs_subdir(fs->path, fullpath));
rt_free(fullpath);
dfs_log(DFS_DEBUG_INFO, ("Actual file path: %s\n", fd->path));
}
else
fd->path = rt_strdup(dfs_subdir(fs->path, fullpath));
rt_free(fullpath);
dfs_log(DFS_DEBUG_INFO, ("Actual file path: %s\n", fd->path));
{
fd->path = fullpath;
}
/* specific file system open routine */
if (fs->ops->open == RT_NULL)
{
@ -241,10 +248,15 @@ int dfs_file_unlink(const char *path)
if (fs->ops->unlink != RT_NULL)
{
if (dfs_subdir(fs->path, fullpath) == RT_NULL)
result = fs->ops->unlink(fs, "/");
if (!(fs->ops->flags & DFS_FS_FLAG_FULLPATH))
{
if (dfs_subdir(fs->path, fullpath) == RT_NULL)
result = fs->ops->unlink(fs, "/");
else
result = fs->ops->unlink(fs, dfs_subdir(fs->path, fullpath));
}
else
result = fs->ops->unlink(fs, dfs_subdir(fs->path, fullpath));
result = fs->ops->unlink(fs, fullpath);
}
else result = -DFS_STATUS_ENOSYS;
@ -380,7 +392,11 @@ int dfs_file_stat(const char *path, struct stat *buf)
}
/* get the real file path and get file stat */
result = fs->ops->stat(fs, dfs_subdir(fs->path, fullpath), buf);
if (fs->ops->flags & DFS_FS_FLAG_FULLPATH)
result = fs->ops->stat(fs, fullpath, buf);
else
result = fs->ops->stat(fs, dfs_subdir(fs->path, fullpath), buf);
}
rt_free(fullpath);