introduction à l'informatique - vertigo : les appels système

Introduction à l’informatiqueVertigo : les appels système

Christophe Cérin

IUT de Villetaneuse

Semestre 2 ; 2014-2015 ; Module M2101

Christophe Cérin (IUTV) Introduction à l’informatique Semestre 2 ; 2014-2015 ; Module M2101 1 / 48

Généralités

Plan

1 Généralités

2 Quelques appels système liés au système de fichiers

3 Appels système et gestion de processus

4 Exercices de TD et TP


Généralités

Définitions

Définition (Appels système (Wikipedia))En informatique, un appel système (en anglais, system call, abrégé en syscall) est une fonction primitivefournie par le noyau (kernel) d’un système d’exploitation et utilisée par les programmes s’exécutant dansl’espace utilisateur (en d’autres termes, tous les processus distincts du noyau). Ce système permet decontrôler de façon sécurisée les applications dans l’espace utilisateur.

Premiers élémentsÉ Le rôle du noyau est de gérer les ressources matérielles (il contient des pilotes de périphériques) et

de fournir aux programmes une interface uniforme pour l’accès à ces ressources. les appelssystème sont normalisés : section 2 du manuel ;

É Quelques exemples :É Système de fichiers : create, open, close, read, write, lseek2,3, dup, link, unlink, stat, fstat, access, chmod,

chown, umask, ioctl ;É Contrôle des processus : execve, fork, wait, _exit, getuid, geteuid, getgid, getegid, getpid, getppid, signal,

kill, alarm, chdir ;É Communication inter-processus : pipe, msgget, msgsnd, msgrcv, msgctl, semget, semop, shmget, shmat,

shmdt.


Généralités

Généralités

Comment se présentent les appels système ?Les appels système peuvent être utilisés comme de simples fonctions écrites en C :É Sur la plupart des noyaux (notamment les noyaux monolithiques comme le noyau Linux) les appels

systèmes sont implémentés par une instruction machine (interrupt, supervisor call, . . .) qui faitbasculer le processeur dans le noyau en mode superviseur ;

É Qui dit mode superviseur dit privilège : un simple utilisateur n’est pas forcément en mesured’exécuter l’appel système ;

É Besoins de privilèges : un programme est limité à son espace d’adresses de telle sorte qu’il ne peutpas lire / modifier l’espace d’adresses d’un autre processus ; Un programme ne doit pas avoir accèsà certaines ressources de bas niveau

Linux et OpenBSD ont chacun 300 appels système, NetBSD en a environ 500, FreeBSD au dessus de500 alors que Plan 9 en a que 51 !


Généralités

Généralités

Implémentation des appels systèmeÉ La librairie comme intermédiaire : "fork" et "execve" sont des fonctions de la bibliothèque C qui

exécutent des instructions qui invoquent les appels système "fork, execve". Faire l’appel systèmedirectement dans le code de l’application est plus complexe et peut exiger du code assembleur (enC et C++) ainsi que la connaissance de l’interface binaire de bas niveau pour le fonctionnement del’appel système, qui peut être sujet à changement au fil du temps. Les fonctions de la bibliothèquesont destinées à l’abstraire ces détails.

É La mise en œuvre des appels système nécessite un transfert de contrôle qui implique uneinteraction spécifique à l’architecture. Une façon typique de mettre en œuvre l’appel système estd’utiliser une interruption logicielle. L’interruption transfère le contrôle au noyau du systèmed’exploitation de telle sorte que la partie logicielle a simplement besoin de mettre en place unecorrespondance avec le numéro de l’appel système nécessaire, et exécuter l’interruption logicielle.

É Exemples sur architecture x86 :É AVANT : use of the INT instruction, where the system call number was placed in the EAX register before

interrupt 0x80 was executedÉ MAINTENANT : SYSCALL/SYSRET, SYSENTER/SYSEXIT (the two mechanisms were independently

created by AMD and Intel, respectively, but in essence do the same thing). These are "fast" control transferinstructions that are designed to quickly transfer control to the OS for a system call without the overhead ofan interrupt. Linux 2.5 began using this on the x86.


Généralités

Exemple pour motiver notre étudeQue se passe t’il quand on lance une commande ls -R ? On propose une simulation par le code Bash :#!/bin/bashlsrep (){for i in ‘ls‘ ; do

