diff --git a/components/dfs/Kconfig b/components/dfs/Kconfig
index 4d1418b8085..c392975f419 100644
--- a/components/dfs/Kconfig
+++ b/components/dfs/Kconfig
@@ -16,6 +16,15 @@ if RT_USING_DFS
         bool "Using working directory"
         default y
 
+    config RT_USING_DFS_LARGE_FILE
+        bool "Enable 64-bit DFS internal file offset"
+        default n
+        help
+            Enable this option to use a signed 64-bit file offset type inside
+            DFS. The POSIX off_t type is still provided by the selected C
+            library/toolchain, but DFS filesystem drivers and DFS-native helper
+            APIs can handle file positions and file sizes larger than 2GB.
+
 if RT_USING_DFS_V1
     config RT_USING_DFS_MNTTABLE
         bool "Using mount table for file system"
diff --git a/components/dfs/dfs_v1/filesystems/9pfs/dfs_9pfs.c b/components/dfs/dfs_v1/filesystems/9pfs/dfs_9pfs.c
index 6e842f51c85..e054fc156a2 100644
--- a/components/dfs/dfs_v1/filesystems/9pfs/dfs_9pfs.c
+++ b/components/dfs/dfs_v1/filesystems/9pfs/dfs_9pfs.c
@@ -367,24 +367,29 @@ rt_err_t dfs_9pfs_del_tag(struct p9_protocol *p9p)
 
 static int p9_to_fs_err(int rc)
 {
-    const int p9_err[] = {
-        [0] = RT_EOK,
-        [-P9_ERROR] = -EIO,
-        [-P9_UNKNOWN_VERSION] = -ENOSYS,
-        [-P9_R_ERROR] = -EIO,
-        [-P9_MSG_TOO_LONG] = -ENOSPC,
-        [-P9_UNEXPECTED_MSG] = -EINVAL,
-        [-P9_UNEXPECTED_TAG] = -EINVAL,
-        [-P9_TRANSPORT_ERROR] = -EIO,
-        [-P9_NO_TRANSPORT] = -EINVAL,
-        [-P9_NULL_PATH] = -EINVAL,
-        [-P9_PATH_ELEMENT_TOO_LONG] = -EINVAL,
-        [-P9_READ_UNEXPECTED_DATA] = -EINVAL,
-        [-P9_NO_BUFFER] = -ENOSPC,
-        [-P9_MSG_SIZE_TOO_BIG] = -ENOSPC,
-    };
-
-    return p9_err[-rc];
+    switch (rc)
+    {
+    case 0:
+        return RT_EOK;
+    case P9_UNKNOWN_VERSION:
+        return -ENOSYS;
+    case P9_MSG_TOO_LONG:
+    case P9_NO_BUFFER:
+    case P9_MSG_SIZE_TOO_BIG:
+        return -ENOSPC;
+    case P9_UNEXPECTED_MSG:
+    case P9_UNEXPECTED_TAG:
+    case P9_NO_TRANSPORT:
+    case P9_NULL_PATH:
+    case P9_PATH_ELEMENT_TOO_LONG:
+    case P9_READ_UNEXPECTED_DATA:
+        return -EINVAL;
+    case P9_ERROR:
+    case P9_R_ERROR:
+    case P9_TRANSPORT_ERROR:
+    default:
+        return -EIO;
+    }
 }
 
 static int p9_alloc_fid(struct p9_connection *conn)
@@ -547,7 +552,7 @@ rt_inline int p9_walk_subpath(struct p9_connection *conn, const char *path)
 
 static int dfs_9pfs_open(struct dfs_file *fd)
 {
-    int rc;
+    int rc = 0;
     rt_uint32_t size;
     rt_bool_t is_root;
     struct p9_connection *conn;
@@ -807,7 +812,7 @@ static int dfs_9pfs_flush(struct dfs_file *fd)
     return p9_to_fs_err(rc);
 }
 
