kernel: fix memory leak

This patch contains part of changes from "bc0000e8e1: fix memory leak"
of branch dev-canmv-plctv2.

On orginal branch, there are some additional changes, including:
- components/dfs/dfs_v2/filesystems/devfs/devfs.c, which has been
  pulled in with RT-Thread#9899.
- nfs part, which are merged with nfs changes.

The remaining part still involves three modules:
- dfs
- lwp
- libcpu/c908
Need to continue to decompose.

Signed-off-by: Wang Chen <[email protected]>

Author: yixinghua121

components/dfs/dfs_v2/include/dfs_file.h

@@ -89,6 +89,7 @@ struct dfs_file
 
     uint32_t flags;
     rt_atomic_t ref_count;
+    rt_atomic_t fd_ref_count;
 
     off_t fpos;
     struct rt_mutex pos_lock;

components/dfs/dfs_v2/src/dfs.c

@@ -223,6 +223,7 @@ int fdt_fd_new(struct dfs_fdtable *fdt)
         {
             file->magic = DFS_FD_MAGIC;
             file->ref_count = 1;
+            file->fd_ref_count = 1;
             rt_mutex_init(&file->pos_lock, "fpos", RT_IPC_FLAG_PRIO);
             fdt->fds[idx] = file;
 
@@ -253,20 +254,27 @@ void fdt_fd_release(struct dfs_fdtable *fdt, int fd)
 
         file = fdt_get_file(fdt, fd);
 
-        if (file && file->ref_count == 1)
+        if (file)
         {
-            rt_mutex_detach(&file->pos_lock);
-
-            if (file->mmap_context)
+            if (file->fd_ref_count)
             {
-                rt_free(file->mmap_context);
+                rt_atomic_sub(&(file->fd_ref_count), 1);
             }
+            if (file->ref_count == 1)
+            {
+                rt_mutex_detach(&file->pos_lock);
 
-            rt_free(file);
-        }
-        else
-        {
-            rt_atomic_sub(&(file->ref_count), 1);
+                if (file->mmap_context)
+                {
+                    rt_free(file->mmap_context);
+                }
+
+                rt_free(file);
+            }
+            else
+            {
+                rt_atomic_sub(&(file->ref_count), 1);
+            }
         }
 
         fdt->fds[fd] = RT_NULL;
@@ -334,6 +342,7 @@ int fdt_fd_associate_file(struct dfs_fdtable *fdt, int fd, struct dfs_file *file
 
     /* inc ref_count */
     rt_atomic_add(&(file->ref_count), 1);
+    rt_atomic_add(&(file->fd_ref_count), 1);
     fdt->fds[fd] = file;
     retfd = fd;
 
@@ -552,6 +561,7 @@ int dfs_dup(int oldfd, int startfd)
 
         /* inc ref_count */
         rt_atomic_add(&(fdt->fds[newfd]->ref_count), 1);
+        rt_atomic_add(&(fdt->fds[newfd]->fd_ref_count), 1);
     }
 exit:
     dfs_file_unlock();
@@ -600,6 +610,7 @@ int dfs_dup_to(int oldfd, struct dfs_fdtable *fdtab)
 
         /* inc ref_count */
         rt_atomic_add(&(fdtab->fds[newfd]->ref_count), 1);
+        rt_atomic_add(&(fdtab->fds[newfd]->fd_ref_count), 1);
     }
 exit:
     dfs_file_unlock();
@@ -736,6 +747,7 @@ rt_err_t sys_dup2(int oldfd, int newfd)
     fdt->fds[newfd] = fdt->fds[oldfd];
     /* inc ref_count */
     rt_atomic_add(&(fdt->fds[newfd]->ref_count), 1);
+    rt_atomic_add(&(fdt->fds[newfd]->fd_ref_count), 1);
     retfd = newfd;
 exit:
     dfs_file_unlock();

components/dfs/dfs_v2/src/dfs_file.c

@@ -194,6 +194,7 @@ void dfs_file_init(struct dfs_file *file)
         file->magic = DFS_FD_MAGIC;
         rt_mutex_init(&file->pos_lock, "fpos", RT_IPC_FLAG_PRIO);
         rt_atomic_store(&(file->ref_count), 1);
