Projet système PC : 2019 - RAFFY Anthony, LUO Siwen : Différence entre versions

De Ensiwiki
Aller à : navigation, rechercher
(Fonctionnalités réalisées)
(Fonctionnalités réalisées)
Ligne 26 : Ligne 26 :
  
 
== Fonctionnalités réalisées ==
 
== Fonctionnalités réalisées ==
Notre OS possède un interpréteur de commande, qui permet d'afficher tous les processus existants par la commande "ps".
+
Notre OS possède un interpréteur de commande, qui permet d'afficher de l'heure et de la date du jour, de changer la couleur et de lister tous les processus existants par la commande "ps".
  
 
==Phases de développement==
 
==Phases de développement==

Version du 25 juin 2019 à 18:19

Project schedule.png
Titre du projet NullOS
Cadre Projet système

Équipe Anthony RAFFY, Siwen LUO
Encadrants Yves Denneulin , Gregory Mounie, Patrick Reignier


Sommaire

Présentation

L'objectif du projet système est la réalisation d'un noyau de système d'exploitation sur une architecture Intel x86 (le risc-v 64 bits).

Equipe

Planning

Planning prévisionnel

PlanPreL.png


Planning effectif

PlanEffL.png

Fonctionnalités réalisées

Notre OS possède un interpréteur de commande, qui permet d'afficher de l'heure et de la date du jour, de changer la couleur et de lister tous les processus existants par la commande "ps".

Phases de développement

Phase 1 : Prise en main de l'environnement

100 %

Phase 2 : Création et lancement de processus de niveau noyau

100 %

Phase 3 : Ordonnancement, création dynamique et terminaison de processus de niveau noyau

100 %

Phase 4 : Gestion des communications et synchronisation de processus de niveau noyau

100 %

Phase 5 : Séparation des espaces mémoire noyau et utilisateur : gestion de processus utilisateur

100 %

Phase 6 : Gestion du clavier et implémentation d'un pilote de console au niveau utilisateur

100 %

Phase 7 : Implémentation d'un interprète de commandes au niveau utilisateur

100 %

Phase 8 : Extensions

0 %

Journal de bord

Semaine 1

Mercredi 5 Juin 2019 (Phase 1)

  • Présentation initiale du projet par M. Mounié.
  • Création d'un script permettant de faciliter le lancement de QEMU et GDB.
  • Anthony et Siwen : Mise en place (en parallèle) du code nécessaire à l’affichage et à la gestion du curseur.
  • Développement de la phase 1 :
    • Les deux scripts (start.sh et start_debug.sh) permettant le lancement de qmeu avec et sans debugger gdb.
    • Le code côté kernel permettant l'affichage de caractère à l'écran et la gestion du curseur.
    • Une ébauche de tests sur l'affichage en utilisant la fonction printf.
  • Fin de la phase 1.

Jeudi 6 Juin 2019 (Phase 2)

  • Début de la phase 2.
  • Ajout de tests sur l'affichage afin de couvrir l'ensemble des cas possibles.
  • Mise en place des structures de code permettant le changement de contexte et la création de processus.
  • Début de développement sur les files de priorité afin de préparer la phase 3.
  • Développement de tests basiques sur le changement de contexte : deux processus affichant chacun un caractère et donnant la priorité au processus bloqué.

Vendredi 7 Juin 2019 (Phase 2)

  • En cours de la phase 2.
  • Développement des fonctions permettant le masquage et le démasquage des interruptions.
  • Développement du traitant d'interruption pour l'interruption d'horloge.
  • Développement de la fonction permettant le réglage de la fréquence horloge.
  • Mise en place de la logique de l'ordonnanceur en utilisant la priorité de chaque processus.
  • Mise en place du processus "idle" au cas où aucun autre processus n'est actif.
  • Fin de la phase 2.

Semaine 2

Lundi 10 Juin 2019 (Phase 3)

  • Début de la phase 3.
  • Terminaison des processus, par kill() ou par exit().
  • Gestion des fils (zombies) et pères lors d'une terminaison.

