universalisos/kernel/vm.cpp

/*
 * Universalisos VM Context Implementation - Stage 3
 * PikeOS 5.0 Feature Parity - Virtual Machine Context
 *
 * Stage 3: Memory Management + VM Context Switching
 * Author: PortugalFuturista Hypervisor Development Team
 * Version: 1.0.0
 */

#include "vm.h"
#include "mm.h"
#include "arch/arm/uart.h"
#include <stdint.h>

// Global hypervisor VM state
static hypervisor_vm_state_t g_hypervisor_vm_state = {
    .vms = {},
    .vm_count = 0,
    .current_vm = nullptr,
    .vm_id_bitmap = 0
};

/**
 * Initialize VM Management System
 */
extern "C" void vm_init(void) {
    uart_puts("VM: Initializing VM Management System\n");

    // Initialize VM state
    g_hypervisor_vm_state.vm_count = 0;
    g_hypervisor_vm_state.current_vm = nullptr;
    g_hypervisor_vm_state.vm_id_bitmap = 0;

    // Clear VM array
    for (int i = 0; i < MAX_VMS; i++) {
        g_hypervisor_vm_state.vms[i] = nullptr;
    }

    uart_puts("VM: VM Management System initialized\n");
    uart_puts("VM: Maximum VMs: ");
    uart_print_dec(MAX_VMS);
    uart_puts("\n");
}

/**
 * Create new VM context
 */
extern "C" vm_context_t* vm_create(const vm_config_t* config) {
    if (!config) {
        uart_puts("VM: Invalid config for VM creation\n");
        return nullptr;
    }

    // Find free VM ID
    uint32_t vm_id = 0;
    for (int i = 0; i < MAX_VMS; i++) {
        if (!(g_hypervisor_vm_state.vm_id_bitmap & (1U << i))) {
            vm_id = i;
            break;
        }
    }

    if (vm_id >= MAX_VMS) {
        uart_puts("VM: No free VM IDs available\n");
        return nullptr;
    }

    uart_puts("VM: Creating VM '");
    uart_puts(config->vm_name);
    uart_puts("' (ID ");
    uart_print_dec(vm_id);
    uart_puts(")\n");

    // Allocate VM context
    static vm_context_t vm_contexts[MAX_VMS];
    vm_context_t* vm = &vm_contexts[vm_id];

    // Initialize VM context
    vm->vm_id = vm_id;
    vm->vm_name = config->vm_name;
    vm->state = VM_STATE_STOPPED;
    vm->asil_level = config->asil_level;

    // Initialize CPU registers to default values
    vm->cpu_regs.r0 = 0;
    vm->cpu_regs.r1 = 0;
    vm->cpu_regs.r2 = 0;
    vm->cpu_regs.r3 = 0;
    vm->cpu_regs.r4 = 0;
    vm->cpu_regs.r5 = 0;
    vm->cpu_regs.r6 = 0;
    vm->cpu_regs.r7 = 0;
    vm->cpu_regs.r8 = 0;
    vm->cpu_regs.r9 = 0;
    vm->cpu_regs.r10 = 0;
    vm->cpu_regs.r11 = 0;
    vm->cpu_regs.r12 = 0;
    vm->cpu_regs.sp = config->stack_pointer;
    vm->cpu_regs.lr = 0;
    vm->cpu_regs.pc = config->entry_point;
    vm->cpu_regs.cpsr = 0x000000D3; // Supervisor mode, IRQ/FIQ disabled
    vm->cpu_regs.spsr = 0x000000D3;

    // Initialize system registers
    vm->sys_regs.sctlr = 0;
    vm->sys_regs.actlr = 0;
    vm->sys_regs.cpacr = 0;
    vm->sys_regs.ttbr0 = 0;
    vm->sys_regs.ttbr1 = 0;
    vm->sys_regs.ttbcr = 0;
    vm->sys_regs.dacr = 0;
    vm->sys_regs.dfsr = 0;
    vm->sys_regs.dfar = 0;
    vm->sys_regs.ifsr = 0;
    vm->sys_regs.ifar = 0;
    vm->sys_regs.iciallu = 0;
    vm->sys_regs.bpiall = 0;

    // Initialize FPU context
    for (int i = 0; i < 64; i++) {
        vm->fpu_ctx.fp_regs[i] = 0;
    }
    vm->fpu_ctx.fpscr = 0;

    // Create page table for VM
    vm->page_table = mm_create_page_table(vm_id);

    // Create memory domain for VM
    char domain_name[64];
    // Simple domain name generation
    domain_name[0] = 'V';
    domain_name[1] = 'M';
    domain_name[2] = '0' + (vm_id / 10);
    domain_name[3] = '0' + (vm_id % 10);
    domain_name[4] = '\0';

    vm->domain = mm_create_domain(vm_id, domain_name);

    // Set memory configuration
    vm->memory_base = 0x10000000 + (vm_id * 0x10000000); // 256MB per VM
    vm->memory_size = config->memory_size;

    // Set scheduling parameters
    vm->priority = 8; // Default priority
    vm->time_quota_us = 10000; // 10ms default quota
    vm->time_used_us = 0;

    // Initialize statistics
    vm->stats.total_run_time = 0;
    vm->stats.context_switches = 0;
    vm->stats.page_faults = 0;
    vm->stats.exceptions = 0;
    vm->stats.interrupts = 0;

    // Initialize safety flags
    vm->enable_safety_checks = true;
    vm->safety_violation = false;

    // Initialize error state
    vm->last_error = 0;
    vm->error_message = nullptr;

    // Add VM to hypervisor state
    g_hypervisor_vm_state.vms[vm_id] = vm;
    g_hypervisor_vm_state.vm_id_bitmap |= (1U << vm_id);
    g_hypervisor_vm_state.vm_count++;

    uart_puts("VM: VM created successfully\n");
    return vm;
}

