Découverte de buildroot avec un raspberrypi

Carte en lecture seule

Étant donné que nous n’aurons pas d’interface pour nous connecter à la carte, elle va etre éteinte « sauvagement » régulièrement. Je préfère donc la basculer en lecture seule, ce qui permet aussi d’etre sûr que tout le système restera immuable sur la durée.

sed -ie '/^\\/dev\\/root/ s/rw 0 1/ro 0 0/' "${TARGET_DIR}/etc/fstab"

La modification est faite avec sed, et permet de suite de voir un peu comment on va modifier le système :

• Chaque modification sera faite à l’aide des outils disponibles dans bash (sed, cp, cat, …), il faut donc déjà etre à l’aise avec le terminal avant d’aller modifier la configuration
• Chaque command nécessite de savoir comment sont construits les fichiers que l’on veut modifier
• Dans le cas où nous ajoutons des nouvelles entrées dans un fichier, il faudra contrôler avant que cette entrée n’est pas déjà présente
• Et enfin, nous allons avoir du boulot pour modifier chaque élément un à un…

La variable ${TARGET_DIR} est fournie par buildroot et permet de cibler l’image que nous sommes en train de construire (par opposition au système hote dans lequel nous compilons le système). Ici, nous modifions bien le fichier /etc/fstab final, et non pas notre système linux !

# Traite les variables non définies comme des erreurs lors de la substitution.
set -u

Ajout du wifi

Pour activer le wifi, nous allons laisser systemd faire le travail, wpa_supplicant propose en effet un service paramétré, qui active l’interface spécifiée dans le nom (ici wlan0), il suffit donc de créer un lien symbolique pour que celui-ci soit activé au démarrage :

# Create the link to interface wlan0 directly in the system configuration
ln -sf /usr/lib/systemd/system/wpa_supplicant@.service "${TARGET_DIR}/usr/lib/systemd/system/multi-user.target.wants/wpa_supplicant@wlan0.service"

(par contre, cela implique d’installer systemd sur la carte, ce qui surcharge les dépendances, mais cela simplifie notre travail finalement…)

La configuration de la carte est comme d’habitude dans un fichier wpa_supplicant.conf qui n’est pas versionné, mais qui sera copié s’il est présent dans le répertoire.

if [ -f "$BR2_EXTERNAL_PIAUDIO_PATH/wpa_supplicant.conf" ]; then
    cat "$BR2_EXTERNAL_PIAUDIO_PATH/wpa_supplicant.conf" > "${TARGET_DIR}/etc/wpa_supplicant/wpa_supplicant-wlan0.conf"
    …
fi

La variable $BR2_EXTERNAL_PIAUDIO_PATH correspond au répertoire de base du système, c’est-à-dire notre répertoire racine. Il s’agit également d’une autre variable d’environnement fournie par buildroot qui nous permet de ne pas avoir à nous soucier de l’emplacement du script quand nous lançons notre compilation.

Pulseaudio

Vient ensuite pulseaudio. Nous n’avons pas à nous occuper de le démarrer avec le système car cela est fourni par un paquet ayant été sélectionné.

Par contre, puisque le système est en lecture seule, nous avons quelques modifications à réaliser pour que le service fonctionne : nous allons créer un répertoire, et le monter en mémoire au démarrage afin que pulseaudio puisse y stocker ses fichiers :

create_missing_dir "/var/lib/pulse"
if ! grep -qE '/var/lib/pulse' "${TARGET_DIR}/etc/fstab"; then
    cat << __EOF__ >> "${TARGET_DIR}/etc/fstab"
tmpfs /var/lib/pulse tmpfs rw 0 0
__EOF__
fi

Ensuite, nous allons modifier le fichier /etc/pulse/system.pa afin d’y ajouter les modules bluetooth, et la connexion distante :

if ! grep -qE '^load-module module-native-protocol-tcp' "${TARGET_DIR}/etc/pulse/system.pa"; then
    cat << __EOF__ >> "${TARGET_DIR}/etc/pulse/system.pa"
load-module module-bluetooth-policy
load-module module-bluetooth-discover
load-module module-native-protocol-tcp auth-ip-acl=127.0.0.1;192.168.0.0/24;2a01:e35:8ac8:0e00::/64 auth-anonymous=1
__EOF__
fi

