Initiation à la Programmation

Système
Chapitre : Les Systèmes de Gestion
des Fichiers (SGF)
 Fichiers
• Un fichier est une entité sur laquelle on peut réaliser
certaines opérations, typiquement lecture et écriture.
– Fichiers sur disque, contenant une séquence d’octets,
– Périphériques physiques : bandes magnétiques, terminaux,
imprimante,...
• POSIX.1 définit plusieurs types de fichiers
– fichiers normaux,
– répertoires,
– tubes,
– fichiers en mode bloc,
– fichiers en mode caractère.
– lien symbolique (pas POSIX 1003.1, mais POSIX 1003.1-2001).
 Le système de fichiers
• Un périphérique tel qu’un disque peut être vu
comme une succession ordonnée de blocs.
• Le système doit donner à l’utilisateur une vue
arborescente,
– avec des répertoires,
– la possibilité de nommer (référencer) un fichier,
– la possibilité de protéger ses données envers les
autres utilisateurs (en lecture, en écriture ou en
exécution), etc.
• Pour cela, à chaque fichier est associé une
structure appelée i-nœud.
 Système de gestion des fichiers (SGF)
• Chaque fichier dans l’arborescence est identifié par
– le système de fichiers sur lequel il réside,
– un identifiant unique sur ce système, appelé i-nœud.
• On peut greffer la racine d’un système de fichier dans un
autre (mount).
• Un i-nœud contient des informations sur le fichier et ses
premiers blocs.
• Pour les autres blocs, on utilise des blocs d’indirection.
– simple,
– double,
– triple.
• Note : Le nom de fichier (qui ne doit pas contenir / ou le
caractère nul) n’est pas stocké dans le i-nœud.
Système de gestion des fichiers (SGF)
 Les entrées-sorties
• Les lectures/écritures sont appelées entrées/sorties.
• Une entrée/sortie provoque une interruption. Le processus
appelant est mis en attente (sommeil) le temps que sa
demande soit traitée.
• Pour accélérer les entrées sorties, les systémes utilisent un
mécanisme de cache : lorsqu’un processus fait une écriture,
elle est réalisée en RAM et non sur le périphérique réel,
dans une zone appelée buffer cache.
• Le buffer cache est périodiquement synchronisé avec le
périphérique.
• Ce mécanisme est transparent pour le programmeur, à part
qu’au retour d’une écriture, les données ne sont pas
nécessairement écrites sur le périphérique.
 Descripteurs
• Un descripteur obtenu par un processus lui est propre.
• Il donne au processus le droit d’accès à une entrée
dans une « table des fichiers ouverts » (TFO).
• Un même fichier peut être ouvert plusieurs fois (dans
des modes éventuellement différents) par un ou
plusieurs processus.
• 3 descripteurs spéciaux :
– STDIN_FILENO, entrée standard,
– STDOUT_FILENO, sortie standard,
– STDERR_FILENO, sortie erreur standard.
 Ouverture d’un fichier
• L’ouverture d’un fichier par un processus est demandée par l’appel
# include <sys/ stat.h> // pour le mode d’ouverture.
# include <fcntl.h>
int open(const char *path , int flag , ... /* mode */ );
• 1er argument : chemin d’accès au fichier.
• 2ème argument : mode d’ouverture. OU bit à bit contenant
– l’une des constantes O_RDONLY, O_WRONLY, O_RDWR.
– des options supplémentaires parmi
• O_APPEND les écritures se feront en fin de fichier,
• O_CREAT création du fichier s’il n’existe pas,
• O_TRUNC tronque le fichier s’il existe,
• O_EXCL échec si création demandée et le fichier existe,
• O_SYNC attente que l’écriture soit réalisée physiquement.
• +···
• 3ème argument optionnel : mode de création (modifié par
l’umask).
Ouverture : structures mises en jeu
• En cas de succès, open renvoie un descripteur entre 0 et
OPEN_MAX.
• Cet entier identifie l’ouverture du fichier par le processus.
• Il permet au noyau d’accéder à une entrée de la TFO
précisant
– le mode d’ouverture du fichier,
– le nombre de descripteurs pointant sur l’entrée.
– le décalage du curseur de lecture/écriture par rapport au début
(offset),
– un pointeur vers un i-nœud en mémoire.
• Un i-nœud est une structure maintenue par le système.
• Cette structure contient des informations sur le fichier
(propriétaire, droits, etc.) et le moyen d’accéder aux
données.
Ouverture : structures mises en jeu
 Ouverture d’un fichier
L’ouverture d’un fichier par open() provoque
1. l’allocation d’un descripteur de fichier.
2. l’allocation d’une entrée dans la table des fichiers ouverts (TFO).
3. l’allocation éventuelle d’une entrée dans la table des v-nœuds, avec
récupération du i-nœud sur disque s’il n’est pas dans le cache.
4. les vérifications de droits d’accès au fichier selon le mode demandé.
5. le rejet éventuel d’opérations illégales (ouverture d’un répertoire, ou
ouverture en écriture d’un exécutable ouvert en cours d’exécution).
6. la création éventuelle du fichier s’il n’existe pas et O_CREAT est
demandé.
7. si le fichier régulier existe et peut être ouvert en mode écriture ou
lecture-écriture, et si O_TRUNC est demandé, le fichier est tronqué
libération éventuelle des blocs.
8. l’initialisation du fichier ouvert (offset, pointeur sur v-nœud, mode
d’ouverture et compteur de références).
 Fermeture d’un fichier
