From 33feb176d09c8f5a6d9374a4276ebfc46ae44a4a Mon Sep 17 00:00:00 2001 From: "bernard.xiong@gmail.com" Date: Sun, 18 Jul 2010 16:15:53 +0000 Subject: [PATCH] add flush, statfs, mkfs to device file system interface. git-svn-id: https://rt-thread.googlecode.com/svn/trunk@802 bbd45198-f89e-11dd-88c7-29a3b14d5316 --- components/dfs/SConscript | 5 +- components/dfs/include/dfs_def.h | 58 +-- components/dfs/include/dfs_fat.h | 29 -- components/dfs/include/dfs_fs.h | 51 ++- components/dfs/include/dfs_posix.h | 38 +- components/dfs/include/dfs_raw.h | 38 -- components/dfs/include/dfs_util.h | 36 -- components/dfs/src/dfs_fs.c | 253 ++++++----- components/dfs/src/dfs_init.c | 84 ---- components/dfs/src/dfs_posix.c | 485 ++++++++++---------- components/dfs/src/dfs_raw.c | 684 ----------------------------- components/dfs/src/dfs_util.c | 295 ------------- 12 files changed, 462 insertions(+), 1594 deletions(-) delete mode 100644 components/dfs/include/dfs_fat.h delete mode 100644 components/dfs/include/dfs_raw.h delete mode 100644 components/dfs/include/dfs_util.h delete mode 100644 components/dfs/src/dfs_init.c delete mode 100644 components/dfs/src/dfs_raw.c delete mode 100644 components/dfs/src/dfs_util.c diff --git a/components/dfs/SConscript b/components/dfs/SConscript index d598c5110e..fdb1127f00 100644 --- a/components/dfs/SConscript +++ b/components/dfs/SConscript @@ -4,11 +4,10 @@ Import('RTT_ROOT') Import('projects') dfs = Split(""" +src/dfs.c src/dfs_fs.c -src/dfs_init.c +src/dfs_file.c src/dfs_posix.c -src/dfs_raw.c -src/dfs_util.c """) # DFS-FatFs options diff --git a/components/dfs/include/dfs_def.h b/components/dfs/include/dfs_def.h index 9abe6d5c27..e3c52dd957 100644 --- a/components/dfs/include/dfs_def.h +++ b/components/dfs/include/dfs_def.h @@ -1,20 +1,18 @@ /* -+------------------------------------------------------------------------------ -| Device FileSystem -+------------------------------------------------------------------------------ -| Copyright 2004, 2005 www.fayfayspace.org. -| All rights reserved. -|------------------------------------------------------------------------------ -| File : dfs_def.h, the definitions of Device FileSystem -|------------------------------------------------------------------------------ -| Chang Logs: -| Date Author notes -| 2004-10-01 ffxz The first version. -| 2004-10-14 ffxz Clean up the code. -| 2005-01-22 ffxz Clean up the code, port to MinGW -+------------------------------------------------------------------------------ -*/ - + * File : dfs_def.h + * This file is part of Device File System in RT-Thread RTOS + * COPYRIGHT (C) 2004-2010, 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 + * 2004-10-01 Beranard The first version. + * 2004-10-14 Beranard Clean up the code. + * 2005-01-22 Beranard Clean up the code, port to MinGW + */ #ifndef __DFS_DEF_H__ #define __DFS_DEF_H__ @@ -113,15 +111,6 @@ #define DEVICE_FORMAT 2 #define DEVICE_CLEAN_SECTOR 3 -struct device_geometry -{ - rt_uint32_t sector_count; /* count of sectors */ - rt_uint32_t cylinder_count; /* count of cylinder */ - rt_uint32_t sectors_per_track; /* number of sectors per track */ - rt_uint32_t head_count; /* count of head */ - rt_uint32_t bytes_per_sector; /* number of bytes per sector */ -}; - struct dfs_stat { rt_device_t st_dev; @@ -130,7 +119,13 @@ struct dfs_stat rt_time_t st_mtime; rt_uint32_t st_blksize; }; -#define stat dfs_stat + +struct dfs_statfs +{ + rt_size_t f_bsize; /* block size */ + rt_size_t f_blocks; /* total data blocks in file system */ + rt_size_t f_bfree; /* free blocks in file system */ +}; /* File types */ #define FT_REGULAR 0 /* regular file */ @@ -141,7 +136,7 @@ struct dfs_stat /* file descriptor */ struct dfs_fd { - char path[DFS_PATH_MAX + 1];/* Name (below mount point) */ + char* path; /* Name (below mount point) */ int type; /* Type (regular or socket) */ int ref_count; /* Descriptor reference count */ @@ -162,14 +157,9 @@ struct dfs_dirent { rt_uint8_t d_type; /* The type of the file */ rt_uint8_t d_namlen; /* The length of the not including the terminating null file name */ - rt_uint16_t d_reclen; /* length of this record */ - char d_name[256]; /* The null-terminated file name */ + rt_uint16_t d_reclen; /* length of this record */ + char d_name[DFS_PATH_MAX]; /* The null-terminated file name */ }; #define dirent dfs_dirent -struct dfs_session -{ - rt_mailbox_t mbox; -}; - #endif diff --git a/components/dfs/include/dfs_fat.h b/components/dfs/include/dfs_fat.h deleted file mode 100644 index 65af6cebb3..0000000000 --- a/components/dfs/include/dfs_fat.h +++ /dev/null @@ -1,29 +0,0 @@ -/* -+------------------------------------------------------------------------------ -| Project : Device Filesystem -+------------------------------------------------------------------------------ -| Copyright 2004, 2005 www.fayfayspace.org. -| All rights reserved. -|------------------------------------------------------------------------------ -| File : dfs_fat.h, FAT 12/16/32 file system definitions -|------------------------------------------------------------------------------ -| Chang Logs: -| Date Author Notes -| 2003-03-30 ffxz -+------------------------------------------------------------------------------ -*/ - -#ifndef __DFS_FAT_H__ -#define __DFS_FAT_H__ - -#ifdef __cplusplus -extern "C" { -#endif - -int fatfs_init(void); - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/components/dfs/include/dfs_fs.h b/components/dfs/include/dfs_fs.h index c31d9585a2..8c0a2b04d9 100644 --- a/components/dfs/include/dfs_fs.h +++ b/components/dfs/include/dfs_fs.h @@ -1,17 +1,16 @@ /* -+------------------------------------------------------------------------------ -| Project : Device Filesystem -+------------------------------------------------------------------------------ -| Copyright 2004, 2005 www.fayfayspace.org. -| All rights reserved. -|------------------------------------------------------------------------------ -| File : dfs_fs.h, the filesystem related defines of Device FileSystem -|------------------------------------------------------------------------------ -| Chang Logs: -| Date Author Notes -| 2005-02-22 ffxz The first version. -+------------------------------------------------------------------------------ -*/ + * File : dfs_fs.h + * This file is part of Device File System in RT-Thread RTOS + * COPYRIGHT (C) 2004-2010, 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 + * 2005-02-22 Bernard The first version. + */ #ifndef __DFS_FS_H__ #define __DFS_FS_H__ @@ -26,16 +25,22 @@ struct dfs_dirent; /* File system operations struct */ struct dfs_filesystem_operation { - char name[DFS_FS_NAME_MAX + 1]; + char *name; + /* mount and unmount file system */ int (*mount) (struct dfs_filesystem* fs, unsigned long rwflag, const void* data); int (*unmount) (struct dfs_filesystem* fs); - int (*open) (struct dfs_fd* fd); + /* make a file system */ + int (*mkfs) (const char* device_name); + int (*statfs) (struct dfs_filesystem* fs, struct dfs_statfs *buf); + + int (*open) (struct dfs_fd* fd); int (*close) (struct dfs_fd* fd); int (*ioctl) (struct dfs_fd* fd, int cmd, void *args); - int (*read) (struct dfs_fd* fd, void* buf, rt_size_t count); + int (*read) (struct dfs_fd* fd, void* buf, rt_size_t count); int (*write) (struct dfs_fd* fd, const void* buf, rt_size_t count); + int (*flush) (struct dfs_fd* fd); int (*lseek) (struct dfs_fd* fd, rt_off_t offset); int (*getdents) (struct dfs_fd* fd, struct dfs_dirent* dirp, rt_uint32_t count); @@ -47,13 +52,12 @@ struct dfs_filesystem_operation /* Mounted file system */ struct dfs_filesystem { - rt_device_t dev_id; /* Attached device */ + rt_device_t dev_id; /* Attached device */ - char path[DFS_PATH_MAX + 1]; /* File system mount point */ - struct dfs_filesystem_operation* ops; /* Operations for file system type */ - rt_uint32_t block_id; /* Current block_id on attached device */ + char* path; /* File system mount point */ + const struct dfs_filesystem_operation* ops; /* Operations for file system type */ - void *data; /* Specific file system data */ + void *data; /* Specific file system data */ }; /* file system partition table */ @@ -65,7 +69,7 @@ struct dfs_partition rt_sem_t lock; }; -int dfs_register(struct dfs_filesystem_operation* ops); +int dfs_register(const struct dfs_filesystem_operation* ops); struct dfs_filesystem* dfs_filesystem_lookup(const char *path); rt_err_t dfs_filesystem_get_partition(struct dfs_partition* part, rt_uint8_t* buf, rt_uint32_t pindex); @@ -75,12 +79,13 @@ int dfs_mount(const char* device_name, const char* path, int dfs_unmount(const char *specialfile); /* extern variable */ -extern struct dfs_filesystem_operation* filesystem_operation_table[]; +extern const struct dfs_filesystem_operation* filesystem_operation_table[]; extern struct dfs_filesystem filesystem_table[]; extern char working_directory[]; void dfs_lock(void); void dfs_unlock(void); +int dfs_statfs(const char* path, struct dfs_statfs* buffer); #endif diff --git a/components/dfs/include/dfs_posix.h b/components/dfs/include/dfs_posix.h index b39ab2cb3e..ce1e94028b 100644 --- a/components/dfs/include/dfs_posix.h +++ b/components/dfs/include/dfs_posix.h @@ -1,21 +1,21 @@ /* -+------------------------------------------------------------------------------ -| Project : Device Filesystem -+------------------------------------------------------------------------------ -| Copyright 2004, 2005 www.fayfayspace.org. -| All rights reserved. -|------------------------------------------------------------------------------ -| File : dfs_posix.h, the filesystem related defines of Device FileSystem -|------------------------------------------------------------------------------ -| Chang Logs: -| Date Author Notes -| 2009-05-27 Yi.qiu The first version. -+------------------------------------------------------------------------------ -*/ + * File : dfs_def.h + * This file is part of Device File System in RT-Thread RTOS + * COPYRIGHT (C) 2004-2010, 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 + * 2009-05-27 Yi.qiu The first version. + * 2010-07-18 Bernard add stat and statfs structure definitions. + */ #ifndef __DFS_POSIX_H__ #define __DFS_POSIX_H__ -#include +#include #define O_RDONLY DFS_O_RDONLY #define O_WRONLY DFS_O_WRONLY @@ -74,6 +74,15 @@ typedef struct int cur; } DIR; +struct stat +{ + struct dfs_stat parent; +}; +struct statfs +{ + struct dfs_statfs parent; +}; + /* file api*/ int open(const char *file, int flags, int mode); int close(int d); @@ -83,6 +92,7 @@ int lseek(int fd, int offset, int dir); int rename(const char* old, const char* new ); int unlink(const char *pathname); int stat(const char *file, struct dfs_stat *buf); +int statfs(const char *path, struct dfs_statfs *buf); /* directory api*/ int mkdir (const char *path, rt_uint16_t mode); diff --git a/components/dfs/include/dfs_raw.h b/components/dfs/include/dfs_raw.h deleted file mode 100644 index dd6bfb0cad..0000000000 --- a/components/dfs/include/dfs_raw.h +++ /dev/null @@ -1,38 +0,0 @@ -/* -+------------------------------------------------------------------------------ -| Project : Device Filesystem -+------------------------------------------------------------------------------ -| Copyright 2004, 2005 www.fayfayspace.org. -| All rights reserved. -|------------------------------------------------------------------------------ -| File : dfs_raw.h, the raw APIs of Device FileSystem -|------------------------------------------------------------------------------ -| Chang Logs: -| Date Author Notes -| 2005-01-26 ffxz The first version -+------------------------------------------------------------------------------ -*/ - -#ifndef __DFS_RAW_H__ -#define __DFS_RAW_H__ - -#include -#include - -int dfile_raw_open(struct dfs_fd* fd, const char *path, int flags); -int dfile_raw_close(struct dfs_fd* fd); -int dfile_raw_ioctl(struct dfs_fd* fd, int cmd, void *args); -int dfile_raw_read(struct dfs_fd* fd, void *buf, rt_size_t len); -int dfile_raw_getdents(struct dfs_fd* fd, struct dfs_dirent* dirp, rt_size_t nbytes); -int dfile_raw_unlink(const char *path); -int dfile_raw_write(struct dfs_fd* fd, const void *buf, rt_size_t len); -int dfile_raw_lseek(struct dfs_fd* fd, rt_off_t offset); -int dfile_raw_stat(const char *path, struct dfs_stat *buf); -int dfile_raw_rename(const char* oldpath, const char* newpath); - -/* FD APIs */ -int fd_new(void); -struct dfs_fd* fd_get(int fd); -void fd_put(struct dfs_fd* fd); - -#endif diff --git a/components/dfs/include/dfs_util.h b/components/dfs/include/dfs_util.h deleted file mode 100644 index 41ba8f2d36..0000000000 --- a/components/dfs/include/dfs_util.h +++ /dev/null @@ -1,36 +0,0 @@ -/* -+------------------------------------------------------------------------------ -| Project : Device Filesystem -+------------------------------------------------------------------------------ -| Copyright 2004, 2005 www.fayfayspace.org. -| All rights reserved. -|------------------------------------------------------------------------------ -| File : dfs_util.h, some misc definitions of Device FileSystem -|------------------------------------------------------------------------------ -| Chang Logs: -| Date Author Notes -| 2005-01-26 ffxz The first version -+------------------------------------------------------------------------------ -*/ - -#ifndef __DFS_UTIL_H__ -#define __DFS_UTIL_H__ - -#include - -int dir_name(const char* path, char* dirname, int len); -int file_name(const char* path, char* filename, int len); - -int next_dir_name(const char* path, int pos, char* next); -void build_fullpath(const char *directory, const char *filename, char *fullpath); -int str_is_prefix(const char* prefix, const char* str); - -#if !defined(RT_USING_MINILIBC) && !defined(RT_USING_NEWLIB) -char *strrchr(const char *t, int c); -#if defined (__ARMCC_VERSION) && (__ARMCC_VERSION / 10000 < 35) -#include -int strncasecmp(const char* s1, const char* s2, size_t len); -#endif /* end of __ARMCC_VERSION */ -#endif - -#endif diff --git a/components/dfs/src/dfs_fs.c b/components/dfs/src/dfs_fs.c index 926a98229e..98e61abd83 100644 --- a/components/dfs/src/dfs_fs.c +++ b/components/dfs/src/dfs_fs.c @@ -1,36 +1,28 @@ /* -+------------------------------------------------------------------------------ -| Project : Device Filesystem -+------------------------------------------------------------------------------ -| Copyright 2004, 2005 www.fayfayspace.org. -| All rights reserved. -|------------------------------------------------------------------------------ -| File : dfs_fs.c, the filesystem related implementations of Device FileSystem -|------------------------------------------------------------------------------ -| Chang Logs: -| Date Author Notes -| 2005-02-22 ffxz The first version. -+------------------------------------------------------------------------------ -*/ + * File : dfs_fs.c + * This file is part of Device File System in RT-Thread RTOS + * COPYRIGHT (C) 2004-2010, 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 + * 2005-02-22 Bernard The first version. + * 2010-06-30 Bernard Optimize for RT-Thread RTOS + */ #include -#include -#include +#include -#include - -/* -+------------------------------------------------------------------------------ -| Function : dfs_register -+------------------------------------------------------------------------------ -| Description : registers a filesystem -| -| Parameters : ops, the implementation of filesystem -| Returns : the status of register -| 0 , successful -| -1, failed -+------------------------------------------------------------------------------ -*/ -int dfs_register(struct dfs_filesystem_operation* ops) +/** + * this function will register a file system instance to device file system. + * + * @param ops the file system instance to be registered. + * + * @return 0 on sucessful, -1 on failed. + */ +int dfs_register(const struct dfs_filesystem_operation* ops) { int index, result; @@ -69,16 +61,14 @@ err: return result; } -/* -+------------------------------------------------------------------------------ -| Function : dfs_filesystem_lookup -+------------------------------------------------------------------------------ -| Description : lookup the mounted filesystem on the specified path -| -| Parameters : path, the specified path string -| Returns : the found filesystem -+------------------------------------------------------------------------------ -*/ +/** + * this function will return the file system mounted on specified path. + * + * @param path the specified path string. + * + * @return the found file system or NULL if no file system mounted on + * specified path + */ struct dfs_filesystem* dfs_filesystem_lookup(const char *path) { struct dfs_filesystem* fs; @@ -97,7 +87,7 @@ struct dfs_filesystem* dfs_filesystem_lookup(const char *path) if (fspath < prefixlen) continue; if ((filesystem_table[index].ops != RT_NULL) && - str_is_prefix(filesystem_table[index].path, path) == 0) + strncmp(filesystem_table[index].path, path, fspath) == 0) { fs = &filesystem_table[index]; prefixlen = fspath; @@ -109,6 +99,15 @@ struct dfs_filesystem* dfs_filesystem_lookup(const char *path) return fs; } +/** + * this function will fetch the partition table on specified buffer. + * + * @param part the returned partition structure. + * @param buf the buffer contains partition table. + * @param pindex the index of partition table to fetch. + * + * @return RT_EOK on successful or -RT_ERROR on failed. + */ rt_err_t dfs_filesystem_get_partition(struct dfs_partition* part, rt_uint8_t* buf, rt_uint32_t pindex) { #define DPT_ADDRESS 0x1be /* device partition offset in Boot Sector */ @@ -146,8 +145,7 @@ rt_err_t dfs_filesystem_get_partition(struct dfs_partition* part, rt_uint8_t* bu part->size = *(dpt+12) | *(dpt+13) << 8 | *(dpt+14) << 16 | *(dpt+15) << 24; -#ifdef RT_USING_FINSH - rt_kprintf("part[%d], begin: %d, size: ", + rt_kprintf("found part[%d], begin: %d, size: ", pindex, part->offset * 512); if ( (part->size>>11) > 0 ) /* MB */ { @@ -166,7 +164,6 @@ rt_err_t dfs_filesystem_get_partition(struct dfs_partition* part, rt_uint8_t* bu { rt_kprintf("%d%s",part->size>>1,"KB\r\n");/* KB */ } -#endif } else { @@ -176,32 +173,23 @@ rt_err_t dfs_filesystem_get_partition(struct dfs_partition* part, rt_uint8_t* bu return result; } -/* -+------------------------------------------------------------------------------ -| Function : dfs_mount -+------------------------------------------------------------------------------ -| Description : mount a filesystem to specified path -| -| Parameters : device_name, the implementation of filesystem -| path, -| filesystemtype, -| rwflag, -| data, -| Returns : the status of register -| 0 , successful -| -1, failed -+------------------------------------------------------------------------------ -*/ +/** + * this function will mount a file system on a specified path. + * + * @param device_name the name of device which includes a file system. + * @param filesystemtype the file system type + * @param rwflag the read/write etc. flag. + * @param data the privated data(parameter) for this file system. + * + * @return 0 on successful or -1 on failed. + */ int dfs_mount(const char* device_name, const char* path, const char* filesystemtype, unsigned long rwflag, const void* data) { - struct dfs_filesystem_operation* ops; + const struct dfs_filesystem_operation* ops; struct dfs_filesystem* fs; char *fullpath=RT_NULL; -#ifdef DFS_USING_WORKDIR - char full_path[DFS_PATH_MAX + 1]; -#endif rt_device_t dev_id; int index; @@ -240,19 +228,11 @@ int dfs_mount(const char* device_name, const char* path, dfs_unlock(); /* make full path for special file */ - fullpath = (char*)path; - if ( fullpath[0] != '/') /* not an abstract path */ + fullpath = dfs_normalize_path(RT_NULL, path); + if ( fullpath == RT_NULL) /* not an abstract path */ { -#ifdef DFS_USING_WORKDIR - /* build full path */ - fullpath = full_path; - dfs_lock(); - build_fullpath(working_directory, path, fullpath); - dfs_unlock(); -#else rt_set_errno(-DFS_STATUS_ENOTDIR); return -1; -#endif } /* Check if the path exists or not, raw APIs call, fixme */ @@ -260,12 +240,13 @@ int dfs_mount(const char* device_name, const char* path, { struct dfs_fd fd; - if ( dfile_raw_open(&fd, fullpath, DFS_O_RDONLY | DFS_O_DIRECTORY) < 0 ) + if ( dfs_file_open(&fd, fullpath, DFS_O_RDONLY | DFS_O_DIRECTORY) < 0 ) { + rt_free(fullpath); rt_set_errno(-DFS_STATUS_ENOTDIR); return -1; } - dfile_raw_close(&fd); + dfs_file_close(&fd); } /* check whether the file system mounted or not */ @@ -291,7 +272,7 @@ int dfs_mount(const char* device_name, const char* path, /* register file system */ fs = &(filesystem_table[index]); - strncpy(fs->path, fullpath, strlen(fullpath)); + fs->path = fullpath; fs->ops = ops; fs->dev_id = dev_id; /* release filesystem_table lock */ @@ -308,6 +289,7 @@ int dfs_mount(const char* device_name, const char* path, rt_memset(fs, 0, sizeof(struct dfs_filesystem)); dfs_unlock(); + rt_free(fullpath); rt_set_errno(-DFS_STATUS_ENOSYS); return -1; } @@ -323,6 +305,7 @@ int dfs_mount(const char* device_name, const char* path, rt_memset(fs, 0, sizeof(struct dfs_filesystem)); dfs_unlock(); + rt_free(fullpath); return -1; } @@ -330,42 +313,28 @@ int dfs_mount(const char* device_name, const char* path, err1: dfs_unlock(); + if (fullpath != RT_NULL) rt_free(fullpath); + return -1; } -/* -+------------------------------------------------------------------------------ -| Function : dfs_unmount -+------------------------------------------------------------------------------ -| Description : unmount a filesystem -| -| Parameters : -| Returns : the status of register -| 0 , successful -| -1, failed -+------------------------------------------------------------------------------ -*/ +/** + * this function will umount a file system on specified path. + * + * @param specialfile the specified path which mounted a file system. + * + * @return 0 on successful or -1 on failed. + */ int dfs_unmount(const char *specialfile) { char *fullpath; -#ifdef DFS_USING_WORKDIR - char full_path[DFS_PATH_MAX + 1]; -#endif struct dfs_filesystem* fs = RT_NULL; - fullpath = (char*)specialfile; - if ( fullpath[0] != '/') + fullpath = dfs_normalize_path(RT_NULL, specialfile); + if (fullpath == RT_NULL) { -#ifdef DFS_USING_WORKDIR - /* build full path */ - fullpath = full_path; - dfs_lock(); - build_fullpath(working_directory, specialfile, fullpath); - dfs_unlock(); -#else rt_set_errno(-DFS_STATUS_ENOTDIR); return -1; -#endif } /* lock filesystem */ @@ -385,11 +354,91 @@ int dfs_unmount(const char *specialfile) rt_memset(fs, 0, sizeof(struct dfs_filesystem)); dfs_unlock(); + rt_free(fullpath); return 0; err1: dfs_unlock(); + rt_free(fullpath); return -1; } + +/** + * make a file system on the special device + * + * @param fs_name, the file system name + * @param device_name, the special device name + * + * @return 0 on successful, otherwise failed. + */ +int dfs_mkfs(const char* fs_name, const char* device_name) +{ + int index; + + /* lock filesystem */ + dfs_lock(); + /* find the file system operations */ + for (index = 0; index < DFS_FILESYSTEM_TYPES_MAX; index++) + { + if (filesystem_operation_table[index] != RT_NULL && + strcmp(filesystem_operation_table[index]->name, fs_name) == 0) + { + /* find file system operation */ + const struct dfs_filesystem_operation* ops = filesystem_operation_table[index]; + dfs_unlock(); + + if (ops->mkfs != RT_NULL) + return ops->mkfs(device_name); + + break; + } + } + dfs_unlock(); + + return -1; +} + +/** + * this function will return the information about a mounted file system. + * + * @param path the path which mounted file system. + * @param buffer the buffer to save the returned information. + * + * @return 0 on successful, others on failed. + */ +int dfs_statfs(const char* path, struct dfs_statfs* buffer) +{ + struct dfs_filesystem* fs; + + fs = dfs_filesystem_lookup(path); + if (fs != NULL) + { + if (fs->ops->statfs!= RT_NULL) + return fs->ops->statfs(fs, buffer); + } + + return -1; +} + +#ifdef RT_USING_FINSH +#include +void mkfs(const char* fs_name, const char* device_name) +{ + dfs_mkfs(fs_name, device_name); +} +FINSH_FUNCTION_EXPORT(mkfs, make a file system); + +void df(const char* path) +{ + struct dfs_statfs buffer; + + if (dfs_statfs(path, &buffer) == 0) + { + rt_kprintf("disk free: %d block[%d bytes per block]\n", buffer.f_bfree, buffer.f_bsize); + } +} +FINSH_FUNCTION_EXPORT(df, get disk free); +#endif + diff --git a/components/dfs/src/dfs_init.c b/components/dfs/src/dfs_init.c deleted file mode 100644 index 2667c7dd88..0000000000 --- a/components/dfs/src/dfs_init.c +++ /dev/null @@ -1,84 +0,0 @@ -/* -+------------------------------------------------------------------------------ -| Project : Device Filesystem -+------------------------------------------------------------------------------ -| Copyright 2004, 2005 www.fayfayspace.org. -| All rights reserved. -|------------------------------------------------------------------------------ -| File : dfs.c, the implementation of Device FileSystem -|------------------------------------------------------------------------------ -| Chang Logs: -| Date Author Notes -| 2002-12-31 ffxz The first version. -| 2005-01-22 ffxz Clean up the code. -+------------------------------------------------------------------------------ -*/ -#include -#include - -#include -#include - -#include - -/* Global variables */ -struct dfs_filesystem_operation* filesystem_operation_table[DFS_FILESYSTEM_TYPES_MAX + 1]; -struct dfs_filesystem filesystem_table[DFS_FILESYSTEMS_MAX + 1]; - -/* device filesystem lock */ -struct rt_mutex dlock; - -#ifdef DFS_USING_WORKDIR -char working_directory[DFS_PATH_MAX + 1]; -#endif - -#ifdef DFS_USING_STDIO -struct dfs_fd fd_table[3 + DFS_FD_MAX]; -#else -struct dfs_fd fd_table[DFS_FD_MAX]; -#endif - -/* -+------------------------------------------------------------------------------ -| Function : dfs_init -+------------------------------------------------------------------------------ -| Description : Inits the Device Filesystem -| Parameters : null -| Returns : null -+------------------------------------------------------------------------------ -*/ -void dfs_init() -{ - int index; - - /* clear filesystem operations table */ - for (index = 0; index < DFS_FILESYSTEM_TYPES_MAX + 1; index++) - filesystem_operation_table[index] = RT_NULL; - - /* create device filesystem lock */ - rt_mutex_init(&dlock, "dlock", RT_IPC_FLAG_FIFO); - - /* clear filesystem table */ - rt_memset(filesystem_table, 0, sizeof(filesystem_table)); - -#ifdef DFS_USING_WORKDIR - /* set current working directory */ - strcpy(working_directory, "/"); -#endif - - /* clean fd table */ - rt_memset(fd_table, 0, sizeof(fd_table)); -} - -void dfs_lock() -{ - rt_err_t result; - - result = rt_mutex_take(&dlock, RT_WAITING_FOREVER); - RT_ASSERT(result == RT_EOK); -} - -void dfs_unlock() -{ - rt_mutex_release(&dlock); -} diff --git a/components/dfs/src/dfs_posix.c b/components/dfs/src/dfs_posix.c index 4780cdec2a..8b5918cb58 100644 --- a/components/dfs/src/dfs_posix.c +++ b/components/dfs/src/dfs_posix.c @@ -1,32 +1,30 @@ /* -+------------------------------------------------------------------------------ -| Project : Device Filesystem -+------------------------------------------------------------------------------ -| Copyright 2004, 2005 www.fayfayspace.org. -| All rights reserved. -|------------------------------------------------------------------------------ -| File : dfs_posix.c, the interface related implementations of Device FileSystem -|------------------------------------------------------------------------------ -| Chang Logs: -| Date Author Notes -| 2009-05-27 Yi.qiu The first version. -+------------------------------------------------------------------------------ -*/ -#include -#include + * File : dfs_posix.c + * This file is part of Device File System in RT-Thread RTOS + * COPYRIGHT (C) 2004-2010, 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 + * 2009-05-27 Yi.qiu The first version + */ + +#include #include -/* -+------------------------------------------------------------------------------ -| Function : open -+------------------------------------------------------------------------------ -| Description : -| -| Parameters : -| Returns : -| -+------------------------------------------------------------------------------ -*/ +/** + * this function is a POSIX compliant version, which will open a file and return + * a file descriptor. + * + * @param file the path name of file. + * @param flags the file open flags. + * @param mode + * + * @return the non-negative integer on successful open, others for failed. + */ int open(const char *file, int flags, int mode) { int fd, result; @@ -37,10 +35,12 @@ int open(const char *file, int flags, int mode) if (fd < 0) return -1; d = fd_get(fd); - result = dfile_raw_open(d, file, flags); + result = dfs_file_open(d, file, flags); if (result < 0) { rt_set_errno(result); + + /* release the ref-count of fd */ fd_put(d); fd_put(d); @@ -52,17 +52,14 @@ int open(const char *file, int flags, int mode) return fd; } -/* -+------------------------------------------------------------------------------ -| Function : close -+------------------------------------------------------------------------------ -| Description : -| -| Parameters : -| Returns : -| -+------------------------------------------------------------------------------ -*/ +/** + * this function is a POSIX compliant version, which will close the open + * file descriptor. + * + * @param fd the file descriptor. + * + * @return 0 on successful, -1 on failed. + */ int close(int fd) { int result; @@ -75,8 +72,7 @@ int close(int fd) return -1; } - result = dfile_raw_close(d); - fd_put(d); + result = dfs_file_close(d); fd_put(d); if (result < 0) @@ -84,20 +80,21 @@ int close(int fd) rt_set_errno(result); return -1; } + + fd_put(d); return 0; } -/* -+------------------------------------------------------------------------------ -| Function : read -+------------------------------------------------------------------------------ -| Description : -| -| Parameters : -| Returns : -| -+------------------------------------------------------------------------------ -*/ +/** + * this function is a POSIX compliant version, which will read specified data buffer + * length for an open file descriptor. + * + * @param fd the file descriptor. + * @param buf the buffer to save the read data. + * @param len the maximal length of data buffer + * + * @return the actual read data buffer length + */ int read(int fd, char *buf, int len) { int result; @@ -111,7 +108,7 @@ int read(int fd, char *buf, int len) return -1; } - result = dfile_raw_read(d, buf, len); + result = dfs_file_read(d, buf, len); if (result < 0) { rt_set_errno(result); @@ -125,17 +122,16 @@ int read(int fd, char *buf, int len) return result; } -/* -+------------------------------------------------------------------------------ -| Function : write -+------------------------------------------------------------------------------ -| Description : -| -| Parameters : -| Returns : -| -+------------------------------------------------------------------------------ -*/ +/** + * this function is a POSIX compliant version, which will write pecified data buffer + * length for an open file descriptor. + * + * @param fd the file descriptor + * @param buf the data buffer to be written. + * @param len the data buffer length. + * + * @return the actual written data buffer length. + */ int write(int fd, char *buf, int len) { int result; @@ -149,7 +145,7 @@ int write(int fd, char *buf, int len) return -1; } - result = dfile_raw_write(d, buf, len); + result = dfs_file_write(d, buf, len); if (result < 0) { rt_set_errno(result); @@ -163,17 +159,16 @@ int write(int fd, char *buf, int len) return result; } -/* -+------------------------------------------------------------------------------ -| Function : lseek -+------------------------------------------------------------------------------ -| Description : -| -| Parameters : -| Returns : -| -+------------------------------------------------------------------------------ -*/ +/** + * this function is a POSIX compliant version, which will seek the offset for an + * open file descriptor. + * + * @param fd the file descriptor. + * @param offset the offset to be seeked. + * @param dir the directory of seek. + * + * @return the current file position, or -1 on failed. + */ int lseek(int fd, int offset, int dir) { int result; @@ -200,7 +195,7 @@ int lseek(int fd, int offset, int dir) break; } - result = dfile_raw_lseek(d, offset); + result = dfs_file_lseek(d, offset); if (result < 0) { rt_set_errno(result); @@ -213,22 +208,22 @@ int lseek(int fd, int offset, int dir) return offset; } -/* -+------------------------------------------------------------------------------ -| Function : rename -+------------------------------------------------------------------------------ -| Description : -| -| Parameters : -| Returns : -| -+------------------------------------------------------------------------------ -*/ -int rename(const char* old, const char* new ) +/** + * this function is a POSIX compliant version, which will rename old file name to + * new file name. + * + * @param old the old file name. + * @param new the new file name. + * + * @return 0 on successful, -1 on failed. + * + * note: the old and new file name must be belong to a same file system. + */ +int rename(const char* old, const char* new) { int result; - result = dfile_raw_rename(old, new); + result = dfs_file_rename(old, new); if (result < 0) { rt_set_errno(result); @@ -237,22 +232,19 @@ int rename(const char* old, const char* new ) return 0; } -/* -+------------------------------------------------------------------------------ -| Function : unlink -+------------------------------------------------------------------------------ -| Description : -| -| Parameters : -| Returns : -| -+------------------------------------------------------------------------------ -*/ +/** + * this function is a POSIX compliant version, which will unlink (remove) a + * specified path file from file system. + * + * @param pathname the specified path name to be unlinked. + * + * @return 0 on successful, -1 on failed. + */ int unlink(const char *pathname) { int result; - result = dfile_raw_unlink(pathname); + result = dfs_file_unlink(pathname); if (result < 0) { rt_set_errno(result); @@ -261,22 +253,19 @@ int unlink(const char *pathname) return 0; } -/* -+------------------------------------------------------------------------------ -| Function : stat -+------------------------------------------------------------------------------ -| Description : -| -| Parameters : -| Returns : -| -+------------------------------------------------------------------------------ -*/ +/** + * this function is a POSIX compliant version, which will get file information. + * + * @param file the file name + * @param buf the the data buffer to save stat description. + * + * @return 0 on successful, -1 on failed. + */ int stat(const char *file, struct dfs_stat *buf) { int result; - result = dfile_raw_stat(file, (struct dfs_stat *)buf); + result = dfs_file_stat(file, buf); if (result < 0) { rt_set_errno(result); @@ -285,17 +274,37 @@ int stat(const char *file, struct dfs_stat *buf) return result; } -/* -+------------------------------------------------------------------------------ -| Function : mkdir -+------------------------------------------------------------------------------ -| Description : -| -| Parameters : -| Returns : -| -+------------------------------------------------------------------------------ -*/ +/** + * this function is a POSIX compliant version, which will return the + * information about a mounted file system. + * + * @param path the path which mounted file system. + * @param buf the buffer to save the returned information. + * + * @return 0 on successful, others on failed. + */ +int statfs(const char *path, struct dfs_statfs *buf) +{ + int result; + + result = dfs_statfs(path, buf); + if (result < 0) + { + rt_set_errno(result); + return -1; + } + + return result; +} + +/** + * this function is a POSIX compliant version, which will make a directory + * + * @param path the directory path to be made. + * @param mode + * + * @return 0 on successful, others on failed. + */ int mkdir (const char *path, rt_uint16_t mode) { int fd; @@ -305,9 +314,7 @@ int mkdir (const char *path, rt_uint16_t mode) fd = fd_new(); d = fd_get(fd); - result = dfile_raw_open(d, path, DFS_O_DIRECTORY | DFS_O_CREAT); - fd_put(d); - fd_put(d); + result = dfs_file_open(d, path, DFS_O_DIRECTORY | DFS_O_CREAT); if (result < 0) { @@ -315,25 +322,23 @@ int mkdir (const char *path, rt_uint16_t mode) return -1; } + fd_put(d); + fd_put(d); return 0; } -/* -+------------------------------------------------------------------------------ -| Function : rmdir -+------------------------------------------------------------------------------ -| Description : -| -| Parameters : -| Returns : -| -+------------------------------------------------------------------------------ -*/ +/** + * this function is a POSIX compliant version, which will remove a directory. + * + * @param pathname the path name to be removed. + * + * @return 0 on sucessfull, others on failed. + */ int rmdir(const char *pathname) { int result; - result = dfile_raw_unlink(pathname); + result = dfs_file_unlink(pathname); if (result < 0) { rt_set_errno(result); @@ -343,17 +348,13 @@ int rmdir(const char *pathname) return 0; } -/* -+------------------------------------------------------------------------------ -| Function : opendir -+------------------------------------------------------------------------------ -| Description : -| -| Parameters : -| Returns : -| -+------------------------------------------------------------------------------ -*/ +/** + * this function is a POSIX compliant version, which will open a directory. + * + * @param name the path name to be open. + * + * @return the DIR pointer of directory, NULL on open failed. + */ DIR* opendir(const char* name) { struct dfs_fd* d; @@ -367,14 +368,14 @@ DIR* opendir(const char* name) if (fd == -1) { rt_kprintf("no fd\n"); return RT_NULL; } d = fd_get(fd); - result = dfile_raw_open(d, name, DFS_O_RDONLY | DFS_O_DIRECTORY); + result = dfs_file_open(d, name, DFS_O_RDONLY | DFS_O_DIRECTORY); if (result >= 0) { /* open successfully */ t = (DIR *) rt_malloc (sizeof(DIR)); if (t == RT_NULL) { - dfile_raw_close(d); + dfs_file_close(d); fd_put(d); } else @@ -394,17 +395,15 @@ DIR* opendir(const char* name) return RT_NULL; } -/* -+------------------------------------------------------------------------------ -| Function : readdir -+------------------------------------------------------------------------------ -| Description : -| -| Parameters : -| Returns : -| -+------------------------------------------------------------------------------ -*/ +/** + * this function is a POSIX compliant version, which will return a pointer + * to a dirent structure representing the next directory entry in the + * directory stream. + * + * @param d the directory stream pointer. + * + * @return the next directory entry, NULL on the end of directory or failed. + */ struct dfs_dirent* readdir(DIR *d) { int result; @@ -419,7 +418,7 @@ struct dfs_dirent* readdir(DIR *d) if (!d->num || (d->cur += ((struct dfs_dirent*)(d->buf + d->cur))->d_reclen) >= d->num) { - result = dfile_raw_getdents(fd, (struct dfs_dirent*)d->buf, sizeof(d->buf) - 1); + result = dfs_file_getdents(fd, (struct dfs_dirent*)d->buf, sizeof(d->buf) - 1); if (result <= 0) { rt_set_errno(result); @@ -436,17 +435,14 @@ struct dfs_dirent* readdir(DIR *d) return (struct dfs_dirent*)(d->buf+d->cur); } -/* -+------------------------------------------------------------------------------ -| Function : telldir -+------------------------------------------------------------------------------ -| Description : -| -| Parameters : -| Returns : -| -+------------------------------------------------------------------------------ -*/ +/** + * this function is a POSIX compliant version, which will return current + * location in directory stream. + * + * @param d the directory stream pointer. + * + * @return the current location in directory stream. + */ rt_off_t telldir(DIR *d) { struct dfs_fd* fd; @@ -465,17 +461,13 @@ rt_off_t telldir(DIR *d) return result; } -/* -+------------------------------------------------------------------------------ -| Function : seekdir -+------------------------------------------------------------------------------ -| Description : -| -| Parameters : -| Returns : -| -+------------------------------------------------------------------------------ -*/ +/** + * this function is a POSIX compliant version, which will set position of + * next directory structure in the directory stream. + * + * @param d the directory stream. + * @param offset the offset in directory stream. + */ void seekdir(DIR *d, rt_off_t offset) { struct dfs_fd* fd; @@ -487,21 +479,15 @@ void seekdir(DIR *d, rt_off_t offset) return ; } - if (dfile_raw_lseek(fd, offset) >= 0) d->num = d->cur = 0; + if (dfs_file_lseek(fd, offset) >= 0) d->num = d->cur = 0; fd_put(fd); } -/* -+------------------------------------------------------------------------------ -| Function : rewinddir -+------------------------------------------------------------------------------ -| Description : -| -| Parameters : -| Returns : -| -+------------------------------------------------------------------------------ -*/ +/** + * this function is a POSIX compliant version, which will reset directory stream. + * + * @param d the directory stream. + */ void rewinddir(DIR *d) { struct dfs_fd* fd; @@ -513,21 +499,18 @@ void rewinddir(DIR *d) return ; } - if (dfile_raw_lseek(fd, 0) >= 0) d->num = d->cur = 0; + if (dfs_file_lseek(fd, 0) >= 0) d->num = d->cur = 0; fd_put(fd); } -/* -+------------------------------------------------------------------------------ -| Function : closedir -+------------------------------------------------------------------------------ -| Description : -| -| Parameters : -| Returns : -| -+------------------------------------------------------------------------------ -*/ +/** + * this function is a POSIX compliant version, which will close a directory + * stream. + * + * @param d the directory stream. + * + * @return 0 on successful, -1 on failed. + */ int closedir(DIR* d) { int result; @@ -540,7 +523,7 @@ int closedir(DIR* d) return -1; } - result = dfile_raw_close(fd); + result = dfs_file_close(fd); fd_put(fd); fd_put(fd); @@ -554,60 +537,58 @@ int closedir(DIR* d) else return 0; } -/* -+------------------------------------------------------------------------------ -| Function : chdir -+------------------------------------------------------------------------------ -| Description : -| -| Parameters : -| Returns : -| -+------------------------------------------------------------------------------ -*/ +#ifdef DFS_USING_WORKDIR +/** + * this function is a POSIX compliant version, which will change working directory. + * + * @param path the path name to be changed to. + * + * @return 0 on successful, -1 on failed. + */ int chdir(const char *path) { - char* fullpath, full_path[DFS_PATH_MAX + 1]; + char* fullpath; + DIR* d; if(path == RT_NULL || rt_strlen(path) > DFS_PATH_MAX) return -1; - fullpath = (char*)path; - if ( fullpath[0] != '/' ) + fullpath = dfs_normalize_path(NULL, path); + if (fullpath == RT_NULL) + return -1; /* build path failed */ + + dfs_lock(); + d = opendir(fullpath); + if (d == RT_NULL) { - /* build full path */ - fullpath = full_path; -#ifdef DFS_USING_WORKDIR - dfs_lock(); - build_fullpath(working_directory, path, fullpath); - strcpy(working_directory, fullpath); + rt_free(fullpath); + /* this is a not exist directory */ dfs_unlock(); -#endif - } - else - { -#ifdef DFS_USING_WORKDIR - dfs_lock(); - rt_strncpy(working_directory, path, strlen(path) + 1); - working_directory[strlen(path)] = '\0'; - dfs_unlock(); -#endif + return -1; } + /* close directory stream */ + closedir(d); + + /* copy full path to working directory */ + strncpy(working_directory, fullpath, DFS_PATH_MAX); + rt_free(fullpath); /* release normalize directory path name */ + + dfs_unlock(); + return 0; } +#endif -/* -+------------------------------------------------------------------------------ -| Function : chdir -+------------------------------------------------------------------------------ -| Description : -| -| Parameters : -| Returns : -| -+------------------------------------------------------------------------------ -*/ +/** + * this function is a POSIX compliant version, which will return current + * working directory. + * + * @param buf the returned current directory. + * @size the buffer size. + * + * @return the returned current directory. + */ char* getcwd(char *buf, rt_size_t size) { #ifdef DFS_USING_WORKDIR diff --git a/components/dfs/src/dfs_raw.c b/components/dfs/src/dfs_raw.c deleted file mode 100644 index c96b4089bd..0000000000 --- a/components/dfs/src/dfs_raw.c +++ /dev/null @@ -1,684 +0,0 @@ -/* -+------------------------------------------------------------------------------ -| Project : Device Filesystem -+------------------------------------------------------------------------------ -| Copyright 2004, 2005 www.fayfayspace.org. -| All rights reserved. -|------------------------------------------------------------------------------ -| File : dfs_raw.c, the raw APIs of Device FileSystem -|------------------------------------------------------------------------------ -| Chang Logs: -| Date Author Notes -| 2005-02-22 ffxz The first version. -+------------------------------------------------------------------------------ -*/ -#include -#include -#include - -extern struct dfs_fd fd_table[]; - -#define NO_WORKING_DIR "system does not support working dir\n" - -/* -+------------------------------------------------------------------------------ -| Function : fd_new -+------------------------------------------------------------------------------ -| Description : -| -| Parameters : -| Returns : -| -+------------------------------------------------------------------------------ -*/ -int fd_new(void) -{ - struct dfs_fd* d; - int idx; - - /* lock filesystem */ - dfs_lock(); - - /* find an empty fd entry */ -#ifdef DFS_USING_STDIO - for (idx = 3; idx < DFS_FD_MAX + 3 && fd_table[idx].ref_count > 0; idx++); -#else - for (idx = 0; idx < DFS_FD_MAX && fd_table[idx].ref_count > 0; idx++); -#endif - - /* can't find an empty fd entry */ -#ifdef DFS_USING_STDIO - if (idx == DFS_FD_MAX + 3) -#else - if (idx == DFS_FD_MAX) -#endif - { - idx = -1; - goto __result; - } - - d = &(fd_table[idx]); - d->ref_count = 1; - -__result: - dfs_unlock(); - return idx; -} - -/* -+------------------------------------------------------------------------------ -| Function : fd_get -+------------------------------------------------------------------------------ -| Description : -| -| Parameters : -| Returns : -| -+------------------------------------------------------------------------------ -*/ -struct dfs_fd* fd_get(int fd) -{ - struct dfs_fd* d; - -#ifdef DFS_USING_STDIO - if ( fd < 3 || fd > DFS_FD_MAX + 3) return RT_NULL; -#else - if ( fd < 0 || fd > DFS_FD_MAX ) return RT_NULL; -#endif - - d = &fd_table[fd]; - - dfs_lock(); - d->ref_count ++; - dfs_unlock(); - - return d; -} - -/* -+------------------------------------------------------------------------------ -| Function : fd_put -+------------------------------------------------------------------------------ -| Description : -| -| Parameters : -| Returns : -| -+------------------------------------------------------------------------------ -*/ -void fd_put(struct dfs_fd* fd) -{ - dfs_lock(); - fd->ref_count --; - /* clear this fd entry */ - if ( fd->ref_count == 0 ) - { - rt_memset(fd, 0, sizeof(struct dfs_fd)); - } - dfs_unlock(); -}; - -/* -+------------------------------------------------------------------------------ -| Function : dfile_raw_open -+------------------------------------------------------------------------------ -| Description : -| -| Parameters : -| Returns : -| -+------------------------------------------------------------------------------ -*/ -int dfile_raw_open(struct dfs_fd* fd, const char *path, int flags) -{ - struct dfs_filesystem* fs; - char *fullpath; -#ifdef DFS_USING_WORKDIR - char full_path[DFS_PATH_MAX + 1]; -#endif - int fspathlen, result; - - /* parameter check */ - if ( fd == RT_NULL ) return -DFS_STATUS_EINVAL; - - /* make sure we have an absolute path */ - fullpath = (char*)path; - if ( fullpath[0] != '/') - { -#ifdef DFS_USING_WORKDIR - /* build full path */ - fullpath = &full_path[0]; - dfs_lock(); - build_fullpath(working_directory, path, fullpath); - dfs_unlock(); -#else - rt_kprintf(NO_WORKING_DIR); - return -1; -#endif - } - - dfs_log(DFS_DEBUG_INFO, ("open file:%s", fullpath)); - - /* find filesystem */ - fs = dfs_filesystem_lookup(fullpath); - if ( fs == RT_NULL ) return -DFS_STATUS_ENOENT; - - dfs_log(DFS_DEBUG_INFO, ("open in filesystem:%s", fs->ops->name)); - fd->fs = fs; - - /* initilize the fd item */ - fd->type = FT_REGULAR; - //fd->ref_count = 1; - fd->flags = flags; - fd->size = 0; - fd->pos = 0; - - fspathlen = strlen(fs->path); - rt_memset(fd->path, 0, DFS_PATH_MAX + 1); - if (*(fullpath + fspathlen) != '/') strcpy(fd->path, "/"); - strcat(fd->path, fullpath + fspathlen); - - /* specific file system open routine */ - if (fs->ops->open == RT_NULL) - { - /* clear fd */ - rt_memset(fd->path, 0, DFS_PATH_MAX + 1); - - fd->type = FT_REGULAR; - fd->ref_count = 0; - fd->fs = RT_NULL; - fd->flags = 0; - fd->size = 0; - fd->pos = 0; - fd->data = RT_NULL; - - return -DFS_STATUS_ENOSYS; - } - - if ((result = fs->ops->open(fd)) < 0) - { - /* clear fd */ - fd->fs = RT_NULL; - fd->flags = 0; - fd->data = RT_NULL; - - 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; -} - -/* -+------------------------------------------------------------------------------ -| Function : dfile_raw_close -+------------------------------------------------------------------------------ -| Description : -| -| Parameters : -| Returns : -| -+------------------------------------------------------------------------------ -*/ -int dfile_raw_close(struct dfs_fd* fd) -{ - int result = 0; - - 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; - - fd->flags &= ~DFS_F_OPEN; - - return result; -} - -/* -+------------------------------------------------------------------------------ -| Function : dfile_raw_ioctl -+------------------------------------------------------------------------------ -| Description : -| -| Parameters : -| Returns : -| -+------------------------------------------------------------------------------ -*/ -int dfile_raw_ioctl(struct dfs_fd* fd, int cmd, void *args) -{ - struct dfs_filesystem* fs; - - if (fd == RT_NULL || fd->type != FT_REGULAR) return -DFS_STATUS_EINVAL; - - fs = fd->fs; -#if 0 /* not support right now */ - if (cmd == FILEGETSIZE) - { - if (args == RT_NULL) return -DFS_STATUS_EINVAL; - - *((rt_uint32_t *) args) = fd->size; - - return 0; - } - else if (cmd == FILEGETPOS) - { - if (args == RT_NULL) return -DFS_STATUS_EINVAL; - - *((rt_uint32_t *) args) = fd->pos; - - return 0; - } -#endif - - if (fs->ops->ioctl != RT_NULL) return fs->ops->ioctl(fd, cmd, args); - - return -DFS_STATUS_ENOSYS; -} - -/* -+------------------------------------------------------------------------------ -| Function : dfile_raw_read -+------------------------------------------------------------------------------ -| Description : -| -| Parameters : -| Returns : -| -+------------------------------------------------------------------------------ -*/ -int dfile_raw_read(struct dfs_fd* fd, void *buf, rt_size_t len) -{ - struct dfs_filesystem* fs; - int result = 0; - - if (fd == RT_NULL) return -DFS_STATUS_EINVAL; - - 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; - - return result; -} - -/* -+------------------------------------------------------------------------------ -| Function : dfile_raw_getdents -+------------------------------------------------------------------------------ -| Description : -| -| Parameters : -| Returns : -| -+------------------------------------------------------------------------------ -*/ -int dfile_raw_getdents(struct dfs_fd* fd, struct dfs_dirent* dirp, rt_size_t nbytes) -{ - struct dfs_filesystem* fs; - - /* 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); - - return -DFS_STATUS_ENOSYS; -} - -/* -+------------------------------------------------------------------------------ -| Function : dfile_raw_unlink -+------------------------------------------------------------------------------ -| Description : -| -| Parameters : -| Returns : -| -+------------------------------------------------------------------------------ -*/ -int dfile_raw_unlink(const char *path) -{ - struct dfs_filesystem* fs; - char *fullpath, *real_path, search_path[DFS_PATH_MAX + 1]; -#ifdef DFS_USING_WORKDIR - char full_path[DFS_PATH_MAX+1]; -#endif - struct dfs_fd* fd; - int index, fspathlen; - - /* Make sure we have an absolute path */ - fullpath = (char*)path; - if ( fullpath[0] != '/') - { -#ifdef DFS_USING_WORKDIR - /* build full path */ - fullpath = full_path; - dfs_lock(); - build_fullpath(working_directory, path, fullpath); - dfs_unlock(); -#else - rt_kprintf(NO_WORKING_DIR); - return -1; -#endif - } - - if ( (fs = dfs_filesystem_lookup(fullpath)) == RT_NULL) return -DFS_STATUS_ENOENT; - - /* Check whether file is already open */ - dfs_lock(); - for (index = 0; index < DFS_FD_MAX; index++) - { - fd = &(fd_table[index]); - if (fd->fs == RT_NULL) continue; - - build_fullpath(fd->fs->path, fd->path, search_path); - if (strcmp(fullpath, search_path) == 0) - { - dfs_unlock(); - return -DFS_STATUS_EEXIST; - } - } - dfs_unlock(); - - fspathlen = strlen(fs->path); - real_path = search_path; - rt_memset( real_path, 0, sizeof( real_path ) ); - if (*(fullpath + fspathlen) != '/') strcpy(real_path, "/"); - strcat(real_path, fullpath + fspathlen); - - if (fs->ops->unlink != RT_NULL) return fs->ops->unlink(fs, real_path); - - return -DFS_STATUS_ENOSYS; -} - -/* -+------------------------------------------------------------------------------ -| Function : dfile_raw_write -+------------------------------------------------------------------------------ -| Description : -| -| Parameters : -| Returns : -| -+------------------------------------------------------------------------------ -*/ -int dfile_raw_write(struct dfs_fd* fd, const void *buf, rt_size_t len) -{ - struct dfs_filesystem* fs = fd->fs; - - if (fd == RT_NULL) return -DFS_STATUS_EINVAL; - if (fs->ops->write == RT_NULL) return -DFS_STATUS_ENOSYS; - - return fs->ops->write(fd, buf, len); -} - -/* -+------------------------------------------------------------------------------ -| Function : dfile_raw_lseek -+------------------------------------------------------------------------------ -| Description : -| -| Parameters : -| Returns : -| -+------------------------------------------------------------------------------ -*/ -int dfile_raw_lseek(struct dfs_fd* fd, rt_off_t offset) -{ - struct dfs_filesystem* fs = fd->fs; - - if (fd == RT_NULL) return -DFS_STATUS_EINVAL; - if (fs->ops->lseek == RT_NULL) return -DFS_STATUS_ENOSYS; - - return fs->ops->lseek(fd, offset); -} - -/* -+------------------------------------------------------------------------------ -| Function : dfile_raw_stat -+------------------------------------------------------------------------------ -| Description : get the file or directory stat description -| -| Parameters : path, the file or directory path -| buf, the stat description will be saved in it -| Returns : -| -+------------------------------------------------------------------------------ -*/ -int dfile_raw_stat(const char *path, struct dfs_stat *buf) -{ - struct dfs_filesystem* fs; - char* fullpath, real_path[DFS_PATH_MAX + 1]; -#ifdef DFS_USING_WORKDIR - char full_path[DFS_PATH_MAX + 1]; -#endif - int fspathlen; - - fullpath = (char*)path; - if ( fullpath[0] != '/' ) - { -#ifdef DFS_USING_WORKDIR - /* build full path */ - fullpath = full_path; - dfs_lock(); - build_fullpath(working_directory, path, fullpath); - dfs_unlock(); -#else - rt_kprintf(NO_WORKING_DIR); - return -1; -#endif - } - - if ( (fs = dfs_filesystem_lookup(fullpath)) == RT_NULL ) - { - dfs_log(DFS_DEBUG_ERROR, ("can't find mounted filesystem on this path:%s", fullpath)); - return -DFS_STATUS_ENOENT; - } - - fspathlen = strlen(fs->path); - rt_memset(real_path, 0, sizeof(real_path)); - if (*(fullpath + fspathlen) != '/') real_path[0] = '/'; - strcat(real_path, fullpath + fspathlen); - - if (real_path[0] == '/' && real_path[1] == '\0') - { - /* 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; - return DFS_STATUS_OK; - } - - if (fs->ops->stat == RT_NULL) - { - dfs_log(DFS_DEBUG_ERROR, ("the filesystem didn't implement this function")); - return -DFS_STATUS_ENOSYS; - } - - return fs->ops->stat(fs, real_path, buf); -} - -/* -+------------------------------------------------------------------------------ -| Function : dfile_raw_rename -+------------------------------------------------------------------------------ -| Description : -| -| Parameters : -| Returns : -| -+------------------------------------------------------------------------------ -*/ -int dfile_raw_rename(const char* oldpath, const char* newpath) -{ - struct dfs_filesystem *oldfs, *newfs; - char *oldfullpath, *newfullpath; -#ifdef DFS_USING_WORKDIR - /* Change DFS_PATH_MAX to DFS_PATH_MAX + 1, yi.qiu@2008.09.23*/ - char old_realpath[DFS_PATH_MAX + 1], new_realpath[DFS_PATH_MAX + 1]; -#endif - - oldfullpath = (char*)oldpath; - newfullpath = (char*)newpath; - - if ( oldfullpath[0] != '/' ) - { -#ifdef DFS_USING_WORKDIR - /* build full path */ - oldfullpath = old_realpath; - dfs_lock(); - build_fullpath(working_directory, oldpath, oldfullpath); - dfs_unlock(); -#else - rt_kprintf(NO_WORKING_DIR); - return -1; -#endif - } - - if ( newfullpath[0] != '/' ) - { -#ifdef DFS_USING_WORKDIR - /* build full path */ - newfullpath = new_realpath; - dfs_lock(); - build_fullpath(working_directory, newpath, newfullpath); - dfs_unlock(); -#else - rt_kprintf(NO_WORKING_DIR); - return -1; -#endif - } - - if ( (oldfs = dfs_filesystem_lookup(oldfullpath)) == RT_NULL ) - { - return -DFS_STATUS_ENOENT; - } - - if ( (newfs = dfs_filesystem_lookup(newfullpath)) == RT_NULL ) - { - return -DFS_STATUS_ENOENT; - } - - if ( oldfs == newfs ) - { - if ( oldfs->ops->rename == RT_NULL ) return -DFS_STATUS_ENOSYS; - - return oldfs->ops->rename(oldfs, oldfullpath, newfullpath); - } - - /* not at same file system, return EXDEV */ - return -DFS_STATUS_EXDEV; -} - -#ifdef RT_USING_FINSH -#include - -static char fullpath[256 + 1]; -static struct dfs_fd fd; -static struct dfs_dirent dirent; -void ls(const char* pathname) -{ - struct dfs_stat stat; - int length; - - /* list directory */ - if ( dfile_raw_open(&fd, pathname, DFS_O_DIRECTORY) == 0 ) - { - rt_kprintf("Directory %s:\n", pathname); - do - { - rt_memset(&dirent, 0, sizeof(struct dfs_dirent)); - length = dfile_raw_getdents(&fd, &dirent, sizeof(struct dfs_dirent)); - if ( length > 0 ) - { - rt_memset(&stat, 0, sizeof(struct dfs_stat)); - - /* build full path for each file */ - if (pathname[strlen(pathname) - 1] != '/') - rt_snprintf(fullpath, sizeof(fullpath), "%s%c%s", pathname, '/', dirent.d_name); - else - rt_snprintf(fullpath, sizeof(fullpath), "%s%s", pathname, dirent.d_name); - - dfile_raw_stat(fullpath, &stat); - if ( stat.st_mode & DFS_S_IFDIR ) - { - rt_kprintf("%s\t\t\n", dirent.d_name); - } - else - { - rt_kprintf("%s\t\t%lu\n", dirent.d_name, stat.st_size); - } - } - }while(length > 0); - - dfile_raw_close(&fd); - } - else - { - rt_kprintf("No such directory\n"); - } -} -FINSH_FUNCTION_EXPORT(ls, list directory contents) - -static void mkdir(const char* pathname) -{ - /* make a new directory */ - if (dfile_raw_open(&fd, pathname, DFS_O_DIRECTORY | DFS_O_CREAT) == 0) - { - dfile_raw_close(&fd); - } - else rt_kprintf("Can't mkdir %s\n", pathname); -} -FINSH_FUNCTION_EXPORT(mkdir, make a directory) - -void rm(const char* filename) -{ - if (dfile_raw_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 (dfile_raw_open(&fd, filename, DFS_O_RDONLY) < 0) - { - rt_kprintf("Open %s failed\n", filename); - return; - } - - do - { - rt_memset(buffer, 0, sizeof(buffer)); - length = dfile_raw_read(&fd, buffer, 81); - if (length > 0) - { - rt_kprintf("%s", buffer); - } - }while (length > 0); - - dfile_raw_close(&fd); -} -FINSH_FUNCTION_EXPORT(cat, print file) - -#endif diff --git a/components/dfs/src/dfs_util.c b/components/dfs/src/dfs_util.c deleted file mode 100644 index af7bab3bf6..0000000000 --- a/components/dfs/src/dfs_util.c +++ /dev/null @@ -1,295 +0,0 @@ -/* -+------------------------------------------------------------------------------ -| Project : Device Filesystem -+------------------------------------------------------------------------------ -| Copyright 2004, 2005 www.fayfayspace.org. -| All rights reserved. -|------------------------------------------------------------------------------ -| File : dfs_utl.c, some misc functions of Device FileSystem -|------------------------------------------------------------------------------ -| Chang Logs: -| Date Author Notes -| 2005-01-26 ffxz The first version -+------------------------------------------------------------------------------ -*/ - -#include - -#include -#include - -/* -+------------------------------------------------------------------------------ -| Function : dir_name -+------------------------------------------------------------------------------ -| Description : Gets the directory name in specified path string -| -| Parameters : path, the specified path string -| path_name, return the path name in this parameter -| len, the length of path name -| Returns : the status of path_name: -| 0 , successful -| -1, failed -| For Example : -| path, dir_name -| /, / -| /usr, / -| /usr/lib, /usr -| /usr/lib/, /usr -+------------------------------------------------------------------------------ -*/ -int dir_name(const char* path, char* dirname, int len) -{ - int pos; - - if ( path[0] == '/' && path[1] == '\0' ) - { - *dirname++ = '/'; - *dirname = '\0'; - return 0; - } - - pos = strlen(path); - while ( *(path + pos - 1) =='/' ) pos --; - while ( pos > 0 && *(path + pos - 1) != '/' ) pos --; - while ( pos > 0 && *(path + pos - 1) == '/' ) pos --; - - if ( pos > len ) return -1; - - if ( pos != 0) - { - memcpy(dirname, path, pos); - *(dirname+pos) = '\0'; - } - else - { - *dirname++ = '/'; - *dirname = '\0'; - } - - return 0; -} - -/* -+------------------------------------------------------------------------------ -| Function : file_name -+------------------------------------------------------------------------------ -| Description : Gets the file name in specified path string -| -| Parameters : path, the specified path string -| filename, return the path name in this parameter -| len, the length of file name -| Returns : the status of file_name: -| 0 , successful -| -1, failed -| For Example : -| path, filename -| /, RT_NULL -| /usr, usr -| /usr/lib, lib -| /usr/lib/, lib -+------------------------------------------------------------------------------ -*/ -int file_name(const char* path, char* filename, int len) -{ - int pos, size; - - if ( path[0] == '/' && path[1] == '\0' ) - { - *filename = '\0'; - return 0; - } - - pos = strlen(path); - while ( *(path + pos -1)=='/' ) pos --; - size = pos; - - while ( *(path + pos -1) != '/' && pos > 0 ) pos --; - - if ( size - pos > len ) return -1; - else size = size - pos ; - - memcpy(filename, path + pos, size); - *(filename+size) = '\0'; - - return 0; -} - -/* -+------------------------------------------------------------------------------ -| Function : next_path_name -+------------------------------------------------------------------------------ -| Description : Gets the next directory name from specified path string -| -| Parameters : path, the specified path string -| pos, the specified position of path string -| next, return the next path in this parameter -| Returns : the position of next directory item, -| -1, if pos reach in the end of the specified path string -| For Example : -+------------------------------------------------------------------------------ -*/ -int next_dir_name(const char* path, int pos, char* next) -{ - const char* q; - - if ( pos > strlen(path) || pos < 0|| path == RT_NULL ) return -1; - - q = path + pos; - - /* check for firt '/' */ - while ( *q == '/' ) q++; - if ( *q == '\0' ) - { - *next = '\0'; - return -1; - } - - while ( *q != '/' && *q != '\0' ) - { - *next++ = *q++; - } - *next = '\0'; - - return q - path + 1; -} - -/* -+------------------------------------------------------------------------------ -| Function : build_fullpath -+------------------------------------------------------------------------------ -| Description : make up the full path from directory and filename -| -| Parameters : path, the specified path string -| filename, return the path name in this parameter -| fullpath, the returned full path name -| Returns : null -+------------------------------------------------------------------------------ -*/ -void build_fullpath(const char *directory, const char *filename, char *fullpath) -{ - char elem[DFS_PATH_MAX + 1]; - int pos, start, len; - - len = 0; - /* check parameters */ - RT_ASSERT(directory != RT_NULL); - RT_ASSERT(filename != RT_NULL); - RT_ASSERT(fullpath != RT_NULL); - - /* copy full of directory */ - strncpy(fullpath, directory, DFS_PATH_MAX + 1); - - for (pos = 0; filename[pos] != '\0'; ) - { - /* strip '//' */ - while (filename[pos] == '/') pos++; - - /* get the filename element, save to elem array */ - for (start = pos; filename[pos] != '/' && filename[pos] != '\0'; pos++) - len = pos - start + 1; - - strncpy(elem, filename + start, DFS_PATH_MAX + 1); - /* clear the end of elem */ - elem[(len < DFS_PATH_MAX + 1? len : DFS_PATH_MAX + 1)] = '\0'; - - /* strip '..' */ - if (elem[0] == '.' && elem[1] == '.') - { - if (strlen(fullpath) == 0) strcpy(fullpath, ""); /* empty filename */ - else if (fullpath[0] == '/' && fullpath[1] !='\0') - { - int i = strlen(fullpath); - - while (fullpath[i - 1] == '/') i--; - while (i > 0 && fullpath[i - 1] != '/') i--; - - fullpath[i] = '\0'; - } - } - /* not '.', copy as normally */ - else if (elem[0] != '.') - { - len = strlen(fullpath); - - if (len == 0) strncpy(fullpath, elem, DFS_PATH_MAX + 1); - else if (fullpath[len - 1] == '/') - { - if (elem[0] == '/') strncat(fullpath, elem + 1, DFS_PATH_MAX + 1); - else strncat(fullpath, elem, DFS_PATH_MAX + 1); - } - else - { - if (elem[0] == '/') strcat(fullpath, elem); - else - { - strncat(fullpath, "/", DFS_PATH_MAX + 1); - strncat(fullpath + 1, elem, DFS_PATH_MAX + 1); - } - } - } - } - - if ( fullpath[0] != '/' && fullpath[(len = strlen(fullpath)) - 1] == '/') - { - fullpath[len - 1] = '\0'; - } -} - -int str_is_prefix(const char* prefix, const char* str) -{ - while ((*prefix) && (*str) && (*prefix == *str)) - { - prefix ++; - str ++; - } - - if (*prefix == 0) return 0; - - return -1; -} - -#if !defined(RT_USING_MINILIBC) && !defined(RT_USING_NEWLIB) -#if !defined(__ICCARM__) -char *strrchr(const char *t, int c) -{ - register char ch; - register const char *l=0; - - ch = c; - for (;;) - { - if ((*t == ch)) l=t; - if ((!*t)) return (char*)l; ++t; - } -} -#endif - -#if defined (__ARMCC_VERSION) && (__ARMCC_VERSION / 10000 < 35) -int strncasecmp ( const char* s1, const char* s2, size_t len ) -{ - register unsigned int x2; - register unsigned int x1; - register const char* end = s1 + len; - - while (1) - { - if ((s1 >= end) ) - return 0; - - x2 = *s2 - 'A'; if ((x2 < 26u)) x2 += 32; - x1 = *s1 - 'A'; if ((x1 < 26u)) x1 += 32; - s1++; s2++; - - if ((x2 != x1)) - break; - - if ((x1 == (unsigned int)-'A')) - break; - } - - return x1 - x2; -} -#endif /* end of __ARMCC_VERSION */ - -#endif