Bluetooth

D’abord, pour activer le bluetooth, nous allons indiquer au noyau de le charger au démarrage :

cat << __EOF__ >> "${BINARIES_DIR}/rpi-firmware/config.txt"
dtparam=krnbt=on
__EOF__

Cette option ajoutée récemment dans les raspberrypi va nous éviter d’avoir à lancer les commande bt-attach ou hciattach. le bluetooth est automatiquement branché sur le port uart, à la vitesse maximale prise en charge par la carte. Cela résoud en une ligne énormément de problèmes rencontrés lors de la configuration du bluetooth si l’on avait voulu faire cela manuellement.

Voir la liste des options possibles sur la page suivante : https://github.com/raspberrypi/firmware/tree/master/boot/overlays

Par contre, il faut libérer pour cela la connexion série, qui est configurée par défaut sur le port ttyAMA0. Il nous faut supprimer la ligne suivante dans le fichier cmdline.txt : console=ttyAMA0,115200

Ensuite, comme précédemment, nous allons également créer un répertoire en mémoire pour pallier le système en lecture seule de la carte :

create_missing_dir "/var/lib/bluetooth/"
if ! grep -qE '/var/lib/bluetooth' "${TARGET_DIR}/etc/fstab"; then
    cat << __EOF__ >> "${TARGET_DIR}/etc/fstab"
tmpfs /var/lib/bluetooth tmpfs rw 0 0
__EOF__
fi

La configuration du bluetooth est lue dans le fichier /etc/bluetooth/main.conf, c’est donc là que nous allons y stocker les paramètres génériques : classe de l’appareil et timeouts :

[General]

Class = 200428
DiscoverableTimeout = 0
PairableTimeout = 0

[Policy]
AutoEnable=true

Enfin, nous avons besoin d’autoriser les connexions externes, et ce, sans aucun accès au système. Cela s’effectue par le biais d’un agent qui demande la confirmation d’un code auprès des deux parties (celui qui veut se connecter, et celui qui accepte les connexions) pour éviter les erreurs. Ici, nous faire fi de la sécurité, et ouvrir les connexions à n’importe qui. Les risques sont limités (le système est en lecture seule, aucune des applications de base permettant de détourner l’ordinateur n’est installée).

C’est un problème que j’avais rencontré dans mon système d’origine, et qui nécessitait de se connecter sur le raspberrypi pour autoriser le périphérique. J’ai finalement trouvé une solution (qui se résume en quelques lignes, mais qui m’a occupé quelques heures avant d’en arriver là).

On va se créer un service systemd (puisqu’il est là…) qui lance un agent perpétuel chargé d’accepter toutes les connexions :

cat << __EOF__ > "${TARGET_DIR}/etc/systemd/system/bt-agent.service"
[Unit]
Description=Bluetooth Agent
After=bt-audio.service
Requires=bt-audio.service

[Service]
Type=simple
ExecStartPre=bt-adapter --set Discoverable 1
ExecStart=bt-agent -c NoInputNoOutput
RestartSec=5
Restart=always
KillSignal=SIGUSR1

[Install]
WantedBy=bluetooth.target
__EOF__

Au passage, ce service déclare le bluetooth en mode « découvrable », ce qui rend vraiment le service ouvert à tous.

Connexion série

Enfin, il faut que nous puissions nous connecter à la carte pour contrôler qu’elle démarre correctement. Or, nous n’avons installé aucun serveur ssh : celle-ci est donc vérouillée. Par contre, le raspberrypi 0 nous offre une chance, puisqu’il est possible de s’y connecter en le branchant directement en usb, mais encore faut-il activer cette option au démarrage…

Il suffit d’ajouter une ligne dans le fichier cmdline.txt et le tour est joué :

if ! grep -qE 'modules-load=dwc2,g_serial' "${BINARIES_DIR}/rpi-firmware/cmdline.txt"; then
    sed '/^root=/ s/$/ modules-load=dwc2,g_serial/' -i "${BINARIES_DIR}/rpi-firmware/cmdline.txt"
fi