exo_05 effacement -- unlink() -- d'un fichier pendant l'accès

Dans cet exercice

Que se passe-t-il ?

• dans un des xterms, faire less ~/Test.txt et le laisser comme ça, au milieu du fichier
• dans l'autre xterm, lister le fichier avec ls -l, puis l'effacer avec rm, ressayer de le lister et voir qu'il n'y est plus, et
• revenir à l'xterm avec le less et continuer à faire défiler le fichier comme si de rien n'était.

Qu'y a-t-il à faire, alors, dans cet exercice ?

1. Wrapper de unlink()
2. Essais d' effacement d'un fichier et tests d'accès après destruction

Travail à faire

exo_06 2. Émulation partielle de la commande ls -la sur un répertoire

Dans cet exercice

drwx    4096    .
drwx    4096    ..
-rw-    645     Makefile
-rw-    1016    exo_06.h
-rw-    1489    exo_06.cxx
-rw-    28704   exo_06.o
drwx    4096    sousRepertoire
-rwx    17440   exo_06.run
lrwx    10      lienSymbolique
.rw-    0       ceciEstBienUnePipe

Quoi de neuf

• opendir() -- pour ouvrir un répertoire, accessible ensuite par le biais d'un pointeur vers DIR -- un "directory stream" (wrapper OpenDir()).
• readdir() -- pour parcourir un répertoire ainsi ouvert, élément par élément (un par appel, avance "toute seule" d'un appel à l'autre). Rend un pointeur vers une structure dirent, dont le membre d_name contient le nom de l'élement courant du répertoire. Rend le pointeur nul à la fin du parcours. Il faut donc l'appeler de manière répétée pour obtenir tous les éléments (wrapper ReadDir()).

   struct dirent {
               ino_t          d_ino;      /* numero d'inoeud */
               off_t          d_off;      /* decalage jusqu'a la dirent suivante */
               unsigned short d_reclen;   /* longueur de cet enregistrement */
               unsigned char  d_type;     /* type du fichier */
               char           d_name[256];/* nom du fichier */
   };

• closedir() -- pour fermer le DIR (wrapper CloseDir()).
• lstat() -- même chose que stat(), mais sans poursuivre les liens symboliques
• tests, où mode est la valeur du champ st_mode d'une struct stat remplie par lstat()
• macros
• S_ISDIR(mode) -- vrai s'il s'agit d'un répertoire
• S_ISREG(mode) -- vrai s'il s'agit d'un fichier normal
• masques -- à tester avec le ET binaire
• S_IFLNK & mode -- vrai s'il s'agit d'un lien symbolique
• S_IRUSR & mode -- vrai si le propriétaire a le droit de lire
• S_IWUSR & mode -- vrai si le propriétaire a le droit d'écriture
• S_IXUSR & mode -- vrai si le propriétaire a le droit d'exécution

Travail à faire

• Écrivez des wrappers (déclaration et définition inline) dans nsSysteme.h, selon les indications suivantes.
  • pour lstat(), chdir() et closedir() un simple test (non-zéro) de la valeur de retour de la fonction système suffit pour détecter l'erreur et lever l'exception, tout comme pour Stat().
  • pour opendir() l'erreur survient lors d'un pointeur rendu nul par son appel. Détecter l'erreur et lever l'exception, mais n'oubliez pas de renvoyer l'information utile s'il n'y a pas d'erreur.
  • pour readdir(), l'erreur survient lors d'un pointeur nul ET lorsque errno n'est pas nulle. Suivez ces pas :
    1. errno prend la valeur 0
    2. on déclare et définit un ddirent * pEntry récupérant le résultat de l'appel de readdir()
    3. si pEntry est nul et errno n'est pas nulle, alors lever l'exception
    4. rendre pEntry
  Pourquoi ces complications pour ReadDir() par rapport à OpenDir() ?
  Car un pointeur rendu nul par readdir() signifie soit une erreur, soit la fin du parcours du répertoire sans erreur. C'est donc errno qui permet de distinguer ces deux cas. De plus, comme errno est une variable globale, assignable n'importe où, il faut la mettre à zéro dans le wrapper avant l'appel de readdir(). Pourquoi ? Puisqu'on ne sait pas quel autre appel système précédent a pu échouer, mais sans terminer fatalement le programme. On aurait ainsi une errno "sale", et il faut donc la nettoyer dans ce cas.
  Enfin, le cas de fin de parcours, sans erreur, est à gérer par l'utilisateur du wrapper, qui peut donc ainsi rendre un pointeur nul sans lever d'exception dans ce cas-là.
  
