RikaiOS

Rikaios

Um pequeno sistema operacional de PC x86 de 32 bits com base em um kernel monolítico com alguns recursos do tipo Unix, escritos em um subconjunto de C ++.

Observação: esta meta-documentação ainda é um trabalho em andamento :-)

Visão / objetivo do projeto

Um pequeno sistema operacional de desktop, com recursos do tipo Unix, que é escrito em um subconjunto C ++ compreensível para os alunos do TI do primeiro ano do Hogeschool Utrecht, de modo que possa ser usado em um contexto educacional.

Sempre que possível, o desempenho e os recursos são sacrificados para reduzir a complexidade e aumentar a legibilidade. Isso deve ajudar o software a ser mais compreensível para uso em um contexto educacional. No entanto, assuntos importantes dos cursos de OS no Hogeschool Utrecht devem ser implementados.

Embora deva inicializar bem em hardware real, o Rikaios é desenvolvido com um emulador ou máquina virtual em mente - o hardware suportado é intencionalmente limitado por uma questão de simplicidade.

Um aviso obrigatório: o sistema operacional pode derreter sua placa -mãe e comer seu mouse de estimação quando executado em hardware de verdade, sem garantias, yada yada, leia o aviso no arquivo de licença antes de executar isso no seu computador de família.

Capturas de tela

Veja o diretório ./aux. Não espere nada chamativo - atualmente são todas as capturas de terminais em série!

Características

O sistema operacional com seu conjunto atual de recursos foi desenvolvido em um período de aproximadamente 6 meses, de fevereiro a julho de 2019.

• um pequeno carregador de inicialização de 2 estágios
• Gerenciamento de memória virtual (paginação)
• Tópicos do kernel
• Processos e threads no modo de usuário
• um agendador de robina redonda preventiva
• um carregador de elfo
• Um sistema de arquivos virtual com suporte primitivo para MountPoints
• A Devfs com arquivos de dispositivo virtual apoiado pelo motorista
• Drivers:
  • Portas em série
  • Controladores de disco ATA
  • Sistema de arquivos FAT32 (somente leitura, atualmente)
  • Adaptadores gráficos baseados em BochsvBE (suporta QEMU, Bochs e VirtualBox)
  • Teclados PS/2
• Sistema exige a criação de processos e a E/S do arquivo
• Um pequeno kernel (Leia: Exception & Malloc-Less) C ++ Substituição da biblioteca padrão da biblioteca
• Algumas ferramentas primitivas de terras de usuário (Shell, CP, LS, Cat, etc.)
• Uma ferramenta de apresentação de apresentação de slides da terra do usuário
• Uma concha especial para testar e consultar estatísticas do kernel
• Um sistema de construção flexível baseado em makefile para todos os softwares do sistema operacional

Recursos ainda para se aproximar (WIP)

Rikaios ainda não é um substituto completo do Linux ;-)

Existem alguns recursos que precisam de trabalho ou estão sendo trabalhados no momento (consulte também a seção contribuinte):

• Syscalls para criar tópicos adicionais de terras do usuário
• Syscalls para mapear a memória adicional (atualmente, os processos são limitados a .Data-/. BSS declarou memória)
• Escreva suporte no driver FAT32
• Suporte ao sistema de arquivos ext2
• um motorista adequado, disciplina de linha
• um console de estrutura, possivelmente em terras de usuário
• Outros mecanismos do IPC
• DMA para o motorista ATA
• uma porta de biblioteca padrão C (por exemplo, newlib ou musl), para que outro software possa ser portado
• Um GCC (ou Clang) Compiler Cross-Compiler SO Userland, que pode ser usado fora do sistema de construção atual
• uma porta GCC (ou Clang) que corre inteiramente dentro do sistema operacional
• Outros itens menores: grep -ERn 'TODO|FIXME|XXX' src/kernel/src src/kernel/include src/user/

Observe que o objetivo do Rikaios é permanecer pequeno: uma pilha de rede ou driver USB, por exemplo, provavelmente não será considerado para implementação.

Dependências

Você precisa deste software instalado (em um host Linux-ish) para construir e executar Rikaios:

• Nasm
• LLD
• llvm
• Clang
• Compiler-RT (Biblioteca de tempo de execução do compilador CLANG)
• separado
• mtools
• qemu (se você estiver correndo com qemu)
• Qemu-Arch-Extra
• Bochs (se você estiver correndo com bochs)
• RLWRAP (Opcional - para a conveniência da edição da linha de comando)

Os números de versão devem ser recentes, especialmente para Clang, LLVM e LLD. É fornecido um Dockerfile do Arch Linux (graças ao @Peikos) que inclui versões compatíveis das dependências acima.

Você pode usar o GCC em vez de Clang/LLVM, se assim o desejar, desde que tenha um cross-toolchain do GCC para i686-HIF. Consulte src/kernel/Makefile para obter detalhes sobre como trocar de ferramenta.

Estrutura de repo

