ktf

KTF - Marco de prueba del núcleo

KTF es un kernel OS pequeño y simple que permite escribir pruebas de software de bajo nivel para arquitecturas de máquinas compatibles (actualmente: x86-64).

Descripción general de las características

• Arquitectura de la máquina: x86-64 , x86-32 en la cocción
• Soporte de SMP con páginas básicas por cpu
• (muy) gestión básica de memoria física (PMM) y gestión de memoria virtual (VMM)
• Asignador de losas muy básico
• Apoyo APIC local
• Tablas de MP iniciales analizando
• Tablas de ACPI básicas
• Conductor UART simple
• (muy) controlador VGA simple

Algunas características más están en proceso. Mira los problemas.

Empezando

El inicio rápido es ejecutar los siguientes comandos. Se ejecutará el contenido del archivo Tests/test.c. Tenga en cuenta que el último comando bloqueará.

Construya un KTF.ISO desde cero, en el contenedor Docker.

 make clean
make docker:ktf.iso

Arrancar la imagen resultante:

 make boot

Construir instrucciones

Requisitos

Es posible que deba instalar lo siguiente (a menos que ya lo tenga):

• Herramientas Grub2 Bootloader-Paquete de grub2-common (por ejemplo, apt install grub2-common )
• Herramientas de generación ISO: paquete xorriso , grub-pc-bin y mtools (por ejemplo apt install xorriso grub-pc-bin mtools )

Construcción de imagen del núcleo (por ejemplo, para ser utilizada con QEMU)

• Nativo

 make

• Estibador

 make docker:all

Generación ISO de arranque (por ejemplo, para arrancar KTF como invitado bajo Xen o en una máquina de metal desnudo)

• Nativo

 make ktf.iso

• Estibador

 make docker:ktf.iso

El comando make genera el archivo ELF compatible con múltiples múltiples kernel64.bin , que puede iniciar directamente con QEMU. El comando make ktf.iso toma el kernel64.bin , lo coloca en jerarquía grub/boot/ directorio y genera un ktf.iso fuera del grub/ (usando grub/boot/grub/grub.cfg como una configuración de grub predeterminada).

Fedora

KTF construye y se ejecuta en Fedora, pero necesitará ajustar algunos de los comandos. Cree un archivo makeconf.local con el siguiente contenido (probado con Fedora 32):

 DIST=$(shell grep NAME= /etc/os-release | cut -d= -f2)
ifeq ($(DIST),Fedora)
GRUB_FILE := grub2-file
GRUB_MKIMAGE := grub2-mkimage
GRUB_MODULES += normal
QEMU_BIN := qemu-kvm
DOCKER_MOUNT_OPTS := :Z
endif

Ejecutando el núcleo

QEMU (KVM o no)

Makefile principal tiene varios objetivos que facilitan el arranque KTF con QEMU. El Makefile detecta si el sistema de host es Linux y habilita el soporte de KVM si es así. Los parámetros predeterminados para QEMU se pueden encontrar en la variable Makefile en QEMU_PARAMS .

Para la ejecución de arranque:

 make boot

Para la ejecución de la depuración:

 make boot_debug

Para la depuración con GDB Run:

 make gdb

Invitado xen

Use el siguiente ejemplo de configuración del dominio de invitados para arrancar KTF con Xen:

 name = "kernel64"
builder = "hvm"
memory = 1024

serial = [ 'file:/tmp/kernel.log' , 'pty' ]

disk = [ '/home/user/ktf.iso,,hdc,cdrom' ]

on_reboot = "destroy"

vcpus = 1

Necesita generar un ISO de arranque para esto.

Agregar nuevas pruebas

Se pueden agregar nuevas pruebas agregando una nueva función en un archivo en la carpeta de tests . Cada firma de prueba debe ser la misma que test_fn proporcionada en test.h Las pruebas se pueden habilitar en grub.cfg agregando la opción con tests y valores clave de la lista separada por comas de nombres de funciones, como tests=test1,test2,unit_tests .

Estilo

El estilo para este proyecto se define en el archivo .clang-format en el directorio principal de este repositorio.

Use el siguiente comando para aplicar el estilo automáticamente al archivo que modifica:

clang-format -style=file -Werror -i MODIFIED_FILE

Para obtener más información, consulte: https://clang.llvm.org/docs/clangformat.html

Este proyecto utiliza https://github.com/doozyx/clang-format-lint-action Action Workflow para detectar coincidencias de estilo automáticamente. Para obtener más información, consulte: https://github.com/marketplace/acciones/clang-format-lint

Ejecutando el flujo de trabajo de clang-formato localmente

Construir un contenedor clang-format-lint

docker build -t clang-format-lint github.com/DoozyX/clang-format-lint-action

Esto debe hacerse solo una vez.

Parche sus archivos

make style

Ejecutando el flujo de trabajo de una línea de escaneo localmente

Construya el contenedor ktf-one-line-scan

• Primero, descargue la imagen base one-line-scan

docker build -t one-line-scan 
    https://raw.githubusercontent.com/awslabs/one-line-scan/master/tools/Dockerfile

• Cree la imagen específica de escaneo de una línea específica de KTF, incluidas las herramientas necesarias para la construcción

 docker build -t ktf-one-line-scan 
    --build-arg USER_ID=$(id -u) 
    --build-arg GROUP_ID=$(id -g) 
    --build-arg USER=$USER 
    --file tools/docker/OnelineScanDockerfile .

Esto debe hacerse solo una vez.

Escanee su directorio de trabajo actual

• Por predeterminado, escaneos de una línea contra la diferencia entre HEAD y origin/mainline

make onelinescan

Créditos y atribuciones

• Las partes del proyecto KTF están inspiradas y se basan en el proyecto XTF [1] desarrollado por Andrew Cooper de Citrix.

[1] http://xenbits.xenproject.org/docs/xtf/

Seguridad

Ver contribuyendo para más información.

Comunidad

Los mantenedores y usuarios de KTF se comunican en Slack. Configuramos un espacio de trabajo Slack y estamos compartiendo activamente ideas, errores y cualquier cosa relacionada con KTF allí. No dude en unirse a nosotros: enlace de invitación de Slack

Licencia

Este proyecto tiene licencia bajo la licencia BSD 2 Cláusula.