ফাইল — file descriptor, open/read/write আর access method

১ · ফাইল কী — নাম দেওয়া তথ্যের একটি বাক্স

আপনার ফোনে একটি ছবি তুললেন। গ্যালারিতে দেখাচ্ছে IMG_2041.jpg, আকার ৩ MB. কিন্তু ফোনের flash মেমরিতে “IMG_2041.jpg” নামে কোনো এক টুকরো জায়গা নেই। আছে হাজার হাজার ছোট ব্লক (সাধারণত ৪ KiB করে), যার কিছু হয়তো পাশাপাশি, কিছু ছড়ানো। কোন ব্লকগুলো মিলে এই ছবি, কোন ক্রমে — সেই হিসাব রাখে অপারেটিং সিস্টেম। আপনাকে দেখায় শুধু একটি নাম আর একটি টানা বাইটের সারি।

এটিই ফাইল-এর সংজ্ঞা: সেকেন্ডারি স্টোরেজে (ডিস্ক, SSD, পেনড্রাইভ) রাখা, একটি নাম দেওয়া, সম্পর্কিত তথ্যের সংগ্রহ। ব্যবহারকারীর দিক থেকে এটি স্টোরেজের সবচেয়ে ছোট একক — ডিস্কে কিছু রাখতে হলে কোনো না কোনো ফাইলের ভেতরেই রাখতে হয়। আর পর্ব ১-এ যে কথা বলেছিলাম, OS-এর বড় কাজ হলো বিমূর্ত রূপ (abstraction) দেওয়া: process যেমন CPU-র বিমূর্ত রূপ, virtual memory যেমন RAM-এর, ফাইল তেমনি ডিস্কের।

দুটি দৃষ্টিভঙ্গি — logical আর physical

এই দুইয়ের মাঝখানে অনুবাদ করে file system — ext4, NTFS, APFS, FAT32. এই পর্বে আমরা অনুবাদের ওপরের দিকটা দেখব: প্রোগ্রাম কোন system call দিয়ে ফাইলের সাথে কথা বলে, kernel খোলা ফাইলের কী হিসাব রাখে, আর কীভাবে ফাইলের ভেতরে ঘোরাফেরা করা যায়। পর্ব ৪২-এ directory, link আর VFS, আর পর্ব ৪৩-এ ডিস্কে আসল বিন্যাস।

২ · ফাইলের পরিচয়পত্র — attribute, inode আর সময়ের হিসাব

ফাইলের ভেতরের ডেটা ছাড়াও OS প্রতিটি ফাইলের কিছু তথ্য রাখে — এগুলো ফাইলের attribute বা metadata. প্রায় সব OS-এর পাঠ্যবইয়ে একই তালিকা আসে:

একটি বিষয় অনেকে খেয়াল করেন না: Unix-ধারার file system-এ ফাইলের নাম inode-এর অংশ নয়। Directory আসলে “নাম → inode নম্বর” জোড়ার একটি তালিকা। তাই একই inode-এর একাধিক নাম থাকতে পারে (hard link), আর inode-এ থাকে কতগুলো নাম তাকে দেখাচ্ছে তার গণনা — link count. এই কারণেই ফাইল “মোছা”-র system call-এর নাম unlink: এটি একটি নাম সরায়, ডেটা মুছে যায় শুধু তখন, যখন link count শূন্য আর কেউ ফাইলটি খুলে রাখেনি। Link-এর পুরো গল্প পর্ব ৪২-এ।

চারটি সময় — কোনটি ঠিক কী মাপে

এই অংশটি পরীক্ষা আর বাস্তব কাজ — দুই জায়গাতেই ভুল বোঝা হয় সবচেয়ে বেশি:

আরেকটি গুরুত্বপূর্ণ পার্থক্য: atime আর mtime ব্যবহারকারী নিজেই যেকোনো মানে বসাতে পারেন (touch -d, utimensat()) — তাই ফাইলের “তারিখ” প্রমাণ হিসেবে দুর্বল। কিন্তু ctime সাধারণ ব্যবহারকারী ইচ্ছেমতো বসাতে পারেন না; atime/mtime বদলালেও ctime “এখন”-এ চলে যায়।

atime-এর খরচ — relatime আর noatime

নিয়ম মানলে প্রতিটি পড়া-র পর inode-এ একটি লেখা হতো — একটি ওয়েব সার্ভার সেকেন্ডে হাজার ফাইল পড়লে হাজারটি অপ্রয়োজনীয় ডিস্ক-লেখা। তাই Linux ২.৬.৩০ (২০০৯) থেকে ডিফল্ট mount বিকল্প relatime: atime আপডেট হয় শুধু তখন, যখন পুরোনো atime mtime বা ctime-এর চেয়ে আগের, অথবা ২৪ ঘণ্টার বেশি পুরোনো। noatime দিলে পড়ায় atime কখনো বদলায় না; strictatime দিলে প্রতিবার বদলায়। Windows-এর NTFS-এও last-access আপডেট অনেক সংস্করণে বন্ধ বা সীমিত থাকে (fsutil behavior query disablelastaccess দিয়ে দেখা যায়)। অর্থাৎ “atime বলছে ফাইলটি কেউ পড়েনি” — এটি নির্ভরযোগ্য সিদ্ধান্ত নয়।

এবার আসল Linux-এ দেখুন। স্ক্রিপ্টটি একটি ফাইল বানিয়ে পুরো stat দেখায়, তারপর ইচ্ছে করে atime আর mtime ২০২০ সালে পিছিয়ে দেয়, আর প্রতিটি কমান্ডের পর কোন সময় বদলাল তা ছাপে। শেষ অংশে তিনটি ফাইলের প্রথম চার বাইট (পরের অংশে কাজে লাগবে):

