Erreur de segmentation en C

[Rockleader]

Bonsoir; je n'arrive pas à détecter deux erreurs

La première est la suivante; je désire décrémenter un compteur lorsqu'un fichier ne peut pas être ouvert; hors je décrémente même lorsque le fichier existe !!!

Code: Tout sélectionner

g_disk.ndisk=NUMBER_OF_DISKS;
int fich=NUMBER_OF_DISKS;
   int k=0;
   int courant;
   int precedent;
   struct dirent *lecture;
        while ((lecture = readdir(rep)))
        {
                courant=strcmp(".",lecture->d_name);
                precedent=strcmp("..",lecture->d_name);
                if (courant != 0 && precedent != 0)
                {
                   g_disk.storage[k]=fopen(lecture->d_name,"r+");
                   if ((g_disk.storage[k]=fopen(lecture->d_name,"r+"))==NULL)
                   {
                      fich=fich-1;
                      printf("trace 1\n"); /*s'affiche autant de fois que de fichier différents de . et ..
                   }
                }
                k=k+1;
        }

La seconde est la suivante; lorsque j'en chaine ce sous programme avec le suivant qui doit fermer les fichiers je prends une erreur de segmentation.

Code: Tout sélectionner

void close_disk_raid5(void)
{
   int k;
   for(k=0;k<g_disk.ndisk;k++)
    {
      fclose(g_disk.storage[k]);   
   }
}

:mur:

[ampholyte]

Bonjour,

Pour ton premier problème, déjà une erreur importante :

g_disk.storage[k]=fopen(lecture->d_name,"r+");
if ((g_disk.storage[k]=fopen(lecture->d_name,"r+"))==NULL)

Ici tu ouvres 2 fois ton fichier s'il existe, ce qui peut être embetant.

Pourquoi ne pas faire simplement :

Code: Tout sélectionner

#include
g_disk.storage[k] = fopen(lecture->d_name, "r+");
if (g_disk.storage[k] == NULL) {
    /* Ici on affiche pourquoi ça renvoit null sur le fichier lecture->d_name */
    fprintf(stderr, "%s : fopen : %s\n", lecture->d_name, strerror(errno));
}


Ci-dessus j'ai également rajouté un test te permettant de voir pourquoi tes fichiers n'existent pas.
Je pense tout simplement que tu essayes d'ouvrir des fichiers qui ne sont pas existant à l'endroit où ton programme le cherche.

Je pense qu'il vaut mieux que tu envoies le path absolu des fichiers et non le path relative (comme tu le fais) car si tes fichiers ne sont pas dans le dossier de ton exécutable alors il ne les trouvera pas.


Pour le second problème c'est un peu compliqué de voir ce qui ne plante sans voir ton code mais je pense que tu fais un dépassement de tableau (un fclose sur un espace mémoire qui ne devrait pas être fait).

Comment as-tu calculé g_disk.ndisk ?

Comment as-tu initialisé g_disk.storage ?

[Rockleader]

Entre temps, j'ai modifié la fonction et régler le problème effectivement je tentais d'appliquer l'ouverture directement sur le fichier sans inclure le dossier; j'ai donc corrigé ça avec un sprintf.

g_disk est une variable globale cad le mal mais c'est une exigence donc on la respecte

Il ne me reste donc plus que l'erreur de segmentation

Main

Code: Tout sélectionner

init_disk_raid5("dos");
close_disk_raid5();

Code

Code: Tout sélectionner

void init_disk_raid5(char* adresse)
{
   DIR* rep = NULL;
   g_disk.ndisk=NUMBER_OF_DISKS;
   g_disk.raidmode=5;
    rep = opendir(adresse);
    int fich=NUMBER_OF_DISKS;
   int k=0;
   int courant;
   int precedent;
   struct dirent *lecture;
   char fichier[FILENAME_MAX_SIZE];
        while ((lecture = readdir(rep)))
        {
                courant=strcmp(".",lecture->d_name);
                precedent=strcmp("..",lecture->d_name);
                if (courant != 0 && precedent != 0)
                {
                   sprintf(fichier, "%s/%s",adresse,lecture->d_name);
                   g_disk.storage[k]=fopen(fichier,"r+");
                   if ((g_disk.storage[k]=fopen(fichier,"r+"))==NULL)
                   {
                      fich=fich-1;
                   }
                }
                k=k+1;
        }
   closedir(rep);
   if (fich <= NUMBER_OF_DISKS-2)
   {
      printf("Deux fichiers ou plus manquant\n RAID5 cassé \n");
      exit(1);
   }

}

void close_disk_raid5(void)
{
   int k;
   for(k=0;k<g_disk.ndisk;k++)
    {
      fclose(g_disk.storage[k]);   
   }
}


ndisk prend la valeur d'une constante.
storage celle des noms de fichiers par le biais de la structure g_disk en global.

Code: Tout sélectionner

typedef struct virtual_disk_s {
    inode_table_t inodes;
    int ndisk;
    int raidmode;
    FILE *storage[NUMBER_OF_DISKS];
} virtual_disk_t;

virtual_disk_t g_disk;

Au passage lorsque j'utilise exit(1) est ce que ça aura bien pour effet de quitter le programme ?

[ampholyte]

Ok pour g_disk.

Concernant exit(1), cela termine ton programme. Par contre si tu n'as pas rencontré d'erreur dans ton programme, il vaut mieux faire un exit(0). Les autres valeurs indiquent des erreurs :
0 => EXIT_SUCCESS
1 => EXIT_FAILURE

Pour la partie qui segfault, comment sais-tu qu'elle provient de ta fonction close_disk_raid5 ? As-tu utilisé un débogueur (genre GDB si tu es en ligne de commande ou le débogueur de code block ou autre ?).

As-tu essayé d’exécuter ton programme pas à pas (en mettant des breakpoints) pour trouver à quel moment ton programme crash ?

PS : N'oublie pas de corriger ton double fopen.

[Rockleader]

Ok pour g_disk.

Concernant exit(1), cela termine ton programme. Par contre si tu n'as pas rencontré d'erreur dans ton programme, il vaut mieux faire un exit(0). Les autres valeurs indiquent des erreurs :
0 => EXIT_SUCCESS
1 => EXIT_FAILURE

Pour la partie qui segfault, comment sais-tu qu'elle provient de ta fonction close_disk_raid5 ? As-tu utilisé un débogueur (genre GDB si tu es en ligne de commande ou le débogueur de code block ou autre ?).

As-tu essayé d’exécuter ton programme pas à pas (en mettant des breakpoints) pour trouver à quel moment ton programme crash ?

PS : N'oublie pas de corriger ton double fopen.

Ok pour exit j'ai vu juste alors je retourne 1 si le programme ne peut pas s'exécuter.

J'ai testé un affichage entre init et close et cet affichage marche bien donc l'erreur vient bien de la fonction de fermeture !

PS : N'oublie pas de corriger ton double fopen

En faisant le test dans le if je rouvre le fichier une seconde fois ?






PS; j'ai une autre question un peu à part, afin de calculer mes bloc de parité je dois utiliser l'opérateur xor.

Pour simplifier je fais avoir un tableau de caractère et avec le xor je pourrais retrouver des morceaux perdu.

Je voudrais la confirmation que xor en c c'est bien ^

Ensuite, j'ai un peu de mal à concevoir qu'une opération mathématique (logique) puisse donner un résultat sur une chaine de caractère. Mais admettons

Par définition j'ai donc ceci à représenté

P=B0^B1^B2^...^Bn-1
B0=P^B1^B2^...^Bn-1

etc etc

C'est assez chaud je trouve quand même

Est ce la même chose d'écrire A^B^C que d'écrire (A^B)^C ainsi que A^(B^C)


Merci pour ton aide précieuse je suis partie pour une nuit blanche =)

[ampholyte]

Ok pour exit j'ai vu juste alors je retourne 1 si le programme ne peut pas s'exécuter.

J'ai testé un affichage entre init et close et cet affichage marche bien donc l'erreur vient bien de la fonction de fermeture !

Hum je vois. Essaye de faire le test suivant :

Code: Tout sélectionner

if (gdisk.storage[k] != NULL) {
    fclose(gdisk.storage[k]);
}


Lorsque que ton flux est null, un fclose provoque un segfault d'où l'ajout de cette condition.

En faisant le test dans le if je rouvre le fichier une seconde fois ?

Tout à fait vu que tu appelles fopen 2 fois. Du coup le premier flux restera ouvert à la fin de ton programme.

PS; j'ai une autre question un peu à part, afin de calculer mes bloc de parité je dois utiliser l'opérateur xor.

Pour simplifier je fais avoir un tableau de caractère et avec le xor je pourrais retrouver des morceaux perdu.

Je voudrais la confirmation que xor en c c'est bien ^

Ensuite, j'ai un peu de mal à concevoir qu'une opération mathématique (logique) puisse donner un résultat sur une chaine de caractère. Mais admettons

Par définition j'ai donc ceci à représenté

P=B0^B1^B2^...^Bn-1
B0=P^B1^B2^...^Bn-1

etc etc

C'est assez chaud je trouve quand même

Est ce la même chose d'écrire A^B^C que d'écrire (A^B)^C ainsi que A^(B^C)


Merci pour ton aide précieuse je suis partie pour une nuit blanche =)

