main() फ़ंक्शन के चलने से पहले की यात्रा

• प्रोग्राम चलने से पहले, kernel execve system call के ज़रिए process को कैसे बनाता और initialize करता है — इसका तकनीकी विश्लेषण
• यह call executable file path, arguments और environment variables देता है, और kernel इन्हीं के आधार पर ELF फ़ॉर्मेट वाले executable को load करता है
• ELF फ़ाइल में code, data, symbol, dynamic linking जानकारी आदि शामिल होती है, और kernel इसे समझकर memory mapping और stack initialization करता है
• इसके बाद kernel नियंत्रण _start entry point को सौंप देता है, और language-specific runtime initialize होने के बाद ही user-defined main फ़ंक्शन call होता है
• यह प्रक्रिया operating system, compiler और runtime के सहयोगी ढांचे को दिखाती है, और system level पर प्रोग्राम execution कैसे होता है यह समझने के लिए महत्वपूर्ण है

---

प्रोग्राम execution की शुरुआत: execve call

• Linux में प्रोग्राम execution execve system call से शुरू होता है
  • execve(const char *filename, char *const argv[], char *const envp[]) के रूप में यह executable file का नाम, argument list और environment variable list पास करता है
  • kernel इससे तय करता है कि कौन-सा प्रोग्राम किस environment में चलाया जाए
• High-level languages में इस call को अक्सर standard library के process execution API में wrap किया जाता है
  • उदाहरण: Rust का std::process::Command अंदरूनी तौर पर execve call करता है
  • यह shell के PATH lookup की तरह command name को full path में बदलने की प्रक्रिया भी करता है
• Shebang(#!) वाले script के मामले में kernel निर्दिष्ट interpreter का उपयोग करके प्रोग्राम चलाता है
  • उदाहरण: #!/usr/bin/python3 → Python interpreter से execution

ELF: executable file की संरचना

• Linux की executable files ELF(Executable and Linkable Format) फ़ॉर्मेट का पालन करती हैं
  • ELF code, data, symbol, relocation जानकारी आदि रखने वाला standard executable file format है
  • दूसरे OS अपने अलग फ़ॉर्मेट इस्तेमाल करते हैं, जैसे Mach-O(macOS), PE(Windows)
• ELF header में फ़ाइल की संरचना और memory layout की जानकारी होती है
  • उदाहरण के लिए: ELF Magic, Class, Entry point address, Program headers, Section headers
  • Entry point address वह address है जहाँ से प्रोग्राम का पहला instruction चलेगा
• उदाहरण ELF header में यह RISC-V architecture के लिए ELF32 executable है, और 0x10358 address को entry point के रूप में सेट किया गया है

ELF के अंदरूनी घटक

• ELF फ़ाइल कई section से बनी होती है
  • .text: executable code
  • .data: initialized global variables
  • .bss: uninitialized global variables
  • .plt: shared library calls के लिए table
  • .symtab, .strtab: symbol और string tables
• PLT(Procedure Linkage Table) shared library function calls को support करती है
  • उदाहरण: libc की printf, malloc आदि
  • ELF का PT_INTERP section dynamic linker(interpreter) को निर्दिष्ट करता है
• kernel ELF को पढ़कर load किए जा सकने वाले sections को memory में रखता है, और ज़रूरत होने पर ASLR, NX bit जैसी security features लागू करता है

symbol table और runtime linking

• ELF की symbol table(symtab) में functions और variables के address की जानकारी होती है
  • उदाहरण: _start, main, __libc_start_main जैसी entries मौजूद होती हैं
  • एक साधारण “Hello, World!” प्रोग्राम में भी 2300 से अधिक symbols हो सकते हैं
• इनमें से अधिकांश standard library और runtime initialization code से आते हैं
  • क्योंकि musl या glibc जैसे libc implementation link किए जाते हैं
• kernel ELF के हर section को load करने के बाद नियंत्रण interpreter(dynamic linker) को दे देता है
  • interpreter relocation, address randomization(ASLR), execution permission setup(NX bit) आदि संभालता है

stack initialization प्रक्रिया

• kernel को प्रोग्राम execution से पहले stack खुद बनानी होती है
  • stack का उपयोग local variables, function call frames और argument passing के लिए होता है
• execve call में दिए गए argv, envp stack में store किए जाते हैं
  • प्रोग्राम इन्हीं के जरिए command-line arguments और environment variables तक पहुँचता है
• kernel ELF auxiliary vector(auxv) भी stack में शामिल करता है
  • इसमें page size, ELF metadata, system information आदि से जुड़े लगभग 30 entries होती हैं
  • उदाहरण: AT_PAGESZ memory page size (जैसे 4KiB) बताता है
• RISC-V emulator के उदाहरण में stack pointer(sp) को ऊँचे address से शुरू करके arguments, environment variables और auxiliary vector को उल्टे क्रम में रखा जाता है

entry point और _start फ़ंक्शन

• ELF का entry point _start फ़ंक्शन के address पर सेट होता है
  • _start user space का पहला code है जिसे kernel control सौंपता है
• ज़्यादातर languages _start में runtime initialization करने के बाद main को call करती हैं
  • उदाहरण: Rust का std::rt::lang_start, C का __libc_start_main
• Rust के उदाहरण में #![no_std], #![no_main] attributes का उपयोग करके runtime के बिना सीधे _start define किया जा सकता है
  • _start के अंदर stack से argc, argv, envp पढ़कर main pointer को call किया जाता है
• Language-specific runtime global constructors, thread-local storage, exception handling जैसी language-specific initialization tasks भी करती है

main() call होने से पहले का पूरा flow

• पूरी प्रक्रिया का सार इस प्रकार है
  1. execve call → kernel ELF फ़ाइल load करता है
  2. ELF parsing → code/data sections map होते हैं, interpreter तय होता है
  3. stack setup → arguments, environment variables, auxiliary vector store होते हैं
  4. entry point _start execute होता है
  5. runtime initialization के बाद main() call होता है
• यह पूरी श्रृंखला operating system kernel, ELF format और language runtime के सहयोगी ढांचे को दिखाती है
• वास्तविक Linux kernel में address space, process table, group management जैसी अतिरिक्त अंदरूनी logic भी होती है, लेकिन यह लेख उससे पहले के मुख्य flow को समझाता है

निष्कर्ष और सुधार

• main() से पहले की execution प्रक्रिया kernel-level initialization और runtime setup का संयुक्त परिणाम है
• एक साधारण “Hello, World!” प्रोग्राम भी जटिल ELF संरचना और runtime initialization से होकर गुजरता है
• लेख के शुरुआती संस्करण में कुछ section loading logic को kernel के हिस्से के रूप में बताया गया था, लेकिन बाद में इसे सुधारते हुए स्पष्ट किया गया कि यह वास्तव में ELF interpreter की भूमिका है
• यह विश्लेषण system programming, compiler और OS architecture की समझ के लिए उपयोगी बुनियादी सामग्री है