Diretório	Descrição
/src/boot	Bootloader (BootSector e Stage2)
/src/boot/utils	Instalador de bootloader
/src/kernel	Código do kernel
/src/kernel/include	Cabeçalhos do kernel expostos à terra do usuário
/src/kernel/include/os-std	Biblioteca padrão do sistema operacional (matemática, contêineres, etc.)
/src/user	Software de Userland
/src/user/libsys	Biblioteca de sistemas C ++ do usuário C ++
/src/disk	(FAT32) sistema de arquivos disponível para o sistema operacional
Makefile	Descrição
/src/Makefile	Construa tudo, cria discos de inicialização e executa emuladores
/src/boot/Makefile	Construa o carregador de inicialização e instalador
/src/kernel/Makefile	Construa kernel
/src/user/Makefile	Construa Userland

Cada Makefile acima inclui (se disponível) um arquivo Makefile.local no mesmo diretório. Isso permite que você substitua qualquer nomes e caminhos executáveis ​​da cadeia de ferramentas e, opcionalmente, adicione alvos adicionais.

Como construir / correr

Não se esqueça de passar -j 4 (ou superior) para aumentar o desempenho da construção em sistemas multicore.

Qemu

Isso constrói o kernel e o carregador de inicialização e cria um disco de inicialização que é executado com o virtualizador / emulador QEMU. Uma conexão serial com o sistema operacional é aberta no terminal do qual você executa o comando make.

 fazer disco e fazer executar

Atualmente, o SHELL e o TTY Driver não possuem recursos sofisticados de edição de linha e suporte à história da linha de comando. Por conveniência, você pode embrulhar Qemu com rlwrap para usar as instalações de edição de linha no lado do host das coisas (fortemente recomendadas):

 fazer disco && rlwrap -a fazer executar

VirtualBox

Para executar no VirtualBox, faça o seguinte:

• Faça um disco usando o destino vdi :

 faça VDI

Então:

• Crie uma VM sem disco no VirtualBox.
• Vá para Configurações da VM -> Sistema -> Aceleração
  • Verifique (✓) Ativar VT-X/AMD-V e Ative Paging aninhado
• Vá para Configurações da VM -> Armazenamento
  • Remova o controlador SATA, se houver.
  • Crie um controlador IDE com configurações padrão
  • Adicione o arquivo disk.vdi como um disco IDE

Agora você deve poder iniciar a VM através do VirtualBox.

Observe que a E/S serial pode ser difícil começar a trabalhar. A versão atual do SO não interage muito com a tela e o teclado/ratos por padrão.

Brincando

Depois de ter o sistema em funcionamento, você deve ver um prompt no terminal serial (se você conectar um monitor, uma tela de respingo também poderá aparecer). Você pode interagir com o sistema operacional usando o terminal serial. Para começar, tente o comando de help .

Vários programas de utilidade são fornecidos no disco. Veja os programas instalados digitando ls bin (supondo que você ainda esteja no diretório /disk0p1 ). Todos os programas ELFs em /disk0p1/bin podem ser executados como comandos sem digitar o caminho completo (pense nele como um diretório $PATH ). Da mesma forma, todos os arquivos ELF no diretório de trabalho, como forth.elf , podem ser executados apenas digitando seu nome.

Para ver como os utilitários funcionam ou para adicionar o seu próprio, consulte o arquivo ReadMe no diretório src/user deste repositório.

Pressionar ESC no teclado (na janela de vídeo, não no terminal serial) permitirá que o shell do kernel, um utilitário de depuração integrado. Isso pode ser usado para imprimir várias estatísticas e informações sobre processos e memória em execução (consulte o comando de ajuda help quando estiver em Kshell).

Depuração

Você pode depurar o kernel com Qemu ou Bochs:

• QEMU/GDB: ​​fornece uma interface de depurador familiar com boa integração C ++.
• Bochs: fornece uma melhor visão geral de baixo nível com bons relatórios de erro x86, é mais lento.

Qemu/gdb

Veja ./src/gdbrc para opções de inicialização (você pode substituir esse caminho de arquivo em um Makefile.local ).

 fazer disco e fazer depuração

Bochs

Consulte ./src/bochsrc para opções de configuração (você pode substituir esse caminho de arquivo em um Makefile.local ).

 fazer disco e fazer bochs

Solução de problemas / erros comuns

 LD.LLD: Erro: Não é possível encontrar biblioteca -lclang_rt.builtins -i386

1. Localize a biblioteca Buildins do seu Clang (por exemplo, locate clang_rt.builtins )
2. Criar arquivo kernel/Makefile.local , com conteúdo: LD_BUILTIN_DIR += /the/directory/containing/the/clang/lib

Perguntas / bugs

Entendo que a documentação disponível ao público é limitada atualmente; portanto, não hesite em abrir um problema ou me enviar um e-mail.

Contribuindo

Por favor, abra um problema do Github / Gitlab para que não possamos garantir que nenhum esforço seja duplicado :-)

Um processo para isso deve ser formalizado nas próximas semanas - existem alguns problemas / recursos abertos que podem definitivamente ser trabalhados, com graus variados de dificuldade / tamanho. Vou documentar isso em breve ™.

Autores

• Chris Smeele

Licença

Este projeto está licenciado sob a licença Apache 2.0. Consulte ./license para mais informações.

Software de terceiros

Este sistema operacional foi escrito do zero, com apenas a seguinte exceção:

• Atualmente, o Userland é enviado com um domínio público portado para a implementação (Jonesforth). Consulte ./src/disk/forth.txt para obter mais informações.