ktf

KTF - estrutura de teste do kernel

O KTF é um pequeno e simples kernel do sistema operacional, que permite a gravação de testes de software de baixo nível para arquiteturas de máquinas suportadas (atualmente: x86-64).

Recursos Visão geral

• Arquitetura da máquina: x86-64 , x86-32 no cozimento
• Suporte ao SMP com páginas básicas por CPU
• (PMM) (VMM) (VMM) (VMM) (VMM)
• Alocador de laje muito básico
• Apoio Apic local
• Tabelas MP iniciais analisando
• Tabelas ACPI básicas analisando
• Driver Uart simples
• (muito) driver VGA simples

Mais alguns recursos estão em andamento. Confira os problemas.

Começando

O início rápido é executar os seguintes comandos. O conteúdo dos testes de arquivo/test.c será executado. Observe que o último comando será bloqueado.

Construa um ktf.iso do zero, no recipiente do docker.

 make clean
make docker:ktf.iso

Inicialize a imagem resultante:

 make boot

Construir instruções

Requisitos

Pode ser necessário instalar o seguinte (a menos que você já o tenha):

• Ferramentas de bootloader GRUB2-pacote grub2-common (por exemplo, apt install grub2-common )
• Ferramentas de geração ISO-pacote xorriso , grub-pc-bin e mtools (por exemplo apt install xorriso grub-pc-bin mtools )

Construição de imagem do kernel (por exemplo, a ser usada com qemu)

• Nativo

 make

• Docker

 make docker:all

Geração ISO inicializável (por exemplo, para inicializar o KTF como um hóspede sob Xen ou em uma máquina de metal nu)

• Nativo

 make ktf.iso

• Docker

 make docker:ktf.iso

O comando make gera o arquivo ELF compatível com kernel64.bin , que você pode inicializar diretamente com o Qemu. O comando make ktf.iso pega o kernel64.bin , coloca -o na hierarquia grub/boot/ Diretório e gera um ktf.iso fora do grub/ (usando grub/boot/grub/grub.cfg como uma configuração padrão do GRUB).

Fedora

O KTF constrói e roda no Fedora, mas você precisará ajustar alguns dos comandos. Crie um arquivo makeconf.local com o seguinte conteúdo (testado com o 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

Correndo o kernel

Qemu (kvm ou não)

O Main Makefile tem vários alvos que facilitam a inicialização do KTF com o QEMU. O Makefile detecta se o sistema host for Linux e ativar o suporte ao KVM, se sim. Os parâmetros padrão para qemu podem ser encontrados no Makefile na variável QEMU_PARAMS .

Para inicializar a execução:

 make boot

Para depuração de depuração:

 make boot_debug

Para depurar com o GDB Run:

 make gdb

Xen convidado

Use o seguinte exemplo de configuração de domínio do hóspede para inicializar o KTF com 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

Você precisa gerar um ISO inicializável para isso.

Adicionando novos testes

Novos testes podem ser adicionados adicionando uma nova função em um arquivo na pasta de tests . Cada assinatura do teste deve ser a mesma que test_fn fornecida no test.h . Os testes podem ser ativados no grub.cfg , adicionando a opção com os principais tests e valores da lista separada por vírgula de nomes de funções, como tests=test1,test2,unit_tests .

Estilo

O estilo deste projeto é definido no arquivo .clang-format no diretório principal deste repositório.

Use o seguinte comando para aplicar o estilo automaticamente ao arquivo que você modifica:

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

Para obter mais informações, consulte: https://clang.llvm.org/docs/clangformat.html

Este projeto usa https://github.com/doozyx/clang-format-lint-action Ação de fluxo de trabalho para detectar incompatibilidades de estilo automaticamente. Para mais informações, consulte: https://github.com/marketplace/actions/clang-format-lint

Executando o fluxo de trabalho em formato de clang localmente

Construa o contêiner clang-format-lint

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

Isso deve ser feito apenas uma vez.

Patch seus arquivos

make style

Executando o fluxo de trabalho de uma linha de uma linha localmente

Construa o contêiner ktf-one-line-scan

• Primeiro, faça o download da imagem base one-line-scan

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

• Crie a imagem específica de uma linhas específicas do KTF, incluindo as ferramentas necessárias para a construção

 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 .

Isso deve ser feito apenas uma vez.

Digitalize seu diretório de trabalho atual

• por padrão, varredura de uma linha contra o diferencial entre HEAD e origin/mainline

make onelinescan

Créditos e atribuições

• Partes do projeto KTF são inspiradas e baseadas no projeto XTF [1] desenvolvido por Andrew Cooper, da Citrix.

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

Segurança

Consulte contribuindo para mais informações.

Comunidade

Mantenedores e usuários do KTF se comunicam no Slack. Montamos um espaço de trabalho frouxo e estamos compartilhando ativamente idéias, bugs e qualquer coisa relacionada ao KTF lá. Sinta -se à vontade para se juntar a nós: link de convite do Slack

Licença

Este projeto está licenciado sob a licença de cláusulas 2 BSD.