sync update dfs v2.

components/dfs/dfs_v2/filesystems/elmfat/dfs_elm.c

@@ -38,6 +38,7 @@
 
 
 static int dfs_elm_free_vnode(struct dfs_vnode *vnode);
+static int dfs_elm_truncate(struct dfs_file *file, off_t offset);
 
 #ifdef RT_USING_PAGECACHE
 static ssize_t dfs_elm_page_read(struct dfs_file *file, struct dfs_page *page);
@@ -547,33 +548,14 @@ int dfs_elm_ioctl(struct dfs_file *file, int cmd, void *args)
     switch (cmd)
     {
     case RT_FIOFTRUNCATE:
-        {
-            FIL *fd;
-            FSIZE_t fptr, length;
-            FRESULT result = FR_OK;
-            fd = (FIL *)(file->vnode->data);
-            RT_ASSERT(fd != RT_NULL);
-
-            /* save file read/write point */
-            fptr = fd->fptr;
-            length = *(off_t*)args;
-            if (length <= fd->obj.objsize)
-            {
-                fd->fptr = length;
-                result = f_truncate(fd);
-            }
-            else
-            {
-                result = f_lseek(fd, length);
-            }
-            /* restore file read/write point */
-            fd->fptr = fptr;
-            return elm_result_to_dfs(result);
-        }
+    {
+        off_t offset = (off_t)(size_t)(args);
+        return dfs_elm_truncate(file, offset);
+    }
     case F_GETLK:
-            return 0;
+        return 0;
     case F_SETLK:
-            return 0;
+        return 0;
     }
     return -ENOSYS;
 }
@@ -701,6 +683,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)
+{
+    FIL *fd;
+    FSIZE_t fptr;
+    FRESULT result = FR_OK;
+    fd = (FIL *)(file->vnode->data);
+    RT_ASSERT(fd != RT_NULL);
+
+    /* save file read/write point */
+    fptr = fd->fptr;
+    if (offset <= fd->obj.objsize)
+    {
+        fd->fptr = offset;
+        result = f_truncate(fd);
+    }
+    else
+    {
+        result = f_lseek(fd, offset);
+    }
+    /* restore file read/write point */
+    fd->fptr = fptr;
+    return elm_result_to_dfs(result);
+}
+
 int dfs_elm_getdents(struct dfs_file *file, struct dirent *dirp, uint32_t count)
 {
     DIR *dir;
@@ -1065,6 +1071,7 @@ static const struct dfs_file_ops dfs_elm_fops =
     .write = dfs_elm_write,
     .flush = dfs_elm_flush,
     .lseek = dfs_elm_lseek,
+    .truncate = dfs_elm_truncate,
     .getdents = dfs_elm_getdents,
 };
 

components/dfs/dfs_v2/include/dfs.h

@@ -109,6 +109,9 @@ void dfs_unlock(void);
 rt_err_t dfs_file_lock(void);
 void dfs_file_unlock(void);
 
+int dfs_dup_to(int oldfd, struct dfs_fdtable *fdtab);
+int dfs_dup_from(int oldfd, struct dfs_fdtable *fdtab);
+
 #ifdef DFS_USING_POSIX
 /* FD APIs */
 int fdt_fd_new(struct dfs_fdtable *fdt);

components/dfs/dfs_v2/include/dfs_file.h

@@ -181,6 +181,8 @@ int dfs_file_mmap2(struct dfs_file *file, struct dfs_mmap2_args *mmap2);
 int dfs_file_mmap(struct dfs_file *file, struct dfs_mmap2_args *mmap2);
 #endif
 
+char *dfs_nolink_path(struct dfs_mnt **mnt, char *fullpath, int mode);
+
 /* 0x5254 is just a magic number to make these relatively unique ("RT") */
 #define RT_FIOFTRUNCATE  0x52540000U
 #define RT_FIOGETADDR    0x52540001U

components/dfs/dfs_v2/src/dfs.c

@@ -451,6 +451,105 @@ int dfs_dup(int oldfd, int startfd)
     return newfd;
 }
 
+/**
+ * @brief  The fd in the current process dup to designate fd table.
+ *
+ * @param  oldfd is the fd in current process.
+ *
+ * @param  fdtab is the fd table to dup, if empty, use global (_fdtab).
+ *
+ * @return -1 on failed or the allocated file descriptor.
+ */
+int dfs_dup_to(int oldfd, struct dfs_fdtable *fdtab)
+{
+    int newfd = -1;
+    struct dfs_fdtable *fdt = NULL;
+
+    dfs_file_lock();
+
+    if (fdtab == NULL)
+    {
+        fdtab = &_fdtab;
+    }
+
+    /* check old fd */
+    fdt = dfs_fdtable_get();
+    if ((oldfd < 0) || (oldfd >= fdt->maxfd))
+    {
+        goto exit;
+    }
+    if (!fdt->fds[oldfd])
+    {
+        goto exit;
+    }
+    /* get a new fd*/
+    newfd = fd_slot_alloc(fdtab, DFS_STDIO_OFFSET);
+    if (newfd >= 0)
+    {
+        fdtab->fds[newfd] = fdt->fds[oldfd];
+
+        /* inc ref_count */
+        rt_atomic_add(&(fdtab->fds[newfd]->ref_count), 1);
+    }
+exit:
+    dfs_file_unlock();
+
+    return newfd;
+}
+
+/**
+ * @brief  The fd in the designate fd table dup to current process.
+ *
+ * @param  oldfd is the fd in the designate fd table.
+ *
+ * @param  fdtab is the fd table for oldfd, if empty, use global (_fdtab).
+ *
+ * @return -1 on failed or the allocated file descriptor.
+ */
+int dfs_dup_from(int oldfd, struct dfs_fdtable *fdtab)
+{
+    int newfd = -1;
+    struct dfs_file *file;
+
+    dfs_file_lock();
+
+    if (fdtab == NULL)
+    {
+        fdtab = &_fdtab;
+    }
+
+    /* check old fd */
+    if ((oldfd < 0) || (oldfd >= fdtab->maxfd))
+    {
+        goto exit;
+    }
+    if (!fdtab->fds[oldfd])
+    {
+        goto exit;
+    }
+    /* get a new fd*/
+    newfd = fd_new();
+    file = fd_get(newfd);
+    if (newfd >= 0 && file)
+    {
+        file->mode = fdtab->fds[oldfd]->mode;
+        file->flags = fdtab->fds[oldfd]->flags;
+        file->fops = fdtab->fds[oldfd]->fops;
+        file->dentry = dfs_dentry_ref(fdtab->fds[oldfd]->dentry);
+        file->vnode = fdtab->fds[oldfd]->vnode;
+        file->mmap_context = RT_NULL;
+        file->data = fdtab->fds[oldfd]->data;
+    }
+
+    dfs_file_close(fdtab->fds[oldfd]);
+
+exit:
+    fdt_fd_release(fdtab, oldfd);
+    dfs_file_unlock();
+
+    return newfd;
+}
+
 #ifdef RT_USING_SMART
 sysret_t sys_dup(int oldfd)
 #else

