ವಿದ್ಯುತ್ ನಿಲುಗಡೆಯ ಸಂದರ್ಭದಲ್ಲಿ Linux ಪ್ರಾಮಿಸ್ ಸೀಕ್ವೆನ್ಶಿಯಲ್ ಫೈಲ್ ಬರೆಯುತ್ತದೆಯೇ?

ವಿದ್ಯುತ್ ವೈಫಲ್ಯದ ಸಮಯದಲ್ಲಿ ಫೈಲ್ ಬರೆಯುವ ಬಾಳಿಕೆಯನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು

ನೀವು ಫೈಲ್‌ಗೆ ಎರಡು ನಿರ್ಣಾಯಕ ಡೇಟಾವನ್ನು ಬರೆಯುತ್ತಿದ್ದೀರಿ ಎಂದು ಕಲ್ಪಿಸಿಕೊಳ್ಳಿ ಮತ್ತು ಇದ್ದಕ್ಕಿದ್ದಂತೆ ವಿದ್ಯುತ್ ಸ್ಥಗಿತಗೊಳ್ಳುತ್ತದೆ. Linux ಅಥವಾ ನಿಮ್ಮ ಆಯ್ಕೆಮಾಡಿದ ಫೈಲ್‌ಸಿಸ್ಟಮ್ ನಿಮ್ಮ ಎರಡನೇ ಬರಹವು ಮೊದಲನೆಯದು ಪೂರ್ಣಗೊಳ್ಳದ ಹೊರತು ಸಂಗ್ರಹಣೆಯಲ್ಲಿ ಗೋಚರಿಸುವುದಿಲ್ಲ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆಯೇ? ಇದು ವಿಪತ್ತು ಸಂಭವಿಸುವವರೆಗೂ ಅನೇಕ ಡೆವಲಪರ್‌ಗಳು ಕಡೆಗಣಿಸುವ ಪ್ರಶ್ನೆಯಾಗಿದೆ. 🛑

ಡೇಟಾ ಸಮಗ್ರತೆಯನ್ನು ನಿರ್ವಹಿಸುವಾಗ ಫೈಲ್ ಬಾಳಿಕೆ ನಿರ್ಣಾಯಕವಾಗಿದೆ, ವಿಶೇಷವಾಗಿ ವಿದ್ಯುತ್ ವೈಫಲ್ಯಗಳು ಅಥವಾ ಕ್ರ್ಯಾಶ್‌ಗಳು ಸಂಭವಿಸಿದಾಗ. POSIX-ಕಂಪ್ಲೈಂಟ್ ಸಿಸ್ಟಮ್‌ಗಳು ಅಥವಾ ext4 ನಂತಹ ಸಾಮಾನ್ಯ ಫೈಲ್‌ಸಿಸ್ಟಮ್‌ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ ಈ ಪ್ರಶ್ನೆಯು ಇನ್ನಷ್ಟು ಒತ್ತುತ್ತದೆ. ಬರಹಗಳು ಅನುಕ್ರಮ ಮತ್ತು ಪರಮಾಣು ಎಂದು ಖಾತರಿಪಡಿಸಲಾಗಿದೆಯೇ ಅಥವಾ ನಿಮಗೆ ಹೆಚ್ಚುವರಿ ಮುನ್ನೆಚ್ಚರಿಕೆಗಳ ಅಗತ್ಯವಿದೆಯೇ?

ಉದಾಹರಣೆಗೆ, ಎರಡು ಅತಿಕ್ರಮಿಸದ ಭಾಗಗಳಲ್ಲಿ ಫೈಲ್‌ಗೆ ಲಾಗ್‌ಗಳು ಅಥವಾ ರಚನಾತ್ಮಕ ಡೇಟಾವನ್ನು ಬರೆಯುವ ದೊಡ್ಡ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಪರಿಗಣಿಸಿ. ಸ್ಪಷ್ಟವಾದ ಗ್ಯಾರಂಟಿಗಳಿಲ್ಲದೆ, ಎರಡನೇ ಬರಹದ ಭಾಗವು ಡಿಸ್ಕ್‌ಗೆ ನುಸುಳುವ ಅಪಾಯವಿದೆ, ಇದು ಫೈಲ್ ಅನ್ನು ಅಸಮಂಜಸ ಸ್ಥಿತಿಯಲ್ಲಿ ಬಿಡುತ್ತದೆ. ಇದು ದೋಷಪೂರಿತ ಡೇಟಾಬೇಸ್‌ಗಳು, ಕಳೆದುಹೋದ ವಹಿವಾಟುಗಳು ಅಥವಾ ಅಪೂರ್ಣ ದಾಖಲೆಗಳಿಗೆ ಕಾರಣವಾಗಬಹುದು. 😓