XOR est commutative et associative donc :

A^B^C = (A^B)^C = A^(B^C) = A^C^B = C^B^A = ...

[Rockleader]

XOR est commutative et associative donc :

A^B^C = (A^B)^C = A^(B^C) = A^C^B = C^B^A = ..

Voilà qui me tire déjà une bonne épine des pattes x)

Merci !

Je continue à réfléchir à cette erreur de segmentation mais je vois vraiment pas d'où elle peut venir

Tout à fait vu que tu appelles fopen 2 fois. Du coup le premier flux restera ouvert à la fin de ton programme.

J'ai encore cramé de la mémoire tu m'avais pourtant prévenu :mur:

Merci ! :lol3:

[ampholyte]

Hum je vois. Essaye de faire le test suivant :

Code:

if (gdisk.storage[k] != NULL) { fclose(gdisk.storage[k]); }


Lorsque que ton flux est null, un fclose provoque un segfault d'où l'ajout de cette condition.

As-tu essayé de rajouter cette condition dans ta fonction dans ta boucle for ?

[Rockleader]

Gomeennnnn

J'avais pas vu ce passage là !! Je teste.

Le programme s'est exécuté sans aucune erreur cette fois ci; mais j'avoue ne pas très bien avoir compris pourquoi. Mes storage ne devrait pas valoir NULL d'après l'initialisation non ?


