Jc/md/lp-01/05Communication inter processus1 Communication inter process Présentation

jc/md/lp-01/05 Communication inter processus 1

Communication inter process

Présentation


Objectif du chapitre

• Notions de mémoire locale, publique et partagée• Passage d’adresses entre deux process


Communications entre processus

• Deux ou plusieurs processus concernés• Différentes informations apparaissent quand on

veut coordonner le travail des processus1. Informations chronologiques isolées

2. Informations chronologiques, avec ou sans comptage d’informations prédéfinies

3. Informations non prédéfinies à partager

4. Partage de programme

• Combinaison des différents cas


Informations chronologiques isolées

• Simple information fournie par un processus, sans action induite : réception d’un message, fin de téléchargement, etc. En fait, il n’y a pas de coopération entre processus.

• Information fournie par un processus et qui provoque une réponse, éventuellement par un processus différent : autodestruction d’un missile quand on reçoit l’information de sortie du plan de vol, etc.

• Traitement par les événements


Informations chronologiques répétitives

• Les informations sont figées et provoquent toujours la même réponse prédéterminée

– Dépassement d’une valeur de consigne : déclenchement d’un ventilateur après

dépassement haut de la température,

arrêt du ventilateur après dépassement bas

– Arrivée et départ de jetons d’une file d’attente– Etc.

• Traitement par les événements, sémaphores, mutex, sections critiques (déjà vus)


Informations non prédéfinies à partager

• Il y a en jeu un véritable message qui peut différer à chaque occurrence : le contenu lu ou créé par le producteur doit être mis à disposition du processus consommateur.

• Le contenu du message peut prendre diverses formes : un texte dans un buffer, une valeur, une adresse, une clé de cryptage, une information d’état (status) d’organe périphérique, etc.

• Il s’agit là de partage d’information


Partage de programme

• Un problème différent du problème de partage de l’information apparaît quand on veut faire bénéficier plusieurs processus d’un même code. Il s’agit normalement de dll, de driver ou de façon générale de programmes réutilisables.

• Nous baptisons ce problème partage de code. Le processus qui contient le code partagé, disons P, produit ou consomme des informations pour le compte d’autres processus, disons A, B, etc. Il est difficile pour P de traiter les informations dans sa mémoire locale puis de les restituer à A, B, etc. Il est beaucoup plus judicieux de permettre à P de travailler directement dans les espaces mémoires privés de A, B, etc. Ce problème étant traité par une technique voisine de celle utilisée pour le partage d’information, nous le traiterons à sa suite.


Mémoire privée et mémoire publique

• Mémoire privée ou localeQuand un processus est créé Windows

CE lui attribue un slot disponible parmi les 32 slots. Dans cet espace la mémoire est privée, réservée au process affecté au slot.

• Mémoire publique ou partagéePar ailleurs, un autre espace mémoire,

public cette fois, est prévu. Il est beaucoup plus vaste et accessible à tous les processus ce qui permet d’établir des communications si besoin.


Mémoire locale (1)

• La zone mémoire qui correspond au slot du process est privée et protégée par des droits d’accès.

• Ce cloisonnement et les mécanismes de permissions associés sont absolument indispensables pour créer des applications robustes car cela évite les interférences involontaires entre processus.

• La contrepartie est évidente : les informations traitées en mémoire locale ne sont pas communicables à priori aux autres processus.


Mémoire locale (2)

• Un processus non propriétaire d’une mémoire privée peut tout de même accéder à cette zone si le propriétaire lui en a communiqué

– L’adresse physique – Les clés d’accès adéquates

• Des fonctions permettent au propriétaire de la zone privée de fournir ces informations aux autres processus dans la mémoire partagée accessible à tous. Nous utiliserons ce mécanisme pour le « partage de code ».


• Espace vaste permettant d’enregistrer des quantités importantes d’informations, c’est-à-dire pratiquement des fichiers.

• Cette zone qui est accessible à tous les processus permet donc de partager des informations entre processus

– Par le système de fichier– Par une zone d’adresse connue de tous les

processus quand l’information est gérable directement, sans l’intervention d’un système de fichiers : une adresse, un buffer, un nom, etc.

Mémoire publique (1)


Mémoire publique (2)

• On attribue un nom au fichier ou à l’objet mémoire de cet espace.

