Segmentation fault programmationsystème sous Knoppix 5.01 avec cc????

Signaler
Messages postés
1
Date d'inscription
samedi 25 août 2007
Statut
Membre
Dernière intervention
25 août 2007
-
Messages postés
206
Date d'inscription
samedi 29 octobre 2005
Statut
Membre
Dernière intervention
7 mars 2012
-
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
#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
#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;

}

1 réponse

Messages postés
206
Date d'inscription
samedi 29 octobre 2005
Statut
Membre
Dernière intervention
7 mars 2012

Salut,




J'ai survolé ton code, et je l'avoue, je n'ai pas tout compris. Je n'ai pas essayé de le faire marché (de tête trop fatigué pour ça) et pas de machine linux sous la main... Mais il me semble que :


Segmentation fault tu essayes d'accéder à une mémoire non allouée problème de pointeur

Or dans ton code :
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);

je ne pense pas que sem_getvalue alloue la mémoire pour a.
Essaye :

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);