Appels système – System calls

Fonction syscall

long syscall(long number, ...)

Fonction syscall: exemple

#include <unistd.h>
#include <sys/syscall.h>
#include <sys/types.h>
#include <signal.h>

int main() {
    pid_t pid;
    pid = syscall(SYS_getpid);
    syscall(SYS_kill, pid, SIGHUP);
}

Fonctions "wrapper"

#include <unistd.h>
#include <sys/types.h>
#include <signal.h>

int main(int argc, char *argv[]) {
    pid_t pid;
    pid = getpid();
    kill( pid, SIGHUP);
}

Librairies de plus haut niveau

Les appels système sont souvent utilisés au travers de librairies de plus haut niveau

// Appel systeme Posix
int open(const char *pathname, int flags, mode_t mode);


// Fonction ANSI-C
FILE *fopen(const char *path, const char *mode);

Types opaques

Les types utilisés peuvent être opaques

// Type temps
typedef /* unspecified */ time_t;

// Retourne l'heure/date actuelle
time_t now = time( NULL );

// Retourne une representation textuelle
char* str = ctime( &now );

                            typedef /* still not specified */ FILE;
                            FILE *f = fopen(/tmp/costs, "w");
                            fprintf(f, "Le cout est: %d CHF", cost);
                        

Types opaques - organisation

Les types opaques sont des structures de données (i.e. typedef) qui ne sont pas définies dans l’interface (i.e. fichier header). Cela permet:

• cacher les détails l’implémentation -> abstraction;
• de modifier la structure de donnée sans modifier le comportement du code utilisateur.

                                typedef struct el* listeChainee;

                                listeChainee initListeChaineeVide();
                                void addListe(listeChainee* liste, void* contenu);
                                void* removeListe(listeChainee *liste);
                            

                                #include "listeChainee.h"

                                /* Declaration dans le .c pour
                                une utilisation privée */
                                typedef struct el {
                                    struct el *suivant;
                                    void* contenu;
                                } element;

                                listeChainee initListeChaineeVide() {
                                    return NULL;
                                }
                            

Problème

On aimerait représenter des personnes par la structure suivante:

Implémentation

struct person {
    char *name;
    int age;
    int isMarried;
    int hasChildren;
    int canDrive;
    int speaksEnglish;
};

typedef struct person person_t;

Sélectionner une pesonne selon des critères

int match( const person_t *p, int isMarried, int hasChildren, int canDrive,
  int speaksEnglish ) {
    if( isMarried && ! p->isMarried ) {
        return 0;
    }
    if( hasChildren && ! p->hasChildren ) {
        return 0;
    }

    //...

    if( speaksEnglish && ! p->speaksEnglish ) {
        return 0;
    }
    return 1;
}

Exemple d'utilisation

person_t alice = { "Alice", 24, 0, 1, 0, 1 };
person_t bob = { "Bob", 37, 1, 0, 1, 1, };

person_t dudes[] = {alice,bob};

int i;
for( i=0; i < 2; i++ ) {
    person_t p = dudes[i];
    if( match( &p, 0, 1, 0, 1 ) ) {
        printf( "%s is selected \n", p.name );
    }
}

Inconvénients

Cette solution présente de nombreux inconvénients:

• Gaspillage de mémoire
• Trop de paramètres identiques
• Lecture séquentielle
• Peu évolutif (rajout de nouvelles propriétés)

Les champs de bits (bit fields)

On pourrait utiliser les bits d'un entier pour contenir la même information:

On peut les combiner (OR - symbole "|") pour gérer tous les cas possibles:

Drapeaux (flags)

• On appelle flag les différents champs du champ de bits.
• On les définis généralement comme des constantes ou des énumérations:

#define IS_MARRIED      (1 << 0)   //0001 = 1
#define HAS_CHILDREN    (1 << 1)   //0010 = 2
#define CAN_DRIVE       (1 << 2)   //0100 = 4
#define SPEAKS_ENGLISH  (1 << 3)   //1000 = 8