ಈ ಲೇಖನವು POSIX, Linux, ಅಥವಾ ext4 ಗ್ಯಾರಂಟಿ ಫೈಲ್ ಬರೆಯುವ ಬಾಳಿಕೆ ಮತ್ತು ಆದೇಶದಂತಹ ಆಧುನಿಕ ಫೈಲ್‌ಸಿಸ್ಟಮ್‌ಗಳನ್ನು ಪರಿಶೋಧಿಸುತ್ತದೆ. ಬರಹಗಳ ನಡುವೆ fsync() ಅಥವಾ fdatasync() ಅನ್ನು ಬಳಸುವುದು ಡೇಟಾ ಅಸಂಗತತೆಯನ್ನು ತಡೆಗಟ್ಟುವ ಏಕೈಕ ವಿಶ್ವಾಸಾರ್ಹ ಪರಿಹಾರವಾಗಿದೆಯೇ ಎಂದು ನಾವು ನಿರ್ಧರಿಸುತ್ತೇವೆ.

ಆಜ್ಞೆ	ಬಳಕೆಯ ಉದಾಹರಣೆ
pwrite	pwrite ಕಾರ್ಯವು ಫೈಲ್ ಪಾಯಿಂಟರ್ ಅನ್ನು ಬದಲಾಯಿಸದೆ ನಿರ್ದಿಷ್ಟ ಫೈಲ್ ಡಿಸ್ಕ್ರಿಪ್ಟರ್‌ಗೆ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಆಫ್‌ಸೆಟ್‌ನಲ್ಲಿ ಡೇಟಾವನ್ನು ಬರೆಯುತ್ತದೆ. ಉದಾಹರಣೆಗೆ: pwrite(fd, data1, size1, offset1). ಇದು ನಿಖರವಾದ ಸ್ಥಾನಗಳಲ್ಲಿ ಬರಹಗಳು ನಡೆಯುವುದನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ, ಆದೇಶ ಬರಹಗಳಿಗೆ ಉಪಯುಕ್ತವಾಗಿದೆ.
fsync	fsync ಆಜ್ಞೆಯು ಫೈಲ್ ಡಿಸ್ಕ್ರಿಪ್ಟರ್‌ಗಾಗಿ ಎಲ್ಲಾ ಬಫರ್ಡ್ ಡೇಟಾವನ್ನು ಡಿಸ್ಕ್‌ಗೆ ಬರೆಯಲು ಒತ್ತಾಯಿಸುತ್ತದೆ. ಡೇಟಾ ಸುರಕ್ಷಿತವಾಗಿ ಮುಂದುವರಿದಿದೆ ಎಂದು ಇದು ಖಾತರಿಪಡಿಸುತ್ತದೆ. ಉದಾಹರಣೆಗೆ: fsync(fd).
O_RDWR	ಓಪನ್ ಸಿಸ್ಟಮ್ ಕರೆಯಲ್ಲಿನ O_RDWR ಫ್ಲ್ಯಾಗ್ ಓದುವಿಕೆ ಮತ್ತು ಬರೆಯುವಿಕೆ ಎರಡಕ್ಕೂ ಫೈಲ್ ಅನ್ನು ತೆರೆಯಲು ಅನುಮತಿಸುತ್ತದೆ. ಉದಾಹರಣೆಗೆ: ತೆರೆದ (ಮಾರ್ಗ, O_RDWR).
O_SYNC	O_SYNC ಫೈಲ್‌ಗೆ ಪ್ರತಿ ಬರಹವು ತಕ್ಷಣವೇ ಡೇಟಾವನ್ನು ಡಿಸ್ಕ್‌ಗೆ ಫ್ಲಶ್ ಮಾಡುತ್ತದೆ, ಬಾಳಿಕೆಗೆ ಖಾತರಿ ನೀಡುತ್ತದೆ. ಉದಾಹರಣೆಗೆ: open(path, O_SYNC).
errno	ವಿಫಲವಾದ ಸಿಸ್ಟಮ್ ಕರೆ ಸಮಯದಲ್ಲಿ ದೋಷ ಸಂಕೇತಗಳನ್ನು ದೋಷ ವೇರಿಯೇಬಲ್ ಸೆರೆಹಿಡಿಯುತ್ತದೆ. ದೋಷ ಸಂದೇಶಗಳನ್ನು ಪ್ರದರ್ಶಿಸಲು ಇದನ್ನು ಸಾಮಾನ್ಯವಾಗಿ ದೋಷದೊಂದಿಗೆ ಬಳಸಲಾಗುತ್ತದೆ. ಉದಾಹರಣೆ: ಅಪರಾಧ ("ಬರೆಯಲು ವಿಫಲವಾಗಿದೆ").
off_t	ಆಫ್_ಟಿ ಡೇಟಾ ಪ್ರಕಾರವು ಫೈಲ್ ಆಫ್‌ಸೆಟ್‌ಗಳನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ, ಇದನ್ನು ಸಾಮಾನ್ಯವಾಗಿ ಫೈಲ್ ಸ್ಥಾನೀಕರಣ ಕಾರ್ಯಾಚರಣೆಗಳಲ್ಲಿ ಬಳಸಲಾಗುತ್ತದೆ. ಉದಾಹರಣೆ: off_t ಆಫ್‌ಸೆಟ್ = 0.
assert	ಪ್ರತಿಪಾದನೆಯ ಕಾರ್ಯವು ಯುನಿಟ್ ಪರೀಕ್ಷೆಗಳಲ್ಲಿನ ಪರಿಸ್ಥಿತಿಗಳನ್ನು ಮೌಲ್ಯೀಕರಿಸುತ್ತದೆ, ನಿರೀಕ್ಷಿತ ಫಲಿತಾಂಶಗಳು ಸಂಭವಿಸುವುದನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ. ಉದಾಹರಣೆ: ವಿಷಯದಲ್ಲಿ "ಡೇಟಾ ಬ್ಲಾಕ್ 1" ಅನ್ನು ಪ್ರತಿಪಾದಿಸಿ.
fcntl.h	fcntl.h ಫೈಲ್ ಡಿಸ್ಕ್ರಿಪ್ಟರ್‌ಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಮತ್ತು ಕಡಿಮೆ ಮಟ್ಟದ I/O ಅನ್ನು ನಿರ್ವಹಿಸಲು ಅಗತ್ಯವಾದ ಫೈಲ್ ನಿಯಂತ್ರಣ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಒಳಗೊಂಡಿದೆ. ಉದಾಹರಣೆ: #include
O_CREAT	O_CREAT ಫ್ಲ್ಯಾಗ್ ತೆರೆದ ಸಮಯದಲ್ಲಿ ಅದು ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲದಿದ್ದರೆ ಫೈಲ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ. ಉದಾಹರಣೆ: ತೆರೆದ (ಮಾರ್ಗ, O_RDWR | O_CREAT).
perror	ದೋಷಪೂರಿತ ಕಾರ್ಯವು ವಿಫಲವಾದ ಸಿಸ್ಟಮ್ ಕರೆಗಳಿಗೆ ಸಂಬಂಧಿಸಿದ ವಿವರಣಾತ್ಮಕ ದೋಷ ಸಂದೇಶಗಳನ್ನು ಮುದ್ರಿಸುತ್ತದೆ. ಉದಾಹರಣೆ: ಅಪರಾಧ ("ತೆರೆದ ವಿಫಲವಾಗಿದೆ").

