simulation système RAID5

Version imprimable

Bonjour/Bonsoir à tous;

je viens vous demander un petit coup de main dans le cadre d'un projets que je dois réaliser pour la fin des vacances; ce n'est pas dans au niveau du codage (ça je sais que je vais galérer mais ça fait partie du jeu :ccool: ) mais surtout de la compréhension du sujet qui est je dois le dire un peu "hard".

Grosso modo le but du projet est de développer l'ensemble des fonctions qui ferait tourner un système RAID5; sauf qu'ici pour simplifier notre problèmes; au lieu de travailler sur 4 disques, l'on symbolise ces disques par 4 fichiers d0 d1 d2 d3 chacun de même taille.

J'ai pu voir divers résumé de comment fonctionnent ces système RAID5
Notamment ici: http://fr.wikipedia.org/wiki/RAID_(i...tique)#RAID_05

Mais j'avoue avoir un peu de mal à faire une synthèse par rapport à ce que l'on me demande.

En fait, j'aimerais être sur d'avoir bien compris les notions:

- de bloc de données
- bloc de parité
- bande
- table d'inode

Pour "débuter" ce projet; un certains nombres de structures nous est déjà fournies.
Code:

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 #ifndef __R5_DEFINES__ #define __R5_DEFINES__ #define NUMBER_OF_DISKS 4 #define BLOCK_SIZE 4 #define FILENAME_MAX_SIZE 32 #define MAX_FILES 100 #define MAX_FILE_SIZE (50*1024) typedef unsigned int uint; typedef unsigned char uchar; /* Type of a block of data */ typedef struct block_s{ uchar data[BLOCK_SIZE]; } block_t; /* Type of the pseudo-inode structure */ typedef struct inode_s{ char filename[FILENAME_MAX_SIZE]; uint size; uint nblock; // nblock = (size+BLOCK_SIZE-1)/BLOCK_SIZE uint block_id; } inode_t; /* Type of the inode table */ typedef inode_t inode_table_t[MAX_FILES]; /* Type of the virtual disk system */ typedef struct virtual_disk_s { inode_table_t inodes; int ndisk; int raidmode; FILE *storage[NUMBER_OF_DISKS]; } virtual_disk_t;
Ce que je voudrais avoir bien compris avant de débuter un quelconque codage hasardeux c'est le rapport entre les structures virtual_disk et inodes par rapport au travail qui doit être fait.

Simple exemple de mon incompréhension du sujet; ma première tâche est d'écrire une fonction qui initialiserait une variable globale "virtual disk_t g_disk ;" à partir du nom de répertoire contenant les disques virtuel. (On n'initialise pas la table d'inode dans un premier temps).
Mais pour le reste; je ne comprends pas vraiment à quoi correspondent les variables dans la structures.

Le fait d'allumer et d'éteindre le système RAID5 correspond il au fait d'ouvrir et de fermer les fichiers ?

Voilà désolé pour la masse de questions :?

Merci d'avance pour votre aide quand à la compréhension de ce sujet !

27/12/2013, 12h39
Metalman

1) Tu veux bien faire du RAID5 "normal"/simple ?
Parce que tu nous envoie sur le 05 ! :P

2) Tu veux faire du RAID5... mais... dans le sens "hardware" ou "software" ?
Hard => disques qui offrent une visibilité d'espace "normal", mais qui derrière font des bandes redondées
Soft => les disques sont normaux... ce sont les partitions qui sont dupliquées un peu partout... et là c'est le bordel à implémenter.... parce que tu as à la fois la gestion du FS à faire + la gestion du RAID sur plusieurs disques

Si tu arrives déjà à simuler du RAID5 hardware dans tes 4 fichiers, ça sera un premier pas très important pour toi !
27/12/2013, 13h21
Amnael

Je pense que c'est bien le RAID5 "simple" ;)

Celui qui correspond à ce schéma:

http://upload.wikimedia.org/wikipedi...RAID_5.svg.png

Et oui je pense que je serais assez content si j'arrivais à le faire ;)

Pour ta question 2; je saurais pas trop te dire; le projet simule les disques avec des fichiers et la perte de données par la suppression de l'un des fichiers. En tout cas c’est ce qu'il me semble en avoir compris.
27/12/2013, 13h42
Metalman

On t'a donné le sujet et il y a une moulinette de correction automatique qui donne des fichiers avec un format précis ?

