Écriture de programmes pour faire face aux erreurs d'E / S provoquant des écritures perdues sous Linux

TL; DR: Si le noyau Linux perd une écriture d'E / S tamponnée , y a-t-il un moyen pour l'application de le savoir?

Je sais que vous devez fsync()le fichier (et son répertoire parent) pour la durabilité . La question est de savoir si le noyau perd les tampons sales qui sont en attente d'écriture en raison d'une erreur d'E / S, comment l'application peut-elle détecter cela et récupérer ou abandonner?

Pensez aux applications de base de données, etc., où l'ordre des écritures et la durabilité des écritures peuvent être cruciaux.

Écritures perdues? Comment?

La couche de blocs du noyau Linux peut dans certaines circonstances perdre les demandes d'E / S tamponnées qui ont été soumises avec succès par write(), pwrite()etc., avec une erreur comme:

Buffer I/O error on device dm-0, logical block 12345
lost page write due to I/O error on dm-0

(Voir end_buffer_write_sync(...)et end_buffer_async_write(...)dansfs/buffer.c ).

Sur les noyaux plus récents, l'erreur contiendra à la place "écriture de page asynchrone perdue" , comme:

Buffer I/O error on dev dm-0, logical block 12345, lost async page write

Étant donné que l'application write()sera déjà retournée sans erreur, il ne semble y avoir aucun moyen de signaler une erreur à l'application.

Les détecter?

Je ne suis pas très familier avec les sources du noyau, mais je pense qu'il est défini AS_EIOsur le tampon qui n'a pas pu être écrit s'il fait une écriture asynchrone:

    set_bit(AS_EIO, &page->mapping->flags);
    set_buffer_write_io_error(bh);
    clear_buffer_uptodate(bh);
    SetPageError(page);

mais je ne sais pas si ou comment l'application peut le découvrir plus tard fsync() le fichier pour confirmer qu il est sur le disque.

Il ressemble wait_on_page_writeback_range(...)enmm/filemap.c puissance par do_sync_mapping_range(...)dansfs/sync.c ce qui est à son tour appelé par sys_sync_file_range(...). Il retourne-EIO si un ou plusieurs tampons n'ont pas pu être écrits.

Si, comme je le suppose, cela se propage au fsync()résultat de, alors si l'application panique et renonce si elle reçoit une erreur d'E / S fsync()et sait comment refaire son travail lors du redémarrage, cela devrait être une sauvegarde suffisante?

Il n'y a probablement aucun moyen pour l'application de savoir quels décalages d'octets dans un fichier correspondent aux pages perdues afin qu'elle puisse les réécrire si elle sait comment, mais si l'application répète tout son travail en attente depuis le dernier succès fsync()du fichier, et cela réécrit des tampons de noyau sales correspondant à des écritures perdues sur le fichier, qui devraient effacer tous les indicateurs d'erreur d'E / S sur les pages perdues et permettre au suivant fsync()de se terminer - n'est-ce pas?

Y a-t-il alors d'autres circonstances, inoffensives, où fsync()peuvent revenir -EIOoù renflouer et refaire des travaux serait trop drastique?

Pourquoi?

Bien entendu, de telles erreurs ne devraient pas se produire. Dans ce cas, l'erreur provenait d'une interaction malheureuse entre les dm-multipathvaleurs par défaut du pilote et le code de détection utilisé par le SAN pour signaler l'échec de l'allocation du stockage alloué de manière dynamique. Mais ce n'est pas la seule circonstance où ils peuvent se produire - j'ai également vu des rapports de LVM à provisionnement fin par exemple, tel qu'utilisé par libvirt, Docker, etc. Une application critique comme une base de données devrait essayer de faire face à de telles erreurs, plutôt que de continuer aveuglément comme si tout allait bien.

Si le noyau pense qu'il est acceptable de perdre des écritures sans mourir avec une panique du noyau, les applications doivent trouver un moyen de faire face.

L'impact pratique est que j'ai trouvé un cas où un problème de trajets multiples avec un SAN a causé des écritures perdues qui ont abouti à une corruption de la base de données parce que le SGBD ne savait pas que ses écritures avaient échoué. Pas drôle.

