Linux में process memory को आसान तरीके से समझना

• Linux की process memory संरचना को वास्तविक कामकाज के स्तर पर समझाया गया है, और virtual address space तथा physical memory के बीच संबंध को चरण-दर-चरण बताया गया है
• page table, VMA, mmap, page fault, CoW जैसे मुख्य mechanisms के आधार पर यह विस्तार से बताया गया है कि process memory को कैसे own और access करती है
• /proc file system के जरिए प्रत्येक process की memory स्थिति को देखने के तरीके, और pagemap, kpageflags जैसे उन्नत diagnostic tools की भूमिका का परिचय दिया गया है
• Transparent Huge Pages (THP), userfaultfd, PAGEMAP_SCAN जैसी आधुनिक kernel features के माध्यम से performance optimization और user-space dirty tracking तकनीकों पर चर्चा की गई है
• Meltdown mitigation PTI, TLB flush, W^X policy जैसी security और performance से जुड़ी kernel design principles को भी समझाया गया है, ताकि Linux memory management की समग्र समझ मिल सके

---

process memory की बुनियादी संरचना

• जब कोई program चलता है, तो ऐसा लगता है जैसे उसके पास एक बहुत बड़ी continuous memory हो, लेकिन वास्तव में Linux kernel इसे page units में dynamically बनाता है
  • CPU page table को देखकर virtual address को physical frame में बदलता है
  • यदि mapping नहीं हो, तो page fault होता है, और kernel नया page allocate करता है या error लौटाता है
• यदि physical RAM कम पड़ जाए, तो kernel unused pages को disk पर भेजता है या file pages हटाकर जगह बनाता है
• /proc एक virtual file system है जिसे kernel memory में बनाता है, और यह process तथा kernel state को files के रूप में दिखाता है

address space और VMA

• हर process के पास एक address space object होता है, जिसके अंदर कई VMA (Virtual Memory Area) होते हैं
  • VMA एक continuous address range है, जिसमें समान permissions (R/W/X) और समान backend (anonymous memory या file) होता है
• page table वह संरचना है जिसे hardware refer करता है, और इसमें virtual pages और physical pages के बीच mapping information (PTE) stored रहती है
• address space में बदलाव तीन system calls से किया जाता है
  • mmap: नया region बनाना
  • mprotect: permissions बदलना
  • munmap: mapping हटाना
• page का basic unit 4KiB होता है, और कुछ systems 2MiB·1GiB के बड़े pages भी support करते हैं

/proc/self/maps से memory layout देखना

• cat /proc/self/maps command से process की memory map देखी जा सकती है
  • इसमें executable की code·data·bss, heap, anonymous mappings, shared libraries, stack आदि दिखते हैं
• [vdso] और [vvar] regions kernel द्वारा map किए गए तेज़ system calls के लिए code और data हैं

mmap कैसे काम करता है

• mmap वास्तविक memory allocation नहीं करता, बल्कि address space के लिए एक वादा दर्ज करता है
  • page पहली access के समय allocate होते हैं
• file mapping के समय offset page-aligned होना चाहिए, और file end से आगे access करने पर SIGBUS होता है
• MAP_SHARED सीधे file में reflect होता है, जबकि MAP_PRIVATE copy-on-write (CoW) के जरिए अलग page बनाता है
• MAP_FIXED_NOREPLACE यह सुनिश्चित करता है कि अगर दिए गए address पर पहले से mapping हो तो call fail हो जाए, जिससे सुरक्षा बढ़ती है

पहली access और page fault

• नई mapping पर पहली access के समय अगर CPU को page table entry न मिले, तो page fault होता है
  • kernel address validity, access permissions, और existence की जाँच करता है
  • anonymous mapping हो तो 0 से भरा नया page allocate होता है, file mapping हो तो page cache से पढ़ा जाता है
• minor fault तब होता है जब data पहले से RAM में हो, और major fault तब जब disk I/O की ज़रूरत हो
• stack को guard page से सुरक्षित रखा जाता है, इसलिए बहुत नीचे की ओर access करने पर SIGSEGV हो सकता है

fork() और MAP_PRIVATE का Copy-on-Write

