ਕੀ ਲੀਨਕਸ ਪਾਵਰ ਆਊਟੇਜ ਦੀ ਸਥਿਤੀ ਵਿੱਚ ਕ੍ਰਮਵਾਰ ਫਾਈਲ ਲਿਖਣ ਦਾ ਵਾਅਦਾ ਕਰਦਾ ਹੈ?

ਪਾਵਰ ਅਸਫਲਤਾਵਾਂ ਦੌਰਾਨ ਫਾਈਲ ਲਿਖਣ ਦੀ ਟਿਕਾਊਤਾ ਨੂੰ ਸਮਝਣਾ

ਕਲਪਨਾ ਕਰੋ ਕਿ ਤੁਸੀਂ ਇੱਕ ਫਾਈਲ ਵਿੱਚ ਡੇਟਾ ਦੇ ਦੋ ਮਹੱਤਵਪੂਰਨ ਟੁਕੜੇ ਲਿਖ ਰਹੇ ਹੋ, ਅਤੇ ਅਚਾਨਕ ਪਾਵਰ ਚਲੀ ਜਾਂਦੀ ਹੈ। ਕੀ ਲੀਨਕਸ ਜਾਂ ਤੁਹਾਡਾ ਚੁਣਿਆ ਹੋਇਆ ਫਾਈਲ ਸਿਸਟਮ ਇਹ ਯਕੀਨੀ ਬਣਾਵੇਗਾ ਕਿ ਤੁਹਾਡੀ ਦੂਜੀ ਲਿਖਤ ਸਟੋਰੇਜ ਵਿੱਚ ਦਿਖਾਈ ਨਹੀਂ ਦਿੰਦੀ ਜਦੋਂ ਤੱਕ ਪਹਿਲਾ ਪੂਰਾ ਨਹੀਂ ਹੁੰਦਾ? ਇਹ ਇੱਕ ਅਜਿਹਾ ਸਵਾਲ ਹੈ ਜਿਸਨੂੰ ਬਹੁਤ ਸਾਰੇ ਡਿਵੈਲਪਰ ਤਬਾਹੀ ਦੇ ਹਮਲੇ ਤੱਕ ਨਜ਼ਰਅੰਦਾਜ਼ ਕਰਦੇ ਹਨ। 🛑

ਡੇਟਾ ਦੀ ਇਕਸਾਰਤਾ ਨੂੰ ਸੰਭਾਲਣ ਵੇਲੇ ਫਾਈਲ ਟਿਕਾਊਤਾ ਮਹੱਤਵਪੂਰਨ ਹੁੰਦੀ ਹੈ, ਖਾਸ ਕਰਕੇ ਜਦੋਂ ਪਾਵਰ ਅਸਫਲਤਾ ਜਾਂ ਕਰੈਸ਼ ਹੁੰਦੇ ਹਨ। POSIX-ਅਨੁਕੂਲ ਸਿਸਟਮ ਜਾਂ ext4 ਵਰਗੇ ਆਮ ਫਾਈਲ ਸਿਸਟਮਾਂ ਨਾਲ ਕੰਮ ਕਰਦੇ ਸਮੇਂ ਇਹ ਸਵਾਲ ਹੋਰ ਵੀ ਦਬਾਅ ਬਣ ਜਾਂਦਾ ਹੈ। ਕੀ ਲਿਖਤਾਂ ਦੇ ਕ੍ਰਮਵਾਰ ਅਤੇ ਪਰਮਾਣੂ ਹੋਣ ਦੀ ਗਰੰਟੀ ਹੈ, ਜਾਂ ਕੀ ਤੁਹਾਨੂੰ ਵਾਧੂ ਸਾਵਧਾਨੀਆਂ ਦੀ ਲੋੜ ਹੈ?