echo "hello, dhaka" > notice.txt                 # 13 bytes with the newline
stat notice.txt                                  # every attribute the kernel keeps

step() {                         # run one command, report which timestamps changed
  local before after a0 m0 c0 a1 m1 c1
  before=$(stat -c '%x|%y|%z' notice.txt); sleep 0.15
  eval "$1"
  after=$(stat -c '%x|%y|%z' notice.txt)
  IFS='|' read -r a0 m0 c0 <<< "$before"; IFS='|' read -r a1 m1 c1 <<< "$after"
  ch() { [ "$1" = "$2" ] && echo same || echo CHANGED; }
  printf '%-27s atime:%-8s mtime:%-8s ctime:%s\n' "$1" \
    "$(ch "$a0" "$a1")" "$(ch "$m0" "$m1")" "$(ch "$c0" "$c1")"
}
echo; echo "== which timestamp changes? =="
touch -d '2020-01-01 00:00' notice.txt           # atime and mtime pushed back to 2020
step 'cat notice.txt > /dev/null'                 # 1st read
step 'cat notice.txt > /dev/null'                 # 2nd read
step 'chmod 600 notice.txt'                      # metadata only
step 'echo more >> notice.txt'                    # data
step 'touch notice.txt'                          # set atime+mtime to now

echo; echo "== atime option of this mount =="
awk -v d="$PWD/" 'index(d, ($2 == "/" ? "/" : $2 "/")) == 1 && length($2) >= n \
  { n = length($2); o = $4 } END { print o }' /proc/self/mounts \
  | tr ',' '\n' | grep -E 'atime' || echo "(none listed)"

echo; echo "== first 4 bytes: the content, not the name =="
echo "just some text" > photo.jpg                # the extension lies
for f in /bin/ls photo.jpg notice.txt; do
  printf '%-11s' "$f"; head -c 4 "$f" | od -An -c
done
rm -f notice.txt photo.jpg

  File: notice.txt
  Size: 13            Blocks: 8          IO Block: 4096   regular file
Device: 253,2    Inode: 4706218     Links: 1
Access: (0644/-rw-r--r--)  Uid: (  999/ wandbox)   Gid: (  999/ wandbox)
Access: 2026-10-25 19:47:30.221482636 +0000
Modify: 2026-10-25 19:47:30.222482658 +0000
Change: 2026-10-25 19:47:30.222482658 +0000
 Birth: 2026-10-25 19:47:30.221482636 +0000

== which timestamp changes? ==
cat notice.txt > /dev/null  atime:CHANGED  mtime:same     ctime:same
cat notice.txt > /dev/null  atime:same     mtime:same     ctime:same
chmod 600 notice.txt        atime:same     mtime:same     ctime:CHANGED
echo more >> notice.txt     atime:same     mtime:CHANGED  ctime:CHANGED
touch notice.txt            atime:CHANGED  mtime:CHANGED  ctime:CHANGED

== atime option of this mount ==
relatime

== first 4 bytes: the content, not the name ==
/bin/ls     177   E   L   F
photo.jpg     j   u   s   t
notice.txt    h   e   l   l

৩ · ফাইলের ধরন — OS কীভাবে চেনে

একটি ফাইলে কী আছে — ছবি, গান, প্রোগ্রাম, না লেখা — OS কীভাবে জানে? এখানে দুটি আলাদা প্রশ্ন মিশে থাকে। প্রথমটি kernel-এর চোখে ধরন: সাধারণ ফাইল, directory, symlink, device, pipe, নাকি socket. এটি inode-এর mode-এ লেখা থাকে, আর kernel তা মেনে চলে — directory-তে write() করা যায় না, device ফাইলে read() মানে driver-কে ডাকা। দ্বিতীয়টি বিষয়বস্তুর ধরন: JPEG না PDF. Unix kernel এটি জানে না এবং জানতে চায়ও না — এটি প্রোগ্রামের মাথাব্যথা।

বিষয়বস্তু চেনার দুই পথ — extension আর magic number

উপরের স্ক্রিপ্টের শেষ অংশটি ঠিক এটিই দেখিয়েছে: photo.jpg নামের ফাইলের প্রথম বাইট j u s t — নাম যা-ই বলুক, ভেতরে লেখা। আর /bin/ls-এর শুরুতে 177 E L F (od অষ্টাধারে লেখে: 177 = 0x7f). Kernel-ও exec-এর সময় ঠিক এভাবে magic number দেখে: \177ELF হলে ELF loader, #! হলে পরের লেখা interpreter-কে ডাকে (পর্ব ১০)। এখানে extension-এর কোনো ভূমিকা নেই — Linux-এ hello.exe নামের ELF ফাইলও দিব্যি চলে।

৪ · ফাইলের কাজ — create, open, read, write, seek, truncate, delete

ফাইল একটি abstract data type-এর মতো: তার ভেতরে কী আছে তা নয়, তার ওপর কোন কাজ করা যায় সেটিই তার সংজ্ঞা। পাঠ্যবইয়ের ছয়-সাতটি মৌলিক কাজ, আর POSIX-এ তাদের system call (পর্ব ৫-এ দেখেছেন এগুলো কীভাবে kernel-এ ঢোকে আর ব্যর্থ হলে errno-তে কারণ আসে):

open() কেন আলাদা একটি কাজ