if [ "$i" != ".." -a "$i" != "." ] ; thenfor ((j=1;j<$2;j++)); do

echo -n " ";doneecho "$i"if [ -d "$i" ] && ! [ -h "$i" ] ; then

nb_blancs=‘expr $2 + 5‘cd "$i"lsrep $i $nb_blancscd ..

fifi

done}

lsrep . 0Christophe Cérin (IUTV) Introduction à l’informatique Semestre 2 ; 2014-2015 ; Module M2101 8 / 48

Généralités

Généralités

Explications du code précédentÉ C’est un code récursif qui liste les fichiers et répertoires à un certain niveau de l’arborescence (ainsi

que les fichiers contenus dans les sous répertoires). Le principe est le suivant :1. Je dois lister un nombre important de fichiers, je ne sais pas faire. . . donc je sais faire ;2. Je sais faire : a) lister les fichiers du répertoires courant b) pour tous les sous-répertoires de ce répertoire

courant : recommencer le même traitement dont je parle ici ;É le a) est appelé le cas de base et il permet d’arrêter les traitements récursifs ; le b) correspond au

cas : le problème est trop gros donc je demande à le casser un plein de petits morceaux que je saisrésoudre ;

É On va étudier quelques appels systèmes relatifs au système de fichier et à la gestion des processus !


Quelques appels système liés au système de fichiers

Plan

1 Généralités






Quelques appels systèmes liés au système de fichiers

Les inodes (Wikipedia)É Les inodes (contraction de « index » et « node » ; en français : nœud d’index) sont des structures de

données contenant des informations concernant les fichiers stockés dans certains systèmes defichiers (notamment de type Linux/Unix). À chaque fichier correspond un numéro d’inode (i-number)dans le système de fichiers dans lequel il réside, unique au périphérique sur lequel il est situé. Lesinodes peuvent, selon le système de fichiers, contenir aussi des informations concernant le fichier,tel que son créateur (ou propriétaire), son type d’accès (par exemple sous Unix : lecture, écriture etexécution), etc.

É Importance des inodes :É Les inodes contiennent notamment les méta-données des systèmes de fichiers, et en particulier celles

concernant les droits d’accès.É Les inodes sont créés lors de la création du système de fichiers. La quantité d’inodes (généralement

déterminée lors du formatage et dépendant de la taille de la partition) indique le nombre maximum defichiers que le système de fichiers peut contenir.

É Le numéro d’inode d’un fichier toto peut être affiché avec la commande ls -i toto



Quelques appels systèmes liés au système de fichiersNormalisation POSIX (d’après Wikipedia)Cette norme impose que les fichiers réguliers aient les attributs suivants :É La taille du fichier en octetsÉ Identifiant du périphérique contenant le fichierÉ L’identifiant du propriétaire du fichier (UID)É L’identifiant du groupe auquel appartient le fichier (GID)É Le numéro d’inode qui identifie le fichier dans le système de fichiersÉ Le mode du fichier qui détermine quel utilisateur peut lire, écrire et exécuter ce fichierÉ horodatage (timestamp) pour

É La date de dernière modification de l’inode ctime (affichée par la commande stat ou par ls -lc, modificationdes droits du fichier)

É La date de dernière modification du fichier mtime (affichée par le classique ls -l)É La date de dernier accès atime (affichée par la commande stat ou par ls -lu)

É Un compteur indiquant le nombre de liens physiques sur cet inode. (Nlinks)Remarque : les inodes ne contiennent pas les noms de fichier.Remarque : un répertoire est simplement une liste de noms et d’inodes. Quand on crée un fichier onajoute une paire (nom, numéro inode) à un répertoire ; Quand on détruit un fichier, on supprime cette paire(ce n’est pas la peine de parcourir le fichiers pour mettre des 0 !)




Les types de fichiersInformation retournée par ls -l :

• d (directory)• l (symbolic link)• b (block device)• c (character device)• p (named pipe)• s (socket)

Device filesIl en existe deux types : ceux dits « par caractères » et ceux dits « par blocs »É Character devices can be accessed one character at a timeÉ Block devices must be accessed in larger units called blocks, which contain a number of characters.