+        rt_atomic_store(&(file->fd_ref_count), 1);
     }
 }
 
@@ -233,6 +234,15 @@ static void dfs_file_unref(struct dfs_file *file)
                     file->vnode = RT_NULL;
                 }
             }
+            if (file->fd_ref_count == 0)
+            {
+                rt_mutex_detach(&file->pos_lock);
+                if (file->mmap_context)
+                {
+                    rt_free(file->mmap_context);
+                }
+                rt_free(file);
+            }
 
             LOG_I("release a file: %p", file);
         }
@@ -684,6 +694,7 @@ int dfs_file_close(struct dfs_file *file)
                 if (file->vnode->aspace)
                 {
                     dfs_aspace_flush(file->vnode->aspace);
+                    dfs_aspace_clean(file->vnode->aspace);
                 }
 #endif
                 ret = file->fops->close(file);

components/lwp/lwp_futex.c

@@ -261,6 +261,8 @@ static rt_futex_t _sftx_create(struct shared_futex_key *key, struct rt_lwp *lwp)
                     futex->mutex = RT_NULL;
                     rt_list_init(&(futex->waiting_thread));
                     futex->custom_obj = obj;
+                    // todo fix multithread share futex
+                    lwp_user_object_add(lwp, obj);
                 }
             }
         }

libcpu/risc-v/t-head/c908/plic.c

@@ -21,6 +21,7 @@
 #include "ioremap.h"
 
 static void *plic_regs = RT_NULL;
+static void *priority_base;
 extern struct rt_irq_desc isr_table[];
 
 struct plic_handler
@@ -32,22 +33,14 @@ struct plic_handler
 
 rt_inline void plic_toggle(struct plic_handler *handler, int hwirq, int enable);
 struct plic_handler plic_handlers[C908_NR_CPUS];
-static void *plic_irq_priority[INTERRUPTS_MAX] = {RT_NULL};
 
 rt_inline void plic_irq_toggle(int hwirq, int enable)
 {
     int cpu = 0;
     void *priority_addr;
 
     /* set priority of interrupt, interrupt 0 is zero. */
-    priority_addr = (void *)((rt_size_t)plic_regs + PRIORITY_BASE + hwirq * PRIORITY_PER_ID);
-#ifdef RT_USING_SMART
-    if (plic_irq_priority[hwirq] == RT_NULL)
-    {
-        plic_irq_priority[hwirq] = (void *)rt_ioremap(priority_addr, 0x1000);
-    }
-    priority_addr = plic_irq_priority[hwirq];
-#endif
+    priority_addr = (void *)((rt_size_t)priority_base + hwirq * PRIORITY_PER_ID);
     writel(enable, priority_addr);
     struct plic_handler *handler = &plic_handlers[cpu];
 
@@ -203,8 +196,8 @@ void plic_init(void)
         handler->hart_base = (void *)((rt_size_t)plic_regs + CONTEXT_BASE + i * CONTEXT_PER_HART);
         handler->enable_base = (void *)((rt_size_t)plic_regs + ENABLE_BASE + i * ENABLE_PER_HART);
 #ifdef RT_USING_SMART
-        handler->hart_base = (void *)rt_ioremap(handler->hart_base, 0x1000);
-        handler->enable_base = (void *)rt_ioremap(handler->enable_base, 0x1000);
+        handler->hart_base = (void *)rt_ioremap(handler->hart_base, CONTEXT_PER_HART);
+        handler->enable_base = (void *)rt_ioremap(handler->enable_base, ENABLE_PER_HART);
 #endif
 done:
         /* priority must be > threshold to trigger an interrupt */
@@ -215,6 +208,11 @@ void plic_init(void)
         }
     }
 
+    priority_base = (void *)((rt_size_t)plic_regs + PRIORITY_BASE);
+#ifdef RT_USING_SMART
+    priority_base = (void *)rt_ioremap(priority_base, INTERRUPTS_MAX * PRIORITY_PER_ID);
+#endif
+
     /* Enable supervisor external interrupts. */
     set_csr(sie, SIE_SEIE);
 }