ਉਦਾਹਰਨ ਲਈ, ਦੋ ਗੈਰ-ਓਵਰਲੈਪਿੰਗ ਹਿੱਸਿਆਂ ਵਿੱਚ ਇੱਕ ਫਾਈਲ ਵਿੱਚ ਇੱਕ ਵੱਡੀ ਐਪਲੀਕੇਸ਼ਨ ਲਿਖਣ ਵਾਲੇ ਲੌਗਸ ਜਾਂ ਸਟ੍ਰਕਚਰਡ ਡੇਟਾ 'ਤੇ ਵਿਚਾਰ ਕਰੋ। ਸਪੱਸ਼ਟ ਗਾਰੰਟੀ ਦੇ ਬਿਨਾਂ, ਇੱਕ ਜੋਖਮ ਹੁੰਦਾ ਹੈ ਕਿ ਦੂਜੀ ਲਿਖਤ ਦਾ ਹਿੱਸਾ ਡਿਸਕ ਵਿੱਚ ਘੁਸ ਜਾਂਦਾ ਹੈ, ਫਾਈਲ ਨੂੰ ਇੱਕ ਅਸੰਗਤ ਸਥਿਤੀ ਵਿੱਚ ਛੱਡਦਾ ਹੈ। ਇਹ ਖਰਾਬ ਡੇਟਾਬੇਸ, ਗੁੰਮ ਹੋਏ ਲੈਣ-ਦੇਣ, ਜਾਂ ਅਧੂਰੇ ਰਿਕਾਰਡਾਂ ਦੀ ਅਗਵਾਈ ਕਰ ਸਕਦਾ ਹੈ। 😓

ਇਹ ਲੇਖ ਖੋਜ ਕਰਦਾ ਹੈ ਕਿ ਕੀ ਪੋਸਿਕਸ, ਲੀਨਕਸ, ਜਾਂ ਆਧੁਨਿਕ ਫਾਈਲ ਸਿਸਟਮ ਜਿਵੇਂ ਕਿ ext4 ਗਾਰੰਟੀ ਫਾਈਲ ਟਿਕਾਊਤਾ ਅਤੇ ਆਰਡਰਿੰਗ। ਅਸੀਂ ਇਹ ਵੀ ਨਿਰਧਾਰਿਤ ਕਰਾਂਗੇ ਕਿ ਕੀ fsync() ਜਾਂ fdatasync() ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਡਾਟਾ ਦੀ ਅਸੰਗਤਤਾ ਨੂੰ ਰੋਕਣ ਦਾ ਇੱਕੋ ਇੱਕ ਭਰੋਸੇਯੋਗ ਹੱਲ ਹੈ।

