Emulating Raspberry Pi with QEMU (2023)

introduction
Download the Raspberry Pi operating system
QEMU
-Installation
-Creating images of the Raspberry Pi operating system
-Boot Raspberry Pi OS on QEMU
SD card size has been increased to around 8GB
Connect to Raspberry Pi OS via SSH
-Habilitar SSH no Raspberry Pi
-Connection to Rpi via SSH (with password)
-Connection to Rpi via SSH (no password)
references

Well, a simple internet search yields so many links, so let me leave a few things out.

As you have already seen, the steps for such an emulation. None of them really worked for me directly, so here are the steps that worked.

These instructions can be executed on a native Linux system or on aSubsistema do Windows para Linux (WSL)🇧🇷 They cannot run on Windows.

Download and unzip the Raspberry Pi OS

Download the Rapberry Pi operating system fromhere🇧🇷 I chose the Raspberry Pi OS 32-bit lite edition because I only need to work in the terminal. Of course, everything mentioned below also works for the desktop edition.

curl <link-to-raspios> -o raspios.img.xz
xz -dk raspios.img.xz # Let's keep the consistency of the original image
# after unpacking

Mount the image to a specific mount directory

sudo mkdir /mnt/rpi
sudo losetup -f --show -P $(pwd)/raspios.img
sudo mount /dev/loop<no>p1 /mnt/rpi

Extract the kernel and all dtb files from the image