Ce « nom de partage » géré au niveau du système pourra être retrouvé par n’importe quel processus ; ce lien conduit à des possibilités de communications entre processus.

• Par ailleurs, cette mémoire publique permet de réaliser des allocations de mémoire virtuelle qui dépassent les limites de l’allocation dans un slot.


Nom de partage

• Nous allons créer un « nom de partage » associé à un objet mémoire ou à un fichier.

• Ce nom géré par le système est visible de tous les processus.

• Tout processus peut travailler avec l’objet associé au « nom de partage » à condition d’avoir les droits adéquats.

• Le nom est maintenu tant qu’au moins un processus l’utilise même après rencontre d’une demande de fermeture du handle associé.


Vue en mémoire d’un fichier

• Windows CE autorise la gestion d’un fichier en créant une correspondance entre le fichier ou l’objet mémoire situé dans l’espace partageable et une zone mémoire de l’espace privé du processus (Memory Mapping a File).

• Le processus travaille ainsi dans son espace privé laissant le système répercuter dans le fichier ou l’objet mémoire situé dans l’espace partagé les modifications faites en mémoire privée.


Usage de la mémoire partagée (1)

• Création ou ouverture d’un fichier en prévision de l’installation d’un « mappage » en mémoire– CreateFileForMapping

• L’opération tient compte de droits d’accès, ouvertures multiples, etc.

• Avec cette fonction, Windows CE crée ou ouvre un nom de fichier au niveau du système plutôt qu’au niveau processus. Cela rend l’objet visible par plusieurs processus.



• Association d’un nom de partage qui n’existe pas encore à un fichier ou récupération d’un handle sur la zone partagée si le nom de partage existe déjà– CreateFileMapping

• Le nom de fichier n’est pas indispensable : quand il n’y en a pas, le système utilise une zone en mémoire physique pour créer l’objet partagé.



• Création de la vue en mémoire du fichier et installation du lien avec l’objet associé– MapViewOfFile

• Libération du lien– UnmapViewOfFile

• La fonction UnmapViewOfFile ne ferme pas l’objet associé mais indique au système que ce processus n’a plus besoin de l’objet. La libération ne sera effective que lorsqu’il n’y aura plus aucun lien sur l’objet.


CreateFileForMapping (1)

• Création d’un fichier ou ouverture d’un fichier existant, en vue d’un mappage en mémoire

HANDLE CreateFileForMapping(LPCTSTR lpFileName,DWORD dwDesiredAccess,DWORD dwShareMode, LPSECURITY_ATTRIBUTES lpSecurityAttributes,

DWORD dwCreationDisposition,DWORD dwFlagsAndAttributes,HANDLE hTemplateFile );


CreateFileForMapping (2)

• Valeur de retour :– Handle sur un nom de fichier créé – Handle sur un alias pour un fichier existant– Erreur INVALID_HANDLE_VALUE

• En cas de handle valide, on peut savoir si le fichier existait avant l’appel

• On peut préciser le type des accès, autoriser les accès multiples, etc.


CreateFileMapping (1)

• Création d’un objet anonyme ou nommé associé à un fichier spécifié

HANDLE CreateFileMapping(HANDLE hFile,LPSECURITY_ATTRIBUTES lpFileMappingAttributes,

DWORD flProtect,DWORD dwMaximumSizeHigh,DWORD dwMaximumSizeLow,LPCTSTR lpName );


CreateFileMapping (2)

• Valeur de retour :– Handle associé à un fichier existant– Handle sur un objet mémoire anonyme – Erreur INVALID_HANDLE_VALUE

• En cas de handle valide, on peut savoir si l’objet existait avant l’appel

• On peut créer un nom de partage• On peut préciser le type des accès, la taille, etc.


MapViewOfFile (1)

• Cette fonction rend visible le contenu d’un fichier dans l’espace d’adresse du process appelant

LPVOID MapViewOfFile( HANDLE hFileMappingObject, DWORD dwDesiredAccess, DWORD dwFileOffsetHigh, DWORD dwFileOffsetLow, DWORD dwNumberOfBytesToMap );


MapViewOfFile (2)

Valeur de retour :– Adresse mémoire de la vue du fichier – Erreur : NULL


UnmapViewOfFile

• Supprime le lien mémoire qui permet de voir un fichier dans l’espace d’adresse du processus appelant