Mardi 11 Juin 2019 (Phase 3)

  • En cours de la phase 3.
  • Ajout de tests pour vérifier le fonctionnement de context-switch entre deux différents processus.
  • Développement des fonctions d'endormissement. (sleep() et wait_clock())
  • Développement des fonctions de terminaisons. (exit() et kill())
  • Modification du changement de contexte pour tenir compte de la terminaison.
  • Modification de l'ordonnancement pour tenir compte des processus endormis et terminés.
  • Amélioration du code pour une meilleur lisibilité et maintenance.

Mercredi 12 Juin 2019 (Phase 3 & 4)

  • Ajout de tests permettants de vérifier le fonctionnement de primitives kill() et start().
  • Ajout de structures pour gérer la filiation.
  • Développement des fonctions de filiations (waitpid) et de l'état "en attente d'un fils".
  • Modification de l'ordonnancement pour gérer la filiation (fils zombie).
  • Ajout d'autres appels systèmes (chprio, getprio).
  • Fin de la phase 3.
  • Ajout de tests afin de vérifier le fonctionnement de l'ordonnanceur, dans les cas où il existe un fil d'attente de processus, soient les pères ou les fils, soient les processus qui finissent automatiquement, ou ne se terminent jamais tous seuls.
  • Début de la phase 4 : file de messages.
  • Changement des méthodes des listes chainées pour en faire des macros, afin de pouvoir les utiliser avec les files.
  • Modification de la structure de processus pour ajouter un état "en attente d'une entrée-sortie".
  • Ajout de tests pour la phase 4.
  • Mise en place de la structure pour gérer les files.

Jeudi 13 Juin 2019 (Phase 4)

  • Ajout des tests permettants de vérifier le fonctionnement des primitives sleep(), waitclock(), kill() et waitpid().
  • En cours de la phase 4.
  • Ajout des fonctions pcreate() et psend().
  • Modification de l'ordonnancement pour tenir compte de l'état "en attente d'une entrée-sortie".
  • Modification du code pour lancer les tests de base.
  • Correction d'une erreur avec la valeur de retour de kill().
  • Fin du développement des files de messages.
  • Correction d'une erreur sur pcreate empechant la création d'une file.
  • Correction d'une erreur ajoutant deux fois un processus dans l'état activable.
  • Ajout de tests basiques sur les files de messages.

Vendredi 14 Juin 2019 (Phase 4)

  • En cours de la phase 4.
  • Ajout des fonctions pcount(), pdelete() et preset().
  • Corrections d'erreurs :
    • Correction de la valeur de retour par "return" en ajoutant une fonction proxy().
    • Correction d'un bug au niveau de la fonction chprio() qui n'appelait pas l'ordonnanceur.
    • Correction de la fonction waitpid() qui écrivait dans un pointeur s'il était nul.
    • Correction d'un bug où l'on pouvait changer la priorité d'un processus zombie.
    • Correction d'un bug où l'on ne verifiait pas si le pointeur de preceive était nul.
    • Correction d'un bug où l'on ajoute un processus déjà dans la queue.
    • Ajustement du nombre de processus maximum pour faire passer les tests de performance.
    • En cas de terminaison d'un processus, le supprimer des queues d'une file ou il était en attente.
  • Corrections d'erreurs avec psend() ou preceive(), ou les messages n'étaient pas immédiatement transmis dans le cas d'une file vide ou pleine.
  • Correction de la fonction pdelete() pour lancer l'ordonnanceur.
  • Fin de la phase 4.
  • Réussite de tous les tests : 1 à 17.

Semaine 3

Lundi 17 Juin 2019 (Phase 5)

  • Correction d'une erreur où le processus libéré était toujours considéré en attente d'entrée-sortie si le pid était redistribué à un nouveau processus.
  • Début de la phase 5.
  • Mise en place du squelette permettant les appels systèmes de l'utilisateur au kernel.
  • Ajout du traitant d'interruption 49.
  • Premiers tests d'appels systèmes par passage de paramètres avec %eax.
  • Ajout des variables nécessaires à l'implémentation de la pile utilisateur.

