Projet système PC : 2013 - Mahieddine DELLABANI, Mehdi DOMEC et Francesca PALOMBINI

De Ensiwiki
Aller à : navigation, rechercher

Mycomputer.png  Deuxième Année  CDROM.png  Informatique 

HalalOS
Halalos.jpg
Banner de l'HalalOS

Introduction

L'objectif de ce projet est la construction d'un noyau de système d'exploitation sur l'architecture Intel IA32 (x86).
Nous vous présentons ici les fonctionnalités prises en charge par notre OS, le HalalOS.

Présentation de l'équipe

Notre équipe est composée de 3 membres :
nous venons tous les trois de la filière SLE (Systèmes et Logiciels Embarqués) de l'Ensimag.

Présentation du projet

Ce projet est développé dans la continuité des cours de deuxième année : PSE, SEPC, CSE, Architecture avancée etc.
On peut dire qu'il s'agit d'un projet à but pédagogique. Au contraire d'autres projets qui incluent dans leur difficulté la définition des besoins du client et du résultat final, le Projet Système présente dès le départ des spécifications précises établies par les professeurs encadrants.
Parmi les enjeux principaux, vérifier l'intégrité de nos connaissances et les mettre en application pour délivrer un noyau minimal mais fonctionnel.
Ce projet est proposé aux étudiants tous les ans, mais c'est la première fois que la mémoire virtuelle faisait partie du cahier des charges (grâce à la modification de la chaîne de compilation par Damien DEJEAN

Travail réalisé

Voici un résumé des principales fonctionnalités implémentées dans notre OS
Nous sommes partis du travail développé lors du cours de Pratique de système, et nous en avons repris pour commencer, la même gestion de l'affichage à l’écran, la structure de processus et la gestion du temps, après les avoir légèrement modifiés pour correspondre au cahier des charges du projet.

Ordonnancement

Tout d'abord, l'ordonnancement entre processus est géré sur la base du niveau de priorité de chaque processus.
En effet, à l'aide d'un jeu de plusieurs files de priorité correspondant aux statuts possibles d'un processus, on définit des règles de préemption qui constituent notre ordonnancement.

Communication entre les processus

La communication entre processus est gérée de deux façon différentes : par les files de messages ou par partage de la mémoire

File de messages

Le partage par file de messages permet aux processus de s'échanger des nombres entiers (les messages) en utilisant une structure bien connue : la file.
Un processus peut essayer de demander ou de recevoir un message d'une file donnée. Lorsque cette file est vide, la demande de message provoquera le blocage du processus. L'envoi d'un message sur cette même file entraînera la réactivation du processus précédemment bloqué. De même, lorsque le processus essaye d'envoyer un message dans une file pleine, il sera bloqué en attente jusqu'à ce qu'un autre processus ne le débloque en libérant un espace dans la file.

Pages partagées

La communication peut se faire également grâce au partage (entre processus) de pages dans la mémoire. Cela permet aux processus d'échanger plus que de simples nombres entiers. Une page peut être allouée ou supprimée de la liste de pages partagées; ainsi, les processus peuvent demander l'acquisition d'une page partagée déjà existante, en ne connaissant que sa clé.

Mémoire virtuelle

La mémoire virtuelle est un mécanisme mis en place pour permettre une forte isolation entre processus. De cette manière ils ne partagent plus d’espace mémoire entre eux, à moins d'utiliser les primitives de communication citées ci-dessus.
Cela a été possible grâce à l'implémentation d'un allocateur pour la gestion des pages, d'une fonction de mapping qui fait la correspondance adresse virtuelle/adresse physique dans la page directory de chaque processus, et qui définit ses droits d'accès.
Pour plus de détails sur cette partie, vous pouvez vous référer aux aspects techniques du cahier des charges.

Séparation user/kernel

L'architecture x86 de Intel propose 4 niveaux de privilèges régissant les droits d'accès des processus. Dans le cadre de notre projet, nous utilisons que les niveaux ring0 et ring3 correspondant respectivement aux modes kernel et user.
Un processus possède donc un espace mémoire qui lui est propre, où sont mappés son code, ses données, ses deux piles (user et kernel); de ce fait, un processus n'accède au noyau que s'il s'exécute en mode privilégié. Autrement une exception est levée.
Les divers moyens de communication entre les processus se trouvant dans le kernel, il faut leur permettre d'y acceder. Pour cela, nous avons dû établir une librairie d'appels systèmes, pour permettre aux processus en mode utilisateur de demander au kernel l'exécution de certaines fonctions.

Pilote clavier / Interprète de commande

Nous avons ensuite implémenté en parallèle du pilote clavier un interpréteur de commande type shell linux, permettant d'interfacer notre noyau avec des utilisateurs. Ce shell est simpliste, il permet l'utilisation des commandes listées ci-dessous
Parmi les extensions, l'implémentation du multishell (cf Extensions ) a constitué une amélioration importante du shell précédemment implémenté.


Commande Signification

ps

  • Afficher les informations sur les processus existants (pid, état, nom)

sinfo

  • Afficher des informations sur les files de messages existantes (fid, nombre de messages, capacité, count)

echo [on/off]

  • Activer (on) ou désactiver (off) l’écho sur la console

clear

  • Effacer l'écran

kill [pid]

  • Tuer le processus dont le pid est passé en paramètre (pid > 5 pour ne pas tuer les multishells)

test [nbr]

  • Lancer le test numéro nbr (autotest numéro 21)

help

  • Afficher les commandes disponibles

shell [nbr]

  • Se déplacer dans le shell numéro nbr, compris entre 1 et 4

banner

  • Afficher le banner

Extensions

En plus des fonctionnalités définies par les cahier des charges, nous avons réalisé plusieurs extensions pour notre noyau.

Multishells

Nous avons eu le temps d'implémenter la gestion des multishells. On définit, au lancement du noyau 4 processus qui initialisent chacun un affichage virtuel. Plus tard un processus lancé héritera de l'affichage de son père pour séparer l'affichage d'un shell à l'autre lorsque les processus lancés s’exécuteront en background.
Pour pouvoir gérer correctement le basculement entre shells, on initialise une file de messages et chacun se bloquera en attente d'interruption clavier sur sa file.
Tout processus (quelque soit son affichage) écrit dans un buffer correspondant à son affichage virtuel. Le clavier débloquera le processus de la file correspondant à l'affichage courant que l'on gagne en mémoire.
Pour basculer d'un shell à l'autre on tape la commande "shell X" qui switchera entre l'ancien display et le nouveau si celui-ci est différent.

Pilote souris

L'implémentation du pilote de la souris n'a pas été aussi poussée que celle du multishells. Les fonctionnalités implémentées sont la détection de mouvement de la souris ainsi que l'appui sur un de ses trois boutons.
Toutes les informations nécessaires à l'implémentation de ce driver sont disponibles sur le site OSDev.

Bilan du projet

Résultats

Comme nous l'avons déjà dit, ce projet nous a permis tout d'abord de mettre en pratique les notions vues en cours pendant toute l'année, tout en développant une façon de travailler indispensable à l'avancement du projet : nous avons dû revenir sur notre code tout au long du projet pour l'adapter à un cahier de charge de plus en plus complet et compliqué. En effet, l'avancement dans les phases du projet donne des détails à prendre en compte dans les parties précédentes.
Notre méthode de travail lors de chaque phase a été analyse - implémentation - test et debug, et les retours entre les phases ont étés nombreux.
Notre OS suit le cahier des charge fourni et passe la batterie de tests qui nous était donnée.

Difficultés rencontrées

La principale difficulté que nous avons rencontré a été d’appréhender l’environnement et l'architecture x86 sur laquelle nous avions eu peu de formation ayant fait notre 1A à Phelma. Notre connaissance de l'environnement du debug, était elle aussi assez faible au début du projet, mais à son terme, nous estimons avoir acquis un bon niveau dans ce domaine.

Documentation

Outils incontournables

  • qemu pour tester notre système d'exploitation.
  • ddd pour débugger notre système d'exploitation.
  • git pour mettre en commun notre code.
  • Planner pour plannifier notre travail.
  • Trello pour organiser notre travail.

Essayez notre noyau

HalalOS : fichier kernel.bin de l'HalalOS