662 lines
20 KiB
C
662 lines
20 KiB
C
/*
|
||
* commands.c – Shell command registry and handler implementations.
|
||
*
|
||
* Each command is a { name, description, usage, handler } entry in the
|
||
* static `commands[]` table. execute_command() splits user input into
|
||
* command + arguments and dispatches to the matching handler.
|
||
*
|
||
* To add a new command:
|
||
* 1. Write a static handler cmd_foo(BootInfo *Boot, CHAR16 *Args)
|
||
* 2. Add a forward declaration above the table
|
||
* 3. Append an entry to commands[] (before the sentinel)
|
||
*/
|
||
|
||
#include "kernel_types.h"
|
||
#include "commands.h"
|
||
#include "string_utils.h"
|
||
#include "memory.h"
|
||
#include "task.h"
|
||
|
||
/* Null-safe print helper used throughout the kernel. */
|
||
#define SAFE_PRINT(Boot, ...) \
|
||
do { \
|
||
if ((Boot) != NULL && (Boot)->print != NULL) { \
|
||
(Boot)->print(__VA_ARGS__); \
|
||
} \
|
||
} while (0)
|
||
|
||
/* ================================================================
|
||
* Forward declarations
|
||
* ================================================================ */
|
||
|
||
static void cmd_shutdown(BootInfo *Boot, CHAR16 *Args);
|
||
static void cmd_help(BootInfo *Boot, CHAR16 *Args);
|
||
static void cmd_man(BootInfo *Boot, CHAR16 *Args);
|
||
static void cmd_clear(BootInfo *Boot, CHAR16 *Args);
|
||
static void cmd_about(BootInfo *Boot, CHAR16 *Args);
|
||
static void cmd_mem(BootInfo *Boot, CHAR16 *Args);
|
||
static void cmd_ps(BootInfo *Boot, CHAR16 *Args);
|
||
static void cmd_spawn(BootInfo *Boot, CHAR16 *Args);
|
||
static void cmd_memtest(BootInfo *Boot, CHAR16 *Args);
|
||
static void cmd_tasktest(BootInfo *Boot, CHAR16 *Args);
|
||
static void cmd_kusr(BootInfo *Boot, CHAR16 *Args);
|
||
|
||
/* Small helper struct used to pass arguments into per-command tasks. */
|
||
typedef struct {
|
||
BootInfo *Boot;
|
||
CommandHandlerFn handler;
|
||
CHAR16 args[128];
|
||
} CommandTaskContext;
|
||
|
||
static void command_task_entry(void *arg);
|
||
|
||
/* Local string copy helper (wide-char, bounded). */
|
||
static void wstrcpy16_local(CHAR16 *dst, const CHAR16 *src, UINTN max)
|
||
{
|
||
UINTN i = 0;
|
||
|
||
if (dst == NULL || max == 0) {
|
||
return;
|
||
}
|
||
|
||
while (src != NULL && src[i] != L'\0' && i < (max - 1)) {
|
||
dst[i] = src[i];
|
||
i++;
|
||
}
|
||
|
||
dst[i] = L'\0';
|
||
}
|
||
|
||
/* ================================================================
|
||
* Command registry
|
||
* ================================================================ */
|
||
|
||
static Command commands[] = {
|
||
{
|
||
L"shutdown",
|
||
L"Shutdown the system",
|
||
L"Usage: shutdown\n\r Initiates a system shutdown using UEFI runtime services.",
|
||
TASK_PRIV_KERNEL,
|
||
cmd_shutdown
|
||
},
|
||
{
|
||
L"help",
|
||
L"Display available commands",
|
||
L"Usage: help\n\r Lists all available commands with brief descriptions.",
|
||
TASK_PRIV_USER,
|
||
cmd_help
|
||
},
|
||
{
|
||
L"man",
|
||
L"Display manual page for a command",
|
||
L"Usage: man <command>\n\r Shows detailed help for the specified command.",
|
||
TASK_PRIV_USER,
|
||
cmd_man
|
||
},
|
||
{
|
||
L"clear",
|
||
L"Clear the screen",
|
||
L"Usage: clear\n\r Clears the console screen.",
|
||
TASK_PRIV_USER,
|
||
cmd_clear
|
||
},
|
||
{
|
||
L"about",
|
||
L"Display system information",
|
||
L"Usage: about\n\r Shows information about this operating system.",
|
||
TASK_PRIV_USER,
|
||
cmd_about
|
||
},
|
||
{
|
||
L"mem",
|
||
L"Display memory statistics",
|
||
L"Usage: mem\n\r Shows physical memory, heap, and paging information.",
|
||
TASK_PRIV_KERNEL,
|
||
cmd_mem
|
||
},
|
||
{
|
||
L"ps",
|
||
L"List running tasks",
|
||
L"Usage: ps\n\r Displays all active tasks with PID, state, and name.",
|
||
TASK_PRIV_DRIVER,
|
||
cmd_ps
|
||
},
|
||
{
|
||
L"spawn",
|
||
L"Spawn a demo background task",
|
||
L"Usage: spawn [name]\n\r Creates a cooperative demo task.\n\r Optional argument sets the task name.",
|
||
TASK_PRIV_DRIVER,
|
||
cmd_spawn
|
||
},
|
||
{
|
||
L"memtest",
|
||
L"Test memory allocation and deallocation",
|
||
L"Usage: memtest\n\r"
|
||
L" Run memory tests in four phases:\n\r"
|
||
L" 1) Heap allocation of 8 blocks (16–4096 bytes) via kmalloc()\n\r"
|
||
L" 2) Heap free and coalescing verification via kfree()\n\r"
|
||
L" 3) Single-page PMM allocate/free via pmm_alloc_page()/pmm_free_page()\n\r"
|
||
L" 4) Multi-page (4-page) PMM allocate/free via pmm_alloc_pages()/pmm_free_pages()\n\r",
|
||
TASK_PRIV_KERNEL,
|
||
cmd_memtest
|
||
},
|
||
{
|
||
L"tasktest",
|
||
L"Test task scheduler with multiple tasks",
|
||
L"Usage: tasktest\n\r"
|
||
L" Spawns three worker tasks (worker-A/B/C) that run cooperatively,\n\r"
|
||
L" each printing three progress steps and yielding between them.\n\r"
|
||
L" After the workers finish, prints the final task list to\n\r"
|
||
L" demonstrate the cooperative round-robin scheduler.",
|
||
TASK_PRIV_DRIVER,
|
||
cmd_tasktest
|
||
},
|
||
{
|
||
L"kusr",
|
||
L"Run a command with kernel privilege",
|
||
L"Usage: kusr <command> [args...]\n\r"
|
||
L" Temporarily elevates the current task to kernel privilege,\n\r"
|
||
L" executes the given command, then restores the original level.",
|
||
TASK_PRIV_USER,
|
||
cmd_kusr
|
||
},
|
||
{NULL, NULL, NULL, 0, NULL} /* sentinel */
|
||
};
|
||
|
||
/* ================================================================
|
||
* System control
|
||
* ================================================================ */
|
||
|
||
static void request_shutdown(BootInfo *Boot)
|
||
{
|
||
Task *caller;
|
||
|
||
if (Boot == NULL) {
|
||
return;
|
||
}
|
||
|
||
/* Subsystem-level privilege enforcement: shutdown requires KERNEL. */
|
||
caller = task_current();
|
||
if (caller != NULL && task_get_privilege(caller) < TASK_PRIV_KERNEL) {
|
||
SAFE_PRINT(Boot, L"Permission denied: shutdown requires kernel privilege.\n\r");
|
||
return;
|
||
}
|
||
|
||
if (Boot->shutdown != NULL) {
|
||
Boot->shutdown();
|
||
return;
|
||
}
|
||
|
||
SAFE_PRINT(Boot, L"Shutdown service unavailable.\n\r");
|
||
}
|
||
|
||
/* ================================================================
|
||
* Built-in command handlers
|
||
* ================================================================ */
|
||
|
||
static void cmd_shutdown(BootInfo *Boot, CHAR16 *Args)
|
||
{
|
||
(void)Args;
|
||
SAFE_PRINT(Boot, L"Shutting down...\n\r");
|
||
request_shutdown(Boot);
|
||
}
|
||
|
||
static void cmd_help(BootInfo *Boot, CHAR16 *Args)
|
||
{
|
||
(void)Args;
|
||
show_help(Boot);
|
||
}
|
||
|
||
static void cmd_man(BootInfo *Boot, CHAR16 *Args)
|
||
{
|
||
UINTN i = 0;
|
||
|
||
if (Args == NULL || Args[0] == L'\0') {
|
||
SAFE_PRINT(Boot, L"Usage: man <command>\n\r");
|
||
SAFE_PRINT(Boot, L"Try 'help' for a list of available commands.\n\r");
|
||
return;
|
||
}
|
||
|
||
trim_spaces_inplace(Args);
|
||
|
||
for (i = 0; commands[i].name != NULL; i++) {
|
||
if (ascii_streq_ci(Args, commands[i].name)) {
|
||
SAFE_PRINT(Boot, L"\n\r");
|
||
SAFE_PRINT(Boot, L"NAME\n\r");
|
||
SAFE_PRINT(Boot, L" %s - %s\n\r\n\r", commands[i].name, commands[i].description);
|
||
SAFE_PRINT(Boot, L"DESCRIPTION\n\r");
|
||
SAFE_PRINT(Boot, L" %s\n\r", commands[i].usage);
|
||
SAFE_PRINT(Boot, L"\n\r");
|
||
return;
|
||
}
|
||
}
|
||
|
||
SAFE_PRINT(Boot, L"No manual entry for '%s'\n\r", Args);
|
||
SAFE_PRINT(Boot, L"Try 'help' for a list of available commands.\n\r");
|
||
}
|
||
|
||
static void cmd_clear(BootInfo *Boot, CHAR16 *Args)
|
||
{
|
||
KSTATUS Status;
|
||
(void)Args;
|
||
|
||
if (Boot != NULL && Boot->clear_screen != NULL) {
|
||
Status = Boot->clear_screen();
|
||
if (Status != 0) {
|
||
SAFE_PRINT(Boot, L"Failed to clear screen (status=%ld)\n\r",
|
||
(UINT64)Status);
|
||
}
|
||
} else {
|
||
SAFE_PRINT(Boot, L"Clear screen function unavailable.\n\r");
|
||
}
|
||
}
|
||
|
||
static void cmd_about(BootInfo *Boot, CHAR16 *Args)
|
||
{
|
||
(void)Args;
|
||
|
||
SAFE_PRINT(Boot, L"\n\r");
|
||
SAFE_PRINT(Boot, L"================================================\n\r");
|
||
SAFE_PRINT(Boot, L" Simple 64-bit Operating System\n\r");
|
||
SAFE_PRINT(Boot, L"================================================\n\r");
|
||
SAFE_PRINT(Boot, L"\n\r");
|
||
SAFE_PRINT(Boot, L"A minimal bootable operating system written in C.\n\r");
|
||
SAFE_PRINT(Boot, L"\n\r");
|
||
SAFE_PRINT(Boot, L"Features:\n\r");
|
||
SAFE_PRINT(Boot, L" - Flexible bootloader interface\n\r");
|
||
SAFE_PRINT(Boot, L" - Console I/O\n\r");
|
||
SAFE_PRINT(Boot, L" - ELF64 Kernel Loader\n\r");
|
||
SAFE_PRINT(Boot, L" - Memory Management (PMM + Heap)\n\r");
|
||
SAFE_PRINT(Boot, L" - Cooperative Multitasking\n\r");
|
||
SAFE_PRINT(Boot, L" - Interactive Command Interface\n\r");
|
||
SAFE_PRINT(Boot, L"\n\r");
|
||
SAFE_PRINT(Boot, L"Type 'help' for available commands.\n\r");
|
||
SAFE_PRINT(Boot, L"\n\r");
|
||
}
|
||
|
||
static void cmd_mem(BootInfo *Boot, CHAR16 *Args)
|
||
{
|
||
(void)Args;
|
||
memory_print_stats(Boot);
|
||
}
|
||
|
||
/* ----------------------------------------------------------------
|
||
* Demo task – runs cooperatively, prints progress, then exits
|
||
* ---------------------------------------------------------------- */
|
||
|
||
static void demo_task_fn(void *arg)
|
||
{
|
||
BootInfo *Boot = (BootInfo *)arg;
|
||
Task *self = task_current();
|
||
UINTN i;
|
||
|
||
SAFE_PRINT(Boot, L"[%s:%d] started\n\r", self->name, self->pid);
|
||
|
||
for (i = 0; i < 5; i++) {
|
||
SAFE_PRINT(Boot, L"[%s:%d] tick %d/5\n\r",
|
||
self->name, self->pid, i + 1);
|
||
task_yield();
|
||
}
|
||
|
||
SAFE_PRINT(Boot, L"[%s:%d] finished\n\r", self->name, self->pid);
|
||
}
|
||
|
||
static void cmd_ps(BootInfo *Boot, CHAR16 *Args)
|
||
{
|
||
(void)Args;
|
||
task_print_list(Boot);
|
||
}
|
||
|
||
static void cmd_spawn(BootInfo *Boot, CHAR16 *Args)
|
||
{
|
||
Task *t;
|
||
const CHAR16 *name;
|
||
|
||
if (Args != NULL && Args[0] != L'\0') {
|
||
trim_spaces_inplace(Args);
|
||
name = Args;
|
||
} else {
|
||
name = L"demo";
|
||
}
|
||
|
||
t = task_create(name, demo_task_fn, Boot);
|
||
if (t == NULL) {
|
||
SAFE_PRINT(Boot, L"Failed to create task (out of slots or memory).\n\r");
|
||
return;
|
||
}
|
||
|
||
SAFE_PRINT(Boot, L"Created task '%s' (PID %d)\n\r", t->name, t->pid);
|
||
}
|
||
|
||
/* ----------------------------------------------------------------
|
||
* memtest – exercise the heap and PMM allocators
|
||
* ---------------------------------------------------------------- */
|
||
|
||
static void cmd_memtest(BootInfo *Boot, CHAR16 *Args)
|
||
{
|
||
void *ptrs[8];
|
||
UINTN sizes[] = { 16, 64, 128, 256, 512, 1024, 2048, 4096 };
|
||
UINTN i;
|
||
UINT64 page;
|
||
UINTN h_total, h_used, h_free, h_blocks;
|
||
Task *caller;
|
||
(void)Args;
|
||
|
||
/* Subsystem-level privilege enforcement: memtest requires KERNEL. */
|
||
caller = task_current();
|
||
if (caller != NULL && task_get_privilege(caller) < TASK_PRIV_KERNEL) {
|
||
SAFE_PRINT(Boot, L"Permission denied: memtest requires kernel privilege.\n\r");
|
||
return;
|
||
}
|
||
|
||
SAFE_PRINT(Boot, L"\n\r");
|
||
SAFE_PRINT(Boot, L"Memory Test\n\r");
|
||
SAFE_PRINT(Boot, L"================================================\n\r");
|
||
SAFE_PRINT(Boot, L"\n\r");
|
||
|
||
/* --- Heap allocation test --- */
|
||
SAFE_PRINT(Boot, L"[1] Heap allocation test\n\r");
|
||
for (i = 0; i < 8; i++) {
|
||
ptrs[i] = kmalloc(sizes[i]);
|
||
if (ptrs[i] != NULL) {
|
||
SAFE_PRINT(Boot, L" kmalloc(%4d) = 0x%lx OK\n\r",
|
||
sizes[i], (UINT64)(UINTN)ptrs[i]);
|
||
} else {
|
||
SAFE_PRINT(Boot, L" kmalloc(%4d) = NULL FAIL\n\r", sizes[i]);
|
||
}
|
||
}
|
||
|
||
heap_get_stats(&h_total, &h_used, &h_free, &h_blocks);
|
||
SAFE_PRINT(Boot, L" Heap after alloc: used=%d free=%d blocks=%d\n\r",
|
||
h_used, h_free, h_blocks);
|
||
|
||
/* --- Heap free test --- */
|
||
SAFE_PRINT(Boot, L"\n\r[2] Heap free test\n\r");
|
||
for (i = 0; i < 8; i++) {
|
||
if (ptrs[i] != NULL) {
|
||
kfree(ptrs[i]);
|
||
SAFE_PRINT(Boot, L" kfree(0x%lx) OK\n\r",
|
||
(UINT64)(UINTN)ptrs[i]);
|
||
}
|
||
}
|
||
|
||
heap_get_stats(&h_total, &h_used, &h_free, &h_blocks);
|
||
SAFE_PRINT(Boot, L" Heap after free: used=%d free=%d blocks=%d\n\r",
|
||
h_used, h_free, h_blocks);
|
||
|
||
/* --- PMM page allocation test --- */
|
||
SAFE_PRINT(Boot, L"\n\r[3] PMM page allocation test\n\r");
|
||
SAFE_PRINT(Boot, L" Free pages before: %d\n\r", pmm_get_free_pages());
|
||
|
||
page = pmm_alloc_page();
|
||
if (page != 0) {
|
||
SAFE_PRINT(Boot, L" pmm_alloc_page() = 0x%lx OK\n\r", page);
|
||
SAFE_PRINT(Boot, L" Free pages after alloc: %d\n\r", pmm_get_free_pages());
|
||
pmm_free_page(page);
|
||
SAFE_PRINT(Boot, L" pmm_free_page() OK\n\r");
|
||
SAFE_PRINT(Boot, L" Free pages after free: %d\n\r", pmm_get_free_pages());
|
||
} else {
|
||
SAFE_PRINT(Boot, L" pmm_alloc_page() = 0 FAIL (out of pages)\n\r");
|
||
}
|
||
|
||
/* --- Multi-page allocation test --- */
|
||
SAFE_PRINT(Boot, L"\n\r[4] PMM multi-page allocation test (4 pages)\n\r");
|
||
page = pmm_alloc_pages(4);
|
||
if (page != 0) {
|
||
SAFE_PRINT(Boot, L" pmm_alloc_pages(4) = 0x%lx OK\n\r", page);
|
||
SAFE_PRINT(Boot, L" Free pages after alloc: %d\n\r", pmm_get_free_pages());
|
||
pmm_free_pages(page, 4);
|
||
SAFE_PRINT(Boot, L" pmm_free_pages() OK\n\r");
|
||
SAFE_PRINT(Boot, L" Free pages after free: %d\n\r", pmm_get_free_pages());
|
||
} else {
|
||
SAFE_PRINT(Boot, L" pmm_alloc_pages(4) = 0 FAIL\n\r");
|
||
}
|
||
|
||
SAFE_PRINT(Boot, L"\n\rAll memory tests completed.\n\r\n\r");
|
||
}
|
||
|
||
/* ----------------------------------------------------------------
|
||
* tasktest – spawn multiple concurrent tasks to exercise scheduler
|
||
* ---------------------------------------------------------------- */
|
||
|
||
static void worker_task_fn(void *arg)
|
||
{
|
||
BootInfo *Boot = (BootInfo *)arg;
|
||
Task *self = task_current();
|
||
UINTN i;
|
||
|
||
for (i = 0; i < 3; i++) {
|
||
SAFE_PRINT(Boot, L" [%s:%d] working... step %d/3\n\r",
|
||
self->name, self->pid, i + 1);
|
||
task_yield();
|
||
}
|
||
|
||
SAFE_PRINT(Boot, L" [%s:%d] done\n\r", self->name, self->pid);
|
||
}
|
||
|
||
static void cmd_tasktest(BootInfo *Boot, CHAR16 *Args)
|
||
{
|
||
Task *t1, *t2, *t3;
|
||
UINTN i;
|
||
(void)Args;
|
||
|
||
SAFE_PRINT(Boot, L"\n\r");
|
||
SAFE_PRINT(Boot, L"Task Scheduler Test\n\r");
|
||
SAFE_PRINT(Boot, L"================================================\n\r");
|
||
SAFE_PRINT(Boot, L"\n\r");
|
||
|
||
SAFE_PRINT(Boot, L"Spawning 3 worker tasks...\n\r\n\r");
|
||
|
||
t1 = task_create(L"worker-A", worker_task_fn, Boot);
|
||
t2 = task_create(L"worker-B", worker_task_fn, Boot);
|
||
t3 = task_create(L"worker-C", worker_task_fn, Boot);
|
||
|
||
if (t1 == NULL || t2 == NULL || t3 == NULL) {
|
||
SAFE_PRINT(Boot, L"Failed to create one or more tasks.\n\r");
|
||
return;
|
||
}
|
||
|
||
SAFE_PRINT(Boot, L"Created: %s (PID %d), %s (PID %d), %s (PID %d)\n\r",
|
||
t1->name, t1->pid, t2->name, t2->pid, t3->name, t3->pid);
|
||
SAFE_PRINT(Boot, L"\n\rYielding to let workers run:\n\r\n\r");
|
||
|
||
/* Yield enough times for all workers to complete (3 tasks x 3 steps) */
|
||
for (i = 0; i < 12; i++) {
|
||
task_yield();
|
||
}
|
||
|
||
SAFE_PRINT(Boot, L"\n\rTask list after test:\n\r");
|
||
task_print_list(Boot);
|
||
|
||
SAFE_PRINT(Boot, L"Task scheduler test completed.\n\r\n\r");
|
||
}
|
||
|
||
/* ----------------------------------------------------------------
|
||
* kusr – run a command with escalated privilege
|
||
* ---------------------------------------------------------------- */
|
||
|
||
static void cmd_kusr(BootInfo *Boot, CHAR16 *Args)
|
||
{
|
||
Task *self;
|
||
TaskPrivilege saved_priv;
|
||
|
||
if (Args == NULL || Args[0] == L'\0') {
|
||
SAFE_PRINT(Boot, L"Usage: kusr <command> [args...]\n\r");
|
||
return;
|
||
}
|
||
|
||
self = task_current();
|
||
if (self == NULL) {
|
||
SAFE_PRINT(Boot, L"kusr: no task context available.\n\r");
|
||
return;
|
||
}
|
||
|
||
/* Elevate, dispatch, restore. */
|
||
saved_priv = task_get_privilege(self);
|
||
task_set_privilege(self, TASK_PRIV_KERNEL);
|
||
|
||
{
|
||
Task *cmd_task = execute_command(Boot, Args, TASK_PRIV_KERNEL);
|
||
if (cmd_task != NULL) {
|
||
task_wait(cmd_task);
|
||
}
|
||
}
|
||
|
||
task_set_privilege(self, saved_priv);
|
||
}
|
||
|
||
/* ================================================================
|
||
* Public API
|
||
* ================================================================ */
|
||
|
||
/* Print a formatted table of all registered commands. */
|
||
void show_help(BootInfo *Boot)
|
||
{
|
||
UINTN i = 0;
|
||
UINTN max_len = 0;
|
||
UINTN name_len = 0;
|
||
UINTN padding = 0;
|
||
|
||
SAFE_PRINT(Boot, L"\n\r");
|
||
SAFE_PRINT(Boot, L"Available commands:\n\r");
|
||
SAFE_PRINT(Boot, L"\n\r");
|
||
|
||
/* Find the longest command name for column alignment */
|
||
for (i = 0; commands[i].name != NULL; i++) {
|
||
name_len = 0;
|
||
while (commands[i].name[name_len] != L'\0') {
|
||
name_len++;
|
||
}
|
||
if (name_len > max_len) {
|
||
max_len = name_len;
|
||
}
|
||
}
|
||
|
||
for (i = 0; commands[i].name != NULL; i++) {
|
||
SAFE_PRINT(Boot, L" %s", commands[i].name);
|
||
|
||
/* Pad to align descriptions */
|
||
name_len = 0;
|
||
while (commands[i].name[name_len] != L'\0') {
|
||
name_len++;
|
||
}
|
||
for (padding = 0; padding < (max_len - name_len + 2); padding++) {
|
||
SAFE_PRINT(Boot, L" ");
|
||
}
|
||
|
||
SAFE_PRINT(Boot, L"- %s\n\r", commands[i].description);
|
||
}
|
||
|
||
SAFE_PRINT(Boot, L"\n\r");
|
||
SAFE_PRINT(Boot, L"For detailed help on a command, type: man <command>\n\r");
|
||
SAFE_PRINT(Boot, L"\n\r");
|
||
}
|
||
|
||
/*
|
||
* Parse a line of user input into command + arguments and dispatch
|
||
* by spawning a dedicated task for the matching handler. Unknown
|
||
* commands print an error.
|
||
*
|
||
* Returns:
|
||
* - Pointer to the spawned Task for the command, or NULL if the
|
||
* command was not found or had to run synchronously.
|
||
*/
|
||
Task *execute_command(BootInfo *Boot, CHAR16 *Input, TaskPrivilege caller_priv)
|
||
{
|
||
CHAR16 *cmd_start = NULL;
|
||
CHAR16 *args_start = NULL;
|
||
UINTN i = 0;
|
||
CommandTaskContext *ctx;
|
||
Task *t;
|
||
|
||
if (Boot == NULL || Input == NULL) {
|
||
return NULL;
|
||
}
|
||
|
||
trim_spaces_inplace(Input);
|
||
|
||
if (Input[0] == L'\0') {
|
||
return NULL;
|
||
}
|
||
|
||
/* Split input into command and argument strings */
|
||
cmd_start = Input;
|
||
args_start = Input;
|
||
|
||
/* Advance past the command keyword */
|
||
while (*args_start != L'\0' && !is_space16(*args_start)) {
|
||
args_start++;
|
||
}
|
||
|
||
/* NUL-terminate the command and skip leading whitespace in args */
|
||
if (*args_start != L'\0') {
|
||
*args_start = L'\0';
|
||
args_start++;
|
||
|
||
/* skip leading whitespace in args */
|
||
while (*args_start != L'\0' && is_space16(*args_start)) {
|
||
args_start++;
|
||
}
|
||
}
|
||
|
||
/* Look up and dispatch the command */
|
||
for (i = 0; commands[i].name != NULL; i++) {
|
||
if (ascii_streq_ci(cmd_start, commands[i].name)) {
|
||
/* Allocate a context block for the command task. */
|
||
ctx = (CommandTaskContext *)kmalloc(sizeof(CommandTaskContext));
|
||
if (ctx == NULL) {
|
||
SAFE_PRINT(Boot, L"Failed to allocate command context; running in core thread.\n\r");
|
||
commands[i].handler(Boot, args_start);
|
||
return NULL;
|
||
}
|
||
|
||
ctx->Boot = Boot;
|
||
ctx->handler = commands[i].handler;
|
||
wstrcpy16_local(ctx->args, args_start, sizeof(ctx->args) / sizeof(ctx->args[0]));
|
||
|
||
t = task_create_with_priv(commands[i].name,
|
||
command_task_entry,
|
||
ctx,
|
||
caller_priv);
|
||
if (t == NULL) {
|
||
SAFE_PRINT(Boot, L"Failed to create task for command '%s'; running in core thread.\n\r",
|
||
commands[i].name);
|
||
kfree(ctx);
|
||
commands[i].handler(Boot, args_start);
|
||
return NULL;
|
||
}
|
||
|
||
SAFE_PRINT(Boot, L"[starling] spawned '%s' as PID %d\n\r", t->name, t->pid);
|
||
return t;
|
||
}
|
||
}
|
||
|
||
/* Command not found */
|
||
SAFE_PRINT(Boot, L"Unknown command: %s\n\r", cmd_start);
|
||
SAFE_PRINT(Boot, L"Type 'help' for a list of available commands.\n\r");
|
||
return NULL;
|
||
}
|
||
|
||
/* ----------------------------------------------------------------
|
||
* Command task entry – executes one command in its own task context
|
||
* ---------------------------------------------------------------- */
|
||
|
||
static void command_task_entry(void *arg)
|
||
{
|
||
CommandTaskContext *ctx = (CommandTaskContext *)arg;
|
||
BootInfo *Boot = NULL;
|
||
|
||
if (ctx == NULL) {
|
||
return;
|
||
}
|
||
|
||
Boot = ctx->Boot;
|
||
|
||
if (ctx->handler != NULL) {
|
||
ctx->handler(Boot, ctx->args);
|
||
}
|
||
|
||
/* Context was heap-allocated in execute_command. */
|
||
kfree(ctx);
|
||
}
|