mkdir dtbs
cp /mnt/rpi/nucleo* .
cp /mnt/rpi/*.dtb dtbs

Remove the password for user "pi".

The latest versions ofRaspberry Pi OS no longer has default username and password combination like pi - raspberry🇧🇷 According to the documentation, the Raspberry Pi operating system also allows you to set the default password for the image you write.

Since in our case we manually downloaded the created image directly, we did not set a default password.

So since we mounted the kernel partition above, let's simply mount the Raspberry Pi root fs:

sudo umount /mnt/rpi
sudo mount /dev/loop<no>p2 /mnt/rpi

edit the file/mnt/rpi/etc/passwordto clear password for user "pi":

sudo vi /mnt/rpi/etc/passwd

Look for this line in the file:

pi : x : 1000 : 1000 : , , : / start / pi : / bin / bash

and remove the 'x' after "pi:". Now save the file. By doing this you simply made it easier for us to log into the Raspberry Pi OS once QEMU boots with it. The line should now look like this:

pi::1000:1000:,,,:/start/pi:/bin/bash

Unmount image - you won't need it anymore

sudo umount /mnt/rpi
sudo losetup -d /dev/loop<nr>

Installation

Installing Qemu usually involves installing multiple packages on a Linux distribution. On Windows, a single download completely installs Qemu.

Typically, on Linux distributions, the following packages are required (tested on OpenSUSE, but these names are on Ubuntu as well):

sudo zypper instalar qemu qemu-arm qemu-tools

Building a QEMU Compatible Raspberry Pi OS Image

The Rpi image we downloaded above is a raw format image. Converting to qcow2 format makes it very efficient when used with QEMU and also takes up less space on the host computer.

In addition, we also increased the SD card size to 8GB so that we can use all the space to install additional software at runtime.

### Convert raw image to QEMU qcow2 format
qemu-img convert -f raw -O qcow2 raspios.img raspios.qcow### Resize the image to 8 GB (should be a power of two)
qemu-img redimensioniert raspios.qcow 8G### Remove existing Raspberry Pi OS RAW image so we can do this
### make no mistake and use.
rm -f raspios.img

Start the Raspberry Pi operating system

The following instructions work on both Windows and Linux (or WSL) systems. Of course, you won't be using them on Windows.sudobeforeqemu-system-arch64.

At the time of writing I'm using QEMU 7.0.0, but I've also been testing this since QEMU version 5.2, so I can guarantee it works at least since that version.

# Start QEMU with Rpi emulation
sudo qemu-system-aarch64 -M raspi3b -display none -append "rw earlyprintk loglevel=8 console=ttyAMA0,115200 dwc_otg.lpm_enable=0 root=/dev/mmcblk0p2 rootdelay=1" -dtb ./dtbs/bcm2710-rpi- 3-b-plus.dtb -sd raspios.qcow -kernel kernel8.img -m 1G -smp 4 -serial mon:stdio -usb -device usb-mouse -device usb-kbd -device usb-net,netdev=net0 - usuario netdev,id=net0,hostfwd=tcp::5555-:22

This will launch QEMU with the Raspberry Pi on the console. When prompted to sign in, just typepiand press <ENTER>. Now you can easily access the Raspberry Pi operating system terminal. You can get root shell just by typingbash-sudono command prompt.

Brief explanation of the command line

Okay, let's try to understand what actually happened above. Here is a brief explanation:

### We select the Raspberry Pi 3b
-M raspi3b### Since we started with a lightweight image, we don't need QEMU graphics
- show none### The path to the image on the SD card mounted on the emulator
### SD card. This image was the one we downloaded from
### Raspbery Pi site and also tweaked for 8G (i.e. a power of 2).
-sd raspios.qcow### The device tree for the Raspberry Pi and kernel images.
### These were extracted from the first partition of
### Image above.
-dtb ./dtbs/bcm2710-rpi-3-b-plus.dtb -kernel kernel8.img### Redirect all I/O messages to/from a serial console.
### Specifically, we also use "mon:" as an argument to -serial
### to ensure ctrl-c when used to stop a long run
Program ### in emulated Rpi does not exit QEMU.
### "mon:" passes Ctrl-C directly to the guest OS (in our
Case ###, the Rapberry Pi operating system).Note that this only works 
###Linux (or WSL) systems: On Windows, QEMU will still exit.
-Serial Seg: stdio### Pass in some kernel command lines: most importantly, these
The ### parameters redirect initial boot messages to the string
### terminal ttyAMA0 - this is the same terminal as that one
### You have accessed QEMU. Since we are redirecting all IO messages to
### previous series, we will see all the news (early release news
### and its entries) directly on the calling end device
### the QEMU. Also, we mentioned that rootfs resides on
### second partition in the image (remember we used the
### passwd file of this partition above?)
-agregar "rw earlyprintk loglevel=8 consola=ttyAMA0,115200 dwc_otg.lpm_enable=0 root=/dev/mmcblk0p2 rootdelay=1"### Memory and number of processors QEMU should use.
### For -smp, we could use $(nproc) on Linux/WSL systems,
### or the number returned by "gci $env:NUMBER_OF_PROCESSORS".
### on Windows machines.
-m 1G -smp 4### Finally, we emulate all input devices as well as the network
### Devices such as USB devices. In addition, we also forward the
### Port 22 on guest (sshd port is listening).
### Port 5555 on host. This will allow us to participate
### Rapberry Pi OS from anywhere (including localhost).
-usb -device usb-ratón -device usb-kbd -device usb-net,netdev=net0 -user netdev,id=net0,hostfwd=tcp::5555-:22

After doing all this to start QEMU successfully, we will be faced with the following problem: The size of the SD card (where the operating system and files in the home directory of thepiuser) would be ridiculously small: around 1.6GB, and most of it is already used by the base system!

So now we need to increase the map size so that all useful work can be done with this emulated Rpi.

Now. create a file/etc/udev/rules.d/90-qemu.ruleson the Raspberry Pi guest OS:

sudo /etc/udev/rules.d/90-qemu.rules

Paste this content into the file:

NUCLEO=="sda", SYMLINK+="mmcblk0"
NUCLEO=="sda?", SYMLINK+="mmcblk0p%n"
NÚCLEO=="sda2", SYMLINK+="raíz"

Shut down QEMU now —sudo off -h now- and restart it with the command line as above.

After QEMU returns, log in aspiagain and start raspi-config as root:

sudo raspi-config

In the curse window that appears, select "Advanced Options":

In the advanced options, select "Extend file system":

This expands the file system to fill the original image size of about 8 GB. After resizing, you need to restart QEMU to use all the extended space.

Habilitar SSH no Raspberry Pi

The Raspberry Pi operating system does not allow SSH connections. The first thing we have to do is activate it with theraspi-configTool:

sudo raspi-config

Now you will see a curses tool. Use the arrow to select "Interface Options".

Press <ENTER> and select SSH:

Select "Yes" in the dialog box that appears:

Press <OK> and then <Done>. This will enable SSH on your Raspberry Pi. You can now connect to your emulated Rpi using SSH.

Connection via ssh (and with password)

Set a password for the pi user

Since we started QEMU with port 22 on the guest forwarded to 5555 on the host, we can just ssh into the Rpi OS from the host.

To do this, however, we must set the password for thepiUsers on Raspberry (remember we removed the password forpiuser above). We just set the password for pi usingpasswordcommand in the guest operating system.

Configure the SSH client

add this~/.ssh/configFile on your host:

IP des Hosts
Identity file ~/.ssh/rpikey
Host local do host
Benutzer pi
Porto 5555

Losidentity fileThe one shown above will be used if you choose to login via SSH without a password (see below).

Accessing the Raspberry Pi with ssh

Access the Rpi guest from the host with this SSH command:

ssh-rpi

Passwordless login via SSH keys

For passwordless SSH login, do the following (use these commands on HOST or RPI):

HOST:Generate SSH key:

We use a passwordless private key (hence the -N option below).

ssh-keygen -b 2048 -t rsa -q -N "" -f ~/.ssh/rpikey

HOST:Copy the public key to your rpi:

ssh-copia-id -i ~/.ssh/rpikey rpi

Note that the above command worked because you had already configured the ssh client with the username and port numbers in the~/.ssh/configfile (see above). Otherwise, use the following command (options-Page 5555and host identitypi@localhostshould be used for the entire remainder of the command if the SSH client is not set to~/.ssh/configbusiness hours):

ssh-copia-id -p 5555 -i ~/.ssh/rpikey pi@localhost

DPI:Enable Passwordless Guest OS on Rapberry Pi

Do this in the original QEMU terminal (not an ssh-connected terminal):

edit the file/etc/ssh/sshd_config:

sudo vi /etc/ssh/sshd_config

Add the following (or comment out the existing line and enter the value "no"):

Password Authentication No

optional,If you also want to login as root via SSH without a password, you must also enable this:

AllowRootLogin without password

After making these changes, restart your SSH server:

Restart sudo /etc/init.d/ssh

HOST:Connect to emulated Rpi without password!

ssh-rpi

There are many places where I got all this information. If something doesn't work out for you, additional information can be added from the original sources. The original sources of information are these:

• Native Raspberry Pi emulation:qemu-rpi-kernel/native Emulation auf Master dhruvvyas90/qemu-rpi-kernel (github.com)
• Image conversion for QCow2:Raspberry Pi, qemu and network access: programming adventures
• Larger SD card:QEmu and Raspbian how to increase image size. — Raspberry Pi forums
• Networks in QEMU + Rpi:QEMU Kernel for Raspberry Pi 3 with Networking and Virtio Support
• SSH connections to QEMU:How to set QEMU output to console and automate it with Shell Script (fadeevab.com)