Schreiben von Programmen zur Bewältigung von E / A-Fehlern, die unter Linux zu Schreibverlust führen

TL; DR: Wenn der Linux-Kernel einen gepufferten E / A-Schreibvorgang verliert , kann die Anwendung dies herausfinden?

Ich weiß, dass Sie fsync()die Datei (und das übergeordnete Verzeichnis) für die Haltbarkeit benötigen . Die Frage ist, ob der Kernel fehlerhafte Puffer verliert, deren Schreibvorgang aufgrund eines E / A-Fehlers aussteht. Wie kann die Anwendung dies erkennen und wiederherstellen oder abbrechen?

Denken Sie an Datenbankanwendungen usw., bei denen die Reihenfolge der Schreibvorgänge und die Schreibdauer von entscheidender Bedeutung sein können.

Verlorene schreibt? Wie?

Die Linux - Kernel-Block Schicht kann unter bestimmten Umständen verlieren I / O - Anfragen gepuffert , die erfolgreich durch eingereicht wurde write(), pwrite()wie usw., mit einem Fehler:

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

(Siehe end_buffer_write_sync(...)und end_buffer_async_write(...)infs/buffer.c ).

Auf neueren Kerneln enthält der Fehler stattdessen "Lost Async Page Write" , wie:

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

Da die Anwendung write()bereits fehlerfrei zurückgegeben wurde, scheint es keine Möglichkeit zu geben, einen Fehler an die Anwendung zurückzumelden.

Sie erkennen?

Ich bin mit den Kernelquellen nicht so vertraut, aber ich denke, dass sie AS_EIOauf den Puffer gesetzt sind, der nicht ausgeschrieben werden konnte, wenn ein asynchroner Schreibvorgang ausgeführt wird:

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

Es ist mir jedoch unklar, ob oder wie die Anwendung dies herausfinden kann, wenn sie später in fsync()der Datei bestätigt, dass sie sich auf der Festplatte befindet.

Es sieht aus wie wait_on_page_writeback_range(...)inmm/filemap.c Macht, do_sync_mapping_range(...)infs/sync.c der wiederum von genannt wird sys_sync_file_range(...). Es wird zurückgegeben, -EIOwenn ein oder mehrere Puffer nicht geschrieben werden konnten.

Wenn sich dies, wie ich vermute, auf fsync()das Ergebnis auswirkt, wenn die App in Panik gerät und ausfällt, wenn ein E / A-Fehler auftritt fsync()und weiß, wie sie ihre Arbeit beim Neustart erneut ausführen kann, sollte dies eine ausreichende Sicherheit sein?

Vermutlich kann die App nicht erkennen, welche Byte-Offsets in einer Datei den verlorenen Seiten entsprechen, sodass sie diese neu schreiben kann, wenn sie weiß, wie, aber wenn die App alle anstehenden Arbeiten seit dem letzten erfolgreichen fsync()der Datei wiederholt und diese neu schreibt Alle schmutzigen Kernel-Puffer, die verlorenen Schreibvorgängen für die Datei entsprechen, sollten alle E / A-Fehlerflags auf den verlorenen Seiten löschen und den nächsten fsync()Abschluss ermöglichen - richtig?

Gibt es dann noch andere harmlose Umstände, fsync()unter -EIOdenen die Rettung und Wiederholung von Arbeiten zu drastisch wäre?

Warum?

Natürlich sollten solche Fehler nicht auftreten. In diesem Fall ist der Fehler auf eine unglückliche Interaktion zwischen den dm-multipathStandardeinstellungen des Treibers und dem vom SAN verwendeten Erfassungscode zurückzuführen, der den Fehler beim Zuweisen von Thin Provisioning-Speicher meldet. Dies ist jedoch nicht der einzige Umstand, unter dem sie auftreten können. Ich habe auch Berichte darüber von beispielsweise Thin Provisioning LVM gesehen, wie sie von libvirt, Docker und anderen verwendet werden. Eine kritische Anwendung wie eine Datenbank sollte versuchen, mit solchen Fehlern umzugehen, anstatt blind weiterzumachen, als ob alles in Ordnung wäre.