• Lorsqu’un processus a fini d’utiliser un fichier, il utilise
# include <unistd .h>
int close(int descr );
• L’appel désalloue
– le descripteur,
– éventuellement l’entrée de la TFO si le compte de descripteurs
pointant sur l’entrée passe à 0,
– éventuellement l’i-nœud en mémoire si le nombre d’ouvertures
passe à 0,
– éventuellement les blocs du fichier si le nombre de liens et le
nombre d’ouvertures est 0.
• Un processus qui se termine ferme implicitement tous ses
descripteurs.
• Dans certains cas il est crucial de ne pas oublier close().
 Lecture
• La lecture sur un fichier peut se faire par la fonction
# include <unistd.h>
ssize_t read(int descr , void *buf , size_t nbytes );
• Lecture via le descripteur descr de nbytes octets, à placer
dans buf.
– 1. Lecture à partir de la position (offset) correspondante dans la
TFO.
– 2. Avancement du curseur du nombre d’octets lus,
• Lecture atomique : ce qui est lu n’est pas entrelacé avec
une autre E/S.
• Retourne le nombre d’octets effectivement lus.
• read renvoie donc moins que nbytes si la fin de fichier est
atteinte.
 Écriture
• L’écriture dans un fichier par la fonction
ssize_t write( int desc , const void *buf , size_t nbytes );
• demande l’écriture des nbytes premiers octets de buf via
descr.
– à partir de la position courante,
– avec écrasement des anciennes données (n’insère pas) ou
– extension du fichier si la fin est rencontrée.
• Retourne le nombre d’octets effectivement écrits.
• Un retour inférieur à nb peut se produire.
• Remarque : on peut écrire des données autres que chaînes
(codages d’entiers, structures, etc.). Attention au codage
(big/little endian, alignement).
 Tête (ou curseur) de lecture/écriture
• Pour lire ou écrire dans un fichier, tout se
passe comme si on avait une « tête (ou
curseur) de lecture-écriture ».
• La tête sera déplacée automatiquement à
chaque lecture ou écriture (tout se passe
comme sur une bande magnétique).
 Déplacement du curseur de
lecture/écriture
• Le curseur de lecture et/ou écriture est associé à un
fichier ouvert.
• Un même fichier peut être ouvert plusieurs fois, avec
des curseurs à des places différentes.
• La position du curseur est mémorisée par un entier > 0
dans l’entrée de la TFO.
• À l’ouverture, il est positionné à :
– la taille du fichier en mode O_APPEND;
– 0 sinon.
• Sur les fichiers ordinaires, on peut demander un
déplacement du curseur.
– Ce n’est pas possible sur tout fichier (ex. terminal).
 Déplacement du curseur de
lecture/écriture
• Pour déplacer, si possible, le curseur associé à un
descripteur descr :
# include <unistd.h>
off_t lseek( int descr , off_t offset, int whence );
• Si whence vaut
– SEEK_SET, déplacement 2 ème argument > 0 relatif au début de
fichier.
– SEEK_CUR, déplacement 2 ème argument relatif à la position
courante.
– SEEK_END, déplacement 2 ème argument relatif à la fin de
fichier.
• L’appel retourne la nouvelle position.
• On peut positionner le curseur après la fin de fichier.
 Duplications et redirections
• L’objectif de la TFO est de créer une indirection, pour
permettre à plusieurs processus de partager le même curseur.
• Plusieurs moyens de créer ce partage.
– Quand un processus en crée un autre, il lui « transmet » ses
descripteurs.
– On peut demander explicitement de dupliquer un descripteur par
dup2.
int dup2(int old_descr , int new_descr);
• old_descr doit correspondre à un descripteur ouvert.
• La fonction
– 1. ferme le descripteur new_descr s’il est ouvert,
– 2. le fait pointer vers la même entrée de la TFO que old_descr.
– 3. retourne la valeur de new_descr (−1 si erreur).
• Les appels dup et fcntl permettent aussi de dupliquer.
 Exemple

#include<stdio.h>
#include <fcntl.h>
int main()
{
int sz;
int fd = open("[Link]", O_WRONLY | O_CREAT | O_TRUNC,
0644);
sz = write(fd, "hello ifoad\n", strlen("hello ifoad\n"));
close(fd);
}
 Exemple

#include<stdio.h>
#include <fcntl.h>
int main()
{
int fd, sz;
char *c = (char *) calloc(100, sizeof(char));
fd = open("[Link]", O_RDONLY);
sz = read(fd, c, 10);
c[sz] = '\0';
printf("Those bytes are as follows: % s\n", c);
}
 Exemple
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
int main(void) {
int number1, number2, sum;
int input_fds = open("[Link]", O_RDONLY);
dup2(input_fds, STDIN_FILENO) ;
scanf("%d %d", &number1, &number2);
sum = number1 + number2;
printf("%d + %d = %d\n", number1, number2, sum);
return EXIT_SUCCESS;
}

$echo 13 24 >> [Link]