ಫೈಲ್ ರೈಟ್ ಬಾಳಿಕೆಯನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಮತ್ತು ಡೇಟಾ ಸ್ಥಿರತೆಯನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳುವುದು

ಈ ಹಿಂದೆ ಪ್ರಸ್ತುತಪಡಿಸಿದ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳಲ್ಲಿ, ವಿದ್ಯುತ್ ವೈಫಲ್ಯಗಳಂತಹ ಅನಿರೀಕ್ಷಿತ ಘಟನೆಗಳು ಸಂಭವಿಸಿದಾಗ ಲಿನಕ್ಸ್ ಫೈಲ್ ರೈಟ್‌ಗಳಲ್ಲಿ ಬಾಳಿಕೆ ಖಾತರಿಗಳು ಸಮಸ್ಯೆಯನ್ನು ನಾವು ತಿಳಿಸಿದ್ದೇವೆ. ಡೇಟಾದ ಎರಡನೇ ಬ್ಲಾಕ್ ಅನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳುವುದರ ಮೇಲೆ ಗಮನ ಕೇಂದ್ರೀಕರಿಸಿದೆ, , ಮೊದಲ ಬ್ಲಾಕ್ ಹೊರತು ಶೇಖರಣೆಯಲ್ಲಿ ಉಳಿಯುವುದಿಲ್ಲ, , ಈಗಾಗಲೇ ಸಂಪೂರ್ಣವಾಗಿ ಬರೆಯಲಾಗಿದೆ. ಪರಿಹಾರವು ಎಚ್ಚರಿಕೆಯಿಂದ ಆಯ್ಕೆಮಾಡಿದ ಸಿಸ್ಟಮ್ ಕರೆಗಳ ಸಂಯೋಜನೆಯ ಮೇಲೆ ಅವಲಂಬಿತವಾಗಿದೆ, ಉದಾಹರಣೆಗೆ ಮತ್ತು fsync, ಮತ್ತು ಫೈಲ್‌ಸಿಸ್ಟಮ್ ನಡವಳಿಕೆಗಳು. ಮೊದಲ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಬಳಸಲಾಗಿದೆ fsync ಡೇಟಾ2 ಬರೆಯಲು ಮುಂದುವರಿಯುವ ಮೊದಲು ಡೇಟಾ1 ಅನ್ನು ಡಿಸ್ಕ್‌ಗೆ ಫ್ಲಶ್ ಮಾಡಲಾಗಿದೆ ಎಂದು ಖಾತರಿಪಡಿಸಲು ಎರಡು ಅನುಕ್ರಮ ಬರಹಗಳ ನಡುವೆ. ಮೊದಲ ಬರವಣಿಗೆಯ ನಂತರ ಸಿಸ್ಟಮ್ ಕ್ರ್ಯಾಶ್ ಆಗಿದ್ದರೂ ಸಹ ಇದು ಡೇಟಾ ಸಮಗ್ರತೆಯನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ.

