Discussion :

[Amnael]

Je n'ai toujours pas de readdir et je pense que c'est pour ça que ça ne marche pas comme ça devrait.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
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;
	for (k=0;k<NUMBER_OF_DISKS;k++)
	{
		char fichier[FILENAME_MAX_SIZE]="d";
		sprintf(fichier,"%s%d",fichier,k);
		/*printf("%s\n",fichier);*/
		g_disk.storage[k]=fopen(fichier,"r+");
	}	
	closedir(rep);
	for (k=0;k<g_disk.ndisk;k++)
	{
		if (g_disk.storage[k]==NULL)
		{
			fich=(fich-1);
			printf("%d\n",fich); /*trace*/
		}
	}
	if (fich <= NUMBER_OF_DISKS-2)
	{
		printf("Deux fichiers ou plus manquant\n RAID5 cassé \n");
	}
 
}
 
void close_disk_raid5(char* adresse)
{
	int k;
	for(k=0;k<g_disk.ndisk;k++)
    {
		fclose(g_disk.storage[k]);	
	}
}

A chaque itération fich est décrémenté ==> Le fichier n'existe pas puisque le pointeur vaut NULL; hors les fichiers existe bien dans le répertoire en question.
Par ailleurs j'ai vérifié que la chaîne concaténé vaillent bien les noms de fichiers et c'est le cas.

==> Soit je n'ai pas la bonne méthode ; soit le pointeur ne vaut pas null quand le fichier est absent mais quand il est présent ? Il y aurait donc une erreur là où j'ai lu ça.




Un autre petit problème; dans la fonction de fermeture je prend un message de "corre dumped" une idée de sa provenance ?

Merci pour votre aide.

[Amnael]

Désolé pour le triple post Mais il se trouve que surprise de la soirée; nos chers prof ont avancé la date de remise de ce projet du 13 à ... demain soir x)

Nuit blanche en perspective donc


J'ai modifié le code précédent de façon à prendre en compte n'importe quel nom de fichier après avoir compris comment fonctionner readdir; je fais simplement un test pour ne pas ouvrir "." et ".."


Ceci dit j'ai toujours ce foutu soucis pour détecter le nombre de fichier qui a été ouvert:
Je les ouvre sans problèmes puisqu'il existe; mais ensuite quand je teste avec NULL pour savoir s'il existe bien; je rentre toujours dans la boucle même lorsque le fichier existe !!!!
Pourtant

La valeur retournée par fopen est un flot de données. Si l'exécution de cette fonction ne se déroule pas normalement, la valeur retournée est le pointeur NULL. Il est donc recommandé de toujours tester si la valeur renvoyée par la fonction fopen est égale à NULL afin de détecter les erreurs (lecture d'un fichier inexistant...).

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
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;
        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+");
                }
                k=k+1;
        }
	closedir(rep);
	for (k=0;k<g_disk.ndisk;k++)
	{
		if (g_disk.storage[k]==NULL)
		{
			fich=(fich-1);
			printf("%d\n",fich);
		}
	}
	if (fich <= NUMBER_OF_DISKS-2)
	{
		printf("Deux fichiers ou plus manquant\n RAID5 cassé \n");
	}
 
}

Et toujours l'erreur de segmentation sur la fonction pour fermer que je n'arrive pas à situer !

[Sve@r]

Code c :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
	for (k=0;k<NUMBER_OF_DISKS;k++)
	{
		char fichier[FILENAME_MAX_SIZE]="d";
		sprintf(fichier,"%s%d",fichier,k);
	}

Hum, mettre fichier dans fichier... je crois que sprintf() n'aimera pas...

Code c :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
	for (k=0;k<NUMBER_OF_DISKS;k++)
	{
		char fichier[FILENAME_MAX_SIZE];
		sprintf(fichier,"d%d", k);
	}

Code c :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
void close_disk_raid5(char* adresse)
{
	int k;
	for(k=0;k<g_disk.ndisk;k++)
	{
		fclose(g_disk.storage[k]);	
	}
}

Un autre petit problème; dans la fonction de fermeture je prend un message de "corre dumped" une idée de sa provenance ?

un des éléments g_disk.storage[k] n'a pas été ouvert et ne peut donc pas être fermé

Code c :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
void close_disk_raid5(/*char* adresse */)
{
	int k;
	for(k=0;k<g_disk.ndisk;k++)
	{
		if (g_disk.storage[k])
			fclose(g_disk.storage[k]);	
	}
}

Code c :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
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+");
	}
	k=k+1;
}

Tu es certain que k doive s'incrémenter tout le temps ???

Code c :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
while ((lecture = readdir(rep))) 
{
	if (strcmp(lecture->d_name, ".") != 0 && strcmp(lecture->d_name, "..") != 0)
	{
		g_disk.storage[k]=fopen(lecture->d_name,"r+");
		k++;
	}
}

