Implementing a hypervisor on RISC-V with Rust using the 1.0 hypervisor extension

Abstract

Formålet med denne avhandlingen er å undersøke og implementere den nye hypervisorutvidelsen for RISC-V, som ble ratifisert i spesifikasjonen i november 2021. Den sentrale implementeringen oppnås ved å implementere en hypervisor og en gjestekjerne skrevet i Rust, for å undersøke dens levedyktighet som et systemprogrammeringsspråk. Den resulterende implementeringen kjører en hypervisor med QEMU og virtualiserer en supervisor-gjestekjerne, hvor det er et hypercall-grensesnitt for SBI klokke kall og virtuelt minne som kartlegger fysiske enheter som UART. Det er imidlertid noen begrensninger: hypervisoren kan ikke virtualisere mer enn én gjest, og virtuelt gjesteminne fungerer ikke som forventet. Og er dermed ikke i stand til å virtualisere mer komplekse gjestekjerner som f.eks. operativsystemer. På grunn av dette, og at den kjørte på en simulator, var det kun mulig å danne en sammenligning basert på en statisk analyse utført på eldre hypervisorer skrevet før spesifikasjonen for utvidelsen ble ratifisert, da det ikke var mulig å samle inn numeriske data. Det er imidlertid fortsatt mulig å si at den nye hypervisorutvidelsen er et verdifullt tillegg, som reduserer programvarekompleksiteten og gjør det lettere å utvikle hypervisorer på arkitekturen. Erfaring fra skrivingen av hypervisoren viser at Rust som programmeringsspråk på systemnivå har mange potensialer, men at det fortsatt er et stykke igjen før det kan bli en pålitelig erstatning for andre industristandarder som C.

This thesis aims to explore and implement the new hypervisor extension for RISC-V, ratified into the specification in November 2021. The core implementation is achieved by implementing a hypervisor and guest kernel written in Rust to explore its viability as a system programming language. The resulting implementation runs a hypervisor with QEMU, virtualizing a supervisor guest kernel where a hypercall interface exists for SBI timer calls and virtual memory mapping physical devices like UART. However, some limitations exist: the hypervisor cannot virtualize more than one guest, and guest virtual memory does not work as expected. And thus it is not able to virtualize more complex guest kernels like operating systems. Due to this, and it was running on a simulator, it was only possible to form a comparison based on a static analysis performed on older hypervisors written before the specification for the extension was ratified since it was not possible to gather numerical data. However, it is still possible to say that the new hypervisor extension is a valuable addition which reduces software complexity and makes hypervisors easier to develop on the architecture. Experiences from writing the hypervisor show that Rust as a system-level programming language has a lot of potentials but still has some way to go before it can become a reliable replacement for other industry standards like C.