Votre disque dur est un block device.Remarque : Les Device files sont crées par la commande /dev/MAKEDEV (on spécifie le type :joystick, usb, parallel port. . .)




Opérations sur les fichiers : création, ouverture, fermeture, adjonctionToutes les options liées à ces fonctions sont obtenues par un man

FILE *stream, *fopen();/* declare a stream and prototype fopen */stream = fopen(‘‘myfile.dat’’,‘‘r’’);/*it is good practice to to check file *//*is opened correctly: */if ((stream = fopen(‘‘myfile.dat’’,‘‘r’’)) == NULL)

{ printf(‘‘Can’t open %sn’’,‘‘myfile.dat’’);exit(1);

}

/* LIRE ET ECRIRE */int fprintf(FILE *stream, char *format,args..)int fscanf(FILE *stream, char *format,args..)int getc(FILE *stream), int fgetc(FILE *stream)int putc(char ch, FILE *s)int fputc(char ch, FILE *s)




Vérifications diversesfeof() -- returns true if the stream is currently at theend of the file. So to read a stream,fp, line by lineyou could do:while ( !feof(fp) ) fscanf(fp,"%s",line);

ferror() -- reports on the error state of the stream andreturns true if an error has occurred.

clearerr() -- resets the error indication for a givenstream.

fileno() -- returns the integer file descriptor associatedwith the named stream.




Entrées/sorties de bas niveauLes commandes qui suivent ne sont pas buffurisées : on accède directement au device sans passer parun tampon intermédiaire :É open, close, write, creat, sizeof

/* program to read a list of floats from a binary file *//* first byte of file is an integer saying how many *//* floats in file. Floats follow after it, File name got from *//* command line */#include<stdio.h>#include<fcntl.h>float bigbuff[1000];main(int argc, char **argv) {

int fd;int bytes_read;int file_length;if ( (fd = open(argv[1],O_RDONLY)) = -1){ /* error file not open */perror("Datafile"); exit(1);

}if ( (bytes_read = read(fd,&file_length, sizeof(int))) == -1){ /* error reading file */

exit(1);}if ( file_length > 999 ){/* file too big */ ....}if ((bytes_read = read(fd,bigbuff,file_length*sizeof(float)))== -1){ /* error reading open */ exit(1);}

}




Consultation d’inodeÉ L’appel système stat permet d’obtenir certaines informations de l’inode ;É Résultat d’un appel à stat() : remplissage d’une structure de donnée struct stat

STAT(2) BSD System Calls Manual STAT(2)

NAMEfstat, fstat64, lstat, lstat64, stat, stat64 -- get file status

SYNOPSIS#include <sys/stat.h>

intstat(const char *restrict path, struct stat *restrict buf);

DESCRIPTIONThe stat() function obtains information about the filepointed to by path. Read, write or execute permission of the namedfile is not required, but all directories listed in the path nameleading to the file must be searchable.

Faire le man 2 stat pour une description complète de la structure struct stat pour votresystème (Linux, BSD. . . )




Exemple (de Michel Divay)É Le code proposé permet de lister les propriétés d’un inode ;É Illustration de l’appel système stat. . . mais aussi open, read, write. . .É http://lipn.univ-paris13.fr/˜cerin/SE/appsystes.c : exemple

complet. Nous prenons que le code relatif à stat pour le commenter :// lister les caractéristiques de l’inode de nomvoid lsInod (char* nom) {

struct stat Resu;

