Introduction · appels système

📄 Ressources du cours

🎥 Vidéos recommandées

• 🇫🇷 fonction fork programmation c linux en darija

  programmer0MAROC · 12:29 · 43k vues — link for download exemple.txt http://www.mediafire.com/?iu6giktc7dgb2uo

• 🇫🇷 GNU/Linux #22 - processus

  FormationVidéo · 48:17 · 34k vues — Cette vidéo aborde les processus du système, de quoi sont ils composés et comment le processeur (via son ordonnanceur) partage les ressources entre chacun d'...

• 🇬🇧 Linux fork() Introduction

  Brian Fraser · 29:40 · 248k vues — Demo the use of the fork() function in Linux/Unix to spawn a new process. Cover the basics of what it does, how to do work in parent and child processes, and...

0. Plan du cours

1. Systèmes d'exploitation · définitions

Architecture en couches d'un ordinateur

Un ordinateur est constitué :

• du matériel — dispositifs physiques + langage machine ;
• d'un système d'exploitation ;
• de programmes — programmes système + programmes d'applications.

Les quatre couches d'un système : du matériel jusqu'aux utilisateurs, en passant par le SE et les applications.

Composition du SE

Le matériel (hardware)

Les dispositifs physiques constituent la couche la plus basse :

• le processeur,
• la mémoire principale,
• des disques,
• des imprimantes,
• des interfaces de connexion réseau,
• …

Les programmes (software, applications)

Ils sont écrits par les utilisateurs ou par les éditeurs de logiciels. But : résoudre des problèmes spécifiques (traitement des problèmes commerciaux, calculs scientifiques, etc.).

2. La double fonction du SE

Un SE répond à deux besoins qui ne sont pas forcément liés :

• le SE en tant que machine étendue (ou « machine virtuelle »),
• le SE en tant que gestionnaire de ressources.

Le SE en tant que machine étendue

Le SE en tant que gestionnaire de ressources

Les différents composants d'un ordinateur doivent coopérer et partager des ressources. Le travail du SE consiste à :

• ordonnancer,
• contrôler l'allocation des ressources : processeurs, mémoires, périphériques d'E/S, entre les différents programmes qui y font appel.

Pour chacune des ressources, le SE doit :

• connaître à tout moment l'utilisateur de la ressource,
• en accorder l'usage de manière équitable,
• éviter les conflits d'accès entre les différents programmes ou utilisateurs.

3. Fonctions de base d'un SE

Un SE, à quoi ça sert ? Six grandes fonctions :

4. Les appels système · principe

Un exemple détaillé avec le compilateur C

Soit l'appel cpt = read(df, tampon, nboctets). Voici les 10 étapes du déroulement :

// Côté utilisateur (mode user)
cpt = read(df, tampon, nboctets);

1. Empiler nboctets
2. Empiler &tampon
3. Empiler df
4. Appeler read()
5. Placement du code du read dans un registre
6. Déroutement vers le noyau — basculer en mode noyau
7. Le code noyau examine le numéro d'appel système, utilise une table de pointeurs indexée sur les numéros d'appels système
8. Exécution de l'appel système
9. Rendre le contrôle à la fonction read de bibliothèque
10. Rendre le contrôle au programme utilisateur

Anatomie d'un appel système : on quitte le mode utilisateur, on transite par la table indexée du noyau, on exécute, et on revient.

5. Les appels système POSIX · panorama

À quoi ça sert ? Trois grandes familles :

6. Gestion des fichiers

Ouvrir un fichier · open

Ouvre un fichier, qui restera ouvert jusqu'à la fin du processus ou jusqu'à close :

int open(const char *pathname, int typeOpen);
int open(const char *pathname, int typeOpen, mode_t droitsFic);

• pathname (chemin) = chaîne de caractères correspondant au chemin d'accès du fichier à ouvrir.
• typeOpen = mode d'ouverture.

Ces modes peuvent se combiner avec un OU binaire avec un attribut de création :

Les étapes d'un open

1. Trouver l'inode du fichier (dans la table des inodes) — charger l'inode en mémoire si elle n'y est pas.
2. Vérifier les droits d'accès — la vérification n'est faite qu'à l'ouverture ; si on enlève les droits sur un fichier ouvert, ça ne bloque pas le processus qui utilise le fichier !
3. Allouer une entrée dans la table des fichiers ouverts.
4. Positionner l'offset courant (0 ou fin de fichier en cas d'ouverture en ajout).
5. Allouer une place dans la table des descripteurs de fichiers du processus.
6. Renvoyer au processus appelant le descripteur obtenu.

Les 3 tables liées à open

Trois niveaux d'indirection : fd processus → entrée globale (offset, mode) → inode.

Fermer un fichier ouvert · close

Ferme le fichier ouvert et libère le descripteur :

int close(int fd);

Lire depuis un fichier ouvert · read

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

Écrire dans un fichier ouvert · write

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

Se positionner dans un fichier ouvert · lseek

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

Dupliquer un descripteur · dup

int dup(int oldfd);

• Duplique un descripteur de fichier valide.
• La copie reçoit le plus petit numéro de descripteur disponible.
• Pénible quand on veut un numéro précis.