• fork के समय parent और child एक ही physical pages share करते हैं, और दोनों को read-only mark किया जाता है
  • write होने पर ही नया page copy किया जाता है ताकि दोनों अलग बने रहें
• MAP_PRIVATE file mapping भी इसी सिद्धांत पर काम करती है
• संबंधित options
  • vfork: parent address space share करना
  • clone(CLONE_VM): thread बनाना
  • MADV_DONTFORK, MADV_WIPEONFORK: child process में mapping को exclude करना या 0 से initialize करना

permissions बदलना और TLB invalidation

• mprotect से page permissions बदलने पर kernel VMA को split करता है और page table modify करता है, फिर TLB invalidate करता है
• W^X policy के अनुसार कोई page एक ही समय पर writable और executable नहीं हो सकता
• TLB (Translation Lookaside Buffer) हाल की address translations का cache है, और invalidation होने पर थोड़ी देरी हो सकती है

/proc के जरिए विस्तार से निरीक्षण

• /proc/<pid>/maps, smaps, smaps_rollup से region-wise permissions, RSS, HugePage usage देखी जा सकती है
• /proc/<pid>/pagemap page-level state (present, swapped, PFN आदि) देता है, लेकिन PFN सामान्य users के लिए छिपा रहता है
• /proc/kpagecount, /proc/kpageflags हर PFN के लिए mapping count और page properties (anonymous, file, dirty आदि) दिखाते हैं
• mincore, SEEK_DATA/SEEK_HOLE से sparse files के data/hole regions की पहचान की जा सकती है
• PAGEMAP_SCAN और userfaultfd को जोड़कर user-space dirty tracking लागू की जा सकती है

Transparent Huge Pages (THP) और mTHP

• THP बार-बार access होने वाली memory को अपने-आप बड़े pages (जैसे 2MiB) में समेटता है, जिससे TLB efficiency बेहतर होती है
  • khugepaged thread पास-पास के pages को merge करता है
• mTHP 16KiB·64KiB आदि आकारों के variable large pages (folio) को support करता है
• /proc/self/smaps में AnonHugePages, FilePmdMapped से उपयोग की जाँच की जा सकती है
• /sys/kernel/mm/transparent_hugepage/ में system-wide settings manage की जाती हैं
• MADV_HUGEPAGE, MADV_NOHUGEPAGE से region-level control संभव है

user-space dirty tracking

• userfaultfd और PAGEMAP_SCAN का उपयोग करके सिर्फ बदले हुए pages को copy किया जा सकता है
  • kernel एक atomic operation में scan और write-protect दोनों करता है
  • snapshot, live migration जैसी स्थितियों में यह उपयोगी है

TLB flush mechanism

• x86 में TLB invalidation के दो तरीके हैं
  • INVLPG: एक single page को invalidate करना
  • page table root को reload करके full flush करना
• PCID और INVPCID process-wise TLB tag management के जरिए अनावश्यक flush कम करते हैं
• tlb_single_page_flush_ceiling वह threshold है जिसके आधार पर kernel page-wise या full flush चुनता है

Meltdown mitigation: Page Table Isolation (PTI)

• Meltdown एक ऐसी vulnerability है जिसमें speculative execution के दौरान kernel data cache के माध्यम से leak हो सकता है
• Linux PTI (Page Table Isolation) के जरिए user और kernel address spaces को अलग करता है
  • entry के समय CR3 switch करके kernel-only page table का उपयोग किया जाता है
  • PCID का उपयोग कर TLB flush को न्यूनतम रखा जाता है
• यह default रूप से enabled रहता है, और nopti से disable किया जा सकता है

kernel की सुरक्षित mapping change प्रक्रिया

• mapping बदलते समय क्रम यह होता है
  1. cache rules लागू करना
  2. page table modify करना
  3. TLB invalidate करना
• kernel internal mappings (vmap, vmalloc) में भी I/O से पहले और बाद में cache·TLB synchronization किया जाता है
• कुछ architectures में code copy करने के बाद instruction cache flush की आवश्यकता होती है

x86 का stack और call structure

• 64-bit mode में RIP, RSP, RBP registers उपयोग होते हैं, और stack नीचे की ओर बढ़ता है
• System V AMD64 ABI के अनुसार arguments RDI, RSI, RDX, RCX, R8, R9 में जाते हैं, और return value RAX में आती है
• user mode ring 3 में चलता है, kernel ring 0 में, और system calls तथा interrupts gates के जरिए switch होते हैं