Ou bien (évite un décalage inutile)

Code c :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
while ((lecture = readdir(rep))) 
{
	if (strcmp(lecture->d_name, ".") == 0 || strcmp(lecture->d_name, "..") == 0) continue;
	g_disk.storage[k]=fopen(lecture->d_name,"r+");
	k++;
}

Ceci dit, pourquoi tu fais du readdir() ? Tu sais que tu dois avoir 4 disques dans ton dossier. Donc tu boucles sur n de 0 à 3 et tu ouvres dn. Et si dn n'est pas là alors fopen renvoie NULL...

Code c :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
for (n=0, reel=0; n < NB_DISK; n++)
{
	char fichier[256]; 
	sprintf(fichier, "d%d", n);
	if (g_disk.storage[n]=fopen(fichier ,"r+"))
		reel++;
}
if (reel == NB_DISK)
	printf("raid nominal\n");
else {
	if (reel == (NB_DISK - 1))
		printf("raid dégradé\n");
	else
		printf("raid cassé (%d/%d)\n", reel, NB_DISK);
}

Désolé pour le triple post Mais il se trouve que surprise de la soirée; nos chers prof ont avancé la date de remise de ce projet du 13 à ... demain soir x)

Nuit blanche en perspective donc

Je vais rester tant que je peux...

[Amnael]

Ceci dit, pourquoi tu fais du readdir() ? Tu sais que tu dois avoir 4 disques dans ton dossier. Donc tu boucles sur n de 0 à 3 et tu ouvres dn. Et si dn n'est pas là alors fopen renvoie NULL...

Simple réflexion de ma part si les nom fichiers étaient forcement

Dn; pourquoi avoir une constante de nom de fichier de taille 32 ?

J'ai donc préféré lire le contenu des répertoires; et ne retenir que les fichiers pour travailler dessus.
J'ai pu débogguer le problème de segmentation

