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

Support blocking server.

This commit is contained in:
TXuian 2024-04-30 18:17:31 +08:00
parent 9f9e25a98e
commit 3a985252d9
13 changed files with 174 additions and 59 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
Ubiquitous/XiZi_AIoT/services/app/Makefile
View File

@ -24,7 +24,7 @@ INC_DIR = -I$(KERNEL_ROOT)/services/shell/letter-shell \
-I$(KERNEL_ROOT)/services/app
ifeq ($(BOARD), imx6q-sabrelite)
all: init test_fs simple_client simple_server shell fs_server test_irq_hdlr test_irq_send readme.txt | bin
all: init test_fs simple_client simple_server shell fs_server test_irq_hdlr test_irq_block test_irq_send readme.txt | bin
else
all: init test_fs simple_client simple_server shell fs_server test_irq_hdlr readme.txt | bin
endif
@ -42,6 +42,10 @@ test_irq_send: test_irq_sender.o usyscall.o libserial.o
@${objdump} -S $@ > $@.asm
endif
test_irq_block: test_irq_block.o libserial.o libipc.o session.o usyscall.o libmem.o
@${ld} ${user_ldflags} -e main -o $@ $^ ${board_specs}
@${objdump} -S $@ > $@.asm
test_irq_hdlr: test_irq_handler.o libserial.o libipc.o session.o usyscall.o libmem.o
@${ld} ${user_ldflags} -e main -o $@ $^ ${board_specs}
@${objdump} -S $@ > $@.asm

20
Ubiquitous/XiZi_AIoT/services/app/test_irq.h Normal file
View File

