apple-oss-distributions/xnuNoyau hybride combinant Mach, FreeBSD et IOKit pour macOS et iOS. Fournit les services de base du système d'exploitation, un framework de pilotes et l'application des politiques de sécurité sur x86_64 et ARM64.
Le noyau XNU fait partie du système d'exploitation Darwin utilisé dans les systèmes d'exploitation macOS et iOS. XNU est un acronyme pour X is Not Unix. XNU est un noyau hybride combinant le noyau Mach développé à l'Université Carnegie Mellon avec des composants de FreeBSD et une API C++ pour l'écriture de pilotes appelée IOKit. XNU fonctionne sur x86_64 et ARM64 pour les configurations à un seul processeur et multi-processeur.
config - configurations pour les API exportées pour l'architecture et la plateforme supportéesSETUP - Ensemble de base d'outils utilisés pour configurer le noyau, la gestion des versions et des symboles kext.EXTERNAL_HEADERS - En-têtes provenant d'autres projets pour éviter les cycles de dépendances lors de la construction. Ces en-têtes doivent être régulièrement synchronisés lorsque la source est mise à jour.libkern - Code de la bibliothèque C++ IOKit pour la gestion des pilotes et des kexts.libsa - Code d'amorçage du noyau pour le démarragelibsyscall - Interface de la bibliothèque d'appels système pour les programmes de l'espace utilisateurlibkdd - Source de la bibliothèque utilisateur pour l'analyse des données du noyau comme les données fragmentées du noyau.makedefs - Règles et définitions de haut niveau pour la construction du noyau.osfmk - Sous-systèmes basés sur le noyau Machpexpert - Code spécifique à la plateforme comme la gestion des interruptions, les atomiques, etc.security - Interfaces de politique de contrôle d'accès obligatoire et implémentation associée.bsd - Code des sous-systèmes BSDtools - Un ensemble d'utilitaires pour tester, déboguer et profiler le noyau.DEVELOPMENTLe système de construction xnu peut construire un noyau en se basant sur les variables KERNEL_CONFIGS et ARCH_CONFIGS comme arguments.
Voici la syntaxe :```text
make SDKROOT= ARCH_CONFIGS= KERNEL_CONFIGS=
Où :
* `<sdkroot>` : chemin vers le SDK macOS sur le disque. (par défaut `/`)
* `<variant>` : peut être `debug`, `development`, `release`, `profile` et configure les indicateurs de compilation et les assertions dans tout le code du noyau.
* `<arch>` : peut être une architecture valide pour laquelle construire. (Par ex. `X86_64`)
Pour construire un noyau pour la même architecture que le système d'exploitation en cours, tapez simplement```text
make SDKROOT=macosx.internal
De plus, il est possible de configurer les architectures via ARCH_CONFIGS et les configurations du noyau avec 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"
> Remarque : Par défaut, l'architecture est définie sur celle de la machine de compilation, et la configuration par défaut du noyau est définie pour compiler pour `DEVELOPMENT`.
Cela créera également une image amorçable, kernel.[config], et un binaire du noyau avec les symboles, kernel.[config].unstripped.
Pour installer le noyau dans un DSTROOT, utilisez la cible `install_kernels` :```text
make install_kernels DSTROOT=/tmp/xnu-dst
Pour une expérience de débogage du noyau plus satisfaisante, avec accès à toutes les variables locales et arguments, mais sans toutes les vérifications supplémentaires du noyau DEBUG, ajoutez quelque chose comme ce qui suit à votre commande make :```text CFLAGS_DEVELOPMENTARM64="-O0 -g -DKERNEL_STACK_MULTIPLIER=2" CXXFLAGS_DEVELOPMENTARM64="-O0 -g -DKERNEL_STACK_MULTIPLIER=2"
N'oubliez pas de remplacer `DEVELOPMENT` et `ARM64` par la version et la plateforme appropriées.
> Drapeaux supplémentaires : Vous pouvez passer des drapeaux supplémentaires au compilateur C en ligne de commande avec le paramètre de construction `EXTRA_CFLAGS`. Ces drapeaux sont ajoutés aux `CFLAGS` de base, et la valeur par défaut du paramètre est une chaîne vide.
>
> Ce paramètre vous permet par exemple d'activer sélectivement du code de débogage protégé par une macro de préprocesseur. Exemple d'utilisation...
>
> ```text
> make SDKROOT=macosx.internal PRODUCT_CONFIGS=j314s
> EXTRA_CFLAGS='-DKERNEL_STACK_MULTIPLIER=2'
> ```
* Pour construire avec la configuration du noyau RELEASE
```text
make KERNEL_CONFIGS=RELEASE SDKROOT=/path/to/SDK
```
### Construction du binaire du noyau FAT
Définissez les architectures dans votre environnement ou lors de l'exécution d'une commande make.```text
make ARCH_CONFIGS="X86_64" exporthdrs all
Le système de build XNU peut éventuellement afficher une sortie de build formatée en couleur. Pour activer cela, vous pouvez soit
définir la variable d'environnement XNU_LOGCOLORS à y, soit passer LOGCOLORS=y à la commande make.
La version xnu est dérivée du SDK ou KDK en lisant le CFBundleVersion
de leur fichier System/Library/Extensions/System.kext/Info.plist.
Cela peut être personnalisé en définissant la variable RC_DARWIN_KERNEL_VERSION dans
l'environnement ou sur la ligne de commande make.
Voir doc/building/xnu_version.md pour plus de détails.
Par défaut, un référentiel d'informations de débogage DWARF est créé lors de la phase d'installation ; il s'agit d'un « bundle » nommé kernel.development.<variant>.dSYM Pour sélectionner l'ancien format d'information de débogage STABS (où les informations de débogage sont intégrées dans l'image kernel.development.unstripped), définissez la variable d'environnement BUILD_STABS.```sh export BUILD_STABS=1 make
## Construction des KernelCaches
Pour tester le noyau xnu, vous devez construire un kernelcache qui lie les kexts et le noyau ensemble en une seule image amorçable.
Pour construire un kernelcache, vous pouvez utiliser les mécanismes suivants :
* Utilisation de la génération automatique de kernelcache avec `kextd`.
Le daemon kextd surveille les changements dans le répertoire `/System/Library/Extensions`.
Vous pouvez ainsi configurer un nouveau noyau comme suit :
```text
cp BUILD/obj/DEVELOPMENT/X86_64/kernel.development /System/Library/Kernels/
touch /System/Library/Extensions
ps -e | grep kextd
```
* Invocation manuelle de `kextcache` pour construire un nouveau kernelcache.
```text
kextcache -q -z -a x86_64 -l -n -c /var/tmp/kernelcache.test -K /var/tmp/kernel.test /System/Library/Extensions
```
## Amorçage d'un KernelCache sur une machine cible
Le noyau de développement et iBoot prennent en charge la configuration des arguments de démarrage afin de pouvoir démarrer en toute sécurité sur le noyau de test et, en cas de problème, revenir en toute sécurité au kernelcache précédemment utilisé.
Voici les étapes pour obtenir une telle configuration :
1. Créez le cache du noyau à l'aide de la commande kextcache sous `/kernelcache.test`
2. Copiez les configurations de démarrage existantes dans un fichier alternatif
```sh
cp /Library/Preferences/SystemConfiguration/com.apple.Boot.plist /next_boot.plist
```
3. Mettez à jour le kernelcache et les boot-args pour votre configuration