هل يعد Linux بكتابة ملف تسلسلي في حالة انقطاع التيار الكهربائي؟

فهم متانة كتابة الملفات أثناء انقطاع التيار الكهربائي

تخيل أنك تكتب قطعتين مهمتين من البيانات في ملف، وفجأة تنقطع الطاقة. هل سيضمن نظام Linux أو نظام الملفات الذي اخترته عدم ظهور الكتابة الثانية في وحدة التخزين ما لم تكتمل الكتابة الأولى؟ إنه سؤال يتجاهله العديد من المطورين حتى تقع الكارثة. 🛑

تعد متانة الملف أمرًا بالغ الأهمية عند التعامل مع سلامة البيانات، خاصة عند حدوث انقطاعات في الطاقة أو تعطلها. يصبح هذا السؤال أكثر إلحاحًا عند العمل مع الأنظمة المتوافقة مع POSIX أو أنظمة الملفات الشائعة مثل ext4. هل الكتابة مضمونة لتكون متسلسلة وذرية، أم أنك بحاجة إلى احتياطات إضافية؟

على سبيل المثال، ضع في اعتبارك تطبيقًا كبيرًا يكتب سجلات أو بيانات منظمة إلى ملف في جزأين غير متداخلين. بدون ضمانات واضحة، هناك خطر من أن يتسلل جزء من عملية الكتابة الثانية إلى القرص، مما يترك الملف في حالة غير متناسقة. يمكن أن يؤدي هذا إلى قواعد بيانات تالفة أو معاملات مفقودة أو سجلات غير كاملة. 😓

تستكشف هذه المقالة ما إذا كانت أنظمة الملفات POSIX أو Linux أو أنظمة الملفات الحديثة مثل ext4 تضمن متانة كتابة الملفات وترتيبها. سنحدد أيضًا ما إذا كان استخدام fsync() أو fdatasync() بين عمليات الكتابة هو الحل الوحيد الموثوق به لمنع عدم تناسق البيانات.

فهم متانة كتابة الملفات وضمان اتساق البيانات

في البرامج النصية المقدمة سابقًا، تناولنا مسألة ضمانات المتانة في ملفات Linux التي يتم كتابتها عند حدوث أحداث غير متوقعة، مثل انقطاع التيار الكهربائي. وكان التركيز على التأكد من أن المجموعة الثانية من البيانات، data2، لن يستمر في التخزين إلا إذا كانت الكتلة الأولى، البيانات1، قد تم كتابته بالكامل بالفعل. يعتمد الحل على مجموعة من استدعاءات النظام المختارة بعناية، مثل pwrite و com.fsyncوسلوكيات نظام الملفات. تم استخدام النص الأول com.fsync بين عمليتي كتابة متسلسلتين لضمان مسح البيانات 1 على القرص قبل متابعة كتابة البيانات 2. وهذا يضمن سلامة البيانات، حتى لو تعطل النظام بعد الكتابة الأولى.

دعونا نقسمها أكثر: pwrite تكتب الدالة إلى إزاحة محددة داخل ملف دون تعديل مؤشر الملف. يعد هذا مفيدًا بشكل خاص لعمليات الكتابة غير المتداخلة، كما هو موضح هنا، حيث تتم كتابة كتلتي البيانات بإزاحات مميزة. باستخدام صراحة com.fsync بعد الكتابة الأولى، نجبر نظام التشغيل على دفع محتوى الملف المخزن مؤقتًا إلى القرص، مما يضمن استمراريته. بدون fsync، قد تظل البيانات في الذاكرة، وتكون عرضة للفقد أثناء انقطاع التيار الكهربائي. تخيل كتابة إدخال سجل مهم أو حفظ جزء من قاعدة البيانات - إذا اختفى الجزء الأول، تصبح البيانات غير متسقة. 😓

في النص الثاني، استكشفنا استخدام O_SYNC العلم في يفتح مكالمة النظام. مع تمكين هذه العلامة، تقوم كل عملية كتابة بدفع البيانات إلى وحدة التخزين على الفور، مما يلغي الحاجة إلى الدليل com.fsync المكالمات. يؤدي ذلك إلى تبسيط الكود مع ضمان ضمانات المتانة. ومع ذلك، هناك مقايضة: يؤدي استخدام O_SYNC إلى فرض عقوبة على الأداء لأن عمليات الكتابة المتزامنة تستغرق وقتًا أطول مقارنة بالكتابة المخزنة مؤقتًا. يعد هذا النهج مثاليًا للأنظمة التي تفوق الموثوقية فيها مخاوف الأداء، مثل الأنظمة المالية أو تسجيل البيانات في الوقت الفعلي. على سبيل المثال، إذا كنت تقوم بحفظ بيانات المستشعر أو سجلات المعاملات، فأنت بحاجة إلى أن تكون كل عملية كتابة موثوقة تمامًا. 🚀

قام البرنامج النصي لاختبار الوحدة المكتوب بلغة Python بالتحقق من صحة هذه الحلول عن طريق التحقق من محتويات الملف بعد تنفيذ برنامج C. لقد تأكد من كتابة كل من data1 و data2 كما هو متوقع. تسلط هذه الخطوة الضوء على أهمية اختبار عمليات الملف في ظل ظروف مختلفة. إذا كنت تريد نشر حل مماثل على خادم إنتاج، فستكون اختبارات الوحدة ضرورية للتحقق من سلامة كتاباتك. من خلال الجمع بين ممارسات الترميز القوية مثل استخدام fsync مع التحقق من الصحة من خلال الاختبارات، يمكنك بثقة ضمان متانة واتساق ملفك المكتوب على الأنظمة المتوافقة مع POSIX.

