diff --git a/Ubiquitous/XiZi_AIoT/services/lib/usyscall/usyscall.c b/Ubiquitous/XiZi_AIoT/services/lib/usyscall/usyscall.c index f975d5aaf..48cfdd30b 100644 --- a/Ubiquitous/XiZi_AIoT/services/lib/usyscall/usyscall.c +++ b/Ubiquitous/XiZi_AIoT/services/lib/usyscall/usyscall.c @@ -1,132 +1,141 @@ -/* - * Copyright (c) 2020 AIIT XUOS Lab - * XiUOS is licensed under Mulan PSL v2. - * You can use this software according to the terms and conditions of the Mulan PSL v2. - * You may obtain a copy of Mulan PSL v2 at: - * http://license.coscl.org.cn/MulanPSL2 - * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, - * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, - * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. - * See the Mulan PSL v2 for more details. - */ -#include "usyscall.h" -#include "libmem.h" - -int spawn(struct Session* session, int fd, ipc_read_fn ipc_read, ipc_fsize_fn ipc_fsize, char* name, char** argv) -{ - /* read elf image */ - int file_size = ipc_fsize(session, fd); - void* img = malloc(file_size); - int read_len = 0; - while (read_len < file_size) { - int cur_read_len = file_size - read_len < 4096 ? file_size - read_len : 4096; - if (cur_read_len < 0) { - return -1; - } - read_len += ipc_read(session, fd, (char*)((uintptr_t)img + read_len), read_len, cur_read_len); - } - /* sys call */ - int ret = syscall(SYSCALL_SPAWN, (uintptr_t)img, (uintptr_t)name, (uintptr_t)argv, 0); - free(img); - return ret; -} - -int thread(void* entry, const char* name, char** argv) -{ - return syscall(SYSCALL_THREAD, (uintptr_t)entry, (uintptr_t)name, (uintptr_t)argv, 0); -} - -void exit(int status) -{ - syscall(SYSCALL_EXIT, (uintptr_t)status, 0, 0, 0); -} - -int yield(task_yield_reason reason) -{ - return syscall(SYSCALL_YIELD, (uintptr_t)reason, 0, 0, 0); -} - -int kill(int pid) -{ - return syscall(SYSCALL_KILL, (intptr_t)pid, 0, 0, 0); -} - -int register_server(char* name) -{ - return syscall(SYSCALL_SERVER, (intptr_t)name, 0, 0, 0); -} - -int session(char* path, int capacity, struct Session* user_session) -{ - return syscall(SYSCALL_SESSION, (intptr_t)path, (intptr_t)capacity, (intptr_t)user_session, 0); -} - -int poll_session(struct Session* userland_session_arr, int arr_capacity) -{ - return syscall(SYSCALL_POLL_SESSION, (intptr_t)userland_session_arr, (intptr_t)arr_capacity, 0, 0); -} - -int close_session(struct Session* session) -{ - return syscall(SYSCALL_CLOSE_SESSION, (intptr_t)session, 0, 0, 0); -} - -int get_memblock_info(sys_state_info* info) -{ - return syscall(SYSCALL_SYS_STATE, SYS_STATE_MEMBLOCK_INFO, (intptr_t)info, 0, 0); -} - -int set_priority(sys_state_info* info) -{ - return syscall(SYSCALL_SYS_STATE, SYS_STATE_SET_TASK_PRIORITY, (intptr_t)info, 0, 0); -} - -int task_heap_base() -{ - return syscall(SYSCALL_SYS_STATE, SYS_STATE_GET_HEAP_BASE, 0, 0, 0); -} - -int show_task() -{ - return syscall(SYSCALL_SYS_STATE, SYS_STATE_SHOW_TASKS, 0, 0, 0); -} - -int show_mem() -{ - return syscall(SYSCALL_SYS_STATE, SYS_STATE_SHOW_MEM_INFO, 0, 0, 0); -} - -int show_cpu() -{ - return syscall(SYSCALL_SYS_STATE, SYS_STATE_SHOW_CPU_INFO, 0, 0, 0); -} - -int mmap(uintptr_t vaddr, uintptr_t paddr, int len, bool is_dev) -{ - return syscall(SYSCALL_MMAP, vaddr, paddr, (intptr_t)len, (intptr_t)is_dev); -} - -int register_irq(int irq, int opcode) -{ - return syscall(SYSCALL_REGISTER_IRQ, (intptr_t)irq, (intptr_t)opcode, 0, 0); -} - -int semaphore_new(int val) -{ - return syscall(SYSCALL_SEMAPHORE, (intptr_t)SYS_SEM_NEW, (intptr_t)val, 0, 0); -} - -bool semaphore_free(int sem_id) -{ - return syscall(SYSCALL_SEMAPHORE, (intptr_t)SYS_SEM_FREE, (intptr_t)sem_id, 0, 0); -} - -bool semaphore_wait(int sem_id) -{ - return syscall(SYSCALL_SEMAPHORE, (intptr_t)SYS_SEM_WAIT, (intptr_t)sem_id, 0, 0); -} - -bool semaphore_signal(int sem_id) -{ - return syscall(SYSCALL_SEMAPHORE, (intptr_t)SYS_SEM_SIGNAL, (intptr_t)sem_id, 0, 0); +/* + * Copyright (c) 2020 AIIT XUOS Lab + * XiUOS is licensed under Mulan PSL v2. + * You can use this software according to the terms and conditions of the Mulan PSL v2. + * You may obtain a copy of Mulan PSL v2 at: + * http://license.coscl.org.cn/MulanPSL2 + * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, + * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, + * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. + * See the Mulan PSL v2 for more details. + */ +#include "usyscall.h" +#include "libmem.h" + +int spawn(struct Session* session, int fd, ipc_read_fn ipc_read, ipc_fsize_fn ipc_fsize, char* name, char** argv) +{ + /* read elf image */ + int file_size = ipc_fsize(session, fd); + void* img = malloc(file_size); + int read_len = 0; + while (read_len < file_size) { + int cur_read_len = file_size - read_len < 4096 ? file_size - read_len : 4096; + if (cur_read_len < 0) { + return -1; + } + read_len += ipc_read(session, fd, (char*)((uintptr_t)img + read_len), read_len, cur_read_len); + } + /* sys call */ + int ret = syscall(SYSCALL_SPAWN, (uintptr_t)img, (uintptr_t)name, (uintptr_t)argv, 0); + free(img); + return ret; +} + +int thread(void* entry, const char* name, char** argv) +{ + return syscall(SYSCALL_THREAD, (uintptr_t)entry, (uintptr_t)name, (uintptr_t)argv, 0); +} + +void exit(int status) +{ + syscall(SYSCALL_EXIT, (uintptr_t)status, 0, 0, 0); +} + +int yield(task_yield_reason reason) +{ + return syscall(SYSCALL_YIELD, (uintptr_t)reason, 0, 0, 0); +} + +int kill(int pid) +{ + return syscall(SYSCALL_KILL, (intptr_t)pid, 0, 0, 0); +} + +int register_server(char* name) +{ + return syscall(SYSCALL_SERVER, (intptr_t)name, 0, 0, 0); +} + +int session(char* path, int capacity, struct Session* user_session) +{ + return syscall(SYSCALL_SESSION, (intptr_t)path, (intptr_t)capacity, (intptr_t)user_session, 0); +} + +int poll_session(struct Session* userland_session_arr, int arr_capacity) +{ + return syscall(SYSCALL_POLL_SESSION, (intptr_t)userland_session_arr, (intptr_t)arr_capacity, 0, 0); +} + +int close_session(struct Session* session) +{ + return syscall(SYSCALL_CLOSE_SESSION, (intptr_t)session, 0, 0, 0); +} + +int get_memblock_info(sys_state_info* info) +{ + return syscall(SYSCALL_SYS_STATE, SYS_STATE_MEMBLOCK_INFO, (intptr_t)info, 0, 0); +} + +int set_priority(sys_state_info* info) +{ + return syscall(SYSCALL_SYS_STATE, SYS_STATE_SET_TASK_PRIORITY, (intptr_t)info, 0, 0); +} + +int task_heap_base() +{ + return syscall(SYSCALL_SYS_STATE, SYS_STATE_GET_HEAP_BASE, 0, 0, 0); +} + +int show_task() +{ + return syscall(SYSCALL_SYS_STATE, SYS_STATE_SHOW_TASKS, 0, 0, 0); +} + +int show_mem() +{ + return syscall(SYSCALL_SYS_STATE, SYS_STATE_SHOW_MEM_INFO, 0, 0, 0); +} + +int show_cpu() +{ + return syscall(SYSCALL_SYS_STATE, SYS_STATE_SHOW_CPU_INFO, 0, 0, 0); +} + +uintptr_t mmap(uintptr_t vaddr, uintptr_t paddr, int len, bool is_dev) +{ + uintptr_t vaddr_inner = vaddr, paddr_inner = paddr; + if (syscall(SYSCALL_MMAP, (intptr_t)&vaddr_inner, (intptr_t)&paddr_inner, (intptr_t)len, (intptr_t)is_dev) < 0) { + return (uintptr_t)NULL; + } + return vaddr_inner; +} + +int naive_mmap(uintptr_t* vaddr, uintptr_t* paddr, int len, bool is_dev) +{ + return syscall(SYSCALL_MMAP, (uintptr_t)vaddr, (intptr_t)paddr, (intptr_t)len, (intptr_t)is_dev); +} + +int register_irq(int irq, int opcode) +{ + return syscall(SYSCALL_REGISTER_IRQ, (intptr_t)irq, (intptr_t)opcode, 0, 0); +} + +int semaphore_new(int val) +{ + return syscall(SYSCALL_SEMAPHORE, (intptr_t)SYS_SEM_NEW, (intptr_t)val, 0, 0); +} + +bool semaphore_free(int sem_id) +{ + return syscall(SYSCALL_SEMAPHORE, (intptr_t)SYS_SEM_FREE, (intptr_t)sem_id, 0, 0); +} + +bool semaphore_wait(int sem_id) +{ + return syscall(SYSCALL_SEMAPHORE, (intptr_t)SYS_SEM_WAIT, (intptr_t)sem_id, 0, 0); +} + +bool semaphore_signal(int sem_id) +{ + return syscall(SYSCALL_SEMAPHORE, (intptr_t)SYS_SEM_SIGNAL, (intptr_t)sem_id, 0, 0); } \ No newline at end of file diff --git a/Ubiquitous/XiZi_AIoT/services/lib/usyscall/usyscall.h b/Ubiquitous/XiZi_AIoT/services/lib/usyscall/usyscall.h index ddb0cf0af..8adca0de8 100644 --- a/Ubiquitous/XiZi_AIoT/services/lib/usyscall/usyscall.h +++ b/Ubiquitous/XiZi_AIoT/services/lib/usyscall/usyscall.h @@ -1,100 +1,105 @@ -/* - * Copyright (c) 2020 AIIT XUOS Lab - * XiUOS is licensed under Mulan PSL v2. - * You can use this software according to the terms and conditions of the Mulan PSL v2. - * You may obtain a copy of Mulan PSL v2 at: - * http://license.coscl.org.cn/MulanPSL2 - * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, - * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, - * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. - * See the Mulan PSL v2 for more details. - */ -#pragma once -#include - -#include "libserial.h" -#include "session.h" - -// clang-format off -#define SYSCALL_TEST 0 -#define SYSCALL_SPAWN 1 // generate a brand new task to run elf -#define SYSCALL_EXIT 2 // exit task, delete the task cb -#define SYSCALL_YIELD 3 // yield task, go to scheduler - -#define SYSCALL_MMAP 4 // map a virt page to phy page -#define SYSCALL_SERVER 5 // register current task as a server -#define SYSCALL_SESSION 6 // create a session to a server -#define SYSCALL_POLL_SESSION 7 // server poll for it's server sessions -#define SYSCALL_CLOSE_SESSION 8 // client close it's client sessions - -#define SYSCALL_THREAD 9 // generate a thread using old memspace -#define SYSCALL_SYS_STATE 10 // run system state -#define SYSCALL_REGISTER_IRQ 11 // - -#define SYSCALL_KILL 12 // kill the task by id - -#define SYSCALL_SEMAPHORE 13 // semaphore related operations -// clang-format on - -typedef enum { - SYS_STATE_TEST = 0, - SYS_STATE_SET_TASK_PRIORITY, - SYS_STATE_GET_HEAP_BASE, - SYS_STATE_MEMBLOCK_INFO, - SYS_STATE_SHOW_TASKS, - SYS_STATE_SHOW_MEM_INFO, - SYS_STATE_SHOW_CPU_INFO, -} sys_state_option; - -typedef enum { - SYS_TASK_YIELD_NO_REASON = 0x0, - SYS_TASK_YIELD_FOREVER = 0x1, - SYS_TASK_YIELD_BLOCK_IPC = 0x2, -} task_yield_reason; - -typedef union { - struct { - uintptr_t memblock_start; - uintptr_t memblock_end; - } memblock_info; - int priority; -} sys_state_info; - -typedef enum { - SYS_SEM_NEW = 0, - SYS_SEM_FREE, - SYS_SEM_SIGNAL, - SYS_SEM_WAIT, -} sys_sem_option; - -typedef int (*ipc_read_fn)(struct Session* session, int fd, char* dst, int offset, int len); -typedef int (*ipc_fsize_fn)(struct Session* session, int fd); -typedef int (*ipc_write_fn)(struct Session* session, int fd, char* src, int offset, int len); - -int syscall(int sys_num, intptr_t a1, intptr_t a2, intptr_t a3, intptr_t a4); - -int spawn(struct Session* session, int fd, ipc_read_fn ipc_read, ipc_fsize_fn ipc_fsize, char* name, char** argv); -int thread(void* entry, const char* name, char** argv); -void exit(int status); -int yield(task_yield_reason reason); -int kill(int pid); - -int register_server(char* name); -int session(char* path, int capacity, struct Session* user_session); -int poll_session(struct Session* userland_session_arr, int arr_capacity); -int close_session(struct Session* session); -int register_irq(int irq, int opcode); - -int mmap(uintptr_t vaddr, uintptr_t paddr, int len, bool is_dev); - -int task_heap_base(); -int get_memblock_info(sys_state_info* info); -int set_priority(sys_state_info* info); -int show_task(); -int show_mem(); -int show_cpu(); - -int semaphore_new(int val); -bool semaphore_free(int sem_id); -bool semaphore_wait(int sem_id); +/* + * Copyright (c) 2020 AIIT XUOS Lab + * XiUOS is licensed under Mulan PSL v2. + * You can use this software according to the terms and conditions of the Mulan PSL v2. + * You may obtain a copy of Mulan PSL v2 at: + * http://license.coscl.org.cn/MulanPSL2 + * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, + * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, + * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. + * See the Mulan PSL v2 for more details. + */ +#pragma once +#include + +#include "libserial.h" +#include "session.h" + +// clang-format off +#define SYSCALL_TEST 0 +#define SYSCALL_SPAWN 1 // generate a brand new task to run elf +#define SYSCALL_EXIT 2 // exit task, delete the task cb +#define SYSCALL_YIELD 3 // yield task, go to scheduler + +#define SYSCALL_MMAP 4 // map a virt page to phy page +#define SYSCALL_SERVER 5 // register current task as a server +#define SYSCALL_SESSION 6 // create a session to a server +#define SYSCALL_POLL_SESSION 7 // server poll for it's server sessions +#define SYSCALL_CLOSE_SESSION 8 // client close it's client sessions + +#define SYSCALL_THREAD 9 // generate a thread using old memspace +#define SYSCALL_SYS_STATE 10 // run system state +#define SYSCALL_REGISTER_IRQ 11 // + +#define SYSCALL_KILL 12 // kill the task by id + +#define SYSCALL_SEMAPHORE 13 // semaphore related operations +// clang-format on + +typedef enum { + SYS_STATE_TEST = 0, + SYS_STATE_SET_TASK_PRIORITY, + SYS_STATE_GET_HEAP_BASE, + SYS_STATE_MEMBLOCK_INFO, + SYS_STATE_SHOW_TASKS, + SYS_STATE_SHOW_MEM_INFO, + SYS_STATE_SHOW_CPU_INFO, + SYS_STATE_GET_CURRENT_TICK, + SYS_STATE_GET_CURRENT_SECOND, +} sys_state_option; + +typedef enum { + SYS_TASK_YIELD_NO_REASON = 0x0, + SYS_TASK_YIELD_FOREVER = 0x1, + SYS_TASK_YIELD_BLOCK_IPC = 0x2, +} task_yield_reason; + +typedef union { + struct { + uintptr_t memblock_start; + uintptr_t memblock_end; + } memblock_info; + int priority; + uintptr_t current_tick; + uintptr_t current_second; +} sys_state_info; + +typedef enum { + SYS_SEM_NEW = 0, + SYS_SEM_FREE, + SYS_SEM_SIGNAL, + SYS_SEM_WAIT, +} sys_sem_option; + +typedef int (*ipc_read_fn)(struct Session* session, int fd, char* dst, int offset, int len); +typedef int (*ipc_fsize_fn)(struct Session* session, int fd); +typedef int (*ipc_write_fn)(struct Session* session, int fd, char* src, int offset, int len); + +int syscall(int sys_num, intptr_t a1, intptr_t a2, intptr_t a3, intptr_t a4); + +int spawn(struct Session* session, int fd, ipc_read_fn ipc_read, ipc_fsize_fn ipc_fsize, char* name, char** argv); +int thread(void* entry, const char* name, char** argv); +void exit(int status); +int yield(task_yield_reason reason); +int kill(int pid); + +int register_server(char* name); +int session(char* path, int capacity, struct Session* user_session); +int poll_session(struct Session* userland_session_arr, int arr_capacity); +int close_session(struct Session* session); +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 task_heap_base(); +int get_memblock_info(sys_state_info* info); +int set_priority(sys_state_info* info); +int show_task(); +int show_mem(); +int show_cpu(); + +int semaphore_new(int val); +bool semaphore_free(int sem_id); +bool semaphore_wait(int sem_id); bool semaphore_signal(int sem_id); \ No newline at end of file diff --git a/Ubiquitous/XiZi_AIoT/softkernel/include/syscall.h b/Ubiquitous/XiZi_AIoT/softkernel/include/syscall.h index 4e1ba2a7a..13e5e845d 100644 --- a/Ubiquitous/XiZi_AIoT/softkernel/include/syscall.h +++ b/Ubiquitous/XiZi_AIoT/softkernel/include/syscall.h @@ -1,112 +1,116 @@ -/* - * Copyright (c) 2020 AIIT XUOS Lab - * XiUOS is licensed under Mulan PSL v2. - * You can use this software according to the terms and conditions of the Mulan PSL v2. - * You may obtain a copy of Mulan PSL v2 at: - * http://license.coscl.org.cn/MulanPSL2 - * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, - * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, - * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. - * See the Mulan PSL v2 for more details. - */ -/** - * @file syscall.h - * @brief syscall header - * @version 3.0 - * @author AIIT XUOS Lab - * @date 2023.08.25 - */ - -/************************************************* -File name: syscall.h -Description: syscall header -Others: -History: -1. Date: 2023-08-28 -Author: AIIT XUOS Lab -Modification: -1. first version -*************************************************/ -#pragma once - -// clang-format off -#define SYSCALL_TEST 0 -#define SYSCALL_SPAWN 1 // generate a brand new task to run elf -#define SYSCALL_EXIT 2 // exit task, delete the task cb -#define SYSCALL_YIELD 3 // yield task, go to scheduler - -#define SYSCALL_MMAP 4 // map a virt page to phy page -#define SYSCALL_SERVER 5 // register current task as a server -#define SYSCALL_SESSION 6 // create a session to a server -#define SYSCALL_POLL_SESSION 7 // server poll for it's server sessions -#define SYSCALL_CLOSE_SESSION 8 // client close it's client sessions - -#define SYSCALL_THREAD 9 // generate a thread using old memspace -#define SYSCALL_SYS_STATE 10 // run system state -#define SYSCALL_REGISTER_IRQ 11 // - -#define SYSCALL_KILL 12 // kill the task by id - -#define SYSCALL_SEMAPHORE 13 // semaphore related operations -// clang-format on - -#ifndef __ASSEMBLER__ -#include - -#include "share_page.h" -#include "task.h" - -typedef enum { - SYS_STATE_TEST = 0, - SYS_STATE_SET_TASK_PRIORITY, - SYS_STATE_GET_HEAP_BASE, - SYS_STATE_MEMBLOCK_INFO, - SYS_STATE_SHOW_TASKS, - SYS_STATE_SHOW_MEM_INFO, - SYS_STATE_SHOW_CPU_INFO, -} sys_state_option; - -typedef enum { - SYS_TASK_YIELD_NO_REASON = 0x0, - SYS_TASK_YIELD_FOREVER = 0x1, - SYS_TASK_YIELD_BLOCK_IPC = 0x2, -} task_yield_reason; - -typedef union { - struct { - uintptr_t memblock_start; - uintptr_t memblock_end; - } memblock_info; - int priority; -} sys_state_info; - -typedef enum { - SYS_SEM_NEW = 0, - SYS_SEM_FREE, - SYS_SEM_SIGNAL, - SYS_SEM_WAIT, -} sys_sem_option; - -int syscall(int sys_num, uintptr_t param1, uintptr_t param2, uintptr_t param3, uintptr_t param4); - -int sys_spawn(char* img_start, char* name, char** argv); -int sys_thread(uintptr_t entry, char* name, char** argv); -int sys_exit(struct Thread* ptask); -int sys_yield(task_yield_reason reason); -int sys_kill(int id); - -int sys_register_as_server(char* name); -int sys_connect_session(char* path, int capacity, struct Session* user_session); -int sys_poll_session(struct Session* userland_session_arr, int arr_capacity); -int sys_close_session(struct Thread* task, struct Session* session); - -int sys_exec(char* img_start, char* name, char** argv); -int sys_state(sys_state_option option, sys_state_info* info); -int sys_mmap(uintptr_t vaddr, uintptr_t paddr, int len, int is_dev); - -int sys_register_irq(int irq_num, int irq_opcode); -int sys_unbind_irq_all(struct Thread* task); -int sys_unbind_irq(struct Thread* task, int irq_num); - -int sys_semaphore(sys_sem_option op, int sem_id); -#endif +/* + * Copyright (c) 2020 AIIT XUOS Lab + * XiUOS is licensed under Mulan PSL v2. + * You can use this software according to the terms and conditions of the Mulan PSL v2. + * You may obtain a copy of Mulan PSL v2 at: + * http://license.coscl.org.cn/MulanPSL2 + * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, + * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, + * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. + * See the Mulan PSL v2 for more details. + */ +/** + * @file syscall.h + * @brief syscall header + * @version 3.0 + * @author AIIT XUOS Lab + * @date 2023.08.25 + */ + +/************************************************* +File name: syscall.h +Description: syscall header +Others: +History: +1. Date: 2023-08-28 +Author: AIIT XUOS Lab +Modification: +1. first version +*************************************************/ +#pragma once + +// clang-format off +#define SYSCALL_TEST 0 +#define SYSCALL_SPAWN 1 // generate a brand new task to run elf +#define SYSCALL_EXIT 2 // exit task, delete the task cb +#define SYSCALL_YIELD 3 // yield task, go to scheduler + +#define SYSCALL_MMAP 4 // map a virt page to phy page +#define SYSCALL_SERVER 5 // register current task as a server +#define SYSCALL_SESSION 6 // create a session to a server +#define SYSCALL_POLL_SESSION 7 // server poll for it's server sessions +#define SYSCALL_CLOSE_SESSION 8 // client close it's client sessions + +#define SYSCALL_THREAD 9 // generate a thread using old memspace +#define SYSCALL_SYS_STATE 10 // run system state +#define SYSCALL_REGISTER_IRQ 11 // + +#define SYSCALL_KILL 12 // kill the task by id + +#define SYSCALL_SEMAPHORE 13 // semaphore related operations +// clang-format on + +#ifndef __ASSEMBLER__ +#include + +#include "share_page.h" +#include "task.h" + +typedef enum { + SYS_STATE_TEST = 0, + SYS_STATE_SET_TASK_PRIORITY, + SYS_STATE_GET_HEAP_BASE, + SYS_STATE_MEMBLOCK_INFO, + SYS_STATE_SHOW_TASKS, + SYS_STATE_SHOW_MEM_INFO, + SYS_STATE_SHOW_CPU_INFO, + SYS_STATE_GET_CURRENT_TICK, + SYS_STATE_GET_CURRENT_SECOND, +} sys_state_option; + +typedef enum { + SYS_TASK_YIELD_NO_REASON = 0x0, + SYS_TASK_YIELD_FOREVER = 0x1, + SYS_TASK_YIELD_BLOCK_IPC = 0x2, +} task_yield_reason; + +typedef union { + struct { + uintptr_t memblock_start; + uintptr_t memblock_end; + } memblock_info; + int priority; + uintptr_t current_tick; + uintptr_t current_second; +} sys_state_info; + +typedef enum { + SYS_SEM_NEW = 0, + SYS_SEM_FREE, + SYS_SEM_SIGNAL, + SYS_SEM_WAIT, +} sys_sem_option; + +int syscall(int sys_num, uintptr_t param1, uintptr_t param2, uintptr_t param3, uintptr_t param4); + +int sys_spawn(char* img_start, char* name, char** argv); +int sys_thread(uintptr_t entry, char* name, char** argv); +int sys_exit(struct Thread* ptask); +int sys_yield(task_yield_reason reason); +int sys_kill(int id); + +int sys_register_as_server(char* name); +int sys_connect_session(char* path, int capacity, struct Session* user_session); +int sys_poll_session(struct Session* userland_session_arr, int arr_capacity); +int sys_close_session(struct Thread* task, struct Session* session); + +int sys_exec(char* img_start, char* name, char** argv); +int sys_state(sys_state_option option, sys_state_info* info); +int sys_mmap(uintptr_t* vaddr, uintptr_t* paddr, int len, int is_dev); + +int sys_register_irq(int irq_num, int irq_opcode); +int sys_unbind_irq_all(struct Thread* task); +int sys_unbind_irq(struct Thread* task, int irq_num); + +int sys_semaphore(sys_sem_option op, int sem_id); +#endif diff --git a/Ubiquitous/XiZi_AIoT/softkernel/syscall/sys_mmap.c b/Ubiquitous/XiZi_AIoT/softkernel/syscall/sys_mmap.c index 1c94c1d5f..432d910e6 100644 --- a/Ubiquitous/XiZi_AIoT/softkernel/syscall/sys_mmap.c +++ b/Ubiquitous/XiZi_AIoT/softkernel/syscall/sys_mmap.c @@ -1,69 +1,71 @@ -/* - * Copyright (c) 2020 AIIT XUOS Lab - * XiUOS is licensed under Mulan PSL v2. - * You can use this software according to the terms and conditions of the Mulan PSL v2. - * You may obtain a copy of Mulan PSL v2 at: - * http://license.coscl.org.cn/MulanPSL2 - * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, - * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, - * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. - * See the Mulan PSL v2 for more details. - */ -/** - * @file sys_mmap.c - * @brief map task phy address to virt address - * @version 3.0 - * @author AIIT XUOS Lab - * @date 2023.08.25 - */ - -/************************************************* -File name: sys_mmap.c -Description: map task phy address to virt address -Others: -History: -1. Date: 2023-08-28 -Author: AIIT XUOS Lab -Modification: -1. first version -*************************************************/ -#include - -#include "assert.h" -#include "kalloc.h" -#include "multicores.h" -#include "share_page.h" -#include "syscall.h" -#include "task.h" - -int sys_mmap(uintptr_t vaddr, uintptr_t paddr, int len, int is_dev) -{ - struct Thread* cur_task = cur_cpu()->task; - assert(cur_task != NULL); - - int true_len = ALIGNUP(len, PAGE_SIZE); - - if (paddr != (uintptr_t)NULL) { - if (xizi_share_page_manager.task_map_pages(cur_task, vaddr, paddr, true_len / PAGE_SIZE, is_dev) == (uintptr_t)NULL) { - return -1; - } - } else { - int load_len = 0; - uintptr_t load_vaddr = vaddr; - while (load_len < true_len) { - char* paddr = raw_alloc(PAGE_SIZE); - if (paddr == NULL) { - return -1; - } - if (xizi_share_page_manager.task_map_pages(cur_task, load_vaddr, (uintptr_t)paddr, 1, false) == (uintptr_t)NULL) { - raw_free(paddr); - return -1; - } - load_vaddr += PAGE_SIZE; - load_len += PAGE_SIZE; - } - } - - cur_task->memspace->mem_size += true_len; - return vaddr + true_len; +/* + * Copyright (c) 2020 AIIT XUOS Lab + * XiUOS is licensed under Mulan PSL v2. + * You can use this software according to the terms and conditions of the Mulan PSL v2. + * You may obtain a copy of Mulan PSL v2 at: + * http://license.coscl.org.cn/MulanPSL2 + * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, + * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, + * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. + * See the Mulan PSL v2 for more details. + */ +/** + * @file sys_mmap.c + * @brief map task phy address to virt address + * @version 3.0 + * @author AIIT XUOS Lab + * @date 2023.08.25 + */ + +/************************************************* +File name: sys_mmap.c +Description: map task phy address to virt address +Others: +History: +1. Date: 2023-08-28 +Author: AIIT XUOS Lab +Modification: +1. first version +*************************************************/ +#include + +#include "assert.h" +#include "kalloc.h" +#include "multicores.h" +#include "share_page.h" +#include "syscall.h" +#include "task.h" + +int sys_mmap(uintptr_t* vaddr, uintptr_t* paddr, int len, int is_dev) +{ + struct Thread* cur_task = cur_cpu()->task; + assert(cur_task != NULL); + + int true_len = ALIGNUP(len, PAGE_SIZE); + + if (*paddr != (uintptr_t)NULL) { + if (xizi_share_page_manager.task_map_pages(cur_task, *vaddr, *paddr, true_len / PAGE_SIZE, is_dev) == (uintptr_t)NULL) { + return -1; + } + } else { + int load_len = 0; + uintptr_t load_vaddr = *vaddr; + while (load_len < true_len) { + char* new_paddr = raw_alloc(PAGE_SIZE); + if (new_paddr == NULL) { + return -1; + } + if (xizi_share_page_manager.task_map_pages(cur_task, load_vaddr, (uintptr_t)new_paddr, 1, false) == (uintptr_t)NULL) { + raw_free(new_paddr); + return -1; + } + load_vaddr += PAGE_SIZE; + load_len += PAGE_SIZE; + *paddr = (uintptr_t)new_paddr; + } + } + + cur_task->memspace->mem_size += true_len; + *vaddr = *vaddr + true_len; + return 0; } \ No newline at end of file diff --git a/Ubiquitous/XiZi_AIoT/softkernel/syscall/sys_state.c b/Ubiquitous/XiZi_AIoT/softkernel/syscall/sys_state.c index ddc3f5f69..47817ea14 100644 --- a/Ubiquitous/XiZi_AIoT/softkernel/syscall/sys_state.c +++ b/Ubiquitous/XiZi_AIoT/softkernel/syscall/sys_state.c @@ -1,170 +1,190 @@ -/* - * Copyright (c) 2020 AIIT XUOS Lab - * XiUOS is licensed under Mulan PSL v2. - * You can use this software according to the terms and conditions of the Mulan PSL v2. - * You may obtain a copy of Mulan PSL v2 at: - * http://license.coscl.org.cn/MulanPSL2 - * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, - * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, - * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. - * See the Mulan PSL v2 for more details. - */ -/** - * @file sys_state.c - * @brief task ask for kernel status(for debug perpose) - * @version 3.0 - * @author AIIT XUOS Lab - * @date 2023.08.25 - */ - -/************************************************* -File name: sys_state.c -Description: task ask for kernel status(for debug perpose) -Others: -History: -1. Date: 2023-08-28 -Author: AIIT XUOS Lab -Modification: -1. first version -*************************************************/ -#include -#include - -#include "assert.h" -#include "buddy.h" -#include "log.h" -#include "multicores.h" -#include "pagetable.h" -#include "syscall.h" -#include "task.h" - -extern uint8_t _binary_fs_img_start[], _binary_fs_img_end[]; - -#define SHOWINFO_BORDER_LINE() LOG_PRINTF("******************************************************\n"); -#define SHOWTASK_TASK_BASE_INFO(task) LOG_PRINTF(" %-6d %-16s %-4d 0x%x(%-d)\n", task->tid, task->name, task->priority, task->memspace->mem_size >> 10, task->memspace->mem_size >> 10) - -void show_tasks(void) -{ - struct Thread* task = NULL; - SHOWINFO_BORDER_LINE(); - for (int i = 0; i < NR_CPU; i++) { - LOG_PRINTF("CPU %-2d: %s\n", i, (global_cpus[i].task == NULL ? "NULL" : global_cpus[i].task->name)); - } - SHOWINFO_BORDER_LINE(); - LOG_PRINTF("%-8s %-6s %-16s %-4s %-8s\n", "STAT", "ID", "TASK", "PRI", "MEM(KB)"); - DOUBLE_LIST_FOR_EACH_ENTRY(task, &xizi_task_manager.task_running_list_head, node) - { - LOG_PRINTF("%-8s", "RUNNING"); - SHOWTASK_TASK_BASE_INFO(task); - } - - for (int i = 0; i < TASK_MAX_PRIORITY; i++) { - if (IS_DOUBLE_LIST_EMPTY(&xizi_task_manager.task_list_head[i])) { - continue; - } - DOUBLE_LIST_FOR_EACH_ENTRY(task, &xizi_task_manager.task_list_head[i], node) - { - switch (task->state) { - case INIT: - LOG_PRINTF("%-8s", "INIT"); - break; - case READY: - LOG_PRINTF("%-8s", "READY"); - break; - case RUNNING: - LOG_PRINTF("%-8s", "RUNNING"); - break; - case DEAD: - LOG_PRINTF("%-8s", "DEAD"); - break; - default: - break; - } - - SHOWTASK_TASK_BASE_INFO(task); - } - } - - DOUBLE_LIST_FOR_EACH_ENTRY(task, &xizi_task_manager.task_blocked_list_head, node) - { - LOG_PRINTF("%-8s", "BLOCK"); - SHOWTASK_TASK_BASE_INFO(task); - } - - struct ksemaphore* sem = NULL; - DOUBLE_LIST_FOR_EACH_ENTRY(sem, &xizi_task_manager.semaphore_pool.sem_list_guard, sem_list_node) - { - task = NULL; - DOUBLE_LIST_FOR_EACH_ENTRY(task, &sem->wait_list_guard, node) - { - LOG_PRINTF("%-8s", "BLOCK"); - SHOWTASK_TASK_BASE_INFO(task); - } - } - - SHOWINFO_BORDER_LINE(); - return; -} - -extern struct KBuddy user_phy_freemem_buddy; -extern struct KBuddy kern_virtmem_buddy; -extern uintptr_t kernel_data_end[]; -void show_mem(void) -{ - SHOWINFO_BORDER_LINE(); - - uint64_t total = (PHY_MEM_STOP - V2P(kernel_data_end)); - uint64_t user_dynamic_free = 0; - uint64_t kernel_free = 0; - for (int j = 0; j < MAX_BUDDY_ORDER; j++) { - user_dynamic_free += user_phy_freemem_buddy.free_list[j].n_free_pages * (1 << j) * PAGE_SIZE; - kernel_free += kern_virtmem_buddy.free_list[j].n_free_pages * (1 << j) * PAGE_SIZE; - } - LOG_PRINTF("%-16s 0x%016lx\n", "TOTAL(B)", total); - LOG_PRINTF("%-16s 0x%016lx\n", "KERNEL USED(B)", (kern_virtmem_buddy.mem_end - kern_virtmem_buddy.mem_start - kernel_free)); - LOG_PRINTF("%-16s 0x%016lx\n", "LIBMEM USED(B)", (user_phy_freemem_buddy.mem_end - user_phy_freemem_buddy.mem_start - user_dynamic_free)); - LOG_PRINTF("%-16s 0x%016lx\n", "FREE(B)", user_dynamic_free + kernel_free); - - SHOWINFO_BORDER_LINE(); - return; -} - -void show_cpu(void) -{ - LOG_PRINTF("**********************************************************\n"); -#ifdef ARCH_SMP - /// @todo support smp - KPrintf(" cpu VALUE \n"); -#endif - - int cpu_id = 0; - - struct Thread* current_task = cur_cpu()->task; - assert(current_task != NULL); - - LOG_PRINTF(" ID COMMAND USED_TICKS FREE_TICKS \n"); - LOG_PRINTF(" %d %s %d %d\n", cpu_id, current_task->name, TASK_CLOCK_TICK - current_task->remain_tick, current_task->remain_tick); - - LOG_PRINTF("***********************************************************\n"); - return; -} - -int sys_state(sys_state_option option, sys_state_info* info) -{ - if (option == SYS_STATE_MEMBLOCK_INFO) { - info->memblock_info.memblock_start = (uintptr_t)V2P(_binary_fs_img_start); - info->memblock_info.memblock_end = (uintptr_t)V2P(_binary_fs_img_end); - } else if (option == SYS_STATE_GET_HEAP_BASE) { - return cur_cpu()->task->memspace->heap_base; - } else if (option == SYS_STATE_SET_TASK_PRIORITY) { - xizi_task_manager.set_cur_task_priority(info->priority); - } else if (option == SYS_STATE_SHOW_TASKS) { - show_tasks(); - } else if (option == SYS_STATE_SHOW_MEM_INFO) { - show_mem(); - } else if (option == SYS_STATE_SHOW_CPU_INFO) { - show_cpu(); - } - - return 0; +/* + * Copyright (c) 2020 AIIT XUOS Lab + * XiUOS is licensed under Mulan PSL v2. + * You can use this software according to the terms and conditions of the Mulan PSL v2. + * You may obtain a copy of Mulan PSL v2 at: + * http://license.coscl.org.cn/MulanPSL2 + * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, + * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, + * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. + * See the Mulan PSL v2 for more details. + */ +/** + * @file sys_state.c + * @brief task ask for kernel status(for debug perpose) + * @version 3.0 + * @author AIIT XUOS Lab + * @date 2023.08.25 + */ + +/************************************************* +File name: sys_state.c +Description: task ask for kernel status(for debug perpose) +Others: +History: +1. Date: 2023-08-28 +Author: AIIT XUOS Lab +Modification: +1. first version +*************************************************/ +#include +#include + +#include "assert.h" +#include "buddy.h" +#include "log.h" +#include "multicores.h" +#include "pagetable.h" +#include "syscall.h" +#include "task.h" + +extern uint8_t _binary_fs_img_start[], _binary_fs_img_end[]; + +#define SHOWINFO_BORDER_LINE() LOG_PRINTF("******************************************************\n"); +#define SHOWTASK_TASK_BASE_INFO(task) LOG_PRINTF(" %-6d %-16s %-4d 0x%x(%-d)\n", task->tid, task->name, task->priority, task->memspace->mem_size >> 10, task->memspace->mem_size >> 10) + +void show_tasks(void) +{ + struct Thread* task = NULL; + SHOWINFO_BORDER_LINE(); + for (int i = 0; i < NR_CPU; i++) { + LOG_PRINTF("CPU %-2d: %s\n", i, (global_cpus[i].task == NULL ? "NULL" : global_cpus[i].task->name)); + } + SHOWINFO_BORDER_LINE(); + LOG_PRINTF("%-8s %-6s %-16s %-4s %-8s\n", "STAT", "ID", "TASK", "PRI", "MEM(KB)"); + DOUBLE_LIST_FOR_EACH_ENTRY(task, &xizi_task_manager.task_running_list_head, node) + { + LOG_PRINTF("%-8s", "RUNNING"); + SHOWTASK_TASK_BASE_INFO(task); + } + + for (int i = 0; i < TASK_MAX_PRIORITY; i++) { + if (IS_DOUBLE_LIST_EMPTY(&xizi_task_manager.task_list_head[i])) { + continue; + } + DOUBLE_LIST_FOR_EACH_ENTRY(task, &xizi_task_manager.task_list_head[i], node) + { + switch (task->state) { + case INIT: + LOG_PRINTF("%-8s", "INIT"); + break; + case READY: + LOG_PRINTF("%-8s", "READY"); + break; + case RUNNING: + LOG_PRINTF("%-8s", "RUNNING"); + break; + case DEAD: + LOG_PRINTF("%-8s", "DEAD"); + break; + default: + break; + } + + SHOWTASK_TASK_BASE_INFO(task); + } + } + + DOUBLE_LIST_FOR_EACH_ENTRY(task, &xizi_task_manager.task_blocked_list_head, node) + { + LOG_PRINTF("%-8s", "BLOCK"); + SHOWTASK_TASK_BASE_INFO(task); + } + + struct ksemaphore* sem = NULL; + DOUBLE_LIST_FOR_EACH_ENTRY(sem, &xizi_task_manager.semaphore_pool.sem_list_guard, sem_list_node) + { + task = NULL; + DOUBLE_LIST_FOR_EACH_ENTRY(task, &sem->wait_list_guard, node) + { + LOG_PRINTF("%-8s", "BLOCK"); + SHOWTASK_TASK_BASE_INFO(task); + } + } + + SHOWINFO_BORDER_LINE(); + return; +} + +extern struct KBuddy user_phy_freemem_buddy; +extern struct KBuddy kern_virtmem_buddy; +extern uintptr_t kernel_data_end[]; +void show_mem(void) +{ + SHOWINFO_BORDER_LINE(); + + uint64_t total = (PHY_MEM_STOP - V2P(kernel_data_end)); + uint64_t user_dynamic_free = 0; + uint64_t kernel_free = 0; + for (int j = 0; j < MAX_BUDDY_ORDER; j++) { + user_dynamic_free += user_phy_freemem_buddy.free_list[j].n_free_pages * (1 << j) * PAGE_SIZE; + kernel_free += kern_virtmem_buddy.free_list[j].n_free_pages * (1 << j) * PAGE_SIZE; + } + LOG_PRINTF("%-16s 0x%016lx\n", "TOTAL(B)", total); + LOG_PRINTF("%-16s 0x%016lx\n", "KERNEL USED(B)", (kern_virtmem_buddy.mem_end - kern_virtmem_buddy.mem_start - kernel_free)); + LOG_PRINTF("%-16s 0x%016lx\n", "LIBMEM USED(B)", (user_phy_freemem_buddy.mem_end - user_phy_freemem_buddy.mem_start - user_dynamic_free)); + LOG_PRINTF("%-16s 0x%016lx\n", "FREE(B)", user_dynamic_free + kernel_free); + + SHOWINFO_BORDER_LINE(); + return; +} + +void show_cpu(void) +{ + LOG_PRINTF("**********************************************************\n"); +#ifdef ARCH_SMP + /// @todo support smp + KPrintf(" cpu VALUE \n"); +#endif + + int cpu_id = 0; + + struct Thread* current_task = cur_cpu()->task; + assert(current_task != NULL); + + LOG_PRINTF(" ID COMMAND USED_TICKS FREE_TICKS \n"); + LOG_PRINTF(" %d %s %d %d\n", cpu_id, current_task->name, TASK_CLOCK_TICK - current_task->remain_tick, current_task->remain_tick); + + LOG_PRINTF("***********************************************************\n"); + return; +} + +int sys_state(sys_state_option option, sys_state_info* info) +{ + switch (option) { + case SYS_STATE_MEMBLOCK_INFO: { + info->memblock_info.memblock_start = (uintptr_t)V2P(_binary_fs_img_start); + info->memblock_info.memblock_end = (uintptr_t)V2P(_binary_fs_img_end); + break; + } + case SYS_STATE_GET_HEAP_BASE: + return cur_cpu()->task->memspace->heap_base; + case SYS_STATE_SET_TASK_PRIORITY: + xizi_task_manager.set_cur_task_priority(info->priority); + break; + case SYS_STATE_SHOW_TASKS: + show_tasks(); + break; + case SYS_STATE_SHOW_MEM_INFO: + show_mem(); + break; + case SYS_STATE_SHOW_CPU_INFO: + show_cpu(); + break; + case SYS_STATE_GET_CURRENT_TICK: { + extern void hw_current_tick(uintptr_t * tick); + hw_current_tick(&info->current_tick); + break; + } + case SYS_STATE_GET_CURRENT_SECOND: { + extern void hw_current_second(uintptr_t * tick); + hw_current_second(&info->current_second); + break; + } + case SYS_STATE_TEST: + default: + break; + } + + return 0; } \ No newline at end of file diff --git a/Ubiquitous/XiZi_AIoT/softkernel/syscall/syscall.c b/Ubiquitous/XiZi_AIoT/softkernel/syscall/syscall.c index 4a15e6389..f5cd4c528 100644 --- a/Ubiquitous/XiZi_AIoT/softkernel/syscall/syscall.c +++ b/Ubiquitous/XiZi_AIoT/softkernel/syscall/syscall.c @@ -1,90 +1,90 @@ -/* - * Copyright (c) 2020 AIIT XUOS Lab - * XiUOS is licensed under Mulan PSL v2. - * You can use this software according to the terms and conditions of the Mulan PSL v2. - * You may obtain a copy of Mulan PSL v2 at: - * http://license.coscl.org.cn/MulanPSL2 - * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, - * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, - * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. - * See the Mulan PSL v2 for more details. - */ -/** - * @file syscall.c - * @brief syscall distributor - * @version 3.0 - * @author AIIT XUOS Lab - * @date 2023.08.25 - */ - -/************************************************* -File name: syscall.c -Description: syscall distributor -Others: -History: -1. Date: 2023-08-28 -Author: AIIT XUOS Lab -Modification: -1. first version -*************************************************/ -#include "log.h" -#include "multicores.h" -#include "trap_common.h" - -#include "syscall.h" - -int syscall(int sys_num, uintptr_t param1, uintptr_t param2, uintptr_t param3, uintptr_t param4) -{ - int ret = -1; - - switch (sys_num) { - case SYSCALL_TEST: - ret = 0; - break; - case SYSCALL_SPAWN: - ret = sys_spawn((char*)param1, (char*)param2, (char**)param3); - break; - case SYSCALL_THREAD: - ret = sys_thread((uintptr_t)param1, (char*)param2, (char**)param3); - break; - case SYSCALL_EXIT: - ret = sys_exit(cur_cpu()->task); - break; - case SYSCALL_YIELD: - ret = sys_yield((task_yield_reason)param1); - break; - case SYSCALL_SERVER: - ret = sys_register_as_server((char*)param1); - break; - case SYSCALL_SESSION: - ret = sys_connect_session((char*)param1, (int)param2, (struct Session*)param3); - break; - case SYSCALL_POLL_SESSION: - ret = sys_poll_session((struct Session*)param1, (int)param2); - break; - case SYSCALL_CLOSE_SESSION: - ret = sys_close_session(cur_cpu()->task, (struct Session*)param1); - break; - case SYSCALL_SYS_STATE: - ret = sys_state(param1, (sys_state_info*)param2); - break; - case SYSCALL_MMAP: - ret = sys_mmap(param1, param2, (int)param3, (int)param4); - break; - case SYSCALL_REGISTER_IRQ: - ret = sys_register_irq((int)param1, (int)param2); - break; - case SYSCALL_KILL: - ret = sys_kill((int)param1); - break; - case SYSCALL_SEMAPHORE: - ret = sys_semaphore((sys_sem_option)param1, (int)param2); - break; - default: - ERROR("Unsurport syscall(%d) right now\n", sys_num); - ret = -1; - break; - } - - return ret; +/* + * Copyright (c) 2020 AIIT XUOS Lab + * XiUOS is licensed under Mulan PSL v2. + * You can use this software according to the terms and conditions of the Mulan PSL v2. + * You may obtain a copy of Mulan PSL v2 at: + * http://license.coscl.org.cn/MulanPSL2 + * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, + * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, + * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. + * See the Mulan PSL v2 for more details. + */ +/** + * @file syscall.c + * @brief syscall distributor + * @version 3.0 + * @author AIIT XUOS Lab + * @date 2023.08.25 + */ + +/************************************************* +File name: syscall.c +Description: syscall distributor +Others: +History: +1. Date: 2023-08-28 +Author: AIIT XUOS Lab +Modification: +1. first version +*************************************************/ +#include "log.h" +#include "multicores.h" +#include "trap_common.h" + +#include "syscall.h" + +int syscall(int sys_num, uintptr_t param1, uintptr_t param2, uintptr_t param3, uintptr_t param4) +{ + int ret = -1; + + switch (sys_num) { + case SYSCALL_TEST: + ret = 0; + break; + case SYSCALL_SPAWN: + ret = sys_spawn((char*)param1, (char*)param2, (char**)param3); + break; + case SYSCALL_THREAD: + ret = sys_thread((uintptr_t)param1, (char*)param2, (char**)param3); + break; + case SYSCALL_EXIT: + ret = sys_exit(cur_cpu()->task); + break; + case SYSCALL_YIELD: + ret = sys_yield((task_yield_reason)param1); + break; + case SYSCALL_SERVER: + ret = sys_register_as_server((char*)param1); + break; + case SYSCALL_SESSION: + ret = sys_connect_session((char*)param1, (int)param2, (struct Session*)param3); + break; + case SYSCALL_POLL_SESSION: + ret = sys_poll_session((struct Session*)param1, (int)param2); + break; + case SYSCALL_CLOSE_SESSION: + ret = sys_close_session(cur_cpu()->task, (struct Session*)param1); + break; + case SYSCALL_SYS_STATE: + ret = sys_state(param1, (sys_state_info*)param2); + break; + case SYSCALL_MMAP: + ret = sys_mmap((uintptr_t*)param1, (uintptr_t*)param2, (int)param3, (int)param4); + break; + case SYSCALL_REGISTER_IRQ: + ret = sys_register_irq((int)param1, (int)param2); + break; + case SYSCALL_KILL: + ret = sys_kill((int)param1); + break; + case SYSCALL_SEMAPHORE: + ret = sys_semaphore((sys_sem_option)param1, (int)param2); + break; + default: + ERROR("Unsurport syscall(%d) right now\n", sys_num); + ret = -1; + break; + } + + return ret; } \ No newline at end of file diff --git a/Ubiquitous/XiZi_AIoT/softkernel/trap/clock_irq_handler.c b/Ubiquitous/XiZi_AIoT/softkernel/trap/clock_irq_handler.c index d7a66169c..7ab8808b8 100644 --- a/Ubiquitous/XiZi_AIoT/softkernel/trap/clock_irq_handler.c +++ b/Ubiquitous/XiZi_AIoT/softkernel/trap/clock_irq_handler.c @@ -1,66 +1,82 @@ -/* - * Copyright (c) 2020 AIIT XUOS Lab - * XiUOS is licensed under Mulan PSL v2. - * You can use this software according to the terms and conditions of the Mulan PSL v2. - * You may obtain a copy of Mulan PSL v2 at: - * http://license.coscl.org.cn/MulanPSL2 - * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, - * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, - * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. - * See the Mulan PSL v2 for more details. - */ -/** - * @file clock_irq_handler.c - * @brief clock interrupt handler - * @version 3.0 - * @author AIIT XUOS Lab - * @date 2023.08.25 - */ - -/************************************************* -File name: clock_irq_handler.c -Description: clock interrupt handler -Others: -History: -1. Date: 2023-08-28 -Author: AIIT XUOS Lab -Modification: -1. first version -*************************************************/ -#include "clock_common_op.h" - -#include "actracer.h" -#include "assert.h" -#include "multicores.h" -#include "task.h" - -#include "log.h" - -static struct TraceTag clock_driver_tag; -static struct XiziClockDriver* p_clock_driver = NULL; - -bool clock_intr_handler_init(struct TraceTag* p_clock_driver_tag) -{ - clock_driver_tag = *p_clock_driver_tag; - p_clock_driver = AchieveResource(p_clock_driver_tag); - return p_clock_driver != NULL; -} - -uint64_t global_tick = 0; -int xizi_clock_handler(int irq, void* tf, void* arg) -{ - /* handle clock interrupt using driver */ - if (p_clock_driver->is_timer_expired()) { - p_clock_driver->clear_clock_intr(); - global_tick++; - struct Thread* current_task = cur_cpu()->task; - if (current_task) { - current_task->remain_tick--; - current_task->maxium_tick--; - if (current_task->remain_tick == 0) { - xizi_task_manager.task_yield_noschedule(current_task, false); - } - } - } - return 0; +/* + * Copyright (c) 2020 AIIT XUOS Lab + * XiUOS is licensed under Mulan PSL v2. + * You can use this software according to the terms and conditions of the Mulan PSL v2. + * You may obtain a copy of Mulan PSL v2 at: + * http://license.coscl.org.cn/MulanPSL2 + * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, + * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, + * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. + * See the Mulan PSL v2 for more details. + */ +/** + * @file clock_irq_handler.c + * @brief clock interrupt handler + * @version 3.0 + * @author AIIT XUOS Lab + * @date 2023.08.25 + */ + +/************************************************* +File name: clock_irq_handler.c +Description: clock interrupt handler +Others: +History: +1. Date: 2023-08-28 +Author: AIIT XUOS Lab +Modification: +1. first version +*************************************************/ +#include "clock_common_op.h" + +#include "actracer.h" +#include "assert.h" +#include "multicores.h" +#include "task.h" + +static struct TraceTag clock_driver_tag; +static struct XiziClockDriver* p_clock_driver = NULL; + +bool clock_intr_handler_init(struct TraceTag* p_clock_driver_tag) +{ + clock_driver_tag = *p_clock_driver_tag; + p_clock_driver = AchieveResource(p_clock_driver_tag); + return p_clock_driver != NULL; +} + +void hw_current_tick(uintptr_t* tick) +{ + if (p_clock_driver == NULL) { + *tick = 0; + return; + } + *tick = p_clock_driver->get_tick(); +} + +void hw_current_second(uintptr_t* second) +{ + if (p_clock_driver == NULL) { + *second = 0; + return; + } + *second = p_clock_driver->get_second(); +} + +uint64_t global_tick = 0; +int xizi_clock_handler(int irq, void* tf, void* arg) +{ + /* handle clock interrupt using driver */ + if (p_clock_driver->is_timer_expired()) { + p_clock_driver->clear_clock_intr(); + global_tick++; + struct Thread* current_task = cur_cpu()->task; + if (current_task) { + current_task->remain_tick--; + current_task->maxium_tick--; + if (current_task->remain_tick == 0) { + xizi_task_manager.task_yield_noschedule(current_task, false); + } + } + } + return 0; } \ No newline at end of file