Add naive_mmap_with_attr

Ubiquitous/XiZi_AIoT/services/lib/usyscall/usyscall.c

@@ -158,6 +158,15 @@ int mmap_with_attr(uintptr_t vaddr, uintptr_t paddr, int len, uintptr_t attr)
     return syscall(SYSCALL_MMAP, (intptr_t)&vaddr_inner, (intptr_t)&paddr_inner, (intptr_t)len, (intptr_t)&info);
 }
 
+int naive_mmap_with_attr(uintptr_t* vaddr, uintptr_t* paddr, int len, uintptr_t attr)
+{
+    sys_mmap_info info = {
+        .type = SYS_MMAP_NORMAL,
+        .attr = attr,
+    };
+    return syscall(SYSCALL_MMAP, (uintptr_t)vaddr, (intptr_t)paddr, (intptr_t)len, (intptr_t)&info);
+}
+
 int register_irq(int irq, int opcode)
 {
     return syscall(SYSCALL_REGISTER_IRQ, (intptr_t)irq, (intptr_t)opcode, 0, 0);

Ubiquitous/XiZi_AIoT/services/lib/usyscall/usyscall.h

@@ -108,6 +108,7 @@ int register_irq(int irq, int opcode);
 uintptr_t mmap(uintptr_t vaddr, uintptr_t paddr, int len, bool is_dev);
 int naive_mmap(uintptr_t* vaddr, uintptr_t* paddr, int len, bool is_dev);
 int mmap_with_attr(uintptr_t vaddr, uintptr_t paddr, int len, uintptr_t attr);
+int naive_mmap_with_attr(uintptr_t* vaddr, uintptr_t* paddr, int len, uintptr_t attr);
 
 int task_heap_base();
 int get_memblock_info(sys_state_info* info);

Ubiquitous/XiZi_AIoT/softkernel/memory/share_page.c

@@ -331,9 +331,10 @@ int delete_share_pages(struct session_backend* session_backend)
             doubleListDel(&session_backend->client_side.node);
             session_backend->client->memspace->mem_size -= session_backend->nr_pages * PAGE_SIZE;
             session_backend->client = NULL;
-
-            assert(ksemaphore_free(&xizi_task_manager.semaphore_pool, session_backend->client_sem_to_wait));
         }
+
+        extern bool ksemaphore_free_safe(struct XiziSemaphorePool * sem_pool, sem_id_t sem_id, struct Thread * target);
+        assert(ksemaphore_free_safe(&xizi_task_manager.semaphore_pool, session_backend->client_sem_to_wait, session_backend->client));
     }
 
     /* free seesion backend */

Ubiquitous/XiZi_AIoT/softkernel/syscall/sys_mmap.c

