tubes.c

Aller à la documentation de ce fichier.

 
#include <manux/tubes.h>
#include <manux/debug.h>
#include <manux/tache.h>    // tacheAjouterFichiers
#include <manux/scheduler.h>// tacheEnCours
#include <manux/fichier.h>
#include <manux/errno.h>    // ESUCCES
#include <manux/memoire.h>  // NULL
#include <manux/kmalloc.h>  // NULL
#include <manux/string.h>   // memcpy
#include <manux/exclusion-mutuelle.h> 
#include <manux/condition.h> 
 
MethodesFichier tubeMethodesFichier;
 
#define MANUX_TUBE_NB_PAGES 1
 
#define MANUX_TUBE_CAPACITE (MANUX_TAILLE_PAGE * MANUX_TUBE_NB_PAGES)
 
#define MIN(a, b) (((a) < (b)) ? (a) : (b))
 
typedef struct _tube {
   uint8_t * donnees;   //< Pointeur sur la zone de données
   uint32_t  taille;          //< Nombre d'octets présents dans le tube
   uint32_t  indiceProchain ; //< Position de la prochaine insertion
 
   int nbEcrivains;
   int nbLecteurs;
  
   ExclusionMutuelle exclusionMutuelle;
   Condition         nouvellesDonnees;
} Tube;
 
static
int tubeOuvrir(INoeud * iNoeud, Fichier * f, uint16_t fanions, uint16_t mode)
{
   Tube * tube = (Tube *) f->iNoeud->prive;
   (void)iNoeud;
   (void)mode;
   
   exclusionMutuelleEntrer(&(tube->exclusionMutuelle));
 
   if (fanions & O_RDONLY) {
      tube->nbLecteurs++;
   }
   if (fanions & O_WRONLY) {
      tube->nbEcrivains++;
   }
 
   exclusionMutuelleSortir(&(tube->exclusionMutuelle));
 
   f->prive = NULL;
 
   return ESUCCES;
}
 
static
int tubeFermer(Fichier * f)
{
 
   printk_debug(DBG_KERNEL_TUBE, "in\n");
   Tube * tube = (Tube *) f->iNoeud->prive;
   
   exclusionMutuelleEntrer(&(tube->exclusionMutuelle));
 
   printk_debug(DBG_KERNEL_TUBE, "mutex locked\n");
   
   if (f->fanions & O_RDONLY) {
      tube->nbLecteurs--;
   }
   if (f->fanions & O_WRONLY) {
      tube->nbEcrivains--;
      if (tube->nbEcrivains == 0) {
         conditionDiffuser(&(tube->nouvellesDonnees));
      }
   }
 
   exclusionMutuelleSortir(&(tube->exclusionMutuelle));
 
   return ESUCCES;
}
 
static
size_t tubeEcrire(Fichier * f, void * buffer, size_t nbOctets)
{
   Tube *   tube;
   uint32_t n = 0;
   uint32_t nbOctetsEcrits = 0; // Le nombre d'octets déja écrits
 
   printk_debug(DBG_KERNEL_TUBE, "in\n");
   
   // Peut-on décemment écrire dans le tube ?
   if ((f == NULL) || (f->iNoeud == NULL) || (f->iNoeud->prive == NULL)) {
      return -EINVAL;
   }
   tube = f->iNoeud->prive;
 
   exclusionMutuelleEntrer(&(tube->exclusionMutuelle));
   
   // On fait une boucle, car il est possible que l'on doive écrire en
   // deux fois si on est proche de la fin du tableau qui contient les
   // données.
   do {
      // On n'écrit ni plus que ce qui est demandé, ni plus que ce
      // qu'on peut
      n = MIN(nbOctets - nbOctetsEcrits, MANUX_TUBE_CAPACITE - tube->taille);
 
      // On ne doit pas aller écrire au delà du buffer
      n = MIN(n, (MANUX_TUBE_CAPACITE - tube->indiceProchain));
 
      // On peut donc copier n octets dans le buffer à partir de la
      // position courante, sans risque de déborder
      memcpy(tube->donnees + tube->indiceProchain, buffer, n);
 
      ordonnanceur(); // Pour forcer
      
      tube->indiceProchain = (tube->indiceProchain + n) % MANUX_TUBE_CAPACITE;
      tube->taille += n;
      
      buffer += n;
 
      nbOctetsEcrits += n;
   } while (n > 0);
 
   if (nbOctetsEcrits > 0) {
      conditionSignaler(&(tube->nouvellesDonnees));
   }
   
   exclusionMutuelleSortir(&(tube->exclusionMutuelle));
 
   printk_debug(DBG_KERNEL_TUBE, "out\n");
 
   return nbOctetsEcrits;  
}
 
