main.c

/* ============================================================================

 * Pactor64 Kernel Main — x86-64

 * Core kernel: I/O, printf, CPU detection, init sequence

 * ============================================================================ */

#include "types.h"

/* === GCC builtins for va_list (no libc) === */

typedef __builtin_va_list va_list;

#define va_start(ap, last) __builtin_va_start(ap, last)

#define va_end(ap)         __builtin_va_end(ap)

#define va_arg(ap, type)   __builtin_va_arg(ap, type)

/* === Port I/O === */

void outb(uint16_t port, uint8_t val) {

    __asm__ volatile ("outb %0, %1" : : "a"(val), "Nd"(port));

}

uint8_t inb(uint16_t port) {

    uint8_t val;

    __asm__ volatile ("inb %1, %0" : "=a"(val) : "Nd"(port));

    return val;

}

/* === String utilities === */

size_t kstrlen(const char *s) { size_t n=0; while(s[n]) n++; return n; }

int kstrcmp(const char *a, const char *b) { while(*a&&*a==*b){a++;b++;} return (uint8_t)*a-(uint8_t)*b; }

int kstrncmp(const char *a, const char *b, size_t n) { for(size_t i=0;i<n;i++){if(a[i]!=b[i])return(uint8_t)a[i]-(uint8_t)b[i];if(!a[i])return 0;}return 0; }

void *kmemset(void *d, int c, size_t n) { uint8_t *p=d; while(n--) *p++=(uint8_t)c; return d; }

void *kmemcpy(void *d, const void *s, size_t n) { uint8_t *dp=d; const uint8_t *sp=s; while(n--) *dp++=*sp++; return d; }

/* === Serial I/O (COM1) === */

#define COM1 0x3F8

void serial_init(void) {

    outb(COM1+1, 0x00);

    outb(COM1+3, 0x80);

    outb(COM1+0, 0x03);

    outb(COM1+1, 0x00);

    outb(COM1+3, 0x03);

    outb(COM1+2, 0xC7);

    outb(COM1+4, 0x0B);

}

void serial_putc(char c) {

    while (!(inb(COM1+5) & 0x20)) {}

    outb(COM1, c);

}

void serial_puts(const char *s) { while(*s) serial_putc(*s++); }

int serial_poll(void) { return inb(COM1+5) & 0x01; }

int serial_getc(void) { return serial_poll() ? inb(COM1) : -1; }

/* === Number printing === */

void kprint_hex(uint64_t val) {

    serial_puts("0x");

    for (int i = 60; i >= 0; i -= 4) {

        int n = (val >> i) & 0xF;

        serial_putc(n < 10 ? '0'+n : 'A'+n-10);

    }

}

void kprint_dec(uint64_t val) {

    if (!val) { serial_putc('0'); return; }

    char buf[21]; int i = 0;

    while (val) { buf[i++] = '0'+(val%10); val /= 10; }

    while (i > 0) serial_putc(buf[--i]);

}

/* === kprintf === */

void kprintf(const char *fmt, ...) {

    va_list ap;

    va_start(ap, fmt);

    for (int i = 0; fmt[i]; i++) {

        if (fmt[i] == '%' && fmt[i+1]) {

            i++;

            switch (fmt[i]) {

                case 'd': kprint_dec(va_arg(ap, uint64_t)); break;

                case 'x': kprint_hex(va_arg(ap, uint64_t)); break;

                case 's': { const char *s = va_arg(ap, const char*);

                            serial_puts(s ? s : "(null)"); break; }

                case 'c': serial_putc((char)va_arg(ap, int)); break;

                case '%': serial_putc('%'); break;

                default:  serial_putc('%'); serial_putc(fmt[i]); break;

            }

        } else serial_putc(fmt[i]);

    }

    va_end(ap);

}

/* === Assembly functions === */

extern void idt_init(void);

extern void pic_remap(int offset1, int offset2);

/* === Module init functions === */

extern void timer_init(uint32_t hz);

extern void keyboard_init(void);

extern void pmm_init(uint64_t mb2_info);

extern void heap_init(void);

extern void vga_init(void);

extern void vga_clear(void);

extern void vga_puts(const char *s);

extern void ata_init(void);

extern void syscall_init(void);

extern void shell_init(void);

extern void shell_run(void);

extern uint64_t kernel_end;

/* === Timer tick counter (from isr.asm) === */

extern volatile uint64_t timer_ticks;

/* === CPU Detection === */

