XNU क्या है?

XNU कर्नेल Darwin ऑपरेटिंग सिस्टम का हिस्सा है जो macOS और iOS ऑपरेटिंग सिस्टम में उपयोग होता है। XNU एक संक्षिप्त नाम है जो "X is Not Unix" के लिए है। XNU एक हाइब्रिड कर्नेल है जो Carnegie Mellon University में विकसित Mach कर्नेल को FreeBSD के घटकों और ड्राइवर लिखने के लिए C++ API जिसे IOKit कहते हैं, के साथ जोड़ता है। XNU x86_64 और ARM64 पर एकल प्रोसेसर और बहु-प्रोसेसर दोनों कॉन्फ़िगरेशन के लिए चलता है।

XNU स्रोत ट्री

config - समर्थित आर्किटेक्चर और प्लेटफ़ॉर्म के लिए निर्यातित APIs के कॉन्फ़िगरेशन
SETUP - कर्नेल कॉन्फ़िगर करने, संस्करण प्रबंधन और kextsymbol प्रबंधन के लिए उपयोग किए जाने वाले बुनियादी उपकरणों का सेट
EXTERNAL_HEADERS - बिल्ड के दौरान निर्भरता चक्र से बचने के लिए अन्य प्रोजेक्ट्स से लिए गए हेडर। ये हेडर स्रोत अपडेट होने पर नियमित रूप से सिंक किए जाने चाहिए।
libkern - ड्राइवर और kexts को संभालने के लिए C++ IOKit लाइब्रेरी कोड
libsa - स्टार्टअप के लिए कर्नेल बूटस्ट्रैप कोड
libsyscall - यूज़रस्पेस प्रोग्राम के लिए syscall लाइब्रेरी इंटरफ़ेस
libkdd - कर्नेल डेटा (जैसे कर्नेल चंक्ड डेटा) को पार्स करने के लिए यूज़र लाइब्रेरी का स्रोत
makedefs - कर्नेल बिल्ड के लिए शीर्ष स्तर के नियम और परिभाषाएँ
osfmk - Mach कर्नेल आधारित उप-प्रणालियाँ
pexpert - प्लेटफ़ॉर्म-विशिष्ट कोड जैसे इंटरप्ट हैंडलिंग, एटॉमिक्स आदि
security - Mandatory Access Check नीति इंटरफ़ेस और संबंधित कार्यान्वयन
bsd - BSD उप-प्रणालियों का कोड
tools - कर्नेल परीक्षण, डिबगिंग और प्रोफाइलिंग के लिए उपयोगिताओं का सेट

XNU कैसे बनाएं

एक `DEVELOPMENT` कर्नेल बनाना

xnu make सिस्टम KERNEL_CONFIGS & ARCH_CONFIGS चरों को तर्क के रूप में लेकर कर्नेल बना सकता है। यहाँ सिंटैक्स है:```text make SDKROOT= ARCH_CONFIGS= KERNEL_CONFIGS=

जहाँ:

* `<sdkroot>`: डिस्क पर macOS SDK का पथ। (डिफ़ॉल्ट रूप से `/`)
* `<variant>`: `debug`, `development`, `release`, `profile` हो सकता है और कर्नेल कोड में संकलन फ्लैग और अभिकथनों को कॉन्फ़िगर करता है।
* `<arch>`: निर्माण के लिए मान्य आर्किटेक्चर हो सकता है। (उदा. `X86_64`)

चल रहे OS के समान आर्किटेक्चर के लिए कर्नेल बनाने के लिए, बस टाइप करें```text
make SDKROOT=macosx.internal

इसके अतिरिक्त, ARCH_CONFIGS के माध्यम से आर्किटेक्चर और KERNEL_CONFIGS के साथ कर्नेल कॉन्फ़िगरेशन को कॉन्फ़िगर करने का समर्थन है।```text make SDKROOT=macosx.internal ARCH_CONFIGS=X86_64 KERNEL_CONFIGS=DEVELOPMENT make SDKROOT=macosx.internal ARCH_CONFIGS=X86_64 KERNEL_CONFIGS="RELEASE DEVELOPMENT DEBUG"

> नोट: डिफ़ॉल्ट रूप से, आर्किटेक्चर बिल्ड मशीन के आर्किटेक्चर पर सेट होता है, और डिफ़ॉल्ट कर्नेल कॉन्फ़िग `DEVELOPMENT` के लिए बिल्ड करने पर सेट होता है।

यह एक बूट करने योग्य इमेज, kernel.[config] और प्रतीकों के साथ एक कर्नेल बाइनरी, kernel.[config].unstripped भी बनाएगा।

कर्नेल को DSTROOT में स्थापित करने के लिए, `install_kernels` लक्ष्य का उपयोग करें:```text
make install_kernels DSTROOT=/tmp/xnu-dst

