- RISC-V आर्किटेक्चर पर time-sharing operating system prototype kernel को लागू करने का अनुभव साझा किया गया है
- time-sharing kernel की अवधारणा और काम करने के तरीके को प्रैक्टिकल-केंद्रित ढंग से समझाया गया है, और C की जगह Zig का उपयोग करके reproducibility बढ़ाई गई है
- kernel और user code को एक ही binary में बांधने वाला unikernel दृष्टिकोण अपनाया गया है, और console output व timer control के लिए OpenSBI आधारित layering चुनी गई है
- thread user mode (U-mode) में चलते हैं, जबकि kernel supervisor mode (S-mode) में timer interrupt के जरिए context switch करता है, और system call के माध्यम से सीमा पार होती है
- मुख्य तकनीक यह है कि interrupt prologue/epilogue द्वारा बनाए गए stack frame को बदलकर दूसरे thread के register set और CSR को restore किया जाता है, जिससे execution flow बदल जाता है
- QEMU virtual machine और नवीनतम OpenSBI पर आधारित ऐसा learning environment दिया गया है जिसे कोई भी दोहरा सकता है, और thread·process·container जैसे virtualization spectrum को वैचारिक रूप से जोड़ते हुए यह शिक्षा और अभ्यास के लिए उपयोगी आधार सामग्री बनता है
अवलोकन
- RISC-V आर्किटेक्चर पर time-sharing operating system kernel को सीधे लागू करने की प्रक्रिया का परिचय दिया गया है
- मुख्य पाठक system software और computer architecture के शुरुआती विद्यार्थी, छात्र, और low-level working principles को समझने में रुचि रखने वाले engineers हैं
- इस प्रयोग में पारंपरिक C भाषा के बजाय Zig भाषा का उपयोग किया गया है ताकि practical reproducibility बढ़े और installation सरल रहे
- अंतिम code popovicu/zig-time-sharing-kernel repository में सार्वजनिक है, और मुख्य लेख से थोड़ा अंतर हो सकता है
- लेख के code excerpts की तुलना में repository version को single source of truth मानने की सिफारिश की गई है
- अभ्यास के समय repository की linker script·build options के आधार पर environment मिलाने की सुविधा मिलती है
Recommended reading
- यह लेख register, memory addressing, interrupt जैसी computer architecture basics की बुनियादी समझ मानकर चलता है
- पूर्व-पाठ के रूप में Bare metal on RISC-V, SBI boot process, timer interrupt examples की सिफारिश की गई है
- micro Linux distribution पर लेख kernel और user space separation की philosophy समझने में वैकल्पिक रूप से उपयोगी है
Unikernel
- application और OS kernel को एक single executable file में link करने वाली unikernel संरचना अपनाई गई है
- इससे runtime loader·linker की जटिलता से बचा जाता है, और user code को kernel के साथ memory में load करने की सरलता मिलती है
- शिक्षा और reproducibility के उद्देश्य से deployment simplicity और environment consistency का लाभ मिलता है
SBI layer
- RISC-V M/S/U mode privilege model का उपयोग करता है, और इस प्रयोग में OpenSBI को M-mode में रखकर kernel को S-mode में चलाया गया है
- console output और timer device control को SBI को सौंपकर portability हासिल की गई है
- SBI उपलब्ध न होने पर UART MMIO को fallback के रूप में इस्तेमाल किया जाता है, लेकिन अभ्यास में नवीनतम OpenSBI की सिफारिश है
Goal for the kernel
- सरलता के लिए केवल static threads का समर्थन किया गया है, और threads को ऐसे functions के रूप में बनाया गया है जो समाप्त नहीं होते
- thread U-mode में चलते हैं और S-mode kernel को system call भेजते हैं
- हर timer tick पर किसी दूसरे thread पर स्विच किया जा सके, इसके लिए single-core आधारित time-sharing scheduling लागू की गई है
Virtualization and what exactly is a thread
- time-sharing threading, programming model को बदले बिना, single-core पर कई काम साथ-साथ चलाने की एक virtualization तकनीक है
- cooperative scheduling के विपरीत, इसमें स्पष्ट yield के बिना timer interrupt द्वारा switch होता है
- हर thread का अपना अलग register set और stack होता है, जबकि बाकी memory साझा की जा सकती है
The stack and memory virtualization
- thread के पास अलग stack होना चाहिए; calling convention के अनुसार local variables, ra preservation आदि के लिए यह execution context बनाए रखने का आवश्यक तत्व है
- virtualization spectrum thread < process < container < VM के रूप में आगे बढ़ता है, जहां isolation level और view अलग-अलग होते हैं
- Linux में container, chroot, cgroups जैसे kernel mechanisms के संयोजन से लागू किए जाते हैं
Virtualizing a thread
- इस प्रयोग का न्यूनतम virtualization लक्ष्य है: programming model अपरिवर्तित, registers·कुछ CSR की सुरक्षा, और अलग stack allocation
- यह रेखांकित किया गया है कि अगर register view सुरक्षित न हो तो meaningful computation संभव नहीं रहती
- शुरुआती a0 आदि को stack पर seed करके thread start के समय argument passing को सरल बनाया गया है
Interrupt context
- interrupt को prologue/epilogue के जरिए register को stack पर save/restore करने वाले function-call जैसे मॉडल के रूप में समझा जा सकता है
- asynchronous timer interrupt register को खराब न करे, इसके लिए preservation convention का पालन अनिवार्य है
- उदाहरण assembly में x0–x31 को सुरक्षित रखने के साथ sstatus, sepc, scause, stval जैसे CSR भी save/restore किए जाते हैं
Implementation (high-level)
Leveraging the interrupt stack convention
- interrupt routine का body prologue और epilogue के बीच स्थित होता है, और यदि sp को किसी दूसरे memory area से बदल दिया जाए तो दूसरे context के registers restore होने लगते हैं
- यही वास्तव में context switch है, और यही इस प्रयोग के time-sharing implementation का मुख्य विचार है
- timer interrupt समय-समय पर हस्तक्षेप करके main flow और interrupt flow को बारी-बारी से चलाता है
Kernel/user space separation
- S-mode kernel / U-mode user की सीमा बनाए रखी जाती है, और interrupt व system call handling S-mode trap handler में होती है
- boot क्रम M-mode के OpenSBI → S-mode kernel initialization → U-mode thread start के रूप में चलता है
- periodic timer interrupt scheduling·context switching को संभव बनाता है
Implementation (code)
Assembly startup
startup.S में BSS initialization और प्रारंभिक stack pointer setup के बाद Zig के main पर jump करने वाली न्यूनतम sequence बनाई गई है
- kernel entry point, C ABI के साथ linkage के लिए
export convention का उपयोग करता है
Main kernel file and I/O drivers
kernel.zig का main पहले OpenSBI console feature की जांच करता है, और विफल होने पर UART MMIO पर fallback करता है
sbi.debug_print ECALL protocol के अनुसार a0/a1/a6/a7 registers सेट करके call करता है- timer सेट करने के बाद S-mode interrupt handler register किया जाता है और tick सक्रिय किए जाते हैं
S-mode handler and the context switch
- handler को Zig के
naked convention में लिखा गया है ताकि CSR preservation सहित पूर्ण prologue/epilogue को manually बनाया जा सके
- body में
handle_kernel(sp) को call किया जाता है, और वापस मिले sp से बदलकर switch होगा या नहीं यह तय किया जाता है
scause से यह पहचाना जाता है कि मामला U-mode ECALL का है या timer interrupt का, और उसी अनुसार branch होती है
The user space threads
- user code को kernel के साथ single binary में शामिल किया गया है, और उदाहरण thread string output → delay loop को दोहराते हैं
syscall.debug_print a7 में 64 system call number और a0/a1 में buffer/length रखकर ECALL करता है- thread initialization के समय stack पर return address·initial register values seed किए जाते हैं ताकि पहली return पर ही arguments उपलब्ध हों
Running the kernel
- build के लिए
zig build, और run के लिए QEMU में virt machine + nographic + OpenSBI fw_dynamic के साथ execution किया जाता है
- boot के समय OpenSBI banner के बाद thread ID के अनुसार periodic output बारी-बारी से दिखाई देती है
-Ddebug-logs=true के साथ build करने पर interrupt source, current stack, queueing·dequeuing logs विस्तार से दिखते हैं
Conclusion
- यह प्रयोग RISC-V + OpenSBI + Zig संयोजन के साथ शैक्षणिक kernel को आधुनिक रूप देता है और reproducibility तथा readability बढ़ाता है
- इसमें न्यूनतम error handling और overprovisioned stack जैसी सरलताएँ हैं, लेकिन फोकस context switch के सार और privilege separation की समझ पर है
- वास्तविक मशीनों पर portability, linker·driver constants के समायोजन और SBI availability सुनिश्चित होने पर संभव है
अतिरिक्त नोट: virtualization spectrum का सार
- Threads: मुख्य रूप से register·stack virtualization, memory sharing की संभावना अधिक
- Process: address space virtualization के जरिए memory isolation, और भीतर कई threads हो सकते हैं
- Container: filesystem·network namespaces जैसी environment view को जोड़कर बनाई गई isolation unit
- VM: hardware के व्यापक full virtualization का लक्ष्य
मुख्य implementation points का सार
- interrupt stack replacement से context switch लागू करना
- S-mode trap handler में CSR सहित पूरा state save/restore करना
- SBI पहले, UART MMIO fallback वाला dual output path
- static threads·single core·time slice पर आधारित सरल scheduling
- ECALL-based system call के जरिए U/S boundary को स्पष्ट रखना
अभी कोई टिप्पणी नहीं है.