Une autre question qu'on avait également abordé je crois mais c'est passé aux oubliettes:

Comment se débarrasser d'un warning dû à la fonction strcmp

r5_defines.c: In function ‘init_disk_raid5’:
r5_defines.c:21:17: warning: implicit declaration of function ‘strcmp’ [-Wimplicit-function-declaration]
courant=strcmp(".",lecture->d_name);

[ampholyte]

Gomeennnnn

J'avais pas vu ce passage là !! Je teste.

Le programme s'est exécuté sans aucune erreur cette fois ci; mais j'avoue ne pas très bien avoir compris pourquoi. Mes storage ne devrait pas valoir NULL d'après l'initialisation non ?

Et bien en fait non, vu que lorsque tu as "." et "..", le résutat de fopen est null et comme k est quand même incrémenté alors g_disk.storage[k] sera NULL pour 2 valeurs de k (sûrement les 2 premières).

Pour éviter cela, tu peux rajouter la condition avant d'incrémenter k, ainsi si ton résultat est NULL alors k ne s'incrémentera pas.

Code: Tout sélectionner

while (...) {
     /* ... */
     if (g_disk.storage[k] != NULL) {
          k++;
     }
}


Une autre question qu'on avait également abordé je crois mais c'est passé aux oubliettes:

Comment se débarrasser d'un warning dû à la fonction strcmp

r5_defines.c: In function ‘init_disk_raid5’:
r5_defines.c:21:17: warning: implicit declaration of function ‘strcmp’ [-Wimplicit-function-declaration]
courant=strcmp(".",lecture->d_name);

Ici le warning est clair, la declaration de strcmp est implicite, c'est à dire qu'il te manque un appel à un fichier contenant cette fonction.

Si tu fais un man strcmp, tu remarqueras que la fonction à besoin de :

Code: Tout sélectionner

#include

edit : désolé pour cette réponse un peu tardive mais ma connexion a planté hier soir.

[Rockleader]

Pas de soucis; j'ai continué à m'avancer jusqu'à 5h du mat de toute façon mais après je tenais plus x)

Bon allez je m'y remet encore une fois merci à toi j'ai éliminé tous mes warnings !

[Rockleader]

