Entrée-sortie, disques et RAID : périphériques et stockage

Un périphérique d’entrée-sortie transfère des données vers ou depuis un ordinateur, ou les conserve de manière persistante. Un clavier fournit des entrées ; une carte réseau envoie et reçoit des paquets ; un disque conserve les données après la coupure de l’alimentation. Les périphériques sont reliés par des bus, ou interconnexions. PCI Express (PCIe) relie les périphériques performants comme les SSD NVMe. SATA et USB desservent d’autres périphériques de stockage et périphériques situés plus loin dans la hiérarchie. Les interconnexions rapides coûtent plus cher à construire et ont des contraintes physiques plus strictes : un ordinateur en combine donc plusieurs types.

L’interface est ce que voit le logiciel

Un contrôleur peut contenir des processeurs, de la mémoire et un micrologiciel, le logiciel exécuté à l’intérieur du périphérique. Le système d’exploitation le contrôle par une interface matérielle exposée. Deux contrôleurs peuvent avoir des structures internes très différentes tout en prenant en charge les mêmes commandes.

Un périphérique simple possède trois registres :

Pour une opération de sortie simple, le noyau vérifie d’abord l’état jusqu’à ce que le périphérique soit prêt. Il écrit ensuite les données, écrit la commande et vérifie l’état jusqu’à la fin de l’opération. Enfin, il vérifie si une erreur s’est produite. Écrire la commande avant de fournir ses données pourrait lancer une opération avec un contenu erroné. La vérification répétée de l’état est la scrutation ; lorsque le processeur transfère les données utiles, il s’agit d’entrées-sorties programmées (PIO).

Accéder aux registres en toute sécurité

Les entrées-sorties par ports donnent aux registres un espace d’adressage distinct. Sur x86, des instructions comme in et out accèdent à ces ports. Le noyau contrôle le code autorisé à les exécuter. Les entrées-sorties mappées en mémoire (MMIO) placent les registres dans l’espace d’adressage physique : les instructions de lecture et d’écriture peuvent ainsi y accéder au moyen de projections contrôlées par les tables des pages du noyau. Les périphériques PCIe utilisent normalement MMIO.

Une adresse MMIO désigne une opération sur un périphérique, même si son accès ressemble à un accès mémoire. Une lecture peut effacer un indicateur. Une écriture peut lancer un transfert. L’état peut changer parce que le périphérique termine son travail, sans que le processeur écrive à cette adresse. Le comportement ordinaire du cache pourrait masquer ces changements ou combiner des accès dont le périphérique a besoin séparément.

Les pilotes Linux utilisent donc des fonctions d’accès comme readl() et writel(), des attributs de projection adaptés et les barrières mémoire nécessaires. Un pointeur volatile peut empêcher le compilateur de supprimer ou de fusionner des accès, mais ne garantit pas entièrement leur ordre par rapport à la mémoire ordinaire ou face au réordonnancement du processeur. Par exemple, un descripteur de commande en RAM doit être visible par le périphérique avant qu’un registre de notification lui demande de le récupérer.

Garder le contrôle des périphériques dans le noyau

Une application appelle normalement read() ou write(). Le noyau vérifie les permissions et exécute le protocole du périphérique pour son compte. Cela empêche un programme d’émettre des commandes qui perturbent la requête d’un autre programme. Un tampon utilisateur est la zone de données de l’application ; un registre de commande est le point de contrôle du contrôleur. Ils jouent des rôles différents, même si tous deux ont des adresses.

Un périphérique peut mettre bien plus de temps à terminer une requête que le processeur à l’émettre. La stratégie d’attente détermine si le processeur passe cet intervalle à vérifier le périphérique ou à exécuter d’autres tâches. Elle ne change pas la vitesse à laquelle le périphérique lui-même termine la requête.

Scruter ou se mettre en sommeil

Avec la scrutation, le processeur lit l’état à plusieurs reprises. La fin de l’opération peut être remarquée rapidement, mais les vérifications effectuées alors que le périphérique est encore occupé consomment du temps processeur. Avec les interruptions, un processus qui attend une lecture devient bloqué et un autre processus prêt peut s’exécuter. Lorsque le périphérique termine, il le signale au processeur. Le gestionnaire d’interruption du noyau vérifie la fin de l’opération, traite le résultat et remet le processus en attente à l’état prêt. L’ordonnanceur décide quand ce processus s’exécute de nouveau.

Supposons que le processus A lance une lecture sur disque qui prend 10 ms. La scrutation occupe le processeur pendant cette attente. Avec des entrées-sorties pilotées par interruption, le processus B peut effectuer des calculs pendant les mêmes 10 ms. L’opération du périphérique pour A dure toujours 10 ms ; des calculs utiles recouvrent l’attente.

Les interruptions demandent aussi du travail : le processeur sauvegarde l’état, exécute le gestionnaire, restaure l’état et peut changer de processus et remplir de nouveau les caches. Le coût est généralement de quelques microsecondes. Si un périphérique répond en 2 µs, une brève boucle de scrutation peut coûter moins cher que le blocage et le réveil du processus. Les interruptions conviennent aux opérations lentes ; une courte scrutation convient aux opérations très rapides.

S’adapter à la vitesse de fin des opérations et à la charge

Une stratégie hybride, ou à deux phases, effectue une brève scrutation, puis se met en sommeil en attendant une interruption si la requête n’est pas terminée. Les opérations rapides évitent un coût de réveil, tandis que les opérations lentes n’occupent pas le processeur pendant toute leur durée. Linux prend en charge la scrutation de la fin des opérations pour certaines requêtes de stockage rapides.

Un trafic d’interruptions important crée un autre problème. Si presque chaque cycle du processeur sert à traiter de nouveaux événements, le code qui consomme leurs données dispose de peu de temps pour s’exécuter. C’est le verrouillage actif : la machine est occupée, mais la progression utile s’effondre. Le mécanisme réseau NAPI de Linux limite le travail lié aux interruptions et passe à une scrutation par lots sous charge.

Le regroupement des interruptions rassemble plusieurs fins d’opération en une notification. Avec 100 000 fins d’opération par seconde et 5 µs de travail processeur par interruption, des notifications séparées coûtent :

Cela représente la moitié du temps d’un cœur de processeur chaque seconde. Regrouper huit fins d’opération par interruption donne 12 500 interruptions et 62,5 ms de travail processeur par seconde, soit 6,25 % d’un cœur. Une requête peut attendre brièvement son lot : la réduction du surcoût s’accompagne donc d’une latence de notification supplémentaire.

Envoyer les notifications au bon cœur

Les périphériques PCIe utilisent couramment MSI ou MSI-X, des interruptions transmises sous forme de messages à une adresse spéciale. Plusieurs vecteurs d’interruption permettent à un périphérique de diriger les fins d’opération de différentes files vers différents cœurs. Un contrôleur NVMe peut associer les files de chaque cœur à des vecteurs d’interruption adaptés, afin de rapprocher le travail de soumission et celui de traitement des fins d’opération. Des vecteurs plus nombreux organisent le travail du processeur ; ils ne raccourcissent ni une lecture flash ni une rotation de disque.