Ou c'est bien un projet à présenter ?

Si tu restes dans le projet à présenter... il te faut quelques specs avant...
Par exemple : la taille max des fichiers... elle représentera la taille de chaque disque

- Tu peux démarrer en faisant une fonction qui coupera en bandes de taille N chaque fichier (CAD, tu prépares une structure qui décrit la taille des bandes, et numérote chaque fichier)
- Ensuite, tu peux faire une écriture "simple" : tu donnes un texte d'une certaine taille, et il va être découpé sur chaque bande (il faut un gros texte OU des petites bandes pour passer correctement ce test)... si tes bandes sont suffisament petites, en faisant un "cat" de chaque fichier, tu verras ton texte dans les 3 premiers fichiers, et le résultat du XOR dans le 4e
- La lecture, cette fois tu demandes à lire N octets de tes disques, et ça va lire dans "le bon ordre" chaque bande (c'est pour cela que tu dois garder dans ta structure initiale un nombre fixe par fichier/disque pour savoir dans quel ordre les itérer en lecture quand tu dépasses la taille d'une bande)
- Lecture "en mode récup'", cette fois tu as perdu un fichier, et tu fais la reconstruction du disque manquant en faisant les XOR des disques manquant

Si tu as ça... tu auras la "base"...
Il ne te manquera plus qu'une fonction de reconstruction qui sera "en gros" une surcouche de la lecture en mode récup' sur la taille d'un disque

EDIT : ah oui mal lu que tu as un header forcé ! désolé.
27/12/2013, 14h07
Amnael

On me fournit un début de spec avec le header que j'ai mis un peu plus haut.
Les 4 fichiers (représentant les disques) sont générés par un script et ont par conséquent tous la même taille et seront contenus dans un même dossier.

J'ai tout un tas de fonctions et procédures à faires ce n'est donc pas un projet où on est libre de présenter les choses comme on veut, je dois respecter ce que l'on me demande de faire.

J'aimerais bien faire passer le pdf en pièce jointe mais avec ma connexion je plante chaque fois avant de l'avoir uploader en entier... peut être par mail aurais je plus de chance ? Mais je veux pas abuser non plus ;)

Le projet est découpé en 3 parties

1 Gestion du RAID de bas niveau
2 Gestion e la table d'inode
3 Lecture/Ecriture/Suppression de fichiers.

Pour mon projet la taille des 4 fichiers est fixé à 500 000 octet Soit 500 Mo

Mais; si ça t'embête pas, ce que je cherche à faire ce serait un exemple simple et concret (même si ce n'est pas réaliste) en fixant une taille infime

Imaginons 4 fichiers de taille 20 octet.
Un bloc aurait une taille arbitraire de 3 octet.

Comment va se faire le découpage sur cet exemple lorsque l'on écrira dans le fichier ?
27/12/2013, 14h26
Metalman

Oui j'avais mal lu ton premier post... omg... pardon...

Pour le RAID5 de "base" sans penser aux inodes, mais juste en termes de données, voilà ce qui se passera :

1) 4 disques de 20o chacun = 3 disques utilisables, et 1 de redondance
CAD : 3 * 20 = 60o utilisables

2) Les blocs font 3o... c'est... pas génial... mais bon...
20 / 3 = 6o
Donc on va avoir 6 blocs de 3o sur chaque disque...
Donc en effet 6 bandes de 9o utilisables + 3o de redondance
3 * 6 = 18, 20 - 18 = 2o
Et pour ne rien perdre : 1 bloc supplémentaire de 2o (il vaut mieux perdre cet espace pour le moment... et ne pas s'en soucier)

3) Tu vas vouloir écrire 10o par exemple... (ça va dépasser... mais osef)
10 / 3 = 3
3 * 3 = 9
9 != 10
3 blocs ne suffisent pas, il en faudra un 4e...
Donc on va consommer 4 blocs. (sur le schéma wikipedia on va donc réserver les blocs A1, A2, A3 et B1... et on va écrire sur A1-3 & Ap et B1 et Bp)

B1 étant "seul".... pour faire une redondance, il faudra connaitre les valeurs des autres bandes B !
Pour cela, il faut initialiser les bandes !
Donc avant toute chose, pour que le RAID soit dispo, il faut l'initialiser en le remplissant de '\0' (sur TOUTES les bandes).