প্রতিটি read-এ নাম দিলেই তো হতো — “/home/rafi/notes.txt থেকে বাইট ১০০ পড়ো”? সমস্যা হলো, নাম থেকে ফাইল খোঁজা খরুচে: প্রতিটি directory একে একে খুলে নাম মেলাতে হয়, প্রতিটি ধাপে অনুমতি যাচাই করতে হয়। open() এই কাজ একবার করে ফলাফল kernel-এর একটি টেবিলে রেখে দেয়, আর আপনাকে দেয় একটি ছোট সংখ্যা — file descriptor. এরপর প্রতিটি read(fd, …) সরাসরি সেই টেবিলের ঘরে যায়। একই কারণে অনুমতি যাচাই হয় open-এর সময়: ফাইল খোলার পর কেউ chmod করে অনুমতি কেড়ে নিলেও, আগে খোলা fd দিয়ে সাধারণত পড়া-লেখা চলতে থাকে।

Offset — ফাইলের ভেতরে “এখন কোথায় আছি”

প্রতিটি খোলা ফাইলের সাথে kernel একটি file offset (পাঠ্যবইয়ে “current-file-position pointer”) রাখে। read(fd, buf, 100) offset থেকে ১০০ বাইট পড়ে offset ১০০ এগিয়ে দেয়; তাই পরপর read ডাকলে ফাইল আপনিই ক্রমানুসারে পড়া হয়। lseek offset-কে যেকোনো জায়গায় নেয়: SEEK_SET (শুরু থেকে), SEEK_CUR (এখান থেকে), SEEK_END (শেষ থেকে)। আর pread/pwrite নির্দিষ্ট offset-এ পড়ে-লেখে কিন্তু offset বদলায় না — একাধিক থ্রেড একই fd ব্যবহার করলে এটিই নিরাপদ।

Offset ফাইলের শেষের পরেও নেওয়া যায়। সেখানে লিখলে মাঝের অংশটি হয়ে যায় একটি hole — যা পড়লে শূন্য আসে, কিন্তু ডিস্কে কোনো ব্লক নেয় না। এমন ফাইলকে বলে sparse file. নিচের প্রোগ্রামে offset-এর চলাফেরা আর একটি ১ MiB-এর sparse file দেখুন:

#include <fcntl.h>
#include <stdio.h>
#include <sys/stat.h>
#include <unistd.h>

static long pos(int fd) { return (long)lseek(fd, 0, SEEK_CUR); }  /* current offset */

int main(void) {
    char buf[8] = {0};
    int fd = open("demo.dat", O_RDWR | O_CREAT | O_TRUNC, 0600);
    if (fd < 0) { perror("open"); return 1; }
    if (write(fd, "DHAKA-1205", 10) != 10) return 1;
    printf("after write(10)       : offset %ld\n", pos(fd));
    lseek(fd, 6, SEEK_SET);                              /* jump to byte 6 */
    if (read(fd, buf, 4) != 4) return 1;
    printf("lseek(6) + read(4)    : got \"%s\", offset %ld\n", buf, pos(fd));
    printf("read() at end of file : returns %zd\n", read(fd, buf, 4));
    printf("lseek(0, SEEK_END)    : %ld = file size\n", (long)lseek(fd, 0, SEEK_END));

    lseek(fd, 1024 * 1024, SEEK_SET);                    /* 1 MiB, far past the end */
    if (write(fd, "END", 3) != 3) return 1;              /* bytes 10..1048575: a hole */
    if (pread(fd, buf, 4, 5000) != 4) return 1;          /* read inside the hole */
    printf("4 bytes at 5000 (hole): %d %d %d %d\n", buf[0], buf[1], buf[2], buf[3]);

    struct stat st;
    fstat(fd, &st);
    printf("st_size       (ls -l) : %lld bytes\n", (long long)st.st_size);
    printf("st_blocks*512 (du)    : %lld bytes on disk\n", (long long)st.st_blocks * 512);
    close(fd);
    unlink("demo.dat");
    return 0;
}

after write(10)       : offset 10
lseek(6) + read(4)    : got "1205", offset 10
read() at end of file : returns 0
lseek(0, SEEK_END)    : 10 = file size
4 bytes at 5000 (hole): 0 0 0 0
st_size       (ls -l) : 1048579 bytes
st_blocks*512 (du)    : 8192 bytes on disk

ফাইলের আকার বনাম ডিস্ক খরচ — ls -l আর du

ls -l দেখায় st_size — logical আকার, শেষ বাইটের অবস্থান + ১। du দেখায় st_blocks × ৫১২ — আসলে কত জায়গা বরাদ্দ (Linux-এ st_blocks সবসময় ৫১২-বাইটের এককে, file system-এর ব্লক যত বড়ই হোক)। দুটি দুই দিকে আলাদা হতে পারে:

• ছোট ফাইল, বড় খরচ: ১ বাইটের ফাইলও ৪ KiB ব্লকের file system-এ সাধারণত পুরো একটি ব্লক নেয় — ls -l 1, du 4K. এটি internal fragmentation; লাখো ছোট ফাইলে (যেমন node_modules) এর যোগফল বিশাল। (কিছু file system খুব ছোট ফাইল inode-এর ভেতরেই রাখে, তখন খরচ ০-ও দেখাতে পারে।)
• বড় ফাইল, ছোট খরচ: sparse file — virtual machine-এর disk image, core dump, ডেটাবেস ফাইল। du --apparent-size আবার logical আকার দেখায়।

মোছা মানে নাম সরানো — খোলা ফাইলের রহস্য