@ -0,0 +1,20 @@
/*
* 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 "libipc.h"
#include "libserial.h"
#include "usyscall.h"
IPC_SERVICES(IpcSwIntrHandler, Ipc_intr_3, Ipc_wait_intr_3);
enum {
SW_INTERRUPT_3 = 3,
};

35
Ubiquitous/XiZi_AIoT/services/app/test_irq_block.c Normal file
View File

@ -0,0 +1,35 @@
/*
* 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 "test_irq.h"
IPC_INTERFACE(Ipc_wait_intr_3, 1, ignore, 0);
int wait_intr(struct Session* session, void* ignore_param)
{
return IPC_CALL(Ipc_wait_intr_3)(session, NULL);
}
static char prog_name[] = "TEST_IRQ_BLOCK";
int main(int argc, char* argv[])
{
struct Session session;
if (connect_session(&session, "TestIRQ", 4096) < 0) {
printf("connect session failed\n");
exit();
}
printf("%s start waiting for IRQ.\n", prog_name);
wait_intr(&session, NULL);
printf("%s return from waiting for IRQ.\n", prog_name);
exit();
}

38
Ubiquitous/XiZi_AIoT/services/app/test_irq_handler.c
View File

@ -10,35 +10,45 @@
* See the Mulan PSL v2 for more details.
*/
#include "libipc.h"
#include "libserial.h"
#include "usyscall.h"
#include "test_irq.h"
IPC_SERVICES(IpcSwIntrHandler, Ipc_intr_3);
enum {
SW_INTERRUPT_3 = 3,
};
void sgi_test_handler(void)
static bool has_one_interrupt = false;
int IPC_DO_SERVE_FUNC(Ipc_intr_3)(void* ignore)
{
printf("TEST_SW_HDLR: In %s()\n", __func__);
has_one_interrupt = true;
return 0;
}
int IPC_DO_SERVE_FUNC(Ipc_intr_3)(void* useless)
int IPC_DO_SERVE_FUNC(Ipc_wait_intr_3)(void* ignore)
{
sgi_test_handler();
// delay the this handle
if (!has_one_interrupt) {
delay_session();
return -1;
}
// serve can be done by now
has_one_interrupt = false;
return 0;
}
IPC_SERVER_INTERFACE(Ipc_intr_3, 1);
IPC_SERVER_REGISTER_INTERFACES(IpcSwIntrHandler, 1, Ipc_intr_3);
IPC_SERVER_INTERFACE(Ipc_wait_intr_3, 1);
IPC_SERVER_REGISTER_INTERFACES(IpcSwIntrHandler, 2, Ipc_intr_3, Ipc_wait_intr_3);
int main()
{
if (register_irq(SW_INTERRUPT_3, Ipc_intr_3) == -1) {
if (register_irq(SW_INTERRUPT_3, Ipc_intr_3) < 0) {
printf("TEST_SW_HDLR: bind failed");
exit();
}
static char prog_name[] = "TestIRQ";
if (register_server("TestIRQ") < 0) {
printf("register server name: %s failed.\n", prog_name);
exit();
}
ipc_server_loop(&IpcSwIntrHandler);
exit();

2
Ubiquitous/XiZi_AIoT/services/fs/fs_server/include/fs.h
View File

@ -88,7 +88,7 @@ struct Inode {
};
// directory entry
#define DIR_NAME_SIZE 14
#define DIR_NAME_SIZE 30
struct DirectEntry {
uint16_t inum;
char name[DIR_NAME_SIZE];

72
Ubiquitous/XiZi_AIoT/services/lib/ipc/libipc.c
View File

@ -156,6 +156,11 @@ void delay_session(void)
session_delayed = true;
}
bool is_cur_session_delayed(void)
{
return session_delayed;
}
void ipc_server_loop(struct IpcNode* ipc_node)
{
struct Session session_list[NR_MAX_SESSION];
@ -168,43 +173,46 @@ void ipc_server_loop(struct IpcNode* ipc_node)
*/
poll_session(session_list, NR_MAX_SESSION);
/* handle each session */
for (int i = 0; i < NR_MAX_SESSION; i++) {
if (session_list[i].buf == NULL) {
yield(SYS_TASK_YIELD_NO_REASON);
break;
}
cur_sess_id = session_list[i].id;
struct IpcMsg* msg = IPCSESSION_MSG(&session_list[i]);
/* handle every message in current session
a session could be delay in case one of its message(current message) needs to wait for an interrupt message's arrival
interfaces[opcode] should explicitly call delay_session() and return to delay this session
*/
while (msg->header.magic == IPC_MSG_MAGIC && msg->header.valid == 1 && msg->header.done == 0) {
// printf("session %d [%d, %d]\n", session_list[i].id, session_list[i].head, session_list[i].tail);
if (session_used_size(&session_list[i]) == 0 && session_forward_tail(&session_list[i], msg->header.len) < 0) {
break;
for (int repeat = 0; repeat <= 1; repeat++) {
for (int i = 0; i < NR_MAX_SESSION; i++) {
if (session_list[i].buf == NULL) {
yield(SYS_TASK_YIELD_NO_REASON);
continue;
}
// this is a message needs to handle
if (ipc_node->interfaces[msg->header.opcode]) {
ipc_node->interfaces[msg->header.opcode](msg);
// check if this session is delayed by op handler, all messages after the delayed message in current session is blocked.
if (session_delayed) {
session_delayed = false;
cur_sess_id = session_list[i].id;
struct IpcMsg* msg = IPCSESSION_MSG(&session_list[i]);
/* handle every message in current session
a session could be delay in case one of its message(current message) needs to wait for an interrupt message's arrival
interfaces[opcode] should explicitly call delay_session() and return to delay this session
*/
while (msg->header.magic == IPC_MSG_MAGIC && msg->header.valid == 1 && msg->header.done == 0) {
// printf("session %d [%d, %d]\n", session_list[i].id, session_list[i].head, session_list[i].tail);
if (session_used_size(&session_list[i]) == 0 && session_forward_tail(&session_list[i], msg->header.len) < 0) {
break;
}
} else {
printf("Unsupport opcode(%d) for server: %s\n", msg->header.opcode, ipc_node->name);
// this is a message needs to handle
if (ipc_node->interfaces[msg->header.opcode]) {
ipc_node->interfaces[msg->header.opcode](msg);
// check if this session is delayed by op handler, all messages after the delayed message in current session is blocked.
if (is_cur_session_delayed()) {
msg->header.delayed = 1;
session_delayed = false;
break;
}
} else {
printf("Unsupport opcode(%d) for server: %s\n", msg->header.opcode, ipc_node->name);
}
// current msg is a message that needs to ignore
// finish this message in server's perspective
if (session_forward_head(&session_list[i], msg->header.len) < 0) {
break;
}
msg = IPCSESSION_MSG(&session_list[i]);
}
// current msg is a message that needs to ignore
// finish this message in server's perspective
if (session_forward_head(&session_list[i], msg->header.len) < 0) {
break;
}
msg = IPCSESSION_MSG(&session_list[i]);
// stop handle this session
cur_sess_id = -1;
}
// stop handle this session
cur_sess_id = -1;
}
}
}

9
Ubiquitous/XiZi_AIoT/services/lib/ipc/libipc.h
View File

@ -47,7 +47,7 @@ typedef struct {
uint64_t valid : 1; // for server to peek new msg
uint64_t done : 1; // for client to check request done
uint64_t init : 1; // for client to check request done
uint64_t reserved : 1;
uint64_t delayed : 1;
uint64_t nr_args : 4;
uint64_t opcode : 8;
uint64_t len : 16;
@ -225,6 +225,7 @@ void ipc_server_loop(struct IpcNode* ipc_node);
return res; \
}
bool is_cur_session_delayed(void);
#define IPC_SERVER_INTERFACE(ipc_name, argc) \
static int IPC_SERVE(ipc_name)(struct IpcMsg * msg) \
{ \
@ -233,8 +234,10 @@ void ipc_server_loop(struct IpcNode* ipc_node);
argv[i] = ipc_msg_get_nth_arg_buf(msg, i); \
} \
int32_t _ret = IPC_DO_SERVE##argc(ipc_name); \
ipc_msg_set_return(msg, &_ret); \
msg->header.done = 1; \
if (!is_cur_session_delayed()) { \
ipc_msg_set_return(msg, &_ret); \
msg->header.done = 1; \
} \
return 0; \
}

2
Ubiquitous/XiZi_AIoT/services/tools/mkfs/mkfs.h
View File

@ -80,7 +80,7 @@ struct Inode {
};
// Directory is a file containing a sequence of DirEntry structures.
#define DIR_NAME_SIZE 14
#define DIR_NAME_SIZE 30
struct DirEntry {
ushort inum;
char name[DIR_NAME_SIZE];

2
Ubiquitous/XiZi_AIoT/softkernel/include/ipc.h
View File

@ -41,7 +41,7 @@ typedef struct {
uint64_t valid : 1; // for server to peek new msg
uint64_t done : 1; // for client to check request done
uint64_t init : 1; // for client to check request done
uint64_t reserved : 1;
uint64_t delayed : 1;
uint64_t nr_args : 4;
uint64_t opcode : 8;
uint64_t len : 16;

28
Ubiquitous/XiZi_AIoT/softkernel/syscall/sys_poll_session.c
View File

@ -28,11 +28,20 @@ Modification:
1. first version
*************************************************/
#include "assert.h"
#include "ipc.h"
#include "multicores.h"
#include "share_page.h"
#include "syscall.h"
#include "task.h"
#define IPCSESSION_MSG(session) ((struct IpcMsg*)((char*)((session)->buf) + (session)->head))
static inline bool is_msg_needed(struct IpcMsg* msg)
{
assert(msg != NULL);
return msg->header.magic == IPC_MSG_MAGIC && msg->header.valid == 1 && msg->header.done == 0 && msg->header.delayed == 0;
}
int sys_poll_session(struct Session* userland_session_arr, int arr_capacity)
{
struct TaskMicroDescriptor* cur_task = cur_cpu()->task;
@ -71,10 +80,11 @@ int sys_poll_session(struct Session* userland_session_arr, int arr_capacity)
}
/* poll with new sessions */
int i = 0;
int nr_sessions_need_to_handle = 0;
int session_idx = 0;
DOUBLE_LIST_FOR_EACH_ENTRY(server_session, &cur_task->svr_sess_listhead, node)
{
if (i >= arr_capacity) {
if (session_idx >= arr_capacity) {
break;
}
@ -90,16 +100,24 @@ int sys_poll_session(struct Session* userland_session_arr, int arr_capacity)
break;
}
userland_session_arr[i++] = (struct Session) {
userland_session_arr[session_idx] = (struct Session) {
.buf = (void*)server_session->buf_addr,
.capacity = server_session->capacity,
.head = server_session->head,
.tail = server_session->tail,
.id = SERVER_SESSION_BACKEND(server_session)->session_id,
};
struct IpcMsg* msg = IPCSESSION_MSG(&userland_session_arr[session_idx]);
if (is_msg_needed(msg)) {
nr_sessions_need_to_handle++;
}
session_idx++;
}
if (LIKELY(i < arr_capacity)) {
userland_session_arr[i].buf = 0;
if (session_idx < arr_capacity && nr_sessions_need_to_handle == 0) {
userland_session_arr[session_idx].buf = 0;
sys_yield(SYS_TASK_YIELD_BLOCK_IPC);
}
return 0;

4
Ubiquitous/XiZi_AIoT/softkernel/syscall/sys_register_irq.c
View File

@ -76,6 +76,10 @@ static void send_irq_to_user(int irq_num)
buf->header.magic = IPC_MSG_MAGIC;
buf->header.valid = 1;
if (irq_forward_table[irq_num].handle_task->state == BLOCKED) {
xizi_task_manager.task_unblock(irq_forward_table[irq_num].handle_task);
}
/* add session head */
session->head = (session->head + len) % session->capacity;
}

14
Ubiquitous/XiZi_AIoT/softkernel/syscall/sys_yield.c
View File

@ -31,7 +31,7 @@ Modification:
#include "syscall.h"
#include "task.h"
#include "log.h"
#include "assert.h"
int sys_yield(task_yield_reason reason)
{
@ -46,5 +46,17 @@ int sys_yield(task_yield_reason reason)
xizi_task_manager.task_block(cur_task);
}
}
// wake up all possible server
struct client_session* client_session = NULL;
DOUBLE_LIST_FOR_EACH_ENTRY(client_session, &cur_task->cli_sess_listhead, node)
{
assert(client_session != NULL);
struct session_backend* session_backend = CLIENT_SESSION_BACKEND(client_session);
if (session_backend->server->state == BLOCKED) {
xizi_task_manager.task_unblock(session_backend->server);
}
}
return 0;
}

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

@ -291,6 +291,7 @@ static void _task_yield_noschedule(struct TaskMicroDescriptor* task, bool blocki
task->state = READY;
}
task->remain_tick = TASK_CLOCK_TICK;
cur_cpu()->task = NULL;
task_node_add_to_ready_list_back(task);
}