static void detect_cpu(void) {

    uint32_t eax, ebx, ecx, edx;

    char vendor[13] = {0};

    __asm__ volatile ("cpuid":"=a"(eax),"=b"(ebx),"=c"(ecx),"=d"(edx):"a"(0));

    *(uint32_t*)&vendor[0]=ebx; *(uint32_t*)&vendor[4]=edx; *(uint32_t*)&vendor[8]=ecx;

    kprintf("  CPU Vendor:     %s\n", vendor);

    __asm__ volatile ("cpuid":"=a"(eax),"=d"(edx):"a"(1));

    kprintf("  Family/Model:   %d/%d Stepping %d\n", (eax>>8)&0xF, (eax>>4)&0xF, eax&0xF);

    kprintf("  Features:       ");

    if(edx&(1<<4))  kprintf("TSC ");

    if(edx&(1<<8))  kprintf("CX8 ");

    if(edx&(1<<23)) kprintf("MMX ");

    if(edx&(1<<25)) kprintf("SSE ");

    if(edx&(1<<26)) kprintf("SSE2 ");

    __asm__ volatile ("cpuid":"=a"(eax),"=d"(edx):"a"(0x80000001));

    if(edx&(1<<29)) kprintf("LM ");

    kprintf("\n");

}

static void dump_registers(void) {

    uint64_t rsp, cr0, cr3, cr4;

    __asm__ volatile ("mov %%rsp,%0":"=r"(rsp));

    __asm__ volatile ("mov %%cr0,%0":"=r"(cr0));

    __asm__ volatile ("mov %%cr3,%0":"=r"(cr3));

    __asm__ volatile ("mov %%cr4,%0":"=r"(cr4));

    kprintf("  RSP:            %x\n", rsp);

    kprintf("  CR0:            %x (PE=%d PG=%d)\n", cr0, cr0&1, (cr0>>31)&1);

    kprintf("  CR3 (PML4):     %x\n", cr3);

    kprintf("  CR4:            %x (PAE=%d)\n", cr4, (cr4>>5)&1);

}

/* === Exception Handler === */

void exception_handler(uint64_t int_num, uint64_t err_code, uint64_t rip) {

    kprintf("\n*** EXCEPTION %d at RIP %x err=%x ***\n", int_num, rip, err_code);

    for (;;) __asm__ volatile ("cli; hlt");

}

/* === Kernel Main === */

void kernel_main_64(uint64_t mb2_info, uint64_t mb2_magic) {

    serial_init();

    kprintf("\n========================================\n");

    kprintf("  Pactor64 — x86-64 Kernel\n");

    kprintf("  Built from NT source code analysis\n");

    kprintf("========================================\n\n");

    if (mb2_magic == 0x36D76289) kprintf("  [OK] Multiboot2 verified\n");

    else kprintf("  [WARN] Multiboot magic: %x\n", mb2_magic);

    detect_cpu();

    dump_registers();

    /* PIC + IDT */

    pic_remap(0x20, 0x28);

    kprintf("  [OK] PIC remapped (IRQs 0x20-0x2F)\n");

    idt_init();

    kprintf("  [OK] IDT initialized (256 vectors, 64-bit)\n");

    /* Enable interrupts */

    __asm__ volatile ("sti");

    kprintf("  [OK] Interrupts enabled\n");

    /* Timer */

    timer_init(100);

    kprintf("  [OK] PIT timer at 100 Hz\n");

    /* Keyboard */

    keyboard_init();

    kprintf("  [OK] PS/2 keyboard initialized\n");

    /* Physical memory */

    pmm_init(mb2_info);

    /* Heap */

    heap_init();

    syscall_init();

    kprintf("  [OK] SYSCALL interface (STAR/LSTAR MSRs)\n");

    /* VGA */

    vga_init();

    vga_clear();

    vga_puts("Pactor64 VGA active.\n");

    kprintf("  [OK] VGA text mode (80x25)\n");

    /* ATA */

    ata_init();

    kprintf("\n  Kernel at 0x100000, end at %x\n", (uint64_t)&kernel_end);

    kprintf("  PML4 at ");

    uint64_t cr3; __asm__ volatile ("mov %%cr3,%0":"=r"(cr3));

    kprint_hex(cr3);

    kprintf("\n\n");

    /* Shell */

    shell_init();

    shell_run();

    kprintf("\n  System halted.\n");

    for (;;) __asm__ volatile ("cli; hlt");

}