/**
 * Destroy VM context
 */
extern "C" void vm_destroy(vm_context_t* vm) {
    if (!vm) return;

    uart_puts("VM: Destroying VM '");
    uart_puts(vm->vm_name);
    uart_puts("'\n");

    // Destroy page table
    if (vm->page_table) {
        mm_destroy_page_table(vm->page_table);
        vm->page_table = nullptr;
    }

    // Destroy memory domain
    if (vm->domain) {
        mm_destroy_domain(vm->domain);
        vm->domain = nullptr;
    }

    // Remove VM from hypervisor state
    g_hypervisor_vm_state.vms[vm->vm_id] = nullptr;
    g_hypervisor_vm_state.vm_id_bitmap &= ~(1U << vm->vm_id);
    g_hypervisor_vm_state.vm_count--;

    vm->state = VM_STATE_DESTROYED;

    uart_puts("VM: VM destroyed\n");
}

/**
 * Start VM execution
 */
extern "C" int vm_start(vm_context_t* vm) {
    if (!vm || vm->state != VM_STATE_STOPPED) {
        uart_puts("VM: Cannot start VM - invalid state\n");
        return -1;
    }

    uart_puts("VM: Starting VM '");
    uart_puts(vm->vm_name);
    uart_puts("'\n");

    vm->state = VM_STATE_STARTING;

    // In Stage 3, we just mark as running
    // Full implementation would perform actual context switch
    vm->state = VM_STATE_RUNNING;

    uart_puts("VM: VM started\n");
    return 0;
}

/**
 * Stop VM execution
 */
extern "C" int vm_stop(vm_context_t* vm) {
    if (!vm) return -1;

    uart_puts("VM: Stopping VM '");
    uart_puts(vm->vm_name);
    uart_puts("'\n");

    vm->state = VM_STATE_STOPPED;

    uart_puts("VM: VM stopped\n");
    return 0;
}

/**
 * Suspend VM execution
 */