BOOL UnmapViewOfFile( LPCVOID lpBaseAddress );

• Valeur de retour– Non nulle en cas de succès


CreateProcess

• Nous utilisons cette fonction avec seulement deux paramètres (les autres sont NULL) :

– Le nom du processus à créer, ici INTER_B– L’adresse de la structure qui contiendra les

informations relatives au process

• Dans la structure d’information créée au chargement de INTER_B, nous récupérons le handle de INTER_B

• Avec le handle de INTER_B, nous surveillons la fin du processus INTER_B


PROCESS_INFORMATION

• Structure déclarée par un typedef dans Winbase.h

• Membres– Handle du processus créé– Handle du thread primaire du processus– Identificateur numérique global pour le processus – Identificateur numérique global pour le thread

• Garnie par le noyau à la création du processus


ExitProcess

VOID ExitProcess( UINT uExitCode );• Cette fonction termine proprement un processus

– En fermant les threads et les handles– En libérant les ressources mémoires– En permettant au noyau de gérer les noms créés

pour les événements, les noms de partage, etc.– En mettant à jour les indicateurs d’appels de dll– Etc.

• La fonction fournit un code de retour au processus appelant, récupérable par la fonction GetExitCodeProcess


GetExitCodeProcess

BOOL GetExitCodeProcess(HANDLE hProcess, LPDWORD lpExitCode );

• Cette fonction permet de lire le code de retour préparé par le processus dont on donne le handle. Tant que le processus n’est pas terminé, la valeur reçue est la valeur réservée STILL_ACTIVE.


Application INTER_A et INTER_B

• INTER_A et INTER_B sont des processus séparés

• INTER_A dispose d’une information dans un fichier ou dans un buffer privé

• INTER_A crée un objet nommé et place le contenu de son buffer privé dans la mémoire publique

• INTER_B ouvre l’objet nommé et prélève l’information dans la mémoire partagée pour la placer dans son buffer privé


INTER_A

• Création du fichier d’informations à partager• Création du nom de partage• Établissement de la correspondance adresse• Édition de messages• Écriture dans le fichier• Lancement du processus INTER_B• Attente de la fin du process INTER_B• Libération des ressources• Fin du process INTER_A


INTER_B

• Édition de messages• Accès au nom de partage• Établissement de la correspondance adresse• Lecture dans le fichier• Édition de message• Libération de ressource• Fin du process INTER_B avec envoi d’un code

de retour au process appelant


INTER_A (1)

// INTER_A.cpp : Defines the entry point for the application.#include "stdafx.h"#include <Pkfuncs.h>/*Pour information, le typedef étant dans Winbase.h typedef struct _PROCESS_INFORMATION {

HANDLE hProcess; HANDLE hThread; DWORD dwProcessId; DWORD dwThreadId; } PROCESS_INFORMATION; */


INTER_A (2)

int WINAPI WinMain( HINSTANCE hInstance, HINSTANCE hPrevInstance, LPTSTR lpCmdLine, int nCmdShow){

WCHAR wcBuffer[256]={_T("JE SUIS UN BUFFER DU PROCESS INTER_A !!!")};HANDLE hmyDataFile;

HANDLE hFileMapping;LPVOID lpMappedMemAddress;PROCESS_INFORMATION process_info_INTER_B;DWORD dwExitCode_INTER_B;


INTER_A (3)

// Création du fichier à partagerhmyDataFile = CreateFileForMapping(_T("myDataFile.txt"),

GENERIC_READ|GENERIC_WRITE,FILE_SHARE_READ,NULL,CREATE_ALWAYS,FILE_ATTRIBUTE_NORMAL,NULL);

if(hmyDataFile == NULL){

RETAILMSG(1,(TEXT("INTER_A: Pb Création myDataFile.\n" )));

return ExitProcess(0);}


INTER_A (4)

// Création du nom de partage

hFileMapping = CreateFileMapping(hmyDataFile,NULL,PAGE_READWRITE,0,1024,

_T("NOM_DE_PARTAGE_myDataFile"));

if(hFileMapping == NULL)

{

RETAILMSG(1,(TEXT("INTER_A: Pb Création NOM_DE_PARTAGE_myDataFile.\n")));

return ExitProcess(0);

}


INTER_A (5)