L’attente et la copie sont deux tâches distinctes. Les interruptions peuvent éviter au processeur d’attendre activement pendant qu’un périphérique travaille, mais le processeur resterait occupé s’il devait transférer chaque mot par un registre de données. L’accès direct à la mémoire (DMA) confie ce transfert à un moteur matériel, généralement situé dans le contrôleur du périphérique.

Mesurer le travail que les PIO laissent au processeur

Imagine un registre de données de 4 octets qui prend 100 ns par accès. Le transfert d’un bloc de 4 Kio nécessite :

Ces opérations sur le registre occupent le processeur. Des tampons plus grands nécessitent proportionnellement plus d’accès. Le DMA supprime cette copie mot par mot par le registre ; le processeur prépare toujours la requête et traite sa fin.

Suivre une lecture par DMA

1. Le pilote prépare un tampon de destination et le rend accessible au périphérique.
2. Il fournit l’adresse ou les adresses DMA, le nombre d’octets, le sens et la commande de lecture.
3. Le périphérique lit les blocs de stockage demandés et écrit les octets en mémoire.
4. Le processeur exécute d’autres tâches pendant que le périphérique transfère les données.
5. La fin de l’opération est signalée, généralement par une interruption. Le gestionnaire vérifie l’état et réveille le processus en attente.

Le moteur DMA agit comme maître de bus et lance les transferts mémoire. Les coûts de préparation dépendent de la projection, de la plateforme et du nombre de zones mémoire. Le DMA consomme aussi de la bande passante mémoire partagée avec le processeur. Il libère des instructions du processeur, pas toutes les ressources.

Décrire une mémoire dispersée

Un tampon peut être contigu dans l’espace d’adressage virtuel d’un processus tout en occupant des pages physiques distinctes. Une liste de dispersion-rassemblement décrit ces zones par des couples d’adresses et de longueurs. Un périphérique peut effectuer une requête sur plusieurs zones sans que le processeur les copie d’abord dans un seul tampon physiquement contigu.

Par exemple, un tampon de trois pages peut reposer sur trois pages non adjacentes. Le pilote crée des descripteurs pour les zones visibles par le périphérique et maintient stables les pages sous-jacentes jusqu’à la fin de l’opération. L’épinglage empêche ces pages d’être retirées ou réutilisées tant que le matériel peut encore y accéder. Les désépingler trop tôt risque de laisser une écriture DMA ultérieure écraser les données d’un autre utilisateur.

Utiliser l’espace d’adressage du périphérique

Un périphérique n’utilise normalement pas le pointeur virtuel d’une application. L’API DMA du noyau fournit des adresses de bus, qui peuvent différer des adresses physiques du processeur. Une IOMMU traduit les adresses des périphériques vers la mémoire physique et restreint la mémoire à laquelle un périphérique peut accéder. Cette isolation aide aussi un hyperviseur à attribuer un périphérique à une machine virtuelle.

Les caches du processeur ajoutent une étape de coordination. Avant un transfert DMA sortant, le périphérique doit voir les derniers octets écrits par le processeur ; après un transfert entrant, le processeur doit voir les mises à jour du périphérique. Certains matériels maintiennent automatiquement la cohérence. D’autres plateformes nécessitent une synchronisation des caches par l’API DMA. La projection des adresses, la durée de vie des pages et la visibilité dans les caches résolvent chacune une partie différente du problème de sécurité du transfert.

Un pilote de périphérique traduit une requête générale en commandes du contrôleur, en accès aux registres et en traitement de la fin de l’opération. Un système de fichiers peut ainsi demander un bloc sans savoir si le matériel utilise SATA, NVMe ou USB. Le pilote connaît le protocole et les particularités du contrôleur.

Attribuer une tâche à chaque couche

Sous Linux, une lecture sur un périphérique de stockage passe généralement par cette chaîne :

Application → appel système → système de fichiers → couche bloc générique → pilote → contrôleur → périphérique de stockage.

Le système de fichiers associe une position dans un fichier à des blocs de stockage. La couche bloc met les requêtes en file, fusionne celles qui sont adjacentes et peut ordonnancer leur exécution. Le pilote soumet les opérations qui en résultent. L’accès brut à un périphérique en mode bloc peut contourner le système de fichiers tout en utilisant les couches inférieures.

L’interface standard permet d’utiliser un nouveau matériel sans réécrire chaque application. Elle masque aussi certaines fonctions particulières. Des interfaces comme ioctl() ou celles qui transmettent directement des commandes permettent aux logiciels de demander des opérations de contrôle qui ne correspondent pas à une lecture ou une écriture de bloc ordinaire.

Distinguer les classes de périphériques

Linux expose les périphériques en mode bloc et en mode caractère sous forme de fichiers spéciaux, comme /dev/sda et /dev/nvme0n1. Les pilotes s’exécutent généralement en mode noyau : un bogue dans un pilote peut donc faire planter le noyau ou corrompre la mémoire. L’isolation des pilotes limite cette portée dans les systèmes qui la prennent en charge. Les pilotes Linux représentent une grande partie de son code source ; des études ont aussi montré que le code des pilotes est particulièrement sujet aux erreurs.

Mettre le travail en file entre les cœurs

La couche bloc blk-mq de Linux utilise des files logicielles par processeur et des files de répartition matérielles. Un ordonnanceur d’entrées-sorties comme mq-deadline, bfq ou kyber peut réordonner le travail ou gérer l’équité ; none évite une politique d’ordonnancement supplémentaire. Les disques durs profitent d’une réduction des déplacements de la tête. Les périphériques NVMe rapides utilisent souvent none, puisqu’ils n’ont pas de tête à repositionner. L’ordonnanceur sélectionné apparaît entre crochets dans /sys/block/<device>/queue/scheduler.

SATA avec AHCI/NCQ prend en charge une file contenant jusqu’à 32 commandes en attente par périphérique. NVMe prend en charge de nombreuses files de soumission et de complétion en mémoire : jusqu’à 65 535 files d’entrées-sorties, avec jusqu’à environ 64 000 commandes par file. Les limites des contrôleurs réels sont plus basses. Les paires de files par cœur réduisent la contention sur les chemins de soumission partagés.

Suivre une lecture NVMe

Un processus appelle read(fd, buf, 4096). En cas d’échec de cache, le système de fichiers trouve le bloc disque et la couche bloc construit une requête. Le pilote NVMe écrit un descripteur dans une file de soumission, puis écrit dans son registre de notification MMIO. Le contrôleur récupère la commande, transfère les données en mémoire par DMA et dépose une entrée de complétion. Une interruption MSI-X amène le noyau à terminer la requête. Lors d’une lecture avec mise en tampon, les données atteignent le tampon de l’application par le cache de pages, et read() renvoie 4096. Un succès de cache peut satisfaire la lecture avant qu’une entrée-sortie sur le périphérique soit nécessaire.