extern "C" int vm_suspend(vm_context_t* vm) {
    if (!vm || vm->state != VM_STATE_RUNNING) {
        return -1;
    }

    uart_puts("VM: Suspending VM '");
    uart_puts(vm->vm_name);
    uart_puts("'\n");

    vm->state = VM_STATE_SUSPENDED;

    uart_puts("VM: VM suspended\n");
    return 0;
}

/**
 * Resume VM execution
 */
extern "C" int vm_resume(vm_context_t* vm) {
    if (!vm || vm->state != VM_STATE_SUSPENDED) {
        return -1;
    }

    uart_puts("VM: Resuming VM '");
    uart_puts(vm->vm_name);
    uart_puts("'\n");

    vm->state = VM_STATE_RUNNING;

    uart_puts("VM: VM resumed\n");
    return 0;
}

/**
 * Get VM context by ID
 */
extern "C" vm_context_t* vm_get_by_id(uint32_t vm_id) {
    if (vm_id >= MAX_VMS) {
        return nullptr;
    }

    return g_hypervisor_vm_state.vms[vm_id];
}

/**
 * Get current running VM
 */
extern "C" vm_context_t* vm_get_current(void) {
    return g_hypervisor_vm_state.current_vm;
}

/**
 * Get VM state as string
 */
extern "C" const char* vm_state_string(vm_state_t state) {
    switch (state) {
        case VM_STATE_STOPPED: return "STOPPED";
        case VM_STATE_STARTING: return "STARTING";
        case VM_STATE_RUNNING: return "RUNNING";
        case VM_STATE_SUSPENDED: return "SUSPENDED";
        case VM_STATE_BLOCKED: return "BLOCKED";
        case VM_STATE_ERROR: return "ERROR";
        case VM_STATE_DESTROYED: return "DESTROYED";
        default: return "UNKNOWN";
    }
}

/**
 * Get ASIL level as string
 */
extern "C" const char* asil_level_string(asil_level_t level) {
    switch (level) {
        case ASIL_NONE: return "NONE";
        case ASIL_QM: return "QM";
        case ASIL_A: return "A";
        case ASIL_B: return "B";
        case ASIL_C: return "C";
        case ASIL_D: return "D";
        default: return "UNKNOWN";
    }
}

/**
 * VM Context Switch
 * Save current VM context and restore next VM context
 */
extern "C" void vm_context_switch(vm_context_t* from_vm, vm_context_t* to_vm) {
    uart_puts("VM: Context switch from '");
    uart_puts(from_vm ? from_vm->vm_name : "none");
    uart_puts("' to '");
    uart_puts(to_vm ? to_vm->vm_name : "none");
    uart_puts("'\n");

    if (from_vm) {
        // Save from_vm context
        vm_save_cpu_context(from_vm);
        vm_save_system_context(from_vm);
        vm_save_fpu_context(from_vm);

        from_vm->state = VM_STATE_SUSPENDED;
        from_vm->stats.context_switches++;
    }

    if (to_vm) {
        // Restore to_vm context
        vm_restore_cpu_context(to_vm);
        vm_restore_system_context(to_vm);
        vm_restore_fpu_context(to_vm);

        to_vm->state = VM_STATE_RUNNING;
        to_vm->stats.context_switches++;

        g_hypervisor_vm_state.current_vm = to_vm;
    } else {
        g_hypervisor_vm_state.current_vm = nullptr;
    }

    uart_puts("VM: Context switch complete\n");
}

/**
 * Save VM CPU context
 */
extern "C" void vm_save_cpu_context(vm_context_t* vm) {
    if (!vm) return;

    // In Stage 3, this is a framework demonstration
    // Full implementation would use inline assembly to save registers
    uart_puts("VM: Saving CPU context for '");
    uart_puts(vm->vm_name);
    uart_puts("'\n");
}

/**
 * Restore VM CPU context
 */