static
size_t tubeLire(Fichier * f, void * buffer, size_t nbOctets)
{
   Tube * tube;
   int n = 0;
   int nbOctetsLus = 0;
   int indicePremier;
   
   printk_debug(DBG_KERNEL_TUBE, "in\n");
 
   // Peut-on décemment lire dans le tube ? (note : les deux premières
   // conditions sont assurées par l'appelant (fichierLire) a priori
   if ((f == NULL) || (f->iNoeud == NULL) || (f->iNoeud->prive == NULL)) {
      return -EINVAL;
   }
   tube = f->iNoeud->prive;
 
   exclusionMutuelleEntrer(&(tube->exclusionMutuelle));
   printk_debug(DBG_KERNEL_TUBE, "mutex locked\n");
 
   // En cas de lecture bloquante, j'attends la dispo des données ou
   // la disparition du dernier écrivain
   if ((f->fanions & O_NONBLOCK) == 0) {
      while ((tube->taille == 0) && (tube->nbEcrivains > 0)) {
        printk_debug(DBG_KERNEL_TUBE, "attente condition\n");
        conditionAttendre(&(tube->nouvellesDonnees), &(tube->exclusionMutuelle));
      }
   }
   // Je sais maintenant qu'il y a des données, ou alors qu'il n'y en
   // aura plus jamais, ou alors je suis en non bloquant, bref, je
   // peux y aller et faire comme si, ...
   
   do {
      // A partir de quel octet peut-on lire ?
      indicePremier = (tube->indiceProchain + MANUX_TUBE_CAPACITE - tube->taille)
    %MANUX_TUBE_CAPACITE;
 
      // On ne lit ni plus que ce qui est demandé, ni plus que ce
      // qu'on a
      n = MIN(nbOctets - nbOctetsLus, tube->taille);
      
      // On ne doit pas aller lire au delà du buffer
      n = MIN(n, (MANUX_TUBE_CAPACITE - indicePremier));
 
      printk_debug(DBG_KERNEL_TUBE,"Je vais lire %d\n", n);
      
      // On peut donc copier n octets dans le buffer à partir de la
      // position courante, sans risque de déborder
      memcpy(buffer, tube->donnees + indicePremier, n);
 
      ordonnanceur(); // Pour forcer
      
      indicePremier = (indicePremier + n) % MANUX_TUBE_CAPACITE;
      tube->taille -= n;
      
      buffer += n;
 
      nbOctetsLus += n;
   } while (n > 0);
 
   exclusionMutuelleSortir(&(tube->exclusionMutuelle));
 
   printk_debug(DBG_KERNEL_TUBE, "out\n");
 
   return nbOctetsLus;  
}
 
MethodesFichier tubeMethodesFichier = {
   .ouvrir = tubeOuvrir,
   .fermer = tubeFermer,
   .ecrire = tubeEcrire,
   .lire = tubeLire
};
 
#ifdef MANUX_APPELS_SYSTEME
int sys_tube(ParametreAS as, int * fds)
{
   INoeud  * iNoeud;
   Fichier * fichiers[2];
   Tube    * tube;
   (void) as;
   
   printk_debug(DBG_KERNEL_TUBE, "Creation d'un tube (lire = 0x%x) ...\n", tubeLire);
 
   // Création de la structure
   tube = kmalloc(sizeof(Tube));
   if (tube == NULL) {
      return ENOMEM;
   }
     
   // Alocation de la mémoire tampon du tube
   if ((tube->donnees = allouerPage()) == NULL) {
      return ENOMEM;
   }
 
   // Initialisation des compteurs
   tube->taille = 0;
   tube->indiceProchain = 0;
 
   // L'exclusion mutuelle qui le protègera
   exclusionMutuelleInitialiser((&(tube->exclusionMutuelle)));
   conditionInitialiser((&(tube->nouvellesDonnees)));
   
   // Création de l'iNoeud qui décrit le tube dans le système
   iNoeud = iNoeudCreer(tube, &tubeMethodesFichier);
 
   // Création du fichier de sortie du tube (celui où on va lire)
   fichiers[0] = fichierCreer(iNoeud, O_RDONLY, 0);
 
   // Création du fichier d'entrée du tube (celui où on va écrire)
   fichiers[1] = fichierCreer(iNoeud, O_WRONLY, 0);
 
   // On ajoute les fichiers à la tâche
   if (tacheAjouterFichiers(tacheEnCours, 2, fichiers, fds) != 2 ) {
      return ENOMEM;
   }
 
   printk_debug(DBG_KERNEL_TUBE, "Tube cree entre %d et %d\n", fds[0], fds[1]);
 
   // Si on est encore là, c'est que tout s'est déroulé comme prévu !
   return ESUCCES;
}
#endif