error situations और diagnosis

• mmap → EINVAL: file offset alignment error
• mmap → ENOMEM: virtual space की कमी या overcommit limit
• file mapping access पर SIGBUS: EOF के पार access
• mprotect(PROT_EXEC) → EACCES: noexec mount या W^X policy
• fork() के बाद RSS बढ़ना: CoW के कारण page copies
• MAP_FIXED से existing mapping overwrite होना → MAP_FIXED_NOREPLACE recommended

practical checklist

• तुरंत memory reserve करनी हो: mmap + PROT_READ|PROT_WRITE + MAP_PRIVATE|MAP_ANONYMOUS
• code generation के समय: W^X बनाए रखें, mprotect(PROT_READ|PROT_EXEC)
• file mapping के समय: offset को page-align करें, EOF के आगे access न करें
• page faults अधिक हों: MADV_WILLNEED या pre-touch का उपयोग करें
• memory usage analysis: /proc/<pid>/smaps_rollup → /proc/<pid>/maps
• बड़े process पर fork: CoW को ध्यान में रखें, child में exec उपयोग करें
• latency-sensitive environment: THP/mTHP, mlock, और TLB behavior observe करें

---

[GN⁺]

Hacker News टिप्पणी

• ऐसे छोटे व्याख्यात्मक लेख मुझे सच में बहुत पसंद हैं
  भले ही बात पहले से पता हो, पढ़ते समय उसे एक बार फिर पक्का कर लेने में मदद मिलती है

• “mmap, without the fog” जैसी पंक्ति देखकर, न जाने क्यों यह LLM के साथ मिलकर लिखा गया लेख लगता है, और इससे बेवजह बेचैनी और चिढ़ होती है

  • लेख का लहजा वैसा लगता है जैसे Gemini से कोई आसान समझाने वाला लेख लिखवाया गया हो
    ऊपर से “without the fog” जैसी अजीब अभिव्यक्ति है, इसलिए और भी ChatGPT के साथ लिखा हुआ सा लगता है

• Instruction pipelining की बात देखकर, मन करता है कि 6502 जैसी पुरानी सरल architecture के दौर में वापस चला जाए
  तब चीज़ें जटिल mapping या proxy के बिना, लगभग “जैसी हैं वैसी” काम करती थीं
  अगर तेज interconnects मिलें, तो शायद उस तरह की सादगी का सपना फिर देखा जा सकता है

  • बेशक, यह मानता हूँ कि ऐसे ‘cheats’ ने performance बढ़ाने में योगदान दिया है
    लेकिन Meltdown, Spectre जैसी समस्याएँ देखें तो बढ़ती जटिलता की कीमत भी साफ़ दिखती है
    अब जब Moore’s law अपनी सीमा के करीब दिख रहा है, तो सोचता हूँ कि क्या यह complexity trade-off वाकई सबसे अच्छा रास्ता है
  • असल में लेख में जो समझाया गया है, वह virtual memory की अवधारणा है, और यह 6502 से लगभग 10 साल पुरानी तकनीक है
  • जटिलता बढ़ी है, यह सही है, लेकिन उतना ही बहुत कुछ हासिल भी हुआ है
    मुझे नहीं लगता कि सादगी हमेशा बेहतर होती है
  • लेकिन फिर भी, यह जानने की जिज्ञासा है कि आपको ऐसी सादगी की कमी क्यों महसूस होती है

• वेबसाइट को खतरनाक या असुरक्षित domain कहकर ब्लॉक किया गया दिख रहा है

  • क्या आप कंपनी का laptop इस्तेमाल कर रहे हैं? हो सकता है आपकी कंपनी की security team .xyz domain पर भरोसा न करती हो
  • शायद security software ने गलत काम किया है
    VirusTotal जांच परिणाम देखें तो कोई समस्या नहीं दिखती
  • यह एक साधारण false alarm लगता है
  • उत्सुकता है कि किस browser ने इसे ब्लॉक किया
  • मज़ेदार है lol

• यह कहने का क्या मतलब है कि error report सिर्फ “noise” है?