ਹੁਕਮ	ਵਰਤੋਂ ਦੀ ਉਦਾਹਰਨ
pwrite	pwrite ਫੰਕਸ਼ਨ ਫਾਈਲ ਪੁਆਇੰਟਰ ਨੂੰ ਬਦਲੇ ਬਿਨਾਂ ਇੱਕ ਖਾਸ ਆਫਸੈੱਟ 'ਤੇ ਇੱਕ ਖਾਸ ਫਾਈਲ ਡਿਸਕ੍ਰਿਪਟਰ ਨੂੰ ਡੇਟਾ ਲਿਖਦਾ ਹੈ। ਉਦਾਹਰਨ ਲਈ: pwrite(fd, data1, size1, offset1)। ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕਰਦਾ ਹੈ ਕਿ ਲਿਖਤਾਂ ਸਹੀ ਸਥਿਤੀਆਂ 'ਤੇ ਹੁੰਦੀਆਂ ਹਨ, ਆਰਡਰ ਕੀਤੀਆਂ ਲਿਖਤਾਂ ਲਈ ਉਪਯੋਗੀ।
fsync	fsync ਕਮਾਂਡ ਇੱਕ ਫਾਈਲ ਡਿਸਕ੍ਰਿਪਟਰ ਲਈ ਸਾਰੇ ਬਫਰ ਕੀਤੇ ਡੇਟਾ ਨੂੰ ਡਿਸਕ ਤੇ ਲਿਖਣ ਲਈ ਮਜਬੂਰ ਕਰਦੀ ਹੈ। ਇਹ ਗਾਰੰਟੀ ਦਿੰਦਾ ਹੈ ਕਿ ਡੇਟਾ ਸੁਰੱਖਿਅਤ ਢੰਗ ਨਾਲ ਬਰਕਰਾਰ ਹੈ। ਉਦਾਹਰਨ ਲਈ: fsync(fd)।
O_RDWR	ਓਪਨ ਸਿਸਟਮ ਕਾਲ ਵਿੱਚ O_RDWR ਫਲੈਗ ਇੱਕ ਫਾਈਲ ਨੂੰ ਪੜ੍ਹਨ ਅਤੇ ਲਿਖਣ ਦੋਵਾਂ ਲਈ ਖੋਲ੍ਹਣ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ। ਉਦਾਹਰਨ ਲਈ: open(path, O_RDWR)।
O_SYNC	O_SYNC ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕਰਦਾ ਹੈ ਕਿ ਫਾਈਲ 'ਤੇ ਹਰ ਲਿਖਤ ਤੁਰੰਤ ਡਾਟਾ ਨੂੰ ਡਿਸਕ 'ਤੇ ਫਲੱਸ਼ ਕਰਦੀ ਹੈ, ਟਿਕਾਊਤਾ ਦੀ ਗਾਰੰਟੀ ਦਿੰਦੀ ਹੈ। ਉਦਾਹਰਨ ਲਈ: open(path, O_SYNC)।
errno	ਇਰਨੋ ਵੇਰੀਏਬਲ ਇੱਕ ਅਸਫਲ ਸਿਸਟਮ ਕਾਲ ਦੌਰਾਨ ਗਲਤੀ ਕੋਡਾਂ ਨੂੰ ਕੈਪਚਰ ਕਰਦਾ ਹੈ। ਇਹ ਅਕਸਰ ਗਲਤੀ ਸੁਨੇਹਿਆਂ ਨੂੰ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨ ਲਈ perror ਨਾਲ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। ਉਦਾਹਰਨ: ਗਲਤੀ ("ਲਿਖਣ ਵਿੱਚ ਅਸਫਲ")।
off_t	off_t ਡਾਟਾ ਕਿਸਮ ਫਾਈਲ ਆਫਸੈਟਾਂ ਨੂੰ ਦਰਸਾਉਂਦੀ ਹੈ, ਆਮ ਤੌਰ 'ਤੇ ਫਾਈਲ ਪੋਜੀਸ਼ਨਿੰਗ ਓਪਰੇਸ਼ਨਾਂ ਵਿੱਚ ਵਰਤੀ ਜਾਂਦੀ ਹੈ। ਉਦਾਹਰਨ: off_t offset = 0।
assert	ਅਸਰਟ ਫੰਕਸ਼ਨ ਯੂਨਿਟ ਟੈਸਟਾਂ ਵਿੱਚ ਸ਼ਰਤਾਂ ਨੂੰ ਪ੍ਰਮਾਣਿਤ ਕਰਦਾ ਹੈ, ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ ਸੰਭਾਵਿਤ ਨਤੀਜੇ ਸਾਹਮਣੇ ਆਉਂਦੇ ਹਨ। ਉਦਾਹਰਨ: ਸਮੱਗਰੀ ਵਿੱਚ "ਡੇਟਾ ਬਲਾਕ 1" ​​ਦਾ ਦਾਅਵਾ ਕਰੋ।
fcntl.h	fcntl.h ਵਿੱਚ ਫਾਈਲ ਡਿਸਕ੍ਰਿਪਟਰਾਂ ਦੇ ਪ੍ਰਬੰਧਨ ਅਤੇ ਘੱਟ-ਪੱਧਰੀ I/O ਕਰਨ ਲਈ ਜ਼ਰੂਰੀ ਫਾਈਲ ਨਿਯੰਤਰਣ ਕਾਰਜ ਸ਼ਾਮਲ ਹਨ। ਉਦਾਹਰਨ: #include
O_CREAT	O_CREAT ਫਲੈਗ ਇੱਕ ਫਾਈਲ ਬਣਾਉਂਦਾ ਹੈ ਜੇਕਰ ਇਹ ਓਪਨ ਦੌਰਾਨ ਮੌਜੂਦ ਨਹੀਂ ਹੈ। ਉਦਾਹਰਨ: open(path, O_RDWR | O_CREAT)।
perror	ਪਰਰ ਫੰਕਸ਼ਨ ਅਸਫ਼ਲ ਸਿਸਟਮ ਕਾਲਾਂ ਨਾਲ ਸੰਬੰਧਿਤ ਵਰਣਨਯੋਗ ਗਲਤੀ ਸੁਨੇਹਿਆਂ ਨੂੰ ਪ੍ਰਿੰਟ ਕਰਦਾ ਹੈ। ਉਦਾਹਰਨ: ਗਲਤੀ ("ਓਪਨ ਅਸਫਲ")।

