RMI ExtraExo

Outils de communication entre processus
Les signaux
Méthodes de Programmation Système 2008/2009 J. Delacroix 1

Signaux : définition
• Le signal est une interruption logicielle délivrée à un processus.

– Il informe les processus de l'occurrence d'événements
asynchrones et permet de faire exécuter à un processus une
action relative à ces événements.
– Il ne transporte pas de données.
• 64 signaux identifiés par un numéro et un nom (SIGX)

– 1 à 31 : signaux classiques
– 32 à 63 : signaux temps réel

Signaux Classiques
• L'événement associé à un signal

– extérieur au processus (frappe caractère, terminaison d'un
autre processus)
– intérieur au processus correspondant à une erreur (erreur
arithmétique ou violation mémoire) : levée d'une trappe.

Liste des signaux selon le standard POSIX
• signaux relatifs à la fin de processus :

– SIGCHLD (17) : mort du fils
– SIGKILL (9) : signal de terminaison
• signaux relatifs à des erreurs (trappes)

– SIGILL (4) : instruction illégale
– SIGFPE (8) : erreur arithmétique
– SIGSEGV (11) : violation mémoire
– SIGPIPE (13) : écriture dans un tube sans lecteur
• signaux relatifs aux temporisations

– SIGALRM (14): fin de temporisation (fonction alarm)
• signaux relatifs aux interactions avec le terminal (extinction, frappe touche DELETE et
BREAK)
– SIGHUP, SIGINT (crtl C), SIGQUIT (crtl \)
• signaux relatifs à la mise au point de programmes
• Deux signaux disponibles pour les utilisateurs (SIGUSR1, SIGUSR2)

Signaux : aspects du traitement
• Comment un processus reçoit-t-il un signal ?
• Quand un processus traite-t-il un signal reçu ?
• Comment un processus associe-t-il un traitement aux signaux ?

Signaux : structures de données du processus
PCB
Typedef struct { unsigned long sig[2]; } sigset_t;
Signaux classiques 11100000001111111111111111111000
Signaux temps réel 01010011010010101001010101000101
files_struct
mm_struct Struct signal_struct { ……
struct k_sigaction action [64];
signal_struct …….}
volatile long state; - - état du processus TASK_STRUCT
sigset_t signal; -- signaux reçus

sigset_t blocked; -- signaux bloqués (« masqués »)
struct task_struct *next_task, *prev_task; -- chainage PCB

struct task_struct *next_run, *prev_run; -- chainage PCB Prêt
int pid; -- pid du processus
struct task_struct *p_opptr, *p_pptr, *p_cptr,; -- pointeurs PCB père originel, père
actuel, fils
long need_resched; -- ordonnancement requis ou pas
long utime, stime, cutime, cstime;
-- temps en mode user, noyau, temps des fils en mode user, noyau
unsigned long policy; -- politique ordonnancement SCHED_RR, SCHED-FIFO,
SCHED_OTHER
struct thread_struct tss; -- valeurs des registres du processeur
struct mm_struct *mm; -- contexte mémoire
struct files_struct *files ; -- table fichiers ouverts
struct signal_struct *sig ; -- table de gestion des signaux ; actions à réaliser
lors de la prise en compte des signaux par le processus
1. Comment un processus reçoit-t-il un signal ?
• Un processus pid_A envoie un signal S à un processus pid_B par le biais

de la primitive kill.
 kill (pid_B, S)
 Positionnement d'un bit à 1 dans le champ signal de la table du

processus pid _B, correspondant au numéro de signal reçu.
 signal pendant (reçu)
 vecteur de bits : pas de mémorisation du nombre de signaux d'un type

reçu.
Signal[0]
Entier de 32 bits
00001100000000000000100000100010
Signaux 1, 5, 11, 27, 26 reçus

2. Quand un processus traite-t-il un signal reçu ?
• Un processus traite les signaux reçus quand il quitte le mode noyau pour
retourner au mode utilisateur
 signal délivré, le bit correspondant est remis à 0; le traitement associé est
