Projet de Systèmes (Licence 2004-2005)
Soutenances: elles auront lieu mercredi 2 et vendredi 4 février 2005 (choisir un horaire auprès du secrétariat). Le rapport sera à remettre le jour de la soutenance.
Simuler les différentes couches d'un système de fichier permettant par abstraction successives d'obtenir à la fois des performances raisonnables et des abstractions suffisamment puissantes pour permettre d'écrire des applications portables.
Le système de fichier d'Unix sera utilisé comme support physique du simulateur: les entrées-sorties du simulateur s'effectueront effectivement dans un (ou plusieurs) fichier(s) Unix. La structure des données constituant le fichier sera alors la suivante: le fichier sera constitué de bloc de 128 octets. Ces blocs de 128 octets constitueront l'unité primitive d'entrée-sortie: aucune lecture ou écriture dans ce fichier ne s'effectuera autrement que par paquet de 128 octets; ces mêmes paquets étant forcément placés à des positions multiples de 128.
On devra alors écrire une bibliothèque d'accès à ce support physique contenant des fonctions comme: error_t read_pblock(pblocknum_t num,pblock_t *block);, error_t write_pblock(pblocknum_t num,pblock_t *block); ou encore error_t start_disk()...
Aucune des fonctions de ce niveau ne sont censées être utilisables directement par les applications.
Afin d'obtenir des performances accrues le système conservera dans un système de caches une copie des blocs disques les plus demandés afin d'éviter d'avoir à les relire ou écrire physiquement trop souvent (pour vérifier l'efficacité d'un tel cache on pourra artificiellement ralentir les fonctions de la couche physique en employant la fonction Posix sleep()). D'autre part l'abstraction manipulée à ce niveau sera le bloc de 256 octets.
Le système de caches s'appuiera pour fonctionner sur l'interface définie au niveau précédent (physique). Les fonctions d'accès à cette couche pourront être: error_t read_sblock(sblocknum_t num,sblock_t *block);, error_t write_sblock(sblocknum_t num,sblock_t *block);, etc.
Aucune des fonctions de ce niveau ne devront être directement utilisées par les applications.
Cette couche devra construire toutes les abstractions constituant un système de fichiers: manipulation des fichiers et répertoires à travers un ensemble de fonctions à définir et qui seront disponibles aux applications.
Le disque logique (disque comme vu à ce niveau) sera constitué basiquement de blocs logiques de 256 octets. Le disque sera partitionné en trois ensembles de blocs:
La structure physique de fichier sera la suivante:
| nom du champ | taille | sémantique |
|---|---|---|
| protect | 1 | droits d'accès: combinaison de 1 pour la lecture autorisée, 2 pour l'écriture autorisée. |
| type | 1 | type du fichier: 0 pour les fichiers ordinaires,1 pour les répertoires. |
| size | 2 | taille du fichier (en octets) exprimée sur deux octets et codée en big-endian. |
| data | 20 | numéros des blocs de données constituant le fichier. Ces octets seront interprétés comme un tableau de 10 entiers big-endian. |
| state | 2 | état du fichier: 0 libre, 1 occupé (ie: possède un lien dans un répertoire). |
| links | 2 | en représentation big-endian: nombre de liens. |
| reserved | 4 | à usage futur |
Le fichier de numéro 0 sera toujours alloué et de type répertoire: il sera considéré comme la racine du système de fichiers.
Les fichiers de type répertoire seront constitués d'une liste d'entrées de répertoire ayant la structure suivante:
| nom du champ | taille | sémantique |
|---|---|---|
| filenum | 2 | en big-endian: numéro du fichier correspondant. | filename | 30 | chaîne de caractères (terminée par le caractère ASCII nul et ne contenant pas le caractère '/') utilisée comme nom de lien. |
Cette couche fournira aux applications des fonctions comme open(), readdir(), stat(), etc.
Pour faciliter l'écriture de ces dernières il sera sans doute utile d'écrire des fonctions utilitaires (non disponibles aux applications) comme: filenum_t reftonum(const char *ref); (permettant d'obtenir à partir d'une référence le numéro du fichier correspondant), etc.
Il sera nécessaire de construire une application particulière de nom format permettant de construire un disque logique vide (prêt à l'emploi). Cette application sera la seule autorisée à utiliser éventuellement des fonctions de très bas-niveau (en effet pour fabriquer un système de fichier on ne peut utiliser des fonctions supposant l'existence de ce même système de fichiers).
On pourra écrire différentes petites applications utilisant l'interface définie précédemment et réalisant des commandes similaires aux commandes d'Unix suivantes: ls, mkdir, rmdir, cat, cp, ln, etc.
Il sera sans doute nécessaire de construire des commandes permettant de créer des fichiers voire d'y écrire des données.
Le projet devra être obligatoirement réalisé en langage C, sous Unix et devra nécessairement s'exécuter sur l'une des machines de l'UFR. La réalisation pourra être effectuée par groupe de trois étudiants au plus.
Le projet fera l'objet d'une soutenance dont la date est encore à déterminée (vraisemblablement fin Janvier 2005, restez à l'écoute!). Un rapport sera à remettre avant la soutenance et décrivant/motivant les différents choix ayant pu être faits lors de la réalisation. Cette soutenance permettra d'évaluer non seulement le projet lui-même mais aussi la capacité des étudiants à défendre leurs choix.