Mardi 18 Juin 2019 (Phase 5)

  • En cours de la phase 5.
  • Ajout de l'appel système cons_write.
  • Ecriture de la fonction intermediaire permettant le changement de privilèges lors du lancement du premier processus utilisateur.
  • Implémentation de la fonction permettant le passage du noyau au mode utilisateur.
  • Sauvegarde de ESP0 dans la TSS.
  • Modification de la fonction permettant de modifier la table des interruptions pour autoriser des interruptions depuis le mode utilisateur.
  • Ajout de console_putbytes coté utilisateur faisant l'appel système cons_write afin d'afficher du texte à l'écran.

Mercredi 19 Juin 2019 (Phase 5)

  • En cours de la phase 5.
  • Développement supplémentaire sur la fonction de changement de privilèges.
  • Distinction dans start() entre processus utilisateur et processus noyau.
  • Ajout de tous les appels systèmes et tests basiques dans la partie utilisateur.
  • Correction pour bien communiquer la valeur de retour des appels systèmes.
  • Modification pour effectuer le changemeent de privilèges à chaque appel de start().
  • Sauvegarde d'ESP0 lors d'un changement de contexte.
  • Tests de développement sur le changement de contexte et ESP0.

Jeudi 20 Juin 2019 (Phase 5)

  • En cours de la phase 5.
  • Corrections diverses :
    • Correction de start(), et correction de ESP0 dans TSS qui était définit à la mauvaise valeur.
    • Correction de bug où la fonction exit() n'était pas appelé lors d'une fin de fonction appelée par start.
  • Ajout de l'appel système current_clock().
  • A ce stade tous les tests passent sauf le test 8 et 18.
  • Le test 9 est très long pour une raison encore inconnue.

Vendredi 21 Juin 2019 (Phase 5 & 6)

  • En cours de la phase 5.
  • Les tests passent tous sauf le test8 et le test19.
  • Diverses corrections :
    • Correction de current_clock() et de la sauvegarde de DS.
    • Ajout d'un tampon dans la pile utilisateur pour ne pas provoquer un dépassement.
    • Libération des piles utilisateurs.
  • Le test 8 passe désormais.
  • Fin de la phase 5.
  • Début de la phase 6.
  • Gestion de claviers :
    • Création d'une structure tampon pour les tarminaux.
    • Ajout de l'appel système cons_read() coté utilisateur et noyau.
    • Début de l'écriture du traitant associé.
    • Ajout de l'état "en attente d'entrée-sortie clavier".
    • Ajout de la queue permettant de gérer cet état.
    • Ajout de la fonction keyboard_data().

Semaine 4

Lundi 24 Juin 2019 (Phase 6)

  • En cours de la phase 6.
  • Ajout de l'interruption clavier.
  • Gestion du tampon circulaire permettant la saisie/lecture clavier.
  • Gestion des caractères spéciaux (Espace, tabulation, suppression).
  • Fin de la phase 6.

Mardi 25 Juin 2019 (Phase 7)

  • Début de la phase 7 : gestion de shell
    • Ajout de l'appel système ps.
    • Ajout d'une tête et de la date du jour.
    • Ajout d'un parser de commandes basiques.
    • Refactorisation du code pour mettre en commun le code utilisateur et kernel.
    • Ajout d'appels systèmes pour gérer la couleur coté utilisateur.
  • Ajout de la commande PS.
  • Fin de la phase 7.

Apports & Difficultés rencontrées

Difficultés rencontrées

  • Reprise des connaissances de l'assembleur et de l'exécution de pile que nous avons étudié l'annéé dernière (Siwen).
  • Lecture du sujet au début, donc beaucoup trop de temps a été utilisé pour entrer dans le contexte (Siwen).
  • Compréhension de la spécification, il est difficile a comprendre ce qu'il est attendu au niveau du code (Siwen).

Apports

  • Approfondir nos connaissances en Système d'Exploitation.
  • Améliorer nos compétences en C et en Assembleur.

Ressources externes

Nous n'avons utilisé que Ensiwiki, donc il n'y a pas de ressources externes.

Démonstrations vidéo/photo