HackMDTerm Project: Improve RISC-V System Emulation of semu
contributed by < hungyuhang, RayChen >
Introduction
System emulation provides a virtual model of a machine (CPU, memory and emulated devices) to run a guest OS. In integrated circuit (IC) design, system emulation plays a significant role during the initial design phase of the chip.
And among those system emulators, semu is a minimalist RISC-V system emulator capable of running Linux the kernel and corresponding userland. But as the term "minimalist" implies, semu does not include some essential peripherals, such as the RTC module.
To improve the system emulation of semu, we add a simple RTC module. The implementations are in the following repositories:
For repository hungyuhang/semu, the code is implemented in the rtc_feature branch.
And the precompiled image of our custom Linux is provided below:
Implementation
We choose LupIO real-time clock (RTC) as the RTC module to emulate, since it is easy for software/hardware adaptation because there are already implementations of the LupIO RTC in lupV and lupio/linux.
Hardware
1. Real-time Clock Device
We chose to port the real-time clock to semu due to its limited functions, minimizing dependencies and reducing the likelihood of encountering bugs during the porting process.
lupV Implementation - rtc.c
Below is the code for the real-time clock(RTC) in lupV:
semu Implementation - rtc.c
To align with the architecture of semu, we have designated lupio_rtc_read as the entry point, with the implementation details housed in lupio_rtc_reg_read. In this document, the register size is specified as 8 bits, thus the entry point's width is set to RV_MEM_LBU. Below is the implementation of the lupio_rtc_read function in semu.
The modification to lupio_rtc_write involves adding the entry point lupio_rtc_write, while the implementation remains printing text in the original lupV code. Therefore, in semu, we opted to return void.The lupio_rtc_write code is as follows:
semu Implementation - main.c
main.c file has four sections that need to be modified, including interrupt handling and memory read/write. The code is as follows:
2. Device Tree
lupV Implementation - machine.c
In lupV, the dynamic generation of the device tree is implemented by generate_dtb function as shown below:
semu Implementation - minimal.dts
In semu, we write a DTS (Device Tree Source) file, and the code is as follows:
Softwate
1. Building the Linux Kernel with Custom RTC Driver
For Linux to use the RTC module we implemented, we need to add a corresponding driver into the Linux kernel.
In order to add the custom RTC driver, I create a custom Linux source code repository linux_for_semu, and replace the Linux repository in build-image.sh by linux_for_semu. This script will run when using $ make build-image to build the image.
In linux_for_semu, I apply the following modifications to add the RTC module:
- Create a directory
lupioinsidedrivers(which is in the Linux source code) for the RTC driver and putrtc.cinside this directory. - Create one Makefile inside the directory
drivers/lupioand inside it put the lineobj-$(CONFIG_LUPIO_RTC) += rtc.oand save this file. - Create one Kconfig file inside the directory
drivers/lupioand inside it put: - Save the file in step 3.
- Add both Makefile and Kconfig file in the Linux source drivers Makefile and Kconfig file which are at
drivers/Makefileanddrivers/Kconfig - In the Makefile add below:
obj-$(CONFIG_LUPIO) += lupio/ - In Kconfig file add below:
source "drivers/lupio/Kconfig" - In
arch/riscv/Kconfig.socsadd below: - Finally in
linux.config, which is in thesemurepository, modify the settings below:
2. Check if Linux Kernel Can Use RTC Module
We will use date command to validate the RTC module.
Use $ date to read the current time.
Use $ date YYYY.MM.DD-hh:mm:ss to write the time.
Since writing data to RTC module is not implemented, we will only test read time function.
When using the date command on lupV, the system returns the current time:
But when using the date command on the original semu, the system only returns the default time:
Issues Encountered
After writing the RTC code, we run the emulator, but the emulator did not run properly.
Below is the error message:
From the message above, we can see that the emulator issues a Load address misaligned error. And the instruction which causes the issue is at address 0xc01f549c
To check the issue, I use the following command to dump the disassembly of the Linux image:
path/to/buildrootis the directory of the toolchain which builds the Linux kernel.
In the disassembly code, there is no address 0xc01f549c, but the instruction at 0x1f549c is the compiled instruction in function lupio_rtc_read_time(). So I assumed that 0x1f549c is the address that epc stored.
And below are the instructions around 0x1f549c:
From the disassembly, we can see that 0x1f549c is a lb instruction. And this instruction causes the exception.
By tracing the code of semu, we find the root cause.
Below is the original code of lupio_rtc_read() in rtc.c:
We can see when using lb instruction to access the RTC module, the width variable in the code above will equals to RV_MEM_LB, which will cause an exception.
And here is the code after modification:
After this modification, the RTC emulation code can handle both lb and lbu instruction access.
Result
After solving the issue above, I run the date command to check the time, and below is the result:
The Linux OS get the date from the RTC module successfully.
If you want run hungyuhang/semu to see the result, you can simply run the same commands as the original semu($ make and $ make check). The Makefile script will download the correct prebuild Linux image file with the RTC driver in it.