Un disque dur expose un tableau de secteurs numérotés à partir de zéro. Ces numéros sont des adresses de bloc logique (LBA). Un secteur faisait traditionnellement 512 octets ; de nombreux disques utilisent désormais des secteurs physiques de 4 096 octets. Un disque 512e accepte des secteurs logiques de 512 octets sur ce format physique plus grand. Un bloc de 4 Kio d’un système de fichiers peut donc couvrir plusieurs secteurs logiques.

Représenter les pièces mobiles

Des plateaux magnétiques tournent sur un axe. Chaque surface comporte des pistes concentriques divisées en secteurs et une tête de lecture-écriture montée sur un bras mobile. Les têtes se déplacent ensemble. Les pistes situées à la même position du bras sur les différentes surfaces forment un cylindre. Les vitesses de rotation courantes comprennent 5 400 et 7 200 tr/min, ainsi que 10 000 et 15 000 tr/min dans les familles de disques plus rapides.

Les LBA proches sont généralement placées à proximité, ce qui aide les lectures séquentielles à éviter les recherches répétées. Un secteur réaffecté à un secteur de réserve peut rompre cette relation. Les logiciels voient donc un espace d’adressage linéaire utile sans connaître le placement physique exact.

Les pistes extérieures offrent plus de place pour les secteurs. L’enregistrement par zones place davantage de secteurs sur ces pistes, si bien que plus d’octets passent sous la tête à chaque tour. Le débit séquentiel peut diminuer à mesure qu’une lecture se rapproche du centre. Le décalage de piste décale les positions des secteurs entre pistes voisines : après le changement de piste de la tête, le secteur séquentiel suivant arrive au bon moment au lieu de venir de passer.

Distinguer fin d’opération et durabilité

Un cache de disque peut conserver des données lues récemment et accepter des écritures. Ces tampons vont de quelques mégaoctets à des centaines de mégaoctets ; le cache de lecture peut conserver le reste d’une piste déjà passée sous la tête. Avec un cache à écriture différée, une écriture peut être terminée alors que ses données restent dans un cache volatil. L’écriture immédiate attend que les données soient sur le support. Un vidage du cache demande que les écritures en cache atteignent un stockage durable ; Force Unit Access (FUA) demande une fin d’écriture durable pour l’écriture concernée.

L’atomicité en cas de coupure de courant est une autre propriété. Une unité d’écriture atomique est entièrement modifiée ou reste inchangée en cas de coupure de courant. La taille du secteur ne fournit pas à elle seule une telle promesse : le périphérique doit documenter sa garantie. Une écriture qui couvre plusieurs unités atomiques peut laisser une écriture déchirée, avec certaines unités nouvelles et d’autres anciennes. Les vidages concernent la durabilité ; les unités atomiques concernent les mises à jour partielles.

Lire correctement les indications de capacité

Les capacités des disques utilisent les préfixes SI décimaux. Les unités binaires utilisent des puissances de deux :

Un disque de 4 To contient donc :

Les deux indications décrivent le même nombre d’octets. Un outil qui affiche environ 3,64 en le notant « TB » a utilisé un calcul binaire avec une notation qui paraît décimale ; la conversion n’a supprimé aucun espace.

Reconnaître une contrainte d’écriture supplémentaire

L’enregistrement magnétique en bardeaux (SMR) fait se chevaucher les pistes adjacentes pour stocker davantage de données. Réécrire une piste peut perturber sa voisine, ce qui rend les petites mises à jour aléatoires coûteuses. Les grandes écritures séquentielles dans des zones adaptées fonctionnent mieux. Il s’agit d’un disque magnétique soumis à une contrainte de gestion des écritures, même si les lectures ordinaires utilisent toujours les mêmes têtes et plateaux en rotation.

Une requête disque prend du temps pour atteindre les données avant de les transférer. Pour une requête simple sans attente en file ni succès de cache, décompose le temps de service en trois parties :

Le temps de recherche correspond au déplacement et à la stabilisation du bras sur la piste. La latence de rotation correspond à l’attente du passage du secteur sous la tête. Le temps de transfert couvre le passage des octets sous celle-ci. Une éventuelle mise en file ajoute une attente avant le début du service.

Convertir la vitesse de rotation en durée d’attente

Un tour prend 60 000 ms divisées par la vitesse en tr/min. À 7 200 tr/min :

Pour une position aléatoire du secteur, l’attente moyenne est d’un demi-tour, soit environ 4,17 ms. À 15 000 tr/min, un tour prend 4 ms et l’attente moyenne est de 2 ms. Une vitesse de rotation plus élevée réduit la latence de rotation ; elle ne réduit pas directement le temps de recherche du bras.

Les fiches techniques indiquent un temps de recherche moyen. Pour des requêtes uniformément réparties, la distance de recherche moyenne est d’environ un tiers de la course complète, mais le temps de recherche n’est pas proportionnel à la distance. L’accélération et la stabilisation dominent les recherches courtes ; les recherches longues comprennent davantage de déplacement à pleine vitesse.

Calculer une petite lecture aléatoire

Utilise un disque à 7 200 tr/min avec un temps de recherche moyen de 8 ms et un débit de transfert de 200 Mo/s. Une requête de 4 Kio contient 4 096 octets. Calcule d’abord le transfert en secondes :

Additionne ensuite le positionnement et le transfert :

Avec une seule requête en attente à la fois, on obtient environ :

Le débit effectif est d’environ 4 096 octets multipliés par 82 par seconde, soit 0,34 Mo/s. Un débit de transfert annoncé de 200 Mo/s décrit le transfert de données une fois la tête positionnée ; il ne peut pas supprimer les quelque 12 ms de positionnement nécessaires à chaque petite requête aléatoire.

Calculer une longue lecture séquentielle

Lis maintenant 100 Mo avec une seule recherche initiale et une seule attente de rotation. Le temps de transfert est de 100/200 s, soit 500 ms. Le temps total est d’environ 512,17 ms, ce qui donne :

Le débit effectif est environ 580 fois supérieur à celui de la petite lecture aléatoire. Un seul coût de positionnement est réparti sur bien plus d’octets. Les grands transferts séquentiels sont dominés par le temps de transfert ; les petites requêtes aléatoires sont dominées par le positionnement.

Utilise les octets de manière cohérente lorsque tu combines des Kio et des Mo/s, et convertis les millisecondes en secondes avant de diviser les octets par le temps. Les IOPS conviennent aux petites opérations aléatoires ; les Mo/s conviennent aux flux séquentiels. La lecture anticipée, le placement rapproché et le regroupement de petites écritures en lots séquentiels améliorent les performances en modifiant la fréquence à laquelle le coût du positionnement est payé.

Un ordonnanceur de requêtes disque choisit la prochaine requête en attente à servir. La position lui fournit des informations utiles sur le coût du service. Réduire le déplacement du bras aide, mais une politique doit aussi tenir compte du temps d’attente de chaque requête.

Comparer les politiques

SSTF peut choisir à répétition de nouvelles requêtes proches pendant qu’une requête éloignée attend. Un système d’exploitation qui ne connaît pas la géométrie exacte l’approche souvent par la distance entre LBA : c’est la politique du bloc le plus proche d’abord. L’équité des politiques de type SCAN suppose que le système puisse continuer à servir les requêtes pendant ses balayages ; un périphérique surchargé ne peut toujours pas garantir un temps de réponse fixe à chaque arrivée.

