developer/xiuos
1
0
Fork 0
forked from xuos/xiuos
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Valid 3 code version

Browse Source
This commit is contained in:
TXuian
2024-10-31 12:42:45 +08:00
parent 7b6c93d391
commit 3e1479bdf0
34 changed files with 831 additions and 520 deletions
Download Patch File Download Diff File Expand all files Collapse all files

31
Ubiquitous/XiZi_AIoT/softkernel/task/memspace.c
View File

@@ -62,10 +62,12 @@ struct MemSpace* alloc_memspace(char* name)
return NULL;
}
pmemspace->mem_usage.mem_block_root = NULL;
if (!CreateResourceTag(&pmemspace->mem_usage.tag, &pmemspace->tag, "MemUsage", TRACER_SYSOBJECT, (void*)&pmemspace->mem_usage)) {
rbtree_init(&pmemspace->kernspace_mem_usage.mem_block_map);
if (!CreateResourceTag(&pmemspace->kernspace_mem_usage.tag, &pmemspace->tag, "MemUsage", TRACER_SYSOBJECT, (void*)&pmemspace->kernspace_mem_usage) || //
!CreateResourceTag(&pmemspace->userspace_mem_usage.tag, &pmemspace->tag, "UserMemUsage", TRACER_SYSOBJECT, (void*)&pmemspace->userspace_mem_usage)) {
DEBUG("Register MemUsage %s failed\n", name);
slab_free(&xizi_task_manager.memspace_allocator, (void*)pmemspace);
DeleteResource(&pmemspace->tag, &xizi_task_manager.tag);
return NULL;
}
return pmemspace;
@@ -74,29 +76,26 @@ struct MemSpace* alloc_memspace(char* name)
void free_memspace(struct MemSpace* pmemspace)
{
assert(pmemspace != NULL);
assert(IS_DOUBLE_LIST_EMPTY(&pmemspace->thread_list_guard));
/* free page table and all its allocated memories */
if (pmemspace->pgdir.pd_addr != NULL) {
xizi_pager.free_user_pgdir(&pmemspace->pgdir);
}
// TracerNode* tmp_node = NULL;
// DOUBLE_LIST_FOR_EACH_ENTRY(tmp_node, &pmemspace->tag.meta->children_guard, list_node)
// {
// assert((uintptr_t)tmp_node->p_resource >= PHY_MEM_BASE && (uintptr_t)tmp_node->p_resource < PHY_MEM_STOP);
// if ((uintptr_t)tmp_node->p_resource < PHY_USER_FREEMEM_BASE) {
// kfree(P2V(tmp_node->p_resource));
// } else {
// raw_free(tmp_node->p_resource);
// }
// }
// delete space
RbtNode* rbt_node = pmemspace->mem_usage.mem_block_root;
RbtNode* rbt_node = pmemspace->kernspace_mem_usage.mem_block_map.root;
while (rbt_node != NULL) {
assert((uintptr_t)V2P(rbt_node->key) >= PHY_MEM_BASE && (uintptr_t)V2P(rbt_node->key) < PHY_MEM_STOP);
kfree_by_ownership(pmemspace->mem_usage.tag, (void*)rbt_node->key);
rbt_node = pmemspace->mem_usage.mem_block_root;
kfree_by_ownership(pmemspace->kernspace_mem_usage.tag, (void*)rbt_node->key);
rbt_node = pmemspace->kernspace_mem_usage.mem_block_map.root;
}
rbt_node = pmemspace->userspace_mem_usage.mem_block_map.root;
while (rbt_node != NULL) {
assert((uintptr_t)rbt_node->key >= PHY_MEM_BASE && (uintptr_t)rbt_node->key < PHY_MEM_STOP);
raw_free_by_ownership(pmemspace->userspace_mem_usage.tag, (void*)rbt_node->key);
rbt_node = pmemspace->userspace_mem_usage.mem_block_map.root;
}
/* free ipc virt address allocator */

63
Ubiquitous/XiZi_AIoT/softkernel/task/semaphore.c
View File

@@ -24,29 +24,28 @@
void semaphore_pool_init(struct XiziSemaphorePool* sem_pool)
{
assert(sem_pool != NULL);
sem_pool->next_sem_id = 1;
sem_pool->next_sem_id = INVALID_SEM_ID + 1;
slab_init(&sem_pool->allocator, sizeof(struct ksemaphore));
doubleListNodeInit(&sem_pool->sem_list_guard);
rbtree_init(&sem_pool->sem_pool_map);
sem_pool->nr_sem = 0;
}
static inline struct ksemaphore* ksemaphore_get_by_id(struct XiziSemaphorePool* sem_pool, int sem_id)
static inline struct ksemaphore* ksemaphore_get_by_id(struct XiziSemaphorePool* sem_pool, sem_id_t sem_id)
{
struct ksemaphore* sem = NULL;
DOUBLE_LIST_FOR_EACH_ENTRY(sem, &sem_pool->sem_list_guard, sem_list_node)
{
if (sem->id == sem_id) {
return sem;
}
RbtNode* target_sem_node = rbt_search(&sem_pool->sem_pool_map, sem_id);
if (target_sem_node == NULL) {
return NULL;
}
return NULL;
return (struct ksemaphore*)target_sem_node->data;
}
int ksemaphore_alloc(struct XiziSemaphorePool* sem_pool, int val)
sem_id_t ksemaphore_alloc(struct XiziSemaphorePool* sem_pool, sem_val_t val)
{
struct ksemaphore* sem = (struct ksemaphore*)slab_alloc(&sem_pool->allocator);
if (sem == NULL) {
ERROR("No memeory to alloc new semaphore.\n");
return -1;
return INVALID_SEM_ID;
}
/* No error down here */
@@ -55,19 +54,34 @@ int ksemaphore_alloc(struct XiziSemaphorePool* sem_pool, int val)
sem->id = sem_pool->next_sem_id++;
if (UNLIKELY(sem->id == 0)) {
slab_free(&sem_pool->allocator, sem);
return -1;
return INVALID_SEM_ID;
}
sem->val = val;
doubleListNodeInit(&sem->sem_list_node);
doubleListNodeInit(&sem->wait_list_guard);
/* list sem to sem_pool */
rbt_insert(&sem_pool->sem_pool_map, sem->id, sem);
doubleListAddOnHead(&sem->sem_list_node, &sem_pool->sem_list_guard);
sem_pool->nr_sem++;
return sem->id;
}
bool ksemaphore_wait(struct XiziSemaphorePool* sem_pool, struct Thread* thd, uint32_t sem_id)
bool ksemaphore_consume(struct XiziSemaphorePool* sem_pool, sem_id_t sem_id, sem_val_t decre)
{
struct ksemaphore* sem = ksemaphore_get_by_id(sem_pool, sem_id);
// invalid sem id
if (sem == NULL) {
return false;
}
// if (decre >= 0) {
sem->val -= decre;
// }
return true;
}
bool ksemaphore_wait(struct XiziSemaphorePool* sem_pool, struct Thread* thd, sem_id_t sem_id)
{
assert(thd != NULL);
assert(thd->state == RUNNING);
@@ -77,6 +91,7 @@ bool ksemaphore_wait(struct XiziSemaphorePool* sem_pool, struct Thread* thd, uin
if (sem == NULL) {
return false;
}
// DEBUG("%s waiting sem %lu(%d), nr_sem: %d I\n", thd->name, sem_id, sem->val, sem_pool->nr_sem);
// no need to wait
if (sem->val > 0) {
@@ -91,7 +106,7 @@ bool ksemaphore_wait(struct XiziSemaphorePool* sem_pool, struct Thread* thd, uin
return true;
}
bool ksemaphore_signal(struct XiziSemaphorePool* sem_pool, uint32_t sem_id)
bool ksemaphore_signal(struct XiziSemaphorePool* sem_pool, sem_id_t sem_id)
{
/* find sem */
struct ksemaphore* sem = ksemaphore_get_by_id(sem_pool, sem_id);
@@ -105,6 +120,7 @@ bool ksemaphore_signal(struct XiziSemaphorePool* sem_pool, uint32_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);
}
}
@@ -112,7 +128,20 @@ bool ksemaphore_signal(struct XiziSemaphorePool* sem_pool, uint32_t sem_id)
return true;
}
bool ksemaphore_free(struct XiziSemaphorePool* sem_pool, uint32_t sem_id)
bool ksemaphore_signal_no_wake(struct XiziSemaphorePool* sem_pool, sem_id_t sem_id)
{
/* find sem */
struct ksemaphore* sem = ksemaphore_get_by_id(sem_pool, sem_id);
// invalid sem id
if (sem == NULL) {
return false;
}
sem->val++;
return true;
}
bool ksemaphore_free(struct XiziSemaphorePool* sem_pool, sem_id_t sem_id)
{
/* find sem */
struct ksemaphore* sem = ksemaphore_get_by_id(sem_pool, sem_id);
@@ -128,8 +157,10 @@ bool ksemaphore_free(struct XiziSemaphorePool* sem_pool, uint32_t sem_id)
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;
}

29
Ubiquitous/XiZi_AIoT/softkernel/task/task.c
View File

@@ -117,8 +117,10 @@ int _task_return_sys_resources(struct Thread* ptask)
assert(session_backend->server == ptask);
// cut the connection from task to session
server_session->closed = true;
rbt_delete(&ptask->svr_sess_map, session_backend->session_id);
xizi_share_page_manager.delete_share_pages(session_backend);
}
// close all client_sessions
struct client_session* client_session = NULL;
while (!IS_DOUBLE_LIST_EMPTY(&ptask->cli_sess_listhead)) {
@@ -128,6 +130,7 @@ int _task_return_sys_resources(struct Thread* ptask)
assert(session_backend->client == ptask);
// cut the connection from task to session
client_session->closed = true;
rbt_delete(&ptask->cli_sess_map, session_backend->session_id);
xizi_share_page_manager.delete_share_pages(session_backend);
}
@@ -174,13 +177,16 @@ static void _dealloc_task_cb(struct Thread* task)
}
}
/* free thread's kernel stack */
if (task->thread_context.kern_stack_addr) {
kfree_by_ownership(task->memspace->mem_usage.tag, (char*)task->thread_context.kern_stack_addr);
}
// remove thread from used task list
task_node_leave_list(task);
/* free memspace if needed to */
if (task->memspace != NULL) {
/* free thread's kernel stack */
if (task->thread_context.kern_stack_addr) {
// kfree_by_ownership(task->memspace->kernspace_mem_usage.tag, (char*)task->thread_context.kern_stack_addr);
}
// awake deamon in this memspace
if (task->memspace->thread_to_notify != NULL) {
if (task->memspace->thread_to_notify != task) {
@@ -195,6 +201,7 @@ static void _dealloc_task_cb(struct Thread* task)
}
doubleListDel(&task->memspace_list_node);
/* free memspace if thread is the last one using it */
if (IS_DOUBLE_LIST_EMPTY(&task->memspace->thread_list_guard)) {
// free memspace
@@ -202,9 +209,6 @@ static void _dealloc_task_cb(struct Thread* task)
}
}
// remove thread from used task list
task_node_leave_list(task);
// free task back to allocator
slab_free(&xizi_task_manager.task_allocator, (void*)task);
}
@@ -227,15 +231,20 @@ static struct Thread* _new_task_cb(struct MemSpace* pmemspace)
/* init basic task member */
doubleListNodeInit(&task->cli_sess_listhead);
rbtree_init(&task->cli_sess_map);
doubleListNodeInit(&task->svr_sess_listhead);
rbtree_init(&task->svr_sess_map);
queue_init(&task->sessions_in_handle);
queue_init(&task->sessions_to_be_handle);
/* when creating a new task, memspace will be freed outside during memory shortage */
task->memspace = NULL;
assert(pmemspace != NULL);
task->memspace = pmemspace;
/* init main thread of task */
task->thread_context.task = task;
// alloc stack page for task
if ((void*)(task->thread_context.kern_stack_addr = (uintptr_t)kalloc_by_ownership(pmemspace->mem_usage.tag, USER_STACK_SIZE)) == NULL) {
if ((void*)(task->thread_context.kern_stack_addr = (uintptr_t)kalloc_by_ownership(pmemspace->kernspace_mem_usage.tag, USER_STACK_SIZE)) == NULL) {
/* here inside, will no free memspace */
_dealloc_task_cb(task);
return NULL;
@@ -243,8 +252,6 @@ static struct Thread* _new_task_cb(struct MemSpace* pmemspace)
/* from now on, _new_task_cb() will not generate error */
/* init vm */
assert(pmemspace != NULL);
task->memspace = pmemspace;
task->thread_context.user_stack_idx = -1;
doubleListNodeInit(&task->memspace_list_node);
doubleListAddOnBack(&task->memspace_list_node, &pmemspace->thread_list_guard);