एक अधिक संतोषजनक कर्नेल डिबगिंग अनुभव के लिए, सभी स्थानीय चर और तर्कों तक पहुंच के साथ, लेकिन DEBUG कर्नेल की सभी अतिरिक्त जांचों के बिना, अपने make कमांड में कुछ इस प्रकार जोड़ें:```text CFLAGS_DEVELOPMENTARM64="-O0 -g -DKERNEL_STACK_MULTIPLIER=2" CXXFLAGS_DEVELOPMENTARM64="-O0 -g -DKERNEL_STACK_MULTIPLIER=2"

Remember to replace `DEVELOPMENT` and `ARM64` with the appropriate build and platform.

> Extra Flags: आप `EXTRA_CFLAGS` बिल्ड सेटिंग के साथ C कंपाइलर को कमांड लाइन पर अतिरिक्त फ्लैग पास कर सकते हैं। ये फ्लैग बेस `CFLAGS` में जोड़े जाते हैं, और सेटिंग का डिफ़ॉल्ट मान एक खाली स्ट्रिंग है।
>
> यह सेटिंग आपको उदाहरण के लिए प्रीप्रोसेसर मैक्रो द्वारा संरक्षित डिबगिंग कोड को चुनिंदा रूप से चालू करने की अनुमति देती है। उपयोग का उदाहरण...
>
> ```text
> make SDKROOT=macosx.internal PRODUCT_CONFIGS=j314s 
> EXTRA_CFLAGS='-DKERNEL_STACK_MULTIPLIER=2'
> ```


* RELEASE कर्नेल कॉन्फ़िगरेशन के साथ बनाने के लिए

    ```text
    make KERNEL_CONFIGS=RELEASE SDKROOT=/path/to/SDK
    ```

### FAT कर्नेल बाइनरी बनाना

अपने वातावरण में या make कमांड चलाते समय आर्किटेक्चर परिभाषित करें।```text
make ARCH_CONFIGS="X86_64" exporthdrs all

अन्य Makefile विकल्प

$ make MAKEJOBS=-j8 # यह बिल्ड के दौरान 8 प्रक्रियाओं का उपयोग करेगा। डिफ़ॉल्ट सक्रिय CPU की संख्या का 2 गुना है।
$ make -j8 # मानक कमांड-लाइन विकल्प भी स्वीकार किया जाता है
$ make -w # पुनरावर्ती make कॉल को ट्रेस करें। VERBOSE=YES के साथ संयोजन में उपयोगी।
$ make BUILD_LTO=0 # LLVM लिंक टाइम ऑप्टिमाइज़ेशन के बिना बिल्ड करें
$ make BOUND_CHECKS=0 # इस बिल्ड के लिए -fbound-attributes अक्षम करें
$ make REMOTEBUILD=user@remotehost # रिमोट होस्ट पर बिल्ड करें
$ make BUILD_CODE_COVERAGE=1 # कोड कवरेज जानकारी एकत्र करने के लिए समर्थन के साथ बिल्ड करें

XNU बिल्ड सिस्टम वैकल्पिक रूप से रंग-स्वरूपित बिल्ड आउटपुट उत्पन्न कर सकता है। इसे सक्षम करने के लिए, आप या तो XNU_LOGCOLORS एनवायरनमेंट वेरिएबल को y पर सेट कर सकते हैं, या make कमांड में LOGCOLORS=y पास कर सकते हैं।

XNU संस्करण को अनुकूलित करें

xnu संस्करण SDK या KDK से उनके System/Library/Extensions/System.kext/Info.plist फ़ाइल के CFBundleVersion को पढ़कर प्राप्त किया जाता है। इसे एनवायरनमेंट में या make कमांड लाइन पर RC_DARWIN_KERNEL_VERSION वेरिएबल सेट करके अनुकूलित किया जा सकता है।

