¿Cómo puedo conectar una tarjeta SD que contiene un sistema operativo Raspberry Pi a mi PC con Linux y arrancar el sistema operativo en un emulador?

¿Por qué no funciona VMWare?

¿Cuáles son las limitaciones de este método?

Relacionado: Emulación en una PC con Windows

Sí, esto es completamente posible. Sin embargo, en realidad es un poco diferente a cómo estás pensando.

Preámbulo

La tarjeta SD contiene una imagen del sistema operativo. Y funciona al inflar esta imagen cuando el dispositivo está encendido.

Como espero que ya sepas, flasheas esta imagen en la tarjeta SD para crear un sistema de trabajo. Sin embargo, lo que puede hacer antes de flashear la imagen es jugar con ella usando QEMU , que es un emulador de procesador , y nos permite emular el conjunto de instrucciones ARM.

De esta manera, cualquier cambio que realice en la imagen (instalación, compilación, etc.) seguirá estando allí después de que lo actualice a la tarjeta SD.

Ahora le explicaré cómo usar QEMU para cargar la imagen. Voy a demostrar con la imagen de Arch Linux, pero el proceso debería ser el mismo independientemente.

Usando QEMU

Requisitos previos

Necesitará adquirir QEMU para su sistema. QEMU solo debe tener un requisito, para que los dispositivos de entrada funcionen, debe tener instalado el paquete de desarrollo SDL, que debe estar disponible desde su administrador de paquetes.

Recomiendo descargar el paquete usando su administrador de paquetes regular:

Arco :

sudo pacman -S sdl qemu

Ubuntu :

Las versiones más recientes (desde 14.04) tienen un paquete para ello:

sudo apt-get install qemu-system-arm

Para versiones anteriores:

sudo apt-get install libsdl-dev
sudo add-apt-repository ppa:linaro-maintainers/tools
sudo apt-get update
sudo apt-get install qemu-system

Construyendo QEMU usted mismo

Alternativamente, puede construir QEMU usted mismo. ¡Esto es genial si quieres probar una nueva versión, pero puede ser lenta y estar preparada para muchos errores durante la compilación! Tenga en cuenta que si construye QEMU desde su sitio web, debe compilarse para soporte ARM. Así que primero revisa tus repositorios de distribución. Esto se puede hacer así;

mkdir rpi-emu && cd rpi-emu
wget http://wiki.qemu.org/download/qemu-1.1.0-1.tar.bz2
tar xvjf qemu-1.1.0-1.tar.bz2
cd qemu-1.1.0-1
./configure –target-list=arm-softmmu,arm-linux-user
make
sudo make install

Verifique que tiene soporte ARM con:

qemu-system-arm --version
QEMU emulator version 1.0,1, Copyright (c) 2003-2008 Fabrice Bellard

Obteniendo la imagen

Estamos trabajando con Arch Linux, por lo que utilizaremos la imagen de Arch Arm. Pero reemplace esto con lo que desee para trabajar, o tal vez ya tenga una imagen. En cuyo caso, omita este paso.

wget http://anorien.csc.warwick.ac.uk/mirrors/raspberrypi.org/images/archlinuxarm/archlinuxarm-29-04-2012/archlinuxarm-29-04-2012.zip
unzip archlinuxarm-29-04-2012.zip 

Para que QEMU funcione, también necesitamos la imagen del núcleo (que estaría dentro del archivo .img).

Nota: No creo que este paso sea necesario para Debian. Alguien por favor confirme.

Afortunadamente, hay imágenes precompiladas disponibles, y puede usar la que está aquí ( descarga directa ).

TODO: ¿Demuestra cómo compilar una imagen del núcleo aquí?

Iniciando la VM

Ahora deberías tener:

• Un archivo img que puede verificar utilizando el sha1 suministrado (recomendado).
• Una imagen del núcleo (zImage).
• QEMU para ARM.

La máquina virtual ahora se puede iniciar utilizando el siguiente comando de largo aliento:

qemu-system-arm -kernel zImage -cpu arm1176 -M versatilepb -serial stdio -append "root=/dev/sda2" -hda archlinuxarm-29-04-2012.img -clock dynticks

Tenga en cuenta que solo tendrá varios cientos de megabytes de almacenamiento utilizando este método (lo que sea que quede en la imagen). Se puede crear un disco duro virtual siguiendo la guía del usuario de QEMU .

Ubuntu 16.04, QEMU 2.9.0 -M raspi2, Raspbian 2016-05-27, núcleo de vainilla

1. Compile QEMU 2.9.0 de la fuente:

   sudo apt-get build-dep qemu-system-arm
   git clone --recursive git://git.qemu-project.org/qemu.git
   cd qemu
   git checkout v2.9.0
   ./configure
   make `nproc`
   

2. Descargue la imagen y extraiga el kernel y dts de ella:

   1. Descarga la imagen y descomprímela:

      wget http://downloads.raspberrypi.org/raspbian/images/raspbian-2016-05-31/2016-05-27-raspbian-jessie.zip
      unzip 2016-05-27-raspbian-jessie.zip
      

   2. Monta la segunda imagen de la partición. La forma más fácil es:

      sudo losetup -f --show -P 2016-05-27-raspbian-jessie.img
      

      Esto solo funciona con lo último losetupen Ubuntu 16.04, otros métodos en: https://askubuntu.com/questions/69363/mount-single-partition-from-image-of-entire-disk-device/496576#496576

      Esto imprime un dispositivo de bucle, por ejemplo:

      /dev/loop0
      

      entonces hacemos:

      sudo mkdir /mnt/rpi
      sudo mount /dev/loop0p1 /mnt/rpi
      cp /mnt/rpi/kernel7.img bcm2709-rpi-2-b.dtb .
      sudo umount /mnt/rpi
      sudo losetup -d /dev/loop0
      

