Reprendre une base de code embarqué existante
EN BREF : Reprendre un firmware existant commence par sécuriser ce qui existe et rendre le build reproductible, puis par reproduire sur un équipement de banc les défauts signalés sur le terrain. Ce n’est qu’ensuite que nous cartographions le code, écrivons les risques et corrigeons d’abord les problèmes les plus sûrs et les plus utiles. Une réécriture n’est envisagée que si les éléments montrent que l’ancienne structure continue de produire de nouveaux défauts.
1.0 Le point de départ habituel
Une reprise typique : le développeur ou le prestataire d’origine est parti. Les sources sont dans une archive, ou en partie sur l’ordinateur portable de quelqu’un. Le build fonctionne sur une seule machine, avec une chaîne de compilation que personne ne se souvient d’avoir installée. Des équipements sont sur le terrain et les remontées arrivent : resets, blocages, une fonction qui échoue avec un modèle de téléphone précis. On attend une correction rapide.
La tentation est de lire le code et de patcher tout de suite. Sans build reproductible ni défaut reproduit, un patch qui vise la mauvaise cause livre un second défaut à côté du premier.
2.0 Phase 1 : sécuriser les actifs
Rassemblez tout avant que cela disparaisse :
| Actif | Pourquoi il compte |
|---|---|
| Code source, toutes les branches et archives | L’évidence ; chercher plusieurs copies et les comparer |
| Installeurs de la chaîne de compilation et versions exactes | La version du compilateur change la génération de code et le timing |
| Scripts de build, fichiers de projet IDE, scripts d’édition de liens | Portent options d’optimisation, plan mémoire et defines absents des sources |
| Binaires actuellement sur le terrain, avec leurs versions | Prouvent quelles sources correspondent à quels équipements |
| Sources et clés du bootloader, s’il y en a | Sans elles, les équipements ne pourront peut-être pas être mis à jour |
| Outils de programmation et procédure de la ligne de production | Nécessaires pour fabriquer de nouveaux équipements |
| Fichiers de conception électronique à chaque révision de carte | Le firmware se ramifie selon la révision de carte |
| Remontées d’anomalies, logs terrain, e-mails clients | Les éléments de preuve des défauts |
Placez les sources sous gestion de versions immédiatement si ce n’est pas déjà fait, avec l’archive inchangée comme premier commit. Les clés de signature et les identifiants vont dans un coffre de clés adapté, pas dans le dépôt.
Parlez à toutes les personnes qui ont travaillé sur le produit tant qu’elles sont joignables : l’ancien développeur, la ligne de production, l’équipe support. Une heure avec l’ancien développeur peut expliquer une bizarrerie du build ou un contournement terrain qu’il faudrait des jours pour retrouver dans le code. Mettez les notes par écrit et rangez-les avec le dépôt.
3.0 Phase 2 : rendre le build reproductible
L’objectif est de produire, à partir des sources, un binaire identique à celui du terrain, ou d’expliquer chaque différence.
- Recréer la chaîne de compilation dans un conteneur ou une VM documentée, en figeant les versions.
- Compiler et comparer la sortie au binaire terrain. Les différences dues à des horodatages ou chemins embarqués sont attendues ; des différences de code, non.
- En cas d’écart, chercher la révision des sources qui correspond. Si aucune ne correspond, le consigner comme constat : le firmware terrain contient peut-être des modifications jamais commitées.
- Ajouter un script de build et de l’intégration continue pour que n’importe qui puisse compiler en une commande.
La définition du projet Reproducible Builds est une bonne cible. Même une reproductibilité partielle indique si l’on travaille bien sur le code qui tourne réellement sur le terrain.
4.0 Phase 3 : reproduire les défauts
Installez un ou plusieurs équipements de banc correspondant aux révisions matérielles du terrain. Pour chaque défaut signalé :
- Noter les symptômes rapportés et les conditions : version firmware, révision matérielle, environnement, séquence d’actions.
- Ajouter des logs ou des traces si le firmware n’en a pas, dans un build séparé par ailleurs identique à la version terrain.
- Tenter de reproduire en faisant varier les conditions suspectes : qualité de l’alimentation, température, environnement radio, fonctionnement prolongé, équipements hôtes particuliers.
- Consigner ce qui s’est reproduit, ce qui ne s’est pas reproduit, et avec quel degré de certitude.
Certains défauts ne se reproduiront pas au banc. Ce résultat est dit clairement, avec les hypothèses et les données terrain qui aideraient, par exemple un build instrumenté sur des équipements terrain que vous sélectionnez.
5.0 Phase 4 : cartographier et évaluer
On lit maintenant le code avec un objectif. Nous rédigeons une courte évaluation qui couvre :
| Domaine | Ce que nous examinons |
|---|---|
| Structure | Modules, couches, organisation des accès au matériel |
| Concurrence | Gestionnaires d’interruption, tâches RTOS, données partagées, priorités |
| Mémoire | Taille des piles, usage du tas, gestion des buffers, constats d’analyse statique |
| Gestion des erreurs | Comportement en cas de panne de périphérique et de timeout, usage du watchdog |
| Chemin de mise à jour | Si les équipements peuvent être mis à jour, et avec quel niveau de sûreté |
| Tests | Ce qui existe, ce qui peut être ajouté à moindre coût |
| Couplage matériel | Dépendances à la révision de carte, constantes magiques liées aux composants |
Les outils d’analyse statique et les avertissements du compilateur à niveau élevé produisent de longues listes sur du code ancien. Nous les trions selon leur probabilité d’expliquer les défauts signalés, plutôt que d’essayer de tout résorber.
6.0 Phase 5 : corriger, vérifier et livrer
Corrigez d’abord les problèmes au meilleur rapport impact/risque, chacun sous forme de petite modification relue, avec un test qui reproduit le défaut avant la correction et passe après. Livrez les corrections dans des versions qui changent le moins de choses possible. Votre équipe décide quand une version sort et quand elle est déployée sur le parc, à partir des preuves de test que nous fournissons.
6.1 Corriger ou réécrire ?
| Indice | Oriente vers |
|---|---|
| Défauts ramenés à quelques défauts précis | Corrections ciblées |
| Produit sur le terrain avec un chemin de mise à jour fonctionnel | Corrections ciblées, puis refonte progressive |
| De nouveaux défauts continuent d’apparaître pour la même cause structurelle, par exemple un état partagé non protégé entre tâches | Réécriture partielle de ce sous-système |
| La plateforme matérielle change de toute façon | La réécriture peut s’envisager avec la nouvelle plateforme |
| Pas de build reproductible et sources manquantes pour des parties clés | La réécriture des parties manquantes est inévitable |
Réécrire entièrement un firmware déployé comporte son propre risque : l’ancien code contient des corrections de problèmes que personne n’a écrits. Quand nous recommandons de réécrire une partie du système, nous disons pourquoi et gardons l’ancien comportement comme référence de test.
7.0 Ce que vous obtenez à chaque phase
- Inventaire des actifs et dépôt avec l’archive d’origine comme base.
- Build reproductible avec chaîne de compilation documentée et intégration continue.
- Rapport de reproduction des défauts.
- Évaluation du code avec risques classés.
- Corrections avec tests et notes de version.
Ces livrables sont utiles que le travail se poursuive avec nous ou non. La page Reprise de firmware existant et dépannage terrain décrit le démarrage d’une mission, et Firmware embarqué couvre le développement de nouveaux firmwares. Pour décrire votre situation, utilisez Parler de votre projet.
Références
- Reproducible Builds, definition: https://reproducible-builds.org/docs/definition/
Questions fréquentes
L'ancien prestataire refuse de nous donner le code source. Que faire ?
Partir de ce que vous avez : les binaires, les équipements et la documentation existante. Une partie du comportement se comprend à partir de là, et l'évaluation montrera quelles parties il faudrait réécrire. Relisez aussi le contrat avec l'ancien prestataire : il prévoit peut-être déjà la remise des sources.
Combien de temps avant de pouvoir corriger le premier bug ?
Cela dépend de la vitesse à laquelle le build devient reproductible et le défaut se reproduit. Ces deux étapes varient davantage que la correction elle-même ; nous rendons donc compte de l'avancement de chacune et chiffrons les corrections une fois les deux terminées.
Pouvez-vous travailler sans accès aux équipements sur le terrain ?
Nous commençons sur des équipements de banc à la même révision matérielle ; l'accès terrain n'est nécessaire que si le défaut dépend de l'installation, du câblage ou de l'environnement radio. Dans ce cas, un build instrumenté sur des équipements terrain que vous choisissez est le moyen pratique d'obtenir des données.
Allez-vous changer le style ou la structure du code ?
Seulement là où cela réduit le risque. Les premières corrections restent petites et proches du style existant pour pouvoir être relues. Une refonte plus large est proposée à part, avec sa justification, une fois les tests en place.