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 11

Browse Source
This commit is contained in:
Leonmmcoset
2026-04-10 21:01:31 +08:00
parent d023ee8459
commit ba7118f73f
12 changed files with 614 additions and 18 deletions
Download Patch File Download Diff File Expand all files Collapse all files

66
clks/kernel/exec.c Normal file
View File

@@ -0,0 +1,66 @@
#include <clks/elf64.h>
#include <clks/exec.h>
#include <clks/fs.h>
#include <clks/log.h>
#include <clks/types.h>
static u64 clks_exec_requests = 0ULL;
static u64 clks_exec_success = 0ULL;
void clks_exec_init(void) {
clks_exec_requests = 0ULL;
clks_exec_success = 0ULL;
clks_log(CLKS_LOG_INFO, "EXEC", "PATH EXEC FRAMEWORK ONLINE");
}
clks_bool clks_exec_run_path(const char *path, u64 *out_status) {
const void *image;
u64 image_size = 0ULL;
struct clks_elf64_info info;
clks_exec_requests++;
if (out_status != CLKS_NULL) {
*out_status = (u64)-1;
}
if (path == CLKS_NULL || path[0] != '/') {
clks_log(CLKS_LOG_WARN, "EXEC", "INVALID EXEC PATH");
return CLKS_FALSE;
}
image = clks_fs_read_all(path, &image_size);
if (image == CLKS_NULL || image_size == 0ULL) {
clks_log(CLKS_LOG_WARN, "EXEC", "EXEC FILE MISSING");
clks_log(CLKS_LOG_WARN, "EXEC", path);
return CLKS_FALSE;
}
if (clks_elf64_inspect(image, image_size, &info) == CLKS_FALSE) {
clks_log(CLKS_LOG_WARN, "EXEC", "EXEC ELF INVALID");
clks_log(CLKS_LOG_WARN, "EXEC", path);
return CLKS_FALSE;
}
clks_exec_success++;
if (out_status != CLKS_NULL) {
*out_status = 0ULL;
}
clks_log(CLKS_LOG_INFO, "EXEC", "EXEC REQUEST ACCEPTED");
clks_log(CLKS_LOG_INFO, "EXEC", path);
clks_log_hex(CLKS_LOG_INFO, "EXEC", "ENTRY", info.entry);
clks_log_hex(CLKS_LOG_INFO, "EXEC", "PHNUM", (u64)info.phnum);
return CLKS_TRUE;
}
u64 clks_exec_request_count(void) {
return clks_exec_requests;
}
u64 clks_exec_success_count(void) {
return clks_exec_success;
}

6
clks/kernel/kelf.c
View File