ಅದನ್ನು ಮತ್ತಷ್ಟು ವಿಭಜಿಸೋಣ: ದಿ ಫಂಕ್ಷನ್ ಫೈಲ್ ಪಾಯಿಂಟರ್ ಅನ್ನು ಮಾರ್ಪಡಿಸದೆ ಫೈಲ್‌ನಲ್ಲಿ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಆಫ್‌ಸೆಟ್‌ಗೆ ಬರೆಯುತ್ತದೆ. ಇಲ್ಲಿ ಪ್ರದರ್ಶಿಸಿದಂತೆ ಅತಿಕ್ರಮಿಸದ ಬರಹಗಳಿಗೆ ಇದು ವಿಶೇಷವಾಗಿ ಉಪಯುಕ್ತವಾಗಿದೆ, ಅಲ್ಲಿ ಎರಡು ಡೇಟಾ ಬ್ಲಾಕ್‌ಗಳನ್ನು ವಿಭಿನ್ನ ಆಫ್‌ಸೆಟ್‌ಗಳಿಗೆ ಬರೆಯಲಾಗುತ್ತದೆ. ಸ್ಪಷ್ಟವಾಗಿ ಬಳಸುವ ಮೂಲಕ ಮೊದಲ ಬರವಣಿಗೆಯ ನಂತರ, ನಾವು ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಂ ಅನ್ನು ಡಿಸ್ಕ್‌ಗೆ ಬಫರ್ ಮಾಡಿದ ವಿಷಯವನ್ನು ಫ್ಲಶ್ ಮಾಡಲು ಒತ್ತಾಯಿಸುತ್ತೇವೆ, ನಿರಂತರತೆಯನ್ನು ಖಾತ್ರಿಪಡಿಸಿಕೊಳ್ಳುತ್ತೇವೆ. fsync ಇಲ್ಲದೆ, ಡೇಟಾವು ಮೆಮೊರಿಯಲ್ಲಿ ಉಳಿಯಬಹುದು, ವಿದ್ಯುತ್ ವೈಫಲ್ಯದ ಸಮಯದಲ್ಲಿ ನಷ್ಟಕ್ಕೆ ಗುರಿಯಾಗಬಹುದು. ವಿಮರ್ಶಾತ್ಮಕ ಲಾಗ್ ನಮೂದನ್ನು ಬರೆಯುವುದನ್ನು ಅಥವಾ ಡೇಟಾಬೇಸ್‌ನ ಭಾಗವನ್ನು ಉಳಿಸುವುದನ್ನು ಕಲ್ಪಿಸಿಕೊಳ್ಳಿ-ಮೊದಲ ಭಾಗವು ಕಣ್ಮರೆಯಾದರೆ, ಡೇಟಾವು ಅಸಮಂಜಸವಾಗುತ್ತದೆ. 😓