exécuté.
Utilisateur Noyau
Processus pid_A Processus pid_B Processus pid_A Processus pid_B
kill (pid_B, 4);

i = i = 1; Exécution de l’appel système
Fp = open (fichier); Open 00000…..10000
Need_resched = true;
Réordonnancement
Processus B élu Examen des signaux reçus
par le processus élu
Traitement
(do_signal())
3. Comment un processus associe-t-il un traitement aux signaux ?
• Traitement des signaux
– A tout signal est associé un traitement par défaut (ignorer, terminer

le processus avec ou sans core, stopper le processus);
– Tout processus peut installer pour chaque type de signal (hormis

SIGKILL), un nouveau traitement appelé handler
• handler SIG_IGN : pour ignorer le signal (sauf mort du fils
pour Linux)
• handler fonction utilisateur pour capter le signal
 fonction signal et sigaction

3. Comment un processus contrôle-t-il ses réactions
vis-à-vis des signaux ?
(fonction du noyau do_signal())
3 2 1 0
entier signal[0] 0 0 0 0 0 0 0
..........................
1 1 1 1 1 1 1
Indicateurs
de ..........................
Comportement
(sig)
SIG_IGN
rien SIG_DFL @handler
action définie par l’utilisateur
Fonction do_signal()
signr = dequeue_signal()
Oui, tous les signaux pendants sont traités

signr = 0 ?
non
Récupération de l’action associée à signr, stockée dans ka
ka = &current->sig->action[signr-1]
Traitement défini par l’utilisateur

Ignorer le signal
Traitement par défaut