4) Tu vas écrire 0123456789 (10 caractères) sur ton RAID, on a dit qu'il fallait couper en blocs de 3o :
A1 va recevoir 012
A2 : 345
A3 : 678
STOP !
Tu as rempli 3 bandes, tu vas calculer leur redondance !
012 XOR 345 XOR 678
Ce résultat tu l'écris sur Ap, et tu peux reprendre l'écriture...
(attention ! Il faut accéder à A1, A2 et A3 pour obtenir leur contenu !)

B1 : 9
tu vas écrire 9 "tout seul"...
CAD que tu vas juste remplir le 1er octet, et interroger les blocs B1, B2, B3, les XOR comme en haut, et mettre le résultat dans Bp

Une fois cette opération terminée, quand tu vas faire un 'cat' de tes fichiers tu verras en gros :
Fichier 1 (A1, B1, ...) :
0129
Fichier 2 (A2, B2, ...) :
345
Fichier 3 (A3, Bp, ...) :
678xxx (3 caractères qui seront le résultat du XOR de B)
Fichier 4 (Ap, B3, ...) :
xxx (3 caractères qui seront le résultat du XOR de A)

Il te faut donc une fonction pour écrire/lire les blcos de tailles 3o (et aussi le bloc de 2o).
En gros il faut pouvoir choisir la lettre A-B-C-D-E-F, et le chiffre 1,2,3,p puis indiquer la taille que l'on écrit (inférieure ou égale à la taille du bloc en cours), et donner la donnée à recopier ou à extraire.

EDIT : j'ai même pas regardé le schéma... je suis parti sur l'idée qu'il y aurait 1 disque supplémentaire en parité.... preuve que je ne regarde qu'à peine les docs....
EDIT2 : maintenant c'est édité pour prise en compte de ce léger oubli ! :)
27/12/2013, 14h43
Amnael

Merci !!!

Tu peux pas savoir à quel point ton exemple m'a aidé à y voir plus clair !

Si je transpose mon énoncé avec ce que tu as dis, je suppose que lorsque tu parles de redondance, ça correspond au bloc de parité ?

Citation:

1) 4 disques de 20o chacun = 3 disques utilisables, et 1 de redondance
CAD : 3 * 20 = 60o utilisables

OK.

Citation:

2) Les bandes font 3o... c'est... pas génial... mais bon...
20 / 3 = 6o
Donc on va avoir 6 bandes de 3o sur chaque disque...
3 * 6 = 18, 20 - 18 = 2o
Et pour ne rien perdre : 1 bande supplémentaire de 2o (il vaut mieux perdre cet espace pour le moment... et ne pas s'en soucier)

C'est là que j'ai décroché

Pour moi une bande ce serait formé de A1 A2 A3 Ap où les A sont des blocs.
Donc si on a un bloc qui fait 3o; la bande ne devrait elle pas faire 9 octet utilisable plus 3 octet pour le bloc de parité, redondance ?

J'ai peut être compris de travers.
27/12/2013, 14h52
Metalman

2 pièce(s) jointe(s)

Voilà les images qui simulent ton exemple....

Evidemment c'est en schématisant que tout vient :
L'initialization met des '\0' sur toutes les bandes numérotées 1-3, et calcule le XOR de tous ces '\0' pour mettre le résultat dans les bandes p (normalement '\0' aussi si je ne me trompe pas trop trop...)

EDIT : euh oui.... les bandes sont les A1-3-p... et chaque Ax est un bloc....
Mais c'est qu'une erreur de vocabulaire de ma part....
Si le schéma est "bien" ce que tu avais en tête, alors on s'est compris ! :P
27/12/2013, 15h25
Amnael

Ouai je pense que c'est bien comme ça que je le visualisais.

Si je me résume
1 bloc de 3o
1 bande de 9o donnée + 3o redondance
4 disques 20o ==> 60o données + 20o redondance

6 bloc sur un disque + 2o redondance par disque
Et donc 6 bandes au total.

Question par rapport au XOR; j'ai compris le principe; ça permettra de retrouver un bloc disparu; mais dans la pratique comment ça marche.

Parce que, un xor c'est une opération mathématique; ou tout du moins une opération logique; donc pour implémenter ça en C avec les blocs qui eux contiennent des chaines de caractères ça va merder.
Ou alors on applique le xor non pas sur le contenu mais sur les indices ?

Enfin bref je vois ce que ça doit faire; mais je vois pas comment ça le fait :?

Merci pour ton aide; je pense que je vais commencer à coder les premières fonctions sinon je vais parler dans le vide à partir de maintenant, tu m'as bien aidé à dégrossir le fonctionnement je t'en remercie énormément !
27/12/2013, 15h47
Metalman

Citation:

6 bloc sur un disque + 2o redondance par disque

Plutôt 2o de "perdus" vu que l'on n'en fait rien...

L'histoire du XOR c'est en effet une opération de logique/maths.
A XOR B = C
B XOR C = A
C XOR A = B

C'est toute la "beauté" de cette opération :P
Et elle fonctionne aussi avec une taille indéfinie (cf wikipedia).

Pour l'implémenter... ça va être une autre paire de manche, je l'admets.
Le "XOR" tout seul existe en C... c'est ^

Pour le cas "simple" de nos 3o, il faudra faire du XOR octet par octet...
IRL, tu vas directement prendre des blocs de 32 ou 64 bits (4 ou 8 octets).

En gros pour déduire Ap :
1) Extraire A1, A2 et A3

