Visual walkthrough — File operations — open, read, write, seek, close

4.2.32 · D2 · Coding › Operating Systems › File operations — open, read, write, seek, close

Hum is exact chain ko follow karenge, har link ke liye ek picture:

Related vault stops is raaste mein: System calls and the kernel boundary, File descriptor table, File system & inodes, Buffered I/O (fopen/fread).

Step 1 — File ko numbered boxes ki row ke roop mein banao

KYA. Kisi bhi code se pehle, raw material ki picture banao. Ek file koi clever cheez nahi hai: yeh bytes ki ek seedhi line hai, aur ek byte bas ek chhota sa box hai jo 0 se 255 tak koi number rakhta hai. Hum boxes ko 0 se number karte hain. Toh ek 20-byte file mein boxes $0,1,2,\dots ,19$ hain.

YEH picture kyun. Neeche har ek call is baat se define hoti hai ki hum kis box ko point kar rahe hain. Agar pehle yeh agree nahi kiya ki boxes ke addresses $0\dots \text{size}-1$ hain, toh "offset 16" ya "seek to end" jaisi phrases ka koi matlab nahi. Sab kuch is ruler se tiki hui hain.

PICTURE. Boxes ki row dekho. Har box ke neeche likha number uska address hai (uski position). Sabse pehla byte address $0$ hai, na ki $1$ — yahi off-by-one wali jagah hai jahan aadhe file bugs rehte hain.

Step 2 — open: ek ticket lo, arrow ko 0 par lagao

KYA. Tumhara program disk ko directly touch nahi kar sakta (woh hardware kernel ka hai — dekho System calls and the kernel boundary). Toh tum poochte ho:

$\underset{\text{tumhara ticket number}}{\underbrace{\text{fd}}}=\text{open}(\underset{\text{kaun si file}}{\underbrace{\text{"data.bin"}}},\underset{\text{"main sirf padhna chahta hoon"}}{\underbrace{\text{O\_RDONLY}}})$

Term by term:

• $\text{"data.bin"}$ — naam; kernel isse file ke inode tak follow karta hai.
• $\text{O\_RDONLY}$ — access mode, ek vaada ki tum kya karoge.
• $\text{fd}$ — returned file descriptor: sabse chhota unused small integer (0,1,2 aam taur par stdin/stdout/stderr ke liye liye hote hain, toh aksar 3 milta hai). Yeh tumhare File descriptor table ko index karta hai.

Returned number kyun? Tumhare paas baad ki har call mein "is open file" ka naam lene ke liye ek chhota handle chahiye. Kernel ek side mein ek open file description box bhi banata hai jo offset store karta hai — aur woh arrow ko $0$ par lagata hai.

PICTURE. Baayein taraf ticket fd = 3 ek kernel box ki taraf point karta hai jisme offset = 0 hai, aur woh arrow byte 0 ke bilkul baayein baitha hai.

Step 3 — read: bytes copy karo, phir arrow ko daayein slide karo

KYA. Hum 8 bytes maangte hain:

$\underset{\text{actually copied bytes}}{\underbrace{\text{n}}}=\text{read}(\underset{\text{ticket}}{\underbrace{\text{fd}}},\underset{\text{RAM mein tumhara box}}{\underbrace{\text{buf}}},\underset{\text{kitne chahiye}}{\underbrace{\text{8}}})$

Kernel arrow se shuru karke bytes tumhare buf mein copy karta hai, phir crucial kaam karta hai:

${\text{offset}}_{\text{new}}={\text{offset}}_{\text{old}}+\text{n}$

Arrow n se kyun move karta hai, 8 se kyun nahi. Tumne 8 maange the par n mila. Arrow utna hi aage badhta hai jitna actually deliver hua, toh doosra read theek wahan se continue karta hai jahan pehla ruka — automatic sequential reading, koi manual counting nahi.

n < 8 kyun ho sakta hai? File mein shayad 8 bytes se kam bachi hoon, ya (pipe/socket ke liye) kam data aaya ho. Toh n sachchi baat hai; 8 sirf ek wish thi.

PICTURE. Pehle: arrow 0 par. read bytes 0–7 ko buf mein copy karta hai. Baad mein: arrow byte 8 ke bilkul baayein jump kar gaya. buf ke sirf pehle n boxes valid hain — baaki garbage hai.

Step 4 — write: same arrow, opposite direction

KYA. Writing, reading ka mirror hai — bytes tumhare buf se file mein arrow par flow karte hain:

$\underset{\text{actually stored bytes}}{\underbrace{\text{n}}}=\text{write}(\text{fd},\text{buf},\underset{\text{kitne store karne hain}}{\underbrace{\text{count}}})$

aur phir arrow daayein n se slide karta hai:

${\text{offset}}_{\text{new}}={\text{offset}}_{\text{old}}+\text{n}$

Yahan bhi n check kyun karein? Ek short write (n < count) tab ho sakti hai jab disk bhar jaaye ya koi signal interrupt kare. Toh production code loop karta hai jab tak sab kuch bahar nahi aa jaata:

ssize_t total = 0, n;
while (total < count) {
    n = write(fd, buf + total, count - total);
    if (n < 0) break;      // real error
    total += n;            // apna bookkeeping aage badhao
}

PICTURE. Arrow kisi box se shuru hota hai; write boxes ko daayein overwrite karta hai aur arrow ko utni hi door kheenchta hai. Red arrow ki position ko Step 3 se compare karo — identical motion, bytes bas doosri taraf jaati hain.

Step 5 — lseek: arrow ko ek bhi byte touch kiye bina teleport karo

KYA. Kabhi kabhi tumhe agle byte ki zaroorat nahi hoti — tumhe byte 16 chahiye, ya aakhri 4 bytes. lseek arrow ko pure arithmetic se move karta hai, kuch bhi copy nahi karta: