Téléchargement Scorpion - Téléchargement du code source Scorpion

Scorpion

Autre code source

1.0.0

Télécharger

Scorpion

Un noyau multi-thread intégré en mode protégé pour l'architecture x86
Le noyau a été développé à l'aide d'un compilateur Cross GCC sur mesure à partir de Source
Scorpion a presque tous les composants fondamentaux englobés dans un noyau monolithique à part entière
Scorpion est un noyau monolithique utilisé pour démontrer comment se comporter du noyau et peut être construit à partir de zéro
La référence constante et étendue utilisée pendant le développement de Scorpion est: https://wiki.osdev.org/main_page

Voici quelques-uns des attributs du scorpion:

Tableau des descripteurs d'interruption
Contrôleur d'interruption programmable
Tas
Pagination
Lire du disque dur
Core du pilote de fichiers FAT16 et VFS (système de fichiers virtuel)
Espace utilisateur
TSS (segment du commutateur de tâche)
Fondation des tâches et du processus
GDT (Table des descripteurs globaux)
Interrompre 0x80 pour le processus d'espace utilisateur et la communication du noyau
Commandes du noyau / système
Conducteur du clavier PS2 PORT
Programme de shell pour utiliser le noyau
Chargeur de programme ELF
Fonctions STDLIB personnalisées pour les programmes d'espace utilisateur
Chargement d'autres programmes dans Shell
Gestion des plantages du programme
Multitâche

Tous les attributs du noyau peuvent ne pas être capturés ici et peuvent continuer à s'améliorer avec le temps, mais ceux ci-dessus resteront les propriétés centrales.

Condition préalable

Il y a des conditions préalables à construire et à tester Scorpion

Une machine hôte debian Linux (soit une machine virtuelle ou de Debian Linux fonctionnant sur une machine physique)
QemU-X86 pour simuler le chargeur de démarrage sur le noyau
Alternativement une machine physique capable d'exécuter des programmes x86
Un clavier de travail avec le port PS2 connecté à la machine physique à tuyau dans les commandes sur la coque pour interagir avec le noyau. Si vous utilisez Qemu, le clavier par défaut de votre ordinateur portable fonctionnera très bien

Construire le noyau et le chargeur de démarrage

Avant de construire le noyau et le chargeur de démarrage, nous devons préparer l'environnement en construisant le compilateur croisé. Un compilateur croisé est nécessaire car votre hôte peut avoir une architecture différente de la cible sur laquelle nous exécutons le noyau.

Installer des dépendances

Installez les dépendances entre les compilateurs avec les commandes suivantes:

 sudo apt install build-essential bison flex libgmp3-dev libmpc-dev libmpfr-dev texinfo libisl-dev

Télécharger le code source

Téléchargez le code source de Bin Utils et GCC dans le répertoire $HOME/src en utilisant les liens suivants:

Bin Utils Release 2.36: https://gnu.org/software/binutils/
GCC Release 10.2.0: https://gnu.org/software/gcc/

Extraire les deux téléchargements dans le répertoire $HOME/src

Construire GCC

Maintenant, convertissons la source en fichiers d'objets de compilateur pour notre cible
D'abord, certains Env Vars doivent être définis pour permettre à la fabrication d'installer des binaires compilés à la bonne place

 export PREFIX="$HOME/opt/cross"
export TARGET=i686-elf
export PATH="$PREFIX/bin:$PATH"

Binutiles

Exécutez la commande suivante pour construire des binutils. N'oubliez pas de remplacer XYZ par votre propre version.

 cd $HOME/src
 
mkdir build-binutils
cd build-binutils
../binutils-x.y.z/configure --target=$TARGET --prefix="$PREFIX" --with-sysroot --disable-nls --disable-werror
make
make install

GCC

Exécutez la commande suivante pour construire GCC. N'oubliez pas de remplacer XYZ par votre propre version.

 cd $HOME/src
 
# The $PREFIX/bin dir _must_ be in the PATH. We did that above.
which -- $TARGET-as || echo $TARGET-as is not in the PATH
 
mkdir build-gcc
cd build-gcc
../gcc-x.y.z/configure --target=$TARGET --prefix="$PREFIX" --disable-nls --enable-languages=c,c++ --without-headers
make all-gcc
make all-target-libgcc
make install-gcc
make install-target-libgcc

Une fois toutes les étapes ci-dessus terminées, allez-y et testez si votre compilateur croisé est construit avec succès et installé ou non avec la commande suivante:

 $HOME/opt/cross/bin/$TARGET-gcc --version

Maintenant que notre compilateur croisé est prêt, nous sommes prêts à construire Scorpion avec le chargeur de démarrage. Exécutez ce qui suit à la racine de la structure du projet

 ./build.sh

Si la construction réussit, 3 binaires doivent être générés dans le répertoire bin à la racine du projet

Le MBR Bootloader boot.bin
Le kernel.bin du noyau.bin
Le binaire Scorpion OS qui contient le chargeur de démarrage et l'ensemble du noyau scorpion.bin

Exécuter / tester Scorpion

Il est temps d'exécuter Scorpion OS en utilisant les binaires générés par la sortie dans la section précédente. Exécutez la commande suivante dans le terminal pour simuler Scorpion avec Qemu

 qemu-system-i386 -hda ./bin/scorpion.bin

Alternativement, vous trouverez que la machine démarre sur le shell suivant en cas de test sur une machine physique si le périphérique de démarrage est réglé correctement dans le menu du BIOS

Scorpion

Une invite de shell doit être activée avec la version Scorpion en haut à gauche. Vous pouvez maintenant commencer à taper sur la coquille. Un exemple de programme appelé blank.elf a été créé et chargé sur le disque dur Scorpion pour qu'il puisse accéder.
Chargez le programme en mémoire en exécutant ce qui suit sur l'invite de commande Scorpion