Projet système PC : 2013 - Mikolaj PAWLIKOWSKI, Marien FRESSINAUD et Paul AMAR

De Ensiwiki
Aller à : navigation, rechercher
DesperadOS
Desperados.png
Projet Système d'Exploitation 2013

Développeurs Mikolaj PAWLIKOWSKI
Marien FRESSINAUD
Paul AMAR

Présentation

Vidéo

La vidéo de présentation est accessible ici: [1]

Desperados video thumbnail.png

Le projet système

Le projet système est à réaliser en fin de deuxième année.
Ce projet est donc la finalité du cours : "Systèmes d'exploitation" que nous avons suivi durant deux périodes. (Période 5 & Période 6)

Le cahier des charges étant commun avec la filière initiale, vous pouvez le trouver sur la page dédiée, à l'adresse suivante : Projet système

L'équipe

L'ensemble de la promotion a été divisé en trinôme. Les trois développeurs pour le Système d'exploitation "DesperadOS" sont :

Gestion de projet

Interface Trello pour notre projet.
Diagramme de Gantt pour notre projet.

Afin de réaliser ce projet, nous avons souhaité utiliser Trello [2], outil collaboratif de gestion de projet.
En effet, l'un de nos coéquipier avait déjà travaillé avec et nous avons souhaité l'utiliser car très facile à prendre en main : l'interface est plus qu'intuitive.

Au fur et à mesure, nous remplissions le Backlog (tâches à réaliser) et nous faisions deux mini-réunions par jour afin de nous attributer le travail.
Certaines tâches étant assez compliquées, nous en parlions tous ensemble afin de discuter de nos (différentes) approches.

Parallèlement, nous avons utilisé Git (dépôt fourni au départ) comme gestionnaire de version, outil que nous avons appris à utiliser depuis l'année dernière.
L'idée a été de créer une branche pour chaque feature que nous développions (ex: console_pc, gestionnaire_processus, horloge_primitives, ...)

Etat de l'avancement du projet

Le cahier des charges étant bien organisé, l'ensemble du projet est défini suivant 7 phases.
Certaines parties diffèrent et sont spécifiques aux apprentis.

Parallèlement, il était indiqué de réaliser une partie "Extension".
Nous avons choisi d'implanter le mode Graphique VGA 13h comme extension.

Phase 1: Gestion de l'écran

Le but de la première phase est de prendre en main l'environnement mais aussi de gérer l'affichage à l'écran.

L'affichage à l'écran, une fois mis en place, nous permet ainsi de pouvoir réaliser des appels à printf().

Parallèlement, il a fallu s'occuper de la gestion du curseur et gérer l'ensemble de cas possibles (ajout d'un caractère, suppression d'un caractère, balayage etc.)

L'ensemble des informations utile pour cette première phase sont situées à l'adresse suivante : [3]

Phase 2: Gestion du temps

Cette deuxième phase consiste à gérer le temps entre différents processus.

