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.

Logigramme de la reprise d'un firmware existant en cinq phases : sécuriser les actifs, build reproductible, reproduire les défauts, cartographier et évaluer, corriger et livrer. Un point de décision après l'évaluation choisit entre corrections ciblées et réécriture partielle, et chaque phase produit un livrable écrit.
Figure 1. Phases de reprise et leurs livrables. La décision entre corriger et réécrire vient après l'évaluation, pas avant.

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 :

ActifPourquoi il compte
Code source, toutes les branches et archivesL’évidence ; chercher plusieurs copies et les comparer
Installeurs de la chaîne de compilation et versions exactesLa version du compilateur change la génération de code et le timing
Scripts de build, fichiers de projet IDE, scripts d’édition de liensPortent options d’optimisation, plan mémoire et defines absents des sources
Binaires actuellement sur le terrain, avec leurs versionsProuvent quelles sources correspondent à quels équipements
Sources et clés du bootloader, s’il y en aSans elles, les équipements ne pourront peut-être pas être mis à jour
Outils de programmation et procédure de la ligne de productionNécessaires pour fabriquer de nouveaux équipements
Fichiers de conception électronique à chaque révision de carteLe firmware se ramifie selon la révision de carte
Remontées d’anomalies, logs terrain, e-mails clientsLes é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.

  1. Recréer la chaîne de compilation dans un conteneur ou une VM documentée, en figeant les versions.
  2. 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.
  3. 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.
  4. 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 :

DomaineCe que nous examinons
StructureModules, couches, organisation des accès au matériel
ConcurrenceGestionnaires d’interruption, tâches RTOS, données partagées, priorités
MémoireTaille des piles, usage du tas, gestion des buffers, constats d’analyse statique
Gestion des erreursComportement en cas de panne de périphérique et de timeout, usage du watchdog
Chemin de mise à jourSi les équipements peuvent être mis à jour, et avec quel niveau de sûreté
TestsCe qui existe, ce qui peut être ajouté à moindre coût
Couplage matérielDé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 ?

IndiceOriente vers
Défauts ramenés à quelques défauts précisCorrections ciblées
Produit sur le terrain avec un chemin de mise à jour fonctionnelCorrections 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âchesRéécriture partielle de ce sous-système
La plateforme matérielle change de toute façonLa réécriture peut s’envisager avec la nouvelle plateforme
Pas de build reproductible et sources manquantes pour des parties clésLa 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

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.