ਫਾਈਲ ਲਿਖਣ ਦੀ ਟਿਕਾਊਤਾ ਨੂੰ ਸਮਝਣਾ ਅਤੇ ਡੇਟਾ ਇਕਸਾਰਤਾ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਣਾ

ਪਹਿਲਾਂ ਪੇਸ਼ ਕੀਤੀਆਂ ਸਕ੍ਰਿਪਟਾਂ ਵਿੱਚ, ਅਸੀਂ ਲੀਨਕਸ ਫਾਈਲ ਰਾਈਟਸ ਵਿੱਚ ਟਿਕਾਊਤਾ ਗਾਰੰਟੀ ਦੇ ਮੁੱਦੇ ਨੂੰ ਸੰਬੋਧਿਤ ਕੀਤਾ ਹੈ ਜਦੋਂ ਅਚਾਨਕ ਘਟਨਾਵਾਂ, ਜਿਵੇਂ ਕਿ ਪਾਵਰ ਫੇਲ੍ਹ ਹੋਣ, ਵਾਪਰਦੀਆਂ ਹਨ। ਫੋਕਸ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ 'ਤੇ ਸੀ ਕਿ ਡੇਟਾ ਦਾ ਦੂਜਾ ਬਲਾਕ, , ਸਟੋਰੇਜ ਲਈ ਜਾਰੀ ਨਹੀਂ ਰਹੇਗਾ ਜਦੋਂ ਤੱਕ ਪਹਿਲਾ ਬਲਾਕ ਨਹੀਂ ਹੁੰਦਾ, , ਪਹਿਲਾਂ ਹੀ ਪੂਰੀ ਤਰ੍ਹਾਂ ਲਿਖਿਆ ਜਾ ਚੁੱਕਾ ਸੀ। ਹੱਲ ਧਿਆਨ ਨਾਲ ਚੁਣੀਆਂ ਗਈਆਂ ਸਿਸਟਮ ਕਾਲਾਂ ਦੇ ਸੁਮੇਲ 'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ, ਜਿਵੇਂ ਕਿ ਅਤੇ fsync, ਅਤੇ ਫਾਈਲ ਸਿਸਟਮ ਵਿਵਹਾਰ। ਪਹਿਲੀ ਸਕਰਿਪਟ ਨੂੰ ਕੰਮ 'ਤੇ fsync ਇਹ ਗਾਰੰਟੀ ਦੇਣ ਲਈ ਦੋ ਕ੍ਰਮਵਾਰ ਰਾਈਟਸ ਦੇ ਵਿਚਕਾਰ ਡਾਟਾ1 ਨੂੰ ਡਾਟਾ2 ਲਿਖਣ ਲਈ ਅੱਗੇ ਵਧਣ ਤੋਂ ਪਹਿਲਾਂ ਡਿਸਕ 'ਤੇ ਫਲੱਸ਼ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਇਹ ਡੇਟਾ ਦੀ ਇਕਸਾਰਤਾ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ, ਭਾਵੇਂ ਸਿਸਟਮ ਪਹਿਲੀ ਲਿਖਤ ਤੋਂ ਬਾਅਦ ਕਰੈਸ਼ ਹੋ ਜਾਵੇ।