// Récupération de l'adresse utilisable pour communiquer lpMappedMemAddress = MapViewOfFile( hFileMapping,FILE_MAP_WRITE,0,0,0);if(lpMappedMemAddress == NULL){

RETAILMSG(1,(TEXT("INTER_A: Pb adresse mémoire de communication\n")));



INTER_A (6)

// Édition de messages

RETAILMSG(1,(TEXT("INTER_A: Adresse du buffer: %x\n"),wcBuffer));

RETAILMSG(1,(TEXT("INTER_A: Information à transférer: %s\n"),wcBuffer));

RETAILMSG(1,(TEXT("INTER_A: Adresse mémoire pour la communication: %x\n"), lpMappedMemAddress));


INTER_A (7)

// Écriture des informatons à partager dans le fichier créé

memcpy(lpMappedMemAddress,wcBuffer, sizeof wcBuffer);


INTER_A (8)

// Création du process INTER_Bif(!CreateProcess(_T("INTER_B.exe"),NULL, NULL,NULL,NULL,0,NULL,NULL,NULL, &process_info_INTER_B)){

RETAILMSG(1,(TEXT("INTER_A: Pb création INTER_B.exe\n")));

UnmapViewOfFile(lpMappedMemAddress);return ExitProcess(0);

}


INTER_A (9)

// Attente de la fin du process INTER_B.while(

GetExitCodeProcess(process_info_INTER_B.hProcess,&dwExitCode_INTER_B),

dwExitCode_INTER_B == STILL_ACTIVE)Sleep(0);

RETAILMSG(1,(TEXT("INTER_A: dwExitCode_INTER_B = %d\n"),dwExitCode_INTER_B));


INTER_A (10)

// Libération des ressources

UnmapViewOfFile(lpMappedMemAddress);

DeleteFile(_T("myDataFile.txt"));

RETAILMSG(1,(TEXT("INTER_A: Fin du process INTER_A\n")));


}


INTER_B (1)

// INTER_B.cpp : Defines the entry point for the application.

#include "stdafx.h"

#include <Pkfuncs.h>

int WINAPI WinMain(HINSTANCE hInstance,

HINSTANCE hPrevInstance,

LPTSTR lpCmdLine,

int nCmdShow)

{


INTER_B (2)

HANDLE hFileMapping;

LPVOID lpMappedMemAddress;

WCHAR wcBuffer[256]={_T("Je suis un buffer du process INTER_B !!!")};

RETAILMSG(1,(TEXT("INTER_B: Adresse du buffer: %x\n"),wcBuffer));

RETAILMSG(1,(TEXT("INTER_B: Buffer avant lecture: %s\n"),wcBuffer));


INTER_B (3)

// Ouverture du handle vers la zone de mémoire partagée

hFileMapping = CreateFileMapping(INVALID_HANDLE_VALUE,NULL,PAGE_READWRITE,0,1024,_T("NOM_DE_PARTAGE_myDataFile"));

// Vérifier que le handle n’est pas nul et que le nom choisi existe bien

if(hFileMapping == NULL || !(GetLastError()==ERROR_ALREADY_EXISTS)){

RETAILMSG(1,(TEXT("INTER_B: Pb création mémoire partagée.\n")));



INTER_B (4)

// Récupération de l'adresse mémoire utilisable pour communiquerlpMappedMemAddress = MapViewOfFile(

hFileMapping,FILE_MAP_READ,0,0,0);if(lpMappedMemAddress == NULL){ RETAILMSG(1,(TEXT("INTER_B: Pb adresse mémoire partagée.\n"))); return ExitProcess(20000);}


INTER_B (5)

RETAILMSG(1,(TEXT("INTER_B: Adresse mémoire pour la communication: %x\n"), lpMappedMemAddress));

// Lecture de l’information

memcpy(wcBuffer,lpMappedMemAddress, sizeof wcBuffer);

// Contenu du buffer de INTER_B après lecture

RETAILMSG(1,(TEXT("INTER_B: Buffer après lecture: %s\n"),wcBuffer));


INTER_B (6)

// Libération du lien


RETAILMSG(1,(TEXT("INTER_B: Fin du process INTER_B\n")));

// Libération des ressources et retour


}


BUILD

• INTER_A non inclus dans l’image• INTER_B inclus dans l’image


