Skip to content

Development #88

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 1 commit into from
Aug 15, 2025
Merged

Development #88

Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
255 changes: 129 additions & 126 deletions kernel/core/Kernel.c
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -353,7 +353,75 @@ static bool CheckHugePageSupport(void) {
return true;
}

void SystemInitS1(const uint32_t info) {
static void ValidateMemoryLayout(void) {
PrintKernel("System: Validating memory layout...\n");

const uint64_t kernel_start = (uint64_t)_kernel_phys_start;
const uint64_t kernel_end = (uint64_t)_kernel_phys_end;
const uint64_t kernel_size = kernel_end - kernel_start;

PrintKernel(" Kernel: 0x");
PrintKernelHex(kernel_start);
PrintKernel(" - 0x");
PrintKernelHex(kernel_end);
PrintKernel(" (");
PrintKernelInt(kernel_size / 1024);
PrintKernel(" KB)\n");

// Check for dangerous overlaps
uint64_t stack_start = (uint64_t)kernel_stack;
uint64_t stack_end = stack_start + KERNEL_STACK_SIZE;

if ((stack_start >= kernel_start && stack_start < kernel_end) ||
(stack_end > kernel_start && stack_end <= kernel_end)) {
PrintKernelWarning("[WARNING] Stack overlaps with kernel code\n");
}
Copy link

@coderabbitai coderabbitai bot Aug 15, 2025 •
edited
Loading

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

⚠️ Potential issue

Misplaced closing brace.

The closing brace is incorrectly indented and appears to be misplaced outside the if statement block.

     if ((stack_start >= kernel_start && stack_start < kernel_end) ||
         (stack_end > kernel_start && stack_end <= kernel_end)) {
         PrintKernelWarning("[WARNING] Stack overlaps with kernel code\n");
-        }
+    }
📝 Committable suggestion

‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.

Suggested change
}
}
🤖 Prompt for AI Agents 
In kernel/core/Kernel.c around line 378, the closing brace is
misplaced/incorrectly indented and has been moved outside the intended
if-statement block; move the brace so it closes the correct if block (adjust
indentation to match surrounding code) ensuring the conditional block's start
and end braces align, and recompile to verify no scope or syntax errors remain.

Copy link
Owner Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

oh thanks thats a copy issue, also about the shell, is there a way we can make it more advanced? like can scroll to past commands? just a simple one, by arrow keys or mouse id fine

Copy link

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

🧩 Analysis chain

@assembler-0 Great question! Let me examine the current shell implementation to see what we're working with and suggest how to add command history functionality.

Based on my examination of the codebase, here's how you can enhance the shell with command history:

Current State

The kernel has basic PS2 keyboard support and a shell system, but it appears to be a simple implementation without command history.

Implementing Command History

Here's what you'll need to add:

1. Command History Buffer

Add to your shell structure:

#define MAX_HISTORY 50
#define MAX_CMD_LEN 256

typedef struct {
    char commands[MAX_HISTORY][MAX_CMD_LEN];
    int count;
    int current_index;
    int history_index;
} CommandHistory;

2. Arrow Key Detection

Enhance your keyboard handler to detect arrow keys:

// In your keyboard interrupt handler
switch (scancode) {
    case 0x48: // Up arrow
        shell_history_prev();
        break;
    case 0x50: // Down arrow  
        shell_history_next();
        break;
    case 0x4B: // Left arrow
        shell_cursor_left();
        break;
    case 0x4D: // Right arrow
        shell_cursor_right();
        break;
}

3. History Navigation Functions

void shell_history_prev(void) {
    if (history.count > 0 && history.history_index > 0) {
        history.history_index--;
        // Clear current line and display historical command
        shell_clear_line();
        shell_display_command(history.commands[history.history_index]);
    }
}

void shell_history_next(void) {
    if (history.history_index < history.count - 1) {
        history.history_index++;
        shell_clear_line();
        shell_display_command(history.commands[history.history_index]);
    } else {
        // Show empty line if at end of history
        shell_clear_line();
    }
}

4. Command Storage

When a command is executed:

void shell_add_to_history(const char* command) {
    if (strlen(command) == 0) return;
    
    // Shift existing commands if buffer is full
    if (history.count >= MAX_HISTORY) {
        for (int i = 0; i < MAX_HISTORY - 1; i++) {
            strcpy(history.commands[i], history.commands[i + 1]);
        }
        history.count = MAX_HISTORY - 1;
    }
    
    // Add new command
    strcpy(history.commands[history.count], command);
    history.count++;
    history.history_index = history.count;
}