ಎರಡನೇ ಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ, ನಾವು ಇದರ ಬಳಕೆಯನ್ನು ಅನ್ವೇಷಿಸಿದ್ದೇವೆ ಧ್ವಜದಲ್ಲಿ ಸಿಸ್ಟಮ್ ಕರೆ. ಈ ಫ್ಲ್ಯಾಗ್ ಅನ್ನು ಸಕ್ರಿಯಗೊಳಿಸುವುದರೊಂದಿಗೆ, ಪ್ರತಿ ಬರಹ ಕಾರ್ಯಾಚರಣೆಯು ತಕ್ಷಣವೇ ಡೇಟಾವನ್ನು ಸಂಗ್ರಹಣೆಗೆ ಫ್ಲಶ್ ಮಾಡುತ್ತದೆ, ಕೈಪಿಡಿಯ ಅಗತ್ಯವನ್ನು ತೆಗೆದುಹಾಕುತ್ತದೆ ಕರೆಗಳು. ಬಾಳಿಕೆ ಗ್ಯಾರಂಟಿಗಳನ್ನು ಖಾತ್ರಿಪಡಿಸುವಾಗ ಇದು ಕೋಡ್ ಅನ್ನು ಸರಳಗೊಳಿಸುತ್ತದೆ. ಆದಾಗ್ಯೂ, ಒಂದು ಟ್ರೇಡ್-ಆಫ್ ಇದೆ: O_SYNC ಅನ್ನು ಬಳಸುವುದರಿಂದ ಕಾರ್ಯಕ್ಷಮತೆಯ ದಂಡವನ್ನು ಪರಿಚಯಿಸುತ್ತದೆ ಏಕೆಂದರೆ ಸಿಂಕ್ರೊನಸ್ ಬರಹಗಳು ಬಫರ್ ಮಾಡಿದ ಬರಹಗಳಿಗೆ ಹೋಲಿಸಿದರೆ ಹೆಚ್ಚು ಸಮಯ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ. ಹಣಕಾಸು ವ್ಯವಸ್ಥೆಗಳು ಅಥವಾ ನೈಜ-ಸಮಯದ ಡೇಟಾ ಲಾಗಿಂಗ್‌ನಂತಹ ಕಾರ್ಯಕ್ಷಮತೆಯ ಕಾಳಜಿಯನ್ನು ವಿಶ್ವಾಸಾರ್ಹತೆಯು ಮೀರಿಸುವ ವ್ಯವಸ್ಥೆಗಳಿಗೆ ಈ ವಿಧಾನವು ಸೂಕ್ತವಾಗಿದೆ. ಉದಾಹರಣೆಗೆ, ನೀವು ಸಂವೇದಕ ಡೇಟಾ ಅಥವಾ ವಹಿವಾಟು ಲಾಗ್‌ಗಳನ್ನು ಉಳಿಸುತ್ತಿದ್ದರೆ, ನೀವು ಸಂಪೂರ್ಣವಾಗಿ ವಿಶ್ವಾಸಾರ್ಹವಾಗಿರಲು ಪ್ರತಿ ಬರಹದ ಅಗತ್ಯವಿದೆ. 🚀

C ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಿದ ನಂತರ ಫೈಲ್‌ನ ವಿಷಯಗಳನ್ನು ಪರಿಶೀಲಿಸುವ ಮೂಲಕ ಪೈಥಾನ್‌ನಲ್ಲಿ ಬರೆಯಲಾದ ಯುನಿಟ್ ಟೆಸ್ಟ್ ಸ್ಕ್ರಿಪ್ಟ್ ಈ ಪರಿಹಾರಗಳನ್ನು ಮೌಲ್ಯೀಕರಿಸಿದೆ. ಡೇಟಾ1 ಮತ್ತು ಡೇಟಾ2 ಎರಡನ್ನೂ ನಿರೀಕ್ಷಿಸಿದಂತೆ ಬರೆಯಲಾಗಿದೆ ಎಂದು ಇದು ಖಚಿತಪಡಿಸಿದೆ. ಈ ಹಂತವು ವಿವಿಧ ಪರಿಸ್ಥಿತಿಗಳಲ್ಲಿ ಫೈಲ್ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಪರೀಕ್ಷಿಸುವ ಪ್ರಾಮುಖ್ಯತೆಯನ್ನು ಎತ್ತಿ ತೋರಿಸುತ್ತದೆ. ಪ್ರೊಡಕ್ಷನ್ ಸರ್ವರ್‌ನಲ್ಲಿ ನೀವು ಇದೇ ರೀತಿಯ ಪರಿಹಾರವನ್ನು ನಿಯೋಜಿಸಲು ಬಯಸಿದರೆ, ನಿಮ್ಮ ಬರಹಗಳ ಸಮಗ್ರತೆಯನ್ನು ಪರಿಶೀಲಿಸಲು ಘಟಕ ಪರೀಕ್ಷೆಗಳು ನಿರ್ಣಾಯಕವಾಗಿರುತ್ತವೆ. ಪರೀಕ್ಷೆಗಳ ಮೂಲಕ ದೃಢೀಕರಣದೊಂದಿಗೆ 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")