if (stat(nom, &Resu) == -1) {perror ("lsInod stat");

} else {printf ("sizeof (struct stat) : %d\n", sizeof (struct stat) );printf ("Dev (en hexa) : 0x%x\n", Resu.st_dev);printf ("Dev (major, minor) : %d/%d\n",

major(Resu.st_dev), minor(Resu.st_dev)) ;printf ("Numéro de l’inode : %d\n", Resu.st_ino);

printf ("Mode (en hexa) : 0x%x\n", Resu.st_mode);printf ("Droits d’accès : ");char c=’?’;if (S_ISREG (Resu.st_mode)) {

c=’-’;} else if (S_ISDIR (Resu.st_mode)) {

c=’d’;} else if (S_ISLNK (Resu.st_mode)) {

c=’l’;}




lsInod() continuedprintf ("%c", c);printf ("%c", Resu.st_mode & S_IRUSR ? ’r’ : ’-’);printf ("%c", Resu.st_mode & S_IRUSR ? ’w’ : ’-’);printf ("%c", Resu.st_mode & S_IXUSR ? ’x’ : ’-’);printf ("%c", Resu.st_mode & S_IRGRP ? ’r’ : ’-’);printf ("%c", Resu.st_mode & S_IWGRP ? ’w’ : ’-’);printf ("%c", Resu.st_mode & S_IXGRP ? ’x’ : ’-’);printf ("%c", Resu.st_mode & S_IROTH ? ’r’ : ’-’);printf ("%c", Resu.st_mode & S_IWOTH ? ’w’ : ’-’);printf ("%c", Resu.st_mode & S_IXOTH ? ’x’ : ’-’);printf ("\n");printf ("Link : %d\n", Resu.st_nlink);printf ("Numéro du propriétaire : %d\n", Resu.st_uid);printf ("Numéro du groupe : %d\n", Resu.st_gid);

if ( S_ISCHR (Resu.st_mode) || S_ISBLK (Resu.st_mode) ) {printf (" %s rdev %d/%d\n",

S_ISCHR(Resu.st_mode)?"caracteres":"bloc",major(Resu.st_rdev), minor(Resu.st_rdev) );

}printf ("Taille : %d\n", Resu.st_size);printf ("Dernier accès en lecture : %ld %s",

Resu.st_atime, ctime (&Resu.st_atime));printf ("Dernier accès en écriture : %ld %s",

Resu.st_mtime, ctime (&Resu.st_mtime));printf ("Dernière modification de l’inode : %ld %s",

Resu.st_ctime, ctime (&Resu.st_ctime));} // if

} // lsInod

Rappel : pour vous approprier le code il faut examiner la signification des différents champs de lastructure stat. . . et donc faire un man 2 stat



Et maintenant les répertoires

opendir and CoÉ Dans le code précédent il y a aussi des fonctions de gestion des répertoires : opendir. . . (man 3opendir)

É Répertoire = fichier contenant des noms de fichiers et/ou répertoiresÉ Interface : via un pointeur sur une structure de type DIR (<dirent.h>)

DIRECTORY(3) BSD Library Functions Manual DIRECTORY(3)NAME

opendir, readdir, readdir_r, telldir, seekdir, rewinddir,closedir, dirfd - directory operations

LIBRARYStandard C Library (libc, -lc)

SYNOPSIS#include <sys/types.h>#include <dirent.h>

DIR * /* ouverture du repertoire de nom filename */opendir(const char *filename);

struct dirent * /* lecture d’une entrée dans le répertoire */readdir(DIR *dirp);



Exemple d’utilisation de opendir()

/* structure describing an open directory. <dirent.h> */typedef struct _dirdesc {

int dd_fd; /* file descriptor associated with directory */long dd_loc; /* offset in current buffer */long dd_size; /* amount of data returned by getdirentries */char *dd_buf; /* data buffer */int dd_len; /* size of data buffer */long dd_seek; /* magic cookie returned by getdirentries */long dd_rewind; /* magic cookie for rewinding */int dd_flags; /* flags for readdir */pthread_mutex_t dd_lock; /* for thread locking */struct _telldir *dd_td; /* telldir position recording */

} DIR;struct dirent { /* <sys/dirent.h> */

u_int32_t d_fileno; /* file number of entry */u_int16_t d_reclen; /* length of this record */u_int8_t d_type; /* file type, see below */u_int8_t d_namlen; /* length of string in d_name */

#ifdef _POSIX_SOURCEchar d_name[255 + 1]; /* name must be no longer than this */#else#define MAXNAMLEN 255char d_name[MAXNAMLEN + 1]; /* name must be no longer than this */#endif};



Exemples d’utilisation de opendir()

Sample code which searches a directory for entry ‘‘name’’ is:

len = strlen(name);dirp = opendir(".");while ((dp = readdir(dirp)) != NULL)

if (dp->d_namlen == len && !strcmp(dp->d_name, name)) {(void)closedir(dirp);return FOUND;

};(void)closedir(dirp);return NOT_FOUND;/***********************************//* Sample code which lists a directory */void listerRep(char *nom){DIR* dp;struct dirent* dirp;if((dp = opendir(name))==NUL)) {

perror("listerRep"); exit(0);} else {

while ((dirp = readdir(dp)) != NULL)printf( »%s\n »,dirp->d_name);

(void)closedir(dirp);}}

