Cos'è XNU?

Il kernel XNU fa parte del sistema operativo Darwin utilizzato nei sistemi operativi macOS e iOS. XNU è un acronimo per X is Not Unix. XNU è un kernel ibrido che combina il kernel Mach sviluppato alla Carnegie Mellon University con componenti di FreeBSD e un'API C++ per scrivere driver chiamata IOKit. XNU funziona su x86_64 e ARM64 per configurazioni sia a singolo processore che multiprocessore.

La struttura dei sorgenti di XNU

• config - configurazioni per le API esportate per architettura e piattaforma supportate
• SETUP - Set di strumenti base usati per configurare il kernel, versioning e gestione dei kextsymbol.
• EXTERNAL_HEADERS - Header provenienti da altri progetti per evitare dipendenze cicliche durante la compilazione. Questi header dovrebbero essere sincronizzati regolarmente quando i sorgenti vengono aggiornati.
• libkern - Codice della libreria C++ IOKit per la gestione di driver e kext.
• libsa - Codice di bootstrap del kernel per l'avvio
• libsyscall - Interfaccia delle syscall per i programmi in spazio utente
• libkdd - Sorgente per la libreria utente per l'analisi di dati del kernel come i dati chunked del kernel.
• makedefs - Regole e definizioni di alto livello per la compilazione del kernel.
• osfmk - Sottosistemi basati sul kernel Mach
• pexpert - Codice specifico della piattaforma come gestione degli interrupt, atomiche, ecc.
• security - Interfacce delle policy di Mandatory Access Check e implementazioni correlate.
• bsd - Codice dei sottosistemi BSD
• tools - Un insieme di utilità per testare, eseguire il debug e profilare il kernel.

Come compilare XNU

Compilare un kernel DEVELOPMENT

Il sistema make di xnu può compilare il kernel basandosi sulle variabili KERNEL_CONFIGS e ARCH_CONFIGS come argomenti. Ecco la sintassi:```text make SDKROOT= ARCH_CONFIGS= KERNEL_CONFIGS=

Where:

* `<sdkroot>`: percorso verso l'SDK macOS su disco. (predefinito a `/`)
* `<variant>`: può essere `debug`, `development`, `release`, `profile` e configura i flag di compilazione e gli assert in tutto il codice del kernel.
* `<arch>`: può essere l'architettura valida per cui compilare. (Ad es. `X86_64`)

Per compilare un kernel per la stessa architettura del sistema operativo in esecuzione, basta digitare```text
make SDKROOT=macosx.internal

Inoltre, c'è supporto per la configurazione delle architetture tramite ARCH_CONFIGS e configurazioni del kernel con 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"

> Nota: Per impostazione predefinita, l'architettura è impostata su quella della macchina di build, e la configurazione predefinita del kernel è impostata per la build di `DEVELOPMENT`.

Questo creerà anche un'immagine avviabile, kernel.[config], e un binario del kernel con simboli, kernel.[config].unstripped.

Per installare il kernel in una DSTROOT, usa il target `install_kernels`:```text
make install_kernels DSTROOT=/tmp/xnu-dst

Per un'esperienza di debug del kernel più soddisfacente, con accesso a tutte le variabili locali e agli argomenti, ma senza tutti i controlli aggiuntivi del kernel DEBUG, aggiungi qualcosa di simile al seguente al tuo comando make:```text CFLAGS_DEVELOPMENTARM64="-O0 -g -DKERNEL_STACK_MULTIPLIER=2" CXXFLAGS_DEVELOPMENTARM64="-O0 -g -DKERNEL_STACK_MULTIPLIER=2"

Ricorda di sostituire `DEVELOPMENT` e `ARM64` con la build e la piattaforma appropriate.

