¿Qué es XNU?

El kernel XNU es parte del sistema operativo Darwin para su uso en los sistemas operativos macOS e iOS. XNU es un acrónimo de X is Not Unix. XNU es un kernel híbrido que combina el kernel Mach desarrollado en la Universidad Carnegie Mellon con componentes de FreeBSD y una API en C++ para escribir controladores llamada IOKit. XNU se ejecuta en x86_64 y ARM64 tanto para configuraciones de un solo procesador como multiprocesador.

El árbol fuente de XNU

• config - configuraciones para las APIs exportadas para la arquitectura y plataforma soportadas.
• SETUP - Conjunto básico de herramientas utilizadas para configurar el kernel, versionado y gestión de kextsymbol.
• EXTERNAL_HEADERS - Encabezados obtenidos de otros proyectos para evitar ciclos de dependencia al compilar. Estos encabezados deben sincronizarse regularmente cuando se actualiza la fuente.
• libkern - Código de la biblioteca IOKit en C++ para el manejo de controladores y kexts.
• libsa - código de arranque del kernel para inicio.
• libsyscall - interfaz de la biblioteca de syscall para programas de espacio de usuario.
• libkdd - fuente de la biblioteca de usuario para analizar datos del kernel como datos fragmentados del kernel.
• makedefs - reglas y definiciones de nivel superior para la compilación del kernel.
• osfmk - subsistemas basados en el kernel Mach.
• pexpert - código específico de la plataforma como manejo de interrupciones, atómicos, etc.
• security - interfaces de políticas de verificación de acceso obligatorio e implementación relacionada.
• bsd - código de subsistemas BSD.
• tools - conjunto de utilidades para probar, depurar y perfilar el kernel.

Cómo compilar XNU

Compilando un kernel DEVELOPMENT

El sistema de compilación de xnu puede compilar el kernel basándose en las variables KERNEL_CONFIGS y ARCH_CONFIGS como argumentos. Aquí está la sintaxis:```text make SDKROOT= ARCH_CONFIGS= KERNEL_CONFIGS=

Donde:

* `<sdkroot>`: ruta al SDK de macOS en el disco. (por defecto a `/`)
* `<variant>`: puede ser `debug`, `development`, `release`, `profile` y configura banderas de compilación y afirmaciones a lo largo del código del kernel.
* `<arch>`: puede ser una arquitectura válida para la cual compilar. (Ej. `X86_64`)

Para compilar un kernel para la misma arquitectura que el sistema operativo en ejecución, solo escriba```text
make SDKROOT=macosx.internal

Además, hay soporte para configurar arquitecturas mediante ARCH_CONFIGS y configuraciones de 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: Por defecto, la arquitectura está configurada para la arquitectura de la máquina de compilación, y la configuración predeterminada del kernel está configurada para compilar para `DEVELOPMENT`.

Esto también creará una imagen de arranque, kernel.[config] y un binario del kernel con símbolos, kernel.[config].unstripped.

Para instalar el kernel en un DSTROOT, utiliza el objetivo `install_kernels`:```text
make install_kernels DSTROOT=/tmp/xnu-dst

Para una experiencia de depuración del kernel más satisfactoria, con acceso a todas las variables locales y argumentos, pero sin todas las comprobaciones adicionales del kernel DEBUG, agregue algo como lo siguiente a su comando make:```text CFLAGS_DEVELOPMENTARM64="-O0 -g -DKERNEL_STACK_MULTIPLIER=2" CXXFLAGS_DEVELOPMENTARM64="-O0 -g -DKERNEL_STACK_MULTIPLIER=2"

Recuerde reemplazar `DEVELOPMENT` y `ARM64` con la compilación y plataforma adecuadas.

> Banderas adicionales: Puede pasar banderas adicionales al compilador de C en la línea de comandos con la configuración de compilación `EXTRA_CFLAGS`. Estas banderas se agregan a las `CFLAGS` base, y el valor predeterminado para la configuración es una cadena vacía.
>
> Esta configuración le permite, por ejemplo, activar selectivamente código de depuración protegido por una macro de preprocesador. Ejemplo de uso...
>
> ```text
> make SDKROOT=macosx.internal PRODUCT_CONFIGS=j314s 
> EXTRA_CFLAGS='-DKERNEL_STACK_MULTIPLIER=2'
> ```


* Para compilar con la configuración del kernel RELEASE

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

### Compilación del binario FAT del kernel

Defina las arquitecturas en su entorno o al ejecutar un comando make.```text
make ARCH_CONFIGS="X86_64" exporthdrs all

Otras Opciones de Makefile

• $ make MAKEJOBS=-j8 # esto usará 8 procesos durante la compilación. El valor predeterminado es 2 veces el número de CPU activas.
• $ make -j8 # la opción estándar de línea de comandos también se acepta
• $ make -w # rastrea invocaciones recursivas de make. Útil en combinación con VERBOSE=YES
• $ make BUILD_LTO=0 # compilar sin Optimización de Tiempo de Enlace de LLVM
• $ make BOUND_CHECKS=0 # deshabilitar -fbound-attributes para esta compilación
• $ make REMOTEBUILD=user@remotehost # realizar la compilación en un host remoto
• $ make BUILD_CODE_COVERAGE=1 # compilar con soporte para recopilar información de cobertura de código

El sistema de compilación de XNU puede opcionalmente generar una salida de compilación con formato de color. Para habilitarlo, puede configurar la variable de entorno XNU_LOGCOLORS a y, o pasar LOGCOLORS=y al comando make.

Personalizar la Versión de XNU

La versión de xnu se deriva del SDK o KDK leyendo el CFBundleVersion de su archivo System/Library/Extensions/System.kext/Info.plist. Esto se puede personalizar configurando la variable RC_DARWIN_KERNEL_VERSION en el entorno o en la línea de comandos de make.

Consulte doc/building/xnu_version.md para más detalles.

Formatos de Información de Depuración

Por defecto, se crea un repositorio de información de depuración DWARF durante la fase de instalación; este es un "bundle" denominado kernel.development.<variant>.dSYM Para seleccionar el formato de información de depuración STABS más antiguo (donde la información de depuración está incrustada en la imagen kernel.development.unstripped), configure la variable de entorno BUILD_STABS.```sh export BUILD_STABS=1 make

## Construyendo KernelCaches

Para probar el kernel de xnu, necesitas construir un kernelcache que enlace los kexts y
kernel juntos en una única imagen arrancable.
Para construir un kernelcache puedes usar los siguientes mecanismos:

* Usando la generación automática de kernelcache con `kextd`.
  El demonio kextd monitorea cambios en el directorio `/System/Library/Extensions`.
  Así que puedes configurar un nuevo kernel como

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

* Invocando manualmente `kextcache` para construir un nuevo kernelcache.

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


## Arrancando un KernelCache en una máquina de destino

El kernel de desarrollo e iBoot soportan configurar argumentos de arranque para que podamos arrancar de manera segura en un kernel de prueba y, si algo sale mal, retroceder de manera segura al kernelcache usado anteriormente.
Los siguientes son los pasos para lograr dicha configuración:

1. Crear el kernel cache usando el comando kextcache como `/kernelcache.test`
2. Copiar las configuraciones de arranque existentes a un archivo alternativo

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

3. Actualizar el kernelcache y los boot-args para tu configuración

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