Construction d'une Image XEN archlinux

arch/arm/boot/dts/overlays/Makefile | 4 +- …/boot/dts/overlays/pi4-32-xen-overlay.dts | 21 ++++++++++ …/boot/dts/overlays/pi4-64-xen-overlay.dts | 39 +++++++++++++++++++ 3 files changed, 63 insertions(+), 1 deletion(-) create mode 100644 arch/arm/boot/dts/overlays/pi4-32-xen-overlay.dts create mode 100644 arch/arm/boot/dts/overlays/pi4-64-xen-overlay.dts

diff –git a/arch/arm/boot/dts/overlays/Makefile b/arch/arm/boot/dts/overlays/Makefile index a6b0d9ea0385..4cfe5885eca1 100644 — a/arch/arm/boot/dts/overlays/Makefile +++ b/arch/arm/boot/dts/overlays/Makefile @@ -244,7 +244,9 @@ dtbo-$(CONFIGARCHBCM2835) += \ w1-gpio-pullup.dtbo \ w5500.dtbo \ wittypi.dtbo \ - wm8960-soundcard.dtbo + wm8960-soundcard.dtbo \ + pi4-32-xen.dtbo \ + pi4-64-xen.dtbo

targets += dtbs dtbsinstall targets += $(dtbo-y) diff –git a/arch/arm/boot/dts/overlays/pi4-32-xen-overlay.dts b/arch/arm/boot/dts/overlays/pi4-32-xen-overlay.dts new file mode 100644 index 000000000000..47afa6ac24b7 — /dev/null +++ b/arch/arm/boot/dts/overlays/pi4-32-xen-overlay.dts @@ -0,0 +1,21 @@ + Xen configuration for Pi 4 +/dts-v1/; +/plugin/; + +/ { + compatible = “brcm,bcm2711”; + + fragment@0 { + target-path = “/chosen”; + overlay { + #address-cells = <0x1>; + #size-cells = <0x1>; + xen,xen-bootargs = “console=dtuart dtuart=/soc/serial@7e215040 syncconsole dom0mem=512M dom0maxvcpus=1 bootscrub=0”; + + dom0 { + compatible = “xen,linux-zimage”, “xen,multiboot-module”; + reg = <0x00400000 0x01800000>; + }; + }; + }; +}; diff –git a/arch/arm/boot/dts/overlays/pi4-64-xen-overlay.dts b/arch/arm/boot/dts/overlays/pi4-64-xen-overlay.dts new file mode 100644 index 000000000000..6c499a831db6 — /dev/null +++ b/arch/arm/boot/dts/overlays/pi4-64-xen-overlay.dts @@ -0,0 +1,39 @@ + Xen configuration for Pi 4 +/dts-v1/; +/plugin/; + +/ { + compatible = “brcm,bcm2711”; + + fragment@0 { + target-path = “/chosen”; + overlay { + #address-cells = <0x1>; + #size-cells = <0x1>; + xen,xen-bootargs = “console=dtuart dtuart=/soc/serial@7e215040 syncconsole dom0mem=512M bootscrub=0”; + + dom0 { + compatible = “xen,linux-zimage”, “xen,multiboot-module”; + reg = <0x00480000 0x01780000>; + }; + }; + }; + + /* Introduce a dummy device node to make Xen map the framebuffer */ + fragment@1 { + target-path = “/”; + overlay { + fbbus { + compatible = “simple-bus”; + ranges; + #address-cells = <2>; + #size-cells = <1>; + fb_mem { + compatible = “dummy”; + status = “okay”; + reg = <0x0 0x3b400000 0x04c00000>; + }; + }; + }; + };

2.34.0 </codedoc>

En l'absence d'un fichier ${WRKDIR}linux/.build-arm64/.config on utilise kernel/configs/xen.config fragment

cd ${WRKDIR}linux
if [ "${BUILD_ARCH}" == "arm64" ]; then
    if [ ! -s ${WRKDIR}linux/.build-arm64/.config ]; then
        # utilize kernel/configs/xen.config fragment
        make O=.build-arm64 ARCH=arm64 CROSS_COMPILE=aarch64-none-linux-gnu- bcm2711_defconfig xen.config
    fi
    make O=.build-arm64 ARCH=arm64 CROSS_COMPILE=aarch64-none-linux-gnu- -j $(nproc) broadcom/${DTBFILE}
    make O=.build-arm64 ARCH=arm64 CROSS_COMPILE=aarch64-none-linux-gnu- -j $(nproc) overlays/${DTBXENO}.dtbo
    if [ ! -s ${WRKDIR}linux/.build-arm64/arch/arm64/boot/Image ]; then
        echo "Building kernel. This takes a while. To monitor progress, open a new terminal and use \"tail -f buildoutput.log\""
        make O=.build-arm64 ARCH=arm64 CROSS_COMPILE=aarch64-none-linux-gnu- -j $(nproc) > ${WRKDIR}buildoutput.log 2> ${WRKDIR}buildoutput2.log
    fi
elif [ "${BUILD_ARCH}" == "armhf" ]; then
    if [ ! -s ${WRKDIR}linux/.build-arm32/.config ]; then
        # utilize kernel/configs/xen.config fragment
        make O=.build-arm32 ARCH=arm CROSS_COMPILE=arm-none-linux-gnueabihf- bcm2711_defconfig xen.config
    fi
    make O=.build-arm32 ARCH=arm CROSS_COMPILE=arm-none-linux-gnueabihf- -j $(nproc) ${DTBFILE}
    make O=.build-arm32 ARCH=arm CROSS_COMPILE=arm-none-linux-gnueabihf- -j $(nproc) overlays/${DTBXENO}.dtbo
    if [ ! -s ${WRKDIR}linux/.build-arm32/arch/arm/boot/zImage ]; then
        echo "Building kernel. This takes a while. To monitor progress, open a new terminal and use \"tail -f buildoutput.log\""
        make O=.build-arm32 ARCH=arm CROSS_COMPILE=arm-none-linux-gnueabihf- -j $(nproc) zImage modules dtbs > ${WRKDIR}buildoutput.log 2> ${WRKDIR}buildoutput2.log
    fi
fi
cd ${WRKDIR}

if [ ! -s ${WRKDIR}xen/xen/xen ]; then
    cd ${WRKDIR}xen
    if [ ! -s xen/.config ]; then
        cat > xen/arch/arm/configs/rpi4_defconfig << EOF
CONFIG_DEBUG=y
CONFIG_SCHED_ARINC653=y
CONFIG_EARLY_UART_CHOICE_8250=y
CONFIG_EARLY_UART_BASE_ADDRESS=0xfe215040
CONFIG_EARLY_UART_8250_REG_SHIFT=2
EOF
        make -C xen XEN_TARGET_ARCH=arm64 CROSS_COMPILE=aarch64-none-linux-gnu- rpi4_defconfig
    fi
    make XEN_TARGET_ARCH=arm64 CROSS_COMPILE=aarch64-none-linux-gnu- dist-xen -j $(nproc)
    cd ${WRKDIR}
fi

Cette section présente la construction et l'activation les outils XEN suivants:

1. xen-qemu-dom0-disk-backend: Démarrage de QEMU en tant que backend de disque
2. xen-init-dom0.service xen-init-dom0: initialiser la configuration Dom0 (nœuds xenstore, stub de configuration JSON)
3. xenconsoled: gère la journalisation à partir des consoles invitées et de l'hyperviseur
4. xendomains: démarre et arrête les invités au démarrage et à l'arrêt
5. xen-watchdog: exécute le démon de surveillance xen

Retourner dans le répertoire des sources xen:

cd ${WRKDIR}xen

Déclarer les préfixes utilisés pour la construction

if [ "${BUILD_ARCH}" == "arm64" ]; then
    LIB_PREFIX=aarch64-linux-gnu
    CROSS_PREFIX=aarch64-none-linux-gnu
    XEN_ARCH=arm64
elif [ "${BUILD_ARCH}" == "armhf" ]; then
    LIB_PREFIX=arm-linux-gnueabihf
    CROSS_PREFIX=arm-none-linux-gnueabihf
    XEN_ARCH=arm32
fi

Modifier les liens symboliques de la bibliothèque partagée en liens relatifs au lieu de liens absolus afin qu'ils fonctionnent bien avec la compilation croisée:

sudo chroot ${MNTROOTFS} symlinks -c /usr/lib/${LIB_PREFIX}/

Indiquer au compilateur natif dans quel système il inclut les répertoires qu'il recherche.

SYSINCDIRS=$(echo bash -c "echo | gcc -E -Wp,-v -o /dev/null - 2>&1" | grep "^ " | sed "s|^ /| -isystem${MNTROOTFS}|"))
SYSINCDIRSCXX=$(echo bash -c "echo | g++ -x c++ -E -Wp,-v -o /dev/null - 2>&1" | grep "^ " | sed "s|^ /| -isystem${MNTROOTFS}|"))

CC="${CROSS_PREFIX}-gcc --sysroot=${MNTROOTFS} -nostdinc ${SYSINCDIRS} -B${MNTROOTFS}lib/${LIB_PREFIX} -B${MNTROOTFS}usr/lib/${LIB_PREFIX}"
CXX="${CROSS_PREFIX}-g++ --sysroot=${MNTROOTFS} -nostdinc ${SYSINCDIRSCXX} -B${MNTROOTFS}lib/${LIB_PREFIX} -B${MNTROOTFS}usr/lib/${LIB_PREFIX}"
LDFLAGS="-Wl,-rpath-link=${MNTROOTFS}lib/${LIB_PREFIX} -Wl,-rpath-link=${MNTROOTFS}usr/lib/${LIB_PREFIX}"

Configurer la source des build:

PKG_CONFIG_LIBDIR=${MNTROOTFS}usr/lib/${LIB_PREFIX}/pkgconfig:${MNTROOTFS}usr/share/pkgconfig \
PKG_CONFIG_SYSROOT_DIR=${MNTROOTFS} \
LDFLAGS="${LDFLAGS}" \
PYTHON=${MNTROOTFS}/usr/bin/python3 \
./configure \
    --with-system-qemu=/usr/bin/qemu-system-i386 \
    --enable-systemd \
    --disable-xen \
    --enable-tools \
    --disable-docs \
    --disable-stubdom \
    --disable-golang \
    --prefix=/usr \
    --with-xenstored=xenstored \
    --build=x86_64-linux-gnu \
    --host=${CROSS_PREFIX} \
    CC="${CC}" \
    CXX="${CXX}"

Construire les binaires dist-tools:

PKG_CONFIG_LIBDIR=${MNTROOTFS}usr/lib/${LIB_PREFIX}/pkgconfig:${MNTROOTFS}usr/share/pkgconfig \
PKG_CONFIG_SYSROOT_DIR=${MNTROOTFS} \
LDFLAGS="${LDFLAGS}" \
make dist-tools \
    CROSS_COMPILE=${CROSS_PREFIX}- XEN_TARGET_ARCH=${XEN_ARCH} \
    CC="${CC}" \
    CXX="${CXX}" \
    -j $(nproc)

Construire les binaires install-tools:

sudo --preserve-env PATH=${PATH} \
PKG_CONFIG_LIBDIR=${MNTROOTFS}usr/lib/${LIB_PREFIX}/pkgconfig:${MNTROOTFS}usr/share/pkgconfig \
PKG_CONFIG_SYSROOT_DIR=${MNTROOTFS} \
LDFLAGS="${LDFLAGS}" \
make install-tools \
    CROSS_COMPILE=${CROSS_PREFIX}- XEN_TARGET_ARCH=${XEN_ARCH} \
    CC="${CC}" \
    CXX="${CXX}" \
    DESTDIR=${MNTROOTFS}

cd ${WRKDIR}linux
if [ "${BUILD_ARCH}" == "arm64" ]; then
    sudo --preserve-env PATH=${PATH} make O=.build-arm64 ARCH=arm64 CROSS_COMPILE=aarch64-none-linux-gnu- INSTALL_MOD_PATH=${MNTROOTFS} modules_install > ${WRKDIR}modules_install.log
elif [ "${BUILD_ARCH}" == "armhf" ]; then
    sudo --preserve-env PATH=${PATH} make O=.build-arm32 ARCH=arm CROSS_COMPILE=arm-none-linux-gnueabihf- INSTALL_MOD_PATH=${MNTROOTFS} modules_install > ${WRKDIR}modules_install.log
fi

cd ${WRKDIR}

Cette section décrit l'asssemblage du bootfiles qui contindra:

• bootfiles/config.txt
• bootfiles/cmdline.txt
• bootfiles/kernel8.img
• booutfiles/bcm2711-rpi-4-b.dtb
• bootfiles/overlays/pi4-xx-xen.dtbo (pi4-32-xen.dtbo pour armhf, pi4-64-xen.dtbo pour aarch64)

Créer le répertoire nommé bootfiles:

cd ${WRKDIR}

if [ ! -d bootfiles ]; then
    mkdir bootfiles
fi

cp ${WRKDIR}firmware/boot/fixup4*.dat ${WRKDIR}firmware/boot/start4*.elf bootfiles/

mkdir -p bootfiles/overlays

Charger dedans les binaires dtb et dtbo:

if [ "${BUILD_ARCH}" == "arm64" ]; then
    cp ${WRKDIR}linux/.build-arm64/arch/arm64/boot/dts/broadcom/${DTBFILE} bootfiles/
    cp ${WRKDIR}linux/.build-arm64/arch/arm64/boot/dts/overlays/${DTBXENO}.dtbo bootfiles/overlays
elif [ "${BUILD_ARCH}" == "armhf" ]; then
    cp ${WRKDIR}linux/.build-arm32/arch/arm/boot/dts/${DTBFILE} bootfiles/
    cp ${WRKDIR}linux/.build-arm32/arch/arm/boot/dts/overlays/${DTBXENO}.dtbo bootfiles/overlays
fi

Créer le fichier bootfiles/cmdline.txt:

cat > bootfiles/cmdline.txt <<EOF
console=hvc0 clk_ignore_unused root=/dev/mmcblk0p2 rootwait
EOF

Créer le fichier bootfiles/config.txt (L'image de démarrage doit être nommée kernel8.img pour que le First Stage Bootloader -FSBL- la charge en mode 64 bits et Xen doit être placé à l'adresse 2M, cf. https://www.raspberrypi.org/documentation/configuration/config-txt/boot.md):

cat > bootfiles/config.txt <<EOF
kernel=kernel8.img
arm_64bit=1
kernel_address=${XEN_ADDR}
dtoverlay=${DTBXENO}
enable_gic=1

#disable_overscan=1

# Enable audio (loads snd_bcm2835)
dtparam=audio=on

[pi4]
max_framebuffers=2

[all]

enable_jtag_gpio=1
enable_uart=1
init_uart_baud=115200
EOF

Création d'un fichier image vide de 26MiB

dd if=/dev/zero of=bootfiles/kernel8.img bs=1024 count=26624

Chargement du noyau xen dedans (en supposant que le fichier soit de moins de 2MiB):

dd if=${WRKDIR}xen/xen/xen of=bootfiles/kernel8.img bs=1024 conv=notrunc

Charger le Kernel Linux dedans (en supposant que la taille du kernel Linux est inférieure à 23,5 Mio l'image est décalée de 2,5 Mio depuis le début du fichier):

if [ "${BUILD_ARCH}" == "arm64" ]; then
    dd if=${WRKDIR}linux/.build-arm64/arch/arm64/boot/Image of=bootfiles/kernel8.img bs=1024 seek=2560 conv=notrunc
elif [ "${BUILD_ARCH}" == "armhf" ]; then
    dd if=${WRKDIR}linux/.build-arm32/arch/arm/boot/zImage of=bootfiles/kernel8.img bs=1024 seek=2048 conv=notrunc
fi

if [ -d /media/${USER}/boot/ ]; then
    cp -r bootfiles/* /media/${USER}/boot/
    sync
fi

exit
sudo umount $LFS/sys
sudo umount $LFS/proc
sudo umount $LFS/dev/shm
sudo umount $LFS/dev/pts
sudo umount $LFS/dev
sudo umount $LFS/tmp

Cete section ne couvre que le nécessaire pour avoir un système bootable:

1. Le chargement du système de base est opéré directement dans le système hôte
2. La configurtaion est opérée dans un jail chrooté diretctement dans la nouvelle structure de fichier.

curl -OLf http://os.archlinuxarm.org/os/ArchLinuxARM-rpi-aarch64-latest.tar.gz

Il faut créer un dossier où on va décompresser le système de base. On va utiliser une variable pour garder le chemin:

export MNTRAMDISK=/tmp/ramdisk/
export MNTROOTFS=${MNTRAMDISK}qemu-arm64-rootfs/

sudo mkdir -p ${MNTRAMDISK}
sudo mount -t tmpfs -o size=3g tmpfs ${MNTRAMDISK}

Extraire tous les fichiers de l'archive tar dans l'image disque montée:

sudo mkdir -p ${MNTROOTFS}
sudo tar -C ${MNTROOTFS} -xf ArchLinuxARM-rpi-aarch64-latest.tar.gz

Monter les systèmes de fichiers spéciaux dans l'image:

sudo mkdir -p ${MNTROOTFS}
sudo mount -o bind /proc ${MNTROOTFS}proc
sudo mount -o bind /dev ${MNTROOTFS}dev
sudo mount -o bind /dev/pts ${MNTROOTFS}dev/pts
sudo mount -o bind /sys ${MNTROOTFS}sys
sudo mount -o bind /tmp ${MNTROOTFS}tmp

La configuration se fait dans un nouveau jail chrooté qui devrait normalement avoir comme prompt :

# chroot "${MNTROOTFS}" /bin/bash

(installation) / #

/etc/resolv.conf est requis pour la connectivité Internet dans chroot. Il sera écrasé par dhcp, alors il ne faut pas trop s'y attarder:

echo "nameserver 8.8.8.8" > /etc/resolv.conf
echo "nameserver 2001:4860:4860::8888" >> /etc/resolv.conf

Renseigner les partitions composant le nouveau système dans le /etc/fstab, exemple :

tmpfs		/tmp	tmpfs	nodev,nosuid	0	0

UUID=[…] swap swap defaults 0 0
UUID=[…] / ext4 defaults 0 1
UUID=[…] /home ext4 defaults 0 1

On peut obtenir les UUID en lançant blkid.

Renseigner le nom de la machine dans le fichier /etc/hostname ainsi que /etc/hosts.

Éditer le fichier /etc/vconsole.conf afin d'y spécifier la disposition du clavier que l'on souhaite utiliser.

cat > /etc/vconsole.conf << "EOF"
KEYMAP=fr-pc
EOF

Créer un lien symbolique /etc/localtime afin de choisir le fuseau horaire, par exemple:

ln -s /usr/share/zoneinfo/Europe/Paris /etc/localtime

Définir un mot passe pour le root :

passwd

Comme on n'a pas installer depuis un système Arch Linux, il faut configurer la liste des miroirs ainsi que pacman keyring, éditer le fichier /etc/pacman.d/mirrorlist et décommenter les serveurs correspondants à la région:

# Any
# Server = ftp://mirrors.kernel.org/archlinux/$repo/os/$arch
Server = http://mirrors.kernel.org/archlinux/$repo/os/$arch

Puis initialiser pacman keyring :

pacman-key --init
pacman-key --populate archlinux

Suite à l’installation, il se peut que l'on rencontre un problème avec pacman et les certificats, pour le régler et avoir un système pleinement opérationnel installer simplement le package ca-certificates-utils

pacman -S ca-certificates
pacman -S ca-certificates-utils

Mettre à jour /etc/fstab pour le périphérique de bloc SD différent par rapport au Raspberry Pi 3 :

sed -i 's/mmcblk0/mmcblk1/g' racine/etc/fstab

Avec ceci, on a un système que l'on peut utiliser de façon autonome.

sudo tar -czf ArchLinuxARM-rpi-aarch64-prepped.tar.gz -C ${MNTROOTFS} $(ls ${MNTROOTFS})

exit
sudo umount ${MNTROOTFS}proc || true
sudo umount ${MNTROOTFS}dev/pts || true
sudo umount ${MNTROOTFS}dev || true
sudo umount ${MNTROOTFS}sys || true
sudo umount ${MNTROOTFS}tmp || true
sudo umount ${MNTBOOT} || true
sudo umount ${MNTROOTFS} || true

Cette section décrit l'assemblage du système de fichier issu des précédentes étapes:

1. le contenu de l'image ArchLinuxARM-rpi-aarch64-prepped.tar.gz
2. le contenu du dossier bootfiles

export MNTRAMDISK=/tmp/ramdisk/
export MNTROOTFS=/tmp/rpi-arm64-rootfs/
export MNTBOOT=${MNTROOTFS}boot/
export IMGFILE=${MNTRAMDISK}rpixen.img

kpartx lit les tables de partitions sur le périphérique spécifié et créé des maps de périphérique sur les segments de partition détectés dans /dev/mapper/:

• -a: ajoute des mappages de partition
• -s: mode de synchronisation=attend que les partitions soient créées

export LOOPDEVS=$(sudo kpartx -avs ArchLinuxARM-rpi-aarch64-prepped.tar.gz | awk '{print $3}')
export LOOPDEVBOOT=/dev/mapper/$(echo ${LOOPDEVS} | awk '{print $1}')
export LOOPDEVROOTFS=/dev/mapper/$(echo ${LOOPDEVS} | awk '{print $2}')

sudo mkdir -p ${MNTROOTFS}
if ! mount | grep ${LOOPDEVROOTFS}; then
    sudo mount ${LOOPDEVROOTFS} ${MNTROOTFS}
fi
sudo mkdir -p ${MNTBOOT}
sudo mount ${LOOPDEVBOOT} ${MNTBOOT}
sudo mount -o bind /proc ${MNTROOTFS}proc
sudo mount -o bind /dev ${MNTROOTFS}dev
sudo mount -o bind /dev/pts ${MNTROOTFS}dev/pts
sudo mount -o bind /sys ${MNTROOTFS}sys
sudo mount -o bind /tmp ${MNTROOTFS}tmp

sudo sync

sudo mkdir -p ${MNTRAMDISK}
sudo mount -t tmpfs -o size=3g tmpfs ${MNTRAMDISK}

Création de l'image disque dans laquelle sera installé le système de base (/mnt/ramdisk/rpixen.img):

qemu-img create ${IMGFILE} 2048M
/sbin/parted ${IMGFILE} --script -- mklabel msdos
MB_TO_SECTOR=2048
/sbin/parted ${IMGFILE} --script -- mkpart primary fat32 $(( 1 * ${MB_TO_SECTOR} ))s $(( 129 * ${MB_TO_SECTOR} - 1 ))s
/sbin/parted ${IMGFILE} --script -- mkpart primary ext4 $(( 129 * ${MB_TO_SECTOR} ))s -1025s

sudo mkfs.vfat ${LOOPDEVBOOT}
sudo mkfs.ext4 ${LOOPDEVROOTFS}

sudo fatlabel ${LOOPDEVBOOT} boot
sudo e2label ${LOOPDEVROOTFS} RpiUbuntu

sudo mount ${LOOPDEVROOTFS} ${MNTROOTFS}

cd ${WRKDIR}

cd ${WRKDIR}

sudo cp -r bootfiles/* ${MNTBOOT}

Comme le script de configuration des outils xen sélectionne un trop grand nombre de modules de pilote backend, on le remplace donc par une liste /usr/lib/modules-load.d/xen.conf plus réduite:

sudo bash -c "cat > ${MNTROOTFS}usr/lib/modules-load.d/xen.conf" <<EOF
xen-evtchn
xen-gntdev
xen-gntalloc
xen-blkback
xen-netback
EOF

Configuration de /etc/hostname:

sudo bash -c "echo ${HOSTNAME} > ${MNTROOTFS}etc/hostname"

Configuration de /etc/hosts:

sudo bash -c "cat > ${MNTROOTFS}etc/hosts" <<EOF
127.0.0.1	localhost
127.0.1.1	${HOSTNAME}
# The following lines are desirable for IPv6 capable hosts
::1     ip6-localhost ip6-loopback
fe00::0 ip6-localnet
ff00::0 ip6-mcastprefix
ff02::1 ip6-allnodes
ff02::2 ip6-allrouters
EOF

Configuration de /etc/fstab:

sudo bash -c "cat > ${MNTROOTFS}etc/fstab" <<EOF
proc            /proc           proc    defaults          0       0
/dev/mmcblk0p1  /boot           vfat    defaults          0       2
/dev/mmcblk0p2  /               ext4    defaults,noatime  0       1
EOF

configuration de /etc/network/interfaces.d/eth0:

sudo bash -c "cat > ${MNTROOTFS}etc/network/interfaces.d/eth0" <<EOF
auto eth0
iface eth0 inet manual
EOF

sudo chmod 0644 ${MNTROOTFS}etc/network/interfaces.d/eth0

Configuration de /etc/network/interfaces.d/xenbr0:

sudo bash -c "cat > ${MNTROOTFS}etc/network/interfaces.d/xenbr0" <<EOF
auto xenbr0
iface xenbr0 inet dhcp
    bridge_ports eth0
EOF

sudo chmod 0644 ${MNTROOTFS}etc/network/interfaces.d/xenbr0

Pour ne pas attendre une éternité que le réseau se mette en ligne:

if [ -s ${MNTROOTFS}lib/systemd/system/networking.service ]; then
    sudo sed -i -e "s/TimeoutStartSec=5min/TimeoutStartSec=15sec/" ${MNTROOTFS}lib/systemd/system/networking.service
fi
if [ -s ${MNTROOTFS}lib/systemd/system/ifup@.service ]; then
    sudo bash -c "echo \"TimeoutStopSec=15s\" >> ${MNTROOTFS}lib/systemd/system/ifup@.service"
fi

Configuration des comptes utilisateurs:

sudo chroot ${MNTROOTFS} useradd -s /bin/bash -G adm,sudo -l -m -p ${HASHED_PASSWORD} ${USERNAME}

Configuration des sudoers Password-less:

sudo chroot ${MNTROOTFS} /bin/bash -euxc "echo \"${USERNAME} ALL=(ALL) NOPASSWD:ALL\" > /etc/sudoers.d/90-${USERNAME}-user"

Activer les démons:

sudo chroot ${MNTROOTFS} systemctl enable xen-qemu-dom0-disk-backend.service
sudo chroot ${MNTROOTFS} systemctl enable xen-init-dom0.service
sudo chroot ${MNTROOTFS} systemctl enable xenconsoled.service
sudo chroot ${MNTROOTFS} systemctl enable xendomains.service
sudo chroot ${MNTROOTFS} systemctl enable xen-watchdog.service

cd ${WRKDIR}

sudo umount ${MNTROOTFS}proc || true
sudo umount ${MNTROOTFS}dev/pts || true
sudo umount ${MNTROOTFS}dev || true
sudo umount ${MNTROOTFS}sys || true
sudo umount ${MNTROOTFS}tmp || true
sudo umount ${MNTBOOT} || true
sudo umount ${MNTROOTFS} || true