अधिक जानकारी के लिए doc/building/xnu_version.md देखें।

डीबग सूचना प्रारूप

डिफ़ॉल्ट रूप से, इंस्टॉल चरण के दौरान एक DWARF डीबग सूचना रिपॉजिटरी बनाई जाती है; यह kernel.development.<variant>.dSYM नामक एक "बंडल" है। पुराने STABS डीबग सूचना प्रारूप का चयन करने के लिए (जहाँ डीबग जानकारी kernel.development.unstripped इमेज में एम्बेडेड होती है), BUILD_STABS एनवायरनमेंट वेरिएबल सेट करें।```sh export BUILD_STABS=1 make

## Building KernelCaches

xnu कर्नेल का परीक्षण करने के लिए, आपको एक कर्नेलकैशे बनाने की आवश्यकता है जो kexts और कर्नेल को एक ही बूट करने योग्य इमेज में जोड़ता है।
कर्नेलकैशे बनाने के लिए आप निम्नलिखित तंत्रों का उपयोग कर सकते हैं:

* `kextd` के साथ स्वचालित कर्नेलकैशे जनरेशन का उपयोग करना।
  kextd डेमॉन `/System/Library/Extensions` निर्देशिका में परिवर्तनों पर नजर रखता है।
  तो आप नए कर्नेल को इस प्रकार सेटअप कर सकते हैं

    ```text
    cp BUILD/obj/DEVELOPMENT/X86_64/kernel.development /System/Library/Kernels/
    touch /System/Library/Extensions
    ps -e | grep kextd
    ```

* नए कर्नेलकैशे बनाने के लिए `kextcache` को मैन्युअल रूप से आमंत्रित करना।

    ```text
    kextcache -q -z -a x86_64 -l -n -c /var/tmp/kernelcache.test -K /var/tmp/kernel.test /System/Library/Extensions
    ```


## Booting a KernelCache on a Target machine

डेवलपमेंट कर्नेल और iBoot बूट आर्गुमेंट्स कॉन्फ़िगर करने का समर्थन करते हैं ताकि हम सुरक्षित रूप से परीक्षण कर्नेल में बूट हो सकें और, यदि कुछ गलत हो, तो सुरक्षित रूप से पहले उपयोग किए गए कर्नेलकैशे पर वापस आ सकें।
इस तरह का सेटअप प्राप्त करने के लिए निम्नलिखित चरण हैं:

1. kextcache कमांड का उपयोग करके `/kernelcache.test` के रूप में कर्नेल कैशे बनाएं।
2. मौजूदा बूट कॉन्फ़िगरेशन को वैकल्पिक फ़ाइल में कॉपी करें

    ```sh
    cp /Library/Preferences/SystemConfiguration/com.apple.Boot.plist /next_boot.plist
    ```

3. अपने सेटअप के लिए कर्नेलकैशे और बूट-आर्ग्स अपडेट करें

    ```sh
    plutil -insert "Kernel Cache" -string "kernelcache.test" /next_boot.plist
    plutil -replace "Kernel Flags" -string "debug=0x144 -v kernelsuffix=test " /next_boot.plist
    ```

4. नए कॉन्फ़िग को `/Library/Preferences/SystemConfiguration/` पर कॉपी करें

    ```sh
    cp /next_boot.plist /Library/Preferences/SystemConfiguration/boot.plist
    ```

5. नए कॉन्फ़िग्स के साथ वॉल्यूम को आशीर्वाद दें।

    ```text
    sudo -n bless  --mount / --setBoot --nextonly --options "config=boot"
    ```

   `--nextonly` फ्लैग निर्दिष्ट करता है कि केवल एक बूट के लिए `boot.plist` कॉन्फ़िग्स का उपयोग करें।
   इसलिए यदि कर्नेल पैनिक होता है तो आप आसानी से पावर रीबूट करके मूल कर्नेल पर वापस आ सकते हैं।


## Creating tags and cscope

अपना बिल्ड एनवायरनमेंट सेट करें और शीर्ष निर्देशिका से, चलाएँ:

    make tags     # यह ctags और etags बनाएगा एक case-sensitive वॉल्यूम पर, केवल ctags case-insensitive पर
    make TAGS     # यह etags बनाएगा
    make cscope   # यह cscope डेटाबेस बनाएगा

xnu

सबसे लोकप्रिय