ਆਓ ਇਸਨੂੰ ਹੋਰ ਤੋੜੀਏ: the ਫੰਕਸ਼ਨ ਫਾਈਲ ਪੁਆਇੰਟਰ ਨੂੰ ਸੋਧੇ ਬਿਨਾਂ ਇੱਕ ਫਾਈਲ ਦੇ ਅੰਦਰ ਇੱਕ ਨਿਰਧਾਰਤ ਆਫਸੈੱਟ ਨੂੰ ਲਿਖਦਾ ਹੈ. ਇਹ ਖਾਸ ਤੌਰ 'ਤੇ ਗੈਰ-ਓਵਰਲੈਪਿੰਗ ਰਾਈਟਸ ਲਈ ਲਾਭਦਾਇਕ ਹੈ, ਜਿਵੇਂ ਕਿ ਇੱਥੇ ਦਿਖਾਇਆ ਗਿਆ ਹੈ, ਜਿੱਥੇ ਦੋ ਡਾਟਾ ਬਲਾਕ ਵੱਖਰੇ ਆਫਸੈਟਾਂ ਲਈ ਲਿਖੇ ਗਏ ਹਨ। ਸਪਸ਼ਟ ਤੌਰ ਤੇ ਵਰਤ ਕੇ ਪਹਿਲੀ ਲਿਖਤ ਤੋਂ ਬਾਅਦ, ਅਸੀਂ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਨੂੰ ਫਾਈਲ ਦੀ ਬਫਰ ਕੀਤੀ ਸਮੱਗਰੀ ਨੂੰ ਡਿਸਕ 'ਤੇ ਫਲੱਸ਼ ਕਰਨ ਲਈ ਮਜਬੂਰ ਕਰਦੇ ਹਾਂ, ਸਥਿਰਤਾ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਂਦੇ ਹੋਏ। 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 ਜਰਨਲਿੰਗ ਦੀ ਭੂਮਿਕਾ ਹੈ। ਜਰਨਲਿੰਗ ਫਾਈਲਸਿਸਟਮ ਮੁੱਖ ਸਟੋਰੇਜ ਲਈ ਵਚਨਬੱਧ ਹੋਣ ਤੋਂ ਪਹਿਲਾਂ ਤਬਦੀਲੀਆਂ ਦੇ ਲੌਗ (ਜਾਂ ਜਰਨਲ) ਨੂੰ ਕਾਇਮ ਰੱਖ ਕੇ ਅਚਾਨਕ ਘਟਨਾਵਾਂ ਜਿਵੇਂ ਕਿ ਪਾਵਰ ਫੇਲ੍ਹ ਹੋਣ ਦੌਰਾਨ ਭ੍ਰਿਸ਼ਟਾਚਾਰ ਨੂੰ ਰੋਕਣ ਵਿੱਚ ਮਦਦ ਕਰਦੇ ਹਨ। ਜਰਨਲ ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕਰਦਾ ਹੈ ਕਿ ਤੁਹਾਡੇ ਡੇਟਾ ਨੂੰ ਇਕਸਾਰ ਰੱਖਦੇ ਹੋਏ, ਅਧੂਰੇ ਕਾਰਜਾਂ ਨੂੰ ਵਾਪਸ ਲਿਆ ਗਿਆ ਹੈ। ਹਾਲਾਂਕਿ, ਜਰਨਲਿੰਗ ਕਾਲਿੰਗ ਵਰਗੀਆਂ ਵਾਧੂ ਸਾਵਧਾਨੀਆਂ ਤੋਂ ਬਿਨਾਂ ਆਰਡਰ ਕੀਤੇ ਲਿਖਤਾਂ ਦੀ ਗਾਰੰਟੀ ਨਹੀਂ ਦਿੰਦੀ . ਸਾਡੀ ਉਦਾਹਰਨ ਵਿੱਚ, ਜਰਨਲਿੰਗ ਦੌਰਾਨ ਇਹ ਯਕੀਨੀ ਹੋ ਸਕਦਾ ਹੈ ਕਿ ਫਾਈਲ ਖਰਾਬ ਨਾ ਹੋਵੇ, ਦੇ ਕੁਝ ਹਿੱਸੇ ਅੱਗੇ ਵੀ ਜਾਰੀ ਰਹਿ ਸਕਦਾ ਹੈ ਡੇਟਾ1.