if (ka->sa.sa_handler == SIG_IGN)
{ -- traitement = ignorer le signal Selon les signaux
if (signr != SIGCHLD) continue; - ignorer;
/* Check for SIGCHLD: it's special. */ -Stopper le processus (TASK_STOPPED)
while (sys_wait4(-1, NULL, WNOHANG, NULL) > 0) -Tuer le processus avec ou sans core (do_exit())
continue;
handle_signal(signr);

3. Exécution d’un handler de signal défini par l’utilisateur

Utilisateur
Noyau
main()
{
1
4
}
fonction handler
sig_int
{
2
Co
} 
@
ha @ handler
nd
3 ler

3. Exécution d’un handler de signal défini par l’utilisateur

NOTIONS DE BASE : traitement d'une exception

Les fonctions liées aux signaux
• Envoyer un signal à un processus

– int kill (pid_t pid, int sig) kill (12563, SIGKILL)
– kill -n°signal pid kill -9 12563
• Associer un handler à un signal

– signal(int sig, fonction) signal(SIGINT, p_hand)
– sigaction(int sig, struct sigaction action, NULL)
• Armer une temporisation

– int alarm (int seconds) alarm(10)
– au bout de seconds unités de temps, le signal SIGALRM est
envoyé au processus
• Attendre un signal
– int pause();

Primitive sigaction()
• Associer un handler à un signal (POSIX)
int sigaction (int sig, const struct sigaction *p_action,

struct sigaction *p_action_anc)
struct sigaction {void (*sa_handler)(); /* SIG_DFL ou SIG_IGN

ou pointeur sur handler */
sigset_t sa_mask; /* masque sur signaux */
int sa_flags; } /* options… à mettre à NULL */

struct sigaction action;

action.sa_handler = p_hand;
sigaction (SIG_INT, &action, NULL);


Signaux : synthèse
Utilisateur
Noyau
Processus 1 Processus 2
{ {
signal(sig1, handler)
Processus 1
kill (proc1, sig1)
sig1
} 0
handler()
} handler
{

Signaux : synthèse
Utilisateur
Noyau
{ {
Processus 1
kill (proc1, sig1)
sig1
} 1
Signal pendant
handler()
} handler
{

Signaux : synthèse
Utilisateur
Noyau
{ {
kill (proc1, sig1)

Processus 1
sig1
}
0
handler() It horloge
} Signal délivré
{
handler
ordonnancement
élection processus 1
examen, traitement signaux
}

Signaux et interruptions
• Signaux • Interruptions
 Le processus P2 envoie un  Le dispositif matériel X envoie
signal au processus P1 (signal une interruption lors de
pendant chez P1)
l’exécution du processus P1.
 Plus tard, le processus P1 est

élu. Il quitte le mode noyau. Il  Immédiatement, le processus
exécute le handler du signal P1 est dérouté en mode noyau
en mode utilisateur (signal pour exécuter le handler
délivré à P1). « routine » de l’interruption.

/* programme où un processus crée un fichier sur lequel il travaille. En cas de
réception du signal SIGINT, le processus ferme le fichier sur lequel il travaille
avant de se terminer */
#include <sys/types.h> onintr ()

#include <signal.h>
#include <unistd.h> {
#include <stdio.h> printf("Handler onintr\n");
#include <fcntl.h>
close(desc);
int desc; exit ();
main() }
{
int i;
extern onintr(); /* Handler */
desc = open("toto", O_RDWR, 0);

signal (SIGINT, onintr);
i = 0;
while (i < 5)
{ write (desc, "abcdefghijgl", 12);
i = i + 1; }
printf("fin process normal\n");
close (desc);
}
/* programme où un processus crée un fils puis se met en attente de la
fin de son fils. Le fils exécute un code qui boucle. Au bout de 10
secondes, le fils n'étant pas achevé, le père tue son fils */
#include <sys/types.h>
#include <unistd.h>
#include <stdio.h> onalarm ()
#include <signal.h> {
pid_t pid;
printf("Handler onalarm\n");
main() kill (pid, SIGKILL);
{
extern onalarm(); /* Handler */ exit ();
}
pid = fork();
if (pid == -1)
printf ("erreur creation de processus");
else
if (pid == 0)
{
printf ("valeur du fork”, pid);
printf (" je suis le fils, mon pid est", getpid());
for(;;)
printf("je boucle !!!! \n");
exit(); }
else {
printf ("valeur du fork", pid);
signal (SIGALRM, onalarm);
alarm(5);
wait (); }
}
Programmation clients serveurs
distants
• Modèle clients serveurs

• Interconnexion de réseaux
• Programmation socket

Le modèle client-serveur

Client Serveur
Requête
envoyer requête ouvrir le service
attendre réponse Moyen de comunication attendre une requête
traiter reponse Message - RPC traiter requête
renvoyer réponse

Requête Serveur Itératif
Un seul processus effectue
la réception, le traitement et
l'émission
Serveur
Serveur Parallèle
Le processus père effectue
Requête la réception. Il crée un fils pour
fork() réaliser le traitement et
thread_create()
l'émission de la réponse.
Serveur
L'interconnexion de réseau : quelques principes
M1
M1
R1
R2
R3
RVirtuel RVirtuel
M2
M2
• Construire un réseau virtuel

- adressage (adresse IP, noms symboliques)
- transport de bout en bout (protocole TCP/IP)

Structure hiérarchique fondée sur le domaine (DNS) Noms symboliques

objet.sous-domaine.domaine fermi.cnam.fr
Noms de Domaine
objet : nom d'une machine.
domaine : géographique (fr, jp) ou institutionnel (com, mil, edu)
Serveur de noms Résolution de noms
Adresses IP : 32 bits Adresses Internet

Paire (adresse réseau, adresse machine dans le réseau) Adresses IP
Forme pointée : 10000000 00001010 00000010 00011110
128.10.2.30
Résolution d'adresses
Adresses Ethernet
Adresses physiques

Machine A Machine B
ports
APPLICATIONS APPLICATIONS
De bout en bout
TRANSPORT TCP UDP Passerelle TCP UDP

Réseau Réseau
RESEAU IP IP IP
INTERFACES INTERFACES INTERFACES
R1
R2
• IP : adressage de machine à machine via adresse IP

• TCP/UDP : adressage d'applications à applications
 notion de ports (entier 16 bits)

La couche UDP (User datagram Protocol) APPLICATIONS
• Protocole transport de bout en bout TCP UDP
adressage d'application à application via les ports UDP IP

Ports UDP réservés
exemple : port 513 application who INTERFACES
• Protocole transport non fiable basé sur IP
Datagrammes indépendants
Perte de datagrammes, datagrammes dupliqués, pas de
remise dans l'ordre d'émission
Analogie : le courrier

La couche TCP (Transport Control Protocol)

APPLICATIONS
• Protocole transport de bout en bout

TCP UDP
adressage d'application à application via les ports TCP

IP
Ports TCP réservés
exemples : port 21 application ftp INTERFACES
• Protocole transport fiable orienté connexion basé sur IP
Connexion / Flux d'octets

Pas de perte de messages, pas de duplication, remise dans
l'ordre d'émission
Analogie : le téléphone

Protocole TCP / UDP
UDP TCP
Echange de datagrammes
Etablissement connexion
Echange de flux d’octets
Fermeture connexion

La couche Application

Création
Inetd
Ecoute
Ecoute
Un démon par service

Encombrement de la table des
processus Le démon inetd
en écoute sur les différents ports
crée le serveur sollicité

Les processus démons réseaux
Exemple :
Machine Cliente Machine Serveur

RESEAU
1) Inetd est actif et écoute
le port lié au protocole
Emission d’une requête de service reseau du service

RESEAU
Le serveur inetd
2) détecte la requête sur le
Réception d’une requête du service par le port du service et lance
serveur la démon associé au
service

