ਇੱਕ filesystem disk blocks ਦੀ ਇੱਕ ਸਮਤਲ array ਨੂੰ files ਅਤੇ directories ਦੀ ਇੱਕ ਲੜੀ ਵਿੱਚ ਬਦਲ ਦਿੰਦਾ ਹੈ, metadata ਅਤੇ ਖਾਲੀ ਥਾਂ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰਦੇ ਹੋਏ ਤਾਂ ਜੋ ਇਹ ਭਰੋਸੇਯੋਗ ਅਤੇ ਤੇਜ਼ ਹੋਵੇ।
UNIX filesystems ਵਿੱਚ, ਹਰ file ਇੱਕ (index node) ਹੈ — ਇੱਕ ਬਣਤਰ ਜੋ file ਦਾ (ਆਕਾਰ, ਮਾਲਕ, permissions, timestamps, link count) ਅਤੇ ਰੱਖਦੀ ਹੈ। ਧਿਆਨ ਦਿਓ ਕਿ ਇੱਕ inode ਕੀ ਰੱਖਦਾ: । ਨਾਮ ਵਿੱਚ ਰਹਿੰਦੇ ਹਨ, ਜੋ ਸਿਰਫ਼ ਨਾਮ → inode number ਮੈਪ ਕਰਨ ਵਾਲੀਆਂ files ਹੁੰਦੀਆਂ ਹਨ:
directory "docs" inode 1042 data blocks
┌───────────────────┐ ┌──────────────┐ ┌────────┐
│ "report.txt" →1042│───────────▶│ mode, uid │──ptr───▶│ block │
│ "notes.txt" →1050│ │ size, times │──ptr───▶│ block │
└───────────────────┘ │ link count=2 │ └────────┘
│ block ptrs │──(indirect)──▶ ...
└──────────────┘
ਇਸੇ ਲਈ ਇੱਕ hard link ਬੱਸ ਇੱਕ ਦੂਜੀ directory entry ਹੈ ਜੋ ਇੱਕੋ inode ਵੱਲ ਇਸ਼ਾਰਾ ਕਰਦੀ ਹੈ (link count 2), ਅਤੇ ਕਿਉਂ rm ਅਸਲ ਵਿੱਚ unlink ਹੈ — ਇਹ ਇੱਕ ਨਾਮ ਹਟਾਉਂਦਾ ਹੈ ਅਤੇ inode ਨੂੰ ਸਿਰਫ਼ ਉਦੋਂ ਮੁਕਤ ਕਰਦਾ ਹੈ ਜਦੋਂ link count ਸਿਫ਼ਰ 'ਤੇ ਪਹੁੰਚ ਜਾਵੇ।
ਇੱਕ ਇਕੱਲੀ ਤਾਰਕਿਕ ਕਾਰਵਾਈ (ਜਿਵੇਂ ਇੱਕ append) ਕਈ blocks ਨੂੰ ਛੂੰਹਦੀ ਹੈ — inode, free-space bitmap, ਡਾਟਾ। ਵਿਚਕਾਰ ਇੱਕ crash filesystem ਨੂੰ ਅਸੰਗਤ ਛੱਡ ਦਿੰਦਾ ਹੈ। ਇੱਕ journal ਪਹਿਲਾਂ ਇਰਾਦੇ ਵਾਲੇ ਬਦਲਾਅ ਇੱਕ log ਵਿੱਚ ਲਿਖਦਾ ਹੈ, ਫਿਰ ਉਹਨਾਂ ਨੂੰ ਲਾਗੂ ਕਰਦਾ ਹੈ; ਇੱਕ crash ਤੋਂ ਬਾਅਦ FS ਇੱਕ ਹੌਲੀ ਪੂਰੀ scan (fsck) ਦੀ ਥਾਂ journal ਨੂੰ replay (ਜਾਂ discard) ਕਰਦਾ ਹੈ। Modes ਸੁਰੱਖਿਆ ਨੂੰ ਗਤੀ ਨਾਲ ਬਦਲਦੇ ਹਨ: ਸਿਰਫ਼ metadata journal ਕਰੋ (ਤੇਜ਼, ਆਮ) ਬਨਾਮ metadata ਅਤੇ data।
Kernel file data ਨੂੰ page cache ਵਿੱਚ RAM ਅੰਦਰ cache ਕਰਦਾ ਹੈ, ਇਸ ਲਈ ਦੁਬਾਰਾ-ਪੜ੍ਹਨ ਮੈਮੋਰੀ ਨੂੰ hit ਕਰਦੇ ਹਨ ਅਤੇ ਲਿਖਾਈਆਂ buffered ਹੁੰਦੀਆਂ ਹਨ ਅਤੇ ਬਾਅਦ ਵਿੱਚ flush ਹੁੰਦੀਆਂ ਹਨ (write-back):
buffered I/O (default): app ↔ page cache ↔ disk → cached, async writeback, fast re-reads
direct I/O (O_DIRECT): app ↔ disk → bypass the cache; DBs manage their own
fsync(): force buffered data to durable storage (required for real durability)
Buffered I/O ਤੇਜ਼ ਹੈ, ਪਰ "ਲਿਖਿਆ" ਡਾਟਾ fsync ਤੱਕ durable ਨਹੀਂ ਹੁੰਦਾ; databases ਅਕਸਰ caching ਅਤੇ durability ਨੂੰ ਸਟੀਕ ਤੌਰ 'ਤੇ ਕੰਟਰੋਲ ਕਰਨ ਲਈ direct I/O ਅਤੇ ਆਪਣਾ buffer pool ਵਰਤਦੇ ਹਨ।
Filesystem ਦੀ ਅੰਦਰੂਨੀ ਬਣਤਰ ਰੋਜ਼ਾਨਾ ਵਿਵਹਾਰ ਸਮਝਾਉਂਦੀ ਹੈ: hard links ਕਿਉਂ ਕੰਮ ਕਰਦੇ ਹਨ, ਇੱਕ ਅਜਿਹੀ file ਮਿਟਾਉਣਾ ਜੋ ਕੋਈ process ਅਜੇ ਵੀ ਖੁੱਲ੍ਹੀ ਰੱਖੀ ਬੈਠਾ ਹੈ, ਥਾਂ ਬੰਦ ਹੋਣ ਤੱਕ ਕਿਉਂ ਮੁਕਤ ਨਹੀਂ ਕਰਦਾ, fsync durability ਲਈ ਕਿਉਂ ਜ਼ਰੂਰੀ ਹੈ (ਅਤੇ ਛੱਡ ਦੇਣ 'ਤੇ ਇੱਕ ਕਲਾਸਿਕ data-loss bug), ਅਤੇ ਕਿਸੇ file ਦਾ ਦੂਜਾ ਪੜ੍ਹਨਾ ਤੁਰੰਤ ਕਿਉਂ ਹੁੰਦਾ ਹੈ (page cache)। Senior ਇੰਜੀਨੀਅਰ ਇੱਕ database ਲਈ buffered ਬਨਾਮ direct I/O ਚੁਣਨ, cache ਲਈ RAM ਦਾ ਆਕਾਰ ਤੈਅ ਕਰਨ, ਜਾਂ crash-consistency ਸਮੱਸਿਆ debug ਕਰਨ ਵੇਲੇ ਇਹਨਾਂ ਬਾਰੇ ਸੋਚਦੇ ਹਨ।
ਵਿਸਤ੍ਰਿਤ ਜਵਾਬਾਂ ਨਾਲ IT ਇੰਟਰਵਿਊ ਸਵਾਲਾਂ ਦੀ ਇੱਕ ਲਾਇਬ੍ਰੇਰੀ — ਜੂਨੀਅਰ ਤੋਂ ਸੀਨੀਅਰ ਤੱਕ।
ਦਾਨ ਕਰੋ