#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
int main() {
    int fd;
    const char *path = "example_file.txt";
    const char *data1 = "First write block";
    const char *data2 = "Second write block";
    size_t size1 = strlen(data1);
    size_t size2 = strlen(data2);
    off_t offset1 = 0;
    off_t offset2 = size1;

    // Open the file
    fd = open(path, O_RDWR | O_CREAT, 0666);
    if (fd == -1) {
        perror("Failed to open file");
        return 1;
    }

    // Perform first write
    if (pwrite(fd, data1, size1, offset1) == -1) {
        perror("Failed to write data1");
        close(fd);
        return 1;
    }

    // Use fsync to flush the first write to disk
    if (fsync(fd) == -1) {
        perror("fsync failed after data1");
        close(fd);
        return 1;
    }

    // Perform second write
    if (pwrite(fd, data2, size2, offset2) == -1) {
        perror("Failed to write data2");
        close(fd);
        return 1;
    }

    // Final fsync to ensure data2 is flushed
    if (fsync(fd) == -1) {
        perror("fsync failed after data2");
        close(fd);
        return 1;
    }

    // Close the file
    if (close(fd) == -1) {
        perror("Failed to close file");
        return 1;
    }

    printf("Writes completed and synced successfully.\n");
    return 0;
}

#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
int main() {
    int fd;
    const char *path = "simple_ordered_file.txt";
    const char *data1 = "Data block 1";
    const char *data2 = "Data block 2";
    size_t size1 = strlen(data1);
    size_t size2 = strlen(data2);

    // Open file with O_SYNC for synchronous writes
    fd = open(path, O_RDWR | O_CREAT | O_SYNC, 0666);
    if (fd == -1) {
        perror("Open failed");
        return 1;
    }

    // Write first data
    if (write(fd, data1, size1) == -1) {
        perror("Write data1 failed");
        close(fd);
        return 1;
    }

    // Write second data
    if (write(fd, data2, size2) == -1) {
        perror("Write data2 failed");
        close(fd);
        return 1;
    }

    // Close file
    close(fd);
    printf("Writes completed with O_SYNC.\n");
    return 0;
}

import os
def validate_file_content(path):
    try:
        with open(path, 'r') as f:
            content = f.read()
        assert "Data block 1" in content
        assert "Data block 2" in content
        print("Test passed: Both writes are present.")
    except AssertionError:
        print("Test failed: Writes are inconsistent.")
    except Exception as e:
        print(f"Error: {e}")

# File validation after running a C program
validate_file_content("simple_ordered_file.txt")

ضمان اتساق البيانات في نظام التشغيل Linux: كتابة اليوميات والكتابات المخزنة مؤقتًا

جانب واحد حاسم من الفهم ضمانات المتانة في أنظمة ملفات Linux مثل ext4، يكون دور التدوين. تساعد أنظمة ملفات تسجيل اليومية على منع الفساد أثناء الأحداث غير المتوقعة مثل انقطاع التيار الكهربائي عن طريق الاحتفاظ بسجل (أو دفتر يومية) للتغييرات قبل أن يتم الالتزام بها في وحدة التخزين الرئيسية. تضمن المجلة إرجاع العمليات غير المكتملة، مما يحافظ على اتساق بياناتك. ومع ذلك، لا يضمن تسجيل اليومية عمليات الكتابة المطلوبة بدون احتياطات إضافية مثل الاتصال fsync. في مثالنا، على الرغم من أن تسجيل دفتر اليومية قد يضمن عدم تلف الملف، إلا أن أجزاء من data2 لا يزال من الممكن أن تستمر من قبل البيانات1.

هناك اعتبار آخر وهو كيفية كتابة ملف المخازن المؤقتة لنظام التشغيل Linux. عندما تستخدم pwrite أو write، غالبًا ما تتم كتابة البيانات إلى مخزن مؤقت للذاكرة، وليس مباشرة إلى القرص. يعمل هذا التخزين المؤقت على تحسين الأداء ولكنه يخلق خطرًا حيث يمكن أن يحدث فقدان البيانات في حالة تعطل النظام قبل مسح المخزن المؤقت. الاتصال fsync أو فتح الملف بامتداد O_SYNC تضمن العلامة نقل البيانات المخزنة مؤقتًا إلى القرص بشكل آمن، مما يمنع حدوث حالات عدم الاتساق. وبدون هذه التدابير، يمكن أن تظهر البيانات مكتوبة جزئيا، خاصة في حالات انقطاع التيار الكهربائي. ⚡

بالنسبة للمطورين الذين يعملون مع الملفات الكبيرة أو الأنظمة المهمة، من الضروري تصميم البرامج مع وضع المتانة في الاعتبار. على سبيل المثال، تخيل أن نظام حجز طيران يكتب بيانات توفر المقاعد. إذا لم تتم كتابة المجموعة الأولى التي تشير إلى تفاصيل الرحلة بالكامل واستمرت المجموعة الثانية، فقد يؤدي ذلك إلى تلف البيانات أو الحجوزات المزدوجة. استخدام fsync أو fdatasync في المراحل الحرجة يتجنب هذه المزالق. قم دائمًا باختبار السلوك في ظل محاكاة الفشل الحقيقي لضمان الموثوقية. 😊