apple-oss-distributions/xnuHybridkernel, der Mach, FreeBSD und IOKit für macOS und iOS kombiniert. Bietet Kern-OS-Dienste, Treiberframework und Durchsetzung von Sicherheitsrichtlinien auf x86_64 und ARM64.
Der XNU-Kernel ist Teil des Darwin-Betriebssystems für die Verwendung in macOS- und iOS-Betriebssystemen. XNU ist ein Akronym für X is Not Unix. XNU ist ein Hybridkernel, der den an der Carnegie Mellon University entwickelten Mach-Kernel mit Komponenten von FreeBSD und einer C++-API zum Schreiben von Treibern namens IOKit kombiniert. XNU läuft auf x86_64 und ARM64 sowohl für Einzelprozessor- als auch für Mehrprozessorkonfigurationen.
config - Konfigurationen für exportierte APIs für unterstützte Architekturen und PlattformenSETUP - Grundlegende Werkzeuge zur Konfiguration des Kernels, Versionierung und Kextsymbol-Verwaltung.EXTERNAL_HEADERS - Header aus anderen Projekten, um Abhängigkeitszyklen beim Bauen zu vermeiden. Diese Header sollten regelmäßig synchronisiert werden, wenn die Quelle aktualisiert wird.libkern - C++-IOKit-Bibliothekscode für die Behandlung von Treibern und Kexts.libsa - Kernel-Bootstrap-Code für den Startlibsyscall - Systemaufruf-Bibliotheksschnittstelle für Userspace-Programmelibkdd - Quelle für die Benutzerbibliothek zum Parsen von Kernel-Daten wie Kernel-Chunked-Daten.makedefs - Top-Level-Regeln und Definitionen für den Kernel-Build.osfmk - Mach-Kernel-basierte Subsystemepexpert - Plattformspezifischer Code wie Interrupt-Handling, Atomare Operationen usw.security - Mandatory Access Check Policy-Schnittstellen und zugehörige Implementierung.bsd - BSD-Subsysteme-Codetools - Eine Reihe von Dienstprogrammen zum Testen, Debuggen und Profilen des Kernels.DEVELOPMENT-KernelsDas XNU-Make-System kann Kernel basierend auf den Variablen KERNEL_CONFIGS und ARCH_CONFIGS als Argumente bauen.
Hier ist die Syntax:```text
make SDKROOT= ARCH_CONFIGS= KERNEL_CONFIGS=
Wo:
* `<sdkroot>`: Pfad zum macOS SDK auf der Festplatte. (Standardwert ist `/`)
* `<variant>`: kann `debug`, `development`, `release`, `profile` sein und konfiguriert Compiler-Flags und Asserts im gesamten Kernel-Code.
* `<arch>`: kann eine gültige Architektur sein, für die gebaut wird. (Z.B. `X86_64`)
Um einen Kernel für die gleiche Architektur wie das laufende Betriebssystem zu bauen, tippen Sie einfach:```text
make SDKROOT=macosx.internal
Zusätzlich gibt es Unterstützung für die Konfiguration von Architekturen über ARCH_CONFIGS und Kernel-Konfigurationen mit 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"
> Hinweis: Standardmäßig ist die Architektur auf die Architektur des Build-Rechners eingestellt, und die Standard-Kernel-Konfiguration ist so eingestellt, dass sie für `DEVELOPMENT` erstellt wird.
Dadurch wird auch ein bootfähiges Image, kernel.[config] und ein Kernel-Binärprogramm mit Symbolen, kernel.[config].unstripped, erstellt.
Um den Kernel in ein DSTROOT zu installieren, verwenden Sie das Ziel `install_kernels`:```text
make install_kernels DSTROOT=/tmp/xnu-dst
Für eine zufriedenstellendere Kernel-Debugging-Erfahrung mit Zugriff auf alle lokalen Variablen und Argumente, aber ohne all die zusätzlichen Überprüfungen des DEBUG-Kernels, fügen Sie etwas wie das Folgende zu Ihrem make-Befehl hinzu:```text CFLAGS_DEVELOPMENTARM64="-O0 -g -DKERNEL_STACK_MULTIPLIER=2" CXXFLAGS_DEVELOPMENTARM64="-O0 -g -DKERNEL_STACK_MULTIPLIER=2"
Denken Sie daran, `DEVELOPMENT` und `ARM64` durch den entsprechenden Build und die entsprechende Plattform zu ersetzen.
> Zusätzliche Flags: Sie können dem C-Compiler über die Befehlszeile zusätzliche Flags mit der Build-Einstellung `EXTRA_CFLAGS` übergeben. Diese Flags werden an die Basis-`CFLAGS` angehängt, und der Standardwert für die Einstellung ist eine leere Zeichenfolge.
>
> Diese Einstellung ermöglicht es Ihnen, z.B. selektiv Debug-Code zu aktivieren, der durch ein Preprocessor-Makro geschützt ist. Beispielverwendung...
>
> ```text
> make SDKROOT=macosx.internal PRODUCT_CONFIGS=j314s
> EXTRA_CFLAGS='-DKERNEL_STACK_MULTIPLIER=2'
> ```
* So bauen Sie mit RELEASE-Kernelkonfiguration
```text
make KERNEL_CONFIGS=RELEASE SDKROOT=/path/to/SDK
```
### FAT-Kernel-Binärdatei erstellen
Definieren Sie Architekturen in Ihrer Umgebung oder beim Ausführen eines make-Befehls.```text
make ARCH_CONFIGS="X86_64" exporthdrs all
Das XNU-Buildsystem kann optional farblich formatierte Build-Ausgaben ausgeben. Um dies zu aktivieren, können Sie entweder die Umgebungsvariable XNU_LOGCOLORS auf y setzen oder LOGCOLORS=y an den make-Befehl übergeben.
Die xnu-Version wird vom SDK oder KDK abgeleitet, indem die CFBundleVersion aus deren System/Library/Extensions/System.kext/Info.plist-Datei gelesen wird.
Dies kann durch Setzen der Variable RC_DARWIN_KERNEL_VERSION in der Umgebung oder in der make-Befehlszeile angepasst werden.
Weitere Einzelheiten finden Sie in doc/building/xnu_version.md.
Standardmäßig wird während der Installationsphase ein DWARF-Debug-Informations-Repository erstellt; dies ist ein "Bundle" namens kernel.development.<variant>.dSYM Um das ältere STABS-Debug-Informationsformat auszuwählen (bei dem Debug-Informationen in das Abbild kernel.development.unstripped eingebettet sind), setzen Sie die Umgebungsvariable BUILD_STABS.```sh export BUILD_STABS=1 make
## Erstellen von KernelCaches
Um den xnu-Kernel zu testen, müssen Sie einen Kernelcache erstellen, der die Kexts und den Kernel zu einem einzigen bootfähigen Image zusammenbindet.
Um einen Kernelcache zu erstellen, können Sie die folgenden Mechanismen nutzen:
* Verwendung der automatischen Kernelcache-Generierung mit `kextd`.
Der Daemon kextd überwacht ständig Änderungen im Verzeichnis `/System/Library/Extensions`.
So können Sie einen neuen Kernel einrichten:
```text
cp BUILD/obj/DEVELOPMENT/X86_64/kernel.development /System/Library/Kernels/
touch /System/Library/Extensions
ps -e | grep kextd
```
* Manuelles Aufrufen von `kextcache` zum Erstellen eines neuen Kernelcaches.
```text
kextcache -q -z -a x86_64 -l -n -c /var/tmp/kernelcache.test -K /var/tmp/kernel.test /System/Library/Extensions
```
## Booten eines KernelCaches auf einem Zielrechner
Der Entwicklungskernel und iBoot unterstützen die Konfiguration von Boot-Argumenten, sodass wir sicher in einen Testkernel booten können und bei Problemen sicher auf den zuvor verwendeten Kernelcache zurückfallen können.
Die folgenden Schritte führen zu einer solchen Einrichtung:
1. Erstellen Sie den Kernelcache mit dem Befehl kextcache als `/kernelcache.test`
2. Kopieren Sie vorhandene Boot-Konfigurationen in eine alternative Datei
```sh
cp /Library/Preferences/SystemConfiguration/com.apple.Boot.plist /next_boot.plist
```
3. Aktualisieren Sie den Kernelcache und die Boot-Argumente für Ihre Einrichtung
```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. Kopieren Sie die neue Konfiguration nach `/Library/Preferences/SystemConfiguration/`