Question relative au dernier exemple : et si le répertoire contient des répertoires, que se passe t’il ?


Appels système et gestion de processus

Plan

1 Généralités


3 Appels système et gestion de processusProcFsProcessus : fork()/join()Interface des signauxProblème de synthèse



Appels système et gestion de processus ProcFs

Plan

1 Généralités






De ProcFs à la gestion de processus

ObjectifsÉ Nous allons utiliser les informations de ProcFs pour obtenir de l’information sur les processus. Nous

allons donc introduire :1. ProcFs : (process file system, système de fichiers processus en anglais) est un pseudo-système de fichiers

(pseudo car dynamiquement généré au démarrage) utilisé pour accéder aux informations du noyau sur lesprocessus. Le système de fichiers est souvent monté sur le répertoire /tt /proc.

2. Notion de processus : création, destruction au moyen de l’interface C ;3. Notion de signaux : définir un signal et la fonction de traitement associée au signal ;4. Exemple : récupérer de l’information sur les ressources consommées par un processus. Cette étude de

cas jongle avec les notions ProcFs, processus, signaux et reprend certaines idées de l’outil SYSSTAT(http://sebastien.godard.pagesperso-orange.fr/), plus exactement la briquepidstat.

É Puisque /proc n’est pas une arborescence réelle, il ne consomme aucun espace disque maisseulement une quantité limitée de mémoire vive.

É procfs est supporté sur les systèmes suivants : Solaris, BSD, Linux, qui étend le concept au-delàdes processus : entre autres, description détaillée des composants matériels, du réseau... etc, IBMAIX (qui utilise l’implémentation de Linux pour une meilleure compatibilité), QNX, (Unix temps réel)



Que trouve t’on dans /proc ?

Le /proc de linux est un dérivé du procsys de Plan 9Il y a un répertoire pour chaque processus en cours (y comprisles processus noyau), le nom de ce processus est le nombrecorrespondant au PID (Identifiant de processus)(exemple : /proc/1 pour init)

/proc/PID/cwd,/proc/PID/exe,/proc/PID/root/proc/PID/status/proc/PID/task

Selon le type d’alimentation, il y aura soit un répertoire ACPI(sur les PC récents), soit sur APM (sur les PC anciens)/proc/bus pour décrire les bus informatiques

USBPCIPnp

/proc/cpuinfo/proc/crypto/proc/devices/proc/diskstats/proc/filesystems/proc/interrupts (voir Interruption (informatique))/proc/kcore/proc/meminfo/proc/modules/proc/mounts/proc/net/proc/partitions

Remarque : liste ci-dessus non exhaustive.



ProcFs

Quelques commandes utilisant /proc (d’après wikipedia)É ps aux : affiche l’état des processus en cours.Cette commande exploite les informations présentes

dans /proc/[pid]/stat.É uname -a : Affiche des informations sur le système : le type de machines, le nom d’hôte de la

machine sur le réseau, le numéro de version du système d’exploitation et le nom du systèmed’exploitation. Elle utilise le /proc/version et le /proc/sys/kernel/version

É swapon -s : affiche le résumé par périphérique de l’utilisation de la pagination sur disque. Utilise/proc/swaps.

É free : affiche les quantités totales de mémoire et de zone de swap libres et utilisées dans lesystème. Utilise /proc/meminfo.

É dmesg : affiche le tampon des messages du noyau. Elle utilise le /proc/kmsg.É uptime : indique depuis quand le système fonctionne. Utilise /proc/loadavg.É lspci : utilitaire permettant d’afficher des informations sur les bus PCI du système ainsi que sur

les périphériques qui y sont connectés. Utilise /proc/bus/pci/devices.É lsmod : affiche la liste des modules du noyau chargés en mémoire. Emploie /proc/modulesÉ mount : affiche les points de montage. Emploie /proc/mounts.É sysctl : permet de lire et modifier les paramètres du noyau.


Appels système et gestion de processus Processus : fork()/join()

Plan

1 Généralités






Créer un processus

Aspects conceptuelsÉ fork() est l’opération de création de processus, généralement implémenté par un appel système

dans le noyau. C’est l’interface historique sur les système d’exploitation Unix. . .mais il existe aussiÉ Vfork, Rfork et Clone (noyau Linux). Ce qui distingue toutes ces implémentations : ce qui est partagé entre

les processus (hors du sujet de ce jour)É fork() fonctionne de la manière suivante : quand le programme (disons a.out) passe sur

l’instruction, un deuxième a.out est lancé. nous avons donc 2 a.out qui tournent simultanément.L’instruction qui suit (un if sur la valeur de retour e fork()) permet de sélectionner le code que l’onexécute selon que l’on est le processus père ou le processus fils.

É On est en présence d’un mode de programmation distribuée de type SPMD (Single Program MultipleData). C’est au programmeur d’imaginer qu’il est tantôt le père tantôt le fils. Le programmeur doitécrire les 2 comportements dans le même programme / fonction. Ce n’est pas habituel pour vous !



Fork() : exemple de base (d’après Wikipedia)Programme C qui utilise fork()#include <sys/types.h> /* pid_t */#include <sys/wait.h> /* waitpid */#include <stdio.h> /* printf, perror */#include <stdlib.h> /* exit */#include <unistd.h> /* _exit, fork */

int main(void){

pid_t pid;

pid = fork();if (pid == -1) {

/** When fork() returns -1, an error happened.*/perror("fork failed");exit(EXIT_FAILURE);

}else if (pid == 0) {

/** When fork() returns 0, we are in the child process.*/printf("Hello from the child process!\n");_exit(EXIT_SUCCESS); /* exit() is unreliable here, so _exit must be used */

}else {

/** When fork() returns a positive number, we are in the parent process* and the return value is the PID of the newly created child process.*/int status;(void)waitpid(pid, &status, 0);

}return EXIT_SUCCESS;

}



Commentaires sur le programme précédent

Les trucs et astucesÉ Le père ne fait rien : il attend simplement que son fils termine. C’est l’instruction waitpid() qui

permet cette synchronisation. Cette instruction ne peut s’utiliser que du coté du père !É Le fils affiche un message et termine ; Le return ne sera effectué que par le père : le fils meurt avant

de l’avoir exécuté par l’intermédiaire du exit.É Le programme précédent est le schéma de base ! C’est lui que l’on particularise au besoin. Il est

donc à connaître par cœur !É Nous allons mettre maintenant en évidence que le partage d’information est réduit. Dans le code qui

suit la variable j est dupliquée par le fork() : on travaille sur une copie ;É Pour régler les problèmes de partage d’information il faudrait mettre en œuvre des mécanismes

élaborés : cela sort de ce cours introductif (aux problèmes).



Mise en évidence du partage d’information entre processus. . . qui est réduit#include <sys/types.h> /* pid_t */#include <sys/wait.h> /* waitpid */#include <stdio.h> /* printf, perror */#include <stdlib.h> /* exit */#include <unistd.h> /* _exit, fork */

int main(void){

pid_t pid;int j=12;

pid = fork();

if (pid == -1) {perror("fork failed"); exit(EXIT_FAILURE);

}else if (pid == 0) {

j++;printf("Hello from the child process! j: %d\n",j);_exit(EXIT_SUCCESS); /* exit() is unreliable here, so _exit must be used */

}else {

int status;(void)waitpid(pid, &status, 0);j++;printf("Hello from the father process! j: %d\n",j);

}return EXIT_SUCCESS;

}

$ gcc -Wall -O4 partage-fork.c$ ./a.outHello from the child process! j: 13Hello from the father process! j: 13


Appels système et gestion de processus Interface des signaux

Plan

1 Généralités






Interface des signauxNous allons examiner quelques rudiments (il existe plusieurs interface)É Les signaux sont une forme limitée de communication inter-processus utilisé sous Unix et d’autres

systèmes d’exploitation compatibles POSIX. Un signal est une notification asynchrone envoyée à unprocessus afin de l’informer d’un événement qui s’est produit. Les signaux ont été autour depuis lesannées 1970 de Bell Labs Unix et ont été inventés dans les années 70, et plus récemment spécifiésdans la norme POSIX.

É Remarque : quand on dit communication inter-processus / partage d’information, il ne s’agit pasd’échange de données entre processus !

É Quand un signal est envoyé, le système d’exploitation interrompt le flux normal du processusd’exécution de la cible pour délivrer le signal. L’exécution peut être interrompue au cours d’uneinstruction non-atomique. Si le processus a déjà enregistré un gestionnaire de signal, la routineassociée au gestionnaire) est exécutée. Dans le cas contraire, le gestionnaire de signaux par défautest exécutée.