components/dfs/dfs_v2/src/dfs_dentry.c

@@ -131,6 +131,7 @@ struct dfs_dentry *dfs_dentry_unref(struct dfs_dentry *dentry)
                 LOG_I("free a dentry: %p", dentry);
                 rt_free(dentry->pathname);
                 rt_free(dentry);
+                dentry = RT_NULL;
             }
             else
             {
@@ -268,7 +269,7 @@ char* dfs_dentry_full_path(struct dfs_dentry* dentry)
         path = (char *) rt_malloc(mnt_len + path_len + 3);
         if (path)
         {
-            if (dentry->pathname[0] == '/')
+            if (dentry->pathname[0] == '/' || dentry->mnt->fullpath[mnt_len - 1] == '/')
             {
                 rt_snprintf(path, mnt_len + path_len + 2, "%s%s", dentry->mnt->fullpath,
                     dentry->pathname);

components/dfs/dfs_v2/src/dfs_file.c

@@ -424,7 +424,6 @@ int dfs_file_open(struct dfs_file *file, const char *path, int oflags, mode_t mo
                             dentry = dfs_dentry_create(mnt, fullpath);
                             if (dentry)
                             {
-                                mode &= ~S_IFMT;
                                 DLOG(msg, "dfs_file", mnt->fs_ops->name, DLOG_MSG, "fs_ops->create_vnode");
 
                                 if (dfs_is_mounted(mnt) == 0)
@@ -560,7 +559,6 @@ int dfs_file_open(struct dfs_file *file, const char *path, int oflags, mode_t mo
                     {
                         ret = -EINVAL;
                     }
-
                 }
             }
 

components/dfs/dfs_v2/src/dfs_file_mmap.c

@@ -350,6 +350,38 @@ rt_err_t on_varea_merge(struct rt_varea *merge_to, struct rt_varea *merge_from)
     return -RT_ERROR;
 }
 
+void *on_varea_mremap(struct rt_varea *varea, rt_size_t new_size, int flags, void *new_address)
+{
+    void *vaddr = RT_NULL;
+    struct dfs_file *file = dfs_mem_obj_get_file(varea->mem_obj);
+
+#ifndef MREMAP_MAYMOVE
+#define MREMAP_MAYMOVE 1
+#endif
+
+    if (file && flags == MREMAP_MAYMOVE)
+    {
+        int ret;
+        rt_mem_obj_t mem_obj = dfs_get_mem_obj(file);
+
+        vaddr = new_address ? new_address : varea->start;
+        new_size = (new_size + ARCH_PAGE_SIZE - 1);
+        new_size &= ~ARCH_PAGE_MASK;
+        ret = rt_aspace_map(varea->aspace, &vaddr, new_size, varea->attr, varea->flag, mem_obj, varea->offset);
+        if (ret != RT_EOK)
+        {
+            LOG_E("failed to map %lx with size %lx with errno %d", vaddr, new_size, ret);
+            vaddr = RT_NULL;
+        }
+        else
+        {
+            LOG_I("old: %p size: %p new: %p size: %p", varea->start, varea->size, vaddr, new_size);
+        }
+    }
+
+    return vaddr;
+}
+
 static struct rt_mem_obj _mem_obj =
 {
     .hint_free      = hint_free,
@@ -365,6 +397,8 @@ static struct rt_mem_obj _mem_obj =
     .on_varea_expand    = on_varea_expand,
     .on_varea_split     = on_varea_split,
     .on_varea_merge     = on_varea_merge,
+
+    .on_varea_mremap    = on_varea_mremap,
 };
 
 struct dfs_mem_obj {

components/dfs/dfs_v2/src/dfs_pcache.c

@@ -1355,6 +1355,10 @@ int dfs_aspace_unmap(struct dfs_file *file, struct rt_varea *varea)
 
                             if (map && varea == map->varea)
                             {
+                                void *vaddr = dfs_aspace_vaddr(map->varea, page->fpos);
+                                //rt_hw_cpu_dcache_ops(RT_HW_CACHE_FLUSH, vaddr, ARCH_PAGE_SIZE);
+                                rt_varea_unmap_page(map->varea, vaddr);
+
                                 if (varea->attr == MMU_MAP_U_RWCB && page->fpos < page->aspace->vnode->size)
                                 {
                                     dfs_page_dirty(page);