Exécutez Linux avec l'architecture ARM à l'aide de QEMU

introduction

Aperçu

Environnement d'exploitation

Environnement

  1. Installez git.

    $ sudo apt-get install git
    
  2. Installez le compilateur croisé ARM.

    $ sudo apt-get install gcc-arm-linux-gnueabi
    
  3. Installez le logiciel nécessaire pour construire le noyau Linux.

    $ sudo apt-get install flex bison libncurses-dev libssl-dev
    
  4. Installez QEMU pour ARM.

    $ sudo apt-get install qemu-system-arm
    

Structure du répertoire au moment de la construction

{top_directory} ├ linux-stable │ └ arch │ └ arm │ └ boot │ ├ zImage: Image du noyau │ └ dts │ └ polyvalent-pb.dtb: arborescence des périphériques │ ├ busybox │ ├ _install: système de fichiers racine │ └ rootfs.img: Image du système de fichiers racine │ ├ driver │ └ sample │ └ driver_sample.ko: module de pilote de périphérique │ └ app └ sample └ app_sample: fichier binaire d'exécution de l'application ~~~

Construction du noyau Linux

  1. Clonez le noyau Linux (noyau stable).

    $ git clone git://git.kernel.org/pub/scm/linux/kernel/git/stable/linux-stable.git
    
  2. Accédez au répertoire cloné.

    $ cd linux-stable
    
  3. Appliquez les paramètres par défaut des cartes Arm Versatile (versatilepb).

    $ make ARCH=arm CROSS_COMPILE=arm-linux-gnueabi- versatile_defconfig
    
  4. Construisez.

    $ make ARCH=arm CROSS_COMPILE=arm-linux-gnueabi-
    
  5. Assurez-vous que l'image du noyau et l'arborescence des périphériques sont générées.

    $ ls -latr arch/arm/boot/dts/versatile-pb.dtb
    $ ls -latr arch/arm/boot/zImage
    

Construire BusyBox

  1. Clonez la BusyBox.

    $ git clone git://git.busybox.net/busybox
    
  2. Accédez au répertoire cloné.

    $ cd busybox
    
  3. Appliquez les paramètres par défaut.

    $ make ARCH=arm CROSS_COMPILE=arm-linux-gnueabi- defconfig
    
  4. Puisque nous devons créer un lien statique pour travailler avec un seul binaire, exécutez la commande make menuconfig pour activer la configuration du noyau "Construire un binaire statique (pas de bibliothèques partagées)".

    $ make ARCH=arm CROSS_COMPILE=arm-linux-gnueabi- menuconfig
    
    Settings --> Build static binary (no shared libs)
    
  5. Construisez.

    $ make ARCH=arm CROSS_COMPILE=arm-linux-gnueabi-
    
  6. Installez. Une fois l'installation terminée, un système de fichiers racine sera créé sous le répertoire _install.

    $ make ARCH=arm CROSS_COMPILE=arm-linux-gnueabi- install
    

Créer un pilote de périphérique

  1. Créez un répertoire pour le pilote de périphérique et accédez-y.

    $ mkdir -p driver/sample
    $ cd driver/sample
    
  2. Créez le code source du pilote de périphérique. (Le code source suivant est un exemple de pilote de périphérique qui se charge / décharge simplement.)

    $ nano driver_sample.c
    
    #include <linux/module.h>
    #include <linux/kernel.h>
    
    static int __init sample_module_init( void )
    {
    	printk( "driver sample load\n" );
    	return 0;
    }
    
    static void __exit sample_module_exit( void )
    {
    	printk( "driver sample remove\n" );
    }
    
    module_init( sample_module_init );
    module_exit( sample_module_exit );
    
    MODULE_DESCRIPTION( "sample_module" );
    MODULE_LICENSE( "GPL" );
    
  3. Créez un Makefile.

    $ nano Makefile
    
    obj-m := driver_sample.o
    
    all:
    	make -C $(shell pwd)/../../linux M=$(shell pwd) modules
    clean:
    	make -C $(shell pwd)/../../linux M=$(shell pwd) clean
    
  4. Compilez le pilote de périphérique.

    $ make ARCH=arm CROSS_COMPILE=arm-linux-gnueabi-
    
  5. Copiez le pilote de périphérique dans le répertoire busybox _install.

    $ cp driver_sample.ko ../../busybox/_install/
    