Dupliquer avec numéro choisi · dup2

int dup2(int oldfd, int newfd);

• Duplique un descripteur de fichier valide.
• La copie reçoit le numéro newfd.
• Si newfd était ouvert, il est fermé automatiquement.
• Très utile pour les redirections.

dup, dup2 et lseek

Descripteurs standards

Par défaut, un processus dispose de :

7. Gestion des processus

Création d'un processus

• Lorsqu'on entre une commande, le shell lance un processus pour l'exécuter.
• Le shell attend la fin du processus, puis attend la commande suivante.
• Un programme qui s'exécute avec un jeu de données particulier est un processus.

Arborescence de processus

Duplication d'un processus · fork

pid_t fork(void);

L'appel système fork est le seul moyen de créer un processus à bas niveau :

• Crée un processus fils de ce processus, et le lance.
• L'exécution continue dans les deux processus, à l'instruction qui suit le fork.
• Les PID et PPID sont les seules informations différentes entre les deux processus.

La manière la plus courante d'utiliser fork

L'appel système fork duplique / clone le processus appelant :

void main() {
    pid_t n = fork();
    if (n != 0) {
        if (n < 0) {
            // gestion des erreurs
        } else {
            // programme du papa
        }
    } else {
        // programme du fils
    }
}

Récupération du PID

pid_t getpid(void);
pid_t getppid(void);
pid_t getpgrp(void);

• getpid retourne le PID du processus courant.
• getppid retourne le PID du processus père.
• getpgrp retourne le PID du groupe du processus courant.

Exemple — clonage, indépendance

Le clonage est une recopie complète et indépendante. Exemple de sortie :

je suis le fils, mon PID est 10271 ; mon pere est 10270
pour le pid 10271, i = 12
je suis le pere, mon PID est 10270
Pour le pid 10270, i = 7

Le branchement classique post-fork : n > 0 côté père, n == 0 côté fils, n < 0 en cas d'erreur.

Attendre la mort d'un fils · wait

pid_t wait(int *status);

La primitive wait permet à un processus d'attendre la fin d'un de ses fils :

• S'il n'y a pas de fils ou erreur, retourne -1.
• Sinon, retourne le PID du fils qui s'est terminé.

Inspecter status

Si status n'est pas NULL, les informations sur la terminaison du fils y sont stockées.

Terminer un processus · exit

void exit(int status);

• status permet d'indiquer au processus père qu'une erreur s'est produite.
• status = 0 si pas d'erreur.

Attendre un fils particulier · waitpid

pid_t waitpid(pid_t pid, int *status, int options);

La fonction waitpid suspend l'exécution du processus courant jusqu'à ce que le processus fils de numéro pid se termine (ou jusqu'à réception d'un signal).

Temporisation · sleep

int sleep(int seconds);

Similaire à la commande shell sleep — le processus qui appelle sleep est bloqué pendant le nombre de secondes spécifiées.

8. Lancer un autre programme · exec* & system

La famille exec*

Les 6 prototypes

int execl (char *path, char *arg0, char *arg1, ..., NULL);
int execv (char *path, char *arg[]);
int execle(char *path, char *arg0, ..., NULL, char *envp[]);
int execve(char *path, char *arg[], char *envp[]);
int execlp(char *file, char *arg0, char *arg1, ..., NULL);
int execvp(char *file, char *arg[]);

execl — liste d'arguments

La fonction execl prend en paramètre une liste des arguments à passer au programme (liste terminée par NULL). Le premier paramètre est une chaîne qui doit contenir le chemin d'accès complet au fichier exécutable ou au script shell à exécuter.

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

int main()
{
    /* dernier élément NULL, OBLIGATOIRE */
    execl("/usr/bin/emacs", "emacs", "fichier.c", "fichier.h", NULL);
    perror("Problème : cette partie du code ne doit jamais être exécutée");
    return 0;
}

execv — tableau d'arguments

La différence avec execl est que l'on n'a pas besoin de connaître la liste des arguments à l'avance (ni même leur nombre). Prototype :

int execv(const char *application, const char *argv[]);

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

int main()
{
    char *argv[] = {"emacs", "fichier.c", "fichier.h", NULL};
    /* dernier élément NULL, obligatoire */
    execv("/usr/bin/emacs", argv);
    puts("Problème : cette partie du code ne doit jamais être exécutée");
    return 0;
}

Récapitulatif des 6 variantes

Lancement d'une commande · system

int system(const char *commande);

• La fonction system de la bibliothèque stdlib.h permet directement de lancer un programme dans un programme C sans utiliser fork et exec.
• Crée un nouveau processus /bin/sh qui exécute la commande (/bin/sh -c commande).
• Le processus appelant cette fonction reste bloqué jusqu'à la fin de l'exécution du processus.

system("clear");

★ Réviser le cours

❓ Q/R

🃏 Flashcards

Clique pour retourner. Tout retourner

int open(const char *pathname,
         int typeOpen);
int open(const char *pathname,
         int typeOpen,
         mode_t droitsFic);

✎ Quiz éclair

📌 À retenir