J'ai une nouvelle erreur de segmentation; je pense que j'ai pas bien fait le lien à plusieurs endroits.

Tout d'abord Je vous met le niveau de raffinage du moins développé au plus développé.

Code: Tout sélectionner

void cmd_test1()
{
   const int tailleBuffer = 256;
   char buffer[tailleBuffer];
   int k;
   for (k=0;k<tailleBuffer;k++)
   {
      buffer[k]=k;
   }
   write_chunk(1,buffer,tailleBuffer);
}

Code: Tout sélectionner

void write_chunk(int start_block,char* buffer,int n) //n octet dans buffer
{
   int nbBande=compute_nstripe(n);
   int nbBlockParite=(start_block/g_disk.ndisk);
   int blockCourant=(start_block + nbBlockParite);
   int diskCourant=0;
   int pos;
   int k;
   for(k=0;k<nbBande;k++) /*On parcourt les bandes*/
   {
      diskCourant=(blockCourant % g_disk.ndisk);
      if (g_disk.storage[diskCourant] != NULL) /*disk courant existe*/
      {
         pos=fseek(g_disk.storage[diskCourant],(blockCourant*BLOCK_SIZE),SEEK_SET);
         write_stripe(&buffer,pos);
         blockCourant=blockCourant+1;
         if (blockCourant==g_disk.ndisk-1)
         {
            blockCourant=0;
         }
      }
   }
}

Code: Tout sélectionner

void write_stripe(char* bande[BLOCK_SIZE],int pos)
{
   int k;
   for(k=0;k<g_disk.ndisk;k++)
   {
      if (g_disk.storage[k] != NULL)
      {
         fseek(g_disk.storage[k],pos,SEEK_SET);
         write_blocks(bande[k],pos,g_disk.storage[k]);
      }
   }
}

Code: Tout sélectionner

void write_blocks(char block[BLOCK_SIZE],int pos,FILE* disk_id)
{
   fseek(disk_id,pos,SEEK_SET);
   fwrite( block , sizeof(block[0]) , sizeof(block)/sizeof(block[0]) , disk_id);
}


Je rentre dans le tableau buffer les 256 (0 à 255 donc) premiers caractères de la table ascii
Je lance write chunks qui doit découper le texte en bande et envoyé les bande à write_stripe
write_stripe doit découper la bande reçue en block envoyé à write_block
write_block écrit le block reçue dans un fichier.


Je suis sur que je me suis mélangé dans les passages de paramètres...

Et au passage est il possible de renvoyer un code d'erreur qui ne stoppe pas le programme à la différence de exit.

[ampholyte]

Ton problème vient de ton appel à la fonction write_chunk.

Code: Tout sélectionner

write_stripe(&buffer,pos);

Buffer est un char * donc il te suffit simplement d'appeler

Code: Tout sélectionner

write_stripe(buffer, pos)

En sortie de tes fonctions c'est toi qui gère le cas des erreurs. Il te suffit de faire un return (le code d'erreur) et le traité par la suite.

Exemple :

Code: Tout sélectionner

double ma_fonction(int a) {
    if (a >= 0) {
        return sqrt(a);
    } else {
        fprintf(stderr, "a doit être positif\n");
        return -1;
    }
}

int main(void) {
     if (ma_fonction(-100) == -1) {
          fprintf(stderr, "Une erreur s'est produite dans ma fonction \n");
          return (EXIT_FAILURE);
     }

     return (EXIT_SUCCESS);
}


[Rockleader]

Du coup je prend des warninngs comme je suis dans des void j'aime pas trop ça mais bon !

Pour la suggestion que tu me fais; si je l'applique je prend un nouveau warning sur le passage de paramètre donc je pense que j'avais bien raison.

Code: Tout sélectionner

r5_defines.c: In function ‘write_chunk’:
r5_defines.c:144:4: warning: passing argument 1 of ‘write_stripe’ from incompatible pointer type [enabled by default]
    write_stripe(buffer,pos);
    ^
r5_defines.c:117:6: note: expected ‘char **’ but argument is of type ‘char *’
 void write_stripe(char* bande[BLOCK_SIZE],int pos)


En revanche, si je garde comme j'ai fait mais en remplaçant ici par 0 ça fonctionne sans erreur de segmentation.

Code: Tout sélectionner

write_chunk(1,buffer,tailleBuffer);