Additionner les déplacements étape par étape

Prends les pistes 0–199, une tête à 50 se dirigeant vers les numéros supérieurs et les requêtes arrivées dans l’ordre 82, 170, 43, 140, 24, 16, 190. Arrête le calcul lorsque toutes les requêtes sont terminées.

FCFS suit la liste. Son déplacement est de 32 + 88 + 127 + 97 + 116 + 8 + 174 = 642 pistes. SSTF passe par 43, 24, 16, 82, 140, 170, 190, soit 208 pistes au total.

SCAN passe par les requêtes de numéro supérieur, continue jusqu’à 199, puis inverse le sens jusqu’à 16. Sa distance est de 149 + 183 = 332. LOOK fait demi-tour à 190, soit 140 + 174 = 314. C-LOOK va de 50 à 190, revient à 16 et termine à 43 : 140 + 174 + 27 = 341 pistes. Le retour est un déplacement réel, même si aucune requête n’est servie pendant celui-ci. C-SCAN irait jusqu’à 199, reviendrait à 0 sans servir, puis servirait les requêtes en remontant jusqu’à 43.

Le meilleur total pour cette file finie ne détermine pas la meilleure politique pour un flux de requêtes futures. Le faible déplacement de SSTF s’accompagne ici d’un risque de famine si la charge continue.

Tenir compte de la rotation et du micrologiciel

La politique plus court temps de positionnement d’abord (SPTF) minimise la somme du temps de recherche et de la latence de rotation. Une piste plus éloignée peut être préférable si son secteur arrive plus tôt. Des choix précis nécessitent la géométrie et la position de rotation : le micrologiciel du disque est donc mieux placé que le système d’exploitation pour les effectuer.

Le système d’exploitation peut fusionner les requêtes portant sur des blocs adjacents, puis soumettre plusieurs commandes par NCQ. Le micrologiciel réordonne ce lot à l’aide d’informations internes. L’ordonnancement anticipatif peut laisser brièvement le disque inactif pour attendre une probable requête ultérieure proche. L’ordonnancement à échéance limite les reports ; mq-deadline sous Linux suit les expirations et favorise les lectures. L’ordonnancement des SSD se concentre sur l’équité et la latence, car il n’y a ni recherche mécanique ni rotation à éviter.

La mémoire flash NAND stocke les informations sous forme de charges électriques dans des cellules. Le contrôleur distingue les niveaux de charge pour lire les bits. Une cellule contenant plus de bits nécessite davantage de niveaux distincts, ce qui augmente la capacité mais complique la programmation et le contrôle des erreurs.

Compter les niveaux de charge

Pour une cellule de b bits, le nombre de niveaux est $2^b$. Plus de bits par cellule réduisent généralement le coût par gigaoctet, mais la programmation devient plus lente et l’endurance en cycles d’effacement diminue. Ce sont des propriétés de l’organisation des cellules ; le contrôleur et le parallélisme de l’ensemble du SSD influent aussi sur les performances.

Associer chaque opération à son unité

Les puces flash contiennent des blocs d’effacement, chacun contenant de nombreuses pages. Une page fait généralement de 4 à 16 Kio, tandis qu’un bloc d’effacement peut contenir des centaines de pages et occuper de centaines de Kio à plusieurs Mio. Une page de mémoire flash, une page de mémoire virtuelle et un bloc de système de fichiers sont des unités distinctes, même si certaines tailles coïncident parfois.

Une lecture renvoie une page, généralement en quelques dizaines de microsecondes. Une programmation écrit une page effacée et prend des centaines de microsecondes. Un effacement remet tous les bits d’un bloc entier à un et prend des millisecondes. Les pages sont programmées dans l’ordre imposé par la puce, généralement des pages de numéro inférieur vers celles de numéro supérieur. Le contrôleur doit respecter ces règles d’ordre lorsqu’il place les données.

Une page utilisée ne peut pas simplement recevoir une version de remplacement. Son bloc d’effacement doit d’abord être effacé, ce qui détruit le contenu de chaque page de ce bloc. C’est le décalage central : les écritures portent sur des pages, tandis que les effacements portent sur des blocs.

Voir le coût d’une mise à jour sur place

Imagine un bloc contenant les pages A, B, C et D. Pour remplacer A par A′ tout en conservant le même placement physique :

1. Lis B, C et D dans un espace de stockage temporaire.
2. Efface le bloc entier, y compris l’ancien A.
3. Programme A′, B, C et D dans les pages effacées.

Une page de nouvelles informations a entraîné trois lectures, quatre programmations et un effacement. Il est impossible d’effacer seulement A. Un SSD évite de payer ce coût à chaque réécriture demandée par l’hôte en écrivant la nouvelle version ailleurs et en modifiant sa correspondance.

Gérer les dommages et la conservation des données

Chaque cycle de programmation-effacement (P/E) endommage légèrement les cellules. Les plages d’endurance représentatives sont d’environ 50 000 à 100 000 cycles pour les SLC, 1 000 à 3 000 pour les TLC et environ 1 000 ou moins pour les QLC ; les valeurs réelles varient fortement selon la génération de la puce et le fabricant. Les contrôleurs retirent du service les blocs devenus peu fiables.

La charge se dissipe aussi avec le temps, surtout dans les cellules usées. La lecture ou la programmation peut perturber les cellules voisines. De puissants codes correcteurs d’erreurs (ECC) corrigent de nombreuses erreurs de bits qui en résultent, et le contrôleur peut rafraîchir les données dont le nombre d’erreurs augmente. La mémoire flash est un stockage persistant dont les opérations sont asymétriques et l’endurance limitée : la rapidité d’une lecture de page ne dit donc pas grand-chose du coût de réécritures soutenues.

L’hôte lit et réécrit des blocs logiques. La couche de traduction flash (FTL) du SSD associe ces adresses à des pages physiques de mémoire flash et gère les effacements qu’elles masquent. Garder en permanence la page logique N à la page physique N obligerait les réécritures fréquentes à effacer les mêmes blocs à répétition.

Écrire une nouvelle version ailleurs

Une FTL structurée en journal programme les nouvelles données dans une page libre et modifie leur correspondance. Supposons que la LBA 100 corresponde à la page physique 0 et la LBA 101 à la page 1. Une réécriture de la LBA 100 est programmée dans la page 2. La correspondance devient 100 → 2 ; la page 0 devient invalide. L’hôte demande toujours la LBA 100 et obtient la nouvelle version.

Invalide est un état de la correspondance, pas un effacement physique immédiat. Les anciens bits restent présents jusqu’à la récupération de leur bloc d’effacement. La suppression ou la réécriture d’un fichier ne donne donc aucune garantie fiable sur le moment où chaque ancienne copie physique disparaît. Un effacement fiable utilise une opération d’assainissement adaptée du disque ou un système de chiffrement de tout le disque correctement géré avec destruction de la clé.

Récupérer l’espace et compter les écritures supplémentaires