RESEAU
Le serveur du service
3) communique avec le
Le client et le serveur du service client du service
communique
Machine Serveur
Le serveur du service
Machine Cliente
RESEAU se termine lorsque le
4) service du client a été
réalisé
Fin de la communication entre le client et le serveur
Pendant l’ensemble de ces étapes, le processus inetd est toujours actif.

distants
• Interface de programmation socket

L'interface socket : situation
APPLICATIONS
INTERFACE SOCKETS
TCP UDP
IP
INTERFACES
• Interface de programmation (ensemble de primitives)

• Point de communication (adresse d'application)
• Compatible SGF
L'interface socket : création d'une socket
Sock = socket (af, type, protocole)
IPPROTO_TCP
famille Type de se rvice IPPROTO_UDP
TCP-IP---> AF_INET SOCK_STREAM 0
UNIX ---> AF_UNIX SOCK_DGRAM
SOCK_RAW
int socket (af, type, protocole)

int af;
int type;
int protocole;
Retourne un descripteur de socket ayant les mêmes propriétés qu'un

descripteur de fichier ( héritage)
Accessible par le créateur et les fils de celui-ci/

L'interface socket : Attachement d'une adresse d'application
in t b in d ( s o c k , p _ a d r e s s e , lg )
d e s c r ip te u r d e la s o c k e t lo n g u e u r d e la
p o in t e u r e n m é m o ir e s u r l'a d r e s s e s tru c tu re a d re s s e
D a n s le d o m a in e T C P /I P
s t r u c t s o c k a d d r _ in
int bind (sock, p_adresse, lg)

int sock;
struct sockaddr_in *p_adresse; -- adresse d'application
int lg;
L'opération d'attachement permet d'étendre le groupe des processus
pouvant accéder à la socket

int bind (sock, p_adresse, lg)

int sock;
struct sockaddr_in *p_adresse; -- adresse d'application
int lg;
struct sockaddr_in {
short sin_family; -- AF-INET
ushort sin_port; -- n° de port
struct in_addr sin_addr; -- @ IP
char sin_zero [8]; -- Huit 0
}
Le numéro de port est un entier en dehors des numéros de port

réservés (>IPPORT_RESERVED). Le champ peut être mis à 0 (Choix laissé au
système)
L'adresse Ip de la machine : - constante INADDR_ANY

- utilisation du fichier /etc/hosts
ou serveur de noms
/etc/hosts
Correspondance adresse IP et nom symbolique
Adresse IP, nom symbolique, alias, commentaire
163.173.128.6 asimov.cnam.fr cnam iris
Struct hostent {
char *h_name; /* nom de la machine */
char **h_aliases; /* alias */
int h_addrtype; /* type de l'adresse */
int h_length; /* longueur de l'adresse */
char **h_addr_list; /* liste des adresses IP depuis le serveur de
noms */
#define h_addr h_addr_list[0] /* premier élément de
la liste IP */
};
-- obtenir l'entrée /etc/host de la machine de nom "nom"

struct hostent *gethostbyname (nom)
char *nom;
nom_serveur
PORTC PORTS
CLIENT SERVEUR
IP client réseau IP serveur
Socket client Socket serveur
Adresse locale
Socket client
Port  PORTC
Adresse IP  INADDR_ANY
Adresse distante
Port  PORTS
Adresse IP  gethostbyname (nom_serveur)
L'interface socket : Communication en mode datagramme
Serveur Client
Socket ()
Bind () Socket () Sock = socket (AF_INET,

SOCK_DGRAM, IPPROTO_UDP)
Bind ()
recvfrom()
sendto() Pas d'établissement de connexion
sendto()  Chaque message échangé contient

recvfrom() l'adresse du destinataire
Appels bloquants

int sendto(sock, msg, lg, option, p_dest, lgdest)
int sock; -- socket d'émission

char *msg; -- adresse zone mémoire contenant le message
int lg; -- taille en octets du message
int option; -- 0
struct sockaddr_in *p_dest; -- adresse du destinataire
int lgdest; -- taille de l'adresse du destinataire
int recvfrom(sock, msg, lg, option, p_exp, p_lgexp)
int sock; -- socket de réception

char *msg; -- adresse zone mémoire pour recevoir le message
int lg; -- taille en octets du message
int option; -- 0 ou MSG_PEEK
struct sockaddr_in *p_exp; -- adresse de l'expéditeur
int *p_lgdest; -- taille de l'adresse de l'expéditeur

/**********************************
* SERVEUR UDP /* Attachement socket */
**********************************/ construit_adresse_locale (adr_s, PORTS) ; --
adresse_ip = INADDR_ANY, port = deuxième
argument) ;
#include <stdio.h>
#include <sys/types.h> bind(sock, &adr_s, sizeof(adr_s));
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h> for (;;)
{
#define PORTS 2058
main() lg = sizeof(adr);
{ n = recvfrom (sock, buf, 20, 0, &adr_c, &lg);
int sock;
char buf[20]; printf("Chaine reçue %s\n", buf);
struct sockaddr_in adr_s, adr_c; }
int lg, n;

/* Création socket */ close(sock);
sock = socket(AF_INET,SOCK_DGRAM,
IPPROTO_UDP);
}
/******************/ /* Attachement socket */

