I think it can if it do not need too invasive and global changes to Haiku kernel. First some detailed discussion is needed about necessary kernel features and kernel <-> VM communication protocol.

Basic idea is:

RVVM sets up emulation as usual (JIT is not needed, thus only interpreter is used)
For each vCPU, RVVM creates a U-mode context that is entirely for it's disposal. This context should not have access to Haiku syscalls nor have anything mapped into it's address space (even in the upper half).
Upon running the vCPU, RVVM copies the U-mode CPU state (int/fp registers and fcsr) from rvvm_hart_t struct into it's respective U-mode "runner" context on the host
On any pagefault, ecall or instruction exception the "runner" context stops and returns control to RVVM vCPU thread. RVVM copies back vCPU state into rvvm_hart_t and interprets the faulting instruction as usual.
On TLB refill, RVVM actually shares a host page mapping of the guest physical memory into the "runner" context address space. TLB flushes flush the "runner" context address space mappings, partially/fully. Ideally ASID support should minimize the amount of misses to this shadow pagetable.
Afterwards execution returns into this "runner" context and we are at step 3 again

This approach generally allows fully native execution, with the following downsides compared to full H-ext virtualization:

Shadow pagetable is used which will have an observable perf penalty for memory access & context switches. However, this cost is much less than a soft TLB approach used right now, and can be further improved with proper ASID support.
Any privileged instruction will be still interpreted

My initial idea of VM<->kernel interface (Pseudocode, this can really be implemented as a syscall or ioctl or whatever):

// Creates a shadow pagetable, destroy with close()
int vm_pgt_create();

// Shares memory from a usual process into the shadow pagetable
// Can be replaced with mmap-like interface that accepts a FD if that makes things simpler, but this approach seems more extensible
int vcpu_map_pages(int pgt_fd, size_t va, void* uptr, size_t size);

int vcpu_unmap_pages(int pgt_fd, size_t va, size_t size);

struct vcpu_runner_state {
    size_t pc;
    size_t gpr[31];
    double fpr[32];
    size_t fcsr;
};

// Accepts initial vCPU U-mode state & shadow pagetable handle for address space
// Runs the vCPU until any kind of exception, modifies vcpu_state post execution
// This design allows vCPU entry/exit & state manipulation in a single syscall
int vcpu_run(int pgt_fd, struct vcpu_runner_state* vcpu_state);

Tianocore EDK2 UEFI firmware support #134

Description

Metadata

Metadata

Assignees

Labels

Projects

Milestone

Relationships

Development

Issue actions