Projet système PC : 2016 - BOUDOUIN Philippe, TAREL Matthieu

De Ensiwiki
Aller à : navigation, rechercher
Ding'OS
DingOs.jpeg
Projet Système d'Exploitation 2016

Développeurs BOUDOUIN Philippe
TAREL Matthieu

Présentation générale

Le projet

L’objectif de ce projet système est l’implémentation du noyau d'un système d’exploitation. Autrement dit, le but de ce projet est la réalisation d’une interface entre l'utilisateur (ou le développeur) et le matériel, qui s'occupe de gérer les différents périphériques et de mettre à disposition des programmes.

Ce projet est pointu et il requière une bonne compréhension des logiciels de bas niveau. Afin d’arriver à nos fin nous avons dû nous documenter, les informations sur le wiki n’étant parfois pas suffisantes bien qu’assez complètes.

Cahier des charges

Les spécifications complètes du projet peuvent être consultées sur la page Wiki correspondante: Spécification En accord avec ces spécifications, la page concernant les Aspects techniques aide à la construction du projet.

Notre équipe

Notre équipe est composée de 2 étudiants :
BOUDOUIN Philippe : Filière ISI
TAREL Matthieu : Filière IF

Motivations

Le but est de réaliser un projet de grande envergure dans lequel nous ne sommes pas forcément à l’aise au départ (nos compétences étant bien plus forte dans d’autres domaines) ce qui constitue un véritable challenge pour nous.

Le but est donc de concevoir un système stable et robuste.

La gestion du projet

Les différentes phases du projet

Le projet s’organise en 7 phases que nous expliquerons succinctement plus tard. Elles doivent être effectuées chronologiquement:

  • Phase 1 : prendre en main l'environnement de développement et gérer l'affichage à l’écran;
  • Phase 2 : gérer la notion de processus, et le changement de contexte entre deux processus;
  • Phase 3 : gérer l'ordonnancement, la création dynamique, la terminaison et la filiation des processus;
  • Phase 4 : gérer la communication et l'endormissement des processus;
  • Phase 5 : séparer les espaces mémoires du noyau et des processus en utilisant la mémoire virtuelle, et ajouter le mode utilisateur;
  • Phase 6 : développer un pilote de console;
  • Phase 7 : développer un interprète de commandes, shell.

Le planning prévisionnel

De manière à aborter sereinement ce projet, nous avons réaliser un estimation du tant de travail pour chaque phase et réaliser un diagramme de Gantt.

Phase Temps estimé
Phase 1 1 jour
Phase 2 2 jour
Phase 3 2 jour
Phase 4 3 jours
Phase 5 4 jours
Phase 6 3 jour
Phase 7 2 jours
Total 17 jours

Nous travaillons environ 9h à 10h par jour sauf les week ends, les horaires sont évidemment souples tant que les objectifs sont atteint.

Le Diagramme de Gantt

Nous avons réalisé notre diagramme avec Excel.

Capture boudouin tarel.png

Nous avons également utilisé Trello pour actualiser la réalisation des différentes tâches chaque jours et ainsi fixer les objectifs pour le lendemain.

La réalisation du projet

Phase 1

Au cours de cette phase, on récupère d’abord les sources de départ du projet via le dépôt git et on se familiarise avec l’exécution du noyau, le débogage avec Qemu, Vinagre, gdb…
Ensuite, on implémente la gestion d’un mode d’affichage à l’écran. Cette partie et simple et rapide.

Avancement:

100 %

Phase 2

On entre véritablement dans le sujet au cours de cette phase. Cette phase est relativement importante puisqu’elle consiste à implémenter toute la structure d’un processus en introduisant des concepts clés pour le projet: assembleur, timer, processus, changement de contexte.
Cette phase ne présente pas de difficulté notable. Afin de vérifier notre implémentation nous avons adapté en mode superviseur les premiers tests fournis.

Avancement:

100 %

Phase 3

Cette phase concerne la gestion du cycle de vie des processeurs. Elle est déjà plus compliquée et nous avons eu nos premières difficultés qui ont toutefois été loin d’être insurmontables.

Avancement:

100 %

Phase 4

Cette phase consiste à implémenter les files de messages et le cas échéant la gestion de l'endormissement de processus.
Pour les files de messages, il faut bien choisir la structure de donnée du tampon. Les messages seront stockés dans un tableau de files, chaque files ayant ses propres piles de processus en attente de place et en attente de message. Pour les files, il est conseillé d’utiliser la structure fournie dans queue.h(.c)
Cette phase concerne aussi la gestion de l’endormissement des processus.
A partir de cette phase plusieurs tests fournis peuvent être testés, ainsi que le test Anneau à jetons (à faire) et le test concernant l’attente sur horloge.
Il est très important de bien testé cette phase, primordiale pour la suite, avant de s’attaquer à la mémoire.

Avancement:

100 %

Phase 5

Cette phase concerne l’implémentation du mode utilisateur, c’est clairement la plus délicate et complexe. Elle nécessite la lecture de documentations externes au Wiki assez complexe. Il est normal de passer beaucoup de temps sur cette phase.
Documentation recommandée:

Afin de réaliser les 3 parties de cette phase (Protection mémoire, Appels système, et Protection d'éxecution), il est fortement conseillé d’aller voir certaines pages Web des année précédentes qui fournissent de précieuses informations et des conseils concernant notamment la pagination, les appels système, et enfin le mode user.
Nous n'avons pas réalisé le partage de mémoire pour cette phase, et certain bugs n'ont pu être résolu.

Avancement:

80 %

Phase 6

Cette phase consistait à développer un pilote de console, ce dans l’optique de la réalisation d’un prototype de shell. La gestion du périphérique clavier se fait grâce à un traitant d'interruption matérielle (interruption clavier numéro 33), les signaux sont envoyés par le clavier au processeur lorsque l’utilisateur tape sur son clavier. Cette phase consistait aussi à développer la primitive cons_read qui lit les caractères saisis et enregistrés dans notre tampon. Cette primitive est essentielle pour pouvoir commencer la réalisation de l'interpréteur de commande.

Avancement:

80 %

Phase 7

Cette phase fut clairement la plus divertissante du projet, c’est dommage de n’avoir pu la commencer que le dernier jour. Nous avons réalisé un Mini-shell avec quelques commandes, de manière à ce que la présentation de notre OS soit bien meilleure.
Les commandes concernant notre shell:

  • Commande echo:
    • echo seul active l'echo.
    • echo on active l'echo.
    • echo off desactive l'echo.
  • Les commandes pour les tests:
    • Pour lancer tous les tests (commande tests seule)
    • Pour lancer un seul test (ex: test 4)
  • La commande kill :
    • Utilisation : kill <pid> où <pid> est un numéro de PID du processus à tuer.
  • La commande waitpid :
    • Utilisation : waitpid <pid> où <pid> est un numéro de PID à attendre.

Avancement:

50 %

Bilan

Ce projet nous a permis de nous familiariser avec les notions de conception de système d'exploitation. Il nous a également permis d’améliorer nos compétences concernant les langages de bas niveau.
Nous sommes un peu déçu de ne pas avoir fini les 7 phases entièrement, mais le mois de travail pour la réalisation de ce projet en binôme s’est globalement très bien passé.
Enfin, nous remercions les encadrant qui ont été présents tout au long de la réalisation de ce projet.

Outils

-Emacs: Pour le code.
-Git: Pour le gestion des versions du projet.
-Qemu: Pour tester notre système.
-gdb: Pour le débuggage.
-Excel: Pour réaliser le diagramme de Gantt.
-Trello: Pour l'organisation du travail.