2) Stocker A1[0] ^ A2[0] ^ A3[0]
3) Stocker A1[1] ^ A2[1] ^ A3[1]
4) Stocker A1[2] ^ A2[2] ^ A3[2]

5) Faire une chaîne de 3o avec les 3 valeurs stockées

6) Ecrire en Ap la chaîne générée

Ap[0] = A1[0] ^ A2[0] ^ A3[0]
Ap[1] = A1[1] ^ A2[1] ^ A3[1]
Ap[2] = A1[2] ^ A2[2] ^ A3[2]

Quand un disque "disparait", il faut évidemment garder en mémoire lequel est "mort", et le remplacer par Ap lorsque l'on fait des appels à un des A1-3

Ok; donc j'ai commencé à coder en fonction de ce que j'ai compris et de ce que l'on me demande.

Citation:

On considère que notre système RAID 5 est représenté par la variable globale virtual_disk_t g_disk ;.
Avant de pouvoir l’utiliser, il est nécessaire de l’initialiser à partir du nom du répertoire contenant les disques virtuels formatés. Ecrire la fonction init disk raid5 qui, à partir du nom du répertoire, initialise cette variable globale. Dans un premier temps, on n’initialisera pas la table d’inodes.
Lorsque notre système sera ” éteint”, il sera nécessaire de s’assurer de l’absence de risque de perte de données. Pour cela, écrire une fonction qui ” éteint” notre système RAID 5.

Toujours en prenant appuie sur le header du premier message

J'ai déclaré deux variables en global dans mon header.
Code:

1 2 virtual_disk_t g_disk; DIR* rep = NULL
Puis j'ai fait la fonction init pour allumer le système et la fonction pour l'éteindre.

Je suis pas sûr à 100% d'avoir bien transcris l'énoncé pour l'initialisation en tout cas.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 void init_disk_raid5(char* adresse) { g_disk.ndisk=NUMBER_OF_DISKS; g_disk.raidmode=5; rep = opendir(adresse); g_disk.storage[0]=fopen("d0","r"); g_disk.storage[1]=fopen("d1","r"); g_disk.storage[2]=fopen("d2","r"); g_disk.storage[3]=fopen("d3","r"); } void close_disk_raid5(char* adresse) { int k; for(k=0;k<g_disk.ndisk;k++) { fclose(g_disk.storage[k]); } closedir(rep); }
Il est possible que le code ne compile pas; j'ai surtout voulu montrer la démarche pour voir si j'avais compris dans le bon sens ou pas.

28/12/2013, 17h34
Sve@r
Citation:
Envoyé par Amnael

J'ai déclaré deux variables en global dans mon header.

Code:

1 2 virtual_disk_t g_disk; DIR* rep = NULL

Il est possible que le code ne compile pas; j'ai surtout voulu montrer la démarche pour voir si j'avais compris dans le bon sens ou pas.
Salut
Es-tu certain d'avoir besoin de variables "globales" ??? Les globales c'est utile vu que ça a été créé mais c'est aussi super dangereux et super limitatif (par exemple tu ne pourras pas utiliser plus d'un seul raid par programme)...