> Flag Extra: Puoi passare flag aggiuntivi al compilatore C dalla riga di comando con l'impostazione di build `EXTRA_CFLAGS`. Questi flag vengono aggiunti ai `CFLAGS` di base, e il valore predefinito dell'impostazione è una stringa vuota.
>
> Questa impostazione ti permette, ad esempio, di attivare selettivamente codice di debug protetto da una macro del preprocessore. Esempio di utilizzo...
>
> ```text
> make SDKROOT=macosx.internal PRODUCT_CONFIGS=j314s 
> EXTRA_CFLAGS='-DKERNEL_STACK_MULTIPLIER=2'
> ```


* Per compilare con la configurazione del kernel RELEASE

    ```text
    make KERNEL_CONFIGS=RELEASE SDKROOT=/percorso/del/SDK
    ```

### Compilazione del Binario del Kernel FAT

Definisci le architetture nel tuo ambiente o quando esegui un comando make.```text
make ARCH_CONFIGS="X86_64" exporthdrs all

Altre Opzioni del Makefile

• $ make MAKEJOBS=-j8 # questo utilizzerà 8 processi durante la build. Il valore predefinito è 2 volte il numero di CPU attive.
• $ make -j8 # anche l'opzione standard da riga di comando è accettata
• $ make -w # traccia le invocazioni make ricorsive. Utile in combinazione con VERBOSE=YES
• $ make BUILD_LTO=0 # build senza ottimizzazione dei tempi di collegamento LLVM
• $ make BOUND_CHECKS=0 # disabilita -fbound-attributes per questa build
• $ make REMOTEBUILD=user@remotehost # esegui la build su host remoto
• $ make BUILD_CODE_COVERAGE=1 # build con supporto per la raccolta di informazioni sulla copertura del codice

Il sistema di build XNU può opzionalmente produrre output di build con formato a colori. Per abilitarlo, puoi impostare la variabile d'ambiente XNU_LOGCOLORS a y, oppure passare LOGCOLORS=y al comando make.

Personalizza la Versione XNU

La versione di XNU è derivata dall'SDK o KDK leggendo il campo CFBundleVersion del file System/Library/Extensions/System.kext/Info.plist. Questo può essere personalizzato impostando la variabile RC_DARWIN_KERNEL_VERSION nell'ambiente o sulla riga di comando di make.

Vedi doc/building/xnu_version.md per maggiori dettagli.

Formati delle Informazioni di Debug

Per impostazione predefinita, viene creato un repository di informazioni di debug DWARF durante la fase di installazione; questo è un "bundle" chiamato kernel.development.<variant>.dSYM Per selezionare il vecchio formato di informazioni di debug STABS (dove le informazioni di debug sono incorporate nell'immagine kernel.development.unstripped), imposta la variabile d'ambiente BUILD_STABS.```sh export BUILD_STABS=1 make

## Costruzione dei KernelCaches

Per testare il kernel xnu, è necessario costruire un kernelcache che colleghi i kext e il kernel in un'unica immagine avviabile.
Per costruire un kernelcache è possibile utilizzare i seguenti meccanismi:

* Usando la generazione automatica del kernelcache con `kextd`.
  Il demone kextd monitora continuamente le modifiche nella directory `/System/Library/Extensions`.
  Quindi puoi configurare un nuovo kernel come

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

* Invocando manualmente `kextcache` per costruire un nuovo kernelcache.

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


## Avvio di un KernelCache su una macchina di destinazione

Il kernel di sviluppo e iBoot supportano la configurazione degli argomenti di avvio in modo da poter avviare in sicurezza un kernel di test e, in caso di problemi, tornare in sicurezza al kernelcache utilizzato in precedenza.
Di seguito sono riportati i passaggi per ottenere una tale configurazione:

1. Crea la cache del kernel usando il comando kextcache come `/kernelcache.test`
2. Copia le configurazioni di avvio esistenti in un file alternativo

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

3. Aggiorna il kernelcache e i boot-args per la tua configurazione

    ```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. Copia la nuova configurazione in `/Library/Preferences/SystemConfiguration/`