Exécution de INTER_A

INTER_A: Adresse du buffer: 1202f9f8INTER_A: Information à transférer: JE SUIS UN BUFFER DU

PROCESS INTER_A !!!INTER_A: Adresse mémoire pour la communication: 46800000INTER_B: Adresse du buffer: 1402fa10INTER_B: Buffer avant lecture: Je suis un buffer du process

INTER_B !!!INTER_B: Adresse mémoire pour la communication: 46800000INTER_B: Buffer après lecture: JE SUIS UN BUFFER DU PROCESS

INTER_A !!!INTER_B: Fin du process INTER_BINTER_A: dwExitCode_INTER_B= 12345INTER_A: Fin du process INTER_A


Variante

• Ici, l’information à partager ne concerne que le contenu d’un buffer. Le passage par un fichier n’est pas indispensable et on peut obtenir le même résultat en modifiant INTER_A pour que le nom de partage corresponde à une zone mémoire physique au lieu d’un fichier.

• INTER_B ne voit aucune différence. Pour s’en assurer on ne modifiera rien dans son écriture.


INTER_C (1)

• Nous modifions INTER_A en INTER_C pour travailler dans une zone mémoire physique et non plus dans un fichier.

• Dans INTER_A,– nous supprimons la création et la destruction du

fichier– dans la création du nom de partage, nous utilisons

un handle invalide

• Nous conservons le même nom de partage pour ne rien modifier dans INTER_B

• INTER_B reste inchangé


INTER_C (2)

// Création du nom de partagehFileMapping = CreateFileMapping(

INVALID_HANDLE_VALUE,NULL,PAGE_READWRITE,0,1024,_T("NOM_DE_PARTAGE_myDataFile"));