fsync()retourne -EIOsi le noyau a perdu une écriture

(Remarque: la première partie fait référence à des noyaux plus anciens; mis à jour ci-dessous pour refléter les noyaux modernes)

Il semble que l' écriture de tampon asynchrone en cas d' end_buffer_async_write(...)échecs définisse un -EIOindicateur sur la page de tampon sale ayant échoué pour le fichier :

set_bit(AS_EIO, &page->mapping->flags);
set_buffer_write_io_error(bh);
clear_buffer_uptodate(bh);
SetPageError(page);

qui est ensuite détectée par wait_on_page_writeback_range(...)comme demandé par do_sync_mapping_range(...)comme demandé par sys_sync_file_range(...)comme demandé par sys_sync_file_range2(...)la mise en œuvre de l'appel de la bibliothèque C fsync().

Mais une seule fois!

Ce commentaire sur sys_sync_file_range

168  * SYNC_FILE_RANGE_WAIT_BEFORE and SYNC_FILE_RANGE_WAIT_AFTER will detect any
169  * I/O errors or ENOSPC conditions and will return those to the caller, after
170  * clearing the EIO and ENOSPC flags in the address_space.

suggère que lorsque fsync()retourne -EIOou (non documenté dans la page de manuel) -ENOSPC, il effacera l'état d'erreur afin qu'un suivant fsync()signalera le succès même si les pages n'ont jamais été écrites.

Assez sûr wait_on_page_writeback_range(...) efface les bits d'erreur lorsqu'il les teste :

301         /* Check for outstanding write errors */
302         if (test_and_clear_bit(AS_ENOSPC, &mapping->flags))
303                 ret = -ENOSPC;
304         if (test_and_clear_bit(AS_EIO, &mapping->flags))
305                 ret = -EIO;

Donc, si l'application s'attend à pouvoir réessayer fsync()jusqu'à ce qu'elle réussisse et qu'elle sache que les données sont sur disque, c'est terriblement faux.

Je suis presque sûr que c'est la source de la corruption de données que j'ai trouvée dans le SGBD. Il réessaye fsync()et pense que tout ira bien quand il réussira.

Est-ce permis?

Les documents POSIX / SuS surfsync() ne le spécifient pas vraiment de toute façon:

Si la fonction fsync () échoue, il n'est pas garanti que les opérations d'E / S en attente se sont terminées.

La page de manuel de Linuxfsync() ne dit rien sur ce qui se passe en cas d'échec.

Il semble donc que la signification des fsync()erreurs est "je ne sais pas ce qui est arrivé à vos écritures, cela a peut-être fonctionné ou non, mieux vaut réessayer pour être sûr".

Noyaux plus récents

Sur 4.9 end_buffer_async_writeensembles -EIOsur la page, juste via mapping_set_error.

    buffer_io_error(bh, ", lost async page write");
    mapping_set_error(page->mapping, -EIO);
    set_buffer_write_io_error(bh);
    clear_buffer_uptodate(bh);
    SetPageError(page);

Du côté de la synchronisation, je pense que c'est similaire, même si la structure est maintenant assez complexe à suivre. filemap_check_errorsen fait mm/filemap.cmaintenant:

    if (test_bit(AS_EIO, &mapping->flags) &&
        test_and_clear_bit(AS_EIO, &mapping->flags))
            ret = -EIO;

qui a à peu près le même effet. Les vérifications d'erreurs semblent toutes passer par filemap_check_errorsce qui fait un test et effacement:

    if (test_bit(AS_EIO, &mapping->flags) &&
        test_and_clear_bit(AS_EIO, &mapping->flags))
            ret = -EIO;
    return ret;

J'utilise btrfssur mon ordinateur portable, mais lorsque je crée un ext4bouclage pour tester /mnt/tmpet configurer une sonde de perf dessus:

sudo dd if=/dev/zero of=/tmp/ext bs=1M count=100
sudo mke2fs -j -T ext4 /tmp/ext
sudo mount -o loop /tmp/ext /mnt/tmp

sudo perf probe filemap_check_errors

sudo perf record -g -e probe:end_buffer_async_write -e probe:filemap_check_errors dd if=/dev/zero of=/mnt/tmp/test bs=4k count=1 conv=fsync