ਇਕ ਹੋਰ ਵਿਚਾਰ ਇਹ ਹੈ ਕਿ ਲੀਨਕਸ ਬਫਰ ਫਾਈਲ ਕਿਵੇਂ ਲਿਖਦਾ ਹੈ. ਜਦੋਂ ਤੁਸੀਂ ਵਰਤਦੇ ਹੋ ਜਾਂ , ਡੇਟਾ ਨੂੰ ਅਕਸਰ ਇੱਕ ਮੈਮੋਰੀ ਬਫਰ ਵਿੱਚ ਲਿਖਿਆ ਜਾਂਦਾ ਹੈ, ਨਾ ਕਿ ਸਿੱਧਾ ਡਿਸਕ ਉੱਤੇ। ਇਹ ਬਫਰਿੰਗ ਕਾਰਗੁਜ਼ਾਰੀ ਵਿੱਚ ਸੁਧਾਰ ਕਰਦੀ ਹੈ ਪਰ ਇੱਕ ਜੋਖਮ ਪੈਦਾ ਕਰਦੀ ਹੈ ਜਿੱਥੇ ਡੇਟਾ ਦਾ ਨੁਕਸਾਨ ਹੋ ਸਕਦਾ ਹੈ ਜੇਕਰ ਸਿਸਟਮ ਬਫਰ ਫਲੱਸ਼ ਹੋਣ ਤੋਂ ਪਹਿਲਾਂ ਕਰੈਸ਼ ਹੋ ਜਾਂਦਾ ਹੈ। ਕਾਲ ਕਰ ਰਿਹਾ ਹੈ ਜਾਂ ਨਾਲ ਫਾਈਲ ਖੋਲ੍ਹਣਾ O_SYNC ਫਲੈਗ ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ ਬਫਰ ਕੀਤੇ ਡੇਟਾ ਨੂੰ ਸੁਰੱਖਿਅਤ ਢੰਗ ਨਾਲ ਡਿਸਕ 'ਤੇ ਫਲੱਸ਼ ਕੀਤਾ ਗਿਆ ਹੈ, ਅਸੰਗਤਤਾਵਾਂ ਨੂੰ ਰੋਕਦਾ ਹੈ। ਇਹਨਾਂ ਉਪਾਵਾਂ ਤੋਂ ਬਿਨਾਂ, ਡੇਟਾ ਅੰਸ਼ਕ ਤੌਰ 'ਤੇ ਲਿਖਿਆ ਦਿਖਾਈ ਦੇ ਸਕਦਾ ਹੈ, ਖਾਸ ਕਰਕੇ ਪਾਵਰ ਫੇਲ੍ਹ ਹੋਣ ਦੇ ਮਾਮਲਿਆਂ ਵਿੱਚ। ⚡

