Projet système PC : 2014 - BARBETTE Justin, DEL PERUGIA Paul, RAMIRES Thibault

De Ensiwiki
Aller à : navigation, rechercher
Project schedule.png
Titre du projet Rastapopoulos
Cadre Projet Système d'Exploitation 2014
Page principale Projet_système

Équipe Justin Barbette Paul Del Perugia Thibault Ramires
Encadrants Damien Dejean Gaëtan Morin Grégory Mounié
 _____           _                                      _           
|  __ \         | |                                    | |          
| |__) |__ _ ___| |_ __ _ _ __   ___  _ __   ___  _   _| | ___  ___ 
|  _  // _` / __| __/ _` | '_ \ / _ \| '_ \ / _ \| | | | |/ _ \/ __|
| | \ \ (_| \__ \ || (_| | |_) | (_) | |_) | (_) | |_| | | (_) \__ \
|_|  \_\__,_|___/\__\__,_| .__/ \___/| .__/ \___/ \__,_|_|\___/|___/
                         | |         | |                            
                         |_|         |_|                                                    


Présentation générale

Le principe du projet est le développement d’un système d’exploitation sur machine nue. La première partie concerne la prise en main de l’environnement de travail et du projet. Elle se fait au travers de l’implémentation des étapes des TPs de PSE. La seconde étape qui démarre à partir de la phase 3 du projet se base sur les réalisations précédentes et une bonne connaissance de l’environnement.

Cahier des charges

À la fin du projet, il est demandé d’avoir :

  • Une gestion des processus : ordonnancement, création dynamique, etc...
  • Une gestion des sémaphores ;
  • Un mode utilisateur qui permet de faire appel au kernel via des primitives système ;
  • Un shell;

Déroulement du projet

Découpage

Nous avons décidé de suivre le découpage effectué dans la roadmap du projet, consultable ici :

  • Phase 1 : prendre en main l'environnement de développement (chargement et débogage de noyau) et gérer l'affichage à l'écran ;
  • Phase 2 : gérer la notion de processus, et le changement de contexte entre deux processus (au niveau noyau) ;
  • Phase 3 : gérer l'ordonnancement, la création dynamique, la terminaison et la filiation des processus (toujours au niveau noyau) ;
  • Phase 4 : gérer la communication (via l'emploi de sémaphores) et l'endormissement (appel wait_clock) des processus ;
  • Phase 5 : ajouter le mode utilisateur ;
  • Phase 6 : développer une console ;
  • Phase 7 : développer un interprèteur de commandes ;
  • Phase d’extensions : ajout de nouvelles fonctionnalités (par exemple un système de fichier).

Planification de l’implémentation

Retroplanning psa.png

Gestion du Projet

  • Nous avons décidé de ne pas créer de branche durant ce projet. En effet, il nous a semblé plus judicieux de ne pas effectuer de développement en parallèle mais plutôt que tout le monde participe ensemble à chaque phase. Cette approche nous a permis d’avoir une connaissance globale du projet et ainsi ne pas avoir de réèlle lacune au niveau de l’implémentation.
  • Tout au long du projet, jamais une seule personne n’a codé pendant que les autres ne faisaient rien, il y avait toujours une personne sur sa machine et les autres étaient la pour réfléchir sur l’implémentation ou une solution aux problèmes rencontrés.
  • Comme les commits le montrent, nous avons essayé de changer de “codeur” entre chaque phase.

Apports

Appels systèmes

Nous avons rajouté plusieurs primitives systèmes en plus de celles demandée dans les spécifications :

Changer la couleur d’ecriture dans la console
void change_color(uint8_t new_color)
utilisé pour tous les affichages de texte coloré
Afficher la liste des processus actifs (PID - Nom - Prio - State)
void syscall_ps(void)
utilisé dans la commande ps
Active ou désative le mode echo
void change_echo(void)
utilisé dans la commande echo
Redémarrer l’os
int syscall_reboot(void)
utilisé dans la commande reboot
Afficher un caractère dans une case précise
void print_char(uint32_t lig, uint32_t col, char c)
utilisé dans le snake
Retourner la dernière lettre minuscule entrée
char get_lastletter(void)
utilisé dans le snake
Nettoyer le buffer clavier
void clear_buffer(void)
utilisé à chaque fin de commande
Endormir le processus de x secondes
void sleep(int sec)
Récupérer le nom d’un processus
void get_name(int pid, char *name)

Commandes

Le shell mis a disposition dans notre OS est doté de plusieurs commandes :

RATPOS help.png

Snake

Nous avons mis en place un petit démontrant quelques une des caractéristiques de notre OS, parmi lesquel la gestion du clavier, de l’ecran, de la couleur…

RATPOS Snake.png

Raccourcis

Quelques fonctionnalités facilitant l’experience utilisateur ont été ajoutées :

  • Ctr+L : efface le shell (equivalent de la commande clear)
  • Historique des entrées utilisateurs, touches flèche haut et bas
  • Edition de l’entrée en cours, touches flèche gauche et droite

Difficultés rencontrées

  • La première difficulté que nous avons rencontré a été la configuration de l’environnement de travail. En effet 2 membres du groupe travaillant sous MacOS, installer un environnement de développement sur leur machine n’a pas été simple. La solution finale retenue a été de compiler et de débugguer dans une machine virtuelle Ubuntu et de tester avec Qemu sous MacOS. En effet le lancement de Qemu dans la machine virtuelle posait des problèmes de performance et s’est révélé très lent.
  • La seconde difficulté a appréhender a été la documentation. En effet, toute la documentation utile au projet est dispersée entre l’enseignement de MMPS (TPs PSE) et les pages concernant le projet sur le wiki. Presque toutes les informations nécessaires au projet sont disponibles sur le wiki, cependant il est très compliqué de s’y retrouver. En effet, la structure des pages n’est pas toujours pertinente et certaines informations sont présentes à plusieurs endroits sans forcément être exactement les mêmes. Il convient donc de bien réfléchir à ce qui est demandé ainsi qu’au choix fait précédemment qui impacte le prochain.

Pour aller plus loin

Faute de temps, nous n’avons pas implémenté d’extensions. De notre point de vue, le plus gros manque est le fait que nous n’ayons pas de système de fichiers, ce qui réduit de manière conséquente l’utilisation du shell. Il aurait également pu être intéressant de gérer certains drivers, comme celui de la souris, du son, etc...