if(hFileMapping == NULL){

RETAILMSG(1,(TEXT("INTER_A: Pb Création NOM_DE_PARTAGE_myDataFile.\n")));



Exécution de INTER_C

INTER_A: Adresse du buffer: 1202f9f8INTER_A: Information à transférer: JE SUIS UN BUFFER DU

PROCESS INTER_A !!!INTER_A: Adresse mémoire pour la communication: 46800000INTER_B: Adresse du buffer: 1402fa10INTER_B: Buffer avant lecture: Je suis un buffer du process

INTER_B !!!INTER_B: Adresse mémoire pour la communication: 46800000INTER_B: Buffer après lecture: JE SUIS UN BUFFER DU PROCESS

INTER_A !!!INTER_B: Fin du process INTER_BINTER_A: dwExitCode_INTER_B= 12345INTER_A: Fin du process INTER_A


Travail à réaliser


Exercice

• Dans cette nouvelle application, nous abordons le partage de code.

• Sur une plate-forme émulateur, il faut créer deux applications INTER_D et INTER_E qui vont coopérer.

• INTER_D sera au choix, insérée ou non dans l’image à télécharger

• INTER_E sera obligatoirement insérée dans l’image à télécharger.


INTER_D et INTER_E

• INTER_D désire exécuter pour son compte le processus INTER_E.

INTER_E est ici un processus séparé mais pourrait aussi être une dll.

• INTER_D demande à INTER_E de lire un buffer dans sa mémoire privée, pour envoyer ces informations ailleurs, par exemple sur un périphérique, dans une zone mémoire système, etc.


INTER_D (1)

• Par le mécanisme vu précédemment de communication entre processus, grâce à un nom de partage, INTER_D va proposer dans la mémoire partagée les deux informations utiles pour qu’un autre processus puisse lire son buffer:

– Permissions courantes du processus INTER_D– Adresse du buffer en mémoire privée de INTER_D

• Ces deux informations sont logées dans une structure pour laquelle on crée un type propre BUFFERINFORMATION


INTER_D (2)

• L’adresse en mémoire privée correspondra à un buffer contenant des informations

– L’information est un message– Pour simplifier, nous supposons qu’il n’y a pas de

problème de longueur d’information, sinon il faudrait placer un troisième élément dans la structure communiquée

– Ici, la longueur est implicite, indiquée par le \0 qui termine le message information

• Libérer les ressources


INTER_E

• Récupère l’information structure de type BUFFERINFORMATION proposée par INTER_D

• Récupère l’adresse proposée du buffer à lire• Récupère les permissions pour avoir accès à

l’espace où se trouve le buffer, ici INTER_D• Récupère et imprime le contenu de la zone lue

dans une mémoire privée, ici chez INTER_D• Libère les ressources utilisées• Renvoie un code de retour


Fonctions utiles

En plus des fonctions déjà rencontrées, il faut utiliser des fonctions complémentaires :

• GetCurrentProcess ou GetCurrentProcessId• MapPtrToProcess et UnMapPtr• GetCurrentPermissions• SetProcPermissions• CloseHandle


GetCurrentProcess (1)

• Cette fonction retourne un pseudohandle sur le processus courant.

HANDLE GetCurrentProcess(void);

Valeur de retour

Pseudohandle sur le processus courant

• Ce handle sera utilisé comme argument par la fonction MapPtrToProcess.


GetCurrentProcess (2)

• Ce pseudohandle est à manier avec précautions et peut être remplacé par un handle moins dangereux construit sur l’identificateur associé au processus fourni par la fonction

GetCurrentProcessId.

• Un pseudohandle ne doit jamais être fermé (l'utilisation de CloseHandle peut être dévastatrice)


GetCurrentPermissions

Cette fonction récupère pour le thread courant les bits du masque interne qui gère les accès aux espaces mémoire.

DWORD GetCurrentPermissions (void);

Paramètresaucun

Valeur de retour :les permissions du thread courant


SetProcPermissions

• Cette fonction positionne pour le thread courant les bits du masque interne qui peut gérer des accès aux espaces mémoire d’ autres processus.

DWORD SetProcPermissions( DWORD newperms );

• Valeur de retour :les anciennes permissions


MapPtrToProcess

• Cette fonction transpose une adresse dans un espace mémoire dans sa correspondante dans l’espace mémoire d’un processus.

LPVOID MapPtrToProcess( LPVOID lpv,

HANDLE hProc ); • Valeur de retour :

Adresse correspondante à lpv dans l’espace du processus de handle hProc ou NULL en cas d’erreur.


UnMapPtr

• Cette fonction supprime une correspondance d’adresse établie précédemment par MapPtrToProcess.

LPVOID UnMapPtr( LPVOID lpv );

• Valeur de retour :valeur de l’adresse dans son espace de départ


Fichier d’en-tête INTER_DE.h

• Utilisé par INTER_D et INTER_E

#include <Pkfuncs.h>

typedef struct

{

DWORD dwProcPermissions;

WCHAR *MapPtr;

} BUFFERINFORMATION;


INTER_D (1)

// INTER_D.cpp : Defines the entry point for the application.

#include "stdafx.h"

#include "INTER_DE.h"



LPTSTR lpCmdLine,

int nCmdShow)

{


INTER_D (2)

//Déclarations WCHAR wcBuffer[256]={_T("JE SUIS UN BUFFER

EN MEMOIRE PRIVEE DE INTER_D !!!")};

BUFFERINFORMATION BufferInformation;



PROCESS_INFORMATION process_info_INTER_E;

DWORD dwExitCode_INTER_E;


INTER_D (3)

// Création du nom de partage // TODO

// Récupération de l'adresse utilisable pour communiquer // TODO

// Édition de messages// TODO

// Récupération des permissions// TODO


INTER_D (4)

// Mappage de l'adresse

// TODO

// Édition de l’adresse après mappage

// TODO

// Écriture en mémoire physique

// TODO


INTER_D (5)

// Création du processus INTER_Eif(!CreateProcess(_T("INTER_E.exe"),NULL, NULL,NULL,NULL,0,NULL,NULL, NULL,&process_info_INTER_E)){

RETAILMSG(1,(TEXT("INTER_D: Pb création du processus INTER_E.exe\n")));

UnmapViewOfFile(lpMappedMemAddress);return ExitProcess(0);

}


INTER_D (6)

// Attente de la fin du processus INTER_E.

while(GetExitCodeProcess(

process_info_INTER_E.hProcess,

&dwExitCode_INTER_E), dwExitCode_INTER_E == STILL_ACTIVE)

Sleep(0);

RETAILMSG(1,(TEXT("INTER_D: Code de retour fourni par le processus INTER_E = %d\n"),

dwExitCode_INTER_E));


INTER_D (7)

// Libération des ressources


UnMapPtr(BufferInformation.MapPtr);

RETAILMSG(1,(TEXT("INTER_D: Fin du processus INTER_D\n")));


}