extern "C" void vm_restore_cpu_context(vm_context_t* vm) {
    if (!vm) return;

    // In Stage 3, this is a framework demonstration
    // Full implementation would use inline assembly to restore registers
    uart_puts("VM: Restoring CPU context for '");
    uart_puts(vm->vm_name);
    uart_puts("'\n");
}

/**
 * Save VM system registers
 */
extern "C" void vm_save_system_context(vm_context_t* vm) {
    if (!vm) return;

    // Save system registers via coprocessor interface
    __asm__ volatile("mrc p15, 0, %0, c1, c0, 0" : "=r"(vm->sys_regs.sctlr)); // SCTLR
    __asm__ volatile("mrc p15, 0, %0, c2, c0, 0" : "=r"(vm->sys_regs.ttbr0)); // TTBR0
    __asm__ volatile("mrc p15, 0, %0, c2, c0, 1" : "=r"(vm->sys_regs.ttbr1)); // TTBR1
    __asm__ volatile("mrc p15, 0, %0, c3, c0, 0" : "=r"(vm->sys_regs.dacr));  // DACR

    uart_puts("VM: System context saved for '");
    uart_puts(vm->vm_name);
    uart_puts("'\n");
}

/**
 * Restore VM system registers
 */
extern "C" void vm_restore_system_context(vm_context_t* vm) {
    if (!vm) return;

    // Restore system registers via coprocessor interface
    __asm__ volatile("mcr p15, 0, %0, c1, c0, 0" : : "r"(vm->sys_regs.sctlr)); // SCTLR
    __asm__ volatile("mcr p15, 0, %0, c2, c0, 0" : : "r"(vm->sys_regs.ttbr0)); // TTBR0
    __asm__ volatile("mcr p15, 0, %0, c2, c0, 1" : : "r"(vm->sys_regs.ttbr1)); // TTBR1
    __asm__ volatile("mcr p15, 0, %0, c3, c0, 0" : : "r"(vm->sys_regs.dacr));  // DACR

    uart_puts("VM: System context restored for '");
    uart_puts(vm->vm_name);
    uart_puts("'\n");
}

/**
 * Save VM FPU context
 */
extern "C" void vm_save_fpu_context(vm_context_t* vm) {
    if (!vm) return;

    // In Stage 3, this is a framework demonstration
    // Full implementation would save VFP/NEON registers
    uart_puts("VM: FPU context saved for '");
    uart_puts(vm->vm_name);
    uart_puts("'\n");
}

/**
 * Restore VM FPU context
 */
extern "C" void vm_restore_fpu_context(vm_context_t* vm) {
    if (!vm) return;

    // In Stage 3, this is a framework demonstration
    // Full implementation would restore VFP/NEON registers
    uart_puts("VM: FPU context restored for '");
    uart_puts(vm->vm_name);
    uart_puts("'\n");
}

/**
 * Validate VM configuration
 */
extern "C" bool vm_validate_config(const vm_config_t* config) {
    if (!config) {
        uart_puts("VM: Invalid config (null)\n");
        return false;
    }

    if (!config->vm_name) {
        uart_puts("VM: Invalid config (no name)\n");
        return false;
    }

    if (config->memory_size == 0) {
        uart_puts("VM: Invalid config (no memory)\n");
        return false;
    }

    if (config->num_vcpus == 0) {
        uart_puts("VM: Invalid config (no vCPUs)\n");
        return false;
    }

    uart_puts("VM: Configuration validated\n");
    return true;
}

/**
 * Print VM information
 */
extern "C" void vm_print_info(vm_context_t* vm) {
    if (!vm) return;

    uart_puts("\n=== VM Information ===\n");
    uart_puts("VM Name: ");
    uart_puts(vm->vm_name);
    uart_puts("\n");

    uart_puts("VM ID: ");
    uart_print_dec(vm->vm_id);
    uart_puts("\n");

    uart_puts("State: ");
    uart_puts(vm_state_string(vm->state));
    uart_puts("\n");

    uart_puts("ASIL Level: ");
    uart_puts(asil_level_string(vm->asil_level));
    uart_puts("\n");

    uart_puts("Memory Size: ");
    uart_print_dec(vm->memory_size / (1024 * 1024));
    uart_puts(" MB\n");

    uart_puts("Priority: ");
    uart_print_dec(vm->priority);
    uart_puts("\n");

    uart_puts("Time Quota: ");
    uart_print_dec(vm->time_quota_us);
    uart_puts(" us\n");

    uart_puts("=======================\n");
}