ಲಿನಕ್ಸ್‌ನಲ್ಲಿ ಡೇಟಾ ಸ್ಥಿರತೆಯನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳುವುದು: ಜರ್ನಲಿಂಗ್ ಮತ್ತು ಬಫರ್ಡ್ ರೈಟ್ಸ್

ತಿಳುವಳಿಕೆಯ ಒಂದು ನಿರ್ಣಾಯಕ ಅಂಶ ext4 ನಂತಹ Linux ಫೈಲ್‌ಸಿಸ್ಟಮ್‌ಗಳಲ್ಲಿ ಜರ್ನಲಿಂಗ್ ಪಾತ್ರವಾಗಿದೆ. ಜರ್ನಲಿಂಗ್ ಫೈಲ್‌ಸಿಸ್ಟಮ್‌ಗಳು ಮುಖ್ಯ ಸಂಗ್ರಹಣೆಗೆ ಬದ್ಧರಾಗುವ ಮೊದಲು ಬದಲಾವಣೆಗಳ ಲಾಗ್ ಅನ್ನು (ಅಥವಾ ಜರ್ನಲ್) ನಿರ್ವಹಿಸುವ ಮೂಲಕ ವಿದ್ಯುತ್ ವೈಫಲ್ಯಗಳಂತಹ ಅನಿರೀಕ್ಷಿತ ಘಟನೆಗಳ ಸಂದರ್ಭದಲ್ಲಿ ಭ್ರಷ್ಟಾಚಾರವನ್ನು ತಡೆಯಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ. ನಿಮ್ಮ ಡೇಟಾವನ್ನು ಸ್ಥಿರವಾಗಿ ಇರಿಸಿಕೊಂಡು, ಅಪೂರ್ಣ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಹಿಂತಿರುಗಿಸಲಾಗಿದೆ ಎಂದು ಜರ್ನಲ್ ಖಚಿತಪಡಿಸುತ್ತದೆ. ಆದಾಗ್ಯೂ, ಕರೆ ಮಾಡುವಂತಹ ಹೆಚ್ಚುವರಿ ಮುನ್ನೆಚ್ಚರಿಕೆಗಳಿಲ್ಲದೆ ಜರ್ನಲಿಂಗ್ ಆದೇಶದ ಬರಹಗಳಿಗೆ ಅಂತರ್ಗತವಾಗಿ ಖಾತರಿ ನೀಡುವುದಿಲ್ಲ . ನಮ್ಮ ಉದಾಹರಣೆಯಲ್ಲಿ, ಜರ್ನಲಿಂಗ್ ಮಾಡುವಾಗ ಫೈಲ್ ದೋಷಪೂರಿತವಾಗುವುದಿಲ್ಲ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಬಹುದು, ಭಾಗಗಳು ಮೊದಲು ಇನ್ನೂ ಮುಂದುವರೆಯಬಹುದು ಡೇಟಾ 1.

ಲಿನಕ್ಸ್ ಬಫರ್ಸ್ ಫೈಲ್ ಹೇಗೆ ಬರೆಯುತ್ತದೆ ಎಂಬುದು ಮತ್ತೊಂದು ಪರಿಗಣನೆಯಾಗಿದೆ. ನೀವು ಬಳಸುವಾಗ ಅಥವಾ , ಡೇಟಾವನ್ನು ಸಾಮಾನ್ಯವಾಗಿ ಮೆಮೊರಿ ಬಫರ್‌ಗೆ ಬರೆಯಲಾಗುತ್ತದೆ, ನೇರವಾಗಿ ಡಿಸ್ಕ್‌ಗೆ ಅಲ್ಲ. ಈ ಬಫರಿಂಗ್ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಸುಧಾರಿಸುತ್ತದೆ ಆದರೆ ಬಫರ್ ಅನ್ನು ಫ್ಲಶ್ ಮಾಡುವ ಮೊದಲು ಸಿಸ್ಟಮ್ ಕ್ರ್ಯಾಶ್ ಆಗಿದ್ದರೆ ಡೇಟಾ ನಷ್ಟ ಸಂಭವಿಸುವ ಅಪಾಯವನ್ನು ಸೃಷ್ಟಿಸುತ್ತದೆ. ಕರೆ ಮಾಡಲಾಗುತ್ತಿದೆ ಅಥವಾ ಇದರೊಂದಿಗೆ ಫೈಲ್ ತೆರೆಯುವುದು O_SYNC ಫ್ಲ್ಯಾಗ್ ಬಫರ್ ಮಾಡಲಾದ ಡೇಟಾವನ್ನು ಸುರಕ್ಷಿತವಾಗಿ ಡಿಸ್ಕ್‌ಗೆ ಫ್ಲಶ್ ಮಾಡುವುದನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ, ಅಸಂಗತತೆಯನ್ನು ತಡೆಯುತ್ತದೆ. ಈ ಕ್ರಮಗಳಿಲ್ಲದೆ, ನಿರ್ದಿಷ್ಟವಾಗಿ ವಿದ್ಯುತ್ ವೈಫಲ್ಯದ ಸಂದರ್ಭಗಳಲ್ಲಿ ಡೇಟಾವನ್ನು ಭಾಗಶಃ ಬರೆಯಬಹುದು. ⚡