INTER_E (1)

// INTER_E.cpp : Defines the entry point for the application.

#include "stdafx.h"

#include "INTER_DE.h"



LPTSTR lpCmdLine,

int nCmdShow)

{


INTER_E (2)

// Déclarations



BUFFERINFORMATION BufferInformation;

DWORD dwProcPermissions;


INTER_E (3)

// Ouverture du handle vers la zone de mémoire partagée

// TODO

// Récupération de l’adresse mémoire utilisable pour communiquer

// TODO

// Récupération et visualisation des informations passées dans la mémoire partagée

// TODO


INTER_E (4)

// Sauvegarde des permissions courantes du

processus // TODO

// Remplacement des permissions d'accès par celles du processus INTER_D

// TODO

// Lecture, visualisation du buffer du processus INTER_D

// TODO


INTER_E (5)

// Restauration des permissions du processus INTER_E

// TODO

// Libération du lien // TODO

// Libération des ressources et retour // TODO



Variante (1)

• Dans INTER_D le buffer alloué se trouve dans l’espace propre du processus. La fonction qui établit la correspondance d’adresse peut être supprimée.

• Ce n’est plus le cas lorsque le buffer est alloué dynamiquement : il se trouve logé dans l’espace réservé au slot 0. La fonction qui transforme l’adresse pour obtenir sa valeur dans le slot du processus est alors indispensable.


Variante (2)

• Il n’est pas illogique de laisser cet appel de fonction pour éviter de retoucher le reste du code lorsqu’on modifie le type d’allocation.

• Dans INTER_F, obtenu par modification de INTER_D, nous traitons le cas d’une allocation dynamique.

• Ce genre de manipulations aide à comprendre les problèmes de gestion de la mémoire dans Windows CE.


INTER_F (1)

• Modifications dans INTER_D pour obtenir un buffer en allocation dynamique

// DéclarationWCHAR *lpBuffer;

// Allocation dynamique d'espace et remplissage lpBuffer = (WCHAR*)malloc(256*sizeof(WCHAR)); wcscpy(lpBuffer,_T("Je suis un buffer de l'INTER_F !!!"));


INTER_F (2)

// Supprimer le buffer wcBuffer

// Remplacer dans le code toute utilisation de wcBuffer par lpBuffer

// Libération de l’espace alloué

free(lpBuffer);


Résultats à obtenir avec INTER_D

INTER_D: Adresse du buffer: 1202f9f4INTER_D: Information à transférer: JE SUIS UN BUFFER EN

MEMOIRE PRIVEE DE INTER_D !!! INTER_D: Adresse mémoire pour la communication: 46800000INTER_D: Adresse du buffer après mappage: 1202f9f4INTER_E: Adresse mémoire pour la communication: 46800000INTER_E: Adresse du buffer en absolu: 1202f9f4INTER_E: Permissions du processus INTER_D: 0101INTER_E: Permissions du processus INTER_E: 0201INTER_E: Lecture du buffer dans INTER_D: JE SUIS UN BUFFER EN

MEMOIRE PRIVEE DE INTER_D !!!INTER_E: Fin du processus INTER_EINTER_D: Code de retour fourni par le processus INTER_E = 12345INTER_D: Fin du processus INTER_D


Résultats à obtenir avec INTER_F

INTER_F: Adresse du buffer: 30050INTER_F: Information à transférer: Je suis un buffer de l'INTER_F !!!INTER_F: Adresse mémoire pour la communication: 46800000INTER_F: Adresse du buffer après mappage: 12030050INTER_E: Adresse mémoire pour la communication: 46800000INTER_E: Adresse du buffer en absolu: 12030050INTER_E: Permissions du processus INTER_D: 0101INTER_E: Permissions du processus INTER_E: 0201INTER_E: Lecture du buffer dans INTER_D: Je suis un buffer de

l'INTER_F !!!INTER_E: Fin du processus INTER_EINTER_F: Code de retour fourni par le processus INTER_E = 12345INTER_F: Fin du processus INTER_F


Conclusion

• Exemples pratiques de communication d’information entre plusieurs process situés chacun dans un espace privé.

Documents

Jc/md/lp-01/05Communication inter processus1 Communication inter process Présentation