/* Client UDP */
/******************/ construit_adresse_locale (adr_c, 0) ; -- adresse_ip
#include <errno.h> = INADDR_ANY, port = deuxième argument ;
#include <sys/types.h> bind(sock, &adr_c, sizeof(adr_c));
#include <netinet/in.h>
#include <netdb.h>
/* Construction adresse du serveur */
#define PORTS 2058
h=gethostbyname(“fermi.cnam.fr”);
main()
construit_adresse_serveur(adr_s, PORTS, h) ;
{
struct hostent *h; -- adresse_ip = h.addr, port = PORTS
struct sockaddr_in adr_s,adr_c;
sendto(sock, "bonjour, serveur !! ", 20, 0, &adr_s,
char buf[20];
sizeof(adr_s));
int sock;
close (sock);
/* création socket */
}
sock = socket(AF_INET,SOCK_DGRAM,
IPPROTO_UDP);

L'interface socket : Communication en mode connecté
Serveur Client
Socket () Sock = socket (AF_INET,

Bind () Socket () SOCK_STREAM,
Bind () IPPROTO_TCP)
Listen ()
Serveur en attente de connexion

Etablissement de connexion
Connect() avec échange
Accept() des adresses participantes
Connexion établie
Write()
Read ()
Write()  Les messages échangés ne

Read()
contiennent pas l'adresse du
Close() Close() destinataire

Serveur Client
Sock_ecoute = socket() -- création de la socket d’écoute sock = socket() -- création de la socket