@@ -77,8 +77,9 @@ int sys_mmap_v2(uintptr_t* vaddr, uintptr_t* paddr, int len, sys_mmap_info* info
     struct Thread* cur_task = cur_cpu()->task;
     assert(cur_task != NULL);
 
-    if (vaddr == NULL) {
+    if (vaddr == NULL || paddr == NULL) {
-        ERROR("Invalid vaddr from %s\n", cur_task->name);
+        ERROR("Invalid vaddr and paddr param from %s\n", cur_task->name);
+        return -1;
     }
 
     int true_len = ALIGNUP(len, PAGE_SIZE);
@@ -86,7 +87,8 @@ int sys_mmap_v2(uintptr_t* vaddr, uintptr_t* paddr, int len, sys_mmap_info* info
     sys_mmap_type type = info->type;
     uintptr_t vaddr_to_map = *vaddr;
     if (type == SYS_MMAP_CUSTOMIZE) {
-        if (paddr == NULL || *paddr == (uintptr_t)NULL || vaddr_to_map == (uintptr_t)NULL) {
+        if (*paddr != (uintptr_t)NULL) {
+            if (*paddr == (uintptr_t)NULL || vaddr_to_map == (uintptr_t)NULL) {
                 ERROR("Customized mapping from %s must have vaddr(%p) and paddr(%p)\n", cur_task->name, vaddr, paddr);
                 return -1;
             }
@@ -103,7 +105,32 @@ int sys_mmap_v2(uintptr_t* vaddr, uintptr_t* paddr, int len, sys_mmap_info* info
                 DeleteResource(&mem_signature_tag, &cur_task->memspace->tag);
                 return -1;
             }
+        } else {
+            char* new_paddr = raw_alloc_by_ownership(cur_task->memspace->userspace_mem_usage.tag, true_len);
+            if (new_paddr == NULL) {
+                ERROR("Alloc dynamic memory failed\n");
+                return -1;
+            }
 
+            TraceTag mem_signature_tag;
+            if (!CreateResourceTag(&mem_signature_tag, &cur_task->memspace->tag, "USER_MEMORY", TRACER_MEM_SIGNATURE, new_paddr)) {
+                raw_free_by_ownership(cur_task->memspace->userspace_mem_usage.tag, new_paddr);
+                ERROR("Sign memory signature failed from %s\n", cur_task->name);
+                return -1;
+            }
+
+            if (_map_customizable_page(cur_task->memspace, vaddr_to_map, (uintptr_t)new_paddr, len, info->attr) == (uintptr_t)NULL) {
+                raw_free_by_ownership(cur_task->memspace->userspace_mem_usage.tag, new_paddr);
+                DeleteResource(&mem_signature_tag, &cur_task->memspace->tag);
+                return -1;
+            }
+
+            // assign new_paddr back to user
+            *paddr = (uintptr_t)new_paddr;
+        }
+
+        cur_task->memspace->mem_size += true_len;
+        *vaddr = *vaddr + true_len;
         return 0;
     }
 

Ubiquitous/XiZi_AIoT/softkernel/syscall/sys_wait_session.c

@@ -40,12 +40,14 @@ int sys_wait_session(struct Session* userland_session)
     RbtNode* client_session_node = rbt_search(&cur_task->cli_sess_map, userland_session->id);
     if (client_session_node == NULL) {
         ERROR("Error waiting session from %s: Invalid session %d\n", cur_task->name, userland_session->id);
+        sys_exit(cur_task);
         return -1;
     }
 
     struct client_session* client_session = (struct client_session*)client_session_node->data;
     if (CLIENT_SESSION_BACKEND(client_session)->session_id != userland_session->id || //
         client_session->buf_addr != (uintptr_t)userland_session->buf) {
+        sys_exit(cur_task);
         ERROR("Error waiting session from %s: Invalid session %d\n", cur_task->name, userland_session->id);
         return -1;
     }

Ubiquitous/XiZi_AIoT/softkernel/task/semaphore.c

@@ -124,7 +124,6 @@ bool ksemaphore_signal(struct XiziSemaphorePool* sem_pool, sem_id_t sem_id)
             struct Thread* thd = CONTAINER_OF(sem->wait_list_guard.next, struct Thread, node);
             assert(thd != NULL && thd->state == BLOCKED);
             xizi_task_manager.task_unblock(thd);
-            // DEBUG("waking %s\n", thd->name);
         }
     }
 
@@ -157,7 +156,7 @@ bool ksemaphore_free(struct XiziSemaphorePool* sem_pool, sem_id_t sem_id)
     struct Thread* thd = NULL;
     DOUBLE_LIST_FOR_EACH_ENTRY(thd, &sem->wait_list_guard, node)
     {
-        assert(thd != NULL);
+        assert(thd != NULL && thd->state == BLOCKED);
         xizi_task_manager.task_unblock(thd);
     }
 
@@ -168,3 +167,29 @@ bool ksemaphore_free(struct XiziSemaphorePool* sem_pool, sem_id_t sem_id)
 
     return true;
 }
+
+bool ksemaphore_free_safe(struct XiziSemaphorePool* sem_pool, sem_id_t sem_id, struct Thread* target)
+{
+    /* find sem */
+    struct ksemaphore* sem = ksemaphore_get_by_id(sem_pool, sem_id);
+    // invalid sem id
+    if (sem == NULL) {
+        return false;
+    }
+
+    struct Thread* thd = NULL;
+    DOUBLE_LIST_FOR_EACH_ENTRY(thd, &sem->wait_list_guard, node)
+    {
+        assert(thd != NULL);
+        if (target != thd && thd->state == BLOCKED) {
+            xizi_task_manager.task_unblock(thd);
+        }
+    }
+
+    rbt_delete(&sem_pool->sem_pool_map, sem_id);
+    doubleListDel(&sem->sem_list_node);
+    slab_free(&sem_pool->allocator, sem);
+    sem_pool->nr_sem--;
+
+    return true;
+}

Ubiquitous/XiZi_AIoT/softkernel/task/task.c

@@ -82,7 +82,7 @@ static void _task_manager_init()
     doubleListNodeInit(&xizi_task_manager.task_sleep_list_head);
     // init task (slab) allocator
     slab_init(&xizi_task_manager.memspace_allocator, sizeof(struct MemSpace), "MemlpaceCtrlBlockAllocator");
-    slab_init(&xizi_task_manager.task_allocator, sizeof(struct Thread), "TreadCtrlBlockAllocator");
+    slab_init(&xizi_task_manager.task_allocator, sizeof(struct Thread), "ThreadCtrlBlockAllocator");
     slab_init(&xizi_task_manager.task_buddy_allocator, sizeof(struct KBuddy), "DMBuddyAllocator");
 
     /* global semaphore factory */