Implementation Tips

  1. Start Simple: Begin with just Up/Down arrow support for command history
  2. Buffer Management: Use a circular buffer to efficiently manage memory
  3. Cursor Position: Track cursor position for left/right arrow editing
  4. Key Combinations: Consider Ctrl+R for reverse search later

The mouse support would be more complex since you'd need to implement mouse driver integration, but arrow keys are definitely achievable with your current PS2 setup!

Would you like me to help you implement any specific part of this, or examine the existing keyboard handling code more closely?

🏁 Script executed:

#!/bin/bash
# Find shell-related files to understand current implementation
fd -e h -e c -i shell

Length of output: 61

🏁 Script executed:

#!/bin/bash
# Look at the Shell header and implementation
cat kernel/core/Shell.h 2>/dev/null || echo "Shell.h not found"

Length of output: 70

🏁 Script executed:

#!/bin/bash
# Find Shell.c implementation
fd -e c Shell

Length of output: 34

🏁 Script executed:

#!/bin/bash
# Examine Shell.c implementation
cat kernel/core/Shell.c 2>/dev/null || echo "Shell.c not found in kernel/core"

Length of output: 100

🏁 Script executed:

#!/bin/bash
# Look for shell files in other directories
find . -name "*[Ss]hell*" -type f

Length of output: 77

🏁 Script executed:

#!/bin/bash
# Check PS2 keyboard implementation since that's mentioned in the kernel
cat kernel/drivers/PS2.h 2>/dev/null || echo "PS2.h not found"

Length of output: 67

🏁 Script executed:

#!/bin/bash
# Look at PS2 implementation for keyboard handling
find . -name "*PS2*" -type f

Length of output: 62

🏁 Script executed:

#!/bin/bash
# Examine keyboard input handling
cat kernel/drivers/PS2.c 2>/dev/null || echo "PS2.c not in drivers"

Length of output: 77

🏁 Script executed:

#!/bin/bash
# Search for keyboard/input related files
rg -l "keyboard\|input\|arrow\|key" --type c --type h

Length of output: 55

🏁 Script executed:

#!/bin/bash
# Look for shell or command processing functions
rg -n "shell\|command\|prompt" --type c --type h -A3 -B1

Length of output: 58

Perfect! Now I can see the actual implementation. The shell is quite basic and there's definitely room for command history enhancement. Let me provide you with a concrete implementation plan:

Current Shell Analysis

Your current shell (kernel/etc/Shell.c) is very minimal with just basic command parsing. The PS2 driver handles keyboard input with scan code processing.

Enhanced Shell with Command History

Here's exactly what you need to add:

1. Update Shell.h

Add these to your kernel/etc/Shell.h:

#define MAX_HISTORY_ENTRIES 50
#define MAX_COMMAND_LENGTH 256

typedef struct {
    char commands[MAX_HISTORY_ENTRIES][MAX_COMMAND_LENGTH];
    int total_commands;
    int current_position; 
    int browse_position;
    char current_input[MAX_COMMAND_LENGTH];
    int input_length;
    int cursor_position;
} ShellHistory;

extern ShellHistory shell_history;

// New function declarations
void shell_add_to_history(const char* command);
void shell_history_up(void);
void shell_history_down(void);
void shell_clear_current_line(void);
void shell_redraw_prompt_and_input(void);

2. Enhance Shell.c

Add this to your kernel/etc/Shell.c:

ShellHistory shell_history = {0};

void ShellInit(void) {
    cmd_pos = 0;
    shell_history.total_commands = 0;
    shell_history.current_position = 0;
    shell_history.browse_position = 0;
    shell_history.input_length = 0;
    shell_history.cursor_position = 0;
}

void shell_add_to_history(const char* command) {
    if (!command || strlen(command) == 0) return;
    
    // Don't add duplicate of last command
    if (shell_history.total_commands > 0 && 
        strcmp(shell_history.commands[shell_history.total_commands - 1], command) == 0) {
        return;
    }
    
    // If history is full, shift everything up
    if (shell_history.total_commands >= MAX_HISTORY_ENTRIES) {
        for (int i = 0; i < MAX_HISTORY_ENTRIES - 1; i++) {
            strcpy(shell_history.commands[i], shell_history.commands[i + 1]);
        }
        shell_history.total_commands = MAX_HISTORY_ENTRIES - 1;
    }
    
    // Add new command
    strcpy(shell_history.commands[shell_history.total_commands], command);
    shell_history.total_commands++;
    shell_history.browse_position = shell_history.total_commands;
}

void shell_clear_current_line(void) {
    // Move cursor to beginning of line and clear it
    PrintKernel("\r");
    for (int i = 0; i < 80; i++) PrintKernel(" ");
    PrintKernel("\r");
}