• Écrivez le main() qui prend un seul argument -- le chemin du répertoire, et qui énumère son contenu comme illustré et expliqué plus haut, à l'aide des wrappers de ces outils. Les pas à faire sont les suivants :
  • ouverture du répertoire avec OpenDir(), récupérant le pointeur pDir vers un DIR
  • changement de répertoire courant avec ChDir()(pour simplifier l'appel de lstat() -- chemin relatif "immédiat")
  • tant qu'il y a encore des entrées à lire dans le répertoire pDir faire
  • retrouvez la nouvelle pEntry avec ReadDir()
  • obtenez la taille et le type de pEntry à l'aide d'une variable S de type structure stat en utilisant Lstat()
  • Attention: Lstat() a besoin du nom de fichier, tandis que pEntry renvoie un pointeur envers une struct dirent
  • affichez le type et les droits de l'entrée courante en utilisant les macros (par exemple S_ISDIR, S_IRUSR)
  • affichez la taille et puis le nom lui-même
  • fin de boucle tant que
  • fermer le DIR avec CloseDir()
• QUESTION: Écrivez sur une feuille à rendre le resultat de l'exécution pour ../include

OPTIONNEL exo_07 accès concurrent en lecture, respectivement lecture/écriture

Dans cet exercice

• écrit des caractères un par un dans un fichier, ou bien
• lit des caractères un par un depuis un fichier

• les lectures n'interfèrent en rien
• les écritures interfèrent, en s'écrasant l'une l'autre (la dernière dans le temps "gagne")
• une écriture est tout de suite visible chez tous les lecteurs

1. On finit le programme pour les essais
2. On fait les essais lectures concurrentes
3. On fait les essais écritures concurrentes
4. On fait les essais lectures/écritures concurrentes

exo_07 1. Programme

Dans cet exercice

• on finit le programme capable d'écrire respectivement de lire des fichiers, de manière temporisée

Comment ça marche

• soit lire <combienALaFois> <delaiInitial> <delai> <nomFic>
• soit ecrire <1erChar> <combienAuTotal> <delaiFinal> <delaiInitial> <delai> <nomFic>

Travail à faire

exo_07 2. Essais écritures concurrentes

Dans cet exercice

Travail à faire

• Comme au point précédent, munissez-vous de deux terminaux (visibles simultanément), et dans un des deux, lancez

  exo_07.run ecrire a 3 2 3 2  exo_07p2.txt
  

  et dans l'autre, lancez

  exo_07.run ecrire  A 3 3 0 4 exo_07p2.txt
  

• QUESTION: Écrivez sur une feuille à rendre à votre enseignant le chronogramme de l'exécution des deux processus, c'est-à-dire le déroulement dans le temps de chaque écriture. Il faut donc faire un tableau avec autant de colonnes que de secondes écoulées et une ligne par processus, avec ce qu'ils auront écrit et au bon moment.
Exemple de chronogramme

temps	0	1	2	3	4
processus 1		A		B	F
processus 2	a	b	c		F

Ici F représente la fermeture du fichier L'opération d'écriture prend un temps négligeable ici, donc il faut compter toutes les cases.

exo_07 3. Essais lectures/écritures concurrentes

Dans cet exercice

Travail à faire

• Créez un fichier exo_07p3.txt qui doit contenir les 26 lettres de l'alphabet.
• Lancez le processus 1 avec les paramètres lire 5 0 4 exo_07p3.txt et en même temps le processus 2 avec les paramètres ecrire 1 7 0 1 0 exo_07p3.txt . On constate que les modifications effectuées par le processus 2 sont immédiatement visibles par le processus 1. Le processus 1 lit en une seule fois les cinq premiers caractères, puis il attend deux secondes, et puis il recommence. Le processus 2 attend une seconde, et écrit les caractères 1 2 3 4 5 6 7 dans le fichier. Donc le processus 1 lit d'abord les lettres, mais à sa deuxième itération il ne peut plus lire que deux caractères, lesquels sont déjà des chiffres.

Solutions