Listen (sock_ecoute, nb)
nb
connect (sock, ....)
sock_service = accept(sock_ecoute,....)
nb
sock_service
read write
Création d’une socket de service sur laquelle
s’effectue les échanges de données

int listen (sock, nb)

int sock; -- socket d’écoute
int nb; -- connexions pendantes max
int accept (sock, p_adr, p_lgadr) : retourne un descripteur socket de service

int sock; -- socket d'écoute du serveur
struct sockaddr_in *p_addr; -- adresse socket connectée (client)
int *p_lgadr; -- taille de l'adresse
int connect (sock, p_adr, lgadr)

int sock; -- socket client
struct sockaddr_in *p_addr; -- adresse socket du serveur avec lequel
s'établit la connexions
int lgadr; -- taille de l'adresse

int write (sock, msg, lg)

int sock; -- socket locale
char *msg; -- adresse en mémoire de la zone contenant le message
int lg; -- taille du message en octets
int read (sock, msg, lg)

int sock; -- socket locale
char *msg; -- adresse en mémoire de la zone pour recevoir le
message
int lg; -- taille du message en octets

Serveur Client
Création Socket d'écoute sock_ecoute Création Socket

et attachement au port et attachement au port
Connect
Listen
BLOQUANT
tant que le serveur
Accept (sock_ecoute) traite une requête
Demande de service
Sock_service Sock_ecoute
Exécution du service Close
Fermeture sock_service
SERVEUR ITERATIF

Création et attachement de la socket d'écoute sock_écoute
socket / bind
SERVEUR
Ouverture du service PARALLELE
listen
Attente de demande de connexion

Acceptation de la demande
sock_service = Accept (sock_ecoute)
Création d'un processus fils Fork
PERE FILS
Fermeture de la socket d'écoute

Fermeture de la socket de service Traitement de la demande
Exit
/* Attachement socket */
/********************************** construit_adresse_locale (adr_s, PORTS) ; --

* SERVEUR TCP adresse_ip = INADDR_ANY, port = deuxième
**********************************/ argument) ;
bind(sock, &adr_s, sizeof(adr_s));

#include <stdio.h> listen(sock,5);
#include <sys/types.h> /* Boucle d'acceptation d'une connexion */
#include <netinet/in.h> while (TRUE) { /* Attente de question sur la
#include <netdb.h> socket */
lg = sizeof (adr_c);
#define PORTS 2058
main() nsock = accept (sock, &adr_c, &lg);
{ pid = fork();
int namelen, sock, nsock;
char buf[20]; if (pid == 0) {
struct sockaddr_in adr_s, adr_c; close (sock);
int lg, n;
read (nsock, buf, 20);
/* Création socket */ close (nsock);
sock =
socket(AF_INET,SOCK_STREAM, exit();
IPPROTO_TCP); }}}}
de Programmation Système 2008/2009
Méthodes J. Delacroix 50
/******************/ /* Attachement socket */

/* Client TCP */
/******************/ construit_adresse_locale (adr_c, 0) ;
#include <errno.h> -- adresse_ip = INADDR_ANY, port = deuxième
#include <sys/types.h> argument ;
#include <netinet/in.h> bind(sock, &adr_c, sizeof(adr_c));
#include <netdb.h>
#define PORTS 2058
/* Construction adresse du serveur */
main()
h=gethostbyname(“fermi.cnam.fr”);
{
struct hostent *h; construit_adresse_serveur(adr_s, PORTS, h) ;
struct sockaddr_in adr_s,adr_c;
-- adresse_ip = h.addr, port = PORTS
char buf[20];
int sock; connect (sock, &adr_s, sizeof(adr_s));
write(sock, "bonjour, serveur !! ", 20);
/* création socket */
sock = close (sock);
socket(AF_INET,SOCK_STREAM,
}
IPPROTO_TCP);


Création et attachement de la socket d'écoute sock_écoute
socket / bind
SERVEUR
Ouverture du service PARALLELE
listen Le père n’attend
pas son fils.
Attente de demande de connexion

Acceptation de la demande
sock_service = Accept
Création d'un processus fils

