Classification des appels système

Classification des appels système

Les appels système peuvent être regroupés en six catégories principales :

• Contrôle de processus
• Gestion de fichiers
• Gestion de périphériques
• Maintenance des informations
• Communications
• Protection

1. Appels système pour le contrôle de processus

Terminaison de processus

Un programme en cours d'exécution doit pouvoir arrêter son exécution :

• end() - Terminaison normale du programme
• abort() - Terminaison anormale du programme

Dans des circonstances normales ou anormales, le système d'exploitation doit transférer le contrôle à l'interpréteur de commandes appelant. L'interpréteur de commandes lit alors la commande suivante.

Chargement et exécution de programmes

Un processus exécutant un programme peut vouloir load() et execute() un autre programme. Cette fonctionnalité permet à l'interpréteur de commandes d'exécuter un programme en fonction, par exemple, d'une commande utilisateur ou d'un clic de souris.

Exemples d'appels système de contrôle de processus sous Unix/Linux

#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>

int main() {
    pid_t pid = fork();  // Appel système pour créer un processus
    
    if (pid == 0) {
        // Processus enfant
        printf("Je suis le processus enfant\n");
        execl("/bin/ls", "ls", "-l", NULL);  // Charge et exécute un nouveau programme
        // Si execl échoue
        perror("execl a échoué");
        _exit(1);  // Terminaison anormale
    } 
    else if (pid > 0) {
        // Processus parent
        printf("Je suis le processus parent, mon enfant a le PID %d\n", pid);
        wait(NULL);  // Attend la terminaison de l'enfant
        printf("L'enfant a terminé\n");
    } 
    else {
        // Erreur
        perror("fork a échoué");
        return 1;
    }
    
    return 0;  // Terminaison normale
}

2. Appels système pour la gestion de fichiers

Exemples d'appels système de gestion de fichiers sous Unix/Linux

#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>

int main() {
    int fd;
    char buffer[100];
    ssize_t bytes_read, bytes_written;
    
    // Création/ouverture d'un fichier (appel système open)
    fd = open("exemple.txt", O_WRONLY | O_CREAT | O_TRUNC, 0644);
    if (fd == -1) {
        perror("Erreur d'ouverture");
        return 1;
    }
    
    // Écriture dans le fichier (appel système write)
    bytes_written = write(fd, "Bonjour, monde!\n", 16);
    if (bytes_written == -1) {
        perror("Erreur d'écriture");
    }
    
    // Fermeture du fichier (appel système close)
    close(fd);
    
    // Réouverture en lecture
    fd = open("exemple.txt", O_RDONLY);
    if (fd == -1) {
        perror("Erreur de réouverture");
        return 1;
    }
    
    // Lecture du fichier (appel système read)
    bytes_read = read(fd, buffer, sizeof(buffer) - 1);
    if (bytes_read == -1) {
        perror("Erreur de lecture");
    } else {
        buffer[bytes_read] = '\0';
        printf("Lu: %s", buffer);
    }
    
    close(fd);
    return 0;
}

3. Appels système pour la gestion des périphériques

Si les ressources sont disponibles, elles peuvent être accordées et le contrôle peut être rendu au processus utilisateur. Sinon, le processus devra attendre que des ressources suffisantes soient disponibles.

Le contrôle de ces ressources se fait par différents appels système. Ces appels système sont responsables de la manipulation de l'appareil, comme la lecture à partir des tampons de l'appareil, l'écriture dans les tampons de l'appareil, etc.

Exemples d'appels système de gestion de périphériques

4. Appels système pour la maintenance des informations

Informations temporelles et système

La plupart des systèmes ont un appel système pour renvoyer l'heure actuelle time() et la date(). D'autres appels système peuvent renvoyer des informations sur le système, telles que :

• Le numéro de version du système d'exploitation
• La quantité de mémoire libre
• L'espace disque disponible
• Le nombre d'utilisateurs connectés

Débogage

Un autre ensemble d'appels système est utile pour déboguer un programme. De nombreux systèmes fournissent des appels système pour effectuer un vidage mémoire dump(). Cette fonction est utile pour le débogage.

Exemples d'appels système de maintenance d'informations sous Unix/Linux

#include <stdio.h>
#include <time.h>
#include <sys/utsname.h>
#include <unistd.h>

int main() {
    // Obtenir l'heure actuelle
    time_t t = time(NULL);
    printf("Heure actuelle : %s", ctime(&t));
    
    // Obtenir des informations sur le système
    struct utsname sys_info;
    if (uname(&sys_info) == 0) {
        printf("Système : %s\n", sys_info.sysname);
        printf("Nom d'hôte : %s\n", sys_info.nodename);
        printf("Version : %s\n", sys_info.version);
        printf("Machine : %s\n", sys_info.machine);
    }
    
    // Obtenir les identifiants de processus
    printf("PID : %d\n", getpid());
    printf("PID parent : %d\n", getppid());
    
    return 0;
}

5. Appels système pour les communications

Modèle de transmission de messages

Dans le modèle de transmission de messages, les processus communicants échangent des messages entre eux pour transférer des informations. Les messages peuvent être échangés entre les processus directement ou indirectement via une boîte aux lettres commune.

Avant que la communication puisse avoir lieu, une connexion doit être ouverte. Le nom de l'autre communicateur doit être connu, qu'il s'agisse d'un autre processus sur le même système ou d'un processus sur un autre ordinateur connecté par un réseau de communication.

Modèle de mémoire partagée

Dans le modèle de mémoire partagée, les processus utilisent les appels système shared_memory_create() et shared_memory_attach() pour créer et accéder aux régions de mémoire détenues par d'autres processus.

Exemples d'appels système de communication sous Unix/Linux

6. Appels système pour la protection

Appels système typiques pour la protection

• set_permission() et get_permission() - manipulent les paramètres d'autorisation des ressources telles que les fichiers et les disques.
• allow_user() et deny_user() - spécifient si des utilisateurs particuliers peuvent (ou ne peuvent pas) être autorisés à accéder à certaines ressources.

Exemples d'appels système de protection sous Unix/Linux

#include <stdio.h>
#include <sys/stat.h>
#include <unistd.h>

int main() {
    // Créer un fichier avec des permissions spécifiques
    FILE* f = fopen("secret.txt", "w");
    if (f) {
        fprintf(f, "Données sensibles\n");
        fclose(f);
    }
    
    // Changer les permissions (set_permission)
    // rw-r--r-- (644) : lecture/écriture pour propriétaire, lecture seulement pour autres
    if (chmod("secret.txt", S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH) == 0) {
        printf("Permissions modifiées avec succès\n");
    }
    
    // Vérifier les permissions (get_permission)
    if (access("secret.txt", R_OK) == 0) {
        printf("Le fichier est lisible\n");
    }
    
    if (access("secret.txt", W_OK) == 0) {
        printf("Le fichier est accessible en écriture\n");
    }
    
    return 0;
}

Récapitulatif des catégories d'appels système