Afin de réaliser cela, il a fallu ajouter un timer au sein de notre système primitif, récupérer les interruptions (ticks d'horloge) et ainsi réaliser un changement de contexte entre les deux processus (si besoin).

Un ordonnanceur est implanté permettant ainsi de réaliser le changement de contexte. L'ordonnanceur fonctionne avec une politique de type "Round-Robin" avec gestion de priorité.

Les informations relatives à cette phase sont à l'adresse suivante : [4]

Phase 3: Ordonnancement manuel des processus

Pour cela, nous avons eu à mettre en place le cycle de vie d'un processus, et permettre qu'un processus passe la main à un autre.

Parallèlement, nous avons mis en place divers files de priorité permettant de gérer les processus en fonction de leurs états. (activables, bloqués sur I/O, bloqués sur sémaphores, ... )

Les informations relatives à cette phase sont aux adresses suivantes :
Processus : [5]
Passage d'un processus à l'autre : [6]

Phase 4: Implantation des sémaphores

Cette partie du projet devait permettre l'utilisation de méthodes de synchronisation / communication entre processus.

Les sémaphores ne sont pas très compliqués à développer si on fait bien attention à suivre scrupuleusement les spécifications et être précautionneux sur certains points que les tests sauront pointer de toutes manières.

Cette partie a vraiment participé à comprendre comment fonctionne un système dans ses mécanismes les plus bas-niveau... mais ce n'est rien par rapport à la partie suivante !

Phase 5: Basculement User Land / Kernel Land et inversement & primitives systèmes

Cette partie est avant tout la plus délicate de tout le projet.
Il faut bien comprendre le concept entre les différentes piles d'un processus (pile user et pile kernel) et comment arriver à échanger entre les deux au moment d'un appel à une primitive système.

Le but étant de bien séparer l'exécution du code côté utilisateur et celui côté kernel. L'intérêt porte essentiellement sur la sécurité et évite que du code arbitraire puisse accéder à n'importe quelle adresse en mémoire.

A titre d'information, ce document PDF vous sera certainement très utile :
Passage kernel/user [7]

C'est donc la partie la plus difficile de notre projet mais qui s'est aussi révélé très intéressante.

Phase 6: Gestion du clavier, écriture d'une console

Exemple de notre commande "demo" qui est un Pong virtuel.

Cette partie a pu être réalisée en parallèle avec l'écriture du changement Kernel/User.

En effet, il a fallu écrire la partie Kernel qui gérait les interruptions Clavier (Interruptions 33, avec démasquage de l'IRQ(1) ), et cela pouvait se faire en parallèle.
Après cela, il fallait arriver à créer un processus "Shell" lancé en mode user faisant appel à des fonctions "système" (ex: kill(), getpid()) "wrappés" qui s'occupent de faire l'interruption système associée.

Concernant la console, certaines primitives étaient demandées telles que (sinfo, ps, ...)

Voici l'ensemble des commandes implantées :

Commande Description

help

Affiche l'ensemble des commandes disponibles dans le Shell (dont celles du Système de gestion de fichiers (voir plus bas)

logo

Affiche le logo en mode texte

demo

Lance une démo (screensaver) de notre mode VGA. (attention aux yeux :) )

clear

Efface l'écran

echo [1]

Active ou non l'echo des touches à l'écran

kill X

Tue le processus de PID X

ps

Affiche la liste de tous les processus du système

reboot

Reboot le système

sleep X

Dort pendant X milli-secondes

sinfo

Affiche l'ensemble des informations relatives aux sémaphores

sysinfo

Affiche les informations utiles sur le système

test X

Lance le test X

tests

lance le processus interactif de tests (pour pouvoir tous les lancer)

uptime

Affiche le temps depuis lequel le système est allumé

Phase 7: Implantation extension n°1, Support VGA

Nous avons choisi le mode 13h de VGA comme la première extension à implanter.

Ce mode est très similaire au mode texte (3), avec les différences:

  • on écrit les pixels au lieu de caractères,
  • la résolution est 320x200 px.


Pour changer le mode VGA en mode 13h, il suffit de :

  • écrire 0x13 dans al,
  • exécuter interruption 0x10.

La difficulté qui se présente est le mode protégé - on n'a pas droit d'exécuter int 0x10 dans ce mode (où on est par défaut dans la vm).

Pour résoudre cela, nous avons utilisé le path fourni par les enseignants. Il propose un moyen d'appeller les interruptions.

Ensuite, il suffit d'écrire dans la mémoire (64 000 octets à partir de l'adresse 0xA0000, un octet dans la palette 256 couleurs par pixel), et les changement seront affichés sur l'écran.


Pour faire une démonstration de ce mode, nous avons écrit un screensaver, avec un rectangle qui rebondit sur les bords de l'écran.

Le menu:

Desperados screen help.png

La démo:

Desperados screen vga 2.png

"Phase 8": Implantation extension n°2, Système de gestion de fichiers

Exemple d'utilisation de notre shell.

Sachant que nous avions un peu de temps, nous avons souhaité implanter un système de fichiers.
En effet, l'idée était de pouvoir gérer des fichiers au sein même de notre shell.

Nous avons donc chercher à implémenter les fonctions UNIX de base dont :

Commande Description

ls

Liste le répertoire courant

touch X

Créer le fichier X

mkdir X

Créer le dossier X

cat X

Affiche le contenu fichier X

rm X

supprime le dossier/fichier X (ainsi que tous ses fichiers)

mv X Y

déplace le fichier/dossier X à l'emplacement Y

cd [X]

On déplace notre répertoire courant à l'emplacement de X ('..', '.', un dosser ou rien)


Afin d'implanter une telle fonctionnalité, nous avons créé une structure "inode" permettant de représenter nos fichiers/dossiers en mémoire.
L'inode "root" comprend un père (étant NULL pour le root folder).

Problèmes rencontrés

L'un de nos plus gros soucis a été de trouver les ressources nécessaires à l'élaboration de notre implantation technique.
Nous avons donc répertorié quelques liens qui nous ont été très utiles. (Voir section "Conseils")

De plus, certains points techniques comme le passage d'une pile Utilisateur à une pile Noyau comportait de nombreuses difficultés de compréhension.

Conseils pour les prochains étudiants

Avant tout développement, il faut beaucoup se documenter et arriver sur EnsiWiki peut se réveler infructueux aux premiers abords.
Voici donc quelques liens qui vous seront à mon avis très utiles :

Roadmap du projet : [8]
Ordre des scéances : [9]
Aspects techniques du projet : [10]
Documentation du projet : [11]