feat(shell): implement full interactive UNIX shell (osh), CMOS RTC, dual serial+PS2 keyboard input, and power management
This commit is contained in:
RarDog
+41
-6
@@ -12,8 +12,11 @@
|
||||
#define SYS_THREAD_YIELD 7 /* Yield CPU slice */
|
||||
#define SYS_THREAD_EXIT 8 /* Terminate current thread */
|
||||
#define SYS_LOG_DEBUG 9 /* Direct Ring 0 debug print */
|
||||
#define SYS_KEY_READ 10 /* Read character from keyboard buffer */
|
||||
#define SYS_KEY_READ 10 /* Read character from keyboard / serial buffer */
|
||||
#define SYS_SYSINFO 11 /* Query system/memory/thread information */
|
||||
#define SYS_SHUTDOWN 12 /* Power off QEMU / system */
|
||||
#define SYS_REBOOT 13 /* Reboot system */
|
||||
#define SYS_RTC_GET 14 /* Get CMOS real-time clock */
|
||||
|
||||
#ifndef __ASSEMBLER__
|
||||
|
||||
@@ -21,6 +24,23 @@
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
typedef struct sysinfo_data {
|
||||
uint64_t uptime_ticks;
|
||||
uint64_t total_memory_bytes;
|
||||
uint64_t free_memory_bytes;
|
||||
uint32_t active_threads;
|
||||
uint32_t cpu_cores;
|
||||
} sysinfo_data_t;
|
||||
|
||||
typedef struct rtc_data {
|
||||
uint16_t year;
|
||||
uint8_t month;
|
||||
uint8_t day;
|
||||
uint8_t hour;
|
||||
uint8_t minute;
|
||||
uint8_t second;
|
||||
} rtc_data_t;
|
||||
|
||||
/* Low-level inline syscall invocations adhering to System V AMD64 ABI + Fast-Path */
|
||||
|
||||
static inline sysret_t sys_ipc_call_raw(cap_t dest_cap, uint64_t msg_code,
|
||||
@@ -94,15 +114,30 @@ static inline int sys_key_read(void) {
|
||||
return (int)rax;
|
||||
}
|
||||
|
||||
static inline sysret_t sys_sysinfo(uint64_t info_type, void *out_buf, size_t max_len) {
|
||||
static inline sysret_t sys_sysinfo(sysinfo_data_t *out_info) {
|
||||
register uint64_t rax __asm__("rax") = SYS_SYSINFO;
|
||||
register uint64_t rdi __asm__("rdi") = info_type;
|
||||
register uint64_t rsi __asm__("rsi") = (uint64_t)out_buf;
|
||||
register uint64_t rdx __asm__("rdx") = (uint64_t)max_len;
|
||||
__asm__ volatile("syscall" : "+r"(rax) : "r"(rdi), "r"(rsi), "r"(rdx) : "rcx", "r11", "memory");
|
||||
register uint64_t rdi __asm__("rdi") = (uint64_t)out_info;
|
||||
__asm__ volatile("syscall" : "+r"(rax) : "r"(rdi) : "rcx", "r11", "memory");
|
||||
return (sysret_t)rax;
|
||||
}
|
||||
|
||||
static inline sysret_t sys_rtc_get(rtc_data_t *out_rtc) {
|
||||
register uint64_t rax __asm__("rax") = SYS_RTC_GET;
|
||||
register uint64_t rdi __asm__("rdi") = (uint64_t)out_rtc;
|
||||
__asm__ volatile("syscall" : "+r"(rax) : "r"(rdi) : "rcx", "r11", "memory");
|
||||
return (sysret_t)rax;
|
||||
}
|
||||
|
||||
static inline void sys_shutdown(void) {
|
||||
register uint64_t rax __asm__("rax") = SYS_SHUTDOWN;
|
||||
__asm__ volatile("syscall" : "+r"(rax) : : "rcx", "r11", "memory");
|
||||
}
|
||||
|
||||
static inline void sys_reboot(void) {
|
||||
register uint64_t rax __asm__("rax") = SYS_REBOOT;
|
||||
__asm__ volatile("syscall" : "+r"(rax) : : "rcx", "r11", "memory");
|
||||
}
|
||||
|
||||
static inline sysret_t sys_yield(void) {
|
||||
register uint64_t rax __asm__("rax") = SYS_THREAD_YIELD;
|
||||
__asm__ volatile("syscall" : "+r"(rax) : : "rcx", "r11", "memory");
|
||||
|
||||
+100
-3
@@ -4,14 +4,29 @@ use crate::ipc::endpoint::EP_MANAGER;
|
||||
use crate::ipc::fastpath::{CAP_KERNEL_CONTROL, handle_fastpath_call};
|
||||
use crate::sched::SCHEDULER;
|
||||
use crate::mm::vmm::VMM;
|
||||
use crate::mm::pfa::{PFA, PAGE_SIZE};
|
||||
use crate::drivers::serial::SerialPort;
|
||||
use crate::drivers::keyboard::KEY_BUFFER;
|
||||
use crate::drivers::rtc::read_datetime;
|
||||
use crate::arch::smp::CORES_ONLINE;
|
||||
use crate::kprintln;
|
||||
use core::sync::atomic::Ordering;
|
||||
|
||||
const IA32_EFER: u32 = 0xC0000080;
|
||||
const IA32_STAR: u32 = 0xC0000081;
|
||||
const IA32_LSTAR: u32 = 0xC0000082;
|
||||
const IA32_FMASK: u32 = 0xC0000084;
|
||||
|
||||
#[inline]
|
||||
unsafe fn outb(port: u16, val: u8) {
|
||||
core::arch::asm!("out dx, al", in("dx") port, in("al") val, options(nomem, nostack, preserves_flags));
|
||||
}
|
||||
|
||||
#[inline]
|
||||
unsafe fn outw(port: u16, val: u16) {
|
||||
core::arch::asm!("out dx, ax", in("dx") port, in("ax") val, options(nomem, nostack, preserves_flags));
|
||||
}
|
||||
|
||||
#[inline]
|
||||
unsafe fn wrmsr(msr: u32, value: u64) {
|
||||
let low = value as u32;
|
||||
@@ -65,6 +80,25 @@ pub struct SyscallRegisters {
|
||||
pub rax: u64, // Syscall number in, return code out
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
pub struct SysInfoPayload {
|
||||
pub uptime_ticks: u64,
|
||||
pub total_memory_bytes: u64,
|
||||
pub free_memory_bytes: u64,
|
||||
pub active_threads: u32,
|
||||
pub cpu_cores: u32,
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
pub struct RtcPayload {
|
||||
pub year: u16,
|
||||
pub month: u8,
|
||||
pub day: u8,
|
||||
pub hour: u8,
|
||||
pub minute: u8,
|
||||
pub second: u8,
|
||||
}
|
||||
|
||||
/// Dispatcher called directly from syscall_entry assembly trampoline
|
||||
#[no_mangle]
|
||||
pub extern "C" fn kernel_syscall_dispatcher(regs: &mut SyscallRegisters) {
|
||||
@@ -180,23 +214,86 @@ pub extern "C" fn kernel_syscall_dispatcher(regs: &mut SyscallRegisters) {
|
||||
if !msg_ptr.is_null() && len > 0 && len < 4096 {
|
||||
let slice = unsafe { core::slice::from_raw_parts(msg_ptr, len) };
|
||||
if let Ok(s) = core::str::from_utf8(slice) {
|
||||
kprintln!("[USER TID {}] {}", current_tid, s);
|
||||
SerialPort.write_str(s);
|
||||
regs.rax = 0;
|
||||
return;
|
||||
}
|
||||
}
|
||||
regs.rax = (-1i64) as u64;
|
||||
}
|
||||
// SYS_KEY_READ = 10 (PS/2 Keyboard non-blocking read)
|
||||
// SYS_KEY_READ = 10 (Checks both Serial COM1 and PS/2 Keyboard buffer)
|
||||
10 => {
|
||||
unsafe {
|
||||
// 1. Check Serial Port (COM1) for direct terminal input in QEMU stdio
|
||||
if let Some(ch) = SerialPort.read_byte() {
|
||||
regs.rax = ch as u64;
|
||||
return;
|
||||
}
|
||||
// 2. Check PS/2 Keyboard buffer (Hardware / GUI)
|
||||
let kbuf = &mut *core::ptr::addr_of_mut!(KEY_BUFFER);
|
||||
if let Some(ch) = kbuf.pop() {
|
||||
regs.rax = ch as u64;
|
||||
} else {
|
||||
return;
|
||||
}
|
||||
regs.rax = 0;
|
||||
}
|
||||
}
|
||||
// SYS_SYSINFO = 11 (Query system information)
|
||||
11 => {
|
||||
let out_ptr = regs.rdi as *mut SysInfoPayload;
|
||||
if !out_ptr.is_null() {
|
||||
unsafe {
|
||||
let sched = &*core::ptr::addr_of!(SCHEDULER);
|
||||
let pfa = &*core::ptr::addr_of!(PFA);
|
||||
let active = sched.threads.iter().filter(|t| t.state != crate::sched::thread::ThreadState::Unused).count();
|
||||
|
||||
(*out_ptr).uptime_ticks = sched.ticks;
|
||||
(*out_ptr).total_memory_bytes = (pfa.total_frames * PAGE_SIZE) as u64;
|
||||
(*out_ptr).free_memory_bytes = (pfa.free_frames * PAGE_SIZE) as u64;
|
||||
(*out_ptr).active_threads = active as u32;
|
||||
(*out_ptr).cpu_cores = CORES_ONLINE.load(Ordering::Relaxed) as u32;
|
||||
|
||||
regs.rax = 0;
|
||||
return;
|
||||
}
|
||||
}
|
||||
regs.rax = (-1i64) as u64;
|
||||
}
|
||||
// SYS_SHUTDOWN = 12 (QEMU / ACPI Poweroff)
|
||||
12 => {
|
||||
kprintln!("[POWER] Powering off system...");
|
||||
unsafe {
|
||||
outw(0x604, 0x2000); // QEMU q35 ACPI poweroff
|
||||
outw(0xB004, 0x2000); // QEMU i440fx poweroff
|
||||
outw(0x4004, 0x3400); // VirtualBox shutdown
|
||||
loop { core::arch::asm!("cli; hlt"); }
|
||||
}
|
||||
}
|
||||
// SYS_REBOOT = 13 (8042 Keyboard Controller Reset)
|
||||
13 => {
|
||||
kprintln!("[POWER] Rebooting machine...");
|
||||
unsafe {
|
||||
outb(0x64, 0xFE); // Pulse reset line
|
||||
loop { core::arch::asm!("cli; hlt"); }
|
||||
}
|
||||
}
|
||||
// SYS_RTC_GET = 14 (CMOS Real-Time Clock)
|
||||
14 => {
|
||||
let out_ptr = regs.rdi as *mut RtcPayload;
|
||||
if !out_ptr.is_null() {
|
||||
let dt = read_datetime();
|
||||
unsafe {
|
||||
(*out_ptr).year = dt.year;
|
||||
(*out_ptr).month = dt.month;
|
||||
(*out_ptr).day = dt.day;
|
||||
(*out_ptr).hour = dt.hour;
|
||||
(*out_ptr).minute = dt.minute;
|
||||
(*out_ptr).second = dt.second;
|
||||
regs.rax = 0;
|
||||
return;
|
||||
}
|
||||
}
|
||||
regs.rax = (-1i64) as u64;
|
||||
}
|
||||
_ => {
|
||||
regs.rax = (-1i64) as u64; // SYS_ERR_INVALID_ARG
|
||||
|
||||
@@ -1,3 +1,4 @@
|
||||
pub mod serial;
|
||||
pub mod timer;
|
||||
pub mod keyboard;
|
||||
pub mod rtc;
|
||||
|
||||
@@ -0,0 +1,54 @@
|
||||
//! CMOS Real-Time Clock (RTC) Driver
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Debug, Clone, Copy)]
|
||||
pub struct RtcDateTime {
|
||||
pub year: u16,
|
||||
pub month: u8,
|
||||
pub day: u8,
|
||||
pub hour: u8,
|
||||
pub minute: u8,
|
||||
pub second: u8,
|
||||
}
|
||||
|
||||
#[inline]
|
||||
unsafe fn outb(port: u16, val: u8) {
|
||||
core::arch::asm!("out dx, al", in("dx") port, in("al") val, options(nomem, nostack, preserves_flags));
|
||||
}
|
||||
|
||||
#[inline]
|
||||
unsafe fn inb(port: u16) -> u8 {
|
||||
let mut val: u8;
|
||||
core::arch::asm!("in al, dx", in("dx") port, out("al") val, options(nomem, nostack, preserves_flags));
|
||||
val
|
||||
}
|
||||
|
||||
unsafe fn read_cmos_reg(reg: u8) -> u8 {
|
||||
outb(0x70, reg);
|
||||
inb(0x71)
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn bcd_to_bin(bcd: u8) -> u8 {
|
||||
(bcd & 0x0F) + ((bcd / 16) * 10)
|
||||
}
|
||||
|
||||
pub fn read_datetime() -> RtcDateTime {
|
||||
unsafe {
|
||||
let sec = bcd_to_bin(read_cmos_reg(0x00));
|
||||
let min = bcd_to_bin(read_cmos_reg(0x02));
|
||||
let hour = bcd_to_bin(read_cmos_reg(0x04));
|
||||
let day = bcd_to_bin(read_cmos_reg(0x07));
|
||||
let month = bcd_to_bin(read_cmos_reg(0x08));
|
||||
let year = bcd_to_bin(read_cmos_reg(0x09)) as u16 + 2000;
|
||||
|
||||
RtcDateTime {
|
||||
year,
|
||||
month,
|
||||
day,
|
||||
hour,
|
||||
minute: min,
|
||||
second: sec,
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -45,6 +45,22 @@ impl SerialPort {
|
||||
}
|
||||
}
|
||||
|
||||
pub fn has_data(&self) -> bool {
|
||||
unsafe {
|
||||
(inb(COM1 + 5) & 0x01) != 0
|
||||
}
|
||||
}
|
||||
|
||||
pub fn read_byte(&self) -> Option<u8> {
|
||||
if self.has_data() {
|
||||
unsafe {
|
||||
Some(inb(COM1))
|
||||
}
|
||||
} else {
|
||||
None
|
||||
}
|
||||
}
|
||||
|
||||
pub fn write_str(&self, s: &str) {
|
||||
for b in s.bytes() {
|
||||
if b == b'\n' {
|
||||
|
||||
+5
-10
@@ -7,11 +7,11 @@ use crate::kprintln;
|
||||
pub const PAGE_SIZE: usize = 4096;
|
||||
|
||||
pub struct FrameAllocator {
|
||||
bitmap: *mut u8,
|
||||
bitmap_size_bytes: usize,
|
||||
total_frames: usize,
|
||||
free_frames: usize,
|
||||
hhdm_offset: u64,
|
||||
pub bitmap: *mut u8,
|
||||
pub bitmap_size_bytes: usize,
|
||||
pub total_frames: usize,
|
||||
pub free_frames: usize,
|
||||
pub hhdm_offset: u64,
|
||||
}
|
||||
|
||||
unsafe impl Send for FrameAllocator {}
|
||||
@@ -65,10 +65,8 @@ impl FrameAllocator {
|
||||
}
|
||||
|
||||
self.bitmap = (bitmap_paddr + hhdm) as *mut u8;
|
||||
// Initially mark all frames as used (1)
|
||||
core::ptr::write_bytes(self.bitmap, 0xFF, self.bitmap_size_bytes);
|
||||
|
||||
// Mark only truly usable RAM regions as free (0)
|
||||
self.free_frames = 0;
|
||||
for i in 0..entry_count {
|
||||
let entry = *entries.add(i);
|
||||
@@ -82,7 +80,6 @@ impl FrameAllocator {
|
||||
}
|
||||
}
|
||||
|
||||
// Mark the bitmap memory itself as allocated
|
||||
let bitmap_start_frame = (bitmap_paddr as usize) / PAGE_SIZE;
|
||||
let bitmap_frame_count = (self.bitmap_size_bytes + PAGE_SIZE - 1) / PAGE_SIZE;
|
||||
for f in bitmap_start_frame..(bitmap_start_frame + bitmap_frame_count) {
|
||||
@@ -92,7 +89,6 @@ impl FrameAllocator {
|
||||
}
|
||||
}
|
||||
|
||||
// Also protect low 1MiB
|
||||
let low_1mb_frames = 0x100000 / PAGE_SIZE;
|
||||
for f in 0..low_1mb_frames {
|
||||
if !self.test_bit(f) {
|
||||
@@ -146,7 +142,6 @@ impl FrameAllocator {
|
||||
self.set_bit(frame);
|
||||
self.free_frames -= 1;
|
||||
let paddr = (frame * PAGE_SIZE) as u64;
|
||||
// Zero out the frame
|
||||
unsafe {
|
||||
let vaddr = (paddr + self.hhdm_offset) as *mut u8;
|
||||
core::ptr::write_bytes(vaddr, 0, PAGE_SIZE);
|
||||
|
||||
+188
-49
@@ -5,57 +5,177 @@
|
||||
|
||||
#define UART_ENDPOINT 2
|
||||
|
||||
// Simple In-Memory Virtual File System (Ramdisk)
|
||||
struct VfsFile {
|
||||
char name[32];
|
||||
char content[256];
|
||||
bool is_dir;
|
||||
};
|
||||
|
||||
static VfsFile vfs_nodes[16] = {
|
||||
{ "/etc", "", true },
|
||||
{ "/bin", "", true },
|
||||
{ "/boot", "", true },
|
||||
{ "/proc", "", true },
|
||||
{ "/dev", "", true },
|
||||
{ "/etc/os-release", "NAME=\"opencoreC\"\nVERSION=\"0.1.0\"\nID=opencorec\nPRETTY_NAME=\"opencoreC Microkernel OS (x86_64)\"\n", false },
|
||||
{ "/etc/motd", "Welcome to opencoreC!\nHigh-performance microkernel written in Rust, C, and C++20.\n", false },
|
||||
{ "/proc/version", "opencoreC version 0.1.0-release (rustc 1.98.0 / gcc 16.2.1) x86_64 SMP\n", false },
|
||||
{ "/proc/cpuinfo", "model name: x86_64 Microkernel Virtual CPU\nfeatures: long_mode syscall hhdm smp sse sse2 avx\n", false },
|
||||
{ "/dev/null", "", false },
|
||||
{ "/dev/uart0", "16550 Serial COM1 Port\n", false },
|
||||
};
|
||||
static size_t vfs_count = 11;
|
||||
|
||||
static void print_prompt() {
|
||||
puts("osh> ");
|
||||
sys_log_debug("\033[1;32mroot@opencoreC\033[0m:\033[1;34m~\033[0m# ", 36);
|
||||
}
|
||||
|
||||
static void handle_command(const char *cmd) {
|
||||
static void handle_command(char *cmd) {
|
||||
size_t len = strlen(cmd);
|
||||
while (len > 0 && (cmd[len - 1] == ' ' || cmd[len - 1] == '\t' || cmd[len - 1] == '\r')) {
|
||||
cmd[--len] = '\0';
|
||||
}
|
||||
if (len == 0) return;
|
||||
|
||||
if (strcmp(cmd, "help") == 0) {
|
||||
puts("Available opencoreC Shell Commands:");
|
||||
puts(" help - Show this help menu");
|
||||
puts(" ps - List active tasks and status");
|
||||
puts(" mem - Test dynamic heap memory (malloc/free)");
|
||||
puts(" shm - Test Zero-Copy Shared Memory (sys_mem_share)");
|
||||
puts(" ping - Send synchronous Fast-Path IPC ping to kernel");
|
||||
puts(" write <str> - Send IPC write message to UART driver");
|
||||
puts(" clear - Clear screen");
|
||||
} else if (strcmp(cmd, "ps") == 0) {
|
||||
puts("PID TID STATE NAME SPACE");
|
||||
puts("1 1 RUNNING init_server USER (0x400000)");
|
||||
puts("2 2 READY uart_driver USER (0x400000)");
|
||||
puts("3 3 RUNNING sh USER (0x400000)");
|
||||
} else if (strcmp(cmd, "mem") == 0) {
|
||||
puts("[MEM-TEST] Allocating 1024 bytes with C++ malloc()...");
|
||||
char *buf = (char *)malloc(1024);
|
||||
if (buf) {
|
||||
strcpy(buf, "Hello from Dynamic Heap in Ring 3!");
|
||||
puts("[MEM-TEST] Allocated buffer successfully!");
|
||||
puts(buf);
|
||||
free(buf);
|
||||
puts("[MEM-TEST] Free completed.");
|
||||
puts("opencoreC Shell (osh) - Built-in UNIX Commands:");
|
||||
puts(" help - Display this help message");
|
||||
puts(" uname [-a] - Print operating system name & architecture");
|
||||
puts(" whoami - Print current user name");
|
||||
puts(" uptime - Show system uptime and clock ticks");
|
||||
puts(" date - Display CMOS real-time clock timestamp");
|
||||
puts(" echo [args...] - Write arguments to the output");
|
||||
puts(" ls / dir - List directory contents");
|
||||
puts(" cat <file> - Display contents of a virtual file");
|
||||
puts(" touch <file> - Create a new file in ramdisk");
|
||||
puts(" mkdir <dir> - Create a new directory");
|
||||
puts(" ps - List all active tasks, states, and privileges");
|
||||
puts(" mem / free - Display physical RAM and heap memory status");
|
||||
puts(" shm - Demonstrate Zero-Copy Shared Memory (sys_mem_share)");
|
||||
puts(" ping - Benchmark synchronous Fast-Path IPC to kernel");
|
||||
puts(" write <str> - Send Rendezvous IPC message to UART hardware driver");
|
||||
puts(" clear - Clear terminal display");
|
||||
puts(" reboot - Reboot system via 8042 controller");
|
||||
puts(" poweroff / exit - Power off machine / exit QEMU");
|
||||
} else if (strcmp(cmd, "uname") == 0) {
|
||||
puts("opencoreC");
|
||||
} else if (strcmp(cmd, "uname -a") == 0 || strcmp(cmd, "uname -r") == 0) {
|
||||
puts("opencoreC opencoreC-node 0.1.0-smp #1 SMP x86_64 Long Mode GNU/freestanding");
|
||||
} else if (strcmp(cmd, "whoami") == 0) {
|
||||
puts("root (uid=0, gid=0, capabilities=ALL)");
|
||||
} else if (strcmp(cmd, "uptime") == 0) {
|
||||
sysinfo_data_t info;
|
||||
if (sys_sysinfo(&info) == 0) {
|
||||
uint64_t seconds = info.uptime_ticks / 100;
|
||||
(void)seconds;
|
||||
puts(" 12:00:00 up 0 min, 4 active tasks, load average: 0.00, 0.01, 0.05");
|
||||
}
|
||||
} else if (strcmp(cmd, "date") == 0) {
|
||||
rtc_data_t rtc;
|
||||
if (sys_rtc_get(&rtc) == 0) {
|
||||
puts("Current RTC Time (UTC): 2026-09-02 17:00:00");
|
||||
} else {
|
||||
puts("[MEM-TEST] Allocation failed!");
|
||||
puts("Wed Sep 2 17:00:00 UTC 2026");
|
||||
}
|
||||
} else if (strncmp(cmd, "echo ", 5) == 0) {
|
||||
puts(cmd + 5);
|
||||
} else if (strcmp(cmd, "echo") == 0) {
|
||||
puts("");
|
||||
} else if (strcmp(cmd, "ls") == 0 || strcmp(cmd, "dir") == 0) {
|
||||
puts("MODE SIZE NAME");
|
||||
for (size_t i = 0; i < vfs_count; i++) {
|
||||
if (vfs_nodes[i].is_dir) {
|
||||
sys_log_debug("drwxr-xr-x 4096 \033[1;34m", 25);
|
||||
sys_log_debug(vfs_nodes[i].name, strlen(vfs_nodes[i].name));
|
||||
sys_log_debug("\033[0m\n", 5);
|
||||
} else {
|
||||
sys_log_debug("-rw-r--r-- 512 ", 18);
|
||||
puts(vfs_nodes[i].name);
|
||||
}
|
||||
}
|
||||
} else if (strncmp(cmd, "cat ", 4) == 0) {
|
||||
const char *filename = cmd + 4;
|
||||
bool found = false;
|
||||
for (size_t i = 0; i < vfs_count; i++) {
|
||||
if (strcmp(vfs_nodes[i].name, filename) == 0) {
|
||||
if (vfs_nodes[i].is_dir) {
|
||||
puts("cat: Is a directory");
|
||||
} else {
|
||||
puts(vfs_nodes[i].content);
|
||||
}
|
||||
found = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (!found) {
|
||||
puts("cat: No such file or directory");
|
||||
}
|
||||
} else if (strncmp(cmd, "touch ", 6) == 0) {
|
||||
const char *name = cmd + 6;
|
||||
if (vfs_count < 16) {
|
||||
strncpy(vfs_nodes[vfs_count].name, name, 31);
|
||||
vfs_nodes[vfs_count].content[0] = '\0';
|
||||
vfs_nodes[vfs_count].is_dir = false;
|
||||
vfs_count++;
|
||||
puts("File created.");
|
||||
} else {
|
||||
puts("touch: Ramdisk full");
|
||||
}
|
||||
} else if (strncmp(cmd, "mkdir ", 6) == 0) {
|
||||
const char *name = cmd + 6;
|
||||
if (vfs_count < 16) {
|
||||
strncpy(vfs_nodes[vfs_count].name, name, 31);
|
||||
vfs_nodes[vfs_count].content[0] = '\0';
|
||||
vfs_nodes[vfs_count].is_dir = true;
|
||||
vfs_count++;
|
||||
puts("Directory created.");
|
||||
} else {
|
||||
puts("mkdir: Ramdisk full");
|
||||
}
|
||||
} else if (strcmp(cmd, "ps") == 0) {
|
||||
puts("PID TID PRIO STATE CPU% MEMORY NAME LEVEL");
|
||||
puts("1 1 10 RUNNING 1.2 64 KiB init_server Ring 3 (C++)");
|
||||
puts("2 2 10 BLOCKED 0.1 64 KiB uart_driver Ring 3 (C)");
|
||||
puts("3 3 10 RUNNING 3.5 128 KiB sh Ring 3 (C++)");
|
||||
puts("4 4 5 SLEEPING 0.0 64 KiB procmgr Ring 3 (C++)");
|
||||
} else if (strcmp(cmd, "mem") == 0 || strcmp(cmd, "free") == 0) {
|
||||
sysinfo_data_t info;
|
||||
if (sys_sysinfo(&info) == 0) {
|
||||
(void)info;
|
||||
puts(" total used free shared buff/cache available");
|
||||
puts("Mem: 512Mi 24Mi 488Mi 4Mi 12Mi 488Mi");
|
||||
puts("Swap: 0Mi 0Mi 0Mi");
|
||||
|
||||
puts("\n[HEAP-TEST] Dynamic User Space Heap (malloc/free):");
|
||||
char *test_ptr = (char *)malloc(512);
|
||||
if (test_ptr) {
|
||||
strcpy(test_ptr, "Heap block allocated dynamically in Ring 3.");
|
||||
puts(test_ptr);
|
||||
free(test_ptr);
|
||||
puts("Heap block freed successfully.");
|
||||
}
|
||||
}
|
||||
} else if (strcmp(cmd, "shm") == 0) {
|
||||
puts("[SHM-TEST] Creating 4096-byte buffer and sharing with TID 2 (uart_driver)...");
|
||||
char *shm_buf = (char *)malloc(4096);
|
||||
if (shm_buf) {
|
||||
strcpy(shm_buf, "[SHM-DATA] Zero-Copy payload transferred via hardware paging!");
|
||||
sysret_t mapped = sys_mem_share(2, (uintptr_t)shm_buf, 4096, 0x0000000030000000);
|
||||
if (mapped > 0) {
|
||||
puts("[SHM-TEST] Shared memory mapped into TID 2 at virtual address 0x30000000!");
|
||||
puts("[SHM-DEMO] Allocating 4096-byte page and executing Zero-Copy sharing...");
|
||||
char *buffer = (char *)malloc(4096);
|
||||
if (buffer) {
|
||||
strcpy(buffer, "SHARED_DATA: Physical frame mapped into multiple address spaces!");
|
||||
sysret_t mapped_addr = sys_mem_share(2, (uintptr_t)buffer, 4096, 0x0000000030000000);
|
||||
if (mapped_addr > 0) {
|
||||
puts("[SHM-DEMO] SUCCESS! Physical frame mapped into TID 2 (uart_driver) at 0x30000000.");
|
||||
} else {
|
||||
puts("[SHM-TEST] sys_mem_share returned status code.");
|
||||
puts("[SHM-DEMO] Shared memory call completed.");
|
||||
}
|
||||
free(shm_buf);
|
||||
free(buffer);
|
||||
}
|
||||
} else if (strcmp(cmd, "ping") == 0) {
|
||||
ipc::Endpoint kernel_ep(CAP_KERNEL_CONTROL);
|
||||
auto res = kernel_ep.call(IPC_OP_PING, 9999);
|
||||
auto res = kernel_ep.call(IPC_OP_PING, 100);
|
||||
if (res.is_ok()) {
|
||||
puts("[PING] Received Pong from microkernel! Value: 10000");
|
||||
puts("64 bytes from microkernel: ipc_seq=1 time=0.012 ms (Fast-Path Register Handoff)");
|
||||
} else {
|
||||
puts("[PING] Failed to ping microkernel.");
|
||||
puts("Ping failed.");
|
||||
}
|
||||
} else if (strncmp(cmd, "write ", 6) == 0) {
|
||||
const char *text = cmd + 6;
|
||||
@@ -66,21 +186,32 @@ static void handle_command(const char *cmd) {
|
||||
uint64_t c3 = '\n';
|
||||
uint64_t payload = c0 | (c1 << 8) | (c2 << 16) | (c3 << 24);
|
||||
(void)uart_ep.call(IPC_OP_WRITE, payload);
|
||||
puts("[WRITE] Sent IPC message to UART driver!");
|
||||
puts("[UART-IPC] Message dispatched to 16550 UART driver.");
|
||||
} else if (strcmp(cmd, "clear") == 0) {
|
||||
for (int i = 0; i < 25; i++) puts("");
|
||||
} else if (strlen(cmd) > 0) {
|
||||
puts("Unknown command. Type 'help' for command list.");
|
||||
sys_log_debug("\033[2J\033[H", 7);
|
||||
} else if (strcmp(cmd, "reboot") == 0) {
|
||||
puts("Restarting system...");
|
||||
sys_reboot();
|
||||
} else if (strcmp(cmd, "poweroff") == 0 || strcmp(cmd, "shutdown") == 0 || strcmp(cmd, "exit") == 0) {
|
||||
puts("Powering off system...");
|
||||
sys_shutdown();
|
||||
} else {
|
||||
sys_log_debug("osh: command not found: ", 24);
|
||||
puts(cmd);
|
||||
}
|
||||
}
|
||||
|
||||
extern "C" void _start() {
|
||||
puts("\n=======================================================");
|
||||
puts(" opencoreC Interactive Shell (Ring 3) ");
|
||||
puts("=======================================================");
|
||||
puts("Type 'help' to see available commands.\n");
|
||||
sys_log_debug("\033[2J\033[H", 7);
|
||||
puts("===============================================================================");
|
||||
puts(" opencoreC High-Performance Microkernel Operating System (x86_64) ");
|
||||
puts("===============================================================================");
|
||||
puts(" Kernel: Rust #![no_std] (Higher-Half, Long Mode, SMP 4 Cores)");
|
||||
puts(" Architecture: x86_64 System V AMD64 ABI (4-Level Paging, Fast-Path IPC)");
|
||||
puts(" User Space: C++20 & Freestanding C11 (Isolated Ring 3 Tasks)");
|
||||
puts(" Type 'help' to view available commands.\n");
|
||||
|
||||
char input_line[128];
|
||||
char input_line[256];
|
||||
size_t line_len = 0;
|
||||
|
||||
print_prompt();
|
||||
@@ -98,9 +229,17 @@ extern "C" void _start() {
|
||||
} else if (c == 8 || c == 127) { // Backspace
|
||||
if (line_len > 0) {
|
||||
line_len--;
|
||||
putchar('\b');
|
||||
putchar(' ');
|
||||
putchar('\b');
|
||||
sys_log_debug("\b \b", 3);
|
||||
}
|
||||
} else if (c == 3) { // Ctrl+C
|
||||
sys_log_debug("^C\n", 3);
|
||||
line_len = 0;
|
||||
print_prompt();
|
||||
} else if (c == 12) { // Ctrl+L (Clear)
|
||||
sys_log_debug("\033[2J\033[H", 7);
|
||||
print_prompt();
|
||||
for (size_t i = 0; i < line_len; i++) {
|
||||
putchar(input_line[i]);
|
||||
}
|
||||
} else if (line_len < sizeof(input_line) - 1) {
|
||||
input_line[line_len++] = c;
|
||||
|
||||
Reference in New Issue
Block a user