Le ramasse-miettes (GC) choisit un bloc, copie ses pages valides ailleurs, met à jour la table de correspondance et efface l’ancien bloc. Les pages invalides n’ont pas besoin d’être copiées. Un bloc contenant de nombreuses pages invalides fournit plus d’espace libre par page valide copiée.

L’amplification des écritures (WA) mesure ces programmations supplémentaires :

Dans un bloc de 64 pages contenant 48 pages valides et 16 pages invalides, le ramasse-miettes copie 48 pages. L’effacement du bloc crée 64 pages libres, mais les copies ont consommé 48 pages ailleurs : le gain net est de 16. Remplir cet espace avec 16 pages de l’hôte produit 64 programmations de pages flash pour 16 écritures de pages par l’hôte, donc WA = 4. Une amplification plus élevée consomme plus vite la bande passante et l’endurance en cycles d’effacement.

Le surprovisionnement réserve un espace flash que l’hôte ne peut pas remplir. Davantage d’espace libre donne au ramasse-miettes la possibilité de choisir des blocs moins coûteux à récupérer. TRIM, appelé Deallocate dans NVMe et UNMAP dans SCSI, indique au périphérique les plages logiques qui ne contiennent plus de données nécessaires. Les pages d’un fichier supprimé peuvent alors être traitées comme invalides au lieu d’être copiées par le ramasse-miettes.

Prévoir la mémoire de correspondance et gérer l’usure

Une table de correspondance au niveau des pages nécessite une entrée par page logique. Un périphérique de 1 Tio avec des pages de 4 Kio possède :

À raison de 4 octets par entrée, la table occupe 1 Gio. La correspondance au niveau des blocs réduit la taille de la table, mais rend les petites mises à jour coûteuses. La correspondance hybride combine des tables de blocs et des zones de journal associées page par page ; une autre approche ne met en cache que les entrées actives de la table de pages.

La répartition de l’usure distribue les effacements entre les blocs. Les nouvelles écritures changent déjà d’emplacement, mais les blocs contenant des données froides et inchangées pourraient sinon éviter l’usure indéfiniment pendant que les zones chaudes s’usent. Déplacer certaines données froides libère des blocs peu utilisés qui rejoignent l’ensemble des blocs disponibles pour l’écriture. Cette migration peut ajouter des écritures : le contrôleur cherche donc un équilibre entre usure uniforme et coût de copie.

Un SSD n’a ni bras de disque ni plateau en rotation. Il évite les délais de positionnement de plusieurs millisecondes, mais sa vitesse dépend toujours de la taille des requêtes, du parallélisme, des écritures précédentes et du travail que son contrôleur effectue en arrière-plan.

Comparer latence et débit

Ces classes de périphériques sont représentatives et ne constituent pas des garanties pour chaque disque. Le débit d’un SSD SATA est limité par la liaison à 6 Gbit/s. NVMe utilise PCIe et peut occuper de nombreux canaux flash à la fois.

Un programme qui lance une petite lecture et attend sa fin avant de lancer la suivante subit la latence de chaque requête. Si la latence est de 80 µs, cette exécution en série permet environ 12 500 opérations par seconde. Un périphérique annoncé avec un nombre d’IOPS bien supérieur nécessite de nombreuses requêtes en cours, fournies par des fils d’exécution ou des entrées-sorties asynchrones. La profondeur de file crée des possibilités de travail en parallèle ; elle peut aussi ajouter de l’attente lorsque le périphérique est saturé.

Tenir compte des écritures précédentes

Les écritures aléatoires et séquentielles restent différentes. Les mises à jour aléatoires peuvent laisser des pages invalides dispersées parmi les pages valides, ce qui augmente les copies du ramasse-miettes. Les charges séquentielles peuvent invalider des zones entières ensemble, ce qui rend leur récupération moins coûteuse et maintient l’amplification des écritures plus près de un. Un SSD vide peut programmer directement dans l’espace libre ; un SSD rempli doit le récupérer. Les performances en régime permanent comprennent ce coût continu du ramasse-miettes, contrairement aux tests réalisés à la sortie de la boîte.

Lire les valeurs d’endurance comme un budget d’écriture

La valeur TBW indique le total de téraoctets écrits par l’hôte. La valeur DWPD exprime le nombre d’écritures complètes du disque par l’hôte par jour sur la période de garantie. Pour un périphérique de 1 To donné pour 600 TBW sur cinq ans :

À raison de 50 Go par jour, 600 To d’écritures de l’hôte s’accumuleraient après 12 000 jours, soit environ 33 ans. Ce calcul compare des charges de travail et ne prévoit pas la durée de vie : les pannes de contrôleur, le vieillissement et les limites de garantie comptent toujours. Une forte amplification interne use les cellules plus rapidement, même si la valeur d’endurance compte les écritures de l’hôte.

Adapter le périphérique au travail

Les disques durs offrent un faible coût par téraoctet pour les grands ensembles de données rarement consultés. Les SSD conviennent aux tâches sensibles à la latence. Le stockage hiérarchisé conserve les données chaudes sur des SSD et les données plus froides sur des disques durs. Les deux peuvent tomber en panne : les disques durs subissent des défauts mécaniques et des secteurs défectueux ; les SSD subissent l’usure, des défauts de contrôleur et des bogues de micrologiciel. La redondance et des sauvegardes séparées restent utiles pour les deux.

Sur les SSD, la défragmentation ajoute des écritures pour peu de gain lié aux recherches. TRIM aide le contrôleur à identifier les données inutilisées. Les outils de partitionnement actuels alignent généralement les débuts de partition sur des frontières de 1 Mio, ce qui évite les requêtes de blocs mal alignées.

Le RAID, une grappe redondante de disques peu coûteux ou indépendants, présente plusieurs disques physiques comme un seul périphérique logique en mode bloc. En interne, une correspondance dirige chaque bloc logique vers des copies de données ou vers une rangée avec redondance. Les applications et les systèmes de fichiers peuvent continuer à utiliser l’interface en mode bloc sans comprendre cette organisation.

Comparer trois critères distincts

La capacité est l’espace utilisable pour les données utilisateur. La fiabilité décrit les pannes qu’une organisation peut tolérer. Les performances comprennent à la fois le débit sur de nombreuses opérations et la latence d’une seule opération. Un niveau peut améliorer un critère tout en en réduisant un autre. Un débit global supérieur ne réduit pas non plus nécessairement la latence d’une seule requête de bloc.

Utilise ce modèle simple pour des disques de même taille :

S et R utilisent les mêmes unités de débit, comme les Mo/s. Sur un disque dur, ils diffèrent fortement : l’exemple précédent donnait environ 195 Mo/s en séquentiel et 0,34 Mo/s pour les petites lectures aléatoires. Les formules du modèle supposent suffisamment de travail concurrent et l’absence de goulot d’étranglement dans le contrôleur ; leur but est de faire apparaître les coûts de l’organisation.

Préciser le modèle de panne

Un disque relevant du modèle de panne par arrêt fonctionne correctement jusqu’à ce qu’il tombe complètement et visiblement en panne. Cela facilite le raisonnement de base sur le RAID : la grappe sait quel disque manque. Les disques réels peuvent aussi avoir des secteurs illisibles ou renvoyer des octets incorrects. Ces défauts partiels et silencieux nécessitent des contrôles d’intégrité en plus d’une organisation qui résiste à la perte d’un disque entier.

