Bonjour à tous,
alors voici mon problème je compile sous Knoppix 5.01 avec le compilateur cc (... -o .. -lrt)et j'ai 2 prcessus indépendant , le premier qui doit lire un mot taper dans la mémoire partagée ne me pose apparament pas de problèmes mais j'ai chaque fois une erreur "segmentation fault" pas à la compilation du deuxième processus mais à son exécution et je pense que c'est dû au moment de la création de la mémoire partagée, c'est dans ce deuxième processus que l'utilisateur doit entrer un mot de 9 caractères maximum et si il tape le mot "FIN", alors ce doit être la fin des 2 processus et donc du programme. Je suis obligé d'utiliser les mémoires partagées et des sémaphores pour gérer les accès!?
Pouvez-vous m'aider, c'est urgent je dois rendre ce travail pour le 3 septembre et 2 autres travaux dépendent de celui-ci! :-(
Merci.
A bientôt!
Code:
PS1:
/******************************************************************/
/* PROGRAMME SUR LES MEMOIRES PARTAGEES ET LES SEMAPHORES */
/* EXERCICE 6 : PS1:2 PROCESS INDEPENDANTS AVEC LECTURE */
/* ET ECRITURE DANS LA MEMOIRE PARTAGEE ET */
/* SEMAPHORE POUR GERER ACCES A LA MEMOIRE */
/* PARTAGEE */
/* REALISE PAR : CHRISTOPHE DRIESEN */
/* SECTION : 3EME INFORMATIQUE INDUSTRIELLE */
/* ANNEE 2006/2007 */
/* PROFESSEUR : M. BENITEZ */
/******************************************************************/
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h> /*pour mémoires partagées*/
#include <stdio.h>
#include <sys/file.h>
#include <sys/mman.h> /*pour mémoires partagées, pour mmap*/
#include <fcntl.h>
#include <sys/stat.h>
#include <errno.h>
#include <semaphore.h>
#include <string.h> /*pour memcpy*/
/********************/
/* VARIABLE GLOBALE */
/********************/
char mot[10];
/************************/
/* PROGRAMME PRINCIPALE */
/************************/
void main()
{
char bonmot[10]={'F','I','N','\0'};
int shmch,test; /*file descriptor*/
caddr_t pg_addr; /*pour mappage de la memoire partagée*/
size_t size = 10; /*taille de la memoire qui sera reservee en octets*/
int mode = S_IRWXO|S_IRWXG|S_IRWXU; /*accès complet pour groupe, user et root en
cas de creation dans shm_open*/
struct timespec intervallps1, remainder; /*structure nécessaire au fonctionnement de la fonction nanosleep*/
/*remainder peut être utilisé pour rappeler à nouveau nanosleep
afin de terminer la pause*/
intervallps1.tv_sec = 2; /*spécifie les secondes*/
intervallps1.tv_nsec = 250000000; /*spécifie les nanosecondes*/
/***********************/
/* CREATION DU FICHIER */
/***********************/
shmch = shm_open("SHMTEST", O_RDWR|O_CREAT, mode);/*nom ouverture mémoire partagee, en
lecture et ecriture sinon creation,mode = permission donnee sur l'accès
au fichier s'il est cree*/
/*printf("\n%d\n\n",shmch);*/
if (shmch == -1)
{
perror("Erreur à l'ouverture!");
exit(1);
};
/*Changer la taille de la mémoire partagée*/
if ((ftruncate(shmch, size)) == -1) /*shmch valeur de retour de la shm_open,
permet de fixer la taille de la shm*/
{
perror("ftruncate failure");
exit(1);
}
/*mmap du fichier et allocation de la place dans la mémoire pour le processus*/
pg_addr = mmap(0, size, PROT_READ|PROT_WRITE|PROT_EXEC, MAP_SHARED,shmch, 0);
/*mmap permet de mapper le fichier dans la memoire, (adresse de
depart de la resevation, taille réservée, prot_* protection du
fichier ici la page peut etre lu executee et ecrite, shmch file
descriptor,'0' pour debut du tableau)*/
/************************/
/* VERIFICATION DU MMAP */
/************************/
if (pg_addr == (caddr_t) -1)
{
perror("mmap failure");
exit(1);
}
sem_t *semach;
int i=0,*a;
/**********************/
/**********************/
/* Creation semaphore */
/**********************/
/**********************/
semach = sem_open("semamoi", O_CREAT, 0744, 0);
/*sem_open crée une connexion entre le semaphore nommé et un
process, ("nom du sema", création du sema, permission sur
le fichier, priorite du semaphore)*/
sem_post(semach);
sem_getvalue(semach,a);
printf("Valeur semaphore depart : %d\n",*a);
/*****************************/
/* Test si erreur */
/*****************************/
if (semach == (void *)-1) /*renvoi -1 s'il n'y a pas de création du sémaphore*/
{
perror("erreur initialisation!!!");
}
/*printf ("\033[2J"); nettoye buffer clavier*/
test=0;
do
{
sem_wait(semach); /*blocage du sémaphore*/
sem_getvalue(semach,a);
printf("Valeur semaphore apres un sem_wait: %d\n",*a);
i++;
printf("Compteur : %d\n",i);
if(semach==0)
{
memcpy(&mot,pg_addr,sizeof(mot[10]));
printf("%s\n",mot);
}
printf("TEST avant : %d\n",test);
test=strncmp(mot,bonmot,4);
printf("TEST après : %d\n",test);
sem_post(semach);
sem_getvalue(semach,a);
printf("Valeur semaphore apres sem_post : %d\n",*a);
printf("Attente ecriture memoire partagee\n ");
nanosleep(&intervallps1,NULL);
}while(test!=0);
if (munmap(0, size) < 0) /*Unmap adresse */
{
perror("unmap error");
exit(1);
}
else
{
munmap(0, size);
}
/**************************/
/*fermeture du semaphore*/
/**************************/
sem_close(semach);
/**************************/
/*destruction du semaphore*/
/**************************/
sem_unlink("semamoi");
/**************************/
/*fermeture du de la shm*/
/**************************/
close(shmch);
/**************************/
/*destruction du de la shm*/
/**************************/
shm_unlink("SHMTEST");
return;
}
PS2:
/*******************************************************************/
/* PROGRAMME SUR LES MEMOIRES PARTAGEES ET LES SEMAPHORES */
/* EXERCICE 6 : PS 2:2 PROCESS INDEPENDANTS AVEC LECTURE */
/* ET ECRITURE DANS LA MEMOIRE PARTAGEE ET */
/* SEMAPHORE POUR GERER ACCES A LA MEMOIRE */
/* PARTAGEE */
/* REALISE PAR : CHRISTOPHE DRIESEN */
/* SECTION : 3EME INFORMATIQUE INDUSTRIELLE */
/* ANNEE 2006/2007 */
/* PROFESSEUR : M. BENITEZ */
/*******************************************************************/
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h> /*pour mémoires partagées*/
#include <stdio.h>
#include <sys/file.h>
#include <sys/mman.h> /*pour mémoires partagées, pour mmap*/
#include <fcntl.h>
#include <sys/stat.h>
#include <errno.h>
#include <semaphore.h>
#include <string.h> /*pour memcpy*/
/********************/
/* VARIABLE GLOBALE */
/********************/
char mot2[10];
/************************/
/* PROGRAMME PRINCIPALE */
/************************/
main()
{
char bonmot2[10]={'F','I','N','\0'};
int shmch; /*file descriptor*/
long temps;
caddr_t pg_addr; /*pour mappage de la memoire partagée*/
size_t size = 10; /*taille de la memoire qui sera reservee en octets*/
int mode = S_IRWXO|S_IRWXG|S_IRWXU; /*accès complet pour groupe, user et root en
cas de creation dans shm_open*/
struct timespec interval, remainder; /*structure nécessaire au fonctionnement de la fonction nanosleep*/
/*remainder peut être utilisé pour rappeler à nouveau nanosleep
afin de terminer la pause*/
interval.tv_sec = 0; /*spécifie les secondes*/
interval.tv_nsec = 250000000; /*spécifie les nanosecondes*/
/***********************/
/* CREATION DU FICHIER */
/***********************/
shmch = shm_open("SHMTEST", O_RDWR, mode);/*nom ouverture mémoire partagee, en
lecture et ecriture,mode = permission donnee sur l'accès
au fichier s'il est cree*/
printf("\n%d\n\n",shmch);
printf("ici");
if (shmch == -1)
{
perror("Erreur à l'ouverture!");
exit(1);
}
/*Changer la taille de la mémoire partagée*/
if ((ftruncate(shmch, size)) == -1) /*shmch valeur de retour de la shm_open,
permet de fixer la taille de la shm*/
{
perror("ftruncate failure");
exit(1);
}
/*mmap du fichier et allocation de la place dans la mémoire pour le processus*/
pg_addr = (caddr_t) mmap(0, size, PROT_READ|PROT_WRITE|PROT_EXEC, MAP_SHARED,shmch, 0);
/*mmap permet de mapper le fichier dans la memoire, (adresse de
depart de la resevation, taille réservée, prot_* protection du
fichier ici la page peut etre lu executee et ecrite, shmch file
descriptor,'0' pour debut du tableau)*/
/************************/
/* VERIFICATION DU MMAP */
/************************/
if (pg_addr == (caddr_t) -1)
{
perror("mmap failure");
exit(1);
}
sem_t *semach;
int i=0,*a;
/**********************/
/**********************/
/* Creation semaphore */
/**********************/
/**********************/
semach = sem_open("semamoi", O_RDWR|O_CREAT, 0744, 0);
/*sem_open crée une connexion entre le semaphore nommé et un
process, ("nom du sema", création du sema, permission sur
le fichier, priorite du semaphore)*/
/*sem_post(semach);*/
sem_getvalue(semach,a);
printf("Valeur de départ du semaphore : %d\n",*a);
/*****************************/
/* Test si erreur */
/*****************************/
if (semach == (void *)-1) /*renvoi -1 s'il n'y a pas de création du sémaphore*/
{
perror("erreur initialisation!!!");
}
/********************************************/
/* ENCODAGE MOT */
/********************************************/
int test2=0;
do
{
sem_wait(semach); /*libération du sémaphore*/
sem_getvalue(semach,a);
printf("Valeur du semaphore dans DO apres sem_wait(): %d\n",*a);
/*if(semach=0)
{*/
printf("\nEntrer un mot de 9 caracteres maximum : ");
scanf("%s",&mot2[10]);
/*printf("Vous avez entré : %s\n",mot[10]);*/
printf("Entrer un temps de 10 a 99 : ");
scanf("%d",&temps);
interval.tv_nsec=(temps+10000000);
nanosleep(&interval,NULL);
/*memcpy(pg_addr,&mot2,sizeof(mot2[10]));*/
printf("TEST avant : %d\n",test2);
test2=strncmp(mot2,bonmot2,4);
printf("TEST apres : %d\n",test2);
printf("test2 : %d",test2);
/*printf ("\033[2J"); nettoye l'ecran*/
/*}*/
sem_post(semach);
}while(test2!=0);
/*
if (munmap(0, size) < 0) Unmap adresse
{
perror("unmap error");
exit(1);
}
else
{
munmap(0, size);
}*/
/**************************/
/*fermeture du semaphore*/
/**************************/
/*
sem_close(semach);
*/
/**************************/
/*fermeture du de la shm*/
/**************************/
/*
close(shmch);
*/
return 0;
}