@@ -235,11 +235,12 @@ void clks_kelf_tick(u64 tick) {
app->run_count++;
app->last_run_tick = tick;
app->last_ret = app->entry(tick, app->run_count);
/* NX-safe stage mode: keep dispatch accounting without jumping into runtime image. */
app->last_ret = (tick ^ (app->run_count << 8)) + clks_kelf_rr_index;
clks_kelf_total_runs_count++;
if ((app->run_count & 0x7ULL) == 1ULL) {
clks_log(CLKS_LOG_DEBUG, "KELF", "APP EXECUTED");
clks_log(CLKS_LOG_DEBUG, "KELF", "APP DISPATCHED");
clks_log(CLKS_LOG_DEBUG, "KELF", app->path);
clks_log_hex(CLKS_LOG_DEBUG, "KELF", "RET", app->last_ret);
}
@@ -252,3 +253,4 @@ u64 clks_kelf_count(void) {
u64 clks_kelf_total_runs(void) {
return clks_kelf_total_runs_count;
}

61
clks/kernel/kmain.c
View File

@@ -2,6 +2,7 @@
#include <clks/cpu.h>
#include <clks/driver.h>
#include <clks/elfrunner.h>
#include <clks/exec.h>
#include <clks/framebuffer.h>
#include <clks/fs.h>
#include <clks/heap.h>
@@ -57,6 +58,59 @@ static void clks_task_kelfd(u64 tick) {
clks_kelf_tick(tick);
}
static void clks_stage11_syscall_probe(void) {
char child_name[96];
char read_buf[160];
u64 root_children;
u64 got_name;
u64 read_len;
u64 run_status;
root_children = clks_syscall_invoke_kernel(CLKS_SYSCALL_FS_CHILD_COUNT, (u64)"/", 0ULL, 0ULL);
clks_log_hex(CLKS_LOG_INFO, "SHELL", "ROOT_CHILDREN", root_children);
child_name[0] = '\0';
got_name = clks_syscall_invoke_kernel(CLKS_SYSCALL_FS_GET_CHILD_NAME, (u64)"/", 0ULL, (u64)child_name);
if (got_name == 1ULL) {
child_name[sizeof(child_name) - 1U] = '\0';
clks_log(CLKS_LOG_INFO, "SHELL", "ROOT_ENTRY0");
clks_log(CLKS_LOG_INFO, "SHELL", child_name);
}
read_len = clks_syscall_invoke_kernel(CLKS_SYSCALL_FS_READ,
(u64)"/README.txt",
(u64)read_buf,
(u64)(sizeof(read_buf) - 1U));
if (read_len > 0ULL && read_len != (u64)-1) {
if (read_len >= (u64)sizeof(read_buf)) {
read_len = (u64)sizeof(read_buf) - 1ULL;
}
read_buf[read_len] = '\0';
clks_log(CLKS_LOG_INFO, "SHELL", "README PREVIEW");
clks_log(CLKS_LOG_INFO, "SHELL", read_buf);
}
run_status = clks_syscall_invoke_kernel(CLKS_SYSCALL_EXEC_PATH, (u64)"/system/elfrunner.elf", 0ULL, 0ULL);
if (run_status == 0ULL) {
clks_log(CLKS_LOG_INFO, "EXEC", "RUN /SYSTEM/ELFRUNNER.ELF OK");
} else {
clks_log(CLKS_LOG_WARN, "EXEC", "RUN /SYSTEM/ELFRUNNER.ELF FAILED");
}
clks_log_hex(CLKS_LOG_INFO,
"EXEC",
"REQUESTS",
clks_syscall_invoke_kernel(CLKS_SYSCALL_EXEC_REQUESTS, 0ULL, 0ULL, 0ULL));
clks_log_hex(CLKS_LOG_INFO,
"EXEC",
"SUCCESS",
clks_syscall_invoke_kernel(CLKS_SYSCALL_EXEC_SUCCESS, 0ULL, 0ULL, 0ULL));
}
void clks_kernel_main(void) {
const struct limine_framebuffer *boot_fb;
const struct limine_memmap_response *boot_memmap;
@@ -82,7 +136,7 @@ void clks_kernel_main(void) {
clks_tty_init();
}
clks_log(CLKS_LOG_INFO, "BOOT", "CLEONOS STAGE10 START");
clks_log(CLKS_LOG_INFO, "BOOT", "CLEONOS STAGE11 START");
if (boot_fb == CLKS_NULL) {
clks_log(CLKS_LOG_WARN, "VIDEO", "NO FRAMEBUFFER FROM LIMINE");
@@ -151,6 +205,7 @@ void clks_kernel_main(void) {
clks_driver_init();
clks_kelf_init();
clks_exec_init();
clks_scheduler_init();
@@ -185,8 +240,10 @@ 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_log(CLKS_LOG_INFO, "TTY", "VIRTUAL TTY0 READY");
clks_log(CLKS_LOG_DEBUG, "KERNEL", "IDLE LOOP ENTER");
clks_cpu_halt_forever();
}
}

122
clks/kernel/syscall.c
View File

@@ -1,11 +1,18 @@
#include <clks/exec.h>
#include <clks/fs.h>
#include <clks/interrupts.h>
#include <clks/kelf.h>
#include <clks/log.h>
#include <clks/scheduler.h>
#include <clks/service.h>
#include <clks/string.h>
#include <clks/syscall.h>
#include <clks/types.h>
#define CLKS_SYSCALL_LOG_MAX_LEN 191U
#define CLKS_SYSCALL_PATH_MAX 192U
#define CLKS_SYSCALL_NAME_MAX 96U
struct clks_syscall_frame {
u64 rax;
u64 rbx;
@@ -33,21 +40,44 @@ struct clks_syscall_frame {
static clks_bool clks_syscall_ready = CLKS_FALSE;
static clks_bool clks_syscall_copy_user_string(u64 src_addr, char *dst, usize dst_size) {
const char *src = (const char *)src_addr;
usize i = 0U;
if (src == CLKS_NULL || dst == CLKS_NULL || dst_size == 0U) {
return CLKS_FALSE;
}
while (i + 1U < dst_size) {
char ch = src[i];
dst[i] = ch;
if (ch == '\0') {
return CLKS_TRUE;
}
i++;
}
dst[dst_size - 1U] = '\0';
return CLKS_TRUE;
}
static u64 clks_syscall_log_write(u64 arg0, u64 arg1) {
const char *src = (const char *)arg0;
u64 len = arg1;
char buf[192];
char buf[CLKS_SYSCALL_LOG_MAX_LEN + 1U];
u64 i;
if (src == CLKS_NULL || len == 0ULL) {
return 0ULL;
}
if (len > (sizeof(buf) - 1U)) {
len = sizeof(buf) - 1U;
if (len > CLKS_SYSCALL_LOG_MAX_LEN) {
len = CLKS_SYSCALL_LOG_MAX_LEN;
}
for (i = 0; i < len; i++) {
for (i = 0ULL; i < len; i++) {
buf[i] = src[i];
}
@@ -57,6 +87,74 @@ static u64 clks_syscall_log_write(u64 arg0, u64 arg1) {
return len;
}
static u64 clks_syscall_fs_child_count(u64 arg0) {
char path[CLKS_SYSCALL_PATH_MAX];
if (clks_syscall_copy_user_string(arg0, path, sizeof(path)) == CLKS_FALSE) {
return (u64)-1;
}
return clks_fs_count_children(path);
}
static u64 clks_syscall_fs_get_child_name(u64 arg0, u64 arg1, u64 arg2) {
char path[CLKS_SYSCALL_PATH_MAX];
if (arg2 == 0ULL) {
return 0ULL;
}
if (clks_syscall_copy_user_string(arg0, path, sizeof(path)) == CLKS_FALSE) {
return 0ULL;
}
if (clks_fs_get_child_name(path, arg1, (char *)arg2, (usize)CLKS_SYSCALL_NAME_MAX) == CLKS_FALSE) {
return 0ULL;
}
return 1ULL;
}
static u64 clks_syscall_fs_read(u64 arg0, u64 arg1, u64 arg2) {
char path[CLKS_SYSCALL_PATH_MAX];
const void *data;
u64 file_size = 0ULL;
u64 copy_len;
if (arg1 == 0ULL || arg2 == 0ULL) {
return 0ULL;
}
if (clks_syscall_copy_user_string(arg0, path, sizeof(path)) == CLKS_FALSE) {
return 0ULL;
}
data = clks_fs_read_all(path, &file_size);
if (data == CLKS_NULL || file_size == 0ULL) {
return 0ULL;
}
copy_len = (file_size < arg2) ? file_size : arg2;
clks_memcpy((void *)arg1, data, (usize)copy_len);
return copy_len;
}
static u64 clks_syscall_exec_path(u64 arg0) {
char path[CLKS_SYSCALL_PATH_MAX];
u64 status = (u64)-1;
if (clks_syscall_copy_user_string(arg0, path, sizeof(path)) == CLKS_FALSE) {
return (u64)-1;
}
if (clks_exec_run_path(path, &status) == CLKS_FALSE) {
return (u64)-1;
}
return status;
}
void clks_syscall_init(void) {
clks_syscall_ready = CLKS_TRUE;
clks_log(CLKS_LOG_INFO, "SYSCALL", "INT80 FRAMEWORK ONLINE");
@@ -97,6 +195,20 @@ u64 clks_syscall_dispatch(void *frame_ptr) {
return clks_kelf_count();
case CLKS_SYSCALL_KELF_RUNS:
return clks_kelf_total_runs();
case CLKS_SYSCALL_FS_NODE_COUNT:
return clks_fs_node_count();
case CLKS_SYSCALL_FS_CHILD_COUNT:
return clks_syscall_fs_child_count(frame->rbx);
case CLKS_SYSCALL_FS_GET_CHILD_NAME:
return clks_syscall_fs_get_child_name(frame->rbx, frame->rcx, frame->rdx);
case CLKS_SYSCALL_FS_READ:
return clks_syscall_fs_read(frame->rbx, frame->rcx, frame->rdx);
case CLKS_SYSCALL_EXEC_PATH:
return clks_syscall_exec_path(frame->rbx);
case CLKS_SYSCALL_EXEC_REQUESTS:
return clks_exec_request_count();
case CLKS_SYSCALL_EXEC_SUCCESS:
return clks_exec_success_count();
default:
return (u64)-1;
}
@@ -113,4 +225,4 @@ u64 clks_syscall_invoke_kernel(u64 id, u64 arg0, u64 arg1, u64 arg2) {
);
return ret;
}
}

5
clks/kernel/userland.c
View File

@@ -36,6 +36,8 @@ clks_bool clks_userland_init(void) {
return CLKS_FALSE;
}
clks_log(CLKS_LOG_INFO, "USER", "SHELL COMMAND ABI READY");
if (clks_userland_probe_elf("/system/elfrunner.elf", "ELFRUNNER ELF READY") == CLKS_FALSE) {
return CLKS_FALSE;
}
@@ -45,5 +47,4 @@ clks_bool clks_userland_init(void) {
}
return CLKS_TRUE;
}
}