É Interface :É L’appel système kill envoie un signal spécifié à un processus spécifié, si les autorisations le permettent. De

même, la mise à mort d’un processus via kill permet à un utilisateur d’envoyer un signal de fin d’exécutionaux processus. Il y a donc l’interface C kill() et le programme kill.

É Les exceptions comme la division par zéro ou une violation de segmentation génèrent des signaux (ici,SIGFPE et SIGSEGV respectivement, qui par défaut provoquent un core dump et une sortie deprogramme)



Les signaux : squelette de base

. . . à connaître par cœur#include<stdio.h>#include<signal.h>#include <unistd.h>

void hd_int(int n){

static int cte;

signal(SIGINT,hd_int);printf("Appel %d\n",cte+1); cte++;sleep(5);printf("Fin appel %d\n",cte);

}

intmain(){

int i;signal(SIGINT,hd_int);while(pause()== -1);printf("Fin du pg\n");return 1;

}



Les signaux

Execution du programme précédent$ gcc signal.c$ ./a.out^CAppel 1^CFin appel 1Appel 2^CFin appel 2Appel 3Fin appel 3^Z[2]+ Stopped ./a.out$ killall a.out[2]+ Terminated: 15 ./a.out



Liste (partielle) des signaux POSIX

Voir http ://en.wikipedia.org/wiki/Signal_(computing)Signal Default Action Description

