diff --git a/src/fs/Kconfig b/src/fs/Kconfig
index 0367555fce06c297700d6d9932ba581207363383..177862295177c82c2dbd9633615f1fc663f7e800 100644
--- a/src/fs/Kconfig
+++ b/src/fs/Kconfig
@@ -44,18 +44,18 @@ config NX_ENABLE_MOUNT_TABLE
 
     endif
 
-config NX_VFS_MAX_PATH
+config NX_FILE_MAX_PATH
     int "vfs max path length" 
     default 512
 
-config NX_VFS_MAX_NAME
+config NX_FILE_MAX_NAME
     int "vfs max name length" 
     default 256
 
-config NX_VFS_MAX_FD
+config NX_FILE_MAX_FD
     int "vfs max file descriptor number" 
     default 256
 
-config NX_VFS_NODE_HASH_SIZE
+config NX_FILE_NODE_HASH_SIZE
     int "vfs max node hash list size" 
     default 256
diff --git a/src/fs/cpio/cpio.c b/src/fs/cpio/cpio.c
index e666358f19a40f1f5e95e4c3068ff660fa5fee4f..6998c8d55aa7016e055f5cf9f828ed3949d9fc39 100644
--- a/src/fs/cpio/cpio.c
+++ b/src/fs/cpio/cpio.c
@@ -7,7 +7,7 @@
  *          Mobile phone: +86-18665388956
  *          QQ: 8192542
  * 
- * Contains: virtual file system form xboot.
+ * Contains: nxos file system.
  * 
  * Change Logs:
  * Date           Author            Notes
@@ -18,7 +18,7 @@
 
 #ifdef CONFIG_NX_FS_CPIO
 
-#include <base/vfs.h>
+#include <base/fs.h>
 #include <base/string.h>
 #include <base/memory.h>
 #include <base/log.h>
@@ -141,7 +141,7 @@ NX_PRIVATE NX_Bool CheckPath(const char * path, const char * prefix, const char
 	return NX_True;
 }
 
-NX_PRIVATE NX_Error CpioMount(NX_VfsMount * m, const char * dev)
+NX_PRIVATE NX_Error CpioMount(NX_MountDesc * m, const char * dev)
 {
 	struct CpioNewcHeader header;
 	NX_U64 rd;
@@ -167,40 +167,40 @@ NX_PRIVATE NX_Error CpioMount(NX_VfsMount * m, const char * dev)
 		return NX_EFAULT;
     }
 
-	m->flags |= NX_VFS_MOUNT_RO;
+	m->flags |= NX_MOUNT_RO;
 	m->root->data = NX_NULL;
 	m->data = NX_NULL;
 
 	return NX_EOK;
 }
 
-NX_PRIVATE NX_Error CpioUnmount(NX_VfsMount * m)
+NX_PRIVATE NX_Error CpioUnmount(NX_MountDesc * m)
 {
 	m->data = NX_NULL;
 	return NX_EOK;
 }
 
-NX_PRIVATE NX_Error CpioMountSync(NX_VfsMount * m)
+NX_PRIVATE NX_Error CpioMountSync(NX_MountDesc * m)
 {
 	return NX_EOK;
 }
 
-NX_PRIVATE NX_Error CpioVget(NX_VfsMount * m, NX_VfsNode * n)
+NX_PRIVATE NX_Error CpioGetNode(NX_MountDesc * m, NX_FileNode * n)
 {
 	return NX_EOK;
 }
 
-NX_PRIVATE NX_Error CpioVput(NX_VfsMount * m, NX_VfsNode * n)
+NX_PRIVATE NX_Error CpioPutNode(NX_MountDesc * m, NX_FileNode * n)
 {
 	return NX_EOK;
 }
 
-NX_PRIVATE NX_U64 CpioRead(NX_VfsNode * n, NX_I64 off, void * buf, NX_U64 len, NX_Error *outErr)
+NX_PRIVATE NX_U64 CpioRead(NX_FileNode * n, NX_I64 off, void * buf, NX_U64 len, NX_Error *outErr)
 {
 	NX_U64 toff;
 	NX_U64 sz = 0;
 
-	if(n->type != NX_VFS_NODE_TYPE_REG)
+	if(n->type != NX_FILE_NODE_TYPE_REG)
     {
         NX_ErrorSet(outErr, NX_EINVAL);
 		return 0;
@@ -225,32 +225,32 @@ NX_PRIVATE NX_U64 CpioRead(NX_VfsNode * n, NX_I64 off, void * buf, NX_U64 len, N
 	return sz;
 }
 
-NX_PRIVATE NX_U64 CpioWrite(NX_VfsNode * n, NX_I64 off, void * buf, NX_U64 len, NX_Error *outErr)
+NX_PRIVATE NX_U64 CpioWrite(NX_FileNode * n, NX_I64 off, void * buf, NX_U64 len, NX_Error *outErr)
 {
     NX_ErrorSet(outErr, NX_EPERM);
 	return 0;
 }
 
-NX_PRIVATE NX_Error CpioIoctl(NX_VfsNode * n, NX_U32 cmd, void *arg)
+NX_PRIVATE NX_Error CpioIoctl(NX_FileNode * n, NX_U32 cmd, void *arg)
 {
 	return NX_ENOFUNC;
 }
 
-NX_PRIVATE NX_Error CpioTruncate(NX_VfsNode * n, NX_I64 off)
+NX_PRIVATE NX_Error CpioTruncate(NX_FileNode * n, NX_I64 off)
 {
 	return NX_EPERM; /* can't truncate */
 }
 
-NX_PRIVATE NX_Error CpioSync(NX_VfsNode * n)
+NX_PRIVATE NX_Error CpioSync(NX_FileNode * n)
 {
 	return NX_EOK;
 }
 
-NX_PRIVATE NX_Error CpioReaddir(NX_VfsNode * dn, NX_I64 off, NX_VfsDirent * d)
+NX_PRIVATE NX_Error CpioReadDir(NX_FileNode * dn, NX_I64 off, NX_Dirent * d)
 {
 	struct CpioNewcHeader header;
-	char path[NX_VFS_MAX_PATH];
-	char name[NX_VFS_MAX_NAME];
+	char path[NX_FILE_MAX_PATH];
+	char name[NX_FILE_MAX_NAME];
 	NX_U32 size, name_size, mode;
 	NX_U64 toff = 0, rd;
 	char buf[9];
@@ -311,38 +311,14 @@ NX_PRIVATE NX_Error CpioReaddir(NX_VfsNode * dn, NX_I64 off, NX_VfsDirent * d)
 			break;
 		}
 	}
-
-	if((mode & 00170000) == 0140000)
-	{
-		d->type = NX_VFS_DIR_TYPE_SOCK;
-	}
-	else if((mode & 00170000) == 0120000)
-	{
-		d->type = NX_VFS_DIR_TYPE_LNK;
-	}
-	else if ((mode & 00170000) == 0100000)
-	{
-		d->type = NX_VFS_DIR_TYPE_REG;
-	}
-	else if ((mode & 00170000) == 0060000)
-	{
-		d->type = NX_VFS_DIR_TYPE_BLK;
-	}
-	else if ((mode & 00170000) == 0040000)
-	{
-		d->type = NX_VFS_DIR_TYPE_DIR;
-	}
-	else if ((mode & 00170000) == 0020000)
-	{
-		d->type = NX_VFS_DIR_TYPE_CHR;
-	}
-	else if ((mode & 00170000) == 0010000)
+    
+	if ((mode & 00170000) == 0040000)
 	{
-		d->type = NX_VFS_DIR_TYPE_FIFO;
+		d->type = NX_DIR_TYPE_DIR;
 	}
 	else
 	{
-		d->type = NX_VFS_DIR_TYPE_REG;
+		d->type = NX_DIR_TYPE_REG;
 	}
 
 	NX_StrCopyN(d->name, name, sizeof(d->name));
@@ -352,10 +328,10 @@ NX_PRIVATE NX_Error CpioReaddir(NX_VfsNode * dn, NX_I64 off, NX_VfsDirent * d)
 	return NX_EOK;
 }
 
