Hypervisor and Memory Management

Core Functions

init()

Initializes the hypervisor for all processor cores.

Returns: vmxroot_error_t

Example:

ScyHV::vmxroot_error_t result = Styx::init();
if (result == STY_SUCCESS) {
    std::cout << "Hypervisor initialized successfully" << std::endl;
}

initPTB()

Initializes the Page Table Base.

Returns: bool

Example:

if (Styx::initPTB()) {
    std::cout << "Page Table Base initialized successfully" << std::endl;
}

my_dtb()

Retrieves the current Directory Table Base.

Returns: guest_phys_t

Example:

ScyHV::guest_phys_t dtb = Styx::my_dtb();
std::cout << "Current DTB: 0x" << std::hex << dtb << std::endl;

Memory Operations

translate(guest_virt_t virt_addr)

Translates a guest virtual address to a guest physical address.

Parameters:

• virt_addr: Guest virtual address

Returns: guest_phys_t

Example:

ScyHV::guest_virt_t virt_addr = 0x7FFE0000;
ScyHV::guest_phys_t phys_addr = Styx::translate(virt_addr);
std::cout << "Physical address: 0x" << std::hex << phys_addr << std::endl;

read_phys(guest_phys_t phys_addr, guest_virt_t buffer, u64 size)

Reads from physical memory.

Parameters:

• phys_addr: Physical address to read from

• buffer: Buffer to store read data

• size: Number of bytes to read

Returns: vmxroot_error_t

Example:

char buffer[1024];
ScyHV::guest_phys_t phys_addr = 0x1000;
ScyHV::vmxroot_error_t result = Styx::read_phys(phys_addr, (ScyHV::guest_virt_t)buffer, sizeof(buffer));
if (result == STY_SUCCESS) {
    std::cout << "Read successful" << std::endl;
}

write_phys(guest_phys_t phys_addr, guest_virt_t buffer, u64 size)

Writes to physical memory.

Parameters:

• phys_addr: Physical address to write to

• buffer: Buffer containing data to write

• size: Number of bytes to write

Returns: vmxroot_error_t

Example:

char data[] = "Hello, World!";
ScyHV::guest_phys_t phys_addr = 0x2000;
ScyHV::vmxroot_error_t result = Styx::write_phys(phys_addr, (ScyHV::guest_virt_t)data, strlen(data));
if (result == STY_SUCCESS) {
    std::cout << "Write successful" << std::endl;
}

read_km(void* dst, void* src, size_t size)

Reads from kernel memory.

Parameters:

• dst: Destination buffer

• src: Source address in kernel memory

• size: Number of bytes to read

Example:

char buffer[1024];
void* kernel_addr = (void*)0xFFFF8000000000;
Styx::read_km(buffer, kernel_addr, sizeof(buffer));

write_km(void* dst, void* src, size_t size)

Writes to kernel memory.

Parameters:

• dst: Destination address in kernel memory

• src: Source buffer

• size: Number of bytes to write

Example:

char data[] = "Kernel data";
void* kernel_addr = (void*)0xFFFF8000001000;
Styx::write_km(kernel_addr, data, strlen(data));

copy_virt(guest_phys_t dirbase_src, guest_virt_t virt_src, guest_phys_t dirbase_dest, guest_virt_t virt_dest, u64 size)

Copies memory between virtual addresses.

Parameters:

• dirbase_src: Source directory base

• virt_src: Source virtual address

• dirbase_dest: Destination directory base

• virt_dest: Destination virtual address

• size: Number of bytes to copy

Returns: vmxroot_error_t

Example:

ScyHV::guest_phys_t src_dirbase = 0x1000;
ScyHV::guest_virt_t src_virt = 0x7FFE0000;
ScyHV::guest_phys_t dest_dirbase = 0x2000;
ScyHV::guest_virt_t dest_virt = 0x7FFF0000;
ScyHV::u64 size = 1024;

ScyHV::vmxroot_error_t result = Styx::copy_virt(src_dirbase, src_virt, dest_dirbase, dest_virt, size);
if (result == STY_SUCCESS) {
    std::cout << "Virtual memory copy successful" << std::endl;
}