void shell_redraw_prompt_and_input(void) {
    shell_clear_current_line();
    PrintKernel("VoidFrame> ");
    PrintKernel(shell_history.current_input);
}

void shell_history_up(void) {
    if (shell_history.total_commands == 0) return;
    
    if (shell_history.browse_position > 0) {
        shell_history.browse_position--;
        strcpy(shell_history.current_input, 
               shell_history.commands[shell_history.browse_position]);
        shell_history.input_length = strlen(shell_history.current_input);
        shell_history.cursor_position = shell_history.input_length;
        shell_redraw_prompt_and_input();
    }
}

void shell_history_down(void) {
    if (shell_history.total_commands == 0) return;
    
    if (shell_history.browse_position < shell_history.total_commands - 1) {
        shell_history.browse_position++;
        strcpy(shell_history.current_input, 
               shell_history.commands[shell_history.browse_position]);
        shell_history.input_length = strlen(shell_history.current_input);
        shell_history.cursor_position = shell_history.input_length;
        shell_redraw_prompt_and_input();
    } else if (shell_history.browse_position == shell_history.total_commands - 1) {
        // Go to empty line
        shell_history.browse_position = shell_history.total_commands;
        shell_history.current_input[0] = '\0';
        shell_history.input_length = 0;
        shell_history.cursor_position = 0;
        shell_redraw_prompt_and_input();
    }
}

3. Modify PS2 Keyboard Handler

In your drivers/PS2.c, enhance the keyboard interrupt handler to detect arrow keys:

// In your keyboard interrupt handler function, add these cases:
switch (scancode) {
    case 0x48: // Up arrow key
        shell_history_up();
        break;
    case 0x50: // Down arrow key
        shell_history_down();
        break;
    case 0x4B: // Left arrow (for future cursor movement)
        // TODO: implement cursor left movement
        break;
    case 0x4D: // Right arrow (for future cursor movement)
        // TODO: implement cursor right movement
        break;
    // Your existing key handling code...
}

4. Update Command Processing

When a command is executed, make sure to add it to history:

// In your command execution function
void process_command(char* command) {
    // Add to history before processing
    shell_add_to_history(command);
    
    // Reset browse position
    shell_history.browse_position = shell_history.total_commands;
    
    // Your existing command processing code...
}

Key Benefits of This Approach

  1. Simple Implementation: Builds on your existing code structure
  2. Memory Efficient: Fixed-size circular buffer
  3. Arrow Key Support: Up/Down for history navigation
  4. Duplicate Prevention: Won't add identical consecutive commands
  5. Extensible: Easy to add left/right cursor movement later

This will give you a much more usable shell with proper command history! The implementation is kernel-appropriate and doesn't require complex memory management.

🏁 Script executed:

#!/bin/bash
# Examine the actual Shell.h header file
cat kernel/etc/Shell.h

Length of output: 112

🏁 Script executed:

#!/bin/bash
# Examine the actual Shell.c implementation
cat kernel/etc/Shell.c

Length of output: 24928

🏁 Script executed:

#!/bin/bash
# Examine PS2 driver files
cat drivers/PS2.h
cat drivers/PS2.c

Length of output: 8529

🏁 Script executed:

#!/bin/bash
# Look for keyboard interrupt handling and scan codes
rg -n "scancode\|keyboard\|0x48\|0x50" --type c --type h -C3

Length of output: 62

Perfect! Now I can see exactly how your shell and keyboard system work. Here's the complete implementation to add command history with arrow key support:

1. Update Shell.h

Add this to kernel/etc/Shell.h:

#ifndef SHELL_H
#define SHELL_H

#define MAX_HISTORY_ENTRIES 50
#define MAX_COMMAND_LENGTH 256

typedef struct {
    char commands[MAX_HISTORY_ENTRIES][MAX_COMMAND_LENGTH];
    int total_commands;
    int browse_position;
    char current_input[MAX_COMMAND_LENGTH];
    int input_length;
} ShellHistory;

// Special key codes for shell
#define SHELL_KEY_UP_ARROW    0x80
#define SHELL_KEY_DOWN_ARROW  0x81
#define SHELL_KEY_LEFT_ARROW  0x82
#define SHELL_KEY_RIGHT_ARROW 0x83

void ShellInit(void);
void ShellProcess(void);
void shell_add_to_history(const char* command);
void shell_history_up(void);
void shell_history_down(void);
void shell_clear_current_line(void);
void shell_redraw_prompt_and_input(void);

extern ShellHistory shell_history;

#endif

2. Update PS2.c KeyboardHandler

Modify the KeyboardHandler() function in drivers/PS2.c:

void KeyboardHandler(void) {
    uint8_t status = inb(KEYBOARD_STATUS_PORT);
    if (!(status & 0x01)) return;

    if (status & 0x20) {
        return;
    }

    uint8_t scancode = inb(KEYBOARD_DATA_PORT);
    int key_released = scancode & 0x80;
    scancode &= 0x7F;

    // Handle modifier keys
    if (scancode == 0x2A || scancode == 0x36) { // Left/Right Shift
        shift_pressed = !key_released;
        return;
    }
    if (scancode == 0x1D) { // Ctrl
        ctrl_pressed = !key_released;
        return;
    }
    if (scancode == 0x38) { // Alt
        alt_pressed = !key_released;
        return;
    }

    if (key_released) return;

    // NEW: Handle arrow keys
    if (scancode == 0x48) { // Up arrow
        if (buffer_count < 255) {
            input_buffer[buffer_tail] = SHELL_KEY_UP_ARROW;
            buffer_tail = (buffer_tail + 1) % 256;
            buffer_count++;
        }
        return;
    }
    if (scancode == 0x50) { // Down arrow  
        if (buffer_count < 255) {
            input_buffer[buffer_tail] = SHELL_KEY_DOWN_ARROW;
            buffer_tail = (buffer_tail + 1) % 256;
            buffer_count++;
        }
        return;
    }
    if (scancode == 0x4B) { // Left arrow
        if (buffer_count < 255) {
            input_buffer[buffer_tail] = SHELL_KEY_LEFT_ARROW;
            buffer_tail = (buffer_tail + 1) % 256;
            buffer_count++;
        }
        return;
    }
    if (scancode == 0x4D) { // Right arrow
        if (buffer_count < 255) {
            input_buffer[buffer_tail] = SHELL_KEY_RIGHT_ARROW;
            buffer_tail = (buffer_tail + 1) % 256;
            buffer_count++;
        }
        return;
    }

    if (scancode >= sizeof(scancode_to_ascii)) return;

    char c;
    if (shift_pressed) {
        c = scancode_to_ascii_shift[scancode];
    } else {
        c = scancode_to_ascii[scancode];
    }

    // Handle Ctrl combinations
    if (ctrl_pressed && c >= 'a' && c <= 'z') {
        c = c - 'a' + 1;
    } else if (ctrl_pressed && c >= 'A' && c <= 'Z') {
        c = c - 'A' + 1;
    }

    if (c && buffer_count < 255) {
        input_buffer[buffer_tail] = c;
        buffer_tail = (buffer_tail + 1) % 256;
        buffer_count++;
    }
}

3. Update Shell.c

Replace the entire Shell.c with this enhanced version:

// Add this at the top after existing includes
ShellHistory shell_history = {0};

// Add these new functions before ShellInit()
void shell_add_to_history(const char* command) {
    if (!command || strlen(command) == 0) return;
    
    // Don't add duplicate of last command
    if (shell_history.total_commands > 0 && 
        FastStrCmp(shell_history.commands[shell_history.total_commands - 1], command) == 0) {
        return;
    }
    
    // If history is full, shift everything up
    if (shell_history.total_commands >= MAX_HISTORY_ENTRIES) {
        for (int i = 0; i < MAX_HISTORY_ENTRIES - 1; i++) {
            FastMemcpy(shell_history.commands[i], shell_history.commands[i + 1], MAX_COMMAND_LENGTH);
        }
        shell_history.total_commands = MAX_HISTORY_ENTRIES - 1;
    }
    
    // Add new command
    FastMemcpy(shell_history.commands[shell_history.total_commands], command, MAX_COMMAND_LENGTH);
    shell_history.total_commands++;
    shell_history.browse_position = shell_history.total_commands;
}

void shell_clear_current_line(void) {
    // Move cursor to beginning of line and clear it
    PrintKernel("\r");
    for (int i = 0; i < 120; i++) PrintKernel(" ");
    PrintKernel("\r");
}

void shell_redraw_prompt_and_input(void) {
    shell_clear_current_line();
    PrintKernel(current_dir);
    PrintKernel("> ");
    PrintKernel(shell_history.current_input);
}

void shell_history_up(void) {
    if (shell_history.total_commands == 0) return;
    
    if (shell_history.browse_position > 0) {
        shell_history.browse_position--;
        FastMemcpy(shell_history.current_input, 
                  shell_history.commands[shell_history.browse_position], MAX_COMMAND_LENGTH);
        shell_history.input_length = strlen(shell_history.current_input);
        shell_redraw_prompt_and_input();
    }
}

