|
|
@@ -19,6 +19,7 @@
|
|
|
/**
|
|
|
* @addtogroup FileApi
|
|
|
*/
|
|
|
+
|
|
|
/*@{*/
|
|
|
|
|
|
/**
|
|
|
@@ -32,84 +33,85 @@
|
|
|
*/
|
|
|
int dfs_file_open(struct dfs_fd *fd, const char *path, int flags)
|
|
|
{
|
|
|
- struct dfs_filesystem *fs;
|
|
|
- char *fullpath;
|
|
|
- int result;
|
|
|
-
|
|
|
- /* parameter check */
|
|
|
- if (fd == RT_NULL)
|
|
|
- return -DFS_STATUS_EINVAL;
|
|
|
-
|
|
|
- /* make sure we have an absolute path */
|
|
|
- fullpath = dfs_normalize_path(RT_NULL, path);
|
|
|
- if (fullpath == RT_NULL)
|
|
|
- {
|
|
|
- return -1;
|
|
|
- }
|
|
|
-
|
|
|
- dfs_log(DFS_DEBUG_INFO, ("open file:%s", fullpath));
|
|
|
-
|
|
|
- /* find filesystem */
|
|
|
- fs = dfs_filesystem_lookup(fullpath);
|
|
|
- if (fs == RT_NULL)
|
|
|
- {
|
|
|
- rt_free(fullpath); /* release path */
|
|
|
- return -DFS_STATUS_ENOENT;
|
|
|
- }
|
|
|
-
|
|
|
- dfs_log(DFS_DEBUG_INFO, ("open in filesystem:%s", fs->ops->name));
|
|
|
- fd->fs = fs;
|
|
|
-
|
|
|
- /* initialize the fd item */
|
|
|
- fd->type = FT_REGULAR;
|
|
|
- fd->flags = flags;
|
|
|
- fd->size = 0;
|
|
|
- fd->pos = 0;
|
|
|
-
|
|
|
- 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 = fullpath;
|
|
|
- }
|
|
|
-
|
|
|
- /* specific file system open routine */
|
|
|
- if (fs->ops->open == RT_NULL)
|
|
|
- {
|
|
|
- /* clear fd */
|
|
|
- rt_free(fd->path);
|
|
|
- rt_memset(fd, 0, sizeof(*fd));
|
|
|
-
|
|
|
- return -DFS_STATUS_ENOSYS;
|
|
|
- }
|
|
|
-
|
|
|
- if ((result = fs->ops->open(fd)) < 0)
|
|
|
- {
|
|
|
- /* clear fd */
|
|
|
- rt_free(fd->path);
|
|
|
- rt_memset(fd, 0, sizeof(*fd));
|
|
|
-
|
|
|
- dfs_log(DFS_DEBUG_INFO, ("open failed"));
|
|
|
-
|
|
|
- return result;
|
|
|
- }
|
|
|
-
|
|
|
- fd->flags |= DFS_F_OPEN;
|
|
|
- if (flags & DFS_O_DIRECTORY)
|
|
|
- {
|
|
|
- fd->type = FT_DIRECTORY;
|
|
|
- fd->flags |= DFS_F_DIRECTORY;
|
|
|
- }
|
|
|
-
|
|
|
- dfs_log(DFS_DEBUG_INFO, ("open successful"));
|
|
|
- return 0;
|
|
|
+ struct dfs_filesystem *fs;
|
|
|
+ char *fullpath;
|
|
|
+ int result;
|
|
|
+
|
|
|
+ /* parameter check */
|
|
|
+ if (fd == RT_NULL)
|
|
|
+ return -DFS_STATUS_EINVAL;
|
|
|
+
|
|
|
+ /* make sure we have an absolute path */
|
|
|
+ fullpath = dfs_normalize_path(RT_NULL, path);
|
|
|
+ if (fullpath == RT_NULL)
|
|
|
+ {
|
|
|
+ return -1;
|
|
|
+ }
|
|
|
+
|
|
|
+ dfs_log(DFS_DEBUG_INFO, ("open file:%s", fullpath));
|
|
|
+
|
|
|
+ /* find filesystem */
|
|
|
+ fs = dfs_filesystem_lookup(fullpath);
|
|
|
+ if (fs == RT_NULL)
|
|
|
+ {
|
|
|
+ rt_free(fullpath); /* release path */
|
|
|
+
|
|
|
+ return -DFS_STATUS_ENOENT;
|
|
|
+ }
|
|
|
+
|
|
|
+ dfs_log(DFS_DEBUG_INFO, ("open in filesystem:%s", fs->ops->name));
|
|
|
+ fd->fs = fs;
|
|
|
+
|
|
|
+ /* initialize the fd item */
|
|
|
+ fd->type = FT_REGULAR;
|
|
|
+ fd->flags = flags;
|
|
|
+ fd->size = 0;
|
|
|
+ fd->pos = 0;
|
|
|
+
|
|
|
+ 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 = fullpath;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* specific file system open routine */
|
|
|
+ if (fs->ops->open == RT_NULL)
|
|
|
+ {
|
|
|
+ /* clear fd */
|
|
|
+ rt_free(fd->path);
|
|
|
+ rt_memset(fd, 0, sizeof(*fd));
|
|
|
+
|
|
|
+ return -DFS_STATUS_ENOSYS;
|
|
|
+ }
|
|
|
+
|
|
|
+ if ((result = fs->ops->open(fd)) < 0)
|
|
|
+ {
|
|
|
+ /* clear fd */
|
|
|
+ rt_free(fd->path);
|
|
|
+ rt_memset(fd, 0, sizeof(*fd));
|
|
|
+
|
|
|
+ dfs_log(DFS_DEBUG_INFO, ("open failed"));
|
|
|
+
|
|
|
+ return result;
|
|
|
+ }
|
|
|
+
|
|
|
+ fd->flags |= DFS_F_OPEN;
|
|
|
+ if (flags & DFS_O_DIRECTORY)
|
|
|
+ {
|
|
|
+ fd->type = FT_DIRECTORY;
|
|
|
+ fd->flags |= DFS_F_DIRECTORY;
|
|
|
+ }
|
|
|
+
|
|
|
+ dfs_log(DFS_DEBUG_INFO, ("open successful"));
|
|
|
+ return 0;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
@@ -121,19 +123,19 @@ int dfs_file_open(struct dfs_fd *fd, const char *path, int flags)
|
|
|
*/
|
|
|
int dfs_file_close(struct dfs_fd *fd)
|
|
|
{
|
|
|
- int result = 0;
|
|
|
+ int result = 0;
|
|
|
|
|
|
- if (fd != RT_NULL && fd->fs->ops->close != RT_NULL)
|
|
|
- result = fd->fs->ops->close(fd);
|
|
|
+ if (fd != RT_NULL && fd->fs->ops->close != RT_NULL)
|
|
|
+ result = fd->fs->ops->close(fd);
|
|
|
|
|
|
- /* close fd error, return */
|
|
|
- if (result < 0)
|
|
|
- return result;
|
|
|
+ /* close fd error, return */
|
|
|
+ if (result < 0)
|
|
|
+ return result;
|
|
|
|
|
|
- rt_free(fd->path);
|
|
|
- rt_memset(fd, 0, sizeof(struct dfs_fd));
|
|
|
+ rt_free(fd->path);
|
|
|
+ rt_memset(fd, 0, sizeof(struct dfs_fd));
|
|
|
|
|
|
- return result;
|
|
|
+ return result;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
@@ -147,20 +149,21 @@ int dfs_file_close(struct dfs_fd *fd)
|
|
|
*/
|
|
|
int dfs_file_ioctl(struct dfs_fd *fd, int cmd, void *args)
|
|
|
{
|
|
|
- struct dfs_filesystem *fs;
|
|
|
+ struct dfs_filesystem *fs;
|
|
|
|
|
|
- if (fd == RT_NULL || fd->type != FT_REGULAR)
|
|
|
- return -DFS_STATUS_EINVAL;
|
|
|
+ if (fd == RT_NULL || fd->type != FT_REGULAR)
|
|
|
+ return -DFS_STATUS_EINVAL;
|
|
|
|
|
|
- fs = fd->fs;
|
|
|
- if (fs->ops->ioctl != RT_NULL)
|
|
|
- return fs->ops->ioctl(fd, cmd, args);
|
|
|
+ fs = fd->fs;
|
|
|
+ if (fs->ops->ioctl != RT_NULL)
|
|
|
+ return fs->ops->ioctl(fd, cmd, args);
|
|
|
|
|
|
- return -DFS_STATUS_ENOSYS;
|
|
|
+ return -DFS_STATUS_ENOSYS;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
- * this function will read specified length data from a file descriptor to a buffer.
|
|
|
+ * this function will read specified length data from a file descriptor to a
|
|
|
+ * buffer.
|
|
|
*
|
|
|
* @param fd the file descriptor.
|
|
|
* @param buf the buffer to save the read data.
|
|
|
@@ -170,20 +173,20 @@ int dfs_file_ioctl(struct dfs_fd *fd, int cmd, void *args)
|
|
|
*/
|
|
|
int dfs_file_read(struct dfs_fd *fd, void *buf, rt_size_t len)
|
|
|
{
|
|
|
- struct dfs_filesystem *fs;
|
|
|
- int result = 0;
|
|
|
+ struct dfs_filesystem *fs;
|
|
|
+ int result = 0;
|
|
|
|
|
|
- if (fd == RT_NULL)
|
|
|
- return -DFS_STATUS_EINVAL;
|
|
|
+ if (fd == RT_NULL)
|
|
|
+ return -DFS_STATUS_EINVAL;
|
|
|
|
|
|
- fs = (struct dfs_filesystem *)fd->fs;
|
|
|
- if (fs->ops->read == RT_NULL)
|
|
|
- return -DFS_STATUS_ENOSYS;
|
|
|
+ fs = (struct dfs_filesystem *)fd->fs;
|
|
|
+ if (fs->ops->read == RT_NULL)
|
|
|
+ return -DFS_STATUS_ENOSYS;
|
|
|
|
|
|
- if ((result = fs->ops->read(fd, buf, len)) < 0)
|
|
|
- fd->flags |= DFS_F_EOF;
|
|
|
+ if ((result = fs->ops->read(fd, buf, len)) < 0)
|
|
|
+ fd->flags |= DFS_F_EOF;
|
|
|
|
|
|
- return result;
|
|
|
+ return result;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
@@ -197,17 +200,17 @@ int dfs_file_read(struct dfs_fd *fd, void *buf, rt_size_t len)
|
|
|
*/
|
|
|
int dfs_file_getdents(struct dfs_fd *fd, struct dirent *dirp, rt_size_t nbytes)
|
|
|
{
|
|
|
- struct dfs_filesystem *fs;
|
|
|
+ struct dfs_filesystem *fs;
|
|
|
|
|
|
- /* parameter check */
|
|
|
- if (fd == RT_NULL || fd->type != FT_DIRECTORY)
|
|
|
- return -DFS_STATUS_EINVAL;
|
|
|
+ /* parameter check */
|
|
|
+ if (fd == RT_NULL || fd->type != FT_DIRECTORY)
|
|
|
+ return -DFS_STATUS_EINVAL;
|
|
|
|
|
|
- fs = (struct dfs_filesystem *)fd->fs;
|
|
|
- if (fs->ops->getdents != RT_NULL)
|
|
|
- return fs->ops->getdents(fd, dirp, nbytes);
|
|
|
+ fs = (struct dfs_filesystem *)fd->fs;
|
|
|
+ if (fs->ops->getdents != RT_NULL)
|
|
|
+ return fs->ops->getdents(fd, dirp, nbytes);
|
|
|
|
|
|
- return -DFS_STATUS_ENOSYS;
|
|
|
+ return -DFS_STATUS_ENOSYS;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
@@ -219,50 +222,50 @@ int dfs_file_getdents(struct dfs_fd *fd, struct dirent *dirp, rt_size_t nbytes)
|
|
|
*/
|
|
|
int dfs_file_unlink(const char *path)
|
|
|
{
|
|
|
- int result;
|
|
|
- char *fullpath;
|
|
|
- struct dfs_filesystem *fs;
|
|
|
-
|
|
|
- result = DFS_STATUS_OK;
|
|
|
-
|
|
|
- /* Make sure we have an absolute path */
|
|
|
- fullpath = dfs_normalize_path(RT_NULL, path);
|
|
|
- if (fullpath == RT_NULL)
|
|
|
- {
|
|
|
- return -DFS_STATUS_EINVAL;
|
|
|
- }
|
|
|
-
|
|
|
- /* get filesystem */
|
|
|
- if ((fs = dfs_filesystem_lookup(fullpath)) == RT_NULL)
|
|
|
- {
|
|
|
- result = -DFS_STATUS_ENOENT;
|
|
|
- goto __exit;
|
|
|
- }
|
|
|
-
|
|
|
- /* Check whether file is already open */
|
|
|
- if (fd_is_open(fullpath) == 0)
|
|
|
- {
|
|
|
- result = -DFS_STATUS_EBUSY;
|
|
|
- goto __exit;
|
|
|
- }
|
|
|
-
|
|
|
- if (fs->ops->unlink != RT_NULL)
|
|
|
- {
|
|
|
- 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, fullpath);
|
|
|
- }
|
|
|
- else result = -DFS_STATUS_ENOSYS;
|
|
|
+ int result;
|
|
|
+ char *fullpath;
|
|
|
+ struct dfs_filesystem *fs;
|
|
|
+
|
|
|
+ result = DFS_STATUS_OK;
|
|
|
+
|
|
|
+ /* Make sure we have an absolute path */
|
|
|
+ fullpath = dfs_normalize_path(RT_NULL, path);
|
|
|
+ if (fullpath == RT_NULL)
|
|
|
+ {
|
|
|
+ return -DFS_STATUS_EINVAL;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* get filesystem */
|
|
|
+ if ((fs = dfs_filesystem_lookup(fullpath)) == RT_NULL)
|
|
|
+ {
|
|
|
+ result = -DFS_STATUS_ENOENT;
|
|
|
+ goto __exit;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* Check whether file is already open */
|
|
|
+ if (fd_is_open(fullpath) == 0)
|
|
|
+ {
|
|
|
+ result = -DFS_STATUS_EBUSY;
|
|
|
+ goto __exit;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (fs->ops->unlink != RT_NULL)
|
|
|
+ {
|
|
|
+ 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, fullpath);
|
|
|
+ }
|
|
|
+ else result = -DFS_STATUS_ENOSYS;
|
|
|
|
|
|
__exit:
|
|
|
- rt_free(fullpath);
|
|
|
- return result;
|
|
|
+ rt_free(fullpath);
|
|
|
+ return result;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
@@ -276,16 +279,16 @@ __exit:
|
|
|
*/
|
|
|
int dfs_file_write(struct dfs_fd *fd, const void *buf, rt_size_t len)
|
|
|
{
|
|
|
- struct dfs_filesystem *fs;
|
|
|
+ struct dfs_filesystem *fs;
|
|
|
|
|
|
- if (fd == RT_NULL)
|
|
|
- return -DFS_STATUS_EINVAL;
|
|
|
+ if (fd == RT_NULL)
|
|
|
+ return -DFS_STATUS_EINVAL;
|
|
|
|
|
|
- fs = fd->fs;
|
|
|
- if (fs->ops->write == RT_NULL)
|
|
|
- return -DFS_STATUS_ENOSYS;
|
|
|
+ fs = fd->fs;
|
|
|
+ if (fs->ops->write == RT_NULL)
|
|
|
+ return -DFS_STATUS_ENOSYS;
|
|
|
|
|
|
- return fs->ops->write(fd, buf, len);
|
|
|
+ return fs->ops->write(fd, buf, len);
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
@@ -297,16 +300,16 @@ int dfs_file_write(struct dfs_fd *fd, const void *buf, rt_size_t len)
|
|
|
*/
|
|
|
int dfs_file_flush(struct dfs_fd *fd)
|
|
|
{
|
|
|
- struct dfs_filesystem *fs;
|
|
|
+ struct dfs_filesystem *fs;
|
|
|
|
|
|
- if (fd == RT_NULL)
|
|
|
- return -DFS_STATUS_EINVAL;
|
|
|
+ if (fd == RT_NULL)
|
|
|
+ return -DFS_STATUS_EINVAL;
|
|
|
|
|
|
- fs = fd->fs;
|
|
|
- if (fs->ops->flush == RT_NULL)
|
|
|
- return -DFS_STATUS_ENOSYS;
|
|
|
+ fs = fd->fs;
|
|
|
+ if (fs->ops->flush == RT_NULL)
|
|
|
+ return -DFS_STATUS_ENOSYS;
|
|
|
|
|
|
- return fs->ops->flush(fd);
|
|
|
+ return fs->ops->flush(fd);
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
@@ -319,21 +322,21 @@ int dfs_file_flush(struct dfs_fd *fd)
|
|
|
*/
|
|
|
int dfs_file_lseek(struct dfs_fd *fd, rt_off_t offset)
|
|
|
{
|
|
|
- int result;
|
|
|
- struct dfs_filesystem *fs = fd->fs;
|
|
|
+ int result;
|
|
|
+ struct dfs_filesystem *fs = fd->fs;
|
|
|
|
|
|
- if (fd == RT_NULL)
|
|
|
- return -DFS_STATUS_EINVAL;
|
|
|
- if (fs->ops->lseek == RT_NULL)
|
|
|
- return -DFS_STATUS_ENOSYS;
|
|
|
+ if (fd == RT_NULL)
|
|
|
+ return -DFS_STATUS_EINVAL;
|
|
|
+ if (fs->ops->lseek == RT_NULL)
|
|
|
+ return -DFS_STATUS_ENOSYS;
|
|
|
|
|
|
- result = fs->ops->lseek(fd, offset);
|
|
|
+ result = fs->ops->lseek(fd, offset);
|
|
|
|
|
|
- /* update current position */
|
|
|
- if (result >= 0)
|
|
|
- fd->pos = result;
|
|
|
+ /* update current position */
|
|
|
+ if (result >= 0)
|
|
|
+ fd->pos = result;
|
|
|
|
|
|
- return result;
|
|
|
+ return result;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
@@ -346,62 +349,65 @@ int dfs_file_lseek(struct dfs_fd *fd, rt_off_t offset)
|
|
|
*/
|
|
|
int dfs_file_stat(const char *path, struct stat *buf)
|
|
|
{
|
|
|
- int result;
|
|
|
- char *fullpath;
|
|
|
- struct dfs_filesystem *fs;
|
|
|
-
|
|
|
- fullpath = dfs_normalize_path(RT_NULL, path);
|
|
|
- if (fullpath == RT_NULL)
|
|
|
- {
|
|
|
- return -1;
|
|
|
- }
|
|
|
-
|
|
|
- if ((fs = dfs_filesystem_lookup(fullpath)) == RT_NULL)
|
|
|
- {
|
|
|
- dfs_log(DFS_DEBUG_ERROR, ("can't find mounted filesystem on this path:%s", fullpath));
|
|
|
- rt_free(fullpath);
|
|
|
- return -DFS_STATUS_ENOENT;
|
|
|
- }
|
|
|
-
|
|
|
- if ((fullpath[0] == '/' && fullpath[1] == '\0') ||
|
|
|
- (dfs_subdir(fs->path, fullpath) == RT_NULL))
|
|
|
- {
|
|
|
- /* it's the root directory */
|
|
|
- buf->st_dev = 0;
|
|
|
-
|
|
|
- buf->st_mode = DFS_S_IRUSR | DFS_S_IRGRP | DFS_S_IROTH |
|
|
|
- DFS_S_IWUSR | DFS_S_IWGRP | DFS_S_IWOTH;
|
|
|
- buf->st_mode |= DFS_S_IFDIR | DFS_S_IXUSR | DFS_S_IXGRP | DFS_S_IXOTH;
|
|
|
-
|
|
|
- buf->st_size = 0;
|
|
|
- buf->st_mtime = 0;
|
|
|
- buf->st_blksize = 512;
|
|
|
-
|
|
|
- /* release full path */
|
|
|
- rt_free(fullpath);
|
|
|
-
|
|
|
- return DFS_STATUS_OK;
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- if (fs->ops->stat == RT_NULL)
|
|
|
- {
|
|
|
- rt_free(fullpath);
|
|
|
- dfs_log(DFS_DEBUG_ERROR, ("the filesystem didn't implement this function"));
|
|
|
- return -DFS_STATUS_ENOSYS;
|
|
|
- }
|
|
|
-
|
|
|
- /* get the real file path and get file stat */
|
|
|
- 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);
|
|
|
-
|
|
|
- return result;
|
|
|
+ int result;
|
|
|
+ char *fullpath;
|
|
|
+ struct dfs_filesystem *fs;
|
|
|
+
|
|
|
+ fullpath = dfs_normalize_path(RT_NULL, path);
|
|
|
+ if (fullpath == RT_NULL)
|
|
|
+ {
|
|
|
+ return -1;
|
|
|
+ }
|
|
|
+
|
|
|
+ if ((fs = dfs_filesystem_lookup(fullpath)) == RT_NULL)
|
|
|
+ {
|
|
|
+ dfs_log(DFS_DEBUG_ERROR,
|
|
|
+ ("can't find mounted filesystem on this path:%s", fullpath));
|
|
|
+ rt_free(fullpath);
|
|
|
+
|
|
|
+ return -DFS_STATUS_ENOENT;
|
|
|
+ }
|
|
|
+
|
|
|
+ if ((fullpath[0] == '/' && fullpath[1] == '\0') ||
|
|
|
+ (dfs_subdir(fs->path, fullpath) == RT_NULL))
|
|
|
+ {
|
|
|
+ /* it's the root directory */
|
|
|
+ buf->st_dev = 0;
|
|
|
+
|
|
|
+ buf->st_mode = DFS_S_IRUSR | DFS_S_IRGRP | DFS_S_IROTH |
|
|
|
+ DFS_S_IWUSR | DFS_S_IWGRP | DFS_S_IWOTH;
|
|
|
+ buf->st_mode |= DFS_S_IFDIR | DFS_S_IXUSR | DFS_S_IXGRP | DFS_S_IXOTH;
|
|
|
+
|
|
|
+ buf->st_size = 0;
|
|
|
+ buf->st_mtime = 0;
|
|
|
+ buf->st_blksize = 512;
|
|
|
+
|
|
|
+ /* release full path */
|
|
|
+ rt_free(fullpath);
|
|
|
+
|
|
|
+ return DFS_STATUS_OK;
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ if (fs->ops->stat == RT_NULL)
|
|
|
+ {
|
|
|
+ rt_free(fullpath);
|
|
|
+ dfs_log(DFS_DEBUG_ERROR,
|
|
|
+ ("the filesystem didn't implement this function"));
|
|
|
+
|
|
|
+ return -DFS_STATUS_ENOSYS;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* get the real file path and get file stat */
|
|
|
+ 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);
|
|
|
+
|
|
|
+ return result;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
@@ -414,58 +420,59 @@ int dfs_file_stat(const char *path, struct stat *buf)
|
|
|
*/
|
|
|
int dfs_file_rename(const char *oldpath, const char *newpath)
|
|
|
{
|
|
|
- int result;
|
|
|
- struct dfs_filesystem *oldfs, *newfs;
|
|
|
- char *oldfullpath, *newfullpath;
|
|
|
-
|
|
|
- result = DFS_STATUS_OK;
|
|
|
- newfullpath = RT_NULL;
|
|
|
- oldfullpath = RT_NULL;
|
|
|
-
|
|
|
- oldfullpath = dfs_normalize_path(RT_NULL, oldpath);
|
|
|
- if (oldfullpath == RT_NULL)
|
|
|
- {
|
|
|
- result = -DFS_STATUS_ENOENT;
|
|
|
- goto __exit;
|
|
|
- }
|
|
|
-
|
|
|
- newfullpath = dfs_normalize_path(RT_NULL, newpath);
|
|
|
- if (newfullpath == RT_NULL)
|
|
|
- {
|
|
|
- result = -DFS_STATUS_ENOENT;
|
|
|
- goto __exit;
|
|
|
- }
|
|
|
-
|
|
|
- oldfs = dfs_filesystem_lookup(oldfullpath);
|
|
|
- newfs = dfs_filesystem_lookup(newfullpath);
|
|
|
-
|
|
|
- if (oldfs == newfs)
|
|
|
- {
|
|
|
- if (oldfs->ops->rename == RT_NULL)
|
|
|
- {
|
|
|
- result = -DFS_STATUS_ENOSYS;
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- if (oldfs->ops->flags & DFS_FS_FLAG_FULLPATH)
|
|
|
- result = oldfs->ops->rename(oldfs, oldfullpath, newfullpath);
|
|
|
- else
|
|
|
- /* use sub directory to rename in file system */
|
|
|
- result = oldfs->ops->rename(oldfs, dfs_subdir(oldfs->path, oldfullpath),
|
|
|
- dfs_subdir(newfs->path, newfullpath));
|
|
|
- }
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- result = -DFS_STATUS_EXDEV;
|
|
|
- }
|
|
|
+ int result;
|
|
|
+ struct dfs_filesystem *oldfs, *newfs;
|
|
|
+ char *oldfullpath, *newfullpath;
|
|
|
+
|
|
|
+ result = DFS_STATUS_OK;
|
|
|
+ newfullpath = RT_NULL;
|
|
|
+ oldfullpath = RT_NULL;
|
|
|
+
|
|
|
+ oldfullpath = dfs_normalize_path(RT_NULL, oldpath);
|
|
|
+ if (oldfullpath == RT_NULL)
|
|
|
+ {
|
|
|
+ result = -DFS_STATUS_ENOENT;
|
|
|
+ goto __exit;
|
|
|
+ }
|
|
|
+
|
|
|
+ newfullpath = dfs_normalize_path(RT_NULL, newpath);
|
|
|
+ if (newfullpath == RT_NULL)
|
|
|
+ {
|
|
|
+ result = -DFS_STATUS_ENOENT;
|
|
|
+ goto __exit;
|
|
|
+ }
|
|
|
+
|
|
|
+ oldfs = dfs_filesystem_lookup(oldfullpath);
|
|
|
+ newfs = dfs_filesystem_lookup(newfullpath);
|
|
|
+
|
|
|
+ if (oldfs == newfs)
|
|
|
+ {
|
|
|
+ if (oldfs->ops->rename == RT_NULL)
|
|
|
+ {
|
|
|
+ result = -DFS_STATUS_ENOSYS;
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ if (oldfs->ops->flags & DFS_FS_FLAG_FULLPATH)
|
|
|
+ result = oldfs->ops->rename(oldfs, oldfullpath, newfullpath);
|
|
|
+ else
|
|
|
+ /* use sub directory to rename in file system */
|
|
|
+ result = oldfs->ops->rename(oldfs,
|
|
|
+ dfs_subdir(oldfs->path, oldfullpath),
|
|
|
+ dfs_subdir(newfs->path, newfullpath));
|
|
|
+ }
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ result = -DFS_STATUS_EXDEV;
|
|
|
+ }
|
|
|
|
|
|
__exit:
|
|
|
- rt_free(oldfullpath);
|
|
|
- rt_free(newfullpath);
|
|
|
+ rt_free(oldfullpath);
|
|
|
+ rt_free(newfullpath);
|
|
|
|
|
|
- /* not at same file system, return EXDEV */
|
|
|
- return result;
|
|
|
+ /* not at same file system, return EXDEV */
|
|
|
+ return result;
|
|
|
}
|
|
|
|
|
|
#ifdef RT_USING_FINSH
|
|
|
@@ -475,147 +482,152 @@ static struct dfs_fd fd;
|
|
|
static struct dirent dirent;
|
|
|
void ls(const char *pathname)
|
|
|
{
|
|
|
- struct stat stat;
|
|
|
- int length;
|
|
|
- char *fullpath, *path;
|
|
|
+ struct stat stat;
|
|
|
+ int length;
|
|
|
+ char *fullpath, *path;
|
|
|
|
|
|
- fullpath = RT_NULL;
|
|
|
- if (pathname == RT_NULL)
|
|
|
- {
|
|
|
+ fullpath = RT_NULL;
|
|
|
+ if (pathname == RT_NULL)
|
|
|
+ {
|
|
|
#ifdef DFS_USING_WORKDIR
|
|
|
- /* open current working directory */
|
|
|
- path = rt_strdup(working_directory);
|
|
|
+ /* open current working directory */
|
|
|
+ path = rt_strdup(working_directory);
|
|
|
#else
|
|
|
- path = rt_strdup("/");
|
|
|
+ path = rt_strdup("/");
|
|
|
#endif
|
|
|
- if (path == RT_NULL) return ; /* out of memory */
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- path = (char *)pathname;
|
|
|
- }
|
|
|
-
|
|
|
- /* list directory */
|
|
|
- if (dfs_file_open(&fd, path, DFS_O_DIRECTORY) == 0)
|
|
|
- {
|
|
|
- rt_kprintf("Directory %s:\n", path);
|
|
|
- do
|
|
|
- {
|
|
|
- rt_memset(&dirent, 0, sizeof(struct dirent));
|
|
|
- length = dfs_file_getdents(&fd, &dirent, sizeof(struct dirent));
|
|
|
- if (length > 0)
|
|
|
- {
|
|
|
- rt_memset(&stat, 0, sizeof(struct stat));
|
|
|
-
|
|
|
- /* build full path for each file */
|
|
|
- fullpath = dfs_normalize_path(path, dirent.d_name);
|
|
|
- if (fullpath == RT_NULL)
|
|
|
- break;
|
|
|
-
|
|
|
- if (dfs_file_stat(fullpath, &stat) == 0)
|
|
|
- {
|
|
|
- rt_kprintf("%-20s", dirent.d_name);
|
|
|
- if ( DFS_S_ISDIR(stat.st_mode))
|
|
|
- {
|
|
|
- rt_kprintf("%-25s\n", "<DIR>");
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- rt_kprintf("%-25lu\n", stat.st_size);
|
|
|
- }
|
|
|
- }
|
|
|
- else
|
|
|
- rt_kprintf("BAD file: %s\n", dirent.d_name);
|
|
|
- rt_free(fullpath);
|
|
|
- }
|
|
|
- }while(length > 0);
|
|
|
-
|
|
|
- dfs_file_close(&fd);
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- rt_kprintf("No such directory\n");
|
|
|
- }
|
|
|
- if (pathname == RT_NULL)
|
|
|
- rt_free(path);
|
|
|
+ if (path == RT_NULL)
|
|
|
+ return ; /* out of memory */
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ path = (char *)pathname;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* list directory */
|
|
|
+ if (dfs_file_open(&fd, path, DFS_O_DIRECTORY) == 0)
|
|
|
+ {
|
|
|
+ rt_kprintf("Directory %s:\n", path);
|
|
|
+ do
|
|
|
+ {
|
|
|
+ rt_memset(&dirent, 0, sizeof(struct dirent));
|
|
|
+ length = dfs_file_getdents(&fd, &dirent, sizeof(struct dirent));
|
|
|
+ if (length > 0)
|
|
|
+ {
|
|
|
+ rt_memset(&stat, 0, sizeof(struct stat));
|
|
|
+
|
|
|
+ /* build full path for each file */
|
|
|
+ fullpath = dfs_normalize_path(path, dirent.d_name);
|
|
|
+ if (fullpath == RT_NULL)
|
|
|
+ break;
|
|
|
+
|
|
|
+ if (dfs_file_stat(fullpath, &stat) == 0)
|
|
|
+ {
|
|
|
+ rt_kprintf("%-20s", dirent.d_name);
|
|
|
+ if ( DFS_S_ISDIR(stat.st_mode))
|
|
|
+ {
|
|
|
+ rt_kprintf("%-25s\n", "<DIR>");
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ rt_kprintf("%-25lu\n", stat.st_size);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ else
|
|
|
+ rt_kprintf("BAD file: %s\n", dirent.d_name);
|
|
|
+ rt_free(fullpath);
|
|
|
+ }
|
|
|
+ }while(length > 0);
|
|
|
+
|
|
|
+ dfs_file_close(&fd);
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ rt_kprintf("No such directory\n");
|
|
|
+ }
|
|
|
+ if (pathname == RT_NULL)
|
|
|
+ rt_free(path);
|
|
|
}
|
|
|
FINSH_FUNCTION_EXPORT(ls, list directory contents)
|
|
|
|
|
|
void rm(const char *filename)
|
|
|
{
|
|
|
- if (dfs_file_unlink(filename) < 0)
|
|
|
- {
|
|
|
- rt_kprintf("Delete %s failed\n", filename);
|
|
|
- }
|
|
|
+ if (dfs_file_unlink(filename) < 0)
|
|
|
+ {
|
|
|
+ rt_kprintf("Delete %s failed\n", filename);
|
|
|
+ }
|
|
|
}
|
|
|
FINSH_FUNCTION_EXPORT(rm, remove files or directories)
|
|
|
|
|
|
void cat(const char* filename)
|
|
|
{
|
|
|
- rt_uint32_t length;
|
|
|
- char buffer[81];
|
|
|
-
|
|
|
- if (dfs_file_open(&fd, filename, DFS_O_RDONLY) < 0)
|
|
|
- {
|
|
|
- rt_kprintf("Open %s failed\n", filename);
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
- do
|
|
|
- {
|
|
|
- rt_memset(buffer, 0, sizeof(buffer));
|
|
|
- length = dfs_file_read(&fd, buffer, sizeof(buffer)-1 );
|
|
|
- if (length > 0)
|
|
|
- {
|
|
|
- rt_kprintf("%s", buffer);
|
|
|
- }
|
|
|
- }while (length > 0);
|
|
|
-
|
|
|
- dfs_file_close(&fd);
|
|
|
+ rt_uint32_t length;
|
|
|
+ char buffer[81];
|
|
|
+
|
|
|
+ if (dfs_file_open(&fd, filename, DFS_O_RDONLY) < 0)
|
|
|
+ {
|
|
|
+ rt_kprintf("Open %s failed\n", filename);
|
|
|
+
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ do
|
|
|
+ {
|
|
|
+ rt_memset(buffer, 0, sizeof(buffer));
|
|
|
+ length = dfs_file_read(&fd, buffer, sizeof(buffer)-1 );
|
|
|
+ if (length > 0)
|
|
|
+ {
|
|
|
+ rt_kprintf("%s", buffer);
|
|
|
+ }
|
|
|
+ }while (length > 0);
|
|
|
+
|
|
|
+ dfs_file_close(&fd);
|
|
|
}
|
|
|
FINSH_FUNCTION_EXPORT(cat, print file)
|
|
|
|
|
|
-#define BUF_SZ 4096
|
|
|
+#define BUF_SZ 4096
|
|
|
void copy(const char *src, const char *dst)
|
|
|
{
|
|
|
- struct dfs_fd src_fd;
|
|
|
- rt_uint8_t *block_ptr;
|
|
|
- rt_uint32_t read_bytes;
|
|
|
-
|
|
|
- block_ptr = rt_malloc(BUF_SZ);
|
|
|
- if (block_ptr == RT_NULL)
|
|
|
- {
|
|
|
- rt_kprintf("out of memory\n");
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
- if (dfs_file_open(&src_fd, src, DFS_O_RDONLY) < 0)
|
|
|
- {
|
|
|
- rt_free(block_ptr);
|
|
|
- rt_kprintf("Read %s failed\n", src);
|
|
|
- return;
|
|
|
- }
|
|
|
- if (dfs_file_open(&fd, dst, DFS_O_WRONLY | DFS_O_CREAT) < 0)
|
|
|
- {
|
|
|
- rt_free(block_ptr);
|
|
|
- dfs_file_close(&src_fd);
|
|
|
-
|
|
|
- rt_kprintf("Write %s failed\n", dst);
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
- do
|
|
|
- {
|
|
|
- read_bytes = dfs_file_read(&src_fd, block_ptr, BUF_SZ);
|
|
|
- if (read_bytes > 0)
|
|
|
- {
|
|
|
- dfs_file_write(&fd, block_ptr, read_bytes);
|
|
|
- }
|
|
|
- } while (read_bytes > 0);
|
|
|
-
|
|
|
- dfs_file_close(&src_fd);
|
|
|
- dfs_file_close(&fd);
|
|
|
- rt_free(block_ptr);
|
|
|
+ struct dfs_fd src_fd;
|
|
|
+ rt_uint8_t *block_ptr;
|
|
|
+ rt_uint32_t read_bytes;
|
|
|
+
|
|
|
+ block_ptr = rt_malloc(BUF_SZ);
|
|
|
+ if (block_ptr == RT_NULL)
|
|
|
+ {
|
|
|
+ rt_kprintf("out of memory\n");
|
|
|
+
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (dfs_file_open(&src_fd, src, DFS_O_RDONLY) < 0)
|
|
|
+ {
|
|
|
+ rt_free(block_ptr);
|
|
|
+ rt_kprintf("Read %s failed\n", src);
|
|
|
+
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ if (dfs_file_open(&fd, dst, DFS_O_WRONLY | DFS_O_CREAT) < 0)
|
|
|
+ {
|
|
|
+ rt_free(block_ptr);
|
|
|
+ dfs_file_close(&src_fd);
|
|
|
+
|
|
|
+ rt_kprintf("Write %s failed\n", dst);
|
|
|
+
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ do
|
|
|
+ {
|
|
|
+ read_bytes = dfs_file_read(&src_fd, block_ptr, BUF_SZ);
|
|
|
+ if (read_bytes > 0)
|
|
|
+ {
|
|
|
+ dfs_file_write(&fd, block_ptr, read_bytes);
|
|
|
+ }
|
|
|
+ } while (read_bytes > 0);
|
|
|
+
|
|
|
+ dfs_file_close(&src_fd);
|
|
|
+ dfs_file_close(&fd);
|
|
|
+ rt_free(block_ptr);
|
|
|
}
|
|
|
FINSH_FUNCTION_EXPORT(copy, copy source file to destination file)
|
|
|
|
dzzxzz@gmail.com