ਵੱਡੀਆਂ ਫਾਈਲਾਂ ਜਾਂ ਨਾਜ਼ੁਕ ਪ੍ਰਣਾਲੀਆਂ ਨਾਲ ਕੰਮ ਕਰਨ ਵਾਲੇ ਡਿਵੈਲਪਰਾਂ ਲਈ, ਟਿਕਾਊਤਾ ਨੂੰ ਧਿਆਨ ਵਿੱਚ ਰੱਖਦੇ ਹੋਏ ਪ੍ਰੋਗਰਾਮਾਂ ਨੂੰ ਡਿਜ਼ਾਈਨ ਕਰਨਾ ਜ਼ਰੂਰੀ ਹੈ। ਉਦਾਹਰਨ ਲਈ, ਇੱਕ ਏਅਰਲਾਈਨ ਰਿਜ਼ਰਵੇਸ਼ਨ ਸਿਸਟਮ ਦੀ ਕਲਪਨਾ ਕਰੋ ਜੋ ਸੀਟ ਉਪਲਬਧਤਾ ਡੇਟਾ ਲਿਖ ਰਿਹਾ ਹੈ। ਜੇਕਰ ਫਲਾਈਟ ਦੇ ਵੇਰਵਿਆਂ ਨੂੰ ਦਰਸਾਉਣ ਵਾਲਾ ਪਹਿਲਾ ਬਲਾਕ ਪੂਰੀ ਤਰ੍ਹਾਂ ਨਹੀਂ ਲਿਖਿਆ ਗਿਆ ਹੈ ਅਤੇ ਦੂਜਾ ਬਲਾਕ ਬਰਕਰਾਰ ਰਹਿੰਦਾ ਹੈ, ਤਾਂ ਇਸ ਨਾਲ ਡਾਟਾ ਭ੍ਰਿਸ਼ਟਾਚਾਰ ਜਾਂ ਡਬਲ ਬੁਕਿੰਗ ਹੋ ਸਕਦੀ ਹੈ। ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਜਾਂ ਨਾਜ਼ੁਕ ਪੜਾਵਾਂ 'ਤੇ ਇਨ੍ਹਾਂ ਨੁਕਸਾਨਾਂ ਤੋਂ ਬਚਦਾ ਹੈ। ਭਰੋਸੇਯੋਗਤਾ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਹਮੇਸ਼ਾ ਅਸਲ ਅਸਫਲਤਾ ਸਿਮੂਲੇਸ਼ਨ ਦੇ ਅਧੀਨ ਵਿਵਹਾਰ ਦੀ ਜਾਂਚ ਕਰੋ। 😊

1. ਕੀ ਕਰਦਾ ਹੈ ਕਰੋ, ਅਤੇ ਮੈਨੂੰ ਇਸਨੂੰ ਕਦੋਂ ਵਰਤਣਾ ਚਾਹੀਦਾ ਹੈ?
2. ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ ਇੱਕ ਫਾਈਲ ਲਈ ਸਾਰਾ ਡਾਟਾ ਅਤੇ ਮੈਟਾਡੇਟਾ ਮੈਮੋਰੀ ਬਫਰਾਂ ਤੋਂ ਡਿਸਕ ਤੱਕ ਫਲੱਸ਼ ਕੀਤਾ ਗਿਆ ਹੈ। ਟਿਕਾਊਤਾ ਦੀ ਗਾਰੰਟੀ ਦੇਣ ਲਈ ਨਾਜ਼ੁਕ ਲਿਖਤਾਂ ਤੋਂ ਬਾਅਦ ਇਸਦੀ ਵਰਤੋਂ ਕਰੋ।
3. ਵਿਚਕਾਰ ਕੀ ਫਰਕ ਹੈ ਅਤੇ ?
4. ਫਾਈਲ ਸਾਈਜ਼ ਅੱਪਡੇਟ ਵਰਗੇ ਮੈਟਾਡੇਟਾ ਨੂੰ ਛੱਡ ਕੇ, ਸਿਰਫ਼ ਫਾਈਲ ਡੇਟਾ ਨੂੰ ਫਲੱਸ਼ ਕਰਦਾ ਹੈ। ਡਾਟਾ ਅਤੇ ਮੈਟਾਡੇਟਾ ਦੋਵਾਂ ਨੂੰ ਫਲੱਸ਼ ਕਰਦਾ ਹੈ।
5. ਕੀ ext4 ਗਾਰੰਟੀ ਵਿੱਚ ਜਰਨਲਿੰਗ ਆਰਡਰਡ ਰਾਈਟ ਕਰਦੀ ਹੈ?
6. ਨਹੀਂ, ext4 ਜਰਨਲਿੰਗ ਇਕਸਾਰਤਾ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਂਦੀ ਹੈ ਪਰ ਇਸ ਗੱਲ ਦੀ ਗਰੰਟੀ ਨਹੀਂ ਦਿੰਦੀ ਕਿ ਲਿਖਤਾਂ ਸਪੱਸ਼ਟ ਤੌਰ 'ਤੇ ਵਰਤੋਂ ਕੀਤੇ ਬਿਨਾਂ ਕ੍ਰਮ ਵਿੱਚ ਹੋਣ। ਜਾਂ .
7. ਕਿਵੇਂ ਕਰਦਾ ਹੈ ਕੀ ਨਿਯਮਤ ਫਾਈਲਾਂ ਤੋਂ ਵੱਖਰਾ ਹੈ?
8. ਨਾਲ , ਹਰ ਲਿਖਤ ਤੁਰੰਤ ਡਿਸਕ 'ਤੇ ਫਲੱਸ਼ ਹੋ ਜਾਂਦੀ ਹੈ, ਟਿਕਾਊਤਾ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਪਰ ਕਾਰਗੁਜ਼ਾਰੀ ਦੀ ਕੀਮਤ 'ਤੇ।
9. ਕੀ ਮੈਂ ਆਪਣੇ ਸਿਸਟਮ ਤੇ ਫਾਈਲ ਲਿਖਣ ਦੀ ਟਿਕਾਊਤਾ ਦੀ ਜਾਂਚ ਕਰ ਸਕਦਾ ਹਾਂ?
10. ਹਾਂ, ਤੁਸੀਂ ਵਰਚੁਅਲ ਮਸ਼ੀਨਾਂ ਜਾਂ ਸਾਧਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਪਾਵਰ ਅਸਫਲਤਾਵਾਂ ਦੀ ਨਕਲ ਕਰ ਸਕਦੇ ਹੋ ਦੇਖਣ ਲਈ ਕਿ ਫਾਈਲ ਕਿਵੇਂ ਵਿਵਹਾਰ ਕਰਦੀ ਹੈ।