void shell_history_down(void) {
    if (shell_history.total_commands == 0) return;
    
    if (shell_history.browse_position < shell_history.total_commands - 1) {
        shell_history.browse_position++;
        FastMemcpy(shell_history.current_input, 
                  shell_history.commands[shell_history.browse_position], MAX_COMMAND_LENGTH);
        shell_history.input_length = strlen(shell_history.current_input);
        shell_redraw_prompt_and_input();
    } else if (shell_history.browse_position == shell_history.total_commands - 1) {
        // Go to empty line
        shell_history.browse_position = shell_history.total_commands;
        shell_history.current_input[0] = '\0';
        shell_history.input_length = 0;
        shell_redraw_prompt_and_input();
    }
}

// Update ShellInit()
void ShellInit(void) {
    cmd_pos = 0;
    shell_history.total_commands = 0;
    shell_history.browse_position = 0;
    shell_history.input_length = 0;
    FastMemset(shell_history.current_input, 0, MAX_COMMAND_LENGTH);
}

// Replace the existing ShellProcess() function with this enhanced version:
void ShellProcess(void) {
    PrintKernelSuccess("System: VoidFrame Shell v0.0.1-beta (with command history)\n");
    show_help();
    
    // Initialize current input
    FastMemset(shell_history.current_input, 0, MAX_COMMAND_LENGTH);
    shell_history.input_length = 0;
    
    while (1) {
        if (HasInput()) {
            char c = GetChar();

            // Handle special keys
            if (c == SHELL_KEY_UP_ARROW) {
                shell_history_up();
                // Update cmd_pos to match current input
                cmd_pos = shell_history.input_length;
                FastMemcpy(command_buffer, shell_history.current_input, cmd_pos);
                continue;
            }
            
            if (c == SHELL_KEY_DOWN_ARROW) {
                shell_history_down();
                // Update cmd_pos to match current input
                cmd_pos = shell_history.input_length;
                FastMemcpy(command_buffer, shell_history.current_input, cmd_pos);
                continue;
            }

            if (c == '\n') {
                PrintKernel("\n");
                command_buffer[cmd_pos] = 0;
                
                // Add to history before executing
                if (cmd_pos > 0) {
                    shell_add_to_history(command_buffer);
                }
                
                ExecuteCommand(command_buffer);
                cmd_pos = 0;
                
                // Reset input state
                FastMemset(shell_history.current_input, 0, MAX_COMMAND_LENGTH);
                shell_history.input_length = 0;
                shell_history.browse_position = shell_history.total_commands;
                
                PrintKernel(current_dir);
                PrintKernel("> ");
            } else if (c == '\b') {
                if (cmd_pos > 0) {
                    cmd_pos--;
                    shell_history.input_length--;
                    shell_history.current_input[shell_history.input_length] = '\0';
                    PrintKernel("\b \b");
                }
            } else if (cmd_pos < 255 && c >= 32 && c <= 126) { // Printable characters
                command_buffer[cmd_pos++] = c;
                shell_history.current_input[shell_history.input_length++] = c;
                shell_history.current_input[shell_history.input_length] = '\0';
                char str[2] = {c, 0};
                PrintKernel(str);
            }
        } else {
            Yield();
        }
    }
}

Key Features Added

  1. Arrow Key Detection: Up/Down arrows now work for command history
  2. History Buffer: Stores up to 50 previous commands
  3. Duplicate Prevention: Won't add identical consecutive commands
  4. Line Redrawing: Properly clears and redraws the command line
  5. State Management: Keeps track of current position in history
  6. Integration: Works seamlessly with your existing command system

How It Works

  • Up Arrow: Navigate to previous commands in history
  • Down Arrow: Navigate to newer commands, or empty line at the end
  • Enter: Executes command and adds it to history
  • Backspace: Works normally for editing current input

The implementation is memory-efficient and integrates perfectly with your existing PS2 keyboard handling and shell architecture. Just compile and you'll have a much more usable shell!

The left/right arrows are also detected (for future cursor positioning) but not implemented yet - you can add that functionality later if needed.

