Creating a Fake Medium for QEMU Boot in a Modern (UEFI, Rust) Ventoy Replacement

In this article, we will discuss how to create a fake Medium QEMU boot using UEFI and Rust, as a potential replacement for Ventoy. This involves creating a bootabledrive with two partitions: a small FAT32 partition for the bootloader, and anextended partition for the rest of the data.

Why Create a Fake Medium QEMU Boot?

Creating a fake Medium QEMU boot can be useful for a variety of reasons. For example, it can be used for testing purposes, or as a replacement for Ventoy, a popular tool for creating bootable USB drives. By building our own solution, we can customize it to fit our specific needs.

Prerequisites

To follow along with this tutorial, you will need the following:

• A machine with Rust installed
• The QEMU emulator

Creating the Boot Partition

To create the boot partition, we will use the fdisk tool to partition the drive. This will create a small FAT32 partition that will contain the bootloader.

fdisk /dev/sdX
 n
 p
 1

 +512M
 t
 c
 a
 1
 w

Replace /dev/sdX with the drive you want to use. This will create a 512MB FAT32 partition, which is sufficient for our needs. Next, we will format the partition using the mkfs.fat tool:

mkfs.fat -F 32 /dev/sdX1

Creating the Bootloader

To create the bootloader, we will use the uefi-rs library to create a simple UEFI application that will display a message and then exit. This can be done using the following Rust code:

use uefi::prelude::*;
 use uefi::proto::console::Console;
 use uefi::table::boot::Boot;

 #[entry]
 fn main(_: Boot, mut handle: Handle, mut system_table: SystemTable) -> ! {
 let console = system_table
 .get_console()
 .ok_or("No console found")?;

 console
 .output_string("Hello, world!
")
 .map_err(|_| "Failed to output string")?;

 handle.exit(uefi::ExitStatus::Success)
 }

This code creates a simple UEFI application that outputs the message "Hello, world!" to the console and then exits. To compile this code, you can use the following command:

rustc --target=x86_64-unknown-uefi --crate-type=staticlib bootloader.rs

Installing the Bootloader

Once the bootloader has been compiled, we can install it to the boot partition using the dd tool:

dd if=target/x86_64-unknown-uefi/debug/bootloader.efi of=/dev/sdX1

Testing the Bootloader

To test the bootloader, we can use QEMU to emulate a system:

qemu-system-x86_64 -drive if=none,id=hd,file=/dev/sdX,format=raw,detect-zeroes=on -device ide-hd,drive=hd -m 1024 -serial mon:stdio

This will start QEMU and use the emulated drive to boot the system. If everything has been set up correctly, you should see the "Hello, world!" message displayed on the console.

In this article, we have discussed how to create a fake Medium QEMU boot using UEFI and Rust. This involves creating a bootable drive with two partitions: a small FAT32 partition for the bootloader, and an extended partition for the rest