-static off_t dfs_9pfs_lseek(struct dfs_file *fd, off_t offset)
+static dfs_off_t dfs_9pfs_lseek(struct dfs_file *fd, dfs_off_t offset)
 {
     int ret = -EIO;
 
@@ -1049,7 +1054,7 @@ static int dfs_9pfs_unlink(struct dfs_filesystem *fs, const char *pathname)
 }
 
 static int dfs_9pfs_stat(struct dfs_filesystem *fs,
-                         const char *filename, struct stat *st)
+                         const char *filename, struct dfs_stat *st)
 {
     int rc = 0, fid;
     rt_uint32_t size, mode;
@@ -1108,8 +1113,8 @@ static int dfs_9pfs_stat(struct dfs_filesystem *fs,
                 st->st_mode |= S_ISVTX;
             }
 
-            st->st_atime = get_rx_value32_of(conn, P9_MSG_STAT_ATIME);
-            st->st_mtime = get_rx_value32_of(conn, P9_MSG_STAT_MTIME);
+            st->atime = get_rx_value32_of(conn, P9_MSG_STAT_ATIME);
+            st->mtime = get_rx_value32_of(conn, P9_MSG_STAT_MTIME);
             st->st_size = get_rx_value64_of(conn, P9_MSG_STAT_LEN);
 
             /*
diff --git a/components/dfs/dfs_v1/filesystems/cromfs/dfs_cromfs.c b/components/dfs/dfs_v1/filesystems/cromfs/dfs_cromfs.c
index fee8b8dbd15..5158b590ad7 100644
--- a/components/dfs/dfs_v1/filesystems/cromfs/dfs_cromfs.c
+++ b/components/dfs/dfs_v1/filesystems/cromfs/dfs_cromfs.c
@@ -788,7 +788,7 @@ static int dfs_cromfs_read(struct dfs_file *file, void *buf, size_t count)
     return length;
 }
 
-static int dfs_cromfs_lseek(struct dfs_file *file, off_t offset)
+static dfs_off_t dfs_cromfs_lseek(struct dfs_file *file, dfs_off_t offset)
 {
     if (offset <= file->vnode->size)
     {
@@ -1012,7 +1012,7 @@ static int dfs_cromfs_open(struct dfs_file *file)
     return ret;
 }
 
-static int dfs_cromfs_stat(struct dfs_filesystem *fs, const char *path, struct stat *st)
+static int dfs_cromfs_stat(struct dfs_filesystem *fs, const char *path, struct dfs_stat *st)
 {
     uint32_t size = 0, osize = 0;
     int is_dir = 0;
@@ -1042,7 +1042,7 @@ static int dfs_cromfs_stat(struct dfs_filesystem *fs, const char *path, struct s
         st->st_size = osize;
     }
 
-    st->st_mtime = 0;
+    st->mtime = 0;
 
     return RT_EOK;
 }
diff --git a/components/dfs/dfs_v1/filesystems/devfs/devfs.c b/components/dfs/dfs_v1/filesystems/devfs/devfs.c
index cceb14150e8..d27011e9245 100644
--- a/components/dfs/dfs_v1/filesystems/devfs/devfs.c
+++ b/components/dfs/dfs_v1/filesystems/devfs/devfs.c
@@ -284,7 +284,7 @@ int dfs_device_fs_unlink(struct dfs_filesystem *fs, const char *path)
     return RT_EOK;
 }
 
-int dfs_device_fs_stat(struct dfs_filesystem *fs, const char *path, struct stat *st)
+int dfs_device_fs_stat(struct dfs_filesystem *fs, const char *path, struct dfs_stat *st)
 {
     st->st_dev = (dev_t)((size_t)dfs_filesystem_lookup(fs->path));
     /* stat root directory */
@@ -296,7 +296,7 @@ int dfs_device_fs_stat(struct dfs_filesystem *fs, const char *path, struct stat
         st->st_mode |= S_IFDIR | S_IXUSR | S_IXGRP | S_IXOTH;
 
         st->st_size  = 0;
-        st->st_mtime = 0;
+        st->mtime = 0;
 
         return RT_EOK;
     }
@@ -322,7 +322,7 @@ int dfs_device_fs_stat(struct dfs_filesystem *fs, const char *path, struct stat
                 st->st_mode |= S_IFREG;
 
             st->st_size  = 0;
-            st->st_mtime = 0;
+            st->mtime = 0;
 
             return RT_EOK;
         }
diff --git a/components/dfs/dfs_v1/filesystems/elmfat/dfs_elm.c b/components/dfs/dfs_v1/filesystems/elmfat/dfs_elm.c
index effd1bcd7c7..13548f83a3b 100644
--- a/components/dfs/dfs_v1/filesystems/elmfat/dfs_elm.c
+++ b/components/dfs/dfs_v1/filesystems/elmfat/dfs_elm.c
@@ -504,13 +504,19 @@ int dfs_elm_ioctl(struct dfs_file *file, int cmd, void *args)
         {
             FIL *fd;
             FSIZE_t fptr, length;
+            dfs_off_t dfs_length;
             FRESULT result = FR_OK;
             fd = (FIL *)(file->data);
             RT_ASSERT(fd != RT_NULL);
 
             /* save file read/write point */
             fptr = fd->fptr;
-            length = *(off_t*)args;
+            dfs_length = *(dfs_off_t*)args;
+            if (dfs_length < 0 || (dfs_off_t)(FSIZE_t)dfs_length != dfs_length)
+            {
+                return -EINVAL;
+            }
+            length = (FSIZE_t)dfs_length;
             if (length <= fd->obj.objsize)
             {
                 fd->fptr = length;
@@ -591,9 +597,14 @@ int dfs_elm_flush(struct dfs_file *file)
     return elm_result_to_dfs(result);
 }
 
-off_t dfs_elm_lseek(struct dfs_file *file, off_t offset)
+dfs_off_t dfs_elm_lseek(struct dfs_file *file, dfs_off_t offset)
 {
     FRESULT result = FR_OK;
+    if (offset < 0 || (dfs_off_t)(FSIZE_t)offset != offset)
+    {
+        return -EINVAL;
+    }
+
     if (file->vnode->type == FT_REGULAR)
     {
         FIL *fd;
@@ -602,7 +613,7 @@ off_t dfs_elm_lseek(struct dfs_file *file, off_t offset)
         fd = (FIL *)(file->data);
         RT_ASSERT(fd != RT_NULL);
 
-        result = f_lseek(fd, offset);
+        result = f_lseek(fd, (FSIZE_t)offset);
         if (result == FR_OK)
         {
             /* return current position */
@@ -751,7 +762,7 @@ int dfs_elm_rename(struct dfs_filesystem *fs, const char *oldpath, const char *n
     return elm_result_to_dfs(result);
 }
 
-int dfs_elm_stat(struct dfs_filesystem *fs, const char *path, struct stat *st)
+int dfs_elm_stat(struct dfs_filesystem *fs, const char *path, struct dfs_stat *st)
 {
     FATFS  *f;
     FILINFO file_info;
@@ -836,7 +847,7 @@ int dfs_elm_stat(struct dfs_filesystem *fs, const char *path, struct stat *st)
             tm_file.tm_min  = min;         /* Minutes: 0-59 */
             tm_file.tm_sec  = sec;         /* Seconds: 0-59 */
 
-            st->st_mtime = timegm(&tm_file);
+            st->mtime = timegm(&tm_file);
         } /* get st_mtime. */
     }
 
diff --git a/components/dfs/dfs_v1/filesystems/iso9660/dfs_iso9660.c b/components/dfs/dfs_v1/filesystems/iso9660/dfs_iso9660.c
index 2358280a799..950e996648e 100644
--- a/components/dfs/dfs_v1/filesystems/iso9660/dfs_iso9660.c
+++ b/components/dfs/dfs_v1/filesystems/iso9660/dfs_iso9660.c
@@ -475,7 +475,7 @@ static ssize_t dfs_iso9660_read(struct dfs_file *fd, void *buf, size_t count)
     return rcount;
 }
 
-static off_t dfs_iso9660_lseek(struct dfs_file *fd, off_t offset)
+static dfs_off_t dfs_iso9660_lseek(struct dfs_file *fd, dfs_off_t offset)
 {
     int ret = -EIO;
 
@@ -648,7 +648,7 @@ static int dfs_iso9660_unmount(struct dfs_filesystem *fs)
 }
 
 static int dfs_iso9660_stat(struct dfs_filesystem *fs,
-        const char *filename, struct stat *st)
+        const char *filename, struct dfs_stat *st)
 {
     struct iso9660 *iso = fs->data;
     struct iso9660_fd *fd = iso9660_lookup(iso, filename, RT_NULL);
@@ -668,9 +668,9 @@ static int dfs_iso9660_stat(struct dfs_filesystem *fs,
         st->st_mode |= S_IFDIR | S_IXUSR | S_IXGRP | S_IXOTH;
     }
 
-    st->st_atime = iso9660_convert_unixtime(iso->joliet ?
+    st->atime = iso9660_convert_unixtime(iso->joliet ?
             &iso->supp.created : &iso->primary.created);
-    st->st_mtime = iso9660_convert_unixtime2(&fd->dirent.mtime);
+    st->mtime = iso9660_convert_unixtime2(&fd->dirent.mtime);
     st->st_size = rt_le32_to_cpu(fd->dirent.size);
 
     rt_free(fd);
diff --git a/components/dfs/dfs_v1/filesystems/mqueue/dfs_mqueue.c b/components/dfs/dfs_v1/filesystems/mqueue/dfs_mqueue.c
index e279c50de1f..222f1abc62d 100644
--- a/components/dfs/dfs_v1/filesystems/mqueue/dfs_mqueue.c
+++ b/components/dfs/dfs_v1/filesystems/mqueue/dfs_mqueue.c
@@ -84,11 +84,11 @@ int dfs_mqueue_open(struct dfs_file *file) {
     return 0;
 }
 
-int dfs_mqueue_stat(struct dfs_filesystem *fs, const char *path, struct stat *st) {
+int dfs_mqueue_stat(struct dfs_filesystem *fs, const char *path, struct dfs_stat *st) {
     st->st_dev = 0;
     st->st_mode = S_IFREG | S_IRUSR | S_IRGRP | S_IROTH | S_IWUSR | S_IWGRP | S_IWOTH;
     st->st_size = 0;
-    st->st_mtime = 0;
+    st->mtime = 0;
     return RT_EOK;
 }
 
diff --git a/components/dfs/dfs_v1/filesystems/nfs/dfs_nfs.c b/components/dfs/dfs_v1/filesystems/nfs/dfs_nfs.c
index b24e6361845..315f8490cc2 100644
--- a/components/dfs/dfs_v1/filesystems/nfs/dfs_nfs.c
+++ b/components/dfs/dfs_v1/filesystems/nfs/dfs_nfs.c
@@ -685,7 +685,7 @@ int nfs_write(struct dfs_file *file, const void *buf, size_t count)
     return total;
 }
 
-int nfs_lseek(struct dfs_file *file, off_t offset)
+dfs_off_t nfs_lseek(struct dfs_file *file, dfs_off_t offset)
 {
     nfs_file *fd;
     nfs_filesystem *nfs;
@@ -837,7 +837,7 @@ int nfs_open(struct dfs_file *file)
     return 0;
 }
 
-int nfs_stat(struct dfs_filesystem *fs, const char *path, struct stat *st)
+int nfs_stat(struct dfs_filesystem *fs, const char *path, struct dfs_stat *st)
 {
     GETATTR3args args;
     GETATTR3res res;
@@ -880,7 +880,7 @@ int nfs_stat(struct dfs_filesystem *fs, const char *path, struct stat *st)
     }
 
     st->st_size  = info->size;
-    st->st_mtime = info->mtime.seconds;
+    st->mtime = info->mtime.seconds;
 
     xdr_free((xdrproc_t)xdr_GETATTR3res, (char *)&res);
     xdr_free((xdrproc_t)xdr_nfs_fh3, (char *)handle);
diff --git a/components/dfs/dfs_v1/filesystems/ramfs/dfs_ramfs.c b/components/dfs/dfs_v1/filesystems/ramfs/dfs_ramfs.c
index 1cb7085964c..94c3cdacf0d 100644
--- a/components/dfs/dfs_v1/filesystems/ramfs/dfs_ramfs.c
+++ b/components/dfs/dfs_v1/filesystems/ramfs/dfs_ramfs.c
@@ -201,9 +201,9 @@ ssize_t dfs_ramfs_write(struct dfs_file *fd, const void *buf, size_t count)
     return count;
 }
 
-off_t dfs_ramfs_lseek(struct dfs_file *file, off_t offset)
+dfs_off_t dfs_ramfs_lseek(struct dfs_file *file, dfs_off_t offset)
 {
-    if (offset <= (off_t)file->vnode->size)
+    if (offset <= file->vnode->size)
     {
         file->pos = offset;
 
@@ -346,7 +346,7 @@ int dfs_ramfs_open(struct dfs_file *file)
 
 int dfs_ramfs_stat(struct dfs_filesystem *fs,
                    const char            *path,
-                   struct stat           *st)
+                   struct dfs_stat       *st)
 {
     rt_size_t size;
     struct ramfs_dirent *dirent;
@@ -363,7 +363,7 @@ int dfs_ramfs_stat(struct dfs_filesystem *fs,
                   S_IWUSR | S_IWGRP | S_IWOTH;
 
     st->st_size = dirent->size;
-    st->st_mtime = 0;
+    st->mtime = 0;
 
     return RT_EOK;
 }
diff --git a/components/dfs/dfs_v1/filesystems/romfs/dfs_romfs.c b/components/dfs/dfs_v1/filesystems/romfs/dfs_romfs.c
index f50f0c74d62..c51527cd5dd 100644
--- a/components/dfs/dfs_v1/filesystems/romfs/dfs_romfs.c
+++ b/components/dfs/dfs_v1/filesystems/romfs/dfs_romfs.c
@@ -178,7 +178,7 @@ ssize_t dfs_romfs_read(struct dfs_file *file, void *buf, size_t count)
     return length;
 }
 
-off_t dfs_romfs_lseek(struct dfs_file *file, off_t offset)
+dfs_off_t dfs_romfs_lseek(struct dfs_file *file, dfs_off_t offset)
 {
     if (offset <= file->vnode->size)
     {
@@ -269,7 +269,7 @@ int dfs_romfs_open(struct dfs_file *file)
     return RT_EOK;
 }
 
-int dfs_romfs_stat(struct dfs_filesystem *fs, const char *path, struct stat *st)
+int dfs_romfs_stat(struct dfs_filesystem *fs, const char *path, struct dfs_stat *st)
 {
     rt_size_t size;
     struct romfs_dirent *dirent;
@@ -294,7 +294,7 @@ int dfs_romfs_stat(struct dfs_filesystem *fs, const char *path, struct stat *st)
     }
 
     st->st_size = dirent->size;
-    st->st_mtime = 0;
+    st->mtime = 0;
 
     return RT_EOK;
 }
diff --git a/components/dfs/dfs_v1/filesystems/skeleton/skeleton.c b/components/dfs/dfs_v1/filesystems/skeleton/skeleton.c
index 5c35cd1ffc3..cbd2c264279 100644
--- a/components/dfs/dfs_v1/filesystems/skeleton/skeleton.c
+++ b/components/dfs/dfs_v1/filesystems/skeleton/skeleton.c
@@ -34,7 +34,7 @@ int dfs_skt_read(struct dfs_file *file, void *buf, rt_size_t count)
     return count;
 }
 
-int dfs_skt_lseek(struct dfs_file *file, rt_off_t offset)
+dfs_off_t dfs_skt_lseek(struct dfs_file *file, dfs_off_t offset)
 {
     return -RT_EIO;
 }
@@ -49,7 +49,7 @@ int dfs_skt_open(struct dfs_file *file)
     return RT_EOK;
 }
 
-int dfs_skt_stat(struct dfs_filesystem *fs, const char *path, struct stat *st)
+int dfs_skt_stat(struct dfs_filesystem *fs, const char *path, struct dfs_stat *st)
 {
     return RT_EOK;
 }
diff --git a/components/dfs/dfs_v1/filesystems/tmpfs/dfs_tmpfs.c b/components/dfs/dfs_v1/filesystems/tmpfs/dfs_tmpfs.c
index cb971ef30c3..9049d5cee5a 100644
--- a/components/dfs/dfs_v1/filesystems/tmpfs/dfs_tmpfs.c
+++ b/components/dfs/dfs_v1/filesystems/tmpfs/dfs_tmpfs.c
@@ -392,9 +392,9 @@ ssize_t dfs_tmpfs_write(struct dfs_file *fd, const void *buf, size_t count)
     return count;
 }
 
-off_t dfs_tmpfs_lseek(struct dfs_file *file, off_t offset)
+dfs_off_t dfs_tmpfs_lseek(struct dfs_file *file, dfs_off_t offset)
 {
-    if (offset <= (off_t)file->vnode->size)
+    if (offset <= file->vnode->size)
     {
         file->pos = offset;
 
@@ -550,7 +550,7 @@ int dfs_tmpfs_open(struct dfs_file *file)
 
 int dfs_tmpfs_stat(struct dfs_filesystem *fs,
                    const char            *path,
-                   struct stat           *st)
+                   struct dfs_stat       *st)
 {
     rt_size_t size;
     struct tmpfs_file *d_file;
@@ -572,7 +572,7 @@ int dfs_tmpfs_stat(struct dfs_filesystem *fs,
     }
 
     st->st_size = d_file->size;
-    st->st_mtime = 0;
+    st->mtime = 0;
 
     return RT_EOK;
 }
diff --git a/components/dfs/dfs_v1/include/dfs.h b/components/dfs/dfs_v1/include/dfs.h
index 12b0d599314..a8a35fe9c66 100644
--- a/components/dfs/dfs_v1/include/dfs.h
+++ b/components/dfs/dfs_v1/include/dfs.h
@@ -69,6 +69,37 @@ extern "C" {
 #define DFS_F_EOF               0x04000000
 #define DFS_F_ERR               0x08000000
 
+#ifdef RT_USING_DFS_LARGE_FILE
+typedef int64_t dfs_off_t;
+#define DFS_OFF_MAX INT64_MAX
+#else
+typedef int32_t dfs_off_t;
+#define DFS_OFF_MAX INT32_MAX
+#endif
+
+struct dfs_stat
+{
+    dev_t st_dev;
+    uint16_t st_ino;
+    uint16_t st_mode;
+    uint16_t st_nlink;
+    uint16_t st_uid;
+    uint16_t st_gid;
+    struct rt_device *st_rdev;
+    dfs_off_t st_size;
+    time_t atime;
+    long st_spare1;
+    time_t mtime;
+    long st_spare2;
+    time_t ctime;
+    long st_spare3;
+    uint32_t st_blksize;
+    uint32_t st_blocks;
+    long st_spare4[2];
+};
+
+void dfs_print_off_t(dfs_off_t value);
+
 struct dfs_fdtable
 {
     uint32_t maxfd;
diff --git a/components/dfs/dfs_v1/include/dfs_file.h b/components/dfs/dfs_v1/include/dfs_file.h
index 26c74c8f161..4449228365a 100644
--- a/components/dfs/dfs_v1/include/dfs_file.h
+++ b/components/dfs/dfs_v1/include/dfs_file.h
@@ -28,7 +28,7 @@ struct dfs_file_ops
     ssize_t (*read)     (struct dfs_file *fd, void *buf, size_t count);
     ssize_t (*write)    (struct dfs_file *fd, const void *buf, size_t count);
     int (*flush)    (struct dfs_file *fd);
-    off_t (*lseek)    (struct dfs_file *fd, off_t offset);
+    dfs_off_t (*lseek)    (struct dfs_file *fd, dfs_off_t offset);
     int (*getdents) (struct dfs_file *fd, struct dirent *dirp, uint32_t count);
 
     int (*poll)     (struct dfs_file *fd, struct rt_pollreq *req);
@@ -50,7 +50,7 @@ struct dfs_vnode
     const struct dfs_file_ops *fops;
     uint32_t flags;              /* self flags, is dir etc.. */
 
-    size_t   size;               /* Size in bytes */
+    dfs_off_t size;              /* Size in bytes */
     void *data;                  /* Specific file system data */
 };
 
@@ -59,7 +59,7 @@ struct dfs_file
     uint16_t magic;              /* file descriptor magic number */
     uint32_t flags;              /* Descriptor flags */
     int ref_count;               /* Descriptor reference count */
-    off_t    pos;                /* Current file position */
+    dfs_off_t pos;               /* Current file position */
     struct dfs_vnode *vnode;     /* file node struct */
     void *data;                  /* Specific fd data */
 };
@@ -72,7 +72,7 @@ struct dfs_mmap2_args
     size_t length;
     int prot;
     int flags;
-    off_t pgoffset;
+    dfs_off_t pgoffset;
 
     struct rt_lwp *lwp;
     void *ret;
@@ -91,11 +91,11 @@ int dfs_file_getdents(struct dfs_file *fd, struct dirent *dirp, size_t nbytes);
 int dfs_file_unlink(const char *path);
 ssize_t dfs_file_write(struct dfs_file *fd, const void *buf, size_t len);
 int dfs_file_flush(struct dfs_file *fd);
-off_t dfs_file_lseek(struct dfs_file *fd, off_t offset);
+dfs_off_t dfs_file_lseek(struct dfs_file *fd, dfs_off_t offset);
 
-int dfs_file_stat(const char *path, struct stat *buf);
+int dfs_file_stat(const char *path, struct dfs_stat *buf);
 int dfs_file_rename(const char *oldpath, const char *newpath);
-int dfs_file_ftruncate(struct dfs_file *fd, off_t length);
+int dfs_file_ftruncate(struct dfs_file *fd, dfs_off_t length);
 #ifdef RT_USING_SMART
 int dfs_file_mmap2(struct dfs_file *fd, struct dfs_mmap2_args *mmap2);
 #endif
diff --git a/components/dfs/dfs_v1/include/dfs_fs.h b/components/dfs/dfs_v1/include/dfs_fs.h
index adfed8d787a..12d00ffd2e2 100644
--- a/components/dfs/dfs_v1/include/dfs_fs.h
+++ b/components/dfs/dfs_v1/include/dfs_fs.h
@@ -41,7 +41,7 @@ struct dfs_filesystem_ops
     int (*statfs)   (struct dfs_filesystem *fs, struct statfs *buf);
 
     int (*unlink)   (struct dfs_filesystem *fs, const char *pathname);
-    int (*stat)     (struct dfs_filesystem *fs, const char *filename, struct stat *buf);
+    int (*stat)     (struct dfs_filesystem *fs, const char *filename, struct dfs_stat *buf);
     int (*rename)   (struct dfs_filesystem *fs, const char *oldpath, const char *newpath);
 };
 
@@ -60,7 +60,7 @@ struct dfs_filesystem
 struct dfs_partition
 {
     uint8_t type;        /* file system type */
-    off_t  offset;       /* partition start offset */
+    dfs_off_t offset;    /* partition start offset */
     size_t size;         /* partition size */
     rt_sem_t lock;
 };
diff --git a/components/dfs/dfs_v1/src/dfs.c b/components/dfs/dfs_v1/src/dfs.c
index 9a7c98cc336..6bfc20b1368 100644
--- a/components/dfs/dfs_v1/src/dfs.c
+++ b/components/dfs/dfs_v1/src/dfs.c
@@ -39,6 +39,35 @@ static struct dfs_fdtable _fdtab;
 static int  fd_alloc(struct dfs_fdtable *fdt, int startfd);
 #endif /* DFS_USING_POSIX */
 
+void dfs_print_off_t(dfs_off_t value)
+{
+    char buf[24];
+    int i = 0;
+    rt_uint64_t number;
+
+    if (value < 0)
+    {
+        rt_kprintf("-");
+        number = (rt_uint64_t)(-(value + 1)) + 1;
+    }
+    else
+    {
+        number = (rt_uint64_t)value;
+    }
+
+    do
+    {
+        buf[i++] = (char)('0' + number % 10);
+        number /= 10;
+    }
+    while (number != 0);
+
+    while (i > 0)
+    {
+        rt_kprintf("%c", buf[--i]);
+    }
+}
+
 /**
  * @addtogroup group_device_virtual_file_system
  * @{
diff --git a/components/dfs/dfs_v1/src/dfs_file.c b/components/dfs/dfs_v1/src/dfs_file.c
index f1c4e7ee4d2..d3902ca99c0 100644
--- a/components/dfs/dfs_v1/src/dfs_file.c
+++ b/components/dfs/dfs_v1/src/dfs_file.c
@@ -578,9 +578,9 @@ int dfs_file_flush(struct dfs_file *fd)
  *
  * @return the current position after seek.
  */
-off_t dfs_file_lseek(struct dfs_file *fd, off_t offset)
+dfs_off_t dfs_file_lseek(struct dfs_file *fd, dfs_off_t offset)
 {
-    int result;
+    dfs_off_t result;
 
     if (fd == NULL)
         return -EINVAL;
@@ -605,7 +605,7 @@ off_t dfs_file_lseek(struct dfs_file *fd, off_t offset)
  *
  * @return 0 on successful, -1 on failed.
  */
-int dfs_file_stat(const char *path, struct stat *buf)
+int dfs_file_stat(const char *path, struct dfs_stat *buf)
 {
     int result;
     char *fullpath;
@@ -734,7 +734,7 @@ int dfs_file_rename(const char *oldpath, const char *newpath)
  *
  * @return the status of truncated.
  */
-int dfs_file_ftruncate(struct dfs_file *fd, off_t length)
+int dfs_file_ftruncate(struct dfs_file *fd, dfs_off_t length)
 {
     int result;
 
@@ -787,7 +787,7 @@ void ls(const char *pathname)
 {
     struct dfs_file fd;
     struct dirent dirent;
-    struct stat stat;
+    struct dfs_stat stat;
     int length;
     char *fullpath, *path;
 
@@ -819,7 +819,7 @@ void ls(const char *pathname)
             length = dfs_file_getdents(&fd, &dirent, sizeof(struct dirent));
             if (length > 0)
             {
-                rt_memset(&stat, 0, sizeof(struct stat));
+                rt_memset(&stat, 0, sizeof(struct dfs_stat));
 
                 /* build full path for each file */
                 fullpath = dfs_normalize_path(path, dirent.d_name);
@@ -835,7 +835,9 @@ void ls(const char *pathname)
                     }
                     else
                     {
-                        rt_kprintf(" %-25lu\n", (unsigned long)stat.st_size);
+                        rt_kprintf(" ");
+                        dfs_print_off_t((dfs_off_t)stat.st_size);
+                        rt_kprintf("\n");
                     }
                 }
                 else
@@ -959,7 +961,7 @@ extern int mkdir(const char *path, mode_t mode);
 static void copydir(const char *src, const char *dst)
 {
     struct dirent dirent;
-    struct stat stat;
+    struct dfs_stat stat;
     int length;
     struct dfs_file cpfd;
     if (dfs_file_open(&cpfd, src, O_DIRECTORY) < 0)
@@ -994,7 +996,7 @@ static void copydir(const char *src, const char *dst)
                 break;
             }
 
-            rt_memset(&stat, 0, sizeof(struct stat));
+            rt_memset(&stat, 0, sizeof(struct dfs_stat));
             if (dfs_file_stat(src_entry_full, &stat) != 0)
             {
                 rt_kprintf("open file: %s failed\n", dirent.d_name);
@@ -1041,7 +1043,7 @@ void copy(const char *src, const char *dst)
 #define FLAG_DST_IS_FILE   0x08
 #define FLAG_DST_NON_EXSIT 0x00
 
-    struct stat stat;
+    struct dfs_stat stat;
     uint32_t flag = 0;
 
     /* check the staus of src and dst */
diff --git a/components/dfs/dfs_v1/src/dfs_posix.c b/components/dfs/dfs_v1/src/dfs_posix.c
index f3d7b70c318..27dd62e19b5 100644
--- a/components/dfs/dfs_v1/src/dfs_posix.c
+++ b/components/dfs/dfs_v1/src/dfs_posix.c
@@ -284,9 +284,10 @@ RTM_EXPORT(write);
  *
  * @return the resulting read/write position in the file, or -1 on failed.
  */
-off_t lseek(int fd, off_t offset, int whence)
+dfs_off_t lseek(int fd, dfs_off_t offset, int whence)
 {
-    int result;
+    dfs_off_t dfs_offset;
+    dfs_off_t result;
     struct dfs_file *d;
 
     d = fd_get(fd);
@@ -300,14 +301,15 @@ off_t lseek(int fd, off_t offset, int whence)
     switch (whence)
     {
     case SEEK_SET:
+        dfs_offset = (dfs_off_t)offset;
         break;
 
     case SEEK_CUR:
-        offset += d->pos;
+        dfs_offset = d->pos + (dfs_off_t)offset;
         break;
 
     case SEEK_END:
-        offset += d->vnode->size;
+        dfs_offset = d->vnode->size + (dfs_off_t)offset;
         break;
 
     default:
@@ -316,13 +318,13 @@ off_t lseek(int fd, off_t offset, int whence)
         return -1;
     }
 
-    if (offset < 0)
+    if (dfs_offset < 0)
     {
         rt_set_errno(-EINVAL);
 
         return -1;
     }
-    result = dfs_file_lseek(d, offset);
+    result = dfs_file_lseek(d, dfs_offset);
     if (result < 0)
     {
         rt_set_errno(result);
@@ -330,7 +332,7 @@ off_t lseek(int fd, off_t offset, int whence)
         return -1;
     }
 
-    return offset;
+    return result;
 }
 RTM_EXPORT(lseek);
 
@@ -398,8 +400,10 @@ RTM_EXPORT(unlink);
 int stat(const char *file, struct stat *buf)
 {
     int result;
+    struct dfs_stat dfs_buf;
 
-    result = dfs_file_stat(file, buf);
+    rt_memset(&dfs_buf, 0, sizeof(dfs_buf));
+    result = dfs_file_stat(file, &dfs_buf);
     if (result < 0)
     {
         rt_set_errno(result);
@@ -407,6 +411,25 @@ int stat(const char *file, struct stat *buf)
         return -1;
     }
 
+    rt_memset(buf, 0, sizeof(struct stat));
+    buf->st_dev = dfs_buf.st_dev;
+    buf->st_ino = dfs_buf.st_ino;
+    buf->st_mode = dfs_buf.st_mode;
+    buf->st_nlink = dfs_buf.st_nlink;
+    buf->st_uid = dfs_buf.st_uid;
+    buf->st_gid = dfs_buf.st_gid;
+#if defined(__ARMCC_VERSION) || defined(__ICCARM__)
+    buf->st_rdev = dfs_buf.st_rdev;
+#else
+    buf->st_rdev = (dev_t)(rt_ubase_t)dfs_buf.st_rdev;
+#endif
+    buf->st_size = dfs_buf.st_size;
+    buf->st_atime = dfs_buf.atime;
+    buf->st_mtime = dfs_buf.mtime;
+    buf->st_ctime = dfs_buf.ctime;
+    buf->st_blksize = dfs_buf.st_blksize;
+    buf->st_blocks = dfs_buf.st_blocks;
+
     return result;
 }
 RTM_EXPORT(stat);
@@ -549,7 +572,7 @@ RTM_EXPORT(ioctl);
  * @return Upon successful completion, ftruncate() shall return 0;
  * otherwise, -1 shall be returned and errno set to indicate the error.
  */
-int ftruncate(int fd, off_t length)
+int ftruncate(int fd, dfs_off_t length)
 {
     int result;
     struct dfs_file *d;
@@ -568,7 +591,7 @@ int ftruncate(int fd, off_t length)
 
         return -1;
     }
-    result = dfs_file_ftruncate(d, length);
+    result = dfs_file_ftruncate(d, (dfs_off_t)length);
     if (result < 0)
     {
         rt_set_errno(result);
diff --git a/components/dfs/dfs_v2/filesystems/cromfs/dfs_cromfs.c b/components/dfs/dfs_v2/filesystems/cromfs/dfs_cromfs.c
index d262b19d233..bd338936ccc 100644
--- a/components/dfs/dfs_v2/filesystems/cromfs/dfs_cromfs.c
+++ b/components/dfs/dfs_v2/filesystems/cromfs/dfs_cromfs.c
@@ -781,7 +781,7 @@ static int fill_file_data(file_info *fi)
     return ret;
 }
 
-static ssize_t dfs_cromfs_read(struct dfs_file *file, void *buf, size_t count, off_t *pos)
+static ssize_t dfs_cromfs_read(struct dfs_file *file, void *buf, size_t count, dfs_off_t *pos)
 {
     rt_err_t result = RT_EOK;
     file_info *fi = NULL;
@@ -791,13 +791,13 @@ static ssize_t dfs_cromfs_read(struct dfs_file *file, void *buf, size_t count, o
     ci = (cromfs_info *)file->dentry->mnt->data;
     fi = (file_info *)file->vnode->data;
 
-    if ((off_t)count < (off_t)file->vnode->size - *pos)
+    if ((dfs_off_t)count < (dfs_off_t)file->vnode->size - *pos)
     {
         length = count;
     }
     else
     {
-        length = (off_t)file->vnode->size - *pos;
+        length = (dfs_off_t)file->vnode->size - *pos;
     }
 
     if (length > 0)
@@ -1063,7 +1063,7 @@ static int dfs_cromfs_open(struct dfs_file *file)
     return ret;
 }
 
-static int dfs_cromfs_stat(struct dfs_dentry *dentry, struct stat *st)
+static int dfs_cromfs_stat(struct dfs_dentry *dentry, struct dfs_stat *st)
 {
     uint32_t size = 0, osize = 0;
     int file_type = 0;
@@ -1102,7 +1102,7 @@ static int dfs_cromfs_stat(struct dfs_dentry *dentry, struct stat *st)
 #endif
     }
 
-    st->st_mtime = 0;
+    st->mtime = 0;
 
     return RT_EOK;
 }
@@ -1323,7 +1323,7 @@ static ssize_t dfs_cromfs_page_read(struct dfs_file *file, struct dfs_page *page
 
     if (page->page)
     {
-        off_t fpos = page->fpos;
+        dfs_off_t fpos = page->fpos;
         ret = dfs_cromfs_read(file, page->page, page->size, &fpos);
     }
 
diff --git a/components/dfs/dfs_v2/filesystems/devfs/devfs.c b/components/dfs/dfs_v2/filesystems/devfs/devfs.c
index 38e9a2e4550..78217e8c6d0 100644
--- a/components/dfs/dfs_v2/filesystems/devfs/devfs.c
+++ b/components/dfs/dfs_v2/filesystems/devfs/devfs.c
@@ -137,7 +137,7 @@ static rt_ubase_t _get_unit_shift(rt_device_t device)
     return shift;
 }
 
-static ssize_t dfs_devfs_read(struct dfs_file *file, void *buf, size_t count, off_t *pos)
+static ssize_t dfs_devfs_read(struct dfs_file *file, void *buf, size_t count, dfs_off_t *pos)
 {
     ssize_t ret = -RT_EIO;
     rt_device_t device;
@@ -173,7 +173,7 @@ static ssize_t dfs_devfs_read(struct dfs_file *file, void *buf, size_t count, of
     return ret;
 }
 
-static ssize_t dfs_devfs_write(struct dfs_file *file, const void *buf, size_t count, off_t *pos)
+static ssize_t dfs_devfs_write(struct dfs_file *file, const void *buf, size_t count, dfs_off_t *pos)
 {
     ssize_t ret = -RT_EIO;
     rt_device_t device;
@@ -298,9 +298,9 @@ static int dfs_devfs_flush(struct dfs_file *file)
     return ret;
 }
 
-static off_t dfs_devfs_lseek(struct dfs_file *file, off_t offset, int wherece)
+static dfs_off_t dfs_devfs_lseek(struct dfs_file *file, dfs_off_t offset, int wherece)
 {
-    off_t ret = -EPERM;
+    dfs_off_t ret = -EPERM;
     rt_device_t device;
 
     RT_ASSERT(file != RT_NULL);
@@ -321,7 +321,7 @@ static off_t dfs_devfs_lseek(struct dfs_file *file, off_t offset, int wherece)
     return ret;
 }
 
-static int dfs_devfs_truncate(struct dfs_file *file, off_t offset)
+static int dfs_devfs_truncate(struct dfs_file *file, dfs_off_t offset)
 {
     int ret = RT_EOK;
     rt_device_t device;
diff --git a/components/dfs/dfs_v2/filesystems/devfs/devtmpfs.c b/components/dfs/dfs_v2/filesystems/devfs/devtmpfs.c
index 82ab422529b..1935e471e6f 100644
--- a/components/dfs/dfs_v2/filesystems/devfs/devtmpfs.c
+++ b/components/dfs/dfs_v2/filesystems/devfs/devtmpfs.c
@@ -188,7 +188,7 @@ static struct devtmpfs_file *devtmpfs_file_lookup(struct devtmpfs_sb *superblock
 {
     const char *subpath, *curpath, *filename = RT_NULL;
     char subdir_name[DIRENT_NAME_MAX];
-    struct devtmpfs_file *file, *curfile, *tmp;
+    struct devtmpfs_file *file = RT_NULL, *curfile, *tmp;
 
     subpath = path;
     while (*subpath == '/' && *subpath)
@@ -223,6 +223,7 @@ static struct devtmpfs_file *devtmpfs_file_lookup(struct devtmpfs_sb *superblock
             if (rt_strcmp(file->name, filename) == 0)
             {
                 rt_spin_unlock(&superblock->lock);
+                /* cppcheck-suppress uninitvar */
                 return file;
             }
         }
@@ -257,7 +258,7 @@ static int devtmpfs_statfs(struct dfs_mnt *mnt, struct statfs *buf)
     return RT_EOK;
 }
 
-static int devtmpfs_stat(struct dfs_dentry *dentry, struct stat *st)
+static int devtmpfs_stat(struct dfs_dentry *dentry, struct dfs_stat *st)
 {
     struct dfs_vnode *vnode;
 
@@ -266,19 +267,16 @@ static int devtmpfs_stat(struct dfs_dentry *dentry, struct stat *st)
         vnode = dentry->vnode;
 
         st->st_dev = (dev_t)(long)(dentry->mnt->dev_id);
-        st->st_ino = (ino_t)dfs_dentry_full_path_crc32(dentry);
+        st->st_ino = (uint16_t)dfs_dentry_full_path_crc32(dentry);
 
         st->st_gid = vnode->gid;
         st->st_uid = vnode->uid;
         st->st_mode = vnode->mode;
         st->st_nlink = vnode->nlink;
         st->st_size = vnode->size;
-        st->st_mtim.tv_nsec = vnode->mtime.tv_nsec;
-        st->st_mtim.tv_sec = vnode->mtime.tv_sec;
-        st->st_ctim.tv_nsec = vnode->ctime.tv_nsec;
-        st->st_ctim.tv_sec = vnode->ctime.tv_sec;
-        st->st_atim.tv_nsec = vnode->atime.tv_nsec;
-        st->st_atim.tv_sec = vnode->atime.tv_sec;
+        st->mtime = vnode->mtime.tv_sec;
+        st->ctime = vnode->ctime.tv_sec;
+        st->atime = vnode->atime.tv_sec;
     }
 
     return RT_EOK;
diff --git a/components/dfs/dfs_v2/filesystems/elmfat/dfs_elm.c b/components/dfs/dfs_v2/filesystems/elmfat/dfs_elm.c
index 90b87a178b4..03870f6a335 100644
--- a/components/dfs/dfs_v2/filesystems/elmfat/dfs_elm.c
+++ b/components/dfs/dfs_v2/filesystems/elmfat/dfs_elm.c
@@ -38,7 +38,7 @@
 
 
 static int dfs_elm_free_vnode(struct dfs_vnode *vnode);
-static int dfs_elm_truncate(struct dfs_file *file, off_t offset);
+static int dfs_elm_truncate(struct dfs_file *file, dfs_off_t offset);
 
 #ifdef RT_USING_PAGECACHE
 static ssize_t dfs_elm_page_read(struct dfs_file *file, struct dfs_page *page);
@@ -549,7 +549,7 @@ int dfs_elm_ioctl(struct dfs_file *file, int cmd, void *args)
     {
     case RT_FIOFTRUNCATE:
     {
-        off_t offset = (off_t)(size_t)(args);
+        dfs_off_t offset = *(dfs_off_t *)args;
         return dfs_elm_truncate(file, offset);
     }
     case F_GETLK:
@@ -560,7 +560,7 @@ int dfs_elm_ioctl(struct dfs_file *file, int cmd, void *args)
     return -ENOSYS;
 }
 
-ssize_t dfs_elm_read(struct dfs_file *file, void *buf, size_t len, off_t *pos)
+ssize_t dfs_elm_read(struct dfs_file *file, void *buf, size_t len, dfs_off_t *pos)
 {
     FIL *fd;
     FRESULT result = FR_OK;
@@ -576,7 +576,12 @@ ssize_t dfs_elm_read(struct dfs_file *file, void *buf, size_t len, off_t *pos)
         fd = (FIL *)(file->vnode->data);
         RT_ASSERT(fd != RT_NULL);
         rt_mutex_take(&file->vnode->lock, RT_WAITING_FOREVER);
-        f_lseek(fd, *pos);
+        if (*pos < 0 || (dfs_off_t)(FSIZE_t)*pos != *pos)
+        {
+            rt_mutex_release(&file->vnode->lock);
+            return -EINVAL;
+        }
+        f_lseek(fd, (FSIZE_t)*pos);
         result = f_read(fd, buf, len, &byte_read);
         /* update position */
         *pos = fd->fptr;
@@ -588,7 +593,7 @@ ssize_t dfs_elm_read(struct dfs_file *file, void *buf, size_t len, off_t *pos)
     return elm_result_to_dfs(result);
 }
 
-ssize_t dfs_elm_write(struct dfs_file *file, const void *buf, size_t len, off_t *pos)
+ssize_t dfs_elm_write(struct dfs_file *file, const void *buf, size_t len, dfs_off_t *pos)
 {
     FIL *fd;
     FRESULT result;
@@ -602,7 +607,12 @@ ssize_t dfs_elm_write(struct dfs_file *file, const void *buf, size_t len, off_t
     fd = (FIL *)(file->vnode->data);
     RT_ASSERT(fd != RT_NULL);
     rt_mutex_take(&file->vnode->lock, RT_WAITING_FOREVER);
-    f_lseek(fd, *pos);
+    if (*pos < 0 || (dfs_off_t)(FSIZE_t)*pos != *pos)
+    {
+        rt_mutex_release(&file->vnode->lock);
+        return -EINVAL;
+    }
+    f_lseek(fd, (FSIZE_t)*pos);
     result = f_write(fd, buf, len, &byte_write);
     /* update position and file size */
     *pos = fd->fptr;
@@ -626,10 +636,10 @@ int dfs_elm_flush(struct dfs_file *file)
     return elm_result_to_dfs(result);
 }
 
-off_t dfs_elm_lseek(struct dfs_file *file, off_t offset, int wherece)
+dfs_off_t dfs_elm_lseek(struct dfs_file *file, dfs_off_t offset, int wherece)
 {
     FRESULT result = FR_OK;
-    off_t pos = 0;
+    dfs_off_t pos = 0;
     switch (wherece)
     {
     case SEEK_SET:
@@ -647,6 +657,11 @@ off_t dfs_elm_lseek(struct dfs_file *file, off_t offset, int wherece)
         return -EINVAL;
     }
 
+    if (offset < 0 || (dfs_off_t)(FSIZE_t)offset != offset)
+    {
+        return -EINVAL;
+    }
+
     if (file->vnode->type == FT_REGULAR)
     {
         FIL *fd;
@@ -655,7 +670,7 @@ off_t dfs_elm_lseek(struct dfs_file *file, off_t offset, int wherece)
         fd = (FIL *)(file->vnode->data);
         RT_ASSERT(fd != RT_NULL);
         rt_mutex_take(&file->vnode->lock, RT_WAITING_FOREVER);
-        result = f_lseek(fd, offset);
+        result = f_lseek(fd, (FSIZE_t)offset);
         pos = fd->fptr;
         rt_mutex_release(&file->vnode->lock);
         if (result == FR_OK)
@@ -684,24 +699,30 @@ off_t dfs_elm_lseek(struct dfs_file *file, off_t offset, int wherece)
     return elm_result_to_dfs(result);
 }
 
-static int dfs_elm_truncate(struct dfs_file *file, off_t offset)
+static int dfs_elm_truncate(struct dfs_file *file, dfs_off_t offset)
 {
     FIL *fd;
-    FSIZE_t fptr;
+    FSIZE_t fptr, length;
     FRESULT result = FR_OK;
     fd = (FIL *)(file->vnode->data);
     RT_ASSERT(fd != RT_NULL);
 
+    if (offset < 0 || (dfs_off_t)(FSIZE_t)offset != offset)
+    {
+        return -EINVAL;
+    }
+    length = (FSIZE_t)offset;
+
     /* save file read/write point */
     fptr = fd->fptr;
-    if (offset <= fd->obj.objsize)
+    if (length <= fd->obj.objsize)
     {
-        fd->fptr = offset;
+        fd->fptr = length;
         result = f_truncate(fd);
     }
     else
     {
-        result = f_lseek(fd, offset);
+        result = f_lseek(fd, length);
     }
     /* restore file read/write point */
     fd->fptr = fptr;
@@ -829,7 +850,7 @@ int dfs_elm_rename(struct dfs_dentry *old_dentry, struct dfs_dentry *new_dentry)
     return elm_result_to_dfs(result);
 }
 
-int dfs_elm_stat(struct dfs_dentry *dentry, struct stat *st)
+int dfs_elm_stat(struct dfs_dentry *dentry, struct dfs_stat *st)
 {
     FATFS  *fat;
     FILINFO file_info;
@@ -864,7 +885,7 @@ int dfs_elm_stat(struct dfs_dentry *dentry, struct stat *st)
     {
         /* convert to dfs stat structure */
         st->st_dev = (dev_t)(size_t)(dentry->mnt->dev_id);
-        st->st_ino = (ino_t)dfs_dentry_full_path_crc32(dentry);
+        st->st_ino = (uint16_t)dfs_dentry_full_path_crc32(dentry);
 
         if (file_info.fattrib & AM_DIR)
         {
@@ -929,7 +950,7 @@ int dfs_elm_stat(struct dfs_dentry *dentry, struct stat *st)
             tm_file.tm_min  = min;         /* Minutes: 0-59 */
             tm_file.tm_sec  = sec;         /* Seconds: 0-59 */
 
-            st->st_mtime = timegm(&tm_file);
+            st->mtime = timegm(&tm_file);
         } /* get st_mtime. */
     }
 
@@ -938,7 +959,7 @@ int dfs_elm_stat(struct dfs_dentry *dentry, struct stat *st)
 
 static struct dfs_vnode *dfs_elm_lookup(struct dfs_dentry *dentry)
 {
-    struct stat st;
+    struct dfs_stat st;
     struct dfs_vnode *vnode = RT_NULL;
 
     if (dentry == NULL || dentry->mnt == NULL || dentry->mnt->data == NULL)
@@ -1030,7 +1051,7 @@ static ssize_t dfs_elm_page_read(struct dfs_file *file, struct dfs_page *page)
 
     if (page->page)
     {
-        off_t fpos = page->fpos;
+        dfs_off_t fpos = page->fpos;
         ret = dfs_elm_read(file, page->page, page->size, &fpos);
     }
 
@@ -1051,7 +1072,7 @@ ssize_t dfs_elm_page_write(struct dfs_page *page)
     fd = (FIL *)(page->aspace->vnode->data);
     RT_ASSERT(fd != RT_NULL);
     rt_mutex_take(&page->aspace->vnode->lock, RT_WAITING_FOREVER);
-    f_lseek(fd, page->fpos);
+    f_lseek(fd, (FSIZE_t)page->fpos);
     result = f_write(fd, page->page, page->len, &byte_write);
     rt_mutex_release(&page->aspace->vnode->lock);
     if (result == FR_OK)
diff --git a/components/dfs/dfs_v2/filesystems/mqueue/dfs_mqueue.c b/components/dfs/dfs_v2/filesystems/mqueue/dfs_mqueue.c
index 4546455a31e..57175ba862d 100644
--- a/components/dfs/dfs_v2/filesystems/mqueue/dfs_mqueue.c
+++ b/components/dfs/dfs_v2/filesystems/mqueue/dfs_mqueue.c
@@ -63,7 +63,7 @@ int dfs_mqueue_open(struct dfs_file *file) {
     return 0;
 }
 
-int dfs_mqueue_stat(struct dfs_dentry *dentry, struct stat *st) {
+int dfs_mqueue_stat(struct dfs_dentry *dentry, struct dfs_stat *st) {
     struct dfs_vnode *vnode = RT_NULL;
     if (dentry && dentry->vnode) {
         vnode = dentry->vnode;
@@ -74,12 +74,9 @@ int dfs_mqueue_stat(struct dfs_dentry *dentry, struct stat *st) {
         st->st_mode = vnode->mode;
         st->st_nlink = vnode->nlink;
         st->st_size = vnode->size;
-        st->st_mtim.tv_nsec = vnode->mtime.tv_nsec;
-        st->st_mtim.tv_sec = vnode->mtime.tv_sec;
-        st->st_ctim.tv_nsec = vnode->ctime.tv_nsec;
-        st->st_ctim.tv_sec = vnode->ctime.tv_sec;
-        st->st_atim.tv_nsec = vnode->atime.tv_nsec;
-        st->st_atim.tv_sec = vnode->atime.tv_sec;
+        st->mtime = vnode->mtime.tv_sec;
+        st->ctime = vnode->ctime.tv_sec;
+        st->atime = vnode->atime.tv_sec;
     }
     return RT_EOK;
 }
diff --git a/components/dfs/dfs_v2/filesystems/procfs/proc.c b/components/dfs/dfs_v2/filesystems/procfs/proc.c
index 0e0d2025da9..4cc3ffc0edd 100644
--- a/components/dfs/dfs_v2/filesystems/procfs/proc.c
+++ b/components/dfs/dfs_v2/filesystems/procfs/proc.c
@@ -133,12 +133,12 @@ static int proc_find(struct proc_dentry **parent, const char **name, rt_bool_t f
     return ret;
 }
 
-static void *single_start(struct dfs_seq_file *seq, off_t *index)
+static void *single_start(struct dfs_seq_file *seq, dfs_off_t *index)
 {
     return NULL + (*index == 0);
 }
 
-static void *single_next(struct dfs_seq_file *seq, void *data, off_t *index)
+static void *single_next(struct dfs_seq_file *seq, void *data, dfs_off_t *index)
 {
     ++*index;
     return NULL;
diff --git a/components/dfs/dfs_v2/filesystems/procfs/proc_cpuinfo.c b/components/dfs/dfs_v2/filesystems/procfs/proc_cpuinfo.c
index 6f498329928..b3e8eeab5eb 100644
--- a/components/dfs/dfs_v2/filesystems/procfs/proc_cpuinfo.c
+++ b/components/dfs/dfs_v2/filesystems/procfs/proc_cpuinfo.c
@@ -18,9 +18,9 @@
 
 #include <dfs_dentry.h>
 
-static void *seq_start(struct dfs_seq_file *seq, off_t *index)
+static void *seq_start(struct dfs_seq_file *seq, dfs_off_t *index)
 {
-    off_t i = *index; // seq->index
+    dfs_off_t i = *index; // seq->index
 
     return NULL + (i == 0);
 }
@@ -29,10 +29,10 @@ static void seq_stop(struct dfs_seq_file *seq, void *data)
 {
 }
 
-static void *seq_next(struct dfs_seq_file *seq, void *data, off_t *index)
+static void *seq_next(struct dfs_seq_file *seq, void *data, dfs_off_t *index)
 {
     /* data: The return value of the start or next*/
-    off_t i = *index + 1; // seq->index
+    dfs_off_t i = *index + 1; // seq->index
 
     *index = i;
 
diff --git a/components/dfs/dfs_v2/filesystems/procfs/proc_devices.c b/components/dfs/dfs_v2/filesystems/procfs/proc_devices.c
index 7bd07187d09..cfd1f11bf7a 100644
--- a/components/dfs/dfs_v2/filesystems/procfs/proc_devices.c
+++ b/components/dfs/dfs_v2/filesystems/procfs/proc_devices.c
@@ -257,9 +257,9 @@ static int show_info(struct dfs_seq_file *seq)
     return 0;
 }
 
-static void *seq_start(struct dfs_seq_file *seq, off_t *index)
+static void *seq_start(struct dfs_seq_file *seq, dfs_off_t *index)
 {
-    off_t i = *index; // seq->index
+    dfs_off_t i = *index; // seq->index
 
     return NULL + (i == 0);
 }
@@ -268,10 +268,10 @@ static void seq_stop(struct dfs_seq_file *seq, void *data)
 {
 }
 
-static void *seq_next(struct dfs_seq_file *seq, void *data, off_t *index)
+static void *seq_next(struct dfs_seq_file *seq, void *data, dfs_off_t *index)
 {
     /* data: The return value of the start or next*/
-    off_t i = *index + 1; // seq->index
+    dfs_off_t i = *index + 1; // seq->index
 
     *index = i;
 
diff --git a/components/dfs/dfs_v2/filesystems/procfs/proc_filesystems.c b/components/dfs/dfs_v2/filesystems/procfs/proc_filesystems.c
index 94e7a858d5a..c9601cd08f3 100644
--- a/components/dfs/dfs_v2/filesystems/procfs/proc_filesystems.c
+++ b/components/dfs/dfs_v2/filesystems/procfs/proc_filesystems.c
@@ -19,9 +19,9 @@
 #include <dfs_dentry.h>
 #include <dfs_fs.h>
 
-static void *seq_start(struct dfs_seq_file *seq, off_t *index)
+static void *seq_start(struct dfs_seq_file *seq, dfs_off_t *index)
 {
-    off_t i = *index; // seq->index
+    dfs_off_t i = *index; // seq->index
     struct dfs_filesystem_type *fs = dfs_filesystems();
 
     if (fs)
@@ -43,10 +43,10 @@ static void seq_stop(struct dfs_seq_file *seq, void *data)
 {
 }
 
-static void *seq_next(struct dfs_seq_file *seq, void *data, off_t *index)
+static void *seq_next(struct dfs_seq_file *seq, void *data, dfs_off_t *index)
 {
     /* data: The return value of the start or next*/
-    off_t i = *index + 1; // seq->index
+    dfs_off_t i = *index + 1; // seq->index
     struct dfs_filesystem_type *fs = (struct dfs_filesystem_type *)data;
 
     *index = i;
diff --git a/components/dfs/dfs_v2/filesystems/procfs/proc_mounts.c b/components/dfs/dfs_v2/filesystems/procfs/proc_mounts.c
index 49a6ba99c6b..9a79194d67b 100644
--- a/components/dfs/dfs_v2/filesystems/procfs/proc_mounts.c
+++ b/components/dfs/dfs_v2/filesystems/procfs/proc_mounts.c
@@ -51,9 +51,9 @@ static struct dfs_mnt* mnt_show(struct dfs_mnt *mnt, void *parameter)
     return RT_NULL;
 }
 
-static void *seq_start(struct dfs_seq_file *seq, off_t *index)
+static void *seq_start(struct dfs_seq_file *seq, dfs_off_t *index)
 {
-    off_t i = *index; // seq->index
+    dfs_off_t i = *index; // seq->index
 
     return NULL + (i == 0);
 }
@@ -62,10 +62,10 @@ static void seq_stop(struct dfs_seq_file *seq, void *data)
 {
 }
 
-static void *seq_next(struct dfs_seq_file *seq, void *data, off_t *index)
+static void *seq_next(struct dfs_seq_file *seq, void *data, dfs_off_t *index)
 {
     /* data: The return value of the start or next*/
-    off_t i = *index + 1; // seq->index
+    dfs_off_t i = *index + 1; // seq->index
 
     *index = i;
 
diff --git a/components/dfs/dfs_v2/filesystems/procfs/proc_net.c b/components/dfs/dfs_v2/filesystems/procfs/proc_net.c
index 76707beffb2..2869548b222 100644
--- a/components/dfs/dfs_v2/filesystems/procfs/proc_net.c
+++ b/components/dfs/dfs_v2/filesystems/procfs/proc_net.c
@@ -26,9 +26,9 @@
 extern int inet_route_foreach(void (*func)(const char *name, uint32_t ip_addr, uint32_t netmask, void *parameter), void *parameter);
 #endif
 
-static void *seq_start(struct dfs_seq_file *seq, off_t *index)
+static void *seq_start(struct dfs_seq_file *seq, dfs_off_t *index)
 {
-    off_t i = *index; // seq->index
+    dfs_off_t i = *index; // seq->index
 
     return NULL + (i == 0);
 }
@@ -37,10 +37,10 @@ static void seq_stop(struct dfs_seq_file *seq, void *data)
 {
 }
 
-static void *seq_next(struct dfs_seq_file *seq, void *data, off_t *index)
+static void *seq_next(struct dfs_seq_file *seq, void *data, dfs_off_t *index)
 {
     /* data: The return value of the start or next*/
-    off_t i = *index + 1; // seq->index
+    dfs_off_t i = *index + 1; // seq->index
 
     *index = i;
 
diff --git a/components/dfs/dfs_v2/filesystems/procfs/proc_partitions.c b/components/dfs/dfs_v2/filesystems/procfs/proc_partitions.c
index 1c7a48a3651..6efc35cc47e 100644
--- a/components/dfs/dfs_v2/filesystems/procfs/proc_partitions.c
+++ b/components/dfs/dfs_v2/filesystems/procfs/proc_partitions.c
@@ -164,9 +164,9 @@ static int show_info(struct dfs_seq_file *seq)
     return 0;
 }
 
-static void *seq_start(struct dfs_seq_file *seq, off_t *index)
+static void *seq_start(struct dfs_seq_file *seq, dfs_off_t *index)
 {
-    off_t i = *index; // seq->index
+    dfs_off_t i = *index; // seq->index
 
     return NULL + (i == 0);
 }
@@ -175,10 +175,10 @@ static void seq_stop(struct dfs_seq_file *seq, void *data)
 {
 }
 
-static void *seq_next(struct dfs_seq_file *seq, void *data, off_t *index)
+static void *seq_next(struct dfs_seq_file *seq, void *data, dfs_off_t *index)
 {
     /* data: The return value of the start or next*/
-    off_t i = *index + 1; // seq->index
+    dfs_off_t i = *index + 1; // seq->index
 
     *index = i;
 
diff --git a/components/dfs/dfs_v2/filesystems/procfs/proc_stat.c b/components/dfs/dfs_v2/filesystems/procfs/proc_stat.c
index aeba99de513..d5d744ed9a1 100644
--- a/components/dfs/dfs_v2/filesystems/procfs/proc_stat.c
+++ b/components/dfs/dfs_v2/filesystems/procfs/proc_stat.c
@@ -19,9 +19,9 @@
 #include <dfs_dentry.h>
 
 
-static void *seq_start(struct dfs_seq_file *seq, off_t *index)
+static void *seq_start(struct dfs_seq_file *seq, dfs_off_t *index)
 {
-    off_t i = *index; // seq->index
+    dfs_off_t i = *index; // seq->index
 
     return NULL + (i == 0);
 }
@@ -30,10 +30,10 @@ static void seq_stop(struct dfs_seq_file *seq, void *data)
 {
 }
 
-static void *seq_next(struct dfs_seq_file *seq, void *data, off_t *index)
+static void *seq_next(struct dfs_seq_file *seq, void *data, dfs_off_t *index)
 {
     /* data: The return value of the start or next*/
-    off_t i = *index + 1; // seq->index
+    dfs_off_t i = *index + 1; // seq->index
 
     *index = i;
 
diff --git a/components/dfs/dfs_v2/filesystems/procfs/proc_tty.c b/components/dfs/dfs_v2/filesystems/procfs/proc_tty.c
index dc77e4cecb6..79743f68c69 100644
--- a/components/dfs/dfs_v2/filesystems/procfs/proc_tty.c
+++ b/components/dfs/dfs_v2/filesystems/procfs/proc_tty.c
@@ -19,9 +19,9 @@
 #include <dfs_dentry.h>
 
 
-static void *seq_start(struct dfs_seq_file *seq, off_t *index)
+static void *seq_start(struct dfs_seq_file *seq, dfs_off_t *index)
 {
-    off_t i = *index; // seq->index
+    dfs_off_t i = *index; // seq->index
 
     return NULL + (i == 0);
 }
@@ -30,10 +30,10 @@ static void seq_stop(struct dfs_seq_file *seq, void *data)
 {
 }
 
-static void *seq_next(struct dfs_seq_file *seq, void *data, off_t *index)
+static void *seq_next(struct dfs_seq_file *seq, void *data, dfs_off_t *index)
 {
     /* data: The return value of the start or next*/
-    off_t i = *index + 1; // seq->index
+    dfs_off_t i = *index + 1; // seq->index
 
     *index = i;
 
diff --git a/components/dfs/dfs_v2/filesystems/procfs/procfs.c b/components/dfs/dfs_v2/filesystems/procfs/procfs.c
index 8cba8ed48c6..bbf4a5ae580 100644
--- a/components/dfs/dfs_v2/filesystems/procfs/procfs.c
+++ b/components/dfs/dfs_v2/filesystems/procfs/procfs.c
@@ -71,7 +71,7 @@ static int dfs_procfs_close(struct dfs_file *file)
     return ret;
 }
 
-static ssize_t dfs_procfs_read(struct dfs_file *file, void *buf, size_t count, off_t *pos)
+static ssize_t dfs_procfs_read(struct dfs_file *file, void *buf, size_t count, dfs_off_t *pos)
 {
     ssize_t ret = -RT_ERROR;
     struct proc_dentry *entry = (struct proc_dentry *)file->vnode->data;
@@ -86,7 +86,7 @@ static ssize_t dfs_procfs_read(struct dfs_file *file, void *buf, size_t count, o
     return ret;
 }
 
-static ssize_t dfs_procfs_write(struct dfs_file *file, const void *buf, size_t count, off_t *pos)
+static ssize_t dfs_procfs_write(struct dfs_file *file, const void *buf, size_t count, dfs_off_t *pos)
 {
     ssize_t ret = -RT_ERROR;
     struct proc_dentry *entry = (struct proc_dentry *)file->vnode->data;
@@ -284,7 +284,7 @@ static int dfs_procfs_unlink(struct dfs_dentry *dentry)
     return -RT_ERROR;
 }
 
-static int dfs_procfs_stat(struct dfs_dentry *dentry, struct stat *st)
+static int dfs_procfs_stat(struct dfs_dentry *dentry, struct dfs_stat *st)
 {
     int ret = RT_EOK;
     struct dfs_vnode *vnode;
@@ -294,19 +294,16 @@ static int dfs_procfs_stat(struct dfs_dentry *dentry, struct stat *st)
         vnode = dentry->vnode;
 
         st->st_dev = (dev_t)(rt_ubase_t)(dentry->mnt->dev_id);
-        st->st_ino = (ino_t)dfs_dentry_full_path_crc32(dentry);
+        st->st_ino = (uint16_t)dfs_dentry_full_path_crc32(dentry);
 
         st->st_gid = vnode->gid;
         st->st_uid = vnode->uid;
         st->st_mode = vnode->mode;
         st->st_nlink = vnode->nlink;
         st->st_size = vnode->size;
-        st->st_mtim.tv_nsec = vnode->mtime.tv_nsec;
-        st->st_mtim.tv_sec = vnode->mtime.tv_sec;
-        st->st_ctim.tv_nsec = vnode->ctime.tv_nsec;
-        st->st_ctim.tv_sec = vnode->ctime.tv_sec;
-        st->st_atim.tv_nsec = vnode->atime.tv_nsec;
-        st->st_atim.tv_sec = vnode->atime.tv_sec;
+        st->mtime = vnode->mtime.tv_sec;
+        st->ctime = vnode->ctime.tv_sec;
+        st->atime = vnode->atime.tv_sec;
     }
 
     PROC_DEBUG(" %s %d >> %s ret: %d\n", __func__, __LINE__, dentry->pathname, ret);
@@ -423,7 +420,7 @@ int dfs_procfs_init(void)
 }
 INIT_COMPONENT_EXPORT(dfs_procfs_init);
 
-int proc_read_data(struct dfs_file *file, void *buf, size_t count, off_t *pos)
+int proc_read_data(struct dfs_file *file, void *buf, size_t count, dfs_off_t *pos)
 {
     if (file->fpos >= file->vnode->size)
     {
diff --git a/components/dfs/dfs_v2/filesystems/procfs/procfs.h b/components/dfs/dfs_v2/filesystems/procfs/procfs.h
index 6e921ae300f..8b85177734e 100644
--- a/components/dfs/dfs_v2/filesystems/procfs/procfs.h
+++ b/components/dfs/dfs_v2/filesystems/procfs/procfs.h
@@ -14,6 +14,6 @@
 
 int dfs_procfs_init(void);
 
-int proc_read_data(struct dfs_file *file, void *buf, size_t count, off_t *pos);
+int proc_read_data(struct dfs_file *file, void *buf, size_t count, dfs_off_t *pos);
 
 #endif
diff --git a/components/dfs/dfs_v2/filesystems/ptyfs/ptyfs.c b/components/dfs/dfs_v2/filesystems/ptyfs/ptyfs.c
index 75bffdf510d..aa8a430848b 100644
--- a/components/dfs/dfs_v2/filesystems/ptyfs/ptyfs.c
+++ b/components/dfs/dfs_v2/filesystems/ptyfs/ptyfs.c
@@ -427,7 +427,7 @@ static int ptyfs_ops_statfs(struct dfs_mnt *mnt, struct statfs *buf)
     return RT_EOK;
 }
 
-static int ptyfs_ops_stat(struct dfs_dentry *dentry, struct stat *st)
+static int ptyfs_ops_stat(struct dfs_dentry *dentry, struct dfs_stat *st)
 {
     struct dfs_vnode *vnode;
 
@@ -437,19 +437,16 @@ static int ptyfs_ops_stat(struct dfs_dentry *dentry, struct stat *st)
 
         /* device id ? */
         st->st_dev = (dev_t)(long)(dentry->mnt->dev_id);
-        st->st_ino = (ino_t)dfs_dentry_full_path_crc32(dentry);
+        st->st_ino = (uint16_t)dfs_dentry_full_path_crc32(dentry);
 
         st->st_gid = vnode->gid;
         st->st_uid = vnode->uid;
         st->st_mode = vnode->mode;
         st->st_nlink = vnode->nlink;
         st->st_size = vnode->size;
-        st->st_mtim.tv_nsec = vnode->mtime.tv_nsec;
-        st->st_mtim.tv_sec = vnode->mtime.tv_sec;
-        st->st_ctim.tv_nsec = vnode->ctime.tv_nsec;
-        st->st_ctim.tv_sec = vnode->ctime.tv_sec;
-        st->st_atim.tv_nsec = vnode->atime.tv_nsec;
-        st->st_atim.tv_sec = vnode->atime.tv_sec;
+        st->mtime = vnode->mtime.tv_sec;
+        st->ctime = vnode->ctime.tv_sec;
+        st->atime = vnode->atime.tv_sec;
     }
 
     return 0;
diff --git a/components/dfs/dfs_v2/filesystems/ramfs/dfs_ramfs.c b/components/dfs/dfs_v2/filesystems/ramfs/dfs_ramfs.c
index fd7326bd018..ab3a7a60c80 100644
--- a/components/dfs/dfs_v2/filesystems/ramfs/dfs_ramfs.c
+++ b/components/dfs/dfs_v2/filesystems/ramfs/dfs_ramfs.c
@@ -13,13 +13,15 @@
 #include <rtthread.h>
 #include <dfs.h>
 #include <dfs_fs.h>
+#include <dfs_dentry.h>
 #include <dfs_file.h>
+#include <dfs_mnt.h>
 
 #include "dfs_ramfs.h"
 
-int dfs_ramfs_mount(struct dfs_filesystem *fs,
-                    unsigned long          rwflag,
-                    const void            *data)
+int dfs_ramfs_mount(struct dfs_mnt *mnt,
+                    unsigned long rwflag,
+                    const void *data)
 {
     struct dfs_ramfs *ramfs;
 
@@ -27,23 +29,23 @@ int dfs_ramfs_mount(struct dfs_filesystem *fs,
         return -EIO;
 
     ramfs = (struct dfs_ramfs *)data;
-    fs->data = ramfs;
+    mnt->data = ramfs;
 
     return RT_EOK;
 }
 
-int dfs_ramfs_unmount(struct dfs_filesystem *fs)
+int dfs_ramfs_unmount(struct dfs_mnt *mnt)
 {
-    fs->data = NULL;
+    mnt->data = NULL;
 
     return RT_EOK;
 }
 
-int dfs_ramfs_statfs(struct dfs_filesystem *fs, struct statfs *buf)
+int dfs_ramfs_statfs(struct dfs_mnt *mnt, struct statfs *buf)
 {
     struct dfs_ramfs *ramfs;
 
-    ramfs = (struct dfs_ramfs *)fs->data;
+    ramfs = (struct dfs_ramfs *)mnt->data;
     RT_ASSERT(ramfs != NULL);
     RT_ASSERT(buf != NULL);
 
@@ -92,43 +94,43 @@ struct ramfs_dirent *dfs_ramfs_lookup(struct dfs_ramfs *ramfs,
     return NULL;
 }
 
-int dfs_ramfs_read(struct dfs_file *file, void *buf, size_t count)
+ssize_t dfs_ramfs_read(struct dfs_file *file, void *buf, size_t count, dfs_off_t *pos)
 {
-    rt_size_t length;
+    ssize_t length;
     struct ramfs_dirent *dirent;
 
     dirent = (struct ramfs_dirent *)file->vnode->data;
     RT_ASSERT(dirent != NULL);
 
-    if (count < file->vnode->size - file->pos)
+    if ((dfs_off_t)count < file->vnode->size - *pos)
         length = count;
     else
-        length = file->vnode->size - file->pos;
+        length = file->vnode->size - *pos;
 
     if (length > 0)
-        rt_memcpy(buf, &(dirent->data[file->pos]), length);
+        rt_memcpy(buf, &(dirent->data[*pos]), length);
 
     /* update file current position */
-    file->pos += length;
+    *pos += length;
 
     return length;
 }
 
-int dfs_ramfs_write(struct dfs_file *fd, const void *buf, size_t count)
+ssize_t dfs_ramfs_write(struct dfs_file *file, const void *buf, size_t count, dfs_off_t *pos)
 {
     struct ramfs_dirent *dirent;
     struct dfs_ramfs *ramfs;
 
-    dirent = (struct ramfs_dirent *)fd->vnode->data;
+    dirent = (struct ramfs_dirent *)file->vnode->data;
     RT_ASSERT(dirent != NULL);
 
     ramfs = dirent->fs;
     RT_ASSERT(ramfs != NULL);
 
-    if (count + fd->pos > fd->vnode->size)
+    if ((dfs_off_t)count + *pos > file->vnode->size)
     {
         rt_uint8_t *ptr;
-        ptr = rt_memheap_realloc(&(ramfs->memheap), dirent->data, fd->pos + count);
+        ptr = rt_memheap_realloc(&(ramfs->memheap), dirent->data, *pos + count);
         if (ptr == NULL)
         {
             rt_set_errno(-ENOMEM);
@@ -138,26 +140,41 @@ int dfs_ramfs_write(struct dfs_file *fd, const void *buf, size_t count)
 
         /* update dirent and file size */
         dirent->data = ptr;
-        dirent->size = fd->pos + count;
-        fd->vnode->size = dirent->size;
+        dirent->size = *pos + count;
+        file->vnode->size = dirent->size;
     }
 
     if (count > 0)
-        rt_memcpy(dirent->data + fd->pos, buf, count);
+        rt_memcpy(dirent->data + *pos, buf, count);
 
     /* update file current position */
-    fd->pos += count;
+    *pos += count;
 
     return count;
 }
 
-int dfs_ramfs_lseek(struct dfs_file *file, off_t offset)
+dfs_off_t dfs_ramfs_lseek(struct dfs_file *file, dfs_off_t offset, int wherece)
 {
-    if (offset <= (off_t)file->vnode->size)
+    switch (wherece)
     {
-        file->pos = offset;
+    case SEEK_SET:
+        break;
+
+    case SEEK_CUR:
+        offset += file->fpos;
+        break;
 
-        return file->pos;
+    case SEEK_END:
+        offset += file->vnode->size;
+        break;
+
+    default:
+        return -EINVAL;
+    }
+
+    if (offset <= (dfs_off_t)file->vnode->size)
+    {
+        return offset;
     }
 
     return -EIO;
@@ -181,7 +198,6 @@ int dfs_ramfs_open(struct dfs_file *file)
     rt_size_t size;
     struct dfs_ramfs *ramfs;
     struct ramfs_dirent *dirent;
-    struct dfs_filesystem *fs;
 
     RT_ASSERT(file->vnode->ref_count > 0);
     if (file->vnode->ref_count > 1)
@@ -191,13 +207,11 @@ int dfs_ramfs_open(struct dfs_file *file)
         {
             return -ENOENT;
         }
-        file->pos = 0;
+        file->fpos = 0;
         return 0;
     }
 
-    fs = file->vnode->fs;
-
-    ramfs = (struct dfs_ramfs *)fs->data;
+    ramfs = (struct dfs_ramfs *)file->vnode->mnt->data;
     RT_ASSERT(ramfs != NULL);
 
     if (file->flags & O_DIRECTORY)
@@ -208,7 +222,7 @@ int dfs_ramfs_open(struct dfs_file *file)
         }
 
         /* open directory */
-        dirent = dfs_ramfs_lookup(ramfs, file->vnode->path, &size);
+        dirent = dfs_ramfs_lookup(ramfs, file->dentry->pathname, &size);
         if (dirent == NULL)
             return -ENOENT;
         if (dirent == &(ramfs->root)) /* it's root directory */
@@ -222,7 +236,7 @@ int dfs_ramfs_open(struct dfs_file *file)
     }
     else
     {
-        dirent = dfs_ramfs_lookup(ramfs, file->vnode->path, &size);
+        dirent = dfs_ramfs_lookup(ramfs, file->dentry->pathname, &size);
         if (dirent == &(ramfs->root)) /* it's root directory */
         {
             return -ENOENT;
@@ -244,7 +258,7 @@ int dfs_ramfs_open(struct dfs_file *file)
                 }
 
                 /* remove '/' separator */
-                name_ptr = file->vnode->path;
+                name_ptr = file->dentry->pathname;
                 while (*name_ptr == '/' && *name_ptr)
                 {
                     name_ptr++;
@@ -282,26 +296,24 @@ int dfs_ramfs_open(struct dfs_file *file)
     file->vnode->size = dirent->size;
     if (file->flags & O_APPEND)
     {
-        file->pos = file->vnode->size;
+        file->fpos = file->vnode->size;
     }
     else
     {
-        file->pos = 0;
+        file->fpos = 0;
     }
 
     return 0;
 }
 
-int dfs_ramfs_stat(struct dfs_filesystem *fs,
-                   const char            *path,
-                   struct stat           *st)
+int dfs_ramfs_stat(struct dfs_dentry *dentry, struct dfs_stat *st)
 {
     rt_size_t size;
     struct ramfs_dirent *dirent;
     struct dfs_ramfs *ramfs;
 
-    ramfs = (struct dfs_ramfs *)fs->data;
-    dirent = dfs_ramfs_lookup(ramfs, path, &size);
+    ramfs = (struct dfs_ramfs *)dentry->mnt->data;
+    dirent = dfs_ramfs_lookup(ramfs, dentry->pathname, &size);
 
     if (dirent == NULL)
         return -ENOENT;
@@ -311,7 +323,7 @@ int dfs_ramfs_stat(struct dfs_filesystem *fs,
                   S_IWUSR | S_IWGRP | S_IWOTH;
 
     st->st_size = dirent->size;
-    st->st_mtime = 0;
+    st->mtime = 0;
 
     return RT_EOK;
 }
@@ -338,14 +350,14 @@ int dfs_ramfs_getdents(struct dfs_file *file,
     if (count == 0)
         return -EINVAL;
 
-    end = file->pos + count;
+    end = file->fpos + count;
     index = 0;
     count = 0;
     for (dirent = rt_list_entry(dirent->list.next, struct ramfs_dirent, list);
          dirent != &(ramfs->root) && index < end;
          dirent = rt_list_entry(dirent->list.next, struct ramfs_dirent, list))
     {
-        if (index >= (rt_size_t)file->pos)
+        if (index >= (rt_size_t)file->fpos)
         {
             d = dirp + count;
             d->d_type = DT_REG;
@@ -354,7 +366,7 @@ int dfs_ramfs_getdents(struct dfs_file *file,
             rt_strncpy(d->d_name, dirent->name, RAMFS_NAME_MAX);
 
             count += 1;
-            file->pos += 1;
+            file->fpos += 1;
         }
         index += 1;
     }
@@ -362,16 +374,16 @@ int dfs_ramfs_getdents(struct dfs_file *file,
     return count * sizeof(struct dirent);
 }
 
-int dfs_ramfs_unlink(struct dfs_filesystem *fs, const char *path)
+int dfs_ramfs_unlink(struct dfs_dentry *dentry)
 {
     rt_size_t size;
     struct dfs_ramfs *ramfs;
     struct ramfs_dirent *dirent;
 
-    ramfs = (struct dfs_ramfs *)fs->data;
+    ramfs = (struct dfs_ramfs *)dentry->mnt->data;
     RT_ASSERT(ramfs != NULL);
 
-    dirent = dfs_ramfs_lookup(ramfs, path, &size);
+    dirent = dfs_ramfs_lookup(ramfs, dentry->pathname, &size);
     if (dirent == NULL)
         return -ENOENT;
 
@@ -383,62 +395,63 @@ int dfs_ramfs_unlink(struct dfs_filesystem *fs, const char *path)
     return RT_EOK;
 }
 
-int dfs_ramfs_rename(struct dfs_filesystem *fs,
-                     const char            *oldpath,
-                     const char            *newpath)
+int dfs_ramfs_rename(struct dfs_dentry *old_dentry, struct dfs_dentry *new_dentry)
 {
     struct ramfs_dirent *dirent;
     struct dfs_ramfs *ramfs;
     rt_size_t size;
 
-    ramfs = (struct dfs_ramfs *)fs->data;
+    ramfs = (struct dfs_ramfs *)old_dentry->mnt->data;
     RT_ASSERT(ramfs != NULL);
 
-    dirent = dfs_ramfs_lookup(ramfs, newpath, &size);
+    dirent = dfs_ramfs_lookup(ramfs, new_dentry->pathname, &size);
     if (dirent != NULL)
         return -EEXIST;
 
-    dirent = dfs_ramfs_lookup(ramfs, oldpath, &size);
+    dirent = dfs_ramfs_lookup(ramfs, old_dentry->pathname, &size);
     if (dirent == NULL)
         return -ENOENT;
 
-    strncpy(dirent->name, newpath, RAMFS_NAME_MAX);
+    strncpy(dirent->name, new_dentry->pathname, RAMFS_NAME_MAX);
 
     return RT_EOK;
 }
 
 static const struct dfs_file_ops _ram_fops =
 {
-    dfs_ramfs_open,
-    dfs_ramfs_close,
-    dfs_ramfs_ioctl,
-    dfs_ramfs_read,
-    dfs_ramfs_write,
-    NULL, /* flush */
-    dfs_ramfs_lseek,
-    dfs_ramfs_getdents,
+    .open = dfs_ramfs_open,
+    .close = dfs_ramfs_close,
+    .ioctl = dfs_ramfs_ioctl,
+    .read = dfs_ramfs_read,
+    .write = dfs_ramfs_write,
+    .lseek = dfs_ramfs_lseek,
+    .getdents = dfs_ramfs_getdents,
 };
 
 static const struct dfs_filesystem_ops _ramfs =
 {
-    "ram",
-    DFS_FS_FLAG_DEFAULT,
-    &_ram_fops,
-
-    dfs_ramfs_mount,
-    dfs_ramfs_unmount,
-    NULL, /* mkfs */
-    dfs_ramfs_statfs,
-
-    dfs_ramfs_unlink,
-    dfs_ramfs_stat,
-    dfs_ramfs_rename,
+    .name = "ram",
+    .flags = DFS_FS_FLAG_DEFAULT,
+    .default_fops = &_ram_fops,
+
+    .mount = dfs_ramfs_mount,
+    .umount = dfs_ramfs_unmount,
+    .statfs = dfs_ramfs_statfs,
+
+    .unlink = dfs_ramfs_unlink,
+    .stat = dfs_ramfs_stat,
+    .rename = dfs_ramfs_rename,
+};
+
+static struct dfs_filesystem_type _ramfs_type =
+{
+    .fs_ops = &_ramfs,
 };
 
 int dfs_ramfs_init(void)
 {
     /* register ram file system */
-    dfs_register(&_ramfs);
+    dfs_register(&_ramfs_type);
 
     return 0;
 }
diff --git a/components/dfs/dfs_v2/filesystems/romfs/dfs_romfs.c b/components/dfs/dfs_v2/filesystems/romfs/dfs_romfs.c
index 772e2218ae8..b56867c0705 100644
--- a/components/dfs/dfs_v2/filesystems/romfs/dfs_romfs.c
+++ b/components/dfs/dfs_v2/filesystems/romfs/dfs_romfs.c
@@ -233,7 +233,7 @@ static int dfs_romfs_free_vnode(struct dfs_vnode *vnode)
     return 0;
 }
 
-static ssize_t dfs_romfs_read(struct dfs_file *file, void *buf, size_t count, off_t *pos)
+static ssize_t dfs_romfs_read(struct dfs_file *file, void *buf, size_t count, dfs_off_t *pos)
 {
     rt_size_t length;
     struct romfs_dirent *dirent;
@@ -300,7 +300,7 @@ int dfs_romfs_open(struct dfs_file *file)
     return RT_EOK;
 }
 
-static int dfs_romfs_stat(struct dfs_dentry *dentry, struct stat *st)
+static int dfs_romfs_stat(struct dfs_dentry *dentry, struct dfs_stat *st)
 {
     rt_err_t ret = dfs_file_lock();
     if (ret == RT_EOK)
@@ -309,7 +309,7 @@ static int dfs_romfs_stat(struct dfs_dentry *dentry, struct stat *st)
         st->st_mode = dentry->vnode->mode;
         st->st_size = dentry->vnode->size;
         st->st_nlink = dentry->vnode->nlink;
-        st->st_mtime = 0;
+        st->mtime = 0;
 
         dfs_file_unlock();
     }
diff --git a/components/dfs/dfs_v2/filesystems/skeleton/skeleton.c b/components/dfs/dfs_v2/filesystems/skeleton/skeleton.c
index af2c871dfc3..16c94aacf15 100644
--- a/components/dfs/dfs_v2/filesystems/skeleton/skeleton.c
+++ b/components/dfs/dfs_v2/filesystems/skeleton/skeleton.c
@@ -9,17 +9,19 @@
 
 #include <rtthread.h>
 #include <dfs.h>
+#include <dfs_dentry.h>
 #include <dfs_fs.h>
 #include <dfs_file.h>
+#include <dfs_mnt.h>
 
 #include "dfs_skt_fs.h"
 
-int dfs_skt_mount(struct dfs_filesystem *fs, unsigned long rwflag, const void *data)
+int dfs_skt_mount(struct dfs_mnt *mnt, unsigned long rwflag, const void *data)
 {
     return RT_EOK;
 }
 
-int dfs_skt_unmount(struct dfs_filesystem *fs)
+int dfs_skt_unmount(struct dfs_mnt *mnt)
 {
     return RT_EOK;
 }
@@ -29,12 +31,12 @@ int dfs_skt_ioctl(struct dfs_file *file, int cmd, void *args)
     return -RT_EIO;
 }
 
-int dfs_skt_read(struct dfs_file *file, void *buf, rt_size_t count)
+ssize_t dfs_skt_read(struct dfs_file *file, void *buf, size_t count, dfs_off_t *pos)
 {
     return count;
 }
 
-int dfs_skt_lseek(struct dfs_file *file, rt_off_t offset)
+dfs_off_t dfs_skt_lseek(struct dfs_file *file, dfs_off_t offset, int wherece)
 {
     return -RT_EIO;
 }
@@ -49,7 +51,7 @@ int dfs_skt_open(struct dfs_file *file)
     return RT_EOK;
 }
 
-int dfs_skt_stat(struct dfs_filesystem *fs, const char *path, struct stat *st)
+int dfs_skt_stat(struct dfs_dentry *dentry, struct dfs_stat *st)
 {
     return RT_EOK;
 }
@@ -61,36 +63,35 @@ int dfs_skt_getdents(struct dfs_file *file, struct dirent *dirp, rt_uint32_t cou
 
 static const struct dfs_file_ops _skt_fops =
 {
-    dfs_skt_open,
-    dfs_skt_close,
-    dfs_skt_ioctl,
-    dfs_skt_read,
-    NULL, /* write */
-    NULL, /* flush */
-    dfs_skt_lseek,
-    dfs_skt_getdents,
+    .open = dfs_skt_open,
+    .close = dfs_skt_close,
+    .ioctl = dfs_skt_ioctl,
+    .read = dfs_skt_read,
+    .lseek = dfs_skt_lseek,
+    .getdents = dfs_skt_getdents,
 };
 
 static const struct dfs_filesystem_ops _skt_fs =
 {
-    "skt",
-    DFS_FS_FLAG_DEFAULT,
-    &_skt_fops,
-
-    dfs_skt_mount,
-    dfs_skt_unmount,
-    NULL, /* mkfs */
-    NULL, /* statfs */
-
-    NULL, /* unlink */
-    dfs_skt_stat,
-    NULL, /* rename */
+    .name = "skt",
+    .flags = DFS_FS_FLAG_DEFAULT,
+    .default_fops = &_skt_fops,
+
+    .mount = dfs_skt_mount,
+    .umount = dfs_skt_unmount,
+
+    .stat = dfs_skt_stat,
+};
+
+static struct dfs_filesystem_type _skt_type =
+{
+    .fs_ops = &_skt_fs,
 };
 
 int dfs_skt_init(void)
 {
     /* register rom file system */
-    dfs_register(&_skt_fs);
+    dfs_register(&_skt_type);
     return 0;
 }
 INIT_COMPONENT_EXPORT(dfs_skt_init);
diff --git a/components/dfs/dfs_v2/filesystems/tmpfs/dfs_tmpfs.c b/components/dfs/dfs_v2/filesystems/tmpfs/dfs_tmpfs.c
index 1dc1fd54f9e..f8f13400fbd 100644
--- a/components/dfs/dfs_v2/filesystems/tmpfs/dfs_tmpfs.c
+++ b/components/dfs/dfs_v2/filesystems/tmpfs/dfs_tmpfs.c
@@ -232,7 +232,7 @@ struct tmpfs_file *dfs_tmpfs_lookup(struct tmpfs_sb  *superblock,
 {
     const char *subpath, *curpath, *filename = RT_NULL;
     char subdir_name[TMPFS_NAME_MAX];
-    struct tmpfs_file *file, *curfile, *tmp;
+    struct tmpfs_file *file = RT_NULL, *curfile, *tmp;
 
     subpath = path;
     while (*subpath == '/' && *subpath)
@@ -266,6 +266,7 @@ struct tmpfs_file *dfs_tmpfs_lookup(struct tmpfs_sb  *superblock,
         {
             if (rt_strcmp(file->name, filename) == 0)
             {
+                /* cppcheck-suppress uninitvar */
                 *size = file->size;
 
                 rt_spin_unlock(&superblock->lock);
@@ -286,7 +287,7 @@ struct tmpfs_file *dfs_tmpfs_lookup(struct tmpfs_sb  *superblock,
     return NULL;
 }
 
-static ssize_t dfs_tmpfs_read(struct dfs_file *file, void *buf, size_t count, off_t *pos)
+static ssize_t dfs_tmpfs_read(struct dfs_file *file, void *buf, size_t count, dfs_off_t *pos)
 {
     ssize_t length;
     struct tmpfs_file *d_file;
@@ -311,7 +312,7 @@ static ssize_t dfs_tmpfs_read(struct dfs_file *file, void *buf, size_t count, of
     return length;
 }
 
-static ssize_t _dfs_tmpfs_write(struct tmpfs_file *d_file, const void *buf, size_t count, off_t *pos)
+static ssize_t _dfs_tmpfs_write(struct tmpfs_file *d_file, const void *buf, size_t count, dfs_off_t *pos)
 {
     struct tmpfs_sb *superblock;
 
@@ -348,7 +349,7 @@ static ssize_t _dfs_tmpfs_write(struct tmpfs_file *d_file, const void *buf, size
     return count;
 }
 
-static ssize_t dfs_tmpfs_write(struct dfs_file *file, const void *buf, size_t count, off_t *pos)
+static ssize_t dfs_tmpfs_write(struct dfs_file *file, const void *buf, size_t count, dfs_off_t *pos)
 {
     struct tmpfs_file *d_file;
 
@@ -364,7 +365,7 @@ static ssize_t dfs_tmpfs_write(struct dfs_file *file, const void *buf, size_t co
     return count;
 }
 
-static off_t dfs_tmpfs_lseek(struct dfs_file *file, off_t offset, int wherece)
+static dfs_off_t dfs_tmpfs_lseek(struct dfs_file *file, dfs_off_t offset, int wherece)
 {
     switch (wherece)
     {
@@ -383,7 +384,7 @@ static off_t dfs_tmpfs_lseek(struct dfs_file *file, off_t offset, int wherece)
         return -EINVAL;
     }
 
-    if (offset <= (off_t)file->vnode->size)
+    if (offset <= (dfs_off_t)file->vnode->size)
     {
         return offset;
     }
@@ -461,7 +462,7 @@ static int dfs_tmpfs_open(struct dfs_file *file)
     return 0;
 }
 
-static int dfs_tmpfs_stat(struct dfs_dentry *dentry, struct stat *st)
+static int dfs_tmpfs_stat(struct dfs_dentry *dentry, struct dfs_stat *st)
 {
     rt_size_t size;
     struct tmpfs_file *d_file;
@@ -474,7 +475,7 @@ static int dfs_tmpfs_stat(struct dfs_dentry *dentry, struct stat *st)
         return -ENOENT;
 
     st->st_dev = (dev_t)(size_t)(dentry->mnt->dev_id);
-    st->st_ino = (ino_t)dfs_dentry_full_path_crc32(dentry);
+    st->st_ino = (uint16_t)dfs_dentry_full_path_crc32(dentry);
 
     if (d_file->type == TMPFS_TYPE_DIR)
     {
@@ -486,7 +487,7 @@ static int dfs_tmpfs_stat(struct dfs_dentry *dentry, struct stat *st)
     }
 
     st->st_size = d_file->size;
-    st->st_mtime = 0;
+    st->mtime = 0;
 
     return RT_EOK;
 }
@@ -789,7 +790,7 @@ static ssize_t dfs_tmp_page_read(struct dfs_file *file, struct dfs_page *page)
 
     if (page->page)
     {
-        off_t fpos = page->fpos;
+        dfs_off_t fpos = page->fpos;
         ret = dfs_tmpfs_read(file, page->page, page->size, &fpos);
     }
 
@@ -798,7 +799,7 @@ static ssize_t dfs_tmp_page_read(struct dfs_file *file, struct dfs_page *page)
 
 ssize_t dfs_tmp_page_write(struct dfs_page *page)
 {
-    off_t pos;
+    dfs_off_t pos;
     size_t count = 0;
     struct tmpfs_file *d_file;
 
@@ -822,7 +823,7 @@ ssize_t dfs_tmp_page_write(struct dfs_page *page)
 }
 #endif
 
-static int dfs_tmpfs_truncate(struct dfs_file *file, off_t offset)
+static int dfs_tmpfs_truncate(struct dfs_file *file, dfs_off_t offset)
 {
     struct tmpfs_file *d_file = RT_NULL;
     struct tmpfs_sb *superblock = RT_NULL;
diff --git a/components/dfs/dfs_v2/include/dfs.h b/components/dfs/dfs_v2/include/dfs.h
index 582ec428aca..76e6bb555a3 100644
--- a/components/dfs/dfs_v2/include/dfs.h
+++ b/components/dfs/dfs_v2/include/dfs.h
@@ -83,10 +83,41 @@
 #define DFS_F_FREAD     0x01
 #define DFS_F_FWRITE    0x02
 
+#ifdef RT_USING_DFS_LARGE_FILE
+typedef int64_t dfs_off_t;
+#define DFS_OFF_MAX INT64_MAX
+#else
+typedef int32_t dfs_off_t;
+#define DFS_OFF_MAX INT32_MAX
+#endif
+
+struct dfs_stat
+{
+    dev_t st_dev;
+    uint16_t st_ino;
+    uint16_t st_mode;
+    uint16_t st_nlink;
+    uint16_t st_uid;
+    uint16_t st_gid;
+    struct rt_device *st_rdev;
+    dfs_off_t st_size;
+    time_t atime;
+    long st_spare1;
+    time_t mtime;
+    long st_spare2;
+    time_t ctime;
+    long st_spare3;
+    uint32_t st_blksize;
+    uint32_t st_blocks;
+    long st_spare4[2];
+};
+
 #ifdef __cplusplus
 extern "C" {
 #endif
 
+void dfs_print_off_t(dfs_off_t value);
+
 rt_inline int dfs_fflags(int oflags)
 {
     int rw = oflags & O_ACCMODE;
diff --git a/components/dfs/dfs_v2/include/dfs_file.h b/components/dfs/dfs_v2/include/dfs_file.h
index 5010ed45346..2d2661db5ba 100644
--- a/components/dfs/dfs_v2/include/dfs_file.h
+++ b/components/dfs/dfs_v2/include/dfs_file.h
@@ -40,11 +40,11 @@ struct dfs_file_ops
     int (*open)(struct dfs_file *file);
     int (*close)(struct dfs_file *file);
     int (*ioctl)(struct dfs_file *file, int cmd, void *arg);
-    ssize_t (*read)(struct dfs_file *file, void *buf, size_t count, off_t *pos);
-    ssize_t (*write)(struct dfs_file *file, const void *buf, size_t count, off_t *pos);
+    ssize_t (*read)(struct dfs_file *file, void *buf, size_t count, dfs_off_t *pos);
+    ssize_t (*write)(struct dfs_file *file, const void *buf, size_t count, dfs_off_t *pos);
     int (*flush)(struct dfs_file *file);
-    off_t (*lseek)(struct dfs_file *file, off_t offset, int wherece);
-    int (*truncate)(struct dfs_file *file, off_t offset);
+    dfs_off_t (*lseek)(struct dfs_file *file, dfs_off_t offset, int wherece);
+    int (*truncate)(struct dfs_file *file, dfs_off_t offset);
     int (*getdents)(struct dfs_file *file, struct dirent *dirp, uint32_t count);
     int (*poll)(struct dfs_file *file, struct rt_pollreq *req);
 
@@ -63,7 +63,7 @@ struct dfs_vnode
 
     struct dfs_mnt *mnt;    /* which mounted file system does this vnode belong to */
 
-    size_t size;
+    dfs_off_t size;
     uint32_t nlink;
 
     const struct dfs_file_ops *fops;
@@ -90,7 +90,7 @@ struct dfs_file
     uint32_t flags;
     rt_atomic_t ref_count;
 
-    off_t fpos;
+    dfs_off_t fpos;
     struct rt_mutex pos_lock;
 
     const struct dfs_file_ops *fops;
@@ -136,7 +136,7 @@ struct dfs_mmap2_args
     size_t length;
     int prot;
     int flags;
-    off_t pgoffset;
+    dfs_off_t pgoffset;
     size_t min_align_size;
 
     struct rt_lwp *lwp;
@@ -150,18 +150,18 @@ void dfs_file_deinit(struct dfs_file *file);
 int dfs_file_open(struct dfs_file *file, const char *path, int flags, mode_t mode);
 int dfs_file_close(struct dfs_file *file);
 
-off_t dfs_file_get_fpos(struct dfs_file *file);
-void dfs_file_set_fpos(struct dfs_file *file, off_t fpos);
-ssize_t dfs_file_pread(struct dfs_file *file, void *buf, size_t len, off_t offset);
+dfs_off_t dfs_file_get_fpos(struct dfs_file *file);
+void dfs_file_set_fpos(struct dfs_file *file, dfs_off_t fpos);
+ssize_t dfs_file_pread(struct dfs_file *file, void *buf, size_t len, dfs_off_t offset);
 ssize_t dfs_file_read(struct dfs_file *file, void *buf, size_t len);
-ssize_t dfs_file_pwrite(struct dfs_file *file, const void *buf, size_t len, off_t offset);
+ssize_t dfs_file_pwrite(struct dfs_file *file, const void *buf, size_t len, dfs_off_t offset);
 ssize_t dfs_file_write(struct dfs_file *file, const void *buf, size_t len);
-off_t generic_dfs_lseek(struct dfs_file *file, off_t offset, int whence);
-off_t dfs_file_lseek(struct dfs_file *file, off_t offset, int wherece);
-int dfs_file_stat(const char *path, struct stat *buf);
-int dfs_file_lstat(const char *path, struct stat *buf);
+dfs_off_t generic_dfs_lseek(struct dfs_file *file, dfs_off_t offset, int whence);
+dfs_off_t dfs_file_lseek(struct dfs_file *file, dfs_off_t offset, int wherece);
+int dfs_file_stat(const char *path, struct dfs_stat *buf);
+int dfs_file_lstat(const char *path, struct dfs_stat *buf);
 int dfs_file_setattr(const char *path, struct dfs_attr *attr);
-int dfs_file_fstat(struct dfs_file *file, struct stat *buf);
+int dfs_file_fstat(struct dfs_file *file, struct dfs_stat *buf);
 int dfs_file_ioctl(struct dfs_file *file, int cmd, void *args);
 int dfs_file_fcntl(int fd, int cmd, unsigned long arg);
 int dfs_file_fsync(struct dfs_file *file);
@@ -170,7 +170,7 @@ int dfs_file_link(const char *oldname, const char *newname);
 int dfs_file_symlink(const char *oldname, const char *name);
 int dfs_file_readlink(const char *path, char *buf, int bufsize);
 int dfs_file_rename(const char *old_file, const char *new_file);
-int dfs_file_ftruncate(struct dfs_file *file, off_t length);
+int dfs_file_ftruncate(struct dfs_file *file, dfs_off_t length);
 int dfs_file_getdents(struct dfs_file *file, struct dirent *dirp, size_t nbytes);
 int dfs_file_mkdir(const char *path, mode_t mode);
 int dfs_file_rmdir(const char *pathname);
diff --git a/components/dfs/dfs_v2/include/dfs_fs.h b/components/dfs/dfs_v2/include/dfs_fs.h
index dcf2fa2b98b..a95cb5b5ce5 100644
--- a/components/dfs/dfs_v2/include/dfs_fs.h
+++ b/components/dfs/dfs_v2/include/dfs_fs.h
@@ -56,7 +56,7 @@ extern "C"
 struct dfs_partition
 {
     uint8_t type; /* file system type */
-    off_t offset; /* partition start offset */
+    dfs_off_t offset; /* partition start offset */
     size_t size;  /* partition size */
     rt_sem_t lock;
 };
@@ -96,7 +96,7 @@ struct dfs_filesystem_ops
     int (*symlink)(struct dfs_dentry *parent_dentry, const char *target, const char *newpath); /*soft link interface*/
 
     int (*rename)(struct dfs_dentry *old_dentry, struct dfs_dentry *new_dentry);
-    int (*stat)(struct dfs_dentry *dentry, struct stat *buf);
+    int (*stat)(struct dfs_dentry *dentry, struct dfs_stat *buf);
 
     int (*statfs)(struct dfs_mnt *mnt, struct statfs *buf);
 
diff --git a/components/dfs/dfs_v2/include/dfs_pcache.h b/components/dfs/dfs_v2/include/dfs_pcache.h
index c87b23f6923..f813c674873 100644
--- a/components/dfs/dfs_v2/include/dfs_pcache.h
+++ b/components/dfs/dfs_v2/include/dfs_pcache.h
@@ -48,7 +48,7 @@ struct dfs_page
     rt_atomic_t ref_count;        /* Reference count for this page */
 
     void *page;                   /* Pointer to physical page data */
-    off_t fpos;                   /* File position this page represents */
+    dfs_off_t fpos;               /* File position this page represents */
     size_t size;                  /* Total size of the page */
     size_t len;                   /* Valid data length in the page */
     int is_dirty;                 /* Dirty flag indicating if page needs writeback */
@@ -105,8 +105,8 @@ struct dfs_pcache
 struct dfs_aspace *dfs_aspace_create(struct dfs_dentry *dentry, struct dfs_vnode *vnode, const struct dfs_aspace_ops *ops);
 int dfs_aspace_destroy(struct dfs_aspace *aspace);
 
-int dfs_aspace_read(struct dfs_file *file, void *buf, size_t count, off_t *pos);
-int dfs_aspace_write(struct dfs_file *file, const void *buf, size_t count, off_t *pos);
+int dfs_aspace_read(struct dfs_file *file, void *buf, size_t count, dfs_off_t *pos);
+int dfs_aspace_write(struct dfs_file *file, const void *buf, size_t count, dfs_off_t *pos);
 int dfs_aspace_flush(struct dfs_aspace *aspace);
 int dfs_aspace_clean(struct dfs_aspace *aspace);
 
@@ -115,8 +115,8 @@ int dfs_aspace_unmap(struct dfs_file *file, struct rt_varea *varea);
 int dfs_aspace_page_unmap(struct dfs_file *file, struct rt_varea *varea, void *vaddr);
 int dfs_aspace_page_dirty(struct dfs_file *file, struct rt_varea *varea, void *vaddr);
 
-off_t dfs_aspace_fpos(struct rt_varea *varea, void *vaddr);
-void *dfs_aspace_vaddr(struct rt_varea *varea, off_t fpos);
+dfs_off_t dfs_aspace_fpos(struct rt_varea *varea, void *vaddr);
+void *dfs_aspace_vaddr(struct rt_varea *varea, dfs_off_t fpos);
 
 int dfs_aspace_mmap_read(struct dfs_file *file, struct rt_varea *varea, void *data);
 int dfs_aspace_mmap_write(struct dfs_file *file, struct rt_varea *varea, void *data);
@@ -131,4 +131,4 @@ void dfs_pcache_clean(struct dfs_mnt *mnt);
 
 #endif
 
-#endif
\ No newline at end of file
+#endif
diff --git a/components/dfs/dfs_v2/include/dfs_seq_file.h b/components/dfs/dfs_v2/include/dfs_seq_file.h
index 2fa4f93e8e8..1d348e8da0e 100644
--- a/components/dfs/dfs_v2/include/dfs_seq_file.h
+++ b/components/dfs/dfs_v2/include/dfs_seq_file.h
@@ -26,8 +26,8 @@ struct dfs_seq_file
     size_t count;       /* Length of valid data in buffer */
     size_t pad_until;   /* Padding target position for alignment */
 
-    off_t index;        /* Current item index in sequence */
-    off_t read_pos;     /* Current read position in file */
+    dfs_off_t index;    /* Current item index in sequence */
+    dfs_off_t read_pos; /* Current read position in file */
 
     struct rt_mutex lock; /* Mutex for thread safety */
 
@@ -41,9 +41,9 @@ struct dfs_seq_file
  */
 struct dfs_seq_ops
 {
-    void *(*start)(struct dfs_seq_file *seq, off_t *index);  /* Start sequence traversal */
+    void *(*start)(struct dfs_seq_file *seq, dfs_off_t *index);  /* Start sequence traversal */
     void (*stop)(struct dfs_seq_file *seq, void *data);      /* Stop sequence traversal */
-    void *(*next)(struct dfs_seq_file *seq, void *data, off_t *index); /* Get next item in sequence */
+    void *(*next)(struct dfs_seq_file *seq, void *data, dfs_off_t *index); /* Get next item in sequence */
     int (*show)(struct dfs_seq_file *seq, void *data);  /* Show current item */
 };
 
@@ -64,8 +64,8 @@ static inline void dfs_seq_setwidth(struct dfs_seq_file *seq, size_t size)
 }
 
 int dfs_seq_open(struct dfs_file *file, const struct dfs_seq_ops *ops);
-ssize_t dfs_seq_read(struct dfs_file *file, void *buf, size_t size, off_t *pos);
-off_t dfs_seq_lseek(struct dfs_file *file, off_t offset, int whence);
+ssize_t dfs_seq_read(struct dfs_file *file, void *buf, size_t size, dfs_off_t *pos);
+dfs_off_t dfs_seq_lseek(struct dfs_file *file, dfs_off_t offset, int whence);
 int dfs_seq_release(struct dfs_file *file);
 int dfs_seq_write(struct dfs_seq_file *seq, const void *data, size_t len);
 
@@ -75,4 +75,4 @@ void dfs_seq_putc(struct dfs_seq_file *seq, char c);
 void dfs_seq_puts(struct dfs_seq_file *seq, const char *s);
 void dfs_seq_pad(struct dfs_seq_file *seq, char c);
 
-#endif
\ No newline at end of file
+#endif
diff --git a/components/dfs/dfs_v2/src/dfs.c b/components/dfs/dfs_v2/src/dfs.c
index de1ea79edc5..9d4a6ed85ef 100644
--- a/components/dfs/dfs_v2/src/dfs.c
+++ b/components/dfs/dfs_v2/src/dfs.c
@@ -39,6 +39,35 @@ static struct rt_mutex fslock;
 static struct rt_mutex fdlock;
 static struct dfs_fdtable _fdtab = {0};
 
+void dfs_print_off_t(dfs_off_t value)
+{
+    char buf[24];
+    int i = 0;
+    rt_uint64_t number;
+
+    if (value < 0)
+    {
+        rt_kprintf("-");
+        number = (rt_uint64_t)(-(value + 1)) + 1;
+    }
+    else
+    {
+        number = (rt_uint64_t)value;
+    }
+
+    do
+    {
+        buf[i++] = (char)('0' + number % 10);
+        number /= 10;
+    }
+    while (number != 0);
+
+    while (i > 0)
+    {
+        rt_kprintf("%c", buf[--i]);
+    }
+}
+
 /**
  * @brief Expand the file descriptor table to accommodate a specified file descriptor
  *
@@ -1238,4 +1267,4 @@ MSH_CMD_EXPORT(dfs_dlog, dfs dlog on|off);
 #endif
 
 #endif
-/** @} */
\ No newline at end of file
+/** @} */
diff --git a/components/dfs/dfs_v2/src/dfs_file.c b/components/dfs/dfs_v2/src/dfs_file.c
index 9c6e383e1b4..f1c2a8b5b93 100644
--- a/components/dfs/dfs_v2/src/dfs_file.c
+++ b/components/dfs/dfs_v2/src/dfs_file.c
@@ -235,9 +235,9 @@ static int _insert_link_path(const char *link_fn, int link_len, char *tmp_path,
  * @note rw_verify_area doesn't like huge counts. We limit them to something that fits in "int"
  *       so that others won't have to do range checks all the time.
  */
-ssize_t rw_verify_area(struct dfs_file *file, off_t *ppos, size_t count)
+ssize_t rw_verify_area(struct dfs_file *file, dfs_off_t *ppos, size_t count)
 {
-    off_t pos;
+    dfs_off_t pos;
     ssize_t retval = -EINVAL;
 
     if ((size_t)count < 0)
@@ -261,9 +261,9 @@ ssize_t rw_verify_area(struct dfs_file *file, off_t *ppos, size_t count)
  *
  * @param[in] file Pointer to the file structure containing position information
  *
- * @return off_t Current file position, or 0 if file pointer is NULL
+ * @return dfs_off_t Current file position, or 0 if file pointer is NULL
  */
-off_t dfs_file_get_fpos(struct dfs_file *file)
+dfs_off_t dfs_file_get_fpos(struct dfs_file *file)
 {
     if (file)
     {
@@ -288,7 +288,7 @@ off_t dfs_file_get_fpos(struct dfs_file *file)
  * @param[in] file Pointer to the file structure to modify
  * @param[in] fpos The new file position to set
  */
-void dfs_file_set_fpos(struct dfs_file *file, off_t fpos)
+void dfs_file_set_fpos(struct dfs_file *file, dfs_off_t fpos)
 {
     if (file)
     {
@@ -895,7 +895,7 @@ int dfs_file_close(struct dfs_file *file)
  *         -ENOSYS if read operation not supported
  *         -EINVAL if invalid parameters or not mounted
  */
-ssize_t dfs_file_pread(struct dfs_file *file, void *buf, size_t len, off_t offset)
+ssize_t dfs_file_pread(struct dfs_file *file, void *buf, size_t len, dfs_off_t offset)
 {
     ssize_t ret = -EBADF;
 
@@ -912,7 +912,7 @@ ssize_t dfs_file_pread(struct dfs_file *file, void *buf, size_t len, off_t offse
         }
         else if (file->vnode && file->vnode->type != FT_DIRECTORY)
         {
-            off_t pos = offset;
+            dfs_off_t pos = offset;
 
             ret = rw_verify_area(file, &pos, len);
             if (ret > 0)
@@ -974,7 +974,7 @@ ssize_t dfs_file_read(struct dfs_file *file, void *buf, size_t len)
         else if (file->vnode && file->vnode->type != FT_DIRECTORY)
         {
             /* fpos lock */
-            off_t pos = dfs_file_get_fpos(file);
+            dfs_off_t pos = dfs_file_get_fpos(file);
 
             ret = rw_verify_area(file, &pos, len);
             if (ret > 0)
@@ -1023,7 +1023,7 @@ ssize_t dfs_file_read(struct dfs_file *file, void *buf, size_t len)
  * @note If O_SYNC flag is set, the data will be immediately flushed to storage device
  *       after write operation.
  */
-ssize_t dfs_file_pwrite(struct dfs_file *file, const void *buf, size_t len, off_t offset)
+ssize_t dfs_file_pwrite(struct dfs_file *file, const void *buf, size_t len, dfs_off_t offset)
 {
     ssize_t ret = -EBADF;
 
@@ -1041,7 +1041,7 @@ ssize_t dfs_file_pwrite(struct dfs_file *file, const void *buf, size_t len, off_
         }
         else if (file->vnode && file->vnode->type != FT_DIRECTORY)
         {
-            off_t pos = offset;
+            dfs_off_t pos = offset;
 
             ret = rw_verify_area(file, &pos, len);
             if (ret > 0)
@@ -1114,7 +1114,7 @@ ssize_t dfs_file_write(struct dfs_file *file, const void *buf, size_t len)
         }
         else if (file->vnode && file->vnode->type != FT_DIRECTORY)
         {
-            off_t pos;
+            dfs_off_t pos;
 
             if (!(file->flags & O_APPEND))
             {
@@ -1180,11 +1180,11 @@ ssize_t dfs_file_write(struct dfs_file *file, const void *buf, size_t len)
  * @param[in] offset Offset value to seek
  * @param[in] whence Seek mode (SEEK_SET/SEEK_CUR/SEEK_END)
  *
- * @return off_t The calculated new file position, or -EINVAL for invalid whence
+ * @return dfs_off_t The calculated new file position, or -EINVAL for invalid whence
  */
-off_t generic_dfs_lseek(struct dfs_file *file, off_t offset, int whence)
+dfs_off_t generic_dfs_lseek(struct dfs_file *file, dfs_off_t offset, int whence)
 {
-    off_t foffset;
+    dfs_off_t foffset;
 
     if (whence == SEEK_SET)
         foffset = offset;
@@ -1208,19 +1208,19 @@ off_t generic_dfs_lseek(struct dfs_file *file, off_t offset, int whence)
  * @param[in] offset Number of bytes to offset from position
  * @param[in] whence Reference position (SEEK_SET/SEEK_CUR/SEEK_END)
  *
- * @return off_t New file position on success, or negative error code:
+ * @return dfs_off_t New file position on success, or negative error code:
  *         -EINVAL if invalid parameters or not mounted
  */
-off_t dfs_file_lseek(struct dfs_file *file, off_t offset, int wherece)
+dfs_off_t dfs_file_lseek(struct dfs_file *file, dfs_off_t offset, int wherece)
 {
-    off_t retval = -EINVAL;
+    dfs_off_t retval = -EINVAL;
 
     if (file && file->fops->lseek)
     {
         if (dfs_is_mounted(file->vnode->mnt) == 0)
         {
             /* fpos lock */
-            off_t pos = dfs_file_get_fpos(file);
+            dfs_off_t pos = dfs_file_get_fpos(file);
             retval = file->fops->lseek(file, offset, wherece);
             if (retval >= 0)
             {
@@ -1246,7 +1246,7 @@ off_t dfs_file_lseek(struct dfs_file *file, off_t offset, int wherece)
  *         -ENOMEM if memory allocation failed
  *         Other negative error codes from filesystem operations
  */
-int dfs_file_stat(const char *path, struct stat *buf)
+int dfs_file_stat(const char *path, struct dfs_stat *buf)
 {
     int ret = -ENOENT;
     char *fullpath = RT_NULL;
@@ -1315,7 +1315,7 @@ int dfs_file_stat(const char *path, struct stat *buf)
  * @note Unlike dfs_file_stat(), this function does not follow symbolic links
  * @see dfs_file_stat()
  */
-int dfs_file_lstat(const char *path, struct stat *buf)
+int dfs_file_lstat(const char *path, struct dfs_stat *buf)
 {
     int ret = -ENOENT;
     char *fullpath = RT_NULL;
@@ -1384,7 +1384,7 @@ int dfs_file_lstat(const char *path, struct stat *buf)
  *
  * @note Currently unimplemented (returns -ENOSYS)
  */
-int dfs_file_fstat(struct dfs_file *file, struct stat *buf)
+int dfs_file_fstat(struct dfs_file *file, struct dfs_stat *buf)
 {
     size_t ret = -EBADF;
 
@@ -1787,7 +1787,7 @@ int dfs_file_unlink(const char *path)
 int dfs_file_link(const char *oldname, const char *newname)
 {
     int ret = -1;
-    struct stat stat;
+    struct dfs_stat stat;
     struct dfs_mnt *mnt = RT_NULL;
     char *old_fullpath, *new_fullpath;
 
@@ -2208,7 +2208,7 @@ int dfs_file_rename(const char *old_file, const char *new_file)
  * @note If RT_USING_PAGECACHE is enabled, the page cache will be cleaned
  *       before truncation to ensure data consistency
  */
-int dfs_file_ftruncate(struct dfs_file *file, off_t length)
+int dfs_file_ftruncate(struct dfs_file *file, dfs_off_t length)
 {
     int ret = 0;
 
@@ -2383,7 +2383,7 @@ int dfs_file_isdir(const char *path)
                 DLOG(msg, "dentry", "dfs_file", DLOG_MSG_RET, "return dentry");
                 if (mnt->fs_ops->stat)
                 {
-                    struct stat stat = {0};
+                    struct dfs_stat stat = {0};
                     DLOG(msg, "dfs_file", mnt->fs_ops->name, DLOG_MSG, "fs_ops->stat(dentry, buf)");
 
                     if (dfs_is_mounted(mnt) == 0)
@@ -2537,7 +2537,7 @@ int dfs_file_mmap2(struct dfs_file *file, struct dfs_mmap2_args *mmap2)
 void ls(const char *pathname)
 {
     struct dirent dirent;
-    struct stat stat;
+    struct dfs_stat stat;
     int length;
     char *fullpath, *path;
     struct dfs_file file;
@@ -2584,7 +2584,7 @@ void ls(const char *pathname)
                 if (length > 0)
                 {
                     DLOG(msg, "dfs_file", "dfs", DLOG_MSG_RET, "dirent.d_name=%s", dirent.d_name);
-                    memset(&stat, 0, sizeof(struct stat));
+                    memset(&stat, 0, sizeof(struct dfs_stat));
 
                     /* build full path for each file */
                     fullpath = dfs_normalize_path(path, dirent.d_name);
@@ -2655,7 +2655,9 @@ void ls(const char *pathname)
                         else if (stat.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH))
                         {
                             rt_kprintf(_COLOR_GREEN "%-20s" _COLOR_NORMAL, dirent.d_name);
-                            rt_kprintf(" %-25lu\n", (unsigned long)stat.st_size);
+                            rt_kprintf(" ");
+                            dfs_print_off_t(stat.st_size);
+                            rt_kprintf("\n");
                         }
                         else if (S_ISCHR(stat.st_mode))
                         {
@@ -2665,7 +2667,9 @@ void ls(const char *pathname)
                         else
                         {
                             rt_kprintf("%-20s", dirent.d_name);
-                            rt_kprintf(" %-25lu\n", (unsigned long)stat.st_size);
+                            rt_kprintf(" ");
+                            dfs_print_off_t(stat.st_size);
+                            rt_kprintf("\n");
                         }
                     }
                     else
@@ -2835,7 +2839,7 @@ extern int mkdir(const char *path, mode_t mode);
 static void copydir(const char *src, const char *dst)
 {
     struct dirent dirent;
-    struct stat stat;
+    struct dfs_stat stat;
     int length;
     struct dfs_file file;
 
@@ -2874,7 +2878,7 @@ static void copydir(const char *src, const char *dst)
                 break;
             }
 
-            rt_memset(&stat, 0, sizeof(struct stat));
+            rt_memset(&stat, 0, sizeof(struct dfs_stat));
             if (dfs_file_lstat(src_entry_full, &stat) != 0)
             {
                 rt_kprintf("open file: %s failed\n", dirent.d_name);
@@ -2948,7 +2952,7 @@ void copy(const char *src, const char *dst)
 #define FLAG_DST_IS_FILE   0x08
 #define FLAG_DST_NON_EXSIT 0x00
 
-    struct stat stat;
+    struct dfs_stat stat;
     uint32_t flag = 0;
 
     /* check the staus of src and dst */
@@ -3029,4 +3033,4 @@ void copy(const char *src, const char *dst)
 }
 FINSH_FUNCTION_EXPORT(copy, copy file or dir)
 
-#endif
\ No newline at end of file
+#endif
diff --git a/components/dfs/dfs_v2/src/dfs_file_mmap.c b/components/dfs/dfs_v2/src/dfs_file_mmap.c
index fbf21f3491c..52cbe36b243 100644
--- a/components/dfs/dfs_v2/src/dfs_file_mmap.c
+++ b/components/dfs/dfs_v2/src/dfs_file_mmap.c
@@ -53,7 +53,7 @@ static void *dfs_mem_obj_get_file(rt_mem_obj_t mem_obj);
  *       The actual mapping is performed by rt_aspace_map().
  */
 static void *_do_mmap(struct rt_lwp *lwp, void *map_vaddr, size_t map_size, size_t attr,
-                      mm_flag_t flags, off_t pgoffset, void *data, rt_err_t *code)
+                      mm_flag_t flags, dfs_off_t pgoffset, void *data, rt_err_t *code)
 {
     int ret = 0;
     void *vaddr = map_vaddr;
diff --git a/components/dfs/dfs_v2/src/dfs_fs.c b/components/dfs/dfs_v2/src/dfs_fs.c
index 39a36f8cf39..9fed820c55d 100644
--- a/components/dfs/dfs_v2/src/dfs_fs.c
+++ b/components/dfs/dfs_v2/src/dfs_fs.c
@@ -169,7 +169,7 @@ int dfs_remount(const char *path, rt_ubase_t flags, void *data)
         }
         else
         {
-            struct stat buf = {0};
+            struct dfs_stat buf = {0};
             if (dfs_file_stat(fullpath, &buf) == 0 && S_ISBLK(buf.st_mode))
             {
                 /* path was not already mounted on target */
@@ -723,4 +723,4 @@ int dfs_filesystem_get_partition(struct dfs_partition *part,
     return RT_EOK;
 }
 
-/* @} */
\ No newline at end of file
+/* @} */
diff --git a/components/dfs/dfs_v2/src/dfs_pcache.c b/components/dfs/dfs_v2/src/dfs_pcache.c
index d82c7ed65b1..5bfeda77b1d 100644
--- a/components/dfs/dfs_v2/src/dfs_pcache.c
+++ b/components/dfs/dfs_v2/src/dfs_pcache.c
@@ -64,7 +64,7 @@ struct dfs_pcache_mq_obj
     rt_uint32_t cmd;
 };
 
-static struct dfs_page *dfs_page_lookup(struct dfs_file *file, off_t pos);
+static struct dfs_page *dfs_page_lookup(struct dfs_file *file, dfs_off_t pos);
 static void dfs_page_ref(struct dfs_page *page);
 static int dfs_page_inactive(struct dfs_page *page);
 static int dfs_page_remove(struct dfs_page *page);
@@ -1002,7 +1002,7 @@ static int dfs_page_unmap(struct dfs_page *page)
  *
  * @return Pointer to the newly created page structure on success, NULL on failure
  */
-static struct dfs_page *dfs_page_create(off_t pos)
+static struct dfs_page *dfs_page_create(dfs_off_t pos)
 {
     struct dfs_page *page = RT_NULL;
     int affid = RT_PAGE_PICK_AFFID(pos);
@@ -1102,7 +1102,7 @@ static void dfs_page_release(struct dfs_page *page)
  * @return 0 if positions are in the same page, negative if fpos is before value,
  *         positive if fpos is after value
  */
-static int dfs_page_compare(off_t fpos, off_t value)
+static int dfs_page_compare(dfs_off_t fpos, dfs_off_t value)
 {
     return fpos / ARCH_PAGE_SIZE * ARCH_PAGE_SIZE - value;
 }
@@ -1380,7 +1380,7 @@ static int dfs_page_dirty(struct dfs_page *page)
  * @param[in] fpos The file position to search for
  * @return struct dfs_page* The found page, or RT_NULL if not found
  */
-static struct dfs_page *dfs_page_search(struct dfs_aspace *aspace, off_t fpos)
+static struct dfs_page *dfs_page_search(struct dfs_aspace *aspace, dfs_off_t fpos)
 {
     int cmp;
     struct dfs_page *page;
@@ -1439,7 +1439,7 @@ static struct dfs_page *dfs_page_search(struct dfs_aspace *aspace, off_t fpos)
  * @return Pointer to the newly created and loaded page on success,
  *         NULL on failure or invalid parameters
  */
-static struct dfs_page *dfs_aspace_load_page(struct dfs_file *file, off_t pos)
+static struct dfs_page *dfs_aspace_load_page(struct dfs_file *file, dfs_off_t pos)
 {
     struct dfs_page *page = RT_NULL;
 
@@ -1477,7 +1477,7 @@ static struct dfs_page *dfs_aspace_load_page(struct dfs_file *file, off_t pos)
  * @return Pointer to the found or newly loaded page on success,
  *         NULL if the page couldn't be found or loaded
  */
-static struct dfs_page *dfs_page_lookup(struct dfs_file *file, off_t pos)
+static struct dfs_page *dfs_page_lookup(struct dfs_file *file, dfs_off_t pos)
 {
     struct dfs_page *page = RT_NULL;
     struct dfs_aspace *aspace = file->vnode->aspace;
@@ -1488,7 +1488,7 @@ static struct dfs_page *dfs_page_lookup(struct dfs_file *file, off_t pos)
     {
         int count = RT_PAGECACHE_PRELOAD;
         struct dfs_page *tmp = RT_NULL;
-        off_t fpos = pos / ARCH_PAGE_SIZE * ARCH_PAGE_SIZE;
+        dfs_off_t fpos = pos / ARCH_PAGE_SIZE * ARCH_PAGE_SIZE;
 
         do
         {
@@ -1555,7 +1555,7 @@ static struct dfs_page *dfs_page_lookup(struct dfs_file *file, off_t pos)
  *
  * @return Number of bytes successfully read, or negative error code
  */
-int dfs_aspace_read(struct dfs_file *file, void *buf, size_t count, off_t *pos)
+int dfs_aspace_read(struct dfs_file *file, void *buf, size_t count, dfs_off_t *pos)
 {
     int ret = -EINVAL;
 
@@ -1576,7 +1576,7 @@ int dfs_aspace_read(struct dfs_file *file, void *buf, size_t count, off_t *pos)
             page = dfs_page_lookup(file, *pos);
             if (page)
             {
-                off_t len;
+                dfs_off_t len;
 
                 dfs_aspace_lock(aspace);
                 if (aspace->vnode->size < page->fpos + ARCH_PAGE_SIZE)
@@ -1629,7 +1629,7 @@ int dfs_aspace_read(struct dfs_file *file, void *buf, size_t count, off_t *pos)
  *
  * @return Number of bytes successfully written, or negative error code
  */
-int dfs_aspace_write(struct dfs_file *file, const void *buf, size_t count, off_t *pos)
+int dfs_aspace_write(struct dfs_file *file, const void *buf, size_t count, dfs_off_t *pos)
 {
     int ret = -EINVAL;
 
@@ -1657,7 +1657,7 @@ int dfs_aspace_write(struct dfs_file *file, const void *buf, size_t count, off_t
             page = dfs_page_lookup(file, *pos);
             if (page)
             {
-                off_t len;
+                dfs_off_t len;
 
                 dfs_aspace_lock(aspace);
                 len = page->fpos + ARCH_PAGE_SIZE - *pos;
@@ -2056,9 +2056,9 @@ int dfs_aspace_page_dirty(struct dfs_file *file, struct rt_varea *varea, void *v
  *
  * @return The calculated file position offset
  */
-off_t dfs_aspace_fpos(struct rt_varea *varea, void *vaddr)
+dfs_off_t dfs_aspace_fpos(struct rt_varea *varea, void *vaddr)
 {
-    return (off_t)(intptr_t)vaddr - (off_t)(intptr_t)varea->start + varea->offset * ARCH_PAGE_SIZE;
+    return (dfs_off_t)(intptr_t)vaddr - (dfs_off_t)(intptr_t)varea->start + varea->offset * ARCH_PAGE_SIZE;
 }
 
 /**
@@ -2069,7 +2069,7 @@ off_t dfs_aspace_fpos(struct rt_varea *varea, void *vaddr)
  *
  * @return The virtual address corresponding to the file position
  */
-void *dfs_aspace_vaddr(struct rt_varea *varea, off_t fpos)
+void *dfs_aspace_vaddr(struct rt_varea *varea, dfs_off_t fpos)
 {
     return varea->start + fpos - varea->offset * ARCH_PAGE_SIZE;
 }
@@ -2098,7 +2098,7 @@ int dfs_aspace_mmap_read(struct dfs_file *file, struct rt_varea *varea, void *da
         struct rt_aspace_io_msg *msg = (struct rt_aspace_io_msg *)data;
         if (msg)
         {
-            off_t fpos = dfs_aspace_fpos(varea, msg->fault_vaddr);
+            dfs_off_t fpos = dfs_aspace_fpos(varea, msg->fault_vaddr);
             return dfs_aspace_read(file, msg->buffer_vaddr, ARCH_PAGE_SIZE, &fpos);
         }
     }
@@ -2130,7 +2130,7 @@ int dfs_aspace_mmap_write(struct dfs_file *file, struct rt_varea *varea, void *d
         struct rt_aspace_io_msg *msg = (struct rt_aspace_io_msg *)data;
         if (msg)
         {
-            off_t fpos = dfs_aspace_fpos(varea, msg->fault_vaddr);
+            dfs_off_t fpos = dfs_aspace_fpos(varea, msg->fault_vaddr);
             return dfs_aspace_write(file, msg->buffer_vaddr, ARCH_PAGE_SIZE, &fpos);
         }
     }
diff --git a/components/dfs/dfs_v2/src/dfs_posix.c b/components/dfs/dfs_v2/src/dfs_posix.c
index d0eff53a467..da1714b0c3b 100644
--- a/components/dfs/dfs_v2/src/dfs_posix.c
+++ b/components/dfs/dfs_v2/src/dfs_posix.c
@@ -21,6 +21,28 @@
 #include <lwp.h>
 #endif
 
+static void dfs_stat_to_posix_stat(const struct dfs_stat *dfs_buf, struct stat *buf)
+{
+    rt_memset(buf, 0, sizeof(struct stat));
+    buf->st_dev = dfs_buf->st_dev;
+    buf->st_ino = dfs_buf->st_ino;
+    buf->st_mode = dfs_buf->st_mode;
+    buf->st_nlink = dfs_buf->st_nlink;
+    buf->st_uid = dfs_buf->st_uid;
+    buf->st_gid = dfs_buf->st_gid;
+#if defined(__ARMCC_VERSION) || defined(__ICCARM__)
+    buf->st_rdev = dfs_buf->st_rdev;
+#else
+    buf->st_rdev = (dev_t)(rt_ubase_t)dfs_buf->st_rdev;
+#endif
+    buf->st_size = dfs_buf->st_size;
+    buf->st_atime = dfs_buf->atime;
+    buf->st_mtime = dfs_buf->mtime;
+    buf->st_ctime = dfs_buf->ctime;
+    buf->st_blksize = dfs_buf->st_blksize;
+    buf->st_blocks = dfs_buf->st_blocks;
+}
+
 /**
  * @addtogroup group_fs_posix_api
  * @{
@@ -154,7 +176,7 @@ int openat(int dirfd, const char *path, int flag, ...)
 int utimensat(int __fd, const char *__path, const struct timespec __times[2], int __flags)
 {
     int ret;
-    struct stat buffer;
+    struct dfs_stat buffer;
     struct dfs_file *d;
     char *fullpath;
     struct dfs_attr attr;
@@ -169,7 +191,7 @@ int utimensat(int __fd, const char *__path, const struct timespec __times[2], in
 
     if (__path[0] == '/' || __fd == AT_FDCWD)
     {
-        if (stat(__path, &buffer) < 0)
+        if (dfs_file_stat(__path, &buffer) < 0)
         {
             return -ENOENT;
         }
@@ -417,9 +439,9 @@ RTM_EXPORT(write);
  *
  * @return the resulting read/write position in the file, or -1 on failed.
  */
-off_t lseek(int fd, off_t offset, int whence)
+dfs_off_t lseek(int fd, dfs_off_t offset, int whence)
 {
-    off_t result;
+    dfs_off_t result;
     struct dfs_file *file;
 
     file = fd_get(fd);
@@ -486,7 +508,7 @@ RTM_EXPORT(rename);
 int unlink(const char *pathname)
 {
     int result;
-    struct stat stat;
+    struct dfs_stat stat;
 
     if (pathname == NULL)
     {
@@ -526,6 +548,7 @@ RTM_EXPORT(unlink);
 int stat(const char *file, struct stat *buf)
 {
     int result;
+    struct dfs_stat dfs_buf;
 
     if (file == NULL || buf == NULL)
     {
@@ -533,12 +556,16 @@ int stat(const char *file, struct stat *buf)
         return -1;
     }
 
-    result = dfs_file_stat(file, buf);
+    rt_memset(&dfs_buf, 0, sizeof(dfs_buf));
+    result = dfs_file_stat(file, &dfs_buf);
     if (result < 0)
     {
         rt_set_errno(-result);
+        return result;
     }
 
+    dfs_stat_to_posix_stat(&dfs_buf, buf);
+
     return result;
 }
 RTM_EXPORT(stat);
@@ -555,6 +582,7 @@ int fstat(int fildes, struct stat *buf)
 {
     int ret = -1;
     struct dfs_file *file;
+    struct dfs_stat dfs_buf;
 
     if (buf == NULL)
     {
@@ -573,7 +601,12 @@ int fstat(int fildes, struct stat *buf)
 
     if (dfs_is_mounted(file->dentry->mnt) == 0)
     {
-        ret = file->dentry->mnt->fs_ops->stat(file->dentry, buf);
+        rt_memset(&dfs_buf, 0, sizeof(dfs_buf));
+        ret = file->dentry->mnt->fs_ops->stat(file->dentry, &dfs_buf);
+        if (ret == RT_EOK)
+        {
+            dfs_stat_to_posix_stat(&dfs_buf, buf);
+        }
     }
 
     return ret;
@@ -700,7 +733,7 @@ RTM_EXPORT(ioctl);
  * @return Upon successful completion, ftruncate() shall return 0;
  * otherwise, -1 shall be returned and errno set to indicate the error.
  */
-int ftruncate(int fd, off_t length)
+int ftruncate(int fd, dfs_off_t length)
 {
     int result;
     struct dfs_file *file;
@@ -812,7 +845,7 @@ RTM_EXPORT(fstatfs);
 int mkdir(const char *path, mode_t mode)
 {
     int result;
-    struct stat stat;
+    struct dfs_stat stat;
     struct dfs_file file;
 
     if (path == NULL)
@@ -863,7 +896,7 @@ int rmdir(const char *pathname)
 {
     int result;
     DIR *dir = RT_NULL;
-    struct stat stat;
+    struct dfs_stat stat;
 
     if (!pathname)
     {
@@ -1382,10 +1415,10 @@ RTM_EXPORT(getcwd);
  * @return the actual read data buffer length. If the returned value is 0, it
  * may be reach the end of file, please check errno.
  */
-ssize_t pread(int fd, void *buf, size_t len, off_t offset)
+ssize_t pread(int fd, void *buf, size_t len, dfs_off_t offset)
 {
     ssize_t result;
-    off_t fpos;
+    dfs_off_t fpos;
     struct dfs_file *file;
 
     if (buf == NULL)
@@ -1429,10 +1462,10 @@ RTM_EXPORT(pread);
  *
  * @return the actual written data buffer length.
  */
-ssize_t pwrite(int fd, const void *buf, size_t len, off_t offset)
+ssize_t pwrite(int fd, const void *buf, size_t len, dfs_off_t offset)
 {
     ssize_t result;
-    off_t fpos;
+    dfs_off_t fpos;
     struct dfs_file *file;
 
     if (buf == NULL)
diff --git a/components/dfs/dfs_v2/src/dfs_seq_file.c b/components/dfs/dfs_v2/src/dfs_seq_file.c
index 9a476c160c0..9c4bb7b5a97 100644
--- a/components/dfs/dfs_v2/src/dfs_seq_file.c
+++ b/components/dfs/dfs_v2/src/dfs_seq_file.c
@@ -96,9 +96,9 @@ int dfs_seq_open(struct dfs_file *file, const struct dfs_seq_ops *ops)
  *
  * @note Data output loop: start() -> show() -> next() -> show() -> ... -> next() -> stop()
  */
-static int dfs_seq_traverse(struct dfs_seq_file *seq, off_t offset)
+static int dfs_seq_traverse(struct dfs_seq_file *seq, dfs_off_t offset)
 {
-    off_t pos = 0;
+    dfs_off_t pos = 0;
     int error = 0;
     void *p;
 
@@ -172,7 +172,7 @@ static int dfs_seq_traverse(struct dfs_seq_file *seq, off_t offset)
  *          6. Handle buffer overflow by doubling size
  *          7. Copy data to user buffer and update positions
  */
-ssize_t dfs_seq_read(struct dfs_file *file, void *buf, size_t size, off_t *pos)
+ssize_t dfs_seq_read(struct dfs_file *file, void *buf, size_t size, dfs_off_t *pos)
 {
     struct dfs_seq_file *seq = file->data;
     size_t copied = 0;
@@ -270,7 +270,7 @@ ssize_t dfs_seq_read(struct dfs_file *file, void *buf, size_t size, off_t *pos)
     while (1)
     {
         size_t offs = seq->count;
-        off_t pos = seq->index;
+        dfs_off_t pos = seq->index;
 
         p = seq->ops->next(seq, p, &seq->index);
         if (pos == seq->index)
@@ -325,13 +325,13 @@ ssize_t dfs_seq_read(struct dfs_file *file, void *buf, size_t size, off_t *pos)
  * @param[in] whence Reference position for offset:
  *                  - SEEK_SET: from file beginning
  *                  - SEEK_CUR: from current position
- * @return off_t New file offset on success, negative error code on failure:
+ * @return dfs_off_t New file offset on success, negative error code on failure:
  *         -EINVAL for invalid parameters
  */
-off_t dfs_seq_lseek(struct dfs_file *file, off_t offset, int whence)
+dfs_off_t dfs_seq_lseek(struct dfs_file *file, dfs_off_t offset, int whence)
 {
     struct dfs_seq_file *seq = file->data;
-    off_t retval = -EINVAL;
+    dfs_off_t retval = -EINVAL;
 
     rt_mutex_take(&seq->lock, RT_WAITING_FOREVER);
 
diff --git a/components/dfs/utest/tc_dfs_api.c b/components/dfs/utest/tc_dfs_api.c
index e33a2411a79..9e82c11e9e3 100644
--- a/components/dfs/utest/tc_dfs_api.c
+++ b/components/dfs/utest/tc_dfs_api.c
@@ -34,7 +34,11 @@ static void test_mkfs(void)
 
 static void test_dfs_mount(void)
 {
+#ifdef RT_USING_DFS_V2
+    struct dfs_stat stat_buf;
+#else
     struct stat stat_buf;
+#endif
 
     /* Check if filesystem is available */
     if (dfs_file_stat(TEST_MNT_PATH, &stat_buf) == 0)
@@ -165,7 +169,11 @@ static void test_dfs_close(void)
 
 static void test_dfs_stat(void)
 {
+#ifdef RT_USING_DFS_V2
+    struct dfs_stat stat_buf;
+#else
     struct stat stat_buf;
+#endif
     uassert_true(dfs_file_stat(TEST_FILE, &stat_buf) == 0);
     uassert_true(S_ISREG(stat_buf.st_mode));
 }
@@ -183,7 +191,11 @@ static void test_dfs_unlink(void)
 static void test_dfs_rename(void)
 {
     rt_err_t ret;
+#ifdef RT_USING_DFS_V2
+    struct dfs_stat stat_buf;
+#else
     struct stat stat_buf;
+#endif
 
     /* Force cleanup of any previous state */
     dfs_file_unlink(TEST_FILE);
diff --git a/components/drivers/block/blk_dfs.c b/components/drivers/block/blk_dfs.c
index 1b5797b0a33..addb5bdc373 100644
--- a/components/drivers/block/blk_dfs.c
+++ b/components/drivers/block/blk_dfs.c
@@ -53,7 +53,7 @@ static int blk_fops_ioctl(struct dfs_file *file, int cmd, void *arg)
     return (int)rt_device_control(dev, cmd, arg);
 }
 
-static ssize_t blk_fops_read(struct dfs_file *file, void *buf, size_t count, off_t *pos)
+static ssize_t blk_fops_read(struct dfs_file *file, void *buf, size_t count, dfs_off_t *pos)
 {
     void *rbuf;
     rt_ssize_t res = 0;
@@ -118,7 +118,7 @@ static ssize_t blk_fops_read(struct dfs_file *file, void *buf, size_t count, off
     return rsize;
 }
 
-static ssize_t blk_fops_write(struct dfs_file *file, const void *buf, size_t count, off_t *pos)
+static ssize_t blk_fops_write(struct dfs_file *file, const void *buf, size_t count, dfs_off_t *pos)
 {
     void *rbuf;
     rt_ssize_t res = 0;
diff --git a/components/drivers/input/input_uapi.c b/components/drivers/input/input_uapi.c
index 21dca947c7e..b2dda754dda 100644
--- a/components/drivers/input/input_uapi.c
+++ b/components/drivers/input/input_uapi.c
@@ -207,7 +207,7 @@ static int input_uapi_fops_ioctl(struct dfs_file *file, int cmd, void *args)
     return -EINVAL;
 }
 
-static ssize_t input_uapi_fops_read(struct dfs_file *file, void *buf, size_t count, off_t *pos)
+static ssize_t input_uapi_fops_read(struct dfs_file *file, void *buf, size_t count, dfs_off_t *pos)
 {
     int err;
     size_t read = 0;
@@ -292,7 +292,7 @@ static ssize_t input_uapi_fops_read(struct dfs_file *file, void *buf, size_t cou
     return read;
 }
 
-static ssize_t input_uapi_fops_write(struct dfs_file *file, const void *buf, size_t count, off_t *pos)
+static ssize_t input_uapi_fops_write(struct dfs_file *file, const void *buf, size_t count, dfs_off_t *pos)
 {
     return -ENOSYS;
 }
diff --git a/components/drivers/ipc/pipe.c b/components/drivers/ipc/pipe.c
index 7471d558077..5fce2ac1c32 100644
--- a/components/drivers/ipc/pipe.c
+++ b/components/drivers/ipc/pipe.c
@@ -225,7 +225,7 @@ static int pipe_fops_ioctl(struct dfs_file *fd, int cmd, void *args)
  *           When the return value is -EAGAIN, it means there are no data to be read.
  */
 #ifdef RT_USING_DFS_V2
-static ssize_t pipe_fops_read(struct dfs_file *fd, void *buf, size_t count, off_t *pos)
+static ssize_t pipe_fops_read(struct dfs_file *fd, void *buf, size_t count, dfs_off_t *pos)
 #else
 static ssize_t pipe_fops_read(struct dfs_file *fd, void *buf, size_t count)
 #endif
@@ -284,7 +284,7 @@ static ssize_t pipe_fops_read(struct dfs_file *fd, void *buf, size_t count)
  *           When the return value is -EPIPE, it means there is no thread that has the pipe open for reading.
  */
 #ifdef RT_USING_DFS_V2
-static ssize_t pipe_fops_write(struct dfs_file *fd, const void *buf, size_t count, off_t *pos)
+static ssize_t pipe_fops_write(struct dfs_file *fd, const void *buf, size_t count, dfs_off_t *pos)
 #else
 static ssize_t pipe_fops_write(struct dfs_file *fd, const void *buf, size_t count)
 #endif
diff --git a/components/drivers/pci/procfs.c b/components/drivers/pci/procfs.c
index b2ce0b057b0..625632e227d 100644
--- a/components/drivers/pci/procfs.c
+++ b/components/drivers/pci/procfs.c
@@ -61,9 +61,9 @@ static void pci_pm_runtime_put(struct rt_pci_device *pdev, rt_ubase_t *flags)
     }
 }
 
-static ssize_t pci_read(struct dfs_file *file, void *buf, size_t count, off_t *ppos)
+static ssize_t pci_read(struct dfs_file *file, void *buf, size_t count, dfs_off_t *ppos)
 {
-    off_t pos = *ppos;
+    dfs_off_t pos = *ppos;
     size_t res = count;
     rt_ubase_t pm_flags;
     struct proc_dentry *dentry = file->vnode->data;
@@ -142,9 +142,9 @@ static ssize_t pci_read(struct dfs_file *file, void *buf, size_t count, off_t *p
     return res;
 }
 
-static ssize_t pci_write(struct dfs_file *file, const void *buf, size_t count, off_t *ppos)
+static ssize_t pci_write(struct dfs_file *file, const void *buf, size_t count, dfs_off_t *ppos)
 {
-    off_t pos = *ppos;
+    dfs_off_t pos = *ppos;
     size_t res = count;
     rt_ubase_t pm_flags;
     struct proc_dentry *dentry = file->vnode->data;
@@ -217,7 +217,7 @@ static ssize_t pci_write(struct dfs_file *file, const void *buf, size_t count, o
     return res;
 }
 
-static off_t pci_lseek(struct dfs_file *file, off_t offset, int wherece)
+static dfs_off_t pci_lseek(struct dfs_file *file, dfs_off_t offset, int wherece)
 {
     struct proc_dentry *dentry = file->vnode->data;
     struct rt_pci_device *pdev = dentry->data;
@@ -239,7 +239,7 @@ static off_t pci_lseek(struct dfs_file *file, off_t offset, int wherece)
         return -EINVAL;
     }
 
-    if (offset <= (off_t)pdev->cfg_size)
+    if (offset <= (dfs_off_t)pdev->cfg_size)
     {
         return offset;
     }
diff --git a/components/drivers/serial/dev_serial.c b/components/drivers/serial/dev_serial.c
index 45bf97c3289..ebaf4d736ae 100644
--- a/components/drivers/serial/dev_serial.c
+++ b/components/drivers/serial/dev_serial.c
@@ -142,7 +142,7 @@ static int serial_fops_ioctl(struct dfs_file *fd, int cmd, void *args)
 }
 
 #ifdef RT_USING_DFS_V2
-static ssize_t serial_fops_read(struct dfs_file *fd, void *buf, size_t count, off_t *pos)
+static ssize_t serial_fops_read(struct dfs_file *fd, void *buf, size_t count, dfs_off_t *pos)
 #else
 static ssize_t serial_fops_read(struct dfs_file *fd, void *buf, size_t count)
 #endif
@@ -180,7 +180,7 @@ static ssize_t serial_fops_read(struct dfs_file *fd, void *buf, size_t count)
 }
 
 #ifdef RT_USING_DFS_V2
-static ssize_t serial_fops_write(struct dfs_file *fd, const void *buf, size_t count, off_t *pos)
+static ssize_t serial_fops_write(struct dfs_file *fd, const void *buf, size_t count, dfs_off_t *pos)
 #else
 static ssize_t serial_fops_write(struct dfs_file *fd, const void *buf, size_t count)
 #endif
diff --git a/components/drivers/serial/dev_serial_v2.c b/components/drivers/serial/dev_serial_v2.c
index d8cc2e0cb5a..9a2563c8847 100644
--- a/components/drivers/serial/dev_serial_v2.c
+++ b/components/drivers/serial/dev_serial_v2.c
@@ -102,7 +102,6 @@ static int serial_fops_open(struct dfs_file *fd)
 
     rt_device_close(device);
     ret = rt_device_open(device, flags);
-    
     if (ret == RT_EOK)
     {
         serial = (struct rt_serial_device *)device;
@@ -150,7 +149,7 @@ static int serial_fops_ioctl(struct dfs_file *fd, int cmd, void *args)
 }
 
 #ifdef RT_USING_DFS_V2
-static ssize_t serial_fops_read(struct dfs_file *fd, void *buf, size_t count, off_t *pos)
+static ssize_t serial_fops_read(struct dfs_file *fd, void *buf, size_t count, dfs_off_t *pos)
 #else
 static ssize_t serial_fops_read(struct dfs_file *fd, void *buf, size_t count)
 #endif
@@ -190,7 +189,7 @@ static ssize_t serial_fops_read(struct dfs_file *fd, void *buf, size_t count)
 }
 
 #ifdef RT_USING_DFS_V2
-static ssize_t serial_fops_write(struct dfs_file *fd, const void *buf, size_t count, off_t *pos)
+static ssize_t serial_fops_write(struct dfs_file *fd, const void *buf, size_t count, dfs_off_t *pos)
 #else
 static ssize_t serial_fops_write(struct dfs_file *fd, const void *buf, size_t count)
 #endif
diff --git a/components/fal/src/fal_rtt.c b/components/fal/src/fal_rtt.c
index 5f4492cf572..ebb7cf016bd 100644
--- a/components/fal/src/fal_rtt.c
+++ b/components/fal/src/fal_rtt.c
@@ -438,7 +438,7 @@ static int char_dev_fopen(struct dfs_file *fd)
 }
 
 #ifdef RT_USING_DFS_V2
-static rt_ssize_t char_dev_fread(struct dfs_file *fd, void *buf, size_t count, off_t *pos)
+static rt_ssize_t char_dev_fread(struct dfs_file *fd, void *buf, size_t count, dfs_off_t *pos)
 #else
 static rt_ssize_t char_dev_fread(struct dfs_file *fd, void *buf, size_t count)
 #endif
@@ -446,7 +446,7 @@ static rt_ssize_t char_dev_fread(struct dfs_file *fd, void *buf, size_t count)
     rt_ssize_t ret = 0;
     struct fal_char_device *part = (struct fal_char_device *) fd->vnode->data;
 #ifndef RT_USING_DFS_V2
-    off_t *pos = &(fd->pos);
+    dfs_off_t *pos = &(fd->pos);
 #endif
 
     RT_ASSERT(part != RT_NULL);
@@ -465,7 +465,7 @@ static rt_ssize_t char_dev_fread(struct dfs_file *fd, void *buf, size_t count)
 }
 
 #ifdef RT_USING_DFS_V2
-static rt_ssize_t char_dev_fwrite(struct dfs_file *fd, const void *buf, size_t count, off_t *pos)
+static rt_ssize_t char_dev_fwrite(struct dfs_file *fd, const void *buf, size_t count, dfs_off_t *pos)
 #else
 static rt_ssize_t char_dev_fwrite(struct dfs_file *fd, const void *buf, size_t count)
 #endif
@@ -473,7 +473,7 @@ static rt_ssize_t char_dev_fwrite(struct dfs_file *fd, const void *buf, size_t c
     rt_ssize_t ret = 0;
     struct fal_char_device *part = (struct fal_char_device *) fd->vnode->data;
 #ifndef RT_USING_DFS_V2
-    off_t *pos = &(fd->pos);
+    dfs_off_t *pos = &(fd->pos);
 #endif
 
     RT_ASSERT(part != RT_NULL);
diff --git a/components/finsh/msh_file.c b/components/finsh/msh_file.c
index cc67fe94d85..348cf3f24a2 100644
--- a/components/finsh/msh_file.c
+++ b/components/finsh/msh_file.c
@@ -429,10 +429,11 @@ static int cmd_rm(int argc, char **argv)
 
     for (index = 1; index < argc; index ++)
     {
-        struct stat s;
 #ifdef RT_USING_DFS_V2
+        struct dfs_stat s;
         if (dfs_file_lstat(argv[index], &s) == 0)
 #else
+        struct stat s;
         if (stat(argv[index], &s) == 0)
 #endif
         {
diff --git a/components/libc/compilers/common/include/sys/unistd.h b/components/libc/compilers/common/include/sys/unistd.h
index 824891d57e4..84e90fdd841 100644
--- a/components/libc/compilers/common/include/sys/unistd.h
+++ b/components/libc/compilers/common/include/sys/unistd.h
@@ -13,8 +13,16 @@
 #define __SYS_UNISTD_H__
 
 #include <stddef.h>
+#include <stdint.h>
+#include <rtconfig.h>
 #include <sys/types.h>
 
+#ifdef RT_USING_DFS_LARGE_FILE
+typedef int64_t dfs_off_t;
+#else
+typedef int32_t dfs_off_t;
+#endif
+
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -33,13 +41,13 @@ extern "C" {
 unsigned alarm(unsigned __secs);
 ssize_t read(int fd, void *buf, size_t len);
 ssize_t write(int fd, const void *buf, size_t len);
-off_t lseek(int fd, off_t offset, int whence);
+dfs_off_t lseek(int fd, dfs_off_t offset, int whence);
 int pause(void);
 int fsync(int fildes);
 long sysconf(int __name);
 int unlink(const char *pathname);
 int close(int d);
-int ftruncate(int fd, off_t length);
+int ftruncate(int fd, dfs_off_t length);
 int rmdir(const char *path);
 int chdir(const char *path);
 char *getcwd(char *buf, size_t size);
diff --git a/components/libc/posix/io/eventfd/eventfd.c b/components/libc/posix/io/eventfd/eventfd.c
index b42a9b01a0c..f799aaa1839 100644
--- a/components/libc/posix/io/eventfd/eventfd.c
+++ b/components/libc/posix/io/eventfd/eventfd.c
@@ -47,8 +47,8 @@ static ssize_t eventfd_write(struct dfs_file *file, const void *buf, size_t coun
 #else
 static int eventfd_close(struct dfs_file *file);
 static int eventfd_poll(struct dfs_file *file, struct rt_pollreq *req);
-static ssize_t eventfd_read(struct dfs_file *file, void *buf, size_t count, off_t *pos);
-static ssize_t eventfd_write(struct dfs_file *file, const void *buf, size_t count, off_t *pos);
+static ssize_t eventfd_read(struct dfs_file *file, void *buf, size_t count, dfs_off_t *pos);
+static ssize_t eventfd_write(struct dfs_file *file, const void *buf, size_t count, dfs_off_t *pos);
 #endif
 
 static const struct dfs_file_ops eventfd_fops =
@@ -123,7 +123,7 @@ static ssize_t eventfd_read(struct dfs_file *file, void *buf, size_t count)
  * @param   pos Pointer to the file position (not used).
  * @return  Number of bytes read on success, otherwise an error code.
  */
-static ssize_t eventfd_read(struct dfs_file *file, void *buf, size_t count, off_t *pos)
+static ssize_t eventfd_read(struct dfs_file *file, void *buf, size_t count, dfs_off_t *pos)
 #endif
 {
     struct eventfd_ctx *ctx = (struct eventfd_ctx *)file->vnode->data;
@@ -190,7 +190,7 @@ static ssize_t eventfd_write(struct dfs_file *file, const void *buf, size_t coun
  * @param   pos Pointer to the file position (not used).
  * @return  Number of bytes written on success, otherwise an error code.
  */
-static ssize_t eventfd_write(struct dfs_file *file, const void *buf, size_t count, off_t *pos)
+static ssize_t eventfd_write(struct dfs_file *file, const void *buf, size_t count, dfs_off_t *pos)
 #endif
 {
     struct eventfd_ctx *ctx = (struct eventfd_ctx *)file->vnode->data;
diff --git a/components/libc/posix/io/signalfd/signalfd.c b/components/libc/posix/io/signalfd/signalfd.c
index b4a08fa9467..969b99df10e 100644
--- a/components/libc/posix/io/signalfd/signalfd.c
+++ b/components/libc/posix/io/signalfd/signalfd.c
@@ -40,7 +40,7 @@ static int signalfd_poll(struct dfs_file *file, struct rt_pollreq *req);
 #ifndef RT_USING_DFS_V2
 static ssize_t signalfd_read(struct dfs_file *file, void *buf, size_t count);
 #else
-static ssize_t signalfd_read(struct dfs_file *file, void *buf, size_t count, off_t *pos);
+static ssize_t signalfd_read(struct dfs_file *file, void *buf, size_t count, dfs_off_t *pos);
 #endif
 static int signalfd_add_notify(struct rt_signalfd_ctx *sfd);
 
@@ -121,7 +121,7 @@ static ssize_t signalfd_read(struct dfs_file *file, void *buf, size_t count)
  * @param   pos     Pointer to the file offset.
  * @return  Upon successful completion, returns the number of bytes read; otherwise, returns an negative error code.
  */
-static ssize_t signalfd_read(struct dfs_file *file, void *buf, size_t count, off_t *pos)
+static ssize_t signalfd_read(struct dfs_file *file, void *buf, size_t count, dfs_off_t *pos)
 #endif
 {
     struct rt_signalfd_ctx *sfd = RT_NULL;
diff --git a/components/libc/posix/io/timerfd/timerfd.c b/components/libc/posix/io/timerfd/timerfd.c
index ddf46fd91ae..48995ff3aed 100644
--- a/components/libc/posix/io/timerfd/timerfd.c
+++ b/components/libc/posix/io/timerfd/timerfd.c
@@ -52,7 +52,7 @@ static int timerfd_poll(struct dfs_file *file, struct rt_pollreq *req);
 #ifndef RT_USING_DFS_V2
 static ssize_t timerfd_read(struct dfs_file *file, void *buf, size_t count);
 #else
-static ssize_t timerfd_read(struct dfs_file *file, void *buf, size_t count, off_t *pos);
+static ssize_t timerfd_read(struct dfs_file *file, void *buf, size_t count, dfs_off_t *pos);
 #endif
 
 static const struct dfs_file_ops timerfd_fops =
@@ -116,7 +116,7 @@ static int timerfd_poll(struct dfs_file *file, struct rt_pollreq *req)
 #ifndef RT_USING_DFS_V2
 static ssize_t timerfd_read(struct dfs_file *file, void *buf, size_t count)
 #else
-static ssize_t timerfd_read(struct dfs_file *file, void *buf, size_t count, off_t *pos)
+static ssize_t timerfd_read(struct dfs_file *file, void *buf, size_t count, dfs_off_t *pos)
 #endif
 {
     struct rt_timerfd *tfd;
diff --git a/components/lwp/lwp_syscall.c b/components/lwp/lwp_syscall.c
index de147d5f099..d9d2dffda6a 100644
--- a/components/lwp/lwp_syscall.c
+++ b/components/lwp/lwp_syscall.c
@@ -91,6 +91,26 @@
 #define SYSCALL_USPACE(f) SYSCALL_SIGN(sys_notimpl)
 #endif /* defined(RT_USING_DFS) && defined(ARCH_MM_MMU) */
 
+#if defined(RT_USING_DFS) && defined(RT_USING_DFS_V2)
+static void lwp_dfs_stat_to_posix_stat(const struct dfs_stat *dfs_buf, struct stat *buf)
+{
+    rt_memset(buf, 0, sizeof(struct stat));
+    buf->st_dev = dfs_buf->st_dev;
+    buf->st_ino = dfs_buf->st_ino;
+    buf->st_mode = dfs_buf->st_mode;
+    buf->st_nlink = dfs_buf->st_nlink;
+    buf->st_uid = dfs_buf->st_uid;
+    buf->st_gid = dfs_buf->st_gid;
+    buf->st_rdev = (dev_t)(rt_ubase_t)dfs_buf->st_rdev;
+    buf->st_size = dfs_buf->st_size;
+    buf->st_atime = dfs_buf->atime;
+    buf->st_mtime = dfs_buf->mtime;
+    buf->st_ctime = dfs_buf->ctime;
+    buf->st_blksize = dfs_buf->st_blksize;
+    buf->st_blocks = dfs_buf->st_blocks;
+}
+#endif
+
 #include "lwp_ipc_internal.h"
 #include <sched.h>
 
@@ -4536,6 +4556,9 @@ sysret_t sys_lstat(const char *file, struct stat *buf)
     size_t copy_len;
     char *copy_path;
     struct stat statbuff = { 0 };
+#ifdef RT_USING_DFS_V2
+    struct dfs_stat dfs_statbuff = { 0 };
+#endif
 
     if (!lwp_user_accessable((void *)buf, sizeof(struct stat)))
     {
@@ -4562,7 +4585,11 @@ sysret_t sys_lstat(const char *file, struct stat *buf)
     }
     copy_path[copy_len] = '\0';
 #ifdef RT_USING_DFS_V2
-    ret = _SYS_WRAP(dfs_file_lstat(copy_path, &statbuff));
+    ret = _SYS_WRAP(dfs_file_lstat(copy_path, &dfs_statbuff));
+    if (ret == 0)
+    {
+        lwp_dfs_stat_to_posix_stat(&dfs_statbuff, &statbuff);
+    }
 #else
     ret = _SYS_WRAP(stat(copy_path, &statbuff));
 #endif
@@ -9816,7 +9843,11 @@ sysret_t sys_mount(char *source, char *target, char *filesystemtype,
     size_t len_source, len_target, len_fs;
     char *tmp = NULL;
     int ret = 0;
+#ifdef RT_USING_DFS_V2
+    struct dfs_stat buf = { 0 };
+#else
     struct stat buf = { 0 };
+#endif
     char *dev_fullpath = RT_NULL;
 
     len_source = source ? lwp_user_strlen(source) : 0;
@@ -10514,7 +10545,7 @@ sysret_t sys_reboot(int magic, int magic2, int type, void *arg)
 ssize_t sys_pread64(int fd, void *buf, int size, size_t offset)
 #ifdef RT_USING_DFS_V2
 {
-    ssize_t pread(int fd, void *buf, size_t len, size_t offset);
+    ssize_t pread(int fd, void *buf, size_t len, dfs_off_t offset);
 #ifdef ARCH_MM_MMU
     ssize_t ret = -1;
     void *kmem = RT_NULL;
@@ -10588,7 +10619,7 @@ ssize_t sys_pread64(int fd, void *buf, int size, size_t offset)
 ssize_t sys_pwrite64(int fd, void *buf, int size, size_t offset)
 #ifdef RT_USING_DFS_V2
 {
-    ssize_t pwrite(int fd, const void *buf, size_t len, size_t offset);
+    ssize_t pwrite(int fd, const void *buf, size_t len, dfs_off_t offset);
 #ifdef ARCH_MM_MMU
     ssize_t ret = -1;
     void *kmem = RT_NULL;
diff --git a/components/lwp/terminal/tty_device.c b/components/lwp/terminal/tty_device.c
index 17364fabc10..e63ba65338e 100644
--- a/components/lwp/terminal/tty_device.c
+++ b/components/lwp/terminal/tty_device.c
@@ -122,7 +122,7 @@ static int tty_fops_ioctl(struct dfs_file *file, int cmd, void *arg)
 }
 
 static ssize_t tty_fops_read(struct dfs_file *file, void *buf, size_t count,
-                             off_t *pos)
+                             dfs_off_t *pos)
 {
     ssize_t rc = 0;
     int error;
@@ -173,7 +173,7 @@ static ssize_t tty_fops_read(struct dfs_file *file, void *buf, size_t count,
 }
 
 static ssize_t tty_fops_write(struct dfs_file *file, const void *buf,
-                              size_t count, off_t *pos)
+                              size_t count, dfs_off_t *pos)
 {
     ssize_t rc = 0;
     int error;
@@ -227,12 +227,12 @@ static int tty_fops_flush(struct dfs_file *file)
     return -EINVAL;
 }
 
-static off_t tty_fops_lseek(struct dfs_file *file, off_t offset, int wherece)
+static dfs_off_t tty_fops_lseek(struct dfs_file *file, dfs_off_t offset, int wherece)
 {
     return -EINVAL;
 }
 
-static int tty_fops_truncate(struct dfs_file *file, off_t offset)
+static int tty_fops_truncate(struct dfs_file *file, dfs_off_t offset)
 {
     /**
      * regarding to POSIX.1, TRUNC is not supported for tty device.
@@ -347,8 +347,7 @@ static void tty_init_termios(lwp_tty_t tp)
     t->__c_ispeed = TTYDEF_SPEED;
     t->__c_ospeed = TTYDEF_SPEED;
 
-    memcpy(&t->c_cc, tty_ctrl_charset,
-           sizeof(tty_ctrl_charset) / sizeof(tty_ctrl_charset[0]));
+    memcpy(&t->c_cc, tty_ctrl_charset, sizeof(t->c_cc));
 
 #ifdef USING_BSD_INIT_LOCK_DEVICE
     tp->t_termios_init_out = *t;
diff --git a/components/lwp/terminal/tty_ptmx.c b/components/lwp/terminal/tty_ptmx.c
index 371c27a26b0..a2e62fcb740 100644
--- a/components/lwp/terminal/tty_ptmx.c
+++ b/components/lwp/terminal/tty_ptmx.c
@@ -74,7 +74,7 @@ static int ptm_fops_close(struct dfs_file *file)
 }
 
 static ssize_t ptm_fops_read(struct dfs_file *file, void *buf, size_t count,
-                             off_t *pos)
+                             dfs_off_t *pos)
 {
     ssize_t rc = 0;
     int error;
@@ -115,7 +115,7 @@ static ssize_t ptm_fops_read(struct dfs_file *file, void *buf, size_t count,
 }
 
 static ssize_t ptm_fops_write(struct dfs_file *file, const void *buf,
-                              size_t count, off_t *pos)
+                              size_t count, dfs_off_t *pos)
 {
     ssize_t rc = 0;
     int error;
@@ -215,12 +215,12 @@ static int ptm_fops_flush(struct dfs_file *file)
     return -EINVAL;
 }
 
-static off_t ptm_fops_lseek(struct dfs_file *file, off_t offset, int wherece)
+static dfs_off_t ptm_fops_lseek(struct dfs_file *file, dfs_off_t offset, int wherece)
 {
     return -EINVAL;
 }
 
-static int ptm_fops_truncate(struct dfs_file *file, off_t offset)
+static int ptm_fops_truncate(struct dfs_file *file, dfs_off_t offset)
 {
     return -EINVAL;
 }
diff --git a/components/net/sal/dfs_net/dfs_net.c b/components/net/sal/dfs_net/dfs_net.c
index cae03c40a1c..918ab51513c 100644
--- a/components/net/sal/dfs_net/dfs_net.c
+++ b/components/net/sal/dfs_net/dfs_net.c
@@ -47,7 +47,7 @@ static int dfs_net_ioctl(struct dfs_file* file, int cmd, void* args)
 }
 
 #ifdef RT_USING_DFS_V2
-static ssize_t dfs_net_read(struct dfs_file* file, void *buf, size_t count, off_t *pos)
+static ssize_t dfs_net_read(struct dfs_file* file, void *buf, size_t count, dfs_off_t *pos)
 #else
 static ssize_t dfs_net_read(struct dfs_file* file, void *buf, size_t count)
 #endif
@@ -66,7 +66,7 @@ static ssize_t dfs_net_read(struct dfs_file* file, void *buf, size_t count)
 }
 
 #ifdef RT_USING_DFS_V2
-static ssize_t dfs_net_write(struct dfs_file *file, const void *buf, size_t count, off_t *pos)
+static ssize_t dfs_net_write(struct dfs_file *file, const void *buf, size_t count, dfs_off_t *pos)
 #else
 static ssize_t dfs_net_write(struct dfs_file *file, const void *buf, size_t count)
 #endif