Ca a l'air d'être un énoncé... on va pas contredire "à chaque fois" qu'il y a une globale surtout quand c'est un exercice.
Enfin au moins il le saura que c'est "à éviter" tu vas me dire :P
EDIT : par contre Sve@r a raison à propos du répertoire... pas besoin de le mettre en global !

Bref, en relisant 2-3 fois ta première déclaration et ta globale je pense avoir compris comment c'est organisé pour ton projet.
Code:

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 #ifndef __R5_DEFINES__ #define __R5_DEFINES__ #define NUMBER_OF_DISKS 4 #define BLOCK_SIZE 4 #define FILENAME_MAX_SIZE 32 #define MAX_FILES 100 #define MAX_FILE_SIZE (50*1024) typedef unsigned int uint; typedef unsigned char uchar; /* Type of a block of data */ typedef struct block_s{ uchar data[BLOCK_SIZE]; } block_t; /* Type of the pseudo-inode structure */ typedef struct inode_s{ char filename[FILENAME_MAX_SIZE]; uint size; uint nblock; // nblock = (size+BLOCK_SIZE-1)/BLOCK_SIZE uint block_id; } inode_t; /* Type of the inode table */ typedef inode_t inode_table_t[MAX_FILES]; /* Type of the virtual disk system */ typedef struct virtual_disk_s { inode_table_t inodes; int ndisk; int raidmode; FILE *storage[NUMBER_OF_DISKS]; } virtual_disk_t;
Code:

1 2 virtual_disk_t g_disk; DIR* rep = NULL
virtual_disk : c'est l'espace disque qui sera "utilisable" par l'utilisateur du RAID
virtual_disk_t : type qui contient une grappe de disques (des FILE* dans notre cas), le type de raid, le nb de disques, et une table d'inodes [au début je croyais qu'il fallait écrire la table d'inodes dans le RAID !... en fait non elle est bien à part)
inode_table_t : type qui est en fait un tableau d'inodes
inode_t : type inode qui contient un nom de fichier, une taille de fichier, le nb de blocs alloués, et l'ID du 1er bloc
block_t : un bloc... c'est simplement "un" caractère non signé [non, c'est bel et bien plusieurs caractères]

Comme les blocs sont en fait des caractères, pour pouvoir "contenir" des '\0' (c'est aussi une donnée en soi...) dans des fichiers, on indiquer le 1er bloc alloué, et le nb de blocs associés au fichier.

Je suppose que pour l'exercice, les fichiers ne peuvent pas être de taille variable. (les inodes ne ressemblent pas aux inodes à la sauce linux où il y a des sauts entre plusieurs inodes)
Tout ce que l'on a essayé de faire depuis le début est correct donc, il faudra "juste" passer par l'interface fournie pour écrire caractère par caractère ! ;)

A propos des fonctions d'ouverture et de fermeture :
- la fermeture est correcte... à ceci près que tu peux faire le closedir dans l'ouverture du RAID
- l'ouverture est très très.... elle marche clairement pas... mais l'idée est là (et tu peux faire un closedir après avoir ouvert tes 4 fichiers/disques)

L'ouverture va fonctionner ainsi :
1) on ouvre le dossier
2) on cherche les 4 fichiers en itérant dans le dossier
3) on ouvre un à un chaque fichier (si UN seul fichier manque, le RAID sera en mode dégradé, s'il en manque + d'un, alors le RAID est cassé, et on annule l'ouverture et on écrit un gros message d'erreur, par exemple)
4) une fois les 3 ou 4 fichiers chargés, on ferme le répertoire

Pour le chargement de la table d'inodes... je... ne comprends pas encore comment ça va se faire en fait...
Mais si tu as un énoncé complet qui te le dit, tant mieux !

30/12/2013, 11h58
Sve@r
Citation:

Envoyé par Metalman

Ca a l'air d'être un énoncé... on va pas contredire "à chaque fois" qu'il y a une globale surtout quand c'est un exercice.

Héhé, tout exercice est quand-même fait pour aussi donner les bonnes habitudes :ccool:
Citation:
Envoyé par Metalman

Code:

1 2 3 4 /* Type of a block of data */ typedef struct block_s{ uchar data[BLOCK_SIZE]; } block_t;

block_t : un bloc... c'est simplement "un" caractère non signé
Euh c'est plutôt un tableau de "n" caractères

Citation:

Envoyé par Metalman

Mais si tu as un énoncé complet qui te le dit, tant mieux !