Wenn der Kernel der Meinung ist, dass es in Ordnung ist, Schreibvorgänge zu verlieren, ohne an einer Kernel-Panik zu sterben, müssen Anwendungen einen Weg finden, um damit umzugehen.

Die praktische Auswirkung ist, dass ich einen Fall gefunden habe, in dem ein Multipath-Problem mit einem SAN zu verlorenen Schreibvorgängen führte, die zu einer Beschädigung der Datenbank führten, weil das DBMS nicht wusste, dass seine Schreibvorgänge fehlgeschlagen waren. Kein Spaß.

fsync() kehrt zurück -EIO wenn der Kernel einen Schreibvorgang verloren hat

(Hinweis: Der frühe Teil verweist auf ältere Kernel; unten aktualisiert, um moderne Kernel widerzuspiegeln.)

Es sieht so aus, als würde das Ausschreiben des asynchronen Puffers bei end_buffer_async_write(...)Fehlern ein -EIOFlag auf der Seite für den fehlerhaften fehlerhaften Puffer für die Datei setzen :

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

Dies wird dann erkannt von wait_on_page_writeback_range(...)aufgerufen von do_sync_mapping_range(...)aufgerufen von sys_sync_file_range(...)aufgerufen sys_sync_file_range2(...), um den Aufruf der C-Bibliothek zu implementieren fsync().

Aber nur einmal!

Dieser Kommentar zu 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.

schlägt vor, dass bei fsync()Rückgabe -EIOoder (undokumentiert in der Manpage) der Fehlerstatus so nachträglich gelöscht -ENOSPCwirdfsync() Meldung den Erfolg meldet, obwohl die Seiten nie geschrieben wurden.

Sicher genug wait_on_page_writeback_range(...) löscht die Fehlerbits, wenn sie getestet werden :

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;

Wenn die Anwendung erwartet, dass sie es erneut versuchen kann, fsync()bis sie erfolgreich ist, und darauf vertraut, dass sich die Daten auf der Festplatte befinden, ist dies furchtbar falsch.

Ich bin mir ziemlich sicher, dass dies die Quelle der Datenbeschädigung ist, die ich im DBMS gefunden habe. Es wird wiederholtfsync() und glaubt, dass alles gut wird, wenn es erfolgreich ist.

Ist das erlaubt?

In den POSIX / SuS-Dokumenten wirdfsync() dies nicht so oder so angegeben:

Wenn die Funktion fsync () fehlschlägt, wird nicht garantiert, dass ausstehende E / A-Vorgänge abgeschlossen wurden.

Linux-Manpage für fsync() sagt einfach nichts darüber aus, was bei einem Fehler passiert.

So scheint es, dass die Bedeutung von fsync() Fehlern "Keine Ahnung, was mit Ihren Schreibvorgängen passiert ist, ob es funktioniert hat oder nicht, versuchen Sie es noch einmal, um sicherzugehen".

Neuere Kernel

Auf 4.9 end_buffer_async_writeSätze -EIOauf der Seite, nur über 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);

Auf der Synchronisierungsseite denke ich, dass es ähnlich ist, obwohl die Struktur jetzt ziemlich komplex zu folgen ist. filemap_check_errorsin mm/filemap.cjetzt tut:

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

das hat fast den gleichen Effekt. Fehlerprüfungen scheinen alle durchlaufen zu sein, filemap_check_errorswas ein Test-and-Clear durchführt:

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

Ich verwende es btrfsauf meinem Laptop, aber wenn ich einen ext4Loopback zum Testen erstelle /mnt/tmpund eine Perf-Sonde darauf einrichte:

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

Ich finde folgenden Aufrufstapel in 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

Ein Durchlesen deutet darauf hin, dass sich moderne Kernel genauso verhalten.

Dies scheint zu bedeuten , dass , wenn fsync()(oder vermutlich write()oder close()) zurückkehrt -EIO, wird die Datei in einem gewissen undefinierten Zustand zwischen, wenn Sie das letzte Mal erfolgreich fsync()d oder close()d er und seine zuletzt write()zehn Zustand.

Prüfung