Linux-এ একটি প্রোগ্রাম ১০ GB-এর লগ ফাইল খুলে রেখেছে, আর আপনি rm দিয়ে ফাইলটি মুছলেন। ls-এ আর নেই, কিন্তু df বলছে জায়গা খালি হয়নি! কারণ unlink শুধু নাম সরিয়েছে; inode আর ব্লক থাকে যতক্ষণ কোনো প্রসেস ফাইলটি খোলা রাখে। প্রোগ্রাম বন্ধ হলে (বা fd বন্ধ করলে) তবেই মুক্ত। এমন ফাইল খুঁজতে lsof +L1 বা ls -l /proc/PID/fd-এ “(deleted)” লেখা দেখুন। Windows ভিন্ন: ডিফল্টে খোলা ফাইল মোছা যায় না (“The action can't be completed because the file is open in …”), যদি না খোলার সময় FILE_SHARE_DELETE দেওয়া হয় — অংশ ৯-এ দেখবেন।

৫ · তিন স্তরের open-file table — fd, open file description আর inode

পর্ব ১০-এ এক অনুচ্ছেদে দেখেছিলেন fork-এর পরে fd কপি হয় কিন্তু offset ভাগ হয়। এবার পুরো কাঠামোটি সঠিকভাবে আঁকি — পরীক্ষায় এর ছবি আঁকতে বলা হয়, আর বাস্তবে অনেক অদ্ভুত বাগের ব্যাখ্যা এখানেই। Unix-ধারার kernel খোলা ফাইলের তথ্য তিনটি স্তরে রাখে:

নিচের ডায়াগ্রামে একটি প্রসেস notes.txt (inode 5501) খোলে, আবার খোলে, dup করে, তারপর fork. “X” আর “Y” হলো open-file table-এর দুটি entry; ref মানে কতগুলো fd এই entry দেখাচ্ছে:

1a = open("notes.txt", O_RDONLY)  → 32read(a, buf, 100)3b = open("notes.txt", O_RDONLY)  → 44c = dup(a)                        → 55pid = fork()6child: read(5, buf, 50)7child: exit(0)8parent: close(3)

এবার আসল Linux-এ মিলিয়ে দেখুন। প্রোগ্রামটি একই ফাইল দুবার খোলে (a, b), তারপর c = dup(a). চারটি এক-বাইট পড়ার পর offset দেখে, আর দুটি ভিন্ন ধরনের flag বসায়: c-তে FD_CLOEXEC (fd flag, প্রথম স্তরে থাকে) আর a-তে O_APPEND (status flag, মাঝের স্তরে থাকে):

#include <fcntl.h>
#include <stdio.h>
#include <sys/stat.h>
#include <unistd.h>

static char get(int fd) { char ch = '?'; if (read(fd, &ch, 1) != 1) ch = '!'; return ch; }

static void show(const char *name, int fd) {
    printf("%s: fd=%d offset=%ld FD_CLOEXEC=%d O_APPEND=%d\n", name, fd,
           (long)lseek(fd, 0, SEEK_CUR),
           (fcntl(fd, F_GETFD) & FD_CLOEXEC) != 0,     /* per-fd flag      */
           (fcntl(fd, F_GETFL) & O_APPEND) != 0);     /* per-description  */
}

int main(void) {
    int w = open("abc.txt", O_WRONLY | O_CREAT | O_TRUNC, 0600);
    if (w < 0 || write(w, "ABCDEFGHIJ", 10) != 10) { perror("setup"); return 1; }
    close(w);
    int a = open("abc.txt", O_RDONLY);    /* open #1: new description X */
    int b = open("abc.txt", O_RDONLY);    /* open #2: new description Y */
    int c = dup(a);                       /* no new description: c -> X */
    if (a < 0 || b < 0 || c < 0) { perror("open/dup"); return 1; }
    char r1 = get(a), r2 = get(b), r3 = get(c), r4 = get(a);   /* in this order */
    printf("1-byte reads: a=%c  b=%c  c=%c  a=%c\n", r1, r2, r3, r4);
    fcntl(c, F_SETFD, FD_CLOEXEC);        /* set on c only */
    fcntl(a, F_SETFL, O_APPEND);          /* set through a */
    show("a", a); show("b", b); show("c", c);
    struct stat sa, sb, sc;
    fstat(a, &sa); fstat(b, &sb); fstat(c, &sc);
    printf("same inode for a, b, c: %s\n",
           sa.st_ino == sb.st_ino && sb.st_ino == sc.st_ino ? "yes" : "no");
    unlink("abc.txt");
    return 0;
}

1-byte reads: a=A  b=A  c=B  a=C
a: fd=3 offset=3 FD_CLOEXEC=0 O_APPEND=1
b: fd=4 offset=1 FD_CLOEXEC=0 O_APPEND=0
c: fd=5 offset=3 FD_CLOEXEC=1 O_APPEND=1
same inode for a, b, c: yes

৬ · Access method — sequential, direct, indexed আর ISAM

OS ফাইলকে বাইটের সারি হিসেবে দেয়; কিন্তু অনেক প্রোগ্রাম ফাইলকে দেখে logical record-এর সারি হিসেবে — যেমন একটি ব্যাংকের প্রতিটি অ্যাকাউন্টের ১২৮ বাইটের রেকর্ড, বা একটি পরীক্ষা বোর্ডের প্রতিটি ছাত্রের ফলাফল। Access method হলো সেই রেকর্ডগুলো কোন ক্রমে, কীভাবে খুঁজে পড়া হবে তার নিয়ম। কিছু OS (IBM mainframe, পুরোনো VMS) একাধিক access method নিজেই দিত; Unix আর Windows দেয় শুধু বাইট আর lseek — বাকি সব প্রোগ্রাম বা library-র ওপর।

Sequential access — একের পর এক

রেকর্ড পড়া হয় ক্রমানুসারে: read next offset এগিয়ে দেয়, write next শেষে যোগ করে, আর পেছনে যেতে হলে সাধারণত শুরুতে ফিরতে হয় (rewind). এটি টেপের মডেল — ক্যাসেট প্লেয়ারে সাত নম্বর গানে যেতে হলে ছয়টি পার হতে হয়। আজও সবচেয়ে বেশি ব্যবহৃত: লগ ফাইল, compiler-এর সোর্স পড়া, ভিডিও চালানো, cat, grep. OS-ও এই ধরন চেনে আর আগাম পড়ে রাখে (readahead), তাই ক্রমানুসারে পড়া HDD-তেও দ্রুত।

Direct (relative) access — সরাসরি রেকর্ড n

ফাইলকে দেখা হয় নম্বর দেওয়া রেকর্ড বা ব্লকের সারি হিসেবে, আর যেকোনো ক্রমে যেকোনোটি পড়া-লেখা যায়: read n, write n. এটি ডিস্কের মডেল — মোবাইলের গানের তালিকা থেকে সরাসরি ১৭ নম্বর গান। এখানে n হলো relative block number — ফাইলের শুরু থেকে গোনা নম্বর (০ থেকে), ডিস্কের আসল ব্লক নম্বর নয়। কোন relative ব্লক ডিস্কের কোন physical ব্লক, সেই অনুবাদ file system-এর (পর্ব ৪৩); প্রোগ্রাম শুধু relative নম্বর জানে, ফলে ফাইল ডিস্কের অন্য জায়গায় সরলেও প্রোগ্রাম বদলাতে হয় না।

নির্দিষ্ট দৈর্ঘ্যের রেকর্ডে (fixed-length record) সূত্রটি সরল:

নিচের ডায়াগ্রামে R = 128 বাইট, file system-এর ব্লক 4096 বাইট, ফাইলে ১০০০টি রেকর্ড (128,000 বাইট)। রেকর্ড 37 পড়া, বদলানো আর শেষে নতুন রেকর্ড যোগের জায়গা খোঁজা:

1n = 37;  R = 128;  B = 40962off = n * R3lseek(fd, off, SEEK_SET)4read(fd, rec, R)5lseek(fd, -R, SEEK_CUR); write(fd, rec, R)6end = lseek(fd, 0, SEEK_END)

ব্লকের হিসাব — blocking factor আর unspanned রেকর্ড

রেকর্ডের দৈর্ঘ্য ব্লকের ভাজক না হলে দুটি পথ। Spanned (packed): রেকর্ডগুলো গায়ে গায়ে, কিছু রেকর্ড দুই ব্লকে ভাগ হয় — Unix-এ সাধারণ ফাইলে এটিই স্বাভাবিক, offset = n × R. Unspanned: একটি ব্লকে যত পুরো রেকর্ড ধরে, বাকি জায়গা ফাঁকা — পুরোনো রেকর্ড-ভিত্তিক সিস্টেম আর অনেক ডেটাবেসের page এভাবে চলে। প্রতি ব্লকে রেকর্ডের সংখ্যাকে বলে blocking factor: bfr = ⌊B ÷ R⌋.

উদাহরণ: B = 4096, R = 100, রেকর্ড 1000 (০ থেকে) কোথায়?

• Unspanned: bfr = ⌊4096 ÷ 100⌋ = 40, প্রতি ব্লকে 4096 − 4000 = 96 বাইট নষ্ট। ব্লক = ⌊1000 ÷ 40⌋ = 25, ব্লকের ভেতরে স্থান = 1000 mod 40 = 0. File offset = 25 × 4096 + 0 × 100 = 102400.
• Spanned: offset = 1000 × 100 = 100000; ব্লক = ⌊100000 ÷ 4096⌋ = 24, ব্লকের ভেতরে 100000 − 24 × 4096 = 100000 − 98304 = 1696.

একই রেকর্ড, দুই নিয়মে দুটি ভিন্ন offset আর ভিন্ন ব্লক — পরীক্ষায় প্রশ্নে কোন নিয়ম বলা আছে সেটিই আসল।

Indexed access — আগে সূচি, তারপর ব্লক

Direct access-এ রেকর্ড নম্বর জানা থাকতে হয়। কিন্তু প্রায়ই জানা থাকে একটি key — রোল নম্বর, অ্যাকাউন্ট নম্বর, মোবাইল নম্বর। তখন আলাদা একটি index রাখা হয়: key-এর ক্রমে সাজানো (key, ব্লক নম্বর) জোড়ার তালিকা। বইয়ের পেছনের সূচিপত্র বা অভিধানের পাশের অক্ষর-ট্যাবের মতো — আগে সূচিতে খুঁজে পাতা নম্বর, তারপর সরাসরি সেই পাতা।

• Dense index: প্রতিটি রেকর্ডের জন্য একটি entry.
• Sparse index: প্রতিটি ডেটা ব্লকের জন্য একটি entry (সেই ব্লকের প্রথম key) — ডেটা ফাইল key-এর ক্রমে সাজানো থাকতে হয়।

পূর্ণ হিসাব (পরীক্ষার পরিচিত ধরন): ১০,০০,০০০টি রেকর্ড, R = 128 বাইট, B = 4096 বাইট, ফাইল key-এর ক্রমে সাজানো। Index entry = 8 বাইট key + 8 বাইট ব্লক-pointer = 16 বাইট।

1. bfr = 4096 ÷ 128 = 32, ডেটা ব্লক = 1,000,000 ÷ 32 = 31,250.
2. প্রতি index ব্লকে entry = 4096 ÷ 16 = 256.
3. Dense index: ⌈1,000,000 ÷ 256⌉ = ⌈3906.25⌉ = 3907 ব্লক। Sparse index: ⌈31,250 ÷ 256⌉ = ⌈122.07⌉ = 123 ব্লক।
4. Index ছাড়া, সাজানো নয় ধরে linear খোঁজ: গড়ে 31,250 ÷ 2 = 15,625 ব্লক পড়া, সবচেয়ে খারাপে 31,250.
5. সাজানো ডেটা ফাইলে সরাসরি binary search: ⌈log₂ 31,250⌉ = 15 ব্লক পড়া (2¹⁵ = 32,768).
6. Sparse index-এর ১২৩টি ব্লকে binary search: ⌈log₂ 123⌉ = 7, তারপর ১টি ডেটা ব্লক — মোট 8.
7. Index-এর ওপরে আরেকটি index (multilevel): ১২৩টি entry একটি ব্লকেই ধরে (১২৩ ≤ ২৫৬)। তাই উপরের স্তর ১ ব্লক → নিচের স্তর ১ ব্লক → ডেটা ১ ব্লক = 3 পড়া। উপরের স্তরটি সাধারণত মেমরিতেই থাকে, তখন ২টি।

১৫,৬২৫ থেকে ৩ — এটিই index-এর শক্তি। এই “সূচির ওপর সূচি” ধারণাটিই আধুনিক রূপে B-tree আর B+ tree, যা প্রায় সব ডেটাবেস আর NTFS, XFS, Btrfs, APFS-এর মতো file system-এর directory বা metadata-য় ব্যবহৃত হয়।

ISAM — indexed sequential

১৯৬০-এর দশকে IBM-এর mainframe-এ জনপ্রিয় ISAM (Indexed Sequential Access Method) দুটি পদ্ধতি একসাথে দিত: key-এর ক্রমে সাজানো ডেটা, তাই পুরো ফাইল ক্রমানুসারে পড়া দ্রুত (মাসশেষে সব অ্যাকাউন্টের স্টেটমেন্ট); আবার একটি বহুস্তর index (master index → cylinder index → track index, ডিস্কের গঠন মেনে), তাই একটি key সরাসরি খোঁজাও দ্রুত। সমস্যা ছিল নতুন রেকর্ড ঢোকানো: সাজানো ক্রম রাখতে নতুন রেকর্ড যেত একটি overflow area-য়, শিকল দিয়ে জোড়া। ১৯৭০-এর দশকে IBM-এর VSAM আর তারপর B-tree এই সমস্যার সমাধান দেয় — B-tree ভরে গেলে নিজেই node ভাগ করে ভারসাম্য রাখে।

৭ · File locking — advisory, mandatory, shared আর exclusive

দুটি প্রসেস একই ফাইলের একই রেকর্ড একসাথে read-modify-write করলে একজনের বদল হারায় — পর্ব ২২-এর race condition, এবার ডিস্কে। সমাধান file lock. দুটি প্রশ্ন দিয়ে lock-কে শ্রেণিভাগ করা হয়:

Unix-এর দুই lock পরিবার — flock আর fcntl

fcntl lock-এর “যেকোনো fd বন্ধ করলেই সব lock যায়” নিয়মটি কুখ্যাত: একটি library ফাইলটি নিজে খুলে পড়ে বন্ধ করলে আপনার প্রোগ্রামের lock নিঃশব্দে হারিয়ে যায়। এর সমাধানে Linux ৩.১৫ যোগ করে OFD lock (F_OFD_SETLK): fcntl-এর মতো byte range, কিন্তু মালিক open file description — flock-এর মতো। আর Linux-এ mandatory lock একসময় mount বিকল্প mand দিয়ে চালু করা যেত, কিন্তু অনির্ভরযোগ্য আর race-প্রবণ বলে ৫.১৫ থেকে সরিয়ে দেওয়া হয়েছে — অর্থাৎ Linux-এ বাস্তবে সব lock advisory.

নিচে একটি ব্যাংক লেজার ফাইলে চারটি প্রসেস A, B, C, D fcntl lock চায়। R = shared, W = exclusive:

1A: F_SETLK  F_RDLCK bytes 0-992B: F_SETLK  F_RDLCK bytes 0-993C: F_SETLK  F_WRLCK bytes 0-994D: F_SETLK  F_WRLCK bytes 200-2995C: F_SETLKW F_WRLCK bytes 0-996A: F_UNLCK  bytes 0-997B: F_UNLCK  bytes 0-998A: F_SETLK  F_RDLCK bytes 0-99

এবার আসল চালানো। Child একটি exclusive lock নিয়ে ধরে রাখে; parent একটি pipe দিয়ে নিশ্চিত হয় যে child lock পেয়েছে (sleep-এর আন্দাজ নয় — তাই ফল প্রতিবার একই), তারপর lock চেয়ে ব্যর্থ হয়, আর তবু write() করে দেখে:

#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <string.h>
#include <sys/wait.h>
#include <unistd.h>

static int lock(int fd, short type) {            /* whole file (len 0), do not wait */
    struct flock fl = { .l_type = type, .l_whence = SEEK_SET };
    return fcntl(fd, F_SETLK, &fl);
}
static const char *res(int r) { return r == 0 ? "granted" : errno == EAGAIN ?
    "denied (EAGAIN)" : errno == EACCES ? "denied (EACCES)" : strerror(errno); }
int main(void) {
    int fd = open("ledger.dat", O_RDWR | O_CREAT | O_TRUNC, 0600), ready[2], done[2];
    char c = 'x';
    if (fd < 0 || pipe(ready) || pipe(done)) { perror("setup"); return 1; }
    fflush(stdout);                               /* nothing left in the buffer at fork */
    pid_t pid = fork();
    if (pid == 0) {                  /* child: lock, tell the parent, wait for "done" */
        if (lock(fd, F_WRLCK) || write(ready[1], &c, 1) != 1 || read(done[0], &c, 1) != 1) _exit(1);
        _exit(0);                                 /* exit releases the lock */
    }
    close(ready[1]); close(done[0]);
    if (read(ready[0], &c, 1) != 1) return 1;     /* child now holds the lock */
    struct flock q = { .l_type = F_WRLCK, .l_whence = SEEK_SET };
    fcntl(fd, F_GETLK, &q);                       /* who blocks a write lock? */
    printf("F_GETLK : %s lock, owner is child: %s\n",
           q.l_type == F_WRLCK ? "write" : "other", q.l_pid == pid ? "yes" : "no");
    printf("parent read lock : %s\n", res(lock(fd, F_RDLCK)));
    printf("parent write lock: %s\n", res(lock(fd, F_WRLCK)));
    printf("parent write()   : %zd bytes written anyway\n", write(fd, "12345", 5));
    if (write(done[1], &c, 1) != 1) return 1;     /* tell the child to exit */
    waitpid(pid, NULL, 0);
    printf("after child exit : %s\n", res(lock(fd, F_WRLCK)));
    close(fd); unlink("ledger.dat");
    return 0;
}

F_GETLK : write lock, owner is child: yes
parent read lock : denied (EAGAIN)
parent write lock: denied (EAGAIN)
parent write()   : 5 bytes written anyway
after child exit : granted

Windows — lock সত্যিই বাধ্যতামূলক

Windows-এ দুই স্তরের সুরক্ষা। প্রথমত share mode: CreateFile-এর dwShareMode-এ ফাইল খোলার সময়ই বলে দেওয়া হয় অন্যরা একসাথে পড়তে, লিখতে বা মুছতে পারবে কি না। Excel একটি ফাইল খুলে রাখলে অন্য প্রোগ্রাম লিখতে চাইলে পায় ERROR_SHARING_VIOLATION — “The process cannot access the file because it is being used by another process”. দ্বিতীয়ত LockFileEx-এর byte-range lock: অন্য handle থেকে সেই অংশে ReadFile/WriteFile ব্যর্থ হয় ERROR_LOCK_VIOLATION দিয়ে।

৮ · Buffer, fsync আর mmap — লেখা কখন সত্যিই ডিস্কে

একটি C প্রোগ্রাম ফাইলে লেখার দুটি পথ পায়। Buffered stdio: fopen, fprintf, fwrite, fread — C library ব্যবহারকারীর মেমরিতে একটি buffer রাখে (glibc-এ সাধারণত ফাইলের st_blksize, প্রায়ই ৪ KiB), আর buffer ভরলে বা fflush/fclose-এ একটি write() ডাকে। Raw system call: open, read, write — প্রতিটি call সরাসরি kernel-এ। পর্ব ৫-এ দেখেছেন printf কেন system call নয় আর buffer কীভাবে system call-এর সংখ্যা কমায়; পর্ব ১০-এ দেখেছেন fork-এর আগে fflush না করলে buffer-এর লেখা দুবার আসে। এখানে প্রশ্নটি অন্য: লেখা কখন টেকসই?

• fflush(fp): stdio buffer → kernel. এখন অন্য প্রসেস read করলে নতুন ডেটা দেখবে, আর আপনার প্রসেস ক্র্যাশ করলেও ডেটা kernel-এ টিকে থাকবে। কিন্তু বিদ্যুৎ চলে গেলে নয়।
• write() ফিরে আসা মানে ডেটা page cache-এ dirty page হয়ে আছে; kernel-এর writeback সাধারণত কয়েক সেকেন্ডের মধ্যে (Linux-এ ডিফল্ট মোটামুটি ৩০ সেকেন্ডের পুরোনো dirty ডেটা) ডিস্কে লেখে।
• fsync(fd): ফাইলের সব dirty ডেটা আর metadata (আকার, mtime, ব্লকের তালিকা) ডিস্কে লিখে, ডিস্ককে তার cache খালি করতে বলে, তারপর ফেরে। fdatasync(fd) একই, কিন্তু যে metadata ডেটা ফিরে পড়ার জন্য দরকার নয় (যেমন শুধু mtime) তা বাদ দেয় — তাই প্রায়ই দ্রুত। আকার বদলালে সেটি অবশ্য লিখতে হয়।
• নতুন ফাইল তৈরি বা rename-এর পর directory-ও একটি ফাইল — তার নামের entry টেকসই করতে directory-র fd-তেও fsync লাগে। “নতুন ফাইলে লিখুন → fsync → rename দিয়ে পুরোনোটি প্রতিস্থাপন → directory fsync” — নিরাপদে কনফিগ ফাইল বদলানোর এই প্রচলিত কৌশল আর ক্র্যাশের পর file system কীভাবে নিজেকে ঠিক রাখে — journaling — পর্ব ৪৪-এর বিষয়।

কোনটি কখন — stdio, raw syscall না mmap

Memory-mapped file-এ ফাইলটি প্রসেসের address space-এ বসে যায়; একটি pointer দিয়ে p[4736] পড়া মানেই ফাইলের বাইট 4736 পড়া — প্রথম ছোঁয়ায় page fault, kernel page cache থেকে page বসিয়ে দেয়। Offset বা lseek লাগে না; direct access এখানে অ্যারের সূচক। এর কৌশল, MAP_PRIVATE বনাম MAP_SHARED আর msync-এর একটি চালানো উদাহরণ পর্ব ৩৫-এ (Virtual memory) দেখেছেন — এখানে আর পুনরাবৃত্তি করছি না।

৯ · Windows-এর দিক — handle, CreateFile আর alternate data stream

Windows-এ fd-এর বদলে handle — একটি অস্বচ্ছ মান, যা প্রসেসের handle table-এর একটি ঘর দেখায়; সেই ঘর দেখায় kernel-এর একটি FILE_OBJECT-কে, যার ভেতরে offset (CurrentByteOffset). তিন স্তরের ছবিটি প্রায় একই। পার্থক্য হলো নকশার মেজাজে: Unix-এর open-এ কয়েকটি flag, Windows-এর CreateFile-এ সাতটি parameter — কী অধিকার চাই, অন্যদের কী করতে দেব, ফাইল না থাকলে কী হবে, আর নানা attribute.

HANDLE h = CreateFileW(L"ledger.dat",
        GENERIC_READ | GENERIC_WRITE,     /* what we want to do          */
        FILE_SHARE_READ,                  /* others may read, not write  */
        NULL, OPEN_ALWAYS,                /* open, or create if missing  */
        FILE_ATTRIBUTE_NORMAL, NULL);
if (h == INVALID_HANDLE_VALUE) { printf("error %lu\n", GetLastError()); return 1; }

LARGE_INTEGER pos = { .QuadPart = 37 * 128 };
SetFilePointerEx(h, pos, NULL, FILE_BEGIN);              /* = lseek(fd, 4736, SEEK_SET) */
DWORD got;
ReadFile(h, rec, 128, &got, NULL);                       /* = read(fd, rec, 128)        */

OVERLAPPED ov = { 0 };                                   /* lock bytes 0..99, exclusive */
LockFileEx(h, LOCKFILE_EXCLUSIVE_LOCK | LOCKFILE_FAIL_IMMEDIATELY, 0, 100, 0, &ov);
FlushFileBuffers(h);                                     /* roughly = fsync(fd)         */
CloseHandle(h);                                          /* = close(fd)                 */

PS> Set-Content -Path notes.txt -Value "visible"
PS> Set-Content -Path notes.txt -Stream secret -Value "hidden text"
PS> (Get-Item notes.txt).Length                 # Explorer shows only the main stream
9
PS> Get-Item notes.txt -Stream * | Select-Object Stream, Length

Stream  Length
------  ------
:$DATA       9
secret      13

PS> Get-Content .\setup.exe -Stream Zone.Identifier   # a file downloaded by a browser
[ZoneTransfer]
ZoneId=3

NTFS-এর একটি বিশেষত্ব alternate data stream (ADS): একটি ফাইলের ভেতরে মূল ডেটা (:$DATA) ছাড়াও নাম দেওয়া বাড়তি stream থাকতে পারে, notes.txt:secret. Explorer-এর দেখানো আকারে এগুলো গোনা হয় না। সবচেয়ে পরিচিত ব্যবহার Zone.Identifier — ব্রাউজার ডাউনলোড করা ফাইলে এটি লিখে রাখে (“Mark of the Web”), আর Windows সেটি দেখে চালানোর আগে সতর্কবার্তা দেয়। প্রতিরক্ষার দিক থেকে মনে রাখুন: ADS-এ ডেটা লুকানো যায়, তাই তদন্তে dir /r বা Get-Item -Stream * দিয়ে stream দেখা হয়; আর FAT32/exFAT-এ বা অনেক zip-এ কপি করলে stream হারিয়ে যায়।

১০ · AI-এর যুগে ফাইল-প্রোগ্রামিং

“একটা C প্রোগ্রাম লিখে দাও যা একটি ফাইলের ১০০ নম্বর রেকর্ড বদলায়” — AI কয়েক সেকেন্ডে কোড দেবে, আর সেটি আপনার ল্যাপটপে প্রথমবার ঠিকঠাকই চলবে। ফাইল-সংক্রান্ত কোডে AI-এর সাধারণ ভুলগুলো:

AI-এর লেখা ফাইল-কোড চালানোর আগে — চেকলিস্ট

• প্রতিটি open, read, write, lseek, fsync, close-এর ফেরত মান দেখা হচ্ছে, short read/write সামলানো হচ্ছে
• offset-এর হিসাব একটি ছোট পরীক্ষা-ফাইলে নিজে মিলিয়েছি (০ না ১ থেকে গোনা, spanned না unspanned)
• একাধিক প্রসেস বা থ্রেড থাকলে lock-এর ধরন বুঝেছি, আর একসাথে অনেকবার চালিয়ে যোগফল মিলিয়েছি — একবার “চলেছে” যথেষ্ট নয়
• টেকসই দরকার হলে fsync কোথায় আছে দেখেছি; man 2 fsync, man 2 fcntl, man 2 open মিলিয়েছি
• কমান্ড বা API আমার OS-এর জন্য কি না দেখেছি; অনুমতির সমস্যায় 777 নয়, মালিক আর ন্যূনতম অধিকার দেখেছি