Manipulations des flags

int i = HAS_CHILDREN;
int j = IS_MARRIED | CAN_DRIVE;

i = i | IS_MARRIED;
j |= SPEAKS_ENGLISH | CAN_DRIVE;

i = i & ~IS_MARRIED;
j &= ~(CAN_DRIVE|IS_MARRIED);

Tests sur les flags

if( i & IS_MARRIED ) ...
if( j & (CAN_DRIVE|SPEAKS_ENGLISH) ) ...

int mask = CAN_DRIVE | SPEAKS_ENGLISH;
if( i & mask == mask ) ...

Implémentation - bit field

struct person {
    char *name;
    int age;
    int properties;
};

typedef struct person person_t;

Sélectionner une pesonne selon des critères - bit field

int match( const person_t *p, int properties ) {
    return ( properties & (p->properties) ) == properties;
}

Exemple d'utilisation - bit field

person_t alice = { "Alice", 24, HAS_CHILDREN | SPEAKS_ENGLISH };
person_t bob = { "Bob", 37, IS_MARRIED | CAN_DRIVE | SPEAKS_ENGLISH };

person_t dudes[] = {alice,bob};

int i;
for( i=0; i < 2; i++ ) {
    person_t p = dudes[i];
    if( match( &p, CAN_DRIVE | SPEAKS_ENGLISH ) ) {
        printf( "%s is suitable \n", p.name );
    }
}

Erreur de retour

Errno (errno.h)

• En C (standards ANSI et POSIX) on utilise la variable globale errno pour passer un code d'erreur.
• Cette variable et les codes d'erreurs standards sont définis dans le fichier errno.h.

Exemples de codes standard POSIX (man errno)

Convention du type de retour (1)

• Par convention si une fonction peut retourner une erreur, on s'arrange pour avoir des fonctions retournant:
  • soit un type entier signé (short, int, long)
  • soit un pointeur
• Par convention ces fonctions retournent en cas d'erreur:
  • soit -1
  • soit NULL

Convention du type de retour (2)

/* Cherche des entrees dans une base de donnees
Retourne:
- soit le nombre de resultats trouves
- soit -1 en cas d'erreurs
Garni le tableau results avec les resultats.
*/
int lookup( DataBase *db, query_t query, int *results );

Utilisation typique

int results[MAX_RESULTS];
int num = lookup( myDB, q, results );
if( num == -1 ) {
    // Gerer l'erreur
} else {
    int i;
    for( i = 0; i < num; i++ ) {
        // Gerer result[i]
    }
}

Comparer le code d'erreur

• la valeur errno indique le type d'erreur (#define associés)
• Normalement, la documentation d'une fonction doit indiquer les codes d'erreurs possibles

if( num < 0 ) {
    switch(errno) {
        case ECONNREFUSED:
            //Gerer un refus de connection;
            break;
        case EPERM:
            //Gerer une operation non autorisée;
            break;
        case ...
    }
}

Obtenir un message d'erreur (strerror)

La fonction strerror retourne un message d'erreur (chaîne de caractère)

if( num < 0 ) {
    printf(stderr, "An error has occured: %s\n", strerror(errno));
}

Afficher un message d'erreur (perror)

La fonction perror permet d'afficher un message d'erreur automatiquement lié a errno sur la sortie d'erreur standard:

//On suppose que le fichier passé en premier paramètre du program est inexistant
int main(int argc, char* argv[]) {
    char* unFichierInexistant = argv[1];
    if (open(unFichierInexistant, O_RDONLY) < 0) {
        perror(unFichierInexistant);
        return -1;
     }
}

$ ./mon-programme /un/fichier/inexistant
/un/fichier/inexistant: No such file or directory

errno est une variable globale

if (somecall() == -1) {
    printf("somecall() failed\n");
    if (errno == ...) { ... }
}

if (somecall() == -1) {
    int errsv = errno;
    printf("somecall() failed\n");
    if (errsv == ...) { ... }
}