3. Correr:

   ./arm-softmmu/qemu-system-arm \
       -M raspi2 \
       -append "rw earlyprintk loglevel=8 console=ttyAMA0,115200 dwc_otg.lpm_enable=0 root=/dev/mmcblk0p2" \
       -cpu arm1176 \
       -dtb bcm2709-rpi-2-b.dtb \
       -sd 2016-05-27-raspbian-jessie.img \
       -kernel kernel7.img \
       -m 1G \
       -smp 4 \
       -serial stdio \
   ;
   

Luego puede iniciar sesión en el terminal que se muestra en su terminal host.

Limitaciones actuales:

• -M raspi2se agregó en QEMU 2.6.0, y Ubuntu 16.04 solo tiene QEMU 2.5.0, por lo que tenemos que compilar QEMU desde la fuente. Pero esto no es difícil.
• la GUI muestra pero no responde al mouse / teclado, probado en SDL y VNC. Pero CLI funciona perfectamente sin embargo. Por lo tanto, también podría usar la imagen Lite que tiene GUI por ahora.
• sin redes

Ubuntu 16.04, QEMU 2.5.0, Raspbian 2016-05-27, kernel modificado

Este método utiliza el -M versatilepbque está presente en QEMU 2.5.0 de Ubuntu 16.04.

La desventaja es que debe descargar un kernel modificado (consulte Emulación con Qemu: ¿por qué el kernel adicional? ) Y modificar la imagen, por lo que es menos representativo del sistema real.

1. Descargar: https://github.com/dhruvvyas90/qemu-rpi-kernel/blob/36ede073f4ccb64f60200ede36c231afe9502070/kernel-qemu-4.4.12-jessie

   Elegimos 4.4.12ya que esa es la versión del kernel en la imagen Raspbian.

   El proceso para generar esa gota de kernel se describe en el repositorio en: https://github.com/dhruvvyas90/qemu-rpi-kernel/tree/36ede073f4ccb64f60200ede36c231afe9502070/tools

   ¿Por qué se necesita esta imagen extra del núcleo? Emulación con Qemu: ¿por qué el núcleo adicional?

2. Modifique la imagen Raspbian como se menciona en: https://github.com/dhruvvyas90/qemu-rpi-kernel/wiki/Emulating-Jessie-image-with-4.x.xx-kernel/0068f0c21d942b0f331e18014ff8e22c20cada5c

   Resumen:

   1. Monte la imagen tal como lo hicimos para el -M raspi2, pero use la segunda partición en lugar de la primera:

      sudo mount /dev/loop0p2 /mnt/rpi
      

   2. Edita la imagen:

      # Comment out the line present there with #
      sudo vim /mnt/rpi/etc/ld.so.preload
      # Comment out the lines of type: "/dev/mmcblk*"
      sudo vim /mnt/rpi/etc/fstab
      

3. Correr:

   sudo apt-get install qemu-system-arm
   qemu-system-arm \
       -kernel kernel-qemu-4.4.12-jessie \
       -cpu arm1176 \
       -m 256 \
       -M versatilepb \
       -no-reboot \
       -serial stdio \
       -append "root=/dev/sda2 panic=1 rootfstype=ext4 rw" \
       -hda 2016-05-27-raspbian-jessie.img
   

[fallido] Ubuntu 17.04, QEMU 2.8.0 -M raspi2, Raspbian 2016-05-27, núcleo de vainilla

En este Ubuntu más nuevo, QEMU 2.8.0 es el predeterminado, por lo que no necesitamos compilar QEMU desde la fuente -M raspi2. Sin embargo, 2.8.0 se bloquea en el arranque después del mensaje:

Console: switching to colour frame buffer device 100x30

Esto demuestra que -M raspi2aún es inestable .

[fallido] Ubuntu 16.04, QEMU 2.9.0 -M raspi2, Raspbian 2017-08-16, núcleo de vainilla

En esta imagen más nueva, usando el mismo método para 2016-05-27, el núcleo entra en pánico al arrancar con:

Please append a correct "root=" boot option; here are the available partitions:
...
[    4.138114] ---[ end Kernel panic - not syncing: VFS: Unable to mount root fs on unknown-block(0,0)

bztsrc/raspi3-tutorial RPI3 metal desnudo en QEMU

https://github.com/bztsrc/raspi3-tutorial es un buen conjunto de ejemplos que solo funcionan en QEMU, comenzando ultra rápido en: Cómo hacer la emulación de QEMU para imágenes Raspberry Pi de metal desnudo

No puede hacer lo que sugiere, porque Raspberry Pi tiene una arquitectura de procesador diferente a la de la mayoría de las PC. Si bien la mayoría de las PC están basadas en x86, RPi es una computadora basada en ARM.

Esta es la misma razón por la que no puede ejecutar, por ejemplo, Microsoft Windows en RPi.

VmWare no funcionará, porque solo puede virtualizar sistemas operativos basados ​​en x86 (32 bits y 64 bits). Hay otros emuladores que pueden virtualizar ARM, como QEMU, pero están ejecutando una emulación de software completa sin soporte de virtualización de CPU nativa, por lo que puede esperar que sean bastante lentos.

Puede probar fácilmente un simulador Raspberry Pi incluido con sensor, línea de comando y editor de archivos en iotify.io. Consulte nuestra documentación en https://docs.iotify.io/ para comenzar con los diferentes proyectos, sistemas operativos y familiarizarse con el entorno de trabajo de Raspberry Pi.