Moi j'aime beaucoup ce TP et je dis chapeau au prof qui l'a pondu et qui est capable de le corriger. Et j'aimerais bien avoir l'énoncé pour m'amuser à le faire de mon coté...
30/12/2013, 12h34
Metalman

Oups... oui en effet le bloc est composé de N caractères.... :oops: my bad...

Moi aussi ça me donne envie de le faire du coup... ^^'
Amnael... tu nous file l'énoncé complet ? :D
04/01/2014, 21h59
Amnael

1 pièce(s) jointe(s)

De retour à la civilisation j'ai pu mettre le pdf en pièce jointe; Have fun ;)

Et désolé pour le temps sans réponse, je n'avais plus d'internet jusqu'à ce soir !

Je me replonge dès aujourd'hui dans ce projet; une semaine top chrono ;)

Pour le répertoire en global; c'était très maladroit je vous l'accorde je ne m'en suis rendu compte qu'après coup; le répertoire étant dépendant de l'adresse il n'y a aucune raison de le déclarer en global, je suis OK sur ce point.

Citation:

L'ouverture va fonctionner ainsi :
1) on ouvre le dossier
2) on cherche les 4 fichiers en itérant dans le dossier
3) on ouvre un à un chaque fichier (si UN seul fichier manque, le RAID sera en mode dégradé, s'il en manque + d'un, alors le RAID est cassé, et on annule l'ouverture et on écrit un gros message d'erreur, par exemple)
4) une fois les 3 ou 4 fichiers chargés, on ferme le répertoire
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 void init_disk_raid5(char* adresse) { DIR* rep = NULL; g_disk.ndisk=NUMBER_OF_DISKS; g_disk.raidmode=5; rep = opendir(adresse); /*1*/ /*3*/ g_disk.storage[0]=fopen("d0","r"); g_disk.storage[1]=fopen("d1","r"); g_disk.storage[2]=fopen("d2","r"); g_disk.storage[3]=fopen("d3","r"); /*3*/ closedir(rep);/*4*/ }
1 - OK; mais comment gérer une erreur du style l'adresse entré n'est pas celle d'un dossier mais même à un fichier par exemple.
(Ici je pense que je peux définir l'adresse avec une constante vu que le raid sera automatiquement dans un même dossier; mais par curiosité j'aimerais savoir comment on gérerait un test de ce genre.

2 - J'avoue ne pas trop savoir comment parcourir le dossier et arriver à lister son contenu. Après plusieurs recherches j'ai pu dénicher une bibliothèque dirent.h qui permettrait ce genre de choses, mais je suis pas sur de tout avoir compris sur ce point là. N'y as t'il pas un moyen de faire sans bibliothèques supplémentaires ?

3 - OK; c'est ce que j'ai fait en supposant qu'ils sont effectivement présent il faut donc rajouter la condition 2 là dessus.

4 - Ok; je n'ai qu'à faire passer ma fermeture dans cette fonction là; mais en réalité je pensais que fermer le dossier pourrait avoir une incidence sur les fichiers déjà ouverts.

EDIT

Après modification voilà ce que ça donne
Je fais bien le test je pense; mais ça n'est pas non plus de la gestion d'erreur; l'affichage ne mettra pas un terme au programme; peut être y a t'il un code similaire au exit en sh pour faire en sorte que lorsque le raid est cassé l'on quitte automatiquement le programme ?
Code:

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 void init_disk_raid5(char* adresse) { DIR* rep = NULL; g_disk.ndisk=NUMBER_OF_DISKS; g_disk.raidmode=5; int nbFich=4; rep = opendir(adresse); int fich=nbFich; g_disk.storage[0]=fopen("d0","r"); g_disk.storage[1]=fopen("d1","r"); g_disk.storage[2]=fopen("d2","r"); g_disk.storage[3]=fopen("d3","r"); closedir(rep); int k; for (k=0;k<g_disk.ndisk;k++) { if (g_disk.storage[k]==NULL) { fich=(fich-1); } } if (fich < nbFich-2) { printf("Deux fichiers ou plus manquant\n RAID5 cassé \n"); } }

06/01/2014, 15h44
Sve@r
De retour moi-aussi. J'ai lu attentivement le sujet. je trouve le barème super hard (si un programme ne compile pas => 0 !!!).

Bon, ceci dit, je regarde ton code. Exemple
Code:

1 2 3 4 g_disk.storage[0]=fopen("d0","r"); g_disk.storage[1]=fopen("d1","r"); g_disk.storage[2]=fopen("d2","r"); g_disk.storage[3]=fopen("d3","r");
Et ainsi de partout ce qui signifie (avec ces instructions identiques x4) que tu pars billes en têtes sur un système de 4 disques. Mais as-tu lu cette partie

Citation:

Pour effectuer vos tests, nous vous conseillons les valeur suivantes de ces constantes.
#define NUMBER OF DISKS 4
#define BLOCK SIZE 4
#define FILENAME MAX SIZE 32
#define MAX FILES 100
#define MAX FILE SIZE (50∗1024)
Veuillez vous assurer toutefois que si on change leur valeurs, votre système doit rester opérationnel.

Ca signifie que ton système devra fonctionner à l'identique pour 3 ou 300 disques !!!
Donc déjà il faut immédiatement remplacer toutes tes opérations à 4 disques par des opérations à N disques (avec itération de tableaux !!!)
Je dis "immédiatement" parce que plus tôt on détecte une faille de ce genre de la rectifier plus facile il est (tiens, je parle comme Yoda :)).