Créer une application

  1. Créez un répertoire pour votre application et accédez-y.

    $ mkdir -p app/sample
    $ cd app/sample
    
  2. Créez le code source de votre application. (Le code source suivant est un exemple d'application qui génère uniquement des journaux.)

    $ nano app_sample.c
    
    #include <stdio.h>
    
    int main(int argc, char *argv[])
    {
    	printf( "app sample run\n" );
    	return 0;
    }
    
  3. Créez un Makefile.

    $ nano Makefile
    
    TARGET	= app_sample
    
    CC		= ${CROSS_COMPILE}gcc
    LD		= ${CROSS_COMPILE}gcc
    
    CSRCS	= $(TARGET).c
    CFLAGS	= -c
    LDFLAGS	= -static -o $(TARGET)
    
    OBJS	= $(CSRCS:.c=.o)
    LIBS	=
    
    .c.o:
    	$(CC) $(CFLAGS) $<
    
    $(TARGET): $(OBJS)
    	$(LD) $(LDFLAGS) $(OBJS) $(LIBS)
    
    clean: ;
    	rm $(OBJS) $(TARGET)
    
  4. Cross-compilez votre application.

    $ make ARCH=arm CROSS_COMPILE=arm-linux-gnueabi-
    
  5. Copiez l'application dans le répertoire busybox _install.

    $ cp app_sample ../../busybox/_install/
    

Exécutez QEMU

  1. Image du système de fichiers racine.

    $ cd busybox/_install/
    $ find .| cpio -o --format=newc > ../rootfs.img
    $ cd ../../
    
  2. Exécutez QEMU.

    $ qemu-system-arm \
    	-M versatilepb \
    	-kernel ./linux/arch/arm/boot/zImage \
    	-dtb ./linux/arch/arm/boot/dts/versatile-pb.dtb \
    	-nographic \
    	-append "rdinit=/bin/sh" \
    	-initrd ./busybox/rootfs.img
    
  3. Lorsque le démarrage est terminé, le shell démarre. En vérifiant avec la commande ls, le système de fichiers racine ressemble à ceci:

    / # ls
    app_sample        dev               linuxrc           sbin
    bin               driver_sample.ko  root              usr
    / #
    
  4. Chargez le pilote de périphérique.

    / # insmod driver_sample.ko
    driver_sample: loading out-of-tree module taints kernel.
    driver sample load
    
  5. Exécutez l'application.

    / # ./app_sample
    app sample run
    

Recommended Posts

Exécutez Linux avec l'architecture ARM à l'aide de QEMU
Accélérez la broderie avec QEMU pour le processeur ARM
Exécutez un serveur Linux avec GCP
Exécutez SwitchBot avec Bleak sur Windows 10
[Note] Exécutez Django sur Amazon Linux 2
Exécutez Yocto sur Ubuntu en utilisant QEMU.
Exécutez cron sur Amazon Linux (défini sur Linux)
Exécutez le GPU Radeon sous Windows sur QEMU / KVM
Exécutez le servo avec Python sur ESP32 (Windows)
Utiliser Tabpy avec Cloud Run (sur GKE)
Assembleur X86 sous Linux (lien avec C)
[C] [python] Lire avec AquesTalk sous Linux
Exécutez bootgen sur Debian GNU / Linux, Ubuntu
Exécuter un lot de Python 2.7 avec nohup sur Amazon Linux AMI sur EC2
Exécutez Debian (Linux) et LXQt sur Athlon 200GE (AMD)
Configurer Golang avec goenv sur GNU / Linux
Démarrer un processus avec une politique de planification sous Linux
Exécutez Flask sur CentOS avec python3.4, Gunicorn + Nginx.
Architecture ARM »Portage
Installez PHP série 7 sur Amazon Linux 2 avec Amazon Linux Extras
Exécutez la matrice LED de manière interactive avec Raspberry Pi 3B + sur Slackbot
Commande Yum pour accéder à MySQL avec Python 3 sous Linux
Exécutez Paints Chainer sur CPU avec python officiel sur win10
Configurer Docker sur Oracle Linux (7.x) avec Vagrant
Installez Docker sur Arch Linux et exécutez-le à distance
Démoniser les processus sous Linux
Exécutez Python avec VBA
Exécutez prepDE.py avec python3
jblas sur Arch Linux
Linux (WSL) sous Windows
Routeur NAT sur Linux
Linux (Lubuntu) avec OneMix3S
Exécutez mysqlclient sur Lambda
Exécutez Blender avec python
Exécutez OpenMVG sur Mac
Surveiller le trafic sous Linux
Mettre à jour vscode sur Linux
Architecture du système Linux [niveau d'exécution]
Relire le démarrage de ARM Linux
Créer LiveUSB sur Linux
Fonctionnement Linux sur Win10
Exécutez iperf avec python
Problèmes avec Chrome après la suspension sur le bureau Linux KDE + Nvidia
Exécutez le pilote Lima sur Debian GNU / Linux pour Ultra96 / Ultra96-V2
Tester Python avec Miniconda dans un environnement OS X et Linux avec travis-ci
Gestion intuitive des mots de passe avec aws ssm sur alias Mac / Linux
Apprenez «l'architecture x86 apprise avec votre propre émulateur» avec Manjaro (Linux)
Créer Python3 pour Windows 10 sur ARM avec Visual Studio 2019 (x86) sur Windows 10 sur ARM