506 lines
16 KiB
C
506 lines
16 KiB
C
#include <multiboot2.h>
|
|
#include <stdint.h>
|
|
#include <stddef.h>
|
|
#include <string.h>
|
|
#include "gdt.h"
|
|
#include "idt.h"
|
|
#include "pic.h"
|
|
#include "port_io.h"
|
|
#include "pmm.h"
|
|
#include "paging.h"
|
|
#include "kmalloc.h"
|
|
#include "driver.h"
|
|
#include "vga.h"
|
|
#include "tss.h"
|
|
#include "syscall.h"
|
|
#include "process.h"
|
|
#include "cpio.h"
|
|
#include "vfs.h"
|
|
#include "initrd_fs.h"
|
|
#include "devicefs.h"
|
|
#include "sysfs.h"
|
|
#include "mbr.h"
|
|
#include "fat32.h"
|
|
#include "keyboard.h"
|
|
#include "ethernet.h"
|
|
#include "ipv4.h"
|
|
#include "arp.h"
|
|
#include "dhcp.h"
|
|
#include "udp.h"
|
|
#include "tcp.h"
|
|
#include "framebuffer.h"
|
|
|
|
/* Global framebuffer info, parsed from multiboot2 tags. */
|
|
framebuffer_info_t fb_info;
|
|
|
|
/**
|
|
* Initialize COM1 serial port for debug output.
|
|
* Baud rate: 115200, 8N1.
|
|
*/
|
|
static void serial_init(void) {
|
|
outb(0x3F8 + 1, 0x00); /* Disable interrupts */
|
|
outb(0x3F8 + 3, 0x80); /* Enable DLAB */
|
|
outb(0x3F8 + 0, 0x01); /* Divisor low: 115200 baud */
|
|
outb(0x3F8 + 1, 0x00); /* Divisor high */
|
|
outb(0x3F8 + 3, 0x03); /* 8 bits, no parity, 1 stop */
|
|
outb(0x3F8 + 2, 0xC7); /* Enable FIFO */
|
|
outb(0x3F8 + 4, 0x03); /* RTS/DSR set */
|
|
}
|
|
|
|
static void serial_putc(char c) {
|
|
/* Wait for transmit buffer empty */
|
|
while (!(inb(0x3F8 + 5) & 0x20));
|
|
outb(0x3F8, c);
|
|
}
|
|
|
|
void offset_print(const char *str)
|
|
{
|
|
while (*str) {
|
|
outb(0xE9, *str); /* debugcon */
|
|
serial_putc(*str); /* COM1 serial */
|
|
str++;
|
|
}
|
|
}
|
|
|
|
void print_hex(uint32_t val)
|
|
{
|
|
const char *hex = "0123456789ABCDEF";
|
|
outb(0xE9, '0'); serial_putc('0');
|
|
outb(0xE9, 'x'); serial_putc('x');
|
|
for (int i = 28; i >= 0; i -= 4) {
|
|
char c = hex[(val >> i) & 0xF];
|
|
outb(0xE9, c);
|
|
serial_putc(c);
|
|
}
|
|
outb(0xE9, '\n'); serial_putc('\n');
|
|
}
|
|
|
|
/* ================================================================
|
|
* VFS sysfs namespace — handles mount/umount via /sys/vfs
|
|
* ================================================================
|
|
*
|
|
* /sys/vfs/mount — write "device mountpoint" to mount a FAT32 device
|
|
* /sys/vfs/mounts — read to list active mounts
|
|
*/
|
|
|
|
/** Last mount status message for reading back. */
|
|
static char vfs_sysfs_status[256] = "no mounts\n";
|
|
|
|
static int vfs_sysfs_list(void *ctx, const char *path, uint32_t idx,
|
|
sysfs_entry_t *out) {
|
|
(void)ctx;
|
|
if (path[0] != '\0') return -1; /* No subdirectories */
|
|
|
|
static const char *entries[] = { "mount", "mounts" };
|
|
if (idx >= 2) return -1;
|
|
|
|
memset(out, 0, sizeof(sysfs_entry_t));
|
|
strncpy(out->name, entries[idx], SYSFS_MAX_NAME - 1);
|
|
out->is_dir = 0;
|
|
return 0;
|
|
}
|
|
|
|
static int vfs_sysfs_read(void *ctx, const char *path, char *buf,
|
|
uint32_t buf_size) {
|
|
(void)ctx;
|
|
|
|
if (strcmp(path, "mount") == 0 || strcmp(path, "mounts") == 0) {
|
|
uint32_t len = strlen(vfs_sysfs_status);
|
|
if (len + 1 > buf_size) len = buf_size - 1;
|
|
memcpy(buf, vfs_sysfs_status, len);
|
|
buf[len] = '\0';
|
|
return (int)len;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
static int vfs_sysfs_write(void *ctx, const char *path, const char *buf,
|
|
uint32_t size) {
|
|
(void)ctx;
|
|
|
|
if (strcmp(path, "mount") != 0) return -1;
|
|
|
|
/* Parse: "device_name mount_path\n" */
|
|
char device[64];
|
|
char mount_path[128];
|
|
int di = 0, mi = 0;
|
|
uint32_t i = 0;
|
|
|
|
/* Parse device name */
|
|
while (i < size && buf[i] != ' ' && buf[i] != '\n' && di < 63) {
|
|
device[di++] = buf[i++];
|
|
}
|
|
device[di] = '\0';
|
|
|
|
/* Skip spaces */
|
|
while (i < size && buf[i] == ' ') i++;
|
|
|
|
/* Parse mount path */
|
|
while (i < size && buf[i] != ' ' && buf[i] != '\n' && mi < 127) {
|
|
mount_path[mi++] = buf[i++];
|
|
}
|
|
mount_path[mi] = '\0';
|
|
|
|
if (di == 0 || mi == 0) {
|
|
strncpy(vfs_sysfs_status, "error: usage: device mountpoint\n",
|
|
sizeof(vfs_sysfs_status) - 1);
|
|
return -1;
|
|
}
|
|
|
|
offset_print(" VFS mount request: ");
|
|
offset_print(device);
|
|
offset_print(" -> ");
|
|
offset_print(mount_path);
|
|
offset_print("\n");
|
|
|
|
/* Find the device */
|
|
devicefs_device_t *dev = devicefs_find(device);
|
|
if (!dev) {
|
|
strncpy(vfs_sysfs_status, "error: device not found\n",
|
|
sizeof(vfs_sysfs_status) - 1);
|
|
offset_print(" VFS mount: device not found\n");
|
|
return -1;
|
|
}
|
|
|
|
/* Mount as FAT32 */
|
|
int ret = fat32_mount_device(dev, mount_path);
|
|
if (ret != 0) {
|
|
strncpy(vfs_sysfs_status, "error: FAT32 mount failed\n",
|
|
sizeof(vfs_sysfs_status) - 1);
|
|
offset_print(" VFS mount: FAT32 mount failed\n");
|
|
return -1;
|
|
}
|
|
|
|
/* Build success message */
|
|
strncpy(vfs_sysfs_status, "mounted ", sizeof(vfs_sysfs_status) - 1);
|
|
uint32_t slen = strlen(vfs_sysfs_status);
|
|
strncpy(vfs_sysfs_status + slen, device,
|
|
sizeof(vfs_sysfs_status) - 1 - slen);
|
|
slen = strlen(vfs_sysfs_status);
|
|
strncpy(vfs_sysfs_status + slen, " at ",
|
|
sizeof(vfs_sysfs_status) - 1 - slen);
|
|
slen = strlen(vfs_sysfs_status);
|
|
strncpy(vfs_sysfs_status + slen, mount_path,
|
|
sizeof(vfs_sysfs_status) - 1 - slen);
|
|
slen = strlen(vfs_sysfs_status);
|
|
if (slen < sizeof(vfs_sysfs_status) - 1) {
|
|
vfs_sysfs_status[slen] = '\n';
|
|
vfs_sysfs_status[slen + 1] = '\0';
|
|
}
|
|
|
|
return (int)size;
|
|
}
|
|
|
|
static sysfs_ops_t vfs_sysfs_ops = {
|
|
.list = vfs_sysfs_list,
|
|
.read = vfs_sysfs_read,
|
|
.write = vfs_sysfs_write,
|
|
};
|
|
|
|
void kernel_main(uint32_t magic, uint32_t addr) {
|
|
/* Initialize serial port first so all debug output goes to COM1 too */
|
|
serial_init();
|
|
|
|
/* Early VGA: write directly to the text buffer at 0xB8000 for boot
|
|
* progress that is visible even without the VGA driver initialized.
|
|
* Attribute 0x1F = white on blue. */
|
|
volatile uint16_t *early_vga = (volatile uint16_t *)0xB8000;
|
|
int early_pos = 0;
|
|
|
|
/* Helper macro: write a short string to early VGA */
|
|
#define EARLY_PRINT(s) do { \
|
|
const char *_p = (s); \
|
|
while (*_p) { \
|
|
early_vga[early_pos++] = (uint16_t)(unsigned char)*_p | (0x1F << 8); \
|
|
_p++; \
|
|
} \
|
|
} while(0)
|
|
|
|
/* Clear screen to blue */
|
|
for (int i = 0; i < 80 * 25; i++)
|
|
early_vga[i] = (uint16_t)' ' | (0x1F << 8);
|
|
|
|
EARLY_PRINT("ClaudeOS early boot");
|
|
early_pos = 80; /* Move to line 2 */
|
|
|
|
if (magic != MULTIBOOT2_BOOTLOADER_MAGIC) {
|
|
EARLY_PRINT("ERROR: Bad magic=0x");
|
|
/* Print magic in hex */
|
|
const char *hex = "0123456789ABCDEF";
|
|
for (int i = 28; i >= 0; i -= 4)
|
|
early_vga[early_pos++] = (uint16_t)(unsigned char)hex[(magic >> i) & 0xF] | (0x4F << 8);
|
|
early_pos = 80 * 3;
|
|
EARLY_PRINT("Expected 0x36D76289 (Multiboot2)");
|
|
early_pos = 80 * 4;
|
|
EARLY_PRINT("Got MB1 magic? Checking grub.cfg...");
|
|
|
|
offset_print("Invalid magic number: ");
|
|
print_hex(magic);
|
|
|
|
/* Hang with interrupts disabled so user can see the message */
|
|
for (;;) __asm__ volatile("hlt");
|
|
}
|
|
|
|
EARLY_PRINT("Magic OK ");
|
|
offset_print("Booting...\n");
|
|
|
|
init_gdt();
|
|
EARLY_PRINT("GDT ");
|
|
offset_print("GDT initialized\n");
|
|
|
|
init_idt();
|
|
EARLY_PRINT("IDT ");
|
|
offset_print("IDT initialized\n");
|
|
|
|
init_pic();
|
|
/* Unmask timer IRQ (IRQ0) explicitly */
|
|
pic_clear_mask(0);
|
|
EARLY_PRINT("PIC ");
|
|
offset_print("PIC initialized\n");
|
|
|
|
init_pmm(addr);
|
|
EARLY_PRINT("PMM ");
|
|
offset_print("PMM initialized\n");
|
|
|
|
/* Scan Multiboot2 tags for the initrd module and framebuffer info */
|
|
uint32_t initrd_start = 0, initrd_end = 0;
|
|
memset(&fb_info, 0, sizeof(fb_info));
|
|
{
|
|
struct multiboot_tag *tag;
|
|
for (tag = (struct multiboot_tag *)(addr + 8);
|
|
tag->type != MULTIBOOT_TAG_TYPE_END;
|
|
tag = (struct multiboot_tag *)((uint8_t *)tag + ((tag->size + 7) & ~7u))) {
|
|
if (tag->type == MULTIBOOT_TAG_TYPE_MODULE) {
|
|
struct multiboot_tag_module *mod = (struct multiboot_tag_module *)tag;
|
|
initrd_start = mod->mod_start;
|
|
initrd_end = mod->mod_end;
|
|
offset_print("Initrd module at ");
|
|
print_hex(initrd_start);
|
|
offset_print(" to ");
|
|
print_hex(initrd_end);
|
|
}
|
|
if (tag->type == MULTIBOOT_TAG_TYPE_FRAMEBUFFER) {
|
|
struct multiboot_tag_framebuffer *fbt =
|
|
(struct multiboot_tag_framebuffer *)tag;
|
|
fb_info.addr = (uint32_t)fbt->common.framebuffer_addr;
|
|
fb_info.pitch = fbt->common.framebuffer_pitch;
|
|
fb_info.width = fbt->common.framebuffer_width;
|
|
fb_info.height = fbt->common.framebuffer_height;
|
|
fb_info.bpp = fbt->common.framebuffer_bpp;
|
|
fb_info.type = fbt->common.framebuffer_type;
|
|
|
|
if (fb_info.type == FB_TYPE_RGB) {
|
|
fb_info.red_pos = fbt->framebuffer_red_field_position;
|
|
fb_info.red_size = fbt->framebuffer_red_mask_size;
|
|
fb_info.green_pos = fbt->framebuffer_green_field_position;
|
|
fb_info.green_size = fbt->framebuffer_green_mask_size;
|
|
fb_info.blue_pos = fbt->framebuffer_blue_field_position;
|
|
fb_info.blue_size = fbt->framebuffer_blue_mask_size;
|
|
}
|
|
|
|
offset_print("Framebuffer: type=");
|
|
print_hex(fb_info.type);
|
|
offset_print(" addr=");
|
|
print_hex(fb_info.addr);
|
|
offset_print(" ");
|
|
print_hex(fb_info.width);
|
|
offset_print(" x ");
|
|
print_hex(fb_info.height);
|
|
offset_print(" bpp=");
|
|
print_hex(fb_info.bpp);
|
|
}
|
|
}
|
|
}
|
|
|
|
init_paging();
|
|
EARLY_PRINT("PAGING ");
|
|
offset_print("Paging initialized\n");
|
|
|
|
/* If GRUB provided a graphical framebuffer, identity-map it so
|
|
* the VGA driver can write pixels to it after paging is enabled. */
|
|
if (fb_info.addr != 0 && fb_info.type == FB_TYPE_RGB) {
|
|
uint32_t fb_size = fb_info.pitch * fb_info.height;
|
|
uint32_t fb_base = fb_info.addr & ~0xFFFu; /* page-align down */
|
|
uint32_t fb_end = (fb_info.addr + fb_size + 0xFFF) & ~0xFFFu;
|
|
offset_print(" Mapping framebuffer ");
|
|
print_hex(fb_base);
|
|
offset_print(" to ");
|
|
print_hex(fb_end);
|
|
for (uint32_t pa = fb_base; pa < fb_end; pa += 4096) {
|
|
paging_map_page(pa, pa, PAGE_PRESENT | PAGE_WRITE | PAGE_WRITETHROUGH);
|
|
}
|
|
}
|
|
|
|
/* Test paging: allocate a page and write to it */
|
|
void *test_page = paging_alloc_page();
|
|
if (test_page) {
|
|
offset_print("Allocated virtual page at: ");
|
|
print_hex((uint32_t)test_page);
|
|
*((volatile uint32_t *)test_page) = 0xDEADBEEF;
|
|
offset_print("Virtual page write/read OK\n");
|
|
paging_free_page(test_page);
|
|
} else {
|
|
offset_print("FAILED to allocate virtual page\n");
|
|
}
|
|
|
|
init_kmalloc();
|
|
EARLY_PRINT("HEAP ");
|
|
offset_print("Memory allocator initialized\n");
|
|
|
|
/* Initialize CPIO ramdisk if module was loaded */
|
|
if (initrd_start != 0) {
|
|
cpio_init((const void *)initrd_start, initrd_end - initrd_start);
|
|
EARLY_PRINT("CPIO ");
|
|
offset_print("CPIO ramdisk initialized\n");
|
|
} else {
|
|
offset_print("No initrd module found\n");
|
|
}
|
|
|
|
init_vfs();
|
|
EARLY_PRINT("VFS ");
|
|
offset_print("VFS initialized\n");
|
|
|
|
if (initrd_start != 0) {
|
|
init_initrd_fs();
|
|
EARLY_PRINT("INITRD ");
|
|
offset_print("Initrd filesystem mounted\n");
|
|
|
|
/* Test VFS: read a file from the initrd */
|
|
int fd = vfs_open("/initrd/README", 0);
|
|
if (fd >= 0) {
|
|
char buf[64];
|
|
int32_t n = vfs_read(fd, buf, sizeof(buf) - 1);
|
|
if (n > 0) {
|
|
buf[n] = '\0';
|
|
offset_print("VFS read /initrd/README: ");
|
|
offset_print(buf);
|
|
}
|
|
vfs_close(fd);
|
|
}
|
|
}
|
|
|
|
init_devicefs();
|
|
EARLY_PRINT("DEV ");
|
|
offset_print("Devicefs initialized\n");
|
|
|
|
init_sysfs();
|
|
EARLY_PRINT("SYS ");
|
|
offset_print("Sysfs initialized\n");
|
|
|
|
/* Register VFS mount namespace in sysfs */
|
|
sysfs_register("vfs", &vfs_sysfs_ops, NULL);
|
|
offset_print("VFS sysfs namespace registered\n");
|
|
|
|
init_tss();
|
|
EARLY_PRINT("TSS ");
|
|
offset_print("TSS initialized\n");
|
|
|
|
init_syscalls();
|
|
EARLY_PRINT("SYSCALL ");
|
|
offset_print("Syscalls initialized\n");
|
|
|
|
keyboard_init();
|
|
EARLY_PRINT("KBD ");
|
|
offset_print("Keyboard initialized\n");
|
|
|
|
init_process();
|
|
EARLY_PRINT("PROC ");
|
|
offset_print("Process subsystem initialized\n");
|
|
|
|
/* If the early VGA canary at 0xB8000 was visible, the display is
|
|
* definitely in text mode, regardless of what the GRUB framebuffer
|
|
* tag says. Force text mode so vga_init doesn't try to use a
|
|
* pixel framebuffer that isn't actually being displayed. */
|
|
if (fb_info.type == FB_TYPE_RGB) {
|
|
offset_print(" Overriding fb type from RGB to EGA_TEXT (early VGA visible)\n");
|
|
fb_info.type = FB_TYPE_EGA_TEXT;
|
|
fb_info.addr = 0x000B8000;
|
|
fb_info.width = 80;
|
|
fb_info.height = 25;
|
|
fb_info.bpp = 16;
|
|
fb_info.pitch = 80 * 2;
|
|
}
|
|
|
|
ethernet_init();
|
|
offset_print("Ethernet subsystem initialized\n");
|
|
|
|
ipv4_init();
|
|
offset_print("IPv4 stack initialized\n");
|
|
|
|
arp_init();
|
|
offset_print("ARP subsystem initialized\n");
|
|
|
|
dhcp_init();
|
|
offset_print("DHCP subsystem initialized\n");
|
|
|
|
udp_init();
|
|
offset_print("UDP stack initialized\n");
|
|
|
|
tcp_init();
|
|
offset_print("TCP stack initialized\n");
|
|
|
|
init_drivers();
|
|
EARLY_PRINT("DRV ");
|
|
offset_print("Drivers initialized\n");
|
|
|
|
/* Scan for MBR partitions on detected hard drives */
|
|
init_mbr();
|
|
offset_print("MBR scan complete\n");
|
|
|
|
/* At this point the VGA driver has been initialized and taken over
|
|
* the display. The early VGA text is no longer visible. */
|
|
|
|
/* Show memory statistics and boot progress on VGA */
|
|
vga_show_mem_stats();
|
|
vga_puts("Boot complete.\n\n");
|
|
|
|
/* Test kmalloc/kfree */
|
|
uint32_t *test_alloc = (uint32_t *)kmalloc(64);
|
|
if (test_alloc) {
|
|
*test_alloc = 42;
|
|
offset_print("kmalloc(64) = ");
|
|
print_hex((uint32_t)test_alloc);
|
|
kfree(test_alloc);
|
|
offset_print("kfree OK\n");
|
|
} else {
|
|
offset_print("FAILED to kmalloc\n");
|
|
}
|
|
|
|
/* Load the initial program from the initrd and run it */
|
|
cpio_entry_t app_entry;
|
|
const char *init_app = "sh";
|
|
if (cpio_find(init_app, &app_entry) == 0) {
|
|
offset_print("Found ");
|
|
offset_print(init_app);
|
|
offset_print(" in initrd (");
|
|
print_hex(app_entry.datasize);
|
|
offset_print(" bytes)\n");
|
|
|
|
int32_t pid = process_create(init_app,
|
|
app_entry.data,
|
|
app_entry.datasize);
|
|
if (pid > 0) {
|
|
offset_print("Created init process, pid=");
|
|
print_hex((uint32_t)pid);
|
|
|
|
/* Enable interrupts before entering user mode */
|
|
asm volatile("sti");
|
|
offset_print("Interrupts enabled\n");
|
|
|
|
/* Enter user mode - does not return */
|
|
process_run_first();
|
|
} else {
|
|
offset_print("FAILED to create init process\n");
|
|
}
|
|
} else {
|
|
offset_print(init_app);
|
|
offset_print(" not found in initrd\n");
|
|
}
|
|
|
|
/* Enable interrupts */
|
|
asm volatile("sti");
|
|
offset_print("Interrupts enabled\n");
|
|
|
|
offset_print("Hello, world\n");
|
|
}
|