Fork
PERE FILS
Fermeture de la socket d'écoute

Fermeture de la socket de service Traitement de la demande
Exit
Le père n'attend pas ses fils  /* Attachement socket */
handler construit_adresse_locale (adr_s, PORTS) ; --
Signal(SIGCHLD, SIG_IGN); adresse_ip = INADDR_ANY, port = deuxième
/********************************** argument) ;
* SERVEUR TCP bind(sock, &adr_s, sizeof(adr_s));
**********************************/
#include <stdio.h> listen(sock,5);
#include <sys/types.h> /* Boucle d'acceptation d'une connexion */
#include <netinet/in.h> Signal(SIGCHLD, SIG_IGN);
#include <netdb.h>
while (TRUE) { /* Attente de question sur la

socket */
#define PORTS 2058
main() lg = sizeof (adr_c);
{ nsock = accept (sock, &adr_c, &lg);
int namelen, sock, nsock;
pid = fork();
char buf[20];
struct sockaddr_in adr_s, adr_c; if (pid == 0) {
int lg, n; close (sock);

read (nsock, buf, 20);
/* Création socket */
sock=socket(AF_INET,SOCK_STREAM, close (nsock);
IPPROTO_TCP); exit();

}}}}
distants
• L’appel de procédure à distance (RPC)

Le protocole rpc
C’est un mécanisme général de communication entre processus
dans les systèmes répartis.
• Permettre à un processus de réaliser, au cours de son exécution,

un appel de procédure avec ses paramètres et valeurs de retour
éventuels, dont l’exécution a lieu sur une autre machine.
• Protocole défini chez Sun Microsystems, à la base de

l’implantation du système de fichiers répartis sous Unix, le protocole
NFS (Network File System).
• Ensemble de services s’appuyant APPLICATIONS

sur l’interface des sockets utilisant RPC
le paradigme de l’appel de procédure INTERFACE SOCKETS
en lieu et place des opérations
send et receive
TCP UDP
IP
. INTERFACES

Le protocole rpc
• Permettre l'appel de procédures à travers le réseau :

 Modèle client / serveur
 Transparence : comme en local
 Notion de souche/ subrogé (stub) client et serveur
CLIENT
RESEAU SERVEUR
Appel proc (x,y)
Paramètres proc (x,y)
Résultat
Site B
Site A

Le protocole rpc
• Les étapes du RPC
Client Souche Client Noyau Noyau Souche Serveur Serveur

Proc(x,y)
Assemblage Déassemblage
des paramètres des paramètres
send receive
x x
y x,y x,y y
Appel Proc(x,y) Proc(x,y)
receive z
z z send Assemblage
Du résultat dans
le message

Le protocole rpc
Les difficultés du RPC
Passage de paramètres
par référence

Le protocole rpc

Panne du réseau : les services idempotents
Assemblage Désassemblage
send receive
x x
y x,y x,y y
z Assemblage
Du résultat dans
send le message
send

Le protocole rpc
Panne du réseau : les services idempotents
On réémet la demande à expiration d’un timer, mais le service a

pu être exécuté !
Exemple
• Lecture des 1 024 premiers octets d’un fichier
• Service bancaire : transférer 3 000 euros sur le compte du percepteur
Solution
Placer un numéro de séquence sur les opérations. Le serveur refuse de
refaire deux fois de suite une demande de service portant un même
numéro de séquence

Le protocole rpc

Panne du serveur : les sémantiques du RPC
Assemblage Désassemblage
send receive
x x
y x,y x,y y HS
send

Le protocole rpc
Panne du serveur : les sémantiques du RPC
Serveur Serveur
Appel Proc(x,y) Appel Proc(x,y)
Proc(x,y)
HS
Proc(x,y)
HS
HS
Panne avant ou pendant l’exécution du service  Panne après exécution du service  le service a été exécuté
le service n’ a pas été exécuté
Exécution au moins une fois : la nouvelle demande du client est rééxécutée

Exécution au plus une fois : la nouvelle demande du client est rejetée

Bien plus que des documents.

RMI ExtraExo