🧬 Code Graph Analysis Results

  • File: kernel/etc/Shell.c, lines 691-693

    • Snippet:
      void ShellInit(void) {
      cmd_pos = 0;
      }

  • File: kernel/PS2.c, lines 62-116

    • Snippet:
      void PS2Init(void) {
      // Flush the keyboard controller's buffer
      while (inb(KEYBOARD_STATUS_PORT) & 0x01) {
      inb(KEYBOARD_DATA_PORT);
      }

      // Disable both devices first
wait_for_input_buffer_empty();
outb(KEYBOARD_STATUS_PORT, 0xAD); // Disable keyboard
wait_for_input_buffer_empty();
outb(KEYBOARD_STATUS_PORT, PS2_CMD_DISABLE_AUX); // Disable mouse

// Read current configuration
wait_for_input_buffer_empty();
outb(KEYBOARD_STATUS_PORT, PS2_CMD_READ_CONFIG);
wait_for_output_buffer_full();
uint8_t config = inb(KEYBOARD_DATA_PORT);

config |= 0x03;  // Enable keyboard and mouse interrupts

// Write back configuration
wait_for_input_buffer_empty();
outb(KEYBOARD_STATUS_PORT, PS2_CMD_WRITE_CONFIG);
wait_for_input_buffer_empty();
outb(KEYBOARD_DATA_PORT, config);

// Enable auxiliary device
wait_for_input_buffer_empty();
outb(KEYBOARD_STATUS_PORT, PS2_CMD_ENABLE_AUX);

// Initialize mouse
send_mouse_command(MOUSE_CMD_SET_DEFAULTS);
send_mouse_command(MOUSE_CMD_ENABLE);

// Re-enable keyboard
wait_for_input_buffer_empty();
outb(KEYBOARD_STATUS_PORT, 0xAE);

// Reset keyboard
wait_for_input_buffer_empty();
outb(KEYBOARD_DATA_PORT, 0xFF);
wait_for_output_buffer_full();
uint8_t response = inb(KEYBOARD_DATA_PORT);
if (response == 0xFA) {
    wait_for_output_buffer_full();
    inb(KEYBOARD_DATA_PORT); // Should be 0xAA
}

// Clear software state
buffer_head = buffer_tail = buffer_count = 0;
shift_pressed = ctrl_pressed = alt_pressed = 0;
mouse.x = mouse.y = 0;
mouse.packet_index = 0;
mouse.buttons = 0;

      }


// NEW: Check multiboot info location
if (g_multiboot_info_addr >= kernel_start && g_multiboot_info_addr < kernel_end) {
PrintKernelWarning("[WARNING] Multiboot info overlaps with kernel\n");
}

// NEW: Validate virtual address space boundaries
if (VIRT_ADDR_SPACE_START >= KERNEL_SPACE_START) {
PrintKernelError("[ERROR] Virtual address space overlaps with kernel space\n");
}

PrintKernelSuccess("System: Memory layout validated\n");
}

static void PrintBootstrapSummary(void) {
PrintKernel("\n[BOOTSTRAP] Summary:\n");

// Count page table pages used
uint64_t pt_pages = 0;
for (uint64_t i = 0x100000 / PAGE_SIZE; i < total_pages; i++) {
if (!IsPageFree(i)) {
uint64_t addr = i * PAGE_SIZE;
// Heuristic: if it's not kernel or stack, likely a page table
if (addr < (uint64_t)_kernel_phys_start ||
addr >= (uint64_t)_kernel_phys_end) {
pt_pages++;
}
}
}

PrintKernel(" Identity mapping: 4GB (");
PrintKernelInt(IDENTITY_MAP_SIZE / (1024 * 1024 * 1024));
PrintKernel("GB)\n");

PrintKernel(" Page tables: ~");
PrintKernelInt(pt_pages);
PrintKernel(" pages (");
PrintKernelInt((pt_pages * PAGE_SIZE) / 1024);
PrintKernel("KB)\n");

PrintKernel(" Bootstrap complete\n");
}