Ich habe einen Testfall implementiert, um dieses Verhalten zu demonstrieren .

Implikationen

Ein DBMS kann dies durch Eingabe der Absturzwiederherstellung bewältigen. Wie um alles in der Welt soll eine normale Benutzeranwendung damit umgehen? Die fsync()Manpage gibt keine Warnung aus, dass es "fsync-wenn-du-fühlst-wie-es" bedeutet, und ich gehe davon aus, dass viele Apps mit diesem Verhalten nicht gut umgehen können.

Fehlerberichte

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

Weiterführende Literatur

lwn.net hat dies im Artikel "Verbesserte Fehlerbehandlung auf Blockebene" angesprochen .

Postgresql.org Mailinglisten-Thread .

Da write () der Anwendung bereits fehlerfrei zurückgegeben wurde, scheint es keine Möglichkeit zu geben, einen Fehler an die Anwendung zurückzumelden.

Ich stimme nicht zu. writekann ohne Fehler zurückkehren, wenn der Schreibvorgang einfach in die Warteschlange gestellt wird. Der Fehler wird jedoch beim nächsten Vorgang gemeldet, bei dem das eigentliche Schreiben auf die Festplatte erforderlich ist, dh beim nächstenfsync , möglicherweise bei einem nachfolgenden Schreibvorgang, wenn das System beschließt, den Cache zu leeren und um am wenigsten beim letzten Schließen der Datei.

Aus diesem Grund ist es für die Anwendung wichtig, den Rückgabewert von close zu testen, um mögliche Schreibfehler zu erkennen.

Wenn Sie wirklich in der Lage sein müssen, eine clevere Fehlerverarbeitung durchzuführen, müssen Sie davon ausgehen, dass alles, was seit dem letzten Erfolg geschrieben wurde, fsync möglicherweise fehlgeschlagen ist und dass zumindest etwas fehlgeschlagen ist.

write(2) bietet weniger als Sie erwarten. Die Manpage ist sehr offen über die Semantik eines erfolgreichen write()Anrufs:

Eine erfolgreiche Rückgabe von write()garantiert nicht, dass Daten auf die Festplatte übertragen wurden. Tatsächlich garantiert es bei einigen fehlerhaften Implementierungen nicht einmal, dass Speicherplatz erfolgreich für die Daten reserviert wurde. Der einzige Weg, um sicher zu sein, besteht darin, fsync(2) anzurufen, nachdem Sie alle Ihre Daten geschrieben haben.

Wir können daraus schließen, dass ein Erfolg write()lediglich bedeutet, dass die Daten die Pufferfunktionen des Kernels erreicht haben. Wenn das Fortbestehen des Puffers fehlschlägt, gibt ein nachfolgender Zugriff auf den Dateideskriptor den Fehlercode zurück. Als letztes Mittel kann das sein close(). Die Manpage des closeSystemaufrufs (2) enthält den folgenden Satz:

Es ist durchaus möglich, dass Fehler bei einer vorherigen write(2) Operation zuerst bei final close() gemeldet werden .

Wenn Ihre Anwendung das Abschreiben von Daten beibehalten muss, muss sie fsync/ fsyncdataregelmäßig verwenden:

fsync()überträgt ("Flushes") alle modifizierten In-Core-Daten (dh modifizierte Puffer-Cache-Seiten für) der Datei, auf die der Dateideskriptor fd verweist, auf das Plattengerät (oder ein anderes permanentes Speichergerät), so dass alle geänderten Informationen abgerufen werden können auch nach dem Absturz des Systems oder dem Neustart. Dies umfasst das Durchschreiben oder Leeren eines Festplattencaches, falls vorhanden. Der Anruf wird blockiert, bis das Gerät meldet, dass die Übertragung abgeschlossen ist.

Verwenden Sie das O_SYNC-Flag, wenn Sie die Datei öffnen. Es stellt sicher, dass die Daten auf die Festplatte geschrieben werden.

Wenn dich das nicht befriedigt, wird es nichts geben.

Überprüfen Sie den Rückgabewert von close. Das Schließen kann fehlschlagen, während gepufferte Schreibvorgänge erfolgreich zu sein scheinen.