-NX_PRIVATE NX_Error CpioLookup(NX_VfsNode * dn, const char * name, NX_VfsNode * n)
+NX_PRIVATE NX_Error CpioLookup(NX_FileNode * dn, const char * name, NX_FileNode * n)
 {
 	struct CpioNewcHeader header;
-	char path[NX_VFS_MAX_PATH];
+	char path[NX_FILE_MAX_PATH];
 	NX_U64 off = 0, rd;
 	NX_U32 size, name_size, mode, mtime;
 	NX_U8 buf[9];
@@ -413,55 +389,20 @@ NX_PRIVATE NX_Error CpioLookup(NX_VfsNode * dn, const char * name, NX_VfsNode *
 	n->ctime = mtime;
 	n->mode = 0;
 
-	if((mode & 00170000) == 0140000)
+	if((mode & 00170000) == 0040000)
 	{
-		n->type = NX_VFS_NODE_TYPE_SOCK;
-		n->mode |= NX_VFS_S_IFSOCK;
-	}
-	else if((mode & 00170000) == 0120000)
-	{
-		n->type = NX_VFS_NODE_TYPE_LNK;
-		n->mode |= NX_VFS_S_IFLNK;
-	}
-	else if((mode & 00170000) == 0100000)
-	{
-		n->type = NX_VFS_NODE_TYPE_REG;
-		n->mode |= NX_VFS_S_IFREG;
-	}
-	else if((mode & 00170000) == 0060000)
-	{
-		n->type = NX_VFS_NODE_TYPE_BLK;
-		n->mode |= NX_VFS_S_IFBLK;
-	}
-	else if((mode & 00170000) == 0040000)
-	{
-		n->type = NX_VFS_NODE_TYPE_DIR;
-		n->mode |= NX_VFS_S_IFDIR;
-	}
-	else if((mode & 00170000) == 0020000)
-	{
-		n->type = NX_VFS_NODE_TYPE_CHR;
-		n->mode |= NX_VFS_S_IFCHR;
-	}
-	else if((mode & 00170000) == 0010000)
-	{
-		n->type = NX_VFS_NODE_TYPE_FIFO;
-		n->mode |= NX_VFS_S_IFIFO;
+		n->type = NX_FILE_NODE_TYPE_DIR;
+		n->mode |= NX_FILE_TYPE_DIR;
 	}
 	else
 	{
-		n->type = NX_VFS_NODE_TYPE_REG;
+		n->type = NX_FILE_NODE_TYPE_REG;
+        n->mode |= NX_FILE_TYPE_REG;
 	}
 
-	n->mode |= (mode & 00400) ? NX_VFS_S_IRUSR : 0;
-	n->mode |= (mode & 00200) ? NX_VFS_S_IWUSR : 0;
-	n->mode |= (mode & 00100) ? NX_VFS_S_IXUSR : 0;
-	n->mode |= (mode & 00040) ? NX_VFS_S_IRGRP : 0;
-	n->mode |= (mode & 00020) ? NX_VFS_S_IWGRP : 0;
-	n->mode |= (mode & 00010) ? NX_VFS_S_IXGRP : 0;
-	n->mode |= (mode & 00004) ? NX_VFS_S_IROTH : 0;
-	n->mode |= (mode & 00002) ? NX_VFS_S_IWOTH : 0;
-	n->mode |= (mode & 00001) ? NX_VFS_S_IXOTH : 0;
+	n->mode |= (mode & 00400) ? NX_FILE_MODE_READ : 0;
+	n->mode |= (mode & 00200) ? NX_FILE_MODE_WRITE : 0;
+	n->mode |= (mode & 00100) ? NX_FILE_MODE_EXEC : 0;
 	n->size = size;
 
 	off += sizeof(struct CpioNewcHeader);
@@ -471,68 +412,66 @@ NX_PRIVATE NX_Error CpioLookup(NX_VfsNode * dn, const char * name, NX_VfsNode *
 	return NX_EOK;
 }
 
-NX_PRIVATE NX_Error CpioCreate(NX_VfsNode * dn, const char * filename, NX_U32 mode)
+NX_PRIVATE NX_Error CpioCreate(NX_FileNode * dn, const char * filename, NX_U32 mode)
 {
 	return NX_EPERM;
 }
 
-NX_PRIVATE NX_Error CpioRemove(NX_VfsNode * dn, NX_VfsNode * n, const char *name)
+NX_PRIVATE NX_Error CpioDelete(NX_FileNode * dn, NX_FileNode * n, const char *name)
 {
 	return NX_EPERM;
 }
 
-NX_PRIVATE NX_Error CpioRename(NX_VfsNode * sn, const char * sname, NX_VfsNode * n, NX_VfsNode * dn, const char * dname)
+NX_PRIVATE NX_Error CpioRename(NX_FileNode * sn, const char * sname, NX_FileNode * n, NX_FileNode * dn, const char * dname)
 {
 	return NX_EPERM;
 }
 
-NX_PRIVATE NX_Error CpioMkdir(NX_VfsNode * dn, const char * name, NX_U32 mode)
+NX_PRIVATE NX_Error CpioCreateDir(NX_FileNode * dn, const char * name, NX_U32 mode)
 {
 	return NX_EPERM;
 }
 
-NX_PRIVATE NX_Error CpioRmdir(NX_VfsNode * dn, NX_VfsNode * n, const char *name)
+NX_PRIVATE NX_Error CpioDeleteDir(NX_FileNode * dn, NX_FileNode * n, const char *name)
 {
 	return NX_EPERM;
 }
 
-NX_PRIVATE NX_Error CpioChmod(NX_VfsNode * n, NX_U32 mode)
+NX_PRIVATE NX_Error CpioSetMode(NX_FileNode * n, NX_U32 mode)
 {
 	return NX_EPERM;
 }
 
-NX_PRIVATE NX_VfsFileSystem cpio = {
+NX_PRIVATE NX_FileSystem cpio = {
 	.name		= "cpio",
-
 	.mount		= CpioMount,
 	.unmount	= CpioUnmount,
-	.msync		= CpioMountSync,
-	.vget		= CpioVget,
-	.vput		= CpioVput,
-
+	.mountSync	= CpioMountSync,
+	.getNode	= CpioGetNode,
+	.putNode	= CpioPutNode,
 	.read		= CpioRead,
 	.write		= CpioWrite,
     .ioctl      = CpioIoctl,
 	.truncate	= CpioTruncate,
 	.sync		= CpioSync,
-	.readdir	= CpioReaddir,
+	.readDir	= CpioReadDir,
 	.lookup		= CpioLookup,
 	.create		= CpioCreate,
-	.remove		= CpioRemove,
+	.delete		= CpioDelete,
 	.rename		= CpioRename,
-	.mkdir		= CpioMkdir,
-	.rmdir		= CpioRmdir,
-	.chmod		= CpioChmod,
+	.createDir	= CpioCreateDir,
+	.deleteDir	= CpioDeleteDir,
+	.setMode	= CpioSetMode,
 };
 
 NX_PRIVATE void NX_FileSystemCpioInit(void)
 {
-	NX_VfsRegisterFileSystem(&cpio);
+	NX_FileSystemRegister(&cpio);
 }
 
 NX_PRIVATE void NX_FileSystemCpioExit(void)
 {
-	NX_VfsUnregisterFileSystem(&cpio);
+	NX_FileSystemUnregister(&cpio);
 }
 
 NX_FS_INIT(NX_FileSystemCpioInit);
diff --git a/src/fs/devfs/devfs.c b/src/fs/devfs/devfs.c
index f5f709d8e3925469ba4b78153ef5402b8f238a9c..1efa158191849a780c34bbc0f9a6c200baf9f4c8 100644
--- a/src/fs/devfs/devfs.c
+++ b/src/fs/devfs/devfs.c
@@ -12,41 +12,41 @@
 #include <nxos.h>
 
 #ifdef CONFIG_NX_FS_DEVFS
-#include <base/vfs.h>
+#include <base/fs.h>
 #include <base/string.h>
 #define NX_LOG_NAME "devfs"
 #include <base/log.h>
 #include <base/driver.h>
 
-NX_PRIVATE NX_Error DevMount(NX_VfsMount * m, const char * dev)
+NX_PRIVATE NX_Error DevMount(NX_MountDesc * m, const char * dev)
 {
 	m->root->data = (void *)NX_NULL;
 	m->data = NX_NULL;
 	return NX_EOK;
 }
 
-NX_PRIVATE NX_Error DevUnmount(NX_VfsMount * m)
+NX_PRIVATE NX_Error DevUnmount(NX_MountDesc * m)
 {
 	m->data = NX_NULL;
 	return NX_EOK;
 }
 
-NX_PRIVATE NX_Error DevMountSync(NX_VfsMount * m)
+NX_PRIVATE NX_Error DevMountSync(NX_MountDesc * m)
 {
 	return NX_EOK;
 }
 
-NX_PRIVATE NX_Error DevVget(NX_VfsMount * m, NX_VfsNode * n)
+NX_PRIVATE NX_Error DevGetNode(NX_MountDesc * m, NX_FileNode * n)
 {
 	return NX_EOK;
 }
 
-NX_PRIVATE NX_Error DevVput(NX_VfsMount * m, NX_VfsNode * n)
+NX_PRIVATE NX_Error DevPutNode(NX_MountDesc * m, NX_FileNode * n)
 {
 	return NX_EOK;
 }
 
-NX_PRIVATE NX_U64 DevRead(NX_VfsNode * n, NX_I64 off, void * buf, NX_U64 len, NX_Error *outErr)
+NX_PRIVATE NX_U64 DevRead(NX_FileNode * n, NX_I64 off, void * buf, NX_U64 len, NX_Error *outErr)
 {
 	NX_Device *dev;
 	NX_Size outLen;
@@ -66,7 +66,7 @@ NX_PRIVATE NX_U64 DevRead(NX_VfsNode * n, NX_I64 off, void * buf, NX_U64 len, NX
 	return outLen;
 }
 
-NX_PRIVATE NX_U64 DevWrite(NX_VfsNode * n, NX_I64 off, void * buf, NX_U64 len, NX_Error *outErr)
+NX_PRIVATE NX_U64 DevWrite(NX_FileNode * n, NX_I64 off, void * buf, NX_U64 len, NX_Error *outErr)
 {
     NX_Device *dev;
 	NX_Size outLen;
@@ -87,7 +87,7 @@ NX_PRIVATE NX_U64 DevWrite(NX_VfsNode * n, NX_I64 off, void * buf, NX_U64 len, N
 	return outLen;
 }
 
-NX_PRIVATE NX_Error DevIoctl(NX_VfsNode * n, NX_U32 cmd, void *arg)
+NX_PRIVATE NX_Error DevIoctl(NX_FileNode * n, NX_U32 cmd, void *arg)
 {
     NX_Device *dev;
 
@@ -96,17 +96,17 @@ NX_PRIVATE NX_Error DevIoctl(NX_VfsNode * n, NX_U32 cmd, void *arg)
     return NX_DeviceControl(dev, cmd, arg);
 }
 
-NX_PRIVATE NX_Error DevTruncate(NX_VfsNode * n, NX_I64 off)
+NX_PRIVATE NX_Error DevTruncate(NX_FileNode * n, NX_I64 off)
 {
 	return NX_EPERM; /* can't truncate */
 }
 
-NX_PRIVATE NX_Error DevSync(NX_VfsNode * n)
+NX_PRIVATE NX_Error DevSync(NX_FileNode * n)
 {
 	return NX_EOK;
 }
 
-NX_PRIVATE NX_Error DevReaddir(NX_VfsNode * dn, NX_I64 off, NX_VfsDirent * d)
+NX_PRIVATE NX_Error DevReadDir(NX_FileNode * dn, NX_I64 off, NX_Dirent * d)
 {
     NX_Device *device;
 
@@ -116,14 +116,7 @@ NX_PRIVATE NX_Error DevReaddir(NX_VfsNode * dn, NX_I64 off, NX_VfsDirent * d)
         return NX_ENORES;
     }
 
-    if (device->driver->type == NX_DEVICE_TYPE_BLOCK)
-    {
-        d->type = NX_VFS_DIR_TYPE_BLK;
-    }
-    else
-    {
-        d->type = NX_VFS_DIR_TYPE_CHR;
-    }
+    d->type = NX_DIR_TYPE_REG;
     
 	NX_StrCopyN(d->name, device->name, sizeof(d->name));
     d->name[sizeof(device->name) - 1] = '\0';
@@ -134,7 +127,7 @@ NX_PRIVATE NX_Error DevReaddir(NX_VfsNode * dn, NX_I64 off, NX_VfsDirent * d)
     return NX_EOK;
 }
 
-NX_PRIVATE NX_Error DevLookup(NX_VfsNode * dn, const char * name, NX_VfsNode * n)
+NX_PRIVATE NX_Error DevLookup(NX_FileNode * dn, const char * name, NX_FileNode * n)
 {
 	NX_Device *dev;
 
@@ -151,83 +144,81 @@ NX_PRIVATE NX_Error DevLookup(NX_VfsNode * dn, const char * name, NX_VfsNode * n
 	n->size = 0;
 	n->data = (void *)dev;
 
-	n->type = NX_VFS_NODE_TYPE_REG;
-	n->mode |= NX_VFS_S_IFREG;
+	n->type = NX_FILE_NODE_TYPE_REG;
+	n->mode |= NX_FILE_TYPE_REG;
 	if(dev->driver->ops->read)
 	{
-		n->mode |= (NX_VFS_S_IRUSR | NX_VFS_S_IRGRP | NX_VFS_S_IROTH);
+		n->mode |= (NX_FILE_MODE_READ);
 	}
 	if(dev->driver->ops->write)
 	{
-		n->mode |= (NX_VFS_S_IWUSR | NX_VFS_S_IWGRP | NX_VFS_S_IWOTH);
+		n->mode |= (NX_FILE_MODE_WRITE);
 	}
 
 	return NX_EOK;
 }
 
-NX_PRIVATE NX_Error DevCreate(NX_VfsNode * dn, const char * filename, NX_U32 mode)
+NX_PRIVATE NX_Error DevCreate(NX_FileNode * dn, const char * filename, NX_U32 mode)
 {
 	return NX_EPERM;
 }
 
-NX_PRIVATE NX_Error DevRemove(NX_VfsNode * dn, NX_VfsNode * n, const char *name)
+NX_PRIVATE NX_Error DevDelete(NX_FileNode * dn, NX_FileNode * n, const char *name)
 {
 	return NX_EPERM;
 }
 
-NX_PRIVATE NX_Error DevRename(NX_VfsNode * sn, const char * sname, NX_VfsNode * n, NX_VfsNode * dn, const char * dname)
+NX_PRIVATE NX_Error DevRename(NX_FileNode * sn, const char * sname, NX_FileNode * n, NX_FileNode * dn, const char * dname)
 {
 	return NX_EPERM;
 }
 
-NX_PRIVATE NX_Error DevMkdir(NX_VfsNode * dn, const char * name, NX_U32 mode)
+NX_PRIVATE NX_Error DevCreateDir(NX_FileNode * dn, const char * name, NX_U32 mode)
 {
 	return NX_EPERM;
 }
 
-NX_PRIVATE NX_Error DevRmdir(NX_VfsNode * dn, NX_VfsNode * n, const char *name)
+NX_PRIVATE NX_Error DevDeleteDir(NX_FileNode * dn, NX_FileNode * n, const char *name)
 {
 	return NX_EPERM;
 }
 
-NX_PRIVATE NX_Error DevChmod(NX_VfsNode * n, NX_U32 mode)
+NX_PRIVATE NX_Error DevSetMode(NX_FileNode * n, NX_U32 mode)
 {
 	return NX_EPERM;
 }
 
-NX_PRIVATE NX_VfsFileSystem devfs = {
+NX_PRIVATE NX_FileSystem devfs = {
 	.name		= "devfs",
-
 	.mount		= DevMount,
 	.unmount	= DevUnmount,
-	.msync		= DevMountSync,
-	.vget		= DevVget,
-	.vput		= DevVput,
-
+	.mountSync	= DevMountSync,
+	.getNode	= DevGetNode,
+	.putNode	= DevPutNode,
 	.read		= DevRead,
 	.write		= DevWrite,
     .ioctl      = DevIoctl,
 	.truncate	= DevTruncate,
 	.sync		= DevSync,
-	.readdir	= DevReaddir,
+	.readDir	= DevReadDir,
 	.lookup		= DevLookup,
 	.create		= DevCreate,
-	.remove		= DevRemove,
+	.delete		= DevDelete,
 	.rename		= DevRename,
-	.mkdir		= DevMkdir,
-	.rmdir		= DevRmdir,
-	.chmod		= DevChmod,
+	.createDir	= DevCreateDir,
+	.deleteDir	= DevDeleteDir,
+	.setMode	= DevSetMode,
 };
 
 NX_PRIVATE void NX_FileSystemDevInit(void)
 {
-	NX_VfsRegisterFileSystem(&devfs);
+	NX_FileSystemRegister(&devfs);
     NX_LOG_I("register devfs done.");
 }
 
 NX_PRIVATE void NX_FileSystemDevExit(void)
 {
-	NX_VfsUnregisterFileSystem(&devfs);
+	NX_FileSystemUnregister(&devfs);
 }
 
 NX_FS_INIT(NX_FileSystemDevInit);
diff --git a/src/fs/fat/fat-node.c b/src/fs/fat/fat-node.c
index 9e8522aa3f0cfab56736877f7bb9a6f1eb78d8c2..f84d5d15b0a69dcccb66f0d002045c7a8340a8fe 100644
--- a/src/fs/fat/fat-node.c
+++ b/src/fs/fat/fat-node.c
@@ -496,11 +496,11 @@ static NX_U8 fatfs_node_lfn_checksum(const NX_U8 * name)
 	return sum;
 }
 
-int fatfs_node_read_dirent(struct fatfs_node_t * dnode, NX_I64 off, NX_VfsDirent * d)
+int fatfs_node_read_dirent(struct fatfs_node_t * dnode, NX_I64 off, NX_Dirent * d)
 {
 	NX_U32 i, rlen, len;
 	NX_U8 lcsum = 0, dcsum = 0, check[11];
-	char lname[NX_VFS_MAX_NAME];
+	char lname[NX_FILE_MAX_NAME];
 	struct fat_dirent_t dent;
 	struct fat_longname_t lfn;
 	NX_U32 fileoff = (NX_U32) off;
@@ -612,9 +612,9 @@ int fatfs_node_read_dirent(struct fatfs_node_t * dnode, NX_I64 off, NX_VfsDirent
 	}
 
 	if(dent.file_attributes & FAT_DIRENT_SUBDIR)
-		d->type = NX_VFS_DIR_TYPE_DIR;
+		d->type = NX_DIR_TYPE_DIR;
 	else
-		d->type = NX_VFS_DIR_TYPE_REG;
+		d->type = NX_DIR_TYPE_REG;
 
 	return 0;
 }
@@ -624,7 +624,7 @@ int fatfs_node_find_dirent(struct fatfs_node_t * dnode, const char * name, struc
 	NX_U8 lcsum = 0, dcsum = 0, check[11];
 	NX_U32 i, off, rlen, len, lfn_off, lfn_len;
 	struct fat_longname_t lfn;
-	char lname[NX_VFS_MAX_NAME];
+	char lname[NX_FILE_MAX_NAME];
 
 	lfn_off = 0;
 	lfn_len = 0;
@@ -721,7 +721,7 @@ int fatfs_node_find_dirent(struct fatfs_node_t * dnode, const char * name, struc
 			lcsum = dcsum;
 		}
 
-		if(!NX_StrCmpN(lname, name, NX_VFS_MAX_NAME) && (lcsum == dcsum))
+		if(!NX_StrCmpN(lname, name, NX_FILE_MAX_NAME) && (lcsum == dcsum))
 		{
 			*dent_off = lfn_off;
 			*dent_len = sizeof(struct fat_dirent_t) + lfn_len;
diff --git a/src/fs/fat/fat-node.h b/src/fs/fat/fat-node.h
index 8d8078ee11e78cde0264d911e6c31b99fb8f5d87..1dca3f083d5e94682f6e9739abe1072514e42712 100644
--- a/src/fs/fat/fat-node.h
+++ b/src/fs/fat/fat-node.h
@@ -49,7 +49,7 @@ int fatfs_node_truncate(struct fatfs_node_t * node, NX_U32 pos);
 int fatfs_node_sync(struct fatfs_node_t * node);
 int fatfs_node_init(struct fatfs_control_t * ctrl, struct fatfs_node_t * node);
 int fatfs_node_exit(struct fatfs_node_t * node);
-int fatfs_node_read_dirent(struct fatfs_node_t * dnode, NX_I64 off, NX_VfsDirent * d);
+int fatfs_node_read_dirent(struct fatfs_node_t * dnode, NX_I64 off, NX_Dirent * d);
 int fatfs_node_find_dirent(struct fatfs_node_t * dnode, const char * name, struct fat_dirent_t * dent, NX_U32 * dent_off, NX_U32 * dent_len);
 int fatfs_node_add_dirent(struct fatfs_node_t * dnode, const char * name, struct fat_dirent_t * ndent);
 int fatfs_node_del_dirent(struct fatfs_node_t * dnode, const char * name, NX_U32 dent_off, NX_U32 dent_len);
diff --git a/src/fs/fat/fat.c b/src/fs/fat/fat.c
index a9c4b745ac51c4c3a2f1b4a3d54864b286d75fea..1805c423689f0fd44a32b781d446d0bbb006833c 100644
--- a/src/fs/fat/fat.c
+++ b/src/fs/fat/fat.c
@@ -48,7 +48,7 @@
 #include <base/memory.h>
 #include <base/log.h>
 
-static NX_Error fatfs_mount(NX_VfsMount * m, const char * dev)
+NX_PRIVATE NX_Error FatfsMount(NX_MountDesc * m, const char * dev)
 {
 	struct fatfs_control_t * ctrl;
 	struct fatfs_node_t * root;
@@ -91,8 +91,8 @@ static NX_Error fatfs_mount(NX_VfsMount * m, const char * dev)
 	root->parent_dent_dirty = NX_False;
 
 	/* Handcraft the root vfs node */
-	m->root->type = NX_VFS_NODE_TYPE_DIR;
-	m->root->mode = NX_VFS_S_IFDIR | NX_VFS_S_IRWXU | NX_VFS_S_IRWXG | NX_VFS_S_IRWXO;
+	m->root->type = NX_FILE_NODE_TYPE_DIR;
+	m->root->mode = NX_FILE_TYPE_DIR | NX_FILE_MODE_MASK;
 	m->root->ctime = 0;
 	m->root->atime = 0;
 	m->root->mtime = 0;
@@ -108,7 +108,7 @@ fail:
 	return NX_ERROR;
 }
 
-static NX_Error fatfs_unmount(NX_VfsMount * m)
+NX_PRIVATE NX_Error FatfsUnmount(NX_MountDesc * m)
 {
 	int rc;
 	struct fatfs_control_t *ctrl = m->data;
@@ -122,7 +122,7 @@ static NX_Error fatfs_unmount(NX_VfsMount * m)
     return rc ? NX_ERROR : NX_EOK;
 }
 
-static NX_Error fatfs_msync(NX_VfsMount * m)
+NX_PRIVATE NX_Error FatfsMountSync(NX_MountDesc * m)
 {
 	struct fatfs_control_t * ctrl = m->data;
 
@@ -135,7 +135,7 @@ static NX_Error fatfs_msync(NX_VfsMount * m)
     return NX_EOK;
 }
 
-static NX_Error fatfs_vget(NX_VfsMount * m, NX_VfsNode * n)
+NX_PRIVATE NX_Error FatfsGetNode(NX_MountDesc * m, NX_FileNode * n)
 {
 	int rc;
 	struct fatfs_node_t * node;
@@ -153,7 +153,7 @@ static NX_Error fatfs_vget(NX_VfsMount * m, NX_VfsNode * n)
     return rc ? NX_ERROR : NX_EOK;
 }
 
-static NX_Error fatfs_vput(NX_VfsMount * m, NX_VfsNode * n)
+NX_PRIVATE NX_Error FatfsPutNode(NX_MountDesc * m, NX_FileNode * n)
 {
 	int rc;
 	struct fatfs_node_t * node = n->data;
@@ -166,7 +166,7 @@ static NX_Error fatfs_vput(NX_VfsMount * m, NX_VfsNode * n)
 	return rc ? NX_ERROR : NX_EOK;
 }
 
-static NX_U64 fatfs_read(NX_VfsNode * n, NX_I64 off, void * buf, NX_U64 len, NX_Error *outErr)
+NX_PRIVATE NX_U64 FatfsRead(NX_FileNode * n, NX_I64 off, void * buf, NX_U64 len, NX_Error *outErr)
 {
 	struct fatfs_node_t * node = n->data;
 	NX_U32 filesize = fatfs_node_get_size(node);
@@ -184,7 +184,7 @@ static NX_U64 fatfs_read(NX_VfsNode * n, NX_I64 off, void * buf, NX_U64 len, NX_
 	return fatfs_node_read(node, (NX_U32) off, len, buf);
 }
 
-static NX_U64 fatfs_write(NX_VfsNode * n, NX_I64 off, void * buf, NX_U64 len, NX_Error *outErr)
+NX_PRIVATE NX_U64 FatfsWrite(NX_FileNode * n, NX_I64 off, void * buf, NX_U64 len, NX_Error *outErr)
 {
 	NX_U32 wlen;
 	struct fatfs_node_t *node = n->data;
@@ -201,7 +201,7 @@ static NX_U64 fatfs_write(NX_VfsNode * n, NX_I64 off, void * buf, NX_U64 len, NX
 	return wlen;
 }
 
-static NX_Error fatfs_truncate(NX_VfsNode * n, NX_I64 off)
+NX_PRIVATE NX_Error FatfsTruncate(NX_FileNode * n, NX_I64 off)
 {
 	int rc;
 	struct fatfs_node_t * node = n->data;
@@ -225,7 +225,7 @@ static NX_Error fatfs_truncate(NX_VfsNode * n, NX_I64 off)
 	return NX_EOK;
 }
 
-static NX_Error fatfs_sync(NX_VfsNode * n)
+NX_PRIVATE NX_Error FatfsSync(NX_FileNode * n)
 {
 	struct fatfs_node_t *node = n->data;
 	NX_U32 year, mon, day, hour, min, sec;
@@ -237,15 +237,15 @@ static NX_Error fatfs_sync(NX_VfsNode * n)
 	fileattr = 0;
 	switch(n->type)
 	{
-	case NX_VFS_NODE_TYPE_DIR:
+	case NX_FILE_NODE_TYPE_DIR:
 		fileattr |= FAT_DIRENT_SUBDIR;
 		break;
-	case NX_VFS_NODE_TYPE_REG:
+	case NX_FILE_NODE_TYPE_REG:
 	default:
 		break;
 	}
 
-	if(!(n->mode & (NX_VFS_S_IWUSR | NX_VFS_S_IWGRP | NX_VFS_S_IWOTH)))
+	if(!(n->mode & (NX_FILE_MODE_WRITE)))
 		fileattr |= FAT_DIRENT_READONLY;
 
 	node->parent_dent.file_attributes = fileattr;
@@ -288,14 +288,14 @@ static NX_Error fatfs_sync(NX_VfsNode * n)
 	return fatfs_node_sync(node) ? NX_ERROR : NX_EOK;
 }
 
-static NX_Error fatfs_readdir(NX_VfsNode * dn, NX_I64 off, NX_VfsDirent * d)
+NX_PRIVATE NX_Error FatfsReadDir(NX_FileNode * dn, NX_I64 off, NX_Dirent * d)
 {
 	struct fatfs_node_t * dnode = dn->data;
 
 	return fatfs_node_read_dirent(dnode, off, d) ? NX_ERROR : NX_EOK;
 }
 
-static NX_Error fatfs_lookup(NX_VfsNode * dn, const char * name, NX_VfsNode * n)
+NX_PRIVATE NX_Error FatfsLookup(NX_FileNode * dn, const char * name, NX_FileNode * n)
 {
 	int rc;
 	NX_U32 off, len;
@@ -330,19 +330,19 @@ static NX_Error fatfs_lookup(NX_VfsNode * dn, const char * name, NX_VfsNode * n)
 
 	if(dent.file_attributes & FAT_DIRENT_SUBDIR)
 	{
-		n->type = NX_VFS_NODE_TYPE_DIR;
-		n->mode |= NX_VFS_S_IFDIR;
+		n->type = NX_FILE_NODE_TYPE_DIR;
+		n->mode |= NX_FILE_TYPE_DIR;
 	}
 	else
 	{
-		n->type = NX_VFS_NODE_TYPE_REG;
-		n->mode |= NX_VFS_S_IFREG;
+		n->type = NX_FILE_NODE_TYPE_REG;
+		n->mode |= NX_FILE_TYPE_REG;
 	}
 
-	n->mode |= (NX_VFS_S_IRWXU | NX_VFS_S_IRWXG | NX_VFS_S_IRWXO);
+	n->mode |= (NX_FILE_MODE_MASK);
 	if(dent.file_attributes & FAT_DIRENT_READONLY)
 	{
-		n->mode &= ~(NX_VFS_S_IWUSR | NX_VFS_S_IWGRP | NX_VFS_S_IWOTH);
+		n->mode &= ~(NX_FILE_MODE_WRITE);
 	}
 
 	n->ctime = fatfs_pack_timestamp(dent.create_date_year, dent.create_date_month, dent.create_date_day, dent.create_time_hours, dent.create_time_minutes,
@@ -356,7 +356,7 @@ static NX_Error fatfs_lookup(NX_VfsNode * dn, const char * name, NX_VfsNode * n)
 	return NX_EOK;
 }
 
-static NX_Error fatfs_create(NX_VfsNode * dn, const char * name, NX_U32 mode)
+NX_PRIVATE NX_Error FatfsCreate(NX_FileNode * dn, const char * name, NX_U32 mode)
 {
 	int rc;
 	NX_U8 fileattr;
@@ -377,7 +377,7 @@ static NX_Error fatfs_create(NX_VfsNode * dn, const char * name, NX_U32 mode)
 	fatfs_current_timestamp(&year, &mon, &day, &hour, &min, &sec);
 
 	fileattr = 0;
-	if(!(mode & (NX_VFS_S_IWUSR | NX_VFS_S_IWGRP | NX_VFS_S_IWOTH)))
+	if(!(mode & (NX_FILE_MODE_WRITE)))
 	{
 		fileattr |= FAT_DIRENT_READONLY;
 	}
@@ -411,7 +411,7 @@ static NX_Error fatfs_create(NX_VfsNode * dn, const char * name, NX_U32 mode)
 	return NX_EOK;
 }
 
-static NX_Error fatfs_remove(NX_VfsNode * dn, NX_VfsNode * n, const char *name)
+NX_PRIVATE NX_Error FatfsDelete(NX_FileNode * dn, NX_FileNode * n, const char *name)
 {
 	int rc;
 	NX_U32 off, len, clust;
@@ -444,7 +444,7 @@ static NX_Error fatfs_remove(NX_VfsNode * dn, NX_VfsNode * n, const char *name)
 	return NX_EOK;
 }
 
-static NX_Error fatfs_rename(NX_VfsNode * sv, const char *sname, NX_VfsNode * n, NX_VfsNode * dn, const char *dname)
+NX_PRIVATE NX_Error FatfsRename(NX_FileNode * sv, const char *sname, NX_FileNode * n, NX_FileNode * dn, const char *dname)
 {
 	int rc;
 	NX_U32 off, len;
@@ -476,7 +476,7 @@ static NX_Error fatfs_rename(NX_VfsNode * sv, const char *sname, NX_VfsNode * n,
 	return NX_EOK;
 }
 
-static NX_Error fatfs_mkdir(NX_VfsNode * dn, const char *name, NX_U32 mode)
+NX_PRIVATE NX_Error FatfsCreateDir(NX_FileNode * dn, const char *name, NX_U32 mode)
 {
 	int rc;
 	NX_U8 fileattr;
@@ -497,7 +497,7 @@ static NX_Error fatfs_mkdir(NX_VfsNode * dn, const char *name, NX_U32 mode)
 	fatfs_current_timestamp(&year, &mon, &day, &hour, &min, &sec);
 
 	fileattr = FAT_DIRENT_SUBDIR;
-	if(!(mode & (NX_VFS_S_IWUSR | NX_VFS_S_IWGRP | NX_VFS_S_IWOTH)))
+	if(!(mode & (NX_FILE_MODE_WRITE)))
 	{
 		fileattr |= FAT_DIRENT_READONLY;
 	}
@@ -531,7 +531,7 @@ static NX_Error fatfs_mkdir(NX_VfsNode * dn, const char *name, NX_U32 mode)
 	return NX_EOK;
 }
 
-static NX_Error fatfs_rmdir(NX_VfsNode * dn, NX_VfsNode * n, const char * name)
+NX_PRIVATE NX_Error FatfsDeleteDir(NX_FileNode * dn, NX_FileNode * n, const char * name)
 {
 	int rc;
 	NX_U32 off, len, clust;
@@ -568,12 +568,12 @@ static NX_Error fatfs_rmdir(NX_VfsNode * dn, NX_VfsNode * n, const char * name)
 	return NX_EOK;
 }
 
-static NX_Error fatfs_chmod(NX_VfsNode * n, NX_U32 mode)
+NX_PRIVATE NX_Error FatfsSetMode(NX_FileNode * n, NX_U32 mode)
 {
 	struct fatfs_node_t *node = n->data;
     NX_U32 year, month, day, hour, min, second;
 
-	n->mode &= ~(NX_VFS_S_IRWXU | NX_VFS_S_IRWXG | NX_VFS_S_IRWXO);
+	n->mode &= ~(NX_FILE_MODE_MASK);
 	n->mode |= mode;
 
     fatfs_current_timestamp(&year, &month, &day, &hour, &min, &second);
@@ -584,37 +584,35 @@ static NX_Error fatfs_chmod(NX_VfsNode * n, NX_U32 mode)
 	return NX_EOK;
 }
 
-static NX_VfsFileSystem fat = {
+NX_PRIVATE NX_FileSystem fat = {
 	.name		= "fat",
-
-	.mount		= fatfs_mount,
-	.unmount	= fatfs_unmount,
-	.msync		= fatfs_msync,
-	.vget		= fatfs_vget,
-	.vput		= fatfs_vput,
-
-	.read		= fatfs_read,
-	.write		= fatfs_write,
-	.truncate	= fatfs_truncate,
-	.sync		= fatfs_sync,
-	.readdir	= fatfs_readdir,
-	.lookup		= fatfs_lookup,
-	.create		= fatfs_create,
-	.remove		= fatfs_remove,
-	.rename		= fatfs_rename,
-	.mkdir		= fatfs_mkdir,
-	.rmdir		= fatfs_rmdir,
-	.chmod		= fatfs_chmod,
+	.mount		= FatfsMount,
+	.unmount	= FatfsUnmount,
+	.mountSync	= FatfsMountSync,
+	.getNode	= FatfsGetNode,
+	.putNode	= FatfsPutNode,
+	.read		= FatfsRead,
+	.write		= FatfsWrite,
+	.truncate	= FatfsTruncate,
+	.sync		= FatfsSync,
+	.readDir	= FatfsReadDir,
+	.lookup		= FatfsLookup,
+	.create		= FatfsCreate,
+	.delete		= FatfsDelete,
+	.rename		= FatfsRename,
+	.createDir	= FatfsCreateDir,
+	.deleteDir	= FatfsDeleteDir,
+	.setMode	= FatfsSetMode,
 };
 
 NX_PRIVATE void NX_FileSystemFatInit(void)
 {
-	NX_VfsRegisterFileSystem(&fat);
+	NX_FileSystemRegister(&fat);
 }
 
 NX_PRIVATE void NX_FileSystemFatExit(void)
 {
-	NX_VfsUnregisterFileSystem(&fat);
+	NX_FileSystemUnregister(&fat);
 }
 
 NX_FS_INIT(NX_FileSystemFatInit);
diff --git a/src/fs/fat/fat.h b/src/fs/fat/fat.h
index af180d28b88a12964bc2233b8f2f998ada03bec5..7698ebbf086c23a08a38511fbfb58f495c887c9a 100644
--- a/src/fs/fat/fat.h
+++ b/src/fs/fat/fat.h
@@ -41,7 +41,7 @@
 #define __FS_FAT_H__
 
 #include <nxos.h>
-#include <base/vfs.h>
+#include <base/fs.h>
 #include <base/block.h>
 #include <base/time.h>
 
@@ -212,7 +212,7 @@ struct fat_dirent_t {
 #define FAT_LONGNAME_SEQNO(s)		((s) & ~0x40)
 #define FAT_LONGNAME_LASTSEQ(s) 	((s) & 0x40)
 #define FAT_LONGNAME_MINSEQ			(1)
-#define FAT_LONGNAME_MAXSEQ			(NX_VFS_MAX_NAME / 13)
+#define FAT_LONGNAME_MAXSEQ			(NX_FILE_MAX_NAME / 13)
 
 /*
  * Directory long filename information for FAT12 / FAT16 / FAT32
diff --git a/src/fs/vfs.c b/src/fs/fs.c
similarity index 62%
rename from src/fs/vfs.c
rename to src/fs/fs.c
index da0cec0182f7134441708358e97e409887147fd4..77edf2211fd7d93508dc36579289dc13e07df4e0 100644
--- a/src/fs/vfs.c
+++ b/src/fs/fs.c
@@ -7,7 +7,7 @@
  *          Mobile phone: +86-18665388956
  *          QQ: 8192542
  * 
- * Contains: virtual file system form xboot.
+ * Contains: nxos file system.
  * 
  * Change Logs:
  * Date           Author            Notes
@@ -15,7 +15,7 @@
  */
 
 #include <nxos.h>
-#include <base/vfs.h>
+#include <base/fs.h>
 #include <base/string.h>
 #include <base/memory.h>
 #include <base/malloc.h>
@@ -25,7 +25,7 @@
 #include <base/thread.h>
 #include <base/process.h>
 
-#define VFS_GET_FILE_TABLE() NX_ThreadGetFileTable(NX_ThreadSelf())
+#define GET_FILE_TABLE() NX_ThreadGetFileTable(NX_ThreadSelf())
 
 NX_PRIVATE NX_LIST_HEAD(fileSystemListHead);
 
@@ -33,13 +33,13 @@ NX_PRIVATE NX_SPIN_DEFINE_UNLOCKED(fileSystemLock);
 
 NX_PRIVATE NX_List fileSystemMountList;
 NX_PRIVATE NX_Mutex fileSystemMountLock;
-NX_PRIVATE NX_List fileSystemNodeList[NX_VFS_NODE_HASH_SIZE];
-NX_PRIVATE NX_Mutex fileSystemNodeLock[NX_VFS_NODE_HASH_SIZE];
+NX_PRIVATE NX_List fileSystemNodeList[NX_FILE_NODE_HASH_SIZE];
+NX_PRIVATE NX_Mutex fileSystemNodeLock[NX_FILE_NODE_HASH_SIZE];
 
 /* default file table for kernel thread */
-NX_PRIVATE NX_VfsFileTable defaultFileTable;
+NX_PRIVATE NX_FileTable defaultFileTable;
 
-NX_Error NX_VfsRegisterFileSystem(NX_VfsFileSystem * fs)
+NX_Error NX_FileSystemRegister(NX_FileSystem * fs)
 {
     NX_UArch level;
 	if(!fs || !fs->name)
@@ -53,7 +53,7 @@ NX_Error NX_VfsRegisterFileSystem(NX_VfsFileSystem * fs)
 	return NX_EOK;
 }
 
-NX_Error NX_VfsUnregisterFileSystem(NX_VfsFileSystem * fs)
+NX_Error NX_FileSystemUnregister(NX_FileSystem * fs)
 {
 	NX_UArch level;
 
@@ -69,9 +69,9 @@ NX_Error NX_VfsUnregisterFileSystem(NX_VfsFileSystem * fs)
 	return NX_EOK;
 }
 
-NX_VfsFileSystem * NX_VfsSearchFileSystem(const char * name)
+NX_FileSystem * NX_FileSystemSearch(const char * name)
 {
-    NX_VfsFileSystem * pos, * n;
+    NX_FileSystem * pos, * n;
 
 	if(!name)
     {
@@ -88,7 +88,7 @@ NX_VfsFileSystem * NX_VfsSearchFileSystem(const char * name)
 	return NX_NULL;
 }
 
-NX_VfsFileTable *NX_VfsGetDefaultFileTable(void)
+NX_FileTable *NX_FileTableGetDefault(void)
 {
     return &defaultFileTable;
 }
@@ -126,9 +126,9 @@ NX_PRIVATE int CountMatch(const char * path, char * mount_root)
 	return 0;
 }
 
-NX_PRIVATE NX_Error VfsFindRoot(const char * path, NX_VfsMount ** mp, char ** root)
+NX_PRIVATE NX_Error FindRoot(const char * path, NX_MountDesc ** mp, char ** root)
 {
-	NX_VfsMount * pos, * m = NX_NULL;
+	NX_MountDesc * pos, * m = NX_NULL;
 	int len, max_len = 0;
 
 	if(!path || !mp || !root)
@@ -163,10 +163,10 @@ NX_PRIVATE NX_Error VfsFindRoot(const char * path, NX_VfsMount ** mp, char ** ro
 	return NX_EOK;
 }
 
-void NX_VfsFileTableInit(NX_VfsFileTable *ft)
+void NX_FileTableInit(NX_FileTable *ft)
 {
     int i;
-	for(i = 0; i < NX_VFS_MAX_FD; i++)
+	for(i = 0; i < NX_FILE_MAX_FD; i++)
 	{
 		NX_MutexInit(&ft->file[i].lock);
 		ft->file[i].node = NX_NULL;
@@ -176,12 +176,12 @@ void NX_VfsFileTableInit(NX_VfsFileTable *ft)
 	NX_MutexInit(&ft->file_lock);
 }
 
-NX_PRIVATE int VfsFileAlloc(NX_VfsFileTable *ft)
+NX_PRIVATE int FileAlloc(NX_FileTable *ft)
 {
 	int i, fd = -1;
 
 	NX_MutexLock(&ft->file_lock);
-	for(i = 3; i < NX_VFS_MAX_FD; i++)
+	for(i = 3; i < NX_FILE_MAX_FD; i++)
 	{
 		if(ft->file[i].node == NX_NULL)
 		{
@@ -194,9 +194,9 @@ NX_PRIVATE int VfsFileAlloc(NX_VfsFileTable *ft)
 	return fd;
 }
 
-NX_PRIVATE void VfsFileFree(NX_VfsFileTable *ft, int fd)
+NX_PRIVATE void FileFree(NX_FileTable *ft, int fd)
 {
-	if((fd >= 3) && (fd < NX_VFS_MAX_FD))
+	if((fd >= 3) && (fd < NX_FILE_MAX_FD))
 	{
 		NX_MutexLock(&ft->file_lock);
 		if(ft->file[fd].node)
@@ -211,17 +211,16 @@ NX_PRIVATE void VfsFileFree(NX_VfsFileTable *ft, int fd)
 	}
 }
 
-
-NX_PRIVATE NX_VfsFile * VfsFileDescriptorToFile(NX_VfsFileTable *ft, int fd)
+NX_PRIVATE NX_FileDesc * FileDescriptorToFile(NX_FileTable *ft, int fd)
 {
     if (!ft)
     {
         return NX_NULL;
     }
-	return ((fd >= 0) && (fd < NX_VFS_MAX_FD)) ? &ft->file[fd] : NX_NULL;
+	return ((fd >= 0) && (fd < NX_FILE_MAX_FD)) ? &ft->file[fd] : NX_NULL;
 }
 
-NX_PRIVATE NX_U32 VfsNodeHash(NX_VfsMount * m, const char * path)
+NX_PRIVATE NX_U32 NodeHash(NX_MountDesc * m, const char * path)
 {
 	NX_U32 val = 0;
 
@@ -232,16 +231,16 @@ NX_PRIVATE NX_U32 VfsNodeHash(NX_VfsMount * m, const char * path)
 			val = ((val << 5) + val) + *path++;
         }
 	}
-	return (val ^ (NX_U32)((NX_UArch)m)) & (NX_VFS_NODE_HASH_SIZE - 1);
+	return (val ^ (NX_U32)((NX_UArch)m)) & (NX_FILE_NODE_HASH_SIZE - 1);
 }
 
-NX_PRIVATE NX_VfsNode * VfsNodeGet(NX_VfsMount * m, const char * path)
+NX_PRIVATE NX_FileNode * NodeGet(NX_MountDesc * m, const char * path)
 {
-	NX_VfsNode * n;
-	NX_U32 hash = VfsNodeHash(m, path);
+	NX_FileNode * n;
+	NX_U32 hash = NodeHash(m, path);
 	int err;
 
-	if(!(n = NX_MemAlloc(sizeof(NX_VfsNode))))
+	if(!(n = NX_MemAlloc(sizeof(NX_FileNode))))
     {
 		return NX_NULL;
     }
@@ -257,7 +256,7 @@ NX_PRIVATE NX_VfsNode * VfsNodeGet(NX_VfsMount * m, const char * path)
 	}
 
 	NX_MutexLock(&m->lock);
-	err = m->fs->vget(m, n);
+	err = m->fs->getNode(m, n);
 	NX_MutexUnlock(&m->lock);
 	if(err != NX_EOK)
 	{
@@ -273,16 +272,16 @@ NX_PRIVATE NX_VfsNode * VfsNodeGet(NX_VfsMount * m, const char * path)
 	return n;
 }
 
-NX_PRIVATE NX_VfsNode * VfsNodeLookup(NX_VfsMount * m, const char * path)
+NX_PRIVATE NX_FileNode * NodeLookup(NX_MountDesc * m, const char * path)
 {
-	NX_VfsNode * n;
-	NX_U32 hash = VfsNodeHash(m, path);
+	NX_FileNode * n;
+	NX_U32 hash = NodeHash(m, path);
 	int found = 0;
 
 	NX_MutexLock(&fileSystemNodeLock[hash]);
 	NX_ListForEachEntry(n, &fileSystemNodeList[hash], link)
 	{
-		if((n->mount == m) && (!NX_StrCmpN(n->path, path, NX_VFS_MAX_PATH)))
+		if((n->mount == m) && (!NX_StrCmpN(n->path, path, NX_FILE_MAX_PATH)))
 		{
 			found = 1;
 			break;
@@ -299,12 +298,12 @@ NX_PRIVATE NX_VfsNode * VfsNodeLookup(NX_VfsMount * m, const char * path)
 	return n;
 }
 
-NX_PRIVATE void VfsNodeIncreaseRef(NX_VfsNode * n)
+NX_PRIVATE void NodeIncreaseRef(NX_FileNode * n)
 {
 	NX_AtomicAdd(&n->refcnt, 1);
 }
 
-NX_PRIVATE void VfsNodePut(NX_VfsNode * n)
+NX_PRIVATE void NodePut(NX_FileNode * n)
 {
 	NX_U32 hash;
 
@@ -315,29 +314,28 @@ NX_PRIVATE void VfsNodePut(NX_VfsNode * n)
 		return;
     }
 
-	hash = VfsNodeHash(n->mount, n->path);
+	hash = NodeHash(n->mount, n->path);
 	NX_MutexLock(&fileSystemNodeLock[hash]);
 	NX_ListDel(&n->link);
 	NX_MutexUnlock(&fileSystemNodeLock[hash]);
 
 	NX_MutexLock(&n->mount->lock);
-	n->mount->fs->vput(n->mount, n);
+	n->mount->fs->putNode(n->mount, n);
 	NX_MutexUnlock(&n->mount->lock);
 
 	NX_AtomicSub(&n->mount->refcnt, 1);
 	NX_MemFree(n);
 }
 
-NX_PRIVATE NX_Error VfsNodeStat(NX_VfsNode * n, NX_VfsStatInfo * st)
+NX_PRIVATE NX_Error NodeStat(NX_FileNode * n, NX_FileStatInfo * st)
 {
 	NX_U32 mode;
 
-	NX_MemZero(st, sizeof(NX_VfsStatInfo));
+	NX_MemZero(st, sizeof(NX_FileStatInfo));
 
-	st->ino = (NX_U64)((NX_UArch)n);
 	NX_MutexLock(&n->lock);
 	st->size = n->size;
-	mode = n->mode & (NX_VFS_S_IRWXU | NX_VFS_S_IRWXG | NX_VFS_S_IRWXO);
+	mode = n->mode & (NX_FILE_MODE_MASK);
 	st->ctime = n->ctime;
 	st->atime = n->atime;
 	st->mtime = n->mtime;
@@ -345,41 +343,21 @@ NX_PRIVATE NX_Error VfsNodeStat(NX_VfsNode * n, NX_VfsStatInfo * st)
 
 	switch(n->type)
 	{
-	case NX_VFS_NODE_TYPE_REG:
-		mode |= NX_VFS_S_IFREG;
-		break;
-	case NX_VFS_NODE_TYPE_DIR:
-		mode |= NX_VFS_S_IFDIR;
-		break;
-	case NX_VFS_NODE_TYPE_BLK:
-		mode |= NX_VFS_S_IFBLK;
-		break;
-	case NX_VFS_NODE_TYPE_CHR:
-		mode |= NX_VFS_S_IFCHR;
+	case NX_FILE_NODE_TYPE_REG:
+		mode |= NX_FILE_TYPE_REG;
 		break;
-	case NX_VFS_NODE_TYPE_LNK:
-		mode |= NX_VFS_S_IFLNK;
-		break;
-	case NX_VFS_NODE_TYPE_SOCK:
-		mode |= NX_VFS_S_IFSOCK;
-		break;
-	case NX_VFS_NODE_TYPE_FIFO:
-		mode |= NX_VFS_S_IFIFO;
+	case NX_FILE_NODE_TYPE_DIR:
+		mode |= NX_FILE_TYPE_DIR;
 		break;
 	default:
 		return NX_ENORES;
 	};
 	st->mode = mode;
 
-	if(n->type == NX_VFS_NODE_TYPE_CHR || n->type == NX_VFS_NODE_TYPE_BLK)
-		st->dev = (NX_U64)((NX_UArch)n->data);
-	st->uid = 0;
-	st->gid = 0;
-
 	return NX_EOK;
 }
 
-NX_PRIVATE int VfsNodeAccess(NX_VfsNode * n, NX_U32 mode)
+NX_PRIVATE int NodeAccess(NX_FileNode * n, NX_U32 mode)
 {
 	NX_U32 m;
 
@@ -387,25 +365,25 @@ NX_PRIVATE int VfsNodeAccess(NX_VfsNode * n, NX_U32 mode)
 	m = n->mode;
 	NX_MutexUnlock(&n->lock);
 
-	if((mode & NX_VFS_R_OK) && !(m & (NX_VFS_S_IRUSR | NX_VFS_S_IRGRP | NX_VFS_S_IROTH)))
+	if((mode & NX_FILE_READ_OK) && !(m & (NX_FILE_MODE_READ)))
     {
 		return -1;
     }
 
-	if(mode & NX_VFS_W_OK)
+	if(mode & NX_FILE_WRITE_OK)
 	{
-		if(n->mount->flags & NX_VFS_MOUNT_RO)
+		if(n->mount->flags & NX_MOUNT_RO)
         {
 			return -1;
         }
 
-		if(!(m & (NX_VFS_S_IWUSR | NX_VFS_S_IWGRP | NX_VFS_S_IWOTH)))
+		if(!(m & (NX_FILE_MODE_WRITE)))
 		{
         	return -1;
         }
 	}
 
-	if((mode & NX_VFS_X_OK) && !(m & (NX_VFS_S_IXUSR | NX_VFS_S_IXGRP | NX_VFS_S_IXOTH)))
+	if((mode & NX_FILE_EXEC_OK) && !(m & (NX_FILE_MODE_EXEC)))
     {
 		return -1;
     }
@@ -413,10 +391,10 @@ NX_PRIVATE int VfsNodeAccess(NX_VfsNode * n, NX_U32 mode)
 	return 0;
 }
 
-NX_PRIVATE void VfsNodeRelease(NX_VfsNode * n)
+NX_PRIVATE void NodeRelease(NX_FileNode * n)
 {
-	NX_VfsMount * m;
-	char path[NX_VFS_MAX_PATH];
+	NX_MountDesc * m;
+	char path[NX_FILE_MAX_PATH];
 	char * p;
 
 	if(!n)
@@ -428,7 +406,7 @@ NX_PRIVATE void VfsNodeRelease(NX_VfsNode * n)
 
 	if(m->root == n)
 	{
-		VfsNodePut(n);
+		NodePut(n);
 		return;
 	}
 
@@ -437,7 +415,7 @@ NX_PRIVATE void VfsNodeRelease(NX_VfsNode * n)
 		return;
     }
 
-	VfsNodePut(n);
+	NodePut(n);
 
 	while(1)
 	{
@@ -453,28 +431,28 @@ NX_PRIVATE void VfsNodeRelease(NX_VfsNode * n)
 			break;
         }
 
-		n = VfsNodeLookup(m, path);
+		n = NodeLookup(m, path);
 		if(!n)
         {
 			continue;
         }
 
-		VfsNodePut(n);
-		VfsNodePut(n);
+		NodePut(n);
+		NodePut(n);
 	}
-	VfsNodePut(m->root);
+	NodePut(m->root);
 }
 
-NX_PRIVATE int VfsNodeAcquire(const char * path, NX_VfsNode ** np)
+NX_PRIVATE int NodeAcquire(const char * path, NX_FileNode ** np)
 {
-	NX_VfsMount * m;
-	NX_VfsNode * dn, * n;
-	char node[NX_VFS_MAX_PATH];
+	NX_MountDesc * m;
+	NX_FileNode * dn, * n;
+	char node[NX_FILE_MAX_PATH];
 	char * p;
 	NX_Error err;
     int i, j;
 
-	if(VfsFindRoot(path, &m, &p) != NX_EOK)
+	if(FindRoot(path, &m, &p) != NX_EOK)
     {
 		return -1;
     }
@@ -485,7 +463,7 @@ NX_PRIVATE int VfsNodeAcquire(const char * path, NX_VfsNode ** np)
     }
 
 	dn = n = m->root;
-	VfsNodeIncreaseRef(dn);
+	NodeIncreaseRef(dn);
 
 	i = 0;
 	while(*p != '\0')
@@ -511,13 +489,13 @@ NX_PRIVATE int VfsNodeAcquire(const char * path, NX_VfsNode ** np)
 		}
 		node[i] = '\0';
 
-		n = VfsNodeLookup(m, node);
+		n = NodeLookup(m, node);
 		if(n == NX_NULL)
 		{
-			n = VfsNodeGet(m, node);
+			n = NodeGet(m, node);
 			if(n == NX_NULL)
 			{
-				VfsNodePut(dn);
+				NodePut(dn);
 				return -1;
 			}
 
@@ -526,9 +504,9 @@ NX_PRIVATE int VfsNodeAcquire(const char * path, NX_VfsNode ** np)
 			err = dn->mount->fs->lookup(dn, &node[j], n);
 			NX_MutexUnlock(&dn->lock);
 			NX_MutexUnlock(&n->lock);
-			if(err != NX_EOK || (*p == '/' && n->type != NX_VFS_NODE_TYPE_DIR))
+			if(err != NX_EOK || (*p == '/' && n->type != NX_FILE_NODE_TYPE_DIR))
 			{
-				VfsNodeRelease(n);
+				NodeRelease(n);
 				return -1;
 			}
 		}
@@ -540,12 +518,12 @@ NX_PRIVATE int VfsNodeAcquire(const char * path, NX_VfsNode ** np)
 }
 
 /* build path(relative or absolte) to absolte path */
-NX_Error NX_VfsBuildAbsPath(const char * path, char * absPath)
+NX_Error NX_PathBuildAbs(const char * path, char * absPath)
 {
 	char * p, * q, * s;
 	int leftLen, fullLen;
-	char left[NX_VFS_MAX_PATH];
-	char nextToken[NX_VFS_MAX_PATH];
+	char left[NX_FILE_MAX_PATH];
+	char nextToken[NX_FILE_MAX_PATH];
 
 	if(path[0] == '/')
 	{
@@ -567,12 +545,12 @@ NX_Error NX_VfsBuildAbsPath(const char * path, char * absPath)
             NX_LOG_E("kernel thread no cwd! must use absolute path on %s .", path);
             return NX_ENORES;
         }
-		NX_StrCopyN(absPath, cwd, NX_VFS_MAX_PATH);
+		NX_StrCopyN(absPath, cwd, NX_FILE_MAX_PATH);
 
 		fullLen = NX_StrLen(absPath);
 		leftLen = NX_StrCopyN(left, path, sizeof(left));
 	}
-	if((leftLen >= sizeof(left)) || (fullLen >= NX_VFS_MAX_PATH))
+	if((leftLen >= sizeof(left)) || (fullLen >= NX_FILE_MAX_PATH))
 	{
 		return NX_EINVAL;
 	}
@@ -596,7 +574,7 @@ NX_Error NX_VfsBuildAbsPath(const char * path, char * absPath)
 
 		if(absPath[fullLen - 1] != '/')
 		{
-			if (fullLen + 1 >= NX_VFS_MAX_PATH)
+			if (fullLen + 1 >= NX_FILE_MAX_PATH)
 			{
 				return NX_EINVAL;
 			}
@@ -620,8 +598,8 @@ NX_Error NX_VfsBuildAbsPath(const char * path, char * absPath)
 			continue;
 		}
 
-		fullLen = NX_StrCatN(absPath, nextToken, NX_VFS_MAX_PATH);
-		if(fullLen >= NX_VFS_MAX_PATH)
+		fullLen = NX_StrCatN(absPath, nextToken, NX_FILE_MAX_PATH);
+		if(fullLen >= NX_FILE_MAX_PATH)
 		{
 			return NX_EINVAL;
 		}
@@ -634,26 +612,26 @@ NX_Error NX_VfsBuildAbsPath(const char * path, char * absPath)
 	return NX_EOK;
 }
 
-NX_Error NX_VfsMountFileSystem(const char * dev, const char * path, const char * fsname, NX_U32 flags)
+NX_Error NX_FileSystemMount(const char * dev, const char * path, const char * fsname, NX_U32 flags)
 {
 	NX_Device * bdev;
-	NX_VfsFileSystem * fs;
-	NX_VfsMount * m, * tm;
-	NX_VfsNode * n, * n_covered;
+	NX_FileSystem * fs;
+	NX_MountDesc * m, * tm;
+	NX_FileNode * n, * n_covered;
 	NX_Error err;
-    char absPath[NX_VFS_MAX_PATH + 1] = {0};
+    char absPath[NX_FILE_MAX_PATH + 1] = {0};
     
 	if(!path || *path == '\0')
     {
 		return NX_EINVAL;
     }
 
-    if ((err = NX_VfsBuildAbsPath(path, absPath)) != NX_EOK)
+    if ((err = NX_PathBuildAbs(path, absPath)) != NX_EOK)
     {
         return err;
     }
 
-	if(!(fs = NX_VfsSearchFileSystem(fsname)))
+	if(!(fs = NX_FileSystemSearch(fsname)))
     {
 		return NX_ENOSRCH;
     }
@@ -670,7 +648,7 @@ NX_Error NX_VfsMountFileSystem(const char * dev, const char * path, const char *
 		bdev = NX_NULL;
 	}
 
-	if(!(m = NX_MemAlloc(sizeof(NX_VfsMount))))
+	if(!(m = NX_MemAlloc(sizeof(NX_MountDesc))))
     {
 		return NX_ENOMEM;
     }
@@ -678,7 +656,7 @@ NX_Error NX_VfsMountFileSystem(const char * dev, const char * path, const char *
 	NX_ListInit(&m->link);
 	NX_MutexInit(&m->lock);
 	m->fs = fs;
-	m->flags = flags & NX_VFS_MOUNT_MASK;
+	m->flags = flags & NX_MOUNT_MASK;
 	NX_AtomicSet(&m->refcnt, 0);
 	if(NX_StrCopyN(m->path, absPath, sizeof(m->path)) >= sizeof(m->path))
 	{
@@ -693,32 +671,32 @@ NX_Error NX_VfsMountFileSystem(const char * dev, const char * path, const char *
 	}
 	else
 	{
-		if(VfsNodeAcquire(absPath, &n_covered) != 0)
+		if(NodeAcquire(absPath, &n_covered) != 0)
 		{
 			NX_MemFree(m);
 			return NX_ENORES;
 		}
-		if(n_covered->type != NX_VFS_NODE_TYPE_DIR)
+		if(n_covered->type != NX_FILE_NODE_TYPE_DIR)
 		{
-			VfsNodeRelease(n_covered);
+			NodeRelease(n_covered);
 			NX_MemFree(m);
 			return NX_EFAULT;
 		}
 	}
 	m->covered = n_covered;
 
-	if(!(n = VfsNodeGet(m, "/")))
+	if(!(n = NodeGet(m, "/")))
 	{
 		if(m->covered)
         {
-			VfsNodeRelease(m->covered);
+			NodeRelease(m->covered);
         }
 		NX_MemFree(m);
 		return NX_EFAULT;
 	}
-	n->type = NX_VFS_NODE_TYPE_DIR;
-	n->flags = NX_VFS_NODE_FLAG_ROOT;
-	n->mode = NX_VFS_S_IFDIR | NX_VFS_S_IRWXU | NX_VFS_S_IRWXG | NX_VFS_S_IRWXO;
+	n->type = NX_FILE_NODE_TYPE_DIR;
+	n->flags = NX_FILE_NODE_FLAG_ROOT;
+	n->mode = NX_FILE_TYPE_DIR | NX_FILE_MODE_MASK;
 	m->root = n;
 
 	NX_MutexLock(&m->lock);
@@ -726,18 +704,18 @@ NX_Error NX_VfsMountFileSystem(const char * dev, const char * path, const char *
 	NX_MutexUnlock(&m->lock);
 	if(err != NX_EOK)
 	{
-		VfsNodeRelease(m->root);
+		NodeRelease(m->root);
 		if(m->covered)
         {
-			VfsNodeRelease(m->covered);
+			NodeRelease(m->covered);
         }
 		NX_MemFree(m);
 		return err;
 	}
 
-	if(m->flags & NX_VFS_MOUNT_RO)
+	if(m->flags & NX_MOUNT_RO)
     {
-		m->root->mode &= ~(NX_VFS_S_IWUSR | NX_VFS_S_IWGRP | NX_VFS_S_IWOTH);
+		m->root->mode &= ~(NX_FILE_MODE_WRITE);
     }
 
 	NX_MutexLock(&fileSystemMountLock);
@@ -749,10 +727,10 @@ NX_Error NX_VfsMountFileSystem(const char * dev, const char * path, const char *
 			NX_MutexLock(&m->lock);
 			m->fs->unmount(m);
 			NX_MutexUnlock(&m->lock);
-			VfsNodeRelease(m->root);
+			NodeRelease(m->root);
 			if(m->covered)
             {
-				VfsNodeRelease(m->covered);
+				NodeRelease(m->covered);
             }
 			NX_MemFree(m);
 			return NX_EAGAIN;
@@ -764,14 +742,14 @@ NX_Error NX_VfsMountFileSystem(const char * dev, const char * path, const char *
 	return NX_EOK;
 }
 
-NX_Error NX_VfsUnmountFileSystem(const char * path)
+NX_Error NX_FileSystemUnmount(const char * path)
 {
-	NX_VfsMount * m;
+	NX_MountDesc * m;
 	int found;
 	NX_Error err;
-    char absPath[NX_VFS_MAX_PATH + 1] = {0};
+    char absPath[NX_FILE_MAX_PATH + 1] = {0};
 
-    if ((err = NX_VfsBuildAbsPath(path, absPath)) != NX_EOK)
+    if ((err = NX_PathBuildAbs(path, absPath)) != NX_EOK)
     {
         return err;
     }
@@ -800,14 +778,14 @@ NX_Error NX_VfsUnmountFileSystem(const char * path)
 	NX_MutexUnlock(&fileSystemMountLock);
 
 	NX_MutexLock(&m->lock);
-	err = m->fs->msync(m);
+	err = m->fs->mountSync(m);
 	m->fs->unmount(m);
 	NX_MutexUnlock(&m->lock);
 
-	VfsNodeRelease(m->root);
+	NodeRelease(m->root);
 	if(m->covered)
     {
-		VfsNodeRelease(m->covered);
+		NodeRelease(m->covered);
     }
 	
     if(m->dev)
@@ -821,15 +799,15 @@ NX_Error NX_VfsUnmountFileSystem(const char * path)
 	return err;
 }
 
-NX_Error NX_VfsSync(void)
+NX_Error NX_FileSystemSync(void)
 {
-	NX_VfsMount * m;
+	NX_MountDesc * m;
     NX_Error err;
 	NX_MutexLock(&fileSystemMountLock);
 	NX_ListForEachEntry(m, &fileSystemMountList, link)
 	{
 		NX_MutexLock(&m->lock);
-		err = m->fs->msync(m);
+		err = m->fs->mountSync(m);
 		if (err != NX_EOK)
         {
             NX_LOG_W("mount point path %s sync error! with %d", m->path, err);
@@ -841,9 +819,9 @@ NX_Error NX_VfsSync(void)
 	return NX_EOK;
 }
 
-NX_VfsMount * NX_VfsGetMount(int index)
+NX_MountDesc * NX_MountGetByIndex(int index)
 {
-	NX_VfsMount * m = NX_NULL;
+	NX_MountDesc * m = NX_NULL;
 	int found = 0;
 
 	if(index < 0)
@@ -868,9 +846,9 @@ NX_VfsMount * NX_VfsGetMount(int index)
 	return m;
 }
 
-int NX_VfsGetMountCount(void)
+int NX_MountGetCount(void)
 {
-	NX_VfsMount * m;
+	NX_MountDesc * m;
 	int ret = 0;
 
 	NX_MutexLock(&fileSystemMountLock);
@@ -883,10 +861,10 @@ int NX_VfsGetMountCount(void)
 	return ret;
 }
 
-NX_PRIVATE int VfsLookupDir(const char * path, NX_VfsNode ** np, char ** name)
+NX_PRIVATE int LookupDir(const char * path, NX_FileNode ** np, char ** name)
 {
-	NX_VfsNode * n;
-	char buf[NX_VFS_MAX_PATH];
+	NX_FileNode * n;
+	char buf[NX_FILE_MAX_PATH];
 	char * file, * dir;
 	int err;
 
@@ -916,13 +894,13 @@ NX_PRIVATE int VfsLookupDir(const char * path, NX_VfsNode ** np, char ** name)
 		dir = buf;
 	}
 
-	if((err = VfsNodeAcquire(dir, &n)))
+	if((err = NodeAcquire(dir, &n)))
     {
 		return err;
     }
-	if(n->type != NX_VFS_NODE_TYPE_DIR)
+	if(n->type != NX_FILE_NODE_TYPE_DIR)
 	{
-		VfsNodeRelease(n);
+		NodeRelease(n);
 		return -1;
 	}
 	*np = n;
@@ -937,53 +915,53 @@ NX_PRIVATE int VfsLookupDir(const char * path, NX_VfsNode ** np, char ** name)
 	return 0;
 }
 
-int NX_VfsOpen(const char * path, NX_U32 flags, NX_U32 mode, NX_Error *outErr)
+int NX_FileOpen(const char * path, NX_U32 flags, NX_U32 mode, NX_Error *outErr)
 {
-	NX_VfsNode * n, * dn;
-	NX_VfsFile * f;
+	NX_FileNode * n, * dn;
+	NX_FileDesc * f;
 	char * filename;
 	int err, fd;
-    NX_VfsFileTable *ft;
-    char absPath[NX_VFS_MAX_PATH + 1] = {0};
+    NX_FileTable *ft;
+    char absPath[NX_FILE_MAX_PATH + 1] = {0};
 
-	if(!path || !(flags & NX_VFS_O_ACCMODE))
+	if(!path || !(flags & NX_FILE_ACCMODE))
     {
         NX_ErrorSet(outErr, NX_EINVAL);
 		return -1;
     }
 
     /* check has file table */
-    ft = VFS_GET_FILE_TABLE();
+    ft = GET_FILE_TABLE();
     if (!ft)
     {
         NX_ErrorSet(outErr, NX_ENORES);
         return -1;
     }
 
-    if (NX_VfsBuildAbsPath(path, absPath) != NX_EOK)
+    if (NX_PathBuildAbs(path, absPath) != NX_EOK)
     {
         NX_ErrorSet(outErr, NX_ENOSRCH);
         return -1;
     }
 
-	if(flags & NX_VFS_O_CREAT)
+	if(flags & NX_FILE_CREAT)
 	{
-		err = VfsNodeAcquire(absPath, &n);
+		err = NodeAcquire(absPath, &n);
 		if(err)
 		{
-			if((err = VfsLookupDir(absPath, &dn, &filename)))
+			if((err = LookupDir(absPath, &dn, &filename)))
             {
                 NX_ErrorSet(outErr, NX_ENOSRCH);
 				return err;
             }
-			if((err = VfsNodeAccess(dn, NX_VFS_W_OK)))
+			if((err = NodeAccess(dn, NX_FILE_WRITE_OK)))
 			{
                 NX_ErrorSet(outErr, NX_EPERM);
-				VfsNodeRelease(dn);
+				NodeRelease(dn);
 				return err;
 			}
-			mode &= ~NX_VFS_S_IFMT;
-			mode |= NX_VFS_S_IFREG;
+			mode &= ~NX_FILE_TYPE_MASK;
+			mode |= NX_FILE_TYPE_REG;
 			NX_MutexLock(&dn->lock);
 			err = dn->mount->fs->create(dn, filename, mode);
 			if(err == NX_EOK)
@@ -991,60 +969,60 @@ int NX_VfsOpen(const char * path, NX_U32 flags, NX_U32 mode, NX_Error *outErr)
 				err = dn->mount->fs->sync(dn);
             }
 			NX_MutexUnlock(&dn->lock);
-			VfsNodeRelease(dn);
+			NodeRelease(dn);
 			if(err != NX_EOK)
             {
                 NX_ErrorSet(outErr, err);
 				return -1;
             }
-			if((err = VfsNodeAcquire(absPath, &n)))
+			if((err = NodeAcquire(absPath, &n)))
             {
                 NX_ErrorSet(outErr, NX_ENORES);
 				return err;
             }
-			flags &= ~NX_VFS_O_TRUNC;
+			flags &= ~NX_FILE_TRUNC;
 		}
 		else
 		{
-			if(flags & NX_VFS_O_EXCL)
+			if(flags & NX_FILE_EXCL)
 			{
                 NX_ErrorSet(outErr, NX_EAGAIN);
-				VfsNodeRelease(n);
+				NodeRelease(n);
 				return -1;
 			}
-			flags &= ~NX_VFS_O_CREAT;
+			flags &= ~NX_FILE_CREAT;
 		}
 	}
 	else
 	{
-		if((err = VfsNodeAcquire(absPath, &n)))
+		if((err = NodeAcquire(absPath, &n)))
 		{
             NX_ErrorSet(outErr, NX_ENORES);
 			return err;
 		}
-		if((flags & NX_VFS_O_WRONLY) || (flags & NX_VFS_O_TRUNC))
+		if((flags & NX_FILE_WRONLY) || (flags & NX_FILE_TRUNC))
 		{
-			if((err = VfsNodeAccess(n, NX_VFS_W_OK)))
+			if((err = NodeAccess(n, NX_FILE_WRITE_OK)))
 			{
                 NX_ErrorSet(outErr, NX_EPERM);
-				VfsNodeRelease(n);
+				NodeRelease(n);
 				return err;
 			}
-			if(n->type == NX_VFS_NODE_TYPE_DIR)
+			if(n->type == NX_FILE_NODE_TYPE_DIR)
 			{
                 NX_ErrorSet(outErr, NX_EPERM);
-				VfsNodeRelease(n);
+				NodeRelease(n);
 				return -1;
 			}
 		}
 	}
 
-	if(flags & NX_VFS_O_TRUNC)
+	if(flags & NX_FILE_TRUNC)
 	{
-		if(!(flags & NX_VFS_O_WRONLY) || (n->type == NX_VFS_NODE_TYPE_DIR))
+		if(!(flags & NX_FILE_WRONLY) || (n->type == NX_FILE_NODE_TYPE_DIR))
 		{
             NX_ErrorSet(outErr, NX_EPERM);
-			VfsNodeRelease(n);
+			NodeRelease(n);
 			return -1;
 		}
 		NX_MutexLock(&n->lock);
@@ -1053,19 +1031,19 @@ int NX_VfsOpen(const char * path, NX_U32 flags, NX_U32 mode, NX_Error *outErr)
 		if(err)
 		{
             NX_ErrorSet(outErr, err);
-			VfsNodeRelease(n);
+			NodeRelease(n);
 			return -1;
 		}
 	}
 
-    fd = VfsFileAlloc(ft);
+    fd = FileAlloc(ft);
 	if(fd < 0)
 	{
         NX_ErrorSet(outErr, NX_ENORES);
-		VfsNodeRelease(n);
+		NodeRelease(n);
 		return -1;
 	}
-	f = VfsFileDescriptorToFile(ft, fd);
+	f = FileDescriptorToFile(ft, fd);
 
 	NX_MutexLock(&f->lock);
 	f->node = n;
@@ -1077,21 +1055,21 @@ int NX_VfsOpen(const char * path, NX_U32 flags, NX_U32 mode, NX_Error *outErr)
 	return fd;
 }
 
-NX_Error NX_VfsClose(int fd)
+NX_Error NX_FileClose(int fd)
 {
-	NX_VfsNode * n;
-	NX_VfsFile * f;
+	NX_FileNode * n;
+	NX_FileDesc * f;
 	NX_Error err;
-    NX_VfsFileTable *ft;
+    NX_FileTable *ft;
 
     /* check has file table */
-    ft = VFS_GET_FILE_TABLE();
+    ft = GET_FILE_TABLE();
     if (!ft)
     {
         return NX_ENORES;
     }
 
-	f = VfsFileDescriptorToFile(ft, fd);
+	f = FileDescriptorToFile(ft, fd);
 	if(!f)
     {
 		return NX_EFAULT;
@@ -1113,19 +1091,19 @@ NX_Error NX_VfsClose(int fd)
 		NX_MutexUnlock(&f->lock);
 		return err;
 	}
-	VfsNodeRelease(n);
+	NodeRelease(n);
 	NX_MutexUnlock(&f->lock);
 
-	VfsFileFree(ft, fd);
+	FileFree(ft, fd);
 	return NX_EOK;
 }
 
-NX_U64 NX_VfsRead(int fd, void * buf, NX_U64 len, NX_Error *outErr)
+NX_U64 NX_FileRead(int fd, void * buf, NX_U64 len, NX_Error *outErr)
 {
-	NX_VfsNode * n;
-	NX_VfsFile * f;
+	NX_FileNode * n;
+	NX_FileDesc * f;
 	NX_U64 ret;
-    NX_VfsFileTable *ft;
+    NX_FileTable *ft;
     NX_Error err = NX_EOK;
 
 	if(!buf || !len)
@@ -1134,8 +1112,8 @@ NX_U64 NX_VfsRead(int fd, void * buf, NX_U64 len, NX_Error *outErr)
 		return 0;
     }
 
-    ft = VFS_GET_FILE_TABLE();
-	f = VfsFileDescriptorToFile(ft, fd);
+    ft = GET_FILE_TABLE();
+	f = FileDescriptorToFile(ft, fd);
 	if(!f)
     {
         NX_ErrorSet(outErr, NX_ENORES);
@@ -1150,14 +1128,14 @@ NX_U64 NX_VfsRead(int fd, void * buf, NX_U64 len, NX_Error *outErr)
         NX_ErrorSet(outErr, NX_EFAULT);
 		return 0;
 	}
-	if(n->type != NX_VFS_NODE_TYPE_REG)
+	if(n->type != NX_FILE_NODE_TYPE_REG)
 	{
 		NX_MutexUnlock(&f->lock);
         NX_ErrorSet(outErr, NX_ENORES);
 		return 0;
 	}
 
-	if(!(f->flags & NX_VFS_O_RDONLY))
+	if(!(f->flags & NX_FILE_RDONLY))
 	{
 		NX_MutexUnlock(&f->lock);
         NX_ErrorSet(outErr, NX_EPERM);
@@ -1174,12 +1152,12 @@ NX_U64 NX_VfsRead(int fd, void * buf, NX_U64 len, NX_Error *outErr)
 	return ret;
 }
 
-NX_U64 NX_VfsWrite(int fd, void * buf, NX_U64 len, NX_Error *outErr)
+NX_U64 NX_FileWrite(int fd, void * buf, NX_U64 len, NX_Error *outErr)
 {
-	NX_VfsNode * n;
-	NX_VfsFile * f;
+	NX_FileNode * n;
+	NX_FileDesc * f;
 	NX_U64 ret;
-    NX_VfsFileTable *ft;
+    NX_FileTable *ft;
     NX_Error err = NX_EOK;
 
 	if(!buf || !len)
@@ -1188,8 +1166,8 @@ NX_U64 NX_VfsWrite(int fd, void * buf, NX_U64 len, NX_Error *outErr)
 		return 0;
     }
 
-    ft = VFS_GET_FILE_TABLE();
-	f = VfsFileDescriptorToFile(ft, fd);
+    ft = GET_FILE_TABLE();
+	f = FileDescriptorToFile(ft, fd);
 	if(!f)
     {
         NX_ErrorSet(outErr, NX_ENORES);
@@ -1204,14 +1182,14 @@ NX_U64 NX_VfsWrite(int fd, void * buf, NX_U64 len, NX_Error *outErr)
         NX_ErrorSet(outErr, NX_EFAULT);
 		return 0;
 	}
-	if(n->type != NX_VFS_NODE_TYPE_REG)
+	if(n->type != NX_FILE_NODE_TYPE_REG)
 	{
 		NX_MutexUnlock(&f->lock);
         NX_ErrorSet(outErr, NX_ENORES);
 		return 0;
 	}
 
-	if(!(f->flags & NX_VFS_O_WRONLY))
+	if(!(f->flags & NX_FILE_WRONLY))
 	{
 		NX_MutexUnlock(&f->lock);
         NX_ErrorSet(outErr, NX_EPERM);
@@ -1229,15 +1207,15 @@ NX_U64 NX_VfsWrite(int fd, void * buf, NX_U64 len, NX_Error *outErr)
 	return ret;
 }
 
-NX_Error NX_VfsIoctl(int fd, NX_U32 cmd, void *arg)
+NX_Error NX_FileIoctl(int fd, NX_U32 cmd, void *arg)
 {
-	NX_VfsNode * n;
-	NX_VfsFile * f;
+	NX_FileNode * n;
+	NX_FileDesc * f;
 	NX_Error err;
-    NX_VfsFileTable *ft;
+    NX_FileTable *ft;
 
-    ft = VFS_GET_FILE_TABLE();
-	f = VfsFileDescriptorToFile(ft, fd);
+    ft = GET_FILE_TABLE();
+	f = FileDescriptorToFile(ft, fd);
 	if(!f)
     {
 		return NX_ENORES;
@@ -1260,15 +1238,15 @@ NX_Error NX_VfsIoctl(int fd, NX_U32 cmd, void *arg)
 	return err;
 }
 
-NX_I64 NX_VfsFileSeek(int fd, NX_I64 off, int whence, NX_Error *outErr)
+NX_Offset NX_FileSetPointer(int fd, NX_Offset off, int whence, NX_Error *outErr)
 {
-	NX_VfsNode * n;
-	NX_VfsFile * f;
-	NX_I64 ret;
-    NX_VfsFileTable *ft;
+	NX_FileNode * n;
+	NX_FileDesc * f;
+	NX_Offset ret;
+    NX_FileTable *ft;
     
-    ft = VFS_GET_FILE_TABLE();
-	f = VfsFileDescriptorToFile(ft, fd);
+    ft = GET_FILE_TABLE();
+	f = FileDescriptorToFile(ft, fd);
 	if(!f)
     {
         NX_ErrorSet(outErr, NX_ENORES);
@@ -1287,14 +1265,14 @@ NX_I64 NX_VfsFileSeek(int fd, NX_I64 off, int whence, NX_Error *outErr)
 	NX_MutexLock(&n->lock);
 	switch(whence)
 	{
-	case NX_VFS_SEEK_SET:
+	case NX_FILE_SEEK_SET:
 		if(off < 0)
 			off = 0;
 		else if(off > (NX_Offset64)n->size)
 			off = n->size;
 		break;
 
-	case NX_VFS_SEEK_CUR:
+	case NX_FILE_SEEK_CUR:
 		if((f->offset + off) > (NX_Offset64)n->size)
 			off = n->size;
 		else if((f->offset + off) < 0)
@@ -1303,7 +1281,7 @@ NX_I64 NX_VfsFileSeek(int fd, NX_I64 off, int whence, NX_Error *outErr)
 			off = f->offset + off;
 		break;
 
-	case NX_VFS_SEEK_END:
+	case NX_FILE_SEEK_END:
 		if(off > 0)
 			off = n->size;
 		else if((n->size + off) < 0)
@@ -1333,15 +1311,15 @@ NX_I64 NX_VfsFileSeek(int fd, NX_I64 off, int whence, NX_Error *outErr)
 	return ret;
 }
 
-NX_Error NX_VfsFileSync(int fd)
+NX_Error NX_FileSync(int fd)
 {
-	NX_VfsNode * n;
-	NX_VfsFile * f;
+	NX_FileNode * n;
+	NX_FileDesc * f;
 	NX_Error err;
-    NX_VfsFileTable *ft;
+    NX_FileTable *ft;
     
-    ft = VFS_GET_FILE_TABLE();
-	f = VfsFileDescriptorToFile(ft, fd);
+    ft = GET_FILE_TABLE();
+	f = FileDescriptorToFile(ft, fd);
 	if(!f)
     {
 		return NX_ENORES;
@@ -1354,7 +1332,7 @@ NX_Error NX_VfsFileSync(int fd)
 		NX_MutexUnlock(&f->lock);
 		return NX_EFAULT;
 	}
-	if(!(f->flags & NX_VFS_O_WRONLY))
+	if(!(f->flags & NX_FILE_WRONLY))
 	{
 		NX_MutexUnlock(&f->lock);
 		return NX_EPERM;
@@ -1367,15 +1345,15 @@ NX_Error NX_VfsFileSync(int fd)
 	return err;
 }
 
-NX_Error NX_VfsFileChmod(int fd, NX_U32 mode)
+NX_Error NX_FileSetMode(int fd, NX_U32 mode)
 {
-	NX_VfsNode * n;
-	NX_VfsFile * f;
+	NX_FileNode * n;
+	NX_FileDesc * f;
 	int err;
-    NX_VfsFileTable *ft;
+    NX_FileTable *ft;
     
-    ft = VFS_GET_FILE_TABLE();
-	f = VfsFileDescriptorToFile(ft, fd);
+    ft = GET_FILE_TABLE();
+	f = FileDescriptorToFile(ft, fd);
 	if(!f)
     {
 		return NX_ENORES;
@@ -1388,29 +1366,29 @@ NX_Error NX_VfsFileChmod(int fd, NX_U32 mode)
 		NX_MutexUnlock(&f->lock);
 		return NX_EFAULT;
 	}
-	mode &= (NX_VFS_S_IRWXU | NX_VFS_S_IRWXG | NX_VFS_S_IRWXO);
+	mode &= (NX_FILE_MODE_MASK);
 	NX_MutexLock(&n->lock);
-	err = n->mount->fs->chmod(n, mode);
+	err = n->mount->fs->setMode(n, mode);
 	NX_MutexUnlock(&n->lock);
 	NX_MutexUnlock(&f->lock);
 
 	return err;
 }
 
-NX_Error NX_VfsFileStat(int fd, NX_VfsStatInfo * st)
+NX_Error NX_FileGetStat(int fd, NX_FileStatInfo * st)
 {
-	NX_VfsNode * n;
-	NX_VfsFile * f;
+	NX_FileNode * n;
+	NX_FileDesc * f;
 	NX_Error err;
-    NX_VfsFileTable *ft;
+    NX_FileTable *ft;
     
 	if(!st)
     {
 		return NX_EINVAL;
     }
 
-    ft = VFS_GET_FILE_TABLE();
-	f = VfsFileDescriptorToFile(ft, fd);
+    ft = GET_FILE_TABLE();
+	f = FileDescriptorToFile(ft, fd);
 	if(!f)
     {
 		return NX_ENORES;
@@ -1423,18 +1401,18 @@ NX_Error NX_VfsFileStat(int fd, NX_VfsStatInfo * st)
 		NX_MutexUnlock(&f->lock);
 		return NX_EFAULT;
 	}
-	err = VfsNodeStat(n, st);
+	err = NodeStat(n, st);
 	NX_MutexUnlock(&f->lock);
 
 	return err;
 }
 
-int NX_VfsOpenDir(const char * name, NX_Error *outErr)
+int NX_DirOpen(const char * name, NX_Error *outErr)
 {
-	NX_VfsNode * n;
-	NX_VfsFile * f;
+	NX_FileNode * n;
+	NX_FileDesc * f;
 	int fd;
-    NX_VfsFileTable *ft;
+    NX_FileTable *ft;
     NX_Error err = NX_EOK;
     
 	if(!name)
@@ -1443,14 +1421,14 @@ int NX_VfsOpenDir(const char * name, NX_Error *outErr)
 		return -1;
     }
 
-	if((fd = NX_VfsOpen(name, NX_VFS_O_RDONLY, 0, &err)) < 0)
+	if((fd = NX_FileOpen(name, NX_FILE_RDONLY, 0, &err)) < 0)
     {
         NX_ErrorSet(outErr, err);
 		return fd;
     }
 
-    ft = VFS_GET_FILE_TABLE();
-	f = VfsFileDescriptorToFile(ft, fd);
+    ft = GET_FILE_TABLE();
+	f = FileDescriptorToFile(ft, fd);
 	if(!f)
     {
         NX_ErrorSet(outErr, NX_ENORES);
@@ -1466,10 +1444,10 @@ int NX_VfsOpenDir(const char * name, NX_Error *outErr)
 		return -1;
 	}
 
-	if(n->type != NX_VFS_NODE_TYPE_DIR)
+	if(n->type != NX_FILE_NODE_TYPE_DIR)
 	{
 		NX_MutexUnlock(&f->lock);
-		NX_VfsClose(fd);
+		NX_FileClose(fd);
         NX_ErrorSet(outErr, NX_ENORES);
 		return -1;
 	}
@@ -1479,14 +1457,14 @@ int NX_VfsOpenDir(const char * name, NX_Error *outErr)
 	return fd;
 }
 
-NX_Error NX_VfsCloseDir(int fd)
+NX_Error NX_DirClose(int fd)
 {
-	NX_VfsNode * n;
-	NX_VfsFile * f;
-    NX_VfsFileTable *ft;
+	NX_FileNode * n;
+	NX_FileDesc * f;
+    NX_FileTable *ft;
     
-    ft = VFS_GET_FILE_TABLE();
-	f = VfsFileDescriptorToFile(ft, fd);
+    ft = GET_FILE_TABLE();
+	f = FileDescriptorToFile(ft, fd);
 	if(!f)
     {
 		return NX_ENORES;
@@ -1500,30 +1478,30 @@ NX_Error NX_VfsCloseDir(int fd)
 		return NX_EFAULT;
 	}
 
-	if(n->type != NX_VFS_NODE_TYPE_DIR)
+	if(n->type != NX_FILE_NODE_TYPE_DIR)
 	{
 		NX_MutexUnlock(&f->lock);
 		return NX_ENORES;
 	}
 	NX_MutexUnlock(&f->lock);
 
-	return NX_VfsClose(fd);
+	return NX_FileClose(fd);
 }
 
-NX_Error NX_VfsReadDir(int fd, NX_VfsDirent * dir)
+NX_Error NX_DirRead(int fd, NX_Dirent * dir)
 {
-	NX_VfsNode * n;
-	NX_VfsFile * f;
+	NX_FileNode * n;
+	NX_FileDesc * f;
 	NX_Error err;
-    NX_VfsFileTable *ft;
+    NX_FileTable *ft;
     
 	if(!dir)
     {
 		return NX_EINVAL;
     }
 
-    ft = VFS_GET_FILE_TABLE();
-	f = VfsFileDescriptorToFile(ft, fd);
+    ft = GET_FILE_TABLE();
+	f = FileDescriptorToFile(ft, fd);
 	if(!f)
     {
 		return NX_ENORES;
@@ -1536,13 +1514,13 @@ NX_Error NX_VfsReadDir(int fd, NX_VfsDirent * dir)
 		NX_MutexUnlock(&f->lock);
 		return NX_EFAULT;
 	}
-	if(n->type != NX_VFS_NODE_TYPE_DIR)
+	if(n->type != NX_FILE_NODE_TYPE_DIR)
 	{
 		NX_MutexUnlock(&f->lock);
 		return NX_ENORES;
 	}
 	NX_MutexLock(&n->lock);
-	err = n->mount->fs->readdir(n, f->offset, dir);
+	err = n->mount->fs->readDir(n, f->offset, dir);
 	NX_MutexUnlock(&n->lock);
 	if(!err)
     {
@@ -1553,14 +1531,14 @@ NX_Error NX_VfsReadDir(int fd, NX_VfsDirent * dir)
 	return err;
 }
 
-NX_Error NX_VfsRewindDir(int fd)
+NX_Error NX_DirResetPointer(int fd)
 {
-	NX_VfsNode * n;
-	NX_VfsFile * f;
-    NX_VfsFileTable *ft;
+	NX_FileNode * n;
+	NX_FileDesc * f;
+    NX_FileTable *ft;
     
-    ft = VFS_GET_FILE_TABLE();
-	f = VfsFileDescriptorToFile(ft, fd);
+    ft = GET_FILE_TABLE();
+	f = FileDescriptorToFile(ft, fd);
 	if(!f)
     {
 		return NX_ENORES;
@@ -1573,7 +1551,7 @@ NX_Error NX_VfsRewindDir(int fd)
 		NX_MutexUnlock(&f->lock);
 		return NX_EFAULT;
 	}
-	if(n->type != NX_VFS_NODE_TYPE_DIR)
+	if(n->type != NX_FILE_NODE_TYPE_DIR)
 	{
 		NX_MutexUnlock(&f->lock);
 		return NX_ENORES;
@@ -1584,46 +1562,46 @@ NX_Error NX_VfsRewindDir(int fd)
 	return 0;
 }
 
-NX_Error NX_VfsMakeDir(const char * path, NX_U32 mode)
+NX_Error NX_DirCreate(const char * path, NX_U32 mode)
 {
-	NX_VfsNode * n, * dn;
+	NX_FileNode * n, * dn;
 	char * name;
 	NX_Error err;
-    char absPath[NX_VFS_MAX_PATH + 1] = {0};
+    char absPath[NX_FILE_MAX_PATH + 1] = {0};
 
 	if(!path)
     {
 		return NX_EINVAL;
     }
 
-    if ((err = NX_VfsBuildAbsPath(path, absPath)) != NX_EOK)
+    if ((err = NX_PathBuildAbs(path, absPath)) != NX_EOK)
     {
         return err;
     }
 
-	if(!VfsNodeAcquire(absPath, &n))
+	if(!NodeAcquire(absPath, &n))
 	{
-		VfsNodeRelease(n);
+		NodeRelease(n);
 		return NX_EAGAIN;
 	}
 
-	if((err = VfsLookupDir(absPath, &dn, &name)))
+	if((err = LookupDir(absPath, &dn, &name)))
     {
 		return NX_ENOSRCH;
     }
 
-	if((err = VfsNodeAccess(dn, NX_VFS_W_OK)))
+	if((err = NodeAccess(dn, NX_FILE_WRITE_OK)))
 	{
-		VfsNodeRelease(dn);
+		NodeRelease(dn);
 		return NX_EPERM;
 	}
 
-	mode &= ~NX_VFS_S_IFMT;
-	mode |= NX_VFS_S_IFDIR;
+	mode &= ~NX_FILE_TYPE_MASK;
+	mode |= NX_FILE_TYPE_DIR;
 
 	NX_MutexLock(&dn->lock);
 
-	err = dn->mount->fs->mkdir(dn, name, mode);
+	err = dn->mount->fs->createDir(dn, name, mode);
 	if(err)
     {
 		goto fail;
@@ -1632,18 +1610,18 @@ NX_Error NX_VfsMakeDir(const char * path, NX_U32 mode)
 
 fail:
 	NX_MutexUnlock(&dn->lock);
-	VfsNodeRelease(dn);
+	NodeRelease(dn);
 
 	return err;
 }
 
-NX_PRIVATE NX_Error VfsCheckDirEmpty(const char * path)
+NX_PRIVATE NX_Error CheckDirEmpty(const char * path)
 {
-	NX_VfsDirent dir;
+	NX_Dirent dir;
 	NX_Error err;
     int fd, count;
 
-	if((fd = NX_VfsOpenDir(path, &err)) < 0)
+	if((fd = NX_DirOpen(path, &err)) < 0)
     {
 		return err;
     }
@@ -1651,7 +1629,7 @@ NX_PRIVATE NX_Error VfsCheckDirEmpty(const char * path)
 	count = 0;
 	do
 	{
-		err = NX_VfsReadDir(fd, &dir);
+		err = NX_DirRead(fd, &dir);
 		if(err != NX_EOK)
         {
 			break;
@@ -1666,7 +1644,7 @@ NX_PRIVATE NX_Error VfsCheckDirEmpty(const char * path)
         }
 	} while(1);
 
-	NX_VfsCloseDir(fd);
+	NX_DirClose(fd);
 	if(count)
     {
 		return NX_EAGAIN;
@@ -1675,55 +1653,55 @@ NX_PRIVATE NX_Error VfsCheckDirEmpty(const char * path)
 	return NX_EOK;
 }
 
-NX_Error NX_VfsRemoveDir(const char * path)
+NX_Error NX_DirDelete(const char * path)
 {
-	NX_VfsNode * n, * dn;
+	NX_FileNode * n, * dn;
 	char * name;
 	NX_Error err;
-    char absPath[NX_VFS_MAX_PATH + 1] = {0};
+    char absPath[NX_FILE_MAX_PATH + 1] = {0};
 
 	if(!path)
     {
 		return NX_EINVAL;
     }
 
-    if ((err = NX_VfsBuildAbsPath(path, absPath)) != NX_EOK)
+    if ((err = NX_PathBuildAbs(path, absPath)) != NX_EOK)
     {
         return err;
     }
 
-	if((err = VfsCheckDirEmpty(absPath)) != NX_EOK)
+	if((err = CheckDirEmpty(absPath)) != NX_EOK)
     {
 		return err;
     }
 
-	if(VfsNodeAcquire(absPath, &n))
+	if(NodeAcquire(absPath, &n))
     {
 		return NX_ENORES;
     }
 
-	if((n->flags == NX_VFS_NODE_FLAG_ROOT) || (NX_AtomicGet(&n->refcnt) >= 2))
+	if((n->flags == NX_FILE_NODE_FLAG_ROOT) || (NX_AtomicGet(&n->refcnt) >= 2))
 	{
-		VfsNodeRelease(n);
+		NodeRelease(n);
 		return NX_EBUSY;
 	}
 
-	if(VfsNodeAccess(n, NX_VFS_W_OK))
+	if(NodeAccess(n, NX_FILE_WRITE_OK))
 	{
-		VfsNodeRelease(n);
+		NodeRelease(n);
 		return NX_EPERM;
 	}
 
-	if(VfsLookupDir(absPath, &dn, &name))
+	if(LookupDir(absPath, &dn, &name))
 	{
-		VfsNodeRelease(n);
+		NodeRelease(n);
 		return NX_ENOSRCH;
 	}
 
 	NX_MutexLock(&dn->lock);
 	NX_MutexLock(&n->lock);
 
-	err = dn->mount->fs->rmdir(dn, n, name);
+	err = dn->mount->fs->deleteDir(dn, n, name);
 	if(err != NX_EOK)
     {
 		goto fail;
@@ -1739,22 +1717,22 @@ NX_Error NX_VfsRemoveDir(const char * path)
 fail:
 	NX_MutexUnlock(&n->lock);
 	NX_MutexUnlock(&dn->lock);
-	VfsNodeRelease(n);
-	VfsNodeRelease(dn);
+	NodeRelease(n);
+	NodeRelease(dn);
 
 	return err;
 }
 
-NX_Error NX_VfsRename(const char * src, const char * dst)
+NX_Error NX_FileRename(const char * src, const char * dst)
 {
-	NX_VfsNode * n1, * n2, * sn, * dn;
+	NX_FileNode * n1, * n2, * sn, * dn;
 	char * sname, * dname;
 	int len;
     NX_Error err;
-    char srcAbsPath[NX_VFS_MAX_PATH + 1] = {0};
-    char dstAbsPath[NX_VFS_MAX_PATH + 1] = {0};
+    char srcAbsPath[NX_FILE_MAX_PATH + 1] = {0};
+    char dstAbsPath[NX_FILE_MAX_PATH + 1] = {0};
 
-	if(!NX_StrCmpN(src, dst, NX_VFS_MAX_PATH))
+	if(!NX_StrCmpN(src, dst, NX_FILE_MAX_PATH))
     {
 		return NX_EINVAL;
     }
@@ -1770,22 +1748,22 @@ NX_Error NX_VfsRename(const char * src, const char * dst)
 		return NX_EINVAL;
     }
 
-    if ((err = NX_VfsBuildAbsPath(src, srcAbsPath)) != NX_EOK)
+    if ((err = NX_PathBuildAbs(src, srcAbsPath)) != NX_EOK)
     {
         return err;
     }
 
-    if ((err = NX_VfsBuildAbsPath(dst, dstAbsPath)) != NX_EOK)
+    if ((err = NX_PathBuildAbs(dst, dstAbsPath)) != NX_EOK)
     {
         return err;
     }
 
-	if(VfsNodeAcquire(srcAbsPath, &n1))
+	if(NodeAcquire(srcAbsPath, &n1))
     {
 		return NX_ENORES;
     }
 
-	if(VfsNodeAccess(n1, NX_VFS_W_OK))
+	if(NodeAccess(n1, NX_FILE_WRITE_OK))
     {
 		err = NX_EPERM;
 		goto fail1;
@@ -1797,20 +1775,20 @@ NX_Error NX_VfsRename(const char * src, const char * dst)
 		goto fail1;
 	}
 
-	if(VfsLookupDir(srcAbsPath, &sn, &sname))
+	if(LookupDir(srcAbsPath, &sn, &sname))
     {
         err = NX_ENOSRCH;
 		goto fail1;
     }
 
-	if(!VfsNodeAcquire(dstAbsPath, &n2))
+	if(!NodeAcquire(dstAbsPath, &n2))
 	{
-		VfsNodeRelease(n2);
+		NodeRelease(n2);
 		err = NX_EBUSY;
 		goto fail2;
 	}
 
-	if(VfsLookupDir(dstAbsPath, &dn, &dname))
+	if(LookupDir(dstAbsPath, &dn, &dname))
     {
         err = NX_ENOSRCH;
 		goto fail2;
@@ -1855,58 +1833,58 @@ fail4:
 	NX_MutexUnlock(&sn->lock);
 	NX_MutexUnlock(&n1->lock);
 fail3:
-	VfsNodeRelease(dn);
+	NodeRelease(dn);
 fail2:
-	VfsNodeRelease(sn);
+	NodeRelease(sn);
 fail1:
-	VfsNodeRelease(n1);
+	NodeRelease(n1);
 
 	return err;
 }
 
-NX_Error NX_VfsUnlink(const char * path)
+NX_Error NX_FileDelete(const char * path)
 {
-	NX_VfsNode * n, * dn;
+	NX_FileNode * n, * dn;
 	char * name;
 	NX_Error err;
-    char absPath[NX_VFS_MAX_PATH + 1] = {0};
+    char absPath[NX_FILE_MAX_PATH + 1] = {0};
 
 	if(!path)
     {
 		return NX_EINVAL;
     }
 
-    if ((err = NX_VfsBuildAbsPath(path, absPath)) != NX_EOK)
+    if ((err = NX_PathBuildAbs(path, absPath)) != NX_EOK)
     {
         return err;
     }
 
-	if(VfsNodeAcquire(absPath, &n))
+	if(NodeAcquire(absPath, &n))
     {
 		return NX_ENOSRCH;
     }
 
-	if(n->type == NX_VFS_NODE_TYPE_DIR)
+	if(n->type == NX_FILE_NODE_TYPE_DIR)
 	{
-		VfsNodeRelease(n);
+		NodeRelease(n);
 		return NX_ENORES;
 	}
 
-	if((n->flags == NX_VFS_NODE_FLAG_ROOT) || (NX_AtomicGet(&n->refcnt) >= 2))
+	if((n->flags == NX_FILE_NODE_FLAG_ROOT) || (NX_AtomicGet(&n->refcnt) >= 2))
 	{
-		VfsNodeRelease(n);
+		NodeRelease(n);
 		return NX_EBUSY;
 	}
 
-	if(VfsNodeAccess(n, NX_VFS_W_OK))
+	if(NodeAccess(n, NX_FILE_WRITE_OK))
 	{
-		VfsNodeRelease(n);
+		NodeRelease(n);
 		return NX_EPERM;
 	}
 
-	if(VfsLookupDir(absPath, &dn, &name))
+	if(LookupDir(absPath, &dn, &name))
 	{
-		VfsNodeRelease(n);
+		NodeRelease(n);
 		return NX_ENOSRCH;
 	}
 
@@ -1924,7 +1902,7 @@ NX_Error NX_VfsUnlink(const char * path)
     }
 
 	NX_MutexLock(&dn->lock);
-	err = dn->mount->fs->remove(dn, n, name);
+	err = dn->mount->fs->delete(dn, n, name);
 	if(err)
     {
 		goto fail2;
@@ -1935,68 +1913,68 @@ fail2:
 	NX_MutexUnlock(&dn->lock);
 fail1:
 	NX_MutexUnlock(&n->lock);
-	VfsNodeRelease(dn);
-	VfsNodeRelease(n);
+	NodeRelease(dn);
+	NodeRelease(n);
 
 	return err;
 }
 
-NX_Error NX_VfsAccess(const char * path, NX_U32 mode)
+NX_Error NX_FileAccess(const char * path, NX_U32 mode)
 {
-	NX_VfsNode * n;
+	NX_FileNode * n;
 	NX_Error err = NX_EOK;
-    char absPath[NX_VFS_MAX_PATH + 1] = {0};
+    char absPath[NX_FILE_MAX_PATH + 1] = {0};
 
 	if(!path)
     {
 		return NX_EINVAL;
     }
 
-    if ((err = NX_VfsBuildAbsPath(path, absPath)) != NX_EOK)
+    if ((err = NX_PathBuildAbs(path, absPath)) != NX_EOK)
     {
         return err;
     }
 
-	if(VfsNodeAcquire(absPath, &n))
+	if(NodeAcquire(absPath, &n))
     {
 		return NX_ENOSRCH;
     }
 
-	if (VfsNodeAccess(n, mode))
+	if (NodeAccess(n, mode))
     {
         err = NX_EPERM;
     }
 	
-    VfsNodeRelease(n);
+    NodeRelease(n);
 
 	return err;
 }
 
-NX_Error NX_VfsChmod(const char * path, NX_U32 mode)
+NX_Error NX_FileSetModeToPath(const char * path, NX_U32 mode)
 {
-	NX_VfsNode * n;
+	NX_FileNode * n;
 	NX_Error err;
-    char absPath[NX_VFS_MAX_PATH + 1] = {0};
+    char absPath[NX_FILE_MAX_PATH + 1] = {0};
 
 	if(!path)
     {
 		return NX_EINVAL;
     }
 
-    if ((err = NX_VfsBuildAbsPath(path, absPath)) != NX_EOK)
+    if ((err = NX_PathBuildAbs(path, absPath)) != NX_EOK)
     {
         return err;
     }
 
-	if(VfsNodeAcquire(absPath, &n))
+	if(NodeAcquire(absPath, &n))
     {
 		return NX_ENOSRCH;
     }
 
-	mode &= (NX_VFS_S_IRWXU | NX_VFS_S_IRWXG | NX_VFS_S_IRWXO);
+	mode &= (NX_FILE_MODE_MASK);
 
 	NX_MutexLock(&n->lock);
-	err = n->mount->fs->chmod(n, mode);
+	err = n->mount->fs->setMode(n, mode);
 	if(err)
     {
 		goto fail;
@@ -2005,51 +1983,51 @@ NX_Error NX_VfsChmod(const char * path, NX_U32 mode)
 
 fail:
 	NX_MutexUnlock(&n->lock);
-	VfsNodeRelease(n);
+	NodeRelease(n);
 
 	return err;
 }
 
-NX_Error NX_VfsStat(const char * path, NX_VfsStatInfo * st)
+NX_Error NX_FileGetStatFromPath(const char * path, NX_FileStatInfo * st)
 {
-	NX_VfsNode * n;
+	NX_FileNode * n;
 	NX_Error err = NX_EOK;
-    char absPath[NX_VFS_MAX_PATH + 1] = {0};
+    char absPath[NX_FILE_MAX_PATH + 1] = {0};
 
 	if(!path || !st)
     {
 		return NX_EINVAL;
     }
 
-    if ((err = NX_VfsBuildAbsPath(path, absPath)) != NX_EOK)
+    if ((err = NX_PathBuildAbs(path, absPath)) != NX_EOK)
     {
         return err;
     }
 
-	if(VfsNodeAcquire(absPath, &n))
+	if(NodeAcquire(absPath, &n))
     {
 		return NX_ENOSRCH;
     }
-	err = VfsNodeStat(n, st);
-	VfsNodeRelease(n);
+	err = NodeStat(n, st);
+	NodeRelease(n);
 
 	return err;
 }
 
-NX_PRIVATE void NX_VfsInit(void)
+NX_PRIVATE void NX_FileSytemInit(void)
 {
 	int i;
 
 	NX_ListInit(&fileSystemMountList);
 	NX_MutexInit(&fileSystemMountLock);
 
-	for(i = 0; i < NX_VFS_NODE_HASH_SIZE; i++)
+	for(i = 0; i < NX_FILE_NODE_HASH_SIZE; i++)
 	{
 		NX_ListInit(&fileSystemNodeList[i]);
 		NX_MutexInit(&fileSystemNodeLock[i]);
 	}
 
-    NX_VfsFileTableInit(&defaultFileTable);
+    NX_FileTableInit(&defaultFileTable);
 }
 
-NX_MODS_INIT(NX_VfsInit);
+NX_MODS_INIT(NX_FileSytemInit);
diff --git a/src/include/base/exobj.h b/src/include/base/exobj.h
index 907e0badb2f26deeedf103b32e7c42fd5c0be14c..68ac44bf760d3c41770128a873e654f9cf256848 100644
--- a/src/include/base/exobj.h
+++ b/src/include/base/exobj.h
@@ -37,6 +37,8 @@ typedef enum NX_ExposedObjectType
     NX_EXOBJ_HUB,
     NX_EXOBJ_SHM,
     NX_EXOBJ_SHMADDR,
+    NX_EXOBJ_FILE,
+    NX_EXOBJ_DIR,
     NX_EXOBJ_TYPE_NR,
 } NX_ExposedObjectType;
 
diff --git a/src/include/base/fs.h b/src/include/base/fs.h
new file mode 100644
index 0000000000000000000000000000000000000000..bb58e03a3af30238c9a53b7fe841e4fc04c66341
--- /dev/null
+++ b/src/include/base/fs.h
@@ -0,0 +1,235 @@
+/**
+ * Copyright (c) 2018-2022, NXOS Development Team
+ * SPDX-License-Identifier: Apache-2.0
+ * 
+ * Copyright(c) 2007-2022 Jianjun Jiang <8192542@qq.com>
+ *          Official site: http://xboot.org
+ *          Mobile phone: +86-18665388956
+ *          QQ: 8192542
+ * 
+ * Contains: nxos file system.
+ * 
+ * Change Logs:
+ * Date           Author            Notes
+ * 2022-3-26      JasonHu           Port from xboot
+ */
+
+#ifndef __NXOS_FILE_SYSTEM__
+#define __NXOS_FILE_SYSTEM__
+
+#include <nxos.h>
+#include <base/mutex.h>
+#include <base/atomic.h>
+#include <base/list.h>
+
+#ifdef CONFIG_NX_FILE_MAX_PATH 
+#define NX_FILE_MAX_PATH CONFIG_NX_FILE_MAX_PATH
+#else
+#define NX_FILE_MAX_PATH		    (1024)
+#endif
+
+#ifdef CONFIG_NX_FILE_MAX_NAME
+#define NX_FILE_MAX_NAME CONFIG_NX_FILE_MAX_NAME
+#else
+#define NX_FILE_MAX_NAME		    (256)
+#endif
+
+#ifdef CONFIG_NX_FILE_MAX_FD
+#define NX_FILE_MAX_FD CONFIG_NX_FILE_MAX_FD
+#else
+#define NX_FILE_MAX_FD		    (256)
+#endif
+
+#ifdef CONFIG_NX_FILE_NODE_HASH_SIZE
+#define NX_FILE_NODE_HASH_SIZE CONFIG_NX_FILE_NODE_HASH_SIZE
+#else
+#define NX_FILE_NODE_HASH_SIZE   (256)
+#endif
+
+#define NX_FILE_RDONLY			(1 << 0)
+#define NX_FILE_WRONLY			(1 << 1)
+#define NX_FILE_RDWR			(NX_FILE_RDONLY | NX_FILE_WRONLY)
+#define NX_FILE_ACCMODE		    (NX_FILE_RDWR)
+
+#define NX_FILE_CREAT			(1 << 8)
+#define NX_FILE_EXCL			(1 << 9)
+#define NX_FILE_TRUNC			(1 << 11)
+#define NX_FILE_APPEND			(1 << 12)
+
+#define NX_FILE_MODE_EXEC			(1 << 6)
+#define NX_FILE_MODE_WRITE			(1 << 7)
+#define NX_FILE_MODE_READ			(1 << 8)
+#define NX_FILE_MODE_MASK			(NX_FILE_MODE_READ | NX_FILE_MODE_WRITE | NX_FILE_MODE_EXEC)
+
+#define	NX_FILE_TYPE_DIR			(1 << 16)
+#define	NX_FILE_TYPE_REG			(1 << 19)
+#define	NX_FILE_TYPE_MASK			(NX_FILE_TYPE_DIR | NX_FILE_TYPE_REG)
+
+#define NX_FILE_IS_DIR(m)		    ((m) & NX_FILE_TYPE_DIR )
+#define NX_FILE_IS_REG(m)		    ((m) & NX_FILE_TYPE_REG )
+
+#define	NX_FILE_READ_OK				(1 << 2)
+#define NX_FILE_WRITE_OK			(1 << 1)
+#define NX_FILE_EXEC_OK				(1 << 0)
+
+#define NX_FILE_SEEK_SET		    (0)
+#define NX_FILE_SEEK_CUR		    (1)
+#define NX_FILE_SEEK_END		    (2)
+
+struct NX_FileStatInfo;
+struct NX_Dirent;
+struct NX_FileNode;
+struct NX_MountDesc;
+struct NX_FileSystem;
+
+typedef struct NX_FileStatInfo
+{
+	NX_Size size;
+	NX_U32 mode;
+	NX_U32 ctime;
+	NX_U32 atime;
+	NX_U32 mtime;
+} NX_FileStatInfo;
+
+enum NX_DirentType
+{
+	NX_DIR_TYPE_UNK,
+	NX_DIR_TYPE_DIR,
+	NX_DIR_TYPE_REG,
+};
+
+typedef struct NX_Dirent
+{
+	NX_Offset off;
+	NX_U32 reclen;
+	enum NX_DirentType type;
+	char name[NX_FILE_MAX_NAME];
+} NX_Dirent;
+
+enum NX_FileNodeFlag
+{
+	NX_FILE_NODE_FLAG_NONE,
+	NX_FILE_NODE_FLAG_ROOT,
+};
+
+enum NX_FileNodeType
+{
+	NX_FILE_NODE_TYPE_UNK,
+	NX_FILE_NODE_TYPE_DIR,
+	NX_FILE_NODE_TYPE_REG,
+};
+
+typedef struct NX_FileNode
+{
+	NX_List link;
+	struct NX_MountDesc * mount;
+	NX_Atomic refcnt;
+	char path[NX_FILE_MAX_PATH];
+	enum NX_FileNodeFlag flags;
+	enum NX_FileNodeType type;
+	NX_Mutex lock;
+	NX_U32 ctime;
+	NX_U32 atime;
+	NX_U32 mtime;
+	NX_U32 mode;
+	NX_Size size;
+	void * data;
+} NX_FileNode;
+
+typedef struct NX_FileDesc
+{
+	NX_Mutex lock;
+	struct NX_FileNode * node;
+	NX_Offset offset;
+	NX_U32 flags;
+} NX_FileDesc;
+
+typedef struct NX_FileTable
+{
+	struct NX_FileDesc file[NX_FILE_MAX_FD];
+    NX_Mutex file_lock;
+} NX_FileTable;
+
+void NX_FileTableInit(NX_FileTable *ft);
+NX_FileTable *NX_FileTableGetDefault(void);
+
+enum
+{
+	NX_MOUNT_RW	    = (0x0 << 0),
+	NX_MOUNT_RO	    = (0x1 << 0),
+	NX_MOUNT_MASK	= (0x1 << 0),
+};
+
+typedef struct NX_MountDesc
+{
+	NX_List link;
+	struct NX_FileSystem * fs;
+	void * dev;
+	char path[NX_FILE_MAX_PATH];
+	NX_U32 flags;
+	NX_Atomic refcnt;
+	struct NX_FileNode * root;
+	struct NX_FileNode * covered;
+	NX_Mutex lock;
+	void * data;
+} NX_MountDesc;
+
+typedef struct NX_FileSystem
+{
+	NX_List list;
+	const char * name;
+
+	NX_Error (*mount)(NX_MountDesc *, const char *);
+	NX_Error (*unmount)(NX_MountDesc *);
+	NX_Error (*mountSync)(NX_MountDesc *);
+	NX_Error (*getNode)(NX_MountDesc *, NX_FileNode *);
+	NX_Error (*putNode)(NX_MountDesc *, NX_FileNode *);
+
+	NX_U64 (*read)(NX_FileNode *, NX_I64, void *, NX_U64, NX_Error *outErr);
+	NX_U64 (*write)(NX_FileNode *, NX_I64, void *, NX_U64, NX_Error *outErr);
+    NX_Error (*ioctl)(NX_FileNode *, NX_U32, void *);
+	NX_Error (*truncate)(NX_FileNode *, NX_I64);
+	NX_Error (*sync)(NX_FileNode *);
+	NX_Error (*readDir)(NX_FileNode *, NX_I64, NX_Dirent *);
+	NX_Error (*lookup)(NX_FileNode *, const char *, NX_FileNode *);
+	NX_Error (*create)(NX_FileNode *, const char *, NX_U32);
+	NX_Error (*delete)(NX_FileNode *, NX_FileNode *, const char *);
+	NX_Error (*rename)(NX_FileNode *, const char *, NX_FileNode *, NX_FileNode *, const char *);
+	NX_Error (*createDir)(NX_FileNode *, const char *, NX_U32);
+	NX_Error (*deleteDir)(NX_FileNode *, NX_FileNode *, const char *);
+	NX_Error (*setMode)(NX_FileNode *, NX_U32);
+} NX_FileSystem;
+
+NX_FileSystem * NX_FileSystemSearch(const char * name);
+NX_Error NX_FileSystemRegister(NX_FileSystem * fs);
+NX_Error NX_FileSystemUnregister(NX_FileSystem * fs);
+NX_MountDesc * NX_MountGetByIndex(int index);
+int NX_MountGetCount(void);
+NX_Error NX_PathBuildAbs(const char * path, char * absPath);
+
+/* user interface */
+NX_Error NX_FileSystemMount(const char * dev, const char * path, const char * fsname, NX_U32 flags);
+NX_Error NX_FileSystemUnmount(const char * path);
+NX_Error NX_FileSystemSync(void);
+int NX_FileOpen(const char * path, NX_U32 flags, NX_U32 mode, NX_Error *outErr);
+NX_Error NX_FileClose(int fd);
+NX_U64 NX_FileRead(int fd, void * buf, NX_U64 len, NX_Error *outErr);
+NX_U64 NX_FileWrite(int fd, void * buf, NX_U64 len, NX_Error *outErr);
+NX_Error NX_FileIoctl(int fd, NX_U32 cmd, void *arg);
+NX_Offset NX_FileSetPointer(int fd, NX_Offset off, int whence, NX_Error *outErr);
+NX_Error NX_FileSync(int fd);
+NX_Error NX_FileSetMode(int fd, NX_U32 mode);
+NX_Error NX_FileGetStat(int fd, NX_FileStatInfo * st);
+int NX_DirOpen(const char * name, NX_Error *outErr);
+NX_Error NX_DirClose(int fd);
+NX_Error NX_DirRead(int fd, NX_Dirent * dir);
+NX_Error NX_DirResetPointer(int fd);
+NX_Error NX_DirCreate(const char * path, NX_U32 mode);
+NX_Error NX_DirDelete(const char * path);
+NX_Error NX_FileRename(const char * src, const char * dst);
+NX_Error NX_FileDelete(const char * path);
+NX_Error NX_FileAccess(const char * path, NX_U32 mode);
+NX_Error NX_FileSetModeToPath(const char * path, NX_U32 mode);
+NX_Error NX_FileGetStatFromPath(const char * path, NX_FileStatInfo * st);
+
+#endif /* __NXOS_FILE_SYSTEM__ */
diff --git a/src/include/base/process.h b/src/include/base/process.h
index 24974b9a7df354dd2ced201b2e371b8ebc0f3725..9ed6ce704afeda78fe01b3392cba0ca3ae5810cf 100644
--- a/src/include/base/process.h
+++ b/src/include/base/process.h
@@ -16,7 +16,7 @@
 #include <base/list.h>
 #include <base/spin.h>
 #include <base/vmspace.h>
-#include <base/vfs.h>
+#include <base/fs.h>
 #include <base/semaphore.h>
 #include <base/exobj.h>
 #include <base/signal.h>
@@ -44,7 +44,7 @@ struct NX_Process
     NX_U32 exitCode;   /* exit code for process */
     NX_U32 waitExitCode;   /* exit code for this process wait another process */
 
-    NX_VfsFileTable *fileTable; /* file table */
+    NX_FileTable *fileTable; /* file table */
     
     NX_Semaphore waiterSem; /* The semaphore of the process waiting for this process to exit */
 
@@ -52,8 +52,8 @@ struct NX_Process
     NX_I32 parentPid; /* parent process id */
 
     void *args; /* process args */
-    char cwd[NX_VFS_MAX_PATH]; /* current work diretory */
-    char exePath[NX_VFS_MAX_PATH]; /* execute path */
+    char cwd[NX_FILE_MAX_PATH]; /* current work diretory */
+    char exePath[NX_FILE_MAX_PATH]; /* execute path */
     NX_ExposedObjectTable exobjTable;
 };
 typedef struct NX_Process NX_Process;
diff --git a/src/include/base/snapshot.h b/src/include/base/snapshot.h
index ff9c5441082ff37eeefd4b2dc662980ccf5f7f66..d5a6b93cae5a70a989e33653779510f7841c24a4 100644
--- a/src/include/base/snapshot.h
+++ b/src/include/base/snapshot.h
@@ -39,7 +39,7 @@ typedef struct NX_SnapshotProcess
     NX_U32 threadCount;
     NX_U32 parentProcessId; 
     NX_U32 flags;
-    char exePath[NX_VFS_MAX_PATH]; /* execute path */
+    char exePath[NX_FILE_MAX_PATH]; /* execute path */
 } NX_SnapshotProcess;
 
 typedef struct NX_SnapshotHead
diff --git a/src/include/base/thread.h b/src/include/base/thread.h
index 5aad898a28f8f90640f51e65c357836d38452381..881fadb365d24d1e8c3c805a659536e134936edf 100644
--- a/src/include/base/thread.h
+++ b/src/include/base/thread.h
@@ -17,7 +17,7 @@
 #include <base/spin.h>
 #include <base/semaphore.h>
 #include <base/process.h>
-#include <base/vfs.h>
+#include <base/fs.h>
 #include <base/signal.h>
 
 #ifdef CONFIG_NX_THREAD_NAME_LEN
@@ -73,7 +73,7 @@ struct NX_ThreadResource
 {
     NX_Timer *sleepTimer;
     NX_Process *process;
-    NX_VfsFileTable *fileTable;
+    NX_FileTable *fileTable;
     struct NX_Hub *hub; /* hub for each thread */
     struct NX_HubChannel *activeChannel; /* channel for this thread */
 
diff --git a/src/include/base/vfs.h b/src/include/base/vfs.h
deleted file mode 100644
index 27afdf01375bee0c2013f00589df102481ca26b2..0000000000000000000000000000000000000000
--- a/src/include/base/vfs.h
+++ /dev/null
@@ -1,273 +0,0 @@
-/**
- * Copyright (c) 2018-2022, NXOS Development Team
- * SPDX-License-Identifier: Apache-2.0
- * 
- * Copyright(c) 2007-2022 Jianjun Jiang <8192542@qq.com>
- *          Official site: http://xboot.org
- *          Mobile phone: +86-18665388956
- *          QQ: 8192542
- * 
- * Contains: virtual file system form xboot.
- * 
- * Change Logs:
- * Date           Author            Notes
- * 2022-3-26      JasonHu           Port from xboot
- */
-
-#ifndef __FS_VFS__
-#define __FS_VFS__
-
-#include <nxos.h>
-#include <base/mutex.h>
-#include <base/atomic.h>
-#include <base/list.h>
-
-#ifdef CONFIG_NX_VFS_MAX_PATH 
-#define NX_VFS_MAX_PATH CONFIG_NX_VFS_MAX_PATH
-#else
-#define NX_VFS_MAX_PATH		    (1024)
-#endif
-
-#ifdef CONFIG_NX_VFS_MAX_NAME
-#define NX_VFS_MAX_NAME CONFIG_NX_VFS_MAX_NAME
-#else
-#define NX_VFS_MAX_NAME		    (256)
-#endif
-
-#ifdef CONFIG_NX_VFS_MAX_FD
-#define NX_VFS_MAX_FD CONFIG_NX_VFS_MAX_FD
-#else
-#define NX_VFS_MAX_FD		    (256)
-#endif
-
-#ifdef CONFIG_NX_VFS_NODE_HASH_SIZE
-#define NX_VFS_NODE_HASH_SIZE CONFIG_NX_VFS_NODE_HASH_SIZE
-#else
-#define NX_VFS_NODE_HASH_SIZE   (256)
-#endif
-
-#define NX_VFS_O_RDONLY			(1 << 0)
-#define NX_VFS_O_WRONLY			(1 << 1)
-#define NX_VFS_O_RDWR			(NX_VFS_O_RDONLY | NX_VFS_O_WRONLY)
-#define NX_VFS_O_ACCMODE		(NX_VFS_O_RDWR)
-
-#define NX_VFS_O_CREAT			(1 << 8)
-#define NX_VFS_O_EXCL			(1 << 9)
-#define NX_VFS_O_NOCTTY			(1 << 10)
-#define NX_VFS_O_TRUNC			(1 << 11)
-#define NX_VFS_O_APPEND			(1 << 12)
-#define NX_VFS_O_DSYNC		    (1 << 13)
-#define NX_VFS_O_NONBLOCK		(1 << 14)
-#define NX_VFS_O_SYNC			(1 << 15)
-
-#define NX_VFS_S_IXOTH			(1 << 0)
-#define NX_VFS_S_IWOTH			(1 << 1)
-#define NX_VFS_S_IROTH			(1 << 2)
-#define NX_VFS_S_IRWXO			(NX_VFS_S_IROTH | NX_VFS_S_IWOTH | NX_VFS_S_IXOTH)
-
-#define NX_VFS_S_IXGRP			(1 << 3)
-#define NX_VFS_S_IWGRP			(1 << 4)
-#define NX_VFS_S_IRGRP			(1 << 5)
-#define NX_VFS_S_IRWXG			(NX_VFS_S_IRGRP | NX_VFS_S_IWGRP | NX_VFS_S_IXGRP)
-
-#define NX_VFS_S_IXUSR			(1 << 6)
-#define NX_VFS_S_IWUSR			(1 << 7)
-#define NX_VFS_S_IRUSR			(1 << 8)
-#define NX_VFS_S_IRWXU			(NX_VFS_S_IRUSR | NX_VFS_S_IWUSR | NX_VFS_S_IXUSR)
-
-#define	NX_VFS_S_IFDIR			(1 << 16)
-#define	NX_VFS_S_IFCHR			(1 << 17)
-#define	NX_VFS_S_IFBLK			(1 << 18)
-#define	NX_VFS_S_IFREG			(1 << 19)
-#define	NX_VFS_S_IFLNK			(1 << 20)
-#define	NX_VFS_S_IFIFO		    (1 << 21)
-#define	NX_VFS_S_IFSOCK			(1 << 22)
-#define	NX_VFS_S_IFMT			(NX_VFS_S_IFDIR | NX_VFS_S_IFCHR | NX_VFS_S_IFBLK | NX_VFS_S_IFREG | NX_VFS_S_IFLNK | NX_VFS_S_IFIFO | NX_VFS_S_IFSOCK)
-
-#define NX_VFS_S_ISDIR(m)		((m) & NX_VFS_S_IFDIR )
-#define NX_VFS_S_ISCHR(m)		((m) & NX_VFS_S_IFCHR )
-#define NX_VFS_S_ISBLK(m)		((m) & NX_VFS_S_IFBLK )
-#define NX_VFS_S_ISREG(m)		((m) & NX_VFS_S_IFREG )
-#define NX_VFS_S_ISLNK(m)		((m) & NX_VFS_S_IFLNK )
-#define NX_VFS_S_ISFIFO(m)		((m) & NX_VFS_S_IFIFO )
-#define NX_VFS_S_ISSOCK(m)		((m) & NX_VFS_S_IFSOCK )
-
-#define	NX_VFS_R_OK				(1 << 2)
-#define NX_VFS_W_OK				(1 << 1)
-#define NX_VFS_X_OK				(1 << 0)
-
-#define NX_VFS_SEEK_SET		    (0)
-#define NX_VFS_SEEK_CUR		    (1)
-#define NX_VFS_SEEK_END		    (2)
-
-struct NX_VfsStatInfo;
-struct NX_VfsDirent;
-struct NX_VfsNode;
-struct NX_VfsMount;
-struct NX_VfsFileSystem;
-
-typedef struct NX_VfsStatInfo
-{
-	NX_U32 ino;
-	NX_Size size;
-	NX_U32 mode;
-	NX_U32 dev;
-	NX_U32 uid;
-	NX_U32 gid;
-	NX_U32 ctime;
-	NX_U32 atime;
-	NX_U32 mtime;
-} NX_VfsStatInfo;
-
-enum NX_VfsDirentType
-{
-	NX_VFS_DIR_TYPE_UNK,
-	NX_VFS_DIR_TYPE_DIR,
-	NX_VFS_DIR_TYPE_CHR,
-	NX_VFS_DIR_TYPE_BLK,
-	NX_VFS_DIR_TYPE_REG,
-	NX_VFS_DIR_TYPE_LNK,
-	NX_VFS_DIR_TYPE_FIFO,
-	NX_VFS_DIR_TYPE_SOCK,
-};
-
-typedef struct NX_VfsDirent
-{
-	NX_Offset off;
-	NX_U32 reclen;
-	enum NX_VfsDirentType type;
-	char name[NX_VFS_MAX_NAME];
-} NX_VfsDirent;
-
-enum NX_VfsNodeFlag
-{
-	NX_VFS_NODE_FLAG_NONE,
-	NX_VFS_NODE_FLAG_ROOT,
-};
-
-enum NX_VfsNodeType
-{
-	NX_VFS_NODE_TYPE_UNK,
-	NX_VFS_NODE_TYPE_DIR,
-	NX_VFS_NODE_TYPE_CHR,
-	NX_VFS_NODE_TYPE_BLK,
-	NX_VFS_NODE_TYPE_REG,
-	NX_VFS_NODE_TYPE_LNK,
-	NX_VFS_NODE_TYPE_FIFO,
-	NX_VFS_NODE_TYPE_SOCK,
-};
-
-typedef struct NX_VfsNode
-{
-	NX_List link;
-	struct NX_VfsMount * mount;
-	NX_Atomic refcnt;
-	char path[NX_VFS_MAX_PATH];
-	enum NX_VfsNodeFlag flags;
-	enum NX_VfsNodeType type;
-	NX_Mutex lock;
-	NX_U32 ctime;
-	NX_U32 atime;
-	NX_U32 mtime;
-	NX_U32 mode;
-	NX_Size size;
-	void * data;
-} NX_VfsNode;
-
-typedef struct NX_VfsFile
-{
-	NX_Mutex lock;
-	struct NX_VfsNode * node;
-	NX_Offset offset;
-	NX_U32 flags;
-} NX_VfsFile;
-
-typedef struct NX_VfsFileTable
-{
-	struct NX_VfsFile file[NX_VFS_MAX_FD];
-    NX_Mutex file_lock;
-} NX_VfsFileTable;
-
-void NX_VfsFileTableInit(NX_VfsFileTable *ft);
-NX_VfsFileTable *NX_VfsGetDefaultFileTable(void);
-
-enum
-{
-	NX_VFS_MOUNT_RW	    = (0x0 << 0),
-	NX_VFS_MOUNT_RO	    = (0x1 << 0),
-	NX_VFS_MOUNT_MASK	= (0x1 << 0),
-};
-
-typedef struct NX_VfsMount
-{
-	NX_List link;
-	struct NX_VfsFileSystem * fs;
-	void * dev;
-	char path[NX_VFS_MAX_PATH];
-	NX_U32 flags;
-	NX_Atomic refcnt;
-	struct NX_VfsNode * root;
-	struct NX_VfsNode * covered;
-	NX_Mutex lock;
-	void * data;
-} NX_VfsMount;
-
-typedef struct NX_VfsFileSystem
-{
-	NX_List list;
-	const char * name;
-
-	NX_Error (*mount)(NX_VfsMount *, const char *);
-	NX_Error (*unmount)(NX_VfsMount *);
-	NX_Error (*msync)(NX_VfsMount *);
-	NX_Error (*vget)(NX_VfsMount *, NX_VfsNode *);
-	NX_Error (*vput)(NX_VfsMount *, NX_VfsNode *);
-
-	NX_U64 (*read)(NX_VfsNode *, NX_I64, void *, NX_U64, NX_Error *outErr);
-	NX_U64 (*write)(NX_VfsNode *, NX_I64, void *, NX_U64, NX_Error *outErr);
-    NX_Error (*ioctl)(NX_VfsNode *, NX_U32, void *);
-	NX_Error (*truncate)(NX_VfsNode *, NX_I64);
-	NX_Error (*sync)(NX_VfsNode *);
-	NX_Error (*readdir)(NX_VfsNode *, NX_I64, NX_VfsDirent *);
-	NX_Error (*lookup)(NX_VfsNode *, const char *, NX_VfsNode *);
-	NX_Error (*create)(NX_VfsNode *, const char *, NX_U32);
-	NX_Error (*remove)(NX_VfsNode *, NX_VfsNode *, const char *);
-	NX_Error (*rename)(NX_VfsNode *, const char *, NX_VfsNode *, NX_VfsNode *, const char *);
-	NX_Error (*mkdir)(NX_VfsNode *, const char *, NX_U32);
-	NX_Error (*rmdir)(NX_VfsNode *, NX_VfsNode *, const char *);
-	NX_Error (*chmod)(NX_VfsNode *, NX_U32);
-} NX_VfsFileSystem;
-
-NX_VfsFileSystem * NX_VfsSearchFileSystem(const char * name);
-NX_Error NX_VfsRegisterFileSystem(NX_VfsFileSystem * fs);
-NX_Error NX_VfsUnregisterFileSystem(NX_VfsFileSystem * fs);
-NX_VfsMount * NX_VfsGetMount(int index);
-int NX_VfsGetMountCount(void);
-NX_Error NX_VfsBuildAbsPath(const char * path, char * absPath);
-
-/* user interface */
-NX_Error NX_VfsMountFileSystem(const char * dev, const char * path, const char * fsname, NX_U32 flags);
-NX_Error NX_VfsUnmountFileSystem(const char * path);
-NX_Error NX_VfsSync(void);
-int NX_VfsOpen(const char * path, NX_U32 flags, NX_U32 mode, NX_Error *outErr);
-NX_Error NX_VfsClose(int fd);
-NX_U64 NX_VfsRead(int fd, void * buf, NX_U64 len, NX_Error *outErr);
-NX_U64 NX_VfsWrite(int fd, void * buf, NX_U64 len, NX_Error *outErr);
-NX_Error NX_VfsIoctl(int fd, NX_U32 cmd, void *arg);
-NX_I64 NX_VfsFileSeek(int fd, NX_I64 off, int whence, NX_Error *outErr);
-NX_Error NX_VfsFileSync(int fd);
-NX_Error NX_VfsFileChmod(int fd, NX_U32 mode);
-NX_Error NX_VfsFileStat(int fd, NX_VfsStatInfo * st);
-int NX_VfsOpenDir(const char * name, NX_Error *outErr);
-NX_Error NX_VfsCloseDir(int fd);
-NX_Error NX_VfsReadDir(int fd, NX_VfsDirent * dir);
-NX_Error NX_VfsRewindDir(int fd);
-NX_Error NX_VfsMakeDir(const char * path, NX_U32 mode);
-NX_Error NX_VfsRemoveDir(const char * path);
-NX_Error NX_VfsRename(const char * src, const char * dst);
-NX_Error NX_VfsUnlink(const char * path);
-NX_Error NX_VfsAccess(const char * path, NX_U32 mode);
-NX_Error NX_VfsChmod(const char * path, NX_U32 mode);
-NX_Error NX_VfsStat(const char * path, NX_VfsStatInfo * st);
-
-#endif /* __FS_VFS__ */
diff --git a/src/init/init.c b/src/init/init.c
index 0a8e5aa80bb23a4ae222199502e81a137c1e1159..75ee5d4e74406a2e368c5d9378edb7eec935f49a 100644
--- a/src/init/init.c
+++ b/src/init/init.c
@@ -46,7 +46,7 @@ NX_PRIVATE void CallsEntry(void *arg)
 
 #ifdef CONFIG_NX_ENABLE_MOUNT_TABLE
     {
-        NX_Error err = NX_VfsMountFileSystem(CONFIG_NX_MOUNT_DEVICE_DEFAULT, CONFIG_NX_MOUNT_PATH_DEFAULT, CONFIG_NX_MOUNT_FSNAME_DEFAULT, 0);
+        NX_Error err = NX_FileSystemMount(CONFIG_NX_MOUNT_DEVICE_DEFAULT, CONFIG_NX_MOUNT_PATH_DEFAULT, CONFIG_NX_MOUNT_FSNAME_DEFAULT, 0);
         NX_LOG_I("---------------- Mount file system begin ----------------");
         if (err != NX_EOK)
         {
@@ -60,7 +60,7 @@ NX_PRIVATE void CallsEntry(void *arg)
         }
 
 #ifdef CONFIG_NX_FS_DEVFS
-        err = NX_VfsMountFileSystem(NX_NULL, CONFIG_NX_DEVFS_PATH_DEFAULT, CONFIG_NX_DEVFS_FSNAME_DEFAULT, 0);
+        err = NX_FileSystemMount(NX_NULL, CONFIG_NX_DEVFS_PATH_DEFAULT, CONFIG_NX_DEVFS_FSNAME_DEFAULT, 0);
         if (err != NX_EOK)
         {
             NX_LOG_W("mount (null) dev on path:%s as fs:%s with state %d/%s", CONFIG_NX_DEVFS_PATH_DEFAULT, CONFIG_NX_DEVFS_FSNAME_DEFAULT, err, NX_ErrorToString(err));
diff --git a/src/platform/d1 b/src/platform/d1
index 3e7eed4e77036f7e014c1c7e6517f69fde64ac78..debbfef0dde94f29e15e4eb7fb57f8cc8d62e862 160000
--- a/src/platform/d1
+++ b/src/platform/d1
@@ -1 +1 @@
-Subproject commit 3e7eed4e77036f7e014c1c7e6517f69fde64ac78
+Subproject commit debbfef0dde94f29e15e4eb7fb57f8cc8d62e862
diff --git a/src/platform/hifive_unmached b/src/platform/hifive_unmached
index 82285d5e0c38761a612d184dcde7db1aa197963a..8217e275f5825c0b36e631c4f6aaa0b33fcbcbfb 160000
--- a/src/platform/hifive_unmached
+++ b/src/platform/hifive_unmached
@@ -1 +1 @@
-Subproject commit 82285d5e0c38761a612d184dcde7db1aa197963a
+Subproject commit 8217e275f5825c0b36e631c4f6aaa0b33fcbcbfb
diff --git a/src/platform/i386 b/src/platform/i386
index d6259ac64f051ff1d3f80682b99a641ef7813d32..2849be41d9880cce200e986a20dac90951761a99 160000
--- a/src/platform/i386
+++ b/src/platform/i386
@@ -1 +1 @@
-Subproject commit d6259ac64f051ff1d3f80682b99a641ef7813d32
+Subproject commit 2849be41d9880cce200e986a20dac90951761a99
diff --git a/src/platform/k210 b/src/platform/k210
index 85c438409c92bca03206fc34239b1cc2a867b28b..a02b1237e93ff7de32c38e9f5ef78fb64b29359d 160000
--- a/src/platform/k210
+++ b/src/platform/k210
@@ -1 +1 @@
-Subproject commit 85c438409c92bca03206fc34239b1cc2a867b28b
+Subproject commit a02b1237e93ff7de32c38e9f5ef78fb64b29359d
diff --git a/src/platform/qemu_riscv64 b/src/platform/qemu_riscv64
index fbfae3dacd39186f2cb09136e7d6c02e60921861..5c63c2f212a425caeeeac7e73f645376cdb83cf4 160000
--- a/src/platform/qemu_riscv64
+++ b/src/platform/qemu_riscv64
@@ -1 +1 @@
-Subproject commit fbfae3dacd39186f2cb09136e7d6c02e60921861
+Subproject commit 5c63c2f212a425caeeeac7e73f645376cdb83cf4
diff --git a/src/process/process.c b/src/process/process.c
index aa84264b2f8c602a353cf563753683889e9fd666..9a7a83cf79821db0861b7bf22ee70c2170548ba9 100644
--- a/src/process/process.c
+++ b/src/process/process.c
@@ -26,7 +26,7 @@
 
 #include <base/debug.h>
 #include <base/elf.h>
-#include <base/vfs.h>
+#include <base/fs.h>
 #include <base/debug.h>
 #include <base/uaccess.h>
 #include <base/sched.h>
@@ -68,7 +68,7 @@ NX_PRIVATE NX_Process *NX_ProcessCreateObject(NX_U32 flags)
         return NX_NULL;
     }
 
-    NX_VfsFileTable *ft = NX_MemAlloc(sizeof(NX_VfsFileTable));
+    NX_FileTable *ft = NX_MemAlloc(sizeof(NX_FileTable));
     if (ft == NX_NULL)
     {
         NX_MemFree(process);
@@ -107,7 +107,7 @@ NX_PRIVATE NX_Process *NX_ProcessCreateObject(NX_U32 flags)
         return NX_NULL;
     }
 
-    NX_VfsFileTableInit(ft);
+    NX_FileTableInit(ft);
     process->fileTable = ft;
     process->flags = flags;
 
@@ -199,12 +199,12 @@ NX_PRIVATE NX_Error NX_LoadCheck(char *path, int fd, NX_Size len, NX_Vmspace *sp
     }
 
     /* check elf magic */
-    if (NX_VfsFileSeek(fd, 0, NX_VFS_SEEK_SET, NX_NULL) != 0)
+    if (NX_FileSetPointer(fd, 0, NX_FILE_SEEK_SET, NX_NULL) != 0)
     {
         return NX_EFAULT;
     }
 
-    if (NX_VfsRead(fd, elfMagic, sizeof(elfMagic), NX_NULL) != sizeof(elfMagic))
+    if (NX_FileRead(fd, elfMagic, sizeof(elfMagic), NX_NULL) != sizeof(elfMagic))
     {
         return NX_EIO;
     }
@@ -217,11 +217,11 @@ NX_PRIVATE NX_Error NX_LoadCheck(char *path, int fd, NX_Size len, NX_Vmspace *sp
     }
 
     /* load header */
-    if (NX_VfsFileSeek(fd, 0, NX_VFS_SEEK_SET, NX_NULL) != 0)
+    if (NX_FileSetPointer(fd, 0, NX_FILE_SEEK_SET, NX_NULL) != 0)
     {
         return NX_EFAULT;
     }
-    if (NX_VfsRead(fd, elfHeader, sizeof(Elf_Ehdr), NX_NULL) != sizeof(Elf_Ehdr))
+    if (NX_FileRead(fd, elfHeader, sizeof(Elf_Ehdr), NX_NULL) != sizeof(Elf_Ehdr))
     {
         return NX_EIO;
     }
@@ -282,11 +282,11 @@ NX_PRIVATE NX_Error NX_LoadMapUserSpace(int fd, NX_Size len, NX_Vmspace *space,
             return NX_EFAULT;
         }
 
-        if (NX_VfsFileSeek(fd, off, NX_VFS_SEEK_SET, NX_NULL) != off)
+        if (NX_FileSetPointer(fd, off, NX_FILE_SEEK_SET, NX_NULL) != off)
         {
             return NX_EFAULT;
         }
-        if (NX_VfsRead(fd, &progHeader, sizeof(progHeader), NX_NULL) != sizeof(progHeader))
+        if (NX_FileRead(fd, &progHeader, sizeof(progHeader), NX_NULL) != sizeof(progHeader))
         {
             return NX_EIO;
         }
@@ -337,11 +337,11 @@ NX_PRIVATE NX_Error NX_LoadFileData(int fd, NX_Size len, NX_Vmspace *space, Elf_
         }
 
         /* read program header */
-        if (NX_VfsFileSeek(fd, progOff, NX_VFS_SEEK_SET, NX_NULL) != progOff)
+        if (NX_FileSetPointer(fd, progOff, NX_FILE_SEEK_SET, NX_NULL) != progOff)
         {
             return NX_EFAULT;
         }
-        if (NX_VfsRead(fd, &progHeader, sizeof(progHeader), NX_NULL) != sizeof(progHeader))
+        if (NX_FileRead(fd, &progHeader, sizeof(progHeader), NX_NULL) != sizeof(progHeader))
         {
             return NX_EIO;
         }
@@ -360,7 +360,7 @@ NX_PRIVATE NX_Error NX_LoadFileData(int fd, NX_Size len, NX_Vmspace *space, Elf_
                 return NX_ERROR;
             }
 
-            if (NX_VfsFileSeek(fd, progHeader.p_offset, NX_VFS_SEEK_SET, NX_NULL) != progHeader.p_offset)
+            if (NX_FileSetPointer(fd, progHeader.p_offset, NX_FILE_SEEK_SET, NX_NULL) != progHeader.p_offset)
             {
                 return NX_EIO;
             }
@@ -377,7 +377,7 @@ NX_PRIVATE NX_Error NX_LoadFileData(int fd, NX_Size len, NX_Vmspace *space, Elf_
 
                 chunk = (size < NX_PAGE_SIZE) ? size : NX_PAGE_SIZE;
 
-                if (NX_VfsRead(fd, (void *)vaddrSelf, chunk, NX_NULL) != chunk)
+                if (NX_FileRead(fd, (void *)vaddrSelf, chunk, NX_NULL) != chunk)
                 {
                     return NX_EIO;
                 }
@@ -473,25 +473,25 @@ NX_PRIVATE NX_Error NX_ProcessLoadImage(NX_Process *process, char *path)
     NX_Size imageMaxSize;
     NX_Vmspace *space;
 
-    fd = NX_VfsOpen(path, NX_VFS_O_RDONLY, 0, &err);
+    fd = NX_FileOpen(path, NX_FILE_RDONLY, 0, &err);
     if (fd < NX_EOK)
     {
         NX_LOG_E("process open file %s failed ! with error %s", path, NX_ErrorToString(err));
         return NX_ENOSRCH;
     }
 
-    len = NX_VfsFileSeek(fd, 0, NX_VFS_SEEK_END, &err);
+    len = NX_FileSetPointer(fd, 0, NX_FILE_SEEK_END, &err);
     if (!len || err != NX_EOK)
     {
         NX_LOG_E("file %s too small !", path);
-        NX_VfsClose(fd);
+        NX_FileClose(fd);
         return NX_ENOSRCH;
     }
 
-    if (NX_VfsFileSeek(fd, 0, NX_VFS_SEEK_SET, NX_NULL) != 0)
+    if (NX_FileSetPointer(fd, 0, NX_FILE_SEEK_SET, NX_NULL) != 0)
     {
         NX_LOG_E("seek file %s failed !", path);
-        NX_VfsClose(fd);
+        NX_FileClose(fd);
         return NX_ENOSRCH;
     }
 
@@ -502,7 +502,7 @@ NX_PRIVATE NX_Error NX_ProcessLoadImage(NX_Process *process, char *path)
     if (len > imageMaxSize)
     {
         NX_LOG_E("image too large %p than %p !", len, imageMaxSize);
-        NX_VfsClose(fd);
+        NX_FileClose(fd);
         return NX_EFAULT;
     }
 
@@ -510,12 +510,12 @@ NX_PRIVATE NX_Error NX_ProcessLoadImage(NX_Process *process, char *path)
     if (err != NX_EOK)
     {
         NX_LOG_E("load elf %s failed with err %d!", path, err);
-        NX_VfsClose(fd);
+        NX_FileClose(fd);
         return err;
     }
 
     /* close file */
-    NX_ASSERT(NX_VfsClose(fd) == 0);
+    NX_ASSERT(NX_FileClose(fd) == 0);
 
     return NX_EOK;
 }
@@ -701,7 +701,7 @@ NX_PRIVATE NX_Error SearchInEnv(char * path, char * absPath, char *env)
             }
 
             /* abs path = env + / + path */
-            NX_MemZero(absPath, NX_VFS_MAX_PATH);
+            NX_MemZero(absPath, NX_FILE_MAX_PATH);
 
             NX_StrCat(absPath, p);
             if (absPath[NX_StrLen(absPath) - 1] != '/')
@@ -710,7 +710,7 @@ NX_PRIVATE NX_Error SearchInEnv(char * path, char * absPath, char *env)
             }
             NX_StrCat(absPath, path);
 
-            if (NX_VfsAccess(absPath, NX_VFS_R_OK) == NX_EOK)
+            if (NX_FileAccess(absPath, NX_FILE_READ_OK) == NX_EOK)
             {
                 NX_MemFree(tmpEnv);
                 return NX_EOK;
@@ -731,7 +731,7 @@ NX_Error NX_ProcessLaunch(char *path, NX_U32 flags, NX_U32 *exitCode, char *cmd,
     NX_Vmspace *space;
     char *name;
     NX_Solt threadSolt = NX_SOLT_INVALID_VALUE;
-    char absPath[NX_VFS_MAX_PATH] = {0,};
+    char absPath[NX_FILE_MAX_PATH] = {0,};
 
     if (path == NX_NULL)
     {
@@ -741,7 +741,7 @@ NX_Error NX_ProcessLaunch(char *path, NX_U32 flags, NX_U32 *exitCode, char *cmd,
     NX_CopyFromUser(absPath, path, NX_StrLen(path));
 
     /* check path exist */
-    if (NX_VfsAccess(absPath, NX_VFS_R_OK) != NX_EOK)
+    if (NX_FileAccess(absPath, NX_FILE_READ_OK) != NX_EOK)
     {
         if (*absPath == '/') /* abs path means no res */
         {
@@ -1001,35 +1001,35 @@ char * NX_ProcessGetCwd(NX_Process * process)
 NX_Error NX_ProcessSetCwd(NX_Process * process, const char * path)
 {
     NX_Error err;
-    NX_VfsStatInfo st;
-    char absPath[NX_VFS_MAX_PATH + 1] = {0};
+    NX_FileStatInfo st;
+    char absPath[NX_FILE_MAX_PATH + 1] = {0};
 
     if (!process || !path)
     {
         return NX_EINVAL;
     }
 
-    if (NX_StrLen(path) >= NX_VFS_MAX_PATH)
+    if (NX_StrLen(path) >= NX_FILE_MAX_PATH)
     {
         return NX_EINVAL;
     }
 
-    if ((err = NX_VfsBuildAbsPath(path, absPath)) != NX_EOK)
+    if ((err = NX_PathBuildAbs(path, absPath)) != NX_EOK)
     {
         return err;
     }
 
-    if (NX_VfsStat(absPath, &st) != NX_EOK)
+    if (NX_FileGetStatFromPath(absPath, &st) != NX_EOK)
     {
         return NX_ENOSRCH;
     }
 
-    if (!NX_VFS_S_ISDIR(st.mode)) /* not dir */
+    if (!NX_FILE_IS_DIR(st.mode)) /* not dir */
     {
         return NX_EPERM;
     }
 
-    NX_StrCopyN(process->cwd, absPath, NX_VFS_MAX_PATH);
+    NX_StrCopyN(process->cwd, absPath, NX_FILE_MAX_PATH);
     return NX_EOK;
 }
 
diff --git a/src/process/syscall.c b/src/process/syscall.c
index 0aa42b21616fc7495b024574251bd2a51d2dcdcc..dac38e9472f09f0d45bcee9f52baf05833bed394 100644
--- a/src/process/syscall.c
+++ b/src/process/syscall.c
@@ -16,7 +16,7 @@
 #include <base/process.h>
 #include <base/debug.h>
 #include <base/thread.h>
-#include <base/vfs.h>
+#include <base/fs.h>
 #include <base/hub.h>
 #include <base/vmspace.h>
 #include <base/uaccess.h>
@@ -64,122 +64,340 @@ NX_PRIVATE NX_Error SysProcessLaunch(char *path, NX_U32 flags, NX_U32 *outExitCo
     return err;
 }
 
-NX_PRIVATE NX_Error SysVfsMount(const char * dev, const char * dir, const char * fsname, NX_U32 flags)
+NX_PRIVATE NX_Error SysFileSystemMount(const char * dev, const char * dir, const char * fsname, NX_U32 flags)
 {
-    return NX_VfsMountFileSystem(dev, dir, fsname, flags);
+    return NX_FileSystemMount(dev, dir, fsname, flags);
 }
 
-NX_PRIVATE NX_Error SysVfsUnmount(const char * path)
+NX_PRIVATE NX_Error SysFileSystemUnmount(const char * path)
 {
-    return NX_VfsUnmountFileSystem(path);
+    return NX_FileSystemUnmount(path);
 }
 
-NX_PRIVATE NX_Error SysVfsSync(void)
+NX_PRIVATE NX_Error SysFileSystemSync(void)
 {
-    return NX_VfsSync();
+    return NX_FileSystemSync();
 }
 
-NX_PRIVATE int SysVfsOpen(const char * path, NX_U32 flags, NX_U32 mode, NX_Error *outErr)
+NX_PRIVATE NX_Error SoltToFile(NX_Solt solt, int * fd)
 {
-    return NX_VfsOpen(path, flags, mode, outErr);
+    NX_Process * process;
+    NX_ExposedObject * exobj;
+
+    if (solt == NX_SOLT_INVALID_VALUE)
+    {
+        return NX_EINVAL;
+    }
+
+    process = NX_ProcessCurrent();
+    if ((exobj = NX_ProcessGetSolt(process, solt)) == NX_NULL)
+    {
+        return NX_ENOSRCH;
+    }
+
+    if (exobj->type != NX_EXOBJ_FILE)
+    {
+        return NX_ENORES;
+    }
+
+    *fd = (int)exobj->object;
+    NX_ASSERT(*fd);
+
+    return NX_EOK;
 }
 
-NX_PRIVATE NX_Error SysVfsClose(int fd)
+NX_PRIVATE NX_Error FileCloseSolt(void * object, NX_ExposedObjectType type)
 {
-    return NX_VfsClose(fd);
+    int fd;
+
+    if (type != NX_EXOBJ_FILE)
+    {
+        return NX_ENORES;
+    }
+
+    fd = (int) object;
+    NX_ASSERT(fd);
+
+    return NX_FileClose(fd);
 }
 
-/* NOTICE: To compate 32 bit cpu, syscall need use NX_Size not NX_U64 */
-NX_PRIVATE NX_Size SysVfsRead(int fd, void * buf, NX_Size len, NX_Error *outErr)
+NX_PRIVATE NX_Error SysFileOpen(const char * path, NX_U32 flags, NX_U32 mode, NX_Solt * outSolt)
 {
-    return NX_VfsRead(fd, buf, len, outErr);
+    int fd;
+    NX_Error err = NX_EOK;
+    NX_Solt solt = NX_SOLT_INVALID_VALUE;
+    NX_Process * process;
+    
+    if (!path || !outSolt)
+    {
+        return NX_EINVAL;
+    }
+    
+    if ((fd = NX_FileOpen(path, flags, mode, &err)) < 0)
+    {
+        return err;
+    }
+
+    process = NX_ProcessCurrent();
+    if ((err = NX_ProcessInstallSolt(process, (void *)fd, NX_EXOBJ_FILE, FileCloseSolt, &solt)) != NX_EOK)
+    {
+        NX_FileClose(fd);
+        return err;
+    }
+
+    NX_CopyToUser((char *)outSolt, (char *)&solt, sizeof(solt));
+
+    return NX_EOK;
 }
 
-/* NOTICE: To compate 32 bit cpu, syscall need use NX_Size not NX_U64 */
-NX_PRIVATE NX_Size SysVfsWrite(int fd, void * buf, NX_Size len, NX_Error *outErr)
+NX_PRIVATE NX_Error SysFileRead(NX_Solt solt, void * buf, NX_Size len, NX_Size *outLen)
 {
-    return NX_VfsWrite(fd, buf, len, outErr);
+    NX_Error err;
+    NX_Size size;
+    int fd = -1;
+    
+    err = SoltToFile(solt, &fd);
+    if (err != NX_EOK)
+    {
+        return err;
+    }
+
+    size = NX_FileRead(fd, buf, len, &err);
+    if (err != NX_EOK)
+    {
+        return err;
+    }
+
+    NX_CopyToUser((char *)outLen, (char *)&size, sizeof(size));
+
+    return NX_EOK;
 }
 
-NX_Error SysVfsIoctl(int fd, NX_U32 cmd, void *arg)
+NX_PRIVATE NX_Error SysFileWrite(NX_Solt solt, void * buf, NX_Size len, NX_Size *outLen)
 {
-    return NX_VfsIoctl(fd, cmd, arg);
+    NX_Error err;
+    NX_Size size;
+    int fd = -1;
+    
+    err = SoltToFile(solt, &fd);
+    if (err != NX_EOK)
+    {
+        return err;
+    }
+
+    size = NX_FileWrite(fd, buf, len, &err);
+    if (err != NX_EOK)
+    {
+        return err;
+    }
+
+    NX_CopyToUser((char *)outLen, (char *)&size, sizeof(size));
+
+    return NX_EOK;
 }
 
-/* NOTICE: To compate 32 bit cpu, syscall need use NX_Offset not NX_I64 */
-NX_PRIVATE NX_Offset SysVfsFileSeek(int fd, NX_Offset off, int whence, NX_Error *outErr)
+NX_Error SysFileIoctl(NX_Solt solt, NX_U32 cmd, void *arg)
 {
-    return NX_VfsFileSeek(fd, off, whence, outErr);
+    NX_Error err;
+    int fd = -1;
+    
+    err = SoltToFile(solt, &fd);
+    if (err != NX_EOK)
+    {
+        return err;
+    }
+
+    return NX_FileIoctl(fd, cmd, arg);
 }
 
-NX_PRIVATE NX_Error SysVfsFileSync(int fd)
+NX_PRIVATE NX_Offset SysFileSetPointer(NX_Solt solt, NX_Offset off, int whence, NX_Error *outErr)
 {
-    return NX_VfsFileSync(fd);
+    NX_Error err;
+    int fd = -1;
+    
+    err = SoltToFile(solt, &fd);
+    if (err != NX_EOK)
+    {
+        return err;
+    }
+
+    return NX_FileSetPointer(fd, off, whence, outErr);
 }
 
-NX_PRIVATE NX_Error SysVfsFileChmod(int fd, NX_U32 mode)
+NX_PRIVATE NX_Error SysFileSync(NX_Solt solt)
 {
-    return NX_VfsFileChmod(fd, mode);
+    NX_Error err;
+    int fd = -1;
+    
+    err = SoltToFile(solt, &fd);
+    if (err != NX_EOK)
+    {
+        return err;
+    }
+
+    return NX_FileSync(fd);
+}
+
+NX_PRIVATE NX_Error SysFileSetMode(NX_Solt solt, NX_U32 mode)
+{
+    NX_Error err;
+    int fd = -1;
+    
+    err = SoltToFile(solt, &fd);
+    if (err != NX_EOK)
+    {
+        return err;
+    }
+
+    return NX_FileSetMode(fd, mode);
 }
 
-NX_PRIVATE NX_Error SysVfsFileStat(int fd, NX_VfsStatInfo * st)
+NX_PRIVATE NX_Error SysFileGetStat(NX_Solt solt, NX_FileStatInfo * st)
 {
-    return NX_VfsFileStat(fd, st);
+    NX_Error err;
+    int fd = -1;
+    
+    err = SoltToFile(solt, &fd);
+    if (err != NX_EOK)
+    {
+        return err;
+    }
+
+    return NX_FileGetStat(fd, st);
 }
 
-NX_PRIVATE int SysVfsOpenDir(const char * name, NX_Error *outErr)
+NX_PRIVATE NX_Error SoltToDir(NX_Solt solt, int * fd)
 {
-    return NX_VfsOpenDir(name, outErr);
+    NX_Process * process;
+    NX_ExposedObject * exobj;
+
+    if (solt == NX_SOLT_INVALID_VALUE)
+    {
+        return NX_EINVAL;
+    }
+
+    process = NX_ProcessCurrent();
+    if ((exobj = NX_ProcessGetSolt(process, solt)) == NX_NULL)
+    {
+        return NX_ENOSRCH;
+    }
+
+    if (exobj->type != NX_EXOBJ_DIR)
+    {
+        return NX_ENORES;
+    }
+
+    *fd = (int)exobj->object;
+    NX_ASSERT(*fd);
+
+    return NX_EOK;
 }
 
-NX_PRIVATE NX_Error SysVfsCloseDir(int fd)
+NX_PRIVATE NX_Error DirCloseSolt(void * object, NX_ExposedObjectType type)
 {
-    return NX_VfsCloseDir(fd);
+    int fd;
+
+    if (type != NX_EXOBJ_DIR)
+    {
+        return NX_ENORES;
+    }
+
+    fd = (int) object;
+    NX_ASSERT(fd);
+
+    return NX_DirClose(fd);
 }
+
+NX_PRIVATE NX_Error SysDirOpen(const char * path, NX_Solt * outSolt)
+{
+    int fd;
+    NX_Error err = NX_EOK;
+    NX_Solt solt = NX_SOLT_INVALID_VALUE;
+    NX_Process * process;
+    
+    if (!path || !outSolt)
+    {
+        return NX_EINVAL;
+    }
     
-NX_PRIVATE NX_Error SysVfsReadDir(int fd, NX_VfsDirent * dir)
+    if ((fd = NX_DirOpen(path, &err)) < 0)
+    {
+        return err;
+    }
+
+    process = NX_ProcessCurrent();
+    if ((err = NX_ProcessInstallSolt(process, (void *)fd, NX_EXOBJ_DIR, DirCloseSolt, &solt)) != NX_EOK)
+    {
+        NX_DirClose(fd);
+        return err;
+    }
+
+    NX_CopyToUser((char *)outSolt, (char *)&solt, sizeof(solt));
+
+    return NX_EOK;
+}
+
+NX_PRIVATE NX_Error SysDirRead(NX_Solt solt, NX_Dirent * dir)
 {
-    return NX_VfsReadDir(fd, dir);
+    NX_Error err;
+    int fd = -1;
+    
+    err = SoltToDir(solt, &fd);
+    if (err != NX_EOK)
+    {
+        return err;
+    }
+
+    return NX_DirRead(fd, dir);
 }
 
-NX_PRIVATE NX_Error SysVfsRewindDir(int fd)
+NX_PRIVATE NX_Error SysDirResetPointer(NX_Solt solt)
 {
-    return NX_VfsRewindDir(fd);
+    NX_Error err;
+    int fd = -1;
+    
+    err = SoltToDir(solt, &fd);
+    if (err != NX_EOK)
+    {
+        return err;
+    }
+
+    return NX_DirResetPointer(fd);
 }
 
-NX_PRIVATE NX_Error SysVfsMakeDir(const char * path, NX_U32 mode)
+NX_PRIVATE NX_Error SysDirCreate(const char * path, NX_U32 mode)
 {
-    return NX_VfsMakeDir(path, mode);
+    return NX_DirCreate(path, mode);
 }
 
-NX_PRIVATE NX_Error SysVfsRemoveDir(const char * path)
+NX_PRIVATE NX_Error SysDirDelete(const char * path)
 {
-    return NX_VfsRemoveDir(path);
+    return NX_DirDelete(path);
 }
 
-NX_PRIVATE NX_Error SysVfsRename(const char * src, const char * dst)
+NX_PRIVATE NX_Error SysFileRename(const char * src, const char * dst)
 {
-    return NX_VfsRename(src, dst);
+    return NX_FileRename(src, dst);
 }
 
-NX_PRIVATE NX_Error SysVfsUnlink(const char * path)
+NX_PRIVATE NX_Error SysFileDelete(const char * path)
 {
-    return NX_VfsUnlink(path);
+    return NX_FileDelete(path);
 }
 
-NX_PRIVATE NX_Error SysVfsAccess(const char * path, NX_U32 mode)
+NX_PRIVATE NX_Error SysFileAccess(const char * path, NX_U32 mode)
 {
-    return NX_VfsAccess(path, mode);
+    return NX_FileAccess(path, mode);
 }
 
-NX_PRIVATE NX_Error SysVfsChmod(const char * path, NX_U32 mode)
+NX_PRIVATE NX_Error SysFileSetModeToPath(const char * path, NX_U32 mode)
 {
-    return NX_VfsChmod(path, mode);
+    return NX_FileSetModeToPath(path, mode);
 }
 
-NX_PRIVATE NX_Error SysVfsStat(const char * path, NX_VfsStatInfo * st)
+NX_PRIVATE NX_Error SysFileGetStatFromPath(const char * path, NX_FileStatInfo * st)
 {
-    return NX_VfsStat(path, st);
+    return NX_FileGetStatFromPath(path, st);
 }
 
 NX_PRIVATE NX_Error HubCloseSolt(void * object, NX_ExposedObjectType type)
@@ -1884,28 +2102,28 @@ NX_PRIVATE const NX_SyscallHandler NX_SyscallTable[] =
     SysDebugLog,            /* 1 */
     SysProcessExit,
     SysProcessLaunch,
-    SysVfsMount,
-    SysVfsUnmount,          /* 5 */
-    SysVfsSync,
-    SysVfsOpen,
-    SysVfsClose,
-    SysVfsRead,
-    SysVfsWrite,            /* 10 */
-    SysVfsFileSeek,
-    SysVfsFileSync,
-    SysVfsFileChmod,
-    SysVfsFileStat,
-    SysVfsOpenDir,          /* 15 */
-    SysVfsCloseDir,
-    SysVfsReadDir,
-    SysVfsRewindDir,
-    SysVfsMakeDir,
-    SysVfsRemoveDir,        /* 20 */
-    SysVfsRename,
-    SysVfsUnlink,
-    SysVfsAccess,
-    SysVfsChmod,
-    SysVfsStat,             /* 25 */
+    SysFileSystemMount,
+    SysFileSystemUnmount,   /* 5 */
+    SysFileSystemSync,
+    SysFileOpen,
+    SysInvalidCall,         /* !removed */
+    SysFileRead,
+    SysFileWrite,           /* 10 */
+    SysFileSetPointer,
+    SysFileSync,
+    SysFileSetMode,
+    SysFileGetStat,
+    SysDirOpen,             /* 15 */
+    SysInvalidCall,         /* !removed */
+    SysDirRead,
+    SysDirResetPointer,
+    SysDirCreate,
+    SysDirDelete,           /* 20 */
+    SysFileRename,
+    SysFileDelete,
+    SysFileAccess,
+    SysFileSetModeToPath,
+    SysFileGetStatFromPath, /* 25 */
     SysHubRegister,
     SysHubUnregister,
     SysInvalidCall,         /* !removed */
@@ -1913,7 +2131,7 @@ NX_PRIVATE const NX_SyscallHandler NX_SyscallTable[] =
     SysHubReturn,           /* 30 */
     SysHubWait,
     SysHubTranslate,
-    SysVfsIoctl,
+    SysFileIoctl,
     SysMemMap,
     SysMemUnmap,            /* 35 */
     SysMemHeap,
@@ -1965,7 +2183,7 @@ NX_PRIVATE const NX_SyscallHandler NX_SyscallTable[] =
     SysDriverRegister,
     SysThreadYield,
     SysPollWait,
-    SysShareMemOpen,      /* 85 */
+    SysShareMemOpen,        /* 85 */
     SysShareMemMap,
 };
 
diff --git a/src/sched/thread.c b/src/sched/thread.c
index 6b424c9756b4cb9f51b75cd236ad20d0613ff575..fb37091cdd0daec733e9101496aef75b41e720c4 100644
--- a/src/sched/thread.c
+++ b/src/sched/thread.c
@@ -77,7 +77,7 @@ NX_PRIVATE NX_Error ThreadInit(NX_Thread *thread,
 
     thread->resource.sleepTimer = NX_NULL;
     thread->resource.process = NX_NULL;
-    thread->resource.fileTable = NX_VfsGetDefaultFileTable();
+    thread->resource.fileTable = NX_FileTableGetDefault();
     thread->resource.hub = NX_NULL;
     thread->resource.activeChannel = NX_NULL;
     thread->resource.exitCode = 0;