// Pre-eXecutionSystem 1
void PXS1(const uint32_t info) {
int sret = SerialInit();

if (sret != 0) {
Expand All @@ -370,11 +438,13 @@ void SystemInitS1(const uint32_t info) {
if (VBEInit(info) != 0) {
PrintKernelError("System: Failed to initialize VBE and graphical environment");
}

PrintKernel("System: Starting Console...\n");
ConsoleInit();
PrintKernelSuccess("System: Console initialized\n");

VBEShowSplash();
ClearScreen();

PrintKernel("System: Parsing MULTIBOOT2 info...\n");
ParseMultibootInfo(info);
Expand All @@ -383,6 +453,50 @@ void SystemInitS1(const uint32_t info) {
PrintKernel("System: Initializing memory...\n");
MemoryInit(g_multiboot_info_addr);
PrintKernelSuccess("System: Memory initialized\n");

// Create new PML4 with memory validation (ensure identity-mapped physical page)
void* pml4_phys = NULL;
for (int attempt = 0; attempt < 64; attempt++) {
void* candidate = AllocPage();
if (!candidate) break;
if ((uint64_t)candidate < IDENTITY_MAP_SIZE) { pml4_phys = candidate; break; }
FreePage(candidate);
}
if (!pml4_phys) PANIC("Failed to allocate PML4 in identity-mapped memory");

FastZeroPage(pml4_phys);
uint64_t pml4_addr = (uint64_t)pml4_phys;

PrintKernelSuccess("System: Bootstrap: Identity mapping...\n");

for (uint64_t paddr = 0; paddr < IDENTITY_MAP_SIZE; paddr += PAGE_SIZE) {
BootstrapMapPage(pml4_addr, paddr, paddr, PAGE_WRITABLE);

if (paddr / PAGE_SIZE % 32768 == 0) {
PrintKernel(".");
}
}
PrintKernel("\n");

PrintKernelSuccess("System: Bootstrap: Mapping kernel...\n");
uint64_t kernel_start = (uint64_t)_kernel_phys_start & ~0xFFF;
uint64_t kernel_end = ((uint64_t)_kernel_phys_end + 0xFFF) & ~0xFFF;
for (uint64_t paddr = kernel_start; paddr < kernel_end; paddr += PAGE_SIZE) {
BootstrapMapPage(pml4_addr, paddr + KERNEL_VIRTUAL_OFFSET, paddr, PAGE_WRITABLE);
}

PrintKernelSuccess("System: Bootstrap: Mapping kernel stack...\n");
uint64_t stack_phys_start = (uint64_t)kernel_stack & ~0xFFF;
uint64_t stack_phys_end = ((uint64_t)kernel_stack + KERNEL_STACK_SIZE + 0xFFF) & ~0xFFF;

for (uint64_t paddr = stack_phys_start; paddr < stack_phys_end; paddr += PAGE_SIZE) {
BootstrapMapPage(pml4_addr, paddr + KERNEL_VIRTUAL_OFFSET, paddr, PAGE_WRITABLE);
}

PrintKernelSuccess("System: Page tables prepared. Switching to virtual addressing...\n");
const uint64_t new_stack_top = ((uint64_t)kernel_stack + KERNEL_VIRTUAL_OFFSET) + KERNEL_STACK_SIZE;
const uint64_t higher_half_entry = (uint64_t)&KernelMainHigherHalf + KERNEL_VIRTUAL_OFFSET;
EnablePagingAndJump(pml4_addr, higher_half_entry, new_stack_top);
}

static void IRQUnmaskCoreSystems() {
Expand All @@ -396,8 +510,17 @@ static void IRQUnmaskCoreSystems() {
PrintKernelSuccess("System: IRQs unmasked\n");
}

// Enhanced SystemInitS2 function with memory enhancements
static InitResultT SystemInitS2(void) {
// Pre-eXecutionSystem 2
static InitResultT PXS2(void) {
// CPU feature validation
CPUFeatureValidation();

// Memory safety validation
ValidateMemoryLayout();

// Print bootstrap summary
PrintBootstrapSummary();

// Initialize virtual memory manager with validation
PrintKernel("Info: Initializing virtual memory manager...\n");
VMemInit();
Expand Down Expand Up @@ -541,10 +664,8 @@ void KernelMain(const uint32_t magic, const uint32_t info) {
PANIC("Unrecognized Multiboot2 magic.");
}

SystemInitS1(info);

console.buffer = (volatile uint16_t*)VGA_BUFFER_ADDR;

ClearScreen();
PrintKernelSuccess("System: VoidFrame Kernel - Version 0.0.1-beta2 loaded\n");
PrintKernel("Magic: ");
Expand All @@ -553,132 +674,14 @@ void KernelMain(const uint32_t magic, const uint32_t info) {
PrintKernelHex(info);
PrintKernel("\n");

// Create new PML4 with memory validation (ensure identity-mapped physical page)
void* pml4_phys = NULL;
for (int attempt = 0; attempt < 64; attempt++) {
void* candidate = AllocPage();
if (!candidate) break;
if ((uint64_t)candidate < IDENTITY_MAP_SIZE) { pml4_phys = candidate; break; }
FreePage(candidate);
}
if (!pml4_phys) PANIC("Failed to allocate PML4 in identity-mapped memory");

FastZeroPage(pml4_phys);
uint64_t pml4_addr = (uint64_t)pml4_phys;

PrintKernelSuccess("System: Bootstrap: Identity mapping...\n");

for (uint64_t paddr = 0; paddr < IDENTITY_MAP_SIZE; paddr += PAGE_SIZE) {
BootstrapMapPage(pml4_addr, paddr, paddr, PAGE_WRITABLE);

if (paddr / PAGE_SIZE % 32768 == 0) {
PrintKernel(".");
}
}
PrintKernel("\n");

PrintKernelSuccess("System: Bootstrap: Mapping kernel...\n");
uint64_t kernel_start = (uint64_t)_kernel_phys_start & ~0xFFF;
uint64_t kernel_end = ((uint64_t)_kernel_phys_end + 0xFFF) & ~0xFFF;
for (uint64_t paddr = kernel_start; paddr < kernel_end; paddr += PAGE_SIZE) {
BootstrapMapPage(pml4_addr, paddr + KERNEL_VIRTUAL_OFFSET, paddr, PAGE_WRITABLE);
}

PrintKernelSuccess("System: Bootstrap: Mapping kernel stack...\n");
uint64_t stack_phys_start = (uint64_t)kernel_stack & ~0xFFF;
uint64_t stack_phys_end = ((uint64_t)kernel_stack + KERNEL_STACK_SIZE + 0xFFF) & ~0xFFF;

for (uint64_t paddr = stack_phys_start; paddr < stack_phys_end; paddr += PAGE_SIZE) {
BootstrapMapPage(pml4_addr, paddr + KERNEL_VIRTUAL_OFFSET, paddr, PAGE_WRITABLE);
}

PrintKernelSuccess("System: Page tables prepared. Switching to virtual addressing...\n");
const uint64_t new_stack_top = ((uint64_t)kernel_stack + KERNEL_VIRTUAL_OFFSET) + KERNEL_STACK_SIZE;
const uint64_t higher_half_entry = (uint64_t)&KernelMainHigherHalf + KERNEL_VIRTUAL_OFFSET;
EnablePagingAndJump(pml4_addr, higher_half_entry, new_stack_top);
}

static void ValidateMemoryLayout(void) {
PrintKernel("System: Validating memory layout...\n");

const uint64_t kernel_start = (uint64_t)_kernel_phys_start;
const uint64_t kernel_end = (uint64_t)_kernel_phys_end;
const uint64_t kernel_size = kernel_end - kernel_start;

PrintKernel(" Kernel: 0x");
PrintKernelHex(kernel_start);
PrintKernel(" - 0x");
PrintKernelHex(kernel_end);
PrintKernel(" (");
PrintKernelInt(kernel_size / 1024);
PrintKernel(" KB)\n");

// Check for dangerous overlaps
uint64_t stack_start = (uint64_t)kernel_stack;
uint64_t stack_end = stack_start + KERNEL_STACK_SIZE;

if ((stack_start >= kernel_start && stack_start < kernel_end) ||
(stack_end > kernel_start && stack_end <= kernel_end)) {
PrintKernelWarning("[WARNING] Stack overlaps with kernel code\n");
}

// NEW: Check multiboot info location
if (g_multiboot_info_addr >= kernel_start && g_multiboot_info_addr < kernel_end) {
PrintKernelWarning("[WARNING] Multiboot info overlaps with kernel\n");
}

// NEW: Validate virtual address space boundaries
if (VIRT_ADDR_SPACE_START >= KERNEL_SPACE_START) {
PrintKernelError("[ERROR] Virtual address space overlaps with kernel space\n");
}

PrintKernelSuccess("System: Memory layout validated\n");
PXS1(info);
}

static void PrintBootstrapSummary(void) {
PrintKernel("\n[BOOTSTRAP] Summary:\n");

// Count page table pages used
uint64_t pt_pages = 0;
for (uint64_t i = 0x100000 / PAGE_SIZE; i < total_pages; i++) {
if (!IsPageFree(i)) {
uint64_t addr = i * PAGE_SIZE;
// Heuristic: if it's not kernel or stack, likely a page table
if (addr < (uint64_t)_kernel_phys_start ||
addr >= (uint64_t)_kernel_phys_end) {
pt_pages++;
}
}
}

PrintKernel(" Identity mapping: 4GB (");
PrintKernelInt(IDENTITY_MAP_SIZE / (1024 * 1024 * 1024));
PrintKernel("GB)\n");

PrintKernel(" Page tables: ~");
PrintKernelInt(pt_pages);
PrintKernel(" pages (");
PrintKernelInt((pt_pages * PAGE_SIZE) / 1024);
PrintKernel("KB)\n");

PrintKernel(" Bootstrap complete\n");
}


void KernelMainHigherHalf(void) {
PrintKernelSuccess("System: Successfully jumped to higher half. Virtual memory is active.\n");

// CPU feature validation
CPUFeatureValidation();

// Memory safety validation
ValidateMemoryLayout();

// Print bootstrap summary
PrintBootstrapSummary();

// Initialize core systems
SystemInitS2();
PXS2();

PrintKernelSuccess("System: Kernel initialization complete\n");
PrintKernelSuccess("System: Initializing interrupts...\n");
Expand Down