LeonMMcoset/cleonos
1
0
Fork 0
mirror of https://github.com/Leonmmcoset/cleonos.git synced 2026-04-21 18:44:01 +00:00
Code Issues Packages Projects Releases Wiki Activity

Stage 12

Browse Source
This commit is contained in:
Leonmmcoset
2026-04-10 21:10:16 +08:00
parent ba7118f73f
commit ae29f2b5cf
10 changed files with 219 additions and 10 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
clks/include/clks/service.h
View File

@@ -12,6 +12,7 @@ enum clks_service_id {
CLKS_SERVICE_DRIVER = 4,
CLKS_SERVICE_SCHED = 5,
CLKS_SERVICE_KELF = 6,
CLKS_SERVICE_USER = 7,
};
enum clks_service_state {

7
clks/include/clks/syscall.h
View File

@@ -19,9 +19,14 @@
#define CLKS_SYSCALL_EXEC_PATH 13ULL
#define CLKS_SYSCALL_EXEC_REQUESTS 14ULL
#define CLKS_SYSCALL_EXEC_SUCCESS 15ULL
#define CLKS_SYSCALL_USER_SHELL_READY 16ULL
#define CLKS_SYSCALL_USER_EXEC_REQUESTED 17ULL
#define CLKS_SYSCALL_USER_LAUNCH_TRIES 18ULL
#define CLKS_SYSCALL_USER_LAUNCH_OK 19ULL
#define CLKS_SYSCALL_USER_LAUNCH_FAIL 20ULL
void clks_syscall_init(void);
u64 clks_syscall_dispatch(void *frame_ptr);
u64 clks_syscall_invoke_kernel(u64 id, u64 arg0, u64 arg1, u64 arg2);
#endif
#endif

6
clks/include/clks/userland.h
View File

@@ -4,5 +4,11 @@
#include <clks/types.h>
clks_bool clks_userland_init(void);
void clks_userland_tick(u64 tick);
clks_bool clks_userland_shell_ready(void);
clks_bool clks_userland_shell_exec_requested(void);
u64 clks_userland_launch_attempts(void);
u64 clks_userland_launch_success(void);
u64 clks_userland_launch_failures(void);
#endif

42
clks/kernel/kmain.c
View File

@@ -58,7 +58,12 @@ static void clks_task_kelfd(u64 tick) {
clks_kelf_tick(tick);
}
static void clks_stage11_syscall_probe(void) {
static void clks_task_usrd(u64 tick) {
clks_service_heartbeat(CLKS_SERVICE_USER, tick);
clks_userland_tick(tick);
}
static void clks_stage12_syscall_probe(void) {
char child_name[96];
char read_buf[160];
u64 root_children;
@@ -109,6 +114,27 @@ static void clks_stage11_syscall_probe(void) {
"EXEC",
"SUCCESS",
clks_syscall_invoke_kernel(CLKS_SYSCALL_EXEC_SUCCESS, 0ULL, 0ULL, 0ULL));
clks_log_hex(CLKS_LOG_INFO,
"USER",
"SHELL_READY",
clks_syscall_invoke_kernel(CLKS_SYSCALL_USER_SHELL_READY, 0ULL, 0ULL, 0ULL));
clks_log_hex(CLKS_LOG_INFO,
"USER",
"EXEC_REQUESTED",
clks_syscall_invoke_kernel(CLKS_SYSCALL_USER_EXEC_REQUESTED, 0ULL, 0ULL, 0ULL));
clks_log_hex(CLKS_LOG_INFO,
"USER",
"LAUNCH_TRIES",
clks_syscall_invoke_kernel(CLKS_SYSCALL_USER_LAUNCH_TRIES, 0ULL, 0ULL, 0ULL));
clks_log_hex(CLKS_LOG_INFO,
"USER",
"LAUNCH_OK",
clks_syscall_invoke_kernel(CLKS_SYSCALL_USER_LAUNCH_OK, 0ULL, 0ULL, 0ULL));
clks_log_hex(CLKS_LOG_INFO,
"USER",
"LAUNCH_FAIL",
clks_syscall_invoke_kernel(CLKS_SYSCALL_USER_LAUNCH_FAIL, 0ULL, 0ULL, 0ULL));
}
void clks_kernel_main(void) {
@@ -136,7 +162,7 @@ void clks_kernel_main(void) {
clks_tty_init();
}
clks_log(CLKS_LOG_INFO, "BOOT", "CLEONOS STAGE11 START");
clks_log(CLKS_LOG_INFO, "BOOT", "CLEONOS STAGE12 START");
if (boot_fb == CLKS_NULL) {
clks_log(CLKS_LOG_WARN, "VIDEO", "NO FRAMEBUFFER FROM LIMINE");
@@ -198,6 +224,8 @@ void clks_kernel_main(void) {
clks_cpu_halt_forever();
}
clks_exec_init();
if (clks_userland_init() == CLKS_FALSE) {
clks_log(CLKS_LOG_ERROR, "USER", "USERLAND INIT FAILED");
clks_cpu_halt_forever();
@@ -205,7 +233,6 @@ void clks_kernel_main(void) {
clks_driver_init();
clks_kelf_init();
clks_exec_init();
clks_scheduler_init();
@@ -221,6 +248,10 @@ void clks_kernel_main(void) {
clks_log(CLKS_LOG_WARN, "SCHED", "FAILED TO ADD KELFD TASK");
}
if (clks_scheduler_add_kernel_task_ex("usrd", 2U, clks_task_usrd) == CLKS_FALSE) {
clks_log(CLKS_LOG_WARN, "SCHED", "FAILED TO ADD USRD TASK");
}
sched_stats = clks_scheduler_get_stats();
clks_log_hex(CLKS_LOG_INFO, "SCHED", "TASK_COUNT", sched_stats.task_count);
@@ -240,10 +271,11 @@ void clks_kernel_main(void) {
syscall_ticks = clks_syscall_invoke_kernel(CLKS_SYSCALL_TIMER_TICKS, 0ULL, 0ULL, 0ULL);
clks_log_hex(CLKS_LOG_INFO, "SYSCALL", "TICKS", syscall_ticks);
clks_stage11_syscall_probe();
clks_stage12_syscall_probe();
clks_log(CLKS_LOG_INFO, "TTY", "VIRTUAL TTY0 READY");
clks_log(CLKS_LOG_DEBUG, "KERNEL", "IDLE LOOP ENTER");
clks_cpu_halt_forever();
}
}

4
clks/kernel/service.c
View File

@@ -7,6 +7,7 @@
#include <clks/service.h>
#include <clks/string.h>
#include <clks/types.h>
#include <clks/userland.h>
#define CLKS_SERVICE_MAX 8U
@@ -84,6 +85,9 @@ void clks_service_init(void) {
clks_service_register(CLKS_SERVICE_KELF,
"kelf",
(clks_kelf_count() > 0ULL) ? CLKS_SERVICE_STATE_READY : CLKS_SERVICE_STATE_DEGRADED);
clks_service_register(CLKS_SERVICE_USER,
"userland",
(clks_userland_shell_ready() == CLKS_TRUE) ? CLKS_SERVICE_STATE_READY : CLKS_SERVICE_STATE_DEGRADED);
clks_log(CLKS_LOG_INFO, "SRV", "KERNEL SERVICES ONLINE");
clks_log_hex(CLKS_LOG_INFO, "SRV", "COUNT", clks_service_count());

13
clks/kernel/syscall.c
View File

@@ -8,6 +8,7 @@
#include <clks/string.h>
#include <clks/syscall.h>
#include <clks/types.h>
#include <clks/userland.h>
#define CLKS_SYSCALL_LOG_MAX_LEN 191U
#define CLKS_SYSCALL_PATH_MAX 192U
@@ -209,6 +210,16 @@ u64 clks_syscall_dispatch(void *frame_ptr) {
return clks_exec_request_count();
case CLKS_SYSCALL_EXEC_SUCCESS:
return clks_exec_success_count();
case CLKS_SYSCALL_USER_SHELL_READY:
return (clks_userland_shell_ready() == CLKS_TRUE) ? 1ULL : 0ULL;
case CLKS_SYSCALL_USER_EXEC_REQUESTED:
return (clks_userland_shell_exec_requested() == CLKS_TRUE) ? 1ULL : 0ULL;
case CLKS_SYSCALL_USER_LAUNCH_TRIES:
return clks_userland_launch_attempts();
case CLKS_SYSCALL_USER_LAUNCH_OK:
return clks_userland_launch_success();
case CLKS_SYSCALL_USER_LAUNCH_FAIL:
return clks_userland_launch_failures();
default:
return (u64)-1;
}
@@ -225,4 +236,4 @@ u64 clks_syscall_invoke_kernel(u64 id, u64 arg0, u64 arg1, u64 arg2) {
);
return ret;
}
}

77
clks/kernel/userland.c
View File

@@ -1,9 +1,19 @@
#include <clks/elf64.h>
#include <clks/exec.h>
#include <clks/fs.h>
#include <clks/log.h>
#include <clks/types.h>
#include <clks/userland.h>
#define CLKS_USERLAND_RETRY_INTERVAL 500ULL
static clks_bool clks_user_shell_ready = CLKS_FALSE;
static clks_bool clks_user_shell_exec_requested_flag = CLKS_FALSE;
static u64 clks_user_launch_attempt_count = 0ULL;
static u64 clks_user_launch_success_count = 0ULL;
static u64 clks_user_launch_fail_count = 0ULL;
static u64 clks_user_last_try_tick = 0ULL;
static clks_bool clks_userland_probe_elf(const char *path, const char *tag) {
const void *image;
u64 size = 0ULL;
@@ -29,13 +39,44 @@ static clks_bool clks_userland_probe_elf(const char *path, const char *tag) {
return CLKS_TRUE;
}
static clks_bool clks_userland_request_shell_exec(void) {
u64 status = (u64)-1;
if (clks_user_shell_ready == CLKS_FALSE) {
return CLKS_FALSE;
}
clks_user_launch_attempt_count++;
if (clks_exec_run_path("/shell/shell.elf", &status) == CLKS_TRUE && status == 0ULL) {
clks_user_shell_exec_requested_flag = CLKS_TRUE;
clks_user_launch_success_count++;
clks_log(CLKS_LOG_INFO, "USER", "SHELL EXEC REQUESTED");
clks_log_hex(CLKS_LOG_INFO, "USER", "SHELL_STATUS", status);
return CLKS_TRUE;
}
clks_user_launch_fail_count++;
clks_log(CLKS_LOG_WARN, "USER", "SHELL EXEC REQUEST FAILED");
return CLKS_FALSE;
}
clks_bool clks_userland_init(void) {
clks_log(CLKS_LOG_INFO, "USER", "USERLAND FRAMEWORK ONLINE");
clks_user_shell_ready = CLKS_FALSE;
clks_user_shell_exec_requested_flag = CLKS_FALSE;
clks_user_launch_attempt_count = 0ULL;
clks_user_launch_success_count = 0ULL;
clks_user_launch_fail_count = 0ULL;
clks_user_last_try_tick = 0ULL;
if (clks_userland_probe_elf("/shell/shell.elf", "SHELL ELF READY") == CLKS_FALSE) {
return CLKS_FALSE;
}
clks_user_shell_ready = CLKS_TRUE;
clks_log(CLKS_LOG_INFO, "USER", "SHELL COMMAND ABI READY");
if (clks_userland_probe_elf("/system/elfrunner.elf", "ELFRUNNER ELF READY") == CLKS_FALSE) {
@@ -46,5 +87,39 @@ clks_bool clks_userland_init(void) {
return CLKS_FALSE;
}
(void)clks_userland_request_shell_exec();
return CLKS_TRUE;
}
}
void clks_userland_tick(u64 tick) {
if (clks_user_shell_ready == CLKS_FALSE || clks_user_shell_exec_requested_flag == CLKS_TRUE) {
return;
}
if (tick - clks_user_last_try_tick < CLKS_USERLAND_RETRY_INTERVAL) {
return;
}
clks_user_last_try_tick = tick;
(void)clks_userland_request_shell_exec();
}
clks_bool clks_userland_shell_ready(void) {
return clks_user_shell_ready;
}
clks_bool clks_userland_shell_exec_requested(void) {
return clks_user_shell_exec_requested_flag;
}
u64 clks_userland_launch_attempts(void) {
return clks_user_launch_attempt_count;
}
u64 clks_userland_launch_success(void) {
return clks_user_launch_success_count;
}
u64 clks_userland_launch_failures(void) {
return clks_user_launch_fail_count;
}