ದೊಡ್ಡ ಫೈಲ್‌ಗಳು ಅಥವಾ ನಿರ್ಣಾಯಕ ವ್ಯವಸ್ಥೆಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವ ಡೆವಲಪರ್‌ಗಳಿಗೆ, ಬಾಳಿಕೆಯನ್ನು ಗಮನದಲ್ಲಿಟ್ಟುಕೊಂಡು ಕಾರ್ಯಕ್ರಮಗಳನ್ನು ವಿನ್ಯಾಸಗೊಳಿಸುವುದು ಅತ್ಯಗತ್ಯ. ಉದಾಹರಣೆಗೆ, ಸೀಟ್ ಲಭ್ಯತೆಯ ಡೇಟಾವನ್ನು ಬರೆಯುವ ಏರ್‌ಲೈನ್ ಮೀಸಲಾತಿ ವ್ಯವಸ್ಥೆಯನ್ನು ಕಲ್ಪಿಸಿಕೊಳ್ಳಿ. ಫ್ಲೈಟ್ ವಿವರಗಳನ್ನು ಸೂಚಿಸುವ ಮೊದಲ ಬ್ಲಾಕ್ ಅನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ಬರೆಯಲಾಗದಿದ್ದರೆ ಮತ್ತು ಎರಡನೇ ಬ್ಲಾಕ್ ಮುಂದುವರಿದರೆ, ಅದು ಡೇಟಾ ಭ್ರಷ್ಟಾಚಾರ ಅಥವಾ ಡಬಲ್ ಬುಕಿಂಗ್‌ಗೆ ಕಾರಣವಾಗಬಹುದು. ಬಳಸುತ್ತಿದೆ ಅಥವಾ ನಿರ್ಣಾಯಕ ಹಂತಗಳಲ್ಲಿ ಈ ಅಪಾಯಗಳನ್ನು ತಪ್ಪಿಸುತ್ತದೆ. ವಿಶ್ವಾಸಾರ್ಹತೆಯನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ನೈಜ ವೈಫಲ್ಯದ ಸಿಮ್ಯುಲೇಶನ್‌ಗಳ ಅಡಿಯಲ್ಲಿ ಯಾವಾಗಲೂ ನಡವಳಿಕೆಯನ್ನು ಪರೀಕ್ಷಿಸಿ. 😊