Je bloque à présent sur la 4ème question (si tu as l'énoncé sous les yeux) il s'agit de celle demandant de calculer le bloc de parité compute_parity; or j'avoue avoir du mal à comprendre comment faire; le xor ça renvoi des valeurs logique 0 ou 1 en principe ==> Comment je vais faire pour récupérer le texte dedans...à moins que je ne comprenne la question de travers.
Et par ailleurs j'ai en entrée un tableau de blocks; un block c'est plusieurs char et le xor je pense ne peut travailler que caractère par caractère

Voilà un peu ce à quoi j'arrive (je sais parfaitement que ça n'est pas correct mais j'ai beau me trifouiller l'esprit je vois pas comment on peut faire ça ! Peut être à cause de l'heure...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
 
char* compute_parity(char block[],int nBlock)
{
	int k;
	for (k=0;k<nBlock;k++)
	{
		int k2=k+1;
		if (k==nBlock-1)
			{
			k2=0;
		    }
		int k3;
		for(k3=0;k3<k2;k3++)
		{
			if (k3 != k)
			{
				block[k]=block[k3]^block[k3+1];
			}
		}
		for(k2=k2;k2<nBlock-1;k2++)
		{
			if (k2 != k)
			{
			block[k]=block[k2]^block[k2+1];
			}
	    }
	}
}

Prenant l'exemple suivant

Je veux calculer B2

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

Je n'arrive pas à enchaîner tous ces xor à la suite tout en prenant compte du fait que le block recherché ne doit pas être présent dans le calcul.

[Sve@r]

Je bloque à présent sur la 4ème question (si tu as l'énoncé sous les yeux) il s'agit de celle demandant de calculer le bloc de parité compute_parity; or j'avoue avoir du mal à comprendre comment faire; le xor ça renvoi des valeurs logique 0 ou 1 en principe ==> Comment je vais faire pour récupérer le texte dedans...à moins que je ne comprenne la question de travers.

Le xor s'applique aux bits... donc il s'applique aussi aux octets !!!

Code c :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <stdio.h>
#include <stdlib.h>
 
int main()
{
	char a,b,c,d;
	a='A';
	b='B';
	c='C';
	d=a^b^c;
 
	printf("%c\n", a^b^d);
	printf("%c\n", a^c^d);
	printf("%c\n", b^c^d);
}

Et par ailleurs j'ai en entrée un tableau de blocks; un block c'est plusieurs char et le xor je pense ne peut travailler que caractère par caractère
...
Prenant l'exemple suivant

Je veux calculer B2

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

Je n'arrive pas à enchaîner tous ces xor à la suite tout en prenant compte du fait que le block recherché ne doit pas être présent dans le calcul.

Code c :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
// Codage (le bloc qui sert de parité sera différent à chaque octet)
char block[NB_BLOCK][NB_CAR]
int c;
int i;
int parite
 
for (parité=0, c=0; c < NB_CAR; c++)
{
    block[parite][c]=0;
    for (i=0; i < NB_BLOCK; i++)
   {
        if (i == parite) continue;
        block[parite][c]^=block[i][c];
    }
    parite=(parite + 1) % NB_BLOCK;
}
 
// Reconstruction (on considère que le bloc 3 est à reconstruire
char block[NB_BLOCK][NB_CAR]
int c;
int i;
 
for (c=0; c < NB_CAR; c++)
{
    block[3][c]=0;
    for (i=0; i < NB_BLOCK; i++)
    {
        if (i == 3) continue;
        block[3][c]^=block[i][c];
    }
}

Tu remarqueras que la structure est exactement la même. Lors du codage la parité cycle sur chaque bloc mais pas lors de la reconstruction (qui reconstruit un bloc absent).
Je pense donc que tu peux faire les deux opérations dans la même fonction qui prendra un paramètre en plus indiquant s'il faut coder ou reconstruire...

[Amnael]

Je ne comprends pas quand tu utilises cette notation

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
if (i == parite) continue;
        block[parite][c]^=block[i][c];

le continue et ^=

[Sve@r]

Je ne comprends pas le continue

Ah ben quand-même !!! C'est une instruction de base du C !!! Elle signifie de passer à l'itération suivante (donc de ne pas faire la fin de la boucle)...

et ^=

Un peu pareil. a+=n signifie a=a+n. Et c'est valable avec tous les opérateurs binaires...

J'ai tapé vite fait un petit exemple de raid

Code c :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
 
#define NB_BLOC 4
#define NB_CAR 4
 
void ecrire(char[NB_BLOC][NB_CAR], char*);
void lire(char[NB_BLOC][NB_CAR]);
void redo(char[NB_BLOC][NB_CAR], int);
void debug(char[NB_BLOC][NB_CAR]);
int main()
{
	char raid[NB_BLOC][NB_CAR];
	ecrire(raid, "bonjour");
 
	// Test initial
	debug(raid);
	printf("Test initial: ");
	lire(raid);
	fputc('\n', stdout);
 
	// Destruction du bloc n° 2 dans son intégralité
	memset(raid[2], 'f', NB_CAR);
	debug(raid);
	printf("Test corrompu: ");
	lire(raid);
	fputc('\n', stdout);
 
	// Reconstruction bloc n° 2
	redo(raid, 2);
 
	// Test final
	debug(raid);
	printf("Test final: ");
	lire(raid);
	fputc('\n', stdout);
}
 
void ecrire(char raid[NB_BLOC][NB_CAR], char *mot)
{
	int n;
	int c;
	int ref;
	int pair;
 
	ref=0;
 
	// Traitement de tous les caractères
	for (pair=0, c=0; c < NB_CAR; c++)
	{
		// Initialisation bloc de parité
		raid[pair][c]=0;
 
		// Traitement de chaque bloc
		for (n=0; n < NB_BLOC; n++)
		{
			// Si on est sur le bloc de parité on le passe
			if (n == pair) continue;
 
			// Si on est encore dans le mot
			if (ref < strlen(mot))
			{
				// Le caractère de référence est écrit sur le bloc
				raid[n][c]=mot[ref];
				ref++;
			}
			else
			{
				// Le bloc prend 0
				raid[n][c]=0;
			}
 
			// Le bloc de parité encode le caractère écrit
			raid[pair][c]^=raid[n][c];
		}
 
		// La parité se décale
		pair=(pair + 1) % NB_BLOC;
	}
}
 
// Lecture
void lire(char raid[NB_BLOC][NB_CAR])
{
	int n;
	int c;
	int pair;
 
	// Traitement de tous les caractères
	for (pair=0, c=0; c < NB_CAR; c++)
	{
		// Traitement de chaque bloc
		for (n=0; n < NB_BLOC; n++)
		{
			// Si on est sur le bloc de parité on le passe
			if (n == pair) continue;
 
			// Affichage du caractère (s'il ne vaut pas 0)
			if (raid[n][c]) fputc(raid[n][c], stdout);
		}
 
		// La parité se décale
		pair=(pair + 1) % NB_BLOC;
	}
}
 
// Reconstruction
void redo(char raid[NB_BLOC][NB_CAR], int repair)
{
	int n;
	int c;
 
	// Traitement de tous les caractères
	for (c=0; c < NB_CAR; c++)
	{
		// Initialisation bloc à réparer
		raid[repair][c]=0;
 
		// Traitement de chaque bloc
		for (n=0; n < NB_BLOC; n++)
		{
			// Si on est sur le bloc à réparer on le passe
			if (n == repair) continue;
 
			// Reconstruction bloc à réparer sur les autres
			raid[repair][c]^=raid[n][c];
		}
	}
}
 
// Débug
void debug(char raid[NB_BLOC][NB_CAR])
{
	int n;
	int c;
	int pair;
 
	// Traitement de tous les caractères
	printf("debug raid\n");
	for (pair=0, c=0; c < NB_CAR; c++)
	{
		// Traitement de chaque bloc
		for (n=0; n < NB_BLOC; n++)
		{
			// Affichage du caractère
			printf("raid[%d][%d]=0x%02x [%c%s], ", n, c, raid[n][c], isprint(raid[n][c]) ?raid[n][c] :'.', (n == pair) ? "(+)" :"");
		}
		fputc('\n', stdout);
 
		// La parité se décale
		pair=(pair + 1) % NB_BLOC;
	}
}

Et le résultat

debug raid
raid[0][0]=0x63 [c(+)], raid[1][0]=0x62 [b], raid[2][0]=0x6f [o], raid[3][0]=0x6e [n],
raid[0][1]=0x6a [j], raid[1][1]=0x70 [p(+)], raid[2][1]=0x6f [o], raid[3][1]=0x75 [u],
raid[0][2]=0x72 [r], raid[1][2]=0x00 [.], raid[2][2]=0x72 [r(+)], raid[3][2]=0x00 [.],
raid[0][3]=0x00 [.], raid[1][3]=0x00 [.], raid[2][3]=0x00 [.], raid[3][3]=0x00 [.(+)],
Test initial: bonjour

debug raid (après l'avoir corrompu)
raid[0][0]=0x63 [c(+)], raid[1][0]=0x62 [b], raid[2][0]=0x66 [f], raid[3][0]=0x6e [n],
raid[0][1]=0x6a [j], raid[1][1]=0x70 [p(+)], raid[2][1]=0x66 [f], raid[3][1]=0x75 [u],
raid[0][2]=0x72 [r], raid[1][2]=0x00 [.], raid[2][2]=0x66 [f(+)], raid[3][2]=0x00 [.],
raid[0][3]=0x00 [.], raid[1][3]=0x00 [.], raid[2][3]=0x66 [f], raid[3][3]=0x00 [.(+)],
Test corrompu: bfnjfurf

debug raid (après l'avoir réparé)
raid[0][0]=0x63 [c(+)], raid[1][0]=0x62 [b], raid[2][0]=0x6f [o], raid[3][0]=0x6e [n],
raid[0][1]=0x6a [j], raid[1][1]=0x70 [p(+)], raid[2][1]=0x6f [o], raid[3][1]=0x75 [u],
raid[0][2]=0x72 [r], raid[1][2]=0x00 [.], raid[2][2]=0x72 [r(+)], raid[3][2]=0x00 [.],
raid[0][3]=0x00 [.], raid[1][3]=0x00 [.], raid[2][3]=0x00 [.], raid[3][3]=0x00 [.(+)],
Test final: bonjour

Les petits (+) du debug indiquent les blocs de parité. Leur valeur numérique correspond au xor des autres mais la lettre marquée ne signifie rien de concret...

[Amnael]

Je regarderais tout ça un peu plus tard; je pense que je vais aller faire un petit somme de 3-4 heures j'ai plus les idées très claires là...

Merci en tout cas pour ton aide précieuse !

Dernière question que je pose avant d'aller pioncer; j'ai continué d'avancer; et sur ma fonction d'écriture pour écrire un block à une position donné voilà ce que j'ai fait, je suis pas sur que ce soit bien écrit; qui plus est je prend un warning et les warnings pour moi c'est encore plus le mal que les variables globales

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
void write_blocks(int pos,FILE* disk_id)
{
	fseek(disk_id,BLOCK_SIZE,pos); 
	char block[BLOCK_SIZE]={0};
	printf("Quel block voulez vous entrer:");
	scanf("%s",&block);
	fprintf(disk_id, "%s\n",block);
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
r5_defines.c: In function ‘write_blocks’:
r5_defines.c:118:2: warning: format ‘%s’ expects argument of type ‘char *’, but argument 2 has type ‘char (*)[4]’ [-Wformat=]
  scanf("%s",&block);

Ah ben quand-même !!! C'est une instruction de base du C !!

Navré; faut dire j'avais commencé le c pour m'amuser au collège j'étais allé jusqu'au tp du plus ou moins fait par matéo sur l'ancien sdz; mais après plus rien j'ai eu d'autres occupations et ça c'est pas arrangé avec le temps =)

En cours; on ne fait pas de prog, on fait surtout de l'analyse spécification et vérification de programmes; c'est intéressant et utile je dis pas le contraire, mais à coté on doit taffer bien plus en TP.


Bref je divague, merci et bonne nuit, je reprendrais un peu plus tard -

[Sve@r]

Dernière question que je pose avant d'aller pioncer; j'ai continué d'avancer; et sur ma fonction d'écriture pour écrire un block à une position donné voilà ce que j'ai fait, je suis pas sur que ce soit bien écrit; qui plus est je prend un warning

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
void write_blocks(int pos,FILE* disk_id)
{
	fseek(disk_id,BLOCK_SIZE,pos); 
	char block[BLOCK_SIZE]={0};
	printf("Quel block voulez vous entrer:");
	scanf("%s",&block);
	fprintf(disk_id, "%s\n",block);
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
r5_defines.c: In function ‘write_blocks’:
r5_defines.c:118:2: warning: format ‘%s’ expects argument of type ‘char *’, but argument 2 has type ‘char (*)[4]’ [-Wformat=]
  scanf("%s",&block);

Pas de "&" devant un nom de tableau dans le scanf. Le simple nom d'un tableau c'est déjà une adresse.

et les warnings pour moi c'est encore plus le mal que les variables globales

Très bon réflexe. Toutefois, exceptionnellement ici, cela ne cause pas de soucis.

[Amnael]

Merci pour tes conseils !

J'ai donc rejeté un oeil sur ce que tu avais écris plus haut

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
// Codage (le bloc qui sert de parité sera différent à chaque octet)
char block[NB_BLOCK][NB_CAR]
int c;
int i;
int parite
 
for (parité=0, c=0; c < NB_CAR; c++)
{
    block[parite][c]=0;
    for (i=0; i < NB_BLOCK; i++)
   {
        if (i == parite) continue;
        block[parite][c]^=block[i][c];
    }
    parite=(parite + 1) % NB_BLOCK;
}

Il manque un point virgule mouhahaha =) Ok je sors xD

Plus sérieusement je ne vois pas ce que représente NB_CAR dans ton bout de programme car à priori pour ma fonction je ne dispose en entrée que d'un tableau de n Blocks

EDIT: En attendant j'ai continué; voilà ce que ça donne pour les trois fonctions d'écritures demandées.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
void write_blocks(int pos,FILE* disk_id)
{
	fseek(disk_id,BLOCK_SIZE,pos);
	char block[BLOCK_SIZE]={0};
	printf("Quel block voulez vous entrer:");
	scanf("%s",block);
	fprintf(disk_id, "%s ",block);
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
void write_stripe(int pos, int numBande)
{
	int k;
	for(k=0;k<g_disk.ndisk;k++)
	{
		if (g_disk.storage[k] != NULL)
		{
			fseek(g_disk.storage[k],BLOCK_SIZE,pos);
			char block[BLOCK_SIZE]={0};
			if (k != compute_parity_index(numBande)) /*si on est pas sur le block de parité*/
			{
				printf("Quel block voulez vous entrer:");
				scanf("%s",block);
				fprintf(g_disk.storage[k], "%s ",block);
			}
			if (k == compute_parity_index(numBande))  /*si on est sur le block de parité*/
			{
				fprintf(g_disk.storage[k], "%s ",/*block*/);/*ecriture block de parité*/
			}
		}
	}
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
void write_chunk(int start_block,char buffer[],int n) //n octet
{
	int nbBlock=compute_nblock(n);
	int nbBlockParite=(start_block/g_disk.ndisk);
	int blockCourant=(start_block + nbBlockParite);
	int diskCourant=0;
	int k;
	for(k=0;k<nbBlock;k++) /*On parcourt les block*/
	{
		diskCourant=(blockCourant % g_disk.ndisk);
		if (g_disk.storage[diskCourant] != NULL)
		{
			fseek(g_disk.storage[diskCourant],BLOCK_SIZE,blockCourant);
			fprintf(g_disk.storage[diskCourant], "%s ",buffer[k]);
			blockCourant=blockCourant+1;
			if (blockCourant==g_disk.ndisk-1)
			{
				blockCourant=0;
			}
		}
	}
}

J’aimerais avoir ton avis sur la cohérence du code par rapport à l'énoncé d'une part si possible.
Tu remarqueras qu'à la fin de la seconde fonction j'ai volontairement mis un paramètre en commentaire car je n'ai toujours pas réussi à faire la parité et je ne veux pas me résoudre à recopier bêtement ton code précédent bien que je le ferais peut être ce soir si je n'y arrive pas à tant pour éviter le 0 de non compilations


A noter que sur ma troisième fonction je prend un warning plutôt étrange.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
warning: format ‘%s’ expects argument of type ‘char *’, but argument 3 has type ‘int’ [-Wformat=]
    fprintf(g_disk.storage[diskCourant], "%s ",buffer[k]);

Hors dans la déclaration je fais bien char buffer[] ==> Tableau de caractère et dans l'appel j'ai bien mon %s (certes il serait peut être plus approprié %c ici; mais quand même d'où je prend un int...


Merci !


EDIT 2

En réalité je devais utiliser le type uchar définis; à présent mon code compile et s'exécute sans erreur.

J'ai rajouté la fonction suivante

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
void cmd_test1()
{
	const int tailleBuffer = 256;
	uchar buffer[tailleBuffer];
	int k;
	for (k=0;k<tailleBuffer;k++)
	{
		buffer[k]=k;
	}
	write_chunk(1,buffer,tailleBuffer);
}

qui se sert donc de write_chunk

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
void write_chunk(int start_block,uchar buffer[],int n) //n octet
{
	int nbBlock=compute_nblock(n);
	int nbBlockParite=(start_block/g_disk.ndisk);
	int blockCourant=(start_block + nbBlockParite);
	int diskCourant=0;
	int k;
	for(k=0;k<nbBlock;k++) /*On parcourt les block*/
	{
		diskCourant=(blockCourant % g_disk.ndisk);
		if (g_disk.storage[diskCourant] != NULL)
		{
			fseek(g_disk.storage[diskCourant],BLOCK_SIZE,blockCourant);
			fprintf(g_disk.storage[diskCourant], "%hhu ",buffer[k]);
			blockCourant=blockCourant+1;
			if (blockCourant==g_disk.ndisk-1)
			{
				blockCourant=0;
			}
		}
	}
}

Malheureusement; le code ne fait pas à priori ce qu'il devrait faire car lorsque j'utilise le script de test qui m'et fourni catastrophe !


cmd_test1 [KO]
cmd_test2 [KO]
files [KO]
files_disk [KO]
repair [KO]
defrag [KO]



Mon code est bon mais ne fait pas ce qu'il devrait faire; an idea ?

[Sve@r]

Plus sérieusement je ne vois pas ce que représente NB_CAR dans ton bout de programme car à priori pour ma fonction je ne dispose en entrée que d'un tableau de n Blocks

J'ai juste illustré l'idée avec ma référence (un tableau de x blocks, chaque bloc contenant y caractères). Tu peux l'adapter à la tienne...

A noter que sur ma troisième fonction je prend un warning plutôt étrange.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
warning: format ‘%s’ expects argument of type ‘char *’, but argument 3 has type ‘int’ [-Wformat=]
    fprintf(g_disk.storage[diskCourant], "%s ",buffer[k]);

Hors dans la déclaration je fais bien char buffer[] ==> Tableau de caractère et dans l'appel j'ai bien mon %s (certes il serait peut être plus approprié %c ici; mais quand même d'où je prend un int...

buffer est une chaine, donc buffer[k] est juste un caractère de cette chaine. Or un caractère n'étant en final qu'un nombre (un code ascii), le compilo voit donc ici un nombre entier qu'il appelle "int" de façon générale. Donc si tu veux enregistrer un caractère c'est effectivement "%c" qu'il faut mettre. Et si tu parles de la chaine alors c'est buffer !!!

J’aimerais avoir ton avis sur la cohérence du code par rapport à l'énoncé d'une part si possible.

Arf non là plus le temps. Faudrait tout ton code, les modules de test. C'est long de tester un code...

Mon code est bon mais ne fait pas ce qu'il devrait faire; an idea ?

Rajouter des printf() pour regarder les valeurs. Commencer par les éléments les plus externes (le raid) et descendre petit à petit. Faire du vrai debug quoi... (tu remarqueras par exemple que dans mon code d'essai j'y avais pensé dès le départ)...

[Zethzer]

Salut ^^ Un ami, en cherchant des infos sur son propre projet est tombé sur ton topic. Ça tombe bien. On est dans la même promo, il semblerait. D'ailleurs, la date du mardi 7 janvier est là depuis un peu avant le nouvel an :/

Pour t'aider un peu :

write_block me fait sauter au plafond perso... Tu demandes d'entrer un bloc ? O_O D'accord, pour cmd_test1, y a que 256 octets à écrire. (64 blocs). On peux encore s'en sortir ... Bien que taper 64 chiffres me saoulerait ...

Pour les tests sur les fichiers, les fichiers sont de différentes tailles et y a + de 5000 blocs à écrire ... Faudrait peut-être automatiser un peu tout ça, nan ? ^^

Reprenons ton write_block :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
void write_blocks(int pos,FILE* disk_id)
{
	fseek(disk_id,BLOCK_SIZE,pos);
	char block[BLOCK_SIZE]={0};
	printf("Quel block voulez vous entrer:");
	scanf("%s",block);
	fprintf(disk_id, "%s ",block);
}

Pour commencer, tu écris le bloc d'une bande. Pourquoi ne donnes-tu pas de bloc à write_block ? (write_stripe doit contenir toute la bande avec les blocs)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

fseek(disk_id,BLOCK_SIZE,pos);

Déjà, mauvaise utilisation fseek. Le prototype est :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

fseek(FILE *stream, long offset, int whence)

Truc particulier sur son utilisation, à la place de "whence", tu peux insérer trois constantes pratiques :
- SEEK_SET : Place le "curseur" au début du fichier (qui donne whence = 0 en fait)
- SEEK_CUR : À la position courant (whence = 1)
- SEEK_END : À la fin du fichier (whence = 2)

Et "offset" te permet de te déplacer par rapport à ta position courante.

Tu sais que tu vas écrire un bloc qui fait BLOCK_SIZE octets. Ça tombe bien, fseek utilise l'octet. Le plus simple est donc de se placer au début du fichier à chaque fois et d'utiliser pos pour avoir ton curseur au bon endroit.

Ensuite, pour l'écriture, au choix de la fonction. Perso, je préfère fwrite ^^

Après lecture du reste. Tu as fait 3 fonctions indépendantes. J'avoue que le sujet est hard à comprendre.

Ce qu'il faut savoir c'est que write_chunk est la base. Et au lieu d'avoir une fonction à 150 lignes. On la dévise en d'autres fonctions (compute_*, write_stripe et write_block)

Dans l'ordre, tu peux te dire :

write_chunk prend tout un buffer. Elle va découper des bandes, qu'elle va écrire en appelant write_stripe (qui elle-même va écrire les blocs en appelant write_block))

PS : Si tu finis les fonctions d'écritures, celle de lecture sont très très similaires.

En espérant ne pas avoir été trop flou =X Désolé d'avance sinon...

[Médinoc]

Attention, si tu fais des appels de fseek() avec valeurs autres que (valeur retournée par ftell()) et SEEK_SET, tu dois ouvrir tes fichiers en mode binaire (avec fopen("fichier", "r+b")) sinon, le comportement est indéfini.

[Zethzer]

Attention, si tu fais des appels de fseek() avec valeurs autres que (valeur retournée par ftell()) et SEEK_SET, tu dois ouvrir tes fichiers en mode binaire (avec fopen("fichier", "r+b")) sinon, le comportement est indéfini.

Merci bien ! Bon à savoir ça !

Utilisant fseek avec que SEEK_SET dans ce projet. Ça ne posait pas problèmes. Pour le futur, ça pourra m'éviter des emmerdes. :p

[Amnael]

Pour la date perso j'ai regardé dimanche midi et dans le dépôt c'était marqué 13 janviers =)

Enfin bref je le fais à l'arraché même si c'est pas fini et que ça marche pas comme ça devrait; au moins ça compile x)



Pour revenir sur les remarques

Oui entre temps je me suis rendu compte que fwrite et fread c'était quand même plus pratique et j'ai modifié; cependant ça marche toujours pas ça ne m'affiche rien sur les fichiers lorsque j'en fais un cat; je parle donc même pas du script =)


A priori ce que j'écris ne me semble pas super abérant

Le prog principal

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
void cmd_test1()
{
	const int tailleBuffer = 256;
	uchar buffer[tailleBuffer];
	int k;
	for (k=0;k<tailleBuffer;k++)
	{
		buffer[k]=k; //on donne au buffer les valeurs de 0 à 255
	}
	write_chunk(1,buffer,tailleBuffer);
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
void write_chunk(int start_block,uchar buffer[],int n) //n octet
{
	int nbBlock=compute_nblock(n);
	int nbBlockParite=(start_block/g_disk.ndisk);
	int blockCourant=(start_block + nbBlockParite);
	int diskCourant=0;
	int k;
	for(k=0;k<nbBlock;k++) /*On parcourt les block*/
	{
		diskCourant=(blockCourant % g_disk.ndisk);
		if (g_disk.storage[diskCourant] != NULL) //si le disque existe
		{
			fseek(g_disk.storage[diskCourant],BLOCK_SIZE,blockCourant);
			fwrite( buffer , sizeof(buffer[0]) , sizeof(buffer)/sizeof(buffer[0]),     g_disk.storage[diskCourant]); //on écrit à la position du block courant sur blocksize octet
			blockCourant=blockCourant+1;
			if (blockCourant==g_disk.ndisk-1)
			{
				blockCourant=0;
			}
		}
	}
}

D'après vous ce serait mon utilisation de fseek qui fait merder donc.
Pourtant mon premier paramètre est bien le fichier; le second un déplacement donc une constante en int mais le fait que ce soit pas un long devrait pas poser de soucis je pense
Et le troisième ce n'est pas l'une des trois constantes pré-définis mais ça reste un int, donc je vois pas le soucis; d’ailleurs le compilo n'en voit pas non plus =)

Ici on ne veut pas spécialement aller au début du fichier ou à la fin ou encore à la position courante; on veut aller de la position courante à une position donné en entré; c'est ainsi que je le vois...

[Zethzer]

Rien à redire pour le cmd_test1 ^^ Quand tu passes 1 à start_block, vérifie que ça ne pose pas problèmes. (Il y a aussi la façon de faire où on lui passe 0)

Par contre, write_chunk, j'ai vraiment du mal à comprendre comment tu le fais :/ À vu de nez, c'est clair que ça ne peut donner quelque chose de correct

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

fseek(g_disk.storage[diskCourant],BLOCK_SIZE,blockCourant);

Je peux me tromper ici : Tu lui dis d'écrire à la position blockCourant, décalé de BLOCK_SIZE. Donc tu te retrouves toujours BLOCK_SIZE plus loin que tu souhaites apparemment. Ton premier fseek te décale directement du début du fichier alors que tu n'as pas commencé à écrire.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

fwrite( buffer , sizeof(buffer[0]) , sizeof(buffer)/sizeof(buffer[0]),     g_disk.storage[diskCourant]); //on écrit à la position du block courant sur blocksize octet

Sauf erreur de ma part (qu'il peut y avoir), m'est avis que tu écris tout le buffer d'un coup :/ Or, il faut bien séparer les données sur chaque disques.

Il te faut x blocs pour écrire n octets. Et y bandes pour écrire x blocs. Sans compter le bloc de parité ^^

D'un point de vue universitaire : tu rends inutile pas mal de questions sur le sujet :/ Je le redis d'une manière différente : les questions se trouvant avant celle d'écrire write_chunk servent juste à organiser cette dernière justement.
write_chunk va recevoir un buffer, le découper en bande. Appelé write_stripe pour écrire cette bande. Et write_stripe va appelé write_block pour écrire les blocs.

[Sve@r]

Code c :

Sélectionner tout - Visualiser dans une fenêtre à part

fseek(g_disk.storage[diskCourant],BLOCK_SIZE,blockCourant);

Cette fonction n'est pas du tout utilisée correctement

• Son premier paramètre doit être le fichier => ok
• Son second doit être une valeur entière représentant un nombre de caractères => BLOCK_SIZE correspond bien à cette définition mais moi j'ai un doute que ce soit la bonne valeur
• Son troisième doit être un indicateur permettant à la fonction d'utiliser le second. Si cet indicateur est égal à SEEK_SET (macro représentant un nombre magique dont on n'a pas à se préoccuper), alors le second paramètre représentera la position absolue dans le fichier. S'il est à SEEK_CUR, alors le second paramètre représentera un décalage en octets dans le fichier (en avant ou en arrière suivant que le second sera positif ou négatif) par rapport à la position actuelle (position obtenue par les read/write voire fseek précédents). Et s'il est égal à SEEK_END, alors le second paramètre représentera un recul par rapport à la fin du fichier.
  Il est évident au vu de cette description que la variable "blockCourant" ne correspond pas à cette définition. Et donc si ce 3° paramètre n'a aucune des valeurs imposées, je me demande comment fonctionnera fseek...

ça ne m'affiche rien sur les fichiers lorsque j'en fais un cat

cat n'est pas fait pour afficher des fichiers binaires. Si tu veux débugguer ton fichier, tu peux passer par od -x. Tu auras tout son contenu en hexa...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

fseek(g_disk.storage[diskCourant],BLOCK_SIZE,blockCourant);

Je peux me tromper ici : Tu lui dis d'écrire à la position blockCourant, décalé de BLOCK_SIZE.

Même pas. En fait, ici il se passe réellement n'importe quoi...

[Amnael]

J'ai essayé de remodifier tout ça pour entrer les block/bande en paramètre

je suis sûr que c'est pas encore ça dans la façon de faire; mais je dois m'approcher è_é

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
void write_blocks(char block[BLOCK_SIZE],int pos,FILE* disk_id)
{
	fseek(disk_id,pos,SEEK_SET);
	int k;
	for (k=0;k<g_disk.ndisk;k++)
	{
	fwrite( block , sizeof(block[0]) , sizeof(block)/sizeof(block[0]) , disk_id);
	}
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
void write_stripe(char bande[][BLOCK_SIZE],int pos,int nBande)
{
	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[nBande],pos,g_disk.storage[k]);
                }
         }
}

J'utilise donc write_block dans stripe;

Mais du coup je suis pas sur de writeblocks; je pense que ça va écrire le bloc entier et pas juste caractère par caractère; hors si je modifie la ligne

fwrite( block , sizeof(block[0]) , sizeof(block)/sizeof(block[0]) , disk_id);
en
fwrite( block[k] , sizeof(block[0]) , sizeof(block)/sizeof(block[0]) , disk_id);

Je me prend une erreur au compilo

[Sve@r]

...hors si je modifie la ligne

fwrite( block , sizeof(block[0]) , sizeof(block)/sizeof(block[0]) , disk_id);
en
fwrite( block[k] , sizeof(block[0]) , sizeof(block)/sizeof(block[0]) , disk_id);

Je me prend une erreur au compilo

Normal. fwrite veut impérativement une adresse. block est bien une adresse mais block[k] n'en est pas une !!!

Code c :

Sélectionner tout - Visualiser dans une fenêtre à part

fwrite(&block[k] , sizeof(block[0]) , sizeof(block)/sizeof(block[0]) , disk_id);