SIGABRT A Process abort signalSIGALRM T Alarm clockSIGBUS A Access to an undefined portion of a memory objectSIGCHLD I - Ignore the Signal Child process terminated, stopped,SIGCONT C - Continue the process Continue executing, if stopped.SIGFPE A Erroneous arithmetic operation.SIGHUP T Hangup.SIGILL A Illegal instruction.SIGINT T Terminal interrupt signal.SIGKILL T Kill (cannot be caught or ignored).SIGPIPE T - Abnormal termination of the process

Write on a pipe with no one to read it.SIGQUIT A - Abnormal termination of the process Terminal quit signal.SIGSEGV A Invalid memory reference.SIGSTOP S - Stop the process

Stop executing (cannot be caught or ignored).SIGTERM T Termination signal.SIGTSTP S Terminal stop signal.SIGTTIN S Background process attempting read.SIGTTOU S Background process attempting write.SIGUSR1 T User-defined signal 1.SIGUSR2 T User-defined signal 2.SIGPOLL T Pollable event.SIGPROF T Profiling timer expired.SIGSYS A Bad system call.SIGTRAP A Trace/breakpoint trap.SIGURG I High bandwidth data is available at a socket.SIGVTALRM T Virtual timer expired.SIGXCPU A CPU time limit exceeded.SIGXFSZ A File size limit exceeded


Appels système et gestion de processus Problème de synthèse

Plan

1 Généralités






Problème de synthèse

Objectif SYSSTATÉ Nous souhaitons observer ce que consomme en terme de ressources du système, un certain

processus PID. Nous allons explorer /proc pour retrouver de l’information sur le PID. Nous allonsaussi faire en sorte qu’en envoyant un signal au processus qui mesure les consommations, celuitermine et affiche à ce moment les informations sur les ressources consommées ;

É Nous allons étudier le source, plus particulièrement le programme pidstat.c de la distribution ;É Nous allons étudier quelques fonctions clés du code ;



Problème de synthèseLire les informations de statistique/***************************************************************************** Read stats from /proc/#[/task/##]/stat.** IN:* @pid Process whose stats are to be read.* @pst Pointer on structure where stats will be saved.* @tgid If !=0, thread whose stats are to be read.** OUT:* @pst Pointer on structure where stats have been saved.* @thread_nr Number of threads of the process.** RETURNS:* 0 if stats have been successfully read, and 1 otherwise.****************************************************************************/