1. ಏನು ಮಾಡುತ್ತದೆ ಮಾಡಿ, ಮತ್ತು ನಾನು ಅದನ್ನು ಯಾವಾಗ ಬಳಸಬೇಕು?
2. ಫೈಲ್‌ಗಾಗಿ ಎಲ್ಲಾ ಡೇಟಾ ಮತ್ತು ಮೆಟಾಡೇಟಾವನ್ನು ಮೆಮೊರಿ ಬಫರ್‌ಗಳಿಂದ ಡಿಸ್ಕ್‌ಗೆ ಫ್ಲಶ್ ಮಾಡಲಾಗಿದೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ. ಬಾಳಿಕೆಯನ್ನು ಖಾತರಿಪಡಿಸಲು ನಿರ್ಣಾಯಕ ಬರಹಗಳ ನಂತರ ಅದನ್ನು ಬಳಸಿ.
3. ನಡುವಿನ ವ್ಯತ್ಯಾಸವೇನು ಮತ್ತು ?
4. ಫೈಲ್ ಗಾತ್ರದ ನವೀಕರಣಗಳಂತಹ ಮೆಟಾಡೇಟಾವನ್ನು ಹೊರತುಪಡಿಸಿ ಫೈಲ್ ಡೇಟಾವನ್ನು ಮಾತ್ರ ಫ್ಲಶ್ ಮಾಡುತ್ತದೆ. ಡೇಟಾ ಮತ್ತು ಮೆಟಾಡೇಟಾ ಎರಡನ್ನೂ ಫ್ಲಶ್ ಮಾಡುತ್ತದೆ.
5. ext4 ರಲ್ಲಿ ಜರ್ನಲಿಂಗ್ ಆದೇಶದ ಬರಹಗಳನ್ನು ಖಾತರಿಪಡಿಸುತ್ತದೆಯೇ?
6. ಇಲ್ಲ, ext4 ಜರ್ನಲಿಂಗ್ ಸ್ಥಿರತೆಯನ್ನು ಖಾತ್ರಿಗೊಳಿಸುತ್ತದೆ ಆದರೆ ಸ್ಪಷ್ಟವಾಗಿ ಬಳಸದೆಯೇ ಬರಹಗಳು ಕ್ರಮವಾಗಿ ಸಂಭವಿಸುತ್ತವೆ ಎಂದು ಖಾತರಿ ನೀಡುವುದಿಲ್ಲ ಅಥವಾ .
7. ಹೇಗೆ ಮಾಡುತ್ತದೆ ಸಾಮಾನ್ಯ ಫೈಲ್ ಬರೆಯುವಿಕೆಗಿಂತ ಭಿನ್ನವಾಗಿದೆಯೇ?
8. ಜೊತೆಗೆ , ಪ್ರತಿ ಬರಹವು ತಕ್ಷಣವೇ ಡಿಸ್ಕ್‌ಗೆ ಫ್ಲಶ್ ಆಗುತ್ತದೆ, ಬಾಳಿಕೆಯನ್ನು ಖಾತ್ರಿಪಡಿಸುತ್ತದೆ ಆದರೆ ಕಾರ್ಯಕ್ಷಮತೆಗೆ ವೆಚ್ಚವಾಗುತ್ತದೆ.
9. ನನ್ನ ಸಿಸ್ಟಂನಲ್ಲಿ ನಾನು ಫೈಲ್ ಬರೆಯುವ ಬಾಳಿಕೆ ಪರೀಕ್ಷಿಸಬಹುದೇ?
10. ಹೌದು, ನೀವು ವರ್ಚುವಲ್ ಯಂತ್ರಗಳು ಅಥವಾ ಉಪಕರಣಗಳನ್ನು ಬಳಸಿಕೊಂಡು ವಿದ್ಯುತ್ ವೈಫಲ್ಯಗಳನ್ನು ಅನುಕರಿಸಬಹುದು ಫೈಲ್ ಬರಹಗಳು ಹೇಗೆ ವರ್ತಿಸುತ್ತವೆ ಎಂಬುದನ್ನು ವೀಕ್ಷಿಸಲು.

ವಿದ್ಯುತ್ ವೈಫಲ್ಯದ ಸಮಯದಲ್ಲಿ ಫೈಲ್ ಬಾಳಿಕೆಯನ್ನು ಖಾತರಿಪಡಿಸಲು ಉದ್ದೇಶಪೂರ್ವಕ ವಿನ್ಯಾಸದ ಅಗತ್ಯವಿದೆ. ಮುಂತಾದ ಉಪಕರಣಗಳಿಲ್ಲದೆ ಅಥವಾ , Linux ಫೈಲ್‌ಸಿಸ್ಟಮ್‌ಗಳು ಫೈಲ್‌ಗಳನ್ನು ಅಸಮಂಜಸ ಸ್ಥಿತಿಗಳಲ್ಲಿ ಬಿಡಬಹುದು. ನಿರ್ಣಾಯಕ ಅನ್ವಯಗಳಿಗೆ, ಪ್ರಮುಖ ಹಂತಗಳಲ್ಲಿ ಬರಹಗಳನ್ನು ಪರೀಕ್ಷಿಸುವುದು ಮತ್ತು ಫ್ಲಶಿಂಗ್ ಮಾಡುವುದು ಅತ್ಯಗತ್ಯ ಅಭ್ಯಾಸಗಳಾಗಿವೆ.

ಕ್ರ್ಯಾಶ್ ಸಮಯದಲ್ಲಿ ಲಾಗ್ ಫೈಲ್‌ನ ಭಾಗಗಳನ್ನು ಕಳೆದುಕೊಳ್ಳುವುದನ್ನು ಕಲ್ಪಿಸಿಕೊಳ್ಳಿ. ಡೇಟಾ2 ಭ್ರಷ್ಟಾಚಾರವನ್ನು ತಡೆಯುವ ಮೊದಲು ಡೇಟಾ1 ಅನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ಸಂಗ್ರಹಿಸಲಾಗಿದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳುವುದು. ಉತ್ತಮ ಅಭ್ಯಾಸಗಳನ್ನು ಅನುಸರಿಸುವುದು ಅನಿರೀಕ್ಷಿತ ವೈಫಲ್ಯಗಳಲ್ಲಿಯೂ ಸಹ ದೃಢವಾದ ಡೇಟಾ ಸಮಗ್ರತೆಯನ್ನು ಖಾತ್ರಿಗೊಳಿಸುತ್ತದೆ. ⚡