PS: j'aime bien cette partie

Citation:

Attention, un outil de détection de la copie sera utilisée sur les archives déposées. Toute copie avérée entrainera la note de 0 au projet et une convocation par le directeur des études et le responsable de l’unité d’enseignement.

Moi, je dis qu'un prof d'info qui n'est pas capable de mettre des droits intelligents sur son dossier de rendu de TP pour que l'élève Dupond ne puisse pas récupèrer le travail de l'élève Durand mérite de se faire hacker et mérite de se faire convoquer tout seul par le directeur des études pendant que le hackeur prend sa place...
Citation:
L’exemple fourni dans cmd format peut être analysé pour servir de base à l'écriture des autres programmes demandés.

Code:

1 2 // si on appelle #./ cmd format hello 500 2
... surtout quand en plus il bosse en permanence sous root. 8-)

Pour la copie => tu peux rendre la même tarball que ton copain... ça n'est pas du hack, et nécessite encore moins de capacités à réfléchir :P

Le 0 en cas de non compilation, c'est "normal"... enfin à mon goût... on fait de l'informatique, c'est le minimum de rendre un truc qui compile.
Le barème est même très tolérant comparé à d'autres écoles...
Mais bref, ça n'est pas le but de la discussion....

Pour la navigation dans les dossiers, remets ton code au propre, déjà !
Code:

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 void init_disk_raid5(char* adresse) { DIR* rep = NULL; int nbFich=4; int fich=nbFich; int k; g_disk.ndisk=NUMBER_OF_DISKS; g_disk.raidmode=5; rep = opendir(adresse); g_disk.storage[0]=fopen("d0","r"); g_disk.storage[1]=fopen("d1","r"); g_disk.storage[2]=fopen("d2","r"); g_disk.storage[3]=fopen("d3","r"); closedir(rep); for (k=0;k<g_disk.ndisk;k++) { if (g_disk.storage[k]==NULL) { fich=(fich-1); } } if (fich < nbFich-2) { printf("Deux fichiers ou plus manquant\n RAID5 cassé \n"); } }
Tu ne construis pas le chemin absolu depuis ton dossier, c'est dommage (mais chiant à faire)....
En effet, tu ouvres un répertoire, te balades dedans et tu ouvres des fichiers en dur.
Bref....
Entre le openddir et le closedir, tu dois faire des readdir ! [man section 3.... et non section 2 comme je m'étais dans un autre topic...]
Chaque readdir te renverra une structure correspondant à UN fichier...
Il faut donc itérer autant de fois que nécessaire (jusqu'à ce qu'il te renvoit NULL).

La structure dirent ressemble à peu près à ça :
Code:

1 2 3 4 5 6 7 struct dirent { ino_t d_ino; /* numéro d'inœud */ off_t d_off; /* décalage jusqu'à la dirent suivante */ unsigned short d_reclen; /* longueur de cet enregistrement */ unsigned char d_type; /* type du fichier */ char d_name[256]; /* nom du fichier */ };
d_type va te donner le type de fichier que tu as actuellement... la valeur DT_REG dit que c'est un fichier !
Et d_name contient le chemin absolu du fichier... que tu peux donner à fopen !

Seule question (peut être à poser au prof/j'ai mal lu le sujet) : où sont les noms des fichiers qui gèrent les disques ? Qui les donne ?

06/01/2014, 17h06
Amnael
Le nom des disques est généré par un script

Le nom ce sera toujours d suivi du numéro du disque=fichier.

Pour ce qui est du readdir là encore je découvre è_é

En fait on a pas eu un seul cours dans lequel on nous as appris la syntaxe et donc on doit tout chercher nous mêmes...je comprends le but mais je trouve quand meme ça un peu dommage ;)

Pour faire ce que j'ai fait je me suis renseigné sur le sdz.

Mais il n'y a pas de mention sur readdir.

En ce qui concerne le fait d'adapter au nombre de disques; OK mais dans la pratique ça veut dire que je dois concaténer un numéro au dte

En fait un truc qui ressemblerait à ça même si le code que je présente là n'est pas correct
Code:

1 2 3 4 for(k=0;k<g_disk.ndisk;k++) { g_disk.storage[k]=fopen("dk","r"); }
Je vais tout de suite chercher s'il y a quelque chose pour faire cette espèce de concaténation; mais je me rappelle avoir voulu faire cela au début sans succès.

Voilà à quoi j'ai pensé comme solution.
Code:

1 2 3 4 5 6 7 for(k=0;k<NUMBER_OF_DISK;k++) { fichier[FILENAME_MAX_SIZE]="d"; strcat(fichier,"%d",k); g_disk.storage[k]=fopen("fichier","r"); }
Mais j'ai pas mal de doutes; est ce que je peux concaténer la valeur de k avec strcat ou bien ça va me prendre la chaine %d,k
Ensuite en mettant fichier dans le fopen comprendra il la variable fichier ou bien la chaine fichier.

EDIT 3 ;)