Toutefois mon plus gros problème c'est que je me suis rendu compte que je n'entrais même pas dans mes condition
Cf la trace en rajout qui n’apparaît pas à l'écran !!!

Code: Tout sélectionner

void write_chunk(int start_block,char* buffer,int n) //n octet dans buffer
{
   int nbBande=compute_nstripe(n);
   int nbBlockParite=(start_block/g_disk.ndisk);
   int blockCourant=(start_block + nbBlockParite);
   int diskCourant=0;
   int pos;
   int k;
   for(k=0;k<nbBande;k++) /*On parcourt les bandes*/
   {
      diskCourant=(blockCourant % g_disk.ndisk);
      if (g_disk.storage[diskCourant] != NULL) /*disk courant existe*/
      {
                       [COLOR=Red] [B] printf"TEST");[/B][/COLOR]
         pos=fseek(g_disk.storage[diskCourant],(blockCourant*BLOCK_SIZE),SEEK_SET);
         write_stripe(&buffer,pos);
         blockCourant=blockCourant+1;
         if (blockCourant==g_disk.ndisk-1)
         {
            blockCourant=0;
         }
      }
   }
}

[ampholyte]

Oui mais tu dois modifier ta fonction par soit :

Code: Tout sélectionner

 void write_stripe(char bande[BLOCK_SIZE],int pos)

Soit par

Code: Tout sélectionner

write_stripe(char* bande,int pos)

Bah cela signifie que ton g_disk.storage[k] est null.

[Rockleader]

Mon initialisation de storage n'as pas l'air mauvaise pourtant.

Code: Tout sélectionner

void init_disk_raid5(char* adresse)
{
   DIR* rep = NULL;
   g_disk.ndisk=NUMBER_OF_DISKS;
   g_disk.raidmode=5;
    rep = opendir(adresse);
    int fich=NUMBER_OF_DISKS;
   int k=0;
   int courant;
   int precedent;
   struct dirent *lecture;
   char fichier[FILENAME_MAX_SIZE];
        while ((lecture = readdir(rep)))
        {
                courant=strcmp(".",lecture->d_name);
                precedent=strcmp("..",lecture->d_name);
                if (courant != 0 && precedent != 0)
                {
                   sprintf(fichier, "%s/%s",adresse,lecture->d_name); //on chaine nomDossier/nomFIchier
                   if ((g_disk.storage[k]=fopen(fichier,"r+"))==NULL)
                   {
                      fich=fich-1;
                   }
                }
                k=k+1;
        }
   closedir(rep);
   if (fich <= NUMBER_OF_DISKS-2)
   {
      printf("Deux fichiers ou plus manquant\n RAID5 cassé \n");
      exit(1);
   }
}

Je ne prend pas la sortie exit1 donc j'ai bien mes fichiers ouvert qui ne valent pas NULL en principe.

Code: Tout sélectionner

Oui mais tu dois modifier ta fonction par soit :

Ce qui veut dire que du coup je vais devoir modifier également les deux autres ? Sa me semble bizarre !!!

[ampholyte]

Comment ça les 2 autres ?

J'avoue ne pas trop comprendre. Est-ce que tu appelles bien ta fonction cmd_test1 après avoir fait un init_disk_raid5 ?

[Rockleader]

Oui dans le main !

cmd fait appel à chunk
chunk fait appel à stripes
stripes fait appel à block

[ampholyte]

Oui dans le main !

cmd fait appel à chunk
chunk fait appel à stripes
stripes fait appel à block

Que fais ta fonction compute_nstripe ?

[Rockleader]

Si je ne me suis pas trompé elle calcule le nombre de bande en fonction du nombre d'octet entré en paramètre.

Code: Tout sélectionner

int compute_nstripe(int octet)
{
   float nBande=0;
   int n2Bande=0;
   n2Bande=(compute_nblock(octet)/(NUMBER_OF_DISKS-1));
   nBande=(compute_nblock(octet)/(NUMBER_OF_DISKS-1));
   if (nBande > n2Bande)
   {
      return n2Bande+1;
   }
   return n2Bande;
}

compute_nblock retourne le nombre de block

Code: Tout sélectionner

int compute_nblock(int octet) /*octet >=0*/
{
   int nBlock=0;
   nBlock=(octet/BLOCK_SIZE);/*octet=nBlock*BLOCK_SIZE*/
   return nBlock;/*nBlock >=0*/
}