Canaux

Merci à Jacques Menu

Descripteur de Canal

• Un descripteur de canal d'entrée/sortie est représenté par un entier non-négatif qui correspond à un index dans la table des canaux ouverts par le processus.
• Trois descripteurs sont créés au lancement d'un processus:

  0	Entrée standard
  1	Sortie standard
  2	Erreur standard

Ouverture de canal

Table des canaux ouverts

Opérations sur les canaux

Les mêmes fonctions sont utilisés quelque soit le type de fichier (fichier de données, socket, pipe, périphériques, etc.):

Ouvrir un canal (open)

int open(const char *pathname, int flags, mode_t mode);

Flags

Les flags suivants peuvent être passés à la fonction open:

Mode (permissions)

Lorsque que le flag O_CREAT est passé, il faut spécifier les permissions:

int fd = open("/tmp/foo.txt", O_RDWR | O_CREAT | O_OEXCL, 0640);

Si O_CREAT est absent, le mode est ignoré.

Ouverture multiple

Fermer un canal (close)

int close(int fd);

Fermeture automatique d'un canal

• Lors de la terminaison d'un processus par exit ou abort, le noyau ferme tous les descripteurs (équivalent à close).
• Egalement lors d'un appel à execv() si le bit close-on-exec est égal à 1.

Manipulation des descripteurs (fcntl)

int fcntl(int fd, int cmd, ... /* arg */ );

Lecture: bas niveau (read)

ssize_t read(int fd, void *buf, size_t count);

Ecriture: bas niveau (write)

ssize_t write(int fd, void *buf, size_t count);

Exemple (examples/copy.c)

Include example there (see script)

Accès aléatoire (lseek)

off_t lseek(int fd, off_t offset, int whence);

Accès aléatoire (2)

La nouvelle position, dépend de whence et d'offset

Exemple (examples/seekStruct.c)

Include example there (see script)

Scénario

• Un fichier contient le montant disponible de comptes bancaires.
• Les comptes sont écrits séquentiellements

int withdraw( int fd, int account, unsigned int amount ) {
    unsigned int before = GET_AMOUNT( fd, account );
    unsigned int after;
    if( before < amount )
        return -1;
    after = before - amount;
    SET_AMOUNT( fd, account, after );
    return after;
}
                        

Problème

• Le compte #10 est crédité de 300 CHF.
• Les deux processus A et B sont exécutés en parallèle.
• A appelle:

  withdraw( accounts, 10, 200 )

• B appelle:

  withdraw( accounts, 10, 150 )

• Qu'est qui pourrait se passer ?

Verrous (locks)

• Les processus peuvent poser des verrous sur des fichiers pour se coordoner.

• Il y a deux types de stratégie:

  • verrouillage facultatif
  • verrouillage obligatoire

Verrouillage facultatif (advisory locks)

• Un verrou facultatif n'est pas pris en compte par les opérations de lecture/écriture.
• Le programmeur peut:
  • Poser un verrou
  • Vérifier si un verrou existe
  • Enlever un verrou
• Un verrou peut porter sur une partie d'un fichier
• Standard POSIX

Verrouillage obligatoire (mandatory locks)

Un verrou obligatoire bloque les opérations de lecture/écriture

Exemple verrou

int withdraw( int fd, int account, unsigned int amount ) {
    LOCK( fd, account );
    unsigned int before = GET_AMOUNT( fd, account );
    unsigned int after;
    if( before < amount )
        return -1;
    after = before - amount;
    SET_AMOUNT( fd, account, after );
    UNLOCK( fd, account );
    return after;
}
                        

Types de verrous

Structure d'un verrou (struct flock)

struct flock {
    ...
    short l_type;    /* Type of lock: F_RDLCK, F_WRLCK, F_UNLCK */
    short l_whence;  /* How to interpret l_start: SEEK_SET, SEEK_CUR, SEEK_END */
    off_t l_start;   /* Starting offset for lock */
    off_t l_len;     /* Number of bytes to lock */
    pid_t l_pid;     /* PID of process blocking our lock (F_GETLK only) */
    ...
};
                        

Type de verrous (constantes utilisées)

Position du verrou

Poser/Enlever un verrou (fcntl)

L'appel système suivant permet de poser/enlever les verrous:

int fcntl(int fd, int cmd, struct flock *lock);

• fd spécifie le descripteur du fichier.
• Le comportement varie selon la commande (cmd) utilisée
• Le pointeur lock permet de passer ou de recevoir les paramètres du verrou.

Commande F_SETLK

• La commande F_SETLK permet de poser/enlever un verrou.
• L'action dépend de lock->l_type:

  F_RDLCK	essaie de poser un verrou partagé
  F_WRLCK	essaie de poser un verrou exclusif
  F_UNLCK	enlève un verrou précédent

• Retourne immédiatement
• Si un conflit empêche de poser le verrou retourne -1 et produit les erreurs EACCES ou EAGAIN.

Commande F_SETLK: LOCK

int LOCK( int fd, int account ) {
    struct flock fl;
    fl.l_type = F_WRLCK;
    fl.l_whence = SEEK_SET;
    fl.l_start = account;
    fl.l_len = 1;
    if (fcntl(fd, F_SETLK, &fl) == -1) {
        if (errno == EACCES || errno == EAGAIN) {
            //Attendre ou faire autre chose
            return LOCK( fd, account );
        } else return -1;
    } else return 0;
}
                    

Commande F_SETLK: UNLOCK

int UNLOCK( int fd, int account ) {
    struct flock fl;
    fl.l_type = F_UNLCK;
    fl.l_whence = SEEK_SET;
    fl.l_start = account;
    fl.l_len = 1;
    return fcntl(fd, F_SETLK, &fl);
}
                    

Commande F_SETLKW

• La commande F_SETLKW permet de poser/enlever un verrou.
• L'action dépend de lock->l_type:

  F_RDLCK	essaie de poser un verrou partagé
  F_WRLCK	essaie de poser un verrou exclusif
  F_UNLCK	enlève un verrou précédent

• Attends en cas de conflit
• Si un signal est capturé l'appel se termine avec un retour de -1 et produit l'erreur EINTR.

Commande F_SETLKW: LOCK

int LOCK( int fd, int account ) {
    struct flock fl;
    fl.l_type = F_WRLCK;
    fl.l_whence = SEEK_SET;
    fl.l_start = account;
    fl.l_len = 1;
    return fcntl(fd, F_SETLKW, &fl);
}
                    

Commande F_GETLK

• La commande F_GETLK permet d'obtenir des informations sur un verrou.
• La structure *lock doit être remplie avec les informations concernant un verrou que l'on souhaite poser.
• Elle est modifiée après l'appel:
  • Si le verrou peut être placé, lock->l_type vaut F_UNLCK
  • Si le verrou ne peut être placé, *lock contient des informations sur un des verrous déjà en place.
• Elle retourne immédiatement.

Problèmes possibles

Lock files

• Approche alternative: représenter les verrous comme des fichiers
• On peut utiliser open avec les flags O_CREAT|O_EXCL.
• Il ne faut pas oublier des les enlever.
• Survit à la terminaison du processus.

Lock files: Exemple

#define LOCK_FILE ".lock"

int LOCK() {
    int fd = open( LOCK_FILE, (O_CREAT|O_EXCL), 0600 );
    if( fd < 0 && errno == EEXIST ) {
        //ATTENDRE
        return LOCK();
    }
    return fd;
}

int UNLOCK( int fd ) {
    close(fd);
    return unlink(LOCK_FILE);
}
                    

Fichiers temporaires (temporary files)

• Un programme peut utiliser des fichier temporaires, par exemple pour:
  • Soulager la mémoire vive
  • Téléchargement partiel
  • Communication entre processus

Créer et ouvrir un fichier temporaire (mkstemp)

int mkstemp(char *template);

Exemple mkstemp

char name[15] = "";
int fd = -1;
strncpy( name, "/tmp/ed.XXXXXX", sizeof name );
fd = mkstemp( name );
if( fd < 0 ) {
    //Gerer l'erreur
}
else {
    printf( "The temporaray filename is %s\n", name );
}
                    

Effacer automatiquement

• Rappel:
  • unlink n'efface pas un fichier, seulement son nom
  • Le fichier est effacé s'il n'y a pas de descripteur ouvert.
• On peut alors immédiatement appeler unlink sur un fichier temporaire créé.
• Le processus peut toujours interragir avec le fichier via le descripteur.
• A la fermeture du descripteur (ou à la terminaison du processus) le fichier est effacé.
• Aucun autre processus ne peut y accéder.

Exemple mkstemp/unlink/link (pseudocode)

int fd = mkstemp( name );
unlink( fd );           // Enleve le nom
DOWNLOAD_INTO( fd );
PLAY_WITH( fd );
close( downloadFD );    // Efface les donnees
                    

Répertoires temporaires (mkdtemp)

char *mkdtemp(char *template);