Transféré par

Informations du document

Description :

Description :

Droits d'auteur :

Formats disponibles

RMI ExtraExo

Transféré par

Description :

Droits d'auteur :

Formats disponibles

Titres liés

Outils de communication entre processus

Méthodes de Programmation Système 2008/2009 J. Delacroix 1

• Le signal est une interruption logicielle délivrée à un processus.

• 64 signaux identifiés par un numéro et un nom (SIGX)

Méthodes de Programmation Système 2008/2009 J. Delacroix 2

• L'événement associé à un signal

Méthodes de Programmation Système 2008/2009 J. Delacroix 3

• signaux relatifs à la fin de processus :

• signaux relatifs à des erreurs (trappes)

• signaux relatifs aux temporisations

• signaux relatifs à la mise au point de programmes

• Deux signaux disponibles pour les utilisateurs (SIGUSR1, SIGUSR2)

Méthodes de Programmation Système 2008/2009 J. Delacroix 4

• Comment un processus reçoit-t-il un signal ?

• Quand un processus traite-t-il un signal reçu ?

• Comment un processus associe-t-il un traitement aux signaux ?

Méthodes de Programmation Système 2008/2009 J. Delacroix 5

volatile long state; - - état du processus TASK_STRUCT

sigset_t signal; -- signaux reçus

struct task_struct *next_task, *prev_task; -- chainage PCB

• Un processus pid_A envoie un signal S à un processus pid_B par le biais

 Positionnement d'un bit à 1 dans le champ signal de la table du

 signal pendant (reçu)

 vecteur de bits : pas de mémorisation du nombre de signaux d'un type

Méthodes de Programmation Système 2008/2009 J. Delacroix 7

Processus pid_A Processus pid_B Processus pid_A Processus pid_B

kill (pid_B, 4);

• Traitement des signaux

– A tout signal est associé un traitement par défaut (ignorer, terminer

– Tout processus peut installer pour chaque type de signal (hormis

Méthodes de Programmation Système 2008/2009 J. Delacroix 9

Oui, tous les signaux pendants sont traités

Traitement défini par l’utilisateur

Traitement par défaut

Méthodes de Programmation Système 2008/2009 J. Delacroix 11

• Traitement des signaux

Méthodes de Programmation Système 2008/2009 J. Delacroix 12

Méthodes de Programmation Système 2008/2009 J. Delacroix 13

Méthodes de Programmation Système 2008/2009 J. Delacroix 14

• Envoyer un signal à un processus

• Associer un handler à un signal

• Armer une temporisation

Méthodes de Programmation Système 2008/2009 J. Delacroix 15

• Associer un handler à un signal (POSIX)

int sigaction (int sig, const struct sigaction *p_action,

struct sigaction {void (*sa_handler)(); /* SIG_DFL ou SIG_IGN

struct sigaction action;

Méthodes de Programmation Système 2008/2009 J. Delacroix 16

Méthodes de Programmation Système 2008/2009 J. Delacroix 17

Méthodes de Programmation Système 2008/2009 J. Delacroix 18

kill (proc1, sig1)

Méthodes de Programmation Système 2008/2009 J. Delacroix 19

 Plus tard, le processus P1 est

Méthodes de Programmation Système 2008/2009 J. Delacroix 20

#include <sys/types.h> onintr ()

desc = open("toto", O_RDWR, 0);

• Modèle clients serveurs

Méthodes de Programmation Système 2008/2009 J. Delacroix 23

• Construire un réseau virtuel

Méthodes de Programmation Système 2008/2009 J. Delacroix 25

Structure hiérarchique fondée sur le domaine (DNS) Noms symboliques

Adresses IP : 32 bits Adresses Internet

Méthodes de Programmation Système 2008/2009 J. Delacroix 26

TRANSPORT TCP UDP Passerelle TCP UDP

INTERFACES INTERFACES INTERFACES

• IP : adressage de machine à machine via adresse IP

struct task_struct next_task, prev_task; -- chainage PCB

struct sigaction {void (sa_handler)(); / SIG_DFL ou SIG_IGN