Une grappe redondante fonctionne en mode dégradé tant que les disques en panne restent dans les limites de sa tolérance. Elle continue à fournir les données, mais les disques restants effectuent un travail supplémentaire ou disposent de moins de capacité de lecture disponible. Une reconstruction remplit un disque de remplacement à partir des informations restantes. Un disque de secours à chaud est un disque inutilisé déjà installé qui permet de commencer rapidement la reconstruction. RAID-0 n’a aucune redondance et ne dispose pas d’un tel état de fonctionnement dégradé après la perte d’un disque membre.

Maintenir la cohérence des mises à jour sur plusieurs disques

Le RAID peut fonctionner dans un contrôleur matériel doté de son propre processeur et d’un cache protégé, dans un logiciel du système d’exploitation comme md sous Linux, ou dans un système de fichiers comme ZFS. Chacun doit traiter une écriture interrompue entre les mises à jour de différents disques. Les miroirs peuvent différer ; les données et la parité peuvent décrire des versions différentes. Le cas de la parité est le trou d’écriture.

Un cache non volatil protégé ou un journal adapté peut conserver les mises à jour en attente pour la reprise. Une table de bits d’intention d’écriture enregistre les zones à resynchroniser après une interruption. Elle ne conserve pas les nouvelles données et ne constitue pas à elle seule une solution complète au trou d’écriture de parité lorsqu’un disque manque aussi.

Le RAID maintient la disponibilité malgré les pannes de disque prévues. Une suppression ou une écriture par un rançongiciel atteint les copies de la grappe par l’interface normale. Un incendie ou un vol peut faire disparaître toute la grappe. Des sauvegardes séparées fournissent des versions ou des copies récupérables malgré ces événements qui touchent toutes les copies.

RAID-0 entrelace les données entre les disques sans conserver d’informations redondantes. Avec une bande d’un bloc et une numérotation commençant à zéro, le bloc logique A va à :

Pour quatre disques, le bloc 14 appartient au disque 2 au déplacement 3. Le modulo choisit le disque ; la division entière compte les rangées complètes avant ce bloc.

Tenir compte de la taille de bande dans la correspondance

Une bande est une suite de blocs consécutifs placés sur un disque avant de passer au suivant. Soit c sa taille en blocs. Identifie d’abord la bande, puis le disque et le déplacement local :

Pour le bloc 14, c = 2 et N = 4, la bande est 7, le disque est 3 et le déplacement est 2. Utiliser directement A modulo N ignorerait les bandes de deux blocs. De petites bandes peuvent répartir une grande requête sur davantage de disques ; de plus grandes bandes gardent davantage de travail proche sur un même disque. Les bandes courantes des grappes vont de 64 à 512 Kio ; md sous Linux utilise généralement 512 Kio par défaut.

RAID-0 a une capacité NB et des débits globaux idéaux NS en séquentiel et NR en aléatoire. Une petite requête sur un seul disque prend toujours environ T. La panne d’un disque membre entraîne la perte d’une partie des données de la grappe : cette organisation convient donc aux données temporaires reproductibles lorsque la disponibilité n’est pas importante.

Ajouter des copies en miroir

Un miroir RAID-1 à deux disques écrit chaque bloc sur les deux membres. RAID-10 entrelace les données entre des paires en miroir. Avec quatre disques et des bandes d’un bloc entre les paires, le bloc A va dans la paire A modulo 2 au déplacement obtenu par division entière de A par 2, et les deux membres le stockent.

RAID-10 utilise la moitié de la capacité brute. Il résiste à toute panne unique et peut résister à N/2 pannes si chacune touche une paire différente. La perte des deux membres d’une paire entraîne la perte des données de cette paire, même si toutes les autres restent en bon état.

Compter le travail utile par disque

Chaque écriture en miroir met à jour deux disques en parallèle. Sa latence est d’environ T, déterminée par le membre le plus lent, tandis que le débit global des écritures aléatoires est NR/2. Les lectures peuvent être réparties entre toutes les copies, ce qui donne NR si les lectures aléatoires indépendantes sont assez nombreuses.

Le modèle simple de lecture séquentielle en miroir donne NS/2 parce que les partenaires sautent chacun les blocs de l’autre. Les mises en œuvre qui attribuent des plages entières de lecture à chaque copie peuvent faire mieux. La mise en miroir fournit davantage de capacité de lecture ; elle ne permet pas à un disque de terminer une lecture individuelle en deux fois moins de temps.

Une rangée à parité stocke des blocs de données et un bloc de redondance égal à leur XOR bit à bit. Pour chaque position de bit, le XOR vaut un lorsqu’un nombre impair d’entrées vaut un. Appliquer le XOR à une valeur et à elle-même l’annule. Cette annulation permet à la grappe de retrouver un bloc manquant.

Récupérer un bloc manquant identifié

Pour les données 0011, 0101 et 1001 :

Si le deuxième bloc manque :

La grappe doit savoir quel bloc reconstruire. Une parité non concordante entre des blocs apparemment sains révèle une incohérence, mais n’identifie pas le membre défectueux. Une somme de contrôle peut aider à établir quelles données sont valides.

Mettre à jour un bloc sans lire toute la rangée

Reconstruire la parité à partir des autres données est la parité additive. Avec cinq disques de données, modifier un bloc nécessite de lire les quatre autres blocs de données, puis de les combiner avec la nouvelle valeur. La parité soustractive, ou lecture-modification-écriture, retire la contribution de l’ancien bloc et insère celle du nouveau :

Remplace 0101 par 1100 dans la rangée précédente :

Cela nécessite deux lectures, des anciennes données et de l’ancienne parité, suivies de deux écritures, des nouvelles données et de la nouvelle parité. La phase de lecture doit se terminer avant la phase d’écriture, ce qui donne une latence d’environ 2T. Une écriture de bande complète dispose de tous les nouveaux blocs de données : elle calcule donc directement la nouvelle parité sans lire les anciens blocs.

Répartir le travail de parité

Le disque de parité de RAID-4 effectue une lecture et une écriture pour chaque petite mise à jour, ce qui crée un goulot d’étranglement fixe. RAID-5 répartit la parité entre les membres et permet aux mises à jour de rangées indépendantes de s’exécuter simultanément. Il paie toujours quatre entrées-sorties physiques par petite écriture logique. Les lectures aléatoires peuvent utiliser tous les disques à NR ; les grandes écritures séquentielles atteignent environ (N − 1)S.

RAID-6 ajoute deux blocs de redondance indépendants P et Q, généralement avec un code Reed–Solomon pour Q. Deux copies du même XOR ne donneraient qu’une seule équation. La mise à jour d’un bloc de données par lecture-modification-écriture lit les anciennes données, P et Q, puis écrit les trois : six entrées-sorties.