ਪਾਵਰ ਫੇਲ੍ਹ ਹੋਣ ਦੌਰਾਨ ਫਾਈਲ ਟਿਕਾਊਤਾ ਦੀ ਗਰੰਟੀ ਦੇਣ ਲਈ ਜਾਣਬੁੱਝ ਕੇ ਡਿਜ਼ਾਈਨ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। ਵਰਗੇ ਸਾਧਨਾਂ ਤੋਂ ਬਿਨਾਂ ਜਾਂ , ਲੀਨਕਸ ਫਾਈਲ ਸਿਸਟਮ ਫਾਈਲਾਂ ਨੂੰ ਅਸੰਗਤ ਸਥਿਤੀਆਂ ਵਿੱਚ ਛੱਡ ਸਕਦੇ ਹਨ। ਨਾਜ਼ੁਕ ਐਪਲੀਕੇਸ਼ਨਾਂ ਲਈ, ਮੁੱਖ ਪੜਾਵਾਂ 'ਤੇ ਲਿਖਤਾਂ ਦੀ ਜਾਂਚ ਅਤੇ ਫਲਸ਼ਿੰਗ ਜ਼ਰੂਰੀ ਅਭਿਆਸ ਹਨ।

ਕਰੈਸ਼ ਦੌਰਾਨ ਲੌਗ ਫਾਈਲ ਦੇ ਭਾਗਾਂ ਨੂੰ ਗੁਆਉਣ ਦੀ ਕਲਪਨਾ ਕਰੋ। ਇਹ ਯਕੀਨੀ ਬਣਾਉਣਾ ਕਿ ਡੇਟਾ2 ਭ੍ਰਿਸ਼ਟਾਚਾਰ ਨੂੰ ਰੋਕਣ ਤੋਂ ਪਹਿਲਾਂ ਡੇਟਾ1 ਨੂੰ ਪੂਰੀ ਤਰ੍ਹਾਂ ਸਟੋਰ ਕੀਤਾ ਗਿਆ ਹੈ। ਸਭ ਤੋਂ ਵਧੀਆ ਅਭਿਆਸਾਂ ਦਾ ਪਾਲਣ ਕਰਨਾ ਮਜ਼ਬੂਤ ​​​​ਡਾਟਾ ਅਖੰਡਤਾ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ, ਇੱਥੋਂ ਤੱਕ ਕਿ ਅਣਪਛਾਤੀ ਅਸਫਲਤਾਵਾਂ ਵਿੱਚ ਵੀ। ⚡