int read_proc_pid_stat(unsigned int pid, struct pid_stats *pst,unsigned int *thread_nr, unsigned int tgid)

{FILE *fp;char filename[128], format[256], comm[MAX_COMM_LEN + 1];size_t len;

if (tgid) {sprintf(filename, TASK_STAT, tgid, pid);

}else {

sprintf(filename, PID_STAT, pid);}

if ((fp = fopen(filename, "r")) == NULL)/* No such process */return 1;




Lire les informations de statistique (suite)sprintf(format, "%%*d (%%%ds %%*s %%*d %%*d %%*d %%*d %%*d %%*u %%lu %%lu"

" %%lu %%lu %%lu %%lu %%lu %%lu %%*d %%*d %%u %%*u %%*d %%lu %%lu"" %%*u %%u %%*u %%*u %%*u %%lu %%lu\\n", MAX_COMM_LEN);" %%*u %%u %%*u %%*u %%*u %%lu %%lu\\n", MAX_COMM_LEN);

fscanf(fp, format, comm,&pst->minflt, &pst->cminflt, &pst->majflt, &pst->cmajflt,&pst->utime, &pst->stime, &pst->cutime, &pst->cstime,thread_nr, &pst->vsz, &pst->rss, &pst->processor,&pst->gtime, &pst->cgtime);

fclose(fp);

/* Convert to kB */pst->vsz >>= 10;pst->rss = PG_TO_KB(pst->rss);

strncpy(pst->comm, comm, MAX_COMM_LEN);pst->comm[MAX_COMM_LEN - 1] = ’\0’;

/* Remove trailing ’)’ */len = strlen(pst->comm);if (len && (pst->comm[len - 1] == ’)’)) {

pst->comm[len - 1] = ’\0’;}

pst->pid = pid;pst->tgid = tgid;return 0;

}




Commentaires sur le codeÉ Le sprintf permet de définit un format pour la lecture dans la structure pid_stats ;É struct pid_stats *pst : définie dans pidstat.h. Structure à 39 champs !É Les autres parties du code sont moins importantes.É Dans le même ordre d’idée, il y a une fonction qui "Read stats from/proc/#[/task/##]/status" puis une autre qui "Read information from/proc/#[/task/##]/smaps" etc (ce qui permet de lire les informations de statistique liéesà la mémoire, aux I/O etc)

É Les fonctions prcédentes sont appelées dans la fonction read_pid_stats() ;É L’affichage des statistiques se fait via write_pid_child_all_stats ou encorewrite_pid_task_cpu_stats ; Du même tonneau, il y a d’autres fonctions d’affichage desstatistiques mémoire, I/O etc

É La boucle principale est rw_pidstat_loop(). Question : est ce que l’envoi d’un signalprovoque la fin d’exécution du programme et l’affichage des statistiques ?


Exercices de TD et TP

Plan

1 Généralités






Exercices de TD et de TP

Gestion de fichiers et code de Michel DivayModifier le code http://lipn.univ-paris13.fr/˜cerin/SE/appsystes.c pourque la fonction listerRep() parcourt également les sous-répertoires.

Programmation C (suite) : système de fichierFaire tous les exercices du point 1 de la pagehttp://lipn.univ-paris13.fr/˜cerin/SE/ExercicesSF.html

Programmation C : processusSur la pagehttp://lipn.univ-paris13.fr/˜cerin/SE/ExercicesCommunic.html, faireles exercices suivants : Préambule ; Exercice 1.4 ; Veuillez interpréter le code suivant :http://lipn.univ-paris13.fr/˜cerin/SE/test-process.c



Exercices de TD et de TP

Programmation C : signauxSur la pagehttp://lipn.univ-paris13.fr/˜cerin/SE/ExercicesCommunic.html, faireles exercices suivants : 3.1, 3.2, 3.3.

MOOCVisionner le cours en ligne "Computer Science 162 – Lecture 1" depuis la pagehttp://www.youtube.com/playlist?list=PLA32F8ECF0A0ED16A Desquestions relatives à ce cours en ligne seront posées lors de l’examen.


introduction à l'informatique - vertigo : les appels système

Documents