Je trouve la pile d'appels suivante dans perf report -T:

        ---__GI___libc_fsync
           entry_SYSCALL_64_fastpath
           sys_fsync
           do_fsync
           vfs_fsync_range
           ext4_sync_file
           filemap_write_and_wait_range
           filemap_check_errors

Une lecture directe suggère que oui, les noyaux modernes se comportent de la même manière.

Cela semble signifier que si fsync()(ou vraisemblablement write()ou close()) le rendement -EIO, le fichier est dans un état indéfini entre lors de la dernière avec succès fsync()d ou close()d , cela et son dernier write()état dix.

Tester

J'ai implémenté un cas de test pour démontrer ce comportement .

Implications

Un SGBD peut faire face à cela en entrant la récupération après incident. Comment diable une application utilisateur normale est-elle censée faire face à cela? La fsync()page de manuel ne donne aucun avertissement que cela signifie "fsync-if-you-feel-like-it" et je m'attends à ce que beaucoup d'applications ne supportent pas bien ce comportement.

Rapports de bogues

• https://bugzilla.kernel.org/show_bug.cgi?id=194755
• https://bugzilla.kernel.org/show_bug.cgi?id=194757

Lectures complémentaires

lwn.net en a parlé dans l'article "Amélioration de la gestion des erreurs de couche de bloc" .

Fil de discussion de la liste de diffusion postgresql.org .

Étant donné que write () de l'application sera déjà retourné sans erreur, il ne semble y avoir aucun moyen de signaler une erreur à l'application.

Je ne suis pas d'accord. writepeut retourner sans erreur si l'écriture est simplement mise en file d'attente, mais l'erreur sera signalée lors de l'opération suivante qui nécessitera l'écriture réelle sur le disque, c'est-à-dire au suivant fsync, éventuellement lors d'une écriture suivante si le système décide de vider le cache et à moins lors de la dernière fermeture de fichier.

C'est la raison pour laquelle il est essentiel pour l'application de tester la valeur de retour de close pour détecter d'éventuelles erreurs d'écriture.

Si vous avez vraiment besoin de pouvoir faire un traitement intelligent des erreurs, vous devez supposer que tout ce qui a été écrit depuis le dernier succès a fsync peut- être échoué et que dans tout cela au moins quelque chose a échoué.

write(2) fournit moins que ce que vous attendez. La page de manuel est très ouverte sur la sémantique d'un write()appel réussi :

Un retour réussi de write()ne garantit pas que les données ont été validées sur le disque. En fait, sur certaines implémentations boguées, cela ne garantit même pas que l'espace a été réservé avec succès pour les données. La seule façon d'être sûr est d'appeler fsync(2) après avoir écrit toutes vos données.

Nous pouvons conclure qu'un succès write()signifie simplement que les données ont atteint les capacités de mise en mémoire tampon du noyau. Si la persistance du tampon échoue, un accès ultérieur au descripteur de fichier renverra le code d'erreur. En dernier recours, cela peut être close(). La page de manuel de l' closeappel système (2) contient la phrase suivante:

Il est tout à fait possible que des erreurs sur une opération précédente write(2) soient d'abord signalées au final close().

Si votre application a besoin de conserver des données écrites, elle doit utiliser fsync/ fsyncdatarégulièrement:

fsync()transfère ("purge") toutes les données internes modifiées (c'est-à-dire les pages de cache de tampon modifiées pour) le fichier référencé par le descripteur de fichier fd vers le périphérique de disque (ou tout autre périphérique de stockage permanent) afin que toutes les informations modifiées puissent être récupérées même après que le système s'est écrasé ou a été redémarré. Cela inclut l'écriture ou le vidage d'un cache disque, le cas échéant. L'appel se bloque jusqu'à ce que l'appareil signale que le transfert est terminé.

Utilisez l'indicateur O_SYNC lorsque vous ouvrez le fichier. Il garantit que les données sont écrites sur le disque.

Si cela ne vous satisfait pas, il n'y aura rien.

Vérifiez la valeur de retour de close. close peut échouer tandis que les écritures tamponnées semblent réussir.