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

@@ -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

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

components/dfs/include/dfs_fat.h

@@ -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

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

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 <dfs_raw.h>
+#include <dfs_file.h>
 
 #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);

components/dfs/include/dfs_raw.h

@@ -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 <dfs_def.h>
-#include <dfs_fs.h>
-
-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

components/dfs/include/dfs_util.h

@@ -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 <dfs_def.h>
-
-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 <stddef.h>
-int strncasecmp(const char* s1, const char* s2, size_t len);
-#endif /* end of __ARMCC_VERSION */
-#endif
-
-#endif

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 <dfs_fs.h>
-#include <dfs_raw.h>
-#include <dfs_util.h>
-
-#include <string.h>
-
-/*
-+------------------------------------------------------------------------------
-| 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)
+#include <dfs_file.h>
+
+/**
+ * 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 <finsh.h>
+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
+

components/dfs/src/dfs_init.c

@@ -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 <dfs_def.h>
-#include <dfs_config.h>
-
-#include <dfs_fs.h>
-#include <dfs_raw.h>
-
-#include <string.h>
-
-/* 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);
-}

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 <string.h>
-#include <dfs_util.h>
+ * 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 <dfs.h>
 #include <dfs_posix.h>
 
-/*
-+------------------------------------------------------------------------------
-| 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] != '/' )
-	{
-		/* build full path */
-		fullpath = full_path;
-#ifdef DFS_USING_WORKDIR
-		dfs_lock();
-		build_fullpath(working_directory, path, fullpath);
-		strcpy(working_directory, fullpath);
-		dfs_unlock();
-#endif
-	}
-	else
+	fullpath = dfs_normalize_path(NULL, path);
+	if (fullpath == RT_NULL)
+		return -1; /* build path failed */
+
+	dfs_lock();
+	d = opendir(fullpath);
+	if (d == RT_NULL)
 	{
-#ifdef DFS_USING_WORKDIR
-		dfs_lock();
-		rt_strncpy(working_directory, path, strlen(path) + 1);
-		working_directory[strlen(path)] = '\0';
+		rt_free(fullpath);
+		/* this is a not exist directory */
 		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

components/dfs/src/dfs_raw.c

@@ -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 <dfs_raw.h>
-#include <dfs_util.h>
-#include <string.h>
-
-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 <finsh.h>
-
-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<DIR>\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

components/dfs/src/dfs_util.c

@@ -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 <string.h>
-
-#include <dfs_fs.h>
-#include <dfs_util.h>
-
-/*
-+------------------------------------------------------------------------------
-| 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