Pour quatre disques de 4 To avec R = 1 Mo/s, RAID-4 et RAID-5 fournissent 12 To et des débits d’écriture aléatoire de 0,5 et 1 Mo/s. RAID-6 fournit 8 To et environ 0,67 Mo/s. En mode dégradé avec RAID-5, un bloc de données manquant nécessite N − 1 lectures de blocs restants. Avec RAID-6 et un bloc de données manquant, la reconstruction par P nécessite N − 2 lectures et exclut Q ; deux blocs manquants nécessitent les deux équations indépendantes.

Pour choisir un niveau RAID, pars de la charge de travail et des pertes auxquelles il doit résister. La capacité seule laisse de côté le coût des écritures, les performances en mode dégradé et le temps nécessaire pour rétablir la redondance. Une grappe plus grande comprend plus de disques qui contribuent à sa capacité, mais aussi plus de disques membres et de secteurs exposés pendant la récupération.

Adapter l’organisation à la charge de travail

RAID-0 convient aux données temporaires qui peuvent être recréées et ne nécessitent pas de tolérance aux pannes de disque. RAID-10 convient à de nombreuses petites lectures et écritures aléatoires lorsqu’il est acceptable de renoncer à la moitié de la capacité. Le RAID à parité utilise efficacement l’espace et fonctionne bien pour les grandes écritures de bande complète. RAID-6 ajoute une protection contre deux pannes quelconques, utile lorsque la reconstruction de grands disques prend longtemps.

Avec quatre disques, RAID-10 et RAID-6 fournissent chacun la moitié de la capacité brute. RAID-10 nécessite deux écritures physiques par petite écriture logique ; la lecture-modification-écriture de RAID-6 nécessite six entrées-sorties. RAID-6 résiste à toute combinaison de deux pannes de disque, tandis que RAID-10 exige que ces pannes touchent des paires différentes. Aucun des deux choix ne l’emporte sur tous les critères.

Calculer une borne inférieure du temps de reconstruction

La reconstruction d’un miroir copie son partenaire restant. La reconstruction complète d’une grappe à parité lit les données restantes et reconstruit les blocs manquants. L’équation P de RAID-6 peut reconstruire un bloc de données manquant sans Q ; les lectures réellement nécessaires à la récupération dépendent de l’organisation et de la mise en œuvre. La reconstruction complète d’un périphérique peut nécessiter des lectures importantes sur les disques restants.

Écrire un disque de remplacement de 20 To à 200 Mo/s prend au moins :

Cela représente environ 27,8 heures sans charge concurrente ni goulot d’étranglement supplémentaire. Les entrées-sorties normales, les recherches, le travail du contrôleur et la limitation du débit de récupération peuvent prolonger cette durée. L’ajout d’un disque de secours à chaud réduit l’attente avant le début de la reconstruction ; il ne supprime pas le temps de copie.

Examiner l’exposition au risque pendant la récupération

Une grappe RAID-5 dégradée a épuisé son unique tolérance à une panne de disque. La perte d’un autre disque empêche la récupération. Un secteur illisible sur un disque restant peut aussi laisser une rangée avec deux blocs inconnus : le bloc du disque manquant et le bloc illisible du disque restant. D’autres rangées peuvent rester récupérables.

À titre d’exemple, la reconstruction d’une grappe RAID-5 de quatre disques de 4 To lit les trois disques restants en entier :

Si les erreurs sont modélisées au taux d’une erreur pour 10¹⁴ bits, l’espérance du nombre d’erreurs est de 0,96. Il s’agit d’une espérance selon ce modèle de taux, pas d’une probabilité de panne de 96 %. La limite du taux d’erreur indiquée sur une fiche technique n’est pas une prévision mesurée pour une reconstruction donnée. Les caractéristiques destinées aux entreprises indiquent souvent une limite plus exigeante, par exemple une erreur pour 10¹⁵ bits.

Passer de quatre à huit disques RAID-5 augmente la capacité utilisable de 75 % à 87,5 % de l’espace brut, tout en augmentant la quantité de données restantes à lire pendant la récupération. Un âge et une usure similaires affaiblissent aussi l’hypothèse de pannes indépendantes. Une base de données comportant beaucoup d’écritures peut favoriser RAID-10 ; une grande archive séquentielle peut favoriser RAID-6. Planifie des vérifications périodiques d’intégrité pour découvrir les secteurs défectueux tant que la redondance subsiste, et conserve des sauvegardes séparées.

Le modèle de panne par arrêt identifie un disque entier comme manquant. Un périphérique relevant du modèle de panne partielle fonctionne dans l’ensemble alors que certains blocs sont illisibles ou incorrects. Ces défauts peuvent rester cachés dans des données rarement consultées jusqu’à ce qu’une autre panne rende ces blocs nécessaires à une reconstruction.

Distinguer une erreur de lecture signalée d’octets erronés

Une erreur de secteur latente (LSE) signifie que le disque ne peut pas lire un secteur et signale une erreur. Elle peut être causée par des dommages physiques ou des erreurs de bits dépassant la capacité de correction du code correcteur d’erreurs interne. Comme l’emplacement est connu, un système redondant peut lire une copie miroir ou reconstruire ce bloc à partir de la parité. Réécrire les données récupérées permet au disque de retirer du service ou de réaffecter l’emplacement endommagé.

La corruption silencieuse signifie qu’une lecture renvoie des octets incorrects sans signaler d’erreur. Un micrologiciel défectueux, un défaut du contrôleur ou du bus, ou une écriture mal dirigée peuvent la provoquer. Le statut de réussite de la commande indique que le transfert est terminé ; il ne valide pas le contenu de bout en bout.

Distinguer les erreurs d’adresse et de version

Une écriture mal dirigée peut écraser un bloc sans rapport tout en laissant la destination prévue avec des données périmées. Une écriture perdue laisse l’ancienne version du bloc prévu en place. Un identifiant d’adresse aide à détecter le premier défaut ; une valeur attendue de la nouvelle version, stockée indépendamment, aide à détecter le second.

Le code correcteur d’erreurs (ECC) interne du disque corrige de nombreuses erreurs dans les bits stockés. Il ne peut pas vérifier tous les défauts ailleurs sur le parcours, comme une valeur corrompue avant que le disque calcule son code ou après qu’il l’a renvoyée. Une protection limitée au support laisse d’autres composants sans vérification.

Comprendre pourquoi l’échelle compte

Une étude de terrain a suivi 1,53 million de disques en production pendant 32 mois. Des LSE ont touché environ 8,5 % des disques de stockage secondaire et 1,9 % des disques de classe entreprise. Une étude distincte de la corruption sur la même population pendant 41 mois a trouvé des sommes de contrôle non concordantes sur respectivement environ 0,86 % et 0,065 % des disques. Ce sont des observations historiques sur des périodes d’étude différentes, pas des probabilités annuelles ni des garanties actuelles. À l’échelle d’un grand parc, même des défauts rares par disque deviennent des événements courants.

Utiliser la redondance avec une vérification

Une lecture ordinaire sur un miroir à deux copies peut choisir une copie sans la comparer à l’autre. Elle peut renvoyer des octets corrompus si aucune somme de contrôle n’est vérifiée. Si les copies sont comparées et diffèrent, les deux copies seules ne permettent pas de savoir laquelle est correcte. Une somme de contrôle valide fournit une base pour sélectionner une bonne version.