/**
 * Print VM statistics
 */
extern "C" void vm_print_statistics(vm_context_t* vm) {
    if (!vm) return;

    uart_puts("\n=== VM Statistics ===\n");
    uart_puts("VM: ");
    uart_puts(vm->vm_name);
    uart_puts("\n");

    uart_puts("Total Run Time: ");
    uart_print_dec(vm->stats.total_run_time);
    uart_puts(" us\n");

    uart_puts("Context Switches: ");
    uart_print_dec(vm->stats.context_switches);
    uart_puts("\n");

    uart_puts("Page Faults: ");
    uart_print_dec(vm->stats.page_faults);
    uart_puts("\n");

    uart_puts("Exceptions: ");
    uart_print_dec(vm->stats.exceptions);
    uart_puts("\n");

    uart_puts("Interrupts: ");
    uart_print_dec(vm->stats.interrupts);
    uart_puts("\n");

    uart_puts("======================\n");
}

/**
 * Print all VMs
 */
extern "C" void vm_print_all_vms(void) {
    uart_puts("\n=== All Virtual Machines ===\n");
    uart_puts("Total VMs: ");
    uart_print_dec(g_hypervisor_vm_state.vm_count);
    uart_puts("\n\n");

    for (int i = 0; i < MAX_VMS; i++) {
        if (g_hypervisor_vm_state.vms[i]) {
            vm_print_info(g_hypervisor_vm_state.vms[i]);
        }
    }

    uart_puts("=============================\n");
}

/**
 * Simple demonstration of VM functionality
 */
extern "C" void vm_demo(void) {
    uart_puts("\n=== VM Management Demonstration ===\n");

    // Create VM configurations
    vm_config_t config1 = {
        .vm_name = "Safety-Critical VM",
        .vm_id = 0,
        .num_vcpus = 1,
        .memory_size = 64 * 1024 * 1024, // 64MB
        .num_devices = 2,
        .asil_level = ASIL_D,
        .enable_isolation = true,
        .entry_point = 0x10000,
        .stack_pointer = 0x8000
    };

    vm_config_t config2 = {
        .vm_name = "Linux Guest",
        .vm_id = 1,
        .num_vcpus = 2,
        .memory_size = 128 * 1024 * 1024, // 128MB
        .num_devices = 4,
        .asil_level = ASIL_QM,
        .enable_isolation = true,
        .entry_point = 0x10000,
        .stack_pointer = 0x8000
    };

    // Validate and create VMs
    if (vm_validate_config(&config1)) {
        vm_context_t* vm1 = vm_create(&config1);
        if (vm1) {
            vm_start(vm1);
            vm_print_info(vm1);
        }
    }

    if (vm_validate_config(&config2)) {
        vm_context_t* vm2 = vm_create(&config2);
        if (vm2) {
            vm_start(vm2);
            vm_print_info(vm2);
        }
    }

    // Demonstrate context switch
    vm_context_t* vm1 = vm_get_by_id(0);
    vm_context_t* vm2 = vm_get_by_id(1);

    if (vm1 && vm2) {
        uart_puts("\n=== Testing Context Switch ===\n");
        vm_context_switch(vm1, vm2);
        vm_context_switch(vm2, vm1);
    }

    // Print all VMs
    vm_print_all_vms();

    uart_puts("=== End VM Management Demonstration ===\n");
}

/**
 * Initialize VM system and run demonstration
 */
extern "C" void vm_init_and_demo(void) {
    vm_init();
    vm_demo();
}