O que é XNU?

O kernel XNU faz parte do sistema operacional Darwin, utilizado nos sistemas operacionais macOS e iOS. XNU é um acrônimo para X is Not Unix. XNU é um kernel híbrido que combina o kernel Mach desenvolvido na Universidade Carnegie Mellon com componentes do FreeBSD e uma API C++ para escrever drivers chamada IOKit. XNU executa em x86_64 e ARM64 para configurações de processador único e multiprocessador.

A Árvore de Código Fonte do XNU

• config - configurações para APIs exportadas para arquitetura e plataforma suportadas
• SETUP - Conjunto básico de ferramentas usadas para configurar o kernel, versionamento e gerenciamento de kextsymbol.
• EXTERNAL_HEADERS - Cabeçalhos obtidos de outros projetos para evitar ciclos de dependência durante a compilação. Esses cabeçalhos devem ser sincronizados regularmente quando o código fonte for atualizado.
• libkern - código da biblioteca C++ IOKit para manipulação de drivers e kexts.
• libsa - código de inicialização do kernel para arranque
• libsyscall - interface de biblioteca de syscall para programas em espaço de usuário
• libkdd - código fonte para biblioteca de usuário para análise de dados do kernel, como dados fragmentados do kernel.
• makedefs - regras e definições de nível superior para a compilação do kernel.
• osfmk - subsistemas baseados no kernel Mach
• pexpert - código específico de plataforma, como tratamento de interrupções, atômicos, etc.
• security - interfaces de política de verificação de acesso obrigatório e implementação relacionada.
• bsd - código dos subsistemas BSD
• tools - Um conjunto de utilitários para teste, depuração e perfilamento do kernel.

Como Compilar o XNU

Compilando um Kernel DEVELOPMENT

O sistema de compilação do xnu pode construir o kernel com base nas variáveis KERNEL_CONFIGS e ARCH_CONFIGS como argumentos. Aqui está a sintaxe:```text make SDKROOT= ARCH_CONFIGS= KERNEL_CONFIGS=

Onde:

* `<sdkroot>`: caminho para o SDK do macOS no disco. (padrão é `/`)
* `<variant>`: pode ser `debug`, `development`, `release`, `profile` e configura flags de compilação e asserções em todo o código do kernel.
* `<arch>`: pode ser uma arquitetura válida para compilar. (Ex.: `X86_64`)

Para compilar um kernel para a mesma arquitetura do SO em execução, basta digitar```text
make SDKROOT=macosx.internal

Além disso, há suporte para configurar arquiteturas através de ARCH_CONFIGS e configurações de kernel com 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: Por padrão, a arquitetura é definida como a arquitetura da máquina de build, e a configuração padrão do kernel é definida para compilar para `DEVELOPMENT`.

Isso também criará uma imagem inicializável, kernel.[config], e um binário do kernel com símbolos, kernel.[config].unstripped.

Para instalar o kernel em um DSTROOT, use o alvo `install_kernels`:```text
make install_kernels DSTROOT=/tmp/xnu-dst

Para uma experiência de depuração do kernel mais satisfatória, com acesso a todas as variáveis e argumentos locais, mas sem todas as verificações extras do kernel DEBUG, adicione algo como o seguinte ao seu comando make:```text CFLAGS_DEVELOPMENTARM64="-O0 -g -DKERNEL_STACK_MULTIPLIER=2" CXXFLAGS_DEVELOPMENTARM64="-O0 -g -DKERNEL_STACK_MULTIPLIER=2"

Lembre-se de substituir `DEVELOPMENT` e `ARM64` pela build e plataforma apropriadas.

> Bandeiras Extras: Você pode passar bandeiras adicionais para o compilador C na linha de comando com a configuração de build `EXTRA_CFLAGS`. Essas bandeiras são anexadas às `CFLAGS` base, e o valor padrão para a configuração é uma string vazia.
>
> Esta configuração permite, por exemplo, ativar seletivamente código de depuração que é protegido por uma macro de pré-processador. Exemplo de uso...
>
> ```text
> make SDKROOT=macosx.internal PRODUCT_CONFIGS=j314s 
> EXTRA_CFLAGS='-DKERNEL_STACK_MULTIPLIER=2'
> ```


* Para compilar com configuração de kernel RELEASE

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

### Compilando o Binário do Kernel FAT

Defina as arquiteturas no seu ambiente ou ao executar um comando make.```text
make ARCH_CONFIGS="X86_64" exporthdrs all

Outras Opções do Makefile

• $ make MAKEJOBS=-j8 # isto usará 8 processos durante a compilação. O padrão é 2x o número de CPUs ativas.
• $ make -j8 # a opção padrão da linha de comando também é aceita
• $ make -w # rastreia invocações recursivas do make. Útil em combinação com VERBOSE=YES
• $ make BUILD_LTO=0 # compilar sem Link Time Optimization do LLVM
• $ make BOUND_CHECKS=0 # desabilitar -fbound-attributes para esta compilação
• $ make REMOTEBUILD=user@remotehost # realizar compilação em host remoto
• $ make BUILD_CODE_COVERAGE=1 # compilar com suporte para coleta de informações de cobertura de código

O sistema de compilação XNU pode opcionalmente gerar saída com formatação colorida. Para habilitar isso, você pode definir a variável de ambiente XNU_LOGCOLORS como y, ou passar LOGCOLORS=y para o comando make.

Personalizar a Versão do XNU

A versão do xnu é derivada do SDK ou KDK lendo o CFBundleVersion do arquivo System/Library/Extensions/System.kext/Info.plist deles. Isso pode ser personalizado definindo a variável RC_DARWIN_KERNEL_VERSION no ambiente ou na linha de comando do make.

Veja doc/building/xnu_version.md para mais detalhes.

Formatos de Informações de Depuração

Por padrão, um repositório de informações de depuração DWARF é criado durante a fase de instalação; este é um "bundle" chamado kernel.development.<variant>.dSYM Para selecionar o formato mais antigo de informações de depuração STABS (onde as informações de depuração são incorporadas na imagem kernel.development.unstripped), defina a variável de ambiente BUILD_STABS.```sh export BUILD_STABS=1 make

## Construindo KernelCaches

Para testar o kernel xnu, você precisa construir um kernelcache que ligue os kexts e o kernel em uma única imagem inicializável.
Para construir um kernelcache, você pode usar os seguintes mecanismos:

* Usando a geração automática de kernelcache com `kextd`.
  O daemon kextd fica monitorando alterações no diretório `/System/Library/Extensions`.
  Então você pode configurar um novo kernel como

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

* Invocando manualmente o `kextcache` para construir um novo kernelcache.

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


## Inicializando um KernelCache em uma máquina alvo

O kernel de desenvolvimento e o iBoot suportam a configuração de argumentos de inicialização para que possamos inicializar com segurança em um kernel de teste e, se algo der errado, cair com segurança no kernelcache usado anteriormente.
A seguir estão os passos para obter tal configuração:

1. Crie o cache do kernel usando o comando kextcache como `/kernelcache.test`
2. Copie as configurações de inicialização existentes para um arquivo alternativo

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

3. Atualize o kernelcache e os boot-args para sua configuração

    ```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. Copie o novo config para `/Library/Preferences/SystemConfiguration/`

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

5. Abençoe o volume com as novas configurações.