Pendant une reconstruction RAID-5, une LSE sur un disque restant peut supprimer les dernières informations nécessaires pour sa rangée. Il manque déjà un bloc à la grappe, et une équation XOR ne peut pas retrouver deux inconnues. Trouver et réparer les défauts latents tant que tous les disques membres sont disponibles préserve les possibilités face à la panne suivante.

Une somme de contrôle représente un bloc de données par une valeur bien plus petite. À la lecture, recalcule-la et compare-la à la valeur attendue qui a été stockée. Une différence révèle une incohérence. Des entrées différentes peuvent partager une même valeur, ce qu’on appelle une collision : des sommes de contrôle concordantes fournissent donc un indice solide dont la force dépend de la fonction choisie et du type d’erreur.

Essayer le XOR et l’addition

Pour les octets 0x36, 0x5A, 0xC1 et 0x0F, le XOR bit à bit donne 0xA2. En binaire, le calcul est :

Inverse le bit de poids faible des deux premiers octets, ce qui donne 0x37 et 0x5B. Les deux changements s’annulent avec le XOR, qui reste égal à 0xA2. Une opération peu coûteuse peut avoir une faiblesse prévisible.

Une somme de contrôle additive de 8 bits additionne les valeurs des octets modulo 256 :

La double inversion précédente change la somme en 0x62 : l’addition détecte donc cette erreur. Mais modifier l’ordre des octets ne change ni la simple addition ni le XOR.

Ajouter une sensibilité à la position

Une somme de contrôle de Fletcher maintient deux sommes, initialisées à zéro. Pour chaque octet d, mets à jour la première somme, puis ajoute sa nouvelle valeur à la seconde :

Le résultat est (97 ; 122). Échanger les deux premiers octets donne (97 ; 158). La première somme ignore l’ordre, mais la seconde pondère les positions par l’accumulation progressive. Fletcher détecte les erreurs portant sur un seul bit et de nombreuses erreurs en rafale à faible coût, même si des collisions restent possibles.

Suivre une courte division CRC

Un contrôle de redondance cyclique (CRC) traite les bits comme des coefficients d’un polynôme et effectue une division à l’aide du XOR. Avec le générateur 1011, qui représente x³ + x + 1, un reste de trois bits protège les données. Pour les données 1101, ajoute trois zéros :

1. Pars de 1101000 et applique le XOR avec 1011000, ce qui laisse 0110000.
2. Aligne le générateur sur le premier bit à un et applique le XOR avec 0101100, ce qui laisse 0011100.
3. Applique le XOR avec 0010110, ce qui laisse 0001010.
4. Applique le XOR avec 0001011, ce qui laisse 0000001.

Le reste est 001 : stocke donc 1101001. La division de ce mot de code donne zéro ; le remplacer par 1111001 donne un reste de 110. Un CRC de n bits détecte toute rafale d’une longueur maximale de n bits. La prise en charge par le processeur rend le CRC pratique pour le stockage et le trafic réseau, notamment CRC32C pour les métadonnées d’ext4 et Btrfs.

Les hachages cryptographiques comme SHA-256 résistent aussi aux tentatives délibérées de collision. Un hachage utilisé contre les modifications malveillantes nécessite une valeur attendue fiable ; remplacer à la fois les données et leur hachage non fiable rend la comparaison inutile. OpenZFS utilise normalement Fletcher pour les données ordinaires et SHA-256 pour la déduplication. Huit octets de somme de contrôle par bloc de 4 Kio coûtent environ 0,2 % d’espace. La détection seule ne fournit aucun octet de remplacement : la réparation nécessite de la redondance ou un code correcteur d’erreurs.

Une fonction de somme de contrôle détermine les changements détectables. La conception du stockage détermine à quelle valeur elle est comparée, à quelle adresse elle appartient et si un remplacement correct existe. Une somme de contrôle robuste associée à la mauvaise version peut malgré tout accepter des données périmées.

Choisir où placer la valeur attendue

ZFS utilise des sommes de contrôle dans les pointeurs des blocs parents, créant un arbre de vérification jusqu’à sa racine. Les informations de protection peuvent aussi contenir l’adresse attendue. L’étiquette de référence de T10 utilise les 32 bits de poids faible de l’adresse de bloc logique, à côté d’un CRC de 16 bits des données et d’une étiquette d’application. Une vérification de l’adresse peut rejeter des octets corrects renvoyés depuis le mauvais emplacement.

Distinguer mauvais emplacement et mauvaise version

Supposons qu’une lecture du disque 3, bloc 1 207, renvoie une paire valide de données et de somme de contrôle portant l’adresse d’un autre emplacement. La somme de contrôle seule concorde, mais l’identifiant d’adresse révèle l’erreur de destination.

Une écriture perdue est plus difficile à détecter : l’ancien contenu peut avoir une somme de contrôle valide et la bonne adresse. La vérification par relecture après écriture compare une nouvelle lecture au nouveau contenu attendu, en ajoutant environ une entrée-sortie. Elle doit observer le résultat stocké, et pas seulement la même copie dans un cache volatil. Une somme de contrôle attendue stockée séparément, par exemple dans un pointeur parent validé, peut à la place rejeter la version périmée du bloc fils. La valeur attendue séparée doit elle-même décrire la mise à jour prévue.

Vérifier avant de renvoyer ou de réparer

Lors d’une lecture, obtiens le bloc et sa somme de contrôle attendue, recalcule-la et compare-les. Si la première copie échoue à la vérification, lis une autre copie ou reconstruis le bloc à partir de la redondance. Vérifie ce résultat avant de le renvoyer. S’il réussit, renvoie les données correctes et réécris la copie endommagée. C’est l’autoréparation. Si aucune copie valide ne peut être trouvée, renvoie une erreur plutôt que des octets non vérifiés.

Par exemple, un pool ZFS en miroir lit le disque A et détecte une différence de somme de contrôle. La copie du disque B réussit la vérification. Le système renvoie les données de B, répare A et enregistre l’erreur de A. Une mise en miroir ordinaire sans vérification des sommes de contrôle pourrait renvoyer les octets erronés de A sans les remarquer.

Chercher les erreurs avant qu’une panne n’impose une récupération

La vérification périodique d’intégrité lit et vérifie régulièrement les données stockées, y compris les blocs que les applications consultent rarement. Tant que la redondance est disponible, le système peut réparer les défauts avant la panne d’un autre disque membre. Dans l’étude historique sur les LSE, cette vérification a trouvé plus de 60 % des erreurs.

La vérification consomme du temps processeur, de l’espace pour les sommes de contrôle et parfois des entrées-sorties supplémentaires. Huit octets par bloc de 4 Kio coûtent environ 0,2 % ; huit octets par 512 octets de données coûtent environ 1,6 %. Les lectures de vérification concurrencent les requêtes au premier plan : les périodes calmes sont donc utiles. L’argument de bout en bout place la vérification finale près du système de fichiers ou de l’application, couvrant une plus grande partie du parcours que l’ECC du disque limité au support.