J'ai trouvé la fonction pour faire ça c'est sprintf.

par contre je suis pas sur de comment ça doit marcher; à priori les fichiers ne peuvent porter comme nom que d0...dn mais pourtant la taille maximale va jusqu'à 32 ce qui serait absurde si on devait restreindre les noms.

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

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.

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

Citation:

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:

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 !

Citation:
Envoyé par Amnael
Code:

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:

1 2 3 4 5 for (k=0;k<NUMBER_OF_DISKS;k++) { char fichier[FILENAME_MAX_SIZE]; sprintf(fichier,"d%d", k); }
Citation:
Envoyé par Amnael
Code:

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:

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]); } }
Citation:
Envoyé par Amnael
Code:

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:

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:

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:

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); }
Citation:

Envoyé par 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 ;)

Je vais rester tant que je peux...

Citation:

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 :aie:

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:

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.

Citation:

Envoyé par Amnael

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:

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); }
Citation:

Envoyé par Amnael

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 :aie:
...
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:

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...

07/01/2014, 03h20
Amnael
Je ne comprends pas quand tu utilises cette notation
Code:

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

Citation:

Envoyé par Amnael

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

Citation:

Envoyé par Amnael

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:

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

Citation:

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...

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 :ccool:
Code:

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:

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

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

Citation:
Envoyé par Amnael
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:

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:

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.

Citation:

Envoyé par Amnael

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.

Merci pour tes conseils !

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

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:

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:

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:

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 :roll:

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

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:

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:

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 ?

07/01/2014, 15h57
Sve@r
Citation:

Envoyé par Amnael

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...
Citation:
Envoyé par Amnael

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

Code:

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 !!!

Citation:

Envoyé par Amnael

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...

Citation:

Envoyé par Amnael

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

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:

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:

fseek(disk_id,BLOCK_SIZE,pos);

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

Code:

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...

07/01/2014, 16h21
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.
07/01/2014, 16h35
Zethzer

Citation:

Envoyé par 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.

Merci bien ! Bon à savoir ça ! :D

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

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:

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:

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...

07/01/2014, 17h34
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:

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:

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.
07/01/2014, 18h15
Sve@r
Citation:

Envoyé par Amnael

Code:

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...
Citation:

Envoyé par Amnael

ç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...

Citation:

Envoyé par Zethzer

Code:

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...

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 è_é:roll:
Code:

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:

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 :aie:

07/01/2014, 22h02
Sve@r

Citation:

Envoyé par Amnael

...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 :aie:

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

Code:

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

Fuseau horaire GMT +2. Il est actuellement 03h05.