wiki-se.plil.fr - Contributions [fr]

SE5 système/réseau 2023/2024

2023-12-06T14:30:53Z

Asellali : /* Menu de la première séance */

= PRA SE5 =

== Menu de la première séance ==

Pour la première séance du 06/10/2023 il vous est demandé d'effectuer individuellement les opérations listées ci-dessous.
* création d'une machine virtuelle sur le serveur <code>capbreton</code> ;
* création d'un conteneur "à la main" sur votre station de travail <code>zabeth</code> :
** créez un conteneur isolé au maximum (sauf pour les utilisateur) avec la méthode décrite en cours,
** création d'un commutateur virtuel privé sur la <code>zabeth</code> dans le réseau IPv4 <code>192.168.68.0/24</code>, l'adresse <code>192.168.68.1</code> est affectée au commutateur lui-même,
** création d'une interface Ethernet virtuelle, une extrémité doit être envoyée dans le conteneur, l'autre dans le commutateur virtuel privé,
** mise en place d'une mascarade sur la <code>zabeth</code>, vérifiez que le conteneur a accès aux mêmes machines que la <code>zabeth</code>.

Par binôme vous devez créer une machine virtuelle mandataire connectée sur le commutateur virtuel SE5 et sur le commutateur virtuel privé des machines virtuelles de services concernées (voir deuxième section du sujet).

Globalement vous devez configurer le routeur principal de la promotion (voir la troisième section du sujet). Pour votre promotion il s'agit du Catalyst 9200 situé en E304. Il faut le connecter en fibre vers le serveur <code>capbreton</code> de la E306 dans le commutateur virtuel SE5 et aussi en fibre vers le local technique SR52 sur un port dans le VLAN 531. Vous pouvez configurer le commutateur via l'utilitaire <code>minicom</code> à partir de la machine <code>zabeth09</code>.

Répartition des élèves pour la première séance :
{| class="wikitable"
! Station de travail !! Elève
|-
| zabeth02 || Elias SIMON
|-
| zabeth03 || Mathis RIFFAUT
|-
| zabeth04 || Dann RODENBURG
|-
| zabeth05 || Benjamin NGUYEN
|-
| zabeth06 || Halaoui Mohammed
|-
| zabeth07 || Blgrim Haitam
|-
| zabeth08 || Florian Vallée
|-
| zabeth09 (routeur) || Julien Charleux
|-
| zabeth10 || Amine SELLALI
|-
| zabeth11 || Paul Amoros
|-
| zabeth12 || Maël Delaby
|-
| zabeth13 || Black Baptiste
|-
| zabeth14 || Timothé Brenier
|-
| zabeth15 || Jeanne Delcourt
|-
| zabeth16 || Estelle Godard
|-
| zabeth17 || Jason DELANNOY
|-
| zabeth18 || Chloé Lemaire
|-
| zabeth19 || Gabriel THOMAS
|-
| zabeth20 || Albin MOUTON
|-
| zabeth21 || Konstantin PATRIKEEV
|-
| zabeth22 || Maxime Balbastre
|-
| zabeth26 || François NAUDOT
|-
| zabeth27 || Karl HABRE
|-
| zabeth28 || Rémi FARAULT
|-
| zabeth30 || Prénom Nom
|-
|}

== Répartition des binômes en PRA ==

Concertez-vous pour trouver des noms de machines de services et de machines mandataires dans deux thèmes.

{| class="wikitable"
! Cahier !! Nom machine services
!IP machine services !! Nom de domaine !! Nom machine mandataire
!IP machine mandataires!! Elève
|-
| [[Atelier SysRes SE5 2023/2024 E1 | Cahier n°1]]
| || || || || || Prénom Nom
|-
| [[Atelier SysRes SE5 2023/2024 E2 | Cahier n°2]]
| Elom|| || || Baloo|| || Elias SIMON
|-
| [[Atelier SysRes SE5 2023/2024 E3 | Cahier n°3]]
| Mustafar (Mustafare)|| || mustafare.lol|| Baloo|| 193.48.57.189|| Mathis RIFFAUT
|-
| [[Atelier SysRes SE5 2023/2024 E4 | Cahier n°4]]
| Dagobah|| || || Aladin|| || Dann RODENBURG
|-
| [[Atelier SysRes SE5 2023/2024 E5 | Cahier n°5]]
| Motis|| || || Dingo|| || Mohammed Halaoui
|-
| [[Atelier SysRes SE5 2023/2024 E6 | Cahier n°6]]
| bogano|| || || Timon|| || Benjamin Nguyen
|-
| [[Atelier SysRes SE5 2023/2024 E7 | Cahier n°7]]
| Takobo|| || || Timon|| 193.48.57.184|| Timothé Brenier
|-
| [[Atelier SysRes SE5 2023/2024 E8 | Cahier n°8]]
| Fondor|| || || mushu|| 193.48.57.190|| Florian Vallée
|-
| [[Atelier SysRes SE5 2023/2024 E9 | Cahier n°9]]
| hoth|| || || BlancheNeige|| 193.48.57.187|| Haitam Blgrim
|-
| [[Atelier SysRes SE5 2023/2024 E10 | Cahier n°10]]
| Abafar|| || abafar.lol|| Aladin|| 193.48.57.179|| Amine SELLALI
|-
| [[Atelier SysRes SE5 2023/2024 E11 | Cahier n°11]]
| Rotia|| || || DIngo|| 193.48.57.181|| Rémi Farault
|-
| [[Atelier SysRes SE5 2023/2024 E12 | Cahier n°12]]
| jedha|| || || judy|| 193.48.57.182|| Julien Charleux
|-
| [[Atelier SysRes SE5 2023/2024 E13 | Cahier n°13]]
| Bogden|| || || BlancheNeige|| || Black Baptiste
|-
| [[Atelier SysRes SE5 2023/2024 E14 | Cahier n°14]]
| || || || || 193.48.57.188|| Maël Delaby
|-
| [[Atelier SysRes SE5 2023/2024 E15 | Cahier n°15]]
| jiruus|| || || cruella|| || Jeanne Delcourt
|-
| [[Atelier SysRes SE5 2023/2024 E16 | Cahier n°16]]
| exegol|| || || cruella|| 193.48.57.186|| Estelle Godard
|-
| [[Atelier SysRes SE5 2023/2024 E17 | Cahier n°17]]
| Jakku|| || || Jafar|| || Jason DELANNOY
|-
| [[Atelier SysRes SE5 2023/2024 E18 | Cahier n°18]]
| naboo|| 192.168.18.2|| naboo.lol|| bouh|| 193.48.57.180 / 192.168.18.1|| Chloé Lemaire
|-
| [[Atelier SysRes SE5 2023/2024 E19 | Cahier n°19]]
| geonosis|| || geonosis.lol|| bouh|| || Gabriel THOMAS
|-
| [[Atelier SysRes SE5 2023/2024 E20 | Cahier n°20]]
| alderaan|| || || Jafar|| 193.48.57.183|| Albin MOUTON
|-
| [[Atelier SysRes SE5 2023/2024 E21 | Cahier n°21]]
| kesh|| || || Judy|| || Konstantin Patrikeev
|-
| [[Atelier SysRes SE5 2023/2024 E22 | Cahier n°22]]
| kashyyyk|| || || mushu|| || Maxime BALBASTRE
|-
| [[Atelier SysRes SE5 2023/2024 E23 | Cahier n°23]]
| Felucia|| || || || 193.48.57.185|| François NAUDOT
|-
| [[Atelier SysRes SE5 2023/2024 E24 | Cahier n°24]]
| Pelagon|| || || || || Paul Amoros
|-
|
|
|}

== Contrôle continu ==

=== Contrôle du 20/11/2023 ===

A noter qu'aucune machine, quelle soit de service ou mandataire, ne peut avoir accès à Internet vu qu'aucun effort n'a été fait pour relier le serveur <code>capbreton</code> au réseau SE5.

Machines de service.

{| class="wikitable"
! Elève !! Nom machine !! Configuration IP
|-
| Elom || Elias SIMON || une seule interface dans le <code>.cfg</code> (CV SE5), pas de configuration IP
|-
| Mustafar|| Mathis RIFFAUT || une seule interface dans le <code>.cfg</code> (CV SE5), pas de configuration IP
|-
| Dagobah|| Dann RODENBURG || une seule interface dans le <code>.cfg</code> (CV SE5), pas de configuration IP
|-
| Motis || Mohammed Halaoui || une seule interface dans le <code>.cfg</code> (CV SE5), pas de configuration IP
|-
| bogano || Benjamin Nguyen || une seule interface dans le <code>.cfg</code> (CV SE5), pas de configuration IP
|-
| Takobo || Timothé Brenier || une seule interface dans le <code>.cfg</code> (CV SE5), pas de configuration IP
|-
| Fondor || Florian Vallée || une seule interface dans le <code>.cfg</code> (CV SE5), pas de configuration IP
|-
| hoth || Haitam Blgrim || une seule interface dans le <code>.cfg</code> (CV SE5), pas de configuration IP
|-
| Abafar || Amine SELLALI || une seule interface dans le <code>.cfg</code> (CV SE5), pas de configuration IP
|-
| Rotia || Rémi Farault || une seule interface dans le <code>.cfg</code> (CV SE5), pas de configuration IP
|-
| jedha || Julien Charleux || une seule interface dans le <code>.cfg</code> (CV SE5), pas de configuration IP
|-
| Bogden || Black Baptiste || une seule interface dans le <code>.cfg</code> (CV SE5), pas de configuration IP
|-
| jiruus || Jeanne Delcourt || une seule interface dans le <code>.cfg</code> (CV SE5), pas de configuration IP
|-
| exegol || Estelle Godard || une seule interface dans le <code>.cfg</code> (CV SE5), pas de configuration IP
|-
| Jakku || Jason DELANNOY || une seule interface dans le <code>.cfg</code> (CV SE5), pas de configuration IP
|-
| naboo || Chloé Lemaire || une seule interface dans le <code>.cfg</code> (CV SE5), pas de configuration IP
|-
| geonosis || Gabriel THOMAS || une seule interface dans le <code>.cfg</code> (CV SE5), pas de configuration IP
|-
| alderaan || Albin MOUTON || une seule interface dans le <code>.cfg</code> (CV SE5), pas de configuration IP
|-
| kesh || Konstantin Patrikeev || une seule interface dans le <code>.cfg</code> (CV SE5), pas de configuration IP
|-
| kashyyyk || Maxime BALBASTRE || une seule interface dans le <code>.cfg</code> (CV SE5), pas de configuration IP
|-
| Felucia || François NAUDOT || une seule interface dans le <code>.cfg</code> (CV SE5), pas de configuration IP
|-
|}

Machines mandataires.

{| class="wikitable"
! Elèves !! Nom machine !! Configuration IP
|-
| Elias SIMON & Mathis RIFFAUT || Baloo || une seule interface dans le <code>.cfg</code> (CV SE5), aucun CV privé, pas de configuration IP
|-
| Dann RODENBURG & Amine SELLALI || Aladin || une seule interface dans le <code>.cfg</code> (CV SE5), aucun CV privé, pas de configuration IP
|-
| Mohammed Halaoui & Rémi Farault || Dingo || une seule interface dans le <code>.cfg</code> (CV SE5), aucun CV privé, pas de configuration IP
|-
| Benjamin Nguyen & Timothé Brenier || Timon || une seule interface dans le <code>.cfg</code> (CV SE5), aucun CV privé, pas de configuration IP
|-
| Florian Vallée & Maxime BALBASTRE || mushu || une seule interface dans le <code>.cfg</code> (CV SE5), aucun CV privé, pas de configuration IP
|-
| Haitam Blgrim & Black Baptiste || BlancheNeige || une seule interface dans le <code>.cfg</code> (CV SE5), aucun CV privé, pas de configuration IP
|-
| Jeanne Delcourt & Estelle Godard || cruella || une seule interface dans le <code>.cfg</code> (CV SE5), aucun CV privé, pas de configuration IP
|-
| Jason DELANNOY & Albin MOUTON || Jafar || une seule interface dans le <code>.cfg</code> (CV SE5), aucun CV privé, pas de configuration IP
|-
| Chloé Lemaire & Gabriel THOMAS || bouh || une seule interface dans le <code>.cfg</code> (CV SE5), aucun CV privé, pas de configuration IP
|-
| Konstantin Patrikeev & Julien Charleux || judy || une seule interface dans le <code>.cfg</code> (CV SE5), aucun CV privé, pas de configuration IP
|-
| François NAUDOT || || rien
|-
|}

Liste des machines

Elom Mustafar dagobah Motis bogano Takobo Fondor hoth abafar Rotia jedha Bogden jiruus exegol Jakku naboo geonosis alderaan kesh kashyyyk Felucia

Baloo aladin Dingo Timon mushu BlancheNeige cruella Jafar bouh judy

=== Contrôle du 03/12/2023 ===

Le serveur <code>capbreton</code> a été relié au réseau SE5 par <code>naboo</code>.

Il est normal de ne pas avoir d'adresse IPv4 sur la machine de services pour l'interface sur le commutateur virtuel. Par contre, avec mise en place de la mascarade sur la machine mandataire, il doit être possible, pour la machine de services, de se connecter à Internet en IPv4.

{| class="wikitable"
! Elève !! Nom machine !! Configuration IP
|-
| Elom || Elias SIMON
| IPv4 sur CV : 10.0.69.220, pas d'IPv4 sur SE5, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:fe0f:b26d, pas de connexion à Internet en IPv4, connexion à Internet en IPv6 possible, pas de résolution DNS fonctionnelle
|-
| Mustafar|| Mathis RIFFAUT
| IPv4 sur CV : 10.0.69.165, pas d'IPv4 sur SE5, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:fea9:f79, pas de connexion à Internet en IPv4, connexion à Internet en IPv6 possible, pas de résolution DNS fonctionnelle
|-
| Dagobah|| Dann RODENBURG
| IPv4 sur CV : 10.0.69.205, pas d'IPv4 sur SE5, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:fe53:7d33, pas de connexion à Internet en IPv4, connexion à Internet en IPv6 possible, pas de résolution DNS fonctionnelle
|-
| Motis || Mohammed Halaoui
| IPv4 sur CV : 10.0.69.195, pas d'IPv4 sur SE5, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:fe7c:2d6a, pas de connexion à Internet en IPv4, connexion à Internet en IPv6 possible, pas de résolution DNS fonctionnelle
|-
| bogano || Benjamin Nguyen
| IPv4 sur CV : 10.0.69.245, pas d'IPv4 sur SE5, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:fe62:6960, pas de connexion à Internet en IPv4, connexion à Internet en IPv6 possible, pas de résolution DNS fonctionnelle
|-
| Takobo || Timothé Brenier
| IPv4 sur CV : 10.0.69.181, pas d'IPv4 sur SE5, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:fe93:8c48, pas de connexion à Internet en IPv4, connexion à Internet en IPv6 possible, pas de résolution DNS fonctionnelle
|-
| Fondor || Florian Vallée
| IPv4 sur CV : 10.0.69.200, pas d'IPv4 sur SE5, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:fe2d:82bf, pas de connexion à Internet en IPv4, connexion à Internet en IPv6 possible, pas de résolution DNS fonctionnelle
|-
| hoth || Haitam Blgrim
| IPv4 sur CV : 10.0.69.157, pas d'IPv4 sur SE5, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:fee8:4736, pas de connexion à Internet en IPv4, connexion à Internet en IPv6 possible, pas de résolution DNS fonctionnelle
|-
| Abafar || Amine SELLALI
| IPv4 sur CV : 10.0.69.233, pas d'IPv4 sur SE5, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:feae:bcbb, pas de connexion à Internet en IPv4, connexion à Internet en IPv6 possible, pas de résolution DNS fonctionnelle
|-
| Rotia || Rémi Farault
| IPv4 sur CV : 10.0.69.130, pas d'IPv4 sur SE5, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:fe2e:ec48, pas de connexion à Internet en IPv4, connexion à Internet en IPv6 possible, pas de résolution DNS fonctionnelle
|-
| jedha || Julien Charleux
| IPv4 sur CV : 10.0.69.221, pas d'IPv4 sur SE5, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:fef6:364f, pas de connexion à Internet en IPv4, connexion à Internet en IPv6 possible, pas de résolution DNS fonctionnelle
|-
| Bogden || Black Baptiste
| IPv4 sur CV : 10.0.69.246, pas d'IPv4 sur SE5, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:fe67:89fd, pas de connexion à Internet en IPv4, connexion à Internet en IPv6 possible, pas de résolution DNS fonctionnelle
|-
| jiruus || Jeanne Delcourt
| IPv4 sur CV : 10.0.69.247, pas d'IPv4 sur SE5, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:fe9c:6f0e, pas de connexion à Internet en IPv4, connexion à Internet en IPv6 possible, pas de résolution DNS fonctionnelle
|-
| exegol || Estelle Godard
| IPv4 sur CV : 10.0.69.147, pas d'IPv4 sur SE5, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:fe17:bc38, pas de connexion à Internet en IPv4, connexion à Internet en IPv6 possible, pas de résolution DNS fonctionnelle
|-
| Jakku || Jason DELANNOY
| IPv4 sur CV : 10.0.69.136, pas d'IPv4 sur SE5, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:fee1:1e4d, pas de connexion à Internet en IPv4, connexion à Internet en IPv6 possible, pas de résolution DNS fonctionnelle
|-
| naboo || Chloé Lemaire
| IPv4 sur CV : 192.168.18.2, pas d'IPv4 sur SE5, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:fef2:7e2, pas de connexion à Internet en IPv4, connexion à Internet en IPv6 possible, résolution DNS fonctionnelle
|-
| geonosis || Gabriel THOMAS
| IPv4 sur CV : 10.0.69.231, pas d'IPv4 sur SE5, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:feb0:b140, pas de connexion à Internet en IPv4, connexion à Internet en IPv6 possible, pas de résolution DNS fonctionnelle
|-
| alderaan || Albin MOUTON
| IPv4 sur CV : 10.0.69.106, pas d'IPv4 sur SE5, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:fe97:2114, pas de connexion à Internet en IPv4, connexion à Internet en IPv6 possible, pas de résolution DNS fonctionnelle
|-
| kesh || Konstantin Patrikeev
| IPv4 sur CV : 10.0.69.222, pas d'IPv4 sur SE5, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:fe10:e2cb, pas de connexion à Internet en IPv4, connexion à Internet en IPv6 possible, pas de résolution DNS fonctionnelle
|-
| kashyyyk || Maxime BALBASTRE
| IPv4 sur CV : 10.0.69.240, pas d'IPv4 sur SE5, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:feca:73e7, pas de connexion à Internet en IPv4, connexion à Internet en IPv6 possible, pas de résolution DNS fonctionnelle
|-
| Felucia || François NAUDOT
| IPv4 sur CV : 10.0.69.139, pas d'IPv4 sur SE5, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:fe89:460a, pas de connexion à Internet en IPv4, connexion à Internet en IPv6 possible, pas de résolution DNS fonctionnelle
|-
|}

Machines mandataires.

{| class="wikitable"
! Elèves !! Nom machine !! Configuration IP
|-
| Elias SIMON & Mathis RIFFAUT || Baloo
| IPv4 sur CV : 10.0.69.152, pas d'IPv4 sur SE5, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:fec8:5379, pas de connexion à Internet en IPv4, connexion à Internet en IPv6 possible, pas de résolution DNS fonctionnelle
|-
| Dann RODENBURG & Amine SELLALI || Aladin
| IPv4 sur CV : 10.0.69.107, pas d'IPv4 sur SE5, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:fe6b:c000, pas de connexion à Internet en IPv4, connexion à Internet en IPv6 possible, pas de résolution DNS fonctionnelle
|-
| Mohammed Halaoui & Rémi Farault || Dingo
| IPv4 sur CV : 10.0.69.156, pas d'IPv4 sur SE5, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:fe0d:4f9c, pas de connexion à Internet en IPv4, connexion à Internet en IPv6 possible, pas de résolution DNS fonctionnelle
|-
| Benjamin Nguyen & Timothé Brenier || Timon
| IPv4 sur CV : 10.0.69.104, pas d'IPv4 sur SE5, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:fedc:7539, pas de connexion à Internet en IPv4, connexion à Internet en IPv6 possible, pas de résolution DNS fonctionnelle
|-
| Florian Vallée & Maxime BALBASTRE || mushu
| IPv4 sur CV : 10.0.69.160, pas d'IPv4 sur SE5, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:fe20:8816, pas de connexion à Internet en IPv4, connexion à Internet en IPv6 possible, pas de résolution DNS fonctionnelle
|-
| Haitam Blgrim & Black Baptiste || BlancheNeige
| IPv4 sur CV : 10.0.69.182, pas d'IPv4 sur SE5, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:feba:38f4, pas de connexion à Internet en IPv4, connexion à Internet en IPv6 possible, pas de résolution DNS fonctionnelle
|-
| Jeanne Delcourt & Estelle Godard || cruella
| IPv4 sur CV : 10.0.69.108, pas d'IPv4 sur SE5, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:fee5:ff99, pas de connexion à Internet en IPv4, connexion à Internet en IPv6 possible, pas de résolution DNS fonctionnelle
|-
| Jason DELANNOY & Albin MOUTON || Jafar
| IPv4 sur CV : 10.0.69.171, pas d'IPv4 sur SE5, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:fe3e:f0bb, pas de connexion à Internet en IPv4, connexion à Internet en IPv6 possible, pas de résolution DNS fonctionnelle
|-
| Chloé Lemaire & Gabriel THOMAS || bouh
| IPv4 sur CV : 192.168.18.1, IPv4 sur SE5 : 193.48.57.180, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:fe4f:dde2, connexion à Internet en IPv4 possible, connexion à Internet en IPv6 possible, résolution DNS fonctionnelle
|-
| Konstantin Patrikeev & Julien Charleux || judy
| IPv4 sur CV : 10.0.69.216, pas d'IPv4 sur SE5, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:fe7d:4762, pas de connexion à Internet en IPv4, connexion à Internet en IPv6 possible, pas de résolution DNS fonctionnelle
|-
| François NAUDOT ||
|-
|}

== Répartition des binômes en ASR ==

Donnez les élèves dans chaque groupe.

{| class="wikitable"
! Groupe !! Elèves
|-
| g1 || Konstantin Patrikeev & Julien Charleux
|-
| g2 || Chloé Lemaire & Gabriel Thomas
|-
| g3 || Timothé Brenier & Benjamin Nguyen
|-
| g4 || François Naudot & Dann Rodenburg
|-
| g5 || Maël Delaby & Paul Amoros
|-
| g6 || Haitam Blgrim & Baptiste Black
|-
| g7 || Jason Delannoy & Albin Mouton
|-
| g8 || Elias Simon & Mathis Riffaut
|-
| g10 || Estelle Godard & Jeanne Delcourt
|-
| g11 || Karl Habre & Amine Sellali
|-
| g12 || Mohammed Halaoui & Rémi Farault
|-
|g13
|Maxime Balbastre & Florian Vallée
|}

Le 05/11/2023, aucun commutateur virtuel correctement configuré, soit une adresse IPv4 sur le commutateur pour aucune raison, soit une configuration <code>static</code> non adaptée, pas de <code>up</code> sur le commutateur virtuel.

== Contrôle continu ==

=== Contrôle au 05/11/2023 ===

{| class="wikitable"
! Groupe !! Elèves !! Migration !! Archi. penfret !! Archi. antifer
|-
| g1 || Konstantin Patrikeev & Julien Charleux || || jcharleu, CV conf. erronée, MV interf. vlan50, pas de config. IPv4 || kpatrikee, CV conf. erronée, MV interf. vlan50, pas de config. IPv4, routeur mauvais disque dans le <code>.cfg</code>
|-
| g2 || Chloé Lemaire & Gabriel Thomas || || gthomas, CV conf. erronée, MV mdp erroné, interf. vlan50 || clemair1, CV conf. erronée, MV interf. vlan50, pas de config. IPv4, routeur lancé, une seule interface réseau, pas de config. réseau
|-
| g3 || Timothé Brenier & Benjamin Nguyen || || bnguyen1, CV conf. erronée, MV interf. vlan50, pas de config. IPv4 || tbrenier, CV conf. erronée, MV interf. vlan50, pas de config. IPv4, routeur mauvais disque dans le <code>.cfg</code>
|-
| g4 || François Naudot & Dann Rodenburg || || drodenbu, CV conf. erronée, MV interf. vlan50, pas de config. IPv4 || fnaudot, CV conf. erronée, MV interf. vlan50, pas de config. IPv4, routeur mauvais disque dans le <code>.cfg</code>
|-
| g5 || Maël Delaby & Paul Amoros || || pas de CV, pas de MV || mdelaby, CV conf. erronée, pygrub dans la MV ? pas de routeur, faut lui créer son propre <code>.cfg</code>
|-
| g6 || Haitam Blgrim & Baptiste Black || || hblgrim, CV conf. erronée, MV avec 2 interfaces, pas de MAC sur la 1ère, config. IPv4 OK || bblack, CV commenté, pas de MV (plus exactement une machine visible via <code>xen list</code> mais pas de <code>.cfg</code> dans <code>/etc/xen</code>), pas de routeur OpenWRT
|-
| g7 || Jason Delannoy & Albin Mouton || || jdelanno, CV conf. erronée, MV interf. vlan50, pas de config. IPv4 || amouton, CV conf. erronée, MV interf. vlan50, pas de config. IPv4, routeur lancé, une seule interface réseau
|-
| g8 || Elias Simon & Mathis Riffaut || || mriffaut, CV conf. erronée, MV interf. vlan50, pas de config. IPv4 || esimon, CV conf. erronée, MV interf. vlan50, pas de config. IPv4, pas de routeur
|-
| g10 || Estelle Godard & Jeanne Delcourt || || jdelcour, CV conf. erronée, MV interf. vlan50, pas de config. IPv4 || egodard, CV conf. erronée, MV interf. vlan50, pas de config. IPv4, routeur lancé, deux interfaces réseau, changez l'ordre des interfaces dans le <code>.cfg</code>
|-
| g11 || Karl Habre & Amine Sellali || || khabre, CV conf. erronée, MV non créée, MV interf. vlan50, pas de config. IPv4 || asellali, CV conf. erronée, MV interf. vlan50, pas de config. IPv4, routeur avec une définition de disque aberrante dans le <code>.cfg</code>
|-
| g12 || Mohammed Halaoui & Rémi Farault || || rfarault, CV conf. erronée, MV interf. vlan50, pas de config. IPv4 || pas de CV, MV interf. vlan50, pas de config. IPv4, pas de routeur
|}

=== Contrôle au 20/11/2023 ===

A noter qu'un sacré coup de pouce aura été nécessaire pour configurer le routeur de promotion, avec un seul élève en appui.

{| class="wikitable"
! Groupe !! Elèves !! Migration !! Archi. penfret !! Archi. antifer
|-
| g1 || Konstantin Patrikeev & Julien Charleux || || jcharleu, CV configuration toujours erronée, pas de VLAN, MV avec une seule interface (vlan50), toujours pas de configuration IPv4 correcte || kpatrikee, CV configuration toujours erronée, pas de VLAN, MV avec une seule interface réseau (dans le vlan50), pas de configuration IPv4 correcte, pour le routeur toujours une mauvaise définition de disque dans le <code>.cfg</code>
|-
| g2 || Chloé Lemaire & Gabriel Thomas || || gthomas, CV configuration toujours erronée, pas de VLAN, MV avec une seule interface (vlan50), pas de configuration IPv4 correcte || clemair1, CV configuré, VLAN configuré, MV lancée et totalement configurée en IPv4, routeur lancé et correctement configuré
|-
| g3 || Timothé Brenier & Benjamin Nguyen || || bnguyen1, CV conf. toujours erronée, pas de VLAN, MV avec une seule interface (vlan50), toujours pas de configuration IPv4 correcte || tbrenier, CV configuration toujours erronée, pas de VLAN, MV avec une seule interface réseau (dans le vlan50), pas de configuration IPv4 correcte, pour le routeur toujours une mauvaise définition de disque dans le <code>.cfg</code>, deux interfaces cependant
|-
| g4 || François Naudot & Dann Rodenburg || || drodenbu, CV conf. toujours erronée, pas de VLAN, MV avec une seule interface (vlan50), toujours pas de configuration IPv4 correcte || fnaudot, CV configuration toujours erronée, pas de VLAN, MV avec une seule interface réseau (dans le vlan50), pas de configuration IPv4 correcte, pour le routeur toujours une mauvaise définition de disque dans le <code>.cfg</code>, deux interfaces cependant
|-
| g5 || Maël Delaby & Paul Amoros || || toujours pas de CV, pas de VLAN, toujours pas de MV || mdelaby, CV configuration toujours erronée, pas de VLAN, toujours le bootloader <code>pygrub</code> dans la MV (commenté), MV avec une seule interface réseau (dans le CV), configuration DHCP OK pour l'interface (dans le CV), toujours pas de routeur : il faut lui créer son propre <code>.cfg</code>
|-
| g6 || Haitam Blgrim & Baptiste Black || || hblgrim, CV conf. toujours erronée, pas de VLAN, MV ne démarre pas à cause de l'erreur sur le CV (correction ReX sur le CV), MV avec 2 interfaces, pas de MAC sur la première interface dans le .cfg, configuration IPv4 OK dans la MV || bblack, CV configuration toujours erronée, pas de VLAN, toujours pas e <code>.cfg</code> pour la MV, un routeur OpenWRT avec la bonne définition de disque, deux interface mais sans @MAC, aucune configuration du routeur
|-
| g7 || Jason Delannoy & Albin Mouton || || jdelanno, CV conf. toujours, erronée, pas de VLAN, MV avec une seule interface (vlan50), toujours pas de configuration IPv4 correcte || amouton, CV configuration toujours erronée, pas de VLAN, MV avec une seule interface réseau (dans le vlan50), pas de configuration IPv4 correcte, routeur lancé, une seule interface réseau, pas de configuration du routeur
|-
| g8 || Elias Simon & Mathis Riffaut || || mriffaut, CV conf. toujours erronée, pas de VLAN, MV avec une seule interface (vlan50), pas de configuration IPv4 correcte || esimon, CV configuration toujours erronée, pas de VLAN, MV avec une seule interface réseau (dans le vlan50), pas de configuration IPv4 correcte, toujours pas de routeur
|-
| g10 || Estelle Godard & Jeanne Delcourt || || jdelcour, CV conf. toujours erronée, pas de VLAN, MV avec une seule interface (vlan50), pas de configuration IPv4 correcte || egodard, CV configuration toujours erronée, pas de VLAN, MV avec une seule interface réseau (dans le vlan50), pas de configuration IPv4 correcte, routeur lancé, deux interfaces réseau, pas de configuration du routeur
|-
| g11 || Karl Habre & Amine Sellali || || khabre, CV conf. toujours erronée, pas de VLAN, MV enfin créée avec une seule interface, pas de configuration IPv4 correcte || asellali, CV configuration toujours erronée, pas de VLAN, MV avec une seule interface réseau (dans le vlan50), pas de configuration IPv4 correcte, routeur avec une définition de disque aberrante dans le <code>.cfg</code>, une seule interface, pas de configuration du routeur
|-
| g12 || Mohammed Halaoui & Rémi Farault || || rfarault, CV conf. toujours erronée, pas de VLAN, MV avec une seule interface (vlan50), pas de configuration IPv4 correcte || pas de CV, MV avec une seule interface réseau (dans le vlan50), pas de configuration IPv4 correcte, toujours pas de routeur
|}

=== Contrôle au 30/11/2023 ===

{| class="wikitable"
! Groupe !! Elèves !! Archi. penfret !! Archi. antifer
|-
| g1 || Konstantin Patrikeev & Julien Charleux || jcharleu, CV configuration toujours erronée, pas de VLAN, MV avec une seule interface (vlan50), toujours pas de configuration IPv4 correcte. || kpatrikee, CV et VLAN configurés mais dites moi comment vous trouvez 1 avec la formule <code>6+N%4</code>, MV avec les bonnes interfaces, inversion dans la configuration IPv4 entre <code>enX0</code> et <code>enX1</code>, pour le routeur toujours une mauvaise définition de disque dans le <code>.cfg</code> par contre les deux interfaces demandées sont présentes.
|-
| g2 || Chloé Lemaire & Gabriel Thomas || gthomas, CV configuré, VLAN configuré, MV lancée et totalement configurée en IPv4. || clemair1, CV configuré, VLAN configuré, MV lancée et totalement configurée en IPv4, routeur lancé et correctement configuré.
|-
| g3 || Timothé Brenier & Benjamin Nguyen || bnguyen1, CV conf. toujours erronée, pas de VLAN, MV avec une seule interface (vlan50), toujours pas de configuration IPv4 correcte. || tbrenier, CV configuration toujours erronée, pas de VLAN, MV avec une seule interface réseau (dans le vlan50), pas de configuration IPv4 correcte, pour le routeur toujours une mauvaise définition de disque dans le <code>.cfg</code>, deux interfaces cependant.
|-
| g4 || François Naudot & Dann Rodenburg || drodenbu, CV conf. toujours erronée, pas de VLAN, MV avec une seule interface (vlan50), toujours pas de configuration IPv4 correcte. || fnaudot, CV configuration toujours erronée, pas de VLAN, MV avec une seule interface réseau (dans le vlan50), pas de configuration IPv4 correcte, pour le routeur toujours une mauvaise définition de disque dans le <code>.cfg</code>, deux interfaces cependant.
|-
| g5 || Maël Delaby & Paul Amoros || toujours pas de CV, pas de VLAN, toujours pas de MV. || mdelaby, CV configuration toujours erronée, pas de VLAN, toujours le bootloader <code>pygrub</code> dans la MV (commenté), MV avec un chemin des disques étranges, MV avec une seule interface réseau (dans le CV), configuration DHCP OK pour l'interface (dans le CV), toujours pas de routeur : il faut lui créer son propre <code>.cfg</code>.
|-
| g6 || Haitam Blgrim & Baptiste Black || hblgrim, il manque les directives pour démarrer et arrêter les interfaces mais sinon CV et VLAN configurés, MV lancé et configurée, il ne faut pas de <code>gateway</code> sur <code>enX1</code>, <code>enX0</code> ne trouve pas son adresse par DHCP à cause du commutateur virtuel non activé. || bblack, CV et VLAN configurés mais pas toutes les directives de démarrage et d'arrêt, toujours pas de <code>.cfg</code> pour la MV, un routeur OpenWRT avec la bonne définition de disque, deux interface mais sans @MAC, aucune configuration du routeur.
|-
| g7 || Jason Delannoy & Albin Mouton || jdelanno, CV conf. toujours, erronée, pas de VLAN, MV avec une seule interface (vlan50), toujours pas de configuration IPv4 correcte; || amouton, CV configuration toujours erronée, pas de VLAN, MV avec une seule interface réseau (dans le vlan50), pas de configuration IPv4 correcte, routeur lancé, une seule interface réseau, pas de configuration du routeur.
|-
| g8 || Elias Simon & Mathis Riffaut || mriffaut, CV conf. toujours erronée, pas de VLAN, MV avec une seule interface (vlan50), pas de configuration IPv4 correcte. || esimon, CV configuration toujours erronée, pas de VLAN, MV avec une seule interface réseau (dans le vlan50), pas de configuration IPv4 correcte, toujours pas de routeur.
|-
| g10 || Estelle Godard & Jeanne Delcourt || jdelcour, CV configuré, VLAN configuré (par contre l'utilisation de <code>ether4</code> est impossible), MV lancée et correctement configurée en IPv4, <code>enX0</code> ne trouve pas son @IPv4 à cause de l'erreur sur le VLAN. || egodard, CV configuré, VLAN configuré (par contre l'utilisation de <code>ether4</code> est impossible), MV avec deux interfaces, correctement configurée en IPv4, pas d'adresse obtenue par DHCP, problème de l'OpenWRT, routeur OpenWRT avec les bonnes interfaces, l'adresse IPv4 sur SE5 est donnée avec un mauvais masque, linterface <code>enX0</code> reçoit bien son adresse IPv4 par DHCP.
|-
| g11 || Karl Habre & Amine Sellali || khabre, CV configuration toujours erronée, pas de VLAN, MV avec une seule interface, pas de configuration IPv4 correcte || asellali, CV configuration toujours erronée, pas de VLAN, MV avec une seule interface réseau (dans le vlan50), pas de configuration IPv4 correcte, routeur avec une définition de disque aberrante dans le <code>.cfg</code>, une seule interface, pas de configuration du routeur
|-
| g12 || Mohammed Halaoui & Rémi Farault || rfarault, CV configuré, VLAN configuré mais configuration commentée (pourquoi donc ?!), MV lancée et correctement configurée en IPv4, <code>enX0</code> ne trouve pas son @IPv4 à cause de l'absence d'interface VLAN. || CV configuré, VLAN configuré, MV avec deux interfaces, correctement configurée en IPv4, un routeur avec les deux interfaces demandées, pas d'adresse IPv4 sur SE5, serveur DHCP fonctionnel.
|}

=== Contrôle au 02/12/2023 ===

{| class="wikitable"
! Groupe !! Elèves !! MV <code>penfret</code> !! MV <code>antifer</code> !! Routeur OpenWRT
|-
| g1 || Konstantin Patrikeev & Julien Charleux
| IPv4 sur CV : 10.0.69.185, IPv4 sur VLAN50 : 172.126.145.103, IPv6 sur VLAN50 : 2001:660:4401:6050:216:3eff:fe00:a98d, pas de connexion à Internet en IPv4, pas de résolution DNS fonctionnelle
| IPv4 sur CV : 10.0.69.218, IPv4 sur VLAN50 : 172.26.145.102, IPv6 sur VLAN50 : 2001:660:4401:6050:216:3eff:fe7d:bc44, pas de connexion à Internet en IPv4, pas de résolution DNS fonctionnelle
| pas d'IPv4 routée sur Internet, une IPv6 routée sur Internet, pas de connexion à Internet en IPv4
|-
| g2 || Chloé Lemaire & Gabriel Thomas
| IPv4 sur CV : 10.0.69.212, IPv4 sur VLAN50 : 172.26.145.105, IPv6 sur VLAN50 : 2001:660:4401:6050:216:3eff:fedb:2ac4, connexion à Internet en IPv4 possible, pas de résolution DNS fonctionnelle
| IPv4 sur CV : 10.0.69.145, IPv4 sur VLAN50 : 172.26.145.104, IPv6 sur VLAN50 : 2001:660:4401:6050:216:3eff:fe31:b916, connexion à Internet en IPv4 possible, resolution DNS fonctionnelle
| IPv4 sur Internet : 193.48.57.180, une IPv6 routée sur Internet, connexion à Internet en IPv4 possible
|-
| g3 || Timothé Brenier & Benjamin Nguyen
| MV non contactable sur le VLAN 50 en IPv6
| pas d'IPv4 sur le CV, IPv4 sur VLAN50 : 172.26.145.106, IPv6 sur VLAN50 : 2001:660:4401:6050:216:3eff:feaa:f292, pas de connexion à Internet en IPv4, pas de résolution DNS fonctionnelle
| routeur openWRT non fonctionnel
|-
| g4 || François Naudot & Dann Rodenburg
| MV non contactable sur le VLAN 50 en IPv6
| pas d'IPv4 sur le CV, IPv4 sur VLAN50 : 172.26.145.108, IPv6 sur VLAN50 : 2001:660:4401:6050:216:3eff:fec6:168, pas de connexion à Internet en IPv4, pas de résolution DNS fonctionnelle
| routeur openWRT non fonctionnel (si ? non, inversion des <code>vif</code>)
|-
| g5 || Maël Delaby & Paul Amoros
| MV non contactable sur le VLAN 50 en IPv6
| image disque du fichier de configuration non présente sur <code>antifer</code>
| routeur openWRT non fonctionnel
|-
| g6 || Haitam Blgrim & Baptiste Black
| MV non contactable sur le VLAN 50 en IPv6
| pas de fichier de configuration
| routeur openWRT non fonctionnel
|-
| g7 || Jason Delannoy & Albin Mouton
| MV non contactable sur le VLAN 50 en IPv6
| machine non contactable en IPv6 sur le bridgeStudents
| pas d'adresse MAC dans le fichier de configuration
|-
| g8 || Elias Simon & Mathis Riffaut
| MV non contactable sur le VLAN 50 en IPv6
| pas d'IPv4 sur le CV, IPv4 sur VLAN50 : 172.26.145.116, IPv6 sur VLAN50 : 2001:660:4401:6050:216:3eff:fe01:754c, pas de connexion à Internet en IPv4, pas de résolution DNS fonctionnelle
| routeur openWRT non fonctionnel
|-
| g10 || Estelle Godard & Jeanne Delcourt
| IPv4 sur CV : 10.0.69.165, IPv4 sur VLAN50 : 172.26.145.121, IPv6 sur VLAN50 : 2001:660:4401:6050:216:3eff:fe7e:35e1, pas de connexion à Internet en IPv4, pas de résolution DNS fonctionnelle
| IPv4 sur CV : 10.0.69.132, IPv4 sur VLAN50 : 172.26.145.120, IPv6 sur VLAN50 : 2001:660:4401:6050:216:3eff:feb4:5ea3, pas de connexion à Internet en IPv4, pas de résolution DNS fonctionnelle
| IPv4 sur Internet : 193.48.57.191, une IPv6 routée sur Internet, pas de connexion à Internet en IPv4
|-
| g11 || Karl Habre & Amine Sellali
| MV non contactable sur le VLAN 50 en IPv6
| machine non contactable en IPv6 sur le bridgeStudents
| pas d'adresse MAC dans le fichier de configuration, création du routeur impossible
|-
| g12 || Mohammed Halaoui & Rémi Farault
| pas d'IPv4 sur le CV, IPv4 sur VLAN50 : 172.26.145.125, IPv6 sur VLAN50 : 2001:660:4401:6050:216:3eff:fe54:5aee, pas de connexion à Internet en IPv4, pas de résolution DNS fonctionnelle
| pas d'IPv4 sur le CV, IPv4 sur VLAN50 : 172.26.145.124, IPv6 sur VLAN50 : 2001:660:4401:6050:216:3eff:fe9a:5186, pas de connexion à Internet en IPv4, pas de résolution DNS fonctionnelle
| pas d'IPv4 routée sur Internet, pas d'IPv6 routée sur Internet, pas de connexion à Internet en IPv4
|-
|}

=== Contrôle au 05/12/2023 ===

Pour utiliser l'interface Web LuCi des openWRT à partir d'une zabeth :
* vérifiez que vous avez bien une IPv6 routée sur IPv6 (avec <code>ip address show dev eth0</code>, l'adresse commence par <code>2001:660:4401:60b0:</code>) ;
* si vous n'en avez pas, prenez le suffixe (les derniers 8 octets de l'adresse locale, celle qui commence par <code>fe80::</code>) et créez votre adresse IPv6 routée par la commande :
ip address add dev eth0 2001:660:4401:60b0:<suffixe>/64
bien entendu vous n'aurez oublié de rajouter la route IPv6 par défaut vers le routeur de la promotion :
ip -6 route add default via 2001:660:4401:60b0:6a9e:bff:fe46:5a76
* établissez un tunnel <code>ssh</code> avec la commande :
zabethXX# ssh -L 6443:localhost:6443 root@IPv6
* connectez vous sur LuCi avec le navigateur de la zabeth pointant sur <code>https://localhost:6443</code>.

Attention l'ordre des interfaces <code>vif</code> dans le <code>.cfg</code> a une importance.

{| class="wikitable"
! Groupe !! Elèves !! MV <code>penfret</code> !! MV <code>antifer</code> !! Routeur OpenWRT
|-
| g1 || Konstantin Patrikeev & Julien Charleux
| IPv4 sur CV : 10.0.69.185, IPv4 sur VLAN50 : 172.126.145.103, IPv6 sur VLAN50 : 2001:660:4401:6050:216:3eff:fe00:a98d, pas de connexion à Internet en IPv4, pas de résolution DNS fonctionnelle
| IPv4 sur CV : 10.0.69.218, IPv4 sur VLAN50 : 172.26.145.102, IPv6 sur VLAN50 : 2001:660:4401:6050:216:3eff:fe7d:bc44, pas de connexion à Internet en IPv4, pas de résolution DNS fonctionnelle
| pas d'IPv4 routée sur Internet (puis <code>193.48.57.191</code> donc une erreur), pas d'IPv6 routée sur Internet, pas de connexion à Internet en IPv4
|-
| g2 || Chloé Lemaire & Gabriel Thomas
| IPv4 sur CV : 10.0.69.212, IPv4 sur VLAN50 : 172.26.145.105, IPv6 sur VLAN50 : 2001:660:4401:6050:216:3eff:fedb:2ac4, connexion à Internet en IPv4 possible, pas de résolution DNS fonctionnelle
| IPv4 sur CV : 10.0.69.145, IPv4 sur VLAN50 : 172.26.145.104, IPv6 sur VLAN50 : 2001:660:4401:6050:216:3eff:fe31:b916, connexion à Internet en IPv4 possible, resolution DNS fonctionnelle
| IPv4 sur Internet : 193.48.57.180, IPv6 sur Internet : 2001:660:4401:60b0:216:3eff:fe31:b916, connexion à Internet en IPv4 possible
|-
| g3 || Timothé Brenier & Benjamin Nguyen
| IPv4 sur CV : 10.0.69.130, IPv4 sur VLAN50 : 172.26.145.107, IPv6 sur VLAN50 : 2001:660:4401:6050:216:3eff:feff:4c44, connexion à Internet en IPv4 possible, résolution DNS fonctionnelle
| IPv4 sur CV : 10.0.69.167, IPv4 sur VLAN50 : 172.26.145.106, IPv6 sur VLAN50 : 2001:660:4401:6050:216:3eff:feaa:f292, connexion à Internet en IPv4 possible, pas de résolution DNS fonctionnelle
| IPv4 sur Internet : 193.48.57.184, IPv6 sur Internet : 2001:660:4401:60b0:216:3eff:feaa:f293, connexion à Internet en IPv4 possible
|-
| g4 || François Naudot & Dann Rodenburg
| IPv4 sur CV : 10.0.69.156, IPv4 sur VLAN50 : 172.26.145.109, IPv6 sur VLAN50 : 2001:660:4401:6050:216:3eff:fe46:70cd, connexion à Internet en IPv4 possible, pas de résolution DNS fonctionnelle
| IPv4 sur CV : 10.0.69.106, IPv4 sur VLAN50 : 172.26.145.108, IPv6 sur VLAN50 : 2001:660:4401:6050:216:3eff:fec6:168, connexion à Internet en IPv4 possible, pas de résolution DNS fonctionnelle
| IPv4 sur Internet : 193.48.57.185, IPv6 sur Internet : 2001:660:4401:60b0:216:3eff:fec6:169, connexion à Internet en IPv4 possible
|-
| g5 || Maël Delaby & Paul Amoros
| IPv4 sur CV : 10.0.69.189, IPv4 sur VLAN50 : 172.26.145.111, IPv6 sur VLAN50 : 2001:660:4401:6050:216:3eff:fe14:cdb5, connexion à Internet en IPv4 possible, pas de résolution DNS fonctionnelle
| IPv4 sur CV : 10.0.69.171, IPv4 sur VLAN50 : 172.26.145.110, IPv6 sur VLAN50 : 2001:660:4401:6050:216:3eff:fe5b:b2b5, connexion à Internet en IPv4 possible, resolution DNS fonctionnelle
| IPv4 sur Internet : 193.48.57.188, IPv6 sur Internet : 2001:660:4401:60b0:216:3eff:fe5b:b2b6, connexion à Internet en IPv4 possible
|-
| g6 || Haitam Blgrim & Baptiste Black
| IPv4 sur CV : 10.0.69.100, IPv4 sur VLAN50 : 172.26.145.113, IPv6 sur VLAN50 : 2001:660:4401:6050:216:3eff:fef9:2bb9, pas de connexion à Internet en IPv4, pas de résolution DNS fonctionnelle
| pas de machine virtuelle
| bloquage du serveur <code>antifer</code> par installation du routeur openWRT sous la racine, machine non contactable en IPv6 sur le SE5
|-
| g7 || Jason Delannoy & Albin Mouton
| CV non configuré, machine non contactable en IPv6 sur le VLAN50
| machine non contactable en IPv6 sur le bridgeStudent
| pas d'adresse MAC dans le <code>.cfg</code>
|-
| g8 || Elias Simon & Mathis Riffaut
| CV non configuré, machine non contactable en IPv6 sur le VLAN50
| machine non contactable en IPv6 sur le bridgeStudents
| machine non contactable en IPv6 sur le SE5
|-
| g10 || Estelle Godard & Jeanne Delcourt
| IPv4 sur CV : 10.0.69.165, IPv4 sur VLAN50 : 172.26.145.121, IPv6 sur VLAN50 : 2001:660:4401:6050:216:3eff:fe7e:35e1, pas de connexion à Internet en IPv4, pas de résolution DNS fonctionnelle
| IPv4 sur CV : 10.0.69.132, IPv4 sur VLAN50 : 172.26.145.120, IPv6 sur VLAN50 : 2001:660:4401:6050:216:3eff:feb4:5ea3, pas de connexion à Internet en IPv4, pas de résolution DNS fonctionnelle
| IPv4 sur Internet : 193.48.57.191 (erreur !!), IPv6 sur Internet : 2001:660:4401:60b0:216:3eff:feb4:5ea4, pas de connexion à Internet en IPv4
|-
| g11 || Karl Habre & Amine Sellali
| machine non contactable en IPv6 sur le VLAN50
| machine non contactable en IPv6 sur le bridgeStudents
| pas d'adresse MAC dans le <code>.cfg</code>
|-
| g12 || Mohammed Halaoui & Rémi Farault
| IPv4 sur CV : 10.0.69.131, IPv4 sur VLAN50 : 172.26.145.125, IPv6 sur VLAN50 : 2001:660:4401:6050:216:3eff:fe54:5aee, pas de connexion à Internet en IPv4, pas de résolution DNS fonctionnelle
| pas d'IPv4 sur le CV, IPv4 sur VLAN50 : 172.26.145.124, IPv6 sur VLAN50 : 2001:660:4401:6050:216:3eff:fe9a:5186, pas de connexion à Internet en IPv4, pas de résolution DNS fonctionnelle
| IPv4 sur Internet : 193.48.57.181, IPv6 sur Internet : 2001:660:4401:60b0:216:3eff:fe9a:5186, pas de connexion à Internet en IPv4
|-
|}

Pas de changement sur les routeurs OpenWRT à 17h30.

Pas de changement sur les MV d'<code>antifer</code> à 18h00.

Une seule modification sur les MV de <code>penfret</code> à 18h15 : la G7 (<code>g7jdelannoVM</code>) est maintenant contactable (@IPv4 et @IPv6 sur le VLAN50) mais sans rien de plus.

=== Contrôle au 06/12/2023 ===

Données brutes pour les routeurs openWRT (pas de relancement) :

G1 | IPv4 sur Internet : 193.48.57.191, IPv6 sur Internet : 2001:660:4401:60b0:216:3eff:fe7d:bc44, pas de connexion à Internet en IPv4
G2 | IPv4 sur Internet : 193.48.57.180, IPv6 sur Internet : 2001:660:4401:60b0:216:3eff:fe31:b916, connexion à Internet en IPv4 possible
G3 | IPv4 sur Internet : 193.48.57.184, IPv6 sur Internet : 2001:660:4401:60b0:216:3eff:feaa:f293, connexion à Internet en IPv4 possible
G4 | IPv4 sur Internet : 193.48.57.185, IPv6 sur Internet : 2001:660:4401:60b0:216:3eff:fec6:169, connexion à Internet en IPv4 possible
G5 | IPv4 sur Internet : 193.48.57.188, IPv6 sur Internet : 2001:660:4401:60b0:216:3eff:fe5b:b2b6, connexion à Internet en IPv4 possible
G6 | IPv4 sur Internet : 193.48.57.187, IPv6 sur Internet : 2001:660:4401:60b0:216:3eff:fef9:2bba, connexion à Internet en IPv4 possible
G7 | Bad MAC address
G8 | machine non contactable en IPv6 sur le SE5
G9 | Rien
G10 | IPv4 sur Internet : 193.48.57.186, IPv6 sur Internet : 2001:660:4401:60b0:216:3eff:feb4:5ea4, pas de connexion à Internet en IPv4
G11 | machine non contactable en IPv6 sur le SE5
G12 | IPv4 sur Internet : 193.48.57.181, IPv6 sur Internet : 2001:660:4401:60b0:216:3eff:fe9a:5186, pas de connexion à Internet en IPv4

Données brutes pour les MV sur <code>antifer</code> :

==== g1kpatrikeevVM
| IPv4 sur CV : 10.0.69.218, IPv4 sur VLAN50 : 172.26.145.102, IPv6 sur VLAN50 : 2001:660:4401:6050:216:3eff:fe7d:bc44, pas de connexion à Internet en IPv4, pas de résolution DNS fonctionnelle
==== g2clemair1VM
| IPv4 sur CV : 10.0.69.145, IPv4 sur VLAN50 : 172.26.145.104, IPv6 sur VLAN50 : 2001:660:4401:6050:216:3eff:fe31:b916, connexion à Internet en IPv4 possible, resolution DNS fonctionnelle
==== g3tbrenierVM
| IPv4 sur CV : 10.0.69.167, IPv4 sur VLAN50 : 172.26.145.106, IPv6 sur VLAN50 : 2001:660:4401:6050:216:3eff:feaa:f292, connexion à Internet en IPv4 possible, pas de résolution DNS fonctionnelle
==== g4fnaudotVM
| IPv4 sur CV : 10.0.69.106, IPv4 sur VLAN50 : 172.26.145.108, IPv6 sur VLAN50 : 2001:660:4401:6050:216:3eff:fec6:168, connexion à Internet en IPv4 possible, pas de résolution DNS fonctionnelle
==== g5mdelabyVM
| IPv4 sur CV : 10.0.69.171, IPv4 sur VLAN50 : 172.26.145.110, IPv6 sur VLAN50 : 2001:660:4401:6050:216:3eff:fe5b:b2b5, connexion à Internet en IPv4 possible, resolution DNS fonctionnelle
==== g6bblackVM
| IPv4 sur CV : 10.0.69.113, IPv4 sur VLAN50 : 172.26.145.112, IPv6 sur VLAN50 : 2001:660:4401:6050:216:3eff:fe4a:d2be, connexion à Internet en IPv4 possible, resolution DNS fonctionnelle
==== g7amoutonVM
| pas d'IPv4 sur le CV, IPv4 sur VLAN50 : 172.26.145.114, IPv6 sur VLAN50 : 2001:660:4401:6050:216:3eff:fe59:7616, pas de connexion à Internet en IPv4, pas de résolution DNS fonctionnelle
==== g8esimonVM
| machine non contactable en IPv6 sur le bridgeStudents
==== g10egodardVM
| IPv4 sur CV : 10.0.69.132, IPv4 sur VLAN50 : 172.26.145.120, IPv6 sur VLAN50 : 2001:660:4401:6050:216:3eff:feb4:5ea3, pas de connexion à Internet en IPv4, pas de résolution DNS fonctionnelle
==== g11asellaliVM
| machine non contactable en IPv6 sur le bridgeStudents
==== g12mhalaouiVM
| pas d'IPv4 sur le CV, IPv4 sur VLAN50 : 172.26.145.124, IPv6 sur VLAN50 : 2001:660:4401:6050:216:3eff:fe9a:5186, pas de connexion à Internet en IPv4, pas de résolution DNS fonctionnelle

Données brutes pour les MV sur <code>penfret</code> :

==== g1jcharleuxVM
| IPv4 sur CV : 10.0.69.185, IPv4 sur VLAN50 : 172.126.145.103, IPv6 sur VLAN50 : 2001:660:4401:6050:216:3eff:fe00:a98d, pas de connexion à Internet en IPv4, pas de résolution DNS fonctionnelle
==== g2gthomasVM
| IPv4 sur CV : 10.0.69.212, IPv4 sur VLAN50 : 172.26.145.105, IPv6 sur VLAN50 : 2001:660:4401:6050:216:3eff:fedb:2ac4, connexion à Internet en IPv4 possible, pas de résolution DNS fonctionnelle
==== g3bnguyen1VM
| IPv4 sur CV : 10.0.69.130, IPv4 sur VLAN50 : 172.26.145.107, IPv6 sur VLAN50 : 2001:660:4401:6050:216:3eff:feff:4c44, connexion à Internet en IPv4 possible, résolution DNS fonctionnelle
==== g4drodenbuVM
| IPv4 sur CV : 10.0.69.156, IPv4 sur VLAN50 : 172.26.145.109, IPv6 sur VLAN50 : 2001:660:4401:6050:216:3eff:fe46:70cd, connexion à Internet en IPv4 possible, pas de résolution DNS fonctionnelle
==== g5pamorosVM
| IPv4 sur CV : 10.0.69.189, IPv4 sur VLAN50 : 172.26.145.111, IPv6 sur VLAN50 : 2001:660:4401:6050:216:3eff:fe14:cdb5, connexion à Internet en IPv4 possible, pas de résolution DNS fonctionnelle
==== g6hblgrimVM
| IPv4 sur CV : 10.0.69.100, IPv4 sur VLAN50 : 172.26.145.113, IPv6 sur VLAN50 : 2001:660:4401:6050:216:3eff:fef9:2bb9, connexion à Internet en IPv4 possible, résolution DNS fonctionnelle
==== g7jdelannoVM
| pas d'IPv4 sur le CV, IPv4 sur VLAN50 : 172.26.145.115, IPv6 sur VLAN50 : 2001:660:4401:6050:216:3eff:fe0f:aba1, pas de connexion à Internet en IPv4, pas de résolution DNS fonctionnelle
==== g8mriffautVM
| machine non contactable en IPv6 sur le VLAN50
==== g10jdelcourVM
| IPv4 sur CV : 10.0.69.165, IPv4 sur VLAN50 : 172.26.145.121, IPv6 sur VLAN50 : 2001:660:4401:6050:216:3eff:fe7e:35e1, pas de connexion à Internet en IPv4, pas de résolution DNS fonctionnelle
==== g11khabreVM
| machine non contactable en IPv6 sur le VLAN50
==== g12rfaraultVM
| IPv4 sur CV : 10.0.69.131, IPv4 sur VLAN50 : 172.26.145.125, IPv6 sur VLAN50 : 2001:660:4401:6050:216:3eff:fe54:5aee, pas de connexion à Internet en IPv4, pas de résolution DNS fonctionnelle

SE5 système/réseau 2023/2024

2023-10-16T12:44:49Z

Asellali : /* Répartition des binômes en ASR */

SE5 système/réseau 2023/2024

2023-10-06T15:10:30Z

Asellali : /* Répartition des binômes */

SE5 système/réseau 2023/2024

2023-10-06T14:16:27Z

Asellali : /* Menu de la première séance */

SE4 2022/2023 EC1

2023-09-06T03:21:41Z

Asellali : /* Fonction TYPE version 3 */

= Objectifs =

Il vous est demandé de :
* réaliser un micro système de fichiers ;
* le système de fichiers doit résider dans un fichier de 8 Mo ;
* le système de fichiers est géré par un exécutable obtenu à partir d'un programme C ;
* L'éxécutable prend deux arguments, le premier est le chemin du fichier dans lequel réside le système de fichiers, les paramètres suivants concernent l'action à appliquer sur le système de fichiers ;
* le micro système de fichier ne comporte qu'un répertoire : le répertoire principal, le répertoire principal peut comporter au maximum 64 fichiers, un fichier est caractérisé par un nom de 16 caractères au maximum et ses blocs de données, un fichier peut comporter au maximum 2040 blocs de données ;
* un bloc de données fait 256 octets et les blocs sont numérotés sur 2 octets ;
* les différentes actions possibles sur le système de fichiers sont :
** <code>TYPE</code> pour créer un fichier si possible, le nom du fichier suit la commande, le contenu du fichier est donné en entrée standard de l'exécutable ;
** <code>CAT</code> pour afficher un fichier, le nom du fichier suit la commande ;
** <code>RM</code> pour détruire un fichier, le nom du fichier suit la commande ;
** <code>MV</code> pour renommer un fichier, les noms original et nouveau du fichier suivent la commande ;
** <code>CP</code> pour copier un fichier, les noms de l'original et de la copie du fichier suivent la commande ;

= Matériel nécessaire =

Un PC sous Linux.

= Travail réalisé =

== Semaine 1 ==

ReX : attention, ce micro-système de fichiers est prévu pour un microcontrôleur, vos variables globales ne peuvent pas dépasser quelques centaines d'octets.

ReX : pour la création du système de fichiers la commande <code>dd</code> suffit, vous voulez dire le formatage du système de fichiers ?

* création du programme programme.c contenant les différentes structures et les différentes fonctions.
* Piste d'amélioration: faire en sorte que la fonction CAT affiche le contenu exact des fichiers passés en argument.

Le code fourni est un programme en langage C qui simule un système de fichiers basique. Ce programme permet aux utilisateurs d'effectuer diverses actions telles que créer, afficher, supprimer, renommer et copier des fichiers dans un système de fichiers simulé. Le système de fichiers est stocké dans un fichier binaire.

ReX : vous n'avez pas tenu compte de la première remarque, vous chargez tout le superbloc et le répertoire racine, votre code ne convient pas.

ReX : vos structures utilisent des types entiers dont la taille n'est pas explicitée, utilisez les types de <code>stdint.h</code>.

ReX : la création de fichier n'est pas fonctionnelle, vous ne cherchez pas les blocs libres, vous ne copiez pas le contenu du fichier dans les blocs, même remarque pour toutes les autres fonctions.

ReX : il manque les fonctions d'accès aux pages du système de fichiers.

'''Explication du programme programme.c'''

Voici une brève explication des principaux éléments et fonctions du code :

# Structures :
#* Fichier : Représente un fichier dans le système de fichiers. Il contient un nom (nom) avec une longueur maximale de 16 caractères, un tableau de numéros de bloc (blocs) où le contenu du fichier est stocké (jusqu'à 2040 blocs), et le nombre de blocs utilisés par le fichier (nbBlocs).
#* Repertoire : Représente le répertoire principal du système de fichiers. Il contient un tableau de fichiers (<code>fichiers</code>) et le nombre de fichiers dans le répertoire (<code>nbFichiers</code>).
# Fonctions :
#* <code>chargerSystemeFichiers</code> : Charge le système de fichiers à partir d'un fichier binaire donné (chemin) dans une structure Repertoire.
#* <code>sauvegarderSystemeFichiers</code> : Sauvegarde le système de fichiers stocké dans la structure Repertoire dans un fichier binaire (chemin).
#* <code>creerFichier</code> : Crée un nouveau fichier dans le système de fichiers avec un nom et un contenu donnés. Le contenu du fichier est simulé en le divisant en blocs.
#* <code>afficherFichier</code> : Affiche le contenu d'un fichier avec le nom spécifié.
#* <code>detruireFichier</code> : Supprime un fichier avec le nom spécifié du système de fichiers.
#* <code>renommerFichier</code> : Renomme un fichier avec l'ancien nom spécifié en un nouveau nom.
#* <code>copierFichier</code> : Copie un fichier avec le nom spécifié en créant un nouveau fichier avec le nom de copie spécifié.
# Fonction <code>main</code> :
#* La fonction <code>main</code> est le point d'entrée du programme.
#* Elle prend des arguments en ligne de commande : <code><chemin_systeme_fichiers></code> et <code><action></code>.
#* <code><chemin_systeme_fichiers></code> est le chemin vers le fichier binaire où le système de fichiers est stocké.
#* <code><action></code> détermine quelle opération effectuer, comme <code>TYPE</code>, <code>CAT</code>, <code>RM</code>, <code>MV</code> ou <code>CP</code>.
#* En fonction de l'action spécifiée, le programme appelle la fonction correspondante pour effectuer l'opération souhaitée sur le système de fichiers.
Remarque : Le code fourni une simulation basique d'un système de fichiers et de ses opérations, mais il n'interagit pas réellement avec un système de fichiers réel sur le disque.

'''Comment utiliser le programme programme.c'''

étape 1: création du système de fichiers respectant le cahier des charges:

dd if=/dev/zero of=systeme_fichiers.bin bs=1M count=8

étape 2: compilation du programme C:

gcc programme.c -o gestionnaire_fs

étape 3: création d'un fichier dans le système de fichier:

./gestionnaire_fs systeme_fichiers.bin TYPE fichier1.txt

-> entrer le texte en entrée standard

étape 4: manipulation des différentes fonctions. Exemples:

./gestionnaire_fs systeme_fichiers.bin CAT fichier1.txt
./gestionnaire_fs systeme_fichiers.bin CP fichier1.txt copie.txt
./gestionnaire_fs systeme_fichiers.bin RM copie.txt
./gestionnaire_fs systeme_fichiers.bin MV fichier1.txt fichier2.txt

== Semaine 2 ==

Amine: Merci pour vos remarques. Désolé de ne pas avoir suivi votre première remarque, je pensais avoir compris ce qu'il fallait faire mais je me rend compte que non. Je vais tout reprendre depuis le début afin de repartir sur de bonnes bases.

'''Création du système de fichier avec la commande "dd"'''

A quoi sert la commande dd?

La commande <code>dd</code> permet de copier tout ou partie d'un disque par blocs d'octets, indépendamment de la structure du contenu du disque en fichiers et en répertoires (source : [https://doc.ubuntu-fr.org/dd]).

Structure de la commande

dd if=<nowiki><source> of=<cible> bs=<taille des blocs></nowiki>

<code>source</code> = données à copier

<code>cible</code> = endroit où les copier

<code>if</code> = input file

<code>of</code> = output file

<code>bs</code> = block size, habituellement une puissance de 2 supérieure ou égale à 512, représentant un nombre d'octets

Choix de la commande:

Pour la source, on prends <code>/dev/zero</code>: cela permet de créer un fichier rempli de 0. Ce fichier servira de base pour notre système de fichiers.

Pour la cible, on va l'appeler <code>filesystem.bin</Code> : ce sera notre système de fichier.

Pour la taille des blocs, on veut des blocs de données de 256 octets d'après l'enoncé. On va donc prendre <code>bs=256</code>.

Enfin, on veut que le système de fichier réside dans un fichier de 8 Mo. On va donc ajouter <code>count=31250</code>: cela indique que nous voulons écrire 32768 blocs de données dans le fichier (31250 * 256 octets = 8 Mo).

Résultat:

dd if=/dev/zero of=filesystem.bin bs=256 count=31250

Question pour M. Redon : j'ai ici essayé de respecter votre remarque "pour la création du système de fichiers la commande <code>dd</code> suffit". Cependant, pour votre seconde remarque "vous chargez tout le superbloc et le répertoire racine, votre code ne convient pas.", je ne suis pas sûr de comprendre où je fais cela: est-ce lors de la commande dd ou est-ce par la suite avec mon programme C? J'ai un peu modifié la commande dd comme vous pouvez le voir ci-dessus. Ai-je corrigé mon erreur avec cette nouvelle commande? J'ai essayé de justifier au maximum la commande dd que j'ai choisie.

ReX : Pas de problème avec la commande <code>dd</code> (mettez tous les extraits de code entre des balises <code>code</code>). Le problème est au niveau du programme C.

Amine: Ok je comprends mieux merci. Je vais donc reprendre le code étape par étape afin de mieux répondre au cahier des charges.

Gestion du système de fichier par un programme C

'''Création des structures'''
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>

// Structure pour représenter un bloc de données

struct DataBlock {
uint8_t data[256]; // 256 octets pour chaque bloc de données
};

// Structure pour représenter un fichier

struct File {
char filename[17]; // 16 caractères pour le nom du fichier + 1 caractère null-terminator
struct DataBlock data_blocks[2040]; // Tableau de blocs de données pour stocker le contenu du fichier
uint16_t num_data_blocks; // Nombre de blocs de données utilisés par le fichier
};

// Structure pour représenter un répertoire

struct Directory {
struct File files[64]; // Tableau de fichiers pour le répertoire principal
uint8_t num_files; // Nombre de fichiers dans le répertoire principal
};

Modification faite : suite à votre remarque, j'ai explicité la taille des entiers grâce aux types de <code>stdint.h.</code> (j'ai également mis les variables en anglais)

ReX : Vous ne pouvez pas utiliser ces structures, une instanciation d'une de ces structure prend trop d'espace mémoire, vous devez faire sans structure. Par ailleurs la façon dont vous représentez vos fichiers ne convient pas, la description d'un fichier contient des numéros de blocs, pas les blocs eux-même. Faites aussi attention qu'un fichier soit décrit par un nombre entier de blocs.

Question pratique: je n'arrive pas à mettre tout le code dans le même bloc comme vous l'avez fait ci-dessus dans l'étape 4 de la semaine 1. Je vois que c'est en format "préformaté" mais j'obtiens des blocs séparés lorsque j'applique ce format à mon code.

ReX : j'ai corrigé, pour un code entier la syntaxe n'est pas la même (un espace en début de chaque ligne), la balise c'est uniquement pour de très courts extraits de code.

=== Fonction <code>readBlock</code>===
Cette fonction est utilisée pour lire un bloc de données à partir du fichier <code>filesystem.bin</code> et le stocker dans un tableau de caractères (<code>storage</code>).

Fonction:

#define BLOCK_SIZE 256
// Fonction pour lire un bloc de données
void readBlock(unsigned int num, int offset, unsigned char *storage, int size) {
FILE *file = fopen("filesystem.bin", "rb");
if (file == NULL) {
perror("Erreur lors de l'ouverture du fichier");
return;
}
fseek(file, num * BLOCK_SIZE + offset, SEEK_SET);
fread(storage, 1, size, file);
fclose(file);
}

Paramètres :

* <code>num</code> : Numéro du bloc à lire. Chaque bloc contient 256 octets (1 bloc = 256 octets).
* <code>offset</code> : Décalage (en octets) à partir du début du bloc pour commencer la lecture.
* <code>storage</code> : Pointeur vers un tableau de caractères où les données lues seront stockées.
* <code>size</code> : Taille du tableau de caractères <code>storage</code>.

Fonctionnement :

* La fonction commence par ouvrir le fichier <code>filesystem.bin</code> en mode lecture binaire (<code>"rb"</code>).
* Elle utilise <code>fseek</code> pour positionner le curseur de lecture dans le fichier à l'endroit approprié pour commencer la lecture du bloc spécifié (<code>num</code>) à partir de l'offset (<code>offset</code>).
* Elle utilise ensuite <code>fread</code> pour lire <code>size</code> octets à partir du fichier et les stocker dans le tableau <code>storage</code>.
* Enfin, elle ferme le fichier avec <code>fclose</code>.

Note : Le paramètre <code>offset</code> est utilisé pour spécifier à partir de quel octet du bloc on souhaite commencer la lecture. Si <code>offset</code> est égal à 0, la lecture commencera depuis le début du bloc. Si <code>offset</code> est différent de 0, la lecture commencera à l'octet spécifié.

Remarque: dans votre mail, vous définissez "readBlock(unsigned int num,int offset,unsigned storage,int size)": storage n'est alors pas un pointeur vers un tableau de caractère. Je me suis donc permis de faire la modification.

ReX : OK pour la fonction, pas la peine d'en mettre autant dans le Wiki pour une fonction aussi simple.

=== Fonction <code>writeBlock</code> ===
Cette fonction est utilisée pour écrire un bloc de données dans le fichier <code>filesystem.bin</code> à partir d'un tableau de caractères (<code>storage</code>).

Fonction:

// Fonction pour écrire un bloc de données
void writeBlock(unsigned int num, int offset, const unsigned char *storage, int size) {
FILE *file = fopen("filesystem.bin", "rb+");
if (file == NULL) {
perror("Erreur lors de l'ouverture du fichier");
return;
}
fseek(file, num * BLOCK_SIZE + offset, SEEK_SET);
fwrite(storage, 1, size, file);
fclose(file);
}

Paramètres :

* <code>num</code> : Numéro du bloc où écrire.
* <code>offset</code> : Décalage (en octets) à partir du début du bloc pour commencer l'écriture.
* <code>storage</code> : Pointeur vers un tableau de caractères contenant les données à écrire dans le fichier.
* <code>size</code> : Taille du tableau de caractères <code>storage</code>.

Fonctionnement :

* La fonction commence par ouvrir le fichier <code>filesystem.bin</code> en mode lecture et écriture binaire (<code>"rb+"</code>).
* Elle utilise <code>fseek</code> pour positionner le curseur de lecture/écriture dans le fichier à l'endroit approprié pour commencer l'écriture du bloc spécifié (<code>num</code>) à partir de l'offset (<code>offset</code>).
* Elle utilise ensuite <code>fwrite</code> pour écrire <code>size</code> octets à partir du tableau <code>storage</code> dans le fichier.
* Enfin, elle ferme le fichier avec <code>fclose</code>.

ReX : Même remarque que pour la fonction précédente.

'''Etape 4: test des fonctions <code>readBlock</code> et <code>writeBlock</code> dans le main'''
// Exemple de fonction principale pour tester les opérations de lecture et d'écriture
int main() {
unsigned char data[BLOCK_SIZE];
// Test de la fonction readBlock
readBlock(0, 0, data, BLOCK_SIZE);
printf("Block 0, offset 0: ");
for (int i = 0; i < BLOCK_SIZE; i++) {
printf("%02x ", data[i]);
}
printf("\n");
// Test de la fonction writeBlock
unsigned char newData[BLOCK_SIZE] = {
0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88,
// ... Autres données du bloc ...
};
writeBlock(1, 0, newData, BLOCK_SIZE);
// Lecture du bloc nouvellement écrit pour vérifier
readBlock(1, 0, data, BLOCK_SIZE);
printf("Block 1, offset 0: ");
for (int i = 0; i < BLOCK_SIZE; i++) {
printf("%02x ", data[i]);
}
printf("\n");
return 0;
}

Fonctionnement :

* On déclare tout d'abord un tableau de caractères <code>data</code> de taille <code>BLOCK_SIZE</code> pour stocker les données lues du bloc.
* Ensuite, la fonction <code>readBlock</code> est appelée avec les arguments (0, 0, data, BLOCK_SIZE) pour lire le premier bloc du fichier (<code>num=0</code>, <code>offset=0</code>) et stocker les données dans <code>data</code>.
* Ensuite, la fonction <code>printf</code> est utilisée pour afficher les données lues du bloc (<code>data</code>) en format hexadécimal.
* Ensuite, un nouveau tableau de caractères <code>newData</code> est créé avec des données spécifiques pour tester la fonction <code>writeBlock</code>.
* La fonction <code>writeBlock</code> est appelée avec les arguments (1, 0, newData, BLOCK_SIZE) pour écrire le tableau <code>newData</code> dans le deuxième bloc du fichier (<code>num=1</code>, <code>offset=0</code>).
* Enfin, la fonction <code>readBlock</code> est appelée à nouveau pour lire le deuxième bloc nouvellement écrit et afficher les données lues en format hexadécimal.

Question générale : ce que j'avais la première semaine n'est plus forcément d'actualité. Puis-je supprimer les choses qui ne le sont plus afin d'alléger la page ou préférez-vous que je laisse?

ReX : Laissez.

Pour la suite : j'ai donc pour l'instant crée deux fonctions, l'une permettant la lecture et l'autre l'écriture d'un bloc, de manière à économiser la mémoire. Pour la suite, je vais essayer de créer la fonction <code>LS</code> en utilisant la fonction <code>readBlock</code>.

ReX : Oui c'est le début du projet. Mais si vous n'avez pas une bonne description de fichier cela ne donnera rien. Voir remarques plus haut.

'''Etape 5: fonction <code>LS</code>'''

Objectif: créer la fonction <code>LS</code> avec la fonction readBlock.

Question: Souhaitez-vous la fonction <code>LS</code> classique, c'est à dire la fonction <code>LS</code> qui affiche simplement le nom des fichiers présent dans le répertoire ?

ReX : Oui. Tu peux ajouter la taille si tu trouves cela trop simple.

Piste : si c'est ce que vous voulez:

* il va tout d'abord falloir que je crée des fichiers, un fichier étant composé d'un nom et de blocs (création d'une fonction createFile)
* Il faudra ensuite que je stocke ces fichiers dans le répertoire (création d'une fonction addFileToDirectory par exemple)
* enfin, il faudra que j'affiche le nom des fichiers. Pour cela, il faudra que je parcours le répertoire (structure "Directory"), puis que pour chaque fichier présent dans le répertoire que j'affiche son nom (création de la fonction LS)

Je devrais surement utiliser la fonction readBlock afin de transférer les blocs dans le fichier au travers de la variable "storage".

ReX : Créer des fichiers n'est pas nécessaire tout de suite je verrais bien si ton code est bon sans test. Laisse tomber <code>createFile</code> et <code>addFileToDirectory</code> pour l'instant.

ReX : Ton algorithme ne fonctionne pas pour un microcontrôleur où il faut économiser la mémoire, tu ne peux pas t'aider de structures. Il faudra que tu charges les noms et seulement les noms, pour la taille il faudra se baser sur le nombre de blocs.

'''Etape 6: rectification du code suite à vos remarques'''

Modifications apportées:

* suppression des structures afin d’économiser de la mémoire.

* le problème quant à la description des fichiers est normalement résolu puisque plus de structures. On ne charge plus les blocs mais seulement les noms de fichiers.

ReX : Non car si les noms ne sont pas répartis de façon régulière dans les blocs de 256 octets tu vas avoir du mal à les charger. Mais écrit la fonction <code>LS</code> et tu verras ce que je veux dire.

J'ai également ajouté deux nouvelles fonctions:

# <code>void readFileName(unsigned int file_num, char *file_name)</code>: Cette fonction permet de lire le nom du fichier associé au numéro de fichier donné (<code>file_num</code>). Elle stocke le nom du fichier lu dans le tableau <code>file_name</code>.
# <code>void writeFileName(unsigned int file_num, const char *file_name)</code>: Cette fonction permet d'écrire le nom du fichier dans le système de fichiers, associé au numéro de fichier donné (<code>file_num</code>). Elle prend en entrée le nom du fichier à écrire (<code>file_name</code>).

Suite: si vous validez cette base, je pourrai passer à la création de la fonction LS.

ReX : tu peux y aller. Je ne vois pas le code des tes deux fonctions <code>readFileName</code> et <code>writeFileName</code>.

Voici le code des fonctions <code>readFileName</code> et <code>writeFileName</code> :

'''Fonction readFileName:'''
// Fonction pour lire le nom du fichier
void readFileName(unsigned int file_num, char *file_name) {
readBlock(file_num, 0, (unsigned char *)file_name, MAX_FILENAME_LENGTH);
file_name[MAX_FILENAME_LENGTH] = '\0'; // Ajout du caractère null-terminator pour former une chaîne de caractères
}

ReX : Non, aucune raison que le fichier de numéro n soit au bloc n. Dessine la représentation d'un fichier sur le SF en comptant les octets si cela peut aider.

'''Fonction writeFileName:'''
// Fonction pour écrire le nom du fichier
void writeFileName(unsigned int file_num, const char *file_name) {
writeBlock(file_num, 0, (const unsigned char *)file_name, MAX_FILENAME_LENGTH);
}

ReX : Faux et inutile pour l'instant. Problème avec la constante MAX_FILENAME_LENGTH.

=== Fonction LS version 1 ===
// Fonction LS pour afficher les fichiers présents dans le système de fichiers
void LS(const char *filesystem_path) {
FILE *file = fopen(filesystem_path, "rb");
if (file == NULL) {
perror("Erreur lors de l'ouverture du fichier système");
return;
}
uint16_t num_files;
fread(&num_files, sizeof(uint16_t), 1, file); // Lecture du nombre de fichiers dans le système
char filename[17];
printf("Fichiers présents dans le système de fichiers:\n");
for (int i = 0; i < num_files; i++) {
readFileName(i, filename); // Lecture du nom du fichier
printf("%s\n", filename); // Affichage du nom du fichier
}
fclose(file);
}
La fonction <code>LS</code> ouvre le fichier système, lit le nombre de fichiers qu'il contient, puis affiche les noms des fichiers un par un, chacun sur une ligne séparée.

ReX : Il y a le nombre de fichiers dans ton superbloc ? Un dessin du format du superbloc avec les numéros des octets ?

ReX : Tout accès au système de fichiers doit se faire avec les deux fonctions <code>readBlock</code> et <code>writeBlock</code>.

== Semaine 3 ==
Question 1: cela fait plusieurs fois que vous mentionnez dans le wiki un "superbloc". Celui-ci n'étant pas clairement défini dans le sujet, je me demande s'il s'agit du bloc crée grâce à la fonction dd, c'est à dire que le superbloc serait en faite le bloc constitué des 31250 blocs de taille 256 octets, où s'il s'agit d'un bloc qui vient en entête, celui contenant alors des informations décrivant le système de fichier (les noms de fichiers...).

ReX : Pour ton pico système de fichiers, le superbloc consiste en les premiers blocs (de 256 octets) qui définissent les 64 fichiers possibles.

Proposition de structure: on pourrait réserver les premiers blocs du système de fichiers aux noms de fichiers ainsi qu'aux numéros des blocs correspondant à chaque fichier.

ReX : Oui c'est évident.

On sait que les noms de fichiers font au maximum 16 caractères + 1 caractère pour le '\0' (donc 17 octets car 1 char=1 octet).

ReX : Non, 16 octets suffisent, des '\0' en fin de nom uniquement si le nom fait moins de 16 caractères.

On sait également qu'un fichier contient au maximum 2040 blocs, chaque bloc étant numéroté sur 2 octets. On pourrait donc avoir en début du système de fichier: 17 octets+2 octets*2040 blocs = 4097 octets pour la description d'un fichier.

ReX : Non, 4096 octets soit 16 blocs de 256.

Or d'après l'une de vos remarques dans le wiki, un fichier doit être décrit par un nombre entier de blocs. Pour un fichier, il nous faudra donc 4097/256=16.004 soit 17 blocs. Il peut y avoir jusqu'à 64 fichiers dans le répertoire, il nous faudra donc 17 blocs*64 fichiers= 1088 blocs pour la description des fichiers.

ReX : Non 1024 blocs de 256 octets dans le superbloc.

Ainsi, pour la fonction LS, il suffira de lire les premiers caractères tous les 17 blocs ( du premier caractère au caractère '\0').

ReX : Non, tous les 16 blocs.

Question 2: Ne faudrait-il pas également stocker quelque part le nombre de fichier qu'il y a dans le répertoire afin de savoir jusqu'à quel bloc la fonction LS doit aller ?

ReX : Non, un fichier dont le nom n'est constitué que de '\0' est réputé ne pas exister.

Question 3: on a donc vu que les 1088 premiers blocs au maximum serviraient à la description du système de fichier. Il reste donc 31250-1088=30132 blocs dans le système de fichier.

ReX : Non, 32768-1024=31744 blocs.

Comment utiliser ces blocs? Ces blocs doivent-ils stocker le contenu des fichiers ?

ReX : Oui, c'et évident.

En effet, avec la fonction TYPE, nous allons créer des fichiers et ces fichiers devront être stockés quelque part. Cependant, étant donné que ce pico système de fichiers est prévu pour un microcontrôleur, je ne sais pas si c'est le contenu des fichiers qui doit être stocké dans les blocs ou autre chose (peut être l'adresse des fichiers, le fichiers se trouvant autre part). En effet, je me dis que si un fichier est très volumineux, il ne pourra pas rentrer dans le système de fichier, ce dernier étant composé d'un nombre limité de blocs, et les blocs étant eux même limité en nombre d'octets.

ReX : Je ne comprend pas ton problème. De tout façon comme dit plus haut, les 31744 blocs suivant le superbloc doivent contenir les données des fichiers.

Désolé de poser des questions peut être basique aussi tard, mais je pense qu'une fois que j'aurai ces réponses, cela ira beaucoup mieux pour la suite. Merci d'avance pour vos réponses.

ReX : Les questions sont effectivement triviales et il est effectivement inquiétant que voir que la travail n'avance pas.

Amine: merci pour vos corrections.

D'après votre commentaire "32768-1024=31744 blocs", j'en déduis qu'il faut que je modifie ma commande dd (qui est actuellement "dd if=/dev/zero of=filesystem.bin bs=256 count=31250" pour avoir le bon filesystem).

ReX : Je comprends pas d'où tu sors le 31250. D'autant plus que la commande ci-dessous est bonne.

Amine : 31250 car 31250 blocs * 256 octets = 8 Mo.

ReX : Haaaa je vois tu utilises le système métrique international où le mégaoctet vaut 10^6 octets, sauf qu'aucun informaticien n'utilisera cette norme hors sol. Quand je parle de 8 Mo c'est 8x1024x1024 octets. Tout simplement parce qu'une puce mémoire de 8 Mo c'est bien 8x1024x1024 octets.

Amine: D'accord merci pour l'information !

'''Nouvelle commande dd:'''

dd if=/dev/zero of=filesystem.bin bs=256 count=32768

=== Fonction LS version 2 ===

Dans notre structure du système de fichier, le superbloc est constitué de 1024 blocs (16 blocs * 64 fichiers), un fichier étant décrit par 16 blocs. Le nom du fichier est donc écrit au début de tous les blocs multiples de 16. Par exemple, le nom du premier fichier est dans les 16 premiers octets du premier bloc, le nom du 2ème fichier est dans les 16 premiers octets du 32ème bloc et ainsi de suite, tant que des fichiers existent. Lorsque qu'il n'y a plus de fichier, le nom du premier caractère du bloc multiple de 16 est un 0.

Voici le code:
// Fonction pour lister les noms de fichiers présents dans le système de fichiers
void LS() {
unsigned char buffer[BLOCK_SIZE];
int fileCount = 0;

for (int blockNum = 1; blockNum <= MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, BLOCK_SIZE);

// Vérifier si le bloc est vide
if (buffer[0] == 0) {
break; // Plus de fichiers à lire
}

char filename[MAX_FILENAME_LENGTH];
memcpy(filename, buffer, MAX_FILENAME_LENGTH);

// Afficher le nom du fichier
printf("%s\n", filename);
fileCount++;
}

if (fileCount == 0) {
printf("Aucun fichier trouvé.\n");
}
}

ReX : Tu supposes que si un fichier a un nom vide, les suivants auront aussi un nom vide. C'est possible mais dans ce cas la commande <code>RM</code> ca être plus compliquée à écrire.

ReX : Tu ne sembles pas comprendre que la mémoire d'un microcontrôleur est limitée. Pourquoi lire le premier bloc de description d'un fichier en entier ? Dit autrement c'est quoi l'intérêt de lire 256 octets alors que 16 suffisent ?

ReX : Pourquoi tu ne lis pas le premier fichier ? Autrement dit pourquoi décaler tout d'un bloc ?

Amine: Merci pour vos remarques. J'ai apporté les modifications à LS dans la section "Semaine 4" du wiki.

'''Réflexion par rapport aux autres fonctions:'''

J'ai créé les fonctions TYPE et CAT mais il y a malheureusement un problème pour l'instant. Vous pouvez les retrouver en pièce jointe dans l'archive du fichier programme.c.

Le problème que j'ai est que lorsque j'affiche le contenu du fichier créé avec TYPE, j'obtiens plein de caractères spéciaux. Par exemple, je créé le fichier "mon_fichier.txt" avec la fonction TYPE, et je mets en entré standard "hello". Ensuite, je veux afficher le contenu de ce fichier grâce à la fonction CAT. Cependant, ce qui s'affiche dans le terminal n'est pas ce que je veux. De la même manière, lorsque je fais la commande "cat filesystem.bin" dans le terminal, c'est la même chose s'affiche, des donnés parasites.

ReX : Avant même de lire ton code je vais te poser la question de savoir comment tu récupères un bloc libre ? Quel algorithme tu utilises. Personnellement je ne sais pas faire sans ajouter au superbloc un tableau bit à bit des blocs libres. Pour avoir un bit pour chaque bloc du système de fichiers, il faut 32768/8=4096 octets soit 16 blocs.

Amine: ok je vais donc ajouter ce tableau de 16 blocs à la suite de mes premiers 1024 blocs servant à la description de fichier. Le superbloc fera maintenant 1024+16=1040 blocs (plus de détail à la fonction RM de la semaine 4).

Question 1: est ce que la fonction CAT que je dois créer doit renvoyer la même chose que "cat filesystem.bin" ?

ReX : Je préfère ne pas répondre tellement la question montre un manque de réflexion.

Question 2: comment savoir combien de blocs doivent etre attribué à un fichier? Par exemple, si je créé un fichier "mon_fichier.txt" et que je mets en entrée standard le texte "hello", un seul bloc suffi pour stocker ce texte. Cependant, si j'avais mis beaucoup de texte en entrée standard, il aurait fallu plus de blocs. Doit-on calculer la taille de l'entrée standard ou doit-on attribuer toujours le meme nombre de blocs à un fichier? Peut-etre ainsi attribuer 2040 blocs par fichier, meme s'il n'en utilise que 1.

ReX : Là encore c'est une question stupéfiante tellement la réponse est évidente. Il suffit de lire les données sur l'entrée standard et de passer au bloc de données suivant dès que le bloc courant est rempli. La question à poser c'était de se demander comment il est possible d'avoir la taille exacte du fichier pour un <code>CAT</code>. Il est uniquement possible de l'avoir à 256 octets près puisque rien n'indique si le dernier block est vide. Le mieux aurait été de prévoir 4 octets dans la description d'un fichier pour stocker la taille. En l'espèce on considérera que les fichiers sont des fichiers ASCII et qu'ils seront terminés par des <code>\'0</code> qui ne seront pas affichés.

== Semaine 4 ==

Voici un bilan de ce que j'ai fait à ce stade du projet:

* j'ai choisi une structure du système de fichier
* j'ai créé les fonctions readBlock et writeBlock permettant de lire et d'écrire des blocs
* j'ai crée la fonction LS permettant d'afficher le nom des fichiers présents dans le système de fichiers
* j'ai programmer un main permettant d'utiliser les fonctions (LS, TYPE...) depuis le terminal
* j'ai réflechi aux fonctions TYPE et CAT.

Actuellement, je suis en train de créer les fonctions TYPE et CAT.

=== Fonction LS version 3 ===
void LS() {
unsigned char buffer[MAX_FILENAME_LENGTH];
int fileCount = 0;

// Parcourir tous les 16 blocs de 0 jusqu'à MAX_FILES_IN_DIRECTORY
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, MAX_FILENAME_LENGTH);

// Vérifier si le nom de fichier est vide
if (buffer[0] != 0) {

// Afficher le nom du fichier
printf("%s\n", buffer);
fileCount++;
}
}

if (fileCount == 0) {
printf("Aucun fichier trouvé.\n");
}
}
Suite à vos remarques, j'ai effectué les modifications suivantes de la fonction LS:

* Je ne suppose plus que si un fichier a un nom vide, les autres auront aussi un nom vide.
* Je ne lis plus les 256 octets mais seulement les 16 premiers octets car cela suffit.
* Je ne lisais en effet pas le premier bloc. Je pensais que le premier bloc était d'indice 1 mais ce n'est pas le cas.

ReX : Ouiiii ! Une fonction correcte. Passe à <code>RM</code> maintenant, c'est la plus facile à faire concernant l'image bit à bit des blocs libres.

=== Fonction setBlockAvailability version 1 ===

Comme vous l'avez indiqué dans votre remarque, il faut un tableau dans le superbloc qui nous permettra de connaitre la disponibilité bit par bit de chaque bloc. Sachant qu'il y a dans notre système de fichiers 32768 blocs, et qu'il faut 1 bit par bloc, nous avons besoin de 32768 bits, soit 32768/8=4096 octets soit 4096/256=16 blocs. Notre superbloc sera donc comme suit: les 1024 premiers blocs servent à la description des fichiers, c'est à dire à leur nom suivi des numéros de blocs qui leur sont associés, puis ces 1024 blocs sont suivi de 16 blocs listant la disponibilité de chaque bloc.

ReX : Bien résumé.

Nous allons tout d'abord écrire la fonction "setBlockAvailability" prenant en paramètre le numéro du bloc à traiter (<code>blockNum</code>) et la disponibilité souhaitée pour ce bloc (<code>availability</code>). Cette fonction permet de marquer la disponibilité d'un bloc spécifique dans le système de fichiers. Nous utiliserons la convention suivante: un bloc disponible sera marqué par un 1 tandis qu'un bloc non disponible par un 0.
#define SUPERBLOCK_START_BLOCK 1024

void setBlockAvailability(int blockNum, int availability) {
// Calculer l'index du byte et le bit offset correspondant
int byteIndex = blockNum / 8;
int bitOffset = blockNum % 8;

// Lire le byte existant du bloc de disponibilité des blocs
unsigned char buffer[1];
readBlock(SUPERBLOCK_START_BLOCK + byteIndex, 0, buffer, 1);

// Mettre à jour le bit d'offset correspondant
if (availability) {
buffer[0] |= (1 << bitOffset);
} else {
buffer[0] &= ~(1 << bitOffset);
}

// Écrire le byte mis à jour dans le bloc de disponibilité des blocs
writeBlock(SUPERBLOCK_START_BLOCK + byteIndex, 0, buffer, 1);
}

ReX : Un tableau de un octet c'est un octet (variable <code>buffer</code>).

Amine: je vais utiliser un <code>unsigned char buffer.</code> Je suis conscient qu'un char vaut un octet mais je ne pense pas qu'il y ait un type de donnée de la taille d'un bit, c'est pourquoi je travaille avec un octet mais je modifie les bits de cet octet grâce aux algorithmes.

ReX : Il faut bien que tu travailles sur un octet vu que l'état des blocs est stocké sous la forme d'octets. Je disais juste qu'un tableau de 1 élément n'a pas d'intérêt par rapport à l'élément lui-même.

Amine: c'est vrai, modification faite.

ReX : Non il faut calculer le numéro du bloc avant de faire le <code>readBlock</code>.

Amine: ok je vais calculer le numéro de bloc avant.

ReX : La mise à jour du bit est correcte mais le block et le déplacement dans le block ne sont pas correctement calculés.

Amine: je vais vous expliquer le raisonnement que j'avais. Prenons un exemple concret, imaginons que je veuille marquer le bloc 1030 comme disponible:

# Calcul de l'index de l'octet et du bit offset :
#* <code>blockNum</code> = 1030
#* Index du byte = 1030 / 8 = 128
#* Bit offset = 1030 % 8 = 6
# Lecture de l'octet existant de disponibilité:
#* Nous lisons l'octet existant à l'index 128 dans les blocs de disponibilité.
# Mise à jour du bit de disponibilité :
#* Nous voulons marquer le bloc 1030 comme disponible, donc nous utilisons le masque <code>(1 << 6)</code> pour définir le bit 6 à 1 dans l'octet. Le résultat sera, par exemple, <code>00100000</code>.
# Écriture du byte mis à jour :
#* Nous écrivons le byte mis à jour <code>00100000</code> à l'index 128 dans les blocs de disponibilité.

ReX : Ben non, un vrai exemple :
* Il faut prendre un n° de bloc plus grand : 3072 ;
* Numéro d'octet dans la carte des blocs libres : 3072/8=384 ;
* Numéro du bloc dans la carte des blocs libres : 384/256=1 ;
* Numéro du bit <code>b</code> dans l'octet n° 384-256=128 du bloc 1 : 3072%8=0 ;
* Il faut donc lire l'octet <code>o</code> de numéro 128 du bloc 1, puis modifier cet octet par <code>o |= (1<<b)</code> ou <code>o &= ~(1<<b)</code> ;
* Enfin il faut écrire l'octet modifié dans le bloc 1.
Amine: merci pour cet exemple! J'ai compris d'où vient mon erreur. Voir fonction setBlockAvailability version 3.

Remarque: par convention, j'apellerai dans la suite de ce projet "premier superbloc" le superbloc correspondant à la description des fichiers, c'est à dire les 1024 premiers blocs, et j'appellerai "second superbloc" les 16 blocs qui suivent servant à décrire la disponibilité des blocs (du bloc 1024 au bloc 1039 inclu). Le reste des blocs servira à stocker les données.

ReX : Non, le superblc est l'ensemble des informations hors blocs de données, tu ne peux pas utiliser un vocabulaire au hasard. Parle de blocs de description des fichiers ou de carte des blocs libres.

Amine: ok

Je pense que le problème qui se pose est que l'indice du bit dans le second superbloc ne correspond pas à l'indice du bloc dans le système de fichier. Par exemple, nous voudrions que si le bloc 1030 est disponible dans le système de fichier, alors le bit numéro 1030 du deuxième superbloc soit à 1, ce qui n'est pas le cas ici. En effet, on se trouve bien dans le bon octet avec ma méthode mais l'écriture du bit se fait de la droite vers la gauche alors qu'on voudrait l'inverse. Ainsi, si le 6ème bit de l'octet doit être à 1, alors il faudrait qu'on obtienne <code>00000100</code> et non <code>00100000.</code> L'indice du bit coinciderait ainsi avec le numéro du bloc.

ReX : Non, réfléchit à nouveau.

Voir plus bas la nouvelle version de setBlockAvailability.

Explication de l'algorithme pour mettre le bit à 1 ou 0:

* <code>buffer[0] |= (1 << bitOffset);</code> : Cette ligne utilise l'opérateur OR bit à bit (<code>|=</code>) pour activer (mettre à 1) le bit spécifié par <code>bitOffset</code> dans le premier octet (<code>buffer[0]</code>). Cela se fait en décalant le bit 1 vers la gauche de <code>bitOffset</code> positions, puis en effectuant une opération OR bit à bit avec le contenu actuel de <code>buffer[0]</code>. Cette opération modifie uniquement le bit ciblé, laissant les autres bits inchangés.

ReX : Oui ça c'est bon.

* <code>buffer[0] &= ~(1 << bitOffset);</code> : Cette ligne utilise l'opérateur AND bit à bit (<code>&=</code>) pour désactiver (mettre à 0) le bit spécifié par <code>bitOffset</code> dans <code>buffer[0]</code>. Pour ce faire, l'expression <code>~(1 << bitOffset)</code> est utilisée pour créer un masque où tous les bits sont à 1, sauf celui correspondant à <code>bitOffset</code>, qui est à 0. En effectuant ensuite une opération AND bit à bit entre le masque et le contenu actuel de <code>buffer[0]</code>, on met à 0 le bit ciblé sans affecter les autres bits.

ReX : Ca aussi.

=== Fonction setBlockAvailability version 2 ===

void setBlockAvailability(int blockNum, int availability) {
// Calculer l'indice de l'octet et le bit offset correspondant
int byteIndex = blockNum / 8;
int bitOffset = 7 - (blockNum % 8); // Inversion de l'ordre des bits

// Calculer le numéro du bloc du super bloc où se trouve l'octet de disponibilité correspondant
int availabilityBlockNum = SUPERBLOCK_START_BLOCK + byteIndex;

// Lire l'octet existant dans le bloc de disponibilité du super bloc
unsigned char buffer;
readBlock(availabilityBlockNum, 0, &buffer, 1);

// Mettre à jour le bit d'offset correspondant :
if (availability) {
buffer |= (1 << bitOffset);
} else {
buffer &= ~(1 << bitOffset);
}

// Écrire l'octet mis à jour dans le bloc de disponibilité du super bloc
writeBlock(availabilityBlockNum, 0, &buffer, 1);
}
J'ai modifié la ligne <code>int bitOffset = 7 - (blockNum % 8);</code> pour inverser l'ordre des bits sélectionnés, de sorte que le bit correspondant au bloc disponible soit correct.

ReX : Encore plus faux.

Si on veut rendre le bloc 1030 indisponible alors que les autres blocs sont disponibles:

ReX : Pardon ? Le bloc de données est libre ou pas suivant la carte des blocs libres. Le rendre disponible n'est possible que si un fichier le comportant est détruit.

# Calcul de l'indice de l'octet et du bit offset correspondant :
#* <code>blockNum = 1030</code>
#* <code>byteIndex = 1030 / 8 = 128</code>
#* <code>bitOffset = 7 - 1030 % 8 = 1</code> Cela signifie que le bit d'intérêt se trouve à la position 2 dans l'octet.
# Calcul du numéro du bloc du super bloc où se trouve l'octet de disponibilité correspondant :
#* <code>availabilityBlockNum = SUPERBLOCK_START_BLOCK + 128 = 1024 + 128 = 1152</code> Donc, nous devons accéder à l'octet 1152 pour mettre à jour la disponibilité du bloc 1030.
# Lecture de l'octet existant dans le bloc de disponibilité du super bloc :
#* Le contenu de l'octet dans le bloc 1152 avant la mise à jour : 11111111 (en binaire)
# Mise à jour du bit d'offset correspondant :
#* Supposons que nous voulions marquer le bloc 1030 comme non disponible (<code>availability = 0</code>).
#* Le bitOffset est 1.
#* Nous effectuons une opération AND avec le complément du bit à la position 1 : <code>11111111 & 11111101 = 11111101</code>
# Écriture de l'octet mis à jour dans le bloc de disponibilité du super bloc :
#* Le contenu de l'octet 128 du second superbloc après la mise à jour : 11111101 (en binaire)

ReX : Toujours aussi faux.

Maintenant, le bit d'indice 1 du 128 ème octet du second superbloc est mis à 0, indiquant que le bloc 1030 n'est plus disponible. Les autres bits restent inchangés car nous avons effectué un AND avec un masque binaire qui avait des 1 partout sauf à la position du bit que nous souhaitions mettre à 0.

ReX : Erreur sur erreur.

=== Fonction setBlockAvailability version 3 ===
J'ai compris d'où vient l'erreur. La fonction readBlock prends en premier paramètre le numéro du bloc à lire, je ne peux donc pas lui donner la valeur "SUPERBLOCK_START_BLOCK + byteIndex" car byteIndex s'exprime en octet alors qu'on s'attend à un nombre de bloc ici. Il faut donc divisé byteIndex par 256 pour être en unité "bloc", et préciser le bit qu'on veut lire grâce à l'offset.

Pour obtenir l'octet que l'on veut, il faut prendre le reste de la division de byteIndex par 256. On va ensuite stocker cet octet dans notre "buffer".

Pour savoir quel bit modifier dans ce "buffer", on va prendre le reste de la division du bloc dont on veut mettre à jour la disponibilité par 8. On va ainsi pouvoir modifier ce bit grâce à l'algorithme, puis réécrire l'octet à son emplacement d'origine.

Cette fonction gère la carte de disponibilités des blocs. Si un bloc est disponible, alors elle le met un 0, si il est indisponible, elle met un 1.
#define SUPERBLOCK_START_BLOCK 1024

void setBlockAvailability(int blockNum, int availability) {

int byteIndexInCard = blockNum / 8; //Numéro d'octet dans la carte des blocs libres
int blockIndexInCard = byteIndexInCard / 256; //Numéro du bloc dans la carte des blocs libres
int byteIndexInBlock = byteIndexInCard % 256; //Numéro d'octet dans le bloc contenant le bit de disponibilité
int bitOffset = blockNum % 8; //Numéro du bit dans l'octet n°byteIndexInBlock du bloc blockIndexInCard

//indice du bloc contenant le bit à mettre à jour dans le bloc de description
int availabilityBlockNum = FIRST_DISPONIBILITY_CARD_BLOCK + blockIndexInCard;

// Lire l'octet existant dans le bloc de disponibilité du super bloc
unsigned char buffer;
readBlock(availabilityBlockNum, byteIndexInBlock, &buffer, 1);

// Mettre à jour le bit d'offset correspondant :
if (availability==1) { // indisponible
buffer |= (1 << bitOffset); // Mettre le bit à 1

} else { // disponible
buffer &= ~(1 << bitOffset); // Mettre le bit à 0
}

// Écrire l'octet mis à jour dans le bloc de disponibilité du super bloc
writeBlock(availabilityBlockNum, byteIndexInBlock, &buffer, 1);
}

ReX : Ben voila, c'est pas possible de te taxer d'excès de vitesse mais c'est bon.

update: j'ai fait une petite modification, maintenant un bloc disponible est marqué d'un 0 et un bloc indisponible est marqué d'un 1. C'est mieux dans la mesure où initialement, tous les blocs sont disponibles et tous les blocs sont à 0. Cela évite de devoir créer une fonction qui initialise toute la carte de disponibilités à 1 pour dire que tous les blocs sont disponibles.

=== Fonction RM version 1 ===

void RM(const char *filesystem_path, const char *filename) {
unsigned char buffer[BLOCK_SIZE];
int fileNum = -1;

// Parcourir les blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (memcmp(filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {
// Effacer le nom du fichier dans le superbloc
memset(filenameBuffer, 0, MAX_FILENAME_LENGTH);
writeBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

unsigned char fileBuffer[MAX_BLOCKS_PER_FILE * 2];
readBlock(blockNum, MAX_FILENAME_LENGTH, fileBuffer, MAX_BLOCKS_PER_FILE * 2);

// Libérer les blocs associés au fichier et réinitialiser les numéros de blocs
for (int i = 0; i < MAX_BLOCKS_PER_FILE * 2; i += 2) {
int blockNum = ((int)fileBuffer[i] << 8) + (int)fileBuffer[i + 1];
if (blockNum == 0) {
break; // Fin du fichier
}
setBlockAvailability(blockNum, 0); // Marquer le bloc comme disponible
fileBuffer[i] = 0;
fileBuffer[i + 1] = 0;
}

// Mettre à jour les numéros de blocs associés au fichier
writeBlock(blockNum, MAX_FILENAME_LENGTH, fileBuffer, MAX_BLOCKS_PER_FILE * 2);

fileNum = blockNum;
break; // Fichier trouvé, sortir de la boucle
}
}

// Afficher le résultat de l'opération
if (fileNum == -1) {
printf("Le fichier \"%s\" n'a pas été trouvé.\n", filename);
} else {
printf("Le fichier \"%s\" a été supprimé avec succès.\n", filename);
}
}

ReX : Vous utilisez <code>strcmp</code> comme <code>strncmp</code>. C'est bien la dernière qu'il faut utiliser mais en précisant la longueur du nom en paramètre, pas la taille maximale.

Amine: vous voulez dire que j'utilise memcmp au lieu de strncmp ? Ok je vais utiliser strncmp, c'est vrai que c'est plus adapté pour la comparaison de chaines de caractère.

ReX : Ha oui c'est <code>memcmp</code> que tu utilises. Ca ne peut effectivement pas marcher. Effectivement avec <code>strncmp</code> cela peut marcher vu qu'il s'arrête au premier 0 contrairement à <code>memcmp</code>.

Cependant, pourquoi doit-on passer la taille exacte du nom du fichier en paramètre, et non la taille maximale d'un nom de fichier? En effet, cela semble fonctionner en mettant la taille maximale en paramètre, tandis que lorsque l'on met la taille exacte du nom du fichier, cela pose un problème: on ne compare plus toute la chaîne de caractère mais seulement une portion du nom complet. Ainsi, si je crée par exemple un fichier que j'appelle "file1", puis que j’exécute la fonction RM "/picofs filesystem.bin RM file" par exemple, alors le fichier file1 va être supprimé quand même car on ne comparera que strlen(file)=4 premiers caractères, qui sont les mêmes, donc la fonction considérera ces chaines comme identiques. On pourrait alors se dire qu'il faudrait alors prendre plutôt comme taille en paramètre de la fonction strlen la taille du nom du fichier se trouvant dans le système de fichier plutôt que celle du nom donné en paramètre de RM. Cependant, le même problème se pose si la taille du nom du fichier du système de fichier est plus petite que celle du nom du fichier passé en paramètre. Par exemple, si le fichier présent dans système de fichier est "file", et qu'on met la longueur de file en paramètre de la fonction strcmp, puis qu'on exécute la commande "/picofs filesystem.bin RM file5", alors file sera quand même supprimé, car on ne comparera que les strlen(file)=4 premiers caractère. Finalement, une solution serait de rajouter une condition qui vérifie que les deux chaînes sont de taille identiques pour pouvoir réaliser la comparaison sur la taille exacte du nom du fichier. Cependant, il me semble qu'en mettant MAX_FILENAME_LENGTH qui vaut 16 en paramètre, cela fonctionne directement. Vous pouvez tester cela en testant mon programme.

ReX : Ok pour <code>strncmp</code> avec la taille maximale d'un nom de fichier.

etape 1: créer un fichier :
./picofs filesystem.bin TYPE fichier.txt

etape 2: verifier que le fichier a bien été créé :
./picofs filesystem.bin LS

Le terminal renvoie bien "fichier.txt"

etape 3: essayer de supprimer le fichier en mettant une chaine troncature du nom du fichier créé :
./picofs filesystem.bin RM fich

le terminal renvoi <<Le fichier "fich" n'a pas été trouvé.>>, le fichier n'a donc pas été supprimé .

etape 4: essayer de supprimer le fichier en mettant un nom plus grand incluant "fichier.txt" :
./picofs filesystem.bin RM fichier.txtt

terminal renvoi <<Le fichier "fichier.txtt" n'a pas été trouvé.>>

etape 5: enfin, tester en mettant le nom exacte du fichier que l'on veut supprimer :
./picofs filesystem.bin RM fichier.txt

terminal renvoi <<Le fichier "fichier.txt" a été supprimé avec succès.>>

Finalement, on voit que cela fonctionne avec la taille maximale mise en paramètre. On pourrait reprocher à cette méthode de comparer des caractères dans le vide, ce qui n'est pas optimal dans une optique d'économie de mémoire qui est la notre, mais la taille maximale d'un nom de fichier étant relativement faible (16 octets), on peut peut-être négliger cela au vu de l'économie d'une opération supplémentaire (comparaison de la taille des chaines de caractères).

ReX : Le parcours des blocs de données du fichier est atroce. Il faut parcourir les numéros de blocs dans le premier bloc du fichier derrière le nom du fichier puis il faut parcourir le 15 autres blocs.

Amine: Ok, je vais corriger cela dans la version 2 de RM (voir semaine 5).

Fonctionnement de la fonction RM:

* Parcours des blocs réservés pour la description des fichiers (superbloc) à partir du bloc 0, en incrémentant de 16 à chaque itération pour accéder aux blocs de noms de fichiers.

ReX : OK.

* Dans chaque bloc de noms de fichiers, la fonction compare le nom de fichier recherché avec les noms stockés dans les 16 octets de chaque bloc.

ReX : Non la fonction ne fait pas ça par contre il faudrait, oui.

Amine: Je pensais que c'était ce que je faisais avec "memcmp(filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0)".

* Si le nom de fichier est trouvé, la fonction efface le nom du fichier dans le superbloc en remplaçant les 16 octets du bloc par des zéros.

ReX : OK.

* Ensuite, la fonction accède aux octets suivants du même bloc pour obtenir les numéros de blocs associés au fichier.

ReX : Non, la boucle sort largement du premier bloc.

* Pour chaque paire de numéros de blocs (2 octets chacun), la fonction convertit les octets en un numéro de bloc. Si le numéro de bloc est nul, cela signifie la fin des blocs associés au fichier, sinon, la fonction marque ce bloc comme disponible en utilisant la fonction <code>setBlockAvailability</code> et réinitialise les numéros de blocs dans le tableau à zéro.
* Les numéros de blocs réinitialisés sont ensuite réécrits dans le bloc de description du fichier.

ReX : L'idée est là mais vu que la boucle n'est pas bonne, rien ne peut marcher.

* La fonction affiche ensuite un message indiquant le résultat de l'opération : soit que le fichier a été supprimé avec succès, soit que le fichier n'a pas été trouvé.

== Semaine 5 ==

=== Fonction RM version 2 ===

Concernant les remarques que vous m'avez faites précédemment:

* j'utilise maintenant la fonction <code>strncmp</code> pour la comparaison des chaines de caractères
* j'ai normalement corrigé le parcours des blocs. Je parcours maintenant d'abord les blocs multiples de 16 à la recherche du bloc contenant le nom du fichier à supprimer. Puis je parcours les 16 blocs de description du fichier à supprimer, afin de récupérer les numéros de blocs, libérer ces blocs dans la carte de disponibilité et de réinitialiser ces blocs dans les blocs de données.

void RM(const char *filesystem_path, const char *filename) {
int fileFound = -1;
int offset;

// Parcourir les blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char*)filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {

// Effacer le nom du fichier dans le superbloc
memset(filenameBuffer, 0, MAX_FILENAME_LENGTH);
writeBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);
fileFound = 1;
offset = blockNum;
break;
}

}

// Fin de fonction si fichier inexistant
if (fileFound == -1) {
printf("Le fichier \"%s\" n'a pas été trouvé.\n", filename);
return;
}

unsigned char buffer[BLOCK_SIZE];
//bloc que l'on va remplir de 0 et mettre à la place des blocs de données
memset(buffer, 0, BLOCK_SIZE); //on rempli buffer de 0

for (int blockNum=offset; blockNum<offset + 16; blockNum++) {

//premier bloc de description, celui contenant le nom du fichier dans les 16 premiers octets
if (blockNum == offset) {

unsigned char fileBuffer[BLOCK_SIZE-MAX_FILENAME_LENGTH];
//bloc dans lequel on va stocker les blocs de description de fichier
readBlock(blockNum, MAX_FILENAME_LENGTH, fileBuffer, BLOCK_SIZE-MAX_FILENAME_LENGTH);

// Libérer les blocs associés au fichier dans la carte de disponibilités
// et dans les blocs de description
for (int i = MAX_FILENAME_LENGTH; i < BLOCK_SIZE-MAX_FILENAME_LENGTH; i += 2) {
int blockNumData = ((int)fileBuffer[i] << 8) + (int)fileBuffer[i + 1];
if (blockNumData == 0) {
break; // Fin du fichier
}
setBlockAvailability(blockNumData, 0); // Marquer le bloc comme disponible
fileBuffer[i] = 0;
fileBuffer[i + 1] = 0;
writeBlock(blockNumData, 0, buffer, BLOCK_SIZE); //on efface les blocs de données
}
writeBlock(blockNum, MAX_FILENAME_LENGTH, fileBuffer, BLOCK_SIZE-MAX_FILENAME_LENGTH);
//on efface le premier bloc de description

} else {
unsigned char fileBuffer[BLOCK_SIZE];
readBlock(blockNum, 0, fileBuffer, BLOCK_SIZE);

// Libérer les blocs associés au fichier dans la carte de disponibilités et dans les blocs de description
for (int i = 0; i < BLOCK_SIZE; i += 2) {
int blockNumData = ((int)fileBuffer[i] << 8) + (int)fileBuffer[i + 1];
if (blockNumData == 0) {
break; // Fin du fichier
}
setBlockAvailability(blockNumData, 0); // Marquer le bloc comme disponible
fileBuffer[i] = 0;
fileBuffer[i + 1] = 0;
writeBlock(blockNumData, 0, buffer, BLOCK_SIZE); //on efface les blocs de données
}
writeBlock(blockNum, 0, fileBuffer, BLOCK_SIZE); //on efface le bloc de description
}
}
printf("Le fichier \"%s\" a été supprimé avec succès.\n", filename);
}

ReX : Pour construire le nombre sur 16 bits utiliser le OU plutôt que l'addition.

ReX : Heu non, je ne lis pas cette fonction avec tout ce code dupliqué, la seule différence entre les deux alternative est la position de début de l'adresse du premier bloc de données (<code>MAX_FILENAME_LENGTH</code> dans un cas et 0 dans l'autre). Donc l'alternative ne doit servir qu'à initialiser ce début, le reste du code doit être factorisé.

ReX : Et corrige le code, tu utilises deux tableaux de blocs (perte mémoire), tu écris le bloc à zéro dans l'itération (perte CPU).

=== Fonction RM version 3 ===

Suite à vos remarques, j'ai réalisé les modifications suivantes:

* j'utilise maintenant le OU plutôt que l'addition pour construire le nombre sur 16 bits.

* j'ai factorisé le code grâce à la création de la variable <code>startOffset</code> valant 16 lorsqu'on se trouve dans le bloc contenant le nom du fichier et valant 0 lorsqu'on se trouve dans les autres.

* Pour ce qui est du fait que j'utilise 2 tableaux de blocs, j'ai du mal à voir comment faire avec 1 seul tableau de blocs car ces deux tableaux n'ont pas du tout le même rôle. Le tableau <code>fileBuffer</code> permet de stocker les 16 blocs de description d'un fichier un à un. Lorsqu'on stocke un bloc dans <code>fileBuffer</code>, on lit ensuite les octets un à un de ce bloc afin de former des numéros de blocs, et pour chaque numéro de bloc créé, on va réinitialiser le bloc correspondant dans les blocs de données. Pour cela, on a donc besoin d'un autre bloc qui viendra écraser les anciens blocs de données. C'est pourquoi j'ai créé un bloc <code>buffer</code>qui est composé de 0 et qui va écraser les blocs de données. On ne peut pas utiliser <code>fileBuffer</code> car on a besoin d'un bloc de zéros, et si on réinitialise <code>fileBuffer</code> on perd toute les données qui s'y trouvent. Une possibilité serait de relire le bloc de donné à chaque itération de la deuxième boucle for imbriquée; cela permettrait de pouvoir réinitialiser le tableau fileBuffer à chaque itérations de cette boucle afin de stocker ce bloc de 0 dans les blocs de données, puis de restocker dans ce même tableau le bloc de description. Cependant, je ne pense pas que ce soit optimal de faire autant appel à la fonction readBlock.

* j'ai créé une fonction resetBock qui permet comme son nom l'indique de reset un bloc en le remplissant de 0. Cela nous évite de créer deux tableaux de blocs dans RM, bien que je pense que cela revienne au même car on fait appel à une fonction qui créé un tableau de blocs. Quoi qu'il en soit, cela allège le code et cette fonction pourra surement me resservir par la suite.

void RM(const char *filesystem_path, const char *filename) {
int fileFound = -1;
int offset;
unsigned char fileBuffer[BLOCK_SIZE];

// Parcourir les blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char *)filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {
// Effacer le nom du fichier dans le superbloc
memset(filenameBuffer, 0, MAX_FILENAME_LENGTH);
writeBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);
fileFound = 1;
offset = blockNum;
break;
}
}

// Fin de fonction si fichier inexistant
if (fileFound == -1) {
printf("Le fichier \"%s\" n'a pas été trouvé.\n", filename);
return;
}

for (int blockNum = offset; blockNum < offset + 16; blockNum++) {
int startOffset = 0;
if (blockNum == offset) {
startOffset = MAX_FILENAME_LENGTH;
}
readBlock(blockNum, startOffset, fileBuffer, BLOCK_SIZE - startOffset);

// Libérer les blocs associés au fichier dans la carte de disponibilités et dans les blocs de description
for (int i = 0; i < BLOCK_SIZE - startOffset; i += 2) {
int blockNumData = (fileBuffer[i] << 8) | fileBuffer[i + 1];
if (blockNumData == 0) {
break; // Fin du fichier
}
setBlockAvailability(blockNumData, 0); // Marquer le bloc comme disponible
fileBuffer[i] = 0;
fileBuffer[i + 1] = 0;
resetBlock(blockNumData); //on efface les blocs de données
}
writeBlock(blockNum, startOffset, fileBuffer, BLOCK_SIZE - startOffset);
}
printf("Le fichier \"%s\" a été supprimé avec succès.\n", filename);
}
'''Fonction resetBlock'''
void resetBlock(unsigned int blockNum) {
unsigned char buffer[BLOCK_SIZE];
memset(buffer, 0, BLOCK_SIZE);

// Utiliser writeBlock pour écrire les données du buffer dans le bloc
writeBlock(blockNum, 0, buffer, BLOCK_SIZE);
}

ReX : Ca s'améliore. Mais pourquoi cette fonction <code>resetBlock</code> ? Tu crois que dans qu'un système de fichiers perd du temps à mettre à zéro les blocs de données libérés ? Si oui, regarde la page de manual de la commande <code>shred</code>, ça manque à ta culture.

Amine: Après avoir consulter le manual de la commande <code>shred</code>, je vois que cette commande écrit des données aléatoires sur l'emplacement du fichier sur le disque. Par défaut, <code>shred</code> effectue un certain nombre de passes (par exemple, 3 passes) pendant lesquelles il écrit des données aléatoires sur l'emplacement du fichier sur le disque. Après avoir écrit les données aléatoires, <code>shred</code> peut effectuer des passes supplémentaires pendant lesquelles il écrit des données nulles (des zéros) sur le même emplacement. L'objectif de <code>shred</code> est d'augmenter la sécurité en rendant plus difficile la récupération des données supprimées à l'aide d'outils de récupération de données.

Cependant, j'ai aussi consulté comment fonctionne la commande <code>rm</code> de linux, et je vois que cette commande libère l'espace occupé par le fichier en marquant les blocs associés comme disponibles. Cela signifie que les données peuvent encore être récupérées à l'aide d'outils de récupération de données, à moins que des mesures supplémentaires ne soient prises pour écraser physiquement l'espace avec des données aléatoires (c'est ce que fait l'utilitaire <code>shred</code>).

On va donc opter pour la deuxième option, c'est à dire qu'on ne va pas perdre notre temps à remettre à zéro les blocs de données libérés, on va simplement marquer les blocs correspondants comme étant disponibles. Cela nous permettra de nous émanciper de la fonction resetBlock et de n'avoir plus qu'un seul tableau de blocs.

ReX : Sinon lire un bloc complet de pointeurs de blocs de données en mémoire n'est pas forcément optimal. L'idéal serait de lire ces blocs morceau par morceau (de 64 octets par exemple). Certes un bloc serait traité en 4 lectures/écritures (ce qui ralentirait le traitement) mais on gagne en mémoire. Le mieux serait de mettre la taille des morceaux en constante pour pouvoir choisir entre vitesse d'exécution et utilisation mémoire.

Amine: d'accord je comprends. Je vais modifier la fonction pour qu'on puisse découper la lecture/écriture en plusieurs blocs.

=== Fonction RM version 4 ===
Modifications apportées:

* je ne réinitialise plus les blocs de données, je supprime simplement le pointeur du fichier vers les blocs de données et je désigne les blocs comme "disponible" dans le carte de disponibilités. J'ai donc supprimé la fonction resetBlock.

* je ne lis plus les blocs en une seule fois mais en plusieurs fois via la variable CHUNK_SIZE:

# J'ai introduit la constante <code>CHUNK_SIZE</code> pour définir la taille de chaque morceau que nous allons lire/écrire à la fois. Cela permet de découper les opérations en blocs plus petits.
# Dans la boucle <code>for</code> où on parcours les blocs à partir de <code>offset</code>, j'ai ajouté une boucle interne qui parcourt les données du bloc en morceaux de taille <code>CHUNK_SIZE</code>.
# À l'intérieur de la boucle interne, j'ai calculé la taille réelle du morceau (<code>chunkSize</code>) en prenant le minimum entre <code>CHUNK_SIZE</code> et la quantité de données restant à lire/écrire dans le bloc.
# J'ai modifié la fonction <code>readBlock</code> pour lire seulement la quantité de données spécifiée par <code>chunkSize</code> à partir de <code>chunkStart</code>. Ces données sont stockées dans le tableau <code>fileBuffer</code>.
# Ensuite, j'ai effectué les mêmes opérations de libération des blocs associés au fichier, en parcourant les données du morceau et en marquant les blocs comme disponibles.
# Finalement, j'ai utilisé la fonction <code>writeBlock</code> pour écrire le morceau de données modifié dans le bloc, en utilisant la même <code>chunkStart</code> pour déterminer où écrire les données.

#define CHUNK_SIZE 64

int min(int a, int b) {
return a < b ? a : b;
}

void RM(const char *filesystem_path, const char *filename) {
int fileFound = -1;
int offset;
unsigned char fileBuffer[BLOCK_SIZE];

// Parcourir les blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char *)filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {
// Effacer le nom du fichier dans le superbloc
memset(filenameBuffer, 0, MAX_FILENAME_LENGTH);
writeBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);
fileFound = 1;
offset = blockNum;
break;
}
}

// Fin de fonction si fichier inexistant
if (fileFound == -1) {
printf("Le fichier \"%s\" n'a pas été trouvé.\n", filename);
return;
}

for (int blockNum = offset; blockNum < offset + 16; blockNum++) {
int startOffset = 0;

if (blockNum == offset) {
startOffset = MAX_FILENAME_LENGTH;
}

for (int chunkStart = startOffset; chunkStart < BLOCK_SIZE; chunkStart += CHUNK_SIZE) {
int chunkSize = min(CHUNK_SIZE, BLOCK_SIZE - chunkStart);
readBlock(blockNum, chunkStart, fileBuffer, chunkSize);

for (int i = 0; i < chunkSize; i += 2) {
int blockNumData = (fileBuffer[i] << 8) | fileBuffer[i + 1];
if (blockNumData == 0) {
writeBlock(blockNum, chunkStart, fileBuffer, chunkSize);
printf("Le fichier \"%s\" a été supprimé avec succès.\n", filename);
return; // Sortir des boucles
}
setBlockAvailability(blockNumData, 0); // Marquer le bloc comme disponible
fileBuffer[i] = 0;
fileBuffer[i + 1] = 0;
}

writeBlock(blockNum, chunkStart, fileBuffer, chunkSize);
}
}

printf("Le fichier \"%s\" a été supprimé avec succès.\n", filename);
}

ReX : Si on trouve un n° de bloc de données à 0, il faut sortir des deux boucles les plus externes après avoir fait le <code>writeBlock</code>.

Amine: Modification faites ci-dessus. Maintenant, dès qu'on trouve un n° de bloc de données à 0 dans la boucle la plus interne, on effectue le <code>writeBlock</code> et ensuite on utilise <code>return</code> pour sortir des deux boucles les plus externes. Cela permet d'optimiser le code en évitant de continuer à traiter inutilement le reste des blocs.

ReX : Pas très propre (duplication de code) mais nous allons nous en contenter.

=== Fonction intermédiaire TYPE version 1 ===

J'ai également commencé à réfléchir à la fonction TYPE. Pour l'instant, elle ne fait qu'ajouter les noms de fichier dans le superbloc. Cela permet de pouvoir tester les fonctions LS et RM (voir dans la rubrique compilation et exécution comment utiliser le programme).
// Fonction pour créer un fichier avec le nom donné et le contenu fourni en entrée standard
void TYPE(const char *filesystem_path, const char *filename) {
unsigned char buffer[MAX_FILENAME_LENGTH];
// Parcours des blocs réservés pour la description des fichiers
for (int blockNum = 0; blockNum <= MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, MAX_FILENAME_LENGTH);
// Vérifier si le bloc est vide (pas de nom de fichier)
if (buffer[0] == 0) {
// Écrire le nom du fichier dans l'emplacement vide du superbloc
writeBlock(blockNum, 0, (const unsigned char *)filename, MAX_FILENAME_LENGTH);
break; // Fichier créé, sortir de la boucle
}
}
printf("Le fichier \"%s\" a été créé avec succès.\n", filename);
}

ReX : Si la boucle se termine sans trouver de slot libre le message de succès s'affiche tout de même.

ReX : Le paramètre <code>filename</code> n'a pas forcément une taille de <code>MAX_FILENAME_LENGTH</code>.

Selon moi, la fonction TYPE devra respecter 3 étapes:

# Enregistrement du Nom du Fichier: L'ajout du nom du fichier dans un des blocs de la première partie du superbloc.
# Stockage des Données du Fichier: La récupération des données saisies en entrée standard par l'utilisateur et leur stockage dans des blocs du système de fichiers à partir d'une certaine position, comme le bloc 1040.
# Mise à Jour de la Disponibilité des Blocs: L'indication que les blocs dans lesquels les données ont été écrites ne sont plus disponibles en modifiant les bits correspondants dans la deuxième partie du superbloc (les 16 derniers blocs du super bloc).

ReX : Relis le point 3 et dit moi si tu te comprends toi même ?

Amine: Ma phrase n'est effectivement pas très claire. Je voulais dire que la fonction TYPE devra mettre à jour la carte de disponibilité du superbloc. C'est à dire que lorsqu'elle écrira des données dans des blocs, elle devra indiquer dans la carte de disponibilités que ces blocs ne sont plus disponibles.

=== Fonction intermédiaire TYPE version 2 ===

Suite à vos remarques, j'ai apporté les modifications suivantes à la fonction TYPE:

* j'ai ajouté une condition pour l'affichage du message de succès de la création d'un fichier (placeFound).

* le paramètre <code>filename</code> n'ayant pas forcément une taille de <code>MAX_FILENAME_LENGTH</code>, je calcule maintenant la longueur de filename, afin d'écrire seulement le nom du fichier avec la fonction writeBlock.

Il fonction n'est bien évidemment pas fini, elle ajoute seulement le nom du fichier dans le superbloc pour l'instant. Cela me permet de tester les fonctions LS et RM.
void TYPE(const char *filesystem_path, const char *filename) {
size_t sizeFilename = strlen(filename);
printf("size filename=%d\n", sizeFilename);
unsigned char buffer[MAX_FILENAME_LENGTH];
int placeFound = 0;

if (sizeFilename > MAX_FILENAME_LENGTH) {
printf("Impossible de créer le fichier, nom trop long\n");
return;
}

// Parcours des blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, MAX_FILENAME_LENGTH);
// Vérifier si le bloc est vide (pas de nom de fichier)
if (buffer[0] == 0) {
// Écrire le nom du fichier dans l'emplacement vide du superbloc
if (sizeFilename < MAX_FILENAME_LENGTH) {
sizeFilename+=1;
}
writeBlock(blockNum, 0, (const unsigned char *)filename, sizeFilename);
placeFound = 1;
break; // Fichier créé, sortir de la boucle
}
}
if (placeFound == 1) {
printf("Le fichier \"%s\" a été créé avec succès.\n", filename);
} else {
printf("Plus de place dans le système de fichier pour créer ce fichier.\n", filename);
}
}

ReX : Mieux, attention il faut copier aussi le <code>\'0</code> final du nom, donc <code>sizeFilename+1</code>. Sinon tu n'es pas sûr qu'il y ait un zéro final. Et attention n°2, il ne faut pas copier ce <code>\'0</code> si le nom fait la taille maximale.

Amine: ok j'ai modifié la fonction TYPE ci-dessus. J'ai ajouté une condition: si le nom du fichier est inférieur à la taille maximale de nom de fichier, alors on incrémente de 1 la taille du nom de fichier. Cela nous permet d'écrire le '\0' dans le bloc de description. Dans le cas où le nom du fichier est de la taille maximale, nous n'avons pas besoin d'écrire le '\0', on n'incrémente donc pas la taille de 1.

J'ai également ajouté une condition: si le nom du fichier est supérieur à la taille maximale, alors un message d'erreur s'affiche et le fichier n'est pas créé.

ReX : OK. L'embryon de fonction <code>TYPE</code> est correct, il manque juste le principal : la création des blocs de données.

=== Fonction MV version 1 ===

J'ai ici créé la fonction MV qui permet de changer le nom d'un fichier. Pour ce faire, la fonction parcourt les blocs de descriptions à la recherche du fichier dont on veut changer le nom. Lorsque ce fichier est trouvé, on supprime l'ancien nom en mettant des 0 sur 16 octets, puis on vient réécrire le nouveau nom dans le même emplacement. Enfin, on sort de la boucle et on affiche le succès ou non de l'opération.
// Fonction qui modifie le nom du fichier
void MV(const char *filesystem_path, const char *old_filename, const char *new_filename) {
size_t sizeNew_filename = strlen(new_filename);
size_t sizeOld_filename = strlen(old_filename);
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
int fileFound = 0;
// Parcourir les blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);
// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char*)filenameBuffer, old_filename, MAX_FILENAME_LENGTH) == 0) {
// Effacer le nom du fichier dans le superbloc
memset(filenameBuffer, 0, MAX_FILENAME_LENGTH);
writeBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);
// Écrire le nom du fichier dans l'emplacement
writeBlock(blockNum, 0, (const unsigned char *)new_filename, sizeNew_filename);
fileFound=1;
break; // Nom modifié, sortir de la boucle
}
}
if (fileFound == 1) {
printf("Le nom du fichier \"%s\" a été renommé avec succès.\n", old_filename);
} else {
printf("Le fichier \"%s\" n'a pas été trouvé.\n", old_filename);
}
}

ReX : Inutile d'écraser l'ancien nom avec des zéros. Il suffit de copier le nouveau en s'assurant qu'il y ait un zéro final sauf si le nouveau nom fait la taille maximale.

Amine: ok, je vais faire les modifications dans la version 2.

== Semaine 6 ==

=== Fonction MV version 2 ===
Dans cette nouvelle version de la fonction MV, j'ai effectué les modifications suivantes:

* je n'écrase plus l'ancien nom avec des 0
* Je colle simplement le nouveau nom par dessus l'ancien, en m'assurant qu'il y ait bien le '\0' à la fin lorsque la taille du nom du fichier est inférieur à la taille maximale. Comme précédemment, afin de m'assurer de la présence de ce '\0' à la fin du nom, j'incrémente la taille de 1 lorsque qu'elle est inférieur à la taille max. Cependant, je ne suis pas sûr à 100% que ce soit la bonne manière de faire.

// Fonction qui modifie le nom du fichier
void MV(const char *filesystem_path, const char *old_filename, const char *new_filename) {
size_t sizeNew_filename = strlen(new_filename);
size_t sizeOld_filename = strlen(old_filename);
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
int fileFound = 0;

// Parcourir les blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {

readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char*)filenameBuffer, old_filename, MAX_FILENAME_LENGTH) == 0) {

if (sizeNew_filename < MAX_FILENAME_LENGTH) {
sizeNew_filename+=1;
}

// Écrire le nom du fichier dans l'emplacement
writeBlock(blockNum, 0, (const unsigned char *)new_filename, sizeNew_filename);

fileFound=1;

break; // Nom modifié, sortir de la boucle
}
}
if (fileFound == 1) {
printf("Le nom du fichier \"%s\" a été renommé avec succès.\n", old_filename);
} else {
printf("Le fichier \"%s\" n'a pas été trouvé.\n", old_filename);
}
}

ReX : C'est bon. La fonction était triviale.

=== Fonction TYPE version 1 ===
void TYPE(const char *filesystem_path, const char *filename) {
size_t sizeFilename = strlen(filename);
unsigned char buffer[MAX_FILENAME_LENGTH];
int placeFound = -1;

if (sizeFilename > MAX_FILENAME_LENGTH) {
printf("Impossible de créer le fichier, nom trop long\n");
return;
}

// Parcours des blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, MAX_FILENAME_LENGTH);
// Vérifier si le bloc est vide (pas de nom de fichier)
if (buffer[0] == 0) {
// Écrire le nom du fichier dans l'emplacement vide du superbloc
if (sizeFilename < MAX_FILENAME_LENGTH) {
sizeFilename += 1; // Ajouter '\0' s'il y a de la place
}
writeBlock(blockNum, 0, (const unsigned char *)filename, sizeFilename);
placeFound = blockNum;

// Lire les données depuis l'entrée standard
unsigned char dataBuffer[BLOCK_SIZE];
size_t bytesRead;
int dataBlockNum = findAvailableBlock(); // Premier bloc de données à partir du bloc 1040
printf("dataBlockNum%d\n",dataBlockNum);
int blockSizeUsed = 0; // Compteur d'octets dans le bloc actuel
int dataBlocksNeeded = 1; // Nombre de blocs de données nécessaires

while ((bytesRead = fread(dataBuffer + blockSizeUsed, 1, BLOCK_SIZE - blockSizeUsed, stdin)) > 0) {
blockSizeUsed += bytesRead;

// Si le bloc actuel est plein, passer au bloc suivant
if (blockSizeUsed == BLOCK_SIZE) {
// printf("dataBlockNum=%d\n",dataBlockNum);
writeBlock(dataBlockNum, 0, dataBuffer, BLOCK_SIZE);
setBlockAvailability(dataBlockNum, 1);

dataBlockNum++; // Passer au bloc suivant
blockSizeUsed = 0; // Réinitialiser la taille utilisée
dataBlocksNeeded++;
}
}

// Écrire le dernier bloc partiel, s'il y en a un
if (blockSizeUsed > 0) {
writeBlock(dataBlockNum, 0, dataBuffer, blockSizeUsed);
setBlockAvailability(dataBlockNum, 1);
}

// Écrire les numéros de blocs utilisés dans le bloc de description
unsigned char blockNumberBuffer[2];
int currentBlockNum = 1040;

for (int i = 0; i < dataBlocksNeeded; i++) {
blockNumberBuffer[0] = (currentBlockNum >> 8) & 0xFF;
blockNumberBuffer[1] = currentBlockNum & 0xFF;
writeBlock(placeFound, MAX_FILENAME_LENGTH + i * 2, blockNumberBuffer, 2);
currentBlockNum++;
}

break; // Fichier créé, sortir de la boucle
}
}

if (placeFound != -1) {
printf("Le fichier \"%s\" a été créé avec succès.\n", filename);
} else {
printf("Plus de place dans le système de fichier pour créer ce fichier.\n");
}
}

ReX : La constante 1040 ne doit pas apparaître en numérique, ce doit être une constante calculée à partir des autres constantes.

Amine: Ok. Je ne l'avais pas défini comme une constante car il s'agit dans la fonction ci-dessus d'une variable qui est incrémenté à chaque itération.

ReX : Je suis las de te répéter que le mémoire est comptée : tu utilises encore un bloc de <code>BLOCK_SIZE</code> octets, c'est trop.

Amine: Comment utiliser des blocs plus petit sachant qu'il s'agit là de blocs de données et qu'un bloc fait 256 octets d'après l'énoncé ? Dois-je les subdiviser en plusieurs blocs plus petit comme fait dans la fonction RM, en 4 blocs de 64 octets par exemple ?

Fonctionnement de la fonction TYPE:

* étape 1: on parcourt les blocs de descriptions à la recherche d'un bloc disponible. Si on ne trouve pas de bloc disponible, on renvoie un message d'erreur, sinon on passe à l'étape suivante.
* étape 2: Si on trouve un emplacement libre dans les blocs de disponibilité, on écrit le nom du fichier dans cet emplacement.

ReX : Dans les blocs de description de fichiers pas dans les blocs de disponibilité.

Amine: Oui autant pour moi.

* étape 3: Ensuite, on lit le texte entré par l'utilisateur en entrée standard, on le répartit dans des blocs de taille BLOCK_SIZE, on met à jour la disponibilité des blocs utilisés.

ReX : Non, il faut appeler <code>findAvailableBlock</code> pour chaque bloc de données à utiliser, aucune certitudes que les blocs libres soient en séquence.

Amine: ok, je ferai cela dans la version 2

* étape 4: Enfin, on écrit les numéros des blocs de données utilisés dans les blocs de description de ce fichier, les numéros étant écris sur deux octets.

ReX : Non cela doit se faire au fur et à mesure des appels à <code>findAvailableBlock</code> et les numéros des blocs de données peuvent s'étaler sur les 16 blocs de description du fichier. Confusion totale sur ce point. Vous n'avez pas compris le mécanisme.

Amine: je corrige cela dans la version 2. J'ai bien compris le mécanisme mais ce n'est pas facile à traduire en code.

=== Fonction TYPE version 2 ===
Dans cette nouvelle version de TYPE, j'ai fait les modifications suivantes:

* j'appelle maintenant <code>findAvailableBlock</code> pour chaque bloc de données à utiliser
* j'écris maintenant les numéros de blocs au fur et à mesures des appels à <code>findAvailableBlock</code>
* je n'utilise plus de tableaux de taille 256 octets mais des tableaux de tailles CHUNK_SIZE. J'ai choisi ici CHUNK_SIZE = 64 octets.

J'utilise toujours un bloc de taille BLOCK_SIZE en attendant de comprendre si je dois diviser ce bloc en plusieurs blocs de taille plus petite ou s'il y a un moyen de ne pas du tout utiliser ces blocs.
void TYPE(const char *filesystem_path, const char *filename) {
size_t sizeFilename = strlen(filename);
unsigned char buffer[MAX_FILENAME_LENGTH];
int placeFound = -1;

if (sizeFilename > MAX_FILENAME_LENGTH) {
printf("Impossible de créer le fichier, nom trop long\n");
return;
}

// Parcours des blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, MAX_FILENAME_LENGTH);
// Vérifier si le bloc est vide (pas de nom de fichier)
if (buffer[0] == 0) {
// Écrire le nom du fichier dans l'emplacement vide du superbloc
if (sizeFilename < MAX_FILENAME_LENGTH) {
sizeFilename += 1; // Ajouter '\0' s'il y a de la place
}
writeBlock(blockNum, 0, (const unsigned char *)filename, sizeFilename);
placeFound = blockNum;

// Lire les données depuis l'entrée standard et écrire dans le fichier
int dataBlockNum = findAvailableBlock(); // Premier bloc de données à partir du bloc 1040
printf("Premier bloc dans lequel on écrit = %d\n", dataBlockNum);
int blockSizeUsed = 0; // Compteur d'octets dans le bloc actuel

unsigned char chunkBuffer[CHUNK_SIZE];
size_t bytesRead;

while ((bytesRead = fread(chunkBuffer, 1, CHUNK_SIZE, stdin)) > 0) {
// Écrire le chunk dans le bloc de données
writeBlock(dataBlockNum, blockSizeUsed, chunkBuffer, bytesRead);
setBlockAvailability(dataBlockNum, 1);

// Écrire le numéro du bloc actuel dans la description du fichier
unsigned char blockNumberBuffer[2];
blockNumberBuffer[0] = (dataBlockNum >> 8) & 0xFF;
blockNumberBuffer[1] = dataBlockNum & 0xFF;
writeBlock(placeFound, MAX_FILENAME_LENGTH + dataBlockNum * 2, blockNumberBuffer, 2);

blockSizeUsed += bytesRead;

// Si le bloc actuel est plein, passer au bloc suivant
if (blockSizeUsed == BLOCK_SIZE) {
dataBlockNum = findAvailableBlock(); // Passer au bloc suivant
blockSizeUsed = 0; // Réinitialiser la taille utilisée
}
}

break; // Fichier créé, sortir de la boucle
}
}

if (placeFound != -1) {
printf("Le fichier \"%s\" a été créé avec succès.\n", filename);
} else {
printf("Plus de place dans le système de fichier pour créer ce fichier.\n");
}
}

=== Fonction findAvailableBlock ===
Cette fonction renvoie l'indice du premier bloc disponible. Je me sers de cette fonction dans la fonction TYPE.
#define FIRST_DATA_BLOCK 1040
#define FIRST_DISPONIBILITY_CARD_BLOCK 1024

// Renvoie le premier bloc de donné disponible
int findAvailableBlock() {
unsigned char availabilityBuffer[BLOCK_SIZE];
int offset;

// Lire la carte de disponibilité (à partir du bloc 1)
for (int blockNum = FIRST_DISPONIBILITY_CARD_BLOCK; blockNum < FIRST_DATA_BLOCK; blockNum++) {
readBlock(blockNum, 0, availabilityBuffer, BLOCK_SIZE);

if (blockNum==FIRST_DISPONIBILITY_CARD_BLOCK) {
offset=FIRST_DATA_BLOCK/8;
} else {
offset=0;
}

// Parcourir les octets de la carte de disponibilité
for (int byteIndex = offset; byteIndex < BLOCK_SIZE - offset; byteIndex++) {
unsigned char byte = availabilityBuffer[byteIndex];

// Parcourir les bits de chaque octet
for (int bitIndex = 0; bitIndex < 8; bitIndex++) {
// Vérifier si le bit est à 0 (bloc disponible)
if ((byte & (1 << bitIndex)) == 0) {
// Calculer l'indice du bloc en fonction du bloc et du bit
int blockIndex = byteIndex * 8 + bitIndex;
return blockIndex;
}
}
}
}

// Aucun bloc disponible trouvé
return -1;
}

ReX : Même remarque que précédement sur les nombres 1024 et 1040.

Amine: Ok, j'ai remplacé 1024 par la constante FIRST_DISPONIBILITY_CARD_BLOCK et 1040 par la constante FIRST_DATA_BLOCK dans la fonction ci-dessus.

ReX : Vous n'avez toujours pas compris la contrainte sur la mémoire.

Amine: dois-je découper le bloc de taille BLOCK_SIZE en quatre blocs de taille 64 octets par exemple ?

ReX : Je ne vois pas ce que vous voulez faire avec <code>if (blockNum==1024) offset=1040/8; else offset=0;</code>.

Amine: dans la carte de disponibilité, chaque bit correspond à un bloc. Ainsi, les bits de 0 à 1040 dans la carte de disponibilité décrivent la disponibilité des blocs 0 à 1040. Or ces blocs correspondent au superbloc, et dans cette fonction, on veut connaître le premier bloc de données disponible. On ne s'intéresse donc pas au 1040 premiers bits de la carte de disponibilité. Je crée donc un offset égal à 1040/8 afin de ne pas prendre en compte les 1040 premiers bits soit les 1040/8=130 premiers octets. Cet offset ne s'applique que lorsqu'on se trouve dans le premier des 16 blocs de la carte de disponibilité, d'où la condition <code>if (blockNum==1024)</code>.

ReX : OK, bien vu.

=== Fonction CAT version 1 ===
void CAT(const char *filesystem_path, const char *filename) {
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
unsigned char buffer[BLOCK_SIZE];
unsigned char blockNumberBuffer[2];
unsigned char dataBuffer[BLOCK_SIZE];
int offset;

// Parcours des blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char *)filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {
// Le nom du fichier a été trouvé

// Parcours les blocs de description
for (int descrBlockNum=0; descrBlockNum<MAX_BLOCKS_PER_FILE_DESCRIPTION; descrBlockNum++) {
if (descrBlockNum==0) {
offset=16;
} else {
offset=0;
}
readBlock(descrBlockNum+blockNum, offset, buffer, BLOCK_SIZE-offset);

// Lire les numéros de blocs associés à ce fichier depuis les blocs de description
unsigned char octet1 = buffer[offset];
unsigned char octet2 = buffer[offset+1];

int dataBlockNum = (octet1 << 8) | octet2;
printf("dataBlockNum=%d\n",dataBlockNum);

// Vérifier si le numéro de bloc est valide (non nul)
if (dataBlockNum == 0) {
return; // Fin du fichier
}

// Lire et afficher le contenu du bloc de données
readBlock(dataBlockNum, 0, dataBuffer, BLOCK_SIZE);
fwrite(dataBuffer, 1, BLOCK_SIZE, stdout);
}

return; // Fichier affiché, sortie de la fonction
}
}

// Si le fichier n'a pas été trouvé
printf("Le fichier \"%s\" n'a pas été trouvé.\n", filename);
}

ReX : Encore mieux : deux blocs de <code>BLOCK_SIZE</code> en mémoire.

ReX : Le <code>break</code> ne sort pas de la boucle externe.

Amine: Oui c'est vrai. J'ai remplacé le <code>break</code> par un <code>return</code> ci-dessus.

ReX : Dans le cadre de la fonction CAT le <code>return</code> est convenable.

Voici ma fonction <code>CAT</code>. Elle fonctionne en plusieurs étape:

* étape 1: on cherche dans les blocs de descriptions si le fichier dont on veut afficher le contenu existe. Si le nom de fichier est trouvé, on passe à l'étape 2. Sinon, on renvoie un message d'erreur.
* étape 2: si le fichier est trouvé, on parcours les 16 blocs de description de ce fichier.
* étape 3: grâce aux opérations de masquage et de décalage, on joint les octets deux par deux pour former un entier qui contient le numéro du bloc de données correspondant au fichier. Si cet entier vaut 0, alors cela signifie qu'il n'y a plus de blocs associé à ce fichier, on peut donc quitter la fonction. Si cet entier est différent de 0, alors on va lire le bloc correspondant à ce numéro et on affiche son contenu dans le terminal.

== Semaine 7 ==

=== Fonction CP version 1 ===
Voici ma fonction CP, qui permet de créer une copie d'un fichier existant. L'idée est la suivante: pour copier un fichier, on doit créer un nouveau fichier et lui attribuer les mêmes blocs de descriptions que le fichier source. Ainsi, le fichier source et le fichier destination pointeront vers les mêmes blocs de données, et auront le même contenu.

ReX : Perdu. Ce n'est absolument pas la fonction de copie de fichiers d'un système de fichiers.

Amine: Après avoir fait des recherches et après réflexion, je me rends compte que cette fonction CP présente un problème: en faisant pointer les blocs de données du fichier destination vers ceux du fichier source, toute modification du fichier source impactera le fichier destination, or ce n'est pas ce qu'on veut faire. Je vous propose donc une nouvelle version de la fonction CP ci-dessous qui remédie à ce problème.

void CP(const char *filesystem_path, const char *source_filename, const char *destination_filename) {
unsigned char source_filenameBuffer[MAX_FILENAME_LENGTH];
unsigned char destination_filenameBuffer[MAX_FILENAME_LENGTH];
unsigned char descriptionBuffer[BLOCK_SIZE];
int destination_offset;
int offset;

// Recherche du fichier source
int source_offset = -1;
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, source_filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier source
if (strncmp((const char *)source_filenameBuffer, source_filename, MAX_FILENAME_LENGTH) == 0) {
source_offset = blockNum;
break;
}
}

if (source_offset == -1) {
printf("Le fichier source \"%s\" n'a pas été trouvé.\n", source_filename);
return;
}

// Recherche d'un emplacement libre pour le fichier destination
destination_offset = -1;
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, destination_filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc est vide (pas de nom de fichier)
if (destination_filenameBuffer[0] == 0) {
destination_offset = blockNum;
break;
}
}

if (destination_offset == -1) {
printf("Plus de place dans le système de fichier pour créer la copie de \"%s\".\n", source_filename);
return;
}

// Ecrit le nom de la copie dans le bloc de description
writeBlock(destination_offset, 0, (const unsigned char *)destination_filename, strlen(destination_filename));

// Copier les blocs de description associés au fichier source dans les blocs de description du fichier destination
for (int i = 0; i < MAX_BLOCKS_PER_FILE_DESCRIPTION; i++) {
if (i==0) {
offset = MAX_FILENAME_LENGTH;
} else {
offset = 0;
}

readBlock(source_offset+i, offset, descriptionBuffer, BLOCK_SIZE-offset);
if (descriptionBuffer[offset]==0) {
return;
} else {
writeBlock(destination_offset+i, offset, descriptionBuffer, BLOCK_SIZE-offset);
}
}

printf("La copie de \"%s\" sous le nom \"%s\" a été créée avec succès.\n", source_filename, destination_filename);
}

ReX : Pas mieux.

== Semaine 8 ==
A ce stade du projet, les fonctions suivantes ont été validé par Monsieur Redon:

* fonction LS
* fonction RM
* fonction MV

Il reste donc les fonctions suivantes à terminer:

* fonction CAT
* fonction CP
* fonction TYPE

=== Fonction CAT version 2 ===
Suite à vos remarques sur la version 1, j'ai fais les modifications suivantes:

* je n'utilise non plus 2 tableaux de taille BLOCK_SIZE, mais 1 seul. Idéalement il faudrait en utiliser 0, je réfléchi donc à m’émanciper de ce tableau en le remplaçant par plusieurs plus petits tableaux.

ReX : Un seul plus petit.

* J'ai remplacé le <code>break</code> par un <code>return</code>

ReX : Déjà validé.

Cette fonction permet d'afficher le contenu d'un fichier créé avec la fonction TYPE. Pour se faire, on parcours tout d'abord les blocs de descriptions pour trouver le fichier dont ont veut afficher le contenu. Une fois ce fichier trouvé, on parcours les 16 blocs de description de ce fichier 1 à 1. Pour chacun de ces blocs de description, on va stocker récupéré les octets deux par deux afin de former des entiers. Pour se faire, on utilise la fonction <code>reconstituteNumber</code> que l'on détaillera juste après. Ces entiers correspondent aux blocs dans lesquels la donné du fichier se trouve. Une fois l'entier reconstitué, on affiche le contenu du bloc correspondant.
#define CHUNK_SIZE 64

void CAT(const char *filesystem_path, const char *filename) {
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
unsigned char byteBuffer[2];
unsigned char dataBuffer[CHUNK_SIZE];
int offset;

// Parcours des blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char *)filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {
// Le nom du fichier a été trouvé

// Parcours les blocs de description
for (int descrBlockNum=0; descrBlockNum<MAX_BLOCKS_PER_FILE_DESCRIPTION; descrBlockNum++) {
if (descrBlockNum==0) {
offset=MAX_FILENAME_LENGTH;
} else {
offset=0;
}

// Lecture des octets deux par deux
for (int i=0; i<BLOCK_SIZE;i+=2) {
readBlock(descrBlockNum+blockNum, offset+i, byteBuffer, 2);

// Lire les numéros de blocs associés à ce fichier depuis les blocs de description
int dataBlockNum = reconstituteNumber(byteBuffer);

// Vérifier si le numéro de bloc est valide (non nul)
if (dataBlockNum == 0) {
return; // Fin du fichier
}

for (int chunkStart = 0; chunkStart < BLOCK_SIZE; chunkStart += CHUNK_SIZE) {
// Lire et afficher le contenu du bloc de données
readBlock(dataBlockNum, chunkStart, dataBuffer, CHUNK_SIZE);
fwrite(dataBuffer, 1, CHUNK_SIZE, stdout);
}
}
}

return; // Fichier affiché, sortie de la fonction
}
}

// Si le fichier n'a pas été trouvé
printf("Le fichier \"%s\" n'a pas été trouvé.\n", filename);
}

ReX : Remplacer le premier bloc de <code>BLOCK_SIZE</code> octets par un bloc de 2 octets est exagéré mais cela pourrait passer. Il reste toujours un bloc de <code>BLOCK_SIZE</code> octets dont il est facile de se passer au bénéfice d'un bloc de, mettons, 64 octets.

Amine: Voilà! Dans la version ci-dessus j'ai remplacé le bloc de taille <code>BLOC_SIZE</code> par un bloc de taille <code>CHUNK_SIZE</code>, avec <code>CHUNK_SIZE</code> modifiable dans les constantes du programme. J'ai pris ici 64 octets.

ReX : OK.

=== Fonction reconstituteNumber ===
Cette fonction permet de reconstituer un numéro de bloc à partir de deux octets.
// Fonction qui reconstitue le numéro de bloc à partir du tableau
int reconstituteNumber(unsigned char blockNumberBuffer[2]) {
unsigned char octet1 = blockNumberBuffer[0];
unsigned char octet2 = blockNumberBuffer[1];
int dataBlockNum = (octet1 << 8) | octet2;
return dataBlockNum;
}

ReX : Bonne idée cette fonction.

=== Fonction CP version 2 ===
Voici une version mise à jour de notre fonction CP. Dans la version précédente, on faisait pointer le fichier source vers les même blocs que le fichier destination. Cela posait un problème: toute modification du fichier source impactait le fichier destination. Ainsi, dans cette nouvelle version, on fait une duplication des blocs de données du fichier source vers le fichier destination. Cela implique donc une mise à jour de la carte de disponibilité, ainsi que l'adaptation des blocs de descriptions. En effet, seulement les blocs de données sont maintenant identiques, plus les blocs de description.

Piste d'amélioration: comme pour la fonction CAT ci-dessus, j'utilise toujours un bloc de taille 256 octets, je vais devoir y remédier.
// Fonction pour copier un fichier existant du système de fichier
void CP(const char *filesystem_path, const char *source_filename, const char *destination_filename) {
unsigned char source_filenameBuffer[MAX_FILENAME_LENGTH];
unsigned char destination_filenameBuffer[MAX_FILENAME_LENGTH];
unsigned char descriptionBuffer[CHUNK_SIZE];
unsigned char numBuffer[2];
int destination_offset;
int source_offset;
int offset;
int numDataBlock;
int newDataBlock;

// Recherche du fichier source
source_offset = -1;
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, source_filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier source
if (strncmp((const char *)source_filenameBuffer, source_filename, MAX_FILENAME_LENGTH) == 0) {
source_offset = blockNum;
break;
}
}

if (source_offset == -1) {
printf("Le fichier source \"%s\" n'a pas été trouvé.\n", source_filename);
return;
}

// Recherche d'un emplacement libre pour le fichier destination
destination_offset = -1;
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, destination_filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc est vide (pas de nom de fichier)
if (destination_filenameBuffer[0] == 0) {
destination_offset = blockNum;
break;
}
}

if (destination_offset == -1) {
printf("Plus de place dans le système de fichier pour créer la copie de \"%s\".\n", source_filename);
return;
}

// Copie du nom de la copie dans le bloc de description
writeBlock(destination_offset, 0, (const unsigned char *)destination_filename, strlen(destination_filename));

// Copier les blocs de données associés au fichier source dans de nouveaux blocs de données pour le fichier destination
for (int i = 0; i < MAX_BLOCKS_PER_FILE_DESCRIPTION; i++) {
if (i == 0) { offset = MAX_FILENAME_LENGTH; }
else { offset = 0; }

// Lecture des numéros de bloc dans les blocs de description
for (int byteNum=0; byteNum<BLOCK_SIZE; byteNum+=2) {
readBlock(source_offset+i, offset+byteNum, numBuffer, 2);

numDataBlock = reconstituteNumber(numBuffer);
if (numDataBlock == 0) {
printf("La copie de \"%s\" sous le nom \"%s\" a été créée avec succès.\n", source_filename, destination_filename);
return;
}

for (int chunkStart = 0; chunkStart < BLOCK_SIZE; chunkStart += CHUNK_SIZE) {
// On stocke le bloc de données associé au fichier source dans descriptionBuffer
readBlock(numDataBlock, chunkStart, descriptionBuffer, CHUNK_SIZE);

if (chunkStart == 0) {
// Trouver un nouveau bloc de données disponible
newDataBlock = findAvailableBlock();

// Mise à jour de la carte de disponibilités
setBlockAvailability(newDataBlock, 1);

// Ecriture du numéro de bloc dans la description du fichier
createNumberBuffer(newDataBlock,numBuffer);
writeBlock(destination_offset+i, offset+byteNum, numBuffer, 2);
}

// Ecriture du bloc de données dans le premier bloc disponible
writeBlock(newDataBlock, chunkStart, descriptionBuffer, CHUNK_SIZE);
}
}
}
}

ReX : Youpi. Il reste à se passer du bloc de <code>BLOCK_SIZE</code> (au bénéfice d'un bloc de taille <code>BLOCK_SIZE/n</code> avec n>1). Ecrire la fonction inverse de <code>reconsituteNumber</code>.

Amine: Voilà! Dans le fonction ci-dessus il n'y a plus de bloc de taille <code>BLOCK_SIZE</code>, on a maintenant des blocs de 64 octets (<code>CHUNK_SIZE</code>). J'ai également créé la fonction <code>createNumberBuffer</code> qui est la fonction inverse de<code>reconstituteNumber</code>. Je la détaille ci-dessous.

ReX : OK.

=== Fonction createNumberBuffer ===
Cette fonction permet repartir un entier sur deux octets.
// Fonction qui réparti un numéro de bloc sur deux octets
void createNumberBuffer(int dataBlockNum, unsigned char blockNumberBuffer[2]) {
blockNumberBuffer[0] = (dataBlockNum >> 8) & 0xFF;
blockNumberBuffer[1] = dataBlockNum & 0xFF;
}

=== Fonction TYPE version 3 ===
La fonction 2 que j'ai fourni ci-dessus n'est pas correcte. Je vais la corriger dans cette version 3.

ReX : Effectivement la version précédente ne gére pas correctement l'écriture des numéros de blocs de données dans la description d'un fichier.

Voici ma version 3 de la fonction TYPE. Voici son fonctionnement:

* tout d'abord, la fonction parcourt les blocs de description à la recherche d'un emplacement vide ;
* une fois l'emplacement vide trouvé, elle écrit le nom du fichier dans cet emplacement ;
* ensuite, on passe à la lecture de l'entrée standard. J'ai essayé d'expliquer au fur et à mesure du programme ce que font les lignes importantes via les commentaires.
void TYPE(const char *filesystem_path, const char *filename) {
size_t sizeFilename = strlen(filename);
unsigned char buffer[MAX_FILENAME_LENGTH];
int placeFound = -1;
int index_description_block = 0; // indice du bloc de descrption
int block_counter = 0; //compteur de blocs utilisés
int index_in_descrBlock = 0;
int offset;
int first_loop=1;

if (sizeFilename > MAX_FILENAME_LENGTH) {
printf("Impossible de créer le fichier, nom trop long\n");
return;
}

// Parcours des blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, MAX_FILENAME_LENGTH);
// Vérifier si le bloc est vide (pas de nom de fichier)
if (buffer[0] == 0) {
// Écrire le nom du fichier dans l'emplacement vide du superbloc
if (sizeFilename < MAX_FILENAME_LENGTH) {
sizeFilename += 1; // Ajouter '\0' s'il y a de la place
}
writeBlock(blockNum, 0, (const unsigned char *)filename, sizeFilename);
placeFound = blockNum;

// Lire les données depuis l'entrée standard et écrire dans le fichier
int dataBlockNum = findAvailableBlock(); // Premier bloc de données à partir du bloc 1040
int blockSizeUsed = 0; // Compteur d'octets dans le bloc actuel

unsigned char chunkBuffer[CHUNK_SIZE];
size_t bytesRead;

while ((bytesRead = fread(chunkBuffer, 1, CHUNK_SIZE, stdin)) > 0) {

// Écrire le chunk dans le bloc de données
writeBlock(dataBlockNum, blockSizeUsed, chunkBuffer, bytesRead);

// Écrire le numéro du bloc actuel dans la description du fichier
unsigned char blockNumberBuffer[2];
createNumberBuffer(dataBlockNum,blockNumberBuffer);

blockSizeUsed += bytesRead;

// Si le bloc actuel est plein, passer au bloc suivant OU si c'est le premier tour dans la boucle
if (blockSizeUsed >= BLOCK_SIZE || first_loop == 1) {

// Mise à jour de la disponibilité du bloc
setBlockAvailability(dataBlockNum, 1);

first_loop = 0;

// Ecriture du numéro de bloc utilisé dans les blocs de description
if (index_description_block == 0) {
offset = MAX_FILENAME_LENGTH;
} else {
offset = 0;
}
// Ecriture du numéro de bloc dans le bloc de description
writeBlock(placeFound + index_description_block, offset + index_in_descrBlock*2, blockNumberBuffer, 2);
index_in_descrBlock++;

dataBlockNum = findAvailableBlock(); // Passer au bloc suivant
blockSizeUsed = 0; // Réinitialiser la taille utilisée

// Passage au bloc de description suivant
if (block_counter == (BLOCK_SIZE/2-offset)) {
index_description_block++;
index_in_descrBlock=0;
}

// Compteur de nombre de blocs utilisés
block_counter++;

// Vérifie si on a atteint le nombre maximal de blocs par fichier
if (block_counter >= MAX_BLOCKS_PER_FILE) {
printf("Le fichier a atteint sa taille maximale\n");
return;
}
}
}

break; // Fichier créé, sortir de la boucle
}
}

if (placeFound != -1) {
printf("Le fichier \"%s\" a été créé avec succès.\n", filename);
} else {
printf("Plus de place dans le système de fichier pour créer ce fichier.\n");
}
}

ReX : La fonction <code>setBlockAvailability</code> n'est pas placée au bon endroit, elle est parfois appelée inutilement.

Amine: Effectivement, on peut ne l'appeler que lorsqu'un bloc a été complètement rempli donc après la condition

ReX : La variable <code>blockSizeUsed</code> peut dépasser <code>BLOCK_SIZE</code> et cela donnera n'importe quoi.

Amine: C'est vrai, je vais donc remplacer la condition if <code>(blockSizeUsed == BLOCK_SIZE || first_loop == 1)</code> en <code>if (blockSizeUsed >= BLOCK_SIZE || first_loop == 1)</code>afin que la variable ne puisse pas dépasser <code>BLOCK_SIZE</code>.

ReX : Si tu écris ton premier "chunk" de données tu ne remplis pas le bloc de données et tu en réclames un suivant.

Amine: correction pas encore apportée

ReX : Pourquoi <code>block_counter</code> est initialisé à 1 ?

Amine: Autant pour moi, il faut initialiser <code>block_counter</code> à 0. Je l'avais initialisé à 1 car initialement dans mon programme nous n'entrions dans la condition que si un bloc était plein, mais j'ai ensuite modifié la condition en oubliant de modifier l'initialisation de la variable.

= Compilation et exécution =
'''Création du système de fichiers :'''
dd if=/dev/zero of=filesystem.bin bs=256 count=32768

'''Compilation :'''

gcc picofs.c -o picofs

'''Exécution de LS, TYPE, CAT, RM, MV ou CP :'''

./picofs filesystem.bin LS
./picofs filesystem.bin TYPE mon_fichier.txt
./picofs filesystem.bin CAT mon_fichier.txt
./picofs filesystem.bin RM mon_fichier.txt
./picofs filesystem.bin MV mon_fichier.txt mon_fichier2.txt
./picofs filesystem.bin CP mon_fichier.txt mon_fichier2.txt

= Documents Rendus =
[[Fichier:PicofsV2.c.tar|vignette]]

SE4 2022/2023 EC1

2023-09-06T03:15:55Z

Asellali : /* Fonction TYPE version 3 */

= Objectifs =

Il vous est demandé de :
* réaliser un micro système de fichiers ;
* le système de fichiers doit résider dans un fichier de 8 Mo ;
* le système de fichiers est géré par un exécutable obtenu à partir d'un programme C ;
* L'éxécutable prend deux arguments, le premier est le chemin du fichier dans lequel réside le système de fichiers, les paramètres suivants concernent l'action à appliquer sur le système de fichiers ;
* le micro système de fichier ne comporte qu'un répertoire : le répertoire principal, le répertoire principal peut comporter au maximum 64 fichiers, un fichier est caractérisé par un nom de 16 caractères au maximum et ses blocs de données, un fichier peut comporter au maximum 2040 blocs de données ;
* un bloc de données fait 256 octets et les blocs sont numérotés sur 2 octets ;
* les différentes actions possibles sur le système de fichiers sont :
** <code>TYPE</code> pour créer un fichier si possible, le nom du fichier suit la commande, le contenu du fichier est donné en entrée standard de l'exécutable ;
** <code>CAT</code> pour afficher un fichier, le nom du fichier suit la commande ;
** <code>RM</code> pour détruire un fichier, le nom du fichier suit la commande ;
** <code>MV</code> pour renommer un fichier, les noms original et nouveau du fichier suivent la commande ;
** <code>CP</code> pour copier un fichier, les noms de l'original et de la copie du fichier suivent la commande ;

= Matériel nécessaire =

Un PC sous Linux.

= Travail réalisé =

== Semaine 1 ==

ReX : attention, ce micro-système de fichiers est prévu pour un microcontrôleur, vos variables globales ne peuvent pas dépasser quelques centaines d'octets.

ReX : pour la création du système de fichiers la commande <code>dd</code> suffit, vous voulez dire le formatage du système de fichiers ?

* création du programme programme.c contenant les différentes structures et les différentes fonctions.
* Piste d'amélioration: faire en sorte que la fonction CAT affiche le contenu exact des fichiers passés en argument.

Le code fourni est un programme en langage C qui simule un système de fichiers basique. Ce programme permet aux utilisateurs d'effectuer diverses actions telles que créer, afficher, supprimer, renommer et copier des fichiers dans un système de fichiers simulé. Le système de fichiers est stocké dans un fichier binaire.

ReX : vous n'avez pas tenu compte de la première remarque, vous chargez tout le superbloc et le répertoire racine, votre code ne convient pas.

ReX : vos structures utilisent des types entiers dont la taille n'est pas explicitée, utilisez les types de <code>stdint.h</code>.

ReX : la création de fichier n'est pas fonctionnelle, vous ne cherchez pas les blocs libres, vous ne copiez pas le contenu du fichier dans les blocs, même remarque pour toutes les autres fonctions.

ReX : il manque les fonctions d'accès aux pages du système de fichiers.

'''Explication du programme programme.c'''

Voici une brève explication des principaux éléments et fonctions du code :

# Structures :
#* Fichier : Représente un fichier dans le système de fichiers. Il contient un nom (nom) avec une longueur maximale de 16 caractères, un tableau de numéros de bloc (blocs) où le contenu du fichier est stocké (jusqu'à 2040 blocs), et le nombre de blocs utilisés par le fichier (nbBlocs).
#* Repertoire : Représente le répertoire principal du système de fichiers. Il contient un tableau de fichiers (<code>fichiers</code>) et le nombre de fichiers dans le répertoire (<code>nbFichiers</code>).
# Fonctions :
#* <code>chargerSystemeFichiers</code> : Charge le système de fichiers à partir d'un fichier binaire donné (chemin) dans une structure Repertoire.
#* <code>sauvegarderSystemeFichiers</code> : Sauvegarde le système de fichiers stocké dans la structure Repertoire dans un fichier binaire (chemin).
#* <code>creerFichier</code> : Crée un nouveau fichier dans le système de fichiers avec un nom et un contenu donnés. Le contenu du fichier est simulé en le divisant en blocs.
#* <code>afficherFichier</code> : Affiche le contenu d'un fichier avec le nom spécifié.
#* <code>detruireFichier</code> : Supprime un fichier avec le nom spécifié du système de fichiers.
#* <code>renommerFichier</code> : Renomme un fichier avec l'ancien nom spécifié en un nouveau nom.
#* <code>copierFichier</code> : Copie un fichier avec le nom spécifié en créant un nouveau fichier avec le nom de copie spécifié.
# Fonction <code>main</code> :
#* La fonction <code>main</code> est le point d'entrée du programme.
#* Elle prend des arguments en ligne de commande : <code><chemin_systeme_fichiers></code> et <code><action></code>.
#* <code><chemin_systeme_fichiers></code> est le chemin vers le fichier binaire où le système de fichiers est stocké.
#* <code><action></code> détermine quelle opération effectuer, comme <code>TYPE</code>, <code>CAT</code>, <code>RM</code>, <code>MV</code> ou <code>CP</code>.
#* En fonction de l'action spécifiée, le programme appelle la fonction correspondante pour effectuer l'opération souhaitée sur le système de fichiers.
Remarque : Le code fourni une simulation basique d'un système de fichiers et de ses opérations, mais il n'interagit pas réellement avec un système de fichiers réel sur le disque.

'''Comment utiliser le programme programme.c'''

étape 1: création du système de fichiers respectant le cahier des charges:

dd if=/dev/zero of=systeme_fichiers.bin bs=1M count=8

étape 2: compilation du programme C:

gcc programme.c -o gestionnaire_fs

étape 3: création d'un fichier dans le système de fichier:

./gestionnaire_fs systeme_fichiers.bin TYPE fichier1.txt

-> entrer le texte en entrée standard

étape 4: manipulation des différentes fonctions. Exemples:

./gestionnaire_fs systeme_fichiers.bin CAT fichier1.txt
./gestionnaire_fs systeme_fichiers.bin CP fichier1.txt copie.txt
./gestionnaire_fs systeme_fichiers.bin RM copie.txt
./gestionnaire_fs systeme_fichiers.bin MV fichier1.txt fichier2.txt

== Semaine 2 ==

Amine: Merci pour vos remarques. Désolé de ne pas avoir suivi votre première remarque, je pensais avoir compris ce qu'il fallait faire mais je me rend compte que non. Je vais tout reprendre depuis le début afin de repartir sur de bonnes bases.

'''Création du système de fichier avec la commande "dd"'''

A quoi sert la commande dd?

La commande <code>dd</code> permet de copier tout ou partie d'un disque par blocs d'octets, indépendamment de la structure du contenu du disque en fichiers et en répertoires (source : [https://doc.ubuntu-fr.org/dd]).

Structure de la commande

dd if=<nowiki><source> of=<cible> bs=<taille des blocs></nowiki>

<code>source</code> = données à copier

<code>cible</code> = endroit où les copier

<code>if</code> = input file

<code>of</code> = output file

<code>bs</code> = block size, habituellement une puissance de 2 supérieure ou égale à 512, représentant un nombre d'octets

Choix de la commande:

Pour la source, on prends <code>/dev/zero</code>: cela permet de créer un fichier rempli de 0. Ce fichier servira de base pour notre système de fichiers.

Pour la cible, on va l'appeler <code>filesystem.bin</Code> : ce sera notre système de fichier.

Pour la taille des blocs, on veut des blocs de données de 256 octets d'après l'enoncé. On va donc prendre <code>bs=256</code>.

Enfin, on veut que le système de fichier réside dans un fichier de 8 Mo. On va donc ajouter <code>count=31250</code>: cela indique que nous voulons écrire 32768 blocs de données dans le fichier (31250 * 256 octets = 8 Mo).

Résultat:

dd if=/dev/zero of=filesystem.bin bs=256 count=31250

Question pour M. Redon : j'ai ici essayé de respecter votre remarque "pour la création du système de fichiers la commande <code>dd</code> suffit". Cependant, pour votre seconde remarque "vous chargez tout le superbloc et le répertoire racine, votre code ne convient pas.", je ne suis pas sûr de comprendre où je fais cela: est-ce lors de la commande dd ou est-ce par la suite avec mon programme C? J'ai un peu modifié la commande dd comme vous pouvez le voir ci-dessus. Ai-je corrigé mon erreur avec cette nouvelle commande? J'ai essayé de justifier au maximum la commande dd que j'ai choisie.

ReX : Pas de problème avec la commande <code>dd</code> (mettez tous les extraits de code entre des balises <code>code</code>). Le problème est au niveau du programme C.

Amine: Ok je comprends mieux merci. Je vais donc reprendre le code étape par étape afin de mieux répondre au cahier des charges.

Gestion du système de fichier par un programme C

'''Création des structures'''
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>

// Structure pour représenter un bloc de données

struct DataBlock {
uint8_t data[256]; // 256 octets pour chaque bloc de données
};

// Structure pour représenter un fichier

struct File {
char filename[17]; // 16 caractères pour le nom du fichier + 1 caractère null-terminator
struct DataBlock data_blocks[2040]; // Tableau de blocs de données pour stocker le contenu du fichier
uint16_t num_data_blocks; // Nombre de blocs de données utilisés par le fichier
};

// Structure pour représenter un répertoire

struct Directory {
struct File files[64]; // Tableau de fichiers pour le répertoire principal
uint8_t num_files; // Nombre de fichiers dans le répertoire principal
};

Modification faite : suite à votre remarque, j'ai explicité la taille des entiers grâce aux types de <code>stdint.h.</code> (j'ai également mis les variables en anglais)

ReX : Vous ne pouvez pas utiliser ces structures, une instanciation d'une de ces structure prend trop d'espace mémoire, vous devez faire sans structure. Par ailleurs la façon dont vous représentez vos fichiers ne convient pas, la description d'un fichier contient des numéros de blocs, pas les blocs eux-même. Faites aussi attention qu'un fichier soit décrit par un nombre entier de blocs.

Question pratique: je n'arrive pas à mettre tout le code dans le même bloc comme vous l'avez fait ci-dessus dans l'étape 4 de la semaine 1. Je vois que c'est en format "préformaté" mais j'obtiens des blocs séparés lorsque j'applique ce format à mon code.

ReX : j'ai corrigé, pour un code entier la syntaxe n'est pas la même (un espace en début de chaque ligne), la balise c'est uniquement pour de très courts extraits de code.

=== Fonction <code>readBlock</code>===
Cette fonction est utilisée pour lire un bloc de données à partir du fichier <code>filesystem.bin</code> et le stocker dans un tableau de caractères (<code>storage</code>).

Fonction:

#define BLOCK_SIZE 256
// Fonction pour lire un bloc de données
void readBlock(unsigned int num, int offset, unsigned char *storage, int size) {
FILE *file = fopen("filesystem.bin", "rb");
if (file == NULL) {
perror("Erreur lors de l'ouverture du fichier");
return;
}
fseek(file, num * BLOCK_SIZE + offset, SEEK_SET);
fread(storage, 1, size, file);
fclose(file);
}

Paramètres :

* <code>num</code> : Numéro du bloc à lire. Chaque bloc contient 256 octets (1 bloc = 256 octets).
* <code>offset</code> : Décalage (en octets) à partir du début du bloc pour commencer la lecture.
* <code>storage</code> : Pointeur vers un tableau de caractères où les données lues seront stockées.
* <code>size</code> : Taille du tableau de caractères <code>storage</code>.

Fonctionnement :

* La fonction commence par ouvrir le fichier <code>filesystem.bin</code> en mode lecture binaire (<code>"rb"</code>).
* Elle utilise <code>fseek</code> pour positionner le curseur de lecture dans le fichier à l'endroit approprié pour commencer la lecture du bloc spécifié (<code>num</code>) à partir de l'offset (<code>offset</code>).
* Elle utilise ensuite <code>fread</code> pour lire <code>size</code> octets à partir du fichier et les stocker dans le tableau <code>storage</code>.
* Enfin, elle ferme le fichier avec <code>fclose</code>.

Note : Le paramètre <code>offset</code> est utilisé pour spécifier à partir de quel octet du bloc on souhaite commencer la lecture. Si <code>offset</code> est égal à 0, la lecture commencera depuis le début du bloc. Si <code>offset</code> est différent de 0, la lecture commencera à l'octet spécifié.

Remarque: dans votre mail, vous définissez "readBlock(unsigned int num,int offset,unsigned storage,int size)": storage n'est alors pas un pointeur vers un tableau de caractère. Je me suis donc permis de faire la modification.

ReX : OK pour la fonction, pas la peine d'en mettre autant dans le Wiki pour une fonction aussi simple.

=== Fonction <code>writeBlock</code> ===
Cette fonction est utilisée pour écrire un bloc de données dans le fichier <code>filesystem.bin</code> à partir d'un tableau de caractères (<code>storage</code>).

Fonction:

// Fonction pour écrire un bloc de données
void writeBlock(unsigned int num, int offset, const unsigned char *storage, int size) {
FILE *file = fopen("filesystem.bin", "rb+");
if (file == NULL) {
perror("Erreur lors de l'ouverture du fichier");
return;
}
fseek(file, num * BLOCK_SIZE + offset, SEEK_SET);
fwrite(storage, 1, size, file);
fclose(file);
}

Paramètres :

* <code>num</code> : Numéro du bloc où écrire.
* <code>offset</code> : Décalage (en octets) à partir du début du bloc pour commencer l'écriture.
* <code>storage</code> : Pointeur vers un tableau de caractères contenant les données à écrire dans le fichier.
* <code>size</code> : Taille du tableau de caractères <code>storage</code>.

Fonctionnement :

* La fonction commence par ouvrir le fichier <code>filesystem.bin</code> en mode lecture et écriture binaire (<code>"rb+"</code>).
* Elle utilise <code>fseek</code> pour positionner le curseur de lecture/écriture dans le fichier à l'endroit approprié pour commencer l'écriture du bloc spécifié (<code>num</code>) à partir de l'offset (<code>offset</code>).
* Elle utilise ensuite <code>fwrite</code> pour écrire <code>size</code> octets à partir du tableau <code>storage</code> dans le fichier.
* Enfin, elle ferme le fichier avec <code>fclose</code>.

ReX : Même remarque que pour la fonction précédente.

'''Etape 4: test des fonctions <code>readBlock</code> et <code>writeBlock</code> dans le main'''
// Exemple de fonction principale pour tester les opérations de lecture et d'écriture
int main() {
unsigned char data[BLOCK_SIZE];
// Test de la fonction readBlock
readBlock(0, 0, data, BLOCK_SIZE);
printf("Block 0, offset 0: ");
for (int i = 0; i < BLOCK_SIZE; i++) {
printf("%02x ", data[i]);
}
printf("\n");
// Test de la fonction writeBlock
unsigned char newData[BLOCK_SIZE] = {
0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88,
// ... Autres données du bloc ...
};
writeBlock(1, 0, newData, BLOCK_SIZE);
// Lecture du bloc nouvellement écrit pour vérifier
readBlock(1, 0, data, BLOCK_SIZE);
printf("Block 1, offset 0: ");
for (int i = 0; i < BLOCK_SIZE; i++) {
printf("%02x ", data[i]);
}
printf("\n");
return 0;
}

Fonctionnement :

* On déclare tout d'abord un tableau de caractères <code>data</code> de taille <code>BLOCK_SIZE</code> pour stocker les données lues du bloc.
* Ensuite, la fonction <code>readBlock</code> est appelée avec les arguments (0, 0, data, BLOCK_SIZE) pour lire le premier bloc du fichier (<code>num=0</code>, <code>offset=0</code>) et stocker les données dans <code>data</code>.
* Ensuite, la fonction <code>printf</code> est utilisée pour afficher les données lues du bloc (<code>data</code>) en format hexadécimal.
* Ensuite, un nouveau tableau de caractères <code>newData</code> est créé avec des données spécifiques pour tester la fonction <code>writeBlock</code>.
* La fonction <code>writeBlock</code> est appelée avec les arguments (1, 0, newData, BLOCK_SIZE) pour écrire le tableau <code>newData</code> dans le deuxième bloc du fichier (<code>num=1</code>, <code>offset=0</code>).
* Enfin, la fonction <code>readBlock</code> est appelée à nouveau pour lire le deuxième bloc nouvellement écrit et afficher les données lues en format hexadécimal.

Question générale : ce que j'avais la première semaine n'est plus forcément d'actualité. Puis-je supprimer les choses qui ne le sont plus afin d'alléger la page ou préférez-vous que je laisse?

ReX : Laissez.

Pour la suite : j'ai donc pour l'instant crée deux fonctions, l'une permettant la lecture et l'autre l'écriture d'un bloc, de manière à économiser la mémoire. Pour la suite, je vais essayer de créer la fonction <code>LS</code> en utilisant la fonction <code>readBlock</code>.

ReX : Oui c'est le début du projet. Mais si vous n'avez pas une bonne description de fichier cela ne donnera rien. Voir remarques plus haut.

'''Etape 5: fonction <code>LS</code>'''

Objectif: créer la fonction <code>LS</code> avec la fonction readBlock.

Question: Souhaitez-vous la fonction <code>LS</code> classique, c'est à dire la fonction <code>LS</code> qui affiche simplement le nom des fichiers présent dans le répertoire ?

ReX : Oui. Tu peux ajouter la taille si tu trouves cela trop simple.

Piste : si c'est ce que vous voulez:

* il va tout d'abord falloir que je crée des fichiers, un fichier étant composé d'un nom et de blocs (création d'une fonction createFile)
* Il faudra ensuite que je stocke ces fichiers dans le répertoire (création d'une fonction addFileToDirectory par exemple)
* enfin, il faudra que j'affiche le nom des fichiers. Pour cela, il faudra que je parcours le répertoire (structure "Directory"), puis que pour chaque fichier présent dans le répertoire que j'affiche son nom (création de la fonction LS)

Je devrais surement utiliser la fonction readBlock afin de transférer les blocs dans le fichier au travers de la variable "storage".

ReX : Créer des fichiers n'est pas nécessaire tout de suite je verrais bien si ton code est bon sans test. Laisse tomber <code>createFile</code> et <code>addFileToDirectory</code> pour l'instant.

ReX : Ton algorithme ne fonctionne pas pour un microcontrôleur où il faut économiser la mémoire, tu ne peux pas t'aider de structures. Il faudra que tu charges les noms et seulement les noms, pour la taille il faudra se baser sur le nombre de blocs.

'''Etape 6: rectification du code suite à vos remarques'''

Modifications apportées:

* suppression des structures afin d’économiser de la mémoire.

* le problème quant à la description des fichiers est normalement résolu puisque plus de structures. On ne charge plus les blocs mais seulement les noms de fichiers.

ReX : Non car si les noms ne sont pas répartis de façon régulière dans les blocs de 256 octets tu vas avoir du mal à les charger. Mais écrit la fonction <code>LS</code> et tu verras ce que je veux dire.

J'ai également ajouté deux nouvelles fonctions:

# <code>void readFileName(unsigned int file_num, char *file_name)</code>: Cette fonction permet de lire le nom du fichier associé au numéro de fichier donné (<code>file_num</code>). Elle stocke le nom du fichier lu dans le tableau <code>file_name</code>.
# <code>void writeFileName(unsigned int file_num, const char *file_name)</code>: Cette fonction permet d'écrire le nom du fichier dans le système de fichiers, associé au numéro de fichier donné (<code>file_num</code>). Elle prend en entrée le nom du fichier à écrire (<code>file_name</code>).

Suite: si vous validez cette base, je pourrai passer à la création de la fonction LS.

ReX : tu peux y aller. Je ne vois pas le code des tes deux fonctions <code>readFileName</code> et <code>writeFileName</code>.

Voici le code des fonctions <code>readFileName</code> et <code>writeFileName</code> :

'''Fonction readFileName:'''
// Fonction pour lire le nom du fichier
void readFileName(unsigned int file_num, char *file_name) {
readBlock(file_num, 0, (unsigned char *)file_name, MAX_FILENAME_LENGTH);
file_name[MAX_FILENAME_LENGTH] = '\0'; // Ajout du caractère null-terminator pour former une chaîne de caractères
}

ReX : Non, aucune raison que le fichier de numéro n soit au bloc n. Dessine la représentation d'un fichier sur le SF en comptant les octets si cela peut aider.

'''Fonction writeFileName:'''
// Fonction pour écrire le nom du fichier
void writeFileName(unsigned int file_num, const char *file_name) {
writeBlock(file_num, 0, (const unsigned char *)file_name, MAX_FILENAME_LENGTH);
}

ReX : Faux et inutile pour l'instant. Problème avec la constante MAX_FILENAME_LENGTH.

=== Fonction LS version 1 ===
// Fonction LS pour afficher les fichiers présents dans le système de fichiers
void LS(const char *filesystem_path) {
FILE *file = fopen(filesystem_path, "rb");
if (file == NULL) {
perror("Erreur lors de l'ouverture du fichier système");
return;
}
uint16_t num_files;
fread(&num_files, sizeof(uint16_t), 1, file); // Lecture du nombre de fichiers dans le système
char filename[17];
printf("Fichiers présents dans le système de fichiers:\n");
for (int i = 0; i < num_files; i++) {
readFileName(i, filename); // Lecture du nom du fichier
printf("%s\n", filename); // Affichage du nom du fichier
}
fclose(file);
}
La fonction <code>LS</code> ouvre le fichier système, lit le nombre de fichiers qu'il contient, puis affiche les noms des fichiers un par un, chacun sur une ligne séparée.

ReX : Il y a le nombre de fichiers dans ton superbloc ? Un dessin du format du superbloc avec les numéros des octets ?

ReX : Tout accès au système de fichiers doit se faire avec les deux fonctions <code>readBlock</code> et <code>writeBlock</code>.

== Semaine 3 ==
Question 1: cela fait plusieurs fois que vous mentionnez dans le wiki un "superbloc". Celui-ci n'étant pas clairement défini dans le sujet, je me demande s'il s'agit du bloc crée grâce à la fonction dd, c'est à dire que le superbloc serait en faite le bloc constitué des 31250 blocs de taille 256 octets, où s'il s'agit d'un bloc qui vient en entête, celui contenant alors des informations décrivant le système de fichier (les noms de fichiers...).

ReX : Pour ton pico système de fichiers, le superbloc consiste en les premiers blocs (de 256 octets) qui définissent les 64 fichiers possibles.

Proposition de structure: on pourrait réserver les premiers blocs du système de fichiers aux noms de fichiers ainsi qu'aux numéros des blocs correspondant à chaque fichier.

ReX : Oui c'est évident.

On sait que les noms de fichiers font au maximum 16 caractères + 1 caractère pour le '\0' (donc 17 octets car 1 char=1 octet).

ReX : Non, 16 octets suffisent, des '\0' en fin de nom uniquement si le nom fait moins de 16 caractères.

On sait également qu'un fichier contient au maximum 2040 blocs, chaque bloc étant numéroté sur 2 octets. On pourrait donc avoir en début du système de fichier: 17 octets+2 octets*2040 blocs = 4097 octets pour la description d'un fichier.

ReX : Non, 4096 octets soit 16 blocs de 256.

Or d'après l'une de vos remarques dans le wiki, un fichier doit être décrit par un nombre entier de blocs. Pour un fichier, il nous faudra donc 4097/256=16.004 soit 17 blocs. Il peut y avoir jusqu'à 64 fichiers dans le répertoire, il nous faudra donc 17 blocs*64 fichiers= 1088 blocs pour la description des fichiers.

ReX : Non 1024 blocs de 256 octets dans le superbloc.

Ainsi, pour la fonction LS, il suffira de lire les premiers caractères tous les 17 blocs ( du premier caractère au caractère '\0').

ReX : Non, tous les 16 blocs.

Question 2: Ne faudrait-il pas également stocker quelque part le nombre de fichier qu'il y a dans le répertoire afin de savoir jusqu'à quel bloc la fonction LS doit aller ?

ReX : Non, un fichier dont le nom n'est constitué que de '\0' est réputé ne pas exister.

Question 3: on a donc vu que les 1088 premiers blocs au maximum serviraient à la description du système de fichier. Il reste donc 31250-1088=30132 blocs dans le système de fichier.

ReX : Non, 32768-1024=31744 blocs.

Comment utiliser ces blocs? Ces blocs doivent-ils stocker le contenu des fichiers ?

ReX : Oui, c'et évident.

En effet, avec la fonction TYPE, nous allons créer des fichiers et ces fichiers devront être stockés quelque part. Cependant, étant donné que ce pico système de fichiers est prévu pour un microcontrôleur, je ne sais pas si c'est le contenu des fichiers qui doit être stocké dans les blocs ou autre chose (peut être l'adresse des fichiers, le fichiers se trouvant autre part). En effet, je me dis que si un fichier est très volumineux, il ne pourra pas rentrer dans le système de fichier, ce dernier étant composé d'un nombre limité de blocs, et les blocs étant eux même limité en nombre d'octets.

ReX : Je ne comprend pas ton problème. De tout façon comme dit plus haut, les 31744 blocs suivant le superbloc doivent contenir les données des fichiers.

Désolé de poser des questions peut être basique aussi tard, mais je pense qu'une fois que j'aurai ces réponses, cela ira beaucoup mieux pour la suite. Merci d'avance pour vos réponses.

ReX : Les questions sont effectivement triviales et il est effectivement inquiétant que voir que la travail n'avance pas.

Amine: merci pour vos corrections.

D'après votre commentaire "32768-1024=31744 blocs", j'en déduis qu'il faut que je modifie ma commande dd (qui est actuellement "dd if=/dev/zero of=filesystem.bin bs=256 count=31250" pour avoir le bon filesystem).

ReX : Je comprends pas d'où tu sors le 31250. D'autant plus que la commande ci-dessous est bonne.

Amine : 31250 car 31250 blocs * 256 octets = 8 Mo.

ReX : Haaaa je vois tu utilises le système métrique international où le mégaoctet vaut 10^6 octets, sauf qu'aucun informaticien n'utilisera cette norme hors sol. Quand je parle de 8 Mo c'est 8x1024x1024 octets. Tout simplement parce qu'une puce mémoire de 8 Mo c'est bien 8x1024x1024 octets.

Amine: D'accord merci pour l'information !

'''Nouvelle commande dd:'''

dd if=/dev/zero of=filesystem.bin bs=256 count=32768

=== Fonction LS version 2 ===

Dans notre structure du système de fichier, le superbloc est constitué de 1024 blocs (16 blocs * 64 fichiers), un fichier étant décrit par 16 blocs. Le nom du fichier est donc écrit au début de tous les blocs multiples de 16. Par exemple, le nom du premier fichier est dans les 16 premiers octets du premier bloc, le nom du 2ème fichier est dans les 16 premiers octets du 32ème bloc et ainsi de suite, tant que des fichiers existent. Lorsque qu'il n'y a plus de fichier, le nom du premier caractère du bloc multiple de 16 est un 0.

Voici le code:
// Fonction pour lister les noms de fichiers présents dans le système de fichiers
void LS() {
unsigned char buffer[BLOCK_SIZE];
int fileCount = 0;

for (int blockNum = 1; blockNum <= MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, BLOCK_SIZE);

// Vérifier si le bloc est vide
if (buffer[0] == 0) {
break; // Plus de fichiers à lire
}

char filename[MAX_FILENAME_LENGTH];
memcpy(filename, buffer, MAX_FILENAME_LENGTH);

// Afficher le nom du fichier
printf("%s\n", filename);
fileCount++;
}

if (fileCount == 0) {
printf("Aucun fichier trouvé.\n");
}
}

ReX : Tu supposes que si un fichier a un nom vide, les suivants auront aussi un nom vide. C'est possible mais dans ce cas la commande <code>RM</code> ca être plus compliquée à écrire.

ReX : Tu ne sembles pas comprendre que la mémoire d'un microcontrôleur est limitée. Pourquoi lire le premier bloc de description d'un fichier en entier ? Dit autrement c'est quoi l'intérêt de lire 256 octets alors que 16 suffisent ?

ReX : Pourquoi tu ne lis pas le premier fichier ? Autrement dit pourquoi décaler tout d'un bloc ?

Amine: Merci pour vos remarques. J'ai apporté les modifications à LS dans la section "Semaine 4" du wiki.

'''Réflexion par rapport aux autres fonctions:'''

J'ai créé les fonctions TYPE et CAT mais il y a malheureusement un problème pour l'instant. Vous pouvez les retrouver en pièce jointe dans l'archive du fichier programme.c.

Le problème que j'ai est que lorsque j'affiche le contenu du fichier créé avec TYPE, j'obtiens plein de caractères spéciaux. Par exemple, je créé le fichier "mon_fichier.txt" avec la fonction TYPE, et je mets en entré standard "hello". Ensuite, je veux afficher le contenu de ce fichier grâce à la fonction CAT. Cependant, ce qui s'affiche dans le terminal n'est pas ce que je veux. De la même manière, lorsque je fais la commande "cat filesystem.bin" dans le terminal, c'est la même chose s'affiche, des donnés parasites.

ReX : Avant même de lire ton code je vais te poser la question de savoir comment tu récupères un bloc libre ? Quel algorithme tu utilises. Personnellement je ne sais pas faire sans ajouter au superbloc un tableau bit à bit des blocs libres. Pour avoir un bit pour chaque bloc du système de fichiers, il faut 32768/8=4096 octets soit 16 blocs.

Amine: ok je vais donc ajouter ce tableau de 16 blocs à la suite de mes premiers 1024 blocs servant à la description de fichier. Le superbloc fera maintenant 1024+16=1040 blocs (plus de détail à la fonction RM de la semaine 4).

Question 1: est ce que la fonction CAT que je dois créer doit renvoyer la même chose que "cat filesystem.bin" ?

ReX : Je préfère ne pas répondre tellement la question montre un manque de réflexion.

Question 2: comment savoir combien de blocs doivent etre attribué à un fichier? Par exemple, si je créé un fichier "mon_fichier.txt" et que je mets en entrée standard le texte "hello", un seul bloc suffi pour stocker ce texte. Cependant, si j'avais mis beaucoup de texte en entrée standard, il aurait fallu plus de blocs. Doit-on calculer la taille de l'entrée standard ou doit-on attribuer toujours le meme nombre de blocs à un fichier? Peut-etre ainsi attribuer 2040 blocs par fichier, meme s'il n'en utilise que 1.

ReX : Là encore c'est une question stupéfiante tellement la réponse est évidente. Il suffit de lire les données sur l'entrée standard et de passer au bloc de données suivant dès que le bloc courant est rempli. La question à poser c'était de se demander comment il est possible d'avoir la taille exacte du fichier pour un <code>CAT</code>. Il est uniquement possible de l'avoir à 256 octets près puisque rien n'indique si le dernier block est vide. Le mieux aurait été de prévoir 4 octets dans la description d'un fichier pour stocker la taille. En l'espèce on considérera que les fichiers sont des fichiers ASCII et qu'ils seront terminés par des <code>\'0</code> qui ne seront pas affichés.

== Semaine 4 ==

Voici un bilan de ce que j'ai fait à ce stade du projet:

* j'ai choisi une structure du système de fichier
* j'ai créé les fonctions readBlock et writeBlock permettant de lire et d'écrire des blocs
* j'ai crée la fonction LS permettant d'afficher le nom des fichiers présents dans le système de fichiers
* j'ai programmer un main permettant d'utiliser les fonctions (LS, TYPE...) depuis le terminal
* j'ai réflechi aux fonctions TYPE et CAT.

Actuellement, je suis en train de créer les fonctions TYPE et CAT.

=== Fonction LS version 3 ===
void LS() {
unsigned char buffer[MAX_FILENAME_LENGTH];
int fileCount = 0;

// Parcourir tous les 16 blocs de 0 jusqu'à MAX_FILES_IN_DIRECTORY
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, MAX_FILENAME_LENGTH);

// Vérifier si le nom de fichier est vide
if (buffer[0] != 0) {

// Afficher le nom du fichier
printf("%s\n", buffer);
fileCount++;
}
}

if (fileCount == 0) {
printf("Aucun fichier trouvé.\n");
}
}
Suite à vos remarques, j'ai effectué les modifications suivantes de la fonction LS:

* Je ne suppose plus que si un fichier a un nom vide, les autres auront aussi un nom vide.
* Je ne lis plus les 256 octets mais seulement les 16 premiers octets car cela suffit.
* Je ne lisais en effet pas le premier bloc. Je pensais que le premier bloc était d'indice 1 mais ce n'est pas le cas.

ReX : Ouiiii ! Une fonction correcte. Passe à <code>RM</code> maintenant, c'est la plus facile à faire concernant l'image bit à bit des blocs libres.

=== Fonction setBlockAvailability version 1 ===

Comme vous l'avez indiqué dans votre remarque, il faut un tableau dans le superbloc qui nous permettra de connaitre la disponibilité bit par bit de chaque bloc. Sachant qu'il y a dans notre système de fichiers 32768 blocs, et qu'il faut 1 bit par bloc, nous avons besoin de 32768 bits, soit 32768/8=4096 octets soit 4096/256=16 blocs. Notre superbloc sera donc comme suit: les 1024 premiers blocs servent à la description des fichiers, c'est à dire à leur nom suivi des numéros de blocs qui leur sont associés, puis ces 1024 blocs sont suivi de 16 blocs listant la disponibilité de chaque bloc.

ReX : Bien résumé.

Nous allons tout d'abord écrire la fonction "setBlockAvailability" prenant en paramètre le numéro du bloc à traiter (<code>blockNum</code>) et la disponibilité souhaitée pour ce bloc (<code>availability</code>). Cette fonction permet de marquer la disponibilité d'un bloc spécifique dans le système de fichiers. Nous utiliserons la convention suivante: un bloc disponible sera marqué par un 1 tandis qu'un bloc non disponible par un 0.
#define SUPERBLOCK_START_BLOCK 1024

void setBlockAvailability(int blockNum, int availability) {
// Calculer l'index du byte et le bit offset correspondant
int byteIndex = blockNum / 8;
int bitOffset = blockNum % 8;

// Lire le byte existant du bloc de disponibilité des blocs
unsigned char buffer[1];
readBlock(SUPERBLOCK_START_BLOCK + byteIndex, 0, buffer, 1);

// Mettre à jour le bit d'offset correspondant
if (availability) {
buffer[0] |= (1 << bitOffset);
} else {
buffer[0] &= ~(1 << bitOffset);
}

// Écrire le byte mis à jour dans le bloc de disponibilité des blocs
writeBlock(SUPERBLOCK_START_BLOCK + byteIndex, 0, buffer, 1);
}

ReX : Un tableau de un octet c'est un octet (variable <code>buffer</code>).

Amine: je vais utiliser un <code>unsigned char buffer.</code> Je suis conscient qu'un char vaut un octet mais je ne pense pas qu'il y ait un type de donnée de la taille d'un bit, c'est pourquoi je travaille avec un octet mais je modifie les bits de cet octet grâce aux algorithmes.

ReX : Il faut bien que tu travailles sur un octet vu que l'état des blocs est stocké sous la forme d'octets. Je disais juste qu'un tableau de 1 élément n'a pas d'intérêt par rapport à l'élément lui-même.

Amine: c'est vrai, modification faite.

ReX : Non il faut calculer le numéro du bloc avant de faire le <code>readBlock</code>.

Amine: ok je vais calculer le numéro de bloc avant.

ReX : La mise à jour du bit est correcte mais le block et le déplacement dans le block ne sont pas correctement calculés.

Amine: je vais vous expliquer le raisonnement que j'avais. Prenons un exemple concret, imaginons que je veuille marquer le bloc 1030 comme disponible:

# Calcul de l'index de l'octet et du bit offset :
#* <code>blockNum</code> = 1030
#* Index du byte = 1030 / 8 = 128
#* Bit offset = 1030 % 8 = 6
# Lecture de l'octet existant de disponibilité:
#* Nous lisons l'octet existant à l'index 128 dans les blocs de disponibilité.
# Mise à jour du bit de disponibilité :
#* Nous voulons marquer le bloc 1030 comme disponible, donc nous utilisons le masque <code>(1 << 6)</code> pour définir le bit 6 à 1 dans l'octet. Le résultat sera, par exemple, <code>00100000</code>.
# Écriture du byte mis à jour :
#* Nous écrivons le byte mis à jour <code>00100000</code> à l'index 128 dans les blocs de disponibilité.

ReX : Ben non, un vrai exemple :
* Il faut prendre un n° de bloc plus grand : 3072 ;
* Numéro d'octet dans la carte des blocs libres : 3072/8=384 ;
* Numéro du bloc dans la carte des blocs libres : 384/256=1 ;
* Numéro du bit <code>b</code> dans l'octet n° 384-256=128 du bloc 1 : 3072%8=0 ;
* Il faut donc lire l'octet <code>o</code> de numéro 128 du bloc 1, puis modifier cet octet par <code>o |= (1<<b)</code> ou <code>o &= ~(1<<b)</code> ;
* Enfin il faut écrire l'octet modifié dans le bloc 1.
Amine: merci pour cet exemple! J'ai compris d'où vient mon erreur. Voir fonction setBlockAvailability version 3.

Remarque: par convention, j'apellerai dans la suite de ce projet "premier superbloc" le superbloc correspondant à la description des fichiers, c'est à dire les 1024 premiers blocs, et j'appellerai "second superbloc" les 16 blocs qui suivent servant à décrire la disponibilité des blocs (du bloc 1024 au bloc 1039 inclu). Le reste des blocs servira à stocker les données.

ReX : Non, le superblc est l'ensemble des informations hors blocs de données, tu ne peux pas utiliser un vocabulaire au hasard. Parle de blocs de description des fichiers ou de carte des blocs libres.

Amine: ok

Je pense que le problème qui se pose est que l'indice du bit dans le second superbloc ne correspond pas à l'indice du bloc dans le système de fichier. Par exemple, nous voudrions que si le bloc 1030 est disponible dans le système de fichier, alors le bit numéro 1030 du deuxième superbloc soit à 1, ce qui n'est pas le cas ici. En effet, on se trouve bien dans le bon octet avec ma méthode mais l'écriture du bit se fait de la droite vers la gauche alors qu'on voudrait l'inverse. Ainsi, si le 6ème bit de l'octet doit être à 1, alors il faudrait qu'on obtienne <code>00000100</code> et non <code>00100000.</code> L'indice du bit coinciderait ainsi avec le numéro du bloc.

ReX : Non, réfléchit à nouveau.

Voir plus bas la nouvelle version de setBlockAvailability.

Explication de l'algorithme pour mettre le bit à 1 ou 0:

* <code>buffer[0] |= (1 << bitOffset);</code> : Cette ligne utilise l'opérateur OR bit à bit (<code>|=</code>) pour activer (mettre à 1) le bit spécifié par <code>bitOffset</code> dans le premier octet (<code>buffer[0]</code>). Cela se fait en décalant le bit 1 vers la gauche de <code>bitOffset</code> positions, puis en effectuant une opération OR bit à bit avec le contenu actuel de <code>buffer[0]</code>. Cette opération modifie uniquement le bit ciblé, laissant les autres bits inchangés.

ReX : Oui ça c'est bon.

* <code>buffer[0] &= ~(1 << bitOffset);</code> : Cette ligne utilise l'opérateur AND bit à bit (<code>&=</code>) pour désactiver (mettre à 0) le bit spécifié par <code>bitOffset</code> dans <code>buffer[0]</code>. Pour ce faire, l'expression <code>~(1 << bitOffset)</code> est utilisée pour créer un masque où tous les bits sont à 1, sauf celui correspondant à <code>bitOffset</code>, qui est à 0. En effectuant ensuite une opération AND bit à bit entre le masque et le contenu actuel de <code>buffer[0]</code>, on met à 0 le bit ciblé sans affecter les autres bits.

ReX : Ca aussi.

=== Fonction setBlockAvailability version 2 ===

void setBlockAvailability(int blockNum, int availability) {
// Calculer l'indice de l'octet et le bit offset correspondant
int byteIndex = blockNum / 8;
int bitOffset = 7 - (blockNum % 8); // Inversion de l'ordre des bits

// Calculer le numéro du bloc du super bloc où se trouve l'octet de disponibilité correspondant
int availabilityBlockNum = SUPERBLOCK_START_BLOCK + byteIndex;

// Lire l'octet existant dans le bloc de disponibilité du super bloc
unsigned char buffer;
readBlock(availabilityBlockNum, 0, &buffer, 1);

// Mettre à jour le bit d'offset correspondant :
if (availability) {
buffer |= (1 << bitOffset);
} else {
buffer &= ~(1 << bitOffset);
}

// Écrire l'octet mis à jour dans le bloc de disponibilité du super bloc
writeBlock(availabilityBlockNum, 0, &buffer, 1);
}
J'ai modifié la ligne <code>int bitOffset = 7 - (blockNum % 8);</code> pour inverser l'ordre des bits sélectionnés, de sorte que le bit correspondant au bloc disponible soit correct.

ReX : Encore plus faux.

Si on veut rendre le bloc 1030 indisponible alors que les autres blocs sont disponibles:

ReX : Pardon ? Le bloc de données est libre ou pas suivant la carte des blocs libres. Le rendre disponible n'est possible que si un fichier le comportant est détruit.

# Calcul de l'indice de l'octet et du bit offset correspondant :
#* <code>blockNum = 1030</code>
#* <code>byteIndex = 1030 / 8 = 128</code>
#* <code>bitOffset = 7 - 1030 % 8 = 1</code> Cela signifie que le bit d'intérêt se trouve à la position 2 dans l'octet.
# Calcul du numéro du bloc du super bloc où se trouve l'octet de disponibilité correspondant :
#* <code>availabilityBlockNum = SUPERBLOCK_START_BLOCK + 128 = 1024 + 128 = 1152</code> Donc, nous devons accéder à l'octet 1152 pour mettre à jour la disponibilité du bloc 1030.
# Lecture de l'octet existant dans le bloc de disponibilité du super bloc :
#* Le contenu de l'octet dans le bloc 1152 avant la mise à jour : 11111111 (en binaire)
# Mise à jour du bit d'offset correspondant :
#* Supposons que nous voulions marquer le bloc 1030 comme non disponible (<code>availability = 0</code>).
#* Le bitOffset est 1.
#* Nous effectuons une opération AND avec le complément du bit à la position 1 : <code>11111111 & 11111101 = 11111101</code>
# Écriture de l'octet mis à jour dans le bloc de disponibilité du super bloc :
#* Le contenu de l'octet 128 du second superbloc après la mise à jour : 11111101 (en binaire)

ReX : Toujours aussi faux.

Maintenant, le bit d'indice 1 du 128 ème octet du second superbloc est mis à 0, indiquant que le bloc 1030 n'est plus disponible. Les autres bits restent inchangés car nous avons effectué un AND avec un masque binaire qui avait des 1 partout sauf à la position du bit que nous souhaitions mettre à 0.

ReX : Erreur sur erreur.

=== Fonction setBlockAvailability version 3 ===
J'ai compris d'où vient l'erreur. La fonction readBlock prends en premier paramètre le numéro du bloc à lire, je ne peux donc pas lui donner la valeur "SUPERBLOCK_START_BLOCK + byteIndex" car byteIndex s'exprime en octet alors qu'on s'attend à un nombre de bloc ici. Il faut donc divisé byteIndex par 256 pour être en unité "bloc", et préciser le bit qu'on veut lire grâce à l'offset.

Pour obtenir l'octet que l'on veut, il faut prendre le reste de la division de byteIndex par 256. On va ensuite stocker cet octet dans notre "buffer".

Pour savoir quel bit modifier dans ce "buffer", on va prendre le reste de la division du bloc dont on veut mettre à jour la disponibilité par 8. On va ainsi pouvoir modifier ce bit grâce à l'algorithme, puis réécrire l'octet à son emplacement d'origine.

Cette fonction gère la carte de disponibilités des blocs. Si un bloc est disponible, alors elle le met un 0, si il est indisponible, elle met un 1.
#define SUPERBLOCK_START_BLOCK 1024

void setBlockAvailability(int blockNum, int availability) {

int byteIndexInCard = blockNum / 8; //Numéro d'octet dans la carte des blocs libres
int blockIndexInCard = byteIndexInCard / 256; //Numéro du bloc dans la carte des blocs libres
int byteIndexInBlock = byteIndexInCard % 256; //Numéro d'octet dans le bloc contenant le bit de disponibilité
int bitOffset = blockNum % 8; //Numéro du bit dans l'octet n°byteIndexInBlock du bloc blockIndexInCard

//indice du bloc contenant le bit à mettre à jour dans le bloc de description
int availabilityBlockNum = FIRST_DISPONIBILITY_CARD_BLOCK + blockIndexInCard;

// Lire l'octet existant dans le bloc de disponibilité du super bloc
unsigned char buffer;
readBlock(availabilityBlockNum, byteIndexInBlock, &buffer, 1);

// Mettre à jour le bit d'offset correspondant :
if (availability==1) { // indisponible
buffer |= (1 << bitOffset); // Mettre le bit à 1

} else { // disponible
buffer &= ~(1 << bitOffset); // Mettre le bit à 0
}

// Écrire l'octet mis à jour dans le bloc de disponibilité du super bloc
writeBlock(availabilityBlockNum, byteIndexInBlock, &buffer, 1);
}

ReX : Ben voila, c'est pas possible de te taxer d'excès de vitesse mais c'est bon.

update: j'ai fait une petite modification, maintenant un bloc disponible est marqué d'un 0 et un bloc indisponible est marqué d'un 1. C'est mieux dans la mesure où initialement, tous les blocs sont disponibles et tous les blocs sont à 0. Cela évite de devoir créer une fonction qui initialise toute la carte de disponibilités à 1 pour dire que tous les blocs sont disponibles.

=== Fonction RM version 1 ===

void RM(const char *filesystem_path, const char *filename) {
unsigned char buffer[BLOCK_SIZE];
int fileNum = -1;

// Parcourir les blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (memcmp(filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {
// Effacer le nom du fichier dans le superbloc
memset(filenameBuffer, 0, MAX_FILENAME_LENGTH);
writeBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

unsigned char fileBuffer[MAX_BLOCKS_PER_FILE * 2];
readBlock(blockNum, MAX_FILENAME_LENGTH, fileBuffer, MAX_BLOCKS_PER_FILE * 2);

// Libérer les blocs associés au fichier et réinitialiser les numéros de blocs
for (int i = 0; i < MAX_BLOCKS_PER_FILE * 2; i += 2) {
int blockNum = ((int)fileBuffer[i] << 8) + (int)fileBuffer[i + 1];
if (blockNum == 0) {
break; // Fin du fichier
}
setBlockAvailability(blockNum, 0); // Marquer le bloc comme disponible
fileBuffer[i] = 0;
fileBuffer[i + 1] = 0;
}

// Mettre à jour les numéros de blocs associés au fichier
writeBlock(blockNum, MAX_FILENAME_LENGTH, fileBuffer, MAX_BLOCKS_PER_FILE * 2);

fileNum = blockNum;
break; // Fichier trouvé, sortir de la boucle
}
}

// Afficher le résultat de l'opération
if (fileNum == -1) {
printf("Le fichier \"%s\" n'a pas été trouvé.\n", filename);
} else {
printf("Le fichier \"%s\" a été supprimé avec succès.\n", filename);
}
}

ReX : Vous utilisez <code>strcmp</code> comme <code>strncmp</code>. C'est bien la dernière qu'il faut utiliser mais en précisant la longueur du nom en paramètre, pas la taille maximale.

Amine: vous voulez dire que j'utilise memcmp au lieu de strncmp ? Ok je vais utiliser strncmp, c'est vrai que c'est plus adapté pour la comparaison de chaines de caractère.

ReX : Ha oui c'est <code>memcmp</code> que tu utilises. Ca ne peut effectivement pas marcher. Effectivement avec <code>strncmp</code> cela peut marcher vu qu'il s'arrête au premier 0 contrairement à <code>memcmp</code>.

Cependant, pourquoi doit-on passer la taille exacte du nom du fichier en paramètre, et non la taille maximale d'un nom de fichier? En effet, cela semble fonctionner en mettant la taille maximale en paramètre, tandis que lorsque l'on met la taille exacte du nom du fichier, cela pose un problème: on ne compare plus toute la chaîne de caractère mais seulement une portion du nom complet. Ainsi, si je crée par exemple un fichier que j'appelle "file1", puis que j’exécute la fonction RM "/picofs filesystem.bin RM file" par exemple, alors le fichier file1 va être supprimé quand même car on ne comparera que strlen(file)=4 premiers caractères, qui sont les mêmes, donc la fonction considérera ces chaines comme identiques. On pourrait alors se dire qu'il faudrait alors prendre plutôt comme taille en paramètre de la fonction strlen la taille du nom du fichier se trouvant dans le système de fichier plutôt que celle du nom donné en paramètre de RM. Cependant, le même problème se pose si la taille du nom du fichier du système de fichier est plus petite que celle du nom du fichier passé en paramètre. Par exemple, si le fichier présent dans système de fichier est "file", et qu'on met la longueur de file en paramètre de la fonction strcmp, puis qu'on exécute la commande "/picofs filesystem.bin RM file5", alors file sera quand même supprimé, car on ne comparera que les strlen(file)=4 premiers caractère. Finalement, une solution serait de rajouter une condition qui vérifie que les deux chaînes sont de taille identiques pour pouvoir réaliser la comparaison sur la taille exacte du nom du fichier. Cependant, il me semble qu'en mettant MAX_FILENAME_LENGTH qui vaut 16 en paramètre, cela fonctionne directement. Vous pouvez tester cela en testant mon programme.

ReX : Ok pour <code>strncmp</code> avec la taille maximale d'un nom de fichier.

etape 1: créer un fichier :
./picofs filesystem.bin TYPE fichier.txt

etape 2: verifier que le fichier a bien été créé :
./picofs filesystem.bin LS

Le terminal renvoie bien "fichier.txt"

etape 3: essayer de supprimer le fichier en mettant une chaine troncature du nom du fichier créé :
./picofs filesystem.bin RM fich

le terminal renvoi <<Le fichier "fich" n'a pas été trouvé.>>, le fichier n'a donc pas été supprimé .

etape 4: essayer de supprimer le fichier en mettant un nom plus grand incluant "fichier.txt" :
./picofs filesystem.bin RM fichier.txtt

terminal renvoi <<Le fichier "fichier.txtt" n'a pas été trouvé.>>

etape 5: enfin, tester en mettant le nom exacte du fichier que l'on veut supprimer :
./picofs filesystem.bin RM fichier.txt

terminal renvoi <<Le fichier "fichier.txt" a été supprimé avec succès.>>

Finalement, on voit que cela fonctionne avec la taille maximale mise en paramètre. On pourrait reprocher à cette méthode de comparer des caractères dans le vide, ce qui n'est pas optimal dans une optique d'économie de mémoire qui est la notre, mais la taille maximale d'un nom de fichier étant relativement faible (16 octets), on peut peut-être négliger cela au vu de l'économie d'une opération supplémentaire (comparaison de la taille des chaines de caractères).

ReX : Le parcours des blocs de données du fichier est atroce. Il faut parcourir les numéros de blocs dans le premier bloc du fichier derrière le nom du fichier puis il faut parcourir le 15 autres blocs.

Amine: Ok, je vais corriger cela dans la version 2 de RM (voir semaine 5).

Fonctionnement de la fonction RM:

* Parcours des blocs réservés pour la description des fichiers (superbloc) à partir du bloc 0, en incrémentant de 16 à chaque itération pour accéder aux blocs de noms de fichiers.

ReX : OK.

* Dans chaque bloc de noms de fichiers, la fonction compare le nom de fichier recherché avec les noms stockés dans les 16 octets de chaque bloc.

ReX : Non la fonction ne fait pas ça par contre il faudrait, oui.

Amine: Je pensais que c'était ce que je faisais avec "memcmp(filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0)".

* Si le nom de fichier est trouvé, la fonction efface le nom du fichier dans le superbloc en remplaçant les 16 octets du bloc par des zéros.

ReX : OK.

* Ensuite, la fonction accède aux octets suivants du même bloc pour obtenir les numéros de blocs associés au fichier.

ReX : Non, la boucle sort largement du premier bloc.

* Pour chaque paire de numéros de blocs (2 octets chacun), la fonction convertit les octets en un numéro de bloc. Si le numéro de bloc est nul, cela signifie la fin des blocs associés au fichier, sinon, la fonction marque ce bloc comme disponible en utilisant la fonction <code>setBlockAvailability</code> et réinitialise les numéros de blocs dans le tableau à zéro.
* Les numéros de blocs réinitialisés sont ensuite réécrits dans le bloc de description du fichier.

ReX : L'idée est là mais vu que la boucle n'est pas bonne, rien ne peut marcher.

* La fonction affiche ensuite un message indiquant le résultat de l'opération : soit que le fichier a été supprimé avec succès, soit que le fichier n'a pas été trouvé.

== Semaine 5 ==

=== Fonction RM version 2 ===

Concernant les remarques que vous m'avez faites précédemment:

* j'utilise maintenant la fonction <code>strncmp</code> pour la comparaison des chaines de caractères
* j'ai normalement corrigé le parcours des blocs. Je parcours maintenant d'abord les blocs multiples de 16 à la recherche du bloc contenant le nom du fichier à supprimer. Puis je parcours les 16 blocs de description du fichier à supprimer, afin de récupérer les numéros de blocs, libérer ces blocs dans la carte de disponibilité et de réinitialiser ces blocs dans les blocs de données.

void RM(const char *filesystem_path, const char *filename) {
int fileFound = -1;
int offset;

// Parcourir les blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char*)filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {

// Effacer le nom du fichier dans le superbloc
memset(filenameBuffer, 0, MAX_FILENAME_LENGTH);
writeBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);
fileFound = 1;
offset = blockNum;
break;
}

}

// Fin de fonction si fichier inexistant
if (fileFound == -1) {
printf("Le fichier \"%s\" n'a pas été trouvé.\n", filename);
return;
}

unsigned char buffer[BLOCK_SIZE];
//bloc que l'on va remplir de 0 et mettre à la place des blocs de données
memset(buffer, 0, BLOCK_SIZE); //on rempli buffer de 0

for (int blockNum=offset; blockNum<offset + 16; blockNum++) {

//premier bloc de description, celui contenant le nom du fichier dans les 16 premiers octets
if (blockNum == offset) {

unsigned char fileBuffer[BLOCK_SIZE-MAX_FILENAME_LENGTH];
//bloc dans lequel on va stocker les blocs de description de fichier
readBlock(blockNum, MAX_FILENAME_LENGTH, fileBuffer, BLOCK_SIZE-MAX_FILENAME_LENGTH);

// Libérer les blocs associés au fichier dans la carte de disponibilités
// et dans les blocs de description
for (int i = MAX_FILENAME_LENGTH; i < BLOCK_SIZE-MAX_FILENAME_LENGTH; i += 2) {
int blockNumData = ((int)fileBuffer[i] << 8) + (int)fileBuffer[i + 1];
if (blockNumData == 0) {
break; // Fin du fichier
}
setBlockAvailability(blockNumData, 0); // Marquer le bloc comme disponible
fileBuffer[i] = 0;
fileBuffer[i + 1] = 0;
writeBlock(blockNumData, 0, buffer, BLOCK_SIZE); //on efface les blocs de données
}
writeBlock(blockNum, MAX_FILENAME_LENGTH, fileBuffer, BLOCK_SIZE-MAX_FILENAME_LENGTH);
//on efface le premier bloc de description

} else {
unsigned char fileBuffer[BLOCK_SIZE];
readBlock(blockNum, 0, fileBuffer, BLOCK_SIZE);

// Libérer les blocs associés au fichier dans la carte de disponibilités et dans les blocs de description
for (int i = 0; i < BLOCK_SIZE; i += 2) {
int blockNumData = ((int)fileBuffer[i] << 8) + (int)fileBuffer[i + 1];
if (blockNumData == 0) {
break; // Fin du fichier
}
setBlockAvailability(blockNumData, 0); // Marquer le bloc comme disponible
fileBuffer[i] = 0;
fileBuffer[i + 1] = 0;
writeBlock(blockNumData, 0, buffer, BLOCK_SIZE); //on efface les blocs de données
}
writeBlock(blockNum, 0, fileBuffer, BLOCK_SIZE); //on efface le bloc de description
}
}
printf("Le fichier \"%s\" a été supprimé avec succès.\n", filename);
}

ReX : Pour construire le nombre sur 16 bits utiliser le OU plutôt que l'addition.

ReX : Heu non, je ne lis pas cette fonction avec tout ce code dupliqué, la seule différence entre les deux alternative est la position de début de l'adresse du premier bloc de données (<code>MAX_FILENAME_LENGTH</code> dans un cas et 0 dans l'autre). Donc l'alternative ne doit servir qu'à initialiser ce début, le reste du code doit être factorisé.

ReX : Et corrige le code, tu utilises deux tableaux de blocs (perte mémoire), tu écris le bloc à zéro dans l'itération (perte CPU).

=== Fonction RM version 3 ===

Suite à vos remarques, j'ai réalisé les modifications suivantes:

* j'utilise maintenant le OU plutôt que l'addition pour construire le nombre sur 16 bits.

* j'ai factorisé le code grâce à la création de la variable <code>startOffset</code> valant 16 lorsqu'on se trouve dans le bloc contenant le nom du fichier et valant 0 lorsqu'on se trouve dans les autres.

* Pour ce qui est du fait que j'utilise 2 tableaux de blocs, j'ai du mal à voir comment faire avec 1 seul tableau de blocs car ces deux tableaux n'ont pas du tout le même rôle. Le tableau <code>fileBuffer</code> permet de stocker les 16 blocs de description d'un fichier un à un. Lorsqu'on stocke un bloc dans <code>fileBuffer</code>, on lit ensuite les octets un à un de ce bloc afin de former des numéros de blocs, et pour chaque numéro de bloc créé, on va réinitialiser le bloc correspondant dans les blocs de données. Pour cela, on a donc besoin d'un autre bloc qui viendra écraser les anciens blocs de données. C'est pourquoi j'ai créé un bloc <code>buffer</code>qui est composé de 0 et qui va écraser les blocs de données. On ne peut pas utiliser <code>fileBuffer</code> car on a besoin d'un bloc de zéros, et si on réinitialise <code>fileBuffer</code> on perd toute les données qui s'y trouvent. Une possibilité serait de relire le bloc de donné à chaque itération de la deuxième boucle for imbriquée; cela permettrait de pouvoir réinitialiser le tableau fileBuffer à chaque itérations de cette boucle afin de stocker ce bloc de 0 dans les blocs de données, puis de restocker dans ce même tableau le bloc de description. Cependant, je ne pense pas que ce soit optimal de faire autant appel à la fonction readBlock.

* j'ai créé une fonction resetBock qui permet comme son nom l'indique de reset un bloc en le remplissant de 0. Cela nous évite de créer deux tableaux de blocs dans RM, bien que je pense que cela revienne au même car on fait appel à une fonction qui créé un tableau de blocs. Quoi qu'il en soit, cela allège le code et cette fonction pourra surement me resservir par la suite.

void RM(const char *filesystem_path, const char *filename) {
int fileFound = -1;
int offset;
unsigned char fileBuffer[BLOCK_SIZE];

// Parcourir les blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char *)filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {
// Effacer le nom du fichier dans le superbloc
memset(filenameBuffer, 0, MAX_FILENAME_LENGTH);
writeBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);
fileFound = 1;
offset = blockNum;
break;
}
}

// Fin de fonction si fichier inexistant
if (fileFound == -1) {
printf("Le fichier \"%s\" n'a pas été trouvé.\n", filename);
return;
}

for (int blockNum = offset; blockNum < offset + 16; blockNum++) {
int startOffset = 0;
if (blockNum == offset) {
startOffset = MAX_FILENAME_LENGTH;
}
readBlock(blockNum, startOffset, fileBuffer, BLOCK_SIZE - startOffset);

// Libérer les blocs associés au fichier dans la carte de disponibilités et dans les blocs de description
for (int i = 0; i < BLOCK_SIZE - startOffset; i += 2) {
int blockNumData = (fileBuffer[i] << 8) | fileBuffer[i + 1];
if (blockNumData == 0) {
break; // Fin du fichier
}
setBlockAvailability(blockNumData, 0); // Marquer le bloc comme disponible
fileBuffer[i] = 0;
fileBuffer[i + 1] = 0;
resetBlock(blockNumData); //on efface les blocs de données
}
writeBlock(blockNum, startOffset, fileBuffer, BLOCK_SIZE - startOffset);
}
printf("Le fichier \"%s\" a été supprimé avec succès.\n", filename);
}
'''Fonction resetBlock'''
void resetBlock(unsigned int blockNum) {
unsigned char buffer[BLOCK_SIZE];
memset(buffer, 0, BLOCK_SIZE);

// Utiliser writeBlock pour écrire les données du buffer dans le bloc
writeBlock(blockNum, 0, buffer, BLOCK_SIZE);
}

ReX : Ca s'améliore. Mais pourquoi cette fonction <code>resetBlock</code> ? Tu crois que dans qu'un système de fichiers perd du temps à mettre à zéro les blocs de données libérés ? Si oui, regarde la page de manual de la commande <code>shred</code>, ça manque à ta culture.

Amine: Après avoir consulter le manual de la commande <code>shred</code>, je vois que cette commande écrit des données aléatoires sur l'emplacement du fichier sur le disque. Par défaut, <code>shred</code> effectue un certain nombre de passes (par exemple, 3 passes) pendant lesquelles il écrit des données aléatoires sur l'emplacement du fichier sur le disque. Après avoir écrit les données aléatoires, <code>shred</code> peut effectuer des passes supplémentaires pendant lesquelles il écrit des données nulles (des zéros) sur le même emplacement. L'objectif de <code>shred</code> est d'augmenter la sécurité en rendant plus difficile la récupération des données supprimées à l'aide d'outils de récupération de données.

Cependant, j'ai aussi consulté comment fonctionne la commande <code>rm</code> de linux, et je vois que cette commande libère l'espace occupé par le fichier en marquant les blocs associés comme disponibles. Cela signifie que les données peuvent encore être récupérées à l'aide d'outils de récupération de données, à moins que des mesures supplémentaires ne soient prises pour écraser physiquement l'espace avec des données aléatoires (c'est ce que fait l'utilitaire <code>shred</code>).

On va donc opter pour la deuxième option, c'est à dire qu'on ne va pas perdre notre temps à remettre à zéro les blocs de données libérés, on va simplement marquer les blocs correspondants comme étant disponibles. Cela nous permettra de nous émanciper de la fonction resetBlock et de n'avoir plus qu'un seul tableau de blocs.

ReX : Sinon lire un bloc complet de pointeurs de blocs de données en mémoire n'est pas forcément optimal. L'idéal serait de lire ces blocs morceau par morceau (de 64 octets par exemple). Certes un bloc serait traité en 4 lectures/écritures (ce qui ralentirait le traitement) mais on gagne en mémoire. Le mieux serait de mettre la taille des morceaux en constante pour pouvoir choisir entre vitesse d'exécution et utilisation mémoire.

Amine: d'accord je comprends. Je vais modifier la fonction pour qu'on puisse découper la lecture/écriture en plusieurs blocs.

=== Fonction RM version 4 ===
Modifications apportées:

* je ne réinitialise plus les blocs de données, je supprime simplement le pointeur du fichier vers les blocs de données et je désigne les blocs comme "disponible" dans le carte de disponibilités. J'ai donc supprimé la fonction resetBlock.

* je ne lis plus les blocs en une seule fois mais en plusieurs fois via la variable CHUNK_SIZE:

# J'ai introduit la constante <code>CHUNK_SIZE</code> pour définir la taille de chaque morceau que nous allons lire/écrire à la fois. Cela permet de découper les opérations en blocs plus petits.
# Dans la boucle <code>for</code> où on parcours les blocs à partir de <code>offset</code>, j'ai ajouté une boucle interne qui parcourt les données du bloc en morceaux de taille <code>CHUNK_SIZE</code>.
# À l'intérieur de la boucle interne, j'ai calculé la taille réelle du morceau (<code>chunkSize</code>) en prenant le minimum entre <code>CHUNK_SIZE</code> et la quantité de données restant à lire/écrire dans le bloc.
# J'ai modifié la fonction <code>readBlock</code> pour lire seulement la quantité de données spécifiée par <code>chunkSize</code> à partir de <code>chunkStart</code>. Ces données sont stockées dans le tableau <code>fileBuffer</code>.
# Ensuite, j'ai effectué les mêmes opérations de libération des blocs associés au fichier, en parcourant les données du morceau et en marquant les blocs comme disponibles.
# Finalement, j'ai utilisé la fonction <code>writeBlock</code> pour écrire le morceau de données modifié dans le bloc, en utilisant la même <code>chunkStart</code> pour déterminer où écrire les données.

#define CHUNK_SIZE 64

int min(int a, int b) {
return a < b ? a : b;
}

void RM(const char *filesystem_path, const char *filename) {
int fileFound = -1;
int offset;
unsigned char fileBuffer[BLOCK_SIZE];

// Parcourir les blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char *)filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {
// Effacer le nom du fichier dans le superbloc
memset(filenameBuffer, 0, MAX_FILENAME_LENGTH);
writeBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);
fileFound = 1;
offset = blockNum;
break;
}
}

// Fin de fonction si fichier inexistant
if (fileFound == -1) {
printf("Le fichier \"%s\" n'a pas été trouvé.\n", filename);
return;
}

for (int blockNum = offset; blockNum < offset + 16; blockNum++) {
int startOffset = 0;

if (blockNum == offset) {
startOffset = MAX_FILENAME_LENGTH;
}

for (int chunkStart = startOffset; chunkStart < BLOCK_SIZE; chunkStart += CHUNK_SIZE) {
int chunkSize = min(CHUNK_SIZE, BLOCK_SIZE - chunkStart);
readBlock(blockNum, chunkStart, fileBuffer, chunkSize);

for (int i = 0; i < chunkSize; i += 2) {
int blockNumData = (fileBuffer[i] << 8) | fileBuffer[i + 1];
if (blockNumData == 0) {
writeBlock(blockNum, chunkStart, fileBuffer, chunkSize);
printf("Le fichier \"%s\" a été supprimé avec succès.\n", filename);
return; // Sortir des boucles
}
setBlockAvailability(blockNumData, 0); // Marquer le bloc comme disponible
fileBuffer[i] = 0;
fileBuffer[i + 1] = 0;
}

writeBlock(blockNum, chunkStart, fileBuffer, chunkSize);
}
}

printf("Le fichier \"%s\" a été supprimé avec succès.\n", filename);
}

ReX : Si on trouve un n° de bloc de données à 0, il faut sortir des deux boucles les plus externes après avoir fait le <code>writeBlock</code>.

Amine: Modification faites ci-dessus. Maintenant, dès qu'on trouve un n° de bloc de données à 0 dans la boucle la plus interne, on effectue le <code>writeBlock</code> et ensuite on utilise <code>return</code> pour sortir des deux boucles les plus externes. Cela permet d'optimiser le code en évitant de continuer à traiter inutilement le reste des blocs.

ReX : Pas très propre (duplication de code) mais nous allons nous en contenter.

=== Fonction intermédiaire TYPE version 1 ===

J'ai également commencé à réfléchir à la fonction TYPE. Pour l'instant, elle ne fait qu'ajouter les noms de fichier dans le superbloc. Cela permet de pouvoir tester les fonctions LS et RM (voir dans la rubrique compilation et exécution comment utiliser le programme).
// Fonction pour créer un fichier avec le nom donné et le contenu fourni en entrée standard
void TYPE(const char *filesystem_path, const char *filename) {
unsigned char buffer[MAX_FILENAME_LENGTH];
// Parcours des blocs réservés pour la description des fichiers
for (int blockNum = 0; blockNum <= MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, MAX_FILENAME_LENGTH);
// Vérifier si le bloc est vide (pas de nom de fichier)
if (buffer[0] == 0) {
// Écrire le nom du fichier dans l'emplacement vide du superbloc
writeBlock(blockNum, 0, (const unsigned char *)filename, MAX_FILENAME_LENGTH);
break; // Fichier créé, sortir de la boucle
}
}
printf("Le fichier \"%s\" a été créé avec succès.\n", filename);
}

ReX : Si la boucle se termine sans trouver de slot libre le message de succès s'affiche tout de même.

ReX : Le paramètre <code>filename</code> n'a pas forcément une taille de <code>MAX_FILENAME_LENGTH</code>.

Selon moi, la fonction TYPE devra respecter 3 étapes:

# Enregistrement du Nom du Fichier: L'ajout du nom du fichier dans un des blocs de la première partie du superbloc.
# Stockage des Données du Fichier: La récupération des données saisies en entrée standard par l'utilisateur et leur stockage dans des blocs du système de fichiers à partir d'une certaine position, comme le bloc 1040.
# Mise à Jour de la Disponibilité des Blocs: L'indication que les blocs dans lesquels les données ont été écrites ne sont plus disponibles en modifiant les bits correspondants dans la deuxième partie du superbloc (les 16 derniers blocs du super bloc).

ReX : Relis le point 3 et dit moi si tu te comprends toi même ?

Amine: Ma phrase n'est effectivement pas très claire. Je voulais dire que la fonction TYPE devra mettre à jour la carte de disponibilité du superbloc. C'est à dire que lorsqu'elle écrira des données dans des blocs, elle devra indiquer dans la carte de disponibilités que ces blocs ne sont plus disponibles.

=== Fonction intermédiaire TYPE version 2 ===

Suite à vos remarques, j'ai apporté les modifications suivantes à la fonction TYPE:

* j'ai ajouté une condition pour l'affichage du message de succès de la création d'un fichier (placeFound).

* le paramètre <code>filename</code> n'ayant pas forcément une taille de <code>MAX_FILENAME_LENGTH</code>, je calcule maintenant la longueur de filename, afin d'écrire seulement le nom du fichier avec la fonction writeBlock.

Il fonction n'est bien évidemment pas fini, elle ajoute seulement le nom du fichier dans le superbloc pour l'instant. Cela me permet de tester les fonctions LS et RM.
void TYPE(const char *filesystem_path, const char *filename) {
size_t sizeFilename = strlen(filename);
printf("size filename=%d\n", sizeFilename);
unsigned char buffer[MAX_FILENAME_LENGTH];
int placeFound = 0;

if (sizeFilename > MAX_FILENAME_LENGTH) {
printf("Impossible de créer le fichier, nom trop long\n");
return;
}

// Parcours des blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, MAX_FILENAME_LENGTH);
// Vérifier si le bloc est vide (pas de nom de fichier)
if (buffer[0] == 0) {
// Écrire le nom du fichier dans l'emplacement vide du superbloc
if (sizeFilename < MAX_FILENAME_LENGTH) {
sizeFilename+=1;
}
writeBlock(blockNum, 0, (const unsigned char *)filename, sizeFilename);
placeFound = 1;
break; // Fichier créé, sortir de la boucle
}
}
if (placeFound == 1) {
printf("Le fichier \"%s\" a été créé avec succès.\n", filename);
} else {
printf("Plus de place dans le système de fichier pour créer ce fichier.\n", filename);
}
}

ReX : Mieux, attention il faut copier aussi le <code>\'0</code> final du nom, donc <code>sizeFilename+1</code>. Sinon tu n'es pas sûr qu'il y ait un zéro final. Et attention n°2, il ne faut pas copier ce <code>\'0</code> si le nom fait la taille maximale.

Amine: ok j'ai modifié la fonction TYPE ci-dessus. J'ai ajouté une condition: si le nom du fichier est inférieur à la taille maximale de nom de fichier, alors on incrémente de 1 la taille du nom de fichier. Cela nous permet d'écrire le '\0' dans le bloc de description. Dans le cas où le nom du fichier est de la taille maximale, nous n'avons pas besoin d'écrire le '\0', on n'incrémente donc pas la taille de 1.

J'ai également ajouté une condition: si le nom du fichier est supérieur à la taille maximale, alors un message d'erreur s'affiche et le fichier n'est pas créé.

ReX : OK. L'embryon de fonction <code>TYPE</code> est correct, il manque juste le principal : la création des blocs de données.

=== Fonction MV version 1 ===

J'ai ici créé la fonction MV qui permet de changer le nom d'un fichier. Pour ce faire, la fonction parcourt les blocs de descriptions à la recherche du fichier dont on veut changer le nom. Lorsque ce fichier est trouvé, on supprime l'ancien nom en mettant des 0 sur 16 octets, puis on vient réécrire le nouveau nom dans le même emplacement. Enfin, on sort de la boucle et on affiche le succès ou non de l'opération.
// Fonction qui modifie le nom du fichier
void MV(const char *filesystem_path, const char *old_filename, const char *new_filename) {
size_t sizeNew_filename = strlen(new_filename);
size_t sizeOld_filename = strlen(old_filename);
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
int fileFound = 0;
// Parcourir les blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);
// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char*)filenameBuffer, old_filename, MAX_FILENAME_LENGTH) == 0) {
// Effacer le nom du fichier dans le superbloc
memset(filenameBuffer, 0, MAX_FILENAME_LENGTH);
writeBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);
// Écrire le nom du fichier dans l'emplacement
writeBlock(blockNum, 0, (const unsigned char *)new_filename, sizeNew_filename);
fileFound=1;
break; // Nom modifié, sortir de la boucle
}
}
if (fileFound == 1) {
printf("Le nom du fichier \"%s\" a été renommé avec succès.\n", old_filename);
} else {
printf("Le fichier \"%s\" n'a pas été trouvé.\n", old_filename);
}
}

ReX : Inutile d'écraser l'ancien nom avec des zéros. Il suffit de copier le nouveau en s'assurant qu'il y ait un zéro final sauf si le nouveau nom fait la taille maximale.

Amine: ok, je vais faire les modifications dans la version 2.

== Semaine 6 ==

=== Fonction MV version 2 ===
Dans cette nouvelle version de la fonction MV, j'ai effectué les modifications suivantes:

* je n'écrase plus l'ancien nom avec des 0
* Je colle simplement le nouveau nom par dessus l'ancien, en m'assurant qu'il y ait bien le '\0' à la fin lorsque la taille du nom du fichier est inférieur à la taille maximale. Comme précédemment, afin de m'assurer de la présence de ce '\0' à la fin du nom, j'incrémente la taille de 1 lorsque qu'elle est inférieur à la taille max. Cependant, je ne suis pas sûr à 100% que ce soit la bonne manière de faire.

// Fonction qui modifie le nom du fichier
void MV(const char *filesystem_path, const char *old_filename, const char *new_filename) {
size_t sizeNew_filename = strlen(new_filename);
size_t sizeOld_filename = strlen(old_filename);
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
int fileFound = 0;

// Parcourir les blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {

readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char*)filenameBuffer, old_filename, MAX_FILENAME_LENGTH) == 0) {

if (sizeNew_filename < MAX_FILENAME_LENGTH) {
sizeNew_filename+=1;
}

// Écrire le nom du fichier dans l'emplacement
writeBlock(blockNum, 0, (const unsigned char *)new_filename, sizeNew_filename);

fileFound=1;

break; // Nom modifié, sortir de la boucle
}
}
if (fileFound == 1) {
printf("Le nom du fichier \"%s\" a été renommé avec succès.\n", old_filename);
} else {
printf("Le fichier \"%s\" n'a pas été trouvé.\n", old_filename);
}
}

ReX : C'est bon. La fonction était triviale.

=== Fonction TYPE version 1 ===
void TYPE(const char *filesystem_path, const char *filename) {
size_t sizeFilename = strlen(filename);
unsigned char buffer[MAX_FILENAME_LENGTH];
int placeFound = -1;

if (sizeFilename > MAX_FILENAME_LENGTH) {
printf("Impossible de créer le fichier, nom trop long\n");
return;
}

// Parcours des blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, MAX_FILENAME_LENGTH);
// Vérifier si le bloc est vide (pas de nom de fichier)
if (buffer[0] == 0) {
// Écrire le nom du fichier dans l'emplacement vide du superbloc
if (sizeFilename < MAX_FILENAME_LENGTH) {
sizeFilename += 1; // Ajouter '\0' s'il y a de la place
}
writeBlock(blockNum, 0, (const unsigned char *)filename, sizeFilename);
placeFound = blockNum;

// Lire les données depuis l'entrée standard
unsigned char dataBuffer[BLOCK_SIZE];
size_t bytesRead;
int dataBlockNum = findAvailableBlock(); // Premier bloc de données à partir du bloc 1040
printf("dataBlockNum%d\n",dataBlockNum);
int blockSizeUsed = 0; // Compteur d'octets dans le bloc actuel
int dataBlocksNeeded = 1; // Nombre de blocs de données nécessaires

while ((bytesRead = fread(dataBuffer + blockSizeUsed, 1, BLOCK_SIZE - blockSizeUsed, stdin)) > 0) {
blockSizeUsed += bytesRead;

// Si le bloc actuel est plein, passer au bloc suivant
if (blockSizeUsed == BLOCK_SIZE) {
// printf("dataBlockNum=%d\n",dataBlockNum);
writeBlock(dataBlockNum, 0, dataBuffer, BLOCK_SIZE);
setBlockAvailability(dataBlockNum, 1);

dataBlockNum++; // Passer au bloc suivant
blockSizeUsed = 0; // Réinitialiser la taille utilisée
dataBlocksNeeded++;
}
}

// Écrire le dernier bloc partiel, s'il y en a un
if (blockSizeUsed > 0) {
writeBlock(dataBlockNum, 0, dataBuffer, blockSizeUsed);
setBlockAvailability(dataBlockNum, 1);
}

// Écrire les numéros de blocs utilisés dans le bloc de description
unsigned char blockNumberBuffer[2];
int currentBlockNum = 1040;

for (int i = 0; i < dataBlocksNeeded; i++) {
blockNumberBuffer[0] = (currentBlockNum >> 8) & 0xFF;
blockNumberBuffer[1] = currentBlockNum & 0xFF;
writeBlock(placeFound, MAX_FILENAME_LENGTH + i * 2, blockNumberBuffer, 2);
currentBlockNum++;
}

break; // Fichier créé, sortir de la boucle
}
}

if (placeFound != -1) {
printf("Le fichier \"%s\" a été créé avec succès.\n", filename);
} else {
printf("Plus de place dans le système de fichier pour créer ce fichier.\n");
}
}

ReX : La constante 1040 ne doit pas apparaître en numérique, ce doit être une constante calculée à partir des autres constantes.

Amine: Ok. Je ne l'avais pas défini comme une constante car il s'agit dans la fonction ci-dessus d'une variable qui est incrémenté à chaque itération.

ReX : Je suis las de te répéter que le mémoire est comptée : tu utilises encore un bloc de <code>BLOCK_SIZE</code> octets, c'est trop.

Amine: Comment utiliser des blocs plus petit sachant qu'il s'agit là de blocs de données et qu'un bloc fait 256 octets d'après l'énoncé ? Dois-je les subdiviser en plusieurs blocs plus petit comme fait dans la fonction RM, en 4 blocs de 64 octets par exemple ?

Fonctionnement de la fonction TYPE:

* étape 1: on parcourt les blocs de descriptions à la recherche d'un bloc disponible. Si on ne trouve pas de bloc disponible, on renvoie un message d'erreur, sinon on passe à l'étape suivante.
* étape 2: Si on trouve un emplacement libre dans les blocs de disponibilité, on écrit le nom du fichier dans cet emplacement.

ReX : Dans les blocs de description de fichiers pas dans les blocs de disponibilité.

Amine: Oui autant pour moi.

* étape 3: Ensuite, on lit le texte entré par l'utilisateur en entrée standard, on le répartit dans des blocs de taille BLOCK_SIZE, on met à jour la disponibilité des blocs utilisés.

ReX : Non, il faut appeler <code>findAvailableBlock</code> pour chaque bloc de données à utiliser, aucune certitudes que les blocs libres soient en séquence.

Amine: ok, je ferai cela dans la version 2

* étape 4: Enfin, on écrit les numéros des blocs de données utilisés dans les blocs de description de ce fichier, les numéros étant écris sur deux octets.

ReX : Non cela doit se faire au fur et à mesure des appels à <code>findAvailableBlock</code> et les numéros des blocs de données peuvent s'étaler sur les 16 blocs de description du fichier. Confusion totale sur ce point. Vous n'avez pas compris le mécanisme.

Amine: je corrige cela dans la version 2. J'ai bien compris le mécanisme mais ce n'est pas facile à traduire en code.

=== Fonction TYPE version 2 ===
Dans cette nouvelle version de TYPE, j'ai fait les modifications suivantes:

* j'appelle maintenant <code>findAvailableBlock</code> pour chaque bloc de données à utiliser
* j'écris maintenant les numéros de blocs au fur et à mesures des appels à <code>findAvailableBlock</code>
* je n'utilise plus de tableaux de taille 256 octets mais des tableaux de tailles CHUNK_SIZE. J'ai choisi ici CHUNK_SIZE = 64 octets.

J'utilise toujours un bloc de taille BLOCK_SIZE en attendant de comprendre si je dois diviser ce bloc en plusieurs blocs de taille plus petite ou s'il y a un moyen de ne pas du tout utiliser ces blocs.
void TYPE(const char *filesystem_path, const char *filename) {
size_t sizeFilename = strlen(filename);
unsigned char buffer[MAX_FILENAME_LENGTH];
int placeFound = -1;

if (sizeFilename > MAX_FILENAME_LENGTH) {
printf("Impossible de créer le fichier, nom trop long\n");
return;
}

// Parcours des blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, MAX_FILENAME_LENGTH);
// Vérifier si le bloc est vide (pas de nom de fichier)
if (buffer[0] == 0) {
// Écrire le nom du fichier dans l'emplacement vide du superbloc
if (sizeFilename < MAX_FILENAME_LENGTH) {
sizeFilename += 1; // Ajouter '\0' s'il y a de la place
}
writeBlock(blockNum, 0, (const unsigned char *)filename, sizeFilename);
placeFound = blockNum;

// Lire les données depuis l'entrée standard et écrire dans le fichier
int dataBlockNum = findAvailableBlock(); // Premier bloc de données à partir du bloc 1040
printf("Premier bloc dans lequel on écrit = %d\n", dataBlockNum);
int blockSizeUsed = 0; // Compteur d'octets dans le bloc actuel

unsigned char chunkBuffer[CHUNK_SIZE];
size_t bytesRead;

while ((bytesRead = fread(chunkBuffer, 1, CHUNK_SIZE, stdin)) > 0) {
// Écrire le chunk dans le bloc de données
writeBlock(dataBlockNum, blockSizeUsed, chunkBuffer, bytesRead);
setBlockAvailability(dataBlockNum, 1);

// Écrire le numéro du bloc actuel dans la description du fichier
unsigned char blockNumberBuffer[2];
blockNumberBuffer[0] = (dataBlockNum >> 8) & 0xFF;
blockNumberBuffer[1] = dataBlockNum & 0xFF;
writeBlock(placeFound, MAX_FILENAME_LENGTH + dataBlockNum * 2, blockNumberBuffer, 2);

blockSizeUsed += bytesRead;

// Si le bloc actuel est plein, passer au bloc suivant
if (blockSizeUsed == BLOCK_SIZE) {
dataBlockNum = findAvailableBlock(); // Passer au bloc suivant
blockSizeUsed = 0; // Réinitialiser la taille utilisée
}
}

break; // Fichier créé, sortir de la boucle
}
}

if (placeFound != -1) {
printf("Le fichier \"%s\" a été créé avec succès.\n", filename);
} else {
printf("Plus de place dans le système de fichier pour créer ce fichier.\n");
}
}

=== Fonction findAvailableBlock ===
Cette fonction renvoie l'indice du premier bloc disponible. Je me sers de cette fonction dans la fonction TYPE.
#define FIRST_DATA_BLOCK 1040
#define FIRST_DISPONIBILITY_CARD_BLOCK 1024

// Renvoie le premier bloc de donné disponible
int findAvailableBlock() {
unsigned char availabilityBuffer[BLOCK_SIZE];
int offset;

// Lire la carte de disponibilité (à partir du bloc 1)
for (int blockNum = FIRST_DISPONIBILITY_CARD_BLOCK; blockNum < FIRST_DATA_BLOCK; blockNum++) {
readBlock(blockNum, 0, availabilityBuffer, BLOCK_SIZE);

if (blockNum==FIRST_DISPONIBILITY_CARD_BLOCK) {
offset=FIRST_DATA_BLOCK/8;
} else {
offset=0;
}

// Parcourir les octets de la carte de disponibilité
for (int byteIndex = offset; byteIndex < BLOCK_SIZE - offset; byteIndex++) {
unsigned char byte = availabilityBuffer[byteIndex];

// Parcourir les bits de chaque octet
for (int bitIndex = 0; bitIndex < 8; bitIndex++) {
// Vérifier si le bit est à 0 (bloc disponible)
if ((byte & (1 << bitIndex)) == 0) {
// Calculer l'indice du bloc en fonction du bloc et du bit
int blockIndex = byteIndex * 8 + bitIndex;
return blockIndex;
}
}
}
}

// Aucun bloc disponible trouvé
return -1;
}

ReX : Même remarque que précédement sur les nombres 1024 et 1040.

Amine: Ok, j'ai remplacé 1024 par la constante FIRST_DISPONIBILITY_CARD_BLOCK et 1040 par la constante FIRST_DATA_BLOCK dans la fonction ci-dessus.

ReX : Vous n'avez toujours pas compris la contrainte sur la mémoire.

Amine: dois-je découper le bloc de taille BLOCK_SIZE en quatre blocs de taille 64 octets par exemple ?

ReX : Je ne vois pas ce que vous voulez faire avec <code>if (blockNum==1024) offset=1040/8; else offset=0;</code>.

Amine: dans la carte de disponibilité, chaque bit correspond à un bloc. Ainsi, les bits de 0 à 1040 dans la carte de disponibilité décrivent la disponibilité des blocs 0 à 1040. Or ces blocs correspondent au superbloc, et dans cette fonction, on veut connaître le premier bloc de données disponible. On ne s'intéresse donc pas au 1040 premiers bits de la carte de disponibilité. Je crée donc un offset égal à 1040/8 afin de ne pas prendre en compte les 1040 premiers bits soit les 1040/8=130 premiers octets. Cet offset ne s'applique que lorsqu'on se trouve dans le premier des 16 blocs de la carte de disponibilité, d'où la condition <code>if (blockNum==1024)</code>.

ReX : OK, bien vu.

=== Fonction CAT version 1 ===
void CAT(const char *filesystem_path, const char *filename) {
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
unsigned char buffer[BLOCK_SIZE];
unsigned char blockNumberBuffer[2];
unsigned char dataBuffer[BLOCK_SIZE];
int offset;

// Parcours des blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char *)filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {
// Le nom du fichier a été trouvé

// Parcours les blocs de description
for (int descrBlockNum=0; descrBlockNum<MAX_BLOCKS_PER_FILE_DESCRIPTION; descrBlockNum++) {
if (descrBlockNum==0) {
offset=16;
} else {
offset=0;
}
readBlock(descrBlockNum+blockNum, offset, buffer, BLOCK_SIZE-offset);

// Lire les numéros de blocs associés à ce fichier depuis les blocs de description
unsigned char octet1 = buffer[offset];
unsigned char octet2 = buffer[offset+1];

int dataBlockNum = (octet1 << 8) | octet2;
printf("dataBlockNum=%d\n",dataBlockNum);

// Vérifier si le numéro de bloc est valide (non nul)
if (dataBlockNum == 0) {
return; // Fin du fichier
}

// Lire et afficher le contenu du bloc de données
readBlock(dataBlockNum, 0, dataBuffer, BLOCK_SIZE);
fwrite(dataBuffer, 1, BLOCK_SIZE, stdout);
}

return; // Fichier affiché, sortie de la fonction
}
}

// Si le fichier n'a pas été trouvé
printf("Le fichier \"%s\" n'a pas été trouvé.\n", filename);
}

ReX : Encore mieux : deux blocs de <code>BLOCK_SIZE</code> en mémoire.

ReX : Le <code>break</code> ne sort pas de la boucle externe.

Amine: Oui c'est vrai. J'ai remplacé le <code>break</code> par un <code>return</code> ci-dessus.

ReX : Dans le cadre de la fonction CAT le <code>return</code> est convenable.

Voici ma fonction <code>CAT</code>. Elle fonctionne en plusieurs étape:

* étape 1: on cherche dans les blocs de descriptions si le fichier dont on veut afficher le contenu existe. Si le nom de fichier est trouvé, on passe à l'étape 2. Sinon, on renvoie un message d'erreur.
* étape 2: si le fichier est trouvé, on parcours les 16 blocs de description de ce fichier.
* étape 3: grâce aux opérations de masquage et de décalage, on joint les octets deux par deux pour former un entier qui contient le numéro du bloc de données correspondant au fichier. Si cet entier vaut 0, alors cela signifie qu'il n'y a plus de blocs associé à ce fichier, on peut donc quitter la fonction. Si cet entier est différent de 0, alors on va lire le bloc correspondant à ce numéro et on affiche son contenu dans le terminal.

== Semaine 7 ==

=== Fonction CP version 1 ===
Voici ma fonction CP, qui permet de créer une copie d'un fichier existant. L'idée est la suivante: pour copier un fichier, on doit créer un nouveau fichier et lui attribuer les mêmes blocs de descriptions que le fichier source. Ainsi, le fichier source et le fichier destination pointeront vers les mêmes blocs de données, et auront le même contenu.

ReX : Perdu. Ce n'est absolument pas la fonction de copie de fichiers d'un système de fichiers.

Amine: Après avoir fait des recherches et après réflexion, je me rends compte que cette fonction CP présente un problème: en faisant pointer les blocs de données du fichier destination vers ceux du fichier source, toute modification du fichier source impactera le fichier destination, or ce n'est pas ce qu'on veut faire. Je vous propose donc une nouvelle version de la fonction CP ci-dessous qui remédie à ce problème.

void CP(const char *filesystem_path, const char *source_filename, const char *destination_filename) {
unsigned char source_filenameBuffer[MAX_FILENAME_LENGTH];
unsigned char destination_filenameBuffer[MAX_FILENAME_LENGTH];
unsigned char descriptionBuffer[BLOCK_SIZE];
int destination_offset;
int offset;

// Recherche du fichier source
int source_offset = -1;
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, source_filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier source
if (strncmp((const char *)source_filenameBuffer, source_filename, MAX_FILENAME_LENGTH) == 0) {
source_offset = blockNum;
break;
}
}

if (source_offset == -1) {
printf("Le fichier source \"%s\" n'a pas été trouvé.\n", source_filename);
return;
}

// Recherche d'un emplacement libre pour le fichier destination
destination_offset = -1;
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, destination_filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc est vide (pas de nom de fichier)
if (destination_filenameBuffer[0] == 0) {
destination_offset = blockNum;
break;
}
}

if (destination_offset == -1) {
printf("Plus de place dans le système de fichier pour créer la copie de \"%s\".\n", source_filename);
return;
}

// Ecrit le nom de la copie dans le bloc de description
writeBlock(destination_offset, 0, (const unsigned char *)destination_filename, strlen(destination_filename));

// Copier les blocs de description associés au fichier source dans les blocs de description du fichier destination
for (int i = 0; i < MAX_BLOCKS_PER_FILE_DESCRIPTION; i++) {
if (i==0) {
offset = MAX_FILENAME_LENGTH;
} else {
offset = 0;
}

readBlock(source_offset+i, offset, descriptionBuffer, BLOCK_SIZE-offset);
if (descriptionBuffer[offset]==0) {
return;
} else {
writeBlock(destination_offset+i, offset, descriptionBuffer, BLOCK_SIZE-offset);
}
}

printf("La copie de \"%s\" sous le nom \"%s\" a été créée avec succès.\n", source_filename, destination_filename);
}

ReX : Pas mieux.

== Semaine 8 ==
A ce stade du projet, les fonctions suivantes ont été validé par Monsieur Redon:

* fonction LS
* fonction RM
* fonction MV

Il reste donc les fonctions suivantes à terminer:

* fonction CAT
* fonction CP
* fonction TYPE

=== Fonction CAT version 2 ===
Suite à vos remarques sur la version 1, j'ai fais les modifications suivantes:

* je n'utilise non plus 2 tableaux de taille BLOCK_SIZE, mais 1 seul. Idéalement il faudrait en utiliser 0, je réfléchi donc à m’émanciper de ce tableau en le remplaçant par plusieurs plus petits tableaux.

ReX : Un seul plus petit.

* J'ai remplacé le <code>break</code> par un <code>return</code>

ReX : Déjà validé.

Cette fonction permet d'afficher le contenu d'un fichier créé avec la fonction TYPE. Pour se faire, on parcours tout d'abord les blocs de descriptions pour trouver le fichier dont ont veut afficher le contenu. Une fois ce fichier trouvé, on parcours les 16 blocs de description de ce fichier 1 à 1. Pour chacun de ces blocs de description, on va stocker récupéré les octets deux par deux afin de former des entiers. Pour se faire, on utilise la fonction <code>reconstituteNumber</code> que l'on détaillera juste après. Ces entiers correspondent aux blocs dans lesquels la donné du fichier se trouve. Une fois l'entier reconstitué, on affiche le contenu du bloc correspondant.
#define CHUNK_SIZE 64

void CAT(const char *filesystem_path, const char *filename) {
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
unsigned char byteBuffer[2];
unsigned char dataBuffer[CHUNK_SIZE];
int offset;

// Parcours des blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char *)filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {
// Le nom du fichier a été trouvé

// Parcours les blocs de description
for (int descrBlockNum=0; descrBlockNum<MAX_BLOCKS_PER_FILE_DESCRIPTION; descrBlockNum++) {
if (descrBlockNum==0) {
offset=MAX_FILENAME_LENGTH;
} else {
offset=0;
}

// Lecture des octets deux par deux
for (int i=0; i<BLOCK_SIZE;i+=2) {
readBlock(descrBlockNum+blockNum, offset+i, byteBuffer, 2);

// Lire les numéros de blocs associés à ce fichier depuis les blocs de description
int dataBlockNum = reconstituteNumber(byteBuffer);

// Vérifier si le numéro de bloc est valide (non nul)
if (dataBlockNum == 0) {
return; // Fin du fichier
}

for (int chunkStart = 0; chunkStart < BLOCK_SIZE; chunkStart += CHUNK_SIZE) {
// Lire et afficher le contenu du bloc de données
readBlock(dataBlockNum, chunkStart, dataBuffer, CHUNK_SIZE);
fwrite(dataBuffer, 1, CHUNK_SIZE, stdout);
}
}
}

return; // Fichier affiché, sortie de la fonction
}
}

// Si le fichier n'a pas été trouvé
printf("Le fichier \"%s\" n'a pas été trouvé.\n", filename);
}

ReX : Remplacer le premier bloc de <code>BLOCK_SIZE</code> octets par un bloc de 2 octets est exagéré mais cela pourrait passer. Il reste toujours un bloc de <code>BLOCK_SIZE</code> octets dont il est facile de se passer au bénéfice d'un bloc de, mettons, 64 octets.

Amine: Voilà! Dans la version ci-dessus j'ai remplacé le bloc de taille <code>BLOC_SIZE</code> par un bloc de taille <code>CHUNK_SIZE</code>, avec <code>CHUNK_SIZE</code> modifiable dans les constantes du programme. J'ai pris ici 64 octets.

ReX : OK.

=== Fonction reconstituteNumber ===
Cette fonction permet de reconstituer un numéro de bloc à partir de deux octets.
// Fonction qui reconstitue le numéro de bloc à partir du tableau
int reconstituteNumber(unsigned char blockNumberBuffer[2]) {
unsigned char octet1 = blockNumberBuffer[0];
unsigned char octet2 = blockNumberBuffer[1];
int dataBlockNum = (octet1 << 8) | octet2;
return dataBlockNum;
}

ReX : Bonne idée cette fonction.

=== Fonction CP version 2 ===
Voici une version mise à jour de notre fonction CP. Dans la version précédente, on faisait pointer le fichier source vers les même blocs que le fichier destination. Cela posait un problème: toute modification du fichier source impactait le fichier destination. Ainsi, dans cette nouvelle version, on fait une duplication des blocs de données du fichier source vers le fichier destination. Cela implique donc une mise à jour de la carte de disponibilité, ainsi que l'adaptation des blocs de descriptions. En effet, seulement les blocs de données sont maintenant identiques, plus les blocs de description.

Piste d'amélioration: comme pour la fonction CAT ci-dessus, j'utilise toujours un bloc de taille 256 octets, je vais devoir y remédier.
// Fonction pour copier un fichier existant du système de fichier
void CP(const char *filesystem_path, const char *source_filename, const char *destination_filename) {
unsigned char source_filenameBuffer[MAX_FILENAME_LENGTH];
unsigned char destination_filenameBuffer[MAX_FILENAME_LENGTH];
unsigned char descriptionBuffer[CHUNK_SIZE];
unsigned char numBuffer[2];
int destination_offset;
int source_offset;
int offset;
int numDataBlock;
int newDataBlock;

// Recherche du fichier source
source_offset = -1;
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, source_filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier source
if (strncmp((const char *)source_filenameBuffer, source_filename, MAX_FILENAME_LENGTH) == 0) {
source_offset = blockNum;
break;
}
}

if (source_offset == -1) {
printf("Le fichier source \"%s\" n'a pas été trouvé.\n", source_filename);
return;
}

// Recherche d'un emplacement libre pour le fichier destination
destination_offset = -1;
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, destination_filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc est vide (pas de nom de fichier)
if (destination_filenameBuffer[0] == 0) {
destination_offset = blockNum;
break;
}
}

if (destination_offset == -1) {
printf("Plus de place dans le système de fichier pour créer la copie de \"%s\".\n", source_filename);
return;
}

// Copie du nom de la copie dans le bloc de description
writeBlock(destination_offset, 0, (const unsigned char *)destination_filename, strlen(destination_filename));

// Copier les blocs de données associés au fichier source dans de nouveaux blocs de données pour le fichier destination
for (int i = 0; i < MAX_BLOCKS_PER_FILE_DESCRIPTION; i++) {
if (i == 0) { offset = MAX_FILENAME_LENGTH; }
else { offset = 0; }

// Lecture des numéros de bloc dans les blocs de description
for (int byteNum=0; byteNum<BLOCK_SIZE; byteNum+=2) {
readBlock(source_offset+i, offset+byteNum, numBuffer, 2);

numDataBlock = reconstituteNumber(numBuffer);
if (numDataBlock == 0) {
printf("La copie de \"%s\" sous le nom \"%s\" a été créée avec succès.\n", source_filename, destination_filename);
return;
}

for (int chunkStart = 0; chunkStart < BLOCK_SIZE; chunkStart += CHUNK_SIZE) {
// On stocke le bloc de données associé au fichier source dans descriptionBuffer
readBlock(numDataBlock, chunkStart, descriptionBuffer, CHUNK_SIZE);

if (chunkStart == 0) {
// Trouver un nouveau bloc de données disponible
newDataBlock = findAvailableBlock();

// Mise à jour de la carte de disponibilités
setBlockAvailability(newDataBlock, 1);

// Ecriture du numéro de bloc dans la description du fichier
createNumberBuffer(newDataBlock,numBuffer);
writeBlock(destination_offset+i, offset+byteNum, numBuffer, 2);
}

// Ecriture du bloc de données dans le premier bloc disponible
writeBlock(newDataBlock, chunkStart, descriptionBuffer, CHUNK_SIZE);
}
}
}
}

ReX : Youpi. Il reste à se passer du bloc de <code>BLOCK_SIZE</code> (au bénéfice d'un bloc de taille <code>BLOCK_SIZE/n</code> avec n>1). Ecrire la fonction inverse de <code>reconsituteNumber</code>.

Amine: Voilà! Dans le fonction ci-dessus il n'y a plus de bloc de taille <code>BLOCK_SIZE</code>, on a maintenant des blocs de 64 octets (<code>CHUNK_SIZE</code>). J'ai également créé la fonction <code>createNumberBuffer</code> qui est la fonction inverse de<code>reconstituteNumber</code>. Je la détaille ci-dessous.

ReX : OK.

=== Fonction createNumberBuffer ===
Cette fonction permet repartir un entier sur deux octets.
// Fonction qui réparti un numéro de bloc sur deux octets
void createNumberBuffer(int dataBlockNum, unsigned char blockNumberBuffer[2]) {
blockNumberBuffer[0] = (dataBlockNum >> 8) & 0xFF;
blockNumberBuffer[1] = dataBlockNum & 0xFF;
}

=== Fonction TYPE version 3 ===
La fonction 2 que j'ai fourni ci-dessus n'est pas correcte. Je vais la corriger dans cette version 3.

ReX : Effectivement la version précédente ne gére pas correctement l'écriture des numéros de blocs de données dans la description d'un fichier.

Voici ma version 3 de la fonction TYPE. Voici son fonctionnement:

* tout d'abord, la fonction parcourt les blocs de description à la recherche d'un emplacement vide ;
* une fois l'emplacement vide trouvé, elle écrit le nom du fichier dans cet emplacement ;
* ensuite, on passe à la lecture de l'entrée standard. J'ai essayé d'expliquer au fur et à mesure du programme ce que font les lignes importantes via les commentaires.
void TYPE(const char *filesystem_path, const char *filename) {
size_t sizeFilename = strlen(filename);
unsigned char buffer[MAX_FILENAME_LENGTH];
int placeFound = -1;
int index_description_block = 0; // indice du bloc de descrption
int block_counter = 1; //compteur de blocs utilisés
int index_in_descrBlock = 0;
int offset;
int first_loop=1;

if (sizeFilename > MAX_FILENAME_LENGTH) {
printf("Impossible de créer le fichier, nom trop long\n");
return;
}

// Parcours des blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, MAX_FILENAME_LENGTH);
// Vérifier si le bloc est vide (pas de nom de fichier)
if (buffer[0] == 0) {
// Écrire le nom du fichier dans l'emplacement vide du superbloc
if (sizeFilename < MAX_FILENAME_LENGTH) {
sizeFilename += 1; // Ajouter '\0' s'il y a de la place
}
writeBlock(blockNum, 0, (const unsigned char *)filename, sizeFilename);
placeFound = blockNum;

// Lire les données depuis l'entrée standard et écrire dans le fichier
int dataBlockNum = findAvailableBlock(); // Premier bloc de données à partir du bloc 1040
int blockSizeUsed = 0; // Compteur d'octets dans le bloc actuel

unsigned char chunkBuffer[CHUNK_SIZE];
size_t bytesRead;

while ((bytesRead = fread(chunkBuffer, 1, CHUNK_SIZE, stdin)) > 0) {

// Écrire le chunk dans le bloc de données
writeBlock(dataBlockNum, blockSizeUsed, chunkBuffer, bytesRead);

// Écrire le numéro du bloc actuel dans la description du fichier
unsigned char blockNumberBuffer[2];
createNumberBuffer(dataBlockNum,blockNumberBuffer);

blockSizeUsed += bytesRead;

// Si le bloc actuel est plein, passer au bloc suivant OU si c'est le premier tour dans la boucle
if (blockSizeUsed >= BLOCK_SIZE || first_loop == 1) {

// Mise à jour de la disponibilité du bloc
setBlockAvailability(dataBlockNum, 1);

first_loop = 0;

// Ecriture du numéro de bloc utilisé dans les blocs de description
if (index_description_block == 0) {
offset = MAX_FILENAME_LENGTH;
} else {
offset = 0;
}
// Ecriture du numéro de bloc dans le bloc de description
writeBlock(placeFound + index_description_block, offset + index_in_descrBlock*2, blockNumberBuffer, 2);
index_in_descrBlock++;

dataBlockNum = findAvailableBlock(); // Passer au bloc suivant
blockSizeUsed = 0; // Réinitialiser la taille utilisée

// Passage au bloc de description suivant
if (block_counter == (BLOCK_SIZE/2-offset)) {
index_description_block++;
index_in_descrBlock=0;
}

// Compteur de nombre de blocs utilisés
block_counter++;

// Vérifie si on a atteint le nombre maximal de blocs par fichier
if (block_counter >= MAX_BLOCKS_PER_FILE) {
printf("Le fichier a atteint sa taille maximale\n");
return;
}
}
}

break; // Fichier créé, sortir de la boucle
}
}

if (placeFound != -1) {
printf("Le fichier \"%s\" a été créé avec succès.\n", filename);
} else {
printf("Plus de place dans le système de fichier pour créer ce fichier.\n");
}
}

ReX : La fonction <code>setBlockAvailability</code> n'est pas placée au bon endroit, elle est parfois appelée inutilement.

Amine: Effectivement, on peut ne l'appeler que lorsqu'un bloc a été complètement rempli donc après la condition

ReX : La variable <code>blockSizeUsed</code> peut dépasser <code>BLOCK_SIZE</code> et cela donnera n'importe quoi.

Amine: C'est vrai, je vais donc remplacer la condition if <code>(blockSizeUsed == BLOCK_SIZE || first_loop == 1)</code> en <code>if (blockSizeUsed >= BLOCK_SIZE || first_loop == 1)</code>afin que la variable ne puisse pas dépasser <code>BLOCK_SIZE</code>.

ReX : Si tu écris ton premier "chunk" de données tu ne remplis pas le bloc de données et tu en réclames un suivant.

ReX : Pourquoi <code>block_counter</code> est initialisé à 1 ?

= Compilation et exécution =
'''Création du système de fichiers :'''
dd if=/dev/zero of=filesystem.bin bs=256 count=32768

'''Compilation :'''

gcc picofs.c -o picofs

'''Exécution de LS, TYPE, CAT, RM, MV ou CP :'''

./picofs filesystem.bin LS
./picofs filesystem.bin TYPE mon_fichier.txt
./picofs filesystem.bin CAT mon_fichier.txt
./picofs filesystem.bin RM mon_fichier.txt
./picofs filesystem.bin MV mon_fichier.txt mon_fichier2.txt
./picofs filesystem.bin CP mon_fichier.txt mon_fichier2.txt

= Documents Rendus =
[[Fichier:PicofsV2.c.tar|vignette]]

SE4 2022/2023 EC1

2023-09-04T18:36:53Z

Asellali : /* Fonction TYPE version 3 */

= Objectifs =

Il vous est demandé de :
* réaliser un micro système de fichiers ;
* le système de fichiers doit résider dans un fichier de 8 Mo ;
* le système de fichiers est géré par un exécutable obtenu à partir d'un programme C ;
* L'éxécutable prend deux arguments, le premier est le chemin du fichier dans lequel réside le système de fichiers, les paramètres suivants concernent l'action à appliquer sur le système de fichiers ;
* le micro système de fichier ne comporte qu'un répertoire : le répertoire principal, le répertoire principal peut comporter au maximum 64 fichiers, un fichier est caractérisé par un nom de 16 caractères au maximum et ses blocs de données, un fichier peut comporter au maximum 2040 blocs de données ;
* un bloc de données fait 256 octets et les blocs sont numérotés sur 2 octets ;
* les différentes actions possibles sur le système de fichiers sont :
** <code>TYPE</code> pour créer un fichier si possible, le nom du fichier suit la commande, le contenu du fichier est donné en entrée standard de l'exécutable ;
** <code>CAT</code> pour afficher un fichier, le nom du fichier suit la commande ;
** <code>RM</code> pour détruire un fichier, le nom du fichier suit la commande ;
** <code>MV</code> pour renommer un fichier, les noms original et nouveau du fichier suivent la commande ;
** <code>CP</code> pour copier un fichier, les noms de l'original et de la copie du fichier suivent la commande ;

= Matériel nécessaire =

Un PC sous Linux.

= Travail réalisé =

== Semaine 1 ==

ReX : attention, ce micro-système de fichiers est prévu pour un microcontrôleur, vos variables globales ne peuvent pas dépasser quelques centaines d'octets.

ReX : pour la création du système de fichiers la commande <code>dd</code> suffit, vous voulez dire le formatage du système de fichiers ?

* création du programme programme.c contenant les différentes structures et les différentes fonctions.
* Piste d'amélioration: faire en sorte que la fonction CAT affiche le contenu exact des fichiers passés en argument.

Le code fourni est un programme en langage C qui simule un système de fichiers basique. Ce programme permet aux utilisateurs d'effectuer diverses actions telles que créer, afficher, supprimer, renommer et copier des fichiers dans un système de fichiers simulé. Le système de fichiers est stocké dans un fichier binaire.

ReX : vous n'avez pas tenu compte de la première remarque, vous chargez tout le superbloc et le répertoire racine, votre code ne convient pas.

ReX : vos structures utilisent des types entiers dont la taille n'est pas explicitée, utilisez les types de <code>stdint.h</code>.

ReX : la création de fichier n'est pas fonctionnelle, vous ne cherchez pas les blocs libres, vous ne copiez pas le contenu du fichier dans les blocs, même remarque pour toutes les autres fonctions.

ReX : il manque les fonctions d'accès aux pages du système de fichiers.

'''Explication du programme programme.c'''

Voici une brève explication des principaux éléments et fonctions du code :

# Structures :
#* Fichier : Représente un fichier dans le système de fichiers. Il contient un nom (nom) avec une longueur maximale de 16 caractères, un tableau de numéros de bloc (blocs) où le contenu du fichier est stocké (jusqu'à 2040 blocs), et le nombre de blocs utilisés par le fichier (nbBlocs).
#* Repertoire : Représente le répertoire principal du système de fichiers. Il contient un tableau de fichiers (<code>fichiers</code>) et le nombre de fichiers dans le répertoire (<code>nbFichiers</code>).
# Fonctions :
#* <code>chargerSystemeFichiers</code> : Charge le système de fichiers à partir d'un fichier binaire donné (chemin) dans une structure Repertoire.
#* <code>sauvegarderSystemeFichiers</code> : Sauvegarde le système de fichiers stocké dans la structure Repertoire dans un fichier binaire (chemin).
#* <code>creerFichier</code> : Crée un nouveau fichier dans le système de fichiers avec un nom et un contenu donnés. Le contenu du fichier est simulé en le divisant en blocs.
#* <code>afficherFichier</code> : Affiche le contenu d'un fichier avec le nom spécifié.
#* <code>detruireFichier</code> : Supprime un fichier avec le nom spécifié du système de fichiers.
#* <code>renommerFichier</code> : Renomme un fichier avec l'ancien nom spécifié en un nouveau nom.
#* <code>copierFichier</code> : Copie un fichier avec le nom spécifié en créant un nouveau fichier avec le nom de copie spécifié.
# Fonction <code>main</code> :
#* La fonction <code>main</code> est le point d'entrée du programme.
#* Elle prend des arguments en ligne de commande : <code><chemin_systeme_fichiers></code> et <code><action></code>.
#* <code><chemin_systeme_fichiers></code> est le chemin vers le fichier binaire où le système de fichiers est stocké.
#* <code><action></code> détermine quelle opération effectuer, comme <code>TYPE</code>, <code>CAT</code>, <code>RM</code>, <code>MV</code> ou <code>CP</code>.
#* En fonction de l'action spécifiée, le programme appelle la fonction correspondante pour effectuer l'opération souhaitée sur le système de fichiers.
Remarque : Le code fourni une simulation basique d'un système de fichiers et de ses opérations, mais il n'interagit pas réellement avec un système de fichiers réel sur le disque.

'''Comment utiliser le programme programme.c'''

étape 1: création du système de fichiers respectant le cahier des charges:

dd if=/dev/zero of=systeme_fichiers.bin bs=1M count=8

étape 2: compilation du programme C:

gcc programme.c -o gestionnaire_fs

étape 3: création d'un fichier dans le système de fichier:

./gestionnaire_fs systeme_fichiers.bin TYPE fichier1.txt

-> entrer le texte en entrée standard

étape 4: manipulation des différentes fonctions. Exemples:

./gestionnaire_fs systeme_fichiers.bin CAT fichier1.txt
./gestionnaire_fs systeme_fichiers.bin CP fichier1.txt copie.txt
./gestionnaire_fs systeme_fichiers.bin RM copie.txt
./gestionnaire_fs systeme_fichiers.bin MV fichier1.txt fichier2.txt

== Semaine 2 ==

Amine: Merci pour vos remarques. Désolé de ne pas avoir suivi votre première remarque, je pensais avoir compris ce qu'il fallait faire mais je me rend compte que non. Je vais tout reprendre depuis le début afin de repartir sur de bonnes bases.

'''Création du système de fichier avec la commande "dd"'''

A quoi sert la commande dd?

La commande <code>dd</code> permet de copier tout ou partie d'un disque par blocs d'octets, indépendamment de la structure du contenu du disque en fichiers et en répertoires (source : [https://doc.ubuntu-fr.org/dd]).

Structure de la commande

dd if=<nowiki><source> of=<cible> bs=<taille des blocs></nowiki>

<code>source</code> = données à copier

<code>cible</code> = endroit où les copier

<code>if</code> = input file

<code>of</code> = output file

<code>bs</code> = block size, habituellement une puissance de 2 supérieure ou égale à 512, représentant un nombre d'octets

Choix de la commande:

Pour la source, on prends <code>/dev/zero</code>: cela permet de créer un fichier rempli de 0. Ce fichier servira de base pour notre système de fichiers.

Pour la cible, on va l'appeler <code>filesystem.bin</Code> : ce sera notre système de fichier.

Pour la taille des blocs, on veut des blocs de données de 256 octets d'après l'enoncé. On va donc prendre <code>bs=256</code>.

Enfin, on veut que le système de fichier réside dans un fichier de 8 Mo. On va donc ajouter <code>count=31250</code>: cela indique que nous voulons écrire 32768 blocs de données dans le fichier (31250 * 256 octets = 8 Mo).

Résultat:

dd if=/dev/zero of=filesystem.bin bs=256 count=31250

Question pour M. Redon : j'ai ici essayé de respecter votre remarque "pour la création du système de fichiers la commande <code>dd</code> suffit". Cependant, pour votre seconde remarque "vous chargez tout le superbloc et le répertoire racine, votre code ne convient pas.", je ne suis pas sûr de comprendre où je fais cela: est-ce lors de la commande dd ou est-ce par la suite avec mon programme C? J'ai un peu modifié la commande dd comme vous pouvez le voir ci-dessus. Ai-je corrigé mon erreur avec cette nouvelle commande? J'ai essayé de justifier au maximum la commande dd que j'ai choisie.

ReX : Pas de problème avec la commande <code>dd</code> (mettez tous les extraits de code entre des balises <code>code</code>). Le problème est au niveau du programme C.

Amine: Ok je comprends mieux merci. Je vais donc reprendre le code étape par étape afin de mieux répondre au cahier des charges.

Gestion du système de fichier par un programme C

'''Création des structures'''
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>

// Structure pour représenter un bloc de données

struct DataBlock {
uint8_t data[256]; // 256 octets pour chaque bloc de données
};

// Structure pour représenter un fichier

struct File {
char filename[17]; // 16 caractères pour le nom du fichier + 1 caractère null-terminator
struct DataBlock data_blocks[2040]; // Tableau de blocs de données pour stocker le contenu du fichier
uint16_t num_data_blocks; // Nombre de blocs de données utilisés par le fichier
};

// Structure pour représenter un répertoire

struct Directory {
struct File files[64]; // Tableau de fichiers pour le répertoire principal
uint8_t num_files; // Nombre de fichiers dans le répertoire principal
};

Modification faite : suite à votre remarque, j'ai explicité la taille des entiers grâce aux types de <code>stdint.h.</code> (j'ai également mis les variables en anglais)

ReX : Vous ne pouvez pas utiliser ces structures, une instanciation d'une de ces structure prend trop d'espace mémoire, vous devez faire sans structure. Par ailleurs la façon dont vous représentez vos fichiers ne convient pas, la description d'un fichier contient des numéros de blocs, pas les blocs eux-même. Faites aussi attention qu'un fichier soit décrit par un nombre entier de blocs.

Question pratique: je n'arrive pas à mettre tout le code dans le même bloc comme vous l'avez fait ci-dessus dans l'étape 4 de la semaine 1. Je vois que c'est en format "préformaté" mais j'obtiens des blocs séparés lorsque j'applique ce format à mon code.

ReX : j'ai corrigé, pour un code entier la syntaxe n'est pas la même (un espace en début de chaque ligne), la balise c'est uniquement pour de très courts extraits de code.

=== Fonction <code>readBlock</code>===
Cette fonction est utilisée pour lire un bloc de données à partir du fichier <code>filesystem.bin</code> et le stocker dans un tableau de caractères (<code>storage</code>).

Fonction:

#define BLOCK_SIZE 256
// Fonction pour lire un bloc de données
void readBlock(unsigned int num, int offset, unsigned char *storage, int size) {
FILE *file = fopen("filesystem.bin", "rb");
if (file == NULL) {
perror("Erreur lors de l'ouverture du fichier");
return;
}
fseek(file, num * BLOCK_SIZE + offset, SEEK_SET);
fread(storage, 1, size, file);
fclose(file);
}

Paramètres :

* <code>num</code> : Numéro du bloc à lire. Chaque bloc contient 256 octets (1 bloc = 256 octets).
* <code>offset</code> : Décalage (en octets) à partir du début du bloc pour commencer la lecture.
* <code>storage</code> : Pointeur vers un tableau de caractères où les données lues seront stockées.
* <code>size</code> : Taille du tableau de caractères <code>storage</code>.

Fonctionnement :

* La fonction commence par ouvrir le fichier <code>filesystem.bin</code> en mode lecture binaire (<code>"rb"</code>).
* Elle utilise <code>fseek</code> pour positionner le curseur de lecture dans le fichier à l'endroit approprié pour commencer la lecture du bloc spécifié (<code>num</code>) à partir de l'offset (<code>offset</code>).
* Elle utilise ensuite <code>fread</code> pour lire <code>size</code> octets à partir du fichier et les stocker dans le tableau <code>storage</code>.
* Enfin, elle ferme le fichier avec <code>fclose</code>.

Note : Le paramètre <code>offset</code> est utilisé pour spécifier à partir de quel octet du bloc on souhaite commencer la lecture. Si <code>offset</code> est égal à 0, la lecture commencera depuis le début du bloc. Si <code>offset</code> est différent de 0, la lecture commencera à l'octet spécifié.

Remarque: dans votre mail, vous définissez "readBlock(unsigned int num,int offset,unsigned storage,int size)": storage n'est alors pas un pointeur vers un tableau de caractère. Je me suis donc permis de faire la modification.

ReX : OK pour la fonction, pas la peine d'en mettre autant dans le Wiki pour une fonction aussi simple.

=== Fonction <code>writeBlock</code> ===
Cette fonction est utilisée pour écrire un bloc de données dans le fichier <code>filesystem.bin</code> à partir d'un tableau de caractères (<code>storage</code>).

Fonction:

// Fonction pour écrire un bloc de données
void writeBlock(unsigned int num, int offset, const unsigned char *storage, int size) {
FILE *file = fopen("filesystem.bin", "rb+");
if (file == NULL) {
perror("Erreur lors de l'ouverture du fichier");
return;
}
fseek(file, num * BLOCK_SIZE + offset, SEEK_SET);
fwrite(storage, 1, size, file);
fclose(file);
}

Paramètres :

* <code>num</code> : Numéro du bloc où écrire.
* <code>offset</code> : Décalage (en octets) à partir du début du bloc pour commencer l'écriture.
* <code>storage</code> : Pointeur vers un tableau de caractères contenant les données à écrire dans le fichier.
* <code>size</code> : Taille du tableau de caractères <code>storage</code>.

Fonctionnement :

* La fonction commence par ouvrir le fichier <code>filesystem.bin</code> en mode lecture et écriture binaire (<code>"rb+"</code>).
* Elle utilise <code>fseek</code> pour positionner le curseur de lecture/écriture dans le fichier à l'endroit approprié pour commencer l'écriture du bloc spécifié (<code>num</code>) à partir de l'offset (<code>offset</code>).
* Elle utilise ensuite <code>fwrite</code> pour écrire <code>size</code> octets à partir du tableau <code>storage</code> dans le fichier.
* Enfin, elle ferme le fichier avec <code>fclose</code>.

ReX : Même remarque que pour la fonction précédente.

'''Etape 4: test des fonctions <code>readBlock</code> et <code>writeBlock</code> dans le main'''
// Exemple de fonction principale pour tester les opérations de lecture et d'écriture
int main() {
unsigned char data[BLOCK_SIZE];
// Test de la fonction readBlock
readBlock(0, 0, data, BLOCK_SIZE);
printf("Block 0, offset 0: ");
for (int i = 0; i < BLOCK_SIZE; i++) {
printf("%02x ", data[i]);
}
printf("\n");
// Test de la fonction writeBlock
unsigned char newData[BLOCK_SIZE] = {
0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88,
// ... Autres données du bloc ...
};
writeBlock(1, 0, newData, BLOCK_SIZE);
// Lecture du bloc nouvellement écrit pour vérifier
readBlock(1, 0, data, BLOCK_SIZE);
printf("Block 1, offset 0: ");
for (int i = 0; i < BLOCK_SIZE; i++) {
printf("%02x ", data[i]);
}
printf("\n");
return 0;
}

Fonctionnement :

* On déclare tout d'abord un tableau de caractères <code>data</code> de taille <code>BLOCK_SIZE</code> pour stocker les données lues du bloc.
* Ensuite, la fonction <code>readBlock</code> est appelée avec les arguments (0, 0, data, BLOCK_SIZE) pour lire le premier bloc du fichier (<code>num=0</code>, <code>offset=0</code>) et stocker les données dans <code>data</code>.
* Ensuite, la fonction <code>printf</code> est utilisée pour afficher les données lues du bloc (<code>data</code>) en format hexadécimal.
* Ensuite, un nouveau tableau de caractères <code>newData</code> est créé avec des données spécifiques pour tester la fonction <code>writeBlock</code>.
* La fonction <code>writeBlock</code> est appelée avec les arguments (1, 0, newData, BLOCK_SIZE) pour écrire le tableau <code>newData</code> dans le deuxième bloc du fichier (<code>num=1</code>, <code>offset=0</code>).
* Enfin, la fonction <code>readBlock</code> est appelée à nouveau pour lire le deuxième bloc nouvellement écrit et afficher les données lues en format hexadécimal.

Question générale : ce que j'avais la première semaine n'est plus forcément d'actualité. Puis-je supprimer les choses qui ne le sont plus afin d'alléger la page ou préférez-vous que je laisse?

ReX : Laissez.

Pour la suite : j'ai donc pour l'instant crée deux fonctions, l'une permettant la lecture et l'autre l'écriture d'un bloc, de manière à économiser la mémoire. Pour la suite, je vais essayer de créer la fonction <code>LS</code> en utilisant la fonction <code>readBlock</code>.

ReX : Oui c'est le début du projet. Mais si vous n'avez pas une bonne description de fichier cela ne donnera rien. Voir remarques plus haut.

'''Etape 5: fonction <code>LS</code>'''

Objectif: créer la fonction <code>LS</code> avec la fonction readBlock.

Question: Souhaitez-vous la fonction <code>LS</code> classique, c'est à dire la fonction <code>LS</code> qui affiche simplement le nom des fichiers présent dans le répertoire ?

ReX : Oui. Tu peux ajouter la taille si tu trouves cela trop simple.

Piste : si c'est ce que vous voulez:

* il va tout d'abord falloir que je crée des fichiers, un fichier étant composé d'un nom et de blocs (création d'une fonction createFile)
* Il faudra ensuite que je stocke ces fichiers dans le répertoire (création d'une fonction addFileToDirectory par exemple)
* enfin, il faudra que j'affiche le nom des fichiers. Pour cela, il faudra que je parcours le répertoire (structure "Directory"), puis que pour chaque fichier présent dans le répertoire que j'affiche son nom (création de la fonction LS)

Je devrais surement utiliser la fonction readBlock afin de transférer les blocs dans le fichier au travers de la variable "storage".

ReX : Créer des fichiers n'est pas nécessaire tout de suite je verrais bien si ton code est bon sans test. Laisse tomber <code>createFile</code> et <code>addFileToDirectory</code> pour l'instant.

ReX : Ton algorithme ne fonctionne pas pour un microcontrôleur où il faut économiser la mémoire, tu ne peux pas t'aider de structures. Il faudra que tu charges les noms et seulement les noms, pour la taille il faudra se baser sur le nombre de blocs.

'''Etape 6: rectification du code suite à vos remarques'''

Modifications apportées:

* suppression des structures afin d’économiser de la mémoire.

* le problème quant à la description des fichiers est normalement résolu puisque plus de structures. On ne charge plus les blocs mais seulement les noms de fichiers.

ReX : Non car si les noms ne sont pas répartis de façon régulière dans les blocs de 256 octets tu vas avoir du mal à les charger. Mais écrit la fonction <code>LS</code> et tu verras ce que je veux dire.

J'ai également ajouté deux nouvelles fonctions:

# <code>void readFileName(unsigned int file_num, char *file_name)</code>: Cette fonction permet de lire le nom du fichier associé au numéro de fichier donné (<code>file_num</code>). Elle stocke le nom du fichier lu dans le tableau <code>file_name</code>.
# <code>void writeFileName(unsigned int file_num, const char *file_name)</code>: Cette fonction permet d'écrire le nom du fichier dans le système de fichiers, associé au numéro de fichier donné (<code>file_num</code>). Elle prend en entrée le nom du fichier à écrire (<code>file_name</code>).

Suite: si vous validez cette base, je pourrai passer à la création de la fonction LS.

ReX : tu peux y aller. Je ne vois pas le code des tes deux fonctions <code>readFileName</code> et <code>writeFileName</code>.

Voici le code des fonctions <code>readFileName</code> et <code>writeFileName</code> :

'''Fonction readFileName:'''
// Fonction pour lire le nom du fichier
void readFileName(unsigned int file_num, char *file_name) {
readBlock(file_num, 0, (unsigned char *)file_name, MAX_FILENAME_LENGTH);
file_name[MAX_FILENAME_LENGTH] = '\0'; // Ajout du caractère null-terminator pour former une chaîne de caractères
}

ReX : Non, aucune raison que le fichier de numéro n soit au bloc n. Dessine la représentation d'un fichier sur le SF en comptant les octets si cela peut aider.

'''Fonction writeFileName:'''
// Fonction pour écrire le nom du fichier
void writeFileName(unsigned int file_num, const char *file_name) {
writeBlock(file_num, 0, (const unsigned char *)file_name, MAX_FILENAME_LENGTH);
}

ReX : Faux et inutile pour l'instant. Problème avec la constante MAX_FILENAME_LENGTH.

=== Fonction LS version 1 ===
// Fonction LS pour afficher les fichiers présents dans le système de fichiers
void LS(const char *filesystem_path) {
FILE *file = fopen(filesystem_path, "rb");
if (file == NULL) {
perror("Erreur lors de l'ouverture du fichier système");
return;
}
uint16_t num_files;
fread(&num_files, sizeof(uint16_t), 1, file); // Lecture du nombre de fichiers dans le système
char filename[17];
printf("Fichiers présents dans le système de fichiers:\n");
for (int i = 0; i < num_files; i++) {
readFileName(i, filename); // Lecture du nom du fichier
printf("%s\n", filename); // Affichage du nom du fichier
}
fclose(file);
}
La fonction <code>LS</code> ouvre le fichier système, lit le nombre de fichiers qu'il contient, puis affiche les noms des fichiers un par un, chacun sur une ligne séparée.

ReX : Il y a le nombre de fichiers dans ton superbloc ? Un dessin du format du superbloc avec les numéros des octets ?

ReX : Tout accès au système de fichiers doit se faire avec les deux fonctions <code>readBlock</code> et <code>writeBlock</code>.

== Semaine 3 ==
Question 1: cela fait plusieurs fois que vous mentionnez dans le wiki un "superbloc". Celui-ci n'étant pas clairement défini dans le sujet, je me demande s'il s'agit du bloc crée grâce à la fonction dd, c'est à dire que le superbloc serait en faite le bloc constitué des 31250 blocs de taille 256 octets, où s'il s'agit d'un bloc qui vient en entête, celui contenant alors des informations décrivant le système de fichier (les noms de fichiers...).

ReX : Pour ton pico système de fichiers, le superbloc consiste en les premiers blocs (de 256 octets) qui définissent les 64 fichiers possibles.

Proposition de structure: on pourrait réserver les premiers blocs du système de fichiers aux noms de fichiers ainsi qu'aux numéros des blocs correspondant à chaque fichier.

ReX : Oui c'est évident.

On sait que les noms de fichiers font au maximum 16 caractères + 1 caractère pour le '\0' (donc 17 octets car 1 char=1 octet).

ReX : Non, 16 octets suffisent, des '\0' en fin de nom uniquement si le nom fait moins de 16 caractères.

On sait également qu'un fichier contient au maximum 2040 blocs, chaque bloc étant numéroté sur 2 octets. On pourrait donc avoir en début du système de fichier: 17 octets+2 octets*2040 blocs = 4097 octets pour la description d'un fichier.

ReX : Non, 4096 octets soit 16 blocs de 256.

Or d'après l'une de vos remarques dans le wiki, un fichier doit être décrit par un nombre entier de blocs. Pour un fichier, il nous faudra donc 4097/256=16.004 soit 17 blocs. Il peut y avoir jusqu'à 64 fichiers dans le répertoire, il nous faudra donc 17 blocs*64 fichiers= 1088 blocs pour la description des fichiers.

ReX : Non 1024 blocs de 256 octets dans le superbloc.

Ainsi, pour la fonction LS, il suffira de lire les premiers caractères tous les 17 blocs ( du premier caractère au caractère '\0').

ReX : Non, tous les 16 blocs.

Question 2: Ne faudrait-il pas également stocker quelque part le nombre de fichier qu'il y a dans le répertoire afin de savoir jusqu'à quel bloc la fonction LS doit aller ?

ReX : Non, un fichier dont le nom n'est constitué que de '\0' est réputé ne pas exister.

Question 3: on a donc vu que les 1088 premiers blocs au maximum serviraient à la description du système de fichier. Il reste donc 31250-1088=30132 blocs dans le système de fichier.

ReX : Non, 32768-1024=31744 blocs.

Comment utiliser ces blocs? Ces blocs doivent-ils stocker le contenu des fichiers ?

ReX : Oui, c'et évident.

En effet, avec la fonction TYPE, nous allons créer des fichiers et ces fichiers devront être stockés quelque part. Cependant, étant donné que ce pico système de fichiers est prévu pour un microcontrôleur, je ne sais pas si c'est le contenu des fichiers qui doit être stocké dans les blocs ou autre chose (peut être l'adresse des fichiers, le fichiers se trouvant autre part). En effet, je me dis que si un fichier est très volumineux, il ne pourra pas rentrer dans le système de fichier, ce dernier étant composé d'un nombre limité de blocs, et les blocs étant eux même limité en nombre d'octets.

ReX : Je ne comprend pas ton problème. De tout façon comme dit plus haut, les 31744 blocs suivant le superbloc doivent contenir les données des fichiers.

Désolé de poser des questions peut être basique aussi tard, mais je pense qu'une fois que j'aurai ces réponses, cela ira beaucoup mieux pour la suite. Merci d'avance pour vos réponses.

ReX : Les questions sont effectivement triviales et il est effectivement inquiétant que voir que la travail n'avance pas.

Amine: merci pour vos corrections.

D'après votre commentaire "32768-1024=31744 blocs", j'en déduis qu'il faut que je modifie ma commande dd (qui est actuellement "dd if=/dev/zero of=filesystem.bin bs=256 count=31250" pour avoir le bon filesystem).

ReX : Je comprends pas d'où tu sors le 31250. D'autant plus que la commande ci-dessous est bonne.

Amine : 31250 car 31250 blocs * 256 octets = 8 Mo.

ReX : Haaaa je vois tu utilises le système métrique international où le mégaoctet vaut 10^6 octets, sauf qu'aucun informaticien n'utilisera cette norme hors sol. Quand je parle de 8 Mo c'est 8x1024x1024 octets. Tout simplement parce qu'une puce mémoire de 8 Mo c'est bien 8x1024x1024 octets.

Amine: D'accord merci pour l'information !

'''Nouvelle commande dd:'''

dd if=/dev/zero of=filesystem.bin bs=256 count=32768

=== Fonction LS version 2 ===

Dans notre structure du système de fichier, le superbloc est constitué de 1024 blocs (16 blocs * 64 fichiers), un fichier étant décrit par 16 blocs. Le nom du fichier est donc écrit au début de tous les blocs multiples de 16. Par exemple, le nom du premier fichier est dans les 16 premiers octets du premier bloc, le nom du 2ème fichier est dans les 16 premiers octets du 32ème bloc et ainsi de suite, tant que des fichiers existent. Lorsque qu'il n'y a plus de fichier, le nom du premier caractère du bloc multiple de 16 est un 0.

Voici le code:
// Fonction pour lister les noms de fichiers présents dans le système de fichiers
void LS() {
unsigned char buffer[BLOCK_SIZE];
int fileCount = 0;

for (int blockNum = 1; blockNum <= MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, BLOCK_SIZE);

// Vérifier si le bloc est vide
if (buffer[0] == 0) {
break; // Plus de fichiers à lire
}

char filename[MAX_FILENAME_LENGTH];
memcpy(filename, buffer, MAX_FILENAME_LENGTH);

// Afficher le nom du fichier
printf("%s\n", filename);
fileCount++;
}

if (fileCount == 0) {
printf("Aucun fichier trouvé.\n");
}
}

ReX : Tu supposes que si un fichier a un nom vide, les suivants auront aussi un nom vide. C'est possible mais dans ce cas la commande <code>RM</code> ca être plus compliquée à écrire.

ReX : Tu ne sembles pas comprendre que la mémoire d'un microcontrôleur est limitée. Pourquoi lire le premier bloc de description d'un fichier en entier ? Dit autrement c'est quoi l'intérêt de lire 256 octets alors que 16 suffisent ?

ReX : Pourquoi tu ne lis pas le premier fichier ? Autrement dit pourquoi décaler tout d'un bloc ?

Amine: Merci pour vos remarques. J'ai apporté les modifications à LS dans la section "Semaine 4" du wiki.

'''Réflexion par rapport aux autres fonctions:'''

J'ai créé les fonctions TYPE et CAT mais il y a malheureusement un problème pour l'instant. Vous pouvez les retrouver en pièce jointe dans l'archive du fichier programme.c.

Le problème que j'ai est que lorsque j'affiche le contenu du fichier créé avec TYPE, j'obtiens plein de caractères spéciaux. Par exemple, je créé le fichier "mon_fichier.txt" avec la fonction TYPE, et je mets en entré standard "hello". Ensuite, je veux afficher le contenu de ce fichier grâce à la fonction CAT. Cependant, ce qui s'affiche dans le terminal n'est pas ce que je veux. De la même manière, lorsque je fais la commande "cat filesystem.bin" dans le terminal, c'est la même chose s'affiche, des donnés parasites.

ReX : Avant même de lire ton code je vais te poser la question de savoir comment tu récupères un bloc libre ? Quel algorithme tu utilises. Personnellement je ne sais pas faire sans ajouter au superbloc un tableau bit à bit des blocs libres. Pour avoir un bit pour chaque bloc du système de fichiers, il faut 32768/8=4096 octets soit 16 blocs.

Amine: ok je vais donc ajouter ce tableau de 16 blocs à la suite de mes premiers 1024 blocs servant à la description de fichier. Le superbloc fera maintenant 1024+16=1040 blocs (plus de détail à la fonction RM de la semaine 4).

Question 1: est ce que la fonction CAT que je dois créer doit renvoyer la même chose que "cat filesystem.bin" ?

ReX : Je préfère ne pas répondre tellement la question montre un manque de réflexion.

Question 2: comment savoir combien de blocs doivent etre attribué à un fichier? Par exemple, si je créé un fichier "mon_fichier.txt" et que je mets en entrée standard le texte "hello", un seul bloc suffi pour stocker ce texte. Cependant, si j'avais mis beaucoup de texte en entrée standard, il aurait fallu plus de blocs. Doit-on calculer la taille de l'entrée standard ou doit-on attribuer toujours le meme nombre de blocs à un fichier? Peut-etre ainsi attribuer 2040 blocs par fichier, meme s'il n'en utilise que 1.

ReX : Là encore c'est une question stupéfiante tellement la réponse est évidente. Il suffit de lire les données sur l'entrée standard et de passer au bloc de données suivant dès que le bloc courant est rempli. La question à poser c'était de se demander comment il est possible d'avoir la taille exacte du fichier pour un <code>CAT</code>. Il est uniquement possible de l'avoir à 256 octets près puisque rien n'indique si le dernier block est vide. Le mieux aurait été de prévoir 4 octets dans la description d'un fichier pour stocker la taille. En l'espèce on considérera que les fichiers sont des fichiers ASCII et qu'ils seront terminés par des <code>\'0</code> qui ne seront pas affichés.

== Semaine 4 ==

Voici un bilan de ce que j'ai fait à ce stade du projet:

* j'ai choisi une structure du système de fichier
* j'ai créé les fonctions readBlock et writeBlock permettant de lire et d'écrire des blocs
* j'ai crée la fonction LS permettant d'afficher le nom des fichiers présents dans le système de fichiers
* j'ai programmer un main permettant d'utiliser les fonctions (LS, TYPE...) depuis le terminal
* j'ai réflechi aux fonctions TYPE et CAT.

Actuellement, je suis en train de créer les fonctions TYPE et CAT.

=== Fonction LS version 3 ===
void LS() {
unsigned char buffer[MAX_FILENAME_LENGTH];
int fileCount = 0;

// Parcourir tous les 16 blocs de 0 jusqu'à MAX_FILES_IN_DIRECTORY
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, MAX_FILENAME_LENGTH);

// Vérifier si le nom de fichier est vide
if (buffer[0] != 0) {

// Afficher le nom du fichier
printf("%s\n", buffer);
fileCount++;
}
}

if (fileCount == 0) {
printf("Aucun fichier trouvé.\n");
}
}
Suite à vos remarques, j'ai effectué les modifications suivantes de la fonction LS:

* Je ne suppose plus que si un fichier a un nom vide, les autres auront aussi un nom vide.
* Je ne lis plus les 256 octets mais seulement les 16 premiers octets car cela suffit.
* Je ne lisais en effet pas le premier bloc. Je pensais que le premier bloc était d'indice 1 mais ce n'est pas le cas.

ReX : Ouiiii ! Une fonction correcte. Passe à <code>RM</code> maintenant, c'est la plus facile à faire concernant l'image bit à bit des blocs libres.

=== Fonction setBlockAvailability version 1 ===

Comme vous l'avez indiqué dans votre remarque, il faut un tableau dans le superbloc qui nous permettra de connaitre la disponibilité bit par bit de chaque bloc. Sachant qu'il y a dans notre système de fichiers 32768 blocs, et qu'il faut 1 bit par bloc, nous avons besoin de 32768 bits, soit 32768/8=4096 octets soit 4096/256=16 blocs. Notre superbloc sera donc comme suit: les 1024 premiers blocs servent à la description des fichiers, c'est à dire à leur nom suivi des numéros de blocs qui leur sont associés, puis ces 1024 blocs sont suivi de 16 blocs listant la disponibilité de chaque bloc.

ReX : Bien résumé.

Nous allons tout d'abord écrire la fonction "setBlockAvailability" prenant en paramètre le numéro du bloc à traiter (<code>blockNum</code>) et la disponibilité souhaitée pour ce bloc (<code>availability</code>). Cette fonction permet de marquer la disponibilité d'un bloc spécifique dans le système de fichiers. Nous utiliserons la convention suivante: un bloc disponible sera marqué par un 1 tandis qu'un bloc non disponible par un 0.
#define SUPERBLOCK_START_BLOCK 1024

void setBlockAvailability(int blockNum, int availability) {
// Calculer l'index du byte et le bit offset correspondant
int byteIndex = blockNum / 8;
int bitOffset = blockNum % 8;

// Lire le byte existant du bloc de disponibilité des blocs
unsigned char buffer[1];
readBlock(SUPERBLOCK_START_BLOCK + byteIndex, 0, buffer, 1);

// Mettre à jour le bit d'offset correspondant
if (availability) {
buffer[0] |= (1 << bitOffset);
} else {
buffer[0] &= ~(1 << bitOffset);
}

// Écrire le byte mis à jour dans le bloc de disponibilité des blocs
writeBlock(SUPERBLOCK_START_BLOCK + byteIndex, 0, buffer, 1);
}

ReX : Un tableau de un octet c'est un octet (variable <code>buffer</code>).

Amine: je vais utiliser un <code>unsigned char buffer.</code> Je suis conscient qu'un char vaut un octet mais je ne pense pas qu'il y ait un type de donnée de la taille d'un bit, c'est pourquoi je travaille avec un octet mais je modifie les bits de cet octet grâce aux algorithmes.

ReX : Il faut bien que tu travailles sur un octet vu que l'état des blocs est stocké sous la forme d'octets. Je disais juste qu'un tableau de 1 élément n'a pas d'intérêt par rapport à l'élément lui-même.

Amine: c'est vrai, modification faite.

ReX : Non il faut calculer le numéro du bloc avant de faire le <code>readBlock</code>.

Amine: ok je vais calculer le numéro de bloc avant.

ReX : La mise à jour du bit est correcte mais le block et le déplacement dans le block ne sont pas correctement calculés.

Amine: je vais vous expliquer le raisonnement que j'avais. Prenons un exemple concret, imaginons que je veuille marquer le bloc 1030 comme disponible:

# Calcul de l'index de l'octet et du bit offset :
#* <code>blockNum</code> = 1030
#* Index du byte = 1030 / 8 = 128
#* Bit offset = 1030 % 8 = 6
# Lecture de l'octet existant de disponibilité:
#* Nous lisons l'octet existant à l'index 128 dans les blocs de disponibilité.
# Mise à jour du bit de disponibilité :
#* Nous voulons marquer le bloc 1030 comme disponible, donc nous utilisons le masque <code>(1 << 6)</code> pour définir le bit 6 à 1 dans l'octet. Le résultat sera, par exemple, <code>00100000</code>.
# Écriture du byte mis à jour :
#* Nous écrivons le byte mis à jour <code>00100000</code> à l'index 128 dans les blocs de disponibilité.

ReX : Ben non, un vrai exemple :
* Il faut prendre un n° de bloc plus grand : 3072 ;
* Numéro d'octet dans la carte des blocs libres : 3072/8=384 ;
* Numéro du bloc dans la carte des blocs libres : 384/256=1 ;
* Numéro du bit <code>b</code> dans l'octet n° 384-256=128 du bloc 1 : 3072%8=0 ;
* Il faut donc lire l'octet <code>o</code> de numéro 128 du bloc 1, puis modifier cet octet par <code>o |= (1<<b)</code> ou <code>o &= ~(1<<b)</code> ;
* Enfin il faut écrire l'octet modifié dans le bloc 1.
Amine: merci pour cet exemple! J'ai compris d'où vient mon erreur. Voir fonction setBlockAvailability version 3.

Remarque: par convention, j'apellerai dans la suite de ce projet "premier superbloc" le superbloc correspondant à la description des fichiers, c'est à dire les 1024 premiers blocs, et j'appellerai "second superbloc" les 16 blocs qui suivent servant à décrire la disponibilité des blocs (du bloc 1024 au bloc 1039 inclu). Le reste des blocs servira à stocker les données.

ReX : Non, le superblc est l'ensemble des informations hors blocs de données, tu ne peux pas utiliser un vocabulaire au hasard. Parle de blocs de description des fichiers ou de carte des blocs libres.

Amine: ok

Je pense que le problème qui se pose est que l'indice du bit dans le second superbloc ne correspond pas à l'indice du bloc dans le système de fichier. Par exemple, nous voudrions que si le bloc 1030 est disponible dans le système de fichier, alors le bit numéro 1030 du deuxième superbloc soit à 1, ce qui n'est pas le cas ici. En effet, on se trouve bien dans le bon octet avec ma méthode mais l'écriture du bit se fait de la droite vers la gauche alors qu'on voudrait l'inverse. Ainsi, si le 6ème bit de l'octet doit être à 1, alors il faudrait qu'on obtienne <code>00000100</code> et non <code>00100000.</code> L'indice du bit coinciderait ainsi avec le numéro du bloc.

ReX : Non, réfléchit à nouveau.

Voir plus bas la nouvelle version de setBlockAvailability.

Explication de l'algorithme pour mettre le bit à 1 ou 0:

* <code>buffer[0] |= (1 << bitOffset);</code> : Cette ligne utilise l'opérateur OR bit à bit (<code>|=</code>) pour activer (mettre à 1) le bit spécifié par <code>bitOffset</code> dans le premier octet (<code>buffer[0]</code>). Cela se fait en décalant le bit 1 vers la gauche de <code>bitOffset</code> positions, puis en effectuant une opération OR bit à bit avec le contenu actuel de <code>buffer[0]</code>. Cette opération modifie uniquement le bit ciblé, laissant les autres bits inchangés.

ReX : Oui ça c'est bon.

* <code>buffer[0] &= ~(1 << bitOffset);</code> : Cette ligne utilise l'opérateur AND bit à bit (<code>&=</code>) pour désactiver (mettre à 0) le bit spécifié par <code>bitOffset</code> dans <code>buffer[0]</code>. Pour ce faire, l'expression <code>~(1 << bitOffset)</code> est utilisée pour créer un masque où tous les bits sont à 1, sauf celui correspondant à <code>bitOffset</code>, qui est à 0. En effectuant ensuite une opération AND bit à bit entre le masque et le contenu actuel de <code>buffer[0]</code>, on met à 0 le bit ciblé sans affecter les autres bits.

ReX : Ca aussi.

=== Fonction setBlockAvailability version 2 ===

void setBlockAvailability(int blockNum, int availability) {
// Calculer l'indice de l'octet et le bit offset correspondant
int byteIndex = blockNum / 8;
int bitOffset = 7 - (blockNum % 8); // Inversion de l'ordre des bits

// Calculer le numéro du bloc du super bloc où se trouve l'octet de disponibilité correspondant
int availabilityBlockNum = SUPERBLOCK_START_BLOCK + byteIndex;

// Lire l'octet existant dans le bloc de disponibilité du super bloc
unsigned char buffer;
readBlock(availabilityBlockNum, 0, &buffer, 1);

// Mettre à jour le bit d'offset correspondant :
if (availability) {
buffer |= (1 << bitOffset);
} else {
buffer &= ~(1 << bitOffset);
}

// Écrire l'octet mis à jour dans le bloc de disponibilité du super bloc
writeBlock(availabilityBlockNum, 0, &buffer, 1);
}
J'ai modifié la ligne <code>int bitOffset = 7 - (blockNum % 8);</code> pour inverser l'ordre des bits sélectionnés, de sorte que le bit correspondant au bloc disponible soit correct.

ReX : Encore plus faux.

Si on veut rendre le bloc 1030 indisponible alors que les autres blocs sont disponibles:

ReX : Pardon ? Le bloc de données est libre ou pas suivant la carte des blocs libres. Le rendre disponible n'est possible que si un fichier le comportant est détruit.

# Calcul de l'indice de l'octet et du bit offset correspondant :
#* <code>blockNum = 1030</code>
#* <code>byteIndex = 1030 / 8 = 128</code>
#* <code>bitOffset = 7 - 1030 % 8 = 1</code> Cela signifie que le bit d'intérêt se trouve à la position 2 dans l'octet.
# Calcul du numéro du bloc du super bloc où se trouve l'octet de disponibilité correspondant :
#* <code>availabilityBlockNum = SUPERBLOCK_START_BLOCK + 128 = 1024 + 128 = 1152</code> Donc, nous devons accéder à l'octet 1152 pour mettre à jour la disponibilité du bloc 1030.
# Lecture de l'octet existant dans le bloc de disponibilité du super bloc :
#* Le contenu de l'octet dans le bloc 1152 avant la mise à jour : 11111111 (en binaire)
# Mise à jour du bit d'offset correspondant :
#* Supposons que nous voulions marquer le bloc 1030 comme non disponible (<code>availability = 0</code>).
#* Le bitOffset est 1.
#* Nous effectuons une opération AND avec le complément du bit à la position 1 : <code>11111111 & 11111101 = 11111101</code>
# Écriture de l'octet mis à jour dans le bloc de disponibilité du super bloc :
#* Le contenu de l'octet 128 du second superbloc après la mise à jour : 11111101 (en binaire)

ReX : Toujours aussi faux.

Maintenant, le bit d'indice 1 du 128 ème octet du second superbloc est mis à 0, indiquant que le bloc 1030 n'est plus disponible. Les autres bits restent inchangés car nous avons effectué un AND avec un masque binaire qui avait des 1 partout sauf à la position du bit que nous souhaitions mettre à 0.

ReX : Erreur sur erreur.

=== Fonction setBlockAvailability version 3 ===
J'ai compris d'où vient l'erreur. La fonction readBlock prends en premier paramètre le numéro du bloc à lire, je ne peux donc pas lui donner la valeur "SUPERBLOCK_START_BLOCK + byteIndex" car byteIndex s'exprime en octet alors qu'on s'attend à un nombre de bloc ici. Il faut donc divisé byteIndex par 256 pour être en unité "bloc", et préciser le bit qu'on veut lire grâce à l'offset.

Pour obtenir l'octet que l'on veut, il faut prendre le reste de la division de byteIndex par 256. On va ensuite stocker cet octet dans notre "buffer".

Pour savoir quel bit modifier dans ce "buffer", on va prendre le reste de la division du bloc dont on veut mettre à jour la disponibilité par 8. On va ainsi pouvoir modifier ce bit grâce à l'algorithme, puis réécrire l'octet à son emplacement d'origine.

Cette fonction gère la carte de disponibilités des blocs. Si un bloc est disponible, alors elle le met un 0, si il est indisponible, elle met un 1.
#define SUPERBLOCK_START_BLOCK 1024

void setBlockAvailability(int blockNum, int availability) {

int byteIndexInCard = blockNum / 8; //Numéro d'octet dans la carte des blocs libres
int blockIndexInCard = byteIndexInCard / 256; //Numéro du bloc dans la carte des blocs libres
int byteIndexInBlock = byteIndexInCard % 256; //Numéro d'octet dans le bloc contenant le bit de disponibilité
int bitOffset = blockNum % 8; //Numéro du bit dans l'octet n°byteIndexInBlock du bloc blockIndexInCard

//indice du bloc contenant le bit à mettre à jour dans le bloc de description
int availabilityBlockNum = FIRST_DISPONIBILITY_CARD_BLOCK + blockIndexInCard;

// Lire l'octet existant dans le bloc de disponibilité du super bloc
unsigned char buffer;
readBlock(availabilityBlockNum, byteIndexInBlock, &buffer, 1);

// Mettre à jour le bit d'offset correspondant :
if (availability==1) { // indisponible
buffer |= (1 << bitOffset); // Mettre le bit à 1

} else { // disponible
buffer &= ~(1 << bitOffset); // Mettre le bit à 0
}

// Écrire l'octet mis à jour dans le bloc de disponibilité du super bloc
writeBlock(availabilityBlockNum, byteIndexInBlock, &buffer, 1);
}

ReX : Ben voila, c'est pas possible de te taxer d'excès de vitesse mais c'est bon.

update: j'ai fait une petite modification, maintenant un bloc disponible est marqué d'un 0 et un bloc indisponible est marqué d'un 1. C'est mieux dans la mesure où initialement, tous les blocs sont disponibles et tous les blocs sont à 0. Cela évite de devoir créer une fonction qui initialise toute la carte de disponibilités à 1 pour dire que tous les blocs sont disponibles.

=== Fonction RM version 1 ===

void RM(const char *filesystem_path, const char *filename) {
unsigned char buffer[BLOCK_SIZE];
int fileNum = -1;

// Parcourir les blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (memcmp(filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {
// Effacer le nom du fichier dans le superbloc
memset(filenameBuffer, 0, MAX_FILENAME_LENGTH);
writeBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

unsigned char fileBuffer[MAX_BLOCKS_PER_FILE * 2];
readBlock(blockNum, MAX_FILENAME_LENGTH, fileBuffer, MAX_BLOCKS_PER_FILE * 2);

// Libérer les blocs associés au fichier et réinitialiser les numéros de blocs
for (int i = 0; i < MAX_BLOCKS_PER_FILE * 2; i += 2) {
int blockNum = ((int)fileBuffer[i] << 8) + (int)fileBuffer[i + 1];
if (blockNum == 0) {
break; // Fin du fichier
}
setBlockAvailability(blockNum, 0); // Marquer le bloc comme disponible
fileBuffer[i] = 0;
fileBuffer[i + 1] = 0;
}

// Mettre à jour les numéros de blocs associés au fichier
writeBlock(blockNum, MAX_FILENAME_LENGTH, fileBuffer, MAX_BLOCKS_PER_FILE * 2);

fileNum = blockNum;
break; // Fichier trouvé, sortir de la boucle
}
}

// Afficher le résultat de l'opération
if (fileNum == -1) {
printf("Le fichier \"%s\" n'a pas été trouvé.\n", filename);
} else {
printf("Le fichier \"%s\" a été supprimé avec succès.\n", filename);
}
}

ReX : Vous utilisez <code>strcmp</code> comme <code>strncmp</code>. C'est bien la dernière qu'il faut utiliser mais en précisant la longueur du nom en paramètre, pas la taille maximale.

Amine: vous voulez dire que j'utilise memcmp au lieu de strncmp ? Ok je vais utiliser strncmp, c'est vrai que c'est plus adapté pour la comparaison de chaines de caractère.

ReX : Ha oui c'est <code>memcmp</code> que tu utilises. Ca ne peut effectivement pas marcher. Effectivement avec <code>strncmp</code> cela peut marcher vu qu'il s'arrête au premier 0 contrairement à <code>memcmp</code>.

Cependant, pourquoi doit-on passer la taille exacte du nom du fichier en paramètre, et non la taille maximale d'un nom de fichier? En effet, cela semble fonctionner en mettant la taille maximale en paramètre, tandis que lorsque l'on met la taille exacte du nom du fichier, cela pose un problème: on ne compare plus toute la chaîne de caractère mais seulement une portion du nom complet. Ainsi, si je crée par exemple un fichier que j'appelle "file1", puis que j’exécute la fonction RM "/picofs filesystem.bin RM file" par exemple, alors le fichier file1 va être supprimé quand même car on ne comparera que strlen(file)=4 premiers caractères, qui sont les mêmes, donc la fonction considérera ces chaines comme identiques. On pourrait alors se dire qu'il faudrait alors prendre plutôt comme taille en paramètre de la fonction strlen la taille du nom du fichier se trouvant dans le système de fichier plutôt que celle du nom donné en paramètre de RM. Cependant, le même problème se pose si la taille du nom du fichier du système de fichier est plus petite que celle du nom du fichier passé en paramètre. Par exemple, si le fichier présent dans système de fichier est "file", et qu'on met la longueur de file en paramètre de la fonction strcmp, puis qu'on exécute la commande "/picofs filesystem.bin RM file5", alors file sera quand même supprimé, car on ne comparera que les strlen(file)=4 premiers caractère. Finalement, une solution serait de rajouter une condition qui vérifie que les deux chaînes sont de taille identiques pour pouvoir réaliser la comparaison sur la taille exacte du nom du fichier. Cependant, il me semble qu'en mettant MAX_FILENAME_LENGTH qui vaut 16 en paramètre, cela fonctionne directement. Vous pouvez tester cela en testant mon programme.

ReX : Ok pour <code>strncmp</code> avec la taille maximale d'un nom de fichier.

etape 1: créer un fichier :
./picofs filesystem.bin TYPE fichier.txt

etape 2: verifier que le fichier a bien été créé :
./picofs filesystem.bin LS

Le terminal renvoie bien "fichier.txt"

etape 3: essayer de supprimer le fichier en mettant une chaine troncature du nom du fichier créé :
./picofs filesystem.bin RM fich

le terminal renvoi <<Le fichier "fich" n'a pas été trouvé.>>, le fichier n'a donc pas été supprimé .

etape 4: essayer de supprimer le fichier en mettant un nom plus grand incluant "fichier.txt" :
./picofs filesystem.bin RM fichier.txtt

terminal renvoi <<Le fichier "fichier.txtt" n'a pas été trouvé.>>

etape 5: enfin, tester en mettant le nom exacte du fichier que l'on veut supprimer :
./picofs filesystem.bin RM fichier.txt

terminal renvoi <<Le fichier "fichier.txt" a été supprimé avec succès.>>

Finalement, on voit que cela fonctionne avec la taille maximale mise en paramètre. On pourrait reprocher à cette méthode de comparer des caractères dans le vide, ce qui n'est pas optimal dans une optique d'économie de mémoire qui est la notre, mais la taille maximale d'un nom de fichier étant relativement faible (16 octets), on peut peut-être négliger cela au vu de l'économie d'une opération supplémentaire (comparaison de la taille des chaines de caractères).

ReX : Le parcours des blocs de données du fichier est atroce. Il faut parcourir les numéros de blocs dans le premier bloc du fichier derrière le nom du fichier puis il faut parcourir le 15 autres blocs.

Amine: Ok, je vais corriger cela dans la version 2 de RM (voir semaine 5).

Fonctionnement de la fonction RM:

* Parcours des blocs réservés pour la description des fichiers (superbloc) à partir du bloc 0, en incrémentant de 16 à chaque itération pour accéder aux blocs de noms de fichiers.

ReX : OK.

* Dans chaque bloc de noms de fichiers, la fonction compare le nom de fichier recherché avec les noms stockés dans les 16 octets de chaque bloc.

ReX : Non la fonction ne fait pas ça par contre il faudrait, oui.

Amine: Je pensais que c'était ce que je faisais avec "memcmp(filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0)".

* Si le nom de fichier est trouvé, la fonction efface le nom du fichier dans le superbloc en remplaçant les 16 octets du bloc par des zéros.

ReX : OK.

* Ensuite, la fonction accède aux octets suivants du même bloc pour obtenir les numéros de blocs associés au fichier.

ReX : Non, la boucle sort largement du premier bloc.

* Pour chaque paire de numéros de blocs (2 octets chacun), la fonction convertit les octets en un numéro de bloc. Si le numéro de bloc est nul, cela signifie la fin des blocs associés au fichier, sinon, la fonction marque ce bloc comme disponible en utilisant la fonction <code>setBlockAvailability</code> et réinitialise les numéros de blocs dans le tableau à zéro.
* Les numéros de blocs réinitialisés sont ensuite réécrits dans le bloc de description du fichier.

ReX : L'idée est là mais vu que la boucle n'est pas bonne, rien ne peut marcher.

* La fonction affiche ensuite un message indiquant le résultat de l'opération : soit que le fichier a été supprimé avec succès, soit que le fichier n'a pas été trouvé.

== Semaine 5 ==

=== Fonction RM version 2 ===

Concernant les remarques que vous m'avez faites précédemment:

* j'utilise maintenant la fonction <code>strncmp</code> pour la comparaison des chaines de caractères
* j'ai normalement corrigé le parcours des blocs. Je parcours maintenant d'abord les blocs multiples de 16 à la recherche du bloc contenant le nom du fichier à supprimer. Puis je parcours les 16 blocs de description du fichier à supprimer, afin de récupérer les numéros de blocs, libérer ces blocs dans la carte de disponibilité et de réinitialiser ces blocs dans les blocs de données.

void RM(const char *filesystem_path, const char *filename) {
int fileFound = -1;
int offset;

// Parcourir les blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char*)filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {

// Effacer le nom du fichier dans le superbloc
memset(filenameBuffer, 0, MAX_FILENAME_LENGTH);
writeBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);
fileFound = 1;
offset = blockNum;
break;
}

}

// Fin de fonction si fichier inexistant
if (fileFound == -1) {
printf("Le fichier \"%s\" n'a pas été trouvé.\n", filename);
return;
}

unsigned char buffer[BLOCK_SIZE];
//bloc que l'on va remplir de 0 et mettre à la place des blocs de données
memset(buffer, 0, BLOCK_SIZE); //on rempli buffer de 0

for (int blockNum=offset; blockNum<offset + 16; blockNum++) {

//premier bloc de description, celui contenant le nom du fichier dans les 16 premiers octets
if (blockNum == offset) {

unsigned char fileBuffer[BLOCK_SIZE-MAX_FILENAME_LENGTH];
//bloc dans lequel on va stocker les blocs de description de fichier
readBlock(blockNum, MAX_FILENAME_LENGTH, fileBuffer, BLOCK_SIZE-MAX_FILENAME_LENGTH);

// Libérer les blocs associés au fichier dans la carte de disponibilités
// et dans les blocs de description
for (int i = MAX_FILENAME_LENGTH; i < BLOCK_SIZE-MAX_FILENAME_LENGTH; i += 2) {
int blockNumData = ((int)fileBuffer[i] << 8) + (int)fileBuffer[i + 1];
if (blockNumData == 0) {
break; // Fin du fichier
}
setBlockAvailability(blockNumData, 0); // Marquer le bloc comme disponible
fileBuffer[i] = 0;
fileBuffer[i + 1] = 0;
writeBlock(blockNumData, 0, buffer, BLOCK_SIZE); //on efface les blocs de données
}
writeBlock(blockNum, MAX_FILENAME_LENGTH, fileBuffer, BLOCK_SIZE-MAX_FILENAME_LENGTH);
//on efface le premier bloc de description

} else {
unsigned char fileBuffer[BLOCK_SIZE];
readBlock(blockNum, 0, fileBuffer, BLOCK_SIZE);

// Libérer les blocs associés au fichier dans la carte de disponibilités et dans les blocs de description
for (int i = 0; i < BLOCK_SIZE; i += 2) {
int blockNumData = ((int)fileBuffer[i] << 8) + (int)fileBuffer[i + 1];
if (blockNumData == 0) {
break; // Fin du fichier
}
setBlockAvailability(blockNumData, 0); // Marquer le bloc comme disponible
fileBuffer[i] = 0;
fileBuffer[i + 1] = 0;
writeBlock(blockNumData, 0, buffer, BLOCK_SIZE); //on efface les blocs de données
}
writeBlock(blockNum, 0, fileBuffer, BLOCK_SIZE); //on efface le bloc de description
}
}
printf("Le fichier \"%s\" a été supprimé avec succès.\n", filename);
}

ReX : Pour construire le nombre sur 16 bits utiliser le OU plutôt que l'addition.

ReX : Heu non, je ne lis pas cette fonction avec tout ce code dupliqué, la seule différence entre les deux alternative est la position de début de l'adresse du premier bloc de données (<code>MAX_FILENAME_LENGTH</code> dans un cas et 0 dans l'autre). Donc l'alternative ne doit servir qu'à initialiser ce début, le reste du code doit être factorisé.

ReX : Et corrige le code, tu utilises deux tableaux de blocs (perte mémoire), tu écris le bloc à zéro dans l'itération (perte CPU).

=== Fonction RM version 3 ===

Suite à vos remarques, j'ai réalisé les modifications suivantes:

* j'utilise maintenant le OU plutôt que l'addition pour construire le nombre sur 16 bits.

* j'ai factorisé le code grâce à la création de la variable <code>startOffset</code> valant 16 lorsqu'on se trouve dans le bloc contenant le nom du fichier et valant 0 lorsqu'on se trouve dans les autres.

* Pour ce qui est du fait que j'utilise 2 tableaux de blocs, j'ai du mal à voir comment faire avec 1 seul tableau de blocs car ces deux tableaux n'ont pas du tout le même rôle. Le tableau <code>fileBuffer</code> permet de stocker les 16 blocs de description d'un fichier un à un. Lorsqu'on stocke un bloc dans <code>fileBuffer</code>, on lit ensuite les octets un à un de ce bloc afin de former des numéros de blocs, et pour chaque numéro de bloc créé, on va réinitialiser le bloc correspondant dans les blocs de données. Pour cela, on a donc besoin d'un autre bloc qui viendra écraser les anciens blocs de données. C'est pourquoi j'ai créé un bloc <code>buffer</code>qui est composé de 0 et qui va écraser les blocs de données. On ne peut pas utiliser <code>fileBuffer</code> car on a besoin d'un bloc de zéros, et si on réinitialise <code>fileBuffer</code> on perd toute les données qui s'y trouvent. Une possibilité serait de relire le bloc de donné à chaque itération de la deuxième boucle for imbriquée; cela permettrait de pouvoir réinitialiser le tableau fileBuffer à chaque itérations de cette boucle afin de stocker ce bloc de 0 dans les blocs de données, puis de restocker dans ce même tableau le bloc de description. Cependant, je ne pense pas que ce soit optimal de faire autant appel à la fonction readBlock.

* j'ai créé une fonction resetBock qui permet comme son nom l'indique de reset un bloc en le remplissant de 0. Cela nous évite de créer deux tableaux de blocs dans RM, bien que je pense que cela revienne au même car on fait appel à une fonction qui créé un tableau de blocs. Quoi qu'il en soit, cela allège le code et cette fonction pourra surement me resservir par la suite.

void RM(const char *filesystem_path, const char *filename) {
int fileFound = -1;
int offset;
unsigned char fileBuffer[BLOCK_SIZE];

// Parcourir les blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char *)filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {
// Effacer le nom du fichier dans le superbloc
memset(filenameBuffer, 0, MAX_FILENAME_LENGTH);
writeBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);
fileFound = 1;
offset = blockNum;
break;
}
}

// Fin de fonction si fichier inexistant
if (fileFound == -1) {
printf("Le fichier \"%s\" n'a pas été trouvé.\n", filename);
return;
}

for (int blockNum = offset; blockNum < offset + 16; blockNum++) {
int startOffset = 0;
if (blockNum == offset) {
startOffset = MAX_FILENAME_LENGTH;
}
readBlock(blockNum, startOffset, fileBuffer, BLOCK_SIZE - startOffset);

// Libérer les blocs associés au fichier dans la carte de disponibilités et dans les blocs de description
for (int i = 0; i < BLOCK_SIZE - startOffset; i += 2) {
int blockNumData = (fileBuffer[i] << 8) | fileBuffer[i + 1];
if (blockNumData == 0) {
break; // Fin du fichier
}
setBlockAvailability(blockNumData, 0); // Marquer le bloc comme disponible
fileBuffer[i] = 0;
fileBuffer[i + 1] = 0;
resetBlock(blockNumData); //on efface les blocs de données
}
writeBlock(blockNum, startOffset, fileBuffer, BLOCK_SIZE - startOffset);
}
printf("Le fichier \"%s\" a été supprimé avec succès.\n", filename);
}
'''Fonction resetBlock'''
void resetBlock(unsigned int blockNum) {
unsigned char buffer[BLOCK_SIZE];
memset(buffer, 0, BLOCK_SIZE);

// Utiliser writeBlock pour écrire les données du buffer dans le bloc
writeBlock(blockNum, 0, buffer, BLOCK_SIZE);
}

ReX : Ca s'améliore. Mais pourquoi cette fonction <code>resetBlock</code> ? Tu crois que dans qu'un système de fichiers perd du temps à mettre à zéro les blocs de données libérés ? Si oui, regarde la page de manual de la commande <code>shred</code>, ça manque à ta culture.

Amine: Après avoir consulter le manual de la commande <code>shred</code>, je vois que cette commande écrit des données aléatoires sur l'emplacement du fichier sur le disque. Par défaut, <code>shred</code> effectue un certain nombre de passes (par exemple, 3 passes) pendant lesquelles il écrit des données aléatoires sur l'emplacement du fichier sur le disque. Après avoir écrit les données aléatoires, <code>shred</code> peut effectuer des passes supplémentaires pendant lesquelles il écrit des données nulles (des zéros) sur le même emplacement. L'objectif de <code>shred</code> est d'augmenter la sécurité en rendant plus difficile la récupération des données supprimées à l'aide d'outils de récupération de données.

Cependant, j'ai aussi consulté comment fonctionne la commande <code>rm</code> de linux, et je vois que cette commande libère l'espace occupé par le fichier en marquant les blocs associés comme disponibles. Cela signifie que les données peuvent encore être récupérées à l'aide d'outils de récupération de données, à moins que des mesures supplémentaires ne soient prises pour écraser physiquement l'espace avec des données aléatoires (c'est ce que fait l'utilitaire <code>shred</code>).

On va donc opter pour la deuxième option, c'est à dire qu'on ne va pas perdre notre temps à remettre à zéro les blocs de données libérés, on va simplement marquer les blocs correspondants comme étant disponibles. Cela nous permettra de nous émanciper de la fonction resetBlock et de n'avoir plus qu'un seul tableau de blocs.

ReX : Sinon lire un bloc complet de pointeurs de blocs de données en mémoire n'est pas forcément optimal. L'idéal serait de lire ces blocs morceau par morceau (de 64 octets par exemple). Certes un bloc serait traité en 4 lectures/écritures (ce qui ralentirait le traitement) mais on gagne en mémoire. Le mieux serait de mettre la taille des morceaux en constante pour pouvoir choisir entre vitesse d'exécution et utilisation mémoire.

Amine: d'accord je comprends. Je vais modifier la fonction pour qu'on puisse découper la lecture/écriture en plusieurs blocs.

=== Fonction RM version 4 ===
Modifications apportées:

* je ne réinitialise plus les blocs de données, je supprime simplement le pointeur du fichier vers les blocs de données et je désigne les blocs comme "disponible" dans le carte de disponibilités. J'ai donc supprimé la fonction resetBlock.

* je ne lis plus les blocs en une seule fois mais en plusieurs fois via la variable CHUNK_SIZE:

# J'ai introduit la constante <code>CHUNK_SIZE</code> pour définir la taille de chaque morceau que nous allons lire/écrire à la fois. Cela permet de découper les opérations en blocs plus petits.
# Dans la boucle <code>for</code> où on parcours les blocs à partir de <code>offset</code>, j'ai ajouté une boucle interne qui parcourt les données du bloc en morceaux de taille <code>CHUNK_SIZE</code>.
# À l'intérieur de la boucle interne, j'ai calculé la taille réelle du morceau (<code>chunkSize</code>) en prenant le minimum entre <code>CHUNK_SIZE</code> et la quantité de données restant à lire/écrire dans le bloc.
# J'ai modifié la fonction <code>readBlock</code> pour lire seulement la quantité de données spécifiée par <code>chunkSize</code> à partir de <code>chunkStart</code>. Ces données sont stockées dans le tableau <code>fileBuffer</code>.
# Ensuite, j'ai effectué les mêmes opérations de libération des blocs associés au fichier, en parcourant les données du morceau et en marquant les blocs comme disponibles.
# Finalement, j'ai utilisé la fonction <code>writeBlock</code> pour écrire le morceau de données modifié dans le bloc, en utilisant la même <code>chunkStart</code> pour déterminer où écrire les données.

#define CHUNK_SIZE 64

int min(int a, int b) {
return a < b ? a : b;
}

void RM(const char *filesystem_path, const char *filename) {
int fileFound = -1;
int offset;
unsigned char fileBuffer[BLOCK_SIZE];

// Parcourir les blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char *)filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {
// Effacer le nom du fichier dans le superbloc
memset(filenameBuffer, 0, MAX_FILENAME_LENGTH);
writeBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);
fileFound = 1;
offset = blockNum;
break;
}
}

// Fin de fonction si fichier inexistant
if (fileFound == -1) {
printf("Le fichier \"%s\" n'a pas été trouvé.\n", filename);
return;
}

for (int blockNum = offset; blockNum < offset + 16; blockNum++) {
int startOffset = 0;

if (blockNum == offset) {
startOffset = MAX_FILENAME_LENGTH;
}

for (int chunkStart = startOffset; chunkStart < BLOCK_SIZE; chunkStart += CHUNK_SIZE) {
int chunkSize = min(CHUNK_SIZE, BLOCK_SIZE - chunkStart);
readBlock(blockNum, chunkStart, fileBuffer, chunkSize);

for (int i = 0; i < chunkSize; i += 2) {
int blockNumData = (fileBuffer[i] << 8) | fileBuffer[i + 1];
if (blockNumData == 0) {
writeBlock(blockNum, chunkStart, fileBuffer, chunkSize);
printf("Le fichier \"%s\" a été supprimé avec succès.\n", filename);
return; // Sortir des boucles
}
setBlockAvailability(blockNumData, 0); // Marquer le bloc comme disponible
fileBuffer[i] = 0;
fileBuffer[i + 1] = 0;
}

writeBlock(blockNum, chunkStart, fileBuffer, chunkSize);
}
}

printf("Le fichier \"%s\" a été supprimé avec succès.\n", filename);
}

ReX : Si on trouve un n° de bloc de données à 0, il faut sortir des deux boucles les plus externes après avoir fait le <code>writeBlock</code>.

Amine: Modification faites ci-dessus. Maintenant, dès qu'on trouve un n° de bloc de données à 0 dans la boucle la plus interne, on effectue le <code>writeBlock</code> et ensuite on utilise <code>return</code> pour sortir des deux boucles les plus externes. Cela permet d'optimiser le code en évitant de continuer à traiter inutilement le reste des blocs.

ReX : Pas très propre (duplication de code) mais nous allons nous en contenter.

=== Fonction intermédiaire TYPE version 1 ===

J'ai également commencé à réfléchir à la fonction TYPE. Pour l'instant, elle ne fait qu'ajouter les noms de fichier dans le superbloc. Cela permet de pouvoir tester les fonctions LS et RM (voir dans la rubrique compilation et exécution comment utiliser le programme).
// Fonction pour créer un fichier avec le nom donné et le contenu fourni en entrée standard
void TYPE(const char *filesystem_path, const char *filename) {
unsigned char buffer[MAX_FILENAME_LENGTH];
// Parcours des blocs réservés pour la description des fichiers
for (int blockNum = 0; blockNum <= MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, MAX_FILENAME_LENGTH);
// Vérifier si le bloc est vide (pas de nom de fichier)
if (buffer[0] == 0) {
// Écrire le nom du fichier dans l'emplacement vide du superbloc
writeBlock(blockNum, 0, (const unsigned char *)filename, MAX_FILENAME_LENGTH);
break; // Fichier créé, sortir de la boucle
}
}
printf("Le fichier \"%s\" a été créé avec succès.\n", filename);
}

ReX : Si la boucle se termine sans trouver de slot libre le message de succès s'affiche tout de même.

ReX : Le paramètre <code>filename</code> n'a pas forcément une taille de <code>MAX_FILENAME_LENGTH</code>.

Selon moi, la fonction TYPE devra respecter 3 étapes:

# Enregistrement du Nom du Fichier: L'ajout du nom du fichier dans un des blocs de la première partie du superbloc.
# Stockage des Données du Fichier: La récupération des données saisies en entrée standard par l'utilisateur et leur stockage dans des blocs du système de fichiers à partir d'une certaine position, comme le bloc 1040.
# Mise à Jour de la Disponibilité des Blocs: L'indication que les blocs dans lesquels les données ont été écrites ne sont plus disponibles en modifiant les bits correspondants dans la deuxième partie du superbloc (les 16 derniers blocs du super bloc).

ReX : Relis le point 3 et dit moi si tu te comprends toi même ?

Amine: Ma phrase n'est effectivement pas très claire. Je voulais dire que la fonction TYPE devra mettre à jour la carte de disponibilité du superbloc. C'est à dire que lorsqu'elle écrira des données dans des blocs, elle devra indiquer dans la carte de disponibilités que ces blocs ne sont plus disponibles.

=== Fonction intermédiaire TYPE version 2 ===

Suite à vos remarques, j'ai apporté les modifications suivantes à la fonction TYPE:

* j'ai ajouté une condition pour l'affichage du message de succès de la création d'un fichier (placeFound).

* le paramètre <code>filename</code> n'ayant pas forcément une taille de <code>MAX_FILENAME_LENGTH</code>, je calcule maintenant la longueur de filename, afin d'écrire seulement le nom du fichier avec la fonction writeBlock.

Il fonction n'est bien évidemment pas fini, elle ajoute seulement le nom du fichier dans le superbloc pour l'instant. Cela me permet de tester les fonctions LS et RM.
void TYPE(const char *filesystem_path, const char *filename) {
size_t sizeFilename = strlen(filename);
printf("size filename=%d\n", sizeFilename);
unsigned char buffer[MAX_FILENAME_LENGTH];
int placeFound = 0;

if (sizeFilename > MAX_FILENAME_LENGTH) {
printf("Impossible de créer le fichier, nom trop long\n");
return;
}

// Parcours des blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, MAX_FILENAME_LENGTH);
// Vérifier si le bloc est vide (pas de nom de fichier)
if (buffer[0] == 0) {
// Écrire le nom du fichier dans l'emplacement vide du superbloc
if (sizeFilename < MAX_FILENAME_LENGTH) {
sizeFilename+=1;
}
writeBlock(blockNum, 0, (const unsigned char *)filename, sizeFilename);
placeFound = 1;
break; // Fichier créé, sortir de la boucle
}
}
if (placeFound == 1) {
printf("Le fichier \"%s\" a été créé avec succès.\n", filename);
} else {
printf("Plus de place dans le système de fichier pour créer ce fichier.\n", filename);
}
}

ReX : Mieux, attention il faut copier aussi le <code>\'0</code> final du nom, donc <code>sizeFilename+1</code>. Sinon tu n'es pas sûr qu'il y ait un zéro final. Et attention n°2, il ne faut pas copier ce <code>\'0</code> si le nom fait la taille maximale.

Amine: ok j'ai modifié la fonction TYPE ci-dessus. J'ai ajouté une condition: si le nom du fichier est inférieur à la taille maximale de nom de fichier, alors on incrémente de 1 la taille du nom de fichier. Cela nous permet d'écrire le '\0' dans le bloc de description. Dans le cas où le nom du fichier est de la taille maximale, nous n'avons pas besoin d'écrire le '\0', on n'incrémente donc pas la taille de 1.

J'ai également ajouté une condition: si le nom du fichier est supérieur à la taille maximale, alors un message d'erreur s'affiche et le fichier n'est pas créé.

ReX : OK. L'embryon de fonction <code>TYPE</code> est correct, il manque juste le principal : la création des blocs de données.

=== Fonction MV version 1 ===

J'ai ici créé la fonction MV qui permet de changer le nom d'un fichier. Pour ce faire, la fonction parcourt les blocs de descriptions à la recherche du fichier dont on veut changer le nom. Lorsque ce fichier est trouvé, on supprime l'ancien nom en mettant des 0 sur 16 octets, puis on vient réécrire le nouveau nom dans le même emplacement. Enfin, on sort de la boucle et on affiche le succès ou non de l'opération.
// Fonction qui modifie le nom du fichier
void MV(const char *filesystem_path, const char *old_filename, const char *new_filename) {
size_t sizeNew_filename = strlen(new_filename);
size_t sizeOld_filename = strlen(old_filename);
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
int fileFound = 0;
// Parcourir les blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);
// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char*)filenameBuffer, old_filename, MAX_FILENAME_LENGTH) == 0) {
// Effacer le nom du fichier dans le superbloc
memset(filenameBuffer, 0, MAX_FILENAME_LENGTH);
writeBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);
// Écrire le nom du fichier dans l'emplacement
writeBlock(blockNum, 0, (const unsigned char *)new_filename, sizeNew_filename);
fileFound=1;
break; // Nom modifié, sortir de la boucle
}
}
if (fileFound == 1) {
printf("Le nom du fichier \"%s\" a été renommé avec succès.\n", old_filename);
} else {
printf("Le fichier \"%s\" n'a pas été trouvé.\n", old_filename);
}
}

ReX : Inutile d'écraser l'ancien nom avec des zéros. Il suffit de copier le nouveau en s'assurant qu'il y ait un zéro final sauf si le nouveau nom fait la taille maximale.

Amine: ok, je vais faire les modifications dans la version 2.

== Semaine 6 ==

=== Fonction MV version 2 ===
Dans cette nouvelle version de la fonction MV, j'ai effectué les modifications suivantes:

* je n'écrase plus l'ancien nom avec des 0
* Je colle simplement le nouveau nom par dessus l'ancien, en m'assurant qu'il y ait bien le '\0' à la fin lorsque la taille du nom du fichier est inférieur à la taille maximale. Comme précédemment, afin de m'assurer de la présence de ce '\0' à la fin du nom, j'incrémente la taille de 1 lorsque qu'elle est inférieur à la taille max. Cependant, je ne suis pas sûr à 100% que ce soit la bonne manière de faire.

// Fonction qui modifie le nom du fichier
void MV(const char *filesystem_path, const char *old_filename, const char *new_filename) {
size_t sizeNew_filename = strlen(new_filename);
size_t sizeOld_filename = strlen(old_filename);
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
int fileFound = 0;

// Parcourir les blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {

readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char*)filenameBuffer, old_filename, MAX_FILENAME_LENGTH) == 0) {

if (sizeNew_filename < MAX_FILENAME_LENGTH) {
sizeNew_filename+=1;
}

// Écrire le nom du fichier dans l'emplacement
writeBlock(blockNum, 0, (const unsigned char *)new_filename, sizeNew_filename);

fileFound=1;

break; // Nom modifié, sortir de la boucle
}
}
if (fileFound == 1) {
printf("Le nom du fichier \"%s\" a été renommé avec succès.\n", old_filename);
} else {
printf("Le fichier \"%s\" n'a pas été trouvé.\n", old_filename);
}
}

ReX : C'est bon. La fonction était triviale.

=== Fonction TYPE version 1 ===
void TYPE(const char *filesystem_path, const char *filename) {
size_t sizeFilename = strlen(filename);
unsigned char buffer[MAX_FILENAME_LENGTH];
int placeFound = -1;

if (sizeFilename > MAX_FILENAME_LENGTH) {
printf("Impossible de créer le fichier, nom trop long\n");
return;
}

// Parcours des blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, MAX_FILENAME_LENGTH);
// Vérifier si le bloc est vide (pas de nom de fichier)
if (buffer[0] == 0) {
// Écrire le nom du fichier dans l'emplacement vide du superbloc
if (sizeFilename < MAX_FILENAME_LENGTH) {
sizeFilename += 1; // Ajouter '\0' s'il y a de la place
}
writeBlock(blockNum, 0, (const unsigned char *)filename, sizeFilename);
placeFound = blockNum;

// Lire les données depuis l'entrée standard
unsigned char dataBuffer[BLOCK_SIZE];
size_t bytesRead;
int dataBlockNum = findAvailableBlock(); // Premier bloc de données à partir du bloc 1040
printf("dataBlockNum%d\n",dataBlockNum);
int blockSizeUsed = 0; // Compteur d'octets dans le bloc actuel
int dataBlocksNeeded = 1; // Nombre de blocs de données nécessaires

while ((bytesRead = fread(dataBuffer + blockSizeUsed, 1, BLOCK_SIZE - blockSizeUsed, stdin)) > 0) {
blockSizeUsed += bytesRead;

// Si le bloc actuel est plein, passer au bloc suivant
if (blockSizeUsed == BLOCK_SIZE) {
// printf("dataBlockNum=%d\n",dataBlockNum);
writeBlock(dataBlockNum, 0, dataBuffer, BLOCK_SIZE);
setBlockAvailability(dataBlockNum, 1);

dataBlockNum++; // Passer au bloc suivant
blockSizeUsed = 0; // Réinitialiser la taille utilisée
dataBlocksNeeded++;
}
}

// Écrire le dernier bloc partiel, s'il y en a un
if (blockSizeUsed > 0) {
writeBlock(dataBlockNum, 0, dataBuffer, blockSizeUsed);
setBlockAvailability(dataBlockNum, 1);
}

// Écrire les numéros de blocs utilisés dans le bloc de description
unsigned char blockNumberBuffer[2];
int currentBlockNum = 1040;

for (int i = 0; i < dataBlocksNeeded; i++) {
blockNumberBuffer[0] = (currentBlockNum >> 8) & 0xFF;
blockNumberBuffer[1] = currentBlockNum & 0xFF;
writeBlock(placeFound, MAX_FILENAME_LENGTH + i * 2, blockNumberBuffer, 2);
currentBlockNum++;
}

break; // Fichier créé, sortir de la boucle
}
}

if (placeFound != -1) {
printf("Le fichier \"%s\" a été créé avec succès.\n", filename);
} else {
printf("Plus de place dans le système de fichier pour créer ce fichier.\n");
}
}

ReX : La constante 1040 ne doit pas apparaître en numérique, ce doit être une constante calculée à partir des autres constantes.

Amine: Ok. Je ne l'avais pas défini comme une constante car il s'agit dans la fonction ci-dessus d'une variable qui est incrémenté à chaque itération.

ReX : Je suis las de te répéter que le mémoire est comptée : tu utilises encore un bloc de <code>BLOCK_SIZE</code> octets, c'est trop.

Amine: Comment utiliser des blocs plus petit sachant qu'il s'agit là de blocs de données et qu'un bloc fait 256 octets d'après l'énoncé ? Dois-je les subdiviser en plusieurs blocs plus petit comme fait dans la fonction RM, en 4 blocs de 64 octets par exemple ?

Fonctionnement de la fonction TYPE:

* étape 1: on parcourt les blocs de descriptions à la recherche d'un bloc disponible. Si on ne trouve pas de bloc disponible, on renvoie un message d'erreur, sinon on passe à l'étape suivante.
* étape 2: Si on trouve un emplacement libre dans les blocs de disponibilité, on écrit le nom du fichier dans cet emplacement.

ReX : Dans les blocs de description de fichiers pas dans les blocs de disponibilité.

Amine: Oui autant pour moi.

* étape 3: Ensuite, on lit le texte entré par l'utilisateur en entrée standard, on le répartit dans des blocs de taille BLOCK_SIZE, on met à jour la disponibilité des blocs utilisés.

ReX : Non, il faut appeler <code>findAvailableBlock</code> pour chaque bloc de données à utiliser, aucune certitudes que les blocs libres soient en séquence.

Amine: ok, je ferai cela dans la version 2

* étape 4: Enfin, on écrit les numéros des blocs de données utilisés dans les blocs de description de ce fichier, les numéros étant écris sur deux octets.

ReX : Non cela doit se faire au fur et à mesure des appels à <code>findAvailableBlock</code> et les numéros des blocs de données peuvent s'étaler sur les 16 blocs de description du fichier. Confusion totale sur ce point. Vous n'avez pas compris le mécanisme.

Amine: je corrige cela dans la version 2. J'ai bien compris le mécanisme mais ce n'est pas facile à traduire en code.

=== Fonction TYPE version 2 ===
Dans cette nouvelle version de TYPE, j'ai fait les modifications suivantes:

* j'appelle maintenant <code>findAvailableBlock</code> pour chaque bloc de données à utiliser
* j'écris maintenant les numéros de blocs au fur et à mesures des appels à <code>findAvailableBlock</code>
* je n'utilise plus de tableaux de taille 256 octets mais des tableaux de tailles CHUNK_SIZE. J'ai choisi ici CHUNK_SIZE = 64 octets.

J'utilise toujours un bloc de taille BLOCK_SIZE en attendant de comprendre si je dois diviser ce bloc en plusieurs blocs de taille plus petite ou s'il y a un moyen de ne pas du tout utiliser ces blocs.
void TYPE(const char *filesystem_path, const char *filename) {
size_t sizeFilename = strlen(filename);
unsigned char buffer[MAX_FILENAME_LENGTH];
int placeFound = -1;

if (sizeFilename > MAX_FILENAME_LENGTH) {
printf("Impossible de créer le fichier, nom trop long\n");
return;
}

// Parcours des blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, MAX_FILENAME_LENGTH);
// Vérifier si le bloc est vide (pas de nom de fichier)
if (buffer[0] == 0) {
// Écrire le nom du fichier dans l'emplacement vide du superbloc
if (sizeFilename < MAX_FILENAME_LENGTH) {
sizeFilename += 1; // Ajouter '\0' s'il y a de la place
}
writeBlock(blockNum, 0, (const unsigned char *)filename, sizeFilename);
placeFound = blockNum;

// Lire les données depuis l'entrée standard et écrire dans le fichier
int dataBlockNum = findAvailableBlock(); // Premier bloc de données à partir du bloc 1040
printf("Premier bloc dans lequel on écrit = %d\n", dataBlockNum);
int blockSizeUsed = 0; // Compteur d'octets dans le bloc actuel

unsigned char chunkBuffer[CHUNK_SIZE];
size_t bytesRead;

while ((bytesRead = fread(chunkBuffer, 1, CHUNK_SIZE, stdin)) > 0) {
// Écrire le chunk dans le bloc de données
writeBlock(dataBlockNum, blockSizeUsed, chunkBuffer, bytesRead);
setBlockAvailability(dataBlockNum, 1);

// Écrire le numéro du bloc actuel dans la description du fichier
unsigned char blockNumberBuffer[2];
blockNumberBuffer[0] = (dataBlockNum >> 8) & 0xFF;
blockNumberBuffer[1] = dataBlockNum & 0xFF;
writeBlock(placeFound, MAX_FILENAME_LENGTH + dataBlockNum * 2, blockNumberBuffer, 2);

blockSizeUsed += bytesRead;

// Si le bloc actuel est plein, passer au bloc suivant
if (blockSizeUsed == BLOCK_SIZE) {
dataBlockNum = findAvailableBlock(); // Passer au bloc suivant
blockSizeUsed = 0; // Réinitialiser la taille utilisée
}
}

break; // Fichier créé, sortir de la boucle
}
}

if (placeFound != -1) {
printf("Le fichier \"%s\" a été créé avec succès.\n", filename);
} else {
printf("Plus de place dans le système de fichier pour créer ce fichier.\n");
}
}

=== Fonction findAvailableBlock ===
Cette fonction renvoie l'indice du premier bloc disponible. Je me sers de cette fonction dans la fonction TYPE.
#define FIRST_DATA_BLOCK 1040
#define FIRST_DISPONIBILITY_CARD_BLOCK 1024

// Renvoie le premier bloc de donné disponible
int findAvailableBlock() {
unsigned char availabilityBuffer[BLOCK_SIZE];
int offset;

// Lire la carte de disponibilité (à partir du bloc 1)
for (int blockNum = FIRST_DISPONIBILITY_CARD_BLOCK; blockNum < FIRST_DATA_BLOCK; blockNum++) {
readBlock(blockNum, 0, availabilityBuffer, BLOCK_SIZE);

if (blockNum==FIRST_DISPONIBILITY_CARD_BLOCK) {
offset=FIRST_DATA_BLOCK/8;
} else {
offset=0;
}

// Parcourir les octets de la carte de disponibilité
for (int byteIndex = offset; byteIndex < BLOCK_SIZE - offset; byteIndex++) {
unsigned char byte = availabilityBuffer[byteIndex];

// Parcourir les bits de chaque octet
for (int bitIndex = 0; bitIndex < 8; bitIndex++) {
// Vérifier si le bit est à 0 (bloc disponible)
if ((byte & (1 << bitIndex)) == 0) {
// Calculer l'indice du bloc en fonction du bloc et du bit
int blockIndex = byteIndex * 8 + bitIndex;
return blockIndex;
}
}
}
}

// Aucun bloc disponible trouvé
return -1;
}

ReX : Même remarque que précédement sur les nombres 1024 et 1040.

Amine: Ok, j'ai remplacé 1024 par la constante FIRST_DISPONIBILITY_CARD_BLOCK et 1040 par la constante FIRST_DATA_BLOCK dans la fonction ci-dessus.

ReX : Vous n'avez toujours pas compris la contrainte sur la mémoire.

Amine: dois-je découper le bloc de taille BLOCK_SIZE en quatre blocs de taille 64 octets par exemple ?

ReX : Je ne vois pas ce que vous voulez faire avec <code>if (blockNum==1024) offset=1040/8; else offset=0;</code>.

Amine: dans la carte de disponibilité, chaque bit correspond à un bloc. Ainsi, les bits de 0 à 1040 dans la carte de disponibilité décrivent la disponibilité des blocs 0 à 1040. Or ces blocs correspondent au superbloc, et dans cette fonction, on veut connaître le premier bloc de données disponible. On ne s'intéresse donc pas au 1040 premiers bits de la carte de disponibilité. Je crée donc un offset égal à 1040/8 afin de ne pas prendre en compte les 1040 premiers bits soit les 1040/8=130 premiers octets. Cet offset ne s'applique que lorsqu'on se trouve dans le premier des 16 blocs de la carte de disponibilité, d'où la condition <code>if (blockNum==1024)</code>.

ReX : OK, bien vu.

=== Fonction CAT version 1 ===
void CAT(const char *filesystem_path, const char *filename) {
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
unsigned char buffer[BLOCK_SIZE];
unsigned char blockNumberBuffer[2];
unsigned char dataBuffer[BLOCK_SIZE];
int offset;

// Parcours des blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char *)filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {
// Le nom du fichier a été trouvé

// Parcours les blocs de description
for (int descrBlockNum=0; descrBlockNum<MAX_BLOCKS_PER_FILE_DESCRIPTION; descrBlockNum++) {
if (descrBlockNum==0) {
offset=16;
} else {
offset=0;
}
readBlock(descrBlockNum+blockNum, offset, buffer, BLOCK_SIZE-offset);

// Lire les numéros de blocs associés à ce fichier depuis les blocs de description
unsigned char octet1 = buffer[offset];
unsigned char octet2 = buffer[offset+1];

int dataBlockNum = (octet1 << 8) | octet2;
printf("dataBlockNum=%d\n",dataBlockNum);

// Vérifier si le numéro de bloc est valide (non nul)
if (dataBlockNum == 0) {
return; // Fin du fichier
}

// Lire et afficher le contenu du bloc de données
readBlock(dataBlockNum, 0, dataBuffer, BLOCK_SIZE);
fwrite(dataBuffer, 1, BLOCK_SIZE, stdout);
}

return; // Fichier affiché, sortie de la fonction
}
}

// Si le fichier n'a pas été trouvé
printf("Le fichier \"%s\" n'a pas été trouvé.\n", filename);
}

ReX : Encore mieux : deux blocs de <code>BLOCK_SIZE</code> en mémoire.

ReX : Le <code>break</code> ne sort pas de la boucle externe.

Amine: Oui c'est vrai. J'ai remplacé le <code>break</code> par un <code>return</code> ci-dessus.

ReX : Dans le cadre de la fonction CAT le <code>return</code> est convenable.

Voici ma fonction <code>CAT</code>. Elle fonctionne en plusieurs étape:

* étape 1: on cherche dans les blocs de descriptions si le fichier dont on veut afficher le contenu existe. Si le nom de fichier est trouvé, on passe à l'étape 2. Sinon, on renvoie un message d'erreur.
* étape 2: si le fichier est trouvé, on parcours les 16 blocs de description de ce fichier.
* étape 3: grâce aux opérations de masquage et de décalage, on joint les octets deux par deux pour former un entier qui contient le numéro du bloc de données correspondant au fichier. Si cet entier vaut 0, alors cela signifie qu'il n'y a plus de blocs associé à ce fichier, on peut donc quitter la fonction. Si cet entier est différent de 0, alors on va lire le bloc correspondant à ce numéro et on affiche son contenu dans le terminal.

== Semaine 7 ==

=== Fonction CP version 1 ===
Voici ma fonction CP, qui permet de créer une copie d'un fichier existant. L'idée est la suivante: pour copier un fichier, on doit créer un nouveau fichier et lui attribuer les mêmes blocs de descriptions que le fichier source. Ainsi, le fichier source et le fichier destination pointeront vers les mêmes blocs de données, et auront le même contenu.

ReX : Perdu. Ce n'est absolument pas la fonction de copie de fichiers d'un système de fichiers.

Amine: Après avoir fait des recherches et après réflexion, je me rends compte que cette fonction CP présente un problème: en faisant pointer les blocs de données du fichier destination vers ceux du fichier source, toute modification du fichier source impactera le fichier destination, or ce n'est pas ce qu'on veut faire. Je vous propose donc une nouvelle version de la fonction CP ci-dessous qui remédie à ce problème.

void CP(const char *filesystem_path, const char *source_filename, const char *destination_filename) {
unsigned char source_filenameBuffer[MAX_FILENAME_LENGTH];
unsigned char destination_filenameBuffer[MAX_FILENAME_LENGTH];
unsigned char descriptionBuffer[BLOCK_SIZE];
int destination_offset;
int offset;

// Recherche du fichier source
int source_offset = -1;
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, source_filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier source
if (strncmp((const char *)source_filenameBuffer, source_filename, MAX_FILENAME_LENGTH) == 0) {
source_offset = blockNum;
break;
}
}

if (source_offset == -1) {
printf("Le fichier source \"%s\" n'a pas été trouvé.\n", source_filename);
return;
}

// Recherche d'un emplacement libre pour le fichier destination
destination_offset = -1;
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, destination_filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc est vide (pas de nom de fichier)
if (destination_filenameBuffer[0] == 0) {
destination_offset = blockNum;
break;
}
}

if (destination_offset == -1) {
printf("Plus de place dans le système de fichier pour créer la copie de \"%s\".\n", source_filename);
return;
}

// Ecrit le nom de la copie dans le bloc de description
writeBlock(destination_offset, 0, (const unsigned char *)destination_filename, strlen(destination_filename));

// Copier les blocs de description associés au fichier source dans les blocs de description du fichier destination
for (int i = 0; i < MAX_BLOCKS_PER_FILE_DESCRIPTION; i++) {
if (i==0) {
offset = MAX_FILENAME_LENGTH;
} else {
offset = 0;
}

readBlock(source_offset+i, offset, descriptionBuffer, BLOCK_SIZE-offset);
if (descriptionBuffer[offset]==0) {
return;
} else {
writeBlock(destination_offset+i, offset, descriptionBuffer, BLOCK_SIZE-offset);
}
}

printf("La copie de \"%s\" sous le nom \"%s\" a été créée avec succès.\n", source_filename, destination_filename);
}

ReX : Pas mieux.

== Semaine 8 ==
A ce stade du projet, les fonctions suivantes ont été validé par Monsieur Redon:

* fonction LS
* fonction RM
* fonction MV

Il reste donc les fonctions suivantes à terminer:

* fonction CAT
* fonction CP
* fonction TYPE

=== Fonction CAT version 2 ===
Suite à vos remarques sur la version 1, j'ai fais les modifications suivantes:

* je n'utilise non plus 2 tableaux de taille BLOCK_SIZE, mais 1 seul. Idéalement il faudrait en utiliser 0, je réfléchi donc à m’émanciper de ce tableau en le remplaçant par plusieurs plus petits tableaux.

ReX : Un seul plus petit.

* J'ai remplacé le <code>break</code> par un <code>return</code>

ReX : Déjà validé.

Cette fonction permet d'afficher le contenu d'un fichier créé avec la fonction TYPE. Pour se faire, on parcours tout d'abord les blocs de descriptions pour trouver le fichier dont ont veut afficher le contenu. Une fois ce fichier trouvé, on parcours les 16 blocs de description de ce fichier 1 à 1. Pour chacun de ces blocs de description, on va stocker récupéré les octets deux par deux afin de former des entiers. Pour se faire, on utilise la fonction <code>reconsituteNumber</code> que l'on détaillera juste après. Ces entiers correspondent aux blocs dans lesquels la donné du fichier se trouve. Une fois l'entier reconstitué, on affiche le contenu du bloc correspondant.
#define CHUNK_SIZE 64

void CAT(const char *filesystem_path, const char *filename) {
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
unsigned char byteBuffer[2];
unsigned char dataBuffer[CHUNK_SIZE];
int offset;

// Parcours des blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char *)filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {
// Le nom du fichier a été trouvé

// Parcours les blocs de description
for (int descrBlockNum=0; descrBlockNum<MAX_BLOCKS_PER_FILE_DESCRIPTION; descrBlockNum++) {
if (descrBlockNum==0) {
offset=MAX_FILENAME_LENGTH;
} else {
offset=0;
}

// Lecture des octets deux par deux
for (int i=0; i<BLOCK_SIZE;i+=2) {
readBlock(descrBlockNum+blockNum, offset+i, byteBuffer, 2);

// Lire les numéros de blocs associés à ce fichier depuis les blocs de description
int dataBlockNum = reconsituteNumber(byteBuffer);

// Vérifier si le numéro de bloc est valide (non nul)
if (dataBlockNum == 0) {
return; // Fin du fichier
}

for (int chunkStart = 0; chunkStart < BLOCK_SIZE; chunkStart += CHUNK_SIZE) {
// Lire et afficher le contenu du bloc de données
readBlock(dataBlockNum, chunkStart, dataBuffer, CHUNK_SIZE);
fwrite(dataBuffer, 1, CHUNK_SIZE, stdout);
}
}
}

return; // Fichier affiché, sortie de la fonction
}
}

// Si le fichier n'a pas été trouvé
printf("Le fichier \"%s\" n'a pas été trouvé.\n", filename);
}

ReX : Remplacer le premier bloc de <code>BLOCK_SIZE</code> octets par un bloc de 2 octets est exagéré mais cela pourrait passer. Il reste toujours un bloc de <code>BLOCK_SIZE</code> octets dont il est facile de se passer au bénéfice d'un bloc de, mettons, 64 octets.

Amine: Voilà! Dans la version ci-dessus j'ai remplacé le bloc de taille <code>BLOC_SIZE</code> par un bloc de taille <code>CHUNK_SIZE</code>, avec <code>CHUNK_SIZE</code> modifiable dans les constantes du programme. J'ai pris ici 64 octets.

=== Fonction reconsituteNumber ===
Cette fonction permet de reconstituer un numéro de bloc à partir de deux octets.
// Fonction qui reconstitue le numéro de bloc à partir du tableau
int reconsituteNumber(unsigned char blockNumberBuffer[2]) {
unsigned char octet1 = blockNumberBuffer[0];
unsigned char octet2 = blockNumberBuffer[1];
int dataBlockNum = (octet1 << 8) | octet2;
return dataBlockNum;
}

ReX : Bonne idée cette fonction.

=== Fonction CP version 2 ===
Voici une version mise à jour de notre fonction CP. Dans la version précédente, on faisait pointer le fichier source vers les même blocs que le fichier destination. Cela posait un problème: toute modification du fichier source impactait le fichier destination. Ainsi, dans cette nouvelle version, on fait une duplication des blocs de données du fichier source vers le fichier destination. Cela implique donc une mise à jour de la carte de disponibilité, ainsi que l'adaptation des blocs de descriptions. En effet, seulement les blocs de données sont maintenant identiques, plus les blocs de description.

Piste d'amélioration: comme pour la fonction CAT ci-dessus, j'utilise toujours un bloc de taille 256 octets, je vais devoir y remédier.
// Fonction pour copier un fichier existant du système de fichier
void CP(const char *filesystem_path, const char *source_filename, const char *destination_filename) {
unsigned char source_filenameBuffer[MAX_FILENAME_LENGTH];
unsigned char destination_filenameBuffer[MAX_FILENAME_LENGTH];
unsigned char descriptionBuffer[CHUNK_SIZE];
unsigned char numBuffer[2];
int destination_offset;
int source_offset;
int offset;
int numDataBlock;
int newDataBlock;

// Recherche du fichier source
source_offset = -1;
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, source_filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier source
if (strncmp((const char *)source_filenameBuffer, source_filename, MAX_FILENAME_LENGTH) == 0) {
source_offset = blockNum;
break;
}
}

if (source_offset == -1) {
printf("Le fichier source \"%s\" n'a pas été trouvé.\n", source_filename);
return;
}

// Recherche d'un emplacement libre pour le fichier destination
destination_offset = -1;
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, destination_filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc est vide (pas de nom de fichier)
if (destination_filenameBuffer[0] == 0) {
destination_offset = blockNum;
break;
}
}

if (destination_offset == -1) {
printf("Plus de place dans le système de fichier pour créer la copie de \"%s\".\n", source_filename);
return;
}

// Copie du nom de la copie dans le bloc de description
writeBlock(destination_offset, 0, (const unsigned char *)destination_filename, strlen(destination_filename));

// Copier les blocs de données associés au fichier source dans de nouveaux blocs de données pour le fichier destination
for (int i = 0; i < MAX_BLOCKS_PER_FILE_DESCRIPTION; i++) {
if (i == 0) { offset = MAX_FILENAME_LENGTH; }
else { offset = 0; }

// Lecture des numéros de bloc dans les blocs de description
for (int byteNum=0; byteNum<BLOCK_SIZE; byteNum+=2) {
readBlock(source_offset + i, offset + byteNum, numBuffer, 2);

numDataBlock = reconsituteNumber(numBuffer);
if (numDataBlock == 0) {
printf("La copie de \"%s\" sous le nom \"%s\" a été créée avec succès.\n", source_filename, destination_filename);
return;
}

for (int chunkStart = 0; chunkStart < BLOCK_SIZE; chunkStart += CHUNK_SIZE) {
// On stocke le bloc de données associé au fichier source dans descriptionBuffer
readBlock(numDataBlock, chunkStart, descriptionBuffer, CHUNK_SIZE);

if (chunkStart == 0) {
// Trouver un nouveau bloc de données disponible
newDataBlock = findAvailableBlock();

// Mise à jour de la carte de disponibilités
setBlockAvailability(newDataBlock, 1);

// Ecriture du numéro de bloc dans la description du fichier
createNumberBuffer(newDataBlock,numBuffer);
writeBlock(destination_offset+i, offset+byteNum, numBuffer, 2);
}

// Ecriture du bloc de données dans le premier bloc disponible
writeBlock(newDataBlock, chunkStart, descriptionBuffer, CHUNK_SIZE);
}
}
}
}

ReX : Youpi. Il reste à se passer du bloc de <code>BLOCK_SIZE</code> (au bénéfice d'un bloc de taille <code>BLOCK_SIZE/n</code> avec n>1). Ecrire la fonction inverse de <code>reconsituteNumber</code>.

Amine: Voilà! Dans le fonction ci-dessus il n'y a plus de bloc de taille <code>BLOCK_SIZE</code>, on a maintenant des blocs de 64 octets (<code>CHUNK_SIZE</code>). J'ai également créé la fonction <code>createNumberBuffer</code> qui est la fonction inverse de<code>reconsituteNumber</code>. Je la détaille ci-dessous.

=== Fonction createNumberBuffer ===
Cette fonction permet repartir un entier sur deux octets.
// Fonction qui réparti un numéro de bloc sur deux octets
void createNumberBuffer(int dataBlockNum, unsigned char blockNumberBuffer[2]) {
blockNumberBuffer[0] = (dataBlockNum >> 8) & 0xFF;
blockNumberBuffer[1] = dataBlockNum & 0xFF;
}

=== Fonction TYPE version 3 ===
La fonction 2 que j'ai fourni ci-dessus n'est pas correcte. Je vais la corriger dans cette version 3.

ReX : Effectivement la version précédente ne gére pas correctement l'écriture des numéros de blocs de données dans la description d'un fichier.

Voici ma version 3 de la fonction TYPE. Voici son fonctionnement:

- tout d'abord, la fonction parcours les blocs de description à la recherche d'un emplacement vide

- une fois l'emplacement vide trouvé, elle écrit le nom du fichier dans cet emplacement

- ensuite, on passe à la lecture de l'entrée standard. J'ai essayé d'expliquer au fur et à mesure du programme ce que font les lignes importantes via les commentaires.
void TYPE(const char *filesystem_path, const char *filename) {
size_t sizeFilename = strlen(filename);
unsigned char buffer[MAX_FILENAME_LENGTH];
int placeFound = -1;
int index_description_block = 0; // indice du bloc de descrption
int block_counter = 1; //compteur de blocs utilisés
int index_in_descrBlock = 0;
int offset;
int first_loop=1;

if (sizeFilename > MAX_FILENAME_LENGTH) {
printf("Impossible de créer le fichier, nom trop long\n");
return;
}

// Parcours des blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, MAX_FILENAME_LENGTH);
// Vérifier si le bloc est vide (pas de nom de fichier)
if (buffer[0] == 0) {
// Écrire le nom du fichier dans l'emplacement vide du superbloc
if (sizeFilename < MAX_FILENAME_LENGTH) {
sizeFilename += 1; // Ajouter '\0' s'il y a de la place
}
writeBlock(blockNum, 0, (const unsigned char *)filename, sizeFilename);
placeFound = blockNum;

// Lire les données depuis l'entrée standard et écrire dans le fichier
int dataBlockNum = findAvailableBlock(); // Premier bloc de données à partir du bloc 1040
int blockSizeUsed = 0; // Compteur d'octets dans le bloc actuel

unsigned char chunkBuffer[CHUNK_SIZE];
size_t bytesRead;

while ((bytesRead = fread(chunkBuffer, 1, CHUNK_SIZE, stdin)) > 0) {

// Écrire le chunk dans le bloc de données
writeBlock(dataBlockNum, blockSizeUsed, chunkBuffer, bytesRead);
setBlockAvailability(dataBlockNum, 1);

// Écrire le numéro du bloc actuel dans la description du fichier
unsigned char blockNumberBuffer[2];
createNumberBuffer(dataBlockNum,blockNumberBuffer);

blockSizeUsed += bytesRead;

// Si le bloc actuel est plein, passer au bloc suivant OU si c'est le premier tour dans la boucle
if (blockSizeUsed == BLOCK_SIZE || first_loop == 1) {

first_loop = -1;

// Ecriture du numéro de bloc utilisé dans les blocs de description
if (index_description_block == 0) {
offset = MAX_FILENAME_LENGTH;
} else {
offset = 0;
}
writeBlock(placeFound + index_description_block, offset + index_in_descrBlock*2, blockNumberBuffer, 2);
index_in_descrBlock++;

dataBlockNum = findAvailableBlock(); // Passer au bloc suivant
blockSizeUsed = 0; // Réinitialiser la taille utilisée

// Passage au bloc de description suivant
if (block_counter == (BLOCK_SIZE/2-offset)) {
index_description_block++;
index_in_descrBlock=0;
}

// Compteur de nombre de blocs utilisés
block_counter++;

// Vérifie si on a atteint le nombre maximal de blocs par fichier
if (block_counter >= MAX_BLOCKS_PER_FILE) {
printf("Le fichier a atteint sa taille maximale\n");
return;
}
}
}

break; // Fichier créé, sortir de la boucle
}
}

if (placeFound != -1) {
printf("Le fichier \"%s\" a été créé avec succès.\n", filename);
} else {
printf("Plus de place dans le système de fichier pour créer ce fichier.\n");
}
}

= Compilation et exécution =
'''Création du système de fichiers :'''
dd if=/dev/zero of=filesystem.bin bs=256 count=32768

'''Compilation :'''

gcc picofs.c -o picofs

'''Exécution de LS, TYPE, CAT, RM, MV ou CP :'''

./picofs filesystem.bin LS
./picofs filesystem.bin TYPE mon_fichier.txt
./picofs filesystem.bin CAT mon_fichier.txt
./picofs filesystem.bin RM mon_fichier.txt
./picofs filesystem.bin MV mon_fichier.txt mon_fichier2.txt
./picofs filesystem.bin CP mon_fichier.txt mon_fichier2.txt

= Documents Rendus =
[[Fichier:PicofsV2.c.tar|vignette]]

SE4 2022/2023 EC1

2023-09-04T18:33:29Z

Asellali : /* Documents Rendus */

= Objectifs =

Il vous est demandé de :
* réaliser un micro système de fichiers ;
* le système de fichiers doit résider dans un fichier de 8 Mo ;
* le système de fichiers est géré par un exécutable obtenu à partir d'un programme C ;
* L'éxécutable prend deux arguments, le premier est le chemin du fichier dans lequel réside le système de fichiers, les paramètres suivants concernent l'action à appliquer sur le système de fichiers ;
* le micro système de fichier ne comporte qu'un répertoire : le répertoire principal, le répertoire principal peut comporter au maximum 64 fichiers, un fichier est caractérisé par un nom de 16 caractères au maximum et ses blocs de données, un fichier peut comporter au maximum 2040 blocs de données ;
* un bloc de données fait 256 octets et les blocs sont numérotés sur 2 octets ;
* les différentes actions possibles sur le système de fichiers sont :
** <code>TYPE</code> pour créer un fichier si possible, le nom du fichier suit la commande, le contenu du fichier est donné en entrée standard de l'exécutable ;
** <code>CAT</code> pour afficher un fichier, le nom du fichier suit la commande ;
** <code>RM</code> pour détruire un fichier, le nom du fichier suit la commande ;
** <code>MV</code> pour renommer un fichier, les noms original et nouveau du fichier suivent la commande ;
** <code>CP</code> pour copier un fichier, les noms de l'original et de la copie du fichier suivent la commande ;

= Matériel nécessaire =

Un PC sous Linux.

= Travail réalisé =

== Semaine 1 ==

ReX : attention, ce micro-système de fichiers est prévu pour un microcontrôleur, vos variables globales ne peuvent pas dépasser quelques centaines d'octets.

ReX : pour la création du système de fichiers la commande <code>dd</code> suffit, vous voulez dire le formatage du système de fichiers ?

* création du programme programme.c contenant les différentes structures et les différentes fonctions.
* Piste d'amélioration: faire en sorte que la fonction CAT affiche le contenu exact des fichiers passés en argument.

Le code fourni est un programme en langage C qui simule un système de fichiers basique. Ce programme permet aux utilisateurs d'effectuer diverses actions telles que créer, afficher, supprimer, renommer et copier des fichiers dans un système de fichiers simulé. Le système de fichiers est stocké dans un fichier binaire.

ReX : vous n'avez pas tenu compte de la première remarque, vous chargez tout le superbloc et le répertoire racine, votre code ne convient pas.

ReX : vos structures utilisent des types entiers dont la taille n'est pas explicitée, utilisez les types de <code>stdint.h</code>.

ReX : la création de fichier n'est pas fonctionnelle, vous ne cherchez pas les blocs libres, vous ne copiez pas le contenu du fichier dans les blocs, même remarque pour toutes les autres fonctions.

ReX : il manque les fonctions d'accès aux pages du système de fichiers.

'''Explication du programme programme.c'''

Voici une brève explication des principaux éléments et fonctions du code :

# Structures :
#* Fichier : Représente un fichier dans le système de fichiers. Il contient un nom (nom) avec une longueur maximale de 16 caractères, un tableau de numéros de bloc (blocs) où le contenu du fichier est stocké (jusqu'à 2040 blocs), et le nombre de blocs utilisés par le fichier (nbBlocs).
#* Repertoire : Représente le répertoire principal du système de fichiers. Il contient un tableau de fichiers (<code>fichiers</code>) et le nombre de fichiers dans le répertoire (<code>nbFichiers</code>).
# Fonctions :
#* <code>chargerSystemeFichiers</code> : Charge le système de fichiers à partir d'un fichier binaire donné (chemin) dans une structure Repertoire.
#* <code>sauvegarderSystemeFichiers</code> : Sauvegarde le système de fichiers stocké dans la structure Repertoire dans un fichier binaire (chemin).
#* <code>creerFichier</code> : Crée un nouveau fichier dans le système de fichiers avec un nom et un contenu donnés. Le contenu du fichier est simulé en le divisant en blocs.
#* <code>afficherFichier</code> : Affiche le contenu d'un fichier avec le nom spécifié.
#* <code>detruireFichier</code> : Supprime un fichier avec le nom spécifié du système de fichiers.
#* <code>renommerFichier</code> : Renomme un fichier avec l'ancien nom spécifié en un nouveau nom.
#* <code>copierFichier</code> : Copie un fichier avec le nom spécifié en créant un nouveau fichier avec le nom de copie spécifié.
# Fonction <code>main</code> :
#* La fonction <code>main</code> est le point d'entrée du programme.
#* Elle prend des arguments en ligne de commande : <code><chemin_systeme_fichiers></code> et <code><action></code>.
#* <code><chemin_systeme_fichiers></code> est le chemin vers le fichier binaire où le système de fichiers est stocké.
#* <code><action></code> détermine quelle opération effectuer, comme <code>TYPE</code>, <code>CAT</code>, <code>RM</code>, <code>MV</code> ou <code>CP</code>.
#* En fonction de l'action spécifiée, le programme appelle la fonction correspondante pour effectuer l'opération souhaitée sur le système de fichiers.
Remarque : Le code fourni une simulation basique d'un système de fichiers et de ses opérations, mais il n'interagit pas réellement avec un système de fichiers réel sur le disque.

'''Comment utiliser le programme programme.c'''

étape 1: création du système de fichiers respectant le cahier des charges:

dd if=/dev/zero of=systeme_fichiers.bin bs=1M count=8

étape 2: compilation du programme C:

gcc programme.c -o gestionnaire_fs

étape 3: création d'un fichier dans le système de fichier:

./gestionnaire_fs systeme_fichiers.bin TYPE fichier1.txt

-> entrer le texte en entrée standard

étape 4: manipulation des différentes fonctions. Exemples:

./gestionnaire_fs systeme_fichiers.bin CAT fichier1.txt
./gestionnaire_fs systeme_fichiers.bin CP fichier1.txt copie.txt
./gestionnaire_fs systeme_fichiers.bin RM copie.txt
./gestionnaire_fs systeme_fichiers.bin MV fichier1.txt fichier2.txt

== Semaine 2 ==

Amine: Merci pour vos remarques. Désolé de ne pas avoir suivi votre première remarque, je pensais avoir compris ce qu'il fallait faire mais je me rend compte que non. Je vais tout reprendre depuis le début afin de repartir sur de bonnes bases.

'''Création du système de fichier avec la commande "dd"'''

A quoi sert la commande dd?

La commande <code>dd</code> permet de copier tout ou partie d'un disque par blocs d'octets, indépendamment de la structure du contenu du disque en fichiers et en répertoires (source : [https://doc.ubuntu-fr.org/dd]).

Structure de la commande

dd if=<nowiki><source> of=<cible> bs=<taille des blocs></nowiki>

<code>source</code> = données à copier

<code>cible</code> = endroit où les copier

<code>if</code> = input file

<code>of</code> = output file

<code>bs</code> = block size, habituellement une puissance de 2 supérieure ou égale à 512, représentant un nombre d'octets

Choix de la commande:

Pour la source, on prends <code>/dev/zero</code>: cela permet de créer un fichier rempli de 0. Ce fichier servira de base pour notre système de fichiers.

Pour la cible, on va l'appeler <code>filesystem.bin</Code> : ce sera notre système de fichier.

Pour la taille des blocs, on veut des blocs de données de 256 octets d'après l'enoncé. On va donc prendre <code>bs=256</code>.

Enfin, on veut que le système de fichier réside dans un fichier de 8 Mo. On va donc ajouter <code>count=31250</code>: cela indique que nous voulons écrire 32768 blocs de données dans le fichier (31250 * 256 octets = 8 Mo).

Résultat:

dd if=/dev/zero of=filesystem.bin bs=256 count=31250

Question pour M. Redon : j'ai ici essayé de respecter votre remarque "pour la création du système de fichiers la commande <code>dd</code> suffit". Cependant, pour votre seconde remarque "vous chargez tout le superbloc et le répertoire racine, votre code ne convient pas.", je ne suis pas sûr de comprendre où je fais cela: est-ce lors de la commande dd ou est-ce par la suite avec mon programme C? J'ai un peu modifié la commande dd comme vous pouvez le voir ci-dessus. Ai-je corrigé mon erreur avec cette nouvelle commande? J'ai essayé de justifier au maximum la commande dd que j'ai choisie.

ReX : Pas de problème avec la commande <code>dd</code> (mettez tous les extraits de code entre des balises <code>code</code>). Le problème est au niveau du programme C.

Amine: Ok je comprends mieux merci. Je vais donc reprendre le code étape par étape afin de mieux répondre au cahier des charges.

Gestion du système de fichier par un programme C

'''Création des structures'''
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>

// Structure pour représenter un bloc de données

struct DataBlock {
uint8_t data[256]; // 256 octets pour chaque bloc de données
};

// Structure pour représenter un fichier

struct File {
char filename[17]; // 16 caractères pour le nom du fichier + 1 caractère null-terminator
struct DataBlock data_blocks[2040]; // Tableau de blocs de données pour stocker le contenu du fichier
uint16_t num_data_blocks; // Nombre de blocs de données utilisés par le fichier
};

// Structure pour représenter un répertoire

struct Directory {
struct File files[64]; // Tableau de fichiers pour le répertoire principal
uint8_t num_files; // Nombre de fichiers dans le répertoire principal
};

Modification faite : suite à votre remarque, j'ai explicité la taille des entiers grâce aux types de <code>stdint.h.</code> (j'ai également mis les variables en anglais)

ReX : Vous ne pouvez pas utiliser ces structures, une instanciation d'une de ces structure prend trop d'espace mémoire, vous devez faire sans structure. Par ailleurs la façon dont vous représentez vos fichiers ne convient pas, la description d'un fichier contient des numéros de blocs, pas les blocs eux-même. Faites aussi attention qu'un fichier soit décrit par un nombre entier de blocs.

Question pratique: je n'arrive pas à mettre tout le code dans le même bloc comme vous l'avez fait ci-dessus dans l'étape 4 de la semaine 1. Je vois que c'est en format "préformaté" mais j'obtiens des blocs séparés lorsque j'applique ce format à mon code.

ReX : j'ai corrigé, pour un code entier la syntaxe n'est pas la même (un espace en début de chaque ligne), la balise c'est uniquement pour de très courts extraits de code.

=== Fonction <code>readBlock</code>===
Cette fonction est utilisée pour lire un bloc de données à partir du fichier <code>filesystem.bin</code> et le stocker dans un tableau de caractères (<code>storage</code>).

Fonction:

#define BLOCK_SIZE 256
// Fonction pour lire un bloc de données
void readBlock(unsigned int num, int offset, unsigned char *storage, int size) {
FILE *file = fopen("filesystem.bin", "rb");
if (file == NULL) {
perror("Erreur lors de l'ouverture du fichier");
return;
}
fseek(file, num * BLOCK_SIZE + offset, SEEK_SET);
fread(storage, 1, size, file);
fclose(file);
}

Paramètres :

* <code>num</code> : Numéro du bloc à lire. Chaque bloc contient 256 octets (1 bloc = 256 octets).
* <code>offset</code> : Décalage (en octets) à partir du début du bloc pour commencer la lecture.
* <code>storage</code> : Pointeur vers un tableau de caractères où les données lues seront stockées.
* <code>size</code> : Taille du tableau de caractères <code>storage</code>.

Fonctionnement :

* La fonction commence par ouvrir le fichier <code>filesystem.bin</code> en mode lecture binaire (<code>"rb"</code>).
* Elle utilise <code>fseek</code> pour positionner le curseur de lecture dans le fichier à l'endroit approprié pour commencer la lecture du bloc spécifié (<code>num</code>) à partir de l'offset (<code>offset</code>).
* Elle utilise ensuite <code>fread</code> pour lire <code>size</code> octets à partir du fichier et les stocker dans le tableau <code>storage</code>.
* Enfin, elle ferme le fichier avec <code>fclose</code>.

Note : Le paramètre <code>offset</code> est utilisé pour spécifier à partir de quel octet du bloc on souhaite commencer la lecture. Si <code>offset</code> est égal à 0, la lecture commencera depuis le début du bloc. Si <code>offset</code> est différent de 0, la lecture commencera à l'octet spécifié.

Remarque: dans votre mail, vous définissez "readBlock(unsigned int num,int offset,unsigned storage,int size)": storage n'est alors pas un pointeur vers un tableau de caractère. Je me suis donc permis de faire la modification.

ReX : OK pour la fonction, pas la peine d'en mettre autant dans le Wiki pour une fonction aussi simple.

=== Fonction <code>writeBlock</code> ===
Cette fonction est utilisée pour écrire un bloc de données dans le fichier <code>filesystem.bin</code> à partir d'un tableau de caractères (<code>storage</code>).

Fonction:

// Fonction pour écrire un bloc de données
void writeBlock(unsigned int num, int offset, const unsigned char *storage, int size) {
FILE *file = fopen("filesystem.bin", "rb+");
if (file == NULL) {
perror("Erreur lors de l'ouverture du fichier");
return;
}
fseek(file, num * BLOCK_SIZE + offset, SEEK_SET);
fwrite(storage, 1, size, file);
fclose(file);
}

Paramètres :

* <code>num</code> : Numéro du bloc où écrire.
* <code>offset</code> : Décalage (en octets) à partir du début du bloc pour commencer l'écriture.
* <code>storage</code> : Pointeur vers un tableau de caractères contenant les données à écrire dans le fichier.
* <code>size</code> : Taille du tableau de caractères <code>storage</code>.

Fonctionnement :

* La fonction commence par ouvrir le fichier <code>filesystem.bin</code> en mode lecture et écriture binaire (<code>"rb+"</code>).
* Elle utilise <code>fseek</code> pour positionner le curseur de lecture/écriture dans le fichier à l'endroit approprié pour commencer l'écriture du bloc spécifié (<code>num</code>) à partir de l'offset (<code>offset</code>).
* Elle utilise ensuite <code>fwrite</code> pour écrire <code>size</code> octets à partir du tableau <code>storage</code> dans le fichier.
* Enfin, elle ferme le fichier avec <code>fclose</code>.

ReX : Même remarque que pour la fonction précédente.

'''Etape 4: test des fonctions <code>readBlock</code> et <code>writeBlock</code> dans le main'''
// Exemple de fonction principale pour tester les opérations de lecture et d'écriture
int main() {
unsigned char data[BLOCK_SIZE];
// Test de la fonction readBlock
readBlock(0, 0, data, BLOCK_SIZE);
printf("Block 0, offset 0: ");
for (int i = 0; i < BLOCK_SIZE; i++) {
printf("%02x ", data[i]);
}
printf("\n");
// Test de la fonction writeBlock
unsigned char newData[BLOCK_SIZE] = {
0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88,
// ... Autres données du bloc ...
};
writeBlock(1, 0, newData, BLOCK_SIZE);
// Lecture du bloc nouvellement écrit pour vérifier
readBlock(1, 0, data, BLOCK_SIZE);
printf("Block 1, offset 0: ");
for (int i = 0; i < BLOCK_SIZE; i++) {
printf("%02x ", data[i]);
}
printf("\n");
return 0;
}

Fonctionnement :

* On déclare tout d'abord un tableau de caractères <code>data</code> de taille <code>BLOCK_SIZE</code> pour stocker les données lues du bloc.
* Ensuite, la fonction <code>readBlock</code> est appelée avec les arguments (0, 0, data, BLOCK_SIZE) pour lire le premier bloc du fichier (<code>num=0</code>, <code>offset=0</code>) et stocker les données dans <code>data</code>.
* Ensuite, la fonction <code>printf</code> est utilisée pour afficher les données lues du bloc (<code>data</code>) en format hexadécimal.
* Ensuite, un nouveau tableau de caractères <code>newData</code> est créé avec des données spécifiques pour tester la fonction <code>writeBlock</code>.
* La fonction <code>writeBlock</code> est appelée avec les arguments (1, 0, newData, BLOCK_SIZE) pour écrire le tableau <code>newData</code> dans le deuxième bloc du fichier (<code>num=1</code>, <code>offset=0</code>).
* Enfin, la fonction <code>readBlock</code> est appelée à nouveau pour lire le deuxième bloc nouvellement écrit et afficher les données lues en format hexadécimal.

Question générale : ce que j'avais la première semaine n'est plus forcément d'actualité. Puis-je supprimer les choses qui ne le sont plus afin d'alléger la page ou préférez-vous que je laisse?

ReX : Laissez.

Pour la suite : j'ai donc pour l'instant crée deux fonctions, l'une permettant la lecture et l'autre l'écriture d'un bloc, de manière à économiser la mémoire. Pour la suite, je vais essayer de créer la fonction <code>LS</code> en utilisant la fonction <code>readBlock</code>.

ReX : Oui c'est le début du projet. Mais si vous n'avez pas une bonne description de fichier cela ne donnera rien. Voir remarques plus haut.

'''Etape 5: fonction <code>LS</code>'''

Objectif: créer la fonction <code>LS</code> avec la fonction readBlock.

Question: Souhaitez-vous la fonction <code>LS</code> classique, c'est à dire la fonction <code>LS</code> qui affiche simplement le nom des fichiers présent dans le répertoire ?

ReX : Oui. Tu peux ajouter la taille si tu trouves cela trop simple.

Piste : si c'est ce que vous voulez:

* il va tout d'abord falloir que je crée des fichiers, un fichier étant composé d'un nom et de blocs (création d'une fonction createFile)
* Il faudra ensuite que je stocke ces fichiers dans le répertoire (création d'une fonction addFileToDirectory par exemple)
* enfin, il faudra que j'affiche le nom des fichiers. Pour cela, il faudra que je parcours le répertoire (structure "Directory"), puis que pour chaque fichier présent dans le répertoire que j'affiche son nom (création de la fonction LS)

Je devrais surement utiliser la fonction readBlock afin de transférer les blocs dans le fichier au travers de la variable "storage".

ReX : Créer des fichiers n'est pas nécessaire tout de suite je verrais bien si ton code est bon sans test. Laisse tomber <code>createFile</code> et <code>addFileToDirectory</code> pour l'instant.

ReX : Ton algorithme ne fonctionne pas pour un microcontrôleur où il faut économiser la mémoire, tu ne peux pas t'aider de structures. Il faudra que tu charges les noms et seulement les noms, pour la taille il faudra se baser sur le nombre de blocs.

'''Etape 6: rectification du code suite à vos remarques'''

Modifications apportées:

* suppression des structures afin d’économiser de la mémoire.

* le problème quant à la description des fichiers est normalement résolu puisque plus de structures. On ne charge plus les blocs mais seulement les noms de fichiers.

ReX : Non car si les noms ne sont pas répartis de façon régulière dans les blocs de 256 octets tu vas avoir du mal à les charger. Mais écrit la fonction <code>LS</code> et tu verras ce que je veux dire.

J'ai également ajouté deux nouvelles fonctions:

# <code>void readFileName(unsigned int file_num, char *file_name)</code>: Cette fonction permet de lire le nom du fichier associé au numéro de fichier donné (<code>file_num</code>). Elle stocke le nom du fichier lu dans le tableau <code>file_name</code>.
# <code>void writeFileName(unsigned int file_num, const char *file_name)</code>: Cette fonction permet d'écrire le nom du fichier dans le système de fichiers, associé au numéro de fichier donné (<code>file_num</code>). Elle prend en entrée le nom du fichier à écrire (<code>file_name</code>).

Suite: si vous validez cette base, je pourrai passer à la création de la fonction LS.

ReX : tu peux y aller. Je ne vois pas le code des tes deux fonctions <code>readFileName</code> et <code>writeFileName</code>.

Voici le code des fonctions <code>readFileName</code> et <code>writeFileName</code> :

'''Fonction readFileName:'''
// Fonction pour lire le nom du fichier
void readFileName(unsigned int file_num, char *file_name) {
readBlock(file_num, 0, (unsigned char *)file_name, MAX_FILENAME_LENGTH);
file_name[MAX_FILENAME_LENGTH] = '\0'; // Ajout du caractère null-terminator pour former une chaîne de caractères
}

ReX : Non, aucune raison que le fichier de numéro n soit au bloc n. Dessine la représentation d'un fichier sur le SF en comptant les octets si cela peut aider.

'''Fonction writeFileName:'''
// Fonction pour écrire le nom du fichier
void writeFileName(unsigned int file_num, const char *file_name) {
writeBlock(file_num, 0, (const unsigned char *)file_name, MAX_FILENAME_LENGTH);
}

ReX : Faux et inutile pour l'instant. Problème avec la constante MAX_FILENAME_LENGTH.

=== Fonction LS version 1 ===
// Fonction LS pour afficher les fichiers présents dans le système de fichiers
void LS(const char *filesystem_path) {
FILE *file = fopen(filesystem_path, "rb");
if (file == NULL) {
perror("Erreur lors de l'ouverture du fichier système");
return;
}
uint16_t num_files;
fread(&num_files, sizeof(uint16_t), 1, file); // Lecture du nombre de fichiers dans le système
char filename[17];
printf("Fichiers présents dans le système de fichiers:\n");
for (int i = 0; i < num_files; i++) {
readFileName(i, filename); // Lecture du nom du fichier
printf("%s\n", filename); // Affichage du nom du fichier
}
fclose(file);
}
La fonction <code>LS</code> ouvre le fichier système, lit le nombre de fichiers qu'il contient, puis affiche les noms des fichiers un par un, chacun sur une ligne séparée.

ReX : Il y a le nombre de fichiers dans ton superbloc ? Un dessin du format du superbloc avec les numéros des octets ?

ReX : Tout accès au système de fichiers doit se faire avec les deux fonctions <code>readBlock</code> et <code>writeBlock</code>.

== Semaine 3 ==
Question 1: cela fait plusieurs fois que vous mentionnez dans le wiki un "superbloc". Celui-ci n'étant pas clairement défini dans le sujet, je me demande s'il s'agit du bloc crée grâce à la fonction dd, c'est à dire que le superbloc serait en faite le bloc constitué des 31250 blocs de taille 256 octets, où s'il s'agit d'un bloc qui vient en entête, celui contenant alors des informations décrivant le système de fichier (les noms de fichiers...).

ReX : Pour ton pico système de fichiers, le superbloc consiste en les premiers blocs (de 256 octets) qui définissent les 64 fichiers possibles.

Proposition de structure: on pourrait réserver les premiers blocs du système de fichiers aux noms de fichiers ainsi qu'aux numéros des blocs correspondant à chaque fichier.

ReX : Oui c'est évident.

On sait que les noms de fichiers font au maximum 16 caractères + 1 caractère pour le '\0' (donc 17 octets car 1 char=1 octet).

ReX : Non, 16 octets suffisent, des '\0' en fin de nom uniquement si le nom fait moins de 16 caractères.

On sait également qu'un fichier contient au maximum 2040 blocs, chaque bloc étant numéroté sur 2 octets. On pourrait donc avoir en début du système de fichier: 17 octets+2 octets*2040 blocs = 4097 octets pour la description d'un fichier.

ReX : Non, 4096 octets soit 16 blocs de 256.

Or d'après l'une de vos remarques dans le wiki, un fichier doit être décrit par un nombre entier de blocs. Pour un fichier, il nous faudra donc 4097/256=16.004 soit 17 blocs. Il peut y avoir jusqu'à 64 fichiers dans le répertoire, il nous faudra donc 17 blocs*64 fichiers= 1088 blocs pour la description des fichiers.

ReX : Non 1024 blocs de 256 octets dans le superbloc.

Ainsi, pour la fonction LS, il suffira de lire les premiers caractères tous les 17 blocs ( du premier caractère au caractère '\0').

ReX : Non, tous les 16 blocs.

Question 2: Ne faudrait-il pas également stocker quelque part le nombre de fichier qu'il y a dans le répertoire afin de savoir jusqu'à quel bloc la fonction LS doit aller ?

ReX : Non, un fichier dont le nom n'est constitué que de '\0' est réputé ne pas exister.

Question 3: on a donc vu que les 1088 premiers blocs au maximum serviraient à la description du système de fichier. Il reste donc 31250-1088=30132 blocs dans le système de fichier.

ReX : Non, 32768-1024=31744 blocs.

Comment utiliser ces blocs? Ces blocs doivent-ils stocker le contenu des fichiers ?

ReX : Oui, c'et évident.

En effet, avec la fonction TYPE, nous allons créer des fichiers et ces fichiers devront être stockés quelque part. Cependant, étant donné que ce pico système de fichiers est prévu pour un microcontrôleur, je ne sais pas si c'est le contenu des fichiers qui doit être stocké dans les blocs ou autre chose (peut être l'adresse des fichiers, le fichiers se trouvant autre part). En effet, je me dis que si un fichier est très volumineux, il ne pourra pas rentrer dans le système de fichier, ce dernier étant composé d'un nombre limité de blocs, et les blocs étant eux même limité en nombre d'octets.

ReX : Je ne comprend pas ton problème. De tout façon comme dit plus haut, les 31744 blocs suivant le superbloc doivent contenir les données des fichiers.

Désolé de poser des questions peut être basique aussi tard, mais je pense qu'une fois que j'aurai ces réponses, cela ira beaucoup mieux pour la suite. Merci d'avance pour vos réponses.

ReX : Les questions sont effectivement triviales et il est effectivement inquiétant que voir que la travail n'avance pas.

Amine: merci pour vos corrections.

D'après votre commentaire "32768-1024=31744 blocs", j'en déduis qu'il faut que je modifie ma commande dd (qui est actuellement "dd if=/dev/zero of=filesystem.bin bs=256 count=31250" pour avoir le bon filesystem).

ReX : Je comprends pas d'où tu sors le 31250. D'autant plus que la commande ci-dessous est bonne.

Amine : 31250 car 31250 blocs * 256 octets = 8 Mo.

ReX : Haaaa je vois tu utilises le système métrique international où le mégaoctet vaut 10^6 octets, sauf qu'aucun informaticien n'utilisera cette norme hors sol. Quand je parle de 8 Mo c'est 8x1024x1024 octets. Tout simplement parce qu'une puce mémoire de 8 Mo c'est bien 8x1024x1024 octets.

Amine: D'accord merci pour l'information !

'''Nouvelle commande dd:'''

dd if=/dev/zero of=filesystem.bin bs=256 count=32768

=== Fonction LS version 2 ===

Dans notre structure du système de fichier, le superbloc est constitué de 1024 blocs (16 blocs * 64 fichiers), un fichier étant décrit par 16 blocs. Le nom du fichier est donc écrit au début de tous les blocs multiples de 16. Par exemple, le nom du premier fichier est dans les 16 premiers octets du premier bloc, le nom du 2ème fichier est dans les 16 premiers octets du 32ème bloc et ainsi de suite, tant que des fichiers existent. Lorsque qu'il n'y a plus de fichier, le nom du premier caractère du bloc multiple de 16 est un 0.

Voici le code:
// Fonction pour lister les noms de fichiers présents dans le système de fichiers
void LS() {
unsigned char buffer[BLOCK_SIZE];
int fileCount = 0;

for (int blockNum = 1; blockNum <= MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, BLOCK_SIZE);

// Vérifier si le bloc est vide
if (buffer[0] == 0) {
break; // Plus de fichiers à lire
}

char filename[MAX_FILENAME_LENGTH];
memcpy(filename, buffer, MAX_FILENAME_LENGTH);

// Afficher le nom du fichier
printf("%s\n", filename);
fileCount++;
}

if (fileCount == 0) {
printf("Aucun fichier trouvé.\n");
}
}

ReX : Tu supposes que si un fichier a un nom vide, les suivants auront aussi un nom vide. C'est possible mais dans ce cas la commande <code>RM</code> ca être plus compliquée à écrire.

ReX : Tu ne sembles pas comprendre que la mémoire d'un microcontrôleur est limitée. Pourquoi lire le premier bloc de description d'un fichier en entier ? Dit autrement c'est quoi l'intérêt de lire 256 octets alors que 16 suffisent ?

ReX : Pourquoi tu ne lis pas le premier fichier ? Autrement dit pourquoi décaler tout d'un bloc ?

Amine: Merci pour vos remarques. J'ai apporté les modifications à LS dans la section "Semaine 4" du wiki.

'''Réflexion par rapport aux autres fonctions:'''

J'ai créé les fonctions TYPE et CAT mais il y a malheureusement un problème pour l'instant. Vous pouvez les retrouver en pièce jointe dans l'archive du fichier programme.c.

Le problème que j'ai est que lorsque j'affiche le contenu du fichier créé avec TYPE, j'obtiens plein de caractères spéciaux. Par exemple, je créé le fichier "mon_fichier.txt" avec la fonction TYPE, et je mets en entré standard "hello". Ensuite, je veux afficher le contenu de ce fichier grâce à la fonction CAT. Cependant, ce qui s'affiche dans le terminal n'est pas ce que je veux. De la même manière, lorsque je fais la commande "cat filesystem.bin" dans le terminal, c'est la même chose s'affiche, des donnés parasites.

ReX : Avant même de lire ton code je vais te poser la question de savoir comment tu récupères un bloc libre ? Quel algorithme tu utilises. Personnellement je ne sais pas faire sans ajouter au superbloc un tableau bit à bit des blocs libres. Pour avoir un bit pour chaque bloc du système de fichiers, il faut 32768/8=4096 octets soit 16 blocs.

Amine: ok je vais donc ajouter ce tableau de 16 blocs à la suite de mes premiers 1024 blocs servant à la description de fichier. Le superbloc fera maintenant 1024+16=1040 blocs (plus de détail à la fonction RM de la semaine 4).

Question 1: est ce que la fonction CAT que je dois créer doit renvoyer la même chose que "cat filesystem.bin" ?

ReX : Je préfère ne pas répondre tellement la question montre un manque de réflexion.

Question 2: comment savoir combien de blocs doivent etre attribué à un fichier? Par exemple, si je créé un fichier "mon_fichier.txt" et que je mets en entrée standard le texte "hello", un seul bloc suffi pour stocker ce texte. Cependant, si j'avais mis beaucoup de texte en entrée standard, il aurait fallu plus de blocs. Doit-on calculer la taille de l'entrée standard ou doit-on attribuer toujours le meme nombre de blocs à un fichier? Peut-etre ainsi attribuer 2040 blocs par fichier, meme s'il n'en utilise que 1.

ReX : Là encore c'est une question stupéfiante tellement la réponse est évidente. Il suffit de lire les données sur l'entrée standard et de passer au bloc de données suivant dès que le bloc courant est rempli. La question à poser c'était de se demander comment il est possible d'avoir la taille exacte du fichier pour un <code>CAT</code>. Il est uniquement possible de l'avoir à 256 octets près puisque rien n'indique si le dernier block est vide. Le mieux aurait été de prévoir 4 octets dans la description d'un fichier pour stocker la taille. En l'espèce on considérera que les fichiers sont des fichiers ASCII et qu'ils seront terminés par des <code>\'0</code> qui ne seront pas affichés.

== Semaine 4 ==

Voici un bilan de ce que j'ai fait à ce stade du projet:

* j'ai choisi une structure du système de fichier
* j'ai créé les fonctions readBlock et writeBlock permettant de lire et d'écrire des blocs
* j'ai crée la fonction LS permettant d'afficher le nom des fichiers présents dans le système de fichiers
* j'ai programmer un main permettant d'utiliser les fonctions (LS, TYPE...) depuis le terminal
* j'ai réflechi aux fonctions TYPE et CAT.

Actuellement, je suis en train de créer les fonctions TYPE et CAT.

=== Fonction LS version 3 ===
void LS() {
unsigned char buffer[MAX_FILENAME_LENGTH];
int fileCount = 0;

// Parcourir tous les 16 blocs de 0 jusqu'à MAX_FILES_IN_DIRECTORY
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, MAX_FILENAME_LENGTH);

// Vérifier si le nom de fichier est vide
if (buffer[0] != 0) {

// Afficher le nom du fichier
printf("%s\n", buffer);
fileCount++;
}
}

if (fileCount == 0) {
printf("Aucun fichier trouvé.\n");
}
}
Suite à vos remarques, j'ai effectué les modifications suivantes de la fonction LS:

* Je ne suppose plus que si un fichier a un nom vide, les autres auront aussi un nom vide.
* Je ne lis plus les 256 octets mais seulement les 16 premiers octets car cela suffit.
* Je ne lisais en effet pas le premier bloc. Je pensais que le premier bloc était d'indice 1 mais ce n'est pas le cas.

ReX : Ouiiii ! Une fonction correcte. Passe à <code>RM</code> maintenant, c'est la plus facile à faire concernant l'image bit à bit des blocs libres.

=== Fonction setBlockAvailability version 1 ===

Comme vous l'avez indiqué dans votre remarque, il faut un tableau dans le superbloc qui nous permettra de connaitre la disponibilité bit par bit de chaque bloc. Sachant qu'il y a dans notre système de fichiers 32768 blocs, et qu'il faut 1 bit par bloc, nous avons besoin de 32768 bits, soit 32768/8=4096 octets soit 4096/256=16 blocs. Notre superbloc sera donc comme suit: les 1024 premiers blocs servent à la description des fichiers, c'est à dire à leur nom suivi des numéros de blocs qui leur sont associés, puis ces 1024 blocs sont suivi de 16 blocs listant la disponibilité de chaque bloc.

ReX : Bien résumé.

Nous allons tout d'abord écrire la fonction "setBlockAvailability" prenant en paramètre le numéro du bloc à traiter (<code>blockNum</code>) et la disponibilité souhaitée pour ce bloc (<code>availability</code>). Cette fonction permet de marquer la disponibilité d'un bloc spécifique dans le système de fichiers. Nous utiliserons la convention suivante: un bloc disponible sera marqué par un 1 tandis qu'un bloc non disponible par un 0.
#define SUPERBLOCK_START_BLOCK 1024

void setBlockAvailability(int blockNum, int availability) {
// Calculer l'index du byte et le bit offset correspondant
int byteIndex = blockNum / 8;
int bitOffset = blockNum % 8;

// Lire le byte existant du bloc de disponibilité des blocs
unsigned char buffer[1];
readBlock(SUPERBLOCK_START_BLOCK + byteIndex, 0, buffer, 1);

// Mettre à jour le bit d'offset correspondant
if (availability) {
buffer[0] |= (1 << bitOffset);
} else {
buffer[0] &= ~(1 << bitOffset);
}

// Écrire le byte mis à jour dans le bloc de disponibilité des blocs
writeBlock(SUPERBLOCK_START_BLOCK + byteIndex, 0, buffer, 1);
}

ReX : Un tableau de un octet c'est un octet (variable <code>buffer</code>).

Amine: je vais utiliser un <code>unsigned char buffer.</code> Je suis conscient qu'un char vaut un octet mais je ne pense pas qu'il y ait un type de donnée de la taille d'un bit, c'est pourquoi je travaille avec un octet mais je modifie les bits de cet octet grâce aux algorithmes.

ReX : Il faut bien que tu travailles sur un octet vu que l'état des blocs est stocké sous la forme d'octets. Je disais juste qu'un tableau de 1 élément n'a pas d'intérêt par rapport à l'élément lui-même.

Amine: c'est vrai, modification faite.

ReX : Non il faut calculer le numéro du bloc avant de faire le <code>readBlock</code>.

Amine: ok je vais calculer le numéro de bloc avant.

ReX : La mise à jour du bit est correcte mais le block et le déplacement dans le block ne sont pas correctement calculés.

Amine: je vais vous expliquer le raisonnement que j'avais. Prenons un exemple concret, imaginons que je veuille marquer le bloc 1030 comme disponible:

# Calcul de l'index de l'octet et du bit offset :
#* <code>blockNum</code> = 1030
#* Index du byte = 1030 / 8 = 128
#* Bit offset = 1030 % 8 = 6
# Lecture de l'octet existant de disponibilité:
#* Nous lisons l'octet existant à l'index 128 dans les blocs de disponibilité.
# Mise à jour du bit de disponibilité :
#* Nous voulons marquer le bloc 1030 comme disponible, donc nous utilisons le masque <code>(1 << 6)</code> pour définir le bit 6 à 1 dans l'octet. Le résultat sera, par exemple, <code>00100000</code>.
# Écriture du byte mis à jour :
#* Nous écrivons le byte mis à jour <code>00100000</code> à l'index 128 dans les blocs de disponibilité.

ReX : Ben non, un vrai exemple :
* Il faut prendre un n° de bloc plus grand : 3072 ;
* Numéro d'octet dans la carte des blocs libres : 3072/8=384 ;
* Numéro du bloc dans la carte des blocs libres : 384/256=1 ;
* Numéro du bit <code>b</code> dans l'octet n° 384-256=128 du bloc 1 : 3072%8=0 ;
* Il faut donc lire l'octet <code>o</code> de numéro 128 du bloc 1, puis modifier cet octet par <code>o |= (1<<b)</code> ou <code>o &= ~(1<<b)</code> ;
* Enfin il faut écrire l'octet modifié dans le bloc 1.
Amine: merci pour cet exemple! J'ai compris d'où vient mon erreur. Voir fonction setBlockAvailability version 3.

Remarque: par convention, j'apellerai dans la suite de ce projet "premier superbloc" le superbloc correspondant à la description des fichiers, c'est à dire les 1024 premiers blocs, et j'appellerai "second superbloc" les 16 blocs qui suivent servant à décrire la disponibilité des blocs (du bloc 1024 au bloc 1039 inclu). Le reste des blocs servira à stocker les données.

ReX : Non, le superblc est l'ensemble des informations hors blocs de données, tu ne peux pas utiliser un vocabulaire au hasard. Parle de blocs de description des fichiers ou de carte des blocs libres.

Amine: ok

Je pense que le problème qui se pose est que l'indice du bit dans le second superbloc ne correspond pas à l'indice du bloc dans le système de fichier. Par exemple, nous voudrions que si le bloc 1030 est disponible dans le système de fichier, alors le bit numéro 1030 du deuxième superbloc soit à 1, ce qui n'est pas le cas ici. En effet, on se trouve bien dans le bon octet avec ma méthode mais l'écriture du bit se fait de la droite vers la gauche alors qu'on voudrait l'inverse. Ainsi, si le 6ème bit de l'octet doit être à 1, alors il faudrait qu'on obtienne <code>00000100</code> et non <code>00100000.</code> L'indice du bit coinciderait ainsi avec le numéro du bloc.

ReX : Non, réfléchit à nouveau.

Voir plus bas la nouvelle version de setBlockAvailability.

Explication de l'algorithme pour mettre le bit à 1 ou 0:

* <code>buffer[0] |= (1 << bitOffset);</code> : Cette ligne utilise l'opérateur OR bit à bit (<code>|=</code>) pour activer (mettre à 1) le bit spécifié par <code>bitOffset</code> dans le premier octet (<code>buffer[0]</code>). Cela se fait en décalant le bit 1 vers la gauche de <code>bitOffset</code> positions, puis en effectuant une opération OR bit à bit avec le contenu actuel de <code>buffer[0]</code>. Cette opération modifie uniquement le bit ciblé, laissant les autres bits inchangés.

ReX : Oui ça c'est bon.

* <code>buffer[0] &= ~(1 << bitOffset);</code> : Cette ligne utilise l'opérateur AND bit à bit (<code>&=</code>) pour désactiver (mettre à 0) le bit spécifié par <code>bitOffset</code> dans <code>buffer[0]</code>. Pour ce faire, l'expression <code>~(1 << bitOffset)</code> est utilisée pour créer un masque où tous les bits sont à 1, sauf celui correspondant à <code>bitOffset</code>, qui est à 0. En effectuant ensuite une opération AND bit à bit entre le masque et le contenu actuel de <code>buffer[0]</code>, on met à 0 le bit ciblé sans affecter les autres bits.

ReX : Ca aussi.

=== Fonction setBlockAvailability version 2 ===

void setBlockAvailability(int blockNum, int availability) {
// Calculer l'indice de l'octet et le bit offset correspondant
int byteIndex = blockNum / 8;
int bitOffset = 7 - (blockNum % 8); // Inversion de l'ordre des bits

// Calculer le numéro du bloc du super bloc où se trouve l'octet de disponibilité correspondant
int availabilityBlockNum = SUPERBLOCK_START_BLOCK + byteIndex;

// Lire l'octet existant dans le bloc de disponibilité du super bloc
unsigned char buffer;
readBlock(availabilityBlockNum, 0, &buffer, 1);

// Mettre à jour le bit d'offset correspondant :
if (availability) {
buffer |= (1 << bitOffset);
} else {
buffer &= ~(1 << bitOffset);
}

// Écrire l'octet mis à jour dans le bloc de disponibilité du super bloc
writeBlock(availabilityBlockNum, 0, &buffer, 1);
}
J'ai modifié la ligne <code>int bitOffset = 7 - (blockNum % 8);</code> pour inverser l'ordre des bits sélectionnés, de sorte que le bit correspondant au bloc disponible soit correct.

ReX : Encore plus faux.

Si on veut rendre le bloc 1030 indisponible alors que les autres blocs sont disponibles:

ReX : Pardon ? Le bloc de données est libre ou pas suivant la carte des blocs libres. Le rendre disponible n'est possible que si un fichier le comportant est détruit.

# Calcul de l'indice de l'octet et du bit offset correspondant :
#* <code>blockNum = 1030</code>
#* <code>byteIndex = 1030 / 8 = 128</code>
#* <code>bitOffset = 7 - 1030 % 8 = 1</code> Cela signifie que le bit d'intérêt se trouve à la position 2 dans l'octet.
# Calcul du numéro du bloc du super bloc où se trouve l'octet de disponibilité correspondant :
#* <code>availabilityBlockNum = SUPERBLOCK_START_BLOCK + 128 = 1024 + 128 = 1152</code> Donc, nous devons accéder à l'octet 1152 pour mettre à jour la disponibilité du bloc 1030.
# Lecture de l'octet existant dans le bloc de disponibilité du super bloc :
#* Le contenu de l'octet dans le bloc 1152 avant la mise à jour : 11111111 (en binaire)
# Mise à jour du bit d'offset correspondant :
#* Supposons que nous voulions marquer le bloc 1030 comme non disponible (<code>availability = 0</code>).
#* Le bitOffset est 1.
#* Nous effectuons une opération AND avec le complément du bit à la position 1 : <code>11111111 & 11111101 = 11111101</code>
# Écriture de l'octet mis à jour dans le bloc de disponibilité du super bloc :
#* Le contenu de l'octet 128 du second superbloc après la mise à jour : 11111101 (en binaire)

ReX : Toujours aussi faux.

Maintenant, le bit d'indice 1 du 128 ème octet du second superbloc est mis à 0, indiquant que le bloc 1030 n'est plus disponible. Les autres bits restent inchangés car nous avons effectué un AND avec un masque binaire qui avait des 1 partout sauf à la position du bit que nous souhaitions mettre à 0.

ReX : Erreur sur erreur.

=== Fonction setBlockAvailability version 3 ===
J'ai compris d'où vient l'erreur. La fonction readBlock prends en premier paramètre le numéro du bloc à lire, je ne peux donc pas lui donner la valeur "SUPERBLOCK_START_BLOCK + byteIndex" car byteIndex s'exprime en octet alors qu'on s'attend à un nombre de bloc ici. Il faut donc divisé byteIndex par 256 pour être en unité "bloc", et préciser le bit qu'on veut lire grâce à l'offset.

Pour obtenir l'octet que l'on veut, il faut prendre le reste de la division de byteIndex par 256. On va ensuite stocker cet octet dans notre "buffer".

Pour savoir quel bit modifier dans ce "buffer", on va prendre le reste de la division du bloc dont on veut mettre à jour la disponibilité par 8. On va ainsi pouvoir modifier ce bit grâce à l'algorithme, puis réécrire l'octet à son emplacement d'origine.

Cette fonction gère la carte de disponibilités des blocs. Si un bloc est disponible, alors elle le met un 0, si il est indisponible, elle met un 1.
#define SUPERBLOCK_START_BLOCK 1024

void setBlockAvailability(int blockNum, int availability) {

int byteIndexInCard = blockNum / 8; //Numéro d'octet dans la carte des blocs libres
int blockIndexInCard = byteIndexInCard / 256; //Numéro du bloc dans la carte des blocs libres
int byteIndexInBlock = byteIndexInCard % 256; //Numéro d'octet dans le bloc contenant le bit de disponibilité
int bitOffset = blockNum % 8; //Numéro du bit dans l'octet n°byteIndexInBlock du bloc blockIndexInCard

//indice du bloc contenant le bit à mettre à jour dans le bloc de description
int availabilityBlockNum = FIRST_DISPONIBILITY_CARD_BLOCK + blockIndexInCard;

// Lire l'octet existant dans le bloc de disponibilité du super bloc
unsigned char buffer;
readBlock(availabilityBlockNum, byteIndexInBlock, &buffer, 1);

// Mettre à jour le bit d'offset correspondant :
if (availability==1) { // indisponible
buffer |= (1 << bitOffset); // Mettre le bit à 1

} else { // disponible
buffer &= ~(1 << bitOffset); // Mettre le bit à 0
}

// Écrire l'octet mis à jour dans le bloc de disponibilité du super bloc
writeBlock(availabilityBlockNum, byteIndexInBlock, &buffer, 1);
}

ReX : Ben voila, c'est pas possible de te taxer d'excès de vitesse mais c'est bon.

update: j'ai fait une petite modification, maintenant un bloc disponible est marqué d'un 0 et un bloc indisponible est marqué d'un 1. C'est mieux dans la mesure où initialement, tous les blocs sont disponibles et tous les blocs sont à 0. Cela évite de devoir créer une fonction qui initialise toute la carte de disponibilités à 1 pour dire que tous les blocs sont disponibles.

=== Fonction RM version 1 ===

void RM(const char *filesystem_path, const char *filename) {
unsigned char buffer[BLOCK_SIZE];
int fileNum = -1;

// Parcourir les blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (memcmp(filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {
// Effacer le nom du fichier dans le superbloc
memset(filenameBuffer, 0, MAX_FILENAME_LENGTH);
writeBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

unsigned char fileBuffer[MAX_BLOCKS_PER_FILE * 2];
readBlock(blockNum, MAX_FILENAME_LENGTH, fileBuffer, MAX_BLOCKS_PER_FILE * 2);

// Libérer les blocs associés au fichier et réinitialiser les numéros de blocs
for (int i = 0; i < MAX_BLOCKS_PER_FILE * 2; i += 2) {
int blockNum = ((int)fileBuffer[i] << 8) + (int)fileBuffer[i + 1];
if (blockNum == 0) {
break; // Fin du fichier
}
setBlockAvailability(blockNum, 0); // Marquer le bloc comme disponible
fileBuffer[i] = 0;
fileBuffer[i + 1] = 0;
}

// Mettre à jour les numéros de blocs associés au fichier
writeBlock(blockNum, MAX_FILENAME_LENGTH, fileBuffer, MAX_BLOCKS_PER_FILE * 2);

fileNum = blockNum;
break; // Fichier trouvé, sortir de la boucle
}
}

// Afficher le résultat de l'opération
if (fileNum == -1) {
printf("Le fichier \"%s\" n'a pas été trouvé.\n", filename);
} else {
printf("Le fichier \"%s\" a été supprimé avec succès.\n", filename);
}
}

ReX : Vous utilisez <code>strcmp</code> comme <code>strncmp</code>. C'est bien la dernière qu'il faut utiliser mais en précisant la longueur du nom en paramètre, pas la taille maximale.

Amine: vous voulez dire que j'utilise memcmp au lieu de strncmp ? Ok je vais utiliser strncmp, c'est vrai que c'est plus adapté pour la comparaison de chaines de caractère.

ReX : Ha oui c'est <code>memcmp</code> que tu utilises. Ca ne peut effectivement pas marcher. Effectivement avec <code>strncmp</code> cela peut marcher vu qu'il s'arrête au premier 0 contrairement à <code>memcmp</code>.

Cependant, pourquoi doit-on passer la taille exacte du nom du fichier en paramètre, et non la taille maximale d'un nom de fichier? En effet, cela semble fonctionner en mettant la taille maximale en paramètre, tandis que lorsque l'on met la taille exacte du nom du fichier, cela pose un problème: on ne compare plus toute la chaîne de caractère mais seulement une portion du nom complet. Ainsi, si je crée par exemple un fichier que j'appelle "file1", puis que j’exécute la fonction RM "/picofs filesystem.bin RM file" par exemple, alors le fichier file1 va être supprimé quand même car on ne comparera que strlen(file)=4 premiers caractères, qui sont les mêmes, donc la fonction considérera ces chaines comme identiques. On pourrait alors se dire qu'il faudrait alors prendre plutôt comme taille en paramètre de la fonction strlen la taille du nom du fichier se trouvant dans le système de fichier plutôt que celle du nom donné en paramètre de RM. Cependant, le même problème se pose si la taille du nom du fichier du système de fichier est plus petite que celle du nom du fichier passé en paramètre. Par exemple, si le fichier présent dans système de fichier est "file", et qu'on met la longueur de file en paramètre de la fonction strcmp, puis qu'on exécute la commande "/picofs filesystem.bin RM file5", alors file sera quand même supprimé, car on ne comparera que les strlen(file)=4 premiers caractère. Finalement, une solution serait de rajouter une condition qui vérifie que les deux chaînes sont de taille identiques pour pouvoir réaliser la comparaison sur la taille exacte du nom du fichier. Cependant, il me semble qu'en mettant MAX_FILENAME_LENGTH qui vaut 16 en paramètre, cela fonctionne directement. Vous pouvez tester cela en testant mon programme.

ReX : Ok pour <code>strncmp</code> avec la taille maximale d'un nom de fichier.

etape 1: créer un fichier :
./picofs filesystem.bin TYPE fichier.txt

etape 2: verifier que le fichier a bien été créé :
./picofs filesystem.bin LS

Le terminal renvoie bien "fichier.txt"

etape 3: essayer de supprimer le fichier en mettant une chaine troncature du nom du fichier créé :
./picofs filesystem.bin RM fich

le terminal renvoi <<Le fichier "fich" n'a pas été trouvé.>>, le fichier n'a donc pas été supprimé .

etape 4: essayer de supprimer le fichier en mettant un nom plus grand incluant "fichier.txt" :
./picofs filesystem.bin RM fichier.txtt

terminal renvoi <<Le fichier "fichier.txtt" n'a pas été trouvé.>>

etape 5: enfin, tester en mettant le nom exacte du fichier que l'on veut supprimer :
./picofs filesystem.bin RM fichier.txt

terminal renvoi <<Le fichier "fichier.txt" a été supprimé avec succès.>>

Finalement, on voit que cela fonctionne avec la taille maximale mise en paramètre. On pourrait reprocher à cette méthode de comparer des caractères dans le vide, ce qui n'est pas optimal dans une optique d'économie de mémoire qui est la notre, mais la taille maximale d'un nom de fichier étant relativement faible (16 octets), on peut peut-être négliger cela au vu de l'économie d'une opération supplémentaire (comparaison de la taille des chaines de caractères).

ReX : Le parcours des blocs de données du fichier est atroce. Il faut parcourir les numéros de blocs dans le premier bloc du fichier derrière le nom du fichier puis il faut parcourir le 15 autres blocs.

Amine: Ok, je vais corriger cela dans la version 2 de RM (voir semaine 5).

Fonctionnement de la fonction RM:

* Parcours des blocs réservés pour la description des fichiers (superbloc) à partir du bloc 0, en incrémentant de 16 à chaque itération pour accéder aux blocs de noms de fichiers.

ReX : OK.

* Dans chaque bloc de noms de fichiers, la fonction compare le nom de fichier recherché avec les noms stockés dans les 16 octets de chaque bloc.

ReX : Non la fonction ne fait pas ça par contre il faudrait, oui.

Amine: Je pensais que c'était ce que je faisais avec "memcmp(filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0)".

* Si le nom de fichier est trouvé, la fonction efface le nom du fichier dans le superbloc en remplaçant les 16 octets du bloc par des zéros.

ReX : OK.

* Ensuite, la fonction accède aux octets suivants du même bloc pour obtenir les numéros de blocs associés au fichier.

ReX : Non, la boucle sort largement du premier bloc.

* Pour chaque paire de numéros de blocs (2 octets chacun), la fonction convertit les octets en un numéro de bloc. Si le numéro de bloc est nul, cela signifie la fin des blocs associés au fichier, sinon, la fonction marque ce bloc comme disponible en utilisant la fonction <code>setBlockAvailability</code> et réinitialise les numéros de blocs dans le tableau à zéro.
* Les numéros de blocs réinitialisés sont ensuite réécrits dans le bloc de description du fichier.

ReX : L'idée est là mais vu que la boucle n'est pas bonne, rien ne peut marcher.

* La fonction affiche ensuite un message indiquant le résultat de l'opération : soit que le fichier a été supprimé avec succès, soit que le fichier n'a pas été trouvé.

== Semaine 5 ==

=== Fonction RM version 2 ===

Concernant les remarques que vous m'avez faites précédemment:

* j'utilise maintenant la fonction <code>strncmp</code> pour la comparaison des chaines de caractères
* j'ai normalement corrigé le parcours des blocs. Je parcours maintenant d'abord les blocs multiples de 16 à la recherche du bloc contenant le nom du fichier à supprimer. Puis je parcours les 16 blocs de description du fichier à supprimer, afin de récupérer les numéros de blocs, libérer ces blocs dans la carte de disponibilité et de réinitialiser ces blocs dans les blocs de données.

void RM(const char *filesystem_path, const char *filename) {
int fileFound = -1;
int offset;

// Parcourir les blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char*)filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {

// Effacer le nom du fichier dans le superbloc
memset(filenameBuffer, 0, MAX_FILENAME_LENGTH);
writeBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);
fileFound = 1;
offset = blockNum;
break;
}

}

// Fin de fonction si fichier inexistant
if (fileFound == -1) {
printf("Le fichier \"%s\" n'a pas été trouvé.\n", filename);
return;
}

unsigned char buffer[BLOCK_SIZE];
//bloc que l'on va remplir de 0 et mettre à la place des blocs de données
memset(buffer, 0, BLOCK_SIZE); //on rempli buffer de 0

for (int blockNum=offset; blockNum<offset + 16; blockNum++) {

//premier bloc de description, celui contenant le nom du fichier dans les 16 premiers octets
if (blockNum == offset) {

unsigned char fileBuffer[BLOCK_SIZE-MAX_FILENAME_LENGTH];
//bloc dans lequel on va stocker les blocs de description de fichier
readBlock(blockNum, MAX_FILENAME_LENGTH, fileBuffer, BLOCK_SIZE-MAX_FILENAME_LENGTH);

// Libérer les blocs associés au fichier dans la carte de disponibilités
// et dans les blocs de description
for (int i = MAX_FILENAME_LENGTH; i < BLOCK_SIZE-MAX_FILENAME_LENGTH; i += 2) {
int blockNumData = ((int)fileBuffer[i] << 8) + (int)fileBuffer[i + 1];
if (blockNumData == 0) {
break; // Fin du fichier
}
setBlockAvailability(blockNumData, 0); // Marquer le bloc comme disponible
fileBuffer[i] = 0;
fileBuffer[i + 1] = 0;
writeBlock(blockNumData, 0, buffer, BLOCK_SIZE); //on efface les blocs de données
}
writeBlock(blockNum, MAX_FILENAME_LENGTH, fileBuffer, BLOCK_SIZE-MAX_FILENAME_LENGTH);
//on efface le premier bloc de description

} else {
unsigned char fileBuffer[BLOCK_SIZE];
readBlock(blockNum, 0, fileBuffer, BLOCK_SIZE);

// Libérer les blocs associés au fichier dans la carte de disponibilités et dans les blocs de description
for (int i = 0; i < BLOCK_SIZE; i += 2) {
int blockNumData = ((int)fileBuffer[i] << 8) + (int)fileBuffer[i + 1];
if (blockNumData == 0) {
break; // Fin du fichier
}
setBlockAvailability(blockNumData, 0); // Marquer le bloc comme disponible
fileBuffer[i] = 0;
fileBuffer[i + 1] = 0;
writeBlock(blockNumData, 0, buffer, BLOCK_SIZE); //on efface les blocs de données
}
writeBlock(blockNum, 0, fileBuffer, BLOCK_SIZE); //on efface le bloc de description
}
}
printf("Le fichier \"%s\" a été supprimé avec succès.\n", filename);
}

ReX : Pour construire le nombre sur 16 bits utiliser le OU plutôt que l'addition.

ReX : Heu non, je ne lis pas cette fonction avec tout ce code dupliqué, la seule différence entre les deux alternative est la position de début de l'adresse du premier bloc de données (<code>MAX_FILENAME_LENGTH</code> dans un cas et 0 dans l'autre). Donc l'alternative ne doit servir qu'à initialiser ce début, le reste du code doit être factorisé.

ReX : Et corrige le code, tu utilises deux tableaux de blocs (perte mémoire), tu écris le bloc à zéro dans l'itération (perte CPU).

=== Fonction RM version 3 ===

Suite à vos remarques, j'ai réalisé les modifications suivantes:

* j'utilise maintenant le OU plutôt que l'addition pour construire le nombre sur 16 bits.

* j'ai factorisé le code grâce à la création de la variable <code>startOffset</code> valant 16 lorsqu'on se trouve dans le bloc contenant le nom du fichier et valant 0 lorsqu'on se trouve dans les autres.

* Pour ce qui est du fait que j'utilise 2 tableaux de blocs, j'ai du mal à voir comment faire avec 1 seul tableau de blocs car ces deux tableaux n'ont pas du tout le même rôle. Le tableau <code>fileBuffer</code> permet de stocker les 16 blocs de description d'un fichier un à un. Lorsqu'on stocke un bloc dans <code>fileBuffer</code>, on lit ensuite les octets un à un de ce bloc afin de former des numéros de blocs, et pour chaque numéro de bloc créé, on va réinitialiser le bloc correspondant dans les blocs de données. Pour cela, on a donc besoin d'un autre bloc qui viendra écraser les anciens blocs de données. C'est pourquoi j'ai créé un bloc <code>buffer</code>qui est composé de 0 et qui va écraser les blocs de données. On ne peut pas utiliser <code>fileBuffer</code> car on a besoin d'un bloc de zéros, et si on réinitialise <code>fileBuffer</code> on perd toute les données qui s'y trouvent. Une possibilité serait de relire le bloc de donné à chaque itération de la deuxième boucle for imbriquée; cela permettrait de pouvoir réinitialiser le tableau fileBuffer à chaque itérations de cette boucle afin de stocker ce bloc de 0 dans les blocs de données, puis de restocker dans ce même tableau le bloc de description. Cependant, je ne pense pas que ce soit optimal de faire autant appel à la fonction readBlock.

* j'ai créé une fonction resetBock qui permet comme son nom l'indique de reset un bloc en le remplissant de 0. Cela nous évite de créer deux tableaux de blocs dans RM, bien que je pense que cela revienne au même car on fait appel à une fonction qui créé un tableau de blocs. Quoi qu'il en soit, cela allège le code et cette fonction pourra surement me resservir par la suite.

void RM(const char *filesystem_path, const char *filename) {
int fileFound = -1;
int offset;
unsigned char fileBuffer[BLOCK_SIZE];

// Parcourir les blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char *)filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {
// Effacer le nom du fichier dans le superbloc
memset(filenameBuffer, 0, MAX_FILENAME_LENGTH);
writeBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);
fileFound = 1;
offset = blockNum;
break;
}
}

// Fin de fonction si fichier inexistant
if (fileFound == -1) {
printf("Le fichier \"%s\" n'a pas été trouvé.\n", filename);
return;
}

for (int blockNum = offset; blockNum < offset + 16; blockNum++) {
int startOffset = 0;
if (blockNum == offset) {
startOffset = MAX_FILENAME_LENGTH;
}
readBlock(blockNum, startOffset, fileBuffer, BLOCK_SIZE - startOffset);

// Libérer les blocs associés au fichier dans la carte de disponibilités et dans les blocs de description
for (int i = 0; i < BLOCK_SIZE - startOffset; i += 2) {
int blockNumData = (fileBuffer[i] << 8) | fileBuffer[i + 1];
if (blockNumData == 0) {
break; // Fin du fichier
}
setBlockAvailability(blockNumData, 0); // Marquer le bloc comme disponible
fileBuffer[i] = 0;
fileBuffer[i + 1] = 0;
resetBlock(blockNumData); //on efface les blocs de données
}
writeBlock(blockNum, startOffset, fileBuffer, BLOCK_SIZE - startOffset);
}
printf("Le fichier \"%s\" a été supprimé avec succès.\n", filename);
}
'''Fonction resetBlock'''
void resetBlock(unsigned int blockNum) {
unsigned char buffer[BLOCK_SIZE];
memset(buffer, 0, BLOCK_SIZE);

// Utiliser writeBlock pour écrire les données du buffer dans le bloc
writeBlock(blockNum, 0, buffer, BLOCK_SIZE);
}

ReX : Ca s'améliore. Mais pourquoi cette fonction <code>resetBlock</code> ? Tu crois que dans qu'un système de fichiers perd du temps à mettre à zéro les blocs de données libérés ? Si oui, regarde la page de manual de la commande <code>shred</code>, ça manque à ta culture.

Amine: Après avoir consulter le manual de la commande <code>shred</code>, je vois que cette commande écrit des données aléatoires sur l'emplacement du fichier sur le disque. Par défaut, <code>shred</code> effectue un certain nombre de passes (par exemple, 3 passes) pendant lesquelles il écrit des données aléatoires sur l'emplacement du fichier sur le disque. Après avoir écrit les données aléatoires, <code>shred</code> peut effectuer des passes supplémentaires pendant lesquelles il écrit des données nulles (des zéros) sur le même emplacement. L'objectif de <code>shred</code> est d'augmenter la sécurité en rendant plus difficile la récupération des données supprimées à l'aide d'outils de récupération de données.

Cependant, j'ai aussi consulté comment fonctionne la commande <code>rm</code> de linux, et je vois que cette commande libère l'espace occupé par le fichier en marquant les blocs associés comme disponibles. Cela signifie que les données peuvent encore être récupérées à l'aide d'outils de récupération de données, à moins que des mesures supplémentaires ne soient prises pour écraser physiquement l'espace avec des données aléatoires (c'est ce que fait l'utilitaire <code>shred</code>).

On va donc opter pour la deuxième option, c'est à dire qu'on ne va pas perdre notre temps à remettre à zéro les blocs de données libérés, on va simplement marquer les blocs correspondants comme étant disponibles. Cela nous permettra de nous émanciper de la fonction resetBlock et de n'avoir plus qu'un seul tableau de blocs.

ReX : Sinon lire un bloc complet de pointeurs de blocs de données en mémoire n'est pas forcément optimal. L'idéal serait de lire ces blocs morceau par morceau (de 64 octets par exemple). Certes un bloc serait traité en 4 lectures/écritures (ce qui ralentirait le traitement) mais on gagne en mémoire. Le mieux serait de mettre la taille des morceaux en constante pour pouvoir choisir entre vitesse d'exécution et utilisation mémoire.

Amine: d'accord je comprends. Je vais modifier la fonction pour qu'on puisse découper la lecture/écriture en plusieurs blocs.

=== Fonction RM version 4 ===
Modifications apportées:

* je ne réinitialise plus les blocs de données, je supprime simplement le pointeur du fichier vers les blocs de données et je désigne les blocs comme "disponible" dans le carte de disponibilités. J'ai donc supprimé la fonction resetBlock.

* je ne lis plus les blocs en une seule fois mais en plusieurs fois via la variable CHUNK_SIZE:

# J'ai introduit la constante <code>CHUNK_SIZE</code> pour définir la taille de chaque morceau que nous allons lire/écrire à la fois. Cela permet de découper les opérations en blocs plus petits.
# Dans la boucle <code>for</code> où on parcours les blocs à partir de <code>offset</code>, j'ai ajouté une boucle interne qui parcourt les données du bloc en morceaux de taille <code>CHUNK_SIZE</code>.
# À l'intérieur de la boucle interne, j'ai calculé la taille réelle du morceau (<code>chunkSize</code>) en prenant le minimum entre <code>CHUNK_SIZE</code> et la quantité de données restant à lire/écrire dans le bloc.
# J'ai modifié la fonction <code>readBlock</code> pour lire seulement la quantité de données spécifiée par <code>chunkSize</code> à partir de <code>chunkStart</code>. Ces données sont stockées dans le tableau <code>fileBuffer</code>.
# Ensuite, j'ai effectué les mêmes opérations de libération des blocs associés au fichier, en parcourant les données du morceau et en marquant les blocs comme disponibles.
# Finalement, j'ai utilisé la fonction <code>writeBlock</code> pour écrire le morceau de données modifié dans le bloc, en utilisant la même <code>chunkStart</code> pour déterminer où écrire les données.

#define CHUNK_SIZE 64

int min(int a, int b) {
return a < b ? a : b;
}

void RM(const char *filesystem_path, const char *filename) {
int fileFound = -1;
int offset;
unsigned char fileBuffer[BLOCK_SIZE];

// Parcourir les blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char *)filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {
// Effacer le nom du fichier dans le superbloc
memset(filenameBuffer, 0, MAX_FILENAME_LENGTH);
writeBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);
fileFound = 1;
offset = blockNum;
break;
}
}

// Fin de fonction si fichier inexistant
if (fileFound == -1) {
printf("Le fichier \"%s\" n'a pas été trouvé.\n", filename);
return;
}

for (int blockNum = offset; blockNum < offset + 16; blockNum++) {
int startOffset = 0;

if (blockNum == offset) {
startOffset = MAX_FILENAME_LENGTH;
}

for (int chunkStart = startOffset; chunkStart < BLOCK_SIZE; chunkStart += CHUNK_SIZE) {
int chunkSize = min(CHUNK_SIZE, BLOCK_SIZE - chunkStart);
readBlock(blockNum, chunkStart, fileBuffer, chunkSize);

for (int i = 0; i < chunkSize; i += 2) {
int blockNumData = (fileBuffer[i] << 8) | fileBuffer[i + 1];
if (blockNumData == 0) {
writeBlock(blockNum, chunkStart, fileBuffer, chunkSize);
printf("Le fichier \"%s\" a été supprimé avec succès.\n", filename);
return; // Sortir des boucles
}
setBlockAvailability(blockNumData, 0); // Marquer le bloc comme disponible
fileBuffer[i] = 0;
fileBuffer[i + 1] = 0;
}

writeBlock(blockNum, chunkStart, fileBuffer, chunkSize);
}
}

printf("Le fichier \"%s\" a été supprimé avec succès.\n", filename);
}

ReX : Si on trouve un n° de bloc de données à 0, il faut sortir des deux boucles les plus externes après avoir fait le <code>writeBlock</code>.

Amine: Modification faites ci-dessus. Maintenant, dès qu'on trouve un n° de bloc de données à 0 dans la boucle la plus interne, on effectue le <code>writeBlock</code> et ensuite on utilise <code>return</code> pour sortir des deux boucles les plus externes. Cela permet d'optimiser le code en évitant de continuer à traiter inutilement le reste des blocs.

ReX : Pas très propre (duplication de code) mais nous allons nous en contenter.

=== Fonction intermédiaire TYPE version 1 ===

J'ai également commencé à réfléchir à la fonction TYPE. Pour l'instant, elle ne fait qu'ajouter les noms de fichier dans le superbloc. Cela permet de pouvoir tester les fonctions LS et RM (voir dans la rubrique compilation et exécution comment utiliser le programme).
// Fonction pour créer un fichier avec le nom donné et le contenu fourni en entrée standard
void TYPE(const char *filesystem_path, const char *filename) {
unsigned char buffer[MAX_FILENAME_LENGTH];
// Parcours des blocs réservés pour la description des fichiers
for (int blockNum = 0; blockNum <= MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, MAX_FILENAME_LENGTH);
// Vérifier si le bloc est vide (pas de nom de fichier)
if (buffer[0] == 0) {
// Écrire le nom du fichier dans l'emplacement vide du superbloc
writeBlock(blockNum, 0, (const unsigned char *)filename, MAX_FILENAME_LENGTH);
break; // Fichier créé, sortir de la boucle
}
}
printf("Le fichier \"%s\" a été créé avec succès.\n", filename);
}

ReX : Si la boucle se termine sans trouver de slot libre le message de succès s'affiche tout de même.

ReX : Le paramètre <code>filename</code> n'a pas forcément une taille de <code>MAX_FILENAME_LENGTH</code>.

Selon moi, la fonction TYPE devra respecter 3 étapes:

# Enregistrement du Nom du Fichier: L'ajout du nom du fichier dans un des blocs de la première partie du superbloc.
# Stockage des Données du Fichier: La récupération des données saisies en entrée standard par l'utilisateur et leur stockage dans des blocs du système de fichiers à partir d'une certaine position, comme le bloc 1040.
# Mise à Jour de la Disponibilité des Blocs: L'indication que les blocs dans lesquels les données ont été écrites ne sont plus disponibles en modifiant les bits correspondants dans la deuxième partie du superbloc (les 16 derniers blocs du super bloc).

ReX : Relis le point 3 et dit moi si tu te comprends toi même ?

Amine: Ma phrase n'est effectivement pas très claire. Je voulais dire que la fonction TYPE devra mettre à jour la carte de disponibilité du superbloc. C'est à dire que lorsqu'elle écrira des données dans des blocs, elle devra indiquer dans la carte de disponibilités que ces blocs ne sont plus disponibles.

=== Fonction intermédiaire TYPE version 2 ===

Suite à vos remarques, j'ai apporté les modifications suivantes à la fonction TYPE:

* j'ai ajouté une condition pour l'affichage du message de succès de la création d'un fichier (placeFound).

* le paramètre <code>filename</code> n'ayant pas forcément une taille de <code>MAX_FILENAME_LENGTH</code>, je calcule maintenant la longueur de filename, afin d'écrire seulement le nom du fichier avec la fonction writeBlock.

Il fonction n'est bien évidemment pas fini, elle ajoute seulement le nom du fichier dans le superbloc pour l'instant. Cela me permet de tester les fonctions LS et RM.
void TYPE(const char *filesystem_path, const char *filename) {
size_t sizeFilename = strlen(filename);
printf("size filename=%d\n", sizeFilename);
unsigned char buffer[MAX_FILENAME_LENGTH];
int placeFound = 0;

if (sizeFilename > MAX_FILENAME_LENGTH) {
printf("Impossible de créer le fichier, nom trop long\n");
return;
}

// Parcours des blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, MAX_FILENAME_LENGTH);
// Vérifier si le bloc est vide (pas de nom de fichier)
if (buffer[0] == 0) {
// Écrire le nom du fichier dans l'emplacement vide du superbloc
if (sizeFilename < MAX_FILENAME_LENGTH) {
sizeFilename+=1;
}
writeBlock(blockNum, 0, (const unsigned char *)filename, sizeFilename);
placeFound = 1;
break; // Fichier créé, sortir de la boucle
}
}
if (placeFound == 1) {
printf("Le fichier \"%s\" a été créé avec succès.\n", filename);
} else {
printf("Plus de place dans le système de fichier pour créer ce fichier.\n", filename);
}
}

ReX : Mieux, attention il faut copier aussi le <code>\'0</code> final du nom, donc <code>sizeFilename+1</code>. Sinon tu n'es pas sûr qu'il y ait un zéro final. Et attention n°2, il ne faut pas copier ce <code>\'0</code> si le nom fait la taille maximale.

Amine: ok j'ai modifié la fonction TYPE ci-dessus. J'ai ajouté une condition: si le nom du fichier est inférieur à la taille maximale de nom de fichier, alors on incrémente de 1 la taille du nom de fichier. Cela nous permet d'écrire le '\0' dans le bloc de description. Dans le cas où le nom du fichier est de la taille maximale, nous n'avons pas besoin d'écrire le '\0', on n'incrémente donc pas la taille de 1.

J'ai également ajouté une condition: si le nom du fichier est supérieur à la taille maximale, alors un message d'erreur s'affiche et le fichier n'est pas créé.

ReX : OK. L'embryon de fonction <code>TYPE</code> est correct, il manque juste le principal : la création des blocs de données.

=== Fonction MV version 1 ===

J'ai ici créé la fonction MV qui permet de changer le nom d'un fichier. Pour ce faire, la fonction parcourt les blocs de descriptions à la recherche du fichier dont on veut changer le nom. Lorsque ce fichier est trouvé, on supprime l'ancien nom en mettant des 0 sur 16 octets, puis on vient réécrire le nouveau nom dans le même emplacement. Enfin, on sort de la boucle et on affiche le succès ou non de l'opération.
// Fonction qui modifie le nom du fichier
void MV(const char *filesystem_path, const char *old_filename, const char *new_filename) {
size_t sizeNew_filename = strlen(new_filename);
size_t sizeOld_filename = strlen(old_filename);
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
int fileFound = 0;
// Parcourir les blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);
// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char*)filenameBuffer, old_filename, MAX_FILENAME_LENGTH) == 0) {
// Effacer le nom du fichier dans le superbloc
memset(filenameBuffer, 0, MAX_FILENAME_LENGTH);
writeBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);
// Écrire le nom du fichier dans l'emplacement
writeBlock(blockNum, 0, (const unsigned char *)new_filename, sizeNew_filename);
fileFound=1;
break; // Nom modifié, sortir de la boucle
}
}
if (fileFound == 1) {
printf("Le nom du fichier \"%s\" a été renommé avec succès.\n", old_filename);
} else {
printf("Le fichier \"%s\" n'a pas été trouvé.\n", old_filename);
}
}

ReX : Inutile d'écraser l'ancien nom avec des zéros. Il suffit de copier le nouveau en s'assurant qu'il y ait un zéro final sauf si le nouveau nom fait la taille maximale.

Amine: ok, je vais faire les modifications dans la version 2.

== Semaine 6 ==

=== Fonction MV version 2 ===
Dans cette nouvelle version de la fonction MV, j'ai effectué les modifications suivantes:

* je n'écrase plus l'ancien nom avec des 0
* Je colle simplement le nouveau nom par dessus l'ancien, en m'assurant qu'il y ait bien le '\0' à la fin lorsque la taille du nom du fichier est inférieur à la taille maximale. Comme précédemment, afin de m'assurer de la présence de ce '\0' à la fin du nom, j'incrémente la taille de 1 lorsque qu'elle est inférieur à la taille max. Cependant, je ne suis pas sûr à 100% que ce soit la bonne manière de faire.

// Fonction qui modifie le nom du fichier
void MV(const char *filesystem_path, const char *old_filename, const char *new_filename) {
size_t sizeNew_filename = strlen(new_filename);
size_t sizeOld_filename = strlen(old_filename);
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
int fileFound = 0;

// Parcourir les blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {

readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char*)filenameBuffer, old_filename, MAX_FILENAME_LENGTH) == 0) {

if (sizeNew_filename < MAX_FILENAME_LENGTH) {
sizeNew_filename+=1;
}

// Écrire le nom du fichier dans l'emplacement
writeBlock(blockNum, 0, (const unsigned char *)new_filename, sizeNew_filename);

fileFound=1;

break; // Nom modifié, sortir de la boucle
}
}
if (fileFound == 1) {
printf("Le nom du fichier \"%s\" a été renommé avec succès.\n", old_filename);
} else {
printf("Le fichier \"%s\" n'a pas été trouvé.\n", old_filename);
}
}

ReX : C'est bon. La fonction était triviale.

=== Fonction TYPE version 1 ===
void TYPE(const char *filesystem_path, const char *filename) {
size_t sizeFilename = strlen(filename);
unsigned char buffer[MAX_FILENAME_LENGTH];
int placeFound = -1;

if (sizeFilename > MAX_FILENAME_LENGTH) {
printf("Impossible de créer le fichier, nom trop long\n");
return;
}

// Parcours des blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, MAX_FILENAME_LENGTH);
// Vérifier si le bloc est vide (pas de nom de fichier)
if (buffer[0] == 0) {
// Écrire le nom du fichier dans l'emplacement vide du superbloc
if (sizeFilename < MAX_FILENAME_LENGTH) {
sizeFilename += 1; // Ajouter '\0' s'il y a de la place
}
writeBlock(blockNum, 0, (const unsigned char *)filename, sizeFilename);
placeFound = blockNum;

// Lire les données depuis l'entrée standard
unsigned char dataBuffer[BLOCK_SIZE];
size_t bytesRead;
int dataBlockNum = findAvailableBlock(); // Premier bloc de données à partir du bloc 1040
printf("dataBlockNum%d\n",dataBlockNum);
int blockSizeUsed = 0; // Compteur d'octets dans le bloc actuel
int dataBlocksNeeded = 1; // Nombre de blocs de données nécessaires

while ((bytesRead = fread(dataBuffer + blockSizeUsed, 1, BLOCK_SIZE - blockSizeUsed, stdin)) > 0) {
blockSizeUsed += bytesRead;

// Si le bloc actuel est plein, passer au bloc suivant
if (blockSizeUsed == BLOCK_SIZE) {
// printf("dataBlockNum=%d\n",dataBlockNum);
writeBlock(dataBlockNum, 0, dataBuffer, BLOCK_SIZE);
setBlockAvailability(dataBlockNum, 1);

dataBlockNum++; // Passer au bloc suivant
blockSizeUsed = 0; // Réinitialiser la taille utilisée
dataBlocksNeeded++;
}
}

// Écrire le dernier bloc partiel, s'il y en a un
if (blockSizeUsed > 0) {
writeBlock(dataBlockNum, 0, dataBuffer, blockSizeUsed);
setBlockAvailability(dataBlockNum, 1);
}

// Écrire les numéros de blocs utilisés dans le bloc de description
unsigned char blockNumberBuffer[2];
int currentBlockNum = 1040;

for (int i = 0; i < dataBlocksNeeded; i++) {
blockNumberBuffer[0] = (currentBlockNum >> 8) & 0xFF;
blockNumberBuffer[1] = currentBlockNum & 0xFF;
writeBlock(placeFound, MAX_FILENAME_LENGTH + i * 2, blockNumberBuffer, 2);
currentBlockNum++;
}

break; // Fichier créé, sortir de la boucle
}
}

if (placeFound != -1) {
printf("Le fichier \"%s\" a été créé avec succès.\n", filename);
} else {
printf("Plus de place dans le système de fichier pour créer ce fichier.\n");
}
}

ReX : La constante 1040 ne doit pas apparaître en numérique, ce doit être une constante calculée à partir des autres constantes.

Amine: Ok. Je ne l'avais pas défini comme une constante car il s'agit dans la fonction ci-dessus d'une variable qui est incrémenté à chaque itération.

ReX : Je suis las de te répéter que le mémoire est comptée : tu utilises encore un bloc de <code>BLOCK_SIZE</code> octets, c'est trop.

Amine: Comment utiliser des blocs plus petit sachant qu'il s'agit là de blocs de données et qu'un bloc fait 256 octets d'après l'énoncé ? Dois-je les subdiviser en plusieurs blocs plus petit comme fait dans la fonction RM, en 4 blocs de 64 octets par exemple ?

Fonctionnement de la fonction TYPE:

* étape 1: on parcourt les blocs de descriptions à la recherche d'un bloc disponible. Si on ne trouve pas de bloc disponible, on renvoie un message d'erreur, sinon on passe à l'étape suivante.
* étape 2: Si on trouve un emplacement libre dans les blocs de disponibilité, on écrit le nom du fichier dans cet emplacement.

ReX : Dans les blocs de description de fichiers pas dans les blocs de disponibilité.

Amine: Oui autant pour moi.

* étape 3: Ensuite, on lit le texte entré par l'utilisateur en entrée standard, on le répartit dans des blocs de taille BLOCK_SIZE, on met à jour la disponibilité des blocs utilisés.

ReX : Non, il faut appeler <code>findAvailableBlock</code> pour chaque bloc de données à utiliser, aucune certitudes que les blocs libres soient en séquence.

Amine: ok, je ferai cela dans la version 2

* étape 4: Enfin, on écrit les numéros des blocs de données utilisés dans les blocs de description de ce fichier, les numéros étant écris sur deux octets.

ReX : Non cela doit se faire au fur et à mesure des appels à <code>findAvailableBlock</code> et les numéros des blocs de données peuvent s'étaler sur les 16 blocs de description du fichier. Confusion totale sur ce point. Vous n'avez pas compris le mécanisme.

Amine: je corrige cela dans la version 2. J'ai bien compris le mécanisme mais ce n'est pas facile à traduire en code.

=== Fonction TYPE version 2 ===
Dans cette nouvelle version de TYPE, j'ai fait les modifications suivantes:

* j'appelle maintenant <code>findAvailableBlock</code> pour chaque bloc de données à utiliser
* j'écris maintenant les numéros de blocs au fur et à mesures des appels à <code>findAvailableBlock</code>
* je n'utilise plus de tableaux de taille 256 octets mais des tableaux de tailles CHUNK_SIZE. J'ai choisi ici CHUNK_SIZE = 64 octets.

J'utilise toujours un bloc de taille BLOCK_SIZE en attendant de comprendre si je dois diviser ce bloc en plusieurs blocs de taille plus petite ou s'il y a un moyen de ne pas du tout utiliser ces blocs.
void TYPE(const char *filesystem_path, const char *filename) {
size_t sizeFilename = strlen(filename);
unsigned char buffer[MAX_FILENAME_LENGTH];
int placeFound = -1;

if (sizeFilename > MAX_FILENAME_LENGTH) {
printf("Impossible de créer le fichier, nom trop long\n");
return;
}

// Parcours des blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, MAX_FILENAME_LENGTH);
// Vérifier si le bloc est vide (pas de nom de fichier)
if (buffer[0] == 0) {
// Écrire le nom du fichier dans l'emplacement vide du superbloc
if (sizeFilename < MAX_FILENAME_LENGTH) {
sizeFilename += 1; // Ajouter '\0' s'il y a de la place
}
writeBlock(blockNum, 0, (const unsigned char *)filename, sizeFilename);
placeFound = blockNum;

// Lire les données depuis l'entrée standard et écrire dans le fichier
int dataBlockNum = findAvailableBlock(); // Premier bloc de données à partir du bloc 1040
printf("Premier bloc dans lequel on écrit = %d\n", dataBlockNum);
int blockSizeUsed = 0; // Compteur d'octets dans le bloc actuel

unsigned char chunkBuffer[CHUNK_SIZE];
size_t bytesRead;

while ((bytesRead = fread(chunkBuffer, 1, CHUNK_SIZE, stdin)) > 0) {
// Écrire le chunk dans le bloc de données
writeBlock(dataBlockNum, blockSizeUsed, chunkBuffer, bytesRead);
setBlockAvailability(dataBlockNum, 1);

// Écrire le numéro du bloc actuel dans la description du fichier
unsigned char blockNumberBuffer[2];
blockNumberBuffer[0] = (dataBlockNum >> 8) & 0xFF;
blockNumberBuffer[1] = dataBlockNum & 0xFF;
writeBlock(placeFound, MAX_FILENAME_LENGTH + dataBlockNum * 2, blockNumberBuffer, 2);

blockSizeUsed += bytesRead;

// Si le bloc actuel est plein, passer au bloc suivant
if (blockSizeUsed == BLOCK_SIZE) {
dataBlockNum = findAvailableBlock(); // Passer au bloc suivant
blockSizeUsed = 0; // Réinitialiser la taille utilisée
}
}

break; // Fichier créé, sortir de la boucle
}
}

if (placeFound != -1) {
printf("Le fichier \"%s\" a été créé avec succès.\n", filename);
} else {
printf("Plus de place dans le système de fichier pour créer ce fichier.\n");
}
}

=== Fonction findAvailableBlock ===
Cette fonction renvoie l'indice du premier bloc disponible. Je me sers de cette fonction dans la fonction TYPE.
#define FIRST_DATA_BLOCK 1040
#define FIRST_DISPONIBILITY_CARD_BLOCK 1024

// Renvoie le premier bloc de donné disponible
int findAvailableBlock() {
unsigned char availabilityBuffer[BLOCK_SIZE];
int offset;

// Lire la carte de disponibilité (à partir du bloc 1)
for (int blockNum = FIRST_DISPONIBILITY_CARD_BLOCK; blockNum < FIRST_DATA_BLOCK; blockNum++) {
readBlock(blockNum, 0, availabilityBuffer, BLOCK_SIZE);

if (blockNum==FIRST_DISPONIBILITY_CARD_BLOCK) {
offset=FIRST_DATA_BLOCK/8;
} else {
offset=0;
}

// Parcourir les octets de la carte de disponibilité
for (int byteIndex = offset; byteIndex < BLOCK_SIZE - offset; byteIndex++) {
unsigned char byte = availabilityBuffer[byteIndex];

// Parcourir les bits de chaque octet
for (int bitIndex = 0; bitIndex < 8; bitIndex++) {
// Vérifier si le bit est à 0 (bloc disponible)
if ((byte & (1 << bitIndex)) == 0) {
// Calculer l'indice du bloc en fonction du bloc et du bit
int blockIndex = byteIndex * 8 + bitIndex;
return blockIndex;
}
}
}
}

// Aucun bloc disponible trouvé
return -1;
}

ReX : Même remarque que précédement sur les nombres 1024 et 1040.

Amine: Ok, j'ai remplacé 1024 par la constante FIRST_DISPONIBILITY_CARD_BLOCK et 1040 par la constante FIRST_DATA_BLOCK dans la fonction ci-dessus.

ReX : Vous n'avez toujours pas compris la contrainte sur la mémoire.

Amine: dois-je découper le bloc de taille BLOCK_SIZE en quatre blocs de taille 64 octets par exemple ?

ReX : Je ne vois pas ce que vous voulez faire avec <code>if (blockNum==1024) offset=1040/8; else offset=0;</code>.

Amine: dans la carte de disponibilité, chaque bit correspond à un bloc. Ainsi, les bits de 0 à 1040 dans la carte de disponibilité décrivent la disponibilité des blocs 0 à 1040. Or ces blocs correspondent au superbloc, et dans cette fonction, on veut connaître le premier bloc de données disponible. On ne s'intéresse donc pas au 1040 premiers bits de la carte de disponibilité. Je crée donc un offset égal à 1040/8 afin de ne pas prendre en compte les 1040 premiers bits soit les 1040/8=130 premiers octets. Cet offset ne s'applique que lorsqu'on se trouve dans le premier des 16 blocs de la carte de disponibilité, d'où la condition <code>if (blockNum==1024)</code>.

ReX : OK, bien vu.

=== Fonction CAT version 1 ===
void CAT(const char *filesystem_path, const char *filename) {
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
unsigned char buffer[BLOCK_SIZE];
unsigned char blockNumberBuffer[2];
unsigned char dataBuffer[BLOCK_SIZE];
int offset;

// Parcours des blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char *)filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {
// Le nom du fichier a été trouvé

// Parcours les blocs de description
for (int descrBlockNum=0; descrBlockNum<MAX_BLOCKS_PER_FILE_DESCRIPTION; descrBlockNum++) {
if (descrBlockNum==0) {
offset=16;
} else {
offset=0;
}
readBlock(descrBlockNum+blockNum, offset, buffer, BLOCK_SIZE-offset);

// Lire les numéros de blocs associés à ce fichier depuis les blocs de description
unsigned char octet1 = buffer[offset];
unsigned char octet2 = buffer[offset+1];

int dataBlockNum = (octet1 << 8) | octet2;
printf("dataBlockNum=%d\n",dataBlockNum);

// Vérifier si le numéro de bloc est valide (non nul)
if (dataBlockNum == 0) {
return; // Fin du fichier
}

// Lire et afficher le contenu du bloc de données
readBlock(dataBlockNum, 0, dataBuffer, BLOCK_SIZE);
fwrite(dataBuffer, 1, BLOCK_SIZE, stdout);
}

return; // Fichier affiché, sortie de la fonction
}
}

// Si le fichier n'a pas été trouvé
printf("Le fichier \"%s\" n'a pas été trouvé.\n", filename);
}

ReX : Encore mieux : deux blocs de <code>BLOCK_SIZE</code> en mémoire.

ReX : Le <code>break</code> ne sort pas de la boucle externe.

Amine: Oui c'est vrai. J'ai remplacé le <code>break</code> par un <code>return</code> ci-dessus.

ReX : Dans le cadre de la fonction CAT le <code>return</code> est convenable.

Voici ma fonction <code>CAT</code>. Elle fonctionne en plusieurs étape:

* étape 1: on cherche dans les blocs de descriptions si le fichier dont on veut afficher le contenu existe. Si le nom de fichier est trouvé, on passe à l'étape 2. Sinon, on renvoie un message d'erreur.
* étape 2: si le fichier est trouvé, on parcours les 16 blocs de description de ce fichier.
* étape 3: grâce aux opérations de masquage et de décalage, on joint les octets deux par deux pour former un entier qui contient le numéro du bloc de données correspondant au fichier. Si cet entier vaut 0, alors cela signifie qu'il n'y a plus de blocs associé à ce fichier, on peut donc quitter la fonction. Si cet entier est différent de 0, alors on va lire le bloc correspondant à ce numéro et on affiche son contenu dans le terminal.

== Semaine 7 ==

=== Fonction CP version 1 ===
Voici ma fonction CP, qui permet de créer une copie d'un fichier existant. L'idée est la suivante: pour copier un fichier, on doit créer un nouveau fichier et lui attribuer les mêmes blocs de descriptions que le fichier source. Ainsi, le fichier source et le fichier destination pointeront vers les mêmes blocs de données, et auront le même contenu.

ReX : Perdu. Ce n'est absolument pas la fonction de copie de fichiers d'un système de fichiers.

Amine: Après avoir fait des recherches et après réflexion, je me rends compte que cette fonction CP présente un problème: en faisant pointer les blocs de données du fichier destination vers ceux du fichier source, toute modification du fichier source impactera le fichier destination, or ce n'est pas ce qu'on veut faire. Je vous propose donc une nouvelle version de la fonction CP ci-dessous qui remédie à ce problème.

void CP(const char *filesystem_path, const char *source_filename, const char *destination_filename) {
unsigned char source_filenameBuffer[MAX_FILENAME_LENGTH];
unsigned char destination_filenameBuffer[MAX_FILENAME_LENGTH];
unsigned char descriptionBuffer[BLOCK_SIZE];
int destination_offset;
int offset;

// Recherche du fichier source
int source_offset = -1;
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, source_filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier source
if (strncmp((const char *)source_filenameBuffer, source_filename, MAX_FILENAME_LENGTH) == 0) {
source_offset = blockNum;
break;
}
}

if (source_offset == -1) {
printf("Le fichier source \"%s\" n'a pas été trouvé.\n", source_filename);
return;
}

// Recherche d'un emplacement libre pour le fichier destination
destination_offset = -1;
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, destination_filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc est vide (pas de nom de fichier)
if (destination_filenameBuffer[0] == 0) {
destination_offset = blockNum;
break;
}
}

if (destination_offset == -1) {
printf("Plus de place dans le système de fichier pour créer la copie de \"%s\".\n", source_filename);
return;
}

// Ecrit le nom de la copie dans le bloc de description
writeBlock(destination_offset, 0, (const unsigned char *)destination_filename, strlen(destination_filename));

// Copier les blocs de description associés au fichier source dans les blocs de description du fichier destination
for (int i = 0; i < MAX_BLOCKS_PER_FILE_DESCRIPTION; i++) {
if (i==0) {
offset = MAX_FILENAME_LENGTH;
} else {
offset = 0;
}

readBlock(source_offset+i, offset, descriptionBuffer, BLOCK_SIZE-offset);
if (descriptionBuffer[offset]==0) {
return;
} else {
writeBlock(destination_offset+i, offset, descriptionBuffer, BLOCK_SIZE-offset);
}
}

printf("La copie de \"%s\" sous le nom \"%s\" a été créée avec succès.\n", source_filename, destination_filename);
}

ReX : Pas mieux.

== Semaine 8 ==
A ce stade du projet, les fonctions suivantes ont été validé par Monsieur Redon:

* fonction LS
* fonction RM
* fonction MV

Il reste donc les fonctions suivantes à terminer:

* fonction CAT
* fonction CP
* fonction TYPE

=== Fonction CAT version 2 ===
Suite à vos remarques sur la version 1, j'ai fais les modifications suivantes:

* je n'utilise non plus 2 tableaux de taille BLOCK_SIZE, mais 1 seul. Idéalement il faudrait en utiliser 0, je réfléchi donc à m’émanciper de ce tableau en le remplaçant par plusieurs plus petits tableaux.

ReX : Un seul plus petit.

* J'ai remplacé le <code>break</code> par un <code>return</code>

ReX : Déjà validé.

Cette fonction permet d'afficher le contenu d'un fichier créé avec la fonction TYPE. Pour se faire, on parcours tout d'abord les blocs de descriptions pour trouver le fichier dont ont veut afficher le contenu. Une fois ce fichier trouvé, on parcours les 16 blocs de description de ce fichier 1 à 1. Pour chacun de ces blocs de description, on va stocker récupéré les octets deux par deux afin de former des entiers. Pour se faire, on utilise la fonction <code>reconsituteNumber</code> que l'on détaillera juste après. Ces entiers correspondent aux blocs dans lesquels la donné du fichier se trouve. Une fois l'entier reconstitué, on affiche le contenu du bloc correspondant.
#define CHUNK_SIZE 64

void CAT(const char *filesystem_path, const char *filename) {
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
unsigned char byteBuffer[2];
unsigned char dataBuffer[CHUNK_SIZE];
int offset;

// Parcours des blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char *)filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {
// Le nom du fichier a été trouvé

// Parcours les blocs de description
for (int descrBlockNum=0; descrBlockNum<MAX_BLOCKS_PER_FILE_DESCRIPTION; descrBlockNum++) {
if (descrBlockNum==0) {
offset=MAX_FILENAME_LENGTH;
} else {
offset=0;
}

// Lecture des octets deux par deux
for (int i=0; i<BLOCK_SIZE;i+=2) {
readBlock(descrBlockNum+blockNum, offset+i, byteBuffer, 2);

// Lire les numéros de blocs associés à ce fichier depuis les blocs de description
int dataBlockNum = reconsituteNumber(byteBuffer);

// Vérifier si le numéro de bloc est valide (non nul)
if (dataBlockNum == 0) {
return; // Fin du fichier
}

for (int chunkStart = 0; chunkStart < BLOCK_SIZE; chunkStart += CHUNK_SIZE) {
// Lire et afficher le contenu du bloc de données
readBlock(dataBlockNum, chunkStart, dataBuffer, CHUNK_SIZE);
fwrite(dataBuffer, 1, CHUNK_SIZE, stdout);
}
}
}

return; // Fichier affiché, sortie de la fonction
}
}

// Si le fichier n'a pas été trouvé
printf("Le fichier \"%s\" n'a pas été trouvé.\n", filename);
}

ReX : Remplacer le premier bloc de <code>BLOCK_SIZE</code> octets par un bloc de 2 octets est exagéré mais cela pourrait passer. Il reste toujours un bloc de <code>BLOCK_SIZE</code> octets dont il est facile de se passer au bénéfice d'un bloc de, mettons, 64 octets.

Amine: Voilà! Dans la version ci-dessus j'ai remplacé le bloc de taille <code>BLOC_SIZE</code> par un bloc de taille <code>CHUNK_SIZE</code>, avec <code>CHUNK_SIZE</code> modifiable dans les constantes du programme. J'ai pris ici 64 octets.

=== Fonction reconsituteNumber ===
Cette fonction permet de reconstituer un numéro de bloc à partir de deux octets.
// Fonction qui reconstitue le numéro de bloc à partir du tableau
int reconsituteNumber(unsigned char blockNumberBuffer[2]) {
unsigned char octet1 = blockNumberBuffer[0];
unsigned char octet2 = blockNumberBuffer[1];
int dataBlockNum = (octet1 << 8) | octet2;
return dataBlockNum;
}

ReX : Bonne idée cette fonction.

=== Fonction CP version 2 ===
Voici une version mise à jour de notre fonction CP. Dans la version précédente, on faisait pointer le fichier source vers les même blocs que le fichier destination. Cela posait un problème: toute modification du fichier source impactait le fichier destination. Ainsi, dans cette nouvelle version, on fait une duplication des blocs de données du fichier source vers le fichier destination. Cela implique donc une mise à jour de la carte de disponibilité, ainsi que l'adaptation des blocs de descriptions. En effet, seulement les blocs de données sont maintenant identiques, plus les blocs de description.

Piste d'amélioration: comme pour la fonction CAT ci-dessus, j'utilise toujours un bloc de taille 256 octets, je vais devoir y remédier.
// Fonction pour copier un fichier existant du système de fichier
void CP(const char *filesystem_path, const char *source_filename, const char *destination_filename) {
unsigned char source_filenameBuffer[MAX_FILENAME_LENGTH];
unsigned char destination_filenameBuffer[MAX_FILENAME_LENGTH];
unsigned char descriptionBuffer[CHUNK_SIZE];
unsigned char numBuffer[2];
int destination_offset;
int source_offset;
int offset;
int numDataBlock;
int newDataBlock;

// Recherche du fichier source
source_offset = -1;
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, source_filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier source
if (strncmp((const char *)source_filenameBuffer, source_filename, MAX_FILENAME_LENGTH) == 0) {
source_offset = blockNum;
break;
}
}

if (source_offset == -1) {
printf("Le fichier source \"%s\" n'a pas été trouvé.\n", source_filename);
return;
}

// Recherche d'un emplacement libre pour le fichier destination
destination_offset = -1;
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, destination_filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc est vide (pas de nom de fichier)
if (destination_filenameBuffer[0] == 0) {
destination_offset = blockNum;
break;
}
}

if (destination_offset == -1) {
printf("Plus de place dans le système de fichier pour créer la copie de \"%s\".\n", source_filename);
return;
}

// Copie du nom de la copie dans le bloc de description
writeBlock(destination_offset, 0, (const unsigned char *)destination_filename, strlen(destination_filename));

// Copier les blocs de données associés au fichier source dans de nouveaux blocs de données pour le fichier destination
for (int i = 0; i < MAX_BLOCKS_PER_FILE_DESCRIPTION; i++) {
if (i == 0) { offset = MAX_FILENAME_LENGTH; }
else { offset = 0; }

// Lecture des numéros de bloc dans les blocs de description
for (int byteNum=0; byteNum<BLOCK_SIZE; byteNum+=2) {
readBlock(source_offset + i, offset + byteNum, numBuffer, 2);

numDataBlock = reconsituteNumber(numBuffer);
if (numDataBlock == 0) {
printf("La copie de \"%s\" sous le nom \"%s\" a été créée avec succès.\n", source_filename, destination_filename);
return;
}

for (int chunkStart = 0; chunkStart < BLOCK_SIZE; chunkStart += CHUNK_SIZE) {
// On stocke le bloc de données associé au fichier source dans descriptionBuffer
readBlock(numDataBlock, chunkStart, descriptionBuffer, CHUNK_SIZE);

if (chunkStart == 0) {
// Trouver un nouveau bloc de données disponible
newDataBlock = findAvailableBlock();

// Mise à jour de la carte de disponibilités
setBlockAvailability(newDataBlock, 1);

// Ecriture du numéro de bloc dans la description du fichier
createNumberBuffer(newDataBlock,numBuffer);
writeBlock(destination_offset+i, offset+byteNum, numBuffer, 2);
}

// Ecriture du bloc de données dans le premier bloc disponible
writeBlock(newDataBlock, chunkStart, descriptionBuffer, CHUNK_SIZE);
}
}
}
}

ReX : Youpi. Il reste à se passer du bloc de <code>BLOCK_SIZE</code> (au bénéfice d'un bloc de taille <code>BLOCK_SIZE/n</code> avec n>1). Ecrire la fonction inverse de <code>reconsituteNumber</code>.

Amine: Voilà! Dans le fonction ci-dessus il n'y a plus de bloc de taille <code>BLOCK_SIZE</code>, on a maintenant des blocs de 64 octets (<code>CHUNK_SIZE</code>). J'ai également créé la fonction <code>createNumberBuffer</code> qui est la fonction inverse de<code>reconsituteNumber</code>. Je la détaille ci-dessous.

=== Fonction createNumberBuffer ===
Cette fonction permet repartir un entier sur deux octets.
// Fonction qui réparti un numéro de bloc sur deux octets
void createNumberBuffer(int dataBlockNum, unsigned char blockNumberBuffer[2]) {
blockNumberBuffer[0] = (dataBlockNum >> 8) & 0xFF;
blockNumberBuffer[1] = dataBlockNum & 0xFF;
}

=== Fonction TYPE version 3 ===
La fonction 2 que j'ai fourni ci-dessus n'est pas correcte. Je vais la corriger dans cette version 3.

ReX : Effectivement la version précédente ne gére pas correctement l'écriture des numéros de blocs de données dans la description d'un fichier.

Voici ma version 3 de la fonction TYPE. Voici son fonctionnement:

- tout d'abord, la fonction parcours les blocs de description à la recherche d'un emplacement vide

- une fois l'emplacement vide trouvé, elle écrit le nom du fichier dans cet emplacement

- ensuite, on passe à la lecture de l'entrée standard. J'ai essayé d'expliquer au fur et à mesure du programme ce que font les lignes importantes via les commentaires.
void TYPE(const char *filesystem_path, const char *filename) {
size_t sizeFilename = strlen(filename);
unsigned char buffer[MAX_FILENAME_LENGTH];
int placeFound = -1;
int index_description_block = 0; // indice du bloc de descrption
int block_counter = 1; //compteur de blocs utilisés
int index_in_descrBlock = 0;
int offset;
int first_loop=1;

if (sizeFilename > MAX_FILENAME_LENGTH) {
printf("Impossible de créer le fichier, nom trop long\n");
return;
}

// Parcours des blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, MAX_FILENAME_LENGTH);
// Vérifier si le bloc est vide (pas de nom de fichier)
if (buffer[0] == 0) {
// Écrire le nom du fichier dans l'emplacement vide du superbloc
if (sizeFilename < MAX_FILENAME_LENGTH) {
sizeFilename += 1; // Ajouter '\0' s'il y a de la place
}
writeBlock(blockNum, 0, (const unsigned char *)filename, sizeFilename);
placeFound = blockNum;

// Lire les données depuis l'entrée standard et écrire dans le fichier
int dataBlockNum = findAvailableBlock(); // Premier bloc de données à partir du bloc 1040
int blockSizeUsed = 0; // Compteur d'octets dans le bloc actuel

unsigned char chunkBuffer[CHUNK_SIZE];
size_t bytesRead;

while ((bytesRead = fread(chunkBuffer, 1, CHUNK_SIZE, stdin)) > 0) {

// Écrire le chunk dans le bloc de données
writeBlock(dataBlockNum, blockSizeUsed, chunkBuffer, bytesRead);
setBlockAvailability(dataBlockNum, 1);

// Écrire le numéro du bloc actuel dans la description du fichier
unsigned char blockNumberBuffer[2];
createNumberBuffer(dataBlockNum,blockNumberBuffer);

blockSizeUsed += bytesRead;

// Si le bloc actuel est plein, passer au bloc suivant OU si c'est le premier tour dans la boucle
if (blockSizeUsed == BLOCK_SIZE || first_loop == 1) {

first_loop = -1;

// Ecriture du numéro de bloc utilisé dans les blocs de description
if (index_description_block == 0) {
offset = MAX_FILENAME_LENGTH;
} else {
offset = 0;
}
writeBlock(placeFound + index_description_block, offset + index_in_descrBlock*2, blockNumberBuffer, 2);
index_in_descrBlock++;

dataBlockNum = findAvailableBlock(); // Passer au bloc suivant
blockSizeUsed = 0; // Réinitialiser la taille utilisée

// Passage au bloc de description suivant
if (block_counter == (BLOCK_SIZE/2-offset)) {
index_description_block++;
index_in_descrBlock=0;
}

// Compteur de nombre de blocs utilisés
block_counter++;

// Vérifie si on a atteint le nombre maximal de blocs par fichier
if (block_counter >= 2040) {
printf("Le fichier a atteint sa taille maximale\n");
return;
}
}
}

break; // Fichier créé, sortir de la boucle
}
}

if (placeFound != -1) {
printf("Le fichier \"%s\" a été créé avec succès.\n", filename);
} else {
printf("Plus de place dans le système de fichier pour créer ce fichier.\n");
}
}

= Compilation et exécution =
'''Création du système de fichiers :'''
dd if=/dev/zero of=filesystem.bin bs=256 count=32768

'''Compilation :'''

gcc picofs.c -o picofs

'''Exécution de LS, TYPE, CAT, RM, MV ou CP :'''

./picofs filesystem.bin LS
./picofs filesystem.bin TYPE mon_fichier.txt
./picofs filesystem.bin CAT mon_fichier.txt
./picofs filesystem.bin RM mon_fichier.txt
./picofs filesystem.bin MV mon_fichier.txt mon_fichier2.txt
./picofs filesystem.bin CP mon_fichier.txt mon_fichier2.txt

= Documents Rendus =
[[Fichier:PicofsV2.c.tar|vignette]]

Fichier:PicofsV2.c.tar

2023-09-04T18:33:22Z

Asellali :

picofs

SE4 2022/2023 EC1

2023-09-04T18:32:07Z

Asellali : /* Fonction TYPE version 3 */

= Objectifs =

Il vous est demandé de :
* réaliser un micro système de fichiers ;
* le système de fichiers doit résider dans un fichier de 8 Mo ;
* le système de fichiers est géré par un exécutable obtenu à partir d'un programme C ;
* L'éxécutable prend deux arguments, le premier est le chemin du fichier dans lequel réside le système de fichiers, les paramètres suivants concernent l'action à appliquer sur le système de fichiers ;
* le micro système de fichier ne comporte qu'un répertoire : le répertoire principal, le répertoire principal peut comporter au maximum 64 fichiers, un fichier est caractérisé par un nom de 16 caractères au maximum et ses blocs de données, un fichier peut comporter au maximum 2040 blocs de données ;
* un bloc de données fait 256 octets et les blocs sont numérotés sur 2 octets ;
* les différentes actions possibles sur le système de fichiers sont :
** <code>TYPE</code> pour créer un fichier si possible, le nom du fichier suit la commande, le contenu du fichier est donné en entrée standard de l'exécutable ;
** <code>CAT</code> pour afficher un fichier, le nom du fichier suit la commande ;
** <code>RM</code> pour détruire un fichier, le nom du fichier suit la commande ;
** <code>MV</code> pour renommer un fichier, les noms original et nouveau du fichier suivent la commande ;
** <code>CP</code> pour copier un fichier, les noms de l'original et de la copie du fichier suivent la commande ;

= Matériel nécessaire =

Un PC sous Linux.

= Travail réalisé =

== Semaine 1 ==

ReX : attention, ce micro-système de fichiers est prévu pour un microcontrôleur, vos variables globales ne peuvent pas dépasser quelques centaines d'octets.

ReX : pour la création du système de fichiers la commande <code>dd</code> suffit, vous voulez dire le formatage du système de fichiers ?

* création du programme programme.c contenant les différentes structures et les différentes fonctions.
* Piste d'amélioration: faire en sorte que la fonction CAT affiche le contenu exact des fichiers passés en argument.

Le code fourni est un programme en langage C qui simule un système de fichiers basique. Ce programme permet aux utilisateurs d'effectuer diverses actions telles que créer, afficher, supprimer, renommer et copier des fichiers dans un système de fichiers simulé. Le système de fichiers est stocké dans un fichier binaire.

ReX : vous n'avez pas tenu compte de la première remarque, vous chargez tout le superbloc et le répertoire racine, votre code ne convient pas.

ReX : vos structures utilisent des types entiers dont la taille n'est pas explicitée, utilisez les types de <code>stdint.h</code>.

ReX : la création de fichier n'est pas fonctionnelle, vous ne cherchez pas les blocs libres, vous ne copiez pas le contenu du fichier dans les blocs, même remarque pour toutes les autres fonctions.

ReX : il manque les fonctions d'accès aux pages du système de fichiers.

'''Explication du programme programme.c'''

Voici une brève explication des principaux éléments et fonctions du code :

# Structures :
#* Fichier : Représente un fichier dans le système de fichiers. Il contient un nom (nom) avec une longueur maximale de 16 caractères, un tableau de numéros de bloc (blocs) où le contenu du fichier est stocké (jusqu'à 2040 blocs), et le nombre de blocs utilisés par le fichier (nbBlocs).
#* Repertoire : Représente le répertoire principal du système de fichiers. Il contient un tableau de fichiers (<code>fichiers</code>) et le nombre de fichiers dans le répertoire (<code>nbFichiers</code>).
# Fonctions :
#* <code>chargerSystemeFichiers</code> : Charge le système de fichiers à partir d'un fichier binaire donné (chemin) dans une structure Repertoire.
#* <code>sauvegarderSystemeFichiers</code> : Sauvegarde le système de fichiers stocké dans la structure Repertoire dans un fichier binaire (chemin).
#* <code>creerFichier</code> : Crée un nouveau fichier dans le système de fichiers avec un nom et un contenu donnés. Le contenu du fichier est simulé en le divisant en blocs.
#* <code>afficherFichier</code> : Affiche le contenu d'un fichier avec le nom spécifié.
#* <code>detruireFichier</code> : Supprime un fichier avec le nom spécifié du système de fichiers.
#* <code>renommerFichier</code> : Renomme un fichier avec l'ancien nom spécifié en un nouveau nom.
#* <code>copierFichier</code> : Copie un fichier avec le nom spécifié en créant un nouveau fichier avec le nom de copie spécifié.
# Fonction <code>main</code> :
#* La fonction <code>main</code> est le point d'entrée du programme.
#* Elle prend des arguments en ligne de commande : <code><chemin_systeme_fichiers></code> et <code><action></code>.
#* <code><chemin_systeme_fichiers></code> est le chemin vers le fichier binaire où le système de fichiers est stocké.
#* <code><action></code> détermine quelle opération effectuer, comme <code>TYPE</code>, <code>CAT</code>, <code>RM</code>, <code>MV</code> ou <code>CP</code>.
#* En fonction de l'action spécifiée, le programme appelle la fonction correspondante pour effectuer l'opération souhaitée sur le système de fichiers.
Remarque : Le code fourni une simulation basique d'un système de fichiers et de ses opérations, mais il n'interagit pas réellement avec un système de fichiers réel sur le disque.

'''Comment utiliser le programme programme.c'''

étape 1: création du système de fichiers respectant le cahier des charges:

dd if=/dev/zero of=systeme_fichiers.bin bs=1M count=8

étape 2: compilation du programme C:

gcc programme.c -o gestionnaire_fs

étape 3: création d'un fichier dans le système de fichier:

./gestionnaire_fs systeme_fichiers.bin TYPE fichier1.txt

-> entrer le texte en entrée standard

étape 4: manipulation des différentes fonctions. Exemples:

./gestionnaire_fs systeme_fichiers.bin CAT fichier1.txt
./gestionnaire_fs systeme_fichiers.bin CP fichier1.txt copie.txt
./gestionnaire_fs systeme_fichiers.bin RM copie.txt
./gestionnaire_fs systeme_fichiers.bin MV fichier1.txt fichier2.txt

== Semaine 2 ==

Amine: Merci pour vos remarques. Désolé de ne pas avoir suivi votre première remarque, je pensais avoir compris ce qu'il fallait faire mais je me rend compte que non. Je vais tout reprendre depuis le début afin de repartir sur de bonnes bases.

'''Création du système de fichier avec la commande "dd"'''

A quoi sert la commande dd?

La commande <code>dd</code> permet de copier tout ou partie d'un disque par blocs d'octets, indépendamment de la structure du contenu du disque en fichiers et en répertoires (source : [https://doc.ubuntu-fr.org/dd]).

Structure de la commande

dd if=<nowiki><source> of=<cible> bs=<taille des blocs></nowiki>

<code>source</code> = données à copier

<code>cible</code> = endroit où les copier

<code>if</code> = input file

<code>of</code> = output file

<code>bs</code> = block size, habituellement une puissance de 2 supérieure ou égale à 512, représentant un nombre d'octets

Choix de la commande:

Pour la source, on prends <code>/dev/zero</code>: cela permet de créer un fichier rempli de 0. Ce fichier servira de base pour notre système de fichiers.

Pour la cible, on va l'appeler <code>filesystem.bin</Code> : ce sera notre système de fichier.

Pour la taille des blocs, on veut des blocs de données de 256 octets d'après l'enoncé. On va donc prendre <code>bs=256</code>.

Enfin, on veut que le système de fichier réside dans un fichier de 8 Mo. On va donc ajouter <code>count=31250</code>: cela indique que nous voulons écrire 32768 blocs de données dans le fichier (31250 * 256 octets = 8 Mo).

Résultat:

dd if=/dev/zero of=filesystem.bin bs=256 count=31250

Question pour M. Redon : j'ai ici essayé de respecter votre remarque "pour la création du système de fichiers la commande <code>dd</code> suffit". Cependant, pour votre seconde remarque "vous chargez tout le superbloc et le répertoire racine, votre code ne convient pas.", je ne suis pas sûr de comprendre où je fais cela: est-ce lors de la commande dd ou est-ce par la suite avec mon programme C? J'ai un peu modifié la commande dd comme vous pouvez le voir ci-dessus. Ai-je corrigé mon erreur avec cette nouvelle commande? J'ai essayé de justifier au maximum la commande dd que j'ai choisie.

ReX : Pas de problème avec la commande <code>dd</code> (mettez tous les extraits de code entre des balises <code>code</code>). Le problème est au niveau du programme C.

Amine: Ok je comprends mieux merci. Je vais donc reprendre le code étape par étape afin de mieux répondre au cahier des charges.

Gestion du système de fichier par un programme C

'''Création des structures'''
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>

// Structure pour représenter un bloc de données

struct DataBlock {
uint8_t data[256]; // 256 octets pour chaque bloc de données
};

// Structure pour représenter un fichier

struct File {
char filename[17]; // 16 caractères pour le nom du fichier + 1 caractère null-terminator
struct DataBlock data_blocks[2040]; // Tableau de blocs de données pour stocker le contenu du fichier
uint16_t num_data_blocks; // Nombre de blocs de données utilisés par le fichier
};

// Structure pour représenter un répertoire

struct Directory {
struct File files[64]; // Tableau de fichiers pour le répertoire principal
uint8_t num_files; // Nombre de fichiers dans le répertoire principal
};

Modification faite : suite à votre remarque, j'ai explicité la taille des entiers grâce aux types de <code>stdint.h.</code> (j'ai également mis les variables en anglais)

ReX : Vous ne pouvez pas utiliser ces structures, une instanciation d'une de ces structure prend trop d'espace mémoire, vous devez faire sans structure. Par ailleurs la façon dont vous représentez vos fichiers ne convient pas, la description d'un fichier contient des numéros de blocs, pas les blocs eux-même. Faites aussi attention qu'un fichier soit décrit par un nombre entier de blocs.

Question pratique: je n'arrive pas à mettre tout le code dans le même bloc comme vous l'avez fait ci-dessus dans l'étape 4 de la semaine 1. Je vois que c'est en format "préformaté" mais j'obtiens des blocs séparés lorsque j'applique ce format à mon code.

ReX : j'ai corrigé, pour un code entier la syntaxe n'est pas la même (un espace en début de chaque ligne), la balise c'est uniquement pour de très courts extraits de code.

=== Fonction <code>readBlock</code>===
Cette fonction est utilisée pour lire un bloc de données à partir du fichier <code>filesystem.bin</code> et le stocker dans un tableau de caractères (<code>storage</code>).

Fonction:

#define BLOCK_SIZE 256
// Fonction pour lire un bloc de données
void readBlock(unsigned int num, int offset, unsigned char *storage, int size) {
FILE *file = fopen("filesystem.bin", "rb");
if (file == NULL) {
perror("Erreur lors de l'ouverture du fichier");
return;
}
fseek(file, num * BLOCK_SIZE + offset, SEEK_SET);
fread(storage, 1, size, file);
fclose(file);
}

Paramètres :

* <code>num</code> : Numéro du bloc à lire. Chaque bloc contient 256 octets (1 bloc = 256 octets).
* <code>offset</code> : Décalage (en octets) à partir du début du bloc pour commencer la lecture.
* <code>storage</code> : Pointeur vers un tableau de caractères où les données lues seront stockées.
* <code>size</code> : Taille du tableau de caractères <code>storage</code>.

Fonctionnement :

* La fonction commence par ouvrir le fichier <code>filesystem.bin</code> en mode lecture binaire (<code>"rb"</code>).
* Elle utilise <code>fseek</code> pour positionner le curseur de lecture dans le fichier à l'endroit approprié pour commencer la lecture du bloc spécifié (<code>num</code>) à partir de l'offset (<code>offset</code>).
* Elle utilise ensuite <code>fread</code> pour lire <code>size</code> octets à partir du fichier et les stocker dans le tableau <code>storage</code>.
* Enfin, elle ferme le fichier avec <code>fclose</code>.

Note : Le paramètre <code>offset</code> est utilisé pour spécifier à partir de quel octet du bloc on souhaite commencer la lecture. Si <code>offset</code> est égal à 0, la lecture commencera depuis le début du bloc. Si <code>offset</code> est différent de 0, la lecture commencera à l'octet spécifié.

Remarque: dans votre mail, vous définissez "readBlock(unsigned int num,int offset,unsigned storage,int size)": storage n'est alors pas un pointeur vers un tableau de caractère. Je me suis donc permis de faire la modification.

ReX : OK pour la fonction, pas la peine d'en mettre autant dans le Wiki pour une fonction aussi simple.

=== Fonction <code>writeBlock</code> ===
Cette fonction est utilisée pour écrire un bloc de données dans le fichier <code>filesystem.bin</code> à partir d'un tableau de caractères (<code>storage</code>).

Fonction:

// Fonction pour écrire un bloc de données
void writeBlock(unsigned int num, int offset, const unsigned char *storage, int size) {
FILE *file = fopen("filesystem.bin", "rb+");
if (file == NULL) {
perror("Erreur lors de l'ouverture du fichier");
return;
}
fseek(file, num * BLOCK_SIZE + offset, SEEK_SET);
fwrite(storage, 1, size, file);
fclose(file);
}

Paramètres :

* <code>num</code> : Numéro du bloc où écrire.
* <code>offset</code> : Décalage (en octets) à partir du début du bloc pour commencer l'écriture.
* <code>storage</code> : Pointeur vers un tableau de caractères contenant les données à écrire dans le fichier.
* <code>size</code> : Taille du tableau de caractères <code>storage</code>.

Fonctionnement :

* La fonction commence par ouvrir le fichier <code>filesystem.bin</code> en mode lecture et écriture binaire (<code>"rb+"</code>).
* Elle utilise <code>fseek</code> pour positionner le curseur de lecture/écriture dans le fichier à l'endroit approprié pour commencer l'écriture du bloc spécifié (<code>num</code>) à partir de l'offset (<code>offset</code>).
* Elle utilise ensuite <code>fwrite</code> pour écrire <code>size</code> octets à partir du tableau <code>storage</code> dans le fichier.
* Enfin, elle ferme le fichier avec <code>fclose</code>.

ReX : Même remarque que pour la fonction précédente.

'''Etape 4: test des fonctions <code>readBlock</code> et <code>writeBlock</code> dans le main'''
// Exemple de fonction principale pour tester les opérations de lecture et d'écriture
int main() {
unsigned char data[BLOCK_SIZE];
// Test de la fonction readBlock
readBlock(0, 0, data, BLOCK_SIZE);
printf("Block 0, offset 0: ");
for (int i = 0; i < BLOCK_SIZE; i++) {
printf("%02x ", data[i]);
}
printf("\n");
// Test de la fonction writeBlock
unsigned char newData[BLOCK_SIZE] = {
0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88,
// ... Autres données du bloc ...
};
writeBlock(1, 0, newData, BLOCK_SIZE);
// Lecture du bloc nouvellement écrit pour vérifier
readBlock(1, 0, data, BLOCK_SIZE);
printf("Block 1, offset 0: ");
for (int i = 0; i < BLOCK_SIZE; i++) {
printf("%02x ", data[i]);
}
printf("\n");
return 0;
}

Fonctionnement :

* On déclare tout d'abord un tableau de caractères <code>data</code> de taille <code>BLOCK_SIZE</code> pour stocker les données lues du bloc.
* Ensuite, la fonction <code>readBlock</code> est appelée avec les arguments (0, 0, data, BLOCK_SIZE) pour lire le premier bloc du fichier (<code>num=0</code>, <code>offset=0</code>) et stocker les données dans <code>data</code>.
* Ensuite, la fonction <code>printf</code> est utilisée pour afficher les données lues du bloc (<code>data</code>) en format hexadécimal.
* Ensuite, un nouveau tableau de caractères <code>newData</code> est créé avec des données spécifiques pour tester la fonction <code>writeBlock</code>.
* La fonction <code>writeBlock</code> est appelée avec les arguments (1, 0, newData, BLOCK_SIZE) pour écrire le tableau <code>newData</code> dans le deuxième bloc du fichier (<code>num=1</code>, <code>offset=0</code>).
* Enfin, la fonction <code>readBlock</code> est appelée à nouveau pour lire le deuxième bloc nouvellement écrit et afficher les données lues en format hexadécimal.

Question générale : ce que j'avais la première semaine n'est plus forcément d'actualité. Puis-je supprimer les choses qui ne le sont plus afin d'alléger la page ou préférez-vous que je laisse?

ReX : Laissez.

Pour la suite : j'ai donc pour l'instant crée deux fonctions, l'une permettant la lecture et l'autre l'écriture d'un bloc, de manière à économiser la mémoire. Pour la suite, je vais essayer de créer la fonction <code>LS</code> en utilisant la fonction <code>readBlock</code>.

ReX : Oui c'est le début du projet. Mais si vous n'avez pas une bonne description de fichier cela ne donnera rien. Voir remarques plus haut.

'''Etape 5: fonction <code>LS</code>'''

Objectif: créer la fonction <code>LS</code> avec la fonction readBlock.

Question: Souhaitez-vous la fonction <code>LS</code> classique, c'est à dire la fonction <code>LS</code> qui affiche simplement le nom des fichiers présent dans le répertoire ?

ReX : Oui. Tu peux ajouter la taille si tu trouves cela trop simple.

Piste : si c'est ce que vous voulez:

* il va tout d'abord falloir que je crée des fichiers, un fichier étant composé d'un nom et de blocs (création d'une fonction createFile)
* Il faudra ensuite que je stocke ces fichiers dans le répertoire (création d'une fonction addFileToDirectory par exemple)
* enfin, il faudra que j'affiche le nom des fichiers. Pour cela, il faudra que je parcours le répertoire (structure "Directory"), puis que pour chaque fichier présent dans le répertoire que j'affiche son nom (création de la fonction LS)

Je devrais surement utiliser la fonction readBlock afin de transférer les blocs dans le fichier au travers de la variable "storage".

ReX : Créer des fichiers n'est pas nécessaire tout de suite je verrais bien si ton code est bon sans test. Laisse tomber <code>createFile</code> et <code>addFileToDirectory</code> pour l'instant.

ReX : Ton algorithme ne fonctionne pas pour un microcontrôleur où il faut économiser la mémoire, tu ne peux pas t'aider de structures. Il faudra que tu charges les noms et seulement les noms, pour la taille il faudra se baser sur le nombre de blocs.

'''Etape 6: rectification du code suite à vos remarques'''

Modifications apportées:

* suppression des structures afin d’économiser de la mémoire.

* le problème quant à la description des fichiers est normalement résolu puisque plus de structures. On ne charge plus les blocs mais seulement les noms de fichiers.

ReX : Non car si les noms ne sont pas répartis de façon régulière dans les blocs de 256 octets tu vas avoir du mal à les charger. Mais écrit la fonction <code>LS</code> et tu verras ce que je veux dire.

J'ai également ajouté deux nouvelles fonctions:

# <code>void readFileName(unsigned int file_num, char *file_name)</code>: Cette fonction permet de lire le nom du fichier associé au numéro de fichier donné (<code>file_num</code>). Elle stocke le nom du fichier lu dans le tableau <code>file_name</code>.
# <code>void writeFileName(unsigned int file_num, const char *file_name)</code>: Cette fonction permet d'écrire le nom du fichier dans le système de fichiers, associé au numéro de fichier donné (<code>file_num</code>). Elle prend en entrée le nom du fichier à écrire (<code>file_name</code>).

Suite: si vous validez cette base, je pourrai passer à la création de la fonction LS.

ReX : tu peux y aller. Je ne vois pas le code des tes deux fonctions <code>readFileName</code> et <code>writeFileName</code>.

Voici le code des fonctions <code>readFileName</code> et <code>writeFileName</code> :

'''Fonction readFileName:'''
// Fonction pour lire le nom du fichier
void readFileName(unsigned int file_num, char *file_name) {
readBlock(file_num, 0, (unsigned char *)file_name, MAX_FILENAME_LENGTH);
file_name[MAX_FILENAME_LENGTH] = '\0'; // Ajout du caractère null-terminator pour former une chaîne de caractères
}

ReX : Non, aucune raison que le fichier de numéro n soit au bloc n. Dessine la représentation d'un fichier sur le SF en comptant les octets si cela peut aider.

'''Fonction writeFileName:'''
// Fonction pour écrire le nom du fichier
void writeFileName(unsigned int file_num, const char *file_name) {
writeBlock(file_num, 0, (const unsigned char *)file_name, MAX_FILENAME_LENGTH);
}

ReX : Faux et inutile pour l'instant. Problème avec la constante MAX_FILENAME_LENGTH.

=== Fonction LS version 1 ===
// Fonction LS pour afficher les fichiers présents dans le système de fichiers
void LS(const char *filesystem_path) {
FILE *file = fopen(filesystem_path, "rb");
if (file == NULL) {
perror("Erreur lors de l'ouverture du fichier système");
return;
}
uint16_t num_files;
fread(&num_files, sizeof(uint16_t), 1, file); // Lecture du nombre de fichiers dans le système
char filename[17];
printf("Fichiers présents dans le système de fichiers:\n");
for (int i = 0; i < num_files; i++) {
readFileName(i, filename); // Lecture du nom du fichier
printf("%s\n", filename); // Affichage du nom du fichier
}
fclose(file);
}
La fonction <code>LS</code> ouvre le fichier système, lit le nombre de fichiers qu'il contient, puis affiche les noms des fichiers un par un, chacun sur une ligne séparée.

ReX : Il y a le nombre de fichiers dans ton superbloc ? Un dessin du format du superbloc avec les numéros des octets ?

ReX : Tout accès au système de fichiers doit se faire avec les deux fonctions <code>readBlock</code> et <code>writeBlock</code>.

== Semaine 3 ==
Question 1: cela fait plusieurs fois que vous mentionnez dans le wiki un "superbloc". Celui-ci n'étant pas clairement défini dans le sujet, je me demande s'il s'agit du bloc crée grâce à la fonction dd, c'est à dire que le superbloc serait en faite le bloc constitué des 31250 blocs de taille 256 octets, où s'il s'agit d'un bloc qui vient en entête, celui contenant alors des informations décrivant le système de fichier (les noms de fichiers...).

ReX : Pour ton pico système de fichiers, le superbloc consiste en les premiers blocs (de 256 octets) qui définissent les 64 fichiers possibles.

Proposition de structure: on pourrait réserver les premiers blocs du système de fichiers aux noms de fichiers ainsi qu'aux numéros des blocs correspondant à chaque fichier.

ReX : Oui c'est évident.

On sait que les noms de fichiers font au maximum 16 caractères + 1 caractère pour le '\0' (donc 17 octets car 1 char=1 octet).

ReX : Non, 16 octets suffisent, des '\0' en fin de nom uniquement si le nom fait moins de 16 caractères.

On sait également qu'un fichier contient au maximum 2040 blocs, chaque bloc étant numéroté sur 2 octets. On pourrait donc avoir en début du système de fichier: 17 octets+2 octets*2040 blocs = 4097 octets pour la description d'un fichier.

ReX : Non, 4096 octets soit 16 blocs de 256.

Or d'après l'une de vos remarques dans le wiki, un fichier doit être décrit par un nombre entier de blocs. Pour un fichier, il nous faudra donc 4097/256=16.004 soit 17 blocs. Il peut y avoir jusqu'à 64 fichiers dans le répertoire, il nous faudra donc 17 blocs*64 fichiers= 1088 blocs pour la description des fichiers.

ReX : Non 1024 blocs de 256 octets dans le superbloc.

Ainsi, pour la fonction LS, il suffira de lire les premiers caractères tous les 17 blocs ( du premier caractère au caractère '\0').

ReX : Non, tous les 16 blocs.

Question 2: Ne faudrait-il pas également stocker quelque part le nombre de fichier qu'il y a dans le répertoire afin de savoir jusqu'à quel bloc la fonction LS doit aller ?

ReX : Non, un fichier dont le nom n'est constitué que de '\0' est réputé ne pas exister.

Question 3: on a donc vu que les 1088 premiers blocs au maximum serviraient à la description du système de fichier. Il reste donc 31250-1088=30132 blocs dans le système de fichier.

ReX : Non, 32768-1024=31744 blocs.

Comment utiliser ces blocs? Ces blocs doivent-ils stocker le contenu des fichiers ?

ReX : Oui, c'et évident.

En effet, avec la fonction TYPE, nous allons créer des fichiers et ces fichiers devront être stockés quelque part. Cependant, étant donné que ce pico système de fichiers est prévu pour un microcontrôleur, je ne sais pas si c'est le contenu des fichiers qui doit être stocké dans les blocs ou autre chose (peut être l'adresse des fichiers, le fichiers se trouvant autre part). En effet, je me dis que si un fichier est très volumineux, il ne pourra pas rentrer dans le système de fichier, ce dernier étant composé d'un nombre limité de blocs, et les blocs étant eux même limité en nombre d'octets.

ReX : Je ne comprend pas ton problème. De tout façon comme dit plus haut, les 31744 blocs suivant le superbloc doivent contenir les données des fichiers.

Désolé de poser des questions peut être basique aussi tard, mais je pense qu'une fois que j'aurai ces réponses, cela ira beaucoup mieux pour la suite. Merci d'avance pour vos réponses.

ReX : Les questions sont effectivement triviales et il est effectivement inquiétant que voir que la travail n'avance pas.

Amine: merci pour vos corrections.

D'après votre commentaire "32768-1024=31744 blocs", j'en déduis qu'il faut que je modifie ma commande dd (qui est actuellement "dd if=/dev/zero of=filesystem.bin bs=256 count=31250" pour avoir le bon filesystem).

ReX : Je comprends pas d'où tu sors le 31250. D'autant plus que la commande ci-dessous est bonne.

Amine : 31250 car 31250 blocs * 256 octets = 8 Mo.

ReX : Haaaa je vois tu utilises le système métrique international où le mégaoctet vaut 10^6 octets, sauf qu'aucun informaticien n'utilisera cette norme hors sol. Quand je parle de 8 Mo c'est 8x1024x1024 octets. Tout simplement parce qu'une puce mémoire de 8 Mo c'est bien 8x1024x1024 octets.

Amine: D'accord merci pour l'information !

'''Nouvelle commande dd:'''

dd if=/dev/zero of=filesystem.bin bs=256 count=32768

=== Fonction LS version 2 ===

Dans notre structure du système de fichier, le superbloc est constitué de 1024 blocs (16 blocs * 64 fichiers), un fichier étant décrit par 16 blocs. Le nom du fichier est donc écrit au début de tous les blocs multiples de 16. Par exemple, le nom du premier fichier est dans les 16 premiers octets du premier bloc, le nom du 2ème fichier est dans les 16 premiers octets du 32ème bloc et ainsi de suite, tant que des fichiers existent. Lorsque qu'il n'y a plus de fichier, le nom du premier caractère du bloc multiple de 16 est un 0.

Voici le code:
// Fonction pour lister les noms de fichiers présents dans le système de fichiers
void LS() {
unsigned char buffer[BLOCK_SIZE];
int fileCount = 0;

for (int blockNum = 1; blockNum <= MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, BLOCK_SIZE);

// Vérifier si le bloc est vide
if (buffer[0] == 0) {
break; // Plus de fichiers à lire
}

char filename[MAX_FILENAME_LENGTH];
memcpy(filename, buffer, MAX_FILENAME_LENGTH);

// Afficher le nom du fichier
printf("%s\n", filename);
fileCount++;
}

if (fileCount == 0) {
printf("Aucun fichier trouvé.\n");
}
}

ReX : Tu supposes que si un fichier a un nom vide, les suivants auront aussi un nom vide. C'est possible mais dans ce cas la commande <code>RM</code> ca être plus compliquée à écrire.

ReX : Tu ne sembles pas comprendre que la mémoire d'un microcontrôleur est limitée. Pourquoi lire le premier bloc de description d'un fichier en entier ? Dit autrement c'est quoi l'intérêt de lire 256 octets alors que 16 suffisent ?

ReX : Pourquoi tu ne lis pas le premier fichier ? Autrement dit pourquoi décaler tout d'un bloc ?

Amine: Merci pour vos remarques. J'ai apporté les modifications à LS dans la section "Semaine 4" du wiki.

'''Réflexion par rapport aux autres fonctions:'''

J'ai créé les fonctions TYPE et CAT mais il y a malheureusement un problème pour l'instant. Vous pouvez les retrouver en pièce jointe dans l'archive du fichier programme.c.

Le problème que j'ai est que lorsque j'affiche le contenu du fichier créé avec TYPE, j'obtiens plein de caractères spéciaux. Par exemple, je créé le fichier "mon_fichier.txt" avec la fonction TYPE, et je mets en entré standard "hello". Ensuite, je veux afficher le contenu de ce fichier grâce à la fonction CAT. Cependant, ce qui s'affiche dans le terminal n'est pas ce que je veux. De la même manière, lorsque je fais la commande "cat filesystem.bin" dans le terminal, c'est la même chose s'affiche, des donnés parasites.

ReX : Avant même de lire ton code je vais te poser la question de savoir comment tu récupères un bloc libre ? Quel algorithme tu utilises. Personnellement je ne sais pas faire sans ajouter au superbloc un tableau bit à bit des blocs libres. Pour avoir un bit pour chaque bloc du système de fichiers, il faut 32768/8=4096 octets soit 16 blocs.

Amine: ok je vais donc ajouter ce tableau de 16 blocs à la suite de mes premiers 1024 blocs servant à la description de fichier. Le superbloc fera maintenant 1024+16=1040 blocs (plus de détail à la fonction RM de la semaine 4).

Question 1: est ce que la fonction CAT que je dois créer doit renvoyer la même chose que "cat filesystem.bin" ?

ReX : Je préfère ne pas répondre tellement la question montre un manque de réflexion.

Question 2: comment savoir combien de blocs doivent etre attribué à un fichier? Par exemple, si je créé un fichier "mon_fichier.txt" et que je mets en entrée standard le texte "hello", un seul bloc suffi pour stocker ce texte. Cependant, si j'avais mis beaucoup de texte en entrée standard, il aurait fallu plus de blocs. Doit-on calculer la taille de l'entrée standard ou doit-on attribuer toujours le meme nombre de blocs à un fichier? Peut-etre ainsi attribuer 2040 blocs par fichier, meme s'il n'en utilise que 1.

ReX : Là encore c'est une question stupéfiante tellement la réponse est évidente. Il suffit de lire les données sur l'entrée standard et de passer au bloc de données suivant dès que le bloc courant est rempli. La question à poser c'était de se demander comment il est possible d'avoir la taille exacte du fichier pour un <code>CAT</code>. Il est uniquement possible de l'avoir à 256 octets près puisque rien n'indique si le dernier block est vide. Le mieux aurait été de prévoir 4 octets dans la description d'un fichier pour stocker la taille. En l'espèce on considérera que les fichiers sont des fichiers ASCII et qu'ils seront terminés par des <code>\'0</code> qui ne seront pas affichés.

== Semaine 4 ==

Voici un bilan de ce que j'ai fait à ce stade du projet:

* j'ai choisi une structure du système de fichier
* j'ai créé les fonctions readBlock et writeBlock permettant de lire et d'écrire des blocs
* j'ai crée la fonction LS permettant d'afficher le nom des fichiers présents dans le système de fichiers
* j'ai programmer un main permettant d'utiliser les fonctions (LS, TYPE...) depuis le terminal
* j'ai réflechi aux fonctions TYPE et CAT.

Actuellement, je suis en train de créer les fonctions TYPE et CAT.

=== Fonction LS version 3 ===
void LS() {
unsigned char buffer[MAX_FILENAME_LENGTH];
int fileCount = 0;

// Parcourir tous les 16 blocs de 0 jusqu'à MAX_FILES_IN_DIRECTORY
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, MAX_FILENAME_LENGTH);

// Vérifier si le nom de fichier est vide
if (buffer[0] != 0) {

// Afficher le nom du fichier
printf("%s\n", buffer);
fileCount++;
}
}

if (fileCount == 0) {
printf("Aucun fichier trouvé.\n");
}
}
Suite à vos remarques, j'ai effectué les modifications suivantes de la fonction LS:

* Je ne suppose plus que si un fichier a un nom vide, les autres auront aussi un nom vide.
* Je ne lis plus les 256 octets mais seulement les 16 premiers octets car cela suffit.
* Je ne lisais en effet pas le premier bloc. Je pensais que le premier bloc était d'indice 1 mais ce n'est pas le cas.

ReX : Ouiiii ! Une fonction correcte. Passe à <code>RM</code> maintenant, c'est la plus facile à faire concernant l'image bit à bit des blocs libres.

=== Fonction setBlockAvailability version 1 ===

Comme vous l'avez indiqué dans votre remarque, il faut un tableau dans le superbloc qui nous permettra de connaitre la disponibilité bit par bit de chaque bloc. Sachant qu'il y a dans notre système de fichiers 32768 blocs, et qu'il faut 1 bit par bloc, nous avons besoin de 32768 bits, soit 32768/8=4096 octets soit 4096/256=16 blocs. Notre superbloc sera donc comme suit: les 1024 premiers blocs servent à la description des fichiers, c'est à dire à leur nom suivi des numéros de blocs qui leur sont associés, puis ces 1024 blocs sont suivi de 16 blocs listant la disponibilité de chaque bloc.

ReX : Bien résumé.

Nous allons tout d'abord écrire la fonction "setBlockAvailability" prenant en paramètre le numéro du bloc à traiter (<code>blockNum</code>) et la disponibilité souhaitée pour ce bloc (<code>availability</code>). Cette fonction permet de marquer la disponibilité d'un bloc spécifique dans le système de fichiers. Nous utiliserons la convention suivante: un bloc disponible sera marqué par un 1 tandis qu'un bloc non disponible par un 0.
#define SUPERBLOCK_START_BLOCK 1024

void setBlockAvailability(int blockNum, int availability) {
// Calculer l'index du byte et le bit offset correspondant
int byteIndex = blockNum / 8;
int bitOffset = blockNum % 8;

// Lire le byte existant du bloc de disponibilité des blocs
unsigned char buffer[1];
readBlock(SUPERBLOCK_START_BLOCK + byteIndex, 0, buffer, 1);

// Mettre à jour le bit d'offset correspondant
if (availability) {
buffer[0] |= (1 << bitOffset);
} else {
buffer[0] &= ~(1 << bitOffset);
}

// Écrire le byte mis à jour dans le bloc de disponibilité des blocs
writeBlock(SUPERBLOCK_START_BLOCK + byteIndex, 0, buffer, 1);
}

ReX : Un tableau de un octet c'est un octet (variable <code>buffer</code>).

Amine: je vais utiliser un <code>unsigned char buffer.</code> Je suis conscient qu'un char vaut un octet mais je ne pense pas qu'il y ait un type de donnée de la taille d'un bit, c'est pourquoi je travaille avec un octet mais je modifie les bits de cet octet grâce aux algorithmes.

ReX : Il faut bien que tu travailles sur un octet vu que l'état des blocs est stocké sous la forme d'octets. Je disais juste qu'un tableau de 1 élément n'a pas d'intérêt par rapport à l'élément lui-même.

Amine: c'est vrai, modification faite.

ReX : Non il faut calculer le numéro du bloc avant de faire le <code>readBlock</code>.

Amine: ok je vais calculer le numéro de bloc avant.

ReX : La mise à jour du bit est correcte mais le block et le déplacement dans le block ne sont pas correctement calculés.

Amine: je vais vous expliquer le raisonnement que j'avais. Prenons un exemple concret, imaginons que je veuille marquer le bloc 1030 comme disponible:

# Calcul de l'index de l'octet et du bit offset :
#* <code>blockNum</code> = 1030
#* Index du byte = 1030 / 8 = 128
#* Bit offset = 1030 % 8 = 6
# Lecture de l'octet existant de disponibilité:
#* Nous lisons l'octet existant à l'index 128 dans les blocs de disponibilité.
# Mise à jour du bit de disponibilité :
#* Nous voulons marquer le bloc 1030 comme disponible, donc nous utilisons le masque <code>(1 << 6)</code> pour définir le bit 6 à 1 dans l'octet. Le résultat sera, par exemple, <code>00100000</code>.
# Écriture du byte mis à jour :
#* Nous écrivons le byte mis à jour <code>00100000</code> à l'index 128 dans les blocs de disponibilité.

ReX : Ben non, un vrai exemple :
* Il faut prendre un n° de bloc plus grand : 3072 ;
* Numéro d'octet dans la carte des blocs libres : 3072/8=384 ;
* Numéro du bloc dans la carte des blocs libres : 384/256=1 ;
* Numéro du bit <code>b</code> dans l'octet n° 384-256=128 du bloc 1 : 3072%8=0 ;
* Il faut donc lire l'octet <code>o</code> de numéro 128 du bloc 1, puis modifier cet octet par <code>o |= (1<<b)</code> ou <code>o &= ~(1<<b)</code> ;
* Enfin il faut écrire l'octet modifié dans le bloc 1.
Amine: merci pour cet exemple! J'ai compris d'où vient mon erreur. Voir fonction setBlockAvailability version 3.

Remarque: par convention, j'apellerai dans la suite de ce projet "premier superbloc" le superbloc correspondant à la description des fichiers, c'est à dire les 1024 premiers blocs, et j'appellerai "second superbloc" les 16 blocs qui suivent servant à décrire la disponibilité des blocs (du bloc 1024 au bloc 1039 inclu). Le reste des blocs servira à stocker les données.

ReX : Non, le superblc est l'ensemble des informations hors blocs de données, tu ne peux pas utiliser un vocabulaire au hasard. Parle de blocs de description des fichiers ou de carte des blocs libres.

Amine: ok

Je pense que le problème qui se pose est que l'indice du bit dans le second superbloc ne correspond pas à l'indice du bloc dans le système de fichier. Par exemple, nous voudrions que si le bloc 1030 est disponible dans le système de fichier, alors le bit numéro 1030 du deuxième superbloc soit à 1, ce qui n'est pas le cas ici. En effet, on se trouve bien dans le bon octet avec ma méthode mais l'écriture du bit se fait de la droite vers la gauche alors qu'on voudrait l'inverse. Ainsi, si le 6ème bit de l'octet doit être à 1, alors il faudrait qu'on obtienne <code>00000100</code> et non <code>00100000.</code> L'indice du bit coinciderait ainsi avec le numéro du bloc.

ReX : Non, réfléchit à nouveau.

Voir plus bas la nouvelle version de setBlockAvailability.

Explication de l'algorithme pour mettre le bit à 1 ou 0:

* <code>buffer[0] |= (1 << bitOffset);</code> : Cette ligne utilise l'opérateur OR bit à bit (<code>|=</code>) pour activer (mettre à 1) le bit spécifié par <code>bitOffset</code> dans le premier octet (<code>buffer[0]</code>). Cela se fait en décalant le bit 1 vers la gauche de <code>bitOffset</code> positions, puis en effectuant une opération OR bit à bit avec le contenu actuel de <code>buffer[0]</code>. Cette opération modifie uniquement le bit ciblé, laissant les autres bits inchangés.

ReX : Oui ça c'est bon.

* <code>buffer[0] &= ~(1 << bitOffset);</code> : Cette ligne utilise l'opérateur AND bit à bit (<code>&=</code>) pour désactiver (mettre à 0) le bit spécifié par <code>bitOffset</code> dans <code>buffer[0]</code>. Pour ce faire, l'expression <code>~(1 << bitOffset)</code> est utilisée pour créer un masque où tous les bits sont à 1, sauf celui correspondant à <code>bitOffset</code>, qui est à 0. En effectuant ensuite une opération AND bit à bit entre le masque et le contenu actuel de <code>buffer[0]</code>, on met à 0 le bit ciblé sans affecter les autres bits.

ReX : Ca aussi.

=== Fonction setBlockAvailability version 2 ===

void setBlockAvailability(int blockNum, int availability) {
// Calculer l'indice de l'octet et le bit offset correspondant
int byteIndex = blockNum / 8;
int bitOffset = 7 - (blockNum % 8); // Inversion de l'ordre des bits

// Calculer le numéro du bloc du super bloc où se trouve l'octet de disponibilité correspondant
int availabilityBlockNum = SUPERBLOCK_START_BLOCK + byteIndex;

// Lire l'octet existant dans le bloc de disponibilité du super bloc
unsigned char buffer;
readBlock(availabilityBlockNum, 0, &buffer, 1);

// Mettre à jour le bit d'offset correspondant :
if (availability) {
buffer |= (1 << bitOffset);
} else {
buffer &= ~(1 << bitOffset);
}

// Écrire l'octet mis à jour dans le bloc de disponibilité du super bloc
writeBlock(availabilityBlockNum, 0, &buffer, 1);
}
J'ai modifié la ligne <code>int bitOffset = 7 - (blockNum % 8);</code> pour inverser l'ordre des bits sélectionnés, de sorte que le bit correspondant au bloc disponible soit correct.

ReX : Encore plus faux.

Si on veut rendre le bloc 1030 indisponible alors que les autres blocs sont disponibles:

ReX : Pardon ? Le bloc de données est libre ou pas suivant la carte des blocs libres. Le rendre disponible n'est possible que si un fichier le comportant est détruit.

# Calcul de l'indice de l'octet et du bit offset correspondant :
#* <code>blockNum = 1030</code>
#* <code>byteIndex = 1030 / 8 = 128</code>
#* <code>bitOffset = 7 - 1030 % 8 = 1</code> Cela signifie que le bit d'intérêt se trouve à la position 2 dans l'octet.
# Calcul du numéro du bloc du super bloc où se trouve l'octet de disponibilité correspondant :
#* <code>availabilityBlockNum = SUPERBLOCK_START_BLOCK + 128 = 1024 + 128 = 1152</code> Donc, nous devons accéder à l'octet 1152 pour mettre à jour la disponibilité du bloc 1030.
# Lecture de l'octet existant dans le bloc de disponibilité du super bloc :
#* Le contenu de l'octet dans le bloc 1152 avant la mise à jour : 11111111 (en binaire)
# Mise à jour du bit d'offset correspondant :
#* Supposons que nous voulions marquer le bloc 1030 comme non disponible (<code>availability = 0</code>).
#* Le bitOffset est 1.
#* Nous effectuons une opération AND avec le complément du bit à la position 1 : <code>11111111 & 11111101 = 11111101</code>
# Écriture de l'octet mis à jour dans le bloc de disponibilité du super bloc :
#* Le contenu de l'octet 128 du second superbloc après la mise à jour : 11111101 (en binaire)

ReX : Toujours aussi faux.

Maintenant, le bit d'indice 1 du 128 ème octet du second superbloc est mis à 0, indiquant que le bloc 1030 n'est plus disponible. Les autres bits restent inchangés car nous avons effectué un AND avec un masque binaire qui avait des 1 partout sauf à la position du bit que nous souhaitions mettre à 0.

ReX : Erreur sur erreur.

=== Fonction setBlockAvailability version 3 ===
J'ai compris d'où vient l'erreur. La fonction readBlock prends en premier paramètre le numéro du bloc à lire, je ne peux donc pas lui donner la valeur "SUPERBLOCK_START_BLOCK + byteIndex" car byteIndex s'exprime en octet alors qu'on s'attend à un nombre de bloc ici. Il faut donc divisé byteIndex par 256 pour être en unité "bloc", et préciser le bit qu'on veut lire grâce à l'offset.

Pour obtenir l'octet que l'on veut, il faut prendre le reste de la division de byteIndex par 256. On va ensuite stocker cet octet dans notre "buffer".

Pour savoir quel bit modifier dans ce "buffer", on va prendre le reste de la division du bloc dont on veut mettre à jour la disponibilité par 8. On va ainsi pouvoir modifier ce bit grâce à l'algorithme, puis réécrire l'octet à son emplacement d'origine.

Cette fonction gère la carte de disponibilités des blocs. Si un bloc est disponible, alors elle le met un 0, si il est indisponible, elle met un 1.
#define SUPERBLOCK_START_BLOCK 1024

void setBlockAvailability(int blockNum, int availability) {

int byteIndexInCard = blockNum / 8; //Numéro d'octet dans la carte des blocs libres
int blockIndexInCard = byteIndexInCard / 256; //Numéro du bloc dans la carte des blocs libres
int byteIndexInBlock = byteIndexInCard % 256; //Numéro d'octet dans le bloc contenant le bit de disponibilité
int bitOffset = blockNum % 8; //Numéro du bit dans l'octet n°byteIndexInBlock du bloc blockIndexInCard

//indice du bloc contenant le bit à mettre à jour dans le bloc de description
int availabilityBlockNum = FIRST_DISPONIBILITY_CARD_BLOCK + blockIndexInCard;

// Lire l'octet existant dans le bloc de disponibilité du super bloc
unsigned char buffer;
readBlock(availabilityBlockNum, byteIndexInBlock, &buffer, 1);

// Mettre à jour le bit d'offset correspondant :
if (availability==1) { // indisponible
buffer |= (1 << bitOffset); // Mettre le bit à 1

} else { // disponible
buffer &= ~(1 << bitOffset); // Mettre le bit à 0
}

// Écrire l'octet mis à jour dans le bloc de disponibilité du super bloc
writeBlock(availabilityBlockNum, byteIndexInBlock, &buffer, 1);
}

ReX : Ben voila, c'est pas possible de te taxer d'excès de vitesse mais c'est bon.

update: j'ai fait une petite modification, maintenant un bloc disponible est marqué d'un 0 et un bloc indisponible est marqué d'un 1. C'est mieux dans la mesure où initialement, tous les blocs sont disponibles et tous les blocs sont à 0. Cela évite de devoir créer une fonction qui initialise toute la carte de disponibilités à 1 pour dire que tous les blocs sont disponibles.

=== Fonction RM version 1 ===

void RM(const char *filesystem_path, const char *filename) {
unsigned char buffer[BLOCK_SIZE];
int fileNum = -1;

// Parcourir les blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (memcmp(filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {
// Effacer le nom du fichier dans le superbloc
memset(filenameBuffer, 0, MAX_FILENAME_LENGTH);
writeBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

unsigned char fileBuffer[MAX_BLOCKS_PER_FILE * 2];
readBlock(blockNum, MAX_FILENAME_LENGTH, fileBuffer, MAX_BLOCKS_PER_FILE * 2);

// Libérer les blocs associés au fichier et réinitialiser les numéros de blocs
for (int i = 0; i < MAX_BLOCKS_PER_FILE * 2; i += 2) {
int blockNum = ((int)fileBuffer[i] << 8) + (int)fileBuffer[i + 1];
if (blockNum == 0) {
break; // Fin du fichier
}
setBlockAvailability(blockNum, 0); // Marquer le bloc comme disponible
fileBuffer[i] = 0;
fileBuffer[i + 1] = 0;
}

// Mettre à jour les numéros de blocs associés au fichier
writeBlock(blockNum, MAX_FILENAME_LENGTH, fileBuffer, MAX_BLOCKS_PER_FILE * 2);

fileNum = blockNum;
break; // Fichier trouvé, sortir de la boucle
}
}

// Afficher le résultat de l'opération
if (fileNum == -1) {
printf("Le fichier \"%s\" n'a pas été trouvé.\n", filename);
} else {
printf("Le fichier \"%s\" a été supprimé avec succès.\n", filename);
}
}

ReX : Vous utilisez <code>strcmp</code> comme <code>strncmp</code>. C'est bien la dernière qu'il faut utiliser mais en précisant la longueur du nom en paramètre, pas la taille maximale.

Amine: vous voulez dire que j'utilise memcmp au lieu de strncmp ? Ok je vais utiliser strncmp, c'est vrai que c'est plus adapté pour la comparaison de chaines de caractère.

ReX : Ha oui c'est <code>memcmp</code> que tu utilises. Ca ne peut effectivement pas marcher. Effectivement avec <code>strncmp</code> cela peut marcher vu qu'il s'arrête au premier 0 contrairement à <code>memcmp</code>.

Cependant, pourquoi doit-on passer la taille exacte du nom du fichier en paramètre, et non la taille maximale d'un nom de fichier? En effet, cela semble fonctionner en mettant la taille maximale en paramètre, tandis que lorsque l'on met la taille exacte du nom du fichier, cela pose un problème: on ne compare plus toute la chaîne de caractère mais seulement une portion du nom complet. Ainsi, si je crée par exemple un fichier que j'appelle "file1", puis que j’exécute la fonction RM "/picofs filesystem.bin RM file" par exemple, alors le fichier file1 va être supprimé quand même car on ne comparera que strlen(file)=4 premiers caractères, qui sont les mêmes, donc la fonction considérera ces chaines comme identiques. On pourrait alors se dire qu'il faudrait alors prendre plutôt comme taille en paramètre de la fonction strlen la taille du nom du fichier se trouvant dans le système de fichier plutôt que celle du nom donné en paramètre de RM. Cependant, le même problème se pose si la taille du nom du fichier du système de fichier est plus petite que celle du nom du fichier passé en paramètre. Par exemple, si le fichier présent dans système de fichier est "file", et qu'on met la longueur de file en paramètre de la fonction strcmp, puis qu'on exécute la commande "/picofs filesystem.bin RM file5", alors file sera quand même supprimé, car on ne comparera que les strlen(file)=4 premiers caractère. Finalement, une solution serait de rajouter une condition qui vérifie que les deux chaînes sont de taille identiques pour pouvoir réaliser la comparaison sur la taille exacte du nom du fichier. Cependant, il me semble qu'en mettant MAX_FILENAME_LENGTH qui vaut 16 en paramètre, cela fonctionne directement. Vous pouvez tester cela en testant mon programme.

ReX : Ok pour <code>strncmp</code> avec la taille maximale d'un nom de fichier.

etape 1: créer un fichier :
./picofs filesystem.bin TYPE fichier.txt

etape 2: verifier que le fichier a bien été créé :
./picofs filesystem.bin LS

Le terminal renvoie bien "fichier.txt"

etape 3: essayer de supprimer le fichier en mettant une chaine troncature du nom du fichier créé :
./picofs filesystem.bin RM fich

le terminal renvoi <<Le fichier "fich" n'a pas été trouvé.>>, le fichier n'a donc pas été supprimé .

etape 4: essayer de supprimer le fichier en mettant un nom plus grand incluant "fichier.txt" :
./picofs filesystem.bin RM fichier.txtt

terminal renvoi <<Le fichier "fichier.txtt" n'a pas été trouvé.>>

etape 5: enfin, tester en mettant le nom exacte du fichier que l'on veut supprimer :
./picofs filesystem.bin RM fichier.txt

terminal renvoi <<Le fichier "fichier.txt" a été supprimé avec succès.>>

Finalement, on voit que cela fonctionne avec la taille maximale mise en paramètre. On pourrait reprocher à cette méthode de comparer des caractères dans le vide, ce qui n'est pas optimal dans une optique d'économie de mémoire qui est la notre, mais la taille maximale d'un nom de fichier étant relativement faible (16 octets), on peut peut-être négliger cela au vu de l'économie d'une opération supplémentaire (comparaison de la taille des chaines de caractères).

ReX : Le parcours des blocs de données du fichier est atroce. Il faut parcourir les numéros de blocs dans le premier bloc du fichier derrière le nom du fichier puis il faut parcourir le 15 autres blocs.

Amine: Ok, je vais corriger cela dans la version 2 de RM (voir semaine 5).

Fonctionnement de la fonction RM:

* Parcours des blocs réservés pour la description des fichiers (superbloc) à partir du bloc 0, en incrémentant de 16 à chaque itération pour accéder aux blocs de noms de fichiers.

ReX : OK.

* Dans chaque bloc de noms de fichiers, la fonction compare le nom de fichier recherché avec les noms stockés dans les 16 octets de chaque bloc.

ReX : Non la fonction ne fait pas ça par contre il faudrait, oui.

Amine: Je pensais que c'était ce que je faisais avec "memcmp(filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0)".

* Si le nom de fichier est trouvé, la fonction efface le nom du fichier dans le superbloc en remplaçant les 16 octets du bloc par des zéros.

ReX : OK.

* Ensuite, la fonction accède aux octets suivants du même bloc pour obtenir les numéros de blocs associés au fichier.

ReX : Non, la boucle sort largement du premier bloc.

* Pour chaque paire de numéros de blocs (2 octets chacun), la fonction convertit les octets en un numéro de bloc. Si le numéro de bloc est nul, cela signifie la fin des blocs associés au fichier, sinon, la fonction marque ce bloc comme disponible en utilisant la fonction <code>setBlockAvailability</code> et réinitialise les numéros de blocs dans le tableau à zéro.
* Les numéros de blocs réinitialisés sont ensuite réécrits dans le bloc de description du fichier.

ReX : L'idée est là mais vu que la boucle n'est pas bonne, rien ne peut marcher.

* La fonction affiche ensuite un message indiquant le résultat de l'opération : soit que le fichier a été supprimé avec succès, soit que le fichier n'a pas été trouvé.

== Semaine 5 ==

=== Fonction RM version 2 ===

Concernant les remarques que vous m'avez faites précédemment:

* j'utilise maintenant la fonction <code>strncmp</code> pour la comparaison des chaines de caractères
* j'ai normalement corrigé le parcours des blocs. Je parcours maintenant d'abord les blocs multiples de 16 à la recherche du bloc contenant le nom du fichier à supprimer. Puis je parcours les 16 blocs de description du fichier à supprimer, afin de récupérer les numéros de blocs, libérer ces blocs dans la carte de disponibilité et de réinitialiser ces blocs dans les blocs de données.

void RM(const char *filesystem_path, const char *filename) {
int fileFound = -1;
int offset;

// Parcourir les blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char*)filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {

// Effacer le nom du fichier dans le superbloc
memset(filenameBuffer, 0, MAX_FILENAME_LENGTH);
writeBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);
fileFound = 1;
offset = blockNum;
break;
}

}

// Fin de fonction si fichier inexistant
if (fileFound == -1) {
printf("Le fichier \"%s\" n'a pas été trouvé.\n", filename);
return;
}

unsigned char buffer[BLOCK_SIZE];
//bloc que l'on va remplir de 0 et mettre à la place des blocs de données
memset(buffer, 0, BLOCK_SIZE); //on rempli buffer de 0

for (int blockNum=offset; blockNum<offset + 16; blockNum++) {

//premier bloc de description, celui contenant le nom du fichier dans les 16 premiers octets
if (blockNum == offset) {

unsigned char fileBuffer[BLOCK_SIZE-MAX_FILENAME_LENGTH];
//bloc dans lequel on va stocker les blocs de description de fichier
readBlock(blockNum, MAX_FILENAME_LENGTH, fileBuffer, BLOCK_SIZE-MAX_FILENAME_LENGTH);

// Libérer les blocs associés au fichier dans la carte de disponibilités
// et dans les blocs de description
for (int i = MAX_FILENAME_LENGTH; i < BLOCK_SIZE-MAX_FILENAME_LENGTH; i += 2) {
int blockNumData = ((int)fileBuffer[i] << 8) + (int)fileBuffer[i + 1];
if (blockNumData == 0) {
break; // Fin du fichier
}
setBlockAvailability(blockNumData, 0); // Marquer le bloc comme disponible
fileBuffer[i] = 0;
fileBuffer[i + 1] = 0;
writeBlock(blockNumData, 0, buffer, BLOCK_SIZE); //on efface les blocs de données
}
writeBlock(blockNum, MAX_FILENAME_LENGTH, fileBuffer, BLOCK_SIZE-MAX_FILENAME_LENGTH);
//on efface le premier bloc de description

} else {
unsigned char fileBuffer[BLOCK_SIZE];
readBlock(blockNum, 0, fileBuffer, BLOCK_SIZE);

// Libérer les blocs associés au fichier dans la carte de disponibilités et dans les blocs de description
for (int i = 0; i < BLOCK_SIZE; i += 2) {
int blockNumData = ((int)fileBuffer[i] << 8) + (int)fileBuffer[i + 1];
if (blockNumData == 0) {
break; // Fin du fichier
}
setBlockAvailability(blockNumData, 0); // Marquer le bloc comme disponible
fileBuffer[i] = 0;
fileBuffer[i + 1] = 0;
writeBlock(blockNumData, 0, buffer, BLOCK_SIZE); //on efface les blocs de données
}
writeBlock(blockNum, 0, fileBuffer, BLOCK_SIZE); //on efface le bloc de description
}
}
printf("Le fichier \"%s\" a été supprimé avec succès.\n", filename);
}

ReX : Pour construire le nombre sur 16 bits utiliser le OU plutôt que l'addition.

ReX : Heu non, je ne lis pas cette fonction avec tout ce code dupliqué, la seule différence entre les deux alternative est la position de début de l'adresse du premier bloc de données (<code>MAX_FILENAME_LENGTH</code> dans un cas et 0 dans l'autre). Donc l'alternative ne doit servir qu'à initialiser ce début, le reste du code doit être factorisé.

ReX : Et corrige le code, tu utilises deux tableaux de blocs (perte mémoire), tu écris le bloc à zéro dans l'itération (perte CPU).

=== Fonction RM version 3 ===

Suite à vos remarques, j'ai réalisé les modifications suivantes:

* j'utilise maintenant le OU plutôt que l'addition pour construire le nombre sur 16 bits.

* j'ai factorisé le code grâce à la création de la variable <code>startOffset</code> valant 16 lorsqu'on se trouve dans le bloc contenant le nom du fichier et valant 0 lorsqu'on se trouve dans les autres.

* Pour ce qui est du fait que j'utilise 2 tableaux de blocs, j'ai du mal à voir comment faire avec 1 seul tableau de blocs car ces deux tableaux n'ont pas du tout le même rôle. Le tableau <code>fileBuffer</code> permet de stocker les 16 blocs de description d'un fichier un à un. Lorsqu'on stocke un bloc dans <code>fileBuffer</code>, on lit ensuite les octets un à un de ce bloc afin de former des numéros de blocs, et pour chaque numéro de bloc créé, on va réinitialiser le bloc correspondant dans les blocs de données. Pour cela, on a donc besoin d'un autre bloc qui viendra écraser les anciens blocs de données. C'est pourquoi j'ai créé un bloc <code>buffer</code>qui est composé de 0 et qui va écraser les blocs de données. On ne peut pas utiliser <code>fileBuffer</code> car on a besoin d'un bloc de zéros, et si on réinitialise <code>fileBuffer</code> on perd toute les données qui s'y trouvent. Une possibilité serait de relire le bloc de donné à chaque itération de la deuxième boucle for imbriquée; cela permettrait de pouvoir réinitialiser le tableau fileBuffer à chaque itérations de cette boucle afin de stocker ce bloc de 0 dans les blocs de données, puis de restocker dans ce même tableau le bloc de description. Cependant, je ne pense pas que ce soit optimal de faire autant appel à la fonction readBlock.

* j'ai créé une fonction resetBock qui permet comme son nom l'indique de reset un bloc en le remplissant de 0. Cela nous évite de créer deux tableaux de blocs dans RM, bien que je pense que cela revienne au même car on fait appel à une fonction qui créé un tableau de blocs. Quoi qu'il en soit, cela allège le code et cette fonction pourra surement me resservir par la suite.

void RM(const char *filesystem_path, const char *filename) {
int fileFound = -1;
int offset;
unsigned char fileBuffer[BLOCK_SIZE];

// Parcourir les blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char *)filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {
// Effacer le nom du fichier dans le superbloc
memset(filenameBuffer, 0, MAX_FILENAME_LENGTH);
writeBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);
fileFound = 1;
offset = blockNum;
break;
}
}

// Fin de fonction si fichier inexistant
if (fileFound == -1) {
printf("Le fichier \"%s\" n'a pas été trouvé.\n", filename);
return;
}

for (int blockNum = offset; blockNum < offset + 16; blockNum++) {
int startOffset = 0;
if (blockNum == offset) {
startOffset = MAX_FILENAME_LENGTH;
}
readBlock(blockNum, startOffset, fileBuffer, BLOCK_SIZE - startOffset);

// Libérer les blocs associés au fichier dans la carte de disponibilités et dans les blocs de description
for (int i = 0; i < BLOCK_SIZE - startOffset; i += 2) {
int blockNumData = (fileBuffer[i] << 8) | fileBuffer[i + 1];
if (blockNumData == 0) {
break; // Fin du fichier
}
setBlockAvailability(blockNumData, 0); // Marquer le bloc comme disponible
fileBuffer[i] = 0;
fileBuffer[i + 1] = 0;
resetBlock(blockNumData); //on efface les blocs de données
}
writeBlock(blockNum, startOffset, fileBuffer, BLOCK_SIZE - startOffset);
}
printf("Le fichier \"%s\" a été supprimé avec succès.\n", filename);
}
'''Fonction resetBlock'''
void resetBlock(unsigned int blockNum) {
unsigned char buffer[BLOCK_SIZE];
memset(buffer, 0, BLOCK_SIZE);

// Utiliser writeBlock pour écrire les données du buffer dans le bloc
writeBlock(blockNum, 0, buffer, BLOCK_SIZE);
}

ReX : Ca s'améliore. Mais pourquoi cette fonction <code>resetBlock</code> ? Tu crois que dans qu'un système de fichiers perd du temps à mettre à zéro les blocs de données libérés ? Si oui, regarde la page de manual de la commande <code>shred</code>, ça manque à ta culture.

Amine: Après avoir consulter le manual de la commande <code>shred</code>, je vois que cette commande écrit des données aléatoires sur l'emplacement du fichier sur le disque. Par défaut, <code>shred</code> effectue un certain nombre de passes (par exemple, 3 passes) pendant lesquelles il écrit des données aléatoires sur l'emplacement du fichier sur le disque. Après avoir écrit les données aléatoires, <code>shred</code> peut effectuer des passes supplémentaires pendant lesquelles il écrit des données nulles (des zéros) sur le même emplacement. L'objectif de <code>shred</code> est d'augmenter la sécurité en rendant plus difficile la récupération des données supprimées à l'aide d'outils de récupération de données.

Cependant, j'ai aussi consulté comment fonctionne la commande <code>rm</code> de linux, et je vois que cette commande libère l'espace occupé par le fichier en marquant les blocs associés comme disponibles. Cela signifie que les données peuvent encore être récupérées à l'aide d'outils de récupération de données, à moins que des mesures supplémentaires ne soient prises pour écraser physiquement l'espace avec des données aléatoires (c'est ce que fait l'utilitaire <code>shred</code>).

On va donc opter pour la deuxième option, c'est à dire qu'on ne va pas perdre notre temps à remettre à zéro les blocs de données libérés, on va simplement marquer les blocs correspondants comme étant disponibles. Cela nous permettra de nous émanciper de la fonction resetBlock et de n'avoir plus qu'un seul tableau de blocs.

ReX : Sinon lire un bloc complet de pointeurs de blocs de données en mémoire n'est pas forcément optimal. L'idéal serait de lire ces blocs morceau par morceau (de 64 octets par exemple). Certes un bloc serait traité en 4 lectures/écritures (ce qui ralentirait le traitement) mais on gagne en mémoire. Le mieux serait de mettre la taille des morceaux en constante pour pouvoir choisir entre vitesse d'exécution et utilisation mémoire.

Amine: d'accord je comprends. Je vais modifier la fonction pour qu'on puisse découper la lecture/écriture en plusieurs blocs.

=== Fonction RM version 4 ===
Modifications apportées:

* je ne réinitialise plus les blocs de données, je supprime simplement le pointeur du fichier vers les blocs de données et je désigne les blocs comme "disponible" dans le carte de disponibilités. J'ai donc supprimé la fonction resetBlock.

* je ne lis plus les blocs en une seule fois mais en plusieurs fois via la variable CHUNK_SIZE:

# J'ai introduit la constante <code>CHUNK_SIZE</code> pour définir la taille de chaque morceau que nous allons lire/écrire à la fois. Cela permet de découper les opérations en blocs plus petits.
# Dans la boucle <code>for</code> où on parcours les blocs à partir de <code>offset</code>, j'ai ajouté une boucle interne qui parcourt les données du bloc en morceaux de taille <code>CHUNK_SIZE</code>.
# À l'intérieur de la boucle interne, j'ai calculé la taille réelle du morceau (<code>chunkSize</code>) en prenant le minimum entre <code>CHUNK_SIZE</code> et la quantité de données restant à lire/écrire dans le bloc.
# J'ai modifié la fonction <code>readBlock</code> pour lire seulement la quantité de données spécifiée par <code>chunkSize</code> à partir de <code>chunkStart</code>. Ces données sont stockées dans le tableau <code>fileBuffer</code>.
# Ensuite, j'ai effectué les mêmes opérations de libération des blocs associés au fichier, en parcourant les données du morceau et en marquant les blocs comme disponibles.
# Finalement, j'ai utilisé la fonction <code>writeBlock</code> pour écrire le morceau de données modifié dans le bloc, en utilisant la même <code>chunkStart</code> pour déterminer où écrire les données.

#define CHUNK_SIZE 64

int min(int a, int b) {
return a < b ? a : b;
}

void RM(const char *filesystem_path, const char *filename) {
int fileFound = -1;
int offset;
unsigned char fileBuffer[BLOCK_SIZE];

// Parcourir les blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char *)filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {
// Effacer le nom du fichier dans le superbloc
memset(filenameBuffer, 0, MAX_FILENAME_LENGTH);
writeBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);
fileFound = 1;
offset = blockNum;
break;
}
}

// Fin de fonction si fichier inexistant
if (fileFound == -1) {
printf("Le fichier \"%s\" n'a pas été trouvé.\n", filename);
return;
}

for (int blockNum = offset; blockNum < offset + 16; blockNum++) {
int startOffset = 0;

if (blockNum == offset) {
startOffset = MAX_FILENAME_LENGTH;
}

for (int chunkStart = startOffset; chunkStart < BLOCK_SIZE; chunkStart += CHUNK_SIZE) {
int chunkSize = min(CHUNK_SIZE, BLOCK_SIZE - chunkStart);
readBlock(blockNum, chunkStart, fileBuffer, chunkSize);

for (int i = 0; i < chunkSize; i += 2) {
int blockNumData = (fileBuffer[i] << 8) | fileBuffer[i + 1];
if (blockNumData == 0) {
writeBlock(blockNum, chunkStart, fileBuffer, chunkSize);
printf("Le fichier \"%s\" a été supprimé avec succès.\n", filename);
return; // Sortir des boucles
}
setBlockAvailability(blockNumData, 0); // Marquer le bloc comme disponible
fileBuffer[i] = 0;
fileBuffer[i + 1] = 0;
}

writeBlock(blockNum, chunkStart, fileBuffer, chunkSize);
}
}

printf("Le fichier \"%s\" a été supprimé avec succès.\n", filename);
}

ReX : Si on trouve un n° de bloc de données à 0, il faut sortir des deux boucles les plus externes après avoir fait le <code>writeBlock</code>.

Amine: Modification faites ci-dessus. Maintenant, dès qu'on trouve un n° de bloc de données à 0 dans la boucle la plus interne, on effectue le <code>writeBlock</code> et ensuite on utilise <code>return</code> pour sortir des deux boucles les plus externes. Cela permet d'optimiser le code en évitant de continuer à traiter inutilement le reste des blocs.

ReX : Pas très propre (duplication de code) mais nous allons nous en contenter.

=== Fonction intermédiaire TYPE version 1 ===

J'ai également commencé à réfléchir à la fonction TYPE. Pour l'instant, elle ne fait qu'ajouter les noms de fichier dans le superbloc. Cela permet de pouvoir tester les fonctions LS et RM (voir dans la rubrique compilation et exécution comment utiliser le programme).
// Fonction pour créer un fichier avec le nom donné et le contenu fourni en entrée standard
void TYPE(const char *filesystem_path, const char *filename) {
unsigned char buffer[MAX_FILENAME_LENGTH];
// Parcours des blocs réservés pour la description des fichiers
for (int blockNum = 0; blockNum <= MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, MAX_FILENAME_LENGTH);
// Vérifier si le bloc est vide (pas de nom de fichier)
if (buffer[0] == 0) {
// Écrire le nom du fichier dans l'emplacement vide du superbloc
writeBlock(blockNum, 0, (const unsigned char *)filename, MAX_FILENAME_LENGTH);
break; // Fichier créé, sortir de la boucle
}
}
printf("Le fichier \"%s\" a été créé avec succès.\n", filename);
}

ReX : Si la boucle se termine sans trouver de slot libre le message de succès s'affiche tout de même.

ReX : Le paramètre <code>filename</code> n'a pas forcément une taille de <code>MAX_FILENAME_LENGTH</code>.

Selon moi, la fonction TYPE devra respecter 3 étapes:

# Enregistrement du Nom du Fichier: L'ajout du nom du fichier dans un des blocs de la première partie du superbloc.
# Stockage des Données du Fichier: La récupération des données saisies en entrée standard par l'utilisateur et leur stockage dans des blocs du système de fichiers à partir d'une certaine position, comme le bloc 1040.
# Mise à Jour de la Disponibilité des Blocs: L'indication que les blocs dans lesquels les données ont été écrites ne sont plus disponibles en modifiant les bits correspondants dans la deuxième partie du superbloc (les 16 derniers blocs du super bloc).

ReX : Relis le point 3 et dit moi si tu te comprends toi même ?

Amine: Ma phrase n'est effectivement pas très claire. Je voulais dire que la fonction TYPE devra mettre à jour la carte de disponibilité du superbloc. C'est à dire que lorsqu'elle écrira des données dans des blocs, elle devra indiquer dans la carte de disponibilités que ces blocs ne sont plus disponibles.

=== Fonction intermédiaire TYPE version 2 ===

Suite à vos remarques, j'ai apporté les modifications suivantes à la fonction TYPE:

* j'ai ajouté une condition pour l'affichage du message de succès de la création d'un fichier (placeFound).

* le paramètre <code>filename</code> n'ayant pas forcément une taille de <code>MAX_FILENAME_LENGTH</code>, je calcule maintenant la longueur de filename, afin d'écrire seulement le nom du fichier avec la fonction writeBlock.

Il fonction n'est bien évidemment pas fini, elle ajoute seulement le nom du fichier dans le superbloc pour l'instant. Cela me permet de tester les fonctions LS et RM.
void TYPE(const char *filesystem_path, const char *filename) {
size_t sizeFilename = strlen(filename);
printf("size filename=%d\n", sizeFilename);
unsigned char buffer[MAX_FILENAME_LENGTH];
int placeFound = 0;

if (sizeFilename > MAX_FILENAME_LENGTH) {
printf("Impossible de créer le fichier, nom trop long\n");
return;
}

// Parcours des blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, MAX_FILENAME_LENGTH);
// Vérifier si le bloc est vide (pas de nom de fichier)
if (buffer[0] == 0) {
// Écrire le nom du fichier dans l'emplacement vide du superbloc
if (sizeFilename < MAX_FILENAME_LENGTH) {
sizeFilename+=1;
}
writeBlock(blockNum, 0, (const unsigned char *)filename, sizeFilename);
placeFound = 1;
break; // Fichier créé, sortir de la boucle
}
}
if (placeFound == 1) {
printf("Le fichier \"%s\" a été créé avec succès.\n", filename);
} else {
printf("Plus de place dans le système de fichier pour créer ce fichier.\n", filename);
}
}

ReX : Mieux, attention il faut copier aussi le <code>\'0</code> final du nom, donc <code>sizeFilename+1</code>. Sinon tu n'es pas sûr qu'il y ait un zéro final. Et attention n°2, il ne faut pas copier ce <code>\'0</code> si le nom fait la taille maximale.

Amine: ok j'ai modifié la fonction TYPE ci-dessus. J'ai ajouté une condition: si le nom du fichier est inférieur à la taille maximale de nom de fichier, alors on incrémente de 1 la taille du nom de fichier. Cela nous permet d'écrire le '\0' dans le bloc de description. Dans le cas où le nom du fichier est de la taille maximale, nous n'avons pas besoin d'écrire le '\0', on n'incrémente donc pas la taille de 1.

J'ai également ajouté une condition: si le nom du fichier est supérieur à la taille maximale, alors un message d'erreur s'affiche et le fichier n'est pas créé.

ReX : OK. L'embryon de fonction <code>TYPE</code> est correct, il manque juste le principal : la création des blocs de données.

=== Fonction MV version 1 ===

J'ai ici créé la fonction MV qui permet de changer le nom d'un fichier. Pour ce faire, la fonction parcourt les blocs de descriptions à la recherche du fichier dont on veut changer le nom. Lorsque ce fichier est trouvé, on supprime l'ancien nom en mettant des 0 sur 16 octets, puis on vient réécrire le nouveau nom dans le même emplacement. Enfin, on sort de la boucle et on affiche le succès ou non de l'opération.
// Fonction qui modifie le nom du fichier
void MV(const char *filesystem_path, const char *old_filename, const char *new_filename) {
size_t sizeNew_filename = strlen(new_filename);
size_t sizeOld_filename = strlen(old_filename);
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
int fileFound = 0;
// Parcourir les blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);
// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char*)filenameBuffer, old_filename, MAX_FILENAME_LENGTH) == 0) {
// Effacer le nom du fichier dans le superbloc
memset(filenameBuffer, 0, MAX_FILENAME_LENGTH);
writeBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);
// Écrire le nom du fichier dans l'emplacement
writeBlock(blockNum, 0, (const unsigned char *)new_filename, sizeNew_filename);
fileFound=1;
break; // Nom modifié, sortir de la boucle
}
}
if (fileFound == 1) {
printf("Le nom du fichier \"%s\" a été renommé avec succès.\n", old_filename);
} else {
printf("Le fichier \"%s\" n'a pas été trouvé.\n", old_filename);
}
}

ReX : Inutile d'écraser l'ancien nom avec des zéros. Il suffit de copier le nouveau en s'assurant qu'il y ait un zéro final sauf si le nouveau nom fait la taille maximale.

Amine: ok, je vais faire les modifications dans la version 2.

== Semaine 6 ==

=== Fonction MV version 2 ===
Dans cette nouvelle version de la fonction MV, j'ai effectué les modifications suivantes:

* je n'écrase plus l'ancien nom avec des 0
* Je colle simplement le nouveau nom par dessus l'ancien, en m'assurant qu'il y ait bien le '\0' à la fin lorsque la taille du nom du fichier est inférieur à la taille maximale. Comme précédemment, afin de m'assurer de la présence de ce '\0' à la fin du nom, j'incrémente la taille de 1 lorsque qu'elle est inférieur à la taille max. Cependant, je ne suis pas sûr à 100% que ce soit la bonne manière de faire.

// Fonction qui modifie le nom du fichier
void MV(const char *filesystem_path, const char *old_filename, const char *new_filename) {
size_t sizeNew_filename = strlen(new_filename);
size_t sizeOld_filename = strlen(old_filename);
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
int fileFound = 0;

// Parcourir les blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {

readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char*)filenameBuffer, old_filename, MAX_FILENAME_LENGTH) == 0) {

if (sizeNew_filename < MAX_FILENAME_LENGTH) {
sizeNew_filename+=1;
}

// Écrire le nom du fichier dans l'emplacement
writeBlock(blockNum, 0, (const unsigned char *)new_filename, sizeNew_filename);

fileFound=1;

break; // Nom modifié, sortir de la boucle
}
}
if (fileFound == 1) {
printf("Le nom du fichier \"%s\" a été renommé avec succès.\n", old_filename);
} else {
printf("Le fichier \"%s\" n'a pas été trouvé.\n", old_filename);
}
}

ReX : C'est bon. La fonction était triviale.

=== Fonction TYPE version 1 ===
void TYPE(const char *filesystem_path, const char *filename) {
size_t sizeFilename = strlen(filename);
unsigned char buffer[MAX_FILENAME_LENGTH];
int placeFound = -1;

if (sizeFilename > MAX_FILENAME_LENGTH) {
printf("Impossible de créer le fichier, nom trop long\n");
return;
}

// Parcours des blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, MAX_FILENAME_LENGTH);
// Vérifier si le bloc est vide (pas de nom de fichier)
if (buffer[0] == 0) {
// Écrire le nom du fichier dans l'emplacement vide du superbloc
if (sizeFilename < MAX_FILENAME_LENGTH) {
sizeFilename += 1; // Ajouter '\0' s'il y a de la place
}
writeBlock(blockNum, 0, (const unsigned char *)filename, sizeFilename);
placeFound = blockNum;

// Lire les données depuis l'entrée standard
unsigned char dataBuffer[BLOCK_SIZE];
size_t bytesRead;
int dataBlockNum = findAvailableBlock(); // Premier bloc de données à partir du bloc 1040
printf("dataBlockNum%d\n",dataBlockNum);
int blockSizeUsed = 0; // Compteur d'octets dans le bloc actuel
int dataBlocksNeeded = 1; // Nombre de blocs de données nécessaires

while ((bytesRead = fread(dataBuffer + blockSizeUsed, 1, BLOCK_SIZE - blockSizeUsed, stdin)) > 0) {
blockSizeUsed += bytesRead;

// Si le bloc actuel est plein, passer au bloc suivant
if (blockSizeUsed == BLOCK_SIZE) {
// printf("dataBlockNum=%d\n",dataBlockNum);
writeBlock(dataBlockNum, 0, dataBuffer, BLOCK_SIZE);
setBlockAvailability(dataBlockNum, 1);

dataBlockNum++; // Passer au bloc suivant
blockSizeUsed = 0; // Réinitialiser la taille utilisée
dataBlocksNeeded++;
}
}

// Écrire le dernier bloc partiel, s'il y en a un
if (blockSizeUsed > 0) {
writeBlock(dataBlockNum, 0, dataBuffer, blockSizeUsed);
setBlockAvailability(dataBlockNum, 1);
}

// Écrire les numéros de blocs utilisés dans le bloc de description
unsigned char blockNumberBuffer[2];
int currentBlockNum = 1040;

for (int i = 0; i < dataBlocksNeeded; i++) {
blockNumberBuffer[0] = (currentBlockNum >> 8) & 0xFF;
blockNumberBuffer[1] = currentBlockNum & 0xFF;
writeBlock(placeFound, MAX_FILENAME_LENGTH + i * 2, blockNumberBuffer, 2);
currentBlockNum++;
}

break; // Fichier créé, sortir de la boucle
}
}

if (placeFound != -1) {
printf("Le fichier \"%s\" a été créé avec succès.\n", filename);
} else {
printf("Plus de place dans le système de fichier pour créer ce fichier.\n");
}
}

ReX : La constante 1040 ne doit pas apparaître en numérique, ce doit être une constante calculée à partir des autres constantes.

Amine: Ok. Je ne l'avais pas défini comme une constante car il s'agit dans la fonction ci-dessus d'une variable qui est incrémenté à chaque itération.

ReX : Je suis las de te répéter que le mémoire est comptée : tu utilises encore un bloc de <code>BLOCK_SIZE</code> octets, c'est trop.

Amine: Comment utiliser des blocs plus petit sachant qu'il s'agit là de blocs de données et qu'un bloc fait 256 octets d'après l'énoncé ? Dois-je les subdiviser en plusieurs blocs plus petit comme fait dans la fonction RM, en 4 blocs de 64 octets par exemple ?

Fonctionnement de la fonction TYPE:

* étape 1: on parcourt les blocs de descriptions à la recherche d'un bloc disponible. Si on ne trouve pas de bloc disponible, on renvoie un message d'erreur, sinon on passe à l'étape suivante.
* étape 2: Si on trouve un emplacement libre dans les blocs de disponibilité, on écrit le nom du fichier dans cet emplacement.

ReX : Dans les blocs de description de fichiers pas dans les blocs de disponibilité.

Amine: Oui autant pour moi.

* étape 3: Ensuite, on lit le texte entré par l'utilisateur en entrée standard, on le répartit dans des blocs de taille BLOCK_SIZE, on met à jour la disponibilité des blocs utilisés.

ReX : Non, il faut appeler <code>findAvailableBlock</code> pour chaque bloc de données à utiliser, aucune certitudes que les blocs libres soient en séquence.

Amine: ok, je ferai cela dans la version 2

* étape 4: Enfin, on écrit les numéros des blocs de données utilisés dans les blocs de description de ce fichier, les numéros étant écris sur deux octets.

ReX : Non cela doit se faire au fur et à mesure des appels à <code>findAvailableBlock</code> et les numéros des blocs de données peuvent s'étaler sur les 16 blocs de description du fichier. Confusion totale sur ce point. Vous n'avez pas compris le mécanisme.

Amine: je corrige cela dans la version 2. J'ai bien compris le mécanisme mais ce n'est pas facile à traduire en code.

=== Fonction TYPE version 2 ===
Dans cette nouvelle version de TYPE, j'ai fait les modifications suivantes:

* j'appelle maintenant <code>findAvailableBlock</code> pour chaque bloc de données à utiliser
* j'écris maintenant les numéros de blocs au fur et à mesures des appels à <code>findAvailableBlock</code>
* je n'utilise plus de tableaux de taille 256 octets mais des tableaux de tailles CHUNK_SIZE. J'ai choisi ici CHUNK_SIZE = 64 octets.

J'utilise toujours un bloc de taille BLOCK_SIZE en attendant de comprendre si je dois diviser ce bloc en plusieurs blocs de taille plus petite ou s'il y a un moyen de ne pas du tout utiliser ces blocs.
void TYPE(const char *filesystem_path, const char *filename) {
size_t sizeFilename = strlen(filename);
unsigned char buffer[MAX_FILENAME_LENGTH];
int placeFound = -1;

if (sizeFilename > MAX_FILENAME_LENGTH) {
printf("Impossible de créer le fichier, nom trop long\n");
return;
}

// Parcours des blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, MAX_FILENAME_LENGTH);
// Vérifier si le bloc est vide (pas de nom de fichier)
if (buffer[0] == 0) {
// Écrire le nom du fichier dans l'emplacement vide du superbloc
if (sizeFilename < MAX_FILENAME_LENGTH) {
sizeFilename += 1; // Ajouter '\0' s'il y a de la place
}
writeBlock(blockNum, 0, (const unsigned char *)filename, sizeFilename);
placeFound = blockNum;

// Lire les données depuis l'entrée standard et écrire dans le fichier
int dataBlockNum = findAvailableBlock(); // Premier bloc de données à partir du bloc 1040
printf("Premier bloc dans lequel on écrit = %d\n", dataBlockNum);
int blockSizeUsed = 0; // Compteur d'octets dans le bloc actuel

unsigned char chunkBuffer[CHUNK_SIZE];
size_t bytesRead;

while ((bytesRead = fread(chunkBuffer, 1, CHUNK_SIZE, stdin)) > 0) {
// Écrire le chunk dans le bloc de données
writeBlock(dataBlockNum, blockSizeUsed, chunkBuffer, bytesRead);
setBlockAvailability(dataBlockNum, 1);

// Écrire le numéro du bloc actuel dans la description du fichier
unsigned char blockNumberBuffer[2];
blockNumberBuffer[0] = (dataBlockNum >> 8) & 0xFF;
blockNumberBuffer[1] = dataBlockNum & 0xFF;
writeBlock(placeFound, MAX_FILENAME_LENGTH + dataBlockNum * 2, blockNumberBuffer, 2);

blockSizeUsed += bytesRead;

// Si le bloc actuel est plein, passer au bloc suivant
if (blockSizeUsed == BLOCK_SIZE) {
dataBlockNum = findAvailableBlock(); // Passer au bloc suivant
blockSizeUsed = 0; // Réinitialiser la taille utilisée
}
}

break; // Fichier créé, sortir de la boucle
}
}

if (placeFound != -1) {
printf("Le fichier \"%s\" a été créé avec succès.\n", filename);
} else {
printf("Plus de place dans le système de fichier pour créer ce fichier.\n");
}
}

=== Fonction findAvailableBlock ===
Cette fonction renvoie l'indice du premier bloc disponible. Je me sers de cette fonction dans la fonction TYPE.
#define FIRST_DATA_BLOCK 1040
#define FIRST_DISPONIBILITY_CARD_BLOCK 1024

// Renvoie le premier bloc de donné disponible
int findAvailableBlock() {
unsigned char availabilityBuffer[BLOCK_SIZE];
int offset;

// Lire la carte de disponibilité (à partir du bloc 1)
for (int blockNum = FIRST_DISPONIBILITY_CARD_BLOCK; blockNum < FIRST_DATA_BLOCK; blockNum++) {
readBlock(blockNum, 0, availabilityBuffer, BLOCK_SIZE);

if (blockNum==FIRST_DISPONIBILITY_CARD_BLOCK) {
offset=FIRST_DATA_BLOCK/8;
} else {
offset=0;
}

// Parcourir les octets de la carte de disponibilité
for (int byteIndex = offset; byteIndex < BLOCK_SIZE - offset; byteIndex++) {
unsigned char byte = availabilityBuffer[byteIndex];

// Parcourir les bits de chaque octet
for (int bitIndex = 0; bitIndex < 8; bitIndex++) {
// Vérifier si le bit est à 0 (bloc disponible)
if ((byte & (1 << bitIndex)) == 0) {
// Calculer l'indice du bloc en fonction du bloc et du bit
int blockIndex = byteIndex * 8 + bitIndex;
return blockIndex;
}
}
}
}

// Aucun bloc disponible trouvé
return -1;
}

ReX : Même remarque que précédement sur les nombres 1024 et 1040.

Amine: Ok, j'ai remplacé 1024 par la constante FIRST_DISPONIBILITY_CARD_BLOCK et 1040 par la constante FIRST_DATA_BLOCK dans la fonction ci-dessus.

ReX : Vous n'avez toujours pas compris la contrainte sur la mémoire.

Amine: dois-je découper le bloc de taille BLOCK_SIZE en quatre blocs de taille 64 octets par exemple ?

ReX : Je ne vois pas ce que vous voulez faire avec <code>if (blockNum==1024) offset=1040/8; else offset=0;</code>.

Amine: dans la carte de disponibilité, chaque bit correspond à un bloc. Ainsi, les bits de 0 à 1040 dans la carte de disponibilité décrivent la disponibilité des blocs 0 à 1040. Or ces blocs correspondent au superbloc, et dans cette fonction, on veut connaître le premier bloc de données disponible. On ne s'intéresse donc pas au 1040 premiers bits de la carte de disponibilité. Je crée donc un offset égal à 1040/8 afin de ne pas prendre en compte les 1040 premiers bits soit les 1040/8=130 premiers octets. Cet offset ne s'applique que lorsqu'on se trouve dans le premier des 16 blocs de la carte de disponibilité, d'où la condition <code>if (blockNum==1024)</code>.

ReX : OK, bien vu.

=== Fonction CAT version 1 ===
void CAT(const char *filesystem_path, const char *filename) {
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
unsigned char buffer[BLOCK_SIZE];
unsigned char blockNumberBuffer[2];
unsigned char dataBuffer[BLOCK_SIZE];
int offset;

// Parcours des blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char *)filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {
// Le nom du fichier a été trouvé

// Parcours les blocs de description
for (int descrBlockNum=0; descrBlockNum<MAX_BLOCKS_PER_FILE_DESCRIPTION; descrBlockNum++) {
if (descrBlockNum==0) {
offset=16;
} else {
offset=0;
}
readBlock(descrBlockNum+blockNum, offset, buffer, BLOCK_SIZE-offset);

// Lire les numéros de blocs associés à ce fichier depuis les blocs de description
unsigned char octet1 = buffer[offset];
unsigned char octet2 = buffer[offset+1];

int dataBlockNum = (octet1 << 8) | octet2;
printf("dataBlockNum=%d\n",dataBlockNum);

// Vérifier si le numéro de bloc est valide (non nul)
if (dataBlockNum == 0) {
return; // Fin du fichier
}

// Lire et afficher le contenu du bloc de données
readBlock(dataBlockNum, 0, dataBuffer, BLOCK_SIZE);
fwrite(dataBuffer, 1, BLOCK_SIZE, stdout);
}

return; // Fichier affiché, sortie de la fonction
}
}

// Si le fichier n'a pas été trouvé
printf("Le fichier \"%s\" n'a pas été trouvé.\n", filename);
}

ReX : Encore mieux : deux blocs de <code>BLOCK_SIZE</code> en mémoire.

ReX : Le <code>break</code> ne sort pas de la boucle externe.

Amine: Oui c'est vrai. J'ai remplacé le <code>break</code> par un <code>return</code> ci-dessus.

ReX : Dans le cadre de la fonction CAT le <code>return</code> est convenable.

Voici ma fonction <code>CAT</code>. Elle fonctionne en plusieurs étape:

* étape 1: on cherche dans les blocs de descriptions si le fichier dont on veut afficher le contenu existe. Si le nom de fichier est trouvé, on passe à l'étape 2. Sinon, on renvoie un message d'erreur.
* étape 2: si le fichier est trouvé, on parcours les 16 blocs de description de ce fichier.
* étape 3: grâce aux opérations de masquage et de décalage, on joint les octets deux par deux pour former un entier qui contient le numéro du bloc de données correspondant au fichier. Si cet entier vaut 0, alors cela signifie qu'il n'y a plus de blocs associé à ce fichier, on peut donc quitter la fonction. Si cet entier est différent de 0, alors on va lire le bloc correspondant à ce numéro et on affiche son contenu dans le terminal.

== Semaine 7 ==

=== Fonction CP version 1 ===
Voici ma fonction CP, qui permet de créer une copie d'un fichier existant. L'idée est la suivante: pour copier un fichier, on doit créer un nouveau fichier et lui attribuer les mêmes blocs de descriptions que le fichier source. Ainsi, le fichier source et le fichier destination pointeront vers les mêmes blocs de données, et auront le même contenu.

ReX : Perdu. Ce n'est absolument pas la fonction de copie de fichiers d'un système de fichiers.

Amine: Après avoir fait des recherches et après réflexion, je me rends compte que cette fonction CP présente un problème: en faisant pointer les blocs de données du fichier destination vers ceux du fichier source, toute modification du fichier source impactera le fichier destination, or ce n'est pas ce qu'on veut faire. Je vous propose donc une nouvelle version de la fonction CP ci-dessous qui remédie à ce problème.

void CP(const char *filesystem_path, const char *source_filename, const char *destination_filename) {
unsigned char source_filenameBuffer[MAX_FILENAME_LENGTH];
unsigned char destination_filenameBuffer[MAX_FILENAME_LENGTH];
unsigned char descriptionBuffer[BLOCK_SIZE];
int destination_offset;
int offset;

// Recherche du fichier source
int source_offset = -1;
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, source_filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier source
if (strncmp((const char *)source_filenameBuffer, source_filename, MAX_FILENAME_LENGTH) == 0) {
source_offset = blockNum;
break;
}
}

if (source_offset == -1) {
printf("Le fichier source \"%s\" n'a pas été trouvé.\n", source_filename);
return;
}

// Recherche d'un emplacement libre pour le fichier destination
destination_offset = -1;
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, destination_filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc est vide (pas de nom de fichier)
if (destination_filenameBuffer[0] == 0) {
destination_offset = blockNum;
break;
}
}

if (destination_offset == -1) {
printf("Plus de place dans le système de fichier pour créer la copie de \"%s\".\n", source_filename);
return;
}

// Ecrit le nom de la copie dans le bloc de description
writeBlock(destination_offset, 0, (const unsigned char *)destination_filename, strlen(destination_filename));

// Copier les blocs de description associés au fichier source dans les blocs de description du fichier destination
for (int i = 0; i < MAX_BLOCKS_PER_FILE_DESCRIPTION; i++) {
if (i==0) {
offset = MAX_FILENAME_LENGTH;
} else {
offset = 0;
}

readBlock(source_offset+i, offset, descriptionBuffer, BLOCK_SIZE-offset);
if (descriptionBuffer[offset]==0) {
return;
} else {
writeBlock(destination_offset+i, offset, descriptionBuffer, BLOCK_SIZE-offset);
}
}

printf("La copie de \"%s\" sous le nom \"%s\" a été créée avec succès.\n", source_filename, destination_filename);
}

ReX : Pas mieux.

== Semaine 8 ==
A ce stade du projet, les fonctions suivantes ont été validé par Monsieur Redon:

* fonction LS
* fonction RM
* fonction MV

Il reste donc les fonctions suivantes à terminer:

* fonction CAT
* fonction CP
* fonction TYPE

=== Fonction CAT version 2 ===
Suite à vos remarques sur la version 1, j'ai fais les modifications suivantes:

* je n'utilise non plus 2 tableaux de taille BLOCK_SIZE, mais 1 seul. Idéalement il faudrait en utiliser 0, je réfléchi donc à m’émanciper de ce tableau en le remplaçant par plusieurs plus petits tableaux.

ReX : Un seul plus petit.

* J'ai remplacé le <code>break</code> par un <code>return</code>

ReX : Déjà validé.

Cette fonction permet d'afficher le contenu d'un fichier créé avec la fonction TYPE. Pour se faire, on parcours tout d'abord les blocs de descriptions pour trouver le fichier dont ont veut afficher le contenu. Une fois ce fichier trouvé, on parcours les 16 blocs de description de ce fichier 1 à 1. Pour chacun de ces blocs de description, on va stocker récupéré les octets deux par deux afin de former des entiers. Pour se faire, on utilise la fonction <code>reconsituteNumber</code> que l'on détaillera juste après. Ces entiers correspondent aux blocs dans lesquels la donné du fichier se trouve. Une fois l'entier reconstitué, on affiche le contenu du bloc correspondant.
#define CHUNK_SIZE 64

void CAT(const char *filesystem_path, const char *filename) {
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
unsigned char byteBuffer[2];
unsigned char dataBuffer[CHUNK_SIZE];
int offset;

// Parcours des blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char *)filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {
// Le nom du fichier a été trouvé

// Parcours les blocs de description
for (int descrBlockNum=0; descrBlockNum<MAX_BLOCKS_PER_FILE_DESCRIPTION; descrBlockNum++) {
if (descrBlockNum==0) {
offset=MAX_FILENAME_LENGTH;
} else {
offset=0;
}

// Lecture des octets deux par deux
for (int i=0; i<BLOCK_SIZE;i+=2) {
readBlock(descrBlockNum+blockNum, offset+i, byteBuffer, 2);

// Lire les numéros de blocs associés à ce fichier depuis les blocs de description
int dataBlockNum = reconsituteNumber(byteBuffer);

// Vérifier si le numéro de bloc est valide (non nul)
if (dataBlockNum == 0) {
return; // Fin du fichier
}

for (int chunkStart = 0; chunkStart < BLOCK_SIZE; chunkStart += CHUNK_SIZE) {
// Lire et afficher le contenu du bloc de données
readBlock(dataBlockNum, chunkStart, dataBuffer, CHUNK_SIZE);
fwrite(dataBuffer, 1, CHUNK_SIZE, stdout);
}
}
}

return; // Fichier affiché, sortie de la fonction
}
}

// Si le fichier n'a pas été trouvé
printf("Le fichier \"%s\" n'a pas été trouvé.\n", filename);
}

ReX : Remplacer le premier bloc de <code>BLOCK_SIZE</code> octets par un bloc de 2 octets est exagéré mais cela pourrait passer. Il reste toujours un bloc de <code>BLOCK_SIZE</code> octets dont il est facile de se passer au bénéfice d'un bloc de, mettons, 64 octets.

Amine: Voilà! Dans la version ci-dessus j'ai remplacé le bloc de taille <code>BLOC_SIZE</code> par un bloc de taille <code>CHUNK_SIZE</code>, avec <code>CHUNK_SIZE</code> modifiable dans les constantes du programme. J'ai pris ici 64 octets.

=== Fonction reconsituteNumber ===
Cette fonction permet de reconstituer un numéro de bloc à partir de deux octets.
// Fonction qui reconstitue le numéro de bloc à partir du tableau
int reconsituteNumber(unsigned char blockNumberBuffer[2]) {
unsigned char octet1 = blockNumberBuffer[0];
unsigned char octet2 = blockNumberBuffer[1];
int dataBlockNum = (octet1 << 8) | octet2;
return dataBlockNum;
}

ReX : Bonne idée cette fonction.

=== Fonction CP version 2 ===
Voici une version mise à jour de notre fonction CP. Dans la version précédente, on faisait pointer le fichier source vers les même blocs que le fichier destination. Cela posait un problème: toute modification du fichier source impactait le fichier destination. Ainsi, dans cette nouvelle version, on fait une duplication des blocs de données du fichier source vers le fichier destination. Cela implique donc une mise à jour de la carte de disponibilité, ainsi que l'adaptation des blocs de descriptions. En effet, seulement les blocs de données sont maintenant identiques, plus les blocs de description.

Piste d'amélioration: comme pour la fonction CAT ci-dessus, j'utilise toujours un bloc de taille 256 octets, je vais devoir y remédier.
// Fonction pour copier un fichier existant du système de fichier
void CP(const char *filesystem_path, const char *source_filename, const char *destination_filename) {
unsigned char source_filenameBuffer[MAX_FILENAME_LENGTH];
unsigned char destination_filenameBuffer[MAX_FILENAME_LENGTH];
unsigned char descriptionBuffer[CHUNK_SIZE];
unsigned char numBuffer[2];
int destination_offset;
int source_offset;
int offset;
int numDataBlock;
int newDataBlock;

// Recherche du fichier source
source_offset = -1;
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, source_filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier source
if (strncmp((const char *)source_filenameBuffer, source_filename, MAX_FILENAME_LENGTH) == 0) {
source_offset = blockNum;
break;
}
}

if (source_offset == -1) {
printf("Le fichier source \"%s\" n'a pas été trouvé.\n", source_filename);
return;
}

// Recherche d'un emplacement libre pour le fichier destination
destination_offset = -1;
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, destination_filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc est vide (pas de nom de fichier)
if (destination_filenameBuffer[0] == 0) {
destination_offset = blockNum;
break;
}
}

if (destination_offset == -1) {
printf("Plus de place dans le système de fichier pour créer la copie de \"%s\".\n", source_filename);
return;
}

// Copie du nom de la copie dans le bloc de description
writeBlock(destination_offset, 0, (const unsigned char *)destination_filename, strlen(destination_filename));

// Copier les blocs de données associés au fichier source dans de nouveaux blocs de données pour le fichier destination
for (int i = 0; i < MAX_BLOCKS_PER_FILE_DESCRIPTION; i++) {
if (i == 0) { offset = MAX_FILENAME_LENGTH; }
else { offset = 0; }

// Lecture des numéros de bloc dans les blocs de description
for (int byteNum=0; byteNum<BLOCK_SIZE; byteNum+=2) {
readBlock(source_offset + i, offset + byteNum, numBuffer, 2);

numDataBlock = reconsituteNumber(numBuffer);
if (numDataBlock == 0) {
printf("La copie de \"%s\" sous le nom \"%s\" a été créée avec succès.\n", source_filename, destination_filename);
return;
}

for (int chunkStart = 0; chunkStart < BLOCK_SIZE; chunkStart += CHUNK_SIZE) {
// On stocke le bloc de données associé au fichier source dans descriptionBuffer
readBlock(numDataBlock, chunkStart, descriptionBuffer, CHUNK_SIZE);

if (chunkStart == 0) {
// Trouver un nouveau bloc de données disponible
newDataBlock = findAvailableBlock();

// Mise à jour de la carte de disponibilités
setBlockAvailability(newDataBlock, 1);

// Ecriture du numéro de bloc dans la description du fichier
createNumberBuffer(newDataBlock,numBuffer);
writeBlock(destination_offset+i, offset+byteNum, numBuffer, 2);
}

// Ecriture du bloc de données dans le premier bloc disponible
writeBlock(newDataBlock, chunkStart, descriptionBuffer, CHUNK_SIZE);
}
}
}
}

ReX : Youpi. Il reste à se passer du bloc de <code>BLOCK_SIZE</code> (au bénéfice d'un bloc de taille <code>BLOCK_SIZE/n</code> avec n>1). Ecrire la fonction inverse de <code>reconsituteNumber</code>.

Amine: Voilà! Dans le fonction ci-dessus il n'y a plus de bloc de taille <code>BLOCK_SIZE</code>, on a maintenant des blocs de 64 octets (<code>CHUNK_SIZE</code>). J'ai également créé la fonction <code>createNumberBuffer</code> qui est la fonction inverse de<code>reconsituteNumber</code>. Je la détaille ci-dessous.

=== Fonction createNumberBuffer ===
Cette fonction permet repartir un entier sur deux octets.
// Fonction qui réparti un numéro de bloc sur deux octets
void createNumberBuffer(int dataBlockNum, unsigned char blockNumberBuffer[2]) {
blockNumberBuffer[0] = (dataBlockNum >> 8) & 0xFF;
blockNumberBuffer[1] = dataBlockNum & 0xFF;
}

=== Fonction TYPE version 3 ===
La fonction 2 que j'ai fourni ci-dessus n'est pas correcte. Je vais la corriger dans cette version 3.

ReX : Effectivement la version précédente ne gére pas correctement l'écriture des numéros de blocs de données dans la description d'un fichier.

Voici ma version 3 de la fonction TYPE. Voici son fonctionnement:

- tout d'abord, la fonction parcours les blocs de description à la recherche d'un emplacement vide

- une fois l'emplacement vide trouvé, elle écrit le nom du fichier dans cet emplacement

- ensuite, on passe à la lecture de l'entrée standard. J'ai essayé d'expliquer au fur et à mesure du programme ce que font les lignes importantes via les commentaires.
void TYPE(const char *filesystem_path, const char *filename) {
size_t sizeFilename = strlen(filename);
unsigned char buffer[MAX_FILENAME_LENGTH];
int placeFound = -1;
int index_description_block = 0; // indice du bloc de descrption
int block_counter = 1; //compteur de blocs utilisés
int index_in_descrBlock = 0;
int offset;
int first_loop=1;

if (sizeFilename > MAX_FILENAME_LENGTH) {
printf("Impossible de créer le fichier, nom trop long\n");
return;
}

// Parcours des blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, MAX_FILENAME_LENGTH);
// Vérifier si le bloc est vide (pas de nom de fichier)
if (buffer[0] == 0) {
// Écrire le nom du fichier dans l'emplacement vide du superbloc
if (sizeFilename < MAX_FILENAME_LENGTH) {
sizeFilename += 1; // Ajouter '\0' s'il y a de la place
}
writeBlock(blockNum, 0, (const unsigned char *)filename, sizeFilename);
placeFound = blockNum;

// Lire les données depuis l'entrée standard et écrire dans le fichier
int dataBlockNum = findAvailableBlock(); // Premier bloc de données à partir du bloc 1040
int blockSizeUsed = 0; // Compteur d'octets dans le bloc actuel

unsigned char chunkBuffer[CHUNK_SIZE];
size_t bytesRead;

while ((bytesRead = fread(chunkBuffer, 1, CHUNK_SIZE, stdin)) > 0) {

// Écrire le chunk dans le bloc de données
writeBlock(dataBlockNum, blockSizeUsed, chunkBuffer, bytesRead);
setBlockAvailability(dataBlockNum, 1);

// Écrire le numéro du bloc actuel dans la description du fichier
unsigned char blockNumberBuffer[2];
createNumberBuffer(dataBlockNum,blockNumberBuffer);

blockSizeUsed += bytesRead;

// Si le bloc actuel est plein, passer au bloc suivant OU si c'est le premier tour dans la boucle
if (blockSizeUsed == BLOCK_SIZE || first_loop == 1) {

first_loop = -1;

// Ecriture du numéro de bloc utilisé dans les blocs de description
if (index_description_block == 0) {
offset = MAX_FILENAME_LENGTH;
} else {
offset = 0;
}
writeBlock(placeFound + index_description_block, offset + index_in_descrBlock*2, blockNumberBuffer, 2);
index_in_descrBlock++;

dataBlockNum = findAvailableBlock(); // Passer au bloc suivant
blockSizeUsed = 0; // Réinitialiser la taille utilisée

// Passage au bloc de description suivant
if (block_counter == (BLOCK_SIZE/2-offset)) {
index_description_block++;
index_in_descrBlock=0;
}

// Compteur de nombre de blocs utilisés
block_counter++;

// Vérifie si on a atteint le nombre maximal de blocs par fichier
if (block_counter >= 2040) {
printf("Le fichier a atteint sa taille maximale\n");
return;
}
}
}

break; // Fichier créé, sortir de la boucle
}
}

if (placeFound != -1) {
printf("Le fichier \"%s\" a été créé avec succès.\n", filename);
} else {
printf("Plus de place dans le système de fichier pour créer ce fichier.\n");
}
}

= Compilation et exécution =
'''Création du système de fichiers :'''
dd if=/dev/zero of=filesystem.bin bs=256 count=32768

'''Compilation :'''

gcc picofs.c -o picofs

'''Exécution de LS, TYPE, CAT, RM, MV ou CP :'''

./picofs filesystem.bin LS
./picofs filesystem.bin TYPE mon_fichier.txt
./picofs filesystem.bin CAT mon_fichier.txt
./picofs filesystem.bin RM mon_fichier.txt
./picofs filesystem.bin MV mon_fichier.txt mon_fichier2.txt
./picofs filesystem.bin CP mon_fichier.txt mon_fichier2.txt

= Documents Rendus =
[[Fichier:PicofsV1.c.tar|vignette]]

SE4 2022/2023 EC1

2023-09-03T21:06:39Z

Asellali : /* Documents Rendus */

= Objectifs =

Il vous est demandé de :
* réaliser un micro système de fichiers ;
* le système de fichiers doit résider dans un fichier de 8 Mo ;
* le système de fichiers est géré par un exécutable obtenu à partir d'un programme C ;
* L'éxécutable prend deux arguments, le premier est le chemin du fichier dans lequel réside le système de fichiers, les paramètres suivants concernent l'action à appliquer sur le système de fichiers ;
* le micro système de fichier ne comporte qu'un répertoire : le répertoire principal, le répertoire principal peut comporter au maximum 64 fichiers, un fichier est caractérisé par un nom de 16 caractères au maximum et ses blocs de données, un fichier peut comporter au maximum 2040 blocs de données ;
* un bloc de données fait 256 octets et les blocs sont numérotés sur 2 octets ;
* les différentes actions possibles sur le système de fichiers sont :
** <code>TYPE</code> pour créer un fichier si possible, le nom du fichier suit la commande, le contenu du fichier est donné en entrée standard de l'exécutable ;
** <code>CAT</code> pour afficher un fichier, le nom du fichier suit la commande ;
** <code>RM</code> pour détruire un fichier, le nom du fichier suit la commande ;
** <code>MV</code> pour renommer un fichier, les noms original et nouveau du fichier suivent la commande ;
** <code>CP</code> pour copier un fichier, les noms de l'original et de la copie du fichier suivent la commande ;

= Matériel nécessaire =

Un PC sous Linux.

= Travail réalisé =

== Semaine 1 ==

ReX : attention, ce micro-système de fichiers est prévu pour un microcontrôleur, vos variables globales ne peuvent pas dépasser quelques centaines d'octets.

ReX : pour la création du système de fichiers la commande <code>dd</code> suffit, vous voulez dire le formatage du système de fichiers ?

* création du programme programme.c contenant les différentes structures et les différentes fonctions.
* Piste d'amélioration: faire en sorte que la fonction CAT affiche le contenu exact des fichiers passés en argument.

Le code fourni est un programme en langage C qui simule un système de fichiers basique. Ce programme permet aux utilisateurs d'effectuer diverses actions telles que créer, afficher, supprimer, renommer et copier des fichiers dans un système de fichiers simulé. Le système de fichiers est stocké dans un fichier binaire.

ReX : vous n'avez pas tenu compte de la première remarque, vous chargez tout le superbloc et le répertoire racine, votre code ne convient pas.

ReX : vos structures utilisent des types entiers dont la taille n'est pas explicitée, utilisez les types de <code>stdint.h</code>.

ReX : la création de fichier n'est pas fonctionnelle, vous ne cherchez pas les blocs libres, vous ne copiez pas le contenu du fichier dans les blocs, même remarque pour toutes les autres fonctions.

ReX : il manque les fonctions d'accès aux pages du système de fichiers.

'''Explication du programme programme.c'''

Voici une brève explication des principaux éléments et fonctions du code :

# Structures :
#* Fichier : Représente un fichier dans le système de fichiers. Il contient un nom (nom) avec une longueur maximale de 16 caractères, un tableau de numéros de bloc (blocs) où le contenu du fichier est stocké (jusqu'à 2040 blocs), et le nombre de blocs utilisés par le fichier (nbBlocs).
#* Repertoire : Représente le répertoire principal du système de fichiers. Il contient un tableau de fichiers (<code>fichiers</code>) et le nombre de fichiers dans le répertoire (<code>nbFichiers</code>).
# Fonctions :
#* <code>chargerSystemeFichiers</code> : Charge le système de fichiers à partir d'un fichier binaire donné (chemin) dans une structure Repertoire.
#* <code>sauvegarderSystemeFichiers</code> : Sauvegarde le système de fichiers stocké dans la structure Repertoire dans un fichier binaire (chemin).
#* <code>creerFichier</code> : Crée un nouveau fichier dans le système de fichiers avec un nom et un contenu donnés. Le contenu du fichier est simulé en le divisant en blocs.
#* <code>afficherFichier</code> : Affiche le contenu d'un fichier avec le nom spécifié.
#* <code>detruireFichier</code> : Supprime un fichier avec le nom spécifié du système de fichiers.
#* <code>renommerFichier</code> : Renomme un fichier avec l'ancien nom spécifié en un nouveau nom.
#* <code>copierFichier</code> : Copie un fichier avec le nom spécifié en créant un nouveau fichier avec le nom de copie spécifié.
# Fonction <code>main</code> :
#* La fonction <code>main</code> est le point d'entrée du programme.
#* Elle prend des arguments en ligne de commande : <code><chemin_systeme_fichiers></code> et <code><action></code>.
#* <code><chemin_systeme_fichiers></code> est le chemin vers le fichier binaire où le système de fichiers est stocké.
#* <code><action></code> détermine quelle opération effectuer, comme <code>TYPE</code>, <code>CAT</code>, <code>RM</code>, <code>MV</code> ou <code>CP</code>.
#* En fonction de l'action spécifiée, le programme appelle la fonction correspondante pour effectuer l'opération souhaitée sur le système de fichiers.
Remarque : Le code fourni une simulation basique d'un système de fichiers et de ses opérations, mais il n'interagit pas réellement avec un système de fichiers réel sur le disque.

'''Comment utiliser le programme programme.c'''

étape 1: création du système de fichiers respectant le cahier des charges:

dd if=/dev/zero of=systeme_fichiers.bin bs=1M count=8

étape 2: compilation du programme C:

gcc programme.c -o gestionnaire_fs

étape 3: création d'un fichier dans le système de fichier:

./gestionnaire_fs systeme_fichiers.bin TYPE fichier1.txt

-> entrer le texte en entrée standard

étape 4: manipulation des différentes fonctions. Exemples:

./gestionnaire_fs systeme_fichiers.bin CAT fichier1.txt
./gestionnaire_fs systeme_fichiers.bin CP fichier1.txt copie.txt
./gestionnaire_fs systeme_fichiers.bin RM copie.txt
./gestionnaire_fs systeme_fichiers.bin MV fichier1.txt fichier2.txt

== Semaine 2 ==

Amine: Merci pour vos remarques. Désolé de ne pas avoir suivi votre première remarque, je pensais avoir compris ce qu'il fallait faire mais je me rend compte que non. Je vais tout reprendre depuis le début afin de repartir sur de bonnes bases.

'''Création du système de fichier avec la commande "dd"'''

A quoi sert la commande dd?

La commande <code>dd</code> permet de copier tout ou partie d'un disque par blocs d'octets, indépendamment de la structure du contenu du disque en fichiers et en répertoires (source : [https://doc.ubuntu-fr.org/dd]).

Structure de la commande

dd if=<nowiki><source> of=<cible> bs=<taille des blocs></nowiki>

<code>source</code> = données à copier

<code>cible</code> = endroit où les copier

<code>if</code> = input file

<code>of</code> = output file

<code>bs</code> = block size, habituellement une puissance de 2 supérieure ou égale à 512, représentant un nombre d'octets

Choix de la commande:

Pour la source, on prends <code>/dev/zero</code>: cela permet de créer un fichier rempli de 0. Ce fichier servira de base pour notre système de fichiers.

Pour la cible, on va l'appeler <code>filesystem.bin</Code> : ce sera notre système de fichier.

Pour la taille des blocs, on veut des blocs de données de 256 octets d'après l'enoncé. On va donc prendre <code>bs=256</code>.

Enfin, on veut que le système de fichier réside dans un fichier de 8 Mo. On va donc ajouter <code>count=31250</code>: cela indique que nous voulons écrire 32768 blocs de données dans le fichier (31250 * 256 octets = 8 Mo).

Résultat:

dd if=/dev/zero of=filesystem.bin bs=256 count=31250

Question pour M. Redon : j'ai ici essayé de respecter votre remarque "pour la création du système de fichiers la commande <code>dd</code> suffit". Cependant, pour votre seconde remarque "vous chargez tout le superbloc et le répertoire racine, votre code ne convient pas.", je ne suis pas sûr de comprendre où je fais cela: est-ce lors de la commande dd ou est-ce par la suite avec mon programme C? J'ai un peu modifié la commande dd comme vous pouvez le voir ci-dessus. Ai-je corrigé mon erreur avec cette nouvelle commande? J'ai essayé de justifier au maximum la commande dd que j'ai choisie.

ReX : Pas de problème avec la commande <code>dd</code> (mettez tous les extraits de code entre des balises <code>code</code>). Le problème est au niveau du programme C.

Amine: Ok je comprends mieux merci. Je vais donc reprendre le code étape par étape afin de mieux répondre au cahier des charges.

Gestion du système de fichier par un programme C

'''Création des structures'''
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>

// Structure pour représenter un bloc de données

struct DataBlock {
uint8_t data[256]; // 256 octets pour chaque bloc de données
};

// Structure pour représenter un fichier

struct File {
char filename[17]; // 16 caractères pour le nom du fichier + 1 caractère null-terminator
struct DataBlock data_blocks[2040]; // Tableau de blocs de données pour stocker le contenu du fichier
uint16_t num_data_blocks; // Nombre de blocs de données utilisés par le fichier
};

// Structure pour représenter un répertoire

struct Directory {
struct File files[64]; // Tableau de fichiers pour le répertoire principal
uint8_t num_files; // Nombre de fichiers dans le répertoire principal
};

Modification faite : suite à votre remarque, j'ai explicité la taille des entiers grâce aux types de <code>stdint.h.</code> (j'ai également mis les variables en anglais)

ReX : Vous ne pouvez pas utiliser ces structures, une instanciation d'une de ces structure prend trop d'espace mémoire, vous devez faire sans structure. Par ailleurs la façon dont vous représentez vos fichiers ne convient pas, la description d'un fichier contient des numéros de blocs, pas les blocs eux-même. Faites aussi attention qu'un fichier soit décrit par un nombre entier de blocs.

Question pratique: je n'arrive pas à mettre tout le code dans le même bloc comme vous l'avez fait ci-dessus dans l'étape 4 de la semaine 1. Je vois que c'est en format "préformaté" mais j'obtiens des blocs séparés lorsque j'applique ce format à mon code.

ReX : j'ai corrigé, pour un code entier la syntaxe n'est pas la même (un espace en début de chaque ligne), la balise c'est uniquement pour de très courts extraits de code.

=== Fonction <code>readBlock</code>===
Cette fonction est utilisée pour lire un bloc de données à partir du fichier <code>filesystem.bin</code> et le stocker dans un tableau de caractères (<code>storage</code>).

Fonction:

#define BLOCK_SIZE 256
// Fonction pour lire un bloc de données
void readBlock(unsigned int num, int offset, unsigned char *storage, int size) {
FILE *file = fopen("filesystem.bin", "rb");
if (file == NULL) {
perror("Erreur lors de l'ouverture du fichier");
return;
}
fseek(file, num * BLOCK_SIZE + offset, SEEK_SET);
fread(storage, 1, size, file);
fclose(file);
}

Paramètres :

* <code>num</code> : Numéro du bloc à lire. Chaque bloc contient 256 octets (1 bloc = 256 octets).
* <code>offset</code> : Décalage (en octets) à partir du début du bloc pour commencer la lecture.
* <code>storage</code> : Pointeur vers un tableau de caractères où les données lues seront stockées.
* <code>size</code> : Taille du tableau de caractères <code>storage</code>.

Fonctionnement :

* La fonction commence par ouvrir le fichier <code>filesystem.bin</code> en mode lecture binaire (<code>"rb"</code>).
* Elle utilise <code>fseek</code> pour positionner le curseur de lecture dans le fichier à l'endroit approprié pour commencer la lecture du bloc spécifié (<code>num</code>) à partir de l'offset (<code>offset</code>).
* Elle utilise ensuite <code>fread</code> pour lire <code>size</code> octets à partir du fichier et les stocker dans le tableau <code>storage</code>.
* Enfin, elle ferme le fichier avec <code>fclose</code>.

Note : Le paramètre <code>offset</code> est utilisé pour spécifier à partir de quel octet du bloc on souhaite commencer la lecture. Si <code>offset</code> est égal à 0, la lecture commencera depuis le début du bloc. Si <code>offset</code> est différent de 0, la lecture commencera à l'octet spécifié.

Remarque: dans votre mail, vous définissez "readBlock(unsigned int num,int offset,unsigned storage,int size)": storage n'est alors pas un pointeur vers un tableau de caractère. Je me suis donc permis de faire la modification.

ReX : OK pour la fonction, pas la peine d'en mettre autant dans le Wiki pour une fonction aussi simple.

=== Fonction <code>writeBlock</code> ===
Cette fonction est utilisée pour écrire un bloc de données dans le fichier <code>filesystem.bin</code> à partir d'un tableau de caractères (<code>storage</code>).

Fonction:

// Fonction pour écrire un bloc de données
void writeBlock(unsigned int num, int offset, const unsigned char *storage, int size) {
FILE *file = fopen("filesystem.bin", "rb+");
if (file == NULL) {
perror("Erreur lors de l'ouverture du fichier");
return;
}
fseek(file, num * BLOCK_SIZE + offset, SEEK_SET);
fwrite(storage, 1, size, file);
fclose(file);
}

Paramètres :

* <code>num</code> : Numéro du bloc où écrire.
* <code>offset</code> : Décalage (en octets) à partir du début du bloc pour commencer l'écriture.
* <code>storage</code> : Pointeur vers un tableau de caractères contenant les données à écrire dans le fichier.
* <code>size</code> : Taille du tableau de caractères <code>storage</code>.

Fonctionnement :

* La fonction commence par ouvrir le fichier <code>filesystem.bin</code> en mode lecture et écriture binaire (<code>"rb+"</code>).
* Elle utilise <code>fseek</code> pour positionner le curseur de lecture/écriture dans le fichier à l'endroit approprié pour commencer l'écriture du bloc spécifié (<code>num</code>) à partir de l'offset (<code>offset</code>).
* Elle utilise ensuite <code>fwrite</code> pour écrire <code>size</code> octets à partir du tableau <code>storage</code> dans le fichier.
* Enfin, elle ferme le fichier avec <code>fclose</code>.

ReX : Même remarque que pour la fonction précédente.

'''Etape 4: test des fonctions <code>readBlock</code> et <code>writeBlock</code> dans le main'''
// Exemple de fonction principale pour tester les opérations de lecture et d'écriture
int main() {
unsigned char data[BLOCK_SIZE];
// Test de la fonction readBlock
readBlock(0, 0, data, BLOCK_SIZE);
printf("Block 0, offset 0: ");
for (int i = 0; i < BLOCK_SIZE; i++) {
printf("%02x ", data[i]);
}
printf("\n");
// Test de la fonction writeBlock
unsigned char newData[BLOCK_SIZE] = {
0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88,
// ... Autres données du bloc ...
};
writeBlock(1, 0, newData, BLOCK_SIZE);
// Lecture du bloc nouvellement écrit pour vérifier
readBlock(1, 0, data, BLOCK_SIZE);
printf("Block 1, offset 0: ");
for (int i = 0; i < BLOCK_SIZE; i++) {
printf("%02x ", data[i]);
}
printf("\n");
return 0;
}

Fonctionnement :

* On déclare tout d'abord un tableau de caractères <code>data</code> de taille <code>BLOCK_SIZE</code> pour stocker les données lues du bloc.
* Ensuite, la fonction <code>readBlock</code> est appelée avec les arguments (0, 0, data, BLOCK_SIZE) pour lire le premier bloc du fichier (<code>num=0</code>, <code>offset=0</code>) et stocker les données dans <code>data</code>.
* Ensuite, la fonction <code>printf</code> est utilisée pour afficher les données lues du bloc (<code>data</code>) en format hexadécimal.
* Ensuite, un nouveau tableau de caractères <code>newData</code> est créé avec des données spécifiques pour tester la fonction <code>writeBlock</code>.
* La fonction <code>writeBlock</code> est appelée avec les arguments (1, 0, newData, BLOCK_SIZE) pour écrire le tableau <code>newData</code> dans le deuxième bloc du fichier (<code>num=1</code>, <code>offset=0</code>).
* Enfin, la fonction <code>readBlock</code> est appelée à nouveau pour lire le deuxième bloc nouvellement écrit et afficher les données lues en format hexadécimal.

Question générale : ce que j'avais la première semaine n'est plus forcément d'actualité. Puis-je supprimer les choses qui ne le sont plus afin d'alléger la page ou préférez-vous que je laisse?

ReX : Laissez.

Pour la suite : j'ai donc pour l'instant crée deux fonctions, l'une permettant la lecture et l'autre l'écriture d'un bloc, de manière à économiser la mémoire. Pour la suite, je vais essayer de créer la fonction <code>LS</code> en utilisant la fonction <code>readBlock</code>.

ReX : Oui c'est le début du projet. Mais si vous n'avez pas une bonne description de fichier cela ne donnera rien. Voir remarques plus haut.

'''Etape 5: fonction <code>LS</code>'''

Objectif: créer la fonction <code>LS</code> avec la fonction readBlock.

Question: Souhaitez-vous la fonction <code>LS</code> classique, c'est à dire la fonction <code>LS</code> qui affiche simplement le nom des fichiers présent dans le répertoire ?

ReX : Oui. Tu peux ajouter la taille si tu trouves cela trop simple.

Piste : si c'est ce que vous voulez:

* il va tout d'abord falloir que je crée des fichiers, un fichier étant composé d'un nom et de blocs (création d'une fonction createFile)
* Il faudra ensuite que je stocke ces fichiers dans le répertoire (création d'une fonction addFileToDirectory par exemple)
* enfin, il faudra que j'affiche le nom des fichiers. Pour cela, il faudra que je parcours le répertoire (structure "Directory"), puis que pour chaque fichier présent dans le répertoire que j'affiche son nom (création de la fonction LS)

Je devrais surement utiliser la fonction readBlock afin de transférer les blocs dans le fichier au travers de la variable "storage".

ReX : Créer des fichiers n'est pas nécessaire tout de suite je verrais bien si ton code est bon sans test. Laisse tomber <code>createFile</code> et <code>addFileToDirectory</code> pour l'instant.

ReX : Ton algorithme ne fonctionne pas pour un microcontrôleur où il faut économiser la mémoire, tu ne peux pas t'aider de structures. Il faudra que tu charges les noms et seulement les noms, pour la taille il faudra se baser sur le nombre de blocs.

'''Etape 6: rectification du code suite à vos remarques'''

Modifications apportées:

* suppression des structures afin d’économiser de la mémoire.

* le problème quant à la description des fichiers est normalement résolu puisque plus de structures. On ne charge plus les blocs mais seulement les noms de fichiers.

ReX : Non car si les noms ne sont pas répartis de façon régulière dans les blocs de 256 octets tu vas avoir du mal à les charger. Mais écrit la fonction <code>LS</code> et tu verras ce que je veux dire.

J'ai également ajouté deux nouvelles fonctions:

# <code>void readFileName(unsigned int file_num, char *file_name)</code>: Cette fonction permet de lire le nom du fichier associé au numéro de fichier donné (<code>file_num</code>). Elle stocke le nom du fichier lu dans le tableau <code>file_name</code>.
# <code>void writeFileName(unsigned int file_num, const char *file_name)</code>: Cette fonction permet d'écrire le nom du fichier dans le système de fichiers, associé au numéro de fichier donné (<code>file_num</code>). Elle prend en entrée le nom du fichier à écrire (<code>file_name</code>).

Suite: si vous validez cette base, je pourrai passer à la création de la fonction LS.

ReX : tu peux y aller. Je ne vois pas le code des tes deux fonctions <code>readFileName</code> et <code>writeFileName</code>.

Voici le code des fonctions <code>readFileName</code> et <code>writeFileName</code> :

'''Fonction readFileName:'''
// Fonction pour lire le nom du fichier
void readFileName(unsigned int file_num, char *file_name) {
readBlock(file_num, 0, (unsigned char *)file_name, MAX_FILENAME_LENGTH);
file_name[MAX_FILENAME_LENGTH] = '\0'; // Ajout du caractère null-terminator pour former une chaîne de caractères
}

ReX : Non, aucune raison que le fichier de numéro n soit au bloc n. Dessine la représentation d'un fichier sur le SF en comptant les octets si cela peut aider.

'''Fonction writeFileName:'''
// Fonction pour écrire le nom du fichier
void writeFileName(unsigned int file_num, const char *file_name) {
writeBlock(file_num, 0, (const unsigned char *)file_name, MAX_FILENAME_LENGTH);
}

ReX : Faux et inutile pour l'instant. Problème avec la constante MAX_FILENAME_LENGTH.

=== Fonction LS version 1 ===
// Fonction LS pour afficher les fichiers présents dans le système de fichiers
void LS(const char *filesystem_path) {
FILE *file = fopen(filesystem_path, "rb");
if (file == NULL) {
perror("Erreur lors de l'ouverture du fichier système");
return;
}
uint16_t num_files;
fread(&num_files, sizeof(uint16_t), 1, file); // Lecture du nombre de fichiers dans le système
char filename[17];
printf("Fichiers présents dans le système de fichiers:\n");
for (int i = 0; i < num_files; i++) {
readFileName(i, filename); // Lecture du nom du fichier
printf("%s\n", filename); // Affichage du nom du fichier
}
fclose(file);
}
La fonction <code>LS</code> ouvre le fichier système, lit le nombre de fichiers qu'il contient, puis affiche les noms des fichiers un par un, chacun sur une ligne séparée.

ReX : Il y a le nombre de fichiers dans ton superbloc ? Un dessin du format du superbloc avec les numéros des octets ?

ReX : Tout accès au système de fichiers doit se faire avec les deux fonctions <code>readBlock</code> et <code>writeBlock</code>.

== Semaine 3 ==
Question 1: cela fait plusieurs fois que vous mentionnez dans le wiki un "superbloc". Celui-ci n'étant pas clairement défini dans le sujet, je me demande s'il s'agit du bloc crée grâce à la fonction dd, c'est à dire que le superbloc serait en faite le bloc constitué des 31250 blocs de taille 256 octets, où s'il s'agit d'un bloc qui vient en entête, celui contenant alors des informations décrivant le système de fichier (les noms de fichiers...).

ReX : Pour ton pico système de fichiers, le superbloc consiste en les premiers blocs (de 256 octets) qui définissent les 64 fichiers possibles.

Proposition de structure: on pourrait réserver les premiers blocs du système de fichiers aux noms de fichiers ainsi qu'aux numéros des blocs correspondant à chaque fichier.

ReX : Oui c'est évident.

On sait que les noms de fichiers font au maximum 16 caractères + 1 caractère pour le '\0' (donc 17 octets car 1 char=1 octet).

ReX : Non, 16 octets suffisent, des '\0' en fin de nom uniquement si le nom fait moins de 16 caractères.

On sait également qu'un fichier contient au maximum 2040 blocs, chaque bloc étant numéroté sur 2 octets. On pourrait donc avoir en début du système de fichier: 17 octets+2 octets*2040 blocs = 4097 octets pour la description d'un fichier.

ReX : Non, 4096 octets soit 16 blocs de 256.

Or d'après l'une de vos remarques dans le wiki, un fichier doit être décrit par un nombre entier de blocs. Pour un fichier, il nous faudra donc 4097/256=16.004 soit 17 blocs. Il peut y avoir jusqu'à 64 fichiers dans le répertoire, il nous faudra donc 17 blocs*64 fichiers= 1088 blocs pour la description des fichiers.

ReX : Non 1024 blocs de 256 octets dans le superbloc.

Ainsi, pour la fonction LS, il suffira de lire les premiers caractères tous les 17 blocs ( du premier caractère au caractère '\0').

ReX : Non, tous les 16 blocs.

Question 2: Ne faudrait-il pas également stocker quelque part le nombre de fichier qu'il y a dans le répertoire afin de savoir jusqu'à quel bloc la fonction LS doit aller ?

ReX : Non, un fichier dont le nom n'est constitué que de '\0' est réputé ne pas exister.

Question 3: on a donc vu que les 1088 premiers blocs au maximum serviraient à la description du système de fichier. Il reste donc 31250-1088=30132 blocs dans le système de fichier.

ReX : Non, 32768-1024=31744 blocs.

Comment utiliser ces blocs? Ces blocs doivent-ils stocker le contenu des fichiers ?

ReX : Oui, c'et évident.

En effet, avec la fonction TYPE, nous allons créer des fichiers et ces fichiers devront être stockés quelque part. Cependant, étant donné que ce pico système de fichiers est prévu pour un microcontrôleur, je ne sais pas si c'est le contenu des fichiers qui doit être stocké dans les blocs ou autre chose (peut être l'adresse des fichiers, le fichiers se trouvant autre part). En effet, je me dis que si un fichier est très volumineux, il ne pourra pas rentrer dans le système de fichier, ce dernier étant composé d'un nombre limité de blocs, et les blocs étant eux même limité en nombre d'octets.

ReX : Je ne comprend pas ton problème. De tout façon comme dit plus haut, les 31744 blocs suivant le superbloc doivent contenir les données des fichiers.

Désolé de poser des questions peut être basique aussi tard, mais je pense qu'une fois que j'aurai ces réponses, cela ira beaucoup mieux pour la suite. Merci d'avance pour vos réponses.

ReX : Les questions sont effectivement triviales et il est effectivement inquiétant que voir que la travail n'avance pas.

Amine: merci pour vos corrections.

D'après votre commentaire "32768-1024=31744 blocs", j'en déduis qu'il faut que je modifie ma commande dd (qui est actuellement "dd if=/dev/zero of=filesystem.bin bs=256 count=31250" pour avoir le bon filesystem).

ReX : Je comprends pas d'où tu sors le 31250. D'autant plus que la commande ci-dessous est bonne.

Amine : 31250 car 31250 blocs * 256 octets = 8 Mo.

ReX : Haaaa je vois tu utilises le système métrique international où le mégaoctet vaut 10^6 octets, sauf qu'aucun informaticien n'utilisera cette norme hors sol. Quand je parle de 8 Mo c'est 8x1024x1024 octets. Tout simplement parce qu'une puce mémoire de 8 Mo c'est bien 8x1024x1024 octets.

Amine: D'accord merci pour l'information !

'''Nouvelle commande dd:'''

dd if=/dev/zero of=filesystem.bin bs=256 count=32768

=== Fonction LS version 2 ===

Dans notre structure du système de fichier, le superbloc est constitué de 1024 blocs (16 blocs * 64 fichiers), un fichier étant décrit par 16 blocs. Le nom du fichier est donc écrit au début de tous les blocs multiples de 16. Par exemple, le nom du premier fichier est dans les 16 premiers octets du premier bloc, le nom du 2ème fichier est dans les 16 premiers octets du 32ème bloc et ainsi de suite, tant que des fichiers existent. Lorsque qu'il n'y a plus de fichier, le nom du premier caractère du bloc multiple de 16 est un 0.

Voici le code:
// Fonction pour lister les noms de fichiers présents dans le système de fichiers
void LS() {
unsigned char buffer[BLOCK_SIZE];
int fileCount = 0;

for (int blockNum = 1; blockNum <= MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, BLOCK_SIZE);

// Vérifier si le bloc est vide
if (buffer[0] == 0) {
break; // Plus de fichiers à lire
}

char filename[MAX_FILENAME_LENGTH];
memcpy(filename, buffer, MAX_FILENAME_LENGTH);

// Afficher le nom du fichier
printf("%s\n", filename);
fileCount++;
}

if (fileCount == 0) {
printf("Aucun fichier trouvé.\n");
}
}

ReX : Tu supposes que si un fichier a un nom vide, les suivants auront aussi un nom vide. C'est possible mais dans ce cas la commande <code>RM</code> ca être plus compliquée à écrire.

ReX : Tu ne sembles pas comprendre que la mémoire d'un microcontrôleur est limitée. Pourquoi lire le premier bloc de description d'un fichier en entier ? Dit autrement c'est quoi l'intérêt de lire 256 octets alors que 16 suffisent ?

ReX : Pourquoi tu ne lis pas le premier fichier ? Autrement dit pourquoi décaler tout d'un bloc ?

Amine: Merci pour vos remarques. J'ai apporté les modifications à LS dans la section "Semaine 4" du wiki.

'''Réflexion par rapport aux autres fonctions:'''

J'ai créé les fonctions TYPE et CAT mais il y a malheureusement un problème pour l'instant. Vous pouvez les retrouver en pièce jointe dans l'archive du fichier programme.c.

Le problème que j'ai est que lorsque j'affiche le contenu du fichier créé avec TYPE, j'obtiens plein de caractères spéciaux. Par exemple, je créé le fichier "mon_fichier.txt" avec la fonction TYPE, et je mets en entré standard "hello". Ensuite, je veux afficher le contenu de ce fichier grâce à la fonction CAT. Cependant, ce qui s'affiche dans le terminal n'est pas ce que je veux. De la même manière, lorsque je fais la commande "cat filesystem.bin" dans le terminal, c'est la même chose s'affiche, des donnés parasites.

ReX : Avant même de lire ton code je vais te poser la question de savoir comment tu récupères un bloc libre ? Quel algorithme tu utilises. Personnellement je ne sais pas faire sans ajouter au superbloc un tableau bit à bit des blocs libres. Pour avoir un bit pour chaque bloc du système de fichiers, il faut 32768/8=4096 octets soit 16 blocs.

Amine: ok je vais donc ajouter ce tableau de 16 blocs à la suite de mes premiers 1024 blocs servant à la description de fichier. Le superbloc fera maintenant 1024+16=1040 blocs (plus de détail à la fonction RM de la semaine 4).

Question 1: est ce que la fonction CAT que je dois créer doit renvoyer la même chose que "cat filesystem.bin" ?

ReX : Je préfère ne pas répondre tellement la question montre un manque de réflexion.

Question 2: comment savoir combien de blocs doivent etre attribué à un fichier? Par exemple, si je créé un fichier "mon_fichier.txt" et que je mets en entrée standard le texte "hello", un seul bloc suffi pour stocker ce texte. Cependant, si j'avais mis beaucoup de texte en entrée standard, il aurait fallu plus de blocs. Doit-on calculer la taille de l'entrée standard ou doit-on attribuer toujours le meme nombre de blocs à un fichier? Peut-etre ainsi attribuer 2040 blocs par fichier, meme s'il n'en utilise que 1.

ReX : Là encore c'est une question stupéfiante tellement la réponse est évidente. Il suffit de lire les données sur l'entrée standard et de passer au bloc de données suivant dès que le bloc courant est rempli. La question à poser c'était de se demander comment il est possible d'avoir la taille exacte du fichier pour un <code>CAT</code>. Il est uniquement possible de l'avoir à 256 octets près puisque rien n'indique si le dernier block est vide. Le mieux aurait été de prévoir 4 octets dans la description d'un fichier pour stocker la taille. En l'espèce on considérera que les fichiers sont des fichiers ASCII et qu'ils seront terminés par des <code>\'0</code> qui ne seront pas affichés.

== Semaine 4 ==

Voici un bilan de ce que j'ai fait à ce stade du projet:

* j'ai choisi une structure du système de fichier
* j'ai créé les fonctions readBlock et writeBlock permettant de lire et d'écrire des blocs
* j'ai crée la fonction LS permettant d'afficher le nom des fichiers présents dans le système de fichiers
* j'ai programmer un main permettant d'utiliser les fonctions (LS, TYPE...) depuis le terminal
* j'ai réflechi aux fonctions TYPE et CAT.

Actuellement, je suis en train de créer les fonctions TYPE et CAT.

=== Fonction LS version 3 ===
void LS() {
unsigned char buffer[MAX_FILENAME_LENGTH];
int fileCount = 0;

// Parcourir tous les 16 blocs de 0 jusqu'à MAX_FILES_IN_DIRECTORY
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, MAX_FILENAME_LENGTH);

// Vérifier si le nom de fichier est vide
if (buffer[0] != 0) {

// Afficher le nom du fichier
printf("%s\n", buffer);
fileCount++;
}
}

if (fileCount == 0) {
printf("Aucun fichier trouvé.\n");
}
}
Suite à vos remarques, j'ai effectué les modifications suivantes de la fonction LS:

* Je ne suppose plus que si un fichier a un nom vide, les autres auront aussi un nom vide.
* Je ne lis plus les 256 octets mais seulement les 16 premiers octets car cela suffit.
* Je ne lisais en effet pas le premier bloc. Je pensais que le premier bloc était d'indice 1 mais ce n'est pas le cas.

ReX : Ouiiii ! Une fonction correcte. Passe à <code>RM</code> maintenant, c'est la plus facile à faire concernant l'image bit à bit des blocs libres.

=== Fonction setBlockAvailability version 1 ===

Comme vous l'avez indiqué dans votre remarque, il faut un tableau dans le superbloc qui nous permettra de connaitre la disponibilité bit par bit de chaque bloc. Sachant qu'il y a dans notre système de fichiers 32768 blocs, et qu'il faut 1 bit par bloc, nous avons besoin de 32768 bits, soit 32768/8=4096 octets soit 4096/256=16 blocs. Notre superbloc sera donc comme suit: les 1024 premiers blocs servent à la description des fichiers, c'est à dire à leur nom suivi des numéros de blocs qui leur sont associés, puis ces 1024 blocs sont suivi de 16 blocs listant la disponibilité de chaque bloc.

ReX : Bien résumé.

Nous allons tout d'abord écrire la fonction "setBlockAvailability" prenant en paramètre le numéro du bloc à traiter (<code>blockNum</code>) et la disponibilité souhaitée pour ce bloc (<code>availability</code>). Cette fonction permet de marquer la disponibilité d'un bloc spécifique dans le système de fichiers. Nous utiliserons la convention suivante: un bloc disponible sera marqué par un 1 tandis qu'un bloc non disponible par un 0.
#define SUPERBLOCK_START_BLOCK 1024

void setBlockAvailability(int blockNum, int availability) {
// Calculer l'index du byte et le bit offset correspondant
int byteIndex = blockNum / 8;
int bitOffset = blockNum % 8;

// Lire le byte existant du bloc de disponibilité des blocs
unsigned char buffer[1];
readBlock(SUPERBLOCK_START_BLOCK + byteIndex, 0, buffer, 1);

// Mettre à jour le bit d'offset correspondant
if (availability) {
buffer[0] |= (1 << bitOffset);
} else {
buffer[0] &= ~(1 << bitOffset);
}

// Écrire le byte mis à jour dans le bloc de disponibilité des blocs
writeBlock(SUPERBLOCK_START_BLOCK + byteIndex, 0, buffer, 1);
}

ReX : Un tableau de un octet c'est un octet (variable <code>buffer</code>).

Amine: je vais utiliser un <code>unsigned char buffer.</code> Je suis conscient qu'un char vaut un octet mais je ne pense pas qu'il y ait un type de donnée de la taille d'un bit, c'est pourquoi je travaille avec un octet mais je modifie les bits de cet octet grâce aux algorithmes.

ReX : Il faut bien que tu travailles sur un octet vu que l'état des blocs est stocké sous la forme d'octets. Je disais juste qu'un tableau de 1 élément n'a pas d'intérêt par rapport à l'élément lui-même.

Amine: c'est vrai, modification faite.

ReX : Non il faut calculer le numéro du bloc avant de faire le <code>readBlock</code>.

Amine: ok je vais calculer le numéro de bloc avant.

ReX : La mise à jour du bit est correcte mais le block et le déplacement dans le block ne sont pas correctement calculés.

Amine: je vais vous expliquer le raisonnement que j'avais. Prenons un exemple concret, imaginons que je veuille marquer le bloc 1030 comme disponible:

# Calcul de l'index de l'octet et du bit offset :
#* <code>blockNum</code> = 1030
#* Index du byte = 1030 / 8 = 128
#* Bit offset = 1030 % 8 = 6
# Lecture de l'octet existant de disponibilité:
#* Nous lisons l'octet existant à l'index 128 dans les blocs de disponibilité.
# Mise à jour du bit de disponibilité :
#* Nous voulons marquer le bloc 1030 comme disponible, donc nous utilisons le masque <code>(1 << 6)</code> pour définir le bit 6 à 1 dans l'octet. Le résultat sera, par exemple, <code>00100000</code>.
# Écriture du byte mis à jour :
#* Nous écrivons le byte mis à jour <code>00100000</code> à l'index 128 dans les blocs de disponibilité.

ReX : Ben non, un vrai exemple :
* Il faut prendre un n° de bloc plus grand : 3072 ;
* Numéro d'octet dans la carte des blocs libres : 3072/8=384 ;
* Numéro du bloc dans la carte des blocs libres : 384/256=1 ;
* Numéro du bit <code>b</code> dans l'octet n° 384-256=128 du bloc 1 : 3072%8=0 ;
* Il faut donc lire l'octet <code>o</code> de numéro 128 du bloc 1, puis modifier cet octet par <code>o |= (1<<b)</code> ou <code>o &= ~(1<<b)</code> ;
* Enfin il faut écrire l'octet modifié dans le bloc 1.
Amine: merci pour cet exemple! J'ai compris d'où vient mon erreur. Voir fonction setBlockAvailability version 3.

Remarque: par convention, j'apellerai dans la suite de ce projet "premier superbloc" le superbloc correspondant à la description des fichiers, c'est à dire les 1024 premiers blocs, et j'appellerai "second superbloc" les 16 blocs qui suivent servant à décrire la disponibilité des blocs (du bloc 1024 au bloc 1039 inclu). Le reste des blocs servira à stocker les données.

ReX : Non, le superblc est l'ensemble des informations hors blocs de données, tu ne peux pas utiliser un vocabulaire au hasard. Parle de blocs de description des fichiers ou de carte des blocs libres.

Amine: ok

Je pense que le problème qui se pose est que l'indice du bit dans le second superbloc ne correspond pas à l'indice du bloc dans le système de fichier. Par exemple, nous voudrions que si le bloc 1030 est disponible dans le système de fichier, alors le bit numéro 1030 du deuxième superbloc soit à 1, ce qui n'est pas le cas ici. En effet, on se trouve bien dans le bon octet avec ma méthode mais l'écriture du bit se fait de la droite vers la gauche alors qu'on voudrait l'inverse. Ainsi, si le 6ème bit de l'octet doit être à 1, alors il faudrait qu'on obtienne <code>00000100</code> et non <code>00100000.</code> L'indice du bit coinciderait ainsi avec le numéro du bloc.

ReX : Non, réfléchit à nouveau.

Voir plus bas la nouvelle version de setBlockAvailability.

Explication de l'algorithme pour mettre le bit à 1 ou 0:

* <code>buffer[0] |= (1 << bitOffset);</code> : Cette ligne utilise l'opérateur OR bit à bit (<code>|=</code>) pour activer (mettre à 1) le bit spécifié par <code>bitOffset</code> dans le premier octet (<code>buffer[0]</code>). Cela se fait en décalant le bit 1 vers la gauche de <code>bitOffset</code> positions, puis en effectuant une opération OR bit à bit avec le contenu actuel de <code>buffer[0]</code>. Cette opération modifie uniquement le bit ciblé, laissant les autres bits inchangés.

ReX : Oui ça c'est bon.

* <code>buffer[0] &= ~(1 << bitOffset);</code> : Cette ligne utilise l'opérateur AND bit à bit (<code>&=</code>) pour désactiver (mettre à 0) le bit spécifié par <code>bitOffset</code> dans <code>buffer[0]</code>. Pour ce faire, l'expression <code>~(1 << bitOffset)</code> est utilisée pour créer un masque où tous les bits sont à 1, sauf celui correspondant à <code>bitOffset</code>, qui est à 0. En effectuant ensuite une opération AND bit à bit entre le masque et le contenu actuel de <code>buffer[0]</code>, on met à 0 le bit ciblé sans affecter les autres bits.

ReX : Ca aussi.

=== Fonction setBlockAvailability version 2 ===

void setBlockAvailability(int blockNum, int availability) {
// Calculer l'indice de l'octet et le bit offset correspondant
int byteIndex = blockNum / 8;
int bitOffset = 7 - (blockNum % 8); // Inversion de l'ordre des bits

// Calculer le numéro du bloc du super bloc où se trouve l'octet de disponibilité correspondant
int availabilityBlockNum = SUPERBLOCK_START_BLOCK + byteIndex;

// Lire l'octet existant dans le bloc de disponibilité du super bloc
unsigned char buffer;
readBlock(availabilityBlockNum, 0, &buffer, 1);

// Mettre à jour le bit d'offset correspondant :
if (availability) {
buffer |= (1 << bitOffset);
} else {
buffer &= ~(1 << bitOffset);
}

// Écrire l'octet mis à jour dans le bloc de disponibilité du super bloc
writeBlock(availabilityBlockNum, 0, &buffer, 1);
}
J'ai modifié la ligne <code>int bitOffset = 7 - (blockNum % 8);</code> pour inverser l'ordre des bits sélectionnés, de sorte que le bit correspondant au bloc disponible soit correct.

ReX : Encore plus faux.

Si on veut rendre le bloc 1030 indisponible alors que les autres blocs sont disponibles:

ReX : Pardon ? Le bloc de données est libre ou pas suivant la carte des blocs libres. Le rendre disponible n'est possible que si un fichier le comportant est détruit.

# Calcul de l'indice de l'octet et du bit offset correspondant :
#* <code>blockNum = 1030</code>
#* <code>byteIndex = 1030 / 8 = 128</code>
#* <code>bitOffset = 7 - 1030 % 8 = 1</code> Cela signifie que le bit d'intérêt se trouve à la position 2 dans l'octet.
# Calcul du numéro du bloc du super bloc où se trouve l'octet de disponibilité correspondant :
#* <code>availabilityBlockNum = SUPERBLOCK_START_BLOCK + 128 = 1024 + 128 = 1152</code> Donc, nous devons accéder à l'octet 1152 pour mettre à jour la disponibilité du bloc 1030.
# Lecture de l'octet existant dans le bloc de disponibilité du super bloc :
#* Le contenu de l'octet dans le bloc 1152 avant la mise à jour : 11111111 (en binaire)
# Mise à jour du bit d'offset correspondant :
#* Supposons que nous voulions marquer le bloc 1030 comme non disponible (<code>availability = 0</code>).
#* Le bitOffset est 1.
#* Nous effectuons une opération AND avec le complément du bit à la position 1 : <code>11111111 & 11111101 = 11111101</code>
# Écriture de l'octet mis à jour dans le bloc de disponibilité du super bloc :
#* Le contenu de l'octet 128 du second superbloc après la mise à jour : 11111101 (en binaire)

ReX : Toujours aussi faux.

Maintenant, le bit d'indice 1 du 128 ème octet du second superbloc est mis à 0, indiquant que le bloc 1030 n'est plus disponible. Les autres bits restent inchangés car nous avons effectué un AND avec un masque binaire qui avait des 1 partout sauf à la position du bit que nous souhaitions mettre à 0.

ReX : Erreur sur erreur.

=== Fonction setBlockAvailability version 3 ===
J'ai compris d'où vient l'erreur. La fonction readBlock prends en premier paramètre le numéro du bloc à lire, je ne peux donc pas lui donner la valeur "SUPERBLOCK_START_BLOCK + byteIndex" car byteIndex s'exprime en octet alors qu'on s'attend à un nombre de bloc ici. Il faut donc divisé byteIndex par 256 pour être en unité "bloc", et préciser le bit qu'on veut lire grâce à l'offset.

Pour obtenir l'octet que l'on veut, il faut prendre le reste de la division de byteIndex par 256. On va ensuite stocker cet octet dans notre "buffer".

Pour savoir quel bit modifier dans ce "buffer", on va prendre le reste de la division du bloc dont on veut mettre à jour la disponibilité par 8. On va ainsi pouvoir modifier ce bit grâce à l'algorithme, puis réécrire l'octet à son emplacement d'origine.

Cette fonction gère la carte de disponibilités des blocs. Si un bloc est disponible, alors elle le met un 0, si il est indisponible, elle met un 1.
#define SUPERBLOCK_START_BLOCK 1024

void setBlockAvailability(int blockNum, int availability) {

int byteIndexInCard = blockNum / 8; //Numéro d'octet dans la carte des blocs libres
int blockIndexInCard = byteIndexInCard / 256; //Numéro du bloc dans la carte des blocs libres
int byteIndexInBlock = byteIndexInCard % 256; //Numéro d'octet dans le bloc contenant le bit de disponibilité
int bitOffset = blockNum % 8; //Numéro du bit dans l'octet n°byteIndexInBlock du bloc blockIndexInCard

//indice du bloc contenant le bit à mettre à jour dans le bloc de description
int availabilityBlockNum = FIRST_DISPONIBILITY_CARD_BLOCK + blockIndexInCard;

// Lire l'octet existant dans le bloc de disponibilité du super bloc
unsigned char buffer;
readBlock(availabilityBlockNum, byteIndexInBlock, &buffer, 1);

// Mettre à jour le bit d'offset correspondant :
if (availability==1) { // indisponible
buffer |= (1 << bitOffset); // Mettre le bit à 1

} else { // disponible
buffer &= ~(1 << bitOffset); // Mettre le bit à 0
}

// Écrire l'octet mis à jour dans le bloc de disponibilité du super bloc
writeBlock(availabilityBlockNum, byteIndexInBlock, &buffer, 1);
}

ReX : Ben voila, c'est pas possible de te taxer d'excès de vitesse mais c'est bon.

update: j'ai fait une petite modification, maintenant un bloc disponible est marqué d'un 0 et un bloc indisponible est marqué d'un 1. C'est mieux dans la mesure où initialement, tous les blocs sont disponibles et tous les blocs sont à 0. Cela évite de devoir créer une fonction qui initialise toute la carte de disponibilités à 1 pour dire que tous les blocs sont disponibles.

=== Fonction RM version 1 ===

void RM(const char *filesystem_path, const char *filename) {
unsigned char buffer[BLOCK_SIZE];
int fileNum = -1;

// Parcourir les blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (memcmp(filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {
// Effacer le nom du fichier dans le superbloc
memset(filenameBuffer, 0, MAX_FILENAME_LENGTH);
writeBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

unsigned char fileBuffer[MAX_BLOCKS_PER_FILE * 2];
readBlock(blockNum, MAX_FILENAME_LENGTH, fileBuffer, MAX_BLOCKS_PER_FILE * 2);

// Libérer les blocs associés au fichier et réinitialiser les numéros de blocs
for (int i = 0; i < MAX_BLOCKS_PER_FILE * 2; i += 2) {
int blockNum = ((int)fileBuffer[i] << 8) + (int)fileBuffer[i + 1];
if (blockNum == 0) {
break; // Fin du fichier
}
setBlockAvailability(blockNum, 0); // Marquer le bloc comme disponible
fileBuffer[i] = 0;
fileBuffer[i + 1] = 0;
}

// Mettre à jour les numéros de blocs associés au fichier
writeBlock(blockNum, MAX_FILENAME_LENGTH, fileBuffer, MAX_BLOCKS_PER_FILE * 2);

fileNum = blockNum;
break; // Fichier trouvé, sortir de la boucle
}
}

// Afficher le résultat de l'opération
if (fileNum == -1) {
printf("Le fichier \"%s\" n'a pas été trouvé.\n", filename);
} else {
printf("Le fichier \"%s\" a été supprimé avec succès.\n", filename);
}
}

ReX : Vous utilisez <code>strcmp</code> comme <code>strncmp</code>. C'est bien la dernière qu'il faut utiliser mais en précisant la longueur du nom en paramètre, pas la taille maximale.

Amine: vous voulez dire que j'utilise memcmp au lieu de strncmp ? Ok je vais utiliser strncmp, c'est vrai que c'est plus adapté pour la comparaison de chaines de caractère.

ReX : Ha oui c'est <code>memcmp</code> que tu utilises. Ca ne peut effectivement pas marcher. Effectivement avec <code>strncmp</code> cela peut marcher vu qu'il s'arrête au premier 0 contrairement à <code>memcmp</code>.

Cependant, pourquoi doit-on passer la taille exacte du nom du fichier en paramètre, et non la taille maximale d'un nom de fichier? En effet, cela semble fonctionner en mettant la taille maximale en paramètre, tandis que lorsque l'on met la taille exacte du nom du fichier, cela pose un problème: on ne compare plus toute la chaîne de caractère mais seulement une portion du nom complet. Ainsi, si je crée par exemple un fichier que j'appelle "file1", puis que j’exécute la fonction RM "/picofs filesystem.bin RM file" par exemple, alors le fichier file1 va être supprimé quand même car on ne comparera que strlen(file)=4 premiers caractères, qui sont les mêmes, donc la fonction considérera ces chaines comme identiques. On pourrait alors se dire qu'il faudrait alors prendre plutôt comme taille en paramètre de la fonction strlen la taille du nom du fichier se trouvant dans le système de fichier plutôt que celle du nom donné en paramètre de RM. Cependant, le même problème se pose si la taille du nom du fichier du système de fichier est plus petite que celle du nom du fichier passé en paramètre. Par exemple, si le fichier présent dans système de fichier est "file", et qu'on met la longueur de file en paramètre de la fonction strcmp, puis qu'on exécute la commande "/picofs filesystem.bin RM file5", alors file sera quand même supprimé, car on ne comparera que les strlen(file)=4 premiers caractère. Finalement, une solution serait de rajouter une condition qui vérifie que les deux chaînes sont de taille identiques pour pouvoir réaliser la comparaison sur la taille exacte du nom du fichier. Cependant, il me semble qu'en mettant MAX_FILENAME_LENGTH qui vaut 16 en paramètre, cela fonctionne directement. Vous pouvez tester cela en testant mon programme.

ReX : Ok pour <code>strncmp</code> avec la taille maximale d'un nom de fichier.

etape 1: créer un fichier :
./picofs filesystem.bin TYPE fichier.txt

etape 2: verifier que le fichier a bien été créé :
./picofs filesystem.bin LS

Le terminal renvoie bien "fichier.txt"

etape 3: essayer de supprimer le fichier en mettant une chaine troncature du nom du fichier créé :
./picofs filesystem.bin RM fich

le terminal renvoi <<Le fichier "fich" n'a pas été trouvé.>>, le fichier n'a donc pas été supprimé .

etape 4: essayer de supprimer le fichier en mettant un nom plus grand incluant "fichier.txt" :
./picofs filesystem.bin RM fichier.txtt

terminal renvoi <<Le fichier "fichier.txtt" n'a pas été trouvé.>>

etape 5: enfin, tester en mettant le nom exacte du fichier que l'on veut supprimer :
./picofs filesystem.bin RM fichier.txt

terminal renvoi <<Le fichier "fichier.txt" a été supprimé avec succès.>>

Finalement, on voit que cela fonctionne avec la taille maximale mise en paramètre. On pourrait reprocher à cette méthode de comparer des caractères dans le vide, ce qui n'est pas optimal dans une optique d'économie de mémoire qui est la notre, mais la taille maximale d'un nom de fichier étant relativement faible (16 octets), on peut peut-être négliger cela au vu de l'économie d'une opération supplémentaire (comparaison de la taille des chaines de caractères).

ReX : Le parcours des blocs de données du fichier est atroce. Il faut parcourir les numéros de blocs dans le premier bloc du fichier derrière le nom du fichier puis il faut parcourir le 15 autres blocs.

Amine: Ok, je vais corriger cela dans la version 2 de RM (voir semaine 5).

Fonctionnement de la fonction RM:

* Parcours des blocs réservés pour la description des fichiers (superbloc) à partir du bloc 0, en incrémentant de 16 à chaque itération pour accéder aux blocs de noms de fichiers.

ReX : OK.

* Dans chaque bloc de noms de fichiers, la fonction compare le nom de fichier recherché avec les noms stockés dans les 16 octets de chaque bloc.

ReX : Non la fonction ne fait pas ça par contre il faudrait, oui.

Amine: Je pensais que c'était ce que je faisais avec "memcmp(filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0)".

* Si le nom de fichier est trouvé, la fonction efface le nom du fichier dans le superbloc en remplaçant les 16 octets du bloc par des zéros.

ReX : OK.

* Ensuite, la fonction accède aux octets suivants du même bloc pour obtenir les numéros de blocs associés au fichier.

ReX : Non, la boucle sort largement du premier bloc.

* Pour chaque paire de numéros de blocs (2 octets chacun), la fonction convertit les octets en un numéro de bloc. Si le numéro de bloc est nul, cela signifie la fin des blocs associés au fichier, sinon, la fonction marque ce bloc comme disponible en utilisant la fonction <code>setBlockAvailability</code> et réinitialise les numéros de blocs dans le tableau à zéro.
* Les numéros de blocs réinitialisés sont ensuite réécrits dans le bloc de description du fichier.

ReX : L'idée est là mais vu que la boucle n'est pas bonne, rien ne peut marcher.

* La fonction affiche ensuite un message indiquant le résultat de l'opération : soit que le fichier a été supprimé avec succès, soit que le fichier n'a pas été trouvé.

== Semaine 5 ==

=== Fonction RM version 2 ===

Concernant les remarques que vous m'avez faites précédemment:

* j'utilise maintenant la fonction <code>strncmp</code> pour la comparaison des chaines de caractères
* j'ai normalement corrigé le parcours des blocs. Je parcours maintenant d'abord les blocs multiples de 16 à la recherche du bloc contenant le nom du fichier à supprimer. Puis je parcours les 16 blocs de description du fichier à supprimer, afin de récupérer les numéros de blocs, libérer ces blocs dans la carte de disponibilité et de réinitialiser ces blocs dans les blocs de données.

void RM(const char *filesystem_path, const char *filename) {
int fileFound = -1;
int offset;

// Parcourir les blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char*)filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {

// Effacer le nom du fichier dans le superbloc
memset(filenameBuffer, 0, MAX_FILENAME_LENGTH);
writeBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);
fileFound = 1;
offset = blockNum;
break;
}

}

// Fin de fonction si fichier inexistant
if (fileFound == -1) {
printf("Le fichier \"%s\" n'a pas été trouvé.\n", filename);
return;
}

unsigned char buffer[BLOCK_SIZE];
//bloc que l'on va remplir de 0 et mettre à la place des blocs de données
memset(buffer, 0, BLOCK_SIZE); //on rempli buffer de 0

for (int blockNum=offset; blockNum<offset + 16; blockNum++) {

//premier bloc de description, celui contenant le nom du fichier dans les 16 premiers octets
if (blockNum == offset) {

unsigned char fileBuffer[BLOCK_SIZE-MAX_FILENAME_LENGTH];
//bloc dans lequel on va stocker les blocs de description de fichier
readBlock(blockNum, MAX_FILENAME_LENGTH, fileBuffer, BLOCK_SIZE-MAX_FILENAME_LENGTH);

// Libérer les blocs associés au fichier dans la carte de disponibilités
// et dans les blocs de description
for (int i = MAX_FILENAME_LENGTH; i < BLOCK_SIZE-MAX_FILENAME_LENGTH; i += 2) {
int blockNumData = ((int)fileBuffer[i] << 8) + (int)fileBuffer[i + 1];
if (blockNumData == 0) {
break; // Fin du fichier
}
setBlockAvailability(blockNumData, 0); // Marquer le bloc comme disponible
fileBuffer[i] = 0;
fileBuffer[i + 1] = 0;
writeBlock(blockNumData, 0, buffer, BLOCK_SIZE); //on efface les blocs de données
}
writeBlock(blockNum, MAX_FILENAME_LENGTH, fileBuffer, BLOCK_SIZE-MAX_FILENAME_LENGTH);
//on efface le premier bloc de description

} else {
unsigned char fileBuffer[BLOCK_SIZE];
readBlock(blockNum, 0, fileBuffer, BLOCK_SIZE);

// Libérer les blocs associés au fichier dans la carte de disponibilités et dans les blocs de description
for (int i = 0; i < BLOCK_SIZE; i += 2) {
int blockNumData = ((int)fileBuffer[i] << 8) + (int)fileBuffer[i + 1];
if (blockNumData == 0) {
break; // Fin du fichier
}
setBlockAvailability(blockNumData, 0); // Marquer le bloc comme disponible
fileBuffer[i] = 0;
fileBuffer[i + 1] = 0;
writeBlock(blockNumData, 0, buffer, BLOCK_SIZE); //on efface les blocs de données
}
writeBlock(blockNum, 0, fileBuffer, BLOCK_SIZE); //on efface le bloc de description
}
}
printf("Le fichier \"%s\" a été supprimé avec succès.\n", filename);
}

ReX : Pour construire le nombre sur 16 bits utiliser le OU plutôt que l'addition.

ReX : Heu non, je ne lis pas cette fonction avec tout ce code dupliqué, la seule différence entre les deux alternative est la position de début de l'adresse du premier bloc de données (<code>MAX_FILENAME_LENGTH</code> dans un cas et 0 dans l'autre). Donc l'alternative ne doit servir qu'à initialiser ce début, le reste du code doit être factorisé.

ReX : Et corrige le code, tu utilises deux tableaux de blocs (perte mémoire), tu écris le bloc à zéro dans l'itération (perte CPU).

=== Fonction RM version 3 ===

Suite à vos remarques, j'ai réalisé les modifications suivantes:

* j'utilise maintenant le OU plutôt que l'addition pour construire le nombre sur 16 bits.

* j'ai factorisé le code grâce à la création de la variable <code>startOffset</code> valant 16 lorsqu'on se trouve dans le bloc contenant le nom du fichier et valant 0 lorsqu'on se trouve dans les autres.

* Pour ce qui est du fait que j'utilise 2 tableaux de blocs, j'ai du mal à voir comment faire avec 1 seul tableau de blocs car ces deux tableaux n'ont pas du tout le même rôle. Le tableau <code>fileBuffer</code> permet de stocker les 16 blocs de description d'un fichier un à un. Lorsqu'on stocke un bloc dans <code>fileBuffer</code>, on lit ensuite les octets un à un de ce bloc afin de former des numéros de blocs, et pour chaque numéro de bloc créé, on va réinitialiser le bloc correspondant dans les blocs de données. Pour cela, on a donc besoin d'un autre bloc qui viendra écraser les anciens blocs de données. C'est pourquoi j'ai créé un bloc <code>buffer</code>qui est composé de 0 et qui va écraser les blocs de données. On ne peut pas utiliser <code>fileBuffer</code> car on a besoin d'un bloc de zéros, et si on réinitialise <code>fileBuffer</code> on perd toute les données qui s'y trouvent. Une possibilité serait de relire le bloc de donné à chaque itération de la deuxième boucle for imbriquée; cela permettrait de pouvoir réinitialiser le tableau fileBuffer à chaque itérations de cette boucle afin de stocker ce bloc de 0 dans les blocs de données, puis de restocker dans ce même tableau le bloc de description. Cependant, je ne pense pas que ce soit optimal de faire autant appel à la fonction readBlock.

* j'ai créé une fonction resetBock qui permet comme son nom l'indique de reset un bloc en le remplissant de 0. Cela nous évite de créer deux tableaux de blocs dans RM, bien que je pense que cela revienne au même car on fait appel à une fonction qui créé un tableau de blocs. Quoi qu'il en soit, cela allège le code et cette fonction pourra surement me resservir par la suite.

void RM(const char *filesystem_path, const char *filename) {
int fileFound = -1;
int offset;
unsigned char fileBuffer[BLOCK_SIZE];

// Parcourir les blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char *)filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {
// Effacer le nom du fichier dans le superbloc
memset(filenameBuffer, 0, MAX_FILENAME_LENGTH);
writeBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);
fileFound = 1;
offset = blockNum;
break;
}
}

// Fin de fonction si fichier inexistant
if (fileFound == -1) {
printf("Le fichier \"%s\" n'a pas été trouvé.\n", filename);
return;
}

for (int blockNum = offset; blockNum < offset + 16; blockNum++) {
int startOffset = 0;
if (blockNum == offset) {
startOffset = MAX_FILENAME_LENGTH;
}
readBlock(blockNum, startOffset, fileBuffer, BLOCK_SIZE - startOffset);

// Libérer les blocs associés au fichier dans la carte de disponibilités et dans les blocs de description
for (int i = 0; i < BLOCK_SIZE - startOffset; i += 2) {
int blockNumData = (fileBuffer[i] << 8) | fileBuffer[i + 1];
if (blockNumData == 0) {
break; // Fin du fichier
}
setBlockAvailability(blockNumData, 0); // Marquer le bloc comme disponible
fileBuffer[i] = 0;
fileBuffer[i + 1] = 0;
resetBlock(blockNumData); //on efface les blocs de données
}
writeBlock(blockNum, startOffset, fileBuffer, BLOCK_SIZE - startOffset);
}
printf("Le fichier \"%s\" a été supprimé avec succès.\n", filename);
}
'''Fonction resetBlock'''
void resetBlock(unsigned int blockNum) {
unsigned char buffer[BLOCK_SIZE];
memset(buffer, 0, BLOCK_SIZE);

// Utiliser writeBlock pour écrire les données du buffer dans le bloc
writeBlock(blockNum, 0, buffer, BLOCK_SIZE);
}

ReX : Ca s'améliore. Mais pourquoi cette fonction <code>resetBlock</code> ? Tu crois que dans qu'un système de fichiers perd du temps à mettre à zéro les blocs de données libérés ? Si oui, regarde la page de manual de la commande <code>shred</code>, ça manque à ta culture.

Amine: Après avoir consulter le manual de la commande <code>shred</code>, je vois que cette commande écrit des données aléatoires sur l'emplacement du fichier sur le disque. Par défaut, <code>shred</code> effectue un certain nombre de passes (par exemple, 3 passes) pendant lesquelles il écrit des données aléatoires sur l'emplacement du fichier sur le disque. Après avoir écrit les données aléatoires, <code>shred</code> peut effectuer des passes supplémentaires pendant lesquelles il écrit des données nulles (des zéros) sur le même emplacement. L'objectif de <code>shred</code> est d'augmenter la sécurité en rendant plus difficile la récupération des données supprimées à l'aide d'outils de récupération de données.

Cependant, j'ai aussi consulté comment fonctionne la commande <code>rm</code> de linux, et je vois que cette commande libère l'espace occupé par le fichier en marquant les blocs associés comme disponibles. Cela signifie que les données peuvent encore être récupérées à l'aide d'outils de récupération de données, à moins que des mesures supplémentaires ne soient prises pour écraser physiquement l'espace avec des données aléatoires (c'est ce que fait l'utilitaire <code>shred</code>).

On va donc opter pour la deuxième option, c'est à dire qu'on ne va pas perdre notre temps à remettre à zéro les blocs de données libérés, on va simplement marquer les blocs correspondants comme étant disponibles. Cela nous permettra de nous émanciper de la fonction resetBlock et de n'avoir plus qu'un seul tableau de blocs.

ReX : Sinon lire un bloc complet de pointeurs de blocs de données en mémoire n'est pas forcément optimal. L'idéal serait de lire ces blocs morceau par morceau (de 64 octets par exemple). Certes un bloc serait traité en 4 lectures/écritures (ce qui ralentirait le traitement) mais on gagne en mémoire. Le mieux serait de mettre la taille des morceaux en constante pour pouvoir choisir entre vitesse d'exécution et utilisation mémoire.

Amine: d'accord je comprends. Je vais modifier la fonction pour qu'on puisse découper la lecture/écriture en plusieurs blocs.

=== Fonction RM version 4 ===
Modifications apportées:

* je ne réinitialise plus les blocs de données, je supprime simplement le pointeur du fichier vers les blocs de données et je désigne les blocs comme "disponible" dans le carte de disponibilités. J'ai donc supprimé la fonction resetBlock.

* je ne lis plus les blocs en une seule fois mais en plusieurs fois via la variable CHUNK_SIZE:

# J'ai introduit la constante <code>CHUNK_SIZE</code> pour définir la taille de chaque morceau que nous allons lire/écrire à la fois. Cela permet de découper les opérations en blocs plus petits.
# Dans la boucle <code>for</code> où on parcours les blocs à partir de <code>offset</code>, j'ai ajouté une boucle interne qui parcourt les données du bloc en morceaux de taille <code>CHUNK_SIZE</code>.
# À l'intérieur de la boucle interne, j'ai calculé la taille réelle du morceau (<code>chunkSize</code>) en prenant le minimum entre <code>CHUNK_SIZE</code> et la quantité de données restant à lire/écrire dans le bloc.
# J'ai modifié la fonction <code>readBlock</code> pour lire seulement la quantité de données spécifiée par <code>chunkSize</code> à partir de <code>chunkStart</code>. Ces données sont stockées dans le tableau <code>fileBuffer</code>.
# Ensuite, j'ai effectué les mêmes opérations de libération des blocs associés au fichier, en parcourant les données du morceau et en marquant les blocs comme disponibles.
# Finalement, j'ai utilisé la fonction <code>writeBlock</code> pour écrire le morceau de données modifié dans le bloc, en utilisant la même <code>chunkStart</code> pour déterminer où écrire les données.

#define CHUNK_SIZE 64

int min(int a, int b) {
return a < b ? a : b;
}

void RM(const char *filesystem_path, const char *filename) {
int fileFound = -1;
int offset;
unsigned char fileBuffer[BLOCK_SIZE];

// Parcourir les blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char *)filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {
// Effacer le nom du fichier dans le superbloc
memset(filenameBuffer, 0, MAX_FILENAME_LENGTH);
writeBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);
fileFound = 1;
offset = blockNum;
break;
}
}

// Fin de fonction si fichier inexistant
if (fileFound == -1) {
printf("Le fichier \"%s\" n'a pas été trouvé.\n", filename);
return;
}

for (int blockNum = offset; blockNum < offset + 16; blockNum++) {
int startOffset = 0;

if (blockNum == offset) {
startOffset = MAX_FILENAME_LENGTH;
}

for (int chunkStart = startOffset; chunkStart < BLOCK_SIZE; chunkStart += CHUNK_SIZE) {
int chunkSize = min(CHUNK_SIZE, BLOCK_SIZE - chunkStart);
readBlock(blockNum, chunkStart, fileBuffer, chunkSize);

for (int i = 0; i < chunkSize; i += 2) {
int blockNumData = (fileBuffer[i] << 8) | fileBuffer[i + 1];
if (blockNumData == 0) {
writeBlock(blockNum, chunkStart, fileBuffer, chunkSize);
printf("Le fichier \"%s\" a été supprimé avec succès.\n", filename);
return; // Sortir des boucles
}
setBlockAvailability(blockNumData, 0); // Marquer le bloc comme disponible
fileBuffer[i] = 0;
fileBuffer[i + 1] = 0;
}

writeBlock(blockNum, chunkStart, fileBuffer, chunkSize);
}
}

printf("Le fichier \"%s\" a été supprimé avec succès.\n", filename);
}

ReX : Si on trouve un n° de bloc de données à 0, il faut sortir des deux boucles les plus externes après avoir fait le <code>writeBlock</code>.

Amine: Modification faites ci-dessus. Maintenant, dès qu'on trouve un n° de bloc de données à 0 dans la boucle la plus interne, on effectue le <code>writeBlock</code> et ensuite on utilise <code>return</code> pour sortir des deux boucles les plus externes. Cela permet d'optimiser le code en évitant de continuer à traiter inutilement le reste des blocs.

ReX : Pas très propre (duplication de code) mais nous allons nous en contenter.

=== Fonction intermédiaire TYPE version 1 ===

J'ai également commencé à réfléchir à la fonction TYPE. Pour l'instant, elle ne fait qu'ajouter les noms de fichier dans le superbloc. Cela permet de pouvoir tester les fonctions LS et RM (voir dans la rubrique compilation et exécution comment utiliser le programme).
// Fonction pour créer un fichier avec le nom donné et le contenu fourni en entrée standard
void TYPE(const char *filesystem_path, const char *filename) {
unsigned char buffer[MAX_FILENAME_LENGTH];
// Parcours des blocs réservés pour la description des fichiers
for (int blockNum = 0; blockNum <= MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, MAX_FILENAME_LENGTH);
// Vérifier si le bloc est vide (pas de nom de fichier)
if (buffer[0] == 0) {
// Écrire le nom du fichier dans l'emplacement vide du superbloc
writeBlock(blockNum, 0, (const unsigned char *)filename, MAX_FILENAME_LENGTH);
break; // Fichier créé, sortir de la boucle
}
}
printf("Le fichier \"%s\" a été créé avec succès.\n", filename);
}

ReX : Si la boucle se termine sans trouver de slot libre le message de succès s'affiche tout de même.

ReX : Le paramètre <code>filename</code> n'a pas forcément une taille de <code>MAX_FILENAME_LENGTH</code>.

Selon moi, la fonction TYPE devra respecter 3 étapes:

# Enregistrement du Nom du Fichier: L'ajout du nom du fichier dans un des blocs de la première partie du superbloc.
# Stockage des Données du Fichier: La récupération des données saisies en entrée standard par l'utilisateur et leur stockage dans des blocs du système de fichiers à partir d'une certaine position, comme le bloc 1040.
# Mise à Jour de la Disponibilité des Blocs: L'indication que les blocs dans lesquels les données ont été écrites ne sont plus disponibles en modifiant les bits correspondants dans la deuxième partie du superbloc (les 16 derniers blocs du super bloc).

ReX : Relis le point 3 et dit moi si tu te comprends toi même ?

Amine: Ma phrase n'est effectivement pas très claire. Je voulais dire que la fonction TYPE devra mettre à jour la carte de disponibilité du superbloc. C'est à dire que lorsqu'elle écrira des données dans des blocs, elle devra indiquer dans la carte de disponibilités que ces blocs ne sont plus disponibles.

=== Fonction intermédiaire TYPE version 2 ===

Suite à vos remarques, j'ai apporté les modifications suivantes à la fonction TYPE:

* j'ai ajouté une condition pour l'affichage du message de succès de la création d'un fichier (placeFound).

* le paramètre <code>filename</code> n'ayant pas forcément une taille de <code>MAX_FILENAME_LENGTH</code>, je calcule maintenant la longueur de filename, afin d'écrire seulement le nom du fichier avec la fonction writeBlock.

Il fonction n'est bien évidemment pas fini, elle ajoute seulement le nom du fichier dans le superbloc pour l'instant. Cela me permet de tester les fonctions LS et RM.
void TYPE(const char *filesystem_path, const char *filename) {
size_t sizeFilename = strlen(filename);
printf("size filename=%d\n", sizeFilename);
unsigned char buffer[MAX_FILENAME_LENGTH];
int placeFound = 0;

if (sizeFilename > MAX_FILENAME_LENGTH) {
printf("Impossible de créer le fichier, nom trop long\n");
return;
}

// Parcours des blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, MAX_FILENAME_LENGTH);
// Vérifier si le bloc est vide (pas de nom de fichier)
if (buffer[0] == 0) {
// Écrire le nom du fichier dans l'emplacement vide du superbloc
if (sizeFilename < MAX_FILENAME_LENGTH) {
sizeFilename+=1;
}
writeBlock(blockNum, 0, (const unsigned char *)filename, sizeFilename);
placeFound = 1;
break; // Fichier créé, sortir de la boucle
}
}
if (placeFound == 1) {
printf("Le fichier \"%s\" a été créé avec succès.\n", filename);
} else {
printf("Plus de place dans le système de fichier pour créer ce fichier.\n", filename);
}
}

ReX : Mieux, attention il faut copier aussi le <code>\'0</code> final du nom, donc <code>sizeFilename+1</code>. Sinon tu n'es pas sûr qu'il y ait un zéro final. Et attention n°2, il ne faut pas copier ce <code>\'0</code> si le nom fait la taille maximale.

Amine: ok j'ai modifié la fonction TYPE ci-dessus. J'ai ajouté une condition: si le nom du fichier est inférieur à la taille maximale de nom de fichier, alors on incrémente de 1 la taille du nom de fichier. Cela nous permet d'écrire le '\0' dans le bloc de description. Dans le cas où le nom du fichier est de la taille maximale, nous n'avons pas besoin d'écrire le '\0', on n'incrémente donc pas la taille de 1.

J'ai également ajouté une condition: si le nom du fichier est supérieur à la taille maximale, alors un message d'erreur s'affiche et le fichier n'est pas créé.

ReX : OK. L'embryon de fonction <code>TYPE</code> est correct, il manque juste le principal : la création des blocs de données.

=== Fonction MV version 1 ===

J'ai ici créé la fonction MV qui permet de changer le nom d'un fichier. Pour ce faire, la fonction parcourt les blocs de descriptions à la recherche du fichier dont on veut changer le nom. Lorsque ce fichier est trouvé, on supprime l'ancien nom en mettant des 0 sur 16 octets, puis on vient réécrire le nouveau nom dans le même emplacement. Enfin, on sort de la boucle et on affiche le succès ou non de l'opération.
// Fonction qui modifie le nom du fichier
void MV(const char *filesystem_path, const char *old_filename, const char *new_filename) {
size_t sizeNew_filename = strlen(new_filename);
size_t sizeOld_filename = strlen(old_filename);
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
int fileFound = 0;
// Parcourir les blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);
// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char*)filenameBuffer, old_filename, MAX_FILENAME_LENGTH) == 0) {
// Effacer le nom du fichier dans le superbloc
memset(filenameBuffer, 0, MAX_FILENAME_LENGTH);
writeBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);
// Écrire le nom du fichier dans l'emplacement
writeBlock(blockNum, 0, (const unsigned char *)new_filename, sizeNew_filename);
fileFound=1;
break; // Nom modifié, sortir de la boucle
}
}
if (fileFound == 1) {
printf("Le nom du fichier \"%s\" a été renommé avec succès.\n", old_filename);
} else {
printf("Le fichier \"%s\" n'a pas été trouvé.\n", old_filename);
}
}

ReX : Inutile d'écraser l'ancien nom avec des zéros. Il suffit de copier le nouveau en s'assurant qu'il y ait un zéro final sauf si le nouveau nom fait la taille maximale.

Amine: ok, je vais faire les modifications dans la version 2.

== Semaine 6 ==

=== Fonction MV version 2 ===
Dans cette nouvelle version de la fonction MV, j'ai effectué les modifications suivantes:

* je n'écrase plus l'ancien nom avec des 0
* Je colle simplement le nouveau nom par dessus l'ancien, en m'assurant qu'il y ait bien le '\0' à la fin lorsque la taille du nom du fichier est inférieur à la taille maximale. Comme précédemment, afin de m'assurer de la présence de ce '\0' à la fin du nom, j'incrémente la taille de 1 lorsque qu'elle est inférieur à la taille max. Cependant, je ne suis pas sûr à 100% que ce soit la bonne manière de faire.

// Fonction qui modifie le nom du fichier
void MV(const char *filesystem_path, const char *old_filename, const char *new_filename) {
size_t sizeNew_filename = strlen(new_filename);
size_t sizeOld_filename = strlen(old_filename);
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
int fileFound = 0;

// Parcourir les blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {

readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char*)filenameBuffer, old_filename, MAX_FILENAME_LENGTH) == 0) {

if (sizeNew_filename < MAX_FILENAME_LENGTH) {
sizeNew_filename+=1;
}

// Écrire le nom du fichier dans l'emplacement
writeBlock(blockNum, 0, (const unsigned char *)new_filename, sizeNew_filename);

fileFound=1;

break; // Nom modifié, sortir de la boucle
}
}
if (fileFound == 1) {
printf("Le nom du fichier \"%s\" a été renommé avec succès.\n", old_filename);
} else {
printf("Le fichier \"%s\" n'a pas été trouvé.\n", old_filename);
}
}

ReX : C'est bon. La fonction était triviale.

=== Fonction TYPE version 1 ===
void TYPE(const char *filesystem_path, const char *filename) {
size_t sizeFilename = strlen(filename);
unsigned char buffer[MAX_FILENAME_LENGTH];
int placeFound = -1;

if (sizeFilename > MAX_FILENAME_LENGTH) {
printf("Impossible de créer le fichier, nom trop long\n");
return;
}

// Parcours des blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, MAX_FILENAME_LENGTH);
// Vérifier si le bloc est vide (pas de nom de fichier)
if (buffer[0] == 0) {
// Écrire le nom du fichier dans l'emplacement vide du superbloc
if (sizeFilename < MAX_FILENAME_LENGTH) {
sizeFilename += 1; // Ajouter '\0' s'il y a de la place
}
writeBlock(blockNum, 0, (const unsigned char *)filename, sizeFilename);
placeFound = blockNum;

// Lire les données depuis l'entrée standard
unsigned char dataBuffer[BLOCK_SIZE];
size_t bytesRead;
int dataBlockNum = findAvailableBlock(); // Premier bloc de données à partir du bloc 1040
printf("dataBlockNum%d\n",dataBlockNum);
int blockSizeUsed = 0; // Compteur d'octets dans le bloc actuel
int dataBlocksNeeded = 1; // Nombre de blocs de données nécessaires

while ((bytesRead = fread(dataBuffer + blockSizeUsed, 1, BLOCK_SIZE - blockSizeUsed, stdin)) > 0) {
blockSizeUsed += bytesRead;

// Si le bloc actuel est plein, passer au bloc suivant
if (blockSizeUsed == BLOCK_SIZE) {
// printf("dataBlockNum=%d\n",dataBlockNum);
writeBlock(dataBlockNum, 0, dataBuffer, BLOCK_SIZE);
setBlockAvailability(dataBlockNum, 1);

dataBlockNum++; // Passer au bloc suivant
blockSizeUsed = 0; // Réinitialiser la taille utilisée
dataBlocksNeeded++;
}
}

// Écrire le dernier bloc partiel, s'il y en a un
if (blockSizeUsed > 0) {
writeBlock(dataBlockNum, 0, dataBuffer, blockSizeUsed);
setBlockAvailability(dataBlockNum, 1);
}

// Écrire les numéros de blocs utilisés dans le bloc de description
unsigned char blockNumberBuffer[2];
int currentBlockNum = 1040;

for (int i = 0; i < dataBlocksNeeded; i++) {
blockNumberBuffer[0] = (currentBlockNum >> 8) & 0xFF;
blockNumberBuffer[1] = currentBlockNum & 0xFF;
writeBlock(placeFound, MAX_FILENAME_LENGTH + i * 2, blockNumberBuffer, 2);
currentBlockNum++;
}

break; // Fichier créé, sortir de la boucle
}
}

if (placeFound != -1) {
printf("Le fichier \"%s\" a été créé avec succès.\n", filename);
} else {
printf("Plus de place dans le système de fichier pour créer ce fichier.\n");
}
}

ReX : La constante 1040 ne doit pas apparaître en numérique, ce doit être une constante calculée à partir des autres constantes.

Amine: Ok. Je ne l'avais pas défini comme une constante car il s'agit dans la fonction ci-dessus d'une variable qui est incrémenté à chaque itération.

ReX : Je suis las de te répéter que le mémoire est comptée : tu utilises encore un bloc de <code>BLOCK_SIZE</code> octets, c'est trop.

Amine: Comment utiliser des blocs plus petit sachant qu'il s'agit là de blocs de données et qu'un bloc fait 256 octets d'après l'énoncé ? Dois-je les subdiviser en plusieurs blocs plus petit comme fait dans la fonction RM, en 4 blocs de 64 octets par exemple ?

Fonctionnement de la fonction TYPE:

* étape 1: on parcourt les blocs de descriptions à la recherche d'un bloc disponible. Si on ne trouve pas de bloc disponible, on renvoie un message d'erreur, sinon on passe à l'étape suivante.
* étape 2: Si on trouve un emplacement libre dans les blocs de disponibilité, on écrit le nom du fichier dans cet emplacement.

ReX : Dans les blocs de description de fichiers pas dans les blocs de disponibilité.

Amine: Oui autant pour moi.

* étape 3: Ensuite, on lit le texte entré par l'utilisateur en entrée standard, on le répartit dans des blocs de taille BLOCK_SIZE, on met à jour la disponibilité des blocs utilisés.

ReX : Non, il faut appeler <code>findAvailableBlock</code> pour chaque bloc de données à utiliser, aucune certitudes que les blocs libres soient en séquence.

Amine: ok, je ferai cela dans la version 2

* étape 4: Enfin, on écrit les numéros des blocs de données utilisés dans les blocs de description de ce fichier, les numéros étant écris sur deux octets.

ReX : Non cela doit se faire au fur et à mesure des appels à <code>findAvailableBlock</code> et les numéros des blocs de données peuvent s'étaler sur les 16 blocs de description du fichier. Confusion totale sur ce point. Vous n'avez pas compris le mécanisme.

Amine: je corrige cela dans la version 2. J'ai bien compris le mécanisme mais ce n'est pas facile à traduire en code.

=== Fonction TYPE version 2 ===
Dans cette nouvelle version de TYPE, j'ai fait les modifications suivantes:

* j'appelle maintenant <code>findAvailableBlock</code> pour chaque bloc de données à utiliser
* j'écris maintenant les numéros de blocs au fur et à mesures des appels à <code>findAvailableBlock</code>
* je n'utilise plus de tableaux de taille 256 octets mais des tableaux de tailles CHUNK_SIZE. J'ai choisi ici CHUNK_SIZE = 64 octets.

J'utilise toujours un bloc de taille BLOCK_SIZE en attendant de comprendre si je dois diviser ce bloc en plusieurs blocs de taille plus petite ou s'il y a un moyen de ne pas du tout utiliser ces blocs.
void TYPE(const char *filesystem_path, const char *filename) {
size_t sizeFilename = strlen(filename);
unsigned char buffer[MAX_FILENAME_LENGTH];
int placeFound = -1;

if (sizeFilename > MAX_FILENAME_LENGTH) {
printf("Impossible de créer le fichier, nom trop long\n");
return;
}

// Parcours des blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, MAX_FILENAME_LENGTH);
// Vérifier si le bloc est vide (pas de nom de fichier)
if (buffer[0] == 0) {
// Écrire le nom du fichier dans l'emplacement vide du superbloc
if (sizeFilename < MAX_FILENAME_LENGTH) {
sizeFilename += 1; // Ajouter '\0' s'il y a de la place
}
writeBlock(blockNum, 0, (const unsigned char *)filename, sizeFilename);
placeFound = blockNum;

// Lire les données depuis l'entrée standard et écrire dans le fichier
int dataBlockNum = findAvailableBlock(); // Premier bloc de données à partir du bloc 1040
printf("Premier bloc dans lequel on écrit = %d\n", dataBlockNum);
int blockSizeUsed = 0; // Compteur d'octets dans le bloc actuel

unsigned char chunkBuffer[CHUNK_SIZE];
size_t bytesRead;

while ((bytesRead = fread(chunkBuffer, 1, CHUNK_SIZE, stdin)) > 0) {
// Écrire le chunk dans le bloc de données
writeBlock(dataBlockNum, blockSizeUsed, chunkBuffer, bytesRead);
setBlockAvailability(dataBlockNum, 1);

// Écrire le numéro du bloc actuel dans la description du fichier
unsigned char blockNumberBuffer[2];
blockNumberBuffer[0] = (dataBlockNum >> 8) & 0xFF;
blockNumberBuffer[1] = dataBlockNum & 0xFF;
writeBlock(placeFound, MAX_FILENAME_LENGTH + dataBlockNum * 2, blockNumberBuffer, 2);

blockSizeUsed += bytesRead;

// Si le bloc actuel est plein, passer au bloc suivant
if (blockSizeUsed == BLOCK_SIZE) {
dataBlockNum = findAvailableBlock(); // Passer au bloc suivant
blockSizeUsed = 0; // Réinitialiser la taille utilisée
}
}

break; // Fichier créé, sortir de la boucle
}
}

if (placeFound != -1) {
printf("Le fichier \"%s\" a été créé avec succès.\n", filename);
} else {
printf("Plus de place dans le système de fichier pour créer ce fichier.\n");
}
}

=== Fonction findAvailableBlock ===
Cette fonction renvoie l'indice du premier bloc disponible. Je me sers de cette fonction dans la fonction TYPE.
#define FIRST_DATA_BLOCK 1040
#define FIRST_DISPONIBILITY_CARD_BLOCK 1024

// Renvoie le premier bloc de donné disponible
int findAvailableBlock() {
unsigned char availabilityBuffer[BLOCK_SIZE];
int offset;

// Lire la carte de disponibilité (à partir du bloc 1)
for (int blockNum = FIRST_DISPONIBILITY_CARD_BLOCK; blockNum < FIRST_DATA_BLOCK; blockNum++) {
readBlock(blockNum, 0, availabilityBuffer, BLOCK_SIZE);

if (blockNum==FIRST_DISPONIBILITY_CARD_BLOCK) {
offset=FIRST_DATA_BLOCK/8;
} else {
offset=0;
}

// Parcourir les octets de la carte de disponibilité
for (int byteIndex = offset; byteIndex < BLOCK_SIZE - offset; byteIndex++) {
unsigned char byte = availabilityBuffer[byteIndex];

// Parcourir les bits de chaque octet
for (int bitIndex = 0; bitIndex < 8; bitIndex++) {
// Vérifier si le bit est à 0 (bloc disponible)
if ((byte & (1 << bitIndex)) == 0) {
// Calculer l'indice du bloc en fonction du bloc et du bit
int blockIndex = byteIndex * 8 + bitIndex;
return blockIndex;
}
}
}
}

// Aucun bloc disponible trouvé
return -1;
}

ReX : Même remarque que précédement sur les nombres 1024 et 1040.

Amine: Ok, j'ai remplacé 1024 par la constante FIRST_DISPONIBILITY_CARD_BLOCK et 1040 par la constante FIRST_DATA_BLOCK dans la fonction ci-dessus.

ReX : Vous n'avez toujours pas compris la contrainte sur la mémoire.

Amine: dois-je découper le bloc de taille BLOCK_SIZE en quatre blocs de taille 64 octets par exemple ?

ReX : Je ne vois pas ce que vous voulez faire avec <code>if (blockNum==1024) offset=1040/8; else offset=0;</code>.

Amine: dans la carte de disponibilité, chaque bit correspond à un bloc. Ainsi, les bits de 0 à 1040 dans la carte de disponibilité décrivent la disponibilité des blocs 0 à 1040. Or ces blocs correspondent au superbloc, et dans cette fonction, on veut connaître le premier bloc de données disponible. On ne s'intéresse donc pas au 1040 premiers bits de la carte de disponibilité. Je crée donc un offset égal à 1040/8 afin de ne pas prendre en compte les 1040 premiers bits soit les 1040/8=130 premiers octets. Cet offset ne s'applique que lorsqu'on se trouve dans le premier des 16 blocs de la carte de disponibilité, d'où la condition <code>if (blockNum==1024)</code>.

ReX : OK, bien vu.

=== Fonction CAT version 1 ===
void CAT(const char *filesystem_path, const char *filename) {
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
unsigned char buffer[BLOCK_SIZE];
unsigned char blockNumberBuffer[2];
unsigned char dataBuffer[BLOCK_SIZE];
int offset;

// Parcours des blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char *)filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {
// Le nom du fichier a été trouvé

// Parcours les blocs de description
for (int descrBlockNum=0; descrBlockNum<MAX_BLOCKS_PER_FILE_DESCRIPTION; descrBlockNum++) {
if (descrBlockNum==0) {
offset=16;
} else {
offset=0;
}
readBlock(descrBlockNum+blockNum, offset, buffer, BLOCK_SIZE-offset);

// Lire les numéros de blocs associés à ce fichier depuis les blocs de description
unsigned char octet1 = buffer[offset];
unsigned char octet2 = buffer[offset+1];

int dataBlockNum = (octet1 << 8) | octet2;
printf("dataBlockNum=%d\n",dataBlockNum);

// Vérifier si le numéro de bloc est valide (non nul)
if (dataBlockNum == 0) {
return; // Fin du fichier
}

// Lire et afficher le contenu du bloc de données
readBlock(dataBlockNum, 0, dataBuffer, BLOCK_SIZE);
fwrite(dataBuffer, 1, BLOCK_SIZE, stdout);
}

return; // Fichier affiché, sortie de la fonction
}
}

// Si le fichier n'a pas été trouvé
printf("Le fichier \"%s\" n'a pas été trouvé.\n", filename);
}

ReX : Encore mieux : deux blocs de <code>BLOCK_SIZE</code> en mémoire.

ReX : Le <code>break</code> ne sort pas de la boucle externe.

Amine: Oui c'est vrai. J'ai remplacé le <code>break</code> par un <code>return</code> ci-dessus.

ReX : Dans le cadre de la fonction CAT le <code>return</code> est convenable.

Voici ma fonction <code>CAT</code>. Elle fonctionne en plusieurs étape:

* étape 1: on cherche dans les blocs de descriptions si le fichier dont on veut afficher le contenu existe. Si le nom de fichier est trouvé, on passe à l'étape 2. Sinon, on renvoie un message d'erreur.
* étape 2: si le fichier est trouvé, on parcours les 16 blocs de description de ce fichier.
* étape 3: grâce aux opérations de masquage et de décalage, on joint les octets deux par deux pour former un entier qui contient le numéro du bloc de données correspondant au fichier. Si cet entier vaut 0, alors cela signifie qu'il n'y a plus de blocs associé à ce fichier, on peut donc quitter la fonction. Si cet entier est différent de 0, alors on va lire le bloc correspondant à ce numéro et on affiche son contenu dans le terminal.

== Semaine 7 ==

=== Fonction CP version 1 ===
Voici ma fonction CP, qui permet de créer une copie d'un fichier existant. L'idée est la suivante: pour copier un fichier, on doit créer un nouveau fichier et lui attribuer les mêmes blocs de descriptions que le fichier source. Ainsi, le fichier source et le fichier destination pointeront vers les mêmes blocs de données, et auront le même contenu.

ReX : Perdu. Ce n'est absolument pas la fonction de copie de fichiers d'un système de fichiers.

Amine: Après avoir fait des recherches et après réflexion, je me rends compte que cette fonction CP présente un problème: en faisant pointer les blocs de données du fichier destination vers ceux du fichier source, toute modification du fichier source impactera le fichier destination, or ce n'est pas ce qu'on veut faire. Je vous propose donc une nouvelle version de la fonction CP ci-dessous qui remédie à ce problème.

void CP(const char *filesystem_path, const char *source_filename, const char *destination_filename) {
unsigned char source_filenameBuffer[MAX_FILENAME_LENGTH];
unsigned char destination_filenameBuffer[MAX_FILENAME_LENGTH];
unsigned char descriptionBuffer[BLOCK_SIZE];
int destination_offset;
int offset;

// Recherche du fichier source
int source_offset = -1;
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, source_filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier source
if (strncmp((const char *)source_filenameBuffer, source_filename, MAX_FILENAME_LENGTH) == 0) {
source_offset = blockNum;
break;
}
}

if (source_offset == -1) {
printf("Le fichier source \"%s\" n'a pas été trouvé.\n", source_filename);
return;
}

// Recherche d'un emplacement libre pour le fichier destination
destination_offset = -1;
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, destination_filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc est vide (pas de nom de fichier)
if (destination_filenameBuffer[0] == 0) {
destination_offset = blockNum;
break;
}
}

if (destination_offset == -1) {
printf("Plus de place dans le système de fichier pour créer la copie de \"%s\".\n", source_filename);
return;
}

// Ecrit le nom de la copie dans le bloc de description
writeBlock(destination_offset, 0, (const unsigned char *)destination_filename, strlen(destination_filename));

// Copier les blocs de description associés au fichier source dans les blocs de description du fichier destination
for (int i = 0; i < MAX_BLOCKS_PER_FILE_DESCRIPTION; i++) {
if (i==0) {
offset = MAX_FILENAME_LENGTH;
} else {
offset = 0;
}

readBlock(source_offset+i, offset, descriptionBuffer, BLOCK_SIZE-offset);
if (descriptionBuffer[offset]==0) {
return;
} else {
writeBlock(destination_offset+i, offset, descriptionBuffer, BLOCK_SIZE-offset);
}
}

printf("La copie de \"%s\" sous le nom \"%s\" a été créée avec succès.\n", source_filename, destination_filename);
}

ReX : Pas mieux.

== Semaine 8 ==
A ce stade du projet, les fonctions suivantes ont été validé par Monsieur Redon:

* fonction LS
* fonction RM
* fonction MV

Il reste donc les fonctions suivantes à terminer:

* fonction CAT
* fonction CP
* fonction TYPE

=== Fonction CAT version 2 ===
Suite à vos remarques sur la version 1, j'ai fais les modifications suivantes:

* je n'utilise non plus 2 tableaux de taille BLOCK_SIZE, mais 1 seul. Idéalement il faudrait en utiliser 0, je réfléchi donc à m’émanciper de ce tableau en le remplaçant par plusieurs plus petits tableaux.

ReX : Un seul plus petit.

* J'ai remplacé le <code>break</code> par un <code>return</code>

ReX : Déjà validé.

Cette fonction permet d'afficher le contenu d'un fichier créé avec la fonction TYPE. Pour se faire, on parcours tout d'abord les blocs de descriptions pour trouver le fichier dont ont veut afficher le contenu. Une fois ce fichier trouvé, on parcours les 16 blocs de description de ce fichier 1 à 1. Pour chacun de ces blocs de description, on va stocker récupéré les octets deux par deux afin de former des entiers. Pour se faire, on utilise la fonction <code>reconsituteNumber</code> que l'on détaillera juste après. Ces entiers correspondent aux blocs dans lesquels la donné du fichier se trouve. Une fois l'entier reconstitué, on affiche le contenu du bloc correspondant.
#define CHUNK_SIZE 64

void CAT(const char *filesystem_path, const char *filename) {
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
unsigned char byteBuffer[2];
unsigned char dataBuffer[CHUNK_SIZE];
int offset;

// Parcours des blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char *)filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {
// Le nom du fichier a été trouvé

// Parcours les blocs de description
for (int descrBlockNum=0; descrBlockNum<MAX_BLOCKS_PER_FILE_DESCRIPTION; descrBlockNum++) {
if (descrBlockNum==0) {
offset=MAX_FILENAME_LENGTH;
} else {
offset=0;
}

// Lecture des octets deux par deux
for (int i=0; i<BLOCK_SIZE;i+=2) {
readBlock(descrBlockNum+blockNum, offset+i, byteBuffer, 2);

// Lire les numéros de blocs associés à ce fichier depuis les blocs de description
int dataBlockNum = reconsituteNumber(byteBuffer);

// Vérifier si le numéro de bloc est valide (non nul)
if (dataBlockNum == 0) {
return; // Fin du fichier
}

for (int chunkStart = 0; chunkStart < BLOCK_SIZE; chunkStart += CHUNK_SIZE) {
// Lire et afficher le contenu du bloc de données
readBlock(dataBlockNum, chunkStart, dataBuffer, CHUNK_SIZE);
fwrite(dataBuffer, 1, CHUNK_SIZE, stdout);
}
}
}

return; // Fichier affiché, sortie de la fonction
}
}

// Si le fichier n'a pas été trouvé
printf("Le fichier \"%s\" n'a pas été trouvé.\n", filename);
}

ReX : Remplacer le premier bloc de <code>BLOCK_SIZE</code> octets par un bloc de 2 octets est exagéré mais cela pourrait passer. Il reste toujours un bloc de <code>BLOCK_SIZE</code> octets dont il est facile de se passer au bénéfice d'un bloc de, mettons, 64 octets.

Amine: Voilà! Dans la version ci-dessus j'ai remplacé le bloc de taille <code>BLOC_SIZE</code> par un bloc de taille <code>CHUNK_SIZE</code>, avec <code>CHUNK_SIZE</code> modifiable dans les constantes du programme. J'ai pris ici 64 octets.

=== Fonction reconsituteNumber ===
Cette fonction permet de reconstituer un numéro de bloc à partir de deux octets.
// Fonction qui reconstitue le numéro de bloc à partir du tableau
int reconsituteNumber(unsigned char blockNumberBuffer[2]) {
unsigned char octet1 = blockNumberBuffer[0];
unsigned char octet2 = blockNumberBuffer[1];
int dataBlockNum = (octet1 << 8) | octet2;
return dataBlockNum;
}

ReX : Bonne idée cette fonction.

=== Fonction CP version 2 ===
Voici une version mise à jour de notre fonction CP. Dans la version précédente, on faisait pointer le fichier source vers les même blocs que le fichier destination. Cela posait un problème: toute modification du fichier source impactait le fichier destination. Ainsi, dans cette nouvelle version, on fait une duplication des blocs de données du fichier source vers le fichier destination. Cela implique donc une mise à jour de la carte de disponibilité, ainsi que l'adaptation des blocs de descriptions. En effet, seulement les blocs de données sont maintenant identiques, plus les blocs de description.

Piste d'amélioration: comme pour la fonction CAT ci-dessus, j'utilise toujours un bloc de taille 256 octets, je vais devoir y remédier.
// Fonction pour copier un fichier existant du système de fichier
void CP(const char *filesystem_path, const char *source_filename, const char *destination_filename) {
unsigned char source_filenameBuffer[MAX_FILENAME_LENGTH];
unsigned char destination_filenameBuffer[MAX_FILENAME_LENGTH];
unsigned char descriptionBuffer[CHUNK_SIZE];
unsigned char numBuffer[2];
int destination_offset;
int source_offset;
int offset;
int numDataBlock;
int newDataBlock;

// Recherche du fichier source
source_offset = -1;
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, source_filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier source
if (strncmp((const char *)source_filenameBuffer, source_filename, MAX_FILENAME_LENGTH) == 0) {
source_offset = blockNum;
break;
}
}

if (source_offset == -1) {
printf("Le fichier source \"%s\" n'a pas été trouvé.\n", source_filename);
return;
}

// Recherche d'un emplacement libre pour le fichier destination
destination_offset = -1;
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, destination_filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc est vide (pas de nom de fichier)
if (destination_filenameBuffer[0] == 0) {
destination_offset = blockNum;
break;
}
}

if (destination_offset == -1) {
printf("Plus de place dans le système de fichier pour créer la copie de \"%s\".\n", source_filename);
return;
}

// Copie du nom de la copie dans le bloc de description
writeBlock(destination_offset, 0, (const unsigned char *)destination_filename, strlen(destination_filename));

// Copier les blocs de données associés au fichier source dans de nouveaux blocs de données pour le fichier destination
for (int i = 0; i < MAX_BLOCKS_PER_FILE_DESCRIPTION; i++) {
if (i == 0) { offset = MAX_FILENAME_LENGTH; }
else { offset = 0; }

// Lecture des numéros de bloc dans les blocs de description
for (int byteNum=0; byteNum<BLOCK_SIZE; byteNum+=2) {
readBlock(source_offset + i, offset + byteNum, numBuffer, 2);

numDataBlock = reconsituteNumber(numBuffer);
if (numDataBlock == 0) {
printf("La copie de \"%s\" sous le nom \"%s\" a été créée avec succès.\n", source_filename, destination_filename);
return;
}

for (int chunkStart = 0; chunkStart < BLOCK_SIZE; chunkStart += CHUNK_SIZE) {
// On stocke le bloc de données associé au fichier source dans descriptionBuffer
readBlock(numDataBlock, chunkStart, descriptionBuffer, CHUNK_SIZE);

if (chunkStart == 0) {
// Trouver un nouveau bloc de données disponible
newDataBlock = findAvailableBlock();

// Mise à jour de la carte de disponibilités
setBlockAvailability(newDataBlock, 1);

// Ecriture du numéro de bloc dans la description du fichier
createNumberBuffer(newDataBlock,numBuffer);
writeBlock(destination_offset+i, offset+byteNum, numBuffer, 2);
}

// Ecriture du bloc de données dans le premier bloc disponible
writeBlock(newDataBlock, chunkStart, descriptionBuffer, CHUNK_SIZE);
}
}
}
}

ReX : Youpi. Il reste à se passer du bloc de <code>BLOCK_SIZE</code> (au bénéfice d'un bloc de taille <code>BLOCK_SIZE/n</code> avec n>1). Ecrire la fonction inverse de <code>reconsituteNumber</code>.

Amine: Voilà! Dans le fonction ci-dessus il n'y a plus de bloc de taille <code>BLOCK_SIZE</code>, on a maintenant des blocs de 64 octets (<code>CHUNK_SIZE</code>). J'ai également créé la fonction <code>createNumberBuffer</code> qui est la fonction inverse de<code>reconsituteNumber</code>. Je la détaille ci-dessous.

=== Fonction createNumberBuffer ===
Cette fonction permet repartir un entier sur deux octets.
// Fonction qui réparti un numéro de bloc sur deux octets
void createNumberBuffer(int dataBlockNum, unsigned char blockNumberBuffer[2]) {
blockNumberBuffer[0] = (dataBlockNum >> 8) & 0xFF;
blockNumberBuffer[1] = dataBlockNum & 0xFF;
}

=== Fonction TYPE version 3 ===
La fonction 2 que j'ai fourni ci-dessus n'est pas correcte. Je vais la corriger dans cette version 3.

ReX : Effectivement la version précédente ne gére pas correctement l'écriture des numéros de blocs de données dans la description d'un fichier.

= Compilation et exécution =
'''Création du système de fichiers :'''
dd if=/dev/zero of=filesystem.bin bs=256 count=32768

'''Compilation :'''

gcc picofs.c -o picofs

'''Exécution de LS, TYPE, CAT, RM, MV ou CP :'''

./picofs filesystem.bin LS
./picofs filesystem.bin TYPE mon_fichier.txt
./picofs filesystem.bin CAT mon_fichier.txt
./picofs filesystem.bin RM mon_fichier.txt
./picofs filesystem.bin MV mon_fichier.txt mon_fichier2.txt
./picofs filesystem.bin CP mon_fichier.txt mon_fichier2.txt

= Documents Rendus =
[[Fichier:PicofsV1.c.tar|vignette]]

Fichier:PicofsV1.c.tar

2023-09-03T21:06:31Z

Asellali :

picofs

SE4 2022/2023 EC1

2023-09-03T19:31:21Z

Asellali : /* Fonction CP version 2 */

= Objectifs =

Il vous est demandé de :
* réaliser un micro système de fichiers ;
* le système de fichiers doit résider dans un fichier de 8 Mo ;
* le système de fichiers est géré par un exécutable obtenu à partir d'un programme C ;
* L'éxécutable prend deux arguments, le premier est le chemin du fichier dans lequel réside le système de fichiers, les paramètres suivants concernent l'action à appliquer sur le système de fichiers ;
* le micro système de fichier ne comporte qu'un répertoire : le répertoire principal, le répertoire principal peut comporter au maximum 64 fichiers, un fichier est caractérisé par un nom de 16 caractères au maximum et ses blocs de données, un fichier peut comporter au maximum 2040 blocs de données ;
* un bloc de données fait 256 octets et les blocs sont numérotés sur 2 octets ;
* les différentes actions possibles sur le système de fichiers sont :
** <code>TYPE</code> pour créer un fichier si possible, le nom du fichier suit la commande, le contenu du fichier est donné en entrée standard de l'exécutable ;
** <code>CAT</code> pour afficher un fichier, le nom du fichier suit la commande ;
** <code>RM</code> pour détruire un fichier, le nom du fichier suit la commande ;
** <code>MV</code> pour renommer un fichier, les noms original et nouveau du fichier suivent la commande ;
** <code>CP</code> pour copier un fichier, les noms de l'original et de la copie du fichier suivent la commande ;

= Matériel nécessaire =

Un PC sous Linux.

= Travail réalisé =

== Semaine 1 ==

ReX : attention, ce micro-système de fichiers est prévu pour un microcontrôleur, vos variables globales ne peuvent pas dépasser quelques centaines d'octets.

ReX : pour la création du système de fichiers la commande <code>dd</code> suffit, vous voulez dire le formatage du système de fichiers ?

* création du programme programme.c contenant les différentes structures et les différentes fonctions.
* Piste d'amélioration: faire en sorte que la fonction CAT affiche le contenu exact des fichiers passés en argument.

Le code fourni est un programme en langage C qui simule un système de fichiers basique. Ce programme permet aux utilisateurs d'effectuer diverses actions telles que créer, afficher, supprimer, renommer et copier des fichiers dans un système de fichiers simulé. Le système de fichiers est stocké dans un fichier binaire.

ReX : vous n'avez pas tenu compte de la première remarque, vous chargez tout le superbloc et le répertoire racine, votre code ne convient pas.

ReX : vos structures utilisent des types entiers dont la taille n'est pas explicitée, utilisez les types de <code>stdint.h</code>.

ReX : la création de fichier n'est pas fonctionnelle, vous ne cherchez pas les blocs libres, vous ne copiez pas le contenu du fichier dans les blocs, même remarque pour toutes les autres fonctions.

ReX : il manque les fonctions d'accès aux pages du système de fichiers.

'''Explication du programme programme.c'''

Voici une brève explication des principaux éléments et fonctions du code :

# Structures :
#* Fichier : Représente un fichier dans le système de fichiers. Il contient un nom (nom) avec une longueur maximale de 16 caractères, un tableau de numéros de bloc (blocs) où le contenu du fichier est stocké (jusqu'à 2040 blocs), et le nombre de blocs utilisés par le fichier (nbBlocs).
#* Repertoire : Représente le répertoire principal du système de fichiers. Il contient un tableau de fichiers (<code>fichiers</code>) et le nombre de fichiers dans le répertoire (<code>nbFichiers</code>).
# Fonctions :
#* <code>chargerSystemeFichiers</code> : Charge le système de fichiers à partir d'un fichier binaire donné (chemin) dans une structure Repertoire.
#* <code>sauvegarderSystemeFichiers</code> : Sauvegarde le système de fichiers stocké dans la structure Repertoire dans un fichier binaire (chemin).
#* <code>creerFichier</code> : Crée un nouveau fichier dans le système de fichiers avec un nom et un contenu donnés. Le contenu du fichier est simulé en le divisant en blocs.
#* <code>afficherFichier</code> : Affiche le contenu d'un fichier avec le nom spécifié.
#* <code>detruireFichier</code> : Supprime un fichier avec le nom spécifié du système de fichiers.
#* <code>renommerFichier</code> : Renomme un fichier avec l'ancien nom spécifié en un nouveau nom.
#* <code>copierFichier</code> : Copie un fichier avec le nom spécifié en créant un nouveau fichier avec le nom de copie spécifié.
# Fonction <code>main</code> :
#* La fonction <code>main</code> est le point d'entrée du programme.
#* Elle prend des arguments en ligne de commande : <code><chemin_systeme_fichiers></code> et <code><action></code>.
#* <code><chemin_systeme_fichiers></code> est le chemin vers le fichier binaire où le système de fichiers est stocké.
#* <code><action></code> détermine quelle opération effectuer, comme <code>TYPE</code>, <code>CAT</code>, <code>RM</code>, <code>MV</code> ou <code>CP</code>.
#* En fonction de l'action spécifiée, le programme appelle la fonction correspondante pour effectuer l'opération souhaitée sur le système de fichiers.
Remarque : Le code fourni une simulation basique d'un système de fichiers et de ses opérations, mais il n'interagit pas réellement avec un système de fichiers réel sur le disque.

'''Comment utiliser le programme programme.c'''

étape 1: création du système de fichiers respectant le cahier des charges:

dd if=/dev/zero of=systeme_fichiers.bin bs=1M count=8

étape 2: compilation du programme C:

gcc programme.c -o gestionnaire_fs

étape 3: création d'un fichier dans le système de fichier:

./gestionnaire_fs systeme_fichiers.bin TYPE fichier1.txt

-> entrer le texte en entrée standard

étape 4: manipulation des différentes fonctions. Exemples:

./gestionnaire_fs systeme_fichiers.bin CAT fichier1.txt
./gestionnaire_fs systeme_fichiers.bin CP fichier1.txt copie.txt
./gestionnaire_fs systeme_fichiers.bin RM copie.txt
./gestionnaire_fs systeme_fichiers.bin MV fichier1.txt fichier2.txt

== Semaine 2 ==

Amine: Merci pour vos remarques. Désolé de ne pas avoir suivi votre première remarque, je pensais avoir compris ce qu'il fallait faire mais je me rend compte que non. Je vais tout reprendre depuis le début afin de repartir sur de bonnes bases.

'''Création du système de fichier avec la commande "dd"'''

A quoi sert la commande dd?

La commande <code>dd</code> permet de copier tout ou partie d'un disque par blocs d'octets, indépendamment de la structure du contenu du disque en fichiers et en répertoires (source : [https://doc.ubuntu-fr.org/dd]).

Structure de la commande

dd if=<nowiki><source> of=<cible> bs=<taille des blocs></nowiki>

<code>source</code> = données à copier

<code>cible</code> = endroit où les copier

<code>if</code> = input file

<code>of</code> = output file

<code>bs</code> = block size, habituellement une puissance de 2 supérieure ou égale à 512, représentant un nombre d'octets

Choix de la commande:

Pour la source, on prends <code>/dev/zero</code>: cela permet de créer un fichier rempli de 0. Ce fichier servira de base pour notre système de fichiers.

Pour la cible, on va l'appeler <code>filesystem.bin</Code> : ce sera notre système de fichier.

Pour la taille des blocs, on veut des blocs de données de 256 octets d'après l'enoncé. On va donc prendre <code>bs=256</code>.

Enfin, on veut que le système de fichier réside dans un fichier de 8 Mo. On va donc ajouter <code>count=31250</code>: cela indique que nous voulons écrire 32768 blocs de données dans le fichier (31250 * 256 octets = 8 Mo).

Résultat:

dd if=/dev/zero of=filesystem.bin bs=256 count=31250

Question pour M. Redon : j'ai ici essayé de respecter votre remarque "pour la création du système de fichiers la commande <code>dd</code> suffit". Cependant, pour votre seconde remarque "vous chargez tout le superbloc et le répertoire racine, votre code ne convient pas.", je ne suis pas sûr de comprendre où je fais cela: est-ce lors de la commande dd ou est-ce par la suite avec mon programme C? J'ai un peu modifié la commande dd comme vous pouvez le voir ci-dessus. Ai-je corrigé mon erreur avec cette nouvelle commande? J'ai essayé de justifier au maximum la commande dd que j'ai choisie.

ReX : Pas de problème avec la commande <code>dd</code> (mettez tous les extraits de code entre des balises <code>code</code>). Le problème est au niveau du programme C.

Amine: Ok je comprends mieux merci. Je vais donc reprendre le code étape par étape afin de mieux répondre au cahier des charges.

Gestion du système de fichier par un programme C

'''Création des structures'''
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>

// Structure pour représenter un bloc de données

struct DataBlock {
uint8_t data[256]; // 256 octets pour chaque bloc de données
};

// Structure pour représenter un fichier

struct File {
char filename[17]; // 16 caractères pour le nom du fichier + 1 caractère null-terminator
struct DataBlock data_blocks[2040]; // Tableau de blocs de données pour stocker le contenu du fichier
uint16_t num_data_blocks; // Nombre de blocs de données utilisés par le fichier
};

// Structure pour représenter un répertoire

struct Directory {
struct File files[64]; // Tableau de fichiers pour le répertoire principal
uint8_t num_files; // Nombre de fichiers dans le répertoire principal
};

Modification faite : suite à votre remarque, j'ai explicité la taille des entiers grâce aux types de <code>stdint.h.</code> (j'ai également mis les variables en anglais)

ReX : Vous ne pouvez pas utiliser ces structures, une instanciation d'une de ces structure prend trop d'espace mémoire, vous devez faire sans structure. Par ailleurs la façon dont vous représentez vos fichiers ne convient pas, la description d'un fichier contient des numéros de blocs, pas les blocs eux-même. Faites aussi attention qu'un fichier soit décrit par un nombre entier de blocs.

Question pratique: je n'arrive pas à mettre tout le code dans le même bloc comme vous l'avez fait ci-dessus dans l'étape 4 de la semaine 1. Je vois que c'est en format "préformaté" mais j'obtiens des blocs séparés lorsque j'applique ce format à mon code.

ReX : j'ai corrigé, pour un code entier la syntaxe n'est pas la même (un espace en début de chaque ligne), la balise c'est uniquement pour de très courts extraits de code.

=== Fonction <code>readBlock</code>===
Cette fonction est utilisée pour lire un bloc de données à partir du fichier <code>filesystem.bin</code> et le stocker dans un tableau de caractères (<code>storage</code>).

Fonction:

#define BLOCK_SIZE 256
// Fonction pour lire un bloc de données
void readBlock(unsigned int num, int offset, unsigned char *storage, int size) {
FILE *file = fopen("filesystem.bin", "rb");
if (file == NULL) {
perror("Erreur lors de l'ouverture du fichier");
return;
}
fseek(file, num * BLOCK_SIZE + offset, SEEK_SET);
fread(storage, 1, size, file);
fclose(file);
}

Paramètres :

* <code>num</code> : Numéro du bloc à lire. Chaque bloc contient 256 octets (1 bloc = 256 octets).
* <code>offset</code> : Décalage (en octets) à partir du début du bloc pour commencer la lecture.
* <code>storage</code> : Pointeur vers un tableau de caractères où les données lues seront stockées.
* <code>size</code> : Taille du tableau de caractères <code>storage</code>.

Fonctionnement :

* La fonction commence par ouvrir le fichier <code>filesystem.bin</code> en mode lecture binaire (<code>"rb"</code>).
* Elle utilise <code>fseek</code> pour positionner le curseur de lecture dans le fichier à l'endroit approprié pour commencer la lecture du bloc spécifié (<code>num</code>) à partir de l'offset (<code>offset</code>).
* Elle utilise ensuite <code>fread</code> pour lire <code>size</code> octets à partir du fichier et les stocker dans le tableau <code>storage</code>.
* Enfin, elle ferme le fichier avec <code>fclose</code>.

Note : Le paramètre <code>offset</code> est utilisé pour spécifier à partir de quel octet du bloc on souhaite commencer la lecture. Si <code>offset</code> est égal à 0, la lecture commencera depuis le début du bloc. Si <code>offset</code> est différent de 0, la lecture commencera à l'octet spécifié.

Remarque: dans votre mail, vous définissez "readBlock(unsigned int num,int offset,unsigned storage,int size)": storage n'est alors pas un pointeur vers un tableau de caractère. Je me suis donc permis de faire la modification.

ReX : OK pour la fonction, pas la peine d'en mettre autant dans le Wiki pour une fonction aussi simple.

=== Fonction <code>writeBlock</code> ===
Cette fonction est utilisée pour écrire un bloc de données dans le fichier <code>filesystem.bin</code> à partir d'un tableau de caractères (<code>storage</code>).

Fonction:

// Fonction pour écrire un bloc de données
void writeBlock(unsigned int num, int offset, const unsigned char *storage, int size) {
FILE *file = fopen("filesystem.bin", "rb+");
if (file == NULL) {
perror("Erreur lors de l'ouverture du fichier");
return;
}
fseek(file, num * BLOCK_SIZE + offset, SEEK_SET);
fwrite(storage, 1, size, file);
fclose(file);
}

Paramètres :

* <code>num</code> : Numéro du bloc où écrire.
* <code>offset</code> : Décalage (en octets) à partir du début du bloc pour commencer l'écriture.
* <code>storage</code> : Pointeur vers un tableau de caractères contenant les données à écrire dans le fichier.
* <code>size</code> : Taille du tableau de caractères <code>storage</code>.

Fonctionnement :

* La fonction commence par ouvrir le fichier <code>filesystem.bin</code> en mode lecture et écriture binaire (<code>"rb+"</code>).
* Elle utilise <code>fseek</code> pour positionner le curseur de lecture/écriture dans le fichier à l'endroit approprié pour commencer l'écriture du bloc spécifié (<code>num</code>) à partir de l'offset (<code>offset</code>).
* Elle utilise ensuite <code>fwrite</code> pour écrire <code>size</code> octets à partir du tableau <code>storage</code> dans le fichier.
* Enfin, elle ferme le fichier avec <code>fclose</code>.

ReX : Même remarque que pour la fonction précédente.

'''Etape 4: test des fonctions <code>readBlock</code> et <code>writeBlock</code> dans le main'''
// Exemple de fonction principale pour tester les opérations de lecture et d'écriture
int main() {
unsigned char data[BLOCK_SIZE];
// Test de la fonction readBlock
readBlock(0, 0, data, BLOCK_SIZE);
printf("Block 0, offset 0: ");
for (int i = 0; i < BLOCK_SIZE; i++) {
printf("%02x ", data[i]);
}
printf("\n");
// Test de la fonction writeBlock
unsigned char newData[BLOCK_SIZE] = {
0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88,
// ... Autres données du bloc ...
};
writeBlock(1, 0, newData, BLOCK_SIZE);
// Lecture du bloc nouvellement écrit pour vérifier
readBlock(1, 0, data, BLOCK_SIZE);
printf("Block 1, offset 0: ");
for (int i = 0; i < BLOCK_SIZE; i++) {
printf("%02x ", data[i]);
}
printf("\n");
return 0;
}

Fonctionnement :

* On déclare tout d'abord un tableau de caractères <code>data</code> de taille <code>BLOCK_SIZE</code> pour stocker les données lues du bloc.
* Ensuite, la fonction <code>readBlock</code> est appelée avec les arguments (0, 0, data, BLOCK_SIZE) pour lire le premier bloc du fichier (<code>num=0</code>, <code>offset=0</code>) et stocker les données dans <code>data</code>.
* Ensuite, la fonction <code>printf</code> est utilisée pour afficher les données lues du bloc (<code>data</code>) en format hexadécimal.
* Ensuite, un nouveau tableau de caractères <code>newData</code> est créé avec des données spécifiques pour tester la fonction <code>writeBlock</code>.
* La fonction <code>writeBlock</code> est appelée avec les arguments (1, 0, newData, BLOCK_SIZE) pour écrire le tableau <code>newData</code> dans le deuxième bloc du fichier (<code>num=1</code>, <code>offset=0</code>).
* Enfin, la fonction <code>readBlock</code> est appelée à nouveau pour lire le deuxième bloc nouvellement écrit et afficher les données lues en format hexadécimal.

Question générale : ce que j'avais la première semaine n'est plus forcément d'actualité. Puis-je supprimer les choses qui ne le sont plus afin d'alléger la page ou préférez-vous que je laisse?

ReX : Laissez.

Pour la suite : j'ai donc pour l'instant crée deux fonctions, l'une permettant la lecture et l'autre l'écriture d'un bloc, de manière à économiser la mémoire. Pour la suite, je vais essayer de créer la fonction <code>LS</code> en utilisant la fonction <code>readBlock</code>.

ReX : Oui c'est le début du projet. Mais si vous n'avez pas une bonne description de fichier cela ne donnera rien. Voir remarques plus haut.

'''Etape 5: fonction <code>LS</code>'''

Objectif: créer la fonction <code>LS</code> avec la fonction readBlock.

Question: Souhaitez-vous la fonction <code>LS</code> classique, c'est à dire la fonction <code>LS</code> qui affiche simplement le nom des fichiers présent dans le répertoire ?

ReX : Oui. Tu peux ajouter la taille si tu trouves cela trop simple.

Piste : si c'est ce que vous voulez:

* il va tout d'abord falloir que je crée des fichiers, un fichier étant composé d'un nom et de blocs (création d'une fonction createFile)
* Il faudra ensuite que je stocke ces fichiers dans le répertoire (création d'une fonction addFileToDirectory par exemple)
* enfin, il faudra que j'affiche le nom des fichiers. Pour cela, il faudra que je parcours le répertoire (structure "Directory"), puis que pour chaque fichier présent dans le répertoire que j'affiche son nom (création de la fonction LS)

Je devrais surement utiliser la fonction readBlock afin de transférer les blocs dans le fichier au travers de la variable "storage".

ReX : Créer des fichiers n'est pas nécessaire tout de suite je verrais bien si ton code est bon sans test. Laisse tomber <code>createFile</code> et <code>addFileToDirectory</code> pour l'instant.

ReX : Ton algorithme ne fonctionne pas pour un microcontrôleur où il faut économiser la mémoire, tu ne peux pas t'aider de structures. Il faudra que tu charges les noms et seulement les noms, pour la taille il faudra se baser sur le nombre de blocs.

'''Etape 6: rectification du code suite à vos remarques'''

Modifications apportées:

* suppression des structures afin d’économiser de la mémoire.

* le problème quant à la description des fichiers est normalement résolu puisque plus de structures. On ne charge plus les blocs mais seulement les noms de fichiers.

ReX : Non car si les noms ne sont pas répartis de façon régulière dans les blocs de 256 octets tu vas avoir du mal à les charger. Mais écrit la fonction <code>LS</code> et tu verras ce que je veux dire.

J'ai également ajouté deux nouvelles fonctions:

# <code>void readFileName(unsigned int file_num, char *file_name)</code>: Cette fonction permet de lire le nom du fichier associé au numéro de fichier donné (<code>file_num</code>). Elle stocke le nom du fichier lu dans le tableau <code>file_name</code>.
# <code>void writeFileName(unsigned int file_num, const char *file_name)</code>: Cette fonction permet d'écrire le nom du fichier dans le système de fichiers, associé au numéro de fichier donné (<code>file_num</code>). Elle prend en entrée le nom du fichier à écrire (<code>file_name</code>).

Suite: si vous validez cette base, je pourrai passer à la création de la fonction LS.

ReX : tu peux y aller. Je ne vois pas le code des tes deux fonctions <code>readFileName</code> et <code>writeFileName</code>.

Voici le code des fonctions <code>readFileName</code> et <code>writeFileName</code> :

'''Fonction readFileName:'''
// Fonction pour lire le nom du fichier
void readFileName(unsigned int file_num, char *file_name) {
readBlock(file_num, 0, (unsigned char *)file_name, MAX_FILENAME_LENGTH);
file_name[MAX_FILENAME_LENGTH] = '\0'; // Ajout du caractère null-terminator pour former une chaîne de caractères
}

ReX : Non, aucune raison que le fichier de numéro n soit au bloc n. Dessine la représentation d'un fichier sur le SF en comptant les octets si cela peut aider.

'''Fonction writeFileName:'''
// Fonction pour écrire le nom du fichier
void writeFileName(unsigned int file_num, const char *file_name) {
writeBlock(file_num, 0, (const unsigned char *)file_name, MAX_FILENAME_LENGTH);
}

ReX : Faux et inutile pour l'instant. Problème avec la constante MAX_FILENAME_LENGTH.

=== Fonction LS version 1 ===
// Fonction LS pour afficher les fichiers présents dans le système de fichiers
void LS(const char *filesystem_path) {
FILE *file = fopen(filesystem_path, "rb");
if (file == NULL) {
perror("Erreur lors de l'ouverture du fichier système");
return;
}
uint16_t num_files;
fread(&num_files, sizeof(uint16_t), 1, file); // Lecture du nombre de fichiers dans le système
char filename[17];
printf("Fichiers présents dans le système de fichiers:\n");
for (int i = 0; i < num_files; i++) {
readFileName(i, filename); // Lecture du nom du fichier
printf("%s\n", filename); // Affichage du nom du fichier
}
fclose(file);
}
La fonction <code>LS</code> ouvre le fichier système, lit le nombre de fichiers qu'il contient, puis affiche les noms des fichiers un par un, chacun sur une ligne séparée.

ReX : Il y a le nombre de fichiers dans ton superbloc ? Un dessin du format du superbloc avec les numéros des octets ?

ReX : Tout accès au système de fichiers doit se faire avec les deux fonctions <code>readBlock</code> et <code>writeBlock</code>.

== Semaine 3 ==
Question 1: cela fait plusieurs fois que vous mentionnez dans le wiki un "superbloc". Celui-ci n'étant pas clairement défini dans le sujet, je me demande s'il s'agit du bloc crée grâce à la fonction dd, c'est à dire que le superbloc serait en faite le bloc constitué des 31250 blocs de taille 256 octets, où s'il s'agit d'un bloc qui vient en entête, celui contenant alors des informations décrivant le système de fichier (les noms de fichiers...).

ReX : Pour ton pico système de fichiers, le superbloc consiste en les premiers blocs (de 256 octets) qui définissent les 64 fichiers possibles.

Proposition de structure: on pourrait réserver les premiers blocs du système de fichiers aux noms de fichiers ainsi qu'aux numéros des blocs correspondant à chaque fichier.

ReX : Oui c'est évident.

On sait que les noms de fichiers font au maximum 16 caractères + 1 caractère pour le '\0' (donc 17 octets car 1 char=1 octet).

ReX : Non, 16 octets suffisent, des '\0' en fin de nom uniquement si le nom fait moins de 16 caractères.

On sait également qu'un fichier contient au maximum 2040 blocs, chaque bloc étant numéroté sur 2 octets. On pourrait donc avoir en début du système de fichier: 17 octets+2 octets*2040 blocs = 4097 octets pour la description d'un fichier.

ReX : Non, 4096 octets soit 16 blocs de 256.

Or d'après l'une de vos remarques dans le wiki, un fichier doit être décrit par un nombre entier de blocs. Pour un fichier, il nous faudra donc 4097/256=16.004 soit 17 blocs. Il peut y avoir jusqu'à 64 fichiers dans le répertoire, il nous faudra donc 17 blocs*64 fichiers= 1088 blocs pour la description des fichiers.

ReX : Non 1024 blocs de 256 octets dans le superbloc.

Ainsi, pour la fonction LS, il suffira de lire les premiers caractères tous les 17 blocs ( du premier caractère au caractère '\0').

ReX : Non, tous les 16 blocs.

Question 2: Ne faudrait-il pas également stocker quelque part le nombre de fichier qu'il y a dans le répertoire afin de savoir jusqu'à quel bloc la fonction LS doit aller ?

ReX : Non, un fichier dont le nom n'est constitué que de '\0' est réputé ne pas exister.

Question 3: on a donc vu que les 1088 premiers blocs au maximum serviraient à la description du système de fichier. Il reste donc 31250-1088=30132 blocs dans le système de fichier.

ReX : Non, 32768-1024=31744 blocs.

Comment utiliser ces blocs? Ces blocs doivent-ils stocker le contenu des fichiers ?

ReX : Oui, c'et évident.

En effet, avec la fonction TYPE, nous allons créer des fichiers et ces fichiers devront être stockés quelque part. Cependant, étant donné que ce pico système de fichiers est prévu pour un microcontrôleur, je ne sais pas si c'est le contenu des fichiers qui doit être stocké dans les blocs ou autre chose (peut être l'adresse des fichiers, le fichiers se trouvant autre part). En effet, je me dis que si un fichier est très volumineux, il ne pourra pas rentrer dans le système de fichier, ce dernier étant composé d'un nombre limité de blocs, et les blocs étant eux même limité en nombre d'octets.

ReX : Je ne comprend pas ton problème. De tout façon comme dit plus haut, les 31744 blocs suivant le superbloc doivent contenir les données des fichiers.

Désolé de poser des questions peut être basique aussi tard, mais je pense qu'une fois que j'aurai ces réponses, cela ira beaucoup mieux pour la suite. Merci d'avance pour vos réponses.

ReX : Les questions sont effectivement triviales et il est effectivement inquiétant que voir que la travail n'avance pas.

Amine: merci pour vos corrections.

D'après votre commentaire "32768-1024=31744 blocs", j'en déduis qu'il faut que je modifie ma commande dd (qui est actuellement "dd if=/dev/zero of=filesystem.bin bs=256 count=31250" pour avoir le bon filesystem).

ReX : Je comprends pas d'où tu sors le 31250. D'autant plus que la commande ci-dessous est bonne.

Amine : 31250 car 31250 blocs * 256 octets = 8 Mo.

ReX : Haaaa je vois tu utilises le système métrique international où le mégaoctet vaut 10^6 octets, sauf qu'aucun informaticien n'utilisera cette norme hors sol. Quand je parle de 8 Mo c'est 8x1024x1024 octets. Tout simplement parce qu'une puce mémoire de 8 Mo c'est bien 8x1024x1024 octets.

Amine: D'accord merci pour l'information !

'''Nouvelle commande dd:'''

dd if=/dev/zero of=filesystem.bin bs=256 count=32768

=== Fonction LS version 2 ===

Dans notre structure du système de fichier, le superbloc est constitué de 1024 blocs (16 blocs * 64 fichiers), un fichier étant décrit par 16 blocs. Le nom du fichier est donc écrit au début de tous les blocs multiples de 16. Par exemple, le nom du premier fichier est dans les 16 premiers octets du premier bloc, le nom du 2ème fichier est dans les 16 premiers octets du 32ème bloc et ainsi de suite, tant que des fichiers existent. Lorsque qu'il n'y a plus de fichier, le nom du premier caractère du bloc multiple de 16 est un 0.

Voici le code:
// Fonction pour lister les noms de fichiers présents dans le système de fichiers
void LS() {
unsigned char buffer[BLOCK_SIZE];
int fileCount = 0;

for (int blockNum = 1; blockNum <= MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, BLOCK_SIZE);

// Vérifier si le bloc est vide
if (buffer[0] == 0) {
break; // Plus de fichiers à lire
}

char filename[MAX_FILENAME_LENGTH];
memcpy(filename, buffer, MAX_FILENAME_LENGTH);

// Afficher le nom du fichier
printf("%s\n", filename);
fileCount++;
}

if (fileCount == 0) {
printf("Aucun fichier trouvé.\n");
}
}

ReX : Tu supposes que si un fichier a un nom vide, les suivants auront aussi un nom vide. C'est possible mais dans ce cas la commande <code>RM</code> ca être plus compliquée à écrire.

ReX : Tu ne sembles pas comprendre que la mémoire d'un microcontrôleur est limitée. Pourquoi lire le premier bloc de description d'un fichier en entier ? Dit autrement c'est quoi l'intérêt de lire 256 octets alors que 16 suffisent ?

ReX : Pourquoi tu ne lis pas le premier fichier ? Autrement dit pourquoi décaler tout d'un bloc ?

Amine: Merci pour vos remarques. J'ai apporté les modifications à LS dans la section "Semaine 4" du wiki.

'''Réflexion par rapport aux autres fonctions:'''

J'ai créé les fonctions TYPE et CAT mais il y a malheureusement un problème pour l'instant. Vous pouvez les retrouver en pièce jointe dans l'archive du fichier programme.c.

Le problème que j'ai est que lorsque j'affiche le contenu du fichier créé avec TYPE, j'obtiens plein de caractères spéciaux. Par exemple, je créé le fichier "mon_fichier.txt" avec la fonction TYPE, et je mets en entré standard "hello". Ensuite, je veux afficher le contenu de ce fichier grâce à la fonction CAT. Cependant, ce qui s'affiche dans le terminal n'est pas ce que je veux. De la même manière, lorsque je fais la commande "cat filesystem.bin" dans le terminal, c'est la même chose s'affiche, des donnés parasites.

ReX : Avant même de lire ton code je vais te poser la question de savoir comment tu récupères un bloc libre ? Quel algorithme tu utilises. Personnellement je ne sais pas faire sans ajouter au superbloc un tableau bit à bit des blocs libres. Pour avoir un bit pour chaque bloc du système de fichiers, il faut 32768/8=4096 octets soit 16 blocs.

Amine: ok je vais donc ajouter ce tableau de 16 blocs à la suite de mes premiers 1024 blocs servant à la description de fichier. Le superbloc fera maintenant 1024+16=1040 blocs (plus de détail à la fonction RM de la semaine 4).

Question 1: est ce que la fonction CAT que je dois créer doit renvoyer la même chose que "cat filesystem.bin" ?

ReX : Je préfère ne pas répondre tellement la question montre un manque de réflexion.

Question 2: comment savoir combien de blocs doivent etre attribué à un fichier? Par exemple, si je créé un fichier "mon_fichier.txt" et que je mets en entrée standard le texte "hello", un seul bloc suffi pour stocker ce texte. Cependant, si j'avais mis beaucoup de texte en entrée standard, il aurait fallu plus de blocs. Doit-on calculer la taille de l'entrée standard ou doit-on attribuer toujours le meme nombre de blocs à un fichier? Peut-etre ainsi attribuer 2040 blocs par fichier, meme s'il n'en utilise que 1.

ReX : Là encore c'est une question stupéfiante tellement la réponse est évidente. Il suffit de lire les données sur l'entrée standard et de passer au bloc de données suivant dès que le bloc courant est rempli. La question à poser c'était de se demander comment il est possible d'avoir la taille exacte du fichier pour un <code>CAT</code>. Il est uniquement possible de l'avoir à 256 octets près puisque rien n'indique si le dernier block est vide. Le mieux aurait été de prévoir 4 octets dans la description d'un fichier pour stocker la taille. En l'espèce on considérera que les fichiers sont des fichiers ASCII et qu'ils seront terminés par des <code>\'0</code> qui ne seront pas affichés.

== Semaine 4 ==

Voici un bilan de ce que j'ai fait à ce stade du projet:

* j'ai choisi une structure du système de fichier
* j'ai créé les fonctions readBlock et writeBlock permettant de lire et d'écrire des blocs
* j'ai crée la fonction LS permettant d'afficher le nom des fichiers présents dans le système de fichiers
* j'ai programmer un main permettant d'utiliser les fonctions (LS, TYPE...) depuis le terminal
* j'ai réflechi aux fonctions TYPE et CAT.

Actuellement, je suis en train de créer les fonctions TYPE et CAT.

=== Fonction LS version 3 ===
void LS() {
unsigned char buffer[MAX_FILENAME_LENGTH];
int fileCount = 0;

// Parcourir tous les 16 blocs de 0 jusqu'à MAX_FILES_IN_DIRECTORY
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, MAX_FILENAME_LENGTH);

// Vérifier si le nom de fichier est vide
if (buffer[0] != 0) {

// Afficher le nom du fichier
printf("%s\n", buffer);
fileCount++;
}
}

if (fileCount == 0) {
printf("Aucun fichier trouvé.\n");
}
}
Suite à vos remarques, j'ai effectué les modifications suivantes de la fonction LS:

* Je ne suppose plus que si un fichier a un nom vide, les autres auront aussi un nom vide.
* Je ne lis plus les 256 octets mais seulement les 16 premiers octets car cela suffit.
* Je ne lisais en effet pas le premier bloc. Je pensais que le premier bloc était d'indice 1 mais ce n'est pas le cas.

ReX : Ouiiii ! Une fonction correcte. Passe à <code>RM</code> maintenant, c'est la plus facile à faire concernant l'image bit à bit des blocs libres.

=== Fonction setBlockAvailability version 1 ===

Comme vous l'avez indiqué dans votre remarque, il faut un tableau dans le superbloc qui nous permettra de connaitre la disponibilité bit par bit de chaque bloc. Sachant qu'il y a dans notre système de fichiers 32768 blocs, et qu'il faut 1 bit par bloc, nous avons besoin de 32768 bits, soit 32768/8=4096 octets soit 4096/256=16 blocs. Notre superbloc sera donc comme suit: les 1024 premiers blocs servent à la description des fichiers, c'est à dire à leur nom suivi des numéros de blocs qui leur sont associés, puis ces 1024 blocs sont suivi de 16 blocs listant la disponibilité de chaque bloc.

ReX : Bien résumé.

Nous allons tout d'abord écrire la fonction "setBlockAvailability" prenant en paramètre le numéro du bloc à traiter (<code>blockNum</code>) et la disponibilité souhaitée pour ce bloc (<code>availability</code>). Cette fonction permet de marquer la disponibilité d'un bloc spécifique dans le système de fichiers. Nous utiliserons la convention suivante: un bloc disponible sera marqué par un 1 tandis qu'un bloc non disponible par un 0.
#define SUPERBLOCK_START_BLOCK 1024

void setBlockAvailability(int blockNum, int availability) {
// Calculer l'index du byte et le bit offset correspondant
int byteIndex = blockNum / 8;
int bitOffset = blockNum % 8;

// Lire le byte existant du bloc de disponibilité des blocs
unsigned char buffer[1];
readBlock(SUPERBLOCK_START_BLOCK + byteIndex, 0, buffer, 1);

// Mettre à jour le bit d'offset correspondant
if (availability) {
buffer[0] |= (1 << bitOffset);
} else {
buffer[0] &= ~(1 << bitOffset);
}

// Écrire le byte mis à jour dans le bloc de disponibilité des blocs
writeBlock(SUPERBLOCK_START_BLOCK + byteIndex, 0, buffer, 1);
}

ReX : Un tableau de un octet c'est un octet (variable <code>buffer</code>).

Amine: je vais utiliser un <code>unsigned char buffer.</code> Je suis conscient qu'un char vaut un octet mais je ne pense pas qu'il y ait un type de donnée de la taille d'un bit, c'est pourquoi je travaille avec un octet mais je modifie les bits de cet octet grâce aux algorithmes.

ReX : Il faut bien que tu travailles sur un octet vu que l'état des blocs est stocké sous la forme d'octets. Je disais juste qu'un tableau de 1 élément n'a pas d'intérêt par rapport à l'élément lui-même.

Amine: c'est vrai, modification faite.

ReX : Non il faut calculer le numéro du bloc avant de faire le <code>readBlock</code>.

Amine: ok je vais calculer le numéro de bloc avant.

ReX : La mise à jour du bit est correcte mais le block et le déplacement dans le block ne sont pas correctement calculés.

Amine: je vais vous expliquer le raisonnement que j'avais. Prenons un exemple concret, imaginons que je veuille marquer le bloc 1030 comme disponible:

# Calcul de l'index de l'octet et du bit offset :
#* <code>blockNum</code> = 1030
#* Index du byte = 1030 / 8 = 128
#* Bit offset = 1030 % 8 = 6
# Lecture de l'octet existant de disponibilité:
#* Nous lisons l'octet existant à l'index 128 dans les blocs de disponibilité.
# Mise à jour du bit de disponibilité :
#* Nous voulons marquer le bloc 1030 comme disponible, donc nous utilisons le masque <code>(1 << 6)</code> pour définir le bit 6 à 1 dans l'octet. Le résultat sera, par exemple, <code>00100000</code>.
# Écriture du byte mis à jour :
#* Nous écrivons le byte mis à jour <code>00100000</code> à l'index 128 dans les blocs de disponibilité.

ReX : Ben non, un vrai exemple :
* Il faut prendre un n° de bloc plus grand : 3072 ;
* Numéro d'octet dans la carte des blocs libres : 3072/8=384 ;
* Numéro du bloc dans la carte des blocs libres : 384/256=1 ;
* Numéro du bit <code>b</code> dans l'octet n° 384-256=128 du bloc 1 : 3072%8=0 ;
* Il faut donc lire l'octet <code>o</code> de numéro 128 du bloc 1, puis modifier cet octet par <code>o |= (1<<b)</code> ou <code>o &= ~(1<<b)</code> ;
* Enfin il faut écrire l'octet modifié dans le bloc 1.
Amine: merci pour cet exemple! J'ai compris d'où vient mon erreur. Voir fonction setBlockAvailability version 3.

Remarque: par convention, j'apellerai dans la suite de ce projet "premier superbloc" le superbloc correspondant à la description des fichiers, c'est à dire les 1024 premiers blocs, et j'appellerai "second superbloc" les 16 blocs qui suivent servant à décrire la disponibilité des blocs (du bloc 1024 au bloc 1039 inclu). Le reste des blocs servira à stocker les données.

ReX : Non, le superblc est l'ensemble des informations hors blocs de données, tu ne peux pas utiliser un vocabulaire au hasard. Parle de blocs de description des fichiers ou de carte des blocs libres.

Amine: ok

Je pense que le problème qui se pose est que l'indice du bit dans le second superbloc ne correspond pas à l'indice du bloc dans le système de fichier. Par exemple, nous voudrions que si le bloc 1030 est disponible dans le système de fichier, alors le bit numéro 1030 du deuxième superbloc soit à 1, ce qui n'est pas le cas ici. En effet, on se trouve bien dans le bon octet avec ma méthode mais l'écriture du bit se fait de la droite vers la gauche alors qu'on voudrait l'inverse. Ainsi, si le 6ème bit de l'octet doit être à 1, alors il faudrait qu'on obtienne <code>00000100</code> et non <code>00100000.</code> L'indice du bit coinciderait ainsi avec le numéro du bloc.

ReX : Non, réfléchit à nouveau.

Voir plus bas la nouvelle version de setBlockAvailability.

Explication de l'algorithme pour mettre le bit à 1 ou 0:

* <code>buffer[0] |= (1 << bitOffset);</code> : Cette ligne utilise l'opérateur OR bit à bit (<code>|=</code>) pour activer (mettre à 1) le bit spécifié par <code>bitOffset</code> dans le premier octet (<code>buffer[0]</code>). Cela se fait en décalant le bit 1 vers la gauche de <code>bitOffset</code> positions, puis en effectuant une opération OR bit à bit avec le contenu actuel de <code>buffer[0]</code>. Cette opération modifie uniquement le bit ciblé, laissant les autres bits inchangés.

ReX : Oui ça c'est bon.

* <code>buffer[0] &= ~(1 << bitOffset);</code> : Cette ligne utilise l'opérateur AND bit à bit (<code>&=</code>) pour désactiver (mettre à 0) le bit spécifié par <code>bitOffset</code> dans <code>buffer[0]</code>. Pour ce faire, l'expression <code>~(1 << bitOffset)</code> est utilisée pour créer un masque où tous les bits sont à 1, sauf celui correspondant à <code>bitOffset</code>, qui est à 0. En effectuant ensuite une opération AND bit à bit entre le masque et le contenu actuel de <code>buffer[0]</code>, on met à 0 le bit ciblé sans affecter les autres bits.

ReX : Ca aussi.

=== Fonction setBlockAvailability version 2 ===

void setBlockAvailability(int blockNum, int availability) {
// Calculer l'indice de l'octet et le bit offset correspondant
int byteIndex = blockNum / 8;
int bitOffset = 7 - (blockNum % 8); // Inversion de l'ordre des bits

// Calculer le numéro du bloc du super bloc où se trouve l'octet de disponibilité correspondant
int availabilityBlockNum = SUPERBLOCK_START_BLOCK + byteIndex;

// Lire l'octet existant dans le bloc de disponibilité du super bloc
unsigned char buffer;
readBlock(availabilityBlockNum, 0, &buffer, 1);

// Mettre à jour le bit d'offset correspondant :
if (availability) {
buffer |= (1 << bitOffset);
} else {
buffer &= ~(1 << bitOffset);
}

// Écrire l'octet mis à jour dans le bloc de disponibilité du super bloc
writeBlock(availabilityBlockNum, 0, &buffer, 1);
}
J'ai modifié la ligne <code>int bitOffset = 7 - (blockNum % 8);</code> pour inverser l'ordre des bits sélectionnés, de sorte que le bit correspondant au bloc disponible soit correct.

ReX : Encore plus faux.

Si on veut rendre le bloc 1030 indisponible alors que les autres blocs sont disponibles:

ReX : Pardon ? Le bloc de données est libre ou pas suivant la carte des blocs libres. Le rendre disponible n'est possible que si un fichier le comportant est détruit.

# Calcul de l'indice de l'octet et du bit offset correspondant :
#* <code>blockNum = 1030</code>
#* <code>byteIndex = 1030 / 8 = 128</code>
#* <code>bitOffset = 7 - 1030 % 8 = 1</code> Cela signifie que le bit d'intérêt se trouve à la position 2 dans l'octet.
# Calcul du numéro du bloc du super bloc où se trouve l'octet de disponibilité correspondant :
#* <code>availabilityBlockNum = SUPERBLOCK_START_BLOCK + 128 = 1024 + 128 = 1152</code> Donc, nous devons accéder à l'octet 1152 pour mettre à jour la disponibilité du bloc 1030.
# Lecture de l'octet existant dans le bloc de disponibilité du super bloc :
#* Le contenu de l'octet dans le bloc 1152 avant la mise à jour : 11111111 (en binaire)
# Mise à jour du bit d'offset correspondant :
#* Supposons que nous voulions marquer le bloc 1030 comme non disponible (<code>availability = 0</code>).
#* Le bitOffset est 1.
#* Nous effectuons une opération AND avec le complément du bit à la position 1 : <code>11111111 & 11111101 = 11111101</code>
# Écriture de l'octet mis à jour dans le bloc de disponibilité du super bloc :
#* Le contenu de l'octet 128 du second superbloc après la mise à jour : 11111101 (en binaire)

ReX : Toujours aussi faux.

Maintenant, le bit d'indice 1 du 128 ème octet du second superbloc est mis à 0, indiquant que le bloc 1030 n'est plus disponible. Les autres bits restent inchangés car nous avons effectué un AND avec un masque binaire qui avait des 1 partout sauf à la position du bit que nous souhaitions mettre à 0.

ReX : Erreur sur erreur.

=== Fonction setBlockAvailability version 3 ===
J'ai compris d'où vient l'erreur. La fonction readBlock prends en premier paramètre le numéro du bloc à lire, je ne peux donc pas lui donner la valeur "SUPERBLOCK_START_BLOCK + byteIndex" car byteIndex s'exprime en octet alors qu'on s'attend à un nombre de bloc ici. Il faut donc divisé byteIndex par 256 pour être en unité "bloc", et préciser le bit qu'on veut lire grâce à l'offset.

Pour obtenir l'octet que l'on veut, il faut prendre le reste de la division de byteIndex par 256. On va ensuite stocker cet octet dans notre "buffer".

Pour savoir quel bit modifier dans ce "buffer", on va prendre le reste de la division du bloc dont on veut mettre à jour la disponibilité par 8. On va ainsi pouvoir modifier ce bit grâce à l'algorithme, puis réécrire l'octet à son emplacement d'origine.

Cette fonction gère la carte de disponibilités des blocs. Si un bloc est disponible, alors elle le met un 0, si il est indisponible, elle met un 1.
#define SUPERBLOCK_START_BLOCK 1024

void setBlockAvailability(int blockNum, int availability) {

int byteIndexInCard = blockNum / 8; //Numéro d'octet dans la carte des blocs libres
int blockIndexInCard = byteIndexInCard / 256; //Numéro du bloc dans la carte des blocs libres
int byteIndexInBlock = byteIndexInCard % 256; //Numéro d'octet dans le bloc contenant le bit de disponibilité
int bitOffset = blockNum % 8; //Numéro du bit dans l'octet n°byteIndexInBlock du bloc blockIndexInCard

//indice du bloc contenant le bit à mettre à jour dans le bloc de description
int availabilityBlockNum = FIRST_DISPONIBILITY_CARD_BLOCK + blockIndexInCard;

// Lire l'octet existant dans le bloc de disponibilité du super bloc
unsigned char buffer;
readBlock(availabilityBlockNum, byteIndexInBlock, &buffer, 1);

// Mettre à jour le bit d'offset correspondant :
if (availability==1) { // indisponible
buffer |= (1 << bitOffset); // Mettre le bit à 1

} else { // disponible
buffer &= ~(1 << bitOffset); // Mettre le bit à 0
}

// Écrire l'octet mis à jour dans le bloc de disponibilité du super bloc
writeBlock(availabilityBlockNum, byteIndexInBlock, &buffer, 1);
}

ReX : Ben voila, c'est pas possible de te taxer d'excès de vitesse mais c'est bon.

update: j'ai fait une petite modification, maintenant un bloc disponible est marqué d'un 0 et un bloc indisponible est marqué d'un 1. C'est mieux dans la mesure où initialement, tous les blocs sont disponibles et tous les blocs sont à 0. Cela évite de devoir créer une fonction qui initialise toute la carte de disponibilités à 1 pour dire que tous les blocs sont disponibles.

=== Fonction RM version 1 ===

void RM(const char *filesystem_path, const char *filename) {
unsigned char buffer[BLOCK_SIZE];
int fileNum = -1;

// Parcourir les blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (memcmp(filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {
// Effacer le nom du fichier dans le superbloc
memset(filenameBuffer, 0, MAX_FILENAME_LENGTH);
writeBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

unsigned char fileBuffer[MAX_BLOCKS_PER_FILE * 2];
readBlock(blockNum, MAX_FILENAME_LENGTH, fileBuffer, MAX_BLOCKS_PER_FILE * 2);

// Libérer les blocs associés au fichier et réinitialiser les numéros de blocs
for (int i = 0; i < MAX_BLOCKS_PER_FILE * 2; i += 2) {
int blockNum = ((int)fileBuffer[i] << 8) + (int)fileBuffer[i + 1];
if (blockNum == 0) {
break; // Fin du fichier
}
setBlockAvailability(blockNum, 0); // Marquer le bloc comme disponible
fileBuffer[i] = 0;
fileBuffer[i + 1] = 0;
}

// Mettre à jour les numéros de blocs associés au fichier
writeBlock(blockNum, MAX_FILENAME_LENGTH, fileBuffer, MAX_BLOCKS_PER_FILE * 2);

fileNum = blockNum;
break; // Fichier trouvé, sortir de la boucle
}
}

// Afficher le résultat de l'opération
if (fileNum == -1) {
printf("Le fichier \"%s\" n'a pas été trouvé.\n", filename);
} else {
printf("Le fichier \"%s\" a été supprimé avec succès.\n", filename);
}
}

ReX : Vous utilisez <code>strcmp</code> comme <code>strncmp</code>. C'est bien la dernière qu'il faut utiliser mais en précisant la longueur du nom en paramètre, pas la taille maximale.

Amine: vous voulez dire que j'utilise memcmp au lieu de strncmp ? Ok je vais utiliser strncmp, c'est vrai que c'est plus adapté pour la comparaison de chaines de caractère.

ReX : Ha oui c'est <code>memcmp</code> que tu utilises. Ca ne peut effectivement pas marcher. Effectivement avec <code>strncmp</code> cela peut marcher vu qu'il s'arrête au premier 0 contrairement à <code>memcmp</code>.

Cependant, pourquoi doit-on passer la taille exacte du nom du fichier en paramètre, et non la taille maximale d'un nom de fichier? En effet, cela semble fonctionner en mettant la taille maximale en paramètre, tandis que lorsque l'on met la taille exacte du nom du fichier, cela pose un problème: on ne compare plus toute la chaîne de caractère mais seulement une portion du nom complet. Ainsi, si je crée par exemple un fichier que j'appelle "file1", puis que j’exécute la fonction RM "/picofs filesystem.bin RM file" par exemple, alors le fichier file1 va être supprimé quand même car on ne comparera que strlen(file)=4 premiers caractères, qui sont les mêmes, donc la fonction considérera ces chaines comme identiques. On pourrait alors se dire qu'il faudrait alors prendre plutôt comme taille en paramètre de la fonction strlen la taille du nom du fichier se trouvant dans le système de fichier plutôt que celle du nom donné en paramètre de RM. Cependant, le même problème se pose si la taille du nom du fichier du système de fichier est plus petite que celle du nom du fichier passé en paramètre. Par exemple, si le fichier présent dans système de fichier est "file", et qu'on met la longueur de file en paramètre de la fonction strcmp, puis qu'on exécute la commande "/picofs filesystem.bin RM file5", alors file sera quand même supprimé, car on ne comparera que les strlen(file)=4 premiers caractère. Finalement, une solution serait de rajouter une condition qui vérifie que les deux chaînes sont de taille identiques pour pouvoir réaliser la comparaison sur la taille exacte du nom du fichier. Cependant, il me semble qu'en mettant MAX_FILENAME_LENGTH qui vaut 16 en paramètre, cela fonctionne directement. Vous pouvez tester cela en testant mon programme.

ReX : Ok pour <code>strncmp</code> avec la taille maximale d'un nom de fichier.

etape 1: créer un fichier :
./picofs filesystem.bin TYPE fichier.txt

etape 2: verifier que le fichier a bien été créé :
./picofs filesystem.bin LS

Le terminal renvoie bien "fichier.txt"

etape 3: essayer de supprimer le fichier en mettant une chaine troncature du nom du fichier créé :
./picofs filesystem.bin RM fich

le terminal renvoi <<Le fichier "fich" n'a pas été trouvé.>>, le fichier n'a donc pas été supprimé .

etape 4: essayer de supprimer le fichier en mettant un nom plus grand incluant "fichier.txt" :
./picofs filesystem.bin RM fichier.txtt

terminal renvoi <<Le fichier "fichier.txtt" n'a pas été trouvé.>>

etape 5: enfin, tester en mettant le nom exacte du fichier que l'on veut supprimer :
./picofs filesystem.bin RM fichier.txt

terminal renvoi <<Le fichier "fichier.txt" a été supprimé avec succès.>>

Finalement, on voit que cela fonctionne avec la taille maximale mise en paramètre. On pourrait reprocher à cette méthode de comparer des caractères dans le vide, ce qui n'est pas optimal dans une optique d'économie de mémoire qui est la notre, mais la taille maximale d'un nom de fichier étant relativement faible (16 octets), on peut peut-être négliger cela au vu de l'économie d'une opération supplémentaire (comparaison de la taille des chaines de caractères).

ReX : Le parcours des blocs de données du fichier est atroce. Il faut parcourir les numéros de blocs dans le premier bloc du fichier derrière le nom du fichier puis il faut parcourir le 15 autres blocs.

Amine: Ok, je vais corriger cela dans la version 2 de RM (voir semaine 5).

Fonctionnement de la fonction RM:

* Parcours des blocs réservés pour la description des fichiers (superbloc) à partir du bloc 0, en incrémentant de 16 à chaque itération pour accéder aux blocs de noms de fichiers.

ReX : OK.

* Dans chaque bloc de noms de fichiers, la fonction compare le nom de fichier recherché avec les noms stockés dans les 16 octets de chaque bloc.

ReX : Non la fonction ne fait pas ça par contre il faudrait, oui.

Amine: Je pensais que c'était ce que je faisais avec "memcmp(filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0)".

* Si le nom de fichier est trouvé, la fonction efface le nom du fichier dans le superbloc en remplaçant les 16 octets du bloc par des zéros.

ReX : OK.

* Ensuite, la fonction accède aux octets suivants du même bloc pour obtenir les numéros de blocs associés au fichier.

ReX : Non, la boucle sort largement du premier bloc.

* Pour chaque paire de numéros de blocs (2 octets chacun), la fonction convertit les octets en un numéro de bloc. Si le numéro de bloc est nul, cela signifie la fin des blocs associés au fichier, sinon, la fonction marque ce bloc comme disponible en utilisant la fonction <code>setBlockAvailability</code> et réinitialise les numéros de blocs dans le tableau à zéro.
* Les numéros de blocs réinitialisés sont ensuite réécrits dans le bloc de description du fichier.

ReX : L'idée est là mais vu que la boucle n'est pas bonne, rien ne peut marcher.

* La fonction affiche ensuite un message indiquant le résultat de l'opération : soit que le fichier a été supprimé avec succès, soit que le fichier n'a pas été trouvé.

== Semaine 5 ==

=== Fonction RM version 2 ===

Concernant les remarques que vous m'avez faites précédemment:

* j'utilise maintenant la fonction <code>strncmp</code> pour la comparaison des chaines de caractères
* j'ai normalement corrigé le parcours des blocs. Je parcours maintenant d'abord les blocs multiples de 16 à la recherche du bloc contenant le nom du fichier à supprimer. Puis je parcours les 16 blocs de description du fichier à supprimer, afin de récupérer les numéros de blocs, libérer ces blocs dans la carte de disponibilité et de réinitialiser ces blocs dans les blocs de données.

void RM(const char *filesystem_path, const char *filename) {
int fileFound = -1;
int offset;

// Parcourir les blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char*)filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {

// Effacer le nom du fichier dans le superbloc
memset(filenameBuffer, 0, MAX_FILENAME_LENGTH);
writeBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);
fileFound = 1;
offset = blockNum;
break;
}

}

// Fin de fonction si fichier inexistant
if (fileFound == -1) {
printf("Le fichier \"%s\" n'a pas été trouvé.\n", filename);
return;
}

unsigned char buffer[BLOCK_SIZE];
//bloc que l'on va remplir de 0 et mettre à la place des blocs de données
memset(buffer, 0, BLOCK_SIZE); //on rempli buffer de 0

for (int blockNum=offset; blockNum<offset + 16; blockNum++) {

//premier bloc de description, celui contenant le nom du fichier dans les 16 premiers octets
if (blockNum == offset) {

unsigned char fileBuffer[BLOCK_SIZE-MAX_FILENAME_LENGTH];
//bloc dans lequel on va stocker les blocs de description de fichier
readBlock(blockNum, MAX_FILENAME_LENGTH, fileBuffer, BLOCK_SIZE-MAX_FILENAME_LENGTH);

// Libérer les blocs associés au fichier dans la carte de disponibilités
// et dans les blocs de description
for (int i = MAX_FILENAME_LENGTH; i < BLOCK_SIZE-MAX_FILENAME_LENGTH; i += 2) {
int blockNumData = ((int)fileBuffer[i] << 8) + (int)fileBuffer[i + 1];
if (blockNumData == 0) {
break; // Fin du fichier
}
setBlockAvailability(blockNumData, 0); // Marquer le bloc comme disponible
fileBuffer[i] = 0;
fileBuffer[i + 1] = 0;
writeBlock(blockNumData, 0, buffer, BLOCK_SIZE); //on efface les blocs de données
}
writeBlock(blockNum, MAX_FILENAME_LENGTH, fileBuffer, BLOCK_SIZE-MAX_FILENAME_LENGTH);
//on efface le premier bloc de description

} else {
unsigned char fileBuffer[BLOCK_SIZE];
readBlock(blockNum, 0, fileBuffer, BLOCK_SIZE);

// Libérer les blocs associés au fichier dans la carte de disponibilités et dans les blocs de description
for (int i = 0; i < BLOCK_SIZE; i += 2) {
int blockNumData = ((int)fileBuffer[i] << 8) + (int)fileBuffer[i + 1];
if (blockNumData == 0) {
break; // Fin du fichier
}
setBlockAvailability(blockNumData, 0); // Marquer le bloc comme disponible
fileBuffer[i] = 0;
fileBuffer[i + 1] = 0;
writeBlock(blockNumData, 0, buffer, BLOCK_SIZE); //on efface les blocs de données
}
writeBlock(blockNum, 0, fileBuffer, BLOCK_SIZE); //on efface le bloc de description
}
}
printf("Le fichier \"%s\" a été supprimé avec succès.\n", filename);
}

ReX : Pour construire le nombre sur 16 bits utiliser le OU plutôt que l'addition.

ReX : Heu non, je ne lis pas cette fonction avec tout ce code dupliqué, la seule différence entre les deux alternative est la position de début de l'adresse du premier bloc de données (<code>MAX_FILENAME_LENGTH</code> dans un cas et 0 dans l'autre). Donc l'alternative ne doit servir qu'à initialiser ce début, le reste du code doit être factorisé.

ReX : Et corrige le code, tu utilises deux tableaux de blocs (perte mémoire), tu écris le bloc à zéro dans l'itération (perte CPU).

=== Fonction RM version 3 ===

Suite à vos remarques, j'ai réalisé les modifications suivantes:

* j'utilise maintenant le OU plutôt que l'addition pour construire le nombre sur 16 bits.

* j'ai factorisé le code grâce à la création de la variable <code>startOffset</code> valant 16 lorsqu'on se trouve dans le bloc contenant le nom du fichier et valant 0 lorsqu'on se trouve dans les autres.

* Pour ce qui est du fait que j'utilise 2 tableaux de blocs, j'ai du mal à voir comment faire avec 1 seul tableau de blocs car ces deux tableaux n'ont pas du tout le même rôle. Le tableau <code>fileBuffer</code> permet de stocker les 16 blocs de description d'un fichier un à un. Lorsqu'on stocke un bloc dans <code>fileBuffer</code>, on lit ensuite les octets un à un de ce bloc afin de former des numéros de blocs, et pour chaque numéro de bloc créé, on va réinitialiser le bloc correspondant dans les blocs de données. Pour cela, on a donc besoin d'un autre bloc qui viendra écraser les anciens blocs de données. C'est pourquoi j'ai créé un bloc <code>buffer</code>qui est composé de 0 et qui va écraser les blocs de données. On ne peut pas utiliser <code>fileBuffer</code> car on a besoin d'un bloc de zéros, et si on réinitialise <code>fileBuffer</code> on perd toute les données qui s'y trouvent. Une possibilité serait de relire le bloc de donné à chaque itération de la deuxième boucle for imbriquée; cela permettrait de pouvoir réinitialiser le tableau fileBuffer à chaque itérations de cette boucle afin de stocker ce bloc de 0 dans les blocs de données, puis de restocker dans ce même tableau le bloc de description. Cependant, je ne pense pas que ce soit optimal de faire autant appel à la fonction readBlock.

* j'ai créé une fonction resetBock qui permet comme son nom l'indique de reset un bloc en le remplissant de 0. Cela nous évite de créer deux tableaux de blocs dans RM, bien que je pense que cela revienne au même car on fait appel à une fonction qui créé un tableau de blocs. Quoi qu'il en soit, cela allège le code et cette fonction pourra surement me resservir par la suite.

void RM(const char *filesystem_path, const char *filename) {
int fileFound = -1;
int offset;
unsigned char fileBuffer[BLOCK_SIZE];

// Parcourir les blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char *)filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {
// Effacer le nom du fichier dans le superbloc
memset(filenameBuffer, 0, MAX_FILENAME_LENGTH);
writeBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);
fileFound = 1;
offset = blockNum;
break;
}
}

// Fin de fonction si fichier inexistant
if (fileFound == -1) {
printf("Le fichier \"%s\" n'a pas été trouvé.\n", filename);
return;
}

for (int blockNum = offset; blockNum < offset + 16; blockNum++) {
int startOffset = 0;
if (blockNum == offset) {
startOffset = MAX_FILENAME_LENGTH;
}
readBlock(blockNum, startOffset, fileBuffer, BLOCK_SIZE - startOffset);

// Libérer les blocs associés au fichier dans la carte de disponibilités et dans les blocs de description
for (int i = 0; i < BLOCK_SIZE - startOffset; i += 2) {
int blockNumData = (fileBuffer[i] << 8) | fileBuffer[i + 1];
if (blockNumData == 0) {
break; // Fin du fichier
}
setBlockAvailability(blockNumData, 0); // Marquer le bloc comme disponible
fileBuffer[i] = 0;
fileBuffer[i + 1] = 0;
resetBlock(blockNumData); //on efface les blocs de données
}
writeBlock(blockNum, startOffset, fileBuffer, BLOCK_SIZE - startOffset);
}
printf("Le fichier \"%s\" a été supprimé avec succès.\n", filename);
}
'''Fonction resetBlock'''
void resetBlock(unsigned int blockNum) {
unsigned char buffer[BLOCK_SIZE];
memset(buffer, 0, BLOCK_SIZE);

// Utiliser writeBlock pour écrire les données du buffer dans le bloc
writeBlock(blockNum, 0, buffer, BLOCK_SIZE);
}

ReX : Ca s'améliore. Mais pourquoi cette fonction <code>resetBlock</code> ? Tu crois que dans qu'un système de fichiers perd du temps à mettre à zéro les blocs de données libérés ? Si oui, regarde la page de manual de la commande <code>shred</code>, ça manque à ta culture.

Amine: Après avoir consulter le manual de la commande <code>shred</code>, je vois que cette commande écrit des données aléatoires sur l'emplacement du fichier sur le disque. Par défaut, <code>shred</code> effectue un certain nombre de passes (par exemple, 3 passes) pendant lesquelles il écrit des données aléatoires sur l'emplacement du fichier sur le disque. Après avoir écrit les données aléatoires, <code>shred</code> peut effectuer des passes supplémentaires pendant lesquelles il écrit des données nulles (des zéros) sur le même emplacement. L'objectif de <code>shred</code> est d'augmenter la sécurité en rendant plus difficile la récupération des données supprimées à l'aide d'outils de récupération de données.

Cependant, j'ai aussi consulté comment fonctionne la commande <code>rm</code> de linux, et je vois que cette commande libère l'espace occupé par le fichier en marquant les blocs associés comme disponibles. Cela signifie que les données peuvent encore être récupérées à l'aide d'outils de récupération de données, à moins que des mesures supplémentaires ne soient prises pour écraser physiquement l'espace avec des données aléatoires (c'est ce que fait l'utilitaire <code>shred</code>).

On va donc opter pour la deuxième option, c'est à dire qu'on ne va pas perdre notre temps à remettre à zéro les blocs de données libérés, on va simplement marquer les blocs correspondants comme étant disponibles. Cela nous permettra de nous émanciper de la fonction resetBlock et de n'avoir plus qu'un seul tableau de blocs.

ReX : Sinon lire un bloc complet de pointeurs de blocs de données en mémoire n'est pas forcément optimal. L'idéal serait de lire ces blocs morceau par morceau (de 64 octets par exemple). Certes un bloc serait traité en 4 lectures/écritures (ce qui ralentirait le traitement) mais on gagne en mémoire. Le mieux serait de mettre la taille des morceaux en constante pour pouvoir choisir entre vitesse d'exécution et utilisation mémoire.

Amine: d'accord je comprends. Je vais modifier la fonction pour qu'on puisse découper la lecture/écriture en plusieurs blocs.

=== Fonction RM version 4 ===
Modifications apportées:

* je ne réinitialise plus les blocs de données, je supprime simplement le pointeur du fichier vers les blocs de données et je désigne les blocs comme "disponible" dans le carte de disponibilités. J'ai donc supprimé la fonction resetBlock.

* je ne lis plus les blocs en une seule fois mais en plusieurs fois via la variable CHUNK_SIZE:

# J'ai introduit la constante <code>CHUNK_SIZE</code> pour définir la taille de chaque morceau que nous allons lire/écrire à la fois. Cela permet de découper les opérations en blocs plus petits.
# Dans la boucle <code>for</code> où on parcours les blocs à partir de <code>offset</code>, j'ai ajouté une boucle interne qui parcourt les données du bloc en morceaux de taille <code>CHUNK_SIZE</code>.
# À l'intérieur de la boucle interne, j'ai calculé la taille réelle du morceau (<code>chunkSize</code>) en prenant le minimum entre <code>CHUNK_SIZE</code> et la quantité de données restant à lire/écrire dans le bloc.
# J'ai modifié la fonction <code>readBlock</code> pour lire seulement la quantité de données spécifiée par <code>chunkSize</code> à partir de <code>chunkStart</code>. Ces données sont stockées dans le tableau <code>fileBuffer</code>.
# Ensuite, j'ai effectué les mêmes opérations de libération des blocs associés au fichier, en parcourant les données du morceau et en marquant les blocs comme disponibles.
# Finalement, j'ai utilisé la fonction <code>writeBlock</code> pour écrire le morceau de données modifié dans le bloc, en utilisant la même <code>chunkStart</code> pour déterminer où écrire les données.

#define CHUNK_SIZE 64

int min(int a, int b) {
return a < b ? a : b;
}

void RM(const char *filesystem_path, const char *filename) {
int fileFound = -1;
int offset;
unsigned char fileBuffer[BLOCK_SIZE];

// Parcourir les blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char *)filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {
// Effacer le nom du fichier dans le superbloc
memset(filenameBuffer, 0, MAX_FILENAME_LENGTH);
writeBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);
fileFound = 1;
offset = blockNum;
break;
}
}

// Fin de fonction si fichier inexistant
if (fileFound == -1) {
printf("Le fichier \"%s\" n'a pas été trouvé.\n", filename);
return;
}

for (int blockNum = offset; blockNum < offset + 16; blockNum++) {
int startOffset = 0;

if (blockNum == offset) {
startOffset = MAX_FILENAME_LENGTH;
}

for (int chunkStart = startOffset; chunkStart < BLOCK_SIZE; chunkStart += CHUNK_SIZE) {
int chunkSize = min(CHUNK_SIZE, BLOCK_SIZE - chunkStart);
readBlock(blockNum, chunkStart, fileBuffer, chunkSize);

for (int i = 0; i < chunkSize; i += 2) {
int blockNumData = (fileBuffer[i] << 8) | fileBuffer[i + 1];
if (blockNumData == 0) {
writeBlock(blockNum, chunkStart, fileBuffer, chunkSize);
printf("Le fichier \"%s\" a été supprimé avec succès.\n", filename);
return; // Sortir des boucles
}
setBlockAvailability(blockNumData, 0); // Marquer le bloc comme disponible
fileBuffer[i] = 0;
fileBuffer[i + 1] = 0;
}

writeBlock(blockNum, chunkStart, fileBuffer, chunkSize);
}
}

printf("Le fichier \"%s\" a été supprimé avec succès.\n", filename);
}

ReX : Si on trouve un n° de bloc de données à 0, il faut sortir des deux boucles les plus externes après avoir fait le <code>writeBlock</code>.

Amine: Modification faites ci-dessus. Maintenant, dès qu'on trouve un n° de bloc de données à 0 dans la boucle la plus interne, on effectue le <code>writeBlock</code> et ensuite on utilise <code>return</code> pour sortir des deux boucles les plus externes. Cela permet d'optimiser le code en évitant de continuer à traiter inutilement le reste des blocs.

ReX : Pas très propre (duplication de code) mais nous allons nous en contenter.

=== Fonction intermédiaire TYPE version 1 ===

J'ai également commencé à réfléchir à la fonction TYPE. Pour l'instant, elle ne fait qu'ajouter les noms de fichier dans le superbloc. Cela permet de pouvoir tester les fonctions LS et RM (voir dans la rubrique compilation et exécution comment utiliser le programme).
// Fonction pour créer un fichier avec le nom donné et le contenu fourni en entrée standard
void TYPE(const char *filesystem_path, const char *filename) {
unsigned char buffer[MAX_FILENAME_LENGTH];
// Parcours des blocs réservés pour la description des fichiers
for (int blockNum = 0; blockNum <= MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, MAX_FILENAME_LENGTH);
// Vérifier si le bloc est vide (pas de nom de fichier)
if (buffer[0] == 0) {
// Écrire le nom du fichier dans l'emplacement vide du superbloc
writeBlock(blockNum, 0, (const unsigned char *)filename, MAX_FILENAME_LENGTH);
break; // Fichier créé, sortir de la boucle
}
}
printf("Le fichier \"%s\" a été créé avec succès.\n", filename);
}

ReX : Si la boucle se termine sans trouver de slot libre le message de succès s'affiche tout de même.

ReX : Le paramètre <code>filename</code> n'a pas forcément une taille de <code>MAX_FILENAME_LENGTH</code>.

Selon moi, la fonction TYPE devra respecter 3 étapes:

# Enregistrement du Nom du Fichier: L'ajout du nom du fichier dans un des blocs de la première partie du superbloc.
# Stockage des Données du Fichier: La récupération des données saisies en entrée standard par l'utilisateur et leur stockage dans des blocs du système de fichiers à partir d'une certaine position, comme le bloc 1040.
# Mise à Jour de la Disponibilité des Blocs: L'indication que les blocs dans lesquels les données ont été écrites ne sont plus disponibles en modifiant les bits correspondants dans la deuxième partie du superbloc (les 16 derniers blocs du super bloc).

ReX : Relis le point 3 et dit moi si tu te comprends toi même ?

Amine: Ma phrase n'est effectivement pas très claire. Je voulais dire que la fonction TYPE devra mettre à jour la carte de disponibilité du superbloc. C'est à dire que lorsqu'elle écrira des données dans des blocs, elle devra indiquer dans la carte de disponibilités que ces blocs ne sont plus disponibles.

=== Fonction intermédiaire TYPE version 2 ===

Suite à vos remarques, j'ai apporté les modifications suivantes à la fonction TYPE:

* j'ai ajouté une condition pour l'affichage du message de succès de la création d'un fichier (placeFound).

* le paramètre <code>filename</code> n'ayant pas forcément une taille de <code>MAX_FILENAME_LENGTH</code>, je calcule maintenant la longueur de filename, afin d'écrire seulement le nom du fichier avec la fonction writeBlock.

Il fonction n'est bien évidemment pas fini, elle ajoute seulement le nom du fichier dans le superbloc pour l'instant. Cela me permet de tester les fonctions LS et RM.
void TYPE(const char *filesystem_path, const char *filename) {
size_t sizeFilename = strlen(filename);
printf("size filename=%d\n", sizeFilename);
unsigned char buffer[MAX_FILENAME_LENGTH];
int placeFound = 0;

if (sizeFilename > MAX_FILENAME_LENGTH) {
printf("Impossible de créer le fichier, nom trop long\n");
return;
}

// Parcours des blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, MAX_FILENAME_LENGTH);
// Vérifier si le bloc est vide (pas de nom de fichier)
if (buffer[0] == 0) {
// Écrire le nom du fichier dans l'emplacement vide du superbloc
if (sizeFilename < MAX_FILENAME_LENGTH) {
sizeFilename+=1;
}
writeBlock(blockNum, 0, (const unsigned char *)filename, sizeFilename);
placeFound = 1;
break; // Fichier créé, sortir de la boucle
}
}
if (placeFound == 1) {
printf("Le fichier \"%s\" a été créé avec succès.\n", filename);
} else {
printf("Plus de place dans le système de fichier pour créer ce fichier.\n", filename);
}
}

ReX : Mieux, attention il faut copier aussi le <code>\'0</code> final du nom, donc <code>sizeFilename+1</code>. Sinon tu n'es pas sûr qu'il y ait un zéro final. Et attention n°2, il ne faut pas copier ce <code>\'0</code> si le nom fait la taille maximale.

Amine: ok j'ai modifié la fonction TYPE ci-dessus. J'ai ajouté une condition: si le nom du fichier est inférieur à la taille maximale de nom de fichier, alors on incrémente de 1 la taille du nom de fichier. Cela nous permet d'écrire le '\0' dans le bloc de description. Dans le cas où le nom du fichier est de la taille maximale, nous n'avons pas besoin d'écrire le '\0', on n'incrémente donc pas la taille de 1.

J'ai également ajouté une condition: si le nom du fichier est supérieur à la taille maximale, alors un message d'erreur s'affiche et le fichier n'est pas créé.

ReX : OK. L'embryon de fonction <code>TYPE</code> est correct, il manque juste le principal : la création des blocs de données.

=== Fonction MV version 1 ===

J'ai ici créé la fonction MV qui permet de changer le nom d'un fichier. Pour ce faire, la fonction parcourt les blocs de descriptions à la recherche du fichier dont on veut changer le nom. Lorsque ce fichier est trouvé, on supprime l'ancien nom en mettant des 0 sur 16 octets, puis on vient réécrire le nouveau nom dans le même emplacement. Enfin, on sort de la boucle et on affiche le succès ou non de l'opération.
// Fonction qui modifie le nom du fichier
void MV(const char *filesystem_path, const char *old_filename, const char *new_filename) {
size_t sizeNew_filename = strlen(new_filename);
size_t sizeOld_filename = strlen(old_filename);
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
int fileFound = 0;
// Parcourir les blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);
// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char*)filenameBuffer, old_filename, MAX_FILENAME_LENGTH) == 0) {
// Effacer le nom du fichier dans le superbloc
memset(filenameBuffer, 0, MAX_FILENAME_LENGTH);
writeBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);
// Écrire le nom du fichier dans l'emplacement
writeBlock(blockNum, 0, (const unsigned char *)new_filename, sizeNew_filename);
fileFound=1;
break; // Nom modifié, sortir de la boucle
}
}
if (fileFound == 1) {
printf("Le nom du fichier \"%s\" a été renommé avec succès.\n", old_filename);
} else {
printf("Le fichier \"%s\" n'a pas été trouvé.\n", old_filename);
}
}

ReX : Inutile d'écraser l'ancien nom avec des zéros. Il suffit de copier le nouveau en s'assurant qu'il y ait un zéro final sauf si le nouveau nom fait la taille maximale.

Amine: ok, je vais faire les modifications dans la version 2.

== Semaine 6 ==

=== Fonction MV version 2 ===
Dans cette nouvelle version de la fonction MV, j'ai effectué les modifications suivantes:

* je n'écrase plus l'ancien nom avec des 0
* Je colle simplement le nouveau nom par dessus l'ancien, en m'assurant qu'il y ait bien le '\0' à la fin lorsque la taille du nom du fichier est inférieur à la taille maximale. Comme précédemment, afin de m'assurer de la présence de ce '\0' à la fin du nom, j'incrémente la taille de 1 lorsque qu'elle est inférieur à la taille max. Cependant, je ne suis pas sûr à 100% que ce soit la bonne manière de faire.

// Fonction qui modifie le nom du fichier
void MV(const char *filesystem_path, const char *old_filename, const char *new_filename) {
size_t sizeNew_filename = strlen(new_filename);
size_t sizeOld_filename = strlen(old_filename);
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
int fileFound = 0;

// Parcourir les blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {

readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char*)filenameBuffer, old_filename, MAX_FILENAME_LENGTH) == 0) {

if (sizeNew_filename < MAX_FILENAME_LENGTH) {
sizeNew_filename+=1;
}

// Écrire le nom du fichier dans l'emplacement
writeBlock(blockNum, 0, (const unsigned char *)new_filename, sizeNew_filename);

fileFound=1;

break; // Nom modifié, sortir de la boucle
}
}
if (fileFound == 1) {
printf("Le nom du fichier \"%s\" a été renommé avec succès.\n", old_filename);
} else {
printf("Le fichier \"%s\" n'a pas été trouvé.\n", old_filename);
}
}

ReX : C'est bon. La fonction était triviale.

=== Fonction TYPE version 1 ===
void TYPE(const char *filesystem_path, const char *filename) {
size_t sizeFilename = strlen(filename);
unsigned char buffer[MAX_FILENAME_LENGTH];
int placeFound = -1;

if (sizeFilename > MAX_FILENAME_LENGTH) {
printf("Impossible de créer le fichier, nom trop long\n");
return;
}

// Parcours des blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, MAX_FILENAME_LENGTH);
// Vérifier si le bloc est vide (pas de nom de fichier)
if (buffer[0] == 0) {
// Écrire le nom du fichier dans l'emplacement vide du superbloc
if (sizeFilename < MAX_FILENAME_LENGTH) {
sizeFilename += 1; // Ajouter '\0' s'il y a de la place
}
writeBlock(blockNum, 0, (const unsigned char *)filename, sizeFilename);
placeFound = blockNum;

// Lire les données depuis l'entrée standard
unsigned char dataBuffer[BLOCK_SIZE];
size_t bytesRead;
int dataBlockNum = findAvailableBlock(); // Premier bloc de données à partir du bloc 1040
printf("dataBlockNum%d\n",dataBlockNum);
int blockSizeUsed = 0; // Compteur d'octets dans le bloc actuel
int dataBlocksNeeded = 1; // Nombre de blocs de données nécessaires

while ((bytesRead = fread(dataBuffer + blockSizeUsed, 1, BLOCK_SIZE - blockSizeUsed, stdin)) > 0) {
blockSizeUsed += bytesRead;

// Si le bloc actuel est plein, passer au bloc suivant
if (blockSizeUsed == BLOCK_SIZE) {
// printf("dataBlockNum=%d\n",dataBlockNum);
writeBlock(dataBlockNum, 0, dataBuffer, BLOCK_SIZE);
setBlockAvailability(dataBlockNum, 1);

dataBlockNum++; // Passer au bloc suivant
blockSizeUsed = 0; // Réinitialiser la taille utilisée
dataBlocksNeeded++;
}
}

// Écrire le dernier bloc partiel, s'il y en a un
if (blockSizeUsed > 0) {
writeBlock(dataBlockNum, 0, dataBuffer, blockSizeUsed);
setBlockAvailability(dataBlockNum, 1);
}

// Écrire les numéros de blocs utilisés dans le bloc de description
unsigned char blockNumberBuffer[2];
int currentBlockNum = 1040;

for (int i = 0; i < dataBlocksNeeded; i++) {
blockNumberBuffer[0] = (currentBlockNum >> 8) & 0xFF;
blockNumberBuffer[1] = currentBlockNum & 0xFF;
writeBlock(placeFound, MAX_FILENAME_LENGTH + i * 2, blockNumberBuffer, 2);
currentBlockNum++;
}

break; // Fichier créé, sortir de la boucle
}
}

if (placeFound != -1) {
printf("Le fichier \"%s\" a été créé avec succès.\n", filename);
} else {
printf("Plus de place dans le système de fichier pour créer ce fichier.\n");
}
}

ReX : La constante 1040 ne doit pas apparaître en numérique, ce doit être une constante calculée à partir des autres constantes.

Amine: Ok. Je ne l'avais pas défini comme une constante car il s'agit dans la fonction ci-dessus d'une variable qui est incrémenté à chaque itération.

ReX : Je suis las de te répéter que le mémoire est comptée : tu utilises encore un bloc de <code>BLOCK_SIZE</code> octets, c'est trop.

Amine: Comment utiliser des blocs plus petit sachant qu'il s'agit là de blocs de données et qu'un bloc fait 256 octets d'après l'énoncé ? Dois-je les subdiviser en plusieurs blocs plus petit comme fait dans la fonction RM, en 4 blocs de 64 octets par exemple ?

Fonctionnement de la fonction TYPE:

* étape 1: on parcourt les blocs de descriptions à la recherche d'un bloc disponible. Si on ne trouve pas de bloc disponible, on renvoie un message d'erreur, sinon on passe à l'étape suivante.
* étape 2: Si on trouve un emplacement libre dans les blocs de disponibilité, on écrit le nom du fichier dans cet emplacement.

ReX : Dans les blocs de description de fichiers pas dans les blocs de disponibilité.

Amine: Oui autant pour moi.

* étape 3: Ensuite, on lit le texte entré par l'utilisateur en entrée standard, on le répartit dans des blocs de taille BLOCK_SIZE, on met à jour la disponibilité des blocs utilisés.

ReX : Non, il faut appeler <code>findAvailableBlock</code> pour chaque bloc de données à utiliser, aucune certitudes que les blocs libres soient en séquence.

Amine: ok, je ferai cela dans la version 2

* étape 4: Enfin, on écrit les numéros des blocs de données utilisés dans les blocs de description de ce fichier, les numéros étant écris sur deux octets.

ReX : Non cela doit se faire au fur et à mesure des appels à <code>findAvailableBlock</code> et les numéros des blocs de données peuvent s'étaler sur les 16 blocs de description du fichier. Confusion totale sur ce point. Vous n'avez pas compris le mécanisme.

Amine: je corrige cela dans la version 2. J'ai bien compris le mécanisme mais ce n'est pas facile à traduire en code.

=== Fonction TYPE version 2 ===
Dans cette nouvelle version de TYPE, j'ai fait les modifications suivantes:

* j'appelle maintenant <code>findAvailableBlock</code> pour chaque bloc de données à utiliser
* j'écris maintenant les numéros de blocs au fur et à mesures des appels à <code>findAvailableBlock</code>
* je n'utilise plus de tableaux de taille 256 octets mais des tableaux de tailles CHUNK_SIZE. J'ai choisi ici CHUNK_SIZE = 64 octets.

J'utilise toujours un bloc de taille BLOCK_SIZE en attendant de comprendre si je dois diviser ce bloc en plusieurs blocs de taille plus petite ou s'il y a un moyen de ne pas du tout utiliser ces blocs.
void TYPE(const char *filesystem_path, const char *filename) {
size_t sizeFilename = strlen(filename);
unsigned char buffer[MAX_FILENAME_LENGTH];
int placeFound = -1;

if (sizeFilename > MAX_FILENAME_LENGTH) {
printf("Impossible de créer le fichier, nom trop long\n");
return;
}

// Parcours des blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, MAX_FILENAME_LENGTH);
// Vérifier si le bloc est vide (pas de nom de fichier)
if (buffer[0] == 0) {
// Écrire le nom du fichier dans l'emplacement vide du superbloc
if (sizeFilename < MAX_FILENAME_LENGTH) {
sizeFilename += 1; // Ajouter '\0' s'il y a de la place
}
writeBlock(blockNum, 0, (const unsigned char *)filename, sizeFilename);
placeFound = blockNum;

// Lire les données depuis l'entrée standard et écrire dans le fichier
int dataBlockNum = findAvailableBlock(); // Premier bloc de données à partir du bloc 1040
printf("Premier bloc dans lequel on écrit = %d\n", dataBlockNum);
int blockSizeUsed = 0; // Compteur d'octets dans le bloc actuel

unsigned char chunkBuffer[CHUNK_SIZE];
size_t bytesRead;

while ((bytesRead = fread(chunkBuffer, 1, CHUNK_SIZE, stdin)) > 0) {
// Écrire le chunk dans le bloc de données
writeBlock(dataBlockNum, blockSizeUsed, chunkBuffer, bytesRead);
setBlockAvailability(dataBlockNum, 1);

// Écrire le numéro du bloc actuel dans la description du fichier
unsigned char blockNumberBuffer[2];
blockNumberBuffer[0] = (dataBlockNum >> 8) & 0xFF;
blockNumberBuffer[1] = dataBlockNum & 0xFF;
writeBlock(placeFound, MAX_FILENAME_LENGTH + dataBlockNum * 2, blockNumberBuffer, 2);

blockSizeUsed += bytesRead;

// Si le bloc actuel est plein, passer au bloc suivant
if (blockSizeUsed == BLOCK_SIZE) {
dataBlockNum = findAvailableBlock(); // Passer au bloc suivant
blockSizeUsed = 0; // Réinitialiser la taille utilisée
}
}

break; // Fichier créé, sortir de la boucle
}
}

if (placeFound != -1) {
printf("Le fichier \"%s\" a été créé avec succès.\n", filename);
} else {
printf("Plus de place dans le système de fichier pour créer ce fichier.\n");
}
}

=== Fonction findAvailableBlock ===
Cette fonction renvoie l'indice du premier bloc disponible. Je me sers de cette fonction dans la fonction TYPE.
#define FIRST_DATA_BLOCK 1040
#define FIRST_DISPONIBILITY_CARD_BLOCK 1024

// Renvoie le premier bloc de donné disponible
int findAvailableBlock() {
unsigned char availabilityBuffer[BLOCK_SIZE];
int offset;

// Lire la carte de disponibilité (à partir du bloc 1)
for (int blockNum = FIRST_DISPONIBILITY_CARD_BLOCK; blockNum < FIRST_DATA_BLOCK; blockNum++) {
readBlock(blockNum, 0, availabilityBuffer, BLOCK_SIZE);

if (blockNum==FIRST_DISPONIBILITY_CARD_BLOCK) {
offset=FIRST_DATA_BLOCK/8;
} else {
offset=0;
}

// Parcourir les octets de la carte de disponibilité
for (int byteIndex = offset; byteIndex < BLOCK_SIZE - offset; byteIndex++) {
unsigned char byte = availabilityBuffer[byteIndex];

// Parcourir les bits de chaque octet
for (int bitIndex = 0; bitIndex < 8; bitIndex++) {
// Vérifier si le bit est à 0 (bloc disponible)
if ((byte & (1 << bitIndex)) == 0) {
// Calculer l'indice du bloc en fonction du bloc et du bit
int blockIndex = byteIndex * 8 + bitIndex;
return blockIndex;
}
}
}
}

// Aucun bloc disponible trouvé
return -1;
}

ReX : Même remarque que précédement sur les nombres 1024 et 1040.

Amine: Ok, j'ai remplacé 1024 par la constante FIRST_DISPONIBILITY_CARD_BLOCK et 1040 par la constante FIRST_DATA_BLOCK dans la fonction ci-dessus.

ReX : Vous n'avez toujours pas compris la contrainte sur la mémoire.

Amine: dois-je découper le bloc de taille BLOCK_SIZE en quatre blocs de taille 64 octets par exemple ?

ReX : Je ne vois pas ce que vous voulez faire avec <code>if (blockNum==1024) offset=1040/8; else offset=0;</code>.

Amine: dans la carte de disponibilité, chaque bit correspond à un bloc. Ainsi, les bits de 0 à 1040 dans la carte de disponibilité décrivent la disponibilité des blocs 0 à 1040. Or ces blocs correspondent au superbloc, et dans cette fonction, on veut connaître le premier bloc de données disponible. On ne s'intéresse donc pas au 1040 premiers bits de la carte de disponibilité. Je crée donc un offset égal à 1040/8 afin de ne pas prendre en compte les 1040 premiers bits soit les 1040/8=130 premiers octets. Cet offset ne s'applique que lorsqu'on se trouve dans le premier des 16 blocs de la carte de disponibilité, d'où la condition <code>if (blockNum==1024)</code>.

ReX : OK, bien vu.

=== Fonction CAT version 1 ===
void CAT(const char *filesystem_path, const char *filename) {
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
unsigned char buffer[BLOCK_SIZE];
unsigned char blockNumberBuffer[2];
unsigned char dataBuffer[BLOCK_SIZE];
int offset;

// Parcours des blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char *)filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {
// Le nom du fichier a été trouvé

// Parcours les blocs de description
for (int descrBlockNum=0; descrBlockNum<MAX_BLOCKS_PER_FILE_DESCRIPTION; descrBlockNum++) {
if (descrBlockNum==0) {
offset=16;
} else {
offset=0;
}
readBlock(descrBlockNum+blockNum, offset, buffer, BLOCK_SIZE-offset);

// Lire les numéros de blocs associés à ce fichier depuis les blocs de description
unsigned char octet1 = buffer[offset];
unsigned char octet2 = buffer[offset+1];

int dataBlockNum = (octet1 << 8) | octet2;
printf("dataBlockNum=%d\n",dataBlockNum);

// Vérifier si le numéro de bloc est valide (non nul)
if (dataBlockNum == 0) {
return; // Fin du fichier
}

// Lire et afficher le contenu du bloc de données
readBlock(dataBlockNum, 0, dataBuffer, BLOCK_SIZE);
fwrite(dataBuffer, 1, BLOCK_SIZE, stdout);
}

return; // Fichier affiché, sortie de la fonction
}
}

// Si le fichier n'a pas été trouvé
printf("Le fichier \"%s\" n'a pas été trouvé.\n", filename);
}

ReX : Encore mieux : deux blocs de <code>BLOCK_SIZE</code> en mémoire.

ReX : Le <code>break</code> ne sort pas de la boucle externe.

Amine: Oui c'est vrai. J'ai remplacé le <code>break</code> par un <code>return</code> ci-dessus.

ReX : Dans le cadre de la fonction CAT le <code>return</code> est convenable.

Voici ma fonction <code>CAT</code>. Elle fonctionne en plusieurs étape:

* étape 1: on cherche dans les blocs de descriptions si le fichier dont on veut afficher le contenu existe. Si le nom de fichier est trouvé, on passe à l'étape 2. Sinon, on renvoie un message d'erreur.
* étape 2: si le fichier est trouvé, on parcours les 16 blocs de description de ce fichier.
* étape 3: grâce aux opérations de masquage et de décalage, on joint les octets deux par deux pour former un entier qui contient le numéro du bloc de données correspondant au fichier. Si cet entier vaut 0, alors cela signifie qu'il n'y a plus de blocs associé à ce fichier, on peut donc quitter la fonction. Si cet entier est différent de 0, alors on va lire le bloc correspondant à ce numéro et on affiche son contenu dans le terminal.

== Semaine 7 ==

=== Fonction CP version 1 ===
Voici ma fonction CP, qui permet de créer une copie d'un fichier existant. L'idée est la suivante: pour copier un fichier, on doit créer un nouveau fichier et lui attribuer les mêmes blocs de descriptions que le fichier source. Ainsi, le fichier source et le fichier destination pointeront vers les mêmes blocs de données, et auront le même contenu.

ReX : Perdu. Ce n'est absolument pas la fonction de copie de fichiers d'un système de fichiers.

Amine: Après avoir fait des recherches et après réflexion, je me rends compte que cette fonction CP présente un problème: en faisant pointer les blocs de données du fichier destination vers ceux du fichier source, toute modification du fichier source impactera le fichier destination, or ce n'est pas ce qu'on veut faire. Je vous propose donc une nouvelle version de la fonction CP ci-dessous qui remédie à ce problème.

void CP(const char *filesystem_path, const char *source_filename, const char *destination_filename) {
unsigned char source_filenameBuffer[MAX_FILENAME_LENGTH];
unsigned char destination_filenameBuffer[MAX_FILENAME_LENGTH];
unsigned char descriptionBuffer[BLOCK_SIZE];
int destination_offset;
int offset;

// Recherche du fichier source
int source_offset = -1;
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, source_filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier source
if (strncmp((const char *)source_filenameBuffer, source_filename, MAX_FILENAME_LENGTH) == 0) {
source_offset = blockNum;
break;
}
}

if (source_offset == -1) {
printf("Le fichier source \"%s\" n'a pas été trouvé.\n", source_filename);
return;
}

// Recherche d'un emplacement libre pour le fichier destination
destination_offset = -1;
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, destination_filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc est vide (pas de nom de fichier)
if (destination_filenameBuffer[0] == 0) {
destination_offset = blockNum;
break;
}
}

if (destination_offset == -1) {
printf("Plus de place dans le système de fichier pour créer la copie de \"%s\".\n", source_filename);
return;
}

// Ecrit le nom de la copie dans le bloc de description
writeBlock(destination_offset, 0, (const unsigned char *)destination_filename, strlen(destination_filename));

// Copier les blocs de description associés au fichier source dans les blocs de description du fichier destination
for (int i = 0; i < MAX_BLOCKS_PER_FILE_DESCRIPTION; i++) {
if (i==0) {
offset = MAX_FILENAME_LENGTH;
} else {
offset = 0;
}

readBlock(source_offset+i, offset, descriptionBuffer, BLOCK_SIZE-offset);
if (descriptionBuffer[offset]==0) {
return;
} else {
writeBlock(destination_offset+i, offset, descriptionBuffer, BLOCK_SIZE-offset);
}
}

printf("La copie de \"%s\" sous le nom \"%s\" a été créée avec succès.\n", source_filename, destination_filename);
}

ReX : Pas mieux.

== Semaine 8 ==
A ce stade du projet, les fonctions suivantes ont été validé par Monsieur Redon:

* fonction LS
* fonction RM
* fonction MV

Il reste donc les fonctions suivantes à terminer:

* fonction CAT
* fonction CP
* fonction TYPE

=== Fonction CAT version 2 ===
Suite à vos remarques sur la version 1, j'ai fais les modifications suivantes:

* je n'utilise non plus 2 tableaux de taille BLOCK_SIZE, mais 1 seul. Idéalement il faudrait en utiliser 0, je réfléchi donc à m’émanciper de ce tableau en le remplaçant par plusieurs plus petits tableaux.

ReX : Un seul plus petit.

* J'ai remplacé le <code>break</code> par un <code>return</code>

ReX : Déjà validé.

Cette fonction permet d'afficher le contenu d'un fichier créé avec la fonction TYPE. Pour se faire, on parcours tout d'abord les blocs de descriptions pour trouver le fichier dont ont veut afficher le contenu. Une fois ce fichier trouvé, on parcours les 16 blocs de description de ce fichier 1 à 1. Pour chacun de ces blocs de description, on va stocker récupéré les octets deux par deux afin de former des entiers. Pour se faire, on utilise la fonction <code>reconsituteNumber</code> que l'on détaillera juste après. Ces entiers correspondent aux blocs dans lesquels la donné du fichier se trouve. Une fois l'entier reconstitué, on affiche le contenu du bloc correspondant.
#define CHUNK_SIZE 64

void CAT(const char *filesystem_path, const char *filename) {
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
unsigned char byteBuffer[2];
unsigned char dataBuffer[CHUNK_SIZE];
int offset;

// Parcours des blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char *)filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {
// Le nom du fichier a été trouvé

// Parcours les blocs de description
for (int descrBlockNum=0; descrBlockNum<MAX_BLOCKS_PER_FILE_DESCRIPTION; descrBlockNum++) {
if (descrBlockNum==0) {
offset=MAX_FILENAME_LENGTH;
} else {
offset=0;
}

// Lecture des octets deux par deux
for (int i=0; i<BLOCK_SIZE;i+=2) {
readBlock(descrBlockNum+blockNum, offset+i, byteBuffer, 2);

// Lire les numéros de blocs associés à ce fichier depuis les blocs de description
int dataBlockNum = reconsituteNumber(byteBuffer);

// Vérifier si le numéro de bloc est valide (non nul)
if (dataBlockNum == 0) {
return; // Fin du fichier
}

for (int chunkStart = 0; chunkStart < BLOCK_SIZE; chunkStart += CHUNK_SIZE) {
// Lire et afficher le contenu du bloc de données
readBlock(dataBlockNum, chunkStart, dataBuffer, CHUNK_SIZE);
fwrite(dataBuffer, 1, CHUNK_SIZE, stdout);
}
}
}

return; // Fichier affiché, sortie de la fonction
}
}

// Si le fichier n'a pas été trouvé
printf("Le fichier \"%s\" n'a pas été trouvé.\n", filename);
}

ReX : Remplacer le premier bloc de <code>BLOCK_SIZE</code> octets par un bloc de 2 octets est exagéré mais cela pourrait passer. Il reste toujours un bloc de <code>BLOCK_SIZE</code> octets dont il est facile de se passer au bénéfice d'un bloc de, mettons, 64 octets.

Amine: Voilà! Dans la version ci-dessus j'ai remplacé le bloc de taille <code>BLOC_SIZE</code> par un bloc de taille <code>CHUNK_SIZE</code>, avec <code>CHUNK_SIZE</code> modifiable dans les constantes du programme. J'ai pris ici 64 octets.

=== Fonction reconsituteNumber ===
Cette fonction permet de reconstituer un numéro de bloc à partir de deux octets.
// Fonction qui reconstitue le numéro de bloc à partir du tableau
int reconsituteNumber(unsigned char blockNumberBuffer[2]) {
unsigned char octet1 = blockNumberBuffer[0];
unsigned char octet2 = blockNumberBuffer[1];
int dataBlockNum = (octet1 << 8) | octet2;
return dataBlockNum;
}

ReX : Bonne idée cette fonction.

=== Fonction CP version 2 ===
Voici une version mise à jour de notre fonction CP. Dans la version précédente, on faisait pointer le fichier source vers les même blocs que le fichier destination. Cela posait un problème: toute modification du fichier source impactait le fichier destination. Ainsi, dans cette nouvelle version, on fait une duplication des blocs de données du fichier source vers le fichier destination. Cela implique donc une mise à jour de la carte de disponibilité, ainsi que l'adaptation des blocs de descriptions. En effet, seulement les blocs de données sont maintenant identiques, plus les blocs de description.

Piste d'amélioration: comme pour la fonction CAT ci-dessus, j'utilise toujours un bloc de taille 256 octets, je vais devoir y remédier.
// Fonction pour copier un fichier existant du système de fichier
void CP(const char *filesystem_path, const char *source_filename, const char *destination_filename) {
unsigned char source_filenameBuffer[MAX_FILENAME_LENGTH];
unsigned char destination_filenameBuffer[MAX_FILENAME_LENGTH];
unsigned char descriptionBuffer[CHUNK_SIZE];
unsigned char numBuffer[2];
int destination_offset;
int source_offset;
int offset;
int numDataBlock;
int newDataBlock;

// Recherche du fichier source
source_offset = -1;
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, source_filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier source
if (strncmp((const char *)source_filenameBuffer, source_filename, MAX_FILENAME_LENGTH) == 0) {
source_offset = blockNum;
break;
}
}

if (source_offset == -1) {
printf("Le fichier source \"%s\" n'a pas été trouvé.\n", source_filename);
return;
}

// Recherche d'un emplacement libre pour le fichier destination
destination_offset = -1;
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, destination_filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc est vide (pas de nom de fichier)
if (destination_filenameBuffer[0] == 0) {
destination_offset = blockNum;
break;
}
}

if (destination_offset == -1) {
printf("Plus de place dans le système de fichier pour créer la copie de \"%s\".\n", source_filename);
return;
}

// Copie du nom de la copie dans le bloc de description
writeBlock(destination_offset, 0, (const unsigned char *)destination_filename, strlen(destination_filename));

// Copier les blocs de données associés au fichier source dans de nouveaux blocs de données pour le fichier destination
for (int i = 0; i < MAX_BLOCKS_PER_FILE_DESCRIPTION; i++) {
if (i == 0) { offset = MAX_FILENAME_LENGTH; }
else { offset = 0; }

// Lecture des numéros de bloc dans les blocs de description
for (int byteNum=0; byteNum<BLOCK_SIZE; byteNum+=2) {
readBlock(source_offset + i, offset + byteNum, numBuffer, 2);

numDataBlock = reconsituteNumber(numBuffer);
if (numDataBlock == 0) {
printf("La copie de \"%s\" sous le nom \"%s\" a été créée avec succès.\n", source_filename, destination_filename);
return;
}

for (int chunkStart = 0; chunkStart < BLOCK_SIZE; chunkStart += CHUNK_SIZE) {
// On stocke le bloc de données associé au fichier source dans descriptionBuffer
readBlock(numDataBlock, chunkStart, descriptionBuffer, CHUNK_SIZE);

if (chunkStart == 0) {
// Trouver un nouveau bloc de données disponible
newDataBlock = findAvailableBlock();

// Mise à jour de la carte de disponibilités
setBlockAvailability(newDataBlock, 1);

// Ecriture du numéro de bloc dans la description du fichier
createNumberBuffer(newDataBlock,numBuffer);
writeBlock(destination_offset+i, offset+byteNum, numBuffer, 2);
}

// Ecriture du bloc de données dans le premier bloc disponible
writeBlock(newDataBlock, chunkStart, descriptionBuffer, CHUNK_SIZE);
}
}
}
}

ReX : Youpi. Il reste à se passer du bloc de <code>BLOCK_SIZE</code> (au bénéfice d'un bloc de taille <code>BLOCK_SIZE/n</code> avec n>1). Ecrire la fonction inverse de <code>reconsituteNumber</code>.

Amine: Voilà! Dans le fonction ci-dessus il n'y a plus de bloc de taille <code>BLOCK_SIZE</code>, on a maintenant des blocs de 64 octets (<code>CHUNK_SIZE</code>). J'ai également créé la fonction <code>createNumberBuffer</code> qui est la fonction inverse de<code>reconsituteNumber</code>. Je la détaille ci-dessous.

=== Fonction createNumberBuffer ===
Cette fonction permet repartir un entier sur deux octets.
// Fonction qui réparti un numéro de bloc sur deux octets
void createNumberBuffer(int dataBlockNum, unsigned char blockNumberBuffer[2]) {
blockNumberBuffer[0] = (dataBlockNum >> 8) & 0xFF;
blockNumberBuffer[1] = dataBlockNum & 0xFF;
}

=== Fonction TYPE version 3 ===
La fonction 2 que j'ai fourni ci-dessus n'est pas correcte. Je vais la corriger dans cette version 3.

ReX : Effectivement la version précédente ne gére pas correctement l'écriture des numéros de blocs de données dans la description d'un fichier.

= Compilation et exécution =
'''Création du système de fichiers :'''
dd if=/dev/zero of=filesystem.bin bs=256 count=32768

'''Compilation :'''

gcc picofs.c -o picofs

'''Exécution de LS, TYPE, CAT, RM, MV ou CP :'''

./picofs filesystem.bin LS
./picofs filesystem.bin TYPE mon_fichier.txt
./picofs filesystem.bin CAT mon_fichier.txt
./picofs filesystem.bin RM mon_fichier.txt
./picofs filesystem.bin MV mon_fichier.txt mon_fichier2.txt
./picofs filesystem.bin CP mon_fichier.txt mon_fichier2.txt

= Documents Rendus =
[[Fichier:Picofilesystemv2.c.tar|vignette]]

SE4 2022/2023 EC1

2023-09-03T18:32:55Z

Asellali : /* Fonction CAT version 2 */

= Objectifs =

Il vous est demandé de :
* réaliser un micro système de fichiers ;
* le système de fichiers doit résider dans un fichier de 8 Mo ;
* le système de fichiers est géré par un exécutable obtenu à partir d'un programme C ;
* L'éxécutable prend deux arguments, le premier est le chemin du fichier dans lequel réside le système de fichiers, les paramètres suivants concernent l'action à appliquer sur le système de fichiers ;
* le micro système de fichier ne comporte qu'un répertoire : le répertoire principal, le répertoire principal peut comporter au maximum 64 fichiers, un fichier est caractérisé par un nom de 16 caractères au maximum et ses blocs de données, un fichier peut comporter au maximum 2040 blocs de données ;
* un bloc de données fait 256 octets et les blocs sont numérotés sur 2 octets ;
* les différentes actions possibles sur le système de fichiers sont :
** <code>TYPE</code> pour créer un fichier si possible, le nom du fichier suit la commande, le contenu du fichier est donné en entrée standard de l'exécutable ;
** <code>CAT</code> pour afficher un fichier, le nom du fichier suit la commande ;
** <code>RM</code> pour détruire un fichier, le nom du fichier suit la commande ;
** <code>MV</code> pour renommer un fichier, les noms original et nouveau du fichier suivent la commande ;
** <code>CP</code> pour copier un fichier, les noms de l'original et de la copie du fichier suivent la commande ;

= Matériel nécessaire =

Un PC sous Linux.

= Travail réalisé =

== Semaine 1 ==

ReX : attention, ce micro-système de fichiers est prévu pour un microcontrôleur, vos variables globales ne peuvent pas dépasser quelques centaines d'octets.

ReX : pour la création du système de fichiers la commande <code>dd</code> suffit, vous voulez dire le formatage du système de fichiers ?

* création du programme programme.c contenant les différentes structures et les différentes fonctions.
* Piste d'amélioration: faire en sorte que la fonction CAT affiche le contenu exact des fichiers passés en argument.

Le code fourni est un programme en langage C qui simule un système de fichiers basique. Ce programme permet aux utilisateurs d'effectuer diverses actions telles que créer, afficher, supprimer, renommer et copier des fichiers dans un système de fichiers simulé. Le système de fichiers est stocké dans un fichier binaire.

ReX : vous n'avez pas tenu compte de la première remarque, vous chargez tout le superbloc et le répertoire racine, votre code ne convient pas.

ReX : vos structures utilisent des types entiers dont la taille n'est pas explicitée, utilisez les types de <code>stdint.h</code>.

ReX : la création de fichier n'est pas fonctionnelle, vous ne cherchez pas les blocs libres, vous ne copiez pas le contenu du fichier dans les blocs, même remarque pour toutes les autres fonctions.

ReX : il manque les fonctions d'accès aux pages du système de fichiers.

'''Explication du programme programme.c'''

Voici une brève explication des principaux éléments et fonctions du code :

# Structures :
#* Fichier : Représente un fichier dans le système de fichiers. Il contient un nom (nom) avec une longueur maximale de 16 caractères, un tableau de numéros de bloc (blocs) où le contenu du fichier est stocké (jusqu'à 2040 blocs), et le nombre de blocs utilisés par le fichier (nbBlocs).
#* Repertoire : Représente le répertoire principal du système de fichiers. Il contient un tableau de fichiers (<code>fichiers</code>) et le nombre de fichiers dans le répertoire (<code>nbFichiers</code>).
# Fonctions :
#* <code>chargerSystemeFichiers</code> : Charge le système de fichiers à partir d'un fichier binaire donné (chemin) dans une structure Repertoire.
#* <code>sauvegarderSystemeFichiers</code> : Sauvegarde le système de fichiers stocké dans la structure Repertoire dans un fichier binaire (chemin).
#* <code>creerFichier</code> : Crée un nouveau fichier dans le système de fichiers avec un nom et un contenu donnés. Le contenu du fichier est simulé en le divisant en blocs.
#* <code>afficherFichier</code> : Affiche le contenu d'un fichier avec le nom spécifié.
#* <code>detruireFichier</code> : Supprime un fichier avec le nom spécifié du système de fichiers.
#* <code>renommerFichier</code> : Renomme un fichier avec l'ancien nom spécifié en un nouveau nom.
#* <code>copierFichier</code> : Copie un fichier avec le nom spécifié en créant un nouveau fichier avec le nom de copie spécifié.
# Fonction <code>main</code> :
#* La fonction <code>main</code> est le point d'entrée du programme.
#* Elle prend des arguments en ligne de commande : <code><chemin_systeme_fichiers></code> et <code><action></code>.
#* <code><chemin_systeme_fichiers></code> est le chemin vers le fichier binaire où le système de fichiers est stocké.
#* <code><action></code> détermine quelle opération effectuer, comme <code>TYPE</code>, <code>CAT</code>, <code>RM</code>, <code>MV</code> ou <code>CP</code>.
#* En fonction de l'action spécifiée, le programme appelle la fonction correspondante pour effectuer l'opération souhaitée sur le système de fichiers.
Remarque : Le code fourni une simulation basique d'un système de fichiers et de ses opérations, mais il n'interagit pas réellement avec un système de fichiers réel sur le disque.

'''Comment utiliser le programme programme.c'''

étape 1: création du système de fichiers respectant le cahier des charges:

dd if=/dev/zero of=systeme_fichiers.bin bs=1M count=8

étape 2: compilation du programme C:

gcc programme.c -o gestionnaire_fs

étape 3: création d'un fichier dans le système de fichier:

./gestionnaire_fs systeme_fichiers.bin TYPE fichier1.txt

-> entrer le texte en entrée standard

étape 4: manipulation des différentes fonctions. Exemples:

./gestionnaire_fs systeme_fichiers.bin CAT fichier1.txt
./gestionnaire_fs systeme_fichiers.bin CP fichier1.txt copie.txt
./gestionnaire_fs systeme_fichiers.bin RM copie.txt
./gestionnaire_fs systeme_fichiers.bin MV fichier1.txt fichier2.txt

== Semaine 2 ==

Amine: Merci pour vos remarques. Désolé de ne pas avoir suivi votre première remarque, je pensais avoir compris ce qu'il fallait faire mais je me rend compte que non. Je vais tout reprendre depuis le début afin de repartir sur de bonnes bases.

'''Création du système de fichier avec la commande "dd"'''

A quoi sert la commande dd?

La commande <code>dd</code> permet de copier tout ou partie d'un disque par blocs d'octets, indépendamment de la structure du contenu du disque en fichiers et en répertoires (source : [https://doc.ubuntu-fr.org/dd]).

Structure de la commande

dd if=<nowiki><source> of=<cible> bs=<taille des blocs></nowiki>

<code>source</code> = données à copier

<code>cible</code> = endroit où les copier

<code>if</code> = input file

<code>of</code> = output file

<code>bs</code> = block size, habituellement une puissance de 2 supérieure ou égale à 512, représentant un nombre d'octets

Choix de la commande:

Pour la source, on prends <code>/dev/zero</code>: cela permet de créer un fichier rempli de 0. Ce fichier servira de base pour notre système de fichiers.

Pour la cible, on va l'appeler <code>filesystem.bin</Code> : ce sera notre système de fichier.

Pour la taille des blocs, on veut des blocs de données de 256 octets d'après l'enoncé. On va donc prendre <code>bs=256</code>.

Enfin, on veut que le système de fichier réside dans un fichier de 8 Mo. On va donc ajouter <code>count=31250</code>: cela indique que nous voulons écrire 32768 blocs de données dans le fichier (31250 * 256 octets = 8 Mo).

Résultat:

dd if=/dev/zero of=filesystem.bin bs=256 count=31250

Question pour M. Redon : j'ai ici essayé de respecter votre remarque "pour la création du système de fichiers la commande <code>dd</code> suffit". Cependant, pour votre seconde remarque "vous chargez tout le superbloc et le répertoire racine, votre code ne convient pas.", je ne suis pas sûr de comprendre où je fais cela: est-ce lors de la commande dd ou est-ce par la suite avec mon programme C? J'ai un peu modifié la commande dd comme vous pouvez le voir ci-dessus. Ai-je corrigé mon erreur avec cette nouvelle commande? J'ai essayé de justifier au maximum la commande dd que j'ai choisie.

ReX : Pas de problème avec la commande <code>dd</code> (mettez tous les extraits de code entre des balises <code>code</code>). Le problème est au niveau du programme C.

Amine: Ok je comprends mieux merci. Je vais donc reprendre le code étape par étape afin de mieux répondre au cahier des charges.

Gestion du système de fichier par un programme C

'''Création des structures'''
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>

// Structure pour représenter un bloc de données

struct DataBlock {
uint8_t data[256]; // 256 octets pour chaque bloc de données
};

// Structure pour représenter un fichier

struct File {
char filename[17]; // 16 caractères pour le nom du fichier + 1 caractère null-terminator
struct DataBlock data_blocks[2040]; // Tableau de blocs de données pour stocker le contenu du fichier
uint16_t num_data_blocks; // Nombre de blocs de données utilisés par le fichier
};

// Structure pour représenter un répertoire

struct Directory {
struct File files[64]; // Tableau de fichiers pour le répertoire principal
uint8_t num_files; // Nombre de fichiers dans le répertoire principal
};

Modification faite : suite à votre remarque, j'ai explicité la taille des entiers grâce aux types de <code>stdint.h.</code> (j'ai également mis les variables en anglais)

ReX : Vous ne pouvez pas utiliser ces structures, une instanciation d'une de ces structure prend trop d'espace mémoire, vous devez faire sans structure. Par ailleurs la façon dont vous représentez vos fichiers ne convient pas, la description d'un fichier contient des numéros de blocs, pas les blocs eux-même. Faites aussi attention qu'un fichier soit décrit par un nombre entier de blocs.

Question pratique: je n'arrive pas à mettre tout le code dans le même bloc comme vous l'avez fait ci-dessus dans l'étape 4 de la semaine 1. Je vois que c'est en format "préformaté" mais j'obtiens des blocs séparés lorsque j'applique ce format à mon code.

ReX : j'ai corrigé, pour un code entier la syntaxe n'est pas la même (un espace en début de chaque ligne), la balise c'est uniquement pour de très courts extraits de code.

=== Fonction <code>readBlock</code>===
Cette fonction est utilisée pour lire un bloc de données à partir du fichier <code>filesystem.bin</code> et le stocker dans un tableau de caractères (<code>storage</code>).

Fonction:

#define BLOCK_SIZE 256
// Fonction pour lire un bloc de données
void readBlock(unsigned int num, int offset, unsigned char *storage, int size) {
FILE *file = fopen("filesystem.bin", "rb");
if (file == NULL) {
perror("Erreur lors de l'ouverture du fichier");
return;
}
fseek(file, num * BLOCK_SIZE + offset, SEEK_SET);
fread(storage, 1, size, file);
fclose(file);
}

Paramètres :

* <code>num</code> : Numéro du bloc à lire. Chaque bloc contient 256 octets (1 bloc = 256 octets).
* <code>offset</code> : Décalage (en octets) à partir du début du bloc pour commencer la lecture.
* <code>storage</code> : Pointeur vers un tableau de caractères où les données lues seront stockées.
* <code>size</code> : Taille du tableau de caractères <code>storage</code>.

Fonctionnement :

* La fonction commence par ouvrir le fichier <code>filesystem.bin</code> en mode lecture binaire (<code>"rb"</code>).
* Elle utilise <code>fseek</code> pour positionner le curseur de lecture dans le fichier à l'endroit approprié pour commencer la lecture du bloc spécifié (<code>num</code>) à partir de l'offset (<code>offset</code>).
* Elle utilise ensuite <code>fread</code> pour lire <code>size</code> octets à partir du fichier et les stocker dans le tableau <code>storage</code>.
* Enfin, elle ferme le fichier avec <code>fclose</code>.

Note : Le paramètre <code>offset</code> est utilisé pour spécifier à partir de quel octet du bloc on souhaite commencer la lecture. Si <code>offset</code> est égal à 0, la lecture commencera depuis le début du bloc. Si <code>offset</code> est différent de 0, la lecture commencera à l'octet spécifié.

Remarque: dans votre mail, vous définissez "readBlock(unsigned int num,int offset,unsigned storage,int size)": storage n'est alors pas un pointeur vers un tableau de caractère. Je me suis donc permis de faire la modification.

ReX : OK pour la fonction, pas la peine d'en mettre autant dans le Wiki pour une fonction aussi simple.

=== Fonction <code>writeBlock</code> ===
Cette fonction est utilisée pour écrire un bloc de données dans le fichier <code>filesystem.bin</code> à partir d'un tableau de caractères (<code>storage</code>).

Fonction:

// Fonction pour écrire un bloc de données
void writeBlock(unsigned int num, int offset, const unsigned char *storage, int size) {
FILE *file = fopen("filesystem.bin", "rb+");
if (file == NULL) {
perror("Erreur lors de l'ouverture du fichier");
return;
}
fseek(file, num * BLOCK_SIZE + offset, SEEK_SET);
fwrite(storage, 1, size, file);
fclose(file);
}

Paramètres :

* <code>num</code> : Numéro du bloc où écrire.
* <code>offset</code> : Décalage (en octets) à partir du début du bloc pour commencer l'écriture.
* <code>storage</code> : Pointeur vers un tableau de caractères contenant les données à écrire dans le fichier.
* <code>size</code> : Taille du tableau de caractères <code>storage</code>.

Fonctionnement :

* La fonction commence par ouvrir le fichier <code>filesystem.bin</code> en mode lecture et écriture binaire (<code>"rb+"</code>).
* Elle utilise <code>fseek</code> pour positionner le curseur de lecture/écriture dans le fichier à l'endroit approprié pour commencer l'écriture du bloc spécifié (<code>num</code>) à partir de l'offset (<code>offset</code>).
* Elle utilise ensuite <code>fwrite</code> pour écrire <code>size</code> octets à partir du tableau <code>storage</code> dans le fichier.
* Enfin, elle ferme le fichier avec <code>fclose</code>.

ReX : Même remarque que pour la fonction précédente.

'''Etape 4: test des fonctions <code>readBlock</code> et <code>writeBlock</code> dans le main'''
// Exemple de fonction principale pour tester les opérations de lecture et d'écriture
int main() {
unsigned char data[BLOCK_SIZE];
// Test de la fonction readBlock
readBlock(0, 0, data, BLOCK_SIZE);
printf("Block 0, offset 0: ");
for (int i = 0; i < BLOCK_SIZE; i++) {
printf("%02x ", data[i]);
}
printf("\n");
// Test de la fonction writeBlock
unsigned char newData[BLOCK_SIZE] = {
0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88,
// ... Autres données du bloc ...
};
writeBlock(1, 0, newData, BLOCK_SIZE);
// Lecture du bloc nouvellement écrit pour vérifier
readBlock(1, 0, data, BLOCK_SIZE);
printf("Block 1, offset 0: ");
for (int i = 0; i < BLOCK_SIZE; i++) {
printf("%02x ", data[i]);
}
printf("\n");
return 0;
}

Fonctionnement :

* On déclare tout d'abord un tableau de caractères <code>data</code> de taille <code>BLOCK_SIZE</code> pour stocker les données lues du bloc.
* Ensuite, la fonction <code>readBlock</code> est appelée avec les arguments (0, 0, data, BLOCK_SIZE) pour lire le premier bloc du fichier (<code>num=0</code>, <code>offset=0</code>) et stocker les données dans <code>data</code>.
* Ensuite, la fonction <code>printf</code> est utilisée pour afficher les données lues du bloc (<code>data</code>) en format hexadécimal.
* Ensuite, un nouveau tableau de caractères <code>newData</code> est créé avec des données spécifiques pour tester la fonction <code>writeBlock</code>.
* La fonction <code>writeBlock</code> est appelée avec les arguments (1, 0, newData, BLOCK_SIZE) pour écrire le tableau <code>newData</code> dans le deuxième bloc du fichier (<code>num=1</code>, <code>offset=0</code>).
* Enfin, la fonction <code>readBlock</code> est appelée à nouveau pour lire le deuxième bloc nouvellement écrit et afficher les données lues en format hexadécimal.

Question générale : ce que j'avais la première semaine n'est plus forcément d'actualité. Puis-je supprimer les choses qui ne le sont plus afin d'alléger la page ou préférez-vous que je laisse?

ReX : Laissez.

Pour la suite : j'ai donc pour l'instant crée deux fonctions, l'une permettant la lecture et l'autre l'écriture d'un bloc, de manière à économiser la mémoire. Pour la suite, je vais essayer de créer la fonction <code>LS</code> en utilisant la fonction <code>readBlock</code>.

ReX : Oui c'est le début du projet. Mais si vous n'avez pas une bonne description de fichier cela ne donnera rien. Voir remarques plus haut.

'''Etape 5: fonction <code>LS</code>'''

Objectif: créer la fonction <code>LS</code> avec la fonction readBlock.

Question: Souhaitez-vous la fonction <code>LS</code> classique, c'est à dire la fonction <code>LS</code> qui affiche simplement le nom des fichiers présent dans le répertoire ?

ReX : Oui. Tu peux ajouter la taille si tu trouves cela trop simple.

Piste : si c'est ce que vous voulez:

* il va tout d'abord falloir que je crée des fichiers, un fichier étant composé d'un nom et de blocs (création d'une fonction createFile)
* Il faudra ensuite que je stocke ces fichiers dans le répertoire (création d'une fonction addFileToDirectory par exemple)
* enfin, il faudra que j'affiche le nom des fichiers. Pour cela, il faudra que je parcours le répertoire (structure "Directory"), puis que pour chaque fichier présent dans le répertoire que j'affiche son nom (création de la fonction LS)

Je devrais surement utiliser la fonction readBlock afin de transférer les blocs dans le fichier au travers de la variable "storage".

ReX : Créer des fichiers n'est pas nécessaire tout de suite je verrais bien si ton code est bon sans test. Laisse tomber <code>createFile</code> et <code>addFileToDirectory</code> pour l'instant.

ReX : Ton algorithme ne fonctionne pas pour un microcontrôleur où il faut économiser la mémoire, tu ne peux pas t'aider de structures. Il faudra que tu charges les noms et seulement les noms, pour la taille il faudra se baser sur le nombre de blocs.

'''Etape 6: rectification du code suite à vos remarques'''

Modifications apportées:

* suppression des structures afin d’économiser de la mémoire.

* le problème quant à la description des fichiers est normalement résolu puisque plus de structures. On ne charge plus les blocs mais seulement les noms de fichiers.

ReX : Non car si les noms ne sont pas répartis de façon régulière dans les blocs de 256 octets tu vas avoir du mal à les charger. Mais écrit la fonction <code>LS</code> et tu verras ce que je veux dire.

J'ai également ajouté deux nouvelles fonctions:

# <code>void readFileName(unsigned int file_num, char *file_name)</code>: Cette fonction permet de lire le nom du fichier associé au numéro de fichier donné (<code>file_num</code>). Elle stocke le nom du fichier lu dans le tableau <code>file_name</code>.
# <code>void writeFileName(unsigned int file_num, const char *file_name)</code>: Cette fonction permet d'écrire le nom du fichier dans le système de fichiers, associé au numéro de fichier donné (<code>file_num</code>). Elle prend en entrée le nom du fichier à écrire (<code>file_name</code>).

Suite: si vous validez cette base, je pourrai passer à la création de la fonction LS.

ReX : tu peux y aller. Je ne vois pas le code des tes deux fonctions <code>readFileName</code> et <code>writeFileName</code>.

Voici le code des fonctions <code>readFileName</code> et <code>writeFileName</code> :

'''Fonction readFileName:'''
// Fonction pour lire le nom du fichier
void readFileName(unsigned int file_num, char *file_name) {
readBlock(file_num, 0, (unsigned char *)file_name, MAX_FILENAME_LENGTH);
file_name[MAX_FILENAME_LENGTH] = '\0'; // Ajout du caractère null-terminator pour former une chaîne de caractères
}

ReX : Non, aucune raison que le fichier de numéro n soit au bloc n. Dessine la représentation d'un fichier sur le SF en comptant les octets si cela peut aider.

'''Fonction writeFileName:'''
// Fonction pour écrire le nom du fichier
void writeFileName(unsigned int file_num, const char *file_name) {
writeBlock(file_num, 0, (const unsigned char *)file_name, MAX_FILENAME_LENGTH);
}

ReX : Faux et inutile pour l'instant. Problème avec la constante MAX_FILENAME_LENGTH.

=== Fonction LS version 1 ===
// Fonction LS pour afficher les fichiers présents dans le système de fichiers
void LS(const char *filesystem_path) {
FILE *file = fopen(filesystem_path, "rb");
if (file == NULL) {
perror("Erreur lors de l'ouverture du fichier système");
return;
}
uint16_t num_files;
fread(&num_files, sizeof(uint16_t), 1, file); // Lecture du nombre de fichiers dans le système
char filename[17];
printf("Fichiers présents dans le système de fichiers:\n");
for (int i = 0; i < num_files; i++) {
readFileName(i, filename); // Lecture du nom du fichier
printf("%s\n", filename); // Affichage du nom du fichier
}
fclose(file);
}
La fonction <code>LS</code> ouvre le fichier système, lit le nombre de fichiers qu'il contient, puis affiche les noms des fichiers un par un, chacun sur une ligne séparée.

ReX : Il y a le nombre de fichiers dans ton superbloc ? Un dessin du format du superbloc avec les numéros des octets ?

ReX : Tout accès au système de fichiers doit se faire avec les deux fonctions <code>readBlock</code> et <code>writeBlock</code>.

== Semaine 3 ==
Question 1: cela fait plusieurs fois que vous mentionnez dans le wiki un "superbloc". Celui-ci n'étant pas clairement défini dans le sujet, je me demande s'il s'agit du bloc crée grâce à la fonction dd, c'est à dire que le superbloc serait en faite le bloc constitué des 31250 blocs de taille 256 octets, où s'il s'agit d'un bloc qui vient en entête, celui contenant alors des informations décrivant le système de fichier (les noms de fichiers...).

ReX : Pour ton pico système de fichiers, le superbloc consiste en les premiers blocs (de 256 octets) qui définissent les 64 fichiers possibles.

Proposition de structure: on pourrait réserver les premiers blocs du système de fichiers aux noms de fichiers ainsi qu'aux numéros des blocs correspondant à chaque fichier.

ReX : Oui c'est évident.

On sait que les noms de fichiers font au maximum 16 caractères + 1 caractère pour le '\0' (donc 17 octets car 1 char=1 octet).

ReX : Non, 16 octets suffisent, des '\0' en fin de nom uniquement si le nom fait moins de 16 caractères.

On sait également qu'un fichier contient au maximum 2040 blocs, chaque bloc étant numéroté sur 2 octets. On pourrait donc avoir en début du système de fichier: 17 octets+2 octets*2040 blocs = 4097 octets pour la description d'un fichier.

ReX : Non, 4096 octets soit 16 blocs de 256.

Or d'après l'une de vos remarques dans le wiki, un fichier doit être décrit par un nombre entier de blocs. Pour un fichier, il nous faudra donc 4097/256=16.004 soit 17 blocs. Il peut y avoir jusqu'à 64 fichiers dans le répertoire, il nous faudra donc 17 blocs*64 fichiers= 1088 blocs pour la description des fichiers.

ReX : Non 1024 blocs de 256 octets dans le superbloc.

Ainsi, pour la fonction LS, il suffira de lire les premiers caractères tous les 17 blocs ( du premier caractère au caractère '\0').

ReX : Non, tous les 16 blocs.

Question 2: Ne faudrait-il pas également stocker quelque part le nombre de fichier qu'il y a dans le répertoire afin de savoir jusqu'à quel bloc la fonction LS doit aller ?

ReX : Non, un fichier dont le nom n'est constitué que de '\0' est réputé ne pas exister.

Question 3: on a donc vu que les 1088 premiers blocs au maximum serviraient à la description du système de fichier. Il reste donc 31250-1088=30132 blocs dans le système de fichier.

ReX : Non, 32768-1024=31744 blocs.

Comment utiliser ces blocs? Ces blocs doivent-ils stocker le contenu des fichiers ?

ReX : Oui, c'et évident.

En effet, avec la fonction TYPE, nous allons créer des fichiers et ces fichiers devront être stockés quelque part. Cependant, étant donné que ce pico système de fichiers est prévu pour un microcontrôleur, je ne sais pas si c'est le contenu des fichiers qui doit être stocké dans les blocs ou autre chose (peut être l'adresse des fichiers, le fichiers se trouvant autre part). En effet, je me dis que si un fichier est très volumineux, il ne pourra pas rentrer dans le système de fichier, ce dernier étant composé d'un nombre limité de blocs, et les blocs étant eux même limité en nombre d'octets.

ReX : Je ne comprend pas ton problème. De tout façon comme dit plus haut, les 31744 blocs suivant le superbloc doivent contenir les données des fichiers.

Désolé de poser des questions peut être basique aussi tard, mais je pense qu'une fois que j'aurai ces réponses, cela ira beaucoup mieux pour la suite. Merci d'avance pour vos réponses.

ReX : Les questions sont effectivement triviales et il est effectivement inquiétant que voir que la travail n'avance pas.

Amine: merci pour vos corrections.

D'après votre commentaire "32768-1024=31744 blocs", j'en déduis qu'il faut que je modifie ma commande dd (qui est actuellement "dd if=/dev/zero of=filesystem.bin bs=256 count=31250" pour avoir le bon filesystem).

ReX : Je comprends pas d'où tu sors le 31250. D'autant plus que la commande ci-dessous est bonne.

Amine : 31250 car 31250 blocs * 256 octets = 8 Mo.

ReX : Haaaa je vois tu utilises le système métrique international où le mégaoctet vaut 10^6 octets, sauf qu'aucun informaticien n'utilisera cette norme hors sol. Quand je parle de 8 Mo c'est 8x1024x1024 octets. Tout simplement parce qu'une puce mémoire de 8 Mo c'est bien 8x1024x1024 octets.

Amine: D'accord merci pour l'information !

'''Nouvelle commande dd:'''

dd if=/dev/zero of=filesystem.bin bs=256 count=32768

=== Fonction LS version 2 ===

Dans notre structure du système de fichier, le superbloc est constitué de 1024 blocs (16 blocs * 64 fichiers), un fichier étant décrit par 16 blocs. Le nom du fichier est donc écrit au début de tous les blocs multiples de 16. Par exemple, le nom du premier fichier est dans les 16 premiers octets du premier bloc, le nom du 2ème fichier est dans les 16 premiers octets du 32ème bloc et ainsi de suite, tant que des fichiers existent. Lorsque qu'il n'y a plus de fichier, le nom du premier caractère du bloc multiple de 16 est un 0.

Voici le code:
// Fonction pour lister les noms de fichiers présents dans le système de fichiers
void LS() {
unsigned char buffer[BLOCK_SIZE];
int fileCount = 0;

for (int blockNum = 1; blockNum <= MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, BLOCK_SIZE);

// Vérifier si le bloc est vide
if (buffer[0] == 0) {
break; // Plus de fichiers à lire
}

char filename[MAX_FILENAME_LENGTH];
memcpy(filename, buffer, MAX_FILENAME_LENGTH);

// Afficher le nom du fichier
printf("%s\n", filename);
fileCount++;
}

if (fileCount == 0) {
printf("Aucun fichier trouvé.\n");
}
}

ReX : Tu supposes que si un fichier a un nom vide, les suivants auront aussi un nom vide. C'est possible mais dans ce cas la commande <code>RM</code> ca être plus compliquée à écrire.

ReX : Tu ne sembles pas comprendre que la mémoire d'un microcontrôleur est limitée. Pourquoi lire le premier bloc de description d'un fichier en entier ? Dit autrement c'est quoi l'intérêt de lire 256 octets alors que 16 suffisent ?

ReX : Pourquoi tu ne lis pas le premier fichier ? Autrement dit pourquoi décaler tout d'un bloc ?

Amine: Merci pour vos remarques. J'ai apporté les modifications à LS dans la section "Semaine 4" du wiki.

'''Réflexion par rapport aux autres fonctions:'''

J'ai créé les fonctions TYPE et CAT mais il y a malheureusement un problème pour l'instant. Vous pouvez les retrouver en pièce jointe dans l'archive du fichier programme.c.

Le problème que j'ai est que lorsque j'affiche le contenu du fichier créé avec TYPE, j'obtiens plein de caractères spéciaux. Par exemple, je créé le fichier "mon_fichier.txt" avec la fonction TYPE, et je mets en entré standard "hello". Ensuite, je veux afficher le contenu de ce fichier grâce à la fonction CAT. Cependant, ce qui s'affiche dans le terminal n'est pas ce que je veux. De la même manière, lorsque je fais la commande "cat filesystem.bin" dans le terminal, c'est la même chose s'affiche, des donnés parasites.

ReX : Avant même de lire ton code je vais te poser la question de savoir comment tu récupères un bloc libre ? Quel algorithme tu utilises. Personnellement je ne sais pas faire sans ajouter au superbloc un tableau bit à bit des blocs libres. Pour avoir un bit pour chaque bloc du système de fichiers, il faut 32768/8=4096 octets soit 16 blocs.

Amine: ok je vais donc ajouter ce tableau de 16 blocs à la suite de mes premiers 1024 blocs servant à la description de fichier. Le superbloc fera maintenant 1024+16=1040 blocs (plus de détail à la fonction RM de la semaine 4).

Question 1: est ce que la fonction CAT que je dois créer doit renvoyer la même chose que "cat filesystem.bin" ?

ReX : Je préfère ne pas répondre tellement la question montre un manque de réflexion.

Question 2: comment savoir combien de blocs doivent etre attribué à un fichier? Par exemple, si je créé un fichier "mon_fichier.txt" et que je mets en entrée standard le texte "hello", un seul bloc suffi pour stocker ce texte. Cependant, si j'avais mis beaucoup de texte en entrée standard, il aurait fallu plus de blocs. Doit-on calculer la taille de l'entrée standard ou doit-on attribuer toujours le meme nombre de blocs à un fichier? Peut-etre ainsi attribuer 2040 blocs par fichier, meme s'il n'en utilise que 1.

ReX : Là encore c'est une question stupéfiante tellement la réponse est évidente. Il suffit de lire les données sur l'entrée standard et de passer au bloc de données suivant dès que le bloc courant est rempli. La question à poser c'était de se demander comment il est possible d'avoir la taille exacte du fichier pour un <code>CAT</code>. Il est uniquement possible de l'avoir à 256 octets près puisque rien n'indique si le dernier block est vide. Le mieux aurait été de prévoir 4 octets dans la description d'un fichier pour stocker la taille. En l'espèce on considérera que les fichiers sont des fichiers ASCII et qu'ils seront terminés par des <code>\'0</code> qui ne seront pas affichés.

== Semaine 4 ==

Voici un bilan de ce que j'ai fait à ce stade du projet:

* j'ai choisi une structure du système de fichier
* j'ai créé les fonctions readBlock et writeBlock permettant de lire et d'écrire des blocs
* j'ai crée la fonction LS permettant d'afficher le nom des fichiers présents dans le système de fichiers
* j'ai programmer un main permettant d'utiliser les fonctions (LS, TYPE...) depuis le terminal
* j'ai réflechi aux fonctions TYPE et CAT.

Actuellement, je suis en train de créer les fonctions TYPE et CAT.

=== Fonction LS version 3 ===
void LS() {
unsigned char buffer[MAX_FILENAME_LENGTH];
int fileCount = 0;

// Parcourir tous les 16 blocs de 0 jusqu'à MAX_FILES_IN_DIRECTORY
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, MAX_FILENAME_LENGTH);

// Vérifier si le nom de fichier est vide
if (buffer[0] != 0) {

// Afficher le nom du fichier
printf("%s\n", buffer);
fileCount++;
}
}

if (fileCount == 0) {
printf("Aucun fichier trouvé.\n");
}
}
Suite à vos remarques, j'ai effectué les modifications suivantes de la fonction LS:

* Je ne suppose plus que si un fichier a un nom vide, les autres auront aussi un nom vide.
* Je ne lis plus les 256 octets mais seulement les 16 premiers octets car cela suffit.
* Je ne lisais en effet pas le premier bloc. Je pensais que le premier bloc était d'indice 1 mais ce n'est pas le cas.

ReX : Ouiiii ! Une fonction correcte. Passe à <code>RM</code> maintenant, c'est la plus facile à faire concernant l'image bit à bit des blocs libres.

=== Fonction setBlockAvailability version 1 ===

Comme vous l'avez indiqué dans votre remarque, il faut un tableau dans le superbloc qui nous permettra de connaitre la disponibilité bit par bit de chaque bloc. Sachant qu'il y a dans notre système de fichiers 32768 blocs, et qu'il faut 1 bit par bloc, nous avons besoin de 32768 bits, soit 32768/8=4096 octets soit 4096/256=16 blocs. Notre superbloc sera donc comme suit: les 1024 premiers blocs servent à la description des fichiers, c'est à dire à leur nom suivi des numéros de blocs qui leur sont associés, puis ces 1024 blocs sont suivi de 16 blocs listant la disponibilité de chaque bloc.

ReX : Bien résumé.

Nous allons tout d'abord écrire la fonction "setBlockAvailability" prenant en paramètre le numéro du bloc à traiter (<code>blockNum</code>) et la disponibilité souhaitée pour ce bloc (<code>availability</code>). Cette fonction permet de marquer la disponibilité d'un bloc spécifique dans le système de fichiers. Nous utiliserons la convention suivante: un bloc disponible sera marqué par un 1 tandis qu'un bloc non disponible par un 0.
#define SUPERBLOCK_START_BLOCK 1024

void setBlockAvailability(int blockNum, int availability) {
// Calculer l'index du byte et le bit offset correspondant
int byteIndex = blockNum / 8;
int bitOffset = blockNum % 8;

// Lire le byte existant du bloc de disponibilité des blocs
unsigned char buffer[1];
readBlock(SUPERBLOCK_START_BLOCK + byteIndex, 0, buffer, 1);

// Mettre à jour le bit d'offset correspondant
if (availability) {
buffer[0] |= (1 << bitOffset);
} else {
buffer[0] &= ~(1 << bitOffset);
}

// Écrire le byte mis à jour dans le bloc de disponibilité des blocs
writeBlock(SUPERBLOCK_START_BLOCK + byteIndex, 0, buffer, 1);
}

ReX : Un tableau de un octet c'est un octet (variable <code>buffer</code>).

Amine: je vais utiliser un <code>unsigned char buffer.</code> Je suis conscient qu'un char vaut un octet mais je ne pense pas qu'il y ait un type de donnée de la taille d'un bit, c'est pourquoi je travaille avec un octet mais je modifie les bits de cet octet grâce aux algorithmes.

ReX : Il faut bien que tu travailles sur un octet vu que l'état des blocs est stocké sous la forme d'octets. Je disais juste qu'un tableau de 1 élément n'a pas d'intérêt par rapport à l'élément lui-même.

Amine: c'est vrai, modification faite.

ReX : Non il faut calculer le numéro du bloc avant de faire le <code>readBlock</code>.

Amine: ok je vais calculer le numéro de bloc avant.

ReX : La mise à jour du bit est correcte mais le block et le déplacement dans le block ne sont pas correctement calculés.

Amine: je vais vous expliquer le raisonnement que j'avais. Prenons un exemple concret, imaginons que je veuille marquer le bloc 1030 comme disponible:

# Calcul de l'index de l'octet et du bit offset :
#* <code>blockNum</code> = 1030
#* Index du byte = 1030 / 8 = 128
#* Bit offset = 1030 % 8 = 6
# Lecture de l'octet existant de disponibilité:
#* Nous lisons l'octet existant à l'index 128 dans les blocs de disponibilité.
# Mise à jour du bit de disponibilité :
#* Nous voulons marquer le bloc 1030 comme disponible, donc nous utilisons le masque <code>(1 << 6)</code> pour définir le bit 6 à 1 dans l'octet. Le résultat sera, par exemple, <code>00100000</code>.
# Écriture du byte mis à jour :
#* Nous écrivons le byte mis à jour <code>00100000</code> à l'index 128 dans les blocs de disponibilité.

ReX : Ben non, un vrai exemple :
* Il faut prendre un n° de bloc plus grand : 3072 ;
* Numéro d'octet dans la carte des blocs libres : 3072/8=384 ;
* Numéro du bloc dans la carte des blocs libres : 384/256=1 ;
* Numéro du bit <code>b</code> dans l'octet n° 384-256=128 du bloc 1 : 3072%8=0 ;
* Il faut donc lire l'octet <code>o</code> de numéro 128 du bloc 1, puis modifier cet octet par <code>o |= (1<<b)</code> ou <code>o &= ~(1<<b)</code> ;
* Enfin il faut écrire l'octet modifié dans le bloc 1.
Amine: merci pour cet exemple! J'ai compris d'où vient mon erreur. Voir fonction setBlockAvailability version 3.

Remarque: par convention, j'apellerai dans la suite de ce projet "premier superbloc" le superbloc correspondant à la description des fichiers, c'est à dire les 1024 premiers blocs, et j'appellerai "second superbloc" les 16 blocs qui suivent servant à décrire la disponibilité des blocs (du bloc 1024 au bloc 1039 inclu). Le reste des blocs servira à stocker les données.

ReX : Non, le superblc est l'ensemble des informations hors blocs de données, tu ne peux pas utiliser un vocabulaire au hasard. Parle de blocs de description des fichiers ou de carte des blocs libres.

Amine: ok

Je pense que le problème qui se pose est que l'indice du bit dans le second superbloc ne correspond pas à l'indice du bloc dans le système de fichier. Par exemple, nous voudrions que si le bloc 1030 est disponible dans le système de fichier, alors le bit numéro 1030 du deuxième superbloc soit à 1, ce qui n'est pas le cas ici. En effet, on se trouve bien dans le bon octet avec ma méthode mais l'écriture du bit se fait de la droite vers la gauche alors qu'on voudrait l'inverse. Ainsi, si le 6ème bit de l'octet doit être à 1, alors il faudrait qu'on obtienne <code>00000100</code> et non <code>00100000.</code> L'indice du bit coinciderait ainsi avec le numéro du bloc.

ReX : Non, réfléchit à nouveau.

Voir plus bas la nouvelle version de setBlockAvailability.

Explication de l'algorithme pour mettre le bit à 1 ou 0:

* <code>buffer[0] |= (1 << bitOffset);</code> : Cette ligne utilise l'opérateur OR bit à bit (<code>|=</code>) pour activer (mettre à 1) le bit spécifié par <code>bitOffset</code> dans le premier octet (<code>buffer[0]</code>). Cela se fait en décalant le bit 1 vers la gauche de <code>bitOffset</code> positions, puis en effectuant une opération OR bit à bit avec le contenu actuel de <code>buffer[0]</code>. Cette opération modifie uniquement le bit ciblé, laissant les autres bits inchangés.

ReX : Oui ça c'est bon.

* <code>buffer[0] &= ~(1 << bitOffset);</code> : Cette ligne utilise l'opérateur AND bit à bit (<code>&=</code>) pour désactiver (mettre à 0) le bit spécifié par <code>bitOffset</code> dans <code>buffer[0]</code>. Pour ce faire, l'expression <code>~(1 << bitOffset)</code> est utilisée pour créer un masque où tous les bits sont à 1, sauf celui correspondant à <code>bitOffset</code>, qui est à 0. En effectuant ensuite une opération AND bit à bit entre le masque et le contenu actuel de <code>buffer[0]</code>, on met à 0 le bit ciblé sans affecter les autres bits.

ReX : Ca aussi.

=== Fonction setBlockAvailability version 2 ===

void setBlockAvailability(int blockNum, int availability) {
// Calculer l'indice de l'octet et le bit offset correspondant
int byteIndex = blockNum / 8;
int bitOffset = 7 - (blockNum % 8); // Inversion de l'ordre des bits

// Calculer le numéro du bloc du super bloc où se trouve l'octet de disponibilité correspondant
int availabilityBlockNum = SUPERBLOCK_START_BLOCK + byteIndex;

// Lire l'octet existant dans le bloc de disponibilité du super bloc
unsigned char buffer;
readBlock(availabilityBlockNum, 0, &buffer, 1);

// Mettre à jour le bit d'offset correspondant :
if (availability) {
buffer |= (1 << bitOffset);
} else {
buffer &= ~(1 << bitOffset);
}

// Écrire l'octet mis à jour dans le bloc de disponibilité du super bloc
writeBlock(availabilityBlockNum, 0, &buffer, 1);
}
J'ai modifié la ligne <code>int bitOffset = 7 - (blockNum % 8);</code> pour inverser l'ordre des bits sélectionnés, de sorte que le bit correspondant au bloc disponible soit correct.

ReX : Encore plus faux.

Si on veut rendre le bloc 1030 indisponible alors que les autres blocs sont disponibles:

ReX : Pardon ? Le bloc de données est libre ou pas suivant la carte des blocs libres. Le rendre disponible n'est possible que si un fichier le comportant est détruit.

# Calcul de l'indice de l'octet et du bit offset correspondant :
#* <code>blockNum = 1030</code>
#* <code>byteIndex = 1030 / 8 = 128</code>
#* <code>bitOffset = 7 - 1030 % 8 = 1</code> Cela signifie que le bit d'intérêt se trouve à la position 2 dans l'octet.
# Calcul du numéro du bloc du super bloc où se trouve l'octet de disponibilité correspondant :
#* <code>availabilityBlockNum = SUPERBLOCK_START_BLOCK + 128 = 1024 + 128 = 1152</code> Donc, nous devons accéder à l'octet 1152 pour mettre à jour la disponibilité du bloc 1030.
# Lecture de l'octet existant dans le bloc de disponibilité du super bloc :
#* Le contenu de l'octet dans le bloc 1152 avant la mise à jour : 11111111 (en binaire)
# Mise à jour du bit d'offset correspondant :
#* Supposons que nous voulions marquer le bloc 1030 comme non disponible (<code>availability = 0</code>).
#* Le bitOffset est 1.
#* Nous effectuons une opération AND avec le complément du bit à la position 1 : <code>11111111 & 11111101 = 11111101</code>
# Écriture de l'octet mis à jour dans le bloc de disponibilité du super bloc :
#* Le contenu de l'octet 128 du second superbloc après la mise à jour : 11111101 (en binaire)

ReX : Toujours aussi faux.

Maintenant, le bit d'indice 1 du 128 ème octet du second superbloc est mis à 0, indiquant que le bloc 1030 n'est plus disponible. Les autres bits restent inchangés car nous avons effectué un AND avec un masque binaire qui avait des 1 partout sauf à la position du bit que nous souhaitions mettre à 0.

ReX : Erreur sur erreur.

=== Fonction setBlockAvailability version 3 ===
J'ai compris d'où vient l'erreur. La fonction readBlock prends en premier paramètre le numéro du bloc à lire, je ne peux donc pas lui donner la valeur "SUPERBLOCK_START_BLOCK + byteIndex" car byteIndex s'exprime en octet alors qu'on s'attend à un nombre de bloc ici. Il faut donc divisé byteIndex par 256 pour être en unité "bloc", et préciser le bit qu'on veut lire grâce à l'offset.

Pour obtenir l'octet que l'on veut, il faut prendre le reste de la division de byteIndex par 256. On va ensuite stocker cet octet dans notre "buffer".

Pour savoir quel bit modifier dans ce "buffer", on va prendre le reste de la division du bloc dont on veut mettre à jour la disponibilité par 8. On va ainsi pouvoir modifier ce bit grâce à l'algorithme, puis réécrire l'octet à son emplacement d'origine.

Cette fonction gère la carte de disponibilités des blocs. Si un bloc est disponible, alors elle le met un 0, si il est indisponible, elle met un 1.
#define SUPERBLOCK_START_BLOCK 1024

void setBlockAvailability(int blockNum, int availability) {

int byteIndexInCard = blockNum / 8; //Numéro d'octet dans la carte des blocs libres
int blockIndexInCard = byteIndexInCard / 256; //Numéro du bloc dans la carte des blocs libres
int byteIndexInBlock = byteIndexInCard % 256; //Numéro d'octet dans le bloc contenant le bit de disponibilité
int bitOffset = blockNum % 8; //Numéro du bit dans l'octet n°byteIndexInBlock du bloc blockIndexInCard

//indice du bloc contenant le bit à mettre à jour dans le bloc de description
int availabilityBlockNum = FIRST_DISPONIBILITY_CARD_BLOCK + blockIndexInCard;

// Lire l'octet existant dans le bloc de disponibilité du super bloc
unsigned char buffer;
readBlock(availabilityBlockNum, byteIndexInBlock, &buffer, 1);

// Mettre à jour le bit d'offset correspondant :
if (availability==1) { // indisponible
buffer |= (1 << bitOffset); // Mettre le bit à 1

} else { // disponible
buffer &= ~(1 << bitOffset); // Mettre le bit à 0
}

// Écrire l'octet mis à jour dans le bloc de disponibilité du super bloc
writeBlock(availabilityBlockNum, byteIndexInBlock, &buffer, 1);
}

ReX : Ben voila, c'est pas possible de te taxer d'excès de vitesse mais c'est bon.

update: j'ai fait une petite modification, maintenant un bloc disponible est marqué d'un 0 et un bloc indisponible est marqué d'un 1. C'est mieux dans la mesure où initialement, tous les blocs sont disponibles et tous les blocs sont à 0. Cela évite de devoir créer une fonction qui initialise toute la carte de disponibilités à 1 pour dire que tous les blocs sont disponibles.

=== Fonction RM version 1 ===

void RM(const char *filesystem_path, const char *filename) {
unsigned char buffer[BLOCK_SIZE];
int fileNum = -1;

// Parcourir les blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (memcmp(filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {
// Effacer le nom du fichier dans le superbloc
memset(filenameBuffer, 0, MAX_FILENAME_LENGTH);
writeBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

unsigned char fileBuffer[MAX_BLOCKS_PER_FILE * 2];
readBlock(blockNum, MAX_FILENAME_LENGTH, fileBuffer, MAX_BLOCKS_PER_FILE * 2);

// Libérer les blocs associés au fichier et réinitialiser les numéros de blocs
for (int i = 0; i < MAX_BLOCKS_PER_FILE * 2; i += 2) {
int blockNum = ((int)fileBuffer[i] << 8) + (int)fileBuffer[i + 1];
if (blockNum == 0) {
break; // Fin du fichier
}
setBlockAvailability(blockNum, 0); // Marquer le bloc comme disponible
fileBuffer[i] = 0;
fileBuffer[i + 1] = 0;
}

// Mettre à jour les numéros de blocs associés au fichier
writeBlock(blockNum, MAX_FILENAME_LENGTH, fileBuffer, MAX_BLOCKS_PER_FILE * 2);

fileNum = blockNum;
break; // Fichier trouvé, sortir de la boucle
}
}

// Afficher le résultat de l'opération
if (fileNum == -1) {
printf("Le fichier \"%s\" n'a pas été trouvé.\n", filename);
} else {
printf("Le fichier \"%s\" a été supprimé avec succès.\n", filename);
}
}

ReX : Vous utilisez <code>strcmp</code> comme <code>strncmp</code>. C'est bien la dernière qu'il faut utiliser mais en précisant la longueur du nom en paramètre, pas la taille maximale.

Amine: vous voulez dire que j'utilise memcmp au lieu de strncmp ? Ok je vais utiliser strncmp, c'est vrai que c'est plus adapté pour la comparaison de chaines de caractère.

ReX : Ha oui c'est <code>memcmp</code> que tu utilises. Ca ne peut effectivement pas marcher. Effectivement avec <code>strncmp</code> cela peut marcher vu qu'il s'arrête au premier 0 contrairement à <code>memcmp</code>.

Cependant, pourquoi doit-on passer la taille exacte du nom du fichier en paramètre, et non la taille maximale d'un nom de fichier? En effet, cela semble fonctionner en mettant la taille maximale en paramètre, tandis que lorsque l'on met la taille exacte du nom du fichier, cela pose un problème: on ne compare plus toute la chaîne de caractère mais seulement une portion du nom complet. Ainsi, si je crée par exemple un fichier que j'appelle "file1", puis que j’exécute la fonction RM "/picofs filesystem.bin RM file" par exemple, alors le fichier file1 va être supprimé quand même car on ne comparera que strlen(file)=4 premiers caractères, qui sont les mêmes, donc la fonction considérera ces chaines comme identiques. On pourrait alors se dire qu'il faudrait alors prendre plutôt comme taille en paramètre de la fonction strlen la taille du nom du fichier se trouvant dans le système de fichier plutôt que celle du nom donné en paramètre de RM. Cependant, le même problème se pose si la taille du nom du fichier du système de fichier est plus petite que celle du nom du fichier passé en paramètre. Par exemple, si le fichier présent dans système de fichier est "file", et qu'on met la longueur de file en paramètre de la fonction strcmp, puis qu'on exécute la commande "/picofs filesystem.bin RM file5", alors file sera quand même supprimé, car on ne comparera que les strlen(file)=4 premiers caractère. Finalement, une solution serait de rajouter une condition qui vérifie que les deux chaînes sont de taille identiques pour pouvoir réaliser la comparaison sur la taille exacte du nom du fichier. Cependant, il me semble qu'en mettant MAX_FILENAME_LENGTH qui vaut 16 en paramètre, cela fonctionne directement. Vous pouvez tester cela en testant mon programme.

ReX : Ok pour <code>strncmp</code> avec la taille maximale d'un nom de fichier.

etape 1: créer un fichier :
./picofs filesystem.bin TYPE fichier.txt

etape 2: verifier que le fichier a bien été créé :
./picofs filesystem.bin LS

Le terminal renvoie bien "fichier.txt"

etape 3: essayer de supprimer le fichier en mettant une chaine troncature du nom du fichier créé :
./picofs filesystem.bin RM fich

le terminal renvoi <<Le fichier "fich" n'a pas été trouvé.>>, le fichier n'a donc pas été supprimé .

etape 4: essayer de supprimer le fichier en mettant un nom plus grand incluant "fichier.txt" :
./picofs filesystem.bin RM fichier.txtt

terminal renvoi <<Le fichier "fichier.txtt" n'a pas été trouvé.>>

etape 5: enfin, tester en mettant le nom exacte du fichier que l'on veut supprimer :
./picofs filesystem.bin RM fichier.txt

terminal renvoi <<Le fichier "fichier.txt" a été supprimé avec succès.>>

Finalement, on voit que cela fonctionne avec la taille maximale mise en paramètre. On pourrait reprocher à cette méthode de comparer des caractères dans le vide, ce qui n'est pas optimal dans une optique d'économie de mémoire qui est la notre, mais la taille maximale d'un nom de fichier étant relativement faible (16 octets), on peut peut-être négliger cela au vu de l'économie d'une opération supplémentaire (comparaison de la taille des chaines de caractères).

ReX : Le parcours des blocs de données du fichier est atroce. Il faut parcourir les numéros de blocs dans le premier bloc du fichier derrière le nom du fichier puis il faut parcourir le 15 autres blocs.

Amine: Ok, je vais corriger cela dans la version 2 de RM (voir semaine 5).

Fonctionnement de la fonction RM:

* Parcours des blocs réservés pour la description des fichiers (superbloc) à partir du bloc 0, en incrémentant de 16 à chaque itération pour accéder aux blocs de noms de fichiers.

ReX : OK.

* Dans chaque bloc de noms de fichiers, la fonction compare le nom de fichier recherché avec les noms stockés dans les 16 octets de chaque bloc.

ReX : Non la fonction ne fait pas ça par contre il faudrait, oui.

Amine: Je pensais que c'était ce que je faisais avec "memcmp(filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0)".

* Si le nom de fichier est trouvé, la fonction efface le nom du fichier dans le superbloc en remplaçant les 16 octets du bloc par des zéros.

ReX : OK.

* Ensuite, la fonction accède aux octets suivants du même bloc pour obtenir les numéros de blocs associés au fichier.

ReX : Non, la boucle sort largement du premier bloc.

* Pour chaque paire de numéros de blocs (2 octets chacun), la fonction convertit les octets en un numéro de bloc. Si le numéro de bloc est nul, cela signifie la fin des blocs associés au fichier, sinon, la fonction marque ce bloc comme disponible en utilisant la fonction <code>setBlockAvailability</code> et réinitialise les numéros de blocs dans le tableau à zéro.
* Les numéros de blocs réinitialisés sont ensuite réécrits dans le bloc de description du fichier.

ReX : L'idée est là mais vu que la boucle n'est pas bonne, rien ne peut marcher.

* La fonction affiche ensuite un message indiquant le résultat de l'opération : soit que le fichier a été supprimé avec succès, soit que le fichier n'a pas été trouvé.

== Semaine 5 ==

=== Fonction RM version 2 ===

Concernant les remarques que vous m'avez faites précédemment:

* j'utilise maintenant la fonction <code>strncmp</code> pour la comparaison des chaines de caractères
* j'ai normalement corrigé le parcours des blocs. Je parcours maintenant d'abord les blocs multiples de 16 à la recherche du bloc contenant le nom du fichier à supprimer. Puis je parcours les 16 blocs de description du fichier à supprimer, afin de récupérer les numéros de blocs, libérer ces blocs dans la carte de disponibilité et de réinitialiser ces blocs dans les blocs de données.

void RM(const char *filesystem_path, const char *filename) {
int fileFound = -1;
int offset;

// Parcourir les blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char*)filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {

// Effacer le nom du fichier dans le superbloc
memset(filenameBuffer, 0, MAX_FILENAME_LENGTH);
writeBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);
fileFound = 1;
offset = blockNum;
break;
}

}

// Fin de fonction si fichier inexistant
if (fileFound == -1) {
printf("Le fichier \"%s\" n'a pas été trouvé.\n", filename);
return;
}

unsigned char buffer[BLOCK_SIZE];
//bloc que l'on va remplir de 0 et mettre à la place des blocs de données
memset(buffer, 0, BLOCK_SIZE); //on rempli buffer de 0

for (int blockNum=offset; blockNum<offset + 16; blockNum++) {

//premier bloc de description, celui contenant le nom du fichier dans les 16 premiers octets
if (blockNum == offset) {

unsigned char fileBuffer[BLOCK_SIZE-MAX_FILENAME_LENGTH];
//bloc dans lequel on va stocker les blocs de description de fichier
readBlock(blockNum, MAX_FILENAME_LENGTH, fileBuffer, BLOCK_SIZE-MAX_FILENAME_LENGTH);

// Libérer les blocs associés au fichier dans la carte de disponibilités
// et dans les blocs de description
for (int i = MAX_FILENAME_LENGTH; i < BLOCK_SIZE-MAX_FILENAME_LENGTH; i += 2) {
int blockNumData = ((int)fileBuffer[i] << 8) + (int)fileBuffer[i + 1];
if (blockNumData == 0) {
break; // Fin du fichier
}
setBlockAvailability(blockNumData, 0); // Marquer le bloc comme disponible
fileBuffer[i] = 0;
fileBuffer[i + 1] = 0;
writeBlock(blockNumData, 0, buffer, BLOCK_SIZE); //on efface les blocs de données
}
writeBlock(blockNum, MAX_FILENAME_LENGTH, fileBuffer, BLOCK_SIZE-MAX_FILENAME_LENGTH);
//on efface le premier bloc de description

} else {
unsigned char fileBuffer[BLOCK_SIZE];
readBlock(blockNum, 0, fileBuffer, BLOCK_SIZE);

// Libérer les blocs associés au fichier dans la carte de disponibilités et dans les blocs de description
for (int i = 0; i < BLOCK_SIZE; i += 2) {
int blockNumData = ((int)fileBuffer[i] << 8) + (int)fileBuffer[i + 1];
if (blockNumData == 0) {
break; // Fin du fichier
}
setBlockAvailability(blockNumData, 0); // Marquer le bloc comme disponible
fileBuffer[i] = 0;
fileBuffer[i + 1] = 0;
writeBlock(blockNumData, 0, buffer, BLOCK_SIZE); //on efface les blocs de données
}
writeBlock(blockNum, 0, fileBuffer, BLOCK_SIZE); //on efface le bloc de description
}
}
printf("Le fichier \"%s\" a été supprimé avec succès.\n", filename);
}

ReX : Pour construire le nombre sur 16 bits utiliser le OU plutôt que l'addition.

ReX : Heu non, je ne lis pas cette fonction avec tout ce code dupliqué, la seule différence entre les deux alternative est la position de début de l'adresse du premier bloc de données (<code>MAX_FILENAME_LENGTH</code> dans un cas et 0 dans l'autre). Donc l'alternative ne doit servir qu'à initialiser ce début, le reste du code doit être factorisé.

ReX : Et corrige le code, tu utilises deux tableaux de blocs (perte mémoire), tu écris le bloc à zéro dans l'itération (perte CPU).

=== Fonction RM version 3 ===

Suite à vos remarques, j'ai réalisé les modifications suivantes:

* j'utilise maintenant le OU plutôt que l'addition pour construire le nombre sur 16 bits.

* j'ai factorisé le code grâce à la création de la variable <code>startOffset</code> valant 16 lorsqu'on se trouve dans le bloc contenant le nom du fichier et valant 0 lorsqu'on se trouve dans les autres.

* Pour ce qui est du fait que j'utilise 2 tableaux de blocs, j'ai du mal à voir comment faire avec 1 seul tableau de blocs car ces deux tableaux n'ont pas du tout le même rôle. Le tableau <code>fileBuffer</code> permet de stocker les 16 blocs de description d'un fichier un à un. Lorsqu'on stocke un bloc dans <code>fileBuffer</code>, on lit ensuite les octets un à un de ce bloc afin de former des numéros de blocs, et pour chaque numéro de bloc créé, on va réinitialiser le bloc correspondant dans les blocs de données. Pour cela, on a donc besoin d'un autre bloc qui viendra écraser les anciens blocs de données. C'est pourquoi j'ai créé un bloc <code>buffer</code>qui est composé de 0 et qui va écraser les blocs de données. On ne peut pas utiliser <code>fileBuffer</code> car on a besoin d'un bloc de zéros, et si on réinitialise <code>fileBuffer</code> on perd toute les données qui s'y trouvent. Une possibilité serait de relire le bloc de donné à chaque itération de la deuxième boucle for imbriquée; cela permettrait de pouvoir réinitialiser le tableau fileBuffer à chaque itérations de cette boucle afin de stocker ce bloc de 0 dans les blocs de données, puis de restocker dans ce même tableau le bloc de description. Cependant, je ne pense pas que ce soit optimal de faire autant appel à la fonction readBlock.

* j'ai créé une fonction resetBock qui permet comme son nom l'indique de reset un bloc en le remplissant de 0. Cela nous évite de créer deux tableaux de blocs dans RM, bien que je pense que cela revienne au même car on fait appel à une fonction qui créé un tableau de blocs. Quoi qu'il en soit, cela allège le code et cette fonction pourra surement me resservir par la suite.

void RM(const char *filesystem_path, const char *filename) {
int fileFound = -1;
int offset;
unsigned char fileBuffer[BLOCK_SIZE];

// Parcourir les blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char *)filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {
// Effacer le nom du fichier dans le superbloc
memset(filenameBuffer, 0, MAX_FILENAME_LENGTH);
writeBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);
fileFound = 1;
offset = blockNum;
break;
}
}

// Fin de fonction si fichier inexistant
if (fileFound == -1) {
printf("Le fichier \"%s\" n'a pas été trouvé.\n", filename);
return;
}

for (int blockNum = offset; blockNum < offset + 16; blockNum++) {
int startOffset = 0;
if (blockNum == offset) {
startOffset = MAX_FILENAME_LENGTH;
}
readBlock(blockNum, startOffset, fileBuffer, BLOCK_SIZE - startOffset);

// Libérer les blocs associés au fichier dans la carte de disponibilités et dans les blocs de description
for (int i = 0; i < BLOCK_SIZE - startOffset; i += 2) {
int blockNumData = (fileBuffer[i] << 8) | fileBuffer[i + 1];
if (blockNumData == 0) {
break; // Fin du fichier
}
setBlockAvailability(blockNumData, 0); // Marquer le bloc comme disponible
fileBuffer[i] = 0;
fileBuffer[i + 1] = 0;
resetBlock(blockNumData); //on efface les blocs de données
}
writeBlock(blockNum, startOffset, fileBuffer, BLOCK_SIZE - startOffset);
}
printf("Le fichier \"%s\" a été supprimé avec succès.\n", filename);
}
'''Fonction resetBlock'''
void resetBlock(unsigned int blockNum) {
unsigned char buffer[BLOCK_SIZE];
memset(buffer, 0, BLOCK_SIZE);

// Utiliser writeBlock pour écrire les données du buffer dans le bloc
writeBlock(blockNum, 0, buffer, BLOCK_SIZE);
}

ReX : Ca s'améliore. Mais pourquoi cette fonction <code>resetBlock</code> ? Tu crois que dans qu'un système de fichiers perd du temps à mettre à zéro les blocs de données libérés ? Si oui, regarde la page de manual de la commande <code>shred</code>, ça manque à ta culture.

Amine: Après avoir consulter le manual de la commande <code>shred</code>, je vois que cette commande écrit des données aléatoires sur l'emplacement du fichier sur le disque. Par défaut, <code>shred</code> effectue un certain nombre de passes (par exemple, 3 passes) pendant lesquelles il écrit des données aléatoires sur l'emplacement du fichier sur le disque. Après avoir écrit les données aléatoires, <code>shred</code> peut effectuer des passes supplémentaires pendant lesquelles il écrit des données nulles (des zéros) sur le même emplacement. L'objectif de <code>shred</code> est d'augmenter la sécurité en rendant plus difficile la récupération des données supprimées à l'aide d'outils de récupération de données.

Cependant, j'ai aussi consulté comment fonctionne la commande <code>rm</code> de linux, et je vois que cette commande libère l'espace occupé par le fichier en marquant les blocs associés comme disponibles. Cela signifie que les données peuvent encore être récupérées à l'aide d'outils de récupération de données, à moins que des mesures supplémentaires ne soient prises pour écraser physiquement l'espace avec des données aléatoires (c'est ce que fait l'utilitaire <code>shred</code>).

On va donc opter pour la deuxième option, c'est à dire qu'on ne va pas perdre notre temps à remettre à zéro les blocs de données libérés, on va simplement marquer les blocs correspondants comme étant disponibles. Cela nous permettra de nous émanciper de la fonction resetBlock et de n'avoir plus qu'un seul tableau de blocs.

ReX : Sinon lire un bloc complet de pointeurs de blocs de données en mémoire n'est pas forcément optimal. L'idéal serait de lire ces blocs morceau par morceau (de 64 octets par exemple). Certes un bloc serait traité en 4 lectures/écritures (ce qui ralentirait le traitement) mais on gagne en mémoire. Le mieux serait de mettre la taille des morceaux en constante pour pouvoir choisir entre vitesse d'exécution et utilisation mémoire.

Amine: d'accord je comprends. Je vais modifier la fonction pour qu'on puisse découper la lecture/écriture en plusieurs blocs.

=== Fonction RM version 4 ===
Modifications apportées:

* je ne réinitialise plus les blocs de données, je supprime simplement le pointeur du fichier vers les blocs de données et je désigne les blocs comme "disponible" dans le carte de disponibilités. J'ai donc supprimé la fonction resetBlock.

* je ne lis plus les blocs en une seule fois mais en plusieurs fois via la variable CHUNK_SIZE:

# J'ai introduit la constante <code>CHUNK_SIZE</code> pour définir la taille de chaque morceau que nous allons lire/écrire à la fois. Cela permet de découper les opérations en blocs plus petits.
# Dans la boucle <code>for</code> où on parcours les blocs à partir de <code>offset</code>, j'ai ajouté une boucle interne qui parcourt les données du bloc en morceaux de taille <code>CHUNK_SIZE</code>.
# À l'intérieur de la boucle interne, j'ai calculé la taille réelle du morceau (<code>chunkSize</code>) en prenant le minimum entre <code>CHUNK_SIZE</code> et la quantité de données restant à lire/écrire dans le bloc.
# J'ai modifié la fonction <code>readBlock</code> pour lire seulement la quantité de données spécifiée par <code>chunkSize</code> à partir de <code>chunkStart</code>. Ces données sont stockées dans le tableau <code>fileBuffer</code>.
# Ensuite, j'ai effectué les mêmes opérations de libération des blocs associés au fichier, en parcourant les données du morceau et en marquant les blocs comme disponibles.
# Finalement, j'ai utilisé la fonction <code>writeBlock</code> pour écrire le morceau de données modifié dans le bloc, en utilisant la même <code>chunkStart</code> pour déterminer où écrire les données.

#define CHUNK_SIZE 64

int min(int a, int b) {
return a < b ? a : b;
}

void RM(const char *filesystem_path, const char *filename) {
int fileFound = -1;
int offset;
unsigned char fileBuffer[BLOCK_SIZE];

// Parcourir les blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char *)filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {
// Effacer le nom du fichier dans le superbloc
memset(filenameBuffer, 0, MAX_FILENAME_LENGTH);
writeBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);
fileFound = 1;
offset = blockNum;
break;
}
}

// Fin de fonction si fichier inexistant
if (fileFound == -1) {
printf("Le fichier \"%s\" n'a pas été trouvé.\n", filename);
return;
}

for (int blockNum = offset; blockNum < offset + 16; blockNum++) {
int startOffset = 0;

if (blockNum == offset) {
startOffset = MAX_FILENAME_LENGTH;
}

for (int chunkStart = startOffset; chunkStart < BLOCK_SIZE; chunkStart += CHUNK_SIZE) {
int chunkSize = min(CHUNK_SIZE, BLOCK_SIZE - chunkStart);
readBlock(blockNum, chunkStart, fileBuffer, chunkSize);

for (int i = 0; i < chunkSize; i += 2) {
int blockNumData = (fileBuffer[i] << 8) | fileBuffer[i + 1];
if (blockNumData == 0) {
writeBlock(blockNum, chunkStart, fileBuffer, chunkSize);
printf("Le fichier \"%s\" a été supprimé avec succès.\n", filename);
return; // Sortir des boucles
}
setBlockAvailability(blockNumData, 0); // Marquer le bloc comme disponible
fileBuffer[i] = 0;
fileBuffer[i + 1] = 0;
}

writeBlock(blockNum, chunkStart, fileBuffer, chunkSize);
}
}

printf("Le fichier \"%s\" a été supprimé avec succès.\n", filename);
}

ReX : Si on trouve un n° de bloc de données à 0, il faut sortir des deux boucles les plus externes après avoir fait le <code>writeBlock</code>.

Amine: Modification faites ci-dessus. Maintenant, dès qu'on trouve un n° de bloc de données à 0 dans la boucle la plus interne, on effectue le <code>writeBlock</code> et ensuite on utilise <code>return</code> pour sortir des deux boucles les plus externes. Cela permet d'optimiser le code en évitant de continuer à traiter inutilement le reste des blocs.

ReX : Pas très propre (duplication de code) mais nous allons nous en contenter.

=== Fonction intermédiaire TYPE version 1 ===

J'ai également commencé à réfléchir à la fonction TYPE. Pour l'instant, elle ne fait qu'ajouter les noms de fichier dans le superbloc. Cela permet de pouvoir tester les fonctions LS et RM (voir dans la rubrique compilation et exécution comment utiliser le programme).
// Fonction pour créer un fichier avec le nom donné et le contenu fourni en entrée standard
void TYPE(const char *filesystem_path, const char *filename) {
unsigned char buffer[MAX_FILENAME_LENGTH];
// Parcours des blocs réservés pour la description des fichiers
for (int blockNum = 0; blockNum <= MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, MAX_FILENAME_LENGTH);
// Vérifier si le bloc est vide (pas de nom de fichier)
if (buffer[0] == 0) {
// Écrire le nom du fichier dans l'emplacement vide du superbloc
writeBlock(blockNum, 0, (const unsigned char *)filename, MAX_FILENAME_LENGTH);
break; // Fichier créé, sortir de la boucle
}
}
printf("Le fichier \"%s\" a été créé avec succès.\n", filename);
}

ReX : Si la boucle se termine sans trouver de slot libre le message de succès s'affiche tout de même.

ReX : Le paramètre <code>filename</code> n'a pas forcément une taille de <code>MAX_FILENAME_LENGTH</code>.

Selon moi, la fonction TYPE devra respecter 3 étapes:

# Enregistrement du Nom du Fichier: L'ajout du nom du fichier dans un des blocs de la première partie du superbloc.
# Stockage des Données du Fichier: La récupération des données saisies en entrée standard par l'utilisateur et leur stockage dans des blocs du système de fichiers à partir d'une certaine position, comme le bloc 1040.
# Mise à Jour de la Disponibilité des Blocs: L'indication que les blocs dans lesquels les données ont été écrites ne sont plus disponibles en modifiant les bits correspondants dans la deuxième partie du superbloc (les 16 derniers blocs du super bloc).

ReX : Relis le point 3 et dit moi si tu te comprends toi même ?

Amine: Ma phrase n'est effectivement pas très claire. Je voulais dire que la fonction TYPE devra mettre à jour la carte de disponibilité du superbloc. C'est à dire que lorsqu'elle écrira des données dans des blocs, elle devra indiquer dans la carte de disponibilités que ces blocs ne sont plus disponibles.

=== Fonction intermédiaire TYPE version 2 ===

Suite à vos remarques, j'ai apporté les modifications suivantes à la fonction TYPE:

* j'ai ajouté une condition pour l'affichage du message de succès de la création d'un fichier (placeFound).

* le paramètre <code>filename</code> n'ayant pas forcément une taille de <code>MAX_FILENAME_LENGTH</code>, je calcule maintenant la longueur de filename, afin d'écrire seulement le nom du fichier avec la fonction writeBlock.

Il fonction n'est bien évidemment pas fini, elle ajoute seulement le nom du fichier dans le superbloc pour l'instant. Cela me permet de tester les fonctions LS et RM.
void TYPE(const char *filesystem_path, const char *filename) {
size_t sizeFilename = strlen(filename);
printf("size filename=%d\n", sizeFilename);
unsigned char buffer[MAX_FILENAME_LENGTH];
int placeFound = 0;

if (sizeFilename > MAX_FILENAME_LENGTH) {
printf("Impossible de créer le fichier, nom trop long\n");
return;
}

// Parcours des blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, MAX_FILENAME_LENGTH);
// Vérifier si le bloc est vide (pas de nom de fichier)
if (buffer[0] == 0) {
// Écrire le nom du fichier dans l'emplacement vide du superbloc
if (sizeFilename < MAX_FILENAME_LENGTH) {
sizeFilename+=1;
}
writeBlock(blockNum, 0, (const unsigned char *)filename, sizeFilename);
placeFound = 1;
break; // Fichier créé, sortir de la boucle
}
}
if (placeFound == 1) {
printf("Le fichier \"%s\" a été créé avec succès.\n", filename);
} else {
printf("Plus de place dans le système de fichier pour créer ce fichier.\n", filename);
}
}

ReX : Mieux, attention il faut copier aussi le <code>\'0</code> final du nom, donc <code>sizeFilename+1</code>. Sinon tu n'es pas sûr qu'il y ait un zéro final. Et attention n°2, il ne faut pas copier ce <code>\'0</code> si le nom fait la taille maximale.

Amine: ok j'ai modifié la fonction TYPE ci-dessus. J'ai ajouté une condition: si le nom du fichier est inférieur à la taille maximale de nom de fichier, alors on incrémente de 1 la taille du nom de fichier. Cela nous permet d'écrire le '\0' dans le bloc de description. Dans le cas où le nom du fichier est de la taille maximale, nous n'avons pas besoin d'écrire le '\0', on n'incrémente donc pas la taille de 1.

J'ai également ajouté une condition: si le nom du fichier est supérieur à la taille maximale, alors un message d'erreur s'affiche et le fichier n'est pas créé.

ReX : OK. L'embryon de fonction <code>TYPE</code> est correct, il manque juste le principal : la création des blocs de données.

=== Fonction MV version 1 ===

J'ai ici créé la fonction MV qui permet de changer le nom d'un fichier. Pour ce faire, la fonction parcourt les blocs de descriptions à la recherche du fichier dont on veut changer le nom. Lorsque ce fichier est trouvé, on supprime l'ancien nom en mettant des 0 sur 16 octets, puis on vient réécrire le nouveau nom dans le même emplacement. Enfin, on sort de la boucle et on affiche le succès ou non de l'opération.
// Fonction qui modifie le nom du fichier
void MV(const char *filesystem_path, const char *old_filename, const char *new_filename) {
size_t sizeNew_filename = strlen(new_filename);
size_t sizeOld_filename = strlen(old_filename);
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
int fileFound = 0;
// Parcourir les blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);
// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char*)filenameBuffer, old_filename, MAX_FILENAME_LENGTH) == 0) {
// Effacer le nom du fichier dans le superbloc
memset(filenameBuffer, 0, MAX_FILENAME_LENGTH);
writeBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);
// Écrire le nom du fichier dans l'emplacement
writeBlock(blockNum, 0, (const unsigned char *)new_filename, sizeNew_filename);
fileFound=1;
break; // Nom modifié, sortir de la boucle
}
}
if (fileFound == 1) {
printf("Le nom du fichier \"%s\" a été renommé avec succès.\n", old_filename);
} else {
printf("Le fichier \"%s\" n'a pas été trouvé.\n", old_filename);
}
}

ReX : Inutile d'écraser l'ancien nom avec des zéros. Il suffit de copier le nouveau en s'assurant qu'il y ait un zéro final sauf si le nouveau nom fait la taille maximale.

Amine: ok, je vais faire les modifications dans la version 2.

== Semaine 6 ==

=== Fonction MV version 2 ===
Dans cette nouvelle version de la fonction MV, j'ai effectué les modifications suivantes:

* je n'écrase plus l'ancien nom avec des 0
* Je colle simplement le nouveau nom par dessus l'ancien, en m'assurant qu'il y ait bien le '\0' à la fin lorsque la taille du nom du fichier est inférieur à la taille maximale. Comme précédemment, afin de m'assurer de la présence de ce '\0' à la fin du nom, j'incrémente la taille de 1 lorsque qu'elle est inférieur à la taille max. Cependant, je ne suis pas sûr à 100% que ce soit la bonne manière de faire.

// Fonction qui modifie le nom du fichier
void MV(const char *filesystem_path, const char *old_filename, const char *new_filename) {
size_t sizeNew_filename = strlen(new_filename);
size_t sizeOld_filename = strlen(old_filename);
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
int fileFound = 0;

// Parcourir les blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {

readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char*)filenameBuffer, old_filename, MAX_FILENAME_LENGTH) == 0) {

if (sizeNew_filename < MAX_FILENAME_LENGTH) {
sizeNew_filename+=1;
}

// Écrire le nom du fichier dans l'emplacement
writeBlock(blockNum, 0, (const unsigned char *)new_filename, sizeNew_filename);

fileFound=1;

break; // Nom modifié, sortir de la boucle
}
}
if (fileFound == 1) {
printf("Le nom du fichier \"%s\" a été renommé avec succès.\n", old_filename);
} else {
printf("Le fichier \"%s\" n'a pas été trouvé.\n", old_filename);
}
}

ReX : C'est bon. La fonction était triviale.

=== Fonction TYPE version 1 ===
void TYPE(const char *filesystem_path, const char *filename) {
size_t sizeFilename = strlen(filename);
unsigned char buffer[MAX_FILENAME_LENGTH];
int placeFound = -1;

if (sizeFilename > MAX_FILENAME_LENGTH) {
printf("Impossible de créer le fichier, nom trop long\n");
return;
}

// Parcours des blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, MAX_FILENAME_LENGTH);
// Vérifier si le bloc est vide (pas de nom de fichier)
if (buffer[0] == 0) {
// Écrire le nom du fichier dans l'emplacement vide du superbloc
if (sizeFilename < MAX_FILENAME_LENGTH) {
sizeFilename += 1; // Ajouter '\0' s'il y a de la place
}
writeBlock(blockNum, 0, (const unsigned char *)filename, sizeFilename);
placeFound = blockNum;

// Lire les données depuis l'entrée standard
unsigned char dataBuffer[BLOCK_SIZE];
size_t bytesRead;
int dataBlockNum = findAvailableBlock(); // Premier bloc de données à partir du bloc 1040
printf("dataBlockNum%d\n",dataBlockNum);
int blockSizeUsed = 0; // Compteur d'octets dans le bloc actuel
int dataBlocksNeeded = 1; // Nombre de blocs de données nécessaires

while ((bytesRead = fread(dataBuffer + blockSizeUsed, 1, BLOCK_SIZE - blockSizeUsed, stdin)) > 0) {
blockSizeUsed += bytesRead;

// Si le bloc actuel est plein, passer au bloc suivant
if (blockSizeUsed == BLOCK_SIZE) {
// printf("dataBlockNum=%d\n",dataBlockNum);
writeBlock(dataBlockNum, 0, dataBuffer, BLOCK_SIZE);
setBlockAvailability(dataBlockNum, 1);

dataBlockNum++; // Passer au bloc suivant
blockSizeUsed = 0; // Réinitialiser la taille utilisée
dataBlocksNeeded++;
}
}

// Écrire le dernier bloc partiel, s'il y en a un
if (blockSizeUsed > 0) {
writeBlock(dataBlockNum, 0, dataBuffer, blockSizeUsed);
setBlockAvailability(dataBlockNum, 1);
}

// Écrire les numéros de blocs utilisés dans le bloc de description
unsigned char blockNumberBuffer[2];
int currentBlockNum = 1040;

for (int i = 0; i < dataBlocksNeeded; i++) {
blockNumberBuffer[0] = (currentBlockNum >> 8) & 0xFF;
blockNumberBuffer[1] = currentBlockNum & 0xFF;
writeBlock(placeFound, MAX_FILENAME_LENGTH + i * 2, blockNumberBuffer, 2);
currentBlockNum++;
}

break; // Fichier créé, sortir de la boucle
}
}

if (placeFound != -1) {
printf("Le fichier \"%s\" a été créé avec succès.\n", filename);
} else {
printf("Plus de place dans le système de fichier pour créer ce fichier.\n");
}
}

ReX : La constante 1040 ne doit pas apparaître en numérique, ce doit être une constante calculée à partir des autres constantes.

Amine: Ok. Je ne l'avais pas défini comme une constante car il s'agit dans la fonction ci-dessus d'une variable qui est incrémenté à chaque itération.

ReX : Je suis las de te répéter que le mémoire est comptée : tu utilises encore un bloc de <code>BLOCK_SIZE</code> octets, c'est trop.

Amine: Comment utiliser des blocs plus petit sachant qu'il s'agit là de blocs de données et qu'un bloc fait 256 octets d'après l'énoncé ? Dois-je les subdiviser en plusieurs blocs plus petit comme fait dans la fonction RM, en 4 blocs de 64 octets par exemple ?

Fonctionnement de la fonction TYPE:

* étape 1: on parcourt les blocs de descriptions à la recherche d'un bloc disponible. Si on ne trouve pas de bloc disponible, on renvoie un message d'erreur, sinon on passe à l'étape suivante.
* étape 2: Si on trouve un emplacement libre dans les blocs de disponibilité, on écrit le nom du fichier dans cet emplacement.

ReX : Dans les blocs de description de fichiers pas dans les blocs de disponibilité.

Amine: Oui autant pour moi.

* étape 3: Ensuite, on lit le texte entré par l'utilisateur en entrée standard, on le répartit dans des blocs de taille BLOCK_SIZE, on met à jour la disponibilité des blocs utilisés.

ReX : Non, il faut appeler <code>findAvailableBlock</code> pour chaque bloc de données à utiliser, aucune certitudes que les blocs libres soient en séquence.

Amine: ok, je ferai cela dans la version 2

* étape 4: Enfin, on écrit les numéros des blocs de données utilisés dans les blocs de description de ce fichier, les numéros étant écris sur deux octets.

ReX : Non cela doit se faire au fur et à mesure des appels à <code>findAvailableBlock</code> et les numéros des blocs de données peuvent s'étaler sur les 16 blocs de description du fichier. Confusion totale sur ce point. Vous n'avez pas compris le mécanisme.

Amine: je corrige cela dans la version 2. J'ai bien compris le mécanisme mais ce n'est pas facile à traduire en code.

=== Fonction TYPE version 2 ===
Dans cette nouvelle version de TYPE, j'ai fait les modifications suivantes:

* j'appelle maintenant <code>findAvailableBlock</code> pour chaque bloc de données à utiliser
* j'écris maintenant les numéros de blocs au fur et à mesures des appels à <code>findAvailableBlock</code>
* je n'utilise plus de tableaux de taille 256 octets mais des tableaux de tailles CHUNK_SIZE. J'ai choisi ici CHUNK_SIZE = 64 octets.

J'utilise toujours un bloc de taille BLOCK_SIZE en attendant de comprendre si je dois diviser ce bloc en plusieurs blocs de taille plus petite ou s'il y a un moyen de ne pas du tout utiliser ces blocs.
void TYPE(const char *filesystem_path, const char *filename) {
size_t sizeFilename = strlen(filename);
unsigned char buffer[MAX_FILENAME_LENGTH];
int placeFound = -1;

if (sizeFilename > MAX_FILENAME_LENGTH) {
printf("Impossible de créer le fichier, nom trop long\n");
return;
}

// Parcours des blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, MAX_FILENAME_LENGTH);
// Vérifier si le bloc est vide (pas de nom de fichier)
if (buffer[0] == 0) {
// Écrire le nom du fichier dans l'emplacement vide du superbloc
if (sizeFilename < MAX_FILENAME_LENGTH) {
sizeFilename += 1; // Ajouter '\0' s'il y a de la place
}
writeBlock(blockNum, 0, (const unsigned char *)filename, sizeFilename);
placeFound = blockNum;

// Lire les données depuis l'entrée standard et écrire dans le fichier
int dataBlockNum = findAvailableBlock(); // Premier bloc de données à partir du bloc 1040
printf("Premier bloc dans lequel on écrit = %d\n", dataBlockNum);
int blockSizeUsed = 0; // Compteur d'octets dans le bloc actuel

unsigned char chunkBuffer[CHUNK_SIZE];
size_t bytesRead;

while ((bytesRead = fread(chunkBuffer, 1, CHUNK_SIZE, stdin)) > 0) {
// Écrire le chunk dans le bloc de données
writeBlock(dataBlockNum, blockSizeUsed, chunkBuffer, bytesRead);
setBlockAvailability(dataBlockNum, 1);

// Écrire le numéro du bloc actuel dans la description du fichier
unsigned char blockNumberBuffer[2];
blockNumberBuffer[0] = (dataBlockNum >> 8) & 0xFF;
blockNumberBuffer[1] = dataBlockNum & 0xFF;
writeBlock(placeFound, MAX_FILENAME_LENGTH + dataBlockNum * 2, blockNumberBuffer, 2);

blockSizeUsed += bytesRead;

// Si le bloc actuel est plein, passer au bloc suivant
if (blockSizeUsed == BLOCK_SIZE) {
dataBlockNum = findAvailableBlock(); // Passer au bloc suivant
blockSizeUsed = 0; // Réinitialiser la taille utilisée
}
}

break; // Fichier créé, sortir de la boucle
}
}

if (placeFound != -1) {
printf("Le fichier \"%s\" a été créé avec succès.\n", filename);
} else {
printf("Plus de place dans le système de fichier pour créer ce fichier.\n");
}
}

=== Fonction findAvailableBlock ===
Cette fonction renvoie l'indice du premier bloc disponible. Je me sers de cette fonction dans la fonction TYPE.
#define FIRST_DATA_BLOCK 1040
#define FIRST_DISPONIBILITY_CARD_BLOCK 1024

// Renvoie le premier bloc de donné disponible
int findAvailableBlock() {
unsigned char availabilityBuffer[BLOCK_SIZE];
int offset;

// Lire la carte de disponibilité (à partir du bloc 1)
for (int blockNum = FIRST_DISPONIBILITY_CARD_BLOCK; blockNum < FIRST_DATA_BLOCK; blockNum++) {
readBlock(blockNum, 0, availabilityBuffer, BLOCK_SIZE);

if (blockNum==FIRST_DISPONIBILITY_CARD_BLOCK) {
offset=FIRST_DATA_BLOCK/8;
} else {
offset=0;
}

// Parcourir les octets de la carte de disponibilité
for (int byteIndex = offset; byteIndex < BLOCK_SIZE - offset; byteIndex++) {
unsigned char byte = availabilityBuffer[byteIndex];

// Parcourir les bits de chaque octet
for (int bitIndex = 0; bitIndex < 8; bitIndex++) {
// Vérifier si le bit est à 0 (bloc disponible)
if ((byte & (1 << bitIndex)) == 0) {
// Calculer l'indice du bloc en fonction du bloc et du bit
int blockIndex = byteIndex * 8 + bitIndex;
return blockIndex;
}
}
}
}

// Aucun bloc disponible trouvé
return -1;
}

ReX : Même remarque que précédement sur les nombres 1024 et 1040.

Amine: Ok, j'ai remplacé 1024 par la constante FIRST_DISPONIBILITY_CARD_BLOCK et 1040 par la constante FIRST_DATA_BLOCK dans la fonction ci-dessus.

ReX : Vous n'avez toujours pas compris la contrainte sur la mémoire.

Amine: dois-je découper le bloc de taille BLOCK_SIZE en quatre blocs de taille 64 octets par exemple ?

ReX : Je ne vois pas ce que vous voulez faire avec <code>if (blockNum==1024) offset=1040/8; else offset=0;</code>.

Amine: dans la carte de disponibilité, chaque bit correspond à un bloc. Ainsi, les bits de 0 à 1040 dans la carte de disponibilité décrivent la disponibilité des blocs 0 à 1040. Or ces blocs correspondent au superbloc, et dans cette fonction, on veut connaître le premier bloc de données disponible. On ne s'intéresse donc pas au 1040 premiers bits de la carte de disponibilité. Je crée donc un offset égal à 1040/8 afin de ne pas prendre en compte les 1040 premiers bits soit les 1040/8=130 premiers octets. Cet offset ne s'applique que lorsqu'on se trouve dans le premier des 16 blocs de la carte de disponibilité, d'où la condition <code>if (blockNum==1024)</code>.

ReX : OK, bien vu.

=== Fonction CAT version 1 ===
void CAT(const char *filesystem_path, const char *filename) {
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
unsigned char buffer[BLOCK_SIZE];
unsigned char blockNumberBuffer[2];
unsigned char dataBuffer[BLOCK_SIZE];
int offset;

// Parcours des blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char *)filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {
// Le nom du fichier a été trouvé

// Parcours les blocs de description
for (int descrBlockNum=0; descrBlockNum<MAX_BLOCKS_PER_FILE_DESCRIPTION; descrBlockNum++) {
if (descrBlockNum==0) {
offset=16;
} else {
offset=0;
}
readBlock(descrBlockNum+blockNum, offset, buffer, BLOCK_SIZE-offset);

// Lire les numéros de blocs associés à ce fichier depuis les blocs de description
unsigned char octet1 = buffer[offset];
unsigned char octet2 = buffer[offset+1];

int dataBlockNum = (octet1 << 8) | octet2;
printf("dataBlockNum=%d\n",dataBlockNum);

// Vérifier si le numéro de bloc est valide (non nul)
if (dataBlockNum == 0) {
return; // Fin du fichier
}

// Lire et afficher le contenu du bloc de données
readBlock(dataBlockNum, 0, dataBuffer, BLOCK_SIZE);
fwrite(dataBuffer, 1, BLOCK_SIZE, stdout);
}

return; // Fichier affiché, sortie de la fonction
}
}

// Si le fichier n'a pas été trouvé
printf("Le fichier \"%s\" n'a pas été trouvé.\n", filename);
}

ReX : Encore mieux : deux blocs de <code>BLOCK_SIZE</code> en mémoire.

ReX : Le <code>break</code> ne sort pas de la boucle externe.

Amine: Oui c'est vrai. J'ai remplacé le <code>break</code> par un <code>return</code> ci-dessus.

ReX : Dans le cadre de la fonction CAT le <code>return</code> est convenable.

Voici ma fonction <code>CAT</code>. Elle fonctionne en plusieurs étape:

* étape 1: on cherche dans les blocs de descriptions si le fichier dont on veut afficher le contenu existe. Si le nom de fichier est trouvé, on passe à l'étape 2. Sinon, on renvoie un message d'erreur.
* étape 2: si le fichier est trouvé, on parcours les 16 blocs de description de ce fichier.
* étape 3: grâce aux opérations de masquage et de décalage, on joint les octets deux par deux pour former un entier qui contient le numéro du bloc de données correspondant au fichier. Si cet entier vaut 0, alors cela signifie qu'il n'y a plus de blocs associé à ce fichier, on peut donc quitter la fonction. Si cet entier est différent de 0, alors on va lire le bloc correspondant à ce numéro et on affiche son contenu dans le terminal.

== Semaine 7 ==

=== Fonction CP version 1 ===
Voici ma fonction CP, qui permet de créer une copie d'un fichier existant. L'idée est la suivante: pour copier un fichier, on doit créer un nouveau fichier et lui attribuer les mêmes blocs de descriptions que le fichier source. Ainsi, le fichier source et le fichier destination pointeront vers les mêmes blocs de données, et auront le même contenu.

ReX : Perdu. Ce n'est absolument pas la fonction de copie de fichiers d'un système de fichiers.

Amine: Après avoir fait des recherches et après réflexion, je me rends compte que cette fonction CP présente un problème: en faisant pointer les blocs de données du fichier destination vers ceux du fichier source, toute modification du fichier source impactera le fichier destination, or ce n'est pas ce qu'on veut faire. Je vous propose donc une nouvelle version de la fonction CP ci-dessous qui remédie à ce problème.

void CP(const char *filesystem_path, const char *source_filename, const char *destination_filename) {
unsigned char source_filenameBuffer[MAX_FILENAME_LENGTH];
unsigned char destination_filenameBuffer[MAX_FILENAME_LENGTH];
unsigned char descriptionBuffer[BLOCK_SIZE];
int destination_offset;
int offset;

// Recherche du fichier source
int source_offset = -1;
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, source_filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier source
if (strncmp((const char *)source_filenameBuffer, source_filename, MAX_FILENAME_LENGTH) == 0) {
source_offset = blockNum;
break;
}
}

if (source_offset == -1) {
printf("Le fichier source \"%s\" n'a pas été trouvé.\n", source_filename);
return;
}

// Recherche d'un emplacement libre pour le fichier destination
destination_offset = -1;
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, destination_filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc est vide (pas de nom de fichier)
if (destination_filenameBuffer[0] == 0) {
destination_offset = blockNum;
break;
}
}

if (destination_offset == -1) {
printf("Plus de place dans le système de fichier pour créer la copie de \"%s\".\n", source_filename);
return;
}

// Ecrit le nom de la copie dans le bloc de description
writeBlock(destination_offset, 0, (const unsigned char *)destination_filename, strlen(destination_filename));

// Copier les blocs de description associés au fichier source dans les blocs de description du fichier destination
for (int i = 0; i < MAX_BLOCKS_PER_FILE_DESCRIPTION; i++) {
if (i==0) {
offset = MAX_FILENAME_LENGTH;
} else {
offset = 0;
}

readBlock(source_offset+i, offset, descriptionBuffer, BLOCK_SIZE-offset);
if (descriptionBuffer[offset]==0) {
return;
} else {
writeBlock(destination_offset+i, offset, descriptionBuffer, BLOCK_SIZE-offset);
}
}

printf("La copie de \"%s\" sous le nom \"%s\" a été créée avec succès.\n", source_filename, destination_filename);
}

ReX : Pas mieux.

== Semaine 8 ==
A ce stade du projet, les fonctions suivantes ont été validé par Monsieur Redon:

* fonction LS
* fonction RM
* fonction MV

Il reste donc les fonctions suivantes à terminer:

* fonction CAT
* fonction CP
* fonction TYPE

=== Fonction CAT version 2 ===
Suite à vos remarques sur la version 1, j'ai fais les modifications suivantes:

* je n'utilise non plus 2 tableaux de taille BLOCK_SIZE, mais 1 seul. Idéalement il faudrait en utiliser 0, je réfléchi donc à m’émanciper de ce tableau en le remplaçant par plusieurs plus petits tableaux.

ReX : Un seul plus petit.

* J'ai remplacé le <code>break</code> par un <code>return</code>

ReX : Déjà validé.

Cette fonction permet d'afficher le contenu d'un fichier créé avec la fonction TYPE. Pour se faire, on parcours tout d'abord les blocs de descriptions pour trouver le fichier dont ont veut afficher le contenu. Une fois ce fichier trouvé, on parcours les 16 blocs de description de ce fichier 1 à 1. Pour chacun de ces blocs de description, on va stocker récupéré les octets deux par deux afin de former des entiers. Pour se faire, on utilise la fonction <code>reconsituteNumber</code> que l'on détaillera juste après. Ces entiers correspondent aux blocs dans lesquels la donné du fichier se trouve. Une fois l'entier reconstitué, on affiche le contenu du bloc correspondant.
#define CHUNK_SIZE 64

void CAT(const char *filesystem_path, const char *filename) {
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
unsigned char byteBuffer[2];
unsigned char dataBuffer[CHUNK_SIZE];
int offset;

// Parcours des blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char *)filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {
// Le nom du fichier a été trouvé

// Parcours les blocs de description
for (int descrBlockNum=0; descrBlockNum<MAX_BLOCKS_PER_FILE_DESCRIPTION; descrBlockNum++) {
if (descrBlockNum==0) {
offset=MAX_FILENAME_LENGTH;
} else {
offset=0;
}

// Lecture des octets deux par deux
for (int i=0; i<BLOCK_SIZE;i+=2) {
readBlock(descrBlockNum+blockNum, offset+i, byteBuffer, 2);

// Lire les numéros de blocs associés à ce fichier depuis les blocs de description
int dataBlockNum = reconsituteNumber(byteBuffer);

// Vérifier si le numéro de bloc est valide (non nul)
if (dataBlockNum == 0) {
return; // Fin du fichier
}

for (int chunkStart = 0; chunkStart < BLOCK_SIZE; chunkStart += CHUNK_SIZE) {
// Lire et afficher le contenu du bloc de données
readBlock(dataBlockNum, chunkStart, dataBuffer, CHUNK_SIZE);
fwrite(dataBuffer, 1, CHUNK_SIZE, stdout);
}
}
}

return; // Fichier affiché, sortie de la fonction
}
}

// Si le fichier n'a pas été trouvé
printf("Le fichier \"%s\" n'a pas été trouvé.\n", filename);
}

ReX : Remplacer le premier bloc de <code>BLOCK_SIZE</code> octets par un bloc de 2 octets est exagéré mais cela pourrait passer. Il reste toujours un bloc de <code>BLOCK_SIZE</code> octets dont il est facile de se passer au bénéfice d'un bloc de, mettons, 64 octets.

Amine: voilà, dans la version ci-dessus j'ai remplacé le bloc de taille <code>BLOC_SIZE</code> par un bloc de taille <code>CHUNK_SIZE</code>, avec <code>CHUNK_SIZE</code> modifiable dans les constantes du programme. J'ai pris ici 64 octets.

=== Fonction reconsituteNumber ===
Cette fonction permet de reconstituer un numéro de bloc à partir de deux octets.
// Fonction qui reconstitue le numéro de bloc à partir du tableau
int reconsituteNumber(unsigned char blockNumberBuffer[2]) {
unsigned char octet1 = blockNumberBuffer[0];
unsigned char octet2 = blockNumberBuffer[1];
int dataBlockNum = (octet1 << 8) | octet2;
return dataBlockNum;
}

ReX : Bonne idée cette fonction.

=== Fonction CP version 2 ===
Voici une version mise à jour de notre fonction CP. Dans la version précédente, on faisait pointer le fichier source vers les même blocs que le fichier destination. Cela posait un problème: toute modification du fichier source impactait le fichier destination. Ainsi, dans cette nouvelle version, on fait une duplication des blocs de données du fichier source vers le fichier destination. Cela implique donc une mise à jour de la carte de disponibilité, ainsi que l'adaptation des blocs de descriptions. En effet, seulement les blocs de données sont maintenant identiques, plus les blocs de description.

Piste d'amélioration: comme pour la fonction CAT ci-dessus, j'utilise toujours un bloc de taille 256 octets, je vais devoir y remédier.
void CP(const char *filesystem_path, const char *source_filename, const char *destination_filename) {
unsigned char source_filenameBuffer[MAX_FILENAME_LENGTH];
unsigned char destination_filenameBuffer[MAX_FILENAME_LENGTH];
unsigned char descriptionBuffer[BLOCK_SIZE];
unsigned char numBuffer[2];
int destination_offset;
int source_offset;
int offset;
int numDataBlock;

// Recherche du fichier source
source_offset = -1;
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, source_filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier source
if (strncmp((const char *)source_filenameBuffer, source_filename, MAX_FILENAME_LENGTH) == 0) {
source_offset = blockNum;
break;
}
}

if (source_offset == -1) {
printf("Le fichier source \"%s\" n'a pas été trouvé.\n", source_filename);
return;
}

// Recherche d'un emplacement libre pour le fichier destination
destination_offset = -1;
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, destination_filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc est vide (pas de nom de fichier)
if (destination_filenameBuffer[0] == 0) {
destination_offset = blockNum;
break;
}
}

if (destination_offset == -1) {
printf("Plus de place dans le système de fichier pour créer la copie de \"%s\".\n", source_filename);
return;
}

// Copie du nom de la copie dans le bloc de description
writeBlock(destination_offset, 0, (const unsigned char *)destination_filename, strlen(destination_filename));

// Copier les blocs de données associés au fichier source dans de nouveaux blocs de données pour le fichier destination
for (int i = 0; i < MAX_BLOCKS_PER_FILE_DESCRIPTION; i++) {
if (i == 0) { offset = MAX_FILENAME_LENGTH; }
else { offset = 0; }

// Lecture des numéros de bloc dans les blocs de description
for (int byteNum=0; byteNum<BLOCK_SIZE; byteNum+=2) {
readBlock(source_offset + i, offset + byteNum, numBuffer, 2);

numDataBlock = reconsituteNumber(numBuffer);
if (numDataBlock == 0) {
return;
}

// On stocke le bloc de données associé au fichier source dans descriptionBuffer
readBlock(numDataBlock, 0, descriptionBuffer, BLOCK_SIZE);

// Trouver un nouveau bloc de données disponible
int newDataBlock = findAvailableBlock();

// Ecriture du bloc de données dans le premier bloc disponible
writeBlock(newDataBlock, 0, descriptionBuffer, BLOCK_SIZE);

// Mise à jour de la carte de disponibilités
setBlockAvailability(newDataBlock, 1);

// Ecriture du numéro de bloc dans la description du fichier
numBuffer[0] = (newDataBlock >> 8) & 0xFF;
numBuffer[1] = newDataBlock & 0xFF;
writeBlock(destination_offset+i, offset+byteNum, numBuffer, 2);
}
}

printf("La copie de \"%s\" sous le nom \"%s\" a été créée avec succès.\n", source_filename, destination_filename);
}

ReX : Youpi. Il reste à se passer du bloc de <code>BLOCK_SIZE</code> (au bénéfice d'un bloc de taille <code>BLOCK_SIZE/n</code> avec n>1). Ecrire la fonction inverse de <code>reconsituteNumber</code>.

=== Fonction TYPE version 3 ===
La fonction 2 que j'ai fourni ci-dessus n'est pas correcte. Je vais la corriger dans cette version 3.

ReX : Effectivement la version précédente ne gére pas correctement l'écriture des numéros de blocs de données dans la description d'un fichier.

= Compilation et exécution =
'''Création du système de fichiers :'''
dd if=/dev/zero of=filesystem.bin bs=256 count=32768

'''Compilation :'''

gcc picofs.c -o picofs

'''Exécution de LS, TYPE, CAT, RM, MV ou CP :'''

./picofs filesystem.bin LS
./picofs filesystem.bin TYPE mon_fichier.txt
./picofs filesystem.bin CAT mon_fichier.txt
./picofs filesystem.bin RM mon_fichier.txt
./picofs filesystem.bin MV mon_fichier.txt mon_fichier2.txt
./picofs filesystem.bin CP mon_fichier.txt mon_fichier2.txt

= Documents Rendus =
[[Fichier:Picofilesystemv2.c.tar|vignette]]

SE4 2022/2023 EC1

2023-09-02T16:22:11Z

Asellali : /* Documents Rendus */

= Objectifs =

Il vous est demandé de :
* réaliser un micro système de fichiers ;
* le système de fichiers doit résider dans un fichier de 8 Mo ;
* le système de fichiers est géré par un exécutable obtenu à partir d'un programme C ;
* L'éxécutable prend deux arguments, le premier est le chemin du fichier dans lequel réside le système de fichiers, les paramètres suivants concernent l'action à appliquer sur le système de fichiers ;
* le micro système de fichier ne comporte qu'un répertoire : le répertoire principal, le répertoire principal peut comporter au maximum 64 fichiers, un fichier est caractérisé par un nom de 16 caractères au maximum et ses blocs de données, un fichier peut comporter au maximum 2040 blocs de données ;
* un bloc de données fait 256 octets et les blocs sont numérotés sur 2 octets ;
* les différentes actions possibles sur le système de fichiers sont :
** <code>TYPE</code> pour créer un fichier si possible, le nom du fichier suit la commande, le contenu du fichier est donné en entrée standard de l'exécutable ;
** <code>CAT</code> pour afficher un fichier, le nom du fichier suit la commande ;
** <code>RM</code> pour détruire un fichier, le nom du fichier suit la commande ;
** <code>MV</code> pour renommer un fichier, les noms original et nouveau du fichier suivent la commande ;
** <code>CP</code> pour copier un fichier, les noms de l'original et de la copie du fichier suivent la commande ;

= Matériel nécessaire =

Un PC sous Linux.

= Travail réalisé =

== Semaine 1 ==

ReX : attention, ce micro-système de fichiers est prévu pour un microcontrôleur, vos variables globales ne peuvent pas dépasser quelques centaines d'octets.

ReX : pour la création du système de fichiers la commande <code>dd</code> suffit, vous voulez dire le formatage du système de fichiers ?

* création du programme programme.c contenant les différentes structures et les différentes fonctions.
* Piste d'amélioration: faire en sorte que la fonction CAT affiche le contenu exact des fichiers passés en argument.

Le code fourni est un programme en langage C qui simule un système de fichiers basique. Ce programme permet aux utilisateurs d'effectuer diverses actions telles que créer, afficher, supprimer, renommer et copier des fichiers dans un système de fichiers simulé. Le système de fichiers est stocké dans un fichier binaire.

ReX : vous n'avez pas tenu compte de la première remarque, vous chargez tout le superbloc et le répertoire racine, votre code ne convient pas.

ReX : vos structures utilisent des types entiers dont la taille n'est pas explicitée, utilisez les types de <code>stdint.h</code>.

ReX : la création de fichier n'est pas fonctionnelle, vous ne cherchez pas les blocs libres, vous ne copiez pas le contenu du fichier dans les blocs, même remarque pour toutes les autres fonctions.

ReX : il manque les fonctions d'accès aux pages du système de fichiers.

'''Explication du programme programme.c'''

Voici une brève explication des principaux éléments et fonctions du code :

# Structures :
#* Fichier : Représente un fichier dans le système de fichiers. Il contient un nom (nom) avec une longueur maximale de 16 caractères, un tableau de numéros de bloc (blocs) où le contenu du fichier est stocké (jusqu'à 2040 blocs), et le nombre de blocs utilisés par le fichier (nbBlocs).
#* Repertoire : Représente le répertoire principal du système de fichiers. Il contient un tableau de fichiers (<code>fichiers</code>) et le nombre de fichiers dans le répertoire (<code>nbFichiers</code>).
# Fonctions :
#* <code>chargerSystemeFichiers</code> : Charge le système de fichiers à partir d'un fichier binaire donné (chemin) dans une structure Repertoire.
#* <code>sauvegarderSystemeFichiers</code> : Sauvegarde le système de fichiers stocké dans la structure Repertoire dans un fichier binaire (chemin).
#* <code>creerFichier</code> : Crée un nouveau fichier dans le système de fichiers avec un nom et un contenu donnés. Le contenu du fichier est simulé en le divisant en blocs.
#* <code>afficherFichier</code> : Affiche le contenu d'un fichier avec le nom spécifié.
#* <code>detruireFichier</code> : Supprime un fichier avec le nom spécifié du système de fichiers.
#* <code>renommerFichier</code> : Renomme un fichier avec l'ancien nom spécifié en un nouveau nom.
#* <code>copierFichier</code> : Copie un fichier avec le nom spécifié en créant un nouveau fichier avec le nom de copie spécifié.
# Fonction <code>main</code> :
#* La fonction <code>main</code> est le point d'entrée du programme.
#* Elle prend des arguments en ligne de commande : <code><chemin_systeme_fichiers></code> et <code><action></code>.
#* <code><chemin_systeme_fichiers></code> est le chemin vers le fichier binaire où le système de fichiers est stocké.
#* <code><action></code> détermine quelle opération effectuer, comme <code>TYPE</code>, <code>CAT</code>, <code>RM</code>, <code>MV</code> ou <code>CP</code>.
#* En fonction de l'action spécifiée, le programme appelle la fonction correspondante pour effectuer l'opération souhaitée sur le système de fichiers.
Remarque : Le code fourni une simulation basique d'un système de fichiers et de ses opérations, mais il n'interagit pas réellement avec un système de fichiers réel sur le disque.

'''Comment utiliser le programme programme.c'''

étape 1: création du système de fichiers respectant le cahier des charges:

dd if=/dev/zero of=systeme_fichiers.bin bs=1M count=8

étape 2: compilation du programme C:

gcc programme.c -o gestionnaire_fs

étape 3: création d'un fichier dans le système de fichier:

./gestionnaire_fs systeme_fichiers.bin TYPE fichier1.txt

-> entrer le texte en entrée standard

étape 4: manipulation des différentes fonctions. Exemples:

./gestionnaire_fs systeme_fichiers.bin CAT fichier1.txt
./gestionnaire_fs systeme_fichiers.bin CP fichier1.txt copie.txt
./gestionnaire_fs systeme_fichiers.bin RM copie.txt
./gestionnaire_fs systeme_fichiers.bin MV fichier1.txt fichier2.txt

== Semaine 2 ==

Amine: Merci pour vos remarques. Désolé de ne pas avoir suivi votre première remarque, je pensais avoir compris ce qu'il fallait faire mais je me rend compte que non. Je vais tout reprendre depuis le début afin de repartir sur de bonnes bases.

'''Création du système de fichier avec la commande "dd"'''

A quoi sert la commande dd?

La commande <code>dd</code> permet de copier tout ou partie d'un disque par blocs d'octets, indépendamment de la structure du contenu du disque en fichiers et en répertoires (source : [https://doc.ubuntu-fr.org/dd]).

Structure de la commande

dd if=<nowiki><source> of=<cible> bs=<taille des blocs></nowiki>

<code>source</code> = données à copier

<code>cible</code> = endroit où les copier

<code>if</code> = input file

<code>of</code> = output file

<code>bs</code> = block size, habituellement une puissance de 2 supérieure ou égale à 512, représentant un nombre d'octets

Choix de la commande:

Pour la source, on prends <code>/dev/zero</code>: cela permet de créer un fichier rempli de 0. Ce fichier servira de base pour notre système de fichiers.

Pour la cible, on va l'appeler <code>filesystem.bin</Code> : ce sera notre système de fichier.

Pour la taille des blocs, on veut des blocs de données de 256 octets d'après l'enoncé. On va donc prendre <code>bs=256</code>.

Enfin, on veut que le système de fichier réside dans un fichier de 8 Mo. On va donc ajouter <code>count=31250</code>: cela indique que nous voulons écrire 32768 blocs de données dans le fichier (31250 * 256 octets = 8 Mo).

Résultat:

dd if=/dev/zero of=filesystem.bin bs=256 count=31250

Question pour M. Redon : j'ai ici essayé de respecter votre remarque "pour la création du système de fichiers la commande <code>dd</code> suffit". Cependant, pour votre seconde remarque "vous chargez tout le superbloc et le répertoire racine, votre code ne convient pas.", je ne suis pas sûr de comprendre où je fais cela: est-ce lors de la commande dd ou est-ce par la suite avec mon programme C? J'ai un peu modifié la commande dd comme vous pouvez le voir ci-dessus. Ai-je corrigé mon erreur avec cette nouvelle commande? J'ai essayé de justifier au maximum la commande dd que j'ai choisie.

ReX : Pas de problème avec la commande <code>dd</code> (mettez tous les extraits de code entre des balises <code>code</code>). Le problème est au niveau du programme C.

Amine: Ok je comprends mieux merci. Je vais donc reprendre le code étape par étape afin de mieux répondre au cahier des charges.

Gestion du système de fichier par un programme C

'''Création des structures'''
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>

// Structure pour représenter un bloc de données

struct DataBlock {
uint8_t data[256]; // 256 octets pour chaque bloc de données
};

// Structure pour représenter un fichier

struct File {
char filename[17]; // 16 caractères pour le nom du fichier + 1 caractère null-terminator
struct DataBlock data_blocks[2040]; // Tableau de blocs de données pour stocker le contenu du fichier
uint16_t num_data_blocks; // Nombre de blocs de données utilisés par le fichier
};

// Structure pour représenter un répertoire

struct Directory {
struct File files[64]; // Tableau de fichiers pour le répertoire principal
uint8_t num_files; // Nombre de fichiers dans le répertoire principal
};

Modification faite : suite à votre remarque, j'ai explicité la taille des entiers grâce aux types de <code>stdint.h.</code> (j'ai également mis les variables en anglais)

ReX : Vous ne pouvez pas utiliser ces structures, une instanciation d'une de ces structure prend trop d'espace mémoire, vous devez faire sans structure. Par ailleurs la façon dont vous représentez vos fichiers ne convient pas, la description d'un fichier contient des numéros de blocs, pas les blocs eux-même. Faites aussi attention qu'un fichier soit décrit par un nombre entier de blocs.

Question pratique: je n'arrive pas à mettre tout le code dans le même bloc comme vous l'avez fait ci-dessus dans l'étape 4 de la semaine 1. Je vois que c'est en format "préformaté" mais j'obtiens des blocs séparés lorsque j'applique ce format à mon code.

ReX : j'ai corrigé, pour un code entier la syntaxe n'est pas la même (un espace en début de chaque ligne), la balise c'est uniquement pour de très courts extraits de code.

=== Fonction <code>readBlock</code>===
Cette fonction est utilisée pour lire un bloc de données à partir du fichier <code>filesystem.bin</code> et le stocker dans un tableau de caractères (<code>storage</code>).

Fonction:

#define BLOCK_SIZE 256
// Fonction pour lire un bloc de données
void readBlock(unsigned int num, int offset, unsigned char *storage, int size) {
FILE *file = fopen("filesystem.bin", "rb");
if (file == NULL) {
perror("Erreur lors de l'ouverture du fichier");
return;
}
fseek(file, num * BLOCK_SIZE + offset, SEEK_SET);
fread(storage, 1, size, file);
fclose(file);
}

Paramètres :

* <code>num</code> : Numéro du bloc à lire. Chaque bloc contient 256 octets (1 bloc = 256 octets).
* <code>offset</code> : Décalage (en octets) à partir du début du bloc pour commencer la lecture.
* <code>storage</code> : Pointeur vers un tableau de caractères où les données lues seront stockées.
* <code>size</code> : Taille du tableau de caractères <code>storage</code>.

Fonctionnement :

* La fonction commence par ouvrir le fichier <code>filesystem.bin</code> en mode lecture binaire (<code>"rb"</code>).
* Elle utilise <code>fseek</code> pour positionner le curseur de lecture dans le fichier à l'endroit approprié pour commencer la lecture du bloc spécifié (<code>num</code>) à partir de l'offset (<code>offset</code>).
* Elle utilise ensuite <code>fread</code> pour lire <code>size</code> octets à partir du fichier et les stocker dans le tableau <code>storage</code>.
* Enfin, elle ferme le fichier avec <code>fclose</code>.

Note : Le paramètre <code>offset</code> est utilisé pour spécifier à partir de quel octet du bloc on souhaite commencer la lecture. Si <code>offset</code> est égal à 0, la lecture commencera depuis le début du bloc. Si <code>offset</code> est différent de 0, la lecture commencera à l'octet spécifié.

Remarque: dans votre mail, vous définissez "readBlock(unsigned int num,int offset,unsigned storage,int size)": storage n'est alors pas un pointeur vers un tableau de caractère. Je me suis donc permis de faire la modification.

ReX : OK pour la fonction, pas la peine d'en mettre autant dans le Wiki pour une fonction aussi simple.

=== Fonction <code>writeBlock</code> ===
Cette fonction est utilisée pour écrire un bloc de données dans le fichier <code>filesystem.bin</code> à partir d'un tableau de caractères (<code>storage</code>).

Fonction:

// Fonction pour écrire un bloc de données
void writeBlock(unsigned int num, int offset, const unsigned char *storage, int size) {
FILE *file = fopen("filesystem.bin", "rb+");
if (file == NULL) {
perror("Erreur lors de l'ouverture du fichier");
return;
}
fseek(file, num * BLOCK_SIZE + offset, SEEK_SET);
fwrite(storage, 1, size, file);
fclose(file);
}

Paramètres :

* <code>num</code> : Numéro du bloc où écrire.
* <code>offset</code> : Décalage (en octets) à partir du début du bloc pour commencer l'écriture.
* <code>storage</code> : Pointeur vers un tableau de caractères contenant les données à écrire dans le fichier.
* <code>size</code> : Taille du tableau de caractères <code>storage</code>.

Fonctionnement :

* La fonction commence par ouvrir le fichier <code>filesystem.bin</code> en mode lecture et écriture binaire (<code>"rb+"</code>).
* Elle utilise <code>fseek</code> pour positionner le curseur de lecture/écriture dans le fichier à l'endroit approprié pour commencer l'écriture du bloc spécifié (<code>num</code>) à partir de l'offset (<code>offset</code>).
* Elle utilise ensuite <code>fwrite</code> pour écrire <code>size</code> octets à partir du tableau <code>storage</code> dans le fichier.
* Enfin, elle ferme le fichier avec <code>fclose</code>.

ReX : Même remarque que pour la fonction précédente.

'''Etape 4: test des fonctions <code>readBlock</code> et <code>writeBlock</code> dans le main'''
// Exemple de fonction principale pour tester les opérations de lecture et d'écriture
int main() {
unsigned char data[BLOCK_SIZE];
// Test de la fonction readBlock
readBlock(0, 0, data, BLOCK_SIZE);
printf("Block 0, offset 0: ");
for (int i = 0; i < BLOCK_SIZE; i++) {
printf("%02x ", data[i]);
}
printf("\n");
// Test de la fonction writeBlock
unsigned char newData[BLOCK_SIZE] = {
0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88,
// ... Autres données du bloc ...
};
writeBlock(1, 0, newData, BLOCK_SIZE);
// Lecture du bloc nouvellement écrit pour vérifier
readBlock(1, 0, data, BLOCK_SIZE);
printf("Block 1, offset 0: ");
for (int i = 0; i < BLOCK_SIZE; i++) {
printf("%02x ", data[i]);
}
printf("\n");
return 0;
}

Fonctionnement :

* On déclare tout d'abord un tableau de caractères <code>data</code> de taille <code>BLOCK_SIZE</code> pour stocker les données lues du bloc.
* Ensuite, la fonction <code>readBlock</code> est appelée avec les arguments (0, 0, data, BLOCK_SIZE) pour lire le premier bloc du fichier (<code>num=0</code>, <code>offset=0</code>) et stocker les données dans <code>data</code>.
* Ensuite, la fonction <code>printf</code> est utilisée pour afficher les données lues du bloc (<code>data</code>) en format hexadécimal.
* Ensuite, un nouveau tableau de caractères <code>newData</code> est créé avec des données spécifiques pour tester la fonction <code>writeBlock</code>.
* La fonction <code>writeBlock</code> est appelée avec les arguments (1, 0, newData, BLOCK_SIZE) pour écrire le tableau <code>newData</code> dans le deuxième bloc du fichier (<code>num=1</code>, <code>offset=0</code>).
* Enfin, la fonction <code>readBlock</code> est appelée à nouveau pour lire le deuxième bloc nouvellement écrit et afficher les données lues en format hexadécimal.

Question générale : ce que j'avais la première semaine n'est plus forcément d'actualité. Puis-je supprimer les choses qui ne le sont plus afin d'alléger la page ou préférez-vous que je laisse?

ReX : Laissez.

Pour la suite : j'ai donc pour l'instant crée deux fonctions, l'une permettant la lecture et l'autre l'écriture d'un bloc, de manière à économiser la mémoire. Pour la suite, je vais essayer de créer la fonction <code>LS</code> en utilisant la fonction <code>readBlock</code>.

ReX : Oui c'est le début du projet. Mais si vous n'avez pas une bonne description de fichier cela ne donnera rien. Voir remarques plus haut.

'''Etape 5: fonction <code>LS</code>'''

Objectif: créer la fonction <code>LS</code> avec la fonction readBlock.

Question: Souhaitez-vous la fonction <code>LS</code> classique, c'est à dire la fonction <code>LS</code> qui affiche simplement le nom des fichiers présent dans le répertoire ?

ReX : Oui. Tu peux ajouter la taille si tu trouves cela trop simple.

Piste : si c'est ce que vous voulez:

* il va tout d'abord falloir que je crée des fichiers, un fichier étant composé d'un nom et de blocs (création d'une fonction createFile)
* Il faudra ensuite que je stocke ces fichiers dans le répertoire (création d'une fonction addFileToDirectory par exemple)
* enfin, il faudra que j'affiche le nom des fichiers. Pour cela, il faudra que je parcours le répertoire (structure "Directory"), puis que pour chaque fichier présent dans le répertoire que j'affiche son nom (création de la fonction LS)

Je devrais surement utiliser la fonction readBlock afin de transférer les blocs dans le fichier au travers de la variable "storage".

ReX : Créer des fichiers n'est pas nécessaire tout de suite je verrais bien si ton code est bon sans test. Laisse tomber <code>createFile</code> et <code>addFileToDirectory</code> pour l'instant.

ReX : Ton algorithme ne fonctionne pas pour un microcontrôleur où il faut économiser la mémoire, tu ne peux pas t'aider de structures. Il faudra que tu charges les noms et seulement les noms, pour la taille il faudra se baser sur le nombre de blocs.

'''Etape 6: rectification du code suite à vos remarques'''

Modifications apportées:

* suppression des structures afin d’économiser de la mémoire.

* le problème quant à la description des fichiers est normalement résolu puisque plus de structures. On ne charge plus les blocs mais seulement les noms de fichiers.

ReX : Non car si les noms ne sont pas répartis de façon régulière dans les blocs de 256 octets tu vas avoir du mal à les charger. Mais écrit la fonction <code>LS</code> et tu verras ce que je veux dire.

J'ai également ajouté deux nouvelles fonctions:

# <code>void readFileName(unsigned int file_num, char *file_name)</code>: Cette fonction permet de lire le nom du fichier associé au numéro de fichier donné (<code>file_num</code>). Elle stocke le nom du fichier lu dans le tableau <code>file_name</code>.
# <code>void writeFileName(unsigned int file_num, const char *file_name)</code>: Cette fonction permet d'écrire le nom du fichier dans le système de fichiers, associé au numéro de fichier donné (<code>file_num</code>). Elle prend en entrée le nom du fichier à écrire (<code>file_name</code>).

Suite: si vous validez cette base, je pourrai passer à la création de la fonction LS.

ReX : tu peux y aller. Je ne vois pas le code des tes deux fonctions <code>readFileName</code> et <code>writeFileName</code>.

Voici le code des fonctions <code>readFileName</code> et <code>writeFileName</code> :

'''Fonction readFileName:'''
// Fonction pour lire le nom du fichier
void readFileName(unsigned int file_num, char *file_name) {
readBlock(file_num, 0, (unsigned char *)file_name, MAX_FILENAME_LENGTH);
file_name[MAX_FILENAME_LENGTH] = '\0'; // Ajout du caractère null-terminator pour former une chaîne de caractères
}

ReX : Non, aucune raison que le fichier de numéro n soit au bloc n. Dessine la représentation d'un fichier sur le SF en comptant les octets si cela peut aider.

'''Fonction writeFileName:'''
// Fonction pour écrire le nom du fichier
void writeFileName(unsigned int file_num, const char *file_name) {
writeBlock(file_num, 0, (const unsigned char *)file_name, MAX_FILENAME_LENGTH);
}

ReX : Faux et inutile pour l'instant. Problème avec la constante MAX_FILENAME_LENGTH.

=== Fonction LS version 1 ===
// Fonction LS pour afficher les fichiers présents dans le système de fichiers
void LS(const char *filesystem_path) {
FILE *file = fopen(filesystem_path, "rb");
if (file == NULL) {
perror("Erreur lors de l'ouverture du fichier système");
return;
}
uint16_t num_files;
fread(&num_files, sizeof(uint16_t), 1, file); // Lecture du nombre de fichiers dans le système
char filename[17];
printf("Fichiers présents dans le système de fichiers:\n");
for (int i = 0; i < num_files; i++) {
readFileName(i, filename); // Lecture du nom du fichier
printf("%s\n", filename); // Affichage du nom du fichier
}
fclose(file);
}
La fonction <code>LS</code> ouvre le fichier système, lit le nombre de fichiers qu'il contient, puis affiche les noms des fichiers un par un, chacun sur une ligne séparée.

ReX : Il y a le nombre de fichiers dans ton superbloc ? Un dessin du format du superbloc avec les numéros des octets ?

ReX : Tout accès au système de fichiers doit se faire avec les deux fonctions <code>readBlock</code> et <code>writeBlock</code>.

== Semaine 3 ==
Question 1: cela fait plusieurs fois que vous mentionnez dans le wiki un "superbloc". Celui-ci n'étant pas clairement défini dans le sujet, je me demande s'il s'agit du bloc crée grâce à la fonction dd, c'est à dire que le superbloc serait en faite le bloc constitué des 31250 blocs de taille 256 octets, où s'il s'agit d'un bloc qui vient en entête, celui contenant alors des informations décrivant le système de fichier (les noms de fichiers...).

ReX : Pour ton pico système de fichiers, le superbloc consiste en les premiers blocs (de 256 octets) qui définissent les 64 fichiers possibles.

Proposition de structure: on pourrait réserver les premiers blocs du système de fichiers aux noms de fichiers ainsi qu'aux numéros des blocs correspondant à chaque fichier.

ReX : Oui c'est évident.

On sait que les noms de fichiers font au maximum 16 caractères + 1 caractère pour le '\0' (donc 17 octets car 1 char=1 octet).

ReX : Non, 16 octets suffisent, des '\0' en fin de nom uniquement si le nom fait moins de 16 caractères.

On sait également qu'un fichier contient au maximum 2040 blocs, chaque bloc étant numéroté sur 2 octets. On pourrait donc avoir en début du système de fichier: 17 octets+2 octets*2040 blocs = 4097 octets pour la description d'un fichier.

ReX : Non, 4096 octets soit 16 blocs de 256.

Or d'après l'une de vos remarques dans le wiki, un fichier doit être décrit par un nombre entier de blocs. Pour un fichier, il nous faudra donc 4097/256=16.004 soit 17 blocs. Il peut y avoir jusqu'à 64 fichiers dans le répertoire, il nous faudra donc 17 blocs*64 fichiers= 1088 blocs pour la description des fichiers.

ReX : Non 1024 blocs de 256 octets dans le superbloc.

Ainsi, pour la fonction LS, il suffira de lire les premiers caractères tous les 17 blocs ( du premier caractère au caractère '\0').

ReX : Non, tous les 16 blocs.

Question 2: Ne faudrait-il pas également stocker quelque part le nombre de fichier qu'il y a dans le répertoire afin de savoir jusqu'à quel bloc la fonction LS doit aller ?

ReX : Non, un fichier dont le nom n'est constitué que de '\0' est réputé ne pas exister.

Question 3: on a donc vu que les 1088 premiers blocs au maximum serviraient à la description du système de fichier. Il reste donc 31250-1088=30132 blocs dans le système de fichier.

ReX : Non, 32768-1024=31744 blocs.

Comment utiliser ces blocs? Ces blocs doivent-ils stocker le contenu des fichiers ?

ReX : Oui, c'et évident.

En effet, avec la fonction TYPE, nous allons créer des fichiers et ces fichiers devront être stockés quelque part. Cependant, étant donné que ce pico système de fichiers est prévu pour un microcontrôleur, je ne sais pas si c'est le contenu des fichiers qui doit être stocké dans les blocs ou autre chose (peut être l'adresse des fichiers, le fichiers se trouvant autre part). En effet, je me dis que si un fichier est très volumineux, il ne pourra pas rentrer dans le système de fichier, ce dernier étant composé d'un nombre limité de blocs, et les blocs étant eux même limité en nombre d'octets.

ReX : Je ne comprend pas ton problème. De tout façon comme dit plus haut, les 31744 blocs suivant le superbloc doivent contenir les données des fichiers.

Désolé de poser des questions peut être basique aussi tard, mais je pense qu'une fois que j'aurai ces réponses, cela ira beaucoup mieux pour la suite. Merci d'avance pour vos réponses.

ReX : Les questions sont effectivement triviales et il est effectivement inquiétant que voir que la travail n'avance pas.

Amine: merci pour vos corrections.

D'après votre commentaire "32768-1024=31744 blocs", j'en déduis qu'il faut que je modifie ma commande dd (qui est actuellement "dd if=/dev/zero of=filesystem.bin bs=256 count=31250" pour avoir le bon filesystem).

ReX : Je comprends pas d'où tu sors le 31250. D'autant plus que la commande ci-dessous est bonne.

Amine : 31250 car 31250 blocs * 256 octets = 8 Mo.

ReX : Haaaa je vois tu utilises le système métrique international où le mégaoctet vaut 10^6 octets, sauf qu'aucun informaticien n'utilisera cette norme hors sol. Quand je parle de 8 Mo c'est 8x1024x1024 octets. Tout simplement parce qu'une puce mémoire de 8 Mo c'est bien 8x1024x1024 octets.

Amine: D'accord merci pour l'information !

'''Nouvelle commande dd:'''

dd if=/dev/zero of=filesystem.bin bs=256 count=32768

=== Fonction LS version 2 ===

Dans notre structure du système de fichier, le superbloc est constitué de 1024 blocs (16 blocs * 64 fichiers), un fichier étant décrit par 16 blocs. Le nom du fichier est donc écrit au début de tous les blocs multiples de 16. Par exemple, le nom du premier fichier est dans les 16 premiers octets du premier bloc, le nom du 2ème fichier est dans les 16 premiers octets du 32ème bloc et ainsi de suite, tant que des fichiers existent. Lorsque qu'il n'y a plus de fichier, le nom du premier caractère du bloc multiple de 16 est un 0.

Voici le code:
// Fonction pour lister les noms de fichiers présents dans le système de fichiers
void LS() {
unsigned char buffer[BLOCK_SIZE];
int fileCount = 0;

for (int blockNum = 1; blockNum <= MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, BLOCK_SIZE);

// Vérifier si le bloc est vide
if (buffer[0] == 0) {
break; // Plus de fichiers à lire
}

char filename[MAX_FILENAME_LENGTH];
memcpy(filename, buffer, MAX_FILENAME_LENGTH);

// Afficher le nom du fichier
printf("%s\n", filename);
fileCount++;
}

if (fileCount == 0) {
printf("Aucun fichier trouvé.\n");
}
}

ReX : Tu supposes que si un fichier a un nom vide, les suivants auront aussi un nom vide. C'est possible mais dans ce cas la commande <code>RM</code> ca être plus compliquée à écrire.

ReX : Tu ne sembles pas comprendre que la mémoire d'un microcontrôleur est limitée. Pourquoi lire le premier bloc de description d'un fichier en entier ? Dit autrement c'est quoi l'intérêt de lire 256 octets alors que 16 suffisent ?

ReX : Pourquoi tu ne lis pas le premier fichier ? Autrement dit pourquoi décaler tout d'un bloc ?

Amine: Merci pour vos remarques. J'ai apporté les modifications à LS dans la section "Semaine 4" du wiki.

'''Réflexion par rapport aux autres fonctions:'''

J'ai créé les fonctions TYPE et CAT mais il y a malheureusement un problème pour l'instant. Vous pouvez les retrouver en pièce jointe dans l'archive du fichier programme.c.

Le problème que j'ai est que lorsque j'affiche le contenu du fichier créé avec TYPE, j'obtiens plein de caractères spéciaux. Par exemple, je créé le fichier "mon_fichier.txt" avec la fonction TYPE, et je mets en entré standard "hello". Ensuite, je veux afficher le contenu de ce fichier grâce à la fonction CAT. Cependant, ce qui s'affiche dans le terminal n'est pas ce que je veux. De la même manière, lorsque je fais la commande "cat filesystem.bin" dans le terminal, c'est la même chose s'affiche, des donnés parasites.

ReX : Avant même de lire ton code je vais te poser la question de savoir comment tu récupères un bloc libre ? Quel algorithme tu utilises. Personnellement je ne sais pas faire sans ajouter au superbloc un tableau bit à bit des blocs libres. Pour avoir un bit pour chaque bloc du système de fichiers, il faut 32768/8=4096 octets soit 16 blocs.

Amine: ok je vais donc ajouter ce tableau de 16 blocs à la suite de mes premiers 1024 blocs servant à la description de fichier. Le superbloc fera maintenant 1024+16=1040 blocs (plus de détail à la fonction RM de la semaine 4).

Question 1: est ce que la fonction CAT que je dois créer doit renvoyer la même chose que "cat filesystem.bin" ?

ReX : Je préfère ne pas répondre tellement la question montre un manque de réflexion.

Question 2: comment savoir combien de blocs doivent etre attribué à un fichier? Par exemple, si je créé un fichier "mon_fichier.txt" et que je mets en entrée standard le texte "hello", un seul bloc suffi pour stocker ce texte. Cependant, si j'avais mis beaucoup de texte en entrée standard, il aurait fallu plus de blocs. Doit-on calculer la taille de l'entrée standard ou doit-on attribuer toujours le meme nombre de blocs à un fichier? Peut-etre ainsi attribuer 2040 blocs par fichier, meme s'il n'en utilise que 1.

ReX : Là encore c'est une question stupéfiante tellement la réponse est évidente. Il suffit de lire les données sur l'entrée standard et de passer au bloc de données suivant dès que le bloc courant est rempli. La question à poser c'était de se demander comment il est possible d'avoir la taille exacte du fichier pour un <code>CAT</code>. Il est uniquement possible de l'avoir à 256 octets près puisque rien n'indique si le dernier block est vide. Le mieux aurait été de prévoir 4 octets dans la description d'un fichier pour stocker la taille. En l'espèce on considérera que les fichiers sont des fichiers ASCII et qu'ils seront terminés par des <code>\'0</code> qui ne seront pas affichés.

== Semaine 4 ==

Voici un bilan de ce que j'ai fait à ce stade du projet:

* j'ai choisi une structure du système de fichier
* j'ai créé les fonctions readBlock et writeBlock permettant de lire et d'écrire des blocs
* j'ai crée la fonction LS permettant d'afficher le nom des fichiers présents dans le système de fichiers
* j'ai programmer un main permettant d'utiliser les fonctions (LS, TYPE...) depuis le terminal
* j'ai réflechi aux fonctions TYPE et CAT.

Actuellement, je suis en train de créer les fonctions TYPE et CAT.

=== Fonction LS version 3 ===
void LS() {
unsigned char buffer[MAX_FILENAME_LENGTH];
int fileCount = 0;

// Parcourir tous les 16 blocs de 0 jusqu'à MAX_FILES_IN_DIRECTORY
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, MAX_FILENAME_LENGTH);

// Vérifier si le nom de fichier est vide
if (buffer[0] != 0) {

// Afficher le nom du fichier
printf("%s\n", buffer);
fileCount++;
}
}

if (fileCount == 0) {
printf("Aucun fichier trouvé.\n");
}
}
Suite à vos remarques, j'ai effectué les modifications suivantes de la fonction LS:

* Je ne suppose plus que si un fichier a un nom vide, les autres auront aussi un nom vide.
* Je ne lis plus les 256 octets mais seulement les 16 premiers octets car cela suffit.
* Je ne lisais en effet pas le premier bloc. Je pensais que le premier bloc était d'indice 1 mais ce n'est pas le cas.

ReX : Ouiiii ! Une fonction correcte. Passe à <code>RM</code> maintenant, c'est la plus facile à faire concernant l'image bit à bit des blocs libres.

=== Fonction setBlockAvailability version 1 ===

Comme vous l'avez indiqué dans votre remarque, il faut un tableau dans le superbloc qui nous permettra de connaitre la disponibilité bit par bit de chaque bloc. Sachant qu'il y a dans notre système de fichiers 32768 blocs, et qu'il faut 1 bit par bloc, nous avons besoin de 32768 bits, soit 32768/8=4096 octets soit 4096/256=16 blocs. Notre superbloc sera donc comme suit: les 1024 premiers blocs servent à la description des fichiers, c'est à dire à leur nom suivi des numéros de blocs qui leur sont associés, puis ces 1024 blocs sont suivi de 16 blocs listant la disponibilité de chaque bloc.

ReX : Bien résumé.

Nous allons tout d'abord écrire la fonction "setBlockAvailability" prenant en paramètre le numéro du bloc à traiter (<code>blockNum</code>) et la disponibilité souhaitée pour ce bloc (<code>availability</code>). Cette fonction permet de marquer la disponibilité d'un bloc spécifique dans le système de fichiers. Nous utiliserons la convention suivante: un bloc disponible sera marqué par un 1 tandis qu'un bloc non disponible par un 0.
#define SUPERBLOCK_START_BLOCK 1024

void setBlockAvailability(int blockNum, int availability) {
// Calculer l'index du byte et le bit offset correspondant
int byteIndex = blockNum / 8;
int bitOffset = blockNum % 8;

// Lire le byte existant du bloc de disponibilité des blocs
unsigned char buffer[1];
readBlock(SUPERBLOCK_START_BLOCK + byteIndex, 0, buffer, 1);

// Mettre à jour le bit d'offset correspondant
if (availability) {
buffer[0] |= (1 << bitOffset);
} else {
buffer[0] &= ~(1 << bitOffset);
}

// Écrire le byte mis à jour dans le bloc de disponibilité des blocs
writeBlock(SUPERBLOCK_START_BLOCK + byteIndex, 0, buffer, 1);
}

ReX : Un tableau de un octet c'est un octet (variable <code>buffer</code>).

Amine: je vais utiliser un <code>unsigned char buffer.</code> Je suis conscient qu'un char vaut un octet mais je ne pense pas qu'il y ait un type de donnée de la taille d'un bit, c'est pourquoi je travaille avec un octet mais je modifie les bits de cet octet grâce aux algorithmes.

ReX : Il faut bien que tu travailles sur un octet vu que l'état des blocs est stocké sous la forme d'octets. Je disais juste qu'un tableau de 1 élément n'a pas d'intérêt par rapport à l'élément lui-même.

Amine: c'est vrai, modification faite.

ReX : Non il faut calculer le numéro du bloc avant de faire le <code>readBlock</code>.

Amine: ok je vais calculer le numéro de bloc avant.

ReX : La mise à jour du bit est correcte mais le block et le déplacement dans le block ne sont pas correctement calculés.

Amine: je vais vous expliquer le raisonnement que j'avais. Prenons un exemple concret, imaginons que je veuille marquer le bloc 1030 comme disponible:

# Calcul de l'index de l'octet et du bit offset :
#* <code>blockNum</code> = 1030
#* Index du byte = 1030 / 8 = 128
#* Bit offset = 1030 % 8 = 6
# Lecture de l'octet existant de disponibilité:
#* Nous lisons l'octet existant à l'index 128 dans les blocs de disponibilité.
# Mise à jour du bit de disponibilité :
#* Nous voulons marquer le bloc 1030 comme disponible, donc nous utilisons le masque <code>(1 << 6)</code> pour définir le bit 6 à 1 dans l'octet. Le résultat sera, par exemple, <code>00100000</code>.
# Écriture du byte mis à jour :
#* Nous écrivons le byte mis à jour <code>00100000</code> à l'index 128 dans les blocs de disponibilité.

ReX : Ben non, un vrai exemple :
* Il faut prendre un n° de bloc plus grand : 3072 ;
* Numéro d'octet dans la carte des blocs libres : 3072/8=384 ;
* Numéro du bloc dans la carte des blocs libres : 384/256=1 ;
* Numéro du bit <code>b</code> dans l'octet n° 384-256=128 du bloc 1 : 3072%8=0 ;
* Il faut donc lire l'octet <code>o</code> de numéro 128 du bloc 1, puis modifier cet octet par <code>o |= (1<<b)</code> ou <code>o &= ~(1<<b)</code> ;
* Enfin il faut écrire l'octet modifié dans le bloc 1.
Amine: merci pour cet exemple! J'ai compris d'où vient mon erreur. Voir fonction setBlockAvailability version 3.

Remarque: par convention, j'apellerai dans la suite de ce projet "premier superbloc" le superbloc correspondant à la description des fichiers, c'est à dire les 1024 premiers blocs, et j'appellerai "second superbloc" les 16 blocs qui suivent servant à décrire la disponibilité des blocs (du bloc 1024 au bloc 1039 inclu). Le reste des blocs servira à stocker les données.

ReX : Non, le superblc est l'ensemble des informations hors blocs de données, tu ne peux pas utiliser un vocabulaire au hasard. Parle de blocs de description des fichiers ou de carte des blocs libres.

Amine: ok

Je pense que le problème qui se pose est que l'indice du bit dans le second superbloc ne correspond pas à l'indice du bloc dans le système de fichier. Par exemple, nous voudrions que si le bloc 1030 est disponible dans le système de fichier, alors le bit numéro 1030 du deuxième superbloc soit à 1, ce qui n'est pas le cas ici. En effet, on se trouve bien dans le bon octet avec ma méthode mais l'écriture du bit se fait de la droite vers la gauche alors qu'on voudrait l'inverse. Ainsi, si le 6ème bit de l'octet doit être à 1, alors il faudrait qu'on obtienne <code>00000100</code> et non <code>00100000.</code> L'indice du bit coinciderait ainsi avec le numéro du bloc.

ReX : Non, réfléchit à nouveau.

Voir plus bas la nouvelle version de setBlockAvailability.

Explication de l'algorithme pour mettre le bit à 1 ou 0:

* <code>buffer[0] |= (1 << bitOffset);</code> : Cette ligne utilise l'opérateur OR bit à bit (<code>|=</code>) pour activer (mettre à 1) le bit spécifié par <code>bitOffset</code> dans le premier octet (<code>buffer[0]</code>). Cela se fait en décalant le bit 1 vers la gauche de <code>bitOffset</code> positions, puis en effectuant une opération OR bit à bit avec le contenu actuel de <code>buffer[0]</code>. Cette opération modifie uniquement le bit ciblé, laissant les autres bits inchangés.

ReX : Oui ça c'est bon.

* <code>buffer[0] &= ~(1 << bitOffset);</code> : Cette ligne utilise l'opérateur AND bit à bit (<code>&=</code>) pour désactiver (mettre à 0) le bit spécifié par <code>bitOffset</code> dans <code>buffer[0]</code>. Pour ce faire, l'expression <code>~(1 << bitOffset)</code> est utilisée pour créer un masque où tous les bits sont à 1, sauf celui correspondant à <code>bitOffset</code>, qui est à 0. En effectuant ensuite une opération AND bit à bit entre le masque et le contenu actuel de <code>buffer[0]</code>, on met à 0 le bit ciblé sans affecter les autres bits.

ReX : Ca aussi.

=== Fonction setBlockAvailability version 2 ===

void setBlockAvailability(int blockNum, int availability) {
// Calculer l'indice de l'octet et le bit offset correspondant
int byteIndex = blockNum / 8;
int bitOffset = 7 - (blockNum % 8); // Inversion de l'ordre des bits

// Calculer le numéro du bloc du super bloc où se trouve l'octet de disponibilité correspondant
int availabilityBlockNum = SUPERBLOCK_START_BLOCK + byteIndex;

// Lire l'octet existant dans le bloc de disponibilité du super bloc
unsigned char buffer;
readBlock(availabilityBlockNum, 0, &buffer, 1);

// Mettre à jour le bit d'offset correspondant :
if (availability) {
buffer |= (1 << bitOffset);
} else {
buffer &= ~(1 << bitOffset);
}

// Écrire l'octet mis à jour dans le bloc de disponibilité du super bloc
writeBlock(availabilityBlockNum, 0, &buffer, 1);
}
J'ai modifié la ligne <code>int bitOffset = 7 - (blockNum % 8);</code> pour inverser l'ordre des bits sélectionnés, de sorte que le bit correspondant au bloc disponible soit correct.

ReX : Encore plus faux.

Si on veut rendre le bloc 1030 indisponible alors que les autres blocs sont disponibles:

ReX : Pardon ? Le bloc de données est libre ou pas suivant la carte des blocs libres. Le rendre disponible n'est possible que si un fichier le comportant est détruit.

# Calcul de l'indice de l'octet et du bit offset correspondant :
#* <code>blockNum = 1030</code>
#* <code>byteIndex = 1030 / 8 = 128</code>
#* <code>bitOffset = 7 - 1030 % 8 = 1</code> Cela signifie que le bit d'intérêt se trouve à la position 2 dans l'octet.
# Calcul du numéro du bloc du super bloc où se trouve l'octet de disponibilité correspondant :
#* <code>availabilityBlockNum = SUPERBLOCK_START_BLOCK + 128 = 1024 + 128 = 1152</code> Donc, nous devons accéder à l'octet 1152 pour mettre à jour la disponibilité du bloc 1030.
# Lecture de l'octet existant dans le bloc de disponibilité du super bloc :
#* Le contenu de l'octet dans le bloc 1152 avant la mise à jour : 11111111 (en binaire)
# Mise à jour du bit d'offset correspondant :
#* Supposons que nous voulions marquer le bloc 1030 comme non disponible (<code>availability = 0</code>).
#* Le bitOffset est 1.
#* Nous effectuons une opération AND avec le complément du bit à la position 1 : <code>11111111 & 11111101 = 11111101</code>
# Écriture de l'octet mis à jour dans le bloc de disponibilité du super bloc :
#* Le contenu de l'octet 128 du second superbloc après la mise à jour : 11111101 (en binaire)

ReX : Toujours aussi faux.

Maintenant, le bit d'indice 1 du 128 ème octet du second superbloc est mis à 0, indiquant que le bloc 1030 n'est plus disponible. Les autres bits restent inchangés car nous avons effectué un AND avec un masque binaire qui avait des 1 partout sauf à la position du bit que nous souhaitions mettre à 0.

ReX : Erreur sur erreur.

=== Fonction setBlockAvailability version 3 ===
J'ai compris d'où vient l'erreur. La fonction readBlock prends en premier paramètre le numéro du bloc à lire, je ne peux donc pas lui donner la valeur "SUPERBLOCK_START_BLOCK + byteIndex" car byteIndex s'exprime en octet alors qu'on s'attend à un nombre de bloc ici. Il faut donc divisé byteIndex par 256 pour être en unité "bloc", et préciser le bit qu'on veut lire grâce à l'offset.

Pour obtenir l'octet que l'on veut, il faut prendre le reste de la division de byteIndex par 256. On va ensuite stocker cet octet dans notre "buffer".

Pour savoir quel bit modifier dans ce "buffer", on va prendre le reste de la division du bloc dont on veut mettre à jour la disponibilité par 8. On va ainsi pouvoir modifier ce bit grâce à l'algorithme, puis réécrire l'octet à son emplacement d'origine.

Cette fonction gère la carte de disponibilités des blocs. Si un bloc est disponible, alors elle le met un 0, si il est indisponible, elle met un 1.
#define SUPERBLOCK_START_BLOCK 1024

void setBlockAvailability(int blockNum, int availability) {

int byteIndexInCard = blockNum / 8; //Numéro d'octet dans la carte des blocs libres
int blockIndexInCard = byteIndexInCard / 256; //Numéro du bloc dans la carte des blocs libres
int byteIndexInBlock = byteIndexInCard % 256; //Numéro d'octet dans le bloc contenant le bit de disponibilité
int bitOffset = blockNum % 8; //Numéro du bit dans l'octet n°byteIndexInBlock du bloc blockIndexInCard

//indice du bloc contenant le bit à mettre à jour dans le bloc de description
int availabilityBlockNum = FIRST_DISPONIBILITY_CARD_BLOCK + blockIndexInCard;

// Lire l'octet existant dans le bloc de disponibilité du super bloc
unsigned char buffer;
readBlock(availabilityBlockNum, byteIndexInBlock, &buffer, 1);

// Mettre à jour le bit d'offset correspondant :
if (availability==1) { // indisponible
buffer |= (1 << bitOffset); // Mettre le bit à 1

} else { // disponible
buffer &= ~(1 << bitOffset); // Mettre le bit à 0
}

// Écrire l'octet mis à jour dans le bloc de disponibilité du super bloc
writeBlock(availabilityBlockNum, byteIndexInBlock, &buffer, 1);
}

ReX : Ben voila, c'est pas possible de te taxer d'excès de vitesse mais c'est bon.

update: j'ai fait une petite modification, maintenant un bloc disponible est marqué d'un 0 et un bloc indisponible est marqué d'un 1. C'est mieux dans la mesure où initialement, tous les blocs sont disponibles et tous les blocs sont à 0. Cela évite de devoir créer une fonction qui initialise toute la carte de disponibilités à 1 pour dire que tous les blocs sont disponibles.

=== Fonction RM version 1 ===

void RM(const char *filesystem_path, const char *filename) {
unsigned char buffer[BLOCK_SIZE];
int fileNum = -1;

// Parcourir les blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (memcmp(filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {
// Effacer le nom du fichier dans le superbloc
memset(filenameBuffer, 0, MAX_FILENAME_LENGTH);
writeBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

unsigned char fileBuffer[MAX_BLOCKS_PER_FILE * 2];
readBlock(blockNum, MAX_FILENAME_LENGTH, fileBuffer, MAX_BLOCKS_PER_FILE * 2);

// Libérer les blocs associés au fichier et réinitialiser les numéros de blocs
for (int i = 0; i < MAX_BLOCKS_PER_FILE * 2; i += 2) {
int blockNum = ((int)fileBuffer[i] << 8) + (int)fileBuffer[i + 1];
if (blockNum == 0) {
break; // Fin du fichier
}
setBlockAvailability(blockNum, 0); // Marquer le bloc comme disponible
fileBuffer[i] = 0;
fileBuffer[i + 1] = 0;
}

// Mettre à jour les numéros de blocs associés au fichier
writeBlock(blockNum, MAX_FILENAME_LENGTH, fileBuffer, MAX_BLOCKS_PER_FILE * 2);

fileNum = blockNum;
break; // Fichier trouvé, sortir de la boucle
}
}

// Afficher le résultat de l'opération
if (fileNum == -1) {
printf("Le fichier \"%s\" n'a pas été trouvé.\n", filename);
} else {
printf("Le fichier \"%s\" a été supprimé avec succès.\n", filename);
}
}

ReX : Vous utilisez <code>strcmp</code> comme <code>strncmp</code>. C'est bien la dernière qu'il faut utiliser mais en précisant la longueur du nom en paramètre, pas la taille maximale.

Amine: vous voulez dire que j'utilise memcmp au lieu de strncmp ? Ok je vais utiliser strncmp, c'est vrai que c'est plus adapté pour la comparaison de chaines de caractère.

ReX : Ha oui c'est <code>memcmp</code> que tu utilises. Ca ne peut effectivement pas marcher. Effectivement avec <code>strncmp</code> cela peut marcher vu qu'il s'arrête au premier 0 contrairement à <code>memcmp</code>.

Cependant, pourquoi doit-on passer la taille exacte du nom du fichier en paramètre, et non la taille maximale d'un nom de fichier? En effet, cela semble fonctionner en mettant la taille maximale en paramètre, tandis que lorsque l'on met la taille exacte du nom du fichier, cela pose un problème: on ne compare plus toute la chaîne de caractère mais seulement une portion du nom complet. Ainsi, si je crée par exemple un fichier que j'appelle "file1", puis que j’exécute la fonction RM "/picofs filesystem.bin RM file" par exemple, alors le fichier file1 va être supprimé quand même car on ne comparera que strlen(file)=4 premiers caractères, qui sont les mêmes, donc la fonction considérera ces chaines comme identiques. On pourrait alors se dire qu'il faudrait alors prendre plutôt comme taille en paramètre de la fonction strlen la taille du nom du fichier se trouvant dans le système de fichier plutôt que celle du nom donné en paramètre de RM. Cependant, le même problème se pose si la taille du nom du fichier du système de fichier est plus petite que celle du nom du fichier passé en paramètre. Par exemple, si le fichier présent dans système de fichier est "file", et qu'on met la longueur de file en paramètre de la fonction strcmp, puis qu'on exécute la commande "/picofs filesystem.bin RM file5", alors file sera quand même supprimé, car on ne comparera que les strlen(file)=4 premiers caractère. Finalement, une solution serait de rajouter une condition qui vérifie que les deux chaînes sont de taille identiques pour pouvoir réaliser la comparaison sur la taille exacte du nom du fichier. Cependant, il me semble qu'en mettant MAX_FILENAME_LENGTH qui vaut 16 en paramètre, cela fonctionne directement. Vous pouvez tester cela en testant mon programme.

ReX : Ok pour <code>strncmp</code> avec la taille maximale d'un nom de fichier.

etape 1: créer un fichier :
./picofs filesystem.bin TYPE fichier.txt

etape 2: verifier que le fichier a bien été créé :
./picofs filesystem.bin LS

Le terminal renvoie bien "fichier.txt"

etape 3: essayer de supprimer le fichier en mettant une chaine troncature du nom du fichier créé :
./picofs filesystem.bin RM fich

le terminal renvoi <<Le fichier "fich" n'a pas été trouvé.>>, le fichier n'a donc pas été supprimé .

etape 4: essayer de supprimer le fichier en mettant un nom plus grand incluant "fichier.txt" :
./picofs filesystem.bin RM fichier.txtt

terminal renvoi <<Le fichier "fichier.txtt" n'a pas été trouvé.>>

etape 5: enfin, tester en mettant le nom exacte du fichier que l'on veut supprimer :
./picofs filesystem.bin RM fichier.txt

terminal renvoi <<Le fichier "fichier.txt" a été supprimé avec succès.>>

Finalement, on voit que cela fonctionne avec la taille maximale mise en paramètre. On pourrait reprocher à cette méthode de comparer des caractères dans le vide, ce qui n'est pas optimal dans une optique d'économie de mémoire qui est la notre, mais la taille maximale d'un nom de fichier étant relativement faible (16 octets), on peut peut-être négliger cela au vu de l'économie d'une opération supplémentaire (comparaison de la taille des chaines de caractères).

ReX : Le parcours des blocs de données du fichier est atroce. Il faut parcourir les numéros de blocs dans le premier bloc du fichier derrière le nom du fichier puis il faut parcourir le 15 autres blocs.

Amine: Ok, je vais corriger cela dans la version 2 de RM (voir semaine 5).

Fonctionnement de la fonction RM:

* Parcours des blocs réservés pour la description des fichiers (superbloc) à partir du bloc 0, en incrémentant de 16 à chaque itération pour accéder aux blocs de noms de fichiers.

ReX : OK.

* Dans chaque bloc de noms de fichiers, la fonction compare le nom de fichier recherché avec les noms stockés dans les 16 octets de chaque bloc.

ReX : Non la fonction ne fait pas ça par contre il faudrait, oui.

Amine: Je pensais que c'était ce que je faisais avec "memcmp(filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0)".

* Si le nom de fichier est trouvé, la fonction efface le nom du fichier dans le superbloc en remplaçant les 16 octets du bloc par des zéros.

ReX : OK.

* Ensuite, la fonction accède aux octets suivants du même bloc pour obtenir les numéros de blocs associés au fichier.

ReX : Non, la boucle sort largement du premier bloc.

* Pour chaque paire de numéros de blocs (2 octets chacun), la fonction convertit les octets en un numéro de bloc. Si le numéro de bloc est nul, cela signifie la fin des blocs associés au fichier, sinon, la fonction marque ce bloc comme disponible en utilisant la fonction <code>setBlockAvailability</code> et réinitialise les numéros de blocs dans le tableau à zéro.
* Les numéros de blocs réinitialisés sont ensuite réécrits dans le bloc de description du fichier.

ReX : L'idée est là mais vu que la boucle n'est pas bonne, rien ne peut marcher.

* La fonction affiche ensuite un message indiquant le résultat de l'opération : soit que le fichier a été supprimé avec succès, soit que le fichier n'a pas été trouvé.

== Semaine 5 ==

=== Fonction RM version 2 ===

Concernant les remarques que vous m'avez faites précédemment:

* j'utilise maintenant la fonction <code>strncmp</code> pour la comparaison des chaines de caractères
* j'ai normalement corrigé le parcours des blocs. Je parcours maintenant d'abord les blocs multiples de 16 à la recherche du bloc contenant le nom du fichier à supprimer. Puis je parcours les 16 blocs de description du fichier à supprimer, afin de récupérer les numéros de blocs, libérer ces blocs dans la carte de disponibilité et de réinitialiser ces blocs dans les blocs de données.

void RM(const char *filesystem_path, const char *filename) {
int fileFound = -1;
int offset;

// Parcourir les blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char*)filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {

// Effacer le nom du fichier dans le superbloc
memset(filenameBuffer, 0, MAX_FILENAME_LENGTH);
writeBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);
fileFound = 1;
offset = blockNum;
break;
}

}

// Fin de fonction si fichier inexistant
if (fileFound == -1) {
printf("Le fichier \"%s\" n'a pas été trouvé.\n", filename);
return;
}

unsigned char buffer[BLOCK_SIZE];
//bloc que l'on va remplir de 0 et mettre à la place des blocs de données
memset(buffer, 0, BLOCK_SIZE); //on rempli buffer de 0

for (int blockNum=offset; blockNum<offset + 16; blockNum++) {

//premier bloc de description, celui contenant le nom du fichier dans les 16 premiers octets
if (blockNum == offset) {

unsigned char fileBuffer[BLOCK_SIZE-MAX_FILENAME_LENGTH];
//bloc dans lequel on va stocker les blocs de description de fichier
readBlock(blockNum, MAX_FILENAME_LENGTH, fileBuffer, BLOCK_SIZE-MAX_FILENAME_LENGTH);

// Libérer les blocs associés au fichier dans la carte de disponibilités
// et dans les blocs de description
for (int i = MAX_FILENAME_LENGTH; i < BLOCK_SIZE-MAX_FILENAME_LENGTH; i += 2) {
int blockNumData = ((int)fileBuffer[i] << 8) + (int)fileBuffer[i + 1];
if (blockNumData == 0) {
break; // Fin du fichier
}
setBlockAvailability(blockNumData, 0); // Marquer le bloc comme disponible
fileBuffer[i] = 0;
fileBuffer[i + 1] = 0;
writeBlock(blockNumData, 0, buffer, BLOCK_SIZE); //on efface les blocs de données
}
writeBlock(blockNum, MAX_FILENAME_LENGTH, fileBuffer, BLOCK_SIZE-MAX_FILENAME_LENGTH);
//on efface le premier bloc de description

} else {
unsigned char fileBuffer[BLOCK_SIZE];
readBlock(blockNum, 0, fileBuffer, BLOCK_SIZE);

// Libérer les blocs associés au fichier dans la carte de disponibilités et dans les blocs de description
for (int i = 0; i < BLOCK_SIZE; i += 2) {
int blockNumData = ((int)fileBuffer[i] << 8) + (int)fileBuffer[i + 1];
if (blockNumData == 0) {
break; // Fin du fichier
}
setBlockAvailability(blockNumData, 0); // Marquer le bloc comme disponible
fileBuffer[i] = 0;
fileBuffer[i + 1] = 0;
writeBlock(blockNumData, 0, buffer, BLOCK_SIZE); //on efface les blocs de données
}
writeBlock(blockNum, 0, fileBuffer, BLOCK_SIZE); //on efface le bloc de description
}
}
printf("Le fichier \"%s\" a été supprimé avec succès.\n", filename);
}

ReX : Pour construire le nombre sur 16 bits utiliser le OU plutôt que l'addition.

ReX : Heu non, je ne lis pas cette fonction avec tout ce code dupliqué, la seule différence entre les deux alternative est la position de début de l'adresse du premier bloc de données (<code>MAX_FILENAME_LENGTH</code> dans un cas et 0 dans l'autre). Donc l'alternative ne doit servir qu'à initialiser ce début, le reste du code doit être factorisé.

ReX : Et corrige le code, tu utilises deux tableaux de blocs (perte mémoire), tu écris le bloc à zéro dans l'itération (perte CPU).

=== Fonction RM version 3 ===

Suite à vos remarques, j'ai réalisé les modifications suivantes:

* j'utilise maintenant le OU plutôt que l'addition pour construire le nombre sur 16 bits.

* j'ai factorisé le code grâce à la création de la variable <code>startOffset</code> valant 16 lorsqu'on se trouve dans le bloc contenant le nom du fichier et valant 0 lorsqu'on se trouve dans les autres.

* Pour ce qui est du fait que j'utilise 2 tableaux de blocs, j'ai du mal à voir comment faire avec 1 seul tableau de blocs car ces deux tableaux n'ont pas du tout le même rôle. Le tableau <code>fileBuffer</code> permet de stocker les 16 blocs de description d'un fichier un à un. Lorsqu'on stocke un bloc dans <code>fileBuffer</code>, on lit ensuite les octets un à un de ce bloc afin de former des numéros de blocs, et pour chaque numéro de bloc créé, on va réinitialiser le bloc correspondant dans les blocs de données. Pour cela, on a donc besoin d'un autre bloc qui viendra écraser les anciens blocs de données. C'est pourquoi j'ai créé un bloc <code>buffer</code>qui est composé de 0 et qui va écraser les blocs de données. On ne peut pas utiliser <code>fileBuffer</code> car on a besoin d'un bloc de zéros, et si on réinitialise <code>fileBuffer</code> on perd toute les données qui s'y trouvent. Une possibilité serait de relire le bloc de donné à chaque itération de la deuxième boucle for imbriquée; cela permettrait de pouvoir réinitialiser le tableau fileBuffer à chaque itérations de cette boucle afin de stocker ce bloc de 0 dans les blocs de données, puis de restocker dans ce même tableau le bloc de description. Cependant, je ne pense pas que ce soit optimal de faire autant appel à la fonction readBlock.

* j'ai créé une fonction resetBock qui permet comme son nom l'indique de reset un bloc en le remplissant de 0. Cela nous évite de créer deux tableaux de blocs dans RM, bien que je pense que cela revienne au même car on fait appel à une fonction qui créé un tableau de blocs. Quoi qu'il en soit, cela allège le code et cette fonction pourra surement me resservir par la suite.

void RM(const char *filesystem_path, const char *filename) {
int fileFound = -1;
int offset;
unsigned char fileBuffer[BLOCK_SIZE];

// Parcourir les blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char *)filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {
// Effacer le nom du fichier dans le superbloc
memset(filenameBuffer, 0, MAX_FILENAME_LENGTH);
writeBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);
fileFound = 1;
offset = blockNum;
break;
}
}

// Fin de fonction si fichier inexistant
if (fileFound == -1) {
printf("Le fichier \"%s\" n'a pas été trouvé.\n", filename);
return;
}

for (int blockNum = offset; blockNum < offset + 16; blockNum++) {
int startOffset = 0;
if (blockNum == offset) {
startOffset = MAX_FILENAME_LENGTH;
}
readBlock(blockNum, startOffset, fileBuffer, BLOCK_SIZE - startOffset);

// Libérer les blocs associés au fichier dans la carte de disponibilités et dans les blocs de description
for (int i = 0; i < BLOCK_SIZE - startOffset; i += 2) {
int blockNumData = (fileBuffer[i] << 8) | fileBuffer[i + 1];
if (blockNumData == 0) {
break; // Fin du fichier
}
setBlockAvailability(blockNumData, 0); // Marquer le bloc comme disponible
fileBuffer[i] = 0;
fileBuffer[i + 1] = 0;
resetBlock(blockNumData); //on efface les blocs de données
}
writeBlock(blockNum, startOffset, fileBuffer, BLOCK_SIZE - startOffset);
}
printf("Le fichier \"%s\" a été supprimé avec succès.\n", filename);
}
'''Fonction resetBlock'''
void resetBlock(unsigned int blockNum) {
unsigned char buffer[BLOCK_SIZE];
memset(buffer, 0, BLOCK_SIZE);

// Utiliser writeBlock pour écrire les données du buffer dans le bloc
writeBlock(blockNum, 0, buffer, BLOCK_SIZE);
}

ReX : Ca s'améliore. Mais pourquoi cette fonction <code>resetBlock</code> ? Tu crois que dans qu'un système de fichiers perd du temps à mettre à zéro les blocs de données libérés ? Si oui, regarde la page de manual de la commande <code>shred</code>, ça manque à ta culture.

Amine: Après avoir consulter le manual de la commande <code>shred</code>, je vois que cette commande écrit des données aléatoires sur l'emplacement du fichier sur le disque. Par défaut, <code>shred</code> effectue un certain nombre de passes (par exemple, 3 passes) pendant lesquelles il écrit des données aléatoires sur l'emplacement du fichier sur le disque. Après avoir écrit les données aléatoires, <code>shred</code> peut effectuer des passes supplémentaires pendant lesquelles il écrit des données nulles (des zéros) sur le même emplacement. L'objectif de <code>shred</code> est d'augmenter la sécurité en rendant plus difficile la récupération des données supprimées à l'aide d'outils de récupération de données.

Cependant, j'ai aussi consulté comment fonctionne la commande <code>rm</code> de linux, et je vois que cette commande libère l'espace occupé par le fichier en marquant les blocs associés comme disponibles. Cela signifie que les données peuvent encore être récupérées à l'aide d'outils de récupération de données, à moins que des mesures supplémentaires ne soient prises pour écraser physiquement l'espace avec des données aléatoires (c'est ce que fait l'utilitaire <code>shred</code>).

On va donc opter pour la deuxième option, c'est à dire qu'on ne va pas perdre notre temps à remettre à zéro les blocs de données libérés, on va simplement marquer les blocs correspondants comme étant disponibles. Cela nous permettra de nous émanciper de la fonction resetBlock et de n'avoir plus qu'un seul tableau de blocs.

ReX : Sinon lire un bloc complet de pointeurs de blocs de données en mémoire n'est pas forcément optimal. L'idéal serait de lire ces blocs morceau par morceau (de 64 octets par exemple). Certes un bloc serait traité en 4 lectures/écritures (ce qui ralentirait le traitement) mais on gagne en mémoire. Le mieux serait de mettre la taille des morceaux en constante pour pouvoir choisir entre vitesse d'exécution et utilisation mémoire.

Amine: d'accord je comprends. Je vais modifier la fonction pour qu'on puisse découper la lecture/écriture en plusieurs blocs.

=== Fonction RM version 4 ===
Modifications apportées:

* je ne réinitialise plus les blocs de données, je supprime simplement le pointeur du fichier vers les blocs de données et je désigne les blocs comme "disponible" dans le carte de disponibilités. J'ai donc supprimé la fonction resetBlock.

* je ne lis plus les blocs en une seule fois mais en plusieurs fois via la variable CHUNK_SIZE:

# J'ai introduit la constante <code>CHUNK_SIZE</code> pour définir la taille de chaque morceau que nous allons lire/écrire à la fois. Cela permet de découper les opérations en blocs plus petits.
# Dans la boucle <code>for</code> où on parcours les blocs à partir de <code>offset</code>, j'ai ajouté une boucle interne qui parcourt les données du bloc en morceaux de taille <code>CHUNK_SIZE</code>.
# À l'intérieur de la boucle interne, j'ai calculé la taille réelle du morceau (<code>chunkSize</code>) en prenant le minimum entre <code>CHUNK_SIZE</code> et la quantité de données restant à lire/écrire dans le bloc.
# J'ai modifié la fonction <code>readBlock</code> pour lire seulement la quantité de données spécifiée par <code>chunkSize</code> à partir de <code>chunkStart</code>. Ces données sont stockées dans le tableau <code>fileBuffer</code>.
# Ensuite, j'ai effectué les mêmes opérations de libération des blocs associés au fichier, en parcourant les données du morceau et en marquant les blocs comme disponibles.
# Finalement, j'ai utilisé la fonction <code>writeBlock</code> pour écrire le morceau de données modifié dans le bloc, en utilisant la même <code>chunkStart</code> pour déterminer où écrire les données.

#define CHUNK_SIZE 64

int min(int a, int b) {
return a < b ? a : b;
}

void RM(const char *filesystem_path, const char *filename) {
int fileFound = -1;
int offset;
unsigned char fileBuffer[BLOCK_SIZE];

// Parcourir les blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char *)filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {
// Effacer le nom du fichier dans le superbloc
memset(filenameBuffer, 0, MAX_FILENAME_LENGTH);
writeBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);
fileFound = 1;
offset = blockNum;
break;
}
}

// Fin de fonction si fichier inexistant
if (fileFound == -1) {
printf("Le fichier \"%s\" n'a pas été trouvé.\n", filename);
return;
}

for (int blockNum = offset; blockNum < offset + 16; blockNum++) {
int startOffset = 0;

if (blockNum == offset) {
startOffset = MAX_FILENAME_LENGTH;
}

for (int chunkStart = startOffset; chunkStart < BLOCK_SIZE; chunkStart += CHUNK_SIZE) {
int chunkSize = min(CHUNK_SIZE, BLOCK_SIZE - chunkStart);
readBlock(blockNum, chunkStart, fileBuffer, chunkSize);

for (int i = 0; i < chunkSize; i += 2) {
int blockNumData = (fileBuffer[i] << 8) | fileBuffer[i + 1];
if (blockNumData == 0) {
writeBlock(blockNum, chunkStart, fileBuffer, chunkSize);
printf("Le fichier \"%s\" a été supprimé avec succès.\n", filename);
return; // Sortir des boucles
}
setBlockAvailability(blockNumData, 0); // Marquer le bloc comme disponible
fileBuffer[i] = 0;
fileBuffer[i + 1] = 0;
}

writeBlock(blockNum, chunkStart, fileBuffer, chunkSize);
}
}

printf("Le fichier \"%s\" a été supprimé avec succès.\n", filename);
}

ReX : Si on trouve un n° de bloc de données à 0, il faut sortir des deux boucles les plus externes après avoir fait le <code>writeBlock</code>.

Amine: Modification faites ci-dessus. Maintenant, dès qu'on trouve un n° de bloc de données à 0 dans la boucle la plus interne, on effectue le <code>writeBlock</code> et ensuite on utilise <code>return</code> pour sortir des deux boucles les plus externes. Cela permet d'optimiser le code en évitant de continuer à traiter inutilement le reste des blocs.

ReX : Pas très propre (duplication de code) mais nous allons nous en contenter.

=== Fonction intermédiaire TYPE version 1 ===

J'ai également commencé à réfléchir à la fonction TYPE. Pour l'instant, elle ne fait qu'ajouter les noms de fichier dans le superbloc. Cela permet de pouvoir tester les fonctions LS et RM (voir dans la rubrique compilation et exécution comment utiliser le programme).
// Fonction pour créer un fichier avec le nom donné et le contenu fourni en entrée standard
void TYPE(const char *filesystem_path, const char *filename) {
unsigned char buffer[MAX_FILENAME_LENGTH];
// Parcours des blocs réservés pour la description des fichiers
for (int blockNum = 0; blockNum <= MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, MAX_FILENAME_LENGTH);
// Vérifier si le bloc est vide (pas de nom de fichier)
if (buffer[0] == 0) {
// Écrire le nom du fichier dans l'emplacement vide du superbloc
writeBlock(blockNum, 0, (const unsigned char *)filename, MAX_FILENAME_LENGTH);
break; // Fichier créé, sortir de la boucle
}
}
printf("Le fichier \"%s\" a été créé avec succès.\n", filename);
}

ReX : Si la boucle se termine sans trouver de slot libre le message de succès s'affiche tout de même.

ReX : Le paramètre <code>filename</code> n'a pas forcément une taille de <code>MAX_FILENAME_LENGTH</code>.

Selon moi, la fonction TYPE devra respecter 3 étapes:

# Enregistrement du Nom du Fichier: L'ajout du nom du fichier dans un des blocs de la première partie du superbloc.
# Stockage des Données du Fichier: La récupération des données saisies en entrée standard par l'utilisateur et leur stockage dans des blocs du système de fichiers à partir d'une certaine position, comme le bloc 1040.
# Mise à Jour de la Disponibilité des Blocs: L'indication que les blocs dans lesquels les données ont été écrites ne sont plus disponibles en modifiant les bits correspondants dans la deuxième partie du superbloc (les 16 derniers blocs du super bloc).

ReX : Relis le point 3 et dit moi si tu te comprends toi même ?

Amine: Ma phrase n'est effectivement pas très claire. Je voulais dire que la fonction TYPE devra mettre à jour la carte de disponibilité du superbloc. C'est à dire que lorsqu'elle écrira des données dans des blocs, elle devra indiquer dans la carte de disponibilités que ces blocs ne sont plus disponibles.

=== Fonction intermédiaire TYPE version 2 ===

Suite à vos remarques, j'ai apporté les modifications suivantes à la fonction TYPE:

* j'ai ajouté une condition pour l'affichage du message de succès de la création d'un fichier (placeFound).

* le paramètre <code>filename</code> n'ayant pas forcément une taille de <code>MAX_FILENAME_LENGTH</code>, je calcule maintenant la longueur de filename, afin d'écrire seulement le nom du fichier avec la fonction writeBlock.

Il fonction n'est bien évidemment pas fini, elle ajoute seulement le nom du fichier dans le superbloc pour l'instant. Cela me permet de tester les fonctions LS et RM.
void TYPE(const char *filesystem_path, const char *filename) {
size_t sizeFilename = strlen(filename);
printf("size filename=%d\n", sizeFilename);
unsigned char buffer[MAX_FILENAME_LENGTH];
int placeFound = 0;

if (sizeFilename > MAX_FILENAME_LENGTH) {
printf("Impossible de créer le fichier, nom trop long\n");
return;
}

// Parcours des blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, MAX_FILENAME_LENGTH);
// Vérifier si le bloc est vide (pas de nom de fichier)
if (buffer[0] == 0) {
// Écrire le nom du fichier dans l'emplacement vide du superbloc
if (sizeFilename < MAX_FILENAME_LENGTH) {
sizeFilename+=1;
}
writeBlock(blockNum, 0, (const unsigned char *)filename, sizeFilename);
placeFound = 1;
break; // Fichier créé, sortir de la boucle
}
}
if (placeFound == 1) {
printf("Le fichier \"%s\" a été créé avec succès.\n", filename);
} else {
printf("Plus de place dans le système de fichier pour créer ce fichier.\n", filename);
}
}

ReX : Mieux, attention il faut copier aussi le <code>\'0</code> final du nom, donc <code>sizeFilename+1</code>. Sinon tu n'es pas sûr qu'il y ait un zéro final. Et attention n°2, il ne faut pas copier ce <code>\'0</code> si le nom fait la taille maximale.

Amine: ok j'ai modifié la fonction TYPE ci-dessus. J'ai ajouté une condition: si le nom du fichier est inférieur à la taille maximale de nom de fichier, alors on incrémente de 1 la taille du nom de fichier. Cela nous permet d'écrire le '\0' dans le bloc de description. Dans le cas où le nom du fichier est de la taille maximale, nous n'avons pas besoin d'écrire le '\0', on n'incrémente donc pas la taille de 1.

J'ai également ajouté une condition: si le nom du fichier est supérieur à la taille maximale, alors un message d'erreur s'affiche et le fichier n'est pas créé.

ReX : OK. L'embryon de fonction <code>TYPE</code> est correct, il manque juste le principal : la création des blocs de données.

=== Fonction MV version 1 ===

J'ai ici créé la fonction MV qui permet de changer le nom d'un fichier. Pour ce faire, la fonction parcourt les blocs de descriptions à la recherche du fichier dont on veut changer le nom. Lorsque ce fichier est trouvé, on supprime l'ancien nom en mettant des 0 sur 16 octets, puis on vient réécrire le nouveau nom dans le même emplacement. Enfin, on sort de la boucle et on affiche le succès ou non de l'opération.
// Fonction qui modifie le nom du fichier
void MV(const char *filesystem_path, const char *old_filename, const char *new_filename) {
size_t sizeNew_filename = strlen(new_filename);
size_t sizeOld_filename = strlen(old_filename);
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
int fileFound = 0;
// Parcourir les blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);
// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char*)filenameBuffer, old_filename, MAX_FILENAME_LENGTH) == 0) {
// Effacer le nom du fichier dans le superbloc
memset(filenameBuffer, 0, MAX_FILENAME_LENGTH);
writeBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);
// Écrire le nom du fichier dans l'emplacement
writeBlock(blockNum, 0, (const unsigned char *)new_filename, sizeNew_filename);
fileFound=1;
break; // Nom modifié, sortir de la boucle
}
}
if (fileFound == 1) {
printf("Le nom du fichier \"%s\" a été renommé avec succès.\n", old_filename);
} else {
printf("Le fichier \"%s\" n'a pas été trouvé.\n", old_filename);
}
}

ReX : Inutile d'écraser l'ancien nom avec des zéros. Il suffit de copier le nouveau en s'assurant qu'il y ait un zéro final sauf si le nouveau nom fait la taille maximale.

Amine: ok, je vais faire les modifications dans la version 2.

== Semaine 6 ==

=== Fonction MV version 2 ===
Dans cette nouvelle version de la fonction MV, j'ai effectué les modifications suivantes:

* je n'écrase plus l'ancien nom avec des 0
* Je colle simplement le nouveau nom par dessus l'ancien, en m'assurant qu'il y ait bien le '\0' à la fin lorsque la taille du nom du fichier est inférieur à la taille maximale. Comme précédemment, afin de m'assurer de la présence de ce '\0' à la fin du nom, j'incrémente la taille de 1 lorsque qu'elle est inférieur à la taille max. Cependant, je ne suis pas sûr à 100% que ce soit la bonne manière de faire.

// Fonction qui modifie le nom du fichier
void MV(const char *filesystem_path, const char *old_filename, const char *new_filename) {
size_t sizeNew_filename = strlen(new_filename);
size_t sizeOld_filename = strlen(old_filename);
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
int fileFound = 0;

// Parcourir les blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {

readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char*)filenameBuffer, old_filename, MAX_FILENAME_LENGTH) == 0) {

if (sizeNew_filename < MAX_FILENAME_LENGTH) {
sizeNew_filename+=1;
}

// Écrire le nom du fichier dans l'emplacement
writeBlock(blockNum, 0, (const unsigned char *)new_filename, sizeNew_filename);

fileFound=1;

break; // Nom modifié, sortir de la boucle
}
}
if (fileFound == 1) {
printf("Le nom du fichier \"%s\" a été renommé avec succès.\n", old_filename);
} else {
printf("Le fichier \"%s\" n'a pas été trouvé.\n", old_filename);
}
}

ReX : C'est bon. La fonction était triviale.

=== Fonction TYPE version 1 ===
void TYPE(const char *filesystem_path, const char *filename) {
size_t sizeFilename = strlen(filename);
unsigned char buffer[MAX_FILENAME_LENGTH];
int placeFound = -1;

if (sizeFilename > MAX_FILENAME_LENGTH) {
printf("Impossible de créer le fichier, nom trop long\n");
return;
}

// Parcours des blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, MAX_FILENAME_LENGTH);
// Vérifier si le bloc est vide (pas de nom de fichier)
if (buffer[0] == 0) {
// Écrire le nom du fichier dans l'emplacement vide du superbloc
if (sizeFilename < MAX_FILENAME_LENGTH) {
sizeFilename += 1; // Ajouter '\0' s'il y a de la place
}
writeBlock(blockNum, 0, (const unsigned char *)filename, sizeFilename);
placeFound = blockNum;

// Lire les données depuis l'entrée standard
unsigned char dataBuffer[BLOCK_SIZE];
size_t bytesRead;
int dataBlockNum = findAvailableBlock(); // Premier bloc de données à partir du bloc 1040
printf("dataBlockNum%d\n",dataBlockNum);
int blockSizeUsed = 0; // Compteur d'octets dans le bloc actuel
int dataBlocksNeeded = 1; // Nombre de blocs de données nécessaires

while ((bytesRead = fread(dataBuffer + blockSizeUsed, 1, BLOCK_SIZE - blockSizeUsed, stdin)) > 0) {
blockSizeUsed += bytesRead;

// Si le bloc actuel est plein, passer au bloc suivant
if (blockSizeUsed == BLOCK_SIZE) {
// printf("dataBlockNum=%d\n",dataBlockNum);
writeBlock(dataBlockNum, 0, dataBuffer, BLOCK_SIZE);
setBlockAvailability(dataBlockNum, 1);

dataBlockNum++; // Passer au bloc suivant
blockSizeUsed = 0; // Réinitialiser la taille utilisée
dataBlocksNeeded++;
}
}

// Écrire le dernier bloc partiel, s'il y en a un
if (blockSizeUsed > 0) {
writeBlock(dataBlockNum, 0, dataBuffer, blockSizeUsed);
setBlockAvailability(dataBlockNum, 1);
}

// Écrire les numéros de blocs utilisés dans le bloc de description
unsigned char blockNumberBuffer[2];
int currentBlockNum = 1040;

for (int i = 0; i < dataBlocksNeeded; i++) {
blockNumberBuffer[0] = (currentBlockNum >> 8) & 0xFF;
blockNumberBuffer[1] = currentBlockNum & 0xFF;
writeBlock(placeFound, MAX_FILENAME_LENGTH + i * 2, blockNumberBuffer, 2);
currentBlockNum++;
}

break; // Fichier créé, sortir de la boucle
}
}

if (placeFound != -1) {
printf("Le fichier \"%s\" a été créé avec succès.\n", filename);
} else {
printf("Plus de place dans le système de fichier pour créer ce fichier.\n");
}
}

ReX : La constante 1040 ne doit pas apparaître en numérique, ce doit être une constante calculée à partir des autres constantes.

Amine: Ok. Je ne l'avais pas défini comme une constante car il s'agit dans la fonction ci-dessus d'une variable qui est incrémenté à chaque itération.

ReX : Je suis las de te répéter que le mémoire est comptée : tu utilises encore un bloc de <code>BLOCK_SIZE</code> octets, c'est trop.

Amine: Comment utiliser des blocs plus petit sachant qu'il s'agit là de blocs de données et qu'un bloc fait 256 octets d'après l'énoncé ? Dois-je les subdiviser en plusieurs blocs plus petit comme fait dans la fonction RM, en 4 blocs de 64 octets par exemple ?

Fonctionnement de la fonction TYPE:

* étape 1: on parcourt les blocs de descriptions à la recherche d'un bloc disponible. Si on ne trouve pas de bloc disponible, on renvoie un message d'erreur, sinon on passe à l'étape suivante.
* étape 2: Si on trouve un emplacement libre dans les blocs de disponibilité, on écrit le nom du fichier dans cet emplacement.

ReX : Dans les blocs de description de fichiers pas dans les blocs de disponibilité.

Amine: Oui autant pour moi.

* étape 3: Ensuite, on lit le texte entré par l'utilisateur en entrée standard, on le répartit dans des blocs de taille BLOCK_SIZE, on met à jour la disponibilité des blocs utilisés.

ReX : Non, il faut appeler <code>findAvailableBlock</code> pour chaque bloc de données à utiliser, aucune certitudes que les blocs libres soient en séquence.

Amine: ok, je ferai cela dans la version 2

* étape 4: Enfin, on écrit les numéros des blocs de données utilisés dans les blocs de description de ce fichier, les numéros étant écris sur deux octets.

ReX : Non cela doit se faire au fur et à mesure des appels à <code>findAvailableBlock</code> et les numéros des blocs de données peuvent s'étaler sur les 16 blocs de description du fichier. Confusion totale sur ce point. Vous n'avez pas compris le mécanisme.

Amine: je corrige cela dans la version 2. J'ai bien compris le mécanisme mais ce n'est pas facile à traduire en code.

=== Fonction TYPE version 2 ===
Dans cette nouvelle version de TYPE, j'ai fait les modifications suivantes:

* j'appelle maintenant <code>findAvailableBlock</code> pour chaque bloc de données à utiliser
* j'écris maintenant les numéros de blocs au fur et à mesures des appels à <code>findAvailableBlock</code>
* je n'utilise plus de tableaux de taille 256 octets mais des tableaux de tailles CHUNK_SIZE. J'ai choisi ici CHUNK_SIZE = 64 octets.

J'utilise toujours un bloc de taille BLOCK_SIZE en attendant de comprendre si je dois diviser ce bloc en plusieurs blocs de taille plus petite ou s'il y a un moyen de ne pas du tout utiliser ces blocs.
void TYPE(const char *filesystem_path, const char *filename) {
size_t sizeFilename = strlen(filename);
unsigned char buffer[MAX_FILENAME_LENGTH];
int placeFound = -1;

if (sizeFilename > MAX_FILENAME_LENGTH) {
printf("Impossible de créer le fichier, nom trop long\n");
return;
}

// Parcours des blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, MAX_FILENAME_LENGTH);
// Vérifier si le bloc est vide (pas de nom de fichier)
if (buffer[0] == 0) {
// Écrire le nom du fichier dans l'emplacement vide du superbloc
if (sizeFilename < MAX_FILENAME_LENGTH) {
sizeFilename += 1; // Ajouter '\0' s'il y a de la place
}
writeBlock(blockNum, 0, (const unsigned char *)filename, sizeFilename);
placeFound = blockNum;

// Lire les données depuis l'entrée standard et écrire dans le fichier
int dataBlockNum = findAvailableBlock(); // Premier bloc de données à partir du bloc 1040
printf("Premier bloc dans lequel on écrit = %d\n", dataBlockNum);
int blockSizeUsed = 0; // Compteur d'octets dans le bloc actuel

unsigned char chunkBuffer[CHUNK_SIZE];
size_t bytesRead;

while ((bytesRead = fread(chunkBuffer, 1, CHUNK_SIZE, stdin)) > 0) {
// Écrire le chunk dans le bloc de données
writeBlock(dataBlockNum, blockSizeUsed, chunkBuffer, bytesRead);
setBlockAvailability(dataBlockNum, 1);

// Écrire le numéro du bloc actuel dans la description du fichier
unsigned char blockNumberBuffer[2];
blockNumberBuffer[0] = (dataBlockNum >> 8) & 0xFF;
blockNumberBuffer[1] = dataBlockNum & 0xFF;
writeBlock(placeFound, MAX_FILENAME_LENGTH + dataBlockNum * 2, blockNumberBuffer, 2);

blockSizeUsed += bytesRead;

// Si le bloc actuel est plein, passer au bloc suivant
if (blockSizeUsed == BLOCK_SIZE) {
dataBlockNum = findAvailableBlock(); // Passer au bloc suivant
blockSizeUsed = 0; // Réinitialiser la taille utilisée
}
}

break; // Fichier créé, sortir de la boucle
}
}

if (placeFound != -1) {
printf("Le fichier \"%s\" a été créé avec succès.\n", filename);
} else {
printf("Plus de place dans le système de fichier pour créer ce fichier.\n");
}
}

=== Fonction findAvailableBlock ===
Cette fonction renvoie l'indice du premier bloc disponible. Je me sers de cette fonction dans la fonction TYPE.
#define FIRST_DATA_BLOCK 1040
#define FIRST_DISPONIBILITY_CARD_BLOCK 1024

// Renvoie le premier bloc de donné disponible
int findAvailableBlock() {
unsigned char availabilityBuffer[BLOCK_SIZE];
int offset;

// Lire la carte de disponibilité (à partir du bloc 1)
for (int blockNum = FIRST_DISPONIBILITY_CARD_BLOCK; blockNum < FIRST_DATA_BLOCK; blockNum++) {
readBlock(blockNum, 0, availabilityBuffer, BLOCK_SIZE);

if (blockNum==FIRST_DISPONIBILITY_CARD_BLOCK) {
offset=FIRST_DATA_BLOCK/8;
} else {
offset=0;
}

// Parcourir les octets de la carte de disponibilité
for (int byteIndex = offset; byteIndex < BLOCK_SIZE - offset; byteIndex++) {
unsigned char byte = availabilityBuffer[byteIndex];

// Parcourir les bits de chaque octet
for (int bitIndex = 0; bitIndex < 8; bitIndex++) {
// Vérifier si le bit est à 0 (bloc disponible)
if ((byte & (1 << bitIndex)) == 0) {
// Calculer l'indice du bloc en fonction du bloc et du bit
int blockIndex = byteIndex * 8 + bitIndex;
return blockIndex;
}
}
}
}

// Aucun bloc disponible trouvé
return -1;
}

ReX : Même remarque que précédement sur les nombres 1024 et 1040.

Amine: Ok, j'ai remplacé 1024 par la constante FIRST_DISPONIBILITY_CARD_BLOCK et 1040 par la constante FIRST_DATA_BLOCK dans la fonction ci-dessus.

ReX : Vous n'avez toujours pas compris la contrainte sur la mémoire.

Amine: dois-je découper le bloc de taille BLOCK_SIZE en quatre blocs de taille 64 octets par exemple ?

ReX : Je ne vois pas ce que vous voulez faire avec <code>if (blockNum==1024) offset=1040/8; else offset=0;</code>.

Amine: dans la carte de disponibilité, chaque bit correspond à un bloc. Ainsi, les bits de 0 à 1040 dans la carte de disponibilité décrivent la disponibilité des blocs 0 à 1040. Or ces blocs correspondent au superbloc, et dans cette fonction, on veut connaître le premier bloc de données disponible. On ne s'intéresse donc pas au 1040 premiers bits de la carte de disponibilité. Je crée donc un offset égal à 1040/8 afin de ne pas prendre en compte les 1040 premiers bits soit les 1040/8=130 premiers octets. Cet offset ne s'applique que lorsqu'on se trouve dans le premier des 16 blocs de la carte de disponibilité, d'où la condition <code>if (blockNum==1024)</code>.

=== Fonction CAT version 1 ===
void CAT(const char *filesystem_path, const char *filename) {
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
unsigned char buffer[BLOCK_SIZE];
unsigned char blockNumberBuffer[2];
unsigned char dataBuffer[BLOCK_SIZE];
int offset;

// Parcours des blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char *)filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {
// Le nom du fichier a été trouvé

// Parcours les blocs de description
for (int descrBlockNum=0; descrBlockNum<MAX_BLOCKS_PER_FILE_DESCRIPTION; descrBlockNum++) {
if (descrBlockNum==0) {
offset=16;
} else {
offset=0;
}
readBlock(descrBlockNum+blockNum, offset, buffer, BLOCK_SIZE-offset);

// Lire les numéros de blocs associés à ce fichier depuis les blocs de description
unsigned char octet1 = buffer[offset];
unsigned char octet2 = buffer[offset+1];

int dataBlockNum = (octet1 << 8) | octet2;
printf("dataBlockNum=%d\n",dataBlockNum);

// Vérifier si le numéro de bloc est valide (non nul)
if (dataBlockNum == 0) {
return; // Fin du fichier
}

// Lire et afficher le contenu du bloc de données
readBlock(dataBlockNum, 0, dataBuffer, BLOCK_SIZE);
fwrite(dataBuffer, 1, BLOCK_SIZE, stdout);
}

return; // Fichier affiché, sortie de la fonction
}
}

// Si le fichier n'a pas été trouvé
printf("Le fichier \"%s\" n'a pas été trouvé.\n", filename);
}

ReX : Encore mieux : deux blocs de <code>BLOCK_SIZE</code> en mémoire.

ReX : Le <code>break</code> ne sort pas de la boucle externe.

Amine: Oui c'est vrai. J'ai remplacé le break pas un return ci-dessus.

Voici ma fonction <code>CAT</code>. Elle fonctionne en plusieurs étape:

* étape 1: on cherche dans les blocs de descriptions si le fichier dont on veut afficher le contenu existe. Si le nom de fichier est trouvé, on passe à l'étape 2. Sinon, on renvoie un message d'erreur.
* étape 2: si le fichier est trouvé, on parcours les 16 blocs de description de ce fichier.
* étape 3: grâce aux opérations de masquage et de décalage, on joint les octets deux par deux pour former un entier qui contient le numéro du bloc de données correspondant au fichier. Si cet entier vaut 0, alors cela signifie qu'il n'y a plus de blocs associé à ce fichier, on peut donc quitter la fonction. Si cet entier est différent de 0, alors on va lire le bloc correspondant à ce numéro et on affiche son contenu dans le terminal.

== Semaine 7 ==

=== Fonction CP version 1 ===
Voici ma fonction CP, qui permet de créer une copie d'un fichier existant. L'idée est la suivante: pour copier un fichier, on doit créer un nouveau fichier et lui attribuer les mêmes blocs de descriptions que le fichier source. Ainsi, le fichier source et le fichier destination pointeront vers les mêmes blocs de données, et auront le même contenu.

ReX : Perdu. Ce n'est absolument pas la fonction de copie de fichiers d'un système de fichiers.

Amine: Après avoir fait des recherches et après réflexion, je me rends compte que cette fonction CP présente un problème: en faisant pointé les blocs de données du fichier destination vers ceux du fichier source, toutes modifications du fichier source impactera le fichier destination, or ce n'est pas ce qu'on veut faire. Je vous propose donc une nouvelle version de la fonction CP ci-dessous qui remédie à ce problème.

void CP(const char *filesystem_path, const char *source_filename, const char *destination_filename) {
unsigned char source_filenameBuffer[MAX_FILENAME_LENGTH];
unsigned char destination_filenameBuffer[MAX_FILENAME_LENGTH];
unsigned char descriptionBuffer[BLOCK_SIZE];
int destination_offset;
int offset;

// Recherche du fichier source
int source_offset = -1;
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, source_filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier source
if (strncmp((const char *)source_filenameBuffer, source_filename, MAX_FILENAME_LENGTH) == 0) {
source_offset = blockNum;
break;
}
}

if (source_offset == -1) {
printf("Le fichier source \"%s\" n'a pas été trouvé.\n", source_filename);
return;
}

// Recherche d'un emplacement libre pour le fichier destination
destination_offset = -1;
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, destination_filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc est vide (pas de nom de fichier)
if (destination_filenameBuffer[0] == 0) {
destination_offset = blockNum;
break;
}
}

if (destination_offset == -1) {
printf("Plus de place dans le système de fichier pour créer la copie de \"%s\".\n", source_filename);
return;
}

// Ecrit le nom de la copie dans le bloc de description
writeBlock(destination_offset, 0, (const unsigned char *)destination_filename, strlen(destination_filename));

// Copier les blocs de description associés au fichier source dans les blocs de description du fichier destination
for (int i = 0; i < MAX_BLOCKS_PER_FILE_DESCRIPTION; i++) {
if (i==0) {
offset = MAX_FILENAME_LENGTH;
} else {
offset = 0;
}

readBlock(source_offset+i, offset, descriptionBuffer, BLOCK_SIZE-offset);
if (descriptionBuffer[offset]==0) {
return;
} else {
writeBlock(destination_offset+i, offset, descriptionBuffer, BLOCK_SIZE-offset);
}
}

printf("La copie de \"%s\" sous le nom \"%s\" a été créée avec succès.\n", source_filename, destination_filename);
}

== Semaine 8 ==
A ce stade du projet, les fonctions suivantes ont été validé par Monsieur Redon:

* fonction LS
* fonction RM
* fonction MV

Il reste donc les fonctions suivantes à terminer:

* fonction CAT
* fonction CP
* fonction TYPE

=== Fonction CAT version 2 ===
Suite à vos remarques sur la version 1, j'ai fais les modifications suivantes:

* je n'utilise non plus 2 tableaux de taille BLOCK_SIZE, mais 1 seul. Idéalement il faudrait en utiliser 0, je réfléchi donc à m’émanciper de ce tableau en le remplaçant par plusieurs plus petits tableaux.
* J'ai remplacé le <code>break</code> par un return

Cette fonction permet d'afficher le contenu d'un fichier créé avec la fonction TYPE. Pour se faire, on parcours tout d'abord les blocs de descriptions pour trouver le fichier dont ont veut afficher le contenu. Une fois ce fichier trouvé, on parcours les 16 blocs de description de ce fichier 1 à 1. Pour chacun de ces blocs de description, on va stocker récupéré les octets deux par deux afin de former des entiers. Pour se faire, on utilise la fonction <code>reconsituteNumber</code> que l'on détaillera juste après. Ces entiers correspondent aux blocs dans lesquels la donné du fichier se trouve. Une fois l'entier reconstitué, on affiche le contenu du bloc correspondant.
void CAT(const char *filesystem_path, const char *filename) {
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
unsigned char byteBuffer[2];
unsigned char dataBuffer[BLOCK_SIZE];
int offset;

// Parcours des blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char *)filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {
// Le nom du fichier a été trouvé

// Parcours les blocs de description
for (int descrBlockNum=0; descrBlockNum<MAX_BLOCKS_PER_FILE_DESCRIPTION; descrBlockNum++) {
if (descrBlockNum==0) {
offset=MAX_FILENAME_LENGTH;
} else {
offset=0;
}

// Lecture des octets deux par deux
for (int i=0; i<BLOCK_SIZE;i+=2) {
readBlock(descrBlockNum+blockNum, offset+i, byteBuffer, 2);

// Lire les numéros de blocs associés à ce fichier depuis les blocs de description
int dataBlockNum = reconsituteNumber(byteBuffer);

// Vérifier si le numéro de bloc est valide (non nul)
if (dataBlockNum == 0) {
return; // Fin du fichier
}

// Lire et afficher le contenu du bloc de données
readBlock(dataBlockNum, 0, dataBuffer, BLOCK_SIZE);
fwrite(dataBuffer, 1, BLOCK_SIZE, stdout);
}
}

return; // Fichier affiché, sortie de la fonction
}
}

// Si le fichier n'a pas été trouvé
printf("Le fichier \"%s\" n'a pas été trouvé.\n", filename);
}

=== Fonction reconsituteNumber ===
Cette fonction permet de reconstituer un numéro de bloc à partir de deux octets.
// Fonction qui reconstitue le numéro de bloc à partir du tableau
int reconsituteNumber(unsigned char blockNumberBuffer[2]) {
unsigned char octet1 = blockNumberBuffer[0];
unsigned char octet2 = blockNumberBuffer[1];
int dataBlockNum = (octet1 << 8) | octet2;
return dataBlockNum;
}

=== Fonction CP version 2 ===
Voici une version mise à jour de notre fonction CP. Dans la version précédente, on faisait pointer le fichier source vers les même blocs que le fichier destination. Cela posait un problème: toute modification du fichier source impactait le fichier destination. Ainsi, dans cette nouvelle version, on fait une duplication des blocs de données du fichier source vers le fichier destination. Cela implique donc une mise à jour de la carte de disponibilité, ainsi que l'adaptation des blocs de descriptions. En effet, seulement les blocs de données sont maintenant identiques, plus les blocs de description.

Piste d'amélioration: comme pour la fonction CAT ci-dessus, j'utilise toujours un bloc de taille 256 octets, je vais devoir y remédier.
void CP(const char *filesystem_path, const char *source_filename, const char *destination_filename) {
unsigned char source_filenameBuffer[MAX_FILENAME_LENGTH];
unsigned char destination_filenameBuffer[MAX_FILENAME_LENGTH];
unsigned char descriptionBuffer[BLOCK_SIZE];
unsigned char numBuffer[2];
int destination_offset;
int source_offset;
int offset;
int numDataBlock;

// Recherche du fichier source
source_offset = -1;
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, source_filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier source
if (strncmp((const char *)source_filenameBuffer, source_filename, MAX_FILENAME_LENGTH) == 0) {
source_offset = blockNum;
break;
}
}

if (source_offset == -1) {
printf("Le fichier source \"%s\" n'a pas été trouvé.\n", source_filename);
return;
}

// Recherche d'un emplacement libre pour le fichier destination
destination_offset = -1;
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, destination_filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc est vide (pas de nom de fichier)
if (destination_filenameBuffer[0] == 0) {
destination_offset = blockNum;
break;
}
}

if (destination_offset == -1) {
printf("Plus de place dans le système de fichier pour créer la copie de \"%s\".\n", source_filename);
return;
}

// Copie du nom de la copie dans le bloc de description
writeBlock(destination_offset, 0, (const unsigned char *)destination_filename, strlen(destination_filename));

// Copier les blocs de données associés au fichier source dans de nouveaux blocs de données pour le fichier destination
for (int i = 0; i < MAX_BLOCKS_PER_FILE_DESCRIPTION; i++) {
if (i == 0) { offset = MAX_FILENAME_LENGTH; }
else { offset = 0; }

// Lecture des numéros de bloc dans les blocs de description
for (int byteNum=0; byteNum<BLOCK_SIZE; byteNum+=2) {
readBlock(source_offset + i, offset + byteNum, numBuffer, 2);

numDataBlock = reconsituteNumber(numBuffer);
if (numDataBlock == 0) {
return;
}

// On stocke le bloc de données associé au fichier source dans descriptionBuffer
readBlock(numDataBlock, 0, descriptionBuffer, BLOCK_SIZE);

// Trouver un nouveau bloc de données disponible
int newDataBlock = findAvailableBlock();

// Ecriture du bloc de données dans le premier bloc disponible
writeBlock(newDataBlock, 0, descriptionBuffer, BLOCK_SIZE);

// Mise à jour de la carte de disponibilités
setBlockAvailability(newDataBlock, 1);

// Ecriture du numéro de bloc dans la description du fichier
numBuffer[0] = (newDataBlock >> 8) & 0xFF;
numBuffer[1] = newDataBlock & 0xFF;
writeBlock(destination_offset+i, offset+byteNum, numBuffer, 2);
}
}

printf("La copie de \"%s\" sous le nom \"%s\" a été créée avec succès.\n", source_filename, destination_filename);
}

=== Fonction TYPE version 3 ===
La fonction 2 que j'ai fourni ci-dessus n'est pas correcte. Je vais la corrigé dans cette version 3

= Compilation et exécution =
'''Création du système de fichiers :'''
dd if=/dev/zero of=filesystem.bin bs=256 count=32768

'''Compilation :'''

gcc picofs.c -o picofs

'''Exécution de LS, TYPE, CAT, RM, MV ou CP :'''

./picofs filesystem.bin LS
./picofs filesystem.bin TYPE mon_fichier.txt
./picofs filesystem.bin CAT mon_fichier.txt
./picofs filesystem.bin RM mon_fichier.txt
./picofs filesystem.bin MV mon_fichier.txt mon_fichier2.txt
./picofs filesystem.bin CP mon_fichier.txt mon_fichier2.txt

= Documents Rendus =
[[Fichier:Picofilesystemv2.c.tar|vignette]]

Fichier:Picofilesystemv2.c.tar

2023-09-02T16:21:59Z

Asellali :

pico file system

SE4 2022/2023 EC1

2023-09-02T16:20:35Z

Asellali : /* Fonction CP version 2 */

= Objectifs =

Il vous est demandé de :
* réaliser un micro système de fichiers ;
* le système de fichiers doit résider dans un fichier de 8 Mo ;
* le système de fichiers est géré par un exécutable obtenu à partir d'un programme C ;
* L'éxécutable prend deux arguments, le premier est le chemin du fichier dans lequel réside le système de fichiers, les paramètres suivants concernent l'action à appliquer sur le système de fichiers ;
* le micro système de fichier ne comporte qu'un répertoire : le répertoire principal, le répertoire principal peut comporter au maximum 64 fichiers, un fichier est caractérisé par un nom de 16 caractères au maximum et ses blocs de données, un fichier peut comporter au maximum 2040 blocs de données ;
* un bloc de données fait 256 octets et les blocs sont numérotés sur 2 octets ;
* les différentes actions possibles sur le système de fichiers sont :
** <code>TYPE</code> pour créer un fichier si possible, le nom du fichier suit la commande, le contenu du fichier est donné en entrée standard de l'exécutable ;
** <code>CAT</code> pour afficher un fichier, le nom du fichier suit la commande ;
** <code>RM</code> pour détruire un fichier, le nom du fichier suit la commande ;
** <code>MV</code> pour renommer un fichier, les noms original et nouveau du fichier suivent la commande ;
** <code>CP</code> pour copier un fichier, les noms de l'original et de la copie du fichier suivent la commande ;

= Matériel nécessaire =

Un PC sous Linux.

= Travail réalisé =

== Semaine 1 ==

ReX : attention, ce micro-système de fichiers est prévu pour un microcontrôleur, vos variables globales ne peuvent pas dépasser quelques centaines d'octets.

ReX : pour la création du système de fichiers la commande <code>dd</code> suffit, vous voulez dire le formatage du système de fichiers ?

* création du programme programme.c contenant les différentes structures et les différentes fonctions.
* Piste d'amélioration: faire en sorte que la fonction CAT affiche le contenu exact des fichiers passés en argument.

Le code fourni est un programme en langage C qui simule un système de fichiers basique. Ce programme permet aux utilisateurs d'effectuer diverses actions telles que créer, afficher, supprimer, renommer et copier des fichiers dans un système de fichiers simulé. Le système de fichiers est stocké dans un fichier binaire.

ReX : vous n'avez pas tenu compte de la première remarque, vous chargez tout le superbloc et le répertoire racine, votre code ne convient pas.

ReX : vos structures utilisent des types entiers dont la taille n'est pas explicitée, utilisez les types de <code>stdint.h</code>.

ReX : la création de fichier n'est pas fonctionnelle, vous ne cherchez pas les blocs libres, vous ne copiez pas le contenu du fichier dans les blocs, même remarque pour toutes les autres fonctions.

ReX : il manque les fonctions d'accès aux pages du système de fichiers.

'''Explication du programme programme.c'''

Voici une brève explication des principaux éléments et fonctions du code :

# Structures :
#* Fichier : Représente un fichier dans le système de fichiers. Il contient un nom (nom) avec une longueur maximale de 16 caractères, un tableau de numéros de bloc (blocs) où le contenu du fichier est stocké (jusqu'à 2040 blocs), et le nombre de blocs utilisés par le fichier (nbBlocs).
#* Repertoire : Représente le répertoire principal du système de fichiers. Il contient un tableau de fichiers (<code>fichiers</code>) et le nombre de fichiers dans le répertoire (<code>nbFichiers</code>).
# Fonctions :
#* <code>chargerSystemeFichiers</code> : Charge le système de fichiers à partir d'un fichier binaire donné (chemin) dans une structure Repertoire.
#* <code>sauvegarderSystemeFichiers</code> : Sauvegarde le système de fichiers stocké dans la structure Repertoire dans un fichier binaire (chemin).
#* <code>creerFichier</code> : Crée un nouveau fichier dans le système de fichiers avec un nom et un contenu donnés. Le contenu du fichier est simulé en le divisant en blocs.
#* <code>afficherFichier</code> : Affiche le contenu d'un fichier avec le nom spécifié.
#* <code>detruireFichier</code> : Supprime un fichier avec le nom spécifié du système de fichiers.
#* <code>renommerFichier</code> : Renomme un fichier avec l'ancien nom spécifié en un nouveau nom.
#* <code>copierFichier</code> : Copie un fichier avec le nom spécifié en créant un nouveau fichier avec le nom de copie spécifié.
# Fonction <code>main</code> :
#* La fonction <code>main</code> est le point d'entrée du programme.
#* Elle prend des arguments en ligne de commande : <code><chemin_systeme_fichiers></code> et <code><action></code>.
#* <code><chemin_systeme_fichiers></code> est le chemin vers le fichier binaire où le système de fichiers est stocké.
#* <code><action></code> détermine quelle opération effectuer, comme <code>TYPE</code>, <code>CAT</code>, <code>RM</code>, <code>MV</code> ou <code>CP</code>.
#* En fonction de l'action spécifiée, le programme appelle la fonction correspondante pour effectuer l'opération souhaitée sur le système de fichiers.
Remarque : Le code fourni une simulation basique d'un système de fichiers et de ses opérations, mais il n'interagit pas réellement avec un système de fichiers réel sur le disque.

'''Comment utiliser le programme programme.c'''

étape 1: création du système de fichiers respectant le cahier des charges:

dd if=/dev/zero of=systeme_fichiers.bin bs=1M count=8

étape 2: compilation du programme C:

gcc programme.c -o gestionnaire_fs

étape 3: création d'un fichier dans le système de fichier:

./gestionnaire_fs systeme_fichiers.bin TYPE fichier1.txt

-> entrer le texte en entrée standard

étape 4: manipulation des différentes fonctions. Exemples:

./gestionnaire_fs systeme_fichiers.bin CAT fichier1.txt
./gestionnaire_fs systeme_fichiers.bin CP fichier1.txt copie.txt
./gestionnaire_fs systeme_fichiers.bin RM copie.txt
./gestionnaire_fs systeme_fichiers.bin MV fichier1.txt fichier2.txt

== Semaine 2 ==

Amine: Merci pour vos remarques. Désolé de ne pas avoir suivi votre première remarque, je pensais avoir compris ce qu'il fallait faire mais je me rend compte que non. Je vais tout reprendre depuis le début afin de repartir sur de bonnes bases.

'''Création du système de fichier avec la commande "dd"'''

A quoi sert la commande dd?

La commande <code>dd</code> permet de copier tout ou partie d'un disque par blocs d'octets, indépendamment de la structure du contenu du disque en fichiers et en répertoires (source : [https://doc.ubuntu-fr.org/dd]).

Structure de la commande

dd if=<nowiki><source> of=<cible> bs=<taille des blocs></nowiki>

<code>source</code> = données à copier

<code>cible</code> = endroit où les copier

<code>if</code> = input file

<code>of</code> = output file

<code>bs</code> = block size, habituellement une puissance de 2 supérieure ou égale à 512, représentant un nombre d'octets

Choix de la commande:

Pour la source, on prends <code>/dev/zero</code>: cela permet de créer un fichier rempli de 0. Ce fichier servira de base pour notre système de fichiers.

Pour la cible, on va l'appeler <code>filesystem.bin</Code> : ce sera notre système de fichier.

Pour la taille des blocs, on veut des blocs de données de 256 octets d'après l'enoncé. On va donc prendre <code>bs=256</code>.

Enfin, on veut que le système de fichier réside dans un fichier de 8 Mo. On va donc ajouter <code>count=31250</code>: cela indique que nous voulons écrire 32768 blocs de données dans le fichier (31250 * 256 octets = 8 Mo).

Résultat:

dd if=/dev/zero of=filesystem.bin bs=256 count=31250

Question pour M. Redon : j'ai ici essayé de respecter votre remarque "pour la création du système de fichiers la commande <code>dd</code> suffit". Cependant, pour votre seconde remarque "vous chargez tout le superbloc et le répertoire racine, votre code ne convient pas.", je ne suis pas sûr de comprendre où je fais cela: est-ce lors de la commande dd ou est-ce par la suite avec mon programme C? J'ai un peu modifié la commande dd comme vous pouvez le voir ci-dessus. Ai-je corrigé mon erreur avec cette nouvelle commande? J'ai essayé de justifier au maximum la commande dd que j'ai choisie.

ReX : Pas de problème avec la commande <code>dd</code> (mettez tous les extraits de code entre des balises <code>code</code>). Le problème est au niveau du programme C.

Amine: Ok je comprends mieux merci. Je vais donc reprendre le code étape par étape afin de mieux répondre au cahier des charges.

Gestion du système de fichier par un programme C

'''Création des structures'''
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>

// Structure pour représenter un bloc de données

struct DataBlock {
uint8_t data[256]; // 256 octets pour chaque bloc de données
};

// Structure pour représenter un fichier

struct File {
char filename[17]; // 16 caractères pour le nom du fichier + 1 caractère null-terminator
struct DataBlock data_blocks[2040]; // Tableau de blocs de données pour stocker le contenu du fichier
uint16_t num_data_blocks; // Nombre de blocs de données utilisés par le fichier
};

// Structure pour représenter un répertoire

struct Directory {
struct File files[64]; // Tableau de fichiers pour le répertoire principal
uint8_t num_files; // Nombre de fichiers dans le répertoire principal
};

Modification faite : suite à votre remarque, j'ai explicité la taille des entiers grâce aux types de <code>stdint.h.</code> (j'ai également mis les variables en anglais)

ReX : Vous ne pouvez pas utiliser ces structures, une instanciation d'une de ces structure prend trop d'espace mémoire, vous devez faire sans structure. Par ailleurs la façon dont vous représentez vos fichiers ne convient pas, la description d'un fichier contient des numéros de blocs, pas les blocs eux-même. Faites aussi attention qu'un fichier soit décrit par un nombre entier de blocs.

Question pratique: je n'arrive pas à mettre tout le code dans le même bloc comme vous l'avez fait ci-dessus dans l'étape 4 de la semaine 1. Je vois que c'est en format "préformaté" mais j'obtiens des blocs séparés lorsque j'applique ce format à mon code.

ReX : j'ai corrigé, pour un code entier la syntaxe n'est pas la même (un espace en début de chaque ligne), la balise c'est uniquement pour de très courts extraits de code.

=== Fonction <code>readBlock</code>===
Cette fonction est utilisée pour lire un bloc de données à partir du fichier <code>filesystem.bin</code> et le stocker dans un tableau de caractères (<code>storage</code>).

Fonction:

#define BLOCK_SIZE 256
// Fonction pour lire un bloc de données
void readBlock(unsigned int num, int offset, unsigned char *storage, int size) {
FILE *file = fopen("filesystem.bin", "rb");
if (file == NULL) {
perror("Erreur lors de l'ouverture du fichier");
return;
}
fseek(file, num * BLOCK_SIZE + offset, SEEK_SET);
fread(storage, 1, size, file);
fclose(file);
}

Paramètres :

* <code>num</code> : Numéro du bloc à lire. Chaque bloc contient 256 octets (1 bloc = 256 octets).
* <code>offset</code> : Décalage (en octets) à partir du début du bloc pour commencer la lecture.
* <code>storage</code> : Pointeur vers un tableau de caractères où les données lues seront stockées.
* <code>size</code> : Taille du tableau de caractères <code>storage</code>.

Fonctionnement :

* La fonction commence par ouvrir le fichier <code>filesystem.bin</code> en mode lecture binaire (<code>"rb"</code>).
* Elle utilise <code>fseek</code> pour positionner le curseur de lecture dans le fichier à l'endroit approprié pour commencer la lecture du bloc spécifié (<code>num</code>) à partir de l'offset (<code>offset</code>).
* Elle utilise ensuite <code>fread</code> pour lire <code>size</code> octets à partir du fichier et les stocker dans le tableau <code>storage</code>.
* Enfin, elle ferme le fichier avec <code>fclose</code>.

Note : Le paramètre <code>offset</code> est utilisé pour spécifier à partir de quel octet du bloc on souhaite commencer la lecture. Si <code>offset</code> est égal à 0, la lecture commencera depuis le début du bloc. Si <code>offset</code> est différent de 0, la lecture commencera à l'octet spécifié.

Remarque: dans votre mail, vous définissez "readBlock(unsigned int num,int offset,unsigned storage,int size)": storage n'est alors pas un pointeur vers un tableau de caractère. Je me suis donc permis de faire la modification.

ReX : OK pour la fonction, pas la peine d'en mettre autant dans le Wiki pour une fonction aussi simple.

=== Fonction <code>writeBlock</code> ===
Cette fonction est utilisée pour écrire un bloc de données dans le fichier <code>filesystem.bin</code> à partir d'un tableau de caractères (<code>storage</code>).

Fonction:

// Fonction pour écrire un bloc de données
void writeBlock(unsigned int num, int offset, const unsigned char *storage, int size) {
FILE *file = fopen("filesystem.bin", "rb+");
if (file == NULL) {
perror("Erreur lors de l'ouverture du fichier");
return;
}
fseek(file, num * BLOCK_SIZE + offset, SEEK_SET);
fwrite(storage, 1, size, file);
fclose(file);
}

Paramètres :

* <code>num</code> : Numéro du bloc où écrire.
* <code>offset</code> : Décalage (en octets) à partir du début du bloc pour commencer l'écriture.
* <code>storage</code> : Pointeur vers un tableau de caractères contenant les données à écrire dans le fichier.
* <code>size</code> : Taille du tableau de caractères <code>storage</code>.

Fonctionnement :

* La fonction commence par ouvrir le fichier <code>filesystem.bin</code> en mode lecture et écriture binaire (<code>"rb+"</code>).
* Elle utilise <code>fseek</code> pour positionner le curseur de lecture/écriture dans le fichier à l'endroit approprié pour commencer l'écriture du bloc spécifié (<code>num</code>) à partir de l'offset (<code>offset</code>).
* Elle utilise ensuite <code>fwrite</code> pour écrire <code>size</code> octets à partir du tableau <code>storage</code> dans le fichier.
* Enfin, elle ferme le fichier avec <code>fclose</code>.

ReX : Même remarque que pour la fonction précédente.

'''Etape 4: test des fonctions <code>readBlock</code> et <code>writeBlock</code> dans le main'''
// Exemple de fonction principale pour tester les opérations de lecture et d'écriture
int main() {
unsigned char data[BLOCK_SIZE];
// Test de la fonction readBlock
readBlock(0, 0, data, BLOCK_SIZE);
printf("Block 0, offset 0: ");
for (int i = 0; i < BLOCK_SIZE; i++) {
printf("%02x ", data[i]);
}
printf("\n");
// Test de la fonction writeBlock
unsigned char newData[BLOCK_SIZE] = {
0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88,
// ... Autres données du bloc ...
};
writeBlock(1, 0, newData, BLOCK_SIZE);
// Lecture du bloc nouvellement écrit pour vérifier
readBlock(1, 0, data, BLOCK_SIZE);
printf("Block 1, offset 0: ");
for (int i = 0; i < BLOCK_SIZE; i++) {
printf("%02x ", data[i]);
}
printf("\n");
return 0;
}

Fonctionnement :

* On déclare tout d'abord un tableau de caractères <code>data</code> de taille <code>BLOCK_SIZE</code> pour stocker les données lues du bloc.
* Ensuite, la fonction <code>readBlock</code> est appelée avec les arguments (0, 0, data, BLOCK_SIZE) pour lire le premier bloc du fichier (<code>num=0</code>, <code>offset=0</code>) et stocker les données dans <code>data</code>.
* Ensuite, la fonction <code>printf</code> est utilisée pour afficher les données lues du bloc (<code>data</code>) en format hexadécimal.
* Ensuite, un nouveau tableau de caractères <code>newData</code> est créé avec des données spécifiques pour tester la fonction <code>writeBlock</code>.
* La fonction <code>writeBlock</code> est appelée avec les arguments (1, 0, newData, BLOCK_SIZE) pour écrire le tableau <code>newData</code> dans le deuxième bloc du fichier (<code>num=1</code>, <code>offset=0</code>).
* Enfin, la fonction <code>readBlock</code> est appelée à nouveau pour lire le deuxième bloc nouvellement écrit et afficher les données lues en format hexadécimal.

Question générale : ce que j'avais la première semaine n'est plus forcément d'actualité. Puis-je supprimer les choses qui ne le sont plus afin d'alléger la page ou préférez-vous que je laisse?

ReX : Laissez.

Pour la suite : j'ai donc pour l'instant crée deux fonctions, l'une permettant la lecture et l'autre l'écriture d'un bloc, de manière à économiser la mémoire. Pour la suite, je vais essayer de créer la fonction <code>LS</code> en utilisant la fonction <code>readBlock</code>.

ReX : Oui c'est le début du projet. Mais si vous n'avez pas une bonne description de fichier cela ne donnera rien. Voir remarques plus haut.

'''Etape 5: fonction <code>LS</code>'''

Objectif: créer la fonction <code>LS</code> avec la fonction readBlock.

Question: Souhaitez-vous la fonction <code>LS</code> classique, c'est à dire la fonction <code>LS</code> qui affiche simplement le nom des fichiers présent dans le répertoire ?

ReX : Oui. Tu peux ajouter la taille si tu trouves cela trop simple.

Piste : si c'est ce que vous voulez:

* il va tout d'abord falloir que je crée des fichiers, un fichier étant composé d'un nom et de blocs (création d'une fonction createFile)
* Il faudra ensuite que je stocke ces fichiers dans le répertoire (création d'une fonction addFileToDirectory par exemple)
* enfin, il faudra que j'affiche le nom des fichiers. Pour cela, il faudra que je parcours le répertoire (structure "Directory"), puis que pour chaque fichier présent dans le répertoire que j'affiche son nom (création de la fonction LS)

Je devrais surement utiliser la fonction readBlock afin de transférer les blocs dans le fichier au travers de la variable "storage".

ReX : Créer des fichiers n'est pas nécessaire tout de suite je verrais bien si ton code est bon sans test. Laisse tomber <code>createFile</code> et <code>addFileToDirectory</code> pour l'instant.

ReX : Ton algorithme ne fonctionne pas pour un microcontrôleur où il faut économiser la mémoire, tu ne peux pas t'aider de structures. Il faudra que tu charges les noms et seulement les noms, pour la taille il faudra se baser sur le nombre de blocs.

'''Etape 6: rectification du code suite à vos remarques'''

Modifications apportées:

* suppression des structures afin d’économiser de la mémoire.

* le problème quant à la description des fichiers est normalement résolu puisque plus de structures. On ne charge plus les blocs mais seulement les noms de fichiers.

ReX : Non car si les noms ne sont pas répartis de façon régulière dans les blocs de 256 octets tu vas avoir du mal à les charger. Mais écrit la fonction <code>LS</code> et tu verras ce que je veux dire.

J'ai également ajouté deux nouvelles fonctions:

# <code>void readFileName(unsigned int file_num, char *file_name)</code>: Cette fonction permet de lire le nom du fichier associé au numéro de fichier donné (<code>file_num</code>). Elle stocke le nom du fichier lu dans le tableau <code>file_name</code>.
# <code>void writeFileName(unsigned int file_num, const char *file_name)</code>: Cette fonction permet d'écrire le nom du fichier dans le système de fichiers, associé au numéro de fichier donné (<code>file_num</code>). Elle prend en entrée le nom du fichier à écrire (<code>file_name</code>).

Suite: si vous validez cette base, je pourrai passer à la création de la fonction LS.

ReX : tu peux y aller. Je ne vois pas le code des tes deux fonctions <code>readFileName</code> et <code>writeFileName</code>.

Voici le code des fonctions <code>readFileName</code> et <code>writeFileName</code> :

'''Fonction readFileName:'''
// Fonction pour lire le nom du fichier
void readFileName(unsigned int file_num, char *file_name) {
readBlock(file_num, 0, (unsigned char *)file_name, MAX_FILENAME_LENGTH);
file_name[MAX_FILENAME_LENGTH] = '\0'; // Ajout du caractère null-terminator pour former une chaîne de caractères
}

ReX : Non, aucune raison que le fichier de numéro n soit au bloc n. Dessine la représentation d'un fichier sur le SF en comptant les octets si cela peut aider.

'''Fonction writeFileName:'''
// Fonction pour écrire le nom du fichier
void writeFileName(unsigned int file_num, const char *file_name) {
writeBlock(file_num, 0, (const unsigned char *)file_name, MAX_FILENAME_LENGTH);
}

ReX : Faux et inutile pour l'instant. Problème avec la constante MAX_FILENAME_LENGTH.

=== Fonction LS version 1 ===
// Fonction LS pour afficher les fichiers présents dans le système de fichiers
void LS(const char *filesystem_path) {
FILE *file = fopen(filesystem_path, "rb");
if (file == NULL) {
perror("Erreur lors de l'ouverture du fichier système");
return;
}
uint16_t num_files;
fread(&num_files, sizeof(uint16_t), 1, file); // Lecture du nombre de fichiers dans le système
char filename[17];
printf("Fichiers présents dans le système de fichiers:\n");
for (int i = 0; i < num_files; i++) {
readFileName(i, filename); // Lecture du nom du fichier
printf("%s\n", filename); // Affichage du nom du fichier
}
fclose(file);
}
La fonction <code>LS</code> ouvre le fichier système, lit le nombre de fichiers qu'il contient, puis affiche les noms des fichiers un par un, chacun sur une ligne séparée.

ReX : Il y a le nombre de fichiers dans ton superbloc ? Un dessin du format du superbloc avec les numéros des octets ?

ReX : Tout accès au système de fichiers doit se faire avec les deux fonctions <code>readBlock</code> et <code>writeBlock</code>.

== Semaine 3 ==
Question 1: cela fait plusieurs fois que vous mentionnez dans le wiki un "superbloc". Celui-ci n'étant pas clairement défini dans le sujet, je me demande s'il s'agit du bloc crée grâce à la fonction dd, c'est à dire que le superbloc serait en faite le bloc constitué des 31250 blocs de taille 256 octets, où s'il s'agit d'un bloc qui vient en entête, celui contenant alors des informations décrivant le système de fichier (les noms de fichiers...).

ReX : Pour ton pico système de fichiers, le superbloc consiste en les premiers blocs (de 256 octets) qui définissent les 64 fichiers possibles.

Proposition de structure: on pourrait réserver les premiers blocs du système de fichiers aux noms de fichiers ainsi qu'aux numéros des blocs correspondant à chaque fichier.

ReX : Oui c'est évident.

On sait que les noms de fichiers font au maximum 16 caractères + 1 caractère pour le '\0' (donc 17 octets car 1 char=1 octet).

ReX : Non, 16 octets suffisent, des '\0' en fin de nom uniquement si le nom fait moins de 16 caractères.

On sait également qu'un fichier contient au maximum 2040 blocs, chaque bloc étant numéroté sur 2 octets. On pourrait donc avoir en début du système de fichier: 17 octets+2 octets*2040 blocs = 4097 octets pour la description d'un fichier.

ReX : Non, 4096 octets soit 16 blocs de 256.

Or d'après l'une de vos remarques dans le wiki, un fichier doit être décrit par un nombre entier de blocs. Pour un fichier, il nous faudra donc 4097/256=16.004 soit 17 blocs. Il peut y avoir jusqu'à 64 fichiers dans le répertoire, il nous faudra donc 17 blocs*64 fichiers= 1088 blocs pour la description des fichiers.

ReX : Non 1024 blocs de 256 octets dans le superbloc.

Ainsi, pour la fonction LS, il suffira de lire les premiers caractères tous les 17 blocs ( du premier caractère au caractère '\0').

ReX : Non, tous les 16 blocs.

Question 2: Ne faudrait-il pas également stocker quelque part le nombre de fichier qu'il y a dans le répertoire afin de savoir jusqu'à quel bloc la fonction LS doit aller ?

ReX : Non, un fichier dont le nom n'est constitué que de '\0' est réputé ne pas exister.

Question 3: on a donc vu que les 1088 premiers blocs au maximum serviraient à la description du système de fichier. Il reste donc 31250-1088=30132 blocs dans le système de fichier.

ReX : Non, 32768-1024=31744 blocs.

Comment utiliser ces blocs? Ces blocs doivent-ils stocker le contenu des fichiers ?

ReX : Oui, c'et évident.

En effet, avec la fonction TYPE, nous allons créer des fichiers et ces fichiers devront être stockés quelque part. Cependant, étant donné que ce pico système de fichiers est prévu pour un microcontrôleur, je ne sais pas si c'est le contenu des fichiers qui doit être stocké dans les blocs ou autre chose (peut être l'adresse des fichiers, le fichiers se trouvant autre part). En effet, je me dis que si un fichier est très volumineux, il ne pourra pas rentrer dans le système de fichier, ce dernier étant composé d'un nombre limité de blocs, et les blocs étant eux même limité en nombre d'octets.

ReX : Je ne comprend pas ton problème. De tout façon comme dit plus haut, les 31744 blocs suivant le superbloc doivent contenir les données des fichiers.

Désolé de poser des questions peut être basique aussi tard, mais je pense qu'une fois que j'aurai ces réponses, cela ira beaucoup mieux pour la suite. Merci d'avance pour vos réponses.

ReX : Les questions sont effectivement triviales et il est effectivement inquiétant que voir que la travail n'avance pas.

Amine: merci pour vos corrections.

D'après votre commentaire "32768-1024=31744 blocs", j'en déduis qu'il faut que je modifie ma commande dd (qui est actuellement "dd if=/dev/zero of=filesystem.bin bs=256 count=31250" pour avoir le bon filesystem).

ReX : Je comprends pas d'où tu sors le 31250. D'autant plus que la commande ci-dessous est bonne.

Amine : 31250 car 31250 blocs * 256 octets = 8 Mo.

ReX : Haaaa je vois tu utilises le système métrique international où le mégaoctet vaut 10^6 octets, sauf qu'aucun informaticien n'utilisera cette norme hors sol. Quand je parle de 8 Mo c'est 8x1024x1024 octets. Tout simplement parce qu'une puce mémoire de 8 Mo c'est bien 8x1024x1024 octets.

Amine: D'accord merci pour l'information !

'''Nouvelle commande dd:'''

dd if=/dev/zero of=filesystem.bin bs=256 count=32768

=== Fonction LS version 2 ===

Dans notre structure du système de fichier, le superbloc est constitué de 1024 blocs (16 blocs * 64 fichiers), un fichier étant décrit par 16 blocs. Le nom du fichier est donc écrit au début de tous les blocs multiples de 16. Par exemple, le nom du premier fichier est dans les 16 premiers octets du premier bloc, le nom du 2ème fichier est dans les 16 premiers octets du 32ème bloc et ainsi de suite, tant que des fichiers existent. Lorsque qu'il n'y a plus de fichier, le nom du premier caractère du bloc multiple de 16 est un 0.

Voici le code:
// Fonction pour lister les noms de fichiers présents dans le système de fichiers
void LS() {
unsigned char buffer[BLOCK_SIZE];
int fileCount = 0;

for (int blockNum = 1; blockNum <= MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, BLOCK_SIZE);

// Vérifier si le bloc est vide
if (buffer[0] == 0) {
break; // Plus de fichiers à lire
}

char filename[MAX_FILENAME_LENGTH];
memcpy(filename, buffer, MAX_FILENAME_LENGTH);

// Afficher le nom du fichier
printf("%s\n", filename);
fileCount++;
}

if (fileCount == 0) {
printf("Aucun fichier trouvé.\n");
}
}

ReX : Tu supposes que si un fichier a un nom vide, les suivants auront aussi un nom vide. C'est possible mais dans ce cas la commande <code>RM</code> ca être plus compliquée à écrire.

ReX : Tu ne sembles pas comprendre que la mémoire d'un microcontrôleur est limitée. Pourquoi lire le premier bloc de description d'un fichier en entier ? Dit autrement c'est quoi l'intérêt de lire 256 octets alors que 16 suffisent ?

ReX : Pourquoi tu ne lis pas le premier fichier ? Autrement dit pourquoi décaler tout d'un bloc ?

Amine: Merci pour vos remarques. J'ai apporté les modifications à LS dans la section "Semaine 4" du wiki.

'''Réflexion par rapport aux autres fonctions:'''

J'ai créé les fonctions TYPE et CAT mais il y a malheureusement un problème pour l'instant. Vous pouvez les retrouver en pièce jointe dans l'archive du fichier programme.c.

Le problème que j'ai est que lorsque j'affiche le contenu du fichier créé avec TYPE, j'obtiens plein de caractères spéciaux. Par exemple, je créé le fichier "mon_fichier.txt" avec la fonction TYPE, et je mets en entré standard "hello". Ensuite, je veux afficher le contenu de ce fichier grâce à la fonction CAT. Cependant, ce qui s'affiche dans le terminal n'est pas ce que je veux. De la même manière, lorsque je fais la commande "cat filesystem.bin" dans le terminal, c'est la même chose s'affiche, des donnés parasites.

ReX : Avant même de lire ton code je vais te poser la question de savoir comment tu récupères un bloc libre ? Quel algorithme tu utilises. Personnellement je ne sais pas faire sans ajouter au superbloc un tableau bit à bit des blocs libres. Pour avoir un bit pour chaque bloc du système de fichiers, il faut 32768/8=4096 octets soit 16 blocs.

Amine: ok je vais donc ajouter ce tableau de 16 blocs à la suite de mes premiers 1024 blocs servant à la description de fichier. Le superbloc fera maintenant 1024+16=1040 blocs (plus de détail à la fonction RM de la semaine 4).

Question 1: est ce que la fonction CAT que je dois créer doit renvoyer la même chose que "cat filesystem.bin" ?

ReX : Je préfère ne pas répondre tellement la question montre un manque de réflexion.

Question 2: comment savoir combien de blocs doivent etre attribué à un fichier? Par exemple, si je créé un fichier "mon_fichier.txt" et que je mets en entrée standard le texte "hello", un seul bloc suffi pour stocker ce texte. Cependant, si j'avais mis beaucoup de texte en entrée standard, il aurait fallu plus de blocs. Doit-on calculer la taille de l'entrée standard ou doit-on attribuer toujours le meme nombre de blocs à un fichier? Peut-etre ainsi attribuer 2040 blocs par fichier, meme s'il n'en utilise que 1.

ReX : Là encore c'est une question stupéfiante tellement la réponse est évidente. Il suffit de lire les données sur l'entrée standard et de passer au bloc de données suivant dès que le bloc courant est rempli. La question à poser c'était de se demander comment il est possible d'avoir la taille exacte du fichier pour un <code>CAT</code>. Il est uniquement possible de l'avoir à 256 octets près puisque rien n'indique si le dernier block est vide. Le mieux aurait été de prévoir 4 octets dans la description d'un fichier pour stocker la taille. En l'espèce on considérera que les fichiers sont des fichiers ASCII et qu'ils seront terminés par des <code>\'0</code> qui ne seront pas affichés.

== Semaine 4 ==

Voici un bilan de ce que j'ai fait à ce stade du projet:

* j'ai choisi une structure du système de fichier
* j'ai créé les fonctions readBlock et writeBlock permettant de lire et d'écrire des blocs
* j'ai crée la fonction LS permettant d'afficher le nom des fichiers présents dans le système de fichiers
* j'ai programmer un main permettant d'utiliser les fonctions (LS, TYPE...) depuis le terminal
* j'ai réflechi aux fonctions TYPE et CAT.

Actuellement, je suis en train de créer les fonctions TYPE et CAT.

=== Fonction LS version 3 ===
void LS() {
unsigned char buffer[MAX_FILENAME_LENGTH];
int fileCount = 0;

// Parcourir tous les 16 blocs de 0 jusqu'à MAX_FILES_IN_DIRECTORY
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, MAX_FILENAME_LENGTH);

// Vérifier si le nom de fichier est vide
if (buffer[0] != 0) {

// Afficher le nom du fichier
printf("%s\n", buffer);
fileCount++;
}
}

if (fileCount == 0) {
printf("Aucun fichier trouvé.\n");
}
}
Suite à vos remarques, j'ai effectué les modifications suivantes de la fonction LS:

* Je ne suppose plus que si un fichier a un nom vide, les autres auront aussi un nom vide.
* Je ne lis plus les 256 octets mais seulement les 16 premiers octets car cela suffit.
* Je ne lisais en effet pas le premier bloc. Je pensais que le premier bloc était d'indice 1 mais ce n'est pas le cas.

ReX : Ouiiii ! Une fonction correcte. Passe à <code>RM</code> maintenant, c'est la plus facile à faire concernant l'image bit à bit des blocs libres.

=== Fonction setBlockAvailability version 1 ===

Comme vous l'avez indiqué dans votre remarque, il faut un tableau dans le superbloc qui nous permettra de connaitre la disponibilité bit par bit de chaque bloc. Sachant qu'il y a dans notre système de fichiers 32768 blocs, et qu'il faut 1 bit par bloc, nous avons besoin de 32768 bits, soit 32768/8=4096 octets soit 4096/256=16 blocs. Notre superbloc sera donc comme suit: les 1024 premiers blocs servent à la description des fichiers, c'est à dire à leur nom suivi des numéros de blocs qui leur sont associés, puis ces 1024 blocs sont suivi de 16 blocs listant la disponibilité de chaque bloc.

ReX : Bien résumé.

Nous allons tout d'abord écrire la fonction "setBlockAvailability" prenant en paramètre le numéro du bloc à traiter (<code>blockNum</code>) et la disponibilité souhaitée pour ce bloc (<code>availability</code>). Cette fonction permet de marquer la disponibilité d'un bloc spécifique dans le système de fichiers. Nous utiliserons la convention suivante: un bloc disponible sera marqué par un 1 tandis qu'un bloc non disponible par un 0.
#define SUPERBLOCK_START_BLOCK 1024

void setBlockAvailability(int blockNum, int availability) {
// Calculer l'index du byte et le bit offset correspondant
int byteIndex = blockNum / 8;
int bitOffset = blockNum % 8;

// Lire le byte existant du bloc de disponibilité des blocs
unsigned char buffer[1];
readBlock(SUPERBLOCK_START_BLOCK + byteIndex, 0, buffer, 1);

// Mettre à jour le bit d'offset correspondant
if (availability) {
buffer[0] |= (1 << bitOffset);
} else {
buffer[0] &= ~(1 << bitOffset);
}

// Écrire le byte mis à jour dans le bloc de disponibilité des blocs
writeBlock(SUPERBLOCK_START_BLOCK + byteIndex, 0, buffer, 1);
}

ReX : Un tableau de un octet c'est un octet (variable <code>buffer</code>).

Amine: je vais utiliser un <code>unsigned char buffer.</code> Je suis conscient qu'un char vaut un octet mais je ne pense pas qu'il y ait un type de donnée de la taille d'un bit, c'est pourquoi je travaille avec un octet mais je modifie les bits de cet octet grâce aux algorithmes.

ReX : Il faut bien que tu travailles sur un octet vu que l'état des blocs est stocké sous la forme d'octets. Je disais juste qu'un tableau de 1 élément n'a pas d'intérêt par rapport à l'élément lui-même.

Amine: c'est vrai, modification faite.

ReX : Non il faut calculer le numéro du bloc avant de faire le <code>readBlock</code>.

Amine: ok je vais calculer le numéro de bloc avant.

ReX : La mise à jour du bit est correcte mais le block et le déplacement dans le block ne sont pas correctement calculés.

Amine: je vais vous expliquer le raisonnement que j'avais. Prenons un exemple concret, imaginons que je veuille marquer le bloc 1030 comme disponible:

# Calcul de l'index de l'octet et du bit offset :
#* <code>blockNum</code> = 1030
#* Index du byte = 1030 / 8 = 128
#* Bit offset = 1030 % 8 = 6
# Lecture de l'octet existant de disponibilité:
#* Nous lisons l'octet existant à l'index 128 dans les blocs de disponibilité.
# Mise à jour du bit de disponibilité :
#* Nous voulons marquer le bloc 1030 comme disponible, donc nous utilisons le masque <code>(1 << 6)</code> pour définir le bit 6 à 1 dans l'octet. Le résultat sera, par exemple, <code>00100000</code>.
# Écriture du byte mis à jour :
#* Nous écrivons le byte mis à jour <code>00100000</code> à l'index 128 dans les blocs de disponibilité.

ReX : Ben non, un vrai exemple :
* Il faut prendre un n° de bloc plus grand : 3072 ;
* Numéro d'octet dans la carte des blocs libres : 3072/8=384 ;
* Numéro du bloc dans la carte des blocs libres : 384/256=1 ;
* Numéro du bit <code>b</code> dans l'octet n° 384-256=128 du bloc 1 : 3072%8=0 ;
* Il faut donc lire l'octet <code>o</code> de numéro 128 du bloc 1, puis modifier cet octet par <code>o |= (1<<b)</code> ou <code>o &= ~(1<<b)</code> ;
* Enfin il faut écrire l'octet modifié dans le bloc 1.
Amine: merci pour cet exemple! J'ai compris d'où vient mon erreur. Voir fonction setBlockAvailability version 3.

Remarque: par convention, j'apellerai dans la suite de ce projet "premier superbloc" le superbloc correspondant à la description des fichiers, c'est à dire les 1024 premiers blocs, et j'appellerai "second superbloc" les 16 blocs qui suivent servant à décrire la disponibilité des blocs (du bloc 1024 au bloc 1039 inclu). Le reste des blocs servira à stocker les données.

ReX : Non, le superblc est l'ensemble des informations hors blocs de données, tu ne peux pas utiliser un vocabulaire au hasard. Parle de blocs de description des fichiers ou de carte des blocs libres.

Amine: ok

Je pense que le problème qui se pose est que l'indice du bit dans le second superbloc ne correspond pas à l'indice du bloc dans le système de fichier. Par exemple, nous voudrions que si le bloc 1030 est disponible dans le système de fichier, alors le bit numéro 1030 du deuxième superbloc soit à 1, ce qui n'est pas le cas ici. En effet, on se trouve bien dans le bon octet avec ma méthode mais l'écriture du bit se fait de la droite vers la gauche alors qu'on voudrait l'inverse. Ainsi, si le 6ème bit de l'octet doit être à 1, alors il faudrait qu'on obtienne <code>00000100</code> et non <code>00100000.</code> L'indice du bit coinciderait ainsi avec le numéro du bloc.

ReX : Non, réfléchit à nouveau.

Voir plus bas la nouvelle version de setBlockAvailability.

Explication de l'algorithme pour mettre le bit à 1 ou 0:

* <code>buffer[0] |= (1 << bitOffset);</code> : Cette ligne utilise l'opérateur OR bit à bit (<code>|=</code>) pour activer (mettre à 1) le bit spécifié par <code>bitOffset</code> dans le premier octet (<code>buffer[0]</code>). Cela se fait en décalant le bit 1 vers la gauche de <code>bitOffset</code> positions, puis en effectuant une opération OR bit à bit avec le contenu actuel de <code>buffer[0]</code>. Cette opération modifie uniquement le bit ciblé, laissant les autres bits inchangés.

ReX : Oui ça c'est bon.

* <code>buffer[0] &= ~(1 << bitOffset);</code> : Cette ligne utilise l'opérateur AND bit à bit (<code>&=</code>) pour désactiver (mettre à 0) le bit spécifié par <code>bitOffset</code> dans <code>buffer[0]</code>. Pour ce faire, l'expression <code>~(1 << bitOffset)</code> est utilisée pour créer un masque où tous les bits sont à 1, sauf celui correspondant à <code>bitOffset</code>, qui est à 0. En effectuant ensuite une opération AND bit à bit entre le masque et le contenu actuel de <code>buffer[0]</code>, on met à 0 le bit ciblé sans affecter les autres bits.

ReX : Ca aussi.

=== Fonction setBlockAvailability version 2 ===

void setBlockAvailability(int blockNum, int availability) {
// Calculer l'indice de l'octet et le bit offset correspondant
int byteIndex = blockNum / 8;
int bitOffset = 7 - (blockNum % 8); // Inversion de l'ordre des bits

// Calculer le numéro du bloc du super bloc où se trouve l'octet de disponibilité correspondant
int availabilityBlockNum = SUPERBLOCK_START_BLOCK + byteIndex;

// Lire l'octet existant dans le bloc de disponibilité du super bloc
unsigned char buffer;
readBlock(availabilityBlockNum, 0, &buffer, 1);

// Mettre à jour le bit d'offset correspondant :
if (availability) {
buffer |= (1 << bitOffset);
} else {
buffer &= ~(1 << bitOffset);
}

// Écrire l'octet mis à jour dans le bloc de disponibilité du super bloc
writeBlock(availabilityBlockNum, 0, &buffer, 1);
}
J'ai modifié la ligne <code>int bitOffset = 7 - (blockNum % 8);</code> pour inverser l'ordre des bits sélectionnés, de sorte que le bit correspondant au bloc disponible soit correct.

ReX : Encore plus faux.

Si on veut rendre le bloc 1030 indisponible alors que les autres blocs sont disponibles:

ReX : Pardon ? Le bloc de données est libre ou pas suivant la carte des blocs libres. Le rendre disponible n'est possible que si un fichier le comportant est détruit.

# Calcul de l'indice de l'octet et du bit offset correspondant :
#* <code>blockNum = 1030</code>
#* <code>byteIndex = 1030 / 8 = 128</code>
#* <code>bitOffset = 7 - 1030 % 8 = 1</code> Cela signifie que le bit d'intérêt se trouve à la position 2 dans l'octet.
# Calcul du numéro du bloc du super bloc où se trouve l'octet de disponibilité correspondant :
#* <code>availabilityBlockNum = SUPERBLOCK_START_BLOCK + 128 = 1024 + 128 = 1152</code> Donc, nous devons accéder à l'octet 1152 pour mettre à jour la disponibilité du bloc 1030.
# Lecture de l'octet existant dans le bloc de disponibilité du super bloc :
#* Le contenu de l'octet dans le bloc 1152 avant la mise à jour : 11111111 (en binaire)
# Mise à jour du bit d'offset correspondant :
#* Supposons que nous voulions marquer le bloc 1030 comme non disponible (<code>availability = 0</code>).
#* Le bitOffset est 1.
#* Nous effectuons une opération AND avec le complément du bit à la position 1 : <code>11111111 & 11111101 = 11111101</code>
# Écriture de l'octet mis à jour dans le bloc de disponibilité du super bloc :
#* Le contenu de l'octet 128 du second superbloc après la mise à jour : 11111101 (en binaire)

ReX : Toujours aussi faux.

Maintenant, le bit d'indice 1 du 128 ème octet du second superbloc est mis à 0, indiquant que le bloc 1030 n'est plus disponible. Les autres bits restent inchangés car nous avons effectué un AND avec un masque binaire qui avait des 1 partout sauf à la position du bit que nous souhaitions mettre à 0.

ReX : Erreur sur erreur.

=== Fonction setBlockAvailability version 3 ===
J'ai compris d'où vient l'erreur. La fonction readBlock prends en premier paramètre le numéro du bloc à lire, je ne peux donc pas lui donner la valeur "SUPERBLOCK_START_BLOCK + byteIndex" car byteIndex s'exprime en octet alors qu'on s'attend à un nombre de bloc ici. Il faut donc divisé byteIndex par 256 pour être en unité "bloc", et préciser le bit qu'on veut lire grâce à l'offset.

Pour obtenir l'octet que l'on veut, il faut prendre le reste de la division de byteIndex par 256. On va ensuite stocker cet octet dans notre "buffer".

Pour savoir quel bit modifier dans ce "buffer", on va prendre le reste de la division du bloc dont on veut mettre à jour la disponibilité par 8. On va ainsi pouvoir modifier ce bit grâce à l'algorithme, puis réécrire l'octet à son emplacement d'origine.

Cette fonction gère la carte de disponibilités des blocs. Si un bloc est disponible, alors elle le met un 0, si il est indisponible, elle met un 1.
#define SUPERBLOCK_START_BLOCK 1024

void setBlockAvailability(int blockNum, int availability) {

int byteIndexInCard = blockNum / 8; //Numéro d'octet dans la carte des blocs libres
int blockIndexInCard = byteIndexInCard / 256; //Numéro du bloc dans la carte des blocs libres
int byteIndexInBlock = byteIndexInCard % 256; //Numéro d'octet dans le bloc contenant le bit de disponibilité
int bitOffset = blockNum % 8; //Numéro du bit dans l'octet n°byteIndexInBlock du bloc blockIndexInCard

//indice du bloc contenant le bit à mettre à jour dans le bloc de description
int availabilityBlockNum = FIRST_DISPONIBILITY_CARD_BLOCK + blockIndexInCard;

// Lire l'octet existant dans le bloc de disponibilité du super bloc
unsigned char buffer;
readBlock(availabilityBlockNum, byteIndexInBlock, &buffer, 1);

// Mettre à jour le bit d'offset correspondant :
if (availability==1) { // indisponible
buffer |= (1 << bitOffset); // Mettre le bit à 1

} else { // disponible
buffer &= ~(1 << bitOffset); // Mettre le bit à 0
}

// Écrire l'octet mis à jour dans le bloc de disponibilité du super bloc
writeBlock(availabilityBlockNum, byteIndexInBlock, &buffer, 1);
}

ReX : Ben voila, c'est pas possible de te taxer d'excès de vitesse mais c'est bon.

update: j'ai fait une petite modification, maintenant un bloc disponible est marqué d'un 0 et un bloc indisponible est marqué d'un 1. C'est mieux dans la mesure où initialement, tous les blocs sont disponibles et tous les blocs sont à 0. Cela évite de devoir créer une fonction qui initialise toute la carte de disponibilités à 1 pour dire que tous les blocs sont disponibles.

=== Fonction RM version 1 ===

void RM(const char *filesystem_path, const char *filename) {
unsigned char buffer[BLOCK_SIZE];
int fileNum = -1;

// Parcourir les blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (memcmp(filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {
// Effacer le nom du fichier dans le superbloc
memset(filenameBuffer, 0, MAX_FILENAME_LENGTH);
writeBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

unsigned char fileBuffer[MAX_BLOCKS_PER_FILE * 2];
readBlock(blockNum, MAX_FILENAME_LENGTH, fileBuffer, MAX_BLOCKS_PER_FILE * 2);

// Libérer les blocs associés au fichier et réinitialiser les numéros de blocs
for (int i = 0; i < MAX_BLOCKS_PER_FILE * 2; i += 2) {
int blockNum = ((int)fileBuffer[i] << 8) + (int)fileBuffer[i + 1];
if (blockNum == 0) {
break; // Fin du fichier
}
setBlockAvailability(blockNum, 0); // Marquer le bloc comme disponible
fileBuffer[i] = 0;
fileBuffer[i + 1] = 0;
}

// Mettre à jour les numéros de blocs associés au fichier
writeBlock(blockNum, MAX_FILENAME_LENGTH, fileBuffer, MAX_BLOCKS_PER_FILE * 2);

fileNum = blockNum;
break; // Fichier trouvé, sortir de la boucle
}
}

// Afficher le résultat de l'opération
if (fileNum == -1) {
printf("Le fichier \"%s\" n'a pas été trouvé.\n", filename);
} else {
printf("Le fichier \"%s\" a été supprimé avec succès.\n", filename);
}
}

ReX : Vous utilisez <code>strcmp</code> comme <code>strncmp</code>. C'est bien la dernière qu'il faut utiliser mais en précisant la longueur du nom en paramètre, pas la taille maximale.

Amine: vous voulez dire que j'utilise memcmp au lieu de strncmp ? Ok je vais utiliser strncmp, c'est vrai que c'est plus adapté pour la comparaison de chaines de caractère.

ReX : Ha oui c'est <code>memcmp</code> que tu utilises. Ca ne peut effectivement pas marcher. Effectivement avec <code>strncmp</code> cela peut marcher vu qu'il s'arrête au premier 0 contrairement à <code>memcmp</code>.

Cependant, pourquoi doit-on passer la taille exacte du nom du fichier en paramètre, et non la taille maximale d'un nom de fichier? En effet, cela semble fonctionner en mettant la taille maximale en paramètre, tandis que lorsque l'on met la taille exacte du nom du fichier, cela pose un problème: on ne compare plus toute la chaîne de caractère mais seulement une portion du nom complet. Ainsi, si je crée par exemple un fichier que j'appelle "file1", puis que j’exécute la fonction RM "/picofs filesystem.bin RM file" par exemple, alors le fichier file1 va être supprimé quand même car on ne comparera que strlen(file)=4 premiers caractères, qui sont les mêmes, donc la fonction considérera ces chaines comme identiques. On pourrait alors se dire qu'il faudrait alors prendre plutôt comme taille en paramètre de la fonction strlen la taille du nom du fichier se trouvant dans le système de fichier plutôt que celle du nom donné en paramètre de RM. Cependant, le même problème se pose si la taille du nom du fichier du système de fichier est plus petite que celle du nom du fichier passé en paramètre. Par exemple, si le fichier présent dans système de fichier est "file", et qu'on met la longueur de file en paramètre de la fonction strcmp, puis qu'on exécute la commande "/picofs filesystem.bin RM file5", alors file sera quand même supprimé, car on ne comparera que les strlen(file)=4 premiers caractère. Finalement, une solution serait de rajouter une condition qui vérifie que les deux chaînes sont de taille identiques pour pouvoir réaliser la comparaison sur la taille exacte du nom du fichier. Cependant, il me semble qu'en mettant MAX_FILENAME_LENGTH qui vaut 16 en paramètre, cela fonctionne directement. Vous pouvez tester cela en testant mon programme.

ReX : Ok pour <code>strncmp</code> avec la taille maximale d'un nom de fichier.

etape 1: créer un fichier :
./picofs filesystem.bin TYPE fichier.txt

etape 2: verifier que le fichier a bien été créé :
./picofs filesystem.bin LS

Le terminal renvoie bien "fichier.txt"

etape 3: essayer de supprimer le fichier en mettant une chaine troncature du nom du fichier créé :
./picofs filesystem.bin RM fich

le terminal renvoi <<Le fichier "fich" n'a pas été trouvé.>>, le fichier n'a donc pas été supprimé .

etape 4: essayer de supprimer le fichier en mettant un nom plus grand incluant "fichier.txt" :
./picofs filesystem.bin RM fichier.txtt

terminal renvoi <<Le fichier "fichier.txtt" n'a pas été trouvé.>>

etape 5: enfin, tester en mettant le nom exacte du fichier que l'on veut supprimer :
./picofs filesystem.bin RM fichier.txt

terminal renvoi <<Le fichier "fichier.txt" a été supprimé avec succès.>>

Finalement, on voit que cela fonctionne avec la taille maximale mise en paramètre. On pourrait reprocher à cette méthode de comparer des caractères dans le vide, ce qui n'est pas optimal dans une optique d'économie de mémoire qui est la notre, mais la taille maximale d'un nom de fichier étant relativement faible (16 octets), on peut peut-être négliger cela au vu de l'économie d'une opération supplémentaire (comparaison de la taille des chaines de caractères).

ReX : Le parcours des blocs de données du fichier est atroce. Il faut parcourir les numéros de blocs dans le premier bloc du fichier derrière le nom du fichier puis il faut parcourir le 15 autres blocs.

Amine: Ok, je vais corriger cela dans la version 2 de RM (voir semaine 5).

Fonctionnement de la fonction RM:

* Parcours des blocs réservés pour la description des fichiers (superbloc) à partir du bloc 0, en incrémentant de 16 à chaque itération pour accéder aux blocs de noms de fichiers.

ReX : OK.

* Dans chaque bloc de noms de fichiers, la fonction compare le nom de fichier recherché avec les noms stockés dans les 16 octets de chaque bloc.

ReX : Non la fonction ne fait pas ça par contre il faudrait, oui.

Amine: Je pensais que c'était ce que je faisais avec "memcmp(filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0)".

* Si le nom de fichier est trouvé, la fonction efface le nom du fichier dans le superbloc en remplaçant les 16 octets du bloc par des zéros.

ReX : OK.

* Ensuite, la fonction accède aux octets suivants du même bloc pour obtenir les numéros de blocs associés au fichier.

ReX : Non, la boucle sort largement du premier bloc.

* Pour chaque paire de numéros de blocs (2 octets chacun), la fonction convertit les octets en un numéro de bloc. Si le numéro de bloc est nul, cela signifie la fin des blocs associés au fichier, sinon, la fonction marque ce bloc comme disponible en utilisant la fonction <code>setBlockAvailability</code> et réinitialise les numéros de blocs dans le tableau à zéro.
* Les numéros de blocs réinitialisés sont ensuite réécrits dans le bloc de description du fichier.

ReX : L'idée est là mais vu que la boucle n'est pas bonne, rien ne peut marcher.

* La fonction affiche ensuite un message indiquant le résultat de l'opération : soit que le fichier a été supprimé avec succès, soit que le fichier n'a pas été trouvé.

== Semaine 5 ==

=== Fonction RM version 2 ===

Concernant les remarques que vous m'avez faites précédemment:

* j'utilise maintenant la fonction <code>strncmp</code> pour la comparaison des chaines de caractères
* j'ai normalement corrigé le parcours des blocs. Je parcours maintenant d'abord les blocs multiples de 16 à la recherche du bloc contenant le nom du fichier à supprimer. Puis je parcours les 16 blocs de description du fichier à supprimer, afin de récupérer les numéros de blocs, libérer ces blocs dans la carte de disponibilité et de réinitialiser ces blocs dans les blocs de données.

void RM(const char *filesystem_path, const char *filename) {
int fileFound = -1;
int offset;

// Parcourir les blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char*)filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {

// Effacer le nom du fichier dans le superbloc
memset(filenameBuffer, 0, MAX_FILENAME_LENGTH);
writeBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);
fileFound = 1;
offset = blockNum;
break;
}

}

// Fin de fonction si fichier inexistant
if (fileFound == -1) {
printf("Le fichier \"%s\" n'a pas été trouvé.\n", filename);
return;
}

unsigned char buffer[BLOCK_SIZE];
//bloc que l'on va remplir de 0 et mettre à la place des blocs de données
memset(buffer, 0, BLOCK_SIZE); //on rempli buffer de 0

for (int blockNum=offset; blockNum<offset + 16; blockNum++) {

//premier bloc de description, celui contenant le nom du fichier dans les 16 premiers octets
if (blockNum == offset) {

unsigned char fileBuffer[BLOCK_SIZE-MAX_FILENAME_LENGTH];
//bloc dans lequel on va stocker les blocs de description de fichier
readBlock(blockNum, MAX_FILENAME_LENGTH, fileBuffer, BLOCK_SIZE-MAX_FILENAME_LENGTH);

// Libérer les blocs associés au fichier dans la carte de disponibilités
// et dans les blocs de description
for (int i = MAX_FILENAME_LENGTH; i < BLOCK_SIZE-MAX_FILENAME_LENGTH; i += 2) {
int blockNumData = ((int)fileBuffer[i] << 8) + (int)fileBuffer[i + 1];
if (blockNumData == 0) {
break; // Fin du fichier
}
setBlockAvailability(blockNumData, 0); // Marquer le bloc comme disponible
fileBuffer[i] = 0;
fileBuffer[i + 1] = 0;
writeBlock(blockNumData, 0, buffer, BLOCK_SIZE); //on efface les blocs de données
}
writeBlock(blockNum, MAX_FILENAME_LENGTH, fileBuffer, BLOCK_SIZE-MAX_FILENAME_LENGTH);
//on efface le premier bloc de description

} else {
unsigned char fileBuffer[BLOCK_SIZE];
readBlock(blockNum, 0, fileBuffer, BLOCK_SIZE);

// Libérer les blocs associés au fichier dans la carte de disponibilités et dans les blocs de description
for (int i = 0; i < BLOCK_SIZE; i += 2) {
int blockNumData = ((int)fileBuffer[i] << 8) + (int)fileBuffer[i + 1];
if (blockNumData == 0) {
break; // Fin du fichier
}
setBlockAvailability(blockNumData, 0); // Marquer le bloc comme disponible
fileBuffer[i] = 0;
fileBuffer[i + 1] = 0;
writeBlock(blockNumData, 0, buffer, BLOCK_SIZE); //on efface les blocs de données
}
writeBlock(blockNum, 0, fileBuffer, BLOCK_SIZE); //on efface le bloc de description
}
}
printf("Le fichier \"%s\" a été supprimé avec succès.\n", filename);
}

ReX : Pour construire le nombre sur 16 bits utiliser le OU plutôt que l'addition.

ReX : Heu non, je ne lis pas cette fonction avec tout ce code dupliqué, la seule différence entre les deux alternative est la position de début de l'adresse du premier bloc de données (<code>MAX_FILENAME_LENGTH</code> dans un cas et 0 dans l'autre). Donc l'alternative ne doit servir qu'à initialiser ce début, le reste du code doit être factorisé.

ReX : Et corrige le code, tu utilises deux tableaux de blocs (perte mémoire), tu écris le bloc à zéro dans l'itération (perte CPU).

=== Fonction RM version 3 ===

Suite à vos remarques, j'ai réalisé les modifications suivantes:

* j'utilise maintenant le OU plutôt que l'addition pour construire le nombre sur 16 bits.

* j'ai factorisé le code grâce à la création de la variable <code>startOffset</code> valant 16 lorsqu'on se trouve dans le bloc contenant le nom du fichier et valant 0 lorsqu'on se trouve dans les autres.

* Pour ce qui est du fait que j'utilise 2 tableaux de blocs, j'ai du mal à voir comment faire avec 1 seul tableau de blocs car ces deux tableaux n'ont pas du tout le même rôle. Le tableau <code>fileBuffer</code> permet de stocker les 16 blocs de description d'un fichier un à un. Lorsqu'on stocke un bloc dans <code>fileBuffer</code>, on lit ensuite les octets un à un de ce bloc afin de former des numéros de blocs, et pour chaque numéro de bloc créé, on va réinitialiser le bloc correspondant dans les blocs de données. Pour cela, on a donc besoin d'un autre bloc qui viendra écraser les anciens blocs de données. C'est pourquoi j'ai créé un bloc <code>buffer</code>qui est composé de 0 et qui va écraser les blocs de données. On ne peut pas utiliser <code>fileBuffer</code> car on a besoin d'un bloc de zéros, et si on réinitialise <code>fileBuffer</code> on perd toute les données qui s'y trouvent. Une possibilité serait de relire le bloc de donné à chaque itération de la deuxième boucle for imbriquée; cela permettrait de pouvoir réinitialiser le tableau fileBuffer à chaque itérations de cette boucle afin de stocker ce bloc de 0 dans les blocs de données, puis de restocker dans ce même tableau le bloc de description. Cependant, je ne pense pas que ce soit optimal de faire autant appel à la fonction readBlock.

* j'ai créé une fonction resetBock qui permet comme son nom l'indique de reset un bloc en le remplissant de 0. Cela nous évite de créer deux tableaux de blocs dans RM, bien que je pense que cela revienne au même car on fait appel à une fonction qui créé un tableau de blocs. Quoi qu'il en soit, cela allège le code et cette fonction pourra surement me resservir par la suite.

void RM(const char *filesystem_path, const char *filename) {
int fileFound = -1;
int offset;
unsigned char fileBuffer[BLOCK_SIZE];

// Parcourir les blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char *)filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {
// Effacer le nom du fichier dans le superbloc
memset(filenameBuffer, 0, MAX_FILENAME_LENGTH);
writeBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);
fileFound = 1;
offset = blockNum;
break;
}
}

// Fin de fonction si fichier inexistant
if (fileFound == -1) {
printf("Le fichier \"%s\" n'a pas été trouvé.\n", filename);
return;
}

for (int blockNum = offset; blockNum < offset + 16; blockNum++) {
int startOffset = 0;
if (blockNum == offset) {
startOffset = MAX_FILENAME_LENGTH;
}
readBlock(blockNum, startOffset, fileBuffer, BLOCK_SIZE - startOffset);

// Libérer les blocs associés au fichier dans la carte de disponibilités et dans les blocs de description
for (int i = 0; i < BLOCK_SIZE - startOffset; i += 2) {
int blockNumData = (fileBuffer[i] << 8) | fileBuffer[i + 1];
if (blockNumData == 0) {
break; // Fin du fichier
}
setBlockAvailability(blockNumData, 0); // Marquer le bloc comme disponible
fileBuffer[i] = 0;
fileBuffer[i + 1] = 0;
resetBlock(blockNumData); //on efface les blocs de données
}
writeBlock(blockNum, startOffset, fileBuffer, BLOCK_SIZE - startOffset);
}
printf("Le fichier \"%s\" a été supprimé avec succès.\n", filename);
}
'''Fonction resetBlock'''
void resetBlock(unsigned int blockNum) {
unsigned char buffer[BLOCK_SIZE];
memset(buffer, 0, BLOCK_SIZE);

// Utiliser writeBlock pour écrire les données du buffer dans le bloc
writeBlock(blockNum, 0, buffer, BLOCK_SIZE);
}

ReX : Ca s'améliore. Mais pourquoi cette fonction <code>resetBlock</code> ? Tu crois que dans qu'un système de fichiers perd du temps à mettre à zéro les blocs de données libérés ? Si oui, regarde la page de manual de la commande <code>shred</code>, ça manque à ta culture.

Amine: Après avoir consulter le manual de la commande <code>shred</code>, je vois que cette commande écrit des données aléatoires sur l'emplacement du fichier sur le disque. Par défaut, <code>shred</code> effectue un certain nombre de passes (par exemple, 3 passes) pendant lesquelles il écrit des données aléatoires sur l'emplacement du fichier sur le disque. Après avoir écrit les données aléatoires, <code>shred</code> peut effectuer des passes supplémentaires pendant lesquelles il écrit des données nulles (des zéros) sur le même emplacement. L'objectif de <code>shred</code> est d'augmenter la sécurité en rendant plus difficile la récupération des données supprimées à l'aide d'outils de récupération de données.

Cependant, j'ai aussi consulté comment fonctionne la commande <code>rm</code> de linux, et je vois que cette commande libère l'espace occupé par le fichier en marquant les blocs associés comme disponibles. Cela signifie que les données peuvent encore être récupérées à l'aide d'outils de récupération de données, à moins que des mesures supplémentaires ne soient prises pour écraser physiquement l'espace avec des données aléatoires (c'est ce que fait l'utilitaire <code>shred</code>).

On va donc opter pour la deuxième option, c'est à dire qu'on ne va pas perdre notre temps à remettre à zéro les blocs de données libérés, on va simplement marquer les blocs correspondants comme étant disponibles. Cela nous permettra de nous émanciper de la fonction resetBlock et de n'avoir plus qu'un seul tableau de blocs.

ReX : Sinon lire un bloc complet de pointeurs de blocs de données en mémoire n'est pas forcément optimal. L'idéal serait de lire ces blocs morceau par morceau (de 64 octets par exemple). Certes un bloc serait traité en 4 lectures/écritures (ce qui ralentirait le traitement) mais on gagne en mémoire. Le mieux serait de mettre la taille des morceaux en constante pour pouvoir choisir entre vitesse d'exécution et utilisation mémoire.

Amine: d'accord je comprends. Je vais modifier la fonction pour qu'on puisse découper la lecture/écriture en plusieurs blocs.

=== Fonction RM version 4 ===
Modifications apportées:

* je ne réinitialise plus les blocs de données, je supprime simplement le pointeur du fichier vers les blocs de données et je désigne les blocs comme "disponible" dans le carte de disponibilités. J'ai donc supprimé la fonction resetBlock.

* je ne lis plus les blocs en une seule fois mais en plusieurs fois via la variable CHUNK_SIZE:

# J'ai introduit la constante <code>CHUNK_SIZE</code> pour définir la taille de chaque morceau que nous allons lire/écrire à la fois. Cela permet de découper les opérations en blocs plus petits.
# Dans la boucle <code>for</code> où on parcours les blocs à partir de <code>offset</code>, j'ai ajouté une boucle interne qui parcourt les données du bloc en morceaux de taille <code>CHUNK_SIZE</code>.
# À l'intérieur de la boucle interne, j'ai calculé la taille réelle du morceau (<code>chunkSize</code>) en prenant le minimum entre <code>CHUNK_SIZE</code> et la quantité de données restant à lire/écrire dans le bloc.
# J'ai modifié la fonction <code>readBlock</code> pour lire seulement la quantité de données spécifiée par <code>chunkSize</code> à partir de <code>chunkStart</code>. Ces données sont stockées dans le tableau <code>fileBuffer</code>.
# Ensuite, j'ai effectué les mêmes opérations de libération des blocs associés au fichier, en parcourant les données du morceau et en marquant les blocs comme disponibles.
# Finalement, j'ai utilisé la fonction <code>writeBlock</code> pour écrire le morceau de données modifié dans le bloc, en utilisant la même <code>chunkStart</code> pour déterminer où écrire les données.

#define CHUNK_SIZE 64

int min(int a, int b) {
return a < b ? a : b;
}

void RM(const char *filesystem_path, const char *filename) {
int fileFound = -1;
int offset;
unsigned char fileBuffer[BLOCK_SIZE];

// Parcourir les blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char *)filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {
// Effacer le nom du fichier dans le superbloc
memset(filenameBuffer, 0, MAX_FILENAME_LENGTH);
writeBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);
fileFound = 1;
offset = blockNum;
break;
}
}

// Fin de fonction si fichier inexistant
if (fileFound == -1) {
printf("Le fichier \"%s\" n'a pas été trouvé.\n", filename);
return;
}

for (int blockNum = offset; blockNum < offset + 16; blockNum++) {
int startOffset = 0;

if (blockNum == offset) {
startOffset = MAX_FILENAME_LENGTH;
}

for (int chunkStart = startOffset; chunkStart < BLOCK_SIZE; chunkStart += CHUNK_SIZE) {
int chunkSize = min(CHUNK_SIZE, BLOCK_SIZE - chunkStart);
readBlock(blockNum, chunkStart, fileBuffer, chunkSize);

for (int i = 0; i < chunkSize; i += 2) {
int blockNumData = (fileBuffer[i] << 8) | fileBuffer[i + 1];
if (blockNumData == 0) {
writeBlock(blockNum, chunkStart, fileBuffer, chunkSize);
printf("Le fichier \"%s\" a été supprimé avec succès.\n", filename);
return; // Sortir des boucles
}
setBlockAvailability(blockNumData, 0); // Marquer le bloc comme disponible
fileBuffer[i] = 0;
fileBuffer[i + 1] = 0;
}

writeBlock(blockNum, chunkStart, fileBuffer, chunkSize);
}
}

printf("Le fichier \"%s\" a été supprimé avec succès.\n", filename);
}

ReX : Si on trouve un n° de bloc de données à 0, il faut sortir des deux boucles les plus externes après avoir fait le <code>writeBlock</code>.

Amine: Modification faites ci-dessus. Maintenant, dès qu'on trouve un n° de bloc de données à 0 dans la boucle la plus interne, on effectue le <code>writeBlock</code> et ensuite on utilise <code>return</code> pour sortir des deux boucles les plus externes. Cela permet d'optimiser le code en évitant de continuer à traiter inutilement le reste des blocs.

ReX : Pas très propre (duplication de code) mais nous allons nous en contenter.

=== Fonction intermédiaire TYPE version 1 ===

J'ai également commencé à réfléchir à la fonction TYPE. Pour l'instant, elle ne fait qu'ajouter les noms de fichier dans le superbloc. Cela permet de pouvoir tester les fonctions LS et RM (voir dans la rubrique compilation et exécution comment utiliser le programme).
// Fonction pour créer un fichier avec le nom donné et le contenu fourni en entrée standard
void TYPE(const char *filesystem_path, const char *filename) {
unsigned char buffer[MAX_FILENAME_LENGTH];
// Parcours des blocs réservés pour la description des fichiers
for (int blockNum = 0; blockNum <= MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, MAX_FILENAME_LENGTH);
// Vérifier si le bloc est vide (pas de nom de fichier)
if (buffer[0] == 0) {
// Écrire le nom du fichier dans l'emplacement vide du superbloc
writeBlock(blockNum, 0, (const unsigned char *)filename, MAX_FILENAME_LENGTH);
break; // Fichier créé, sortir de la boucle
}
}
printf("Le fichier \"%s\" a été créé avec succès.\n", filename);
}

ReX : Si la boucle se termine sans trouver de slot libre le message de succès s'affiche tout de même.

ReX : Le paramètre <code>filename</code> n'a pas forcément une taille de <code>MAX_FILENAME_LENGTH</code>.

Selon moi, la fonction TYPE devra respecter 3 étapes:

# Enregistrement du Nom du Fichier: L'ajout du nom du fichier dans un des blocs de la première partie du superbloc.
# Stockage des Données du Fichier: La récupération des données saisies en entrée standard par l'utilisateur et leur stockage dans des blocs du système de fichiers à partir d'une certaine position, comme le bloc 1040.
# Mise à Jour de la Disponibilité des Blocs: L'indication que les blocs dans lesquels les données ont été écrites ne sont plus disponibles en modifiant les bits correspondants dans la deuxième partie du superbloc (les 16 derniers blocs du super bloc).

ReX : Relis le point 3 et dit moi si tu te comprends toi même ?

Amine: Ma phrase n'est effectivement pas très claire. Je voulais dire que la fonction TYPE devra mettre à jour la carte de disponibilité du superbloc. C'est à dire que lorsqu'elle écrira des données dans des blocs, elle devra indiquer dans la carte de disponibilités que ces blocs ne sont plus disponibles.

=== Fonction intermédiaire TYPE version 2 ===

Suite à vos remarques, j'ai apporté les modifications suivantes à la fonction TYPE:

* j'ai ajouté une condition pour l'affichage du message de succès de la création d'un fichier (placeFound).

* le paramètre <code>filename</code> n'ayant pas forcément une taille de <code>MAX_FILENAME_LENGTH</code>, je calcule maintenant la longueur de filename, afin d'écrire seulement le nom du fichier avec la fonction writeBlock.

Il fonction n'est bien évidemment pas fini, elle ajoute seulement le nom du fichier dans le superbloc pour l'instant. Cela me permet de tester les fonctions LS et RM.
void TYPE(const char *filesystem_path, const char *filename) {
size_t sizeFilename = strlen(filename);
printf("size filename=%d\n", sizeFilename);
unsigned char buffer[MAX_FILENAME_LENGTH];
int placeFound = 0;

if (sizeFilename > MAX_FILENAME_LENGTH) {
printf("Impossible de créer le fichier, nom trop long\n");
return;
}

// Parcours des blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, MAX_FILENAME_LENGTH);
// Vérifier si le bloc est vide (pas de nom de fichier)
if (buffer[0] == 0) {
// Écrire le nom du fichier dans l'emplacement vide du superbloc
if (sizeFilename < MAX_FILENAME_LENGTH) {
sizeFilename+=1;
}
writeBlock(blockNum, 0, (const unsigned char *)filename, sizeFilename);
placeFound = 1;
break; // Fichier créé, sortir de la boucle
}
}
if (placeFound == 1) {
printf("Le fichier \"%s\" a été créé avec succès.\n", filename);
} else {
printf("Plus de place dans le système de fichier pour créer ce fichier.\n", filename);
}
}

ReX : Mieux, attention il faut copier aussi le <code>\'0</code> final du nom, donc <code>sizeFilename+1</code>. Sinon tu n'es pas sûr qu'il y ait un zéro final. Et attention n°2, il ne faut pas copier ce <code>\'0</code> si le nom fait la taille maximale.

Amine: ok j'ai modifié la fonction TYPE ci-dessus. J'ai ajouté une condition: si le nom du fichier est inférieur à la taille maximale de nom de fichier, alors on incrémente de 1 la taille du nom de fichier. Cela nous permet d'écrire le '\0' dans le bloc de description. Dans le cas où le nom du fichier est de la taille maximale, nous n'avons pas besoin d'écrire le '\0', on n'incrémente donc pas la taille de 1.

J'ai également ajouté une condition: si le nom du fichier est supérieur à la taille maximale, alors un message d'erreur s'affiche et le fichier n'est pas créé.

ReX : OK. L'embryon de fonction <code>TYPE</code> est correct, il manque juste le principal : la création des blocs de données.

=== Fonction MV version 1 ===

J'ai ici créé la fonction MV qui permet de changer le nom d'un fichier. Pour ce faire, la fonction parcourt les blocs de descriptions à la recherche du fichier dont on veut changer le nom. Lorsque ce fichier est trouvé, on supprime l'ancien nom en mettant des 0 sur 16 octets, puis on vient réécrire le nouveau nom dans le même emplacement. Enfin, on sort de la boucle et on affiche le succès ou non de l'opération.
// Fonction qui modifie le nom du fichier
void MV(const char *filesystem_path, const char *old_filename, const char *new_filename) {
size_t sizeNew_filename = strlen(new_filename);
size_t sizeOld_filename = strlen(old_filename);
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
int fileFound = 0;
// Parcourir les blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);
// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char*)filenameBuffer, old_filename, MAX_FILENAME_LENGTH) == 0) {
// Effacer le nom du fichier dans le superbloc
memset(filenameBuffer, 0, MAX_FILENAME_LENGTH);
writeBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);
// Écrire le nom du fichier dans l'emplacement
writeBlock(blockNum, 0, (const unsigned char *)new_filename, sizeNew_filename);
fileFound=1;
break; // Nom modifié, sortir de la boucle
}
}
if (fileFound == 1) {
printf("Le nom du fichier \"%s\" a été renommé avec succès.\n", old_filename);
} else {
printf("Le fichier \"%s\" n'a pas été trouvé.\n", old_filename);
}
}

ReX : Inutile d'écraser l'ancien nom avec des zéros. Il suffit de copier le nouveau en s'assurant qu'il y ait un zéro final sauf si le nouveau nom fait la taille maximale.

Amine: ok, je vais faire les modifications dans la version 2.

== Semaine 6 ==

=== Fonction MV version 2 ===
Dans cette nouvelle version de la fonction MV, j'ai effectué les modifications suivantes:

* je n'écrase plus l'ancien nom avec des 0
* Je colle simplement le nouveau nom par dessus l'ancien, en m'assurant qu'il y ait bien le '\0' à la fin lorsque la taille du nom du fichier est inférieur à la taille maximale. Comme précédemment, afin de m'assurer de la présence de ce '\0' à la fin du nom, j'incrémente la taille de 1 lorsque qu'elle est inférieur à la taille max. Cependant, je ne suis pas sûr à 100% que ce soit la bonne manière de faire.

// Fonction qui modifie le nom du fichier
void MV(const char *filesystem_path, const char *old_filename, const char *new_filename) {
size_t sizeNew_filename = strlen(new_filename);
size_t sizeOld_filename = strlen(old_filename);
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
int fileFound = 0;

// Parcourir les blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {

readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char*)filenameBuffer, old_filename, MAX_FILENAME_LENGTH) == 0) {

if (sizeNew_filename < MAX_FILENAME_LENGTH) {
sizeNew_filename+=1;
}

// Écrire le nom du fichier dans l'emplacement
writeBlock(blockNum, 0, (const unsigned char *)new_filename, sizeNew_filename);

fileFound=1;

break; // Nom modifié, sortir de la boucle
}
}
if (fileFound == 1) {
printf("Le nom du fichier \"%s\" a été renommé avec succès.\n", old_filename);
} else {
printf("Le fichier \"%s\" n'a pas été trouvé.\n", old_filename);
}
}

ReX : C'est bon. La fonction était triviale.

=== Fonction TYPE version 1 ===
void TYPE(const char *filesystem_path, const char *filename) {
size_t sizeFilename = strlen(filename);
unsigned char buffer[MAX_FILENAME_LENGTH];
int placeFound = -1;

if (sizeFilename > MAX_FILENAME_LENGTH) {
printf("Impossible de créer le fichier, nom trop long\n");
return;
}

// Parcours des blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, MAX_FILENAME_LENGTH);
// Vérifier si le bloc est vide (pas de nom de fichier)
if (buffer[0] == 0) {
// Écrire le nom du fichier dans l'emplacement vide du superbloc
if (sizeFilename < MAX_FILENAME_LENGTH) {
sizeFilename += 1; // Ajouter '\0' s'il y a de la place
}
writeBlock(blockNum, 0, (const unsigned char *)filename, sizeFilename);
placeFound = blockNum;

// Lire les données depuis l'entrée standard
unsigned char dataBuffer[BLOCK_SIZE];
size_t bytesRead;
int dataBlockNum = findAvailableBlock(); // Premier bloc de données à partir du bloc 1040
printf("dataBlockNum%d\n",dataBlockNum);
int blockSizeUsed = 0; // Compteur d'octets dans le bloc actuel
int dataBlocksNeeded = 1; // Nombre de blocs de données nécessaires

while ((bytesRead = fread(dataBuffer + blockSizeUsed, 1, BLOCK_SIZE - blockSizeUsed, stdin)) > 0) {
blockSizeUsed += bytesRead;

// Si le bloc actuel est plein, passer au bloc suivant
if (blockSizeUsed == BLOCK_SIZE) {
// printf("dataBlockNum=%d\n",dataBlockNum);
writeBlock(dataBlockNum, 0, dataBuffer, BLOCK_SIZE);
setBlockAvailability(dataBlockNum, 1);

dataBlockNum++; // Passer au bloc suivant
blockSizeUsed = 0; // Réinitialiser la taille utilisée
dataBlocksNeeded++;
}
}

// Écrire le dernier bloc partiel, s'il y en a un
if (blockSizeUsed > 0) {
writeBlock(dataBlockNum, 0, dataBuffer, blockSizeUsed);
setBlockAvailability(dataBlockNum, 1);
}

// Écrire les numéros de blocs utilisés dans le bloc de description
unsigned char blockNumberBuffer[2];
int currentBlockNum = 1040;

for (int i = 0; i < dataBlocksNeeded; i++) {
blockNumberBuffer[0] = (currentBlockNum >> 8) & 0xFF;
blockNumberBuffer[1] = currentBlockNum & 0xFF;
writeBlock(placeFound, MAX_FILENAME_LENGTH + i * 2, blockNumberBuffer, 2);
currentBlockNum++;
}

break; // Fichier créé, sortir de la boucle
}
}

if (placeFound != -1) {
printf("Le fichier \"%s\" a été créé avec succès.\n", filename);
} else {
printf("Plus de place dans le système de fichier pour créer ce fichier.\n");
}
}

ReX : La constante 1040 ne doit pas apparaître en numérique, ce doit être une constante calculée à partir des autres constantes.

Amine: Ok. Je ne l'avais pas défini comme une constante car il s'agit dans la fonction ci-dessus d'une variable qui est incrémenté à chaque itération.

ReX : Je suis las de te répéter que le mémoire est comptée : tu utilises encore un bloc de <code>BLOCK_SIZE</code> octets, c'est trop.

Amine: Comment utiliser des blocs plus petit sachant qu'il s'agit là de blocs de données et qu'un bloc fait 256 octets d'après l'énoncé ? Dois-je les subdiviser en plusieurs blocs plus petit comme fait dans la fonction RM, en 4 blocs de 64 octets par exemple ?

Fonctionnement de la fonction TYPE:

* étape 1: on parcourt les blocs de descriptions à la recherche d'un bloc disponible. Si on ne trouve pas de bloc disponible, on renvoie un message d'erreur, sinon on passe à l'étape suivante.
* étape 2: Si on trouve un emplacement libre dans les blocs de disponibilité, on écrit le nom du fichier dans cet emplacement.

ReX : Dans les blocs de description de fichiers pas dans les blocs de disponibilité.

Amine: Oui autant pour moi.

* étape 3: Ensuite, on lit le texte entré par l'utilisateur en entrée standard, on le répartit dans des blocs de taille BLOCK_SIZE, on met à jour la disponibilité des blocs utilisés.

ReX : Non, il faut appeler <code>findAvailableBlock</code> pour chaque bloc de données à utiliser, aucune certitudes que les blocs libres soient en séquence.

Amine: ok, je ferai cela dans la version 2

* étape 4: Enfin, on écrit les numéros des blocs de données utilisés dans les blocs de description de ce fichier, les numéros étant écris sur deux octets.

ReX : Non cela doit se faire au fur et à mesure des appels à <code>findAvailableBlock</code> et les numéros des blocs de données peuvent s'étaler sur les 16 blocs de description du fichier. Confusion totale sur ce point. Vous n'avez pas compris le mécanisme.

Amine: je corrige cela dans la version 2. J'ai bien compris le mécanisme mais ce n'est pas facile à traduire en code.

=== Fonction TYPE version 2 ===
Dans cette nouvelle version de TYPE, j'ai fait les modifications suivantes:

* j'appelle maintenant <code>findAvailableBlock</code> pour chaque bloc de données à utiliser
* j'écris maintenant les numéros de blocs au fur et à mesures des appels à <code>findAvailableBlock</code>
* je n'utilise plus de tableaux de taille 256 octets mais des tableaux de tailles CHUNK_SIZE. J'ai choisi ici CHUNK_SIZE = 64 octets.

J'utilise toujours un bloc de taille BLOCK_SIZE en attendant de comprendre si je dois diviser ce bloc en plusieurs blocs de taille plus petite ou s'il y a un moyen de ne pas du tout utiliser ces blocs.
void TYPE(const char *filesystem_path, const char *filename) {
size_t sizeFilename = strlen(filename);
unsigned char buffer[MAX_FILENAME_LENGTH];
int placeFound = -1;

if (sizeFilename > MAX_FILENAME_LENGTH) {
printf("Impossible de créer le fichier, nom trop long\n");
return;
}

// Parcours des blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, MAX_FILENAME_LENGTH);
// Vérifier si le bloc est vide (pas de nom de fichier)
if (buffer[0] == 0) {
// Écrire le nom du fichier dans l'emplacement vide du superbloc
if (sizeFilename < MAX_FILENAME_LENGTH) {
sizeFilename += 1; // Ajouter '\0' s'il y a de la place
}
writeBlock(blockNum, 0, (const unsigned char *)filename, sizeFilename);
placeFound = blockNum;

// Lire les données depuis l'entrée standard et écrire dans le fichier
int dataBlockNum = findAvailableBlock(); // Premier bloc de données à partir du bloc 1040
printf("Premier bloc dans lequel on écrit = %d\n", dataBlockNum);
int blockSizeUsed = 0; // Compteur d'octets dans le bloc actuel

unsigned char chunkBuffer[CHUNK_SIZE];
size_t bytesRead;

while ((bytesRead = fread(chunkBuffer, 1, CHUNK_SIZE, stdin)) > 0) {
// Écrire le chunk dans le bloc de données
writeBlock(dataBlockNum, blockSizeUsed, chunkBuffer, bytesRead);
setBlockAvailability(dataBlockNum, 1);

// Écrire le numéro du bloc actuel dans la description du fichier
unsigned char blockNumberBuffer[2];
blockNumberBuffer[0] = (dataBlockNum >> 8) & 0xFF;
blockNumberBuffer[1] = dataBlockNum & 0xFF;
writeBlock(placeFound, MAX_FILENAME_LENGTH + dataBlockNum * 2, blockNumberBuffer, 2);

blockSizeUsed += bytesRead;

// Si le bloc actuel est plein, passer au bloc suivant
if (blockSizeUsed == BLOCK_SIZE) {
dataBlockNum = findAvailableBlock(); // Passer au bloc suivant
blockSizeUsed = 0; // Réinitialiser la taille utilisée
}
}

break; // Fichier créé, sortir de la boucle
}
}

if (placeFound != -1) {
printf("Le fichier \"%s\" a été créé avec succès.\n", filename);
} else {
printf("Plus de place dans le système de fichier pour créer ce fichier.\n");
}
}

=== Fonction findAvailableBlock ===
Cette fonction renvoie l'indice du premier bloc disponible. Je me sers de cette fonction dans la fonction TYPE.
#define FIRST_DATA_BLOCK 1040
#define FIRST_DISPONIBILITY_CARD_BLOCK 1024

// Renvoie le premier bloc de donné disponible
int findAvailableBlock() {
unsigned char availabilityBuffer[BLOCK_SIZE];
int offset;

// Lire la carte de disponibilité (à partir du bloc 1)
for (int blockNum = FIRST_DISPONIBILITY_CARD_BLOCK; blockNum < FIRST_DATA_BLOCK; blockNum++) {
readBlock(blockNum, 0, availabilityBuffer, BLOCK_SIZE);

if (blockNum==FIRST_DISPONIBILITY_CARD_BLOCK) {
offset=FIRST_DATA_BLOCK/8;
} else {
offset=0;
}

// Parcourir les octets de la carte de disponibilité
for (int byteIndex = offset; byteIndex < BLOCK_SIZE - offset; byteIndex++) {
unsigned char byte = availabilityBuffer[byteIndex];

// Parcourir les bits de chaque octet
for (int bitIndex = 0; bitIndex < 8; bitIndex++) {
// Vérifier si le bit est à 0 (bloc disponible)
if ((byte & (1 << bitIndex)) == 0) {
// Calculer l'indice du bloc en fonction du bloc et du bit
int blockIndex = byteIndex * 8 + bitIndex;
return blockIndex;
}
}
}
}

// Aucun bloc disponible trouvé
return -1;
}

ReX : Même remarque que précédement sur les nombres 1024 et 1040.

Amine: Ok, j'ai remplacé 1024 par la constante FIRST_DISPONIBILITY_CARD_BLOCK et 1040 par la constante FIRST_DATA_BLOCK dans la fonction ci-dessus.

ReX : Vous n'avez toujours pas compris la contrainte sur la mémoire.

Amine: dois-je découper le bloc de taille BLOCK_SIZE en quatre blocs de taille 64 octets par exemple ?

ReX : Je ne vois pas ce que vous voulez faire avec <code>if (blockNum==1024) offset=1040/8; else offset=0;</code>.

Amine: dans la carte de disponibilité, chaque bit correspond à un bloc. Ainsi, les bits de 0 à 1040 dans la carte de disponibilité décrivent la disponibilité des blocs 0 à 1040. Or ces blocs correspondent au superbloc, et dans cette fonction, on veut connaître le premier bloc de données disponible. On ne s'intéresse donc pas au 1040 premiers bits de la carte de disponibilité. Je crée donc un offset égal à 1040/8 afin de ne pas prendre en compte les 1040 premiers bits soit les 1040/8=130 premiers octets. Cet offset ne s'applique que lorsqu'on se trouve dans le premier des 16 blocs de la carte de disponibilité, d'où la condition <code>if (blockNum==1024)</code>.

=== Fonction CAT version 1 ===
void CAT(const char *filesystem_path, const char *filename) {
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
unsigned char buffer[BLOCK_SIZE];
unsigned char blockNumberBuffer[2];
unsigned char dataBuffer[BLOCK_SIZE];
int offset;

// Parcours des blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char *)filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {
// Le nom du fichier a été trouvé

// Parcours les blocs de description
for (int descrBlockNum=0; descrBlockNum<MAX_BLOCKS_PER_FILE_DESCRIPTION; descrBlockNum++) {
if (descrBlockNum==0) {
offset=16;
} else {
offset=0;
}
readBlock(descrBlockNum+blockNum, offset, buffer, BLOCK_SIZE-offset);

// Lire les numéros de blocs associés à ce fichier depuis les blocs de description
unsigned char octet1 = buffer[offset];
unsigned char octet2 = buffer[offset+1];

int dataBlockNum = (octet1 << 8) | octet2;
printf("dataBlockNum=%d\n",dataBlockNum);

// Vérifier si le numéro de bloc est valide (non nul)
if (dataBlockNum == 0) {
return; // Fin du fichier
}

// Lire et afficher le contenu du bloc de données
readBlock(dataBlockNum, 0, dataBuffer, BLOCK_SIZE);
fwrite(dataBuffer, 1, BLOCK_SIZE, stdout);
}

return; // Fichier affiché, sortie de la fonction
}
}

// Si le fichier n'a pas été trouvé
printf("Le fichier \"%s\" n'a pas été trouvé.\n", filename);
}

ReX : Encore mieux : deux blocs de <code>BLOCK_SIZE</code> en mémoire.

ReX : Le <code>break</code> ne sort pas de la boucle externe.

Amine: Oui c'est vrai. J'ai remplacé le break pas un return ci-dessus.

Voici ma fonction <code>CAT</code>. Elle fonctionne en plusieurs étape:

* étape 1: on cherche dans les blocs de descriptions si le fichier dont on veut afficher le contenu existe. Si le nom de fichier est trouvé, on passe à l'étape 2. Sinon, on renvoie un message d'erreur.
* étape 2: si le fichier est trouvé, on parcours les 16 blocs de description de ce fichier.
* étape 3: grâce aux opérations de masquage et de décalage, on joint les octets deux par deux pour former un entier qui contient le numéro du bloc de données correspondant au fichier. Si cet entier vaut 0, alors cela signifie qu'il n'y a plus de blocs associé à ce fichier, on peut donc quitter la fonction. Si cet entier est différent de 0, alors on va lire le bloc correspondant à ce numéro et on affiche son contenu dans le terminal.

== Semaine 7 ==

=== Fonction CP version 1 ===
Voici ma fonction CP, qui permet de créer une copie d'un fichier existant. L'idée est la suivante: pour copier un fichier, on doit créer un nouveau fichier et lui attribuer les mêmes blocs de descriptions que le fichier source. Ainsi, le fichier source et le fichier destination pointeront vers les mêmes blocs de données, et auront le même contenu.

ReX : Perdu. Ce n'est absolument pas la fonction de copie de fichiers d'un système de fichiers.

Amine: Après avoir fait des recherches et après réflexion, je me rends compte que cette fonction CP présente un problème: en faisant pointé les blocs de données du fichier destination vers ceux du fichier source, toutes modifications du fichier source impactera le fichier destination, or ce n'est pas ce qu'on veut faire. Je vous propose donc une nouvelle version de la fonction CP ci-dessous qui remédie à ce problème.

void CP(const char *filesystem_path, const char *source_filename, const char *destination_filename) {
unsigned char source_filenameBuffer[MAX_FILENAME_LENGTH];
unsigned char destination_filenameBuffer[MAX_FILENAME_LENGTH];
unsigned char descriptionBuffer[BLOCK_SIZE];
int destination_offset;
int offset;

// Recherche du fichier source
int source_offset = -1;
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, source_filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier source
if (strncmp((const char *)source_filenameBuffer, source_filename, MAX_FILENAME_LENGTH) == 0) {
source_offset = blockNum;
break;
}
}

if (source_offset == -1) {
printf("Le fichier source \"%s\" n'a pas été trouvé.\n", source_filename);
return;
}

// Recherche d'un emplacement libre pour le fichier destination
destination_offset = -1;
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, destination_filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc est vide (pas de nom de fichier)
if (destination_filenameBuffer[0] == 0) {
destination_offset = blockNum;
break;
}
}

if (destination_offset == -1) {
printf("Plus de place dans le système de fichier pour créer la copie de \"%s\".\n", source_filename);
return;
}

// Ecrit le nom de la copie dans le bloc de description
writeBlock(destination_offset, 0, (const unsigned char *)destination_filename, strlen(destination_filename));

// Copier les blocs de description associés au fichier source dans les blocs de description du fichier destination
for (int i = 0; i < MAX_BLOCKS_PER_FILE_DESCRIPTION; i++) {
if (i==0) {
offset = MAX_FILENAME_LENGTH;
} else {
offset = 0;
}

readBlock(source_offset+i, offset, descriptionBuffer, BLOCK_SIZE-offset);
if (descriptionBuffer[offset]==0) {
return;
} else {
writeBlock(destination_offset+i, offset, descriptionBuffer, BLOCK_SIZE-offset);
}
}

printf("La copie de \"%s\" sous le nom \"%s\" a été créée avec succès.\n", source_filename, destination_filename);
}

== Semaine 8 ==
A ce stade du projet, les fonctions suivantes ont été validé par Monsieur Redon:

* fonction LS
* fonction RM
* fonction MV

Il reste donc les fonctions suivantes à terminer:

* fonction CAT
* fonction CP
* fonction TYPE

=== Fonction CAT version 2 ===
Suite à vos remarques sur la version 1, j'ai fais les modifications suivantes:

* je n'utilise non plus 2 tableaux de taille BLOCK_SIZE, mais 1 seul. Idéalement il faudrait en utiliser 0, je réfléchi donc à m’émanciper de ce tableau en le remplaçant par plusieurs plus petits tableaux.
* J'ai remplacé le <code>break</code> par un return

Cette fonction permet d'afficher le contenu d'un fichier créé avec la fonction TYPE. Pour se faire, on parcours tout d'abord les blocs de descriptions pour trouver le fichier dont ont veut afficher le contenu. Une fois ce fichier trouvé, on parcours les 16 blocs de description de ce fichier 1 à 1. Pour chacun de ces blocs de description, on va stocker récupéré les octets deux par deux afin de former des entiers. Pour se faire, on utilise la fonction <code>reconsituteNumber</code> que l'on détaillera juste après. Ces entiers correspondent aux blocs dans lesquels la donné du fichier se trouve. Une fois l'entier reconstitué, on affiche le contenu du bloc correspondant.
void CAT(const char *filesystem_path, const char *filename) {
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
unsigned char byteBuffer[2];
unsigned char dataBuffer[BLOCK_SIZE];
int offset;

// Parcours des blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char *)filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {
// Le nom du fichier a été trouvé

// Parcours les blocs de description
for (int descrBlockNum=0; descrBlockNum<MAX_BLOCKS_PER_FILE_DESCRIPTION; descrBlockNum++) {
if (descrBlockNum==0) {
offset=MAX_FILENAME_LENGTH;
} else {
offset=0;
}

// Lecture des octets deux par deux
for (int i=0; i<BLOCK_SIZE;i+=2) {
readBlock(descrBlockNum+blockNum, offset+i, byteBuffer, 2);

// Lire les numéros de blocs associés à ce fichier depuis les blocs de description
int dataBlockNum = reconsituteNumber(byteBuffer);

// Vérifier si le numéro de bloc est valide (non nul)
if (dataBlockNum == 0) {
return; // Fin du fichier
}

// Lire et afficher le contenu du bloc de données
readBlock(dataBlockNum, 0, dataBuffer, BLOCK_SIZE);
fwrite(dataBuffer, 1, BLOCK_SIZE, stdout);
}
}

return; // Fichier affiché, sortie de la fonction
}
}

// Si le fichier n'a pas été trouvé
printf("Le fichier \"%s\" n'a pas été trouvé.\n", filename);
}

=== Fonction reconsituteNumber ===
Cette fonction permet de reconstituer un numéro de bloc à partir de deux octets.
// Fonction qui reconstitue le numéro de bloc à partir du tableau
int reconsituteNumber(unsigned char blockNumberBuffer[2]) {
unsigned char octet1 = blockNumberBuffer[0];
unsigned char octet2 = blockNumberBuffer[1];
int dataBlockNum = (octet1 << 8) | octet2;
return dataBlockNum;
}

=== Fonction CP version 2 ===
Voici une version mise à jour de notre fonction CP. Dans la version précédente, on faisait pointer le fichier source vers les même blocs que le fichier destination. Cela posait un problème: toute modification du fichier source impactait le fichier destination. Ainsi, dans cette nouvelle version, on fait une duplication des blocs de données du fichier source vers le fichier destination. Cela implique donc une mise à jour de la carte de disponibilité, ainsi que l'adaptation des blocs de descriptions. En effet, seulement les blocs de données sont maintenant identiques, plus les blocs de description.

Piste d'amélioration: comme pour la fonction CAT ci-dessus, j'utilise toujours un bloc de taille 256 octets, je vais devoir y remédier.
void CP(const char *filesystem_path, const char *source_filename, const char *destination_filename) {
unsigned char source_filenameBuffer[MAX_FILENAME_LENGTH];
unsigned char destination_filenameBuffer[MAX_FILENAME_LENGTH];
unsigned char descriptionBuffer[BLOCK_SIZE];
unsigned char numBuffer[2];
int destination_offset;
int source_offset;
int offset;
int numDataBlock;

// Recherche du fichier source
source_offset = -1;
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, source_filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier source
if (strncmp((const char *)source_filenameBuffer, source_filename, MAX_FILENAME_LENGTH) == 0) {
source_offset = blockNum;
break;
}
}

if (source_offset == -1) {
printf("Le fichier source \"%s\" n'a pas été trouvé.\n", source_filename);
return;
}

// Recherche d'un emplacement libre pour le fichier destination
destination_offset = -1;
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, destination_filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc est vide (pas de nom de fichier)
if (destination_filenameBuffer[0] == 0) {
destination_offset = blockNum;
break;
}
}

if (destination_offset == -1) {
printf("Plus de place dans le système de fichier pour créer la copie de \"%s\".\n", source_filename);
return;
}

// Copie du nom de la copie dans le bloc de description
writeBlock(destination_offset, 0, (const unsigned char *)destination_filename, strlen(destination_filename));

// Copier les blocs de données associés au fichier source dans de nouveaux blocs de données pour le fichier destination
for (int i = 0; i < MAX_BLOCKS_PER_FILE_DESCRIPTION; i++) {
if (i == 0) { offset = MAX_FILENAME_LENGTH; }
else { offset = 0; }

// Lecture des numéros de bloc dans les blocs de description
for (int byteNum=0; byteNum<BLOCK_SIZE; byteNum+=2) {
readBlock(source_offset + i, offset + byteNum, numBuffer, 2);

numDataBlock = reconsituteNumber(numBuffer);
if (numDataBlock == 0) {
return;
}

// On stocke le bloc de données associé au fichier source dans descriptionBuffer
readBlock(numDataBlock, 0, descriptionBuffer, BLOCK_SIZE);

// Trouver un nouveau bloc de données disponible
int newDataBlock = findAvailableBlock();

// Ecriture du bloc de données dans le premier bloc disponible
writeBlock(newDataBlock, 0, descriptionBuffer, BLOCK_SIZE);

// Mise à jour de la carte de disponibilités
setBlockAvailability(newDataBlock, 1);

// Ecriture du numéro de bloc dans la description du fichier
numBuffer[0] = (newDataBlock >> 8) & 0xFF;
numBuffer[1] = newDataBlock & 0xFF;
writeBlock(destination_offset+i, offset+byteNum, numBuffer, 2);
}
}

printf("La copie de \"%s\" sous le nom \"%s\" a été créée avec succès.\n", source_filename, destination_filename);
}

=== Fonction TYPE version 3 ===
La fonction 2 que j'ai fourni ci-dessus n'est pas correcte. Je vais la corrigé dans cette version 3

= Compilation et exécution =
'''Création du système de fichiers :'''
dd if=/dev/zero of=filesystem.bin bs=256 count=32768

'''Compilation :'''

gcc picofs.c -o picofs

'''Exécution de LS, TYPE, CAT, RM, MV ou CP :'''

./picofs filesystem.bin LS
./picofs filesystem.bin TYPE mon_fichier.txt
./picofs filesystem.bin CAT mon_fichier.txt
./picofs filesystem.bin RM mon_fichier.txt
./picofs filesystem.bin MV mon_fichier.txt mon_fichier2.txt
./picofs filesystem.bin CP mon_fichier.txt mon_fichier2.txt

= Documents Rendus =
[[Fichier:Pcfs.c.tar|vignette]]

SE4 2022/2023 EC1

2023-09-02T16:19:34Z

Asellali : /* Fonction CP version 2 */

= Objectifs =

Il vous est demandé de :
* réaliser un micro système de fichiers ;
* le système de fichiers doit résider dans un fichier de 8 Mo ;
* le système de fichiers est géré par un exécutable obtenu à partir d'un programme C ;
* L'éxécutable prend deux arguments, le premier est le chemin du fichier dans lequel réside le système de fichiers, les paramètres suivants concernent l'action à appliquer sur le système de fichiers ;
* le micro système de fichier ne comporte qu'un répertoire : le répertoire principal, le répertoire principal peut comporter au maximum 64 fichiers, un fichier est caractérisé par un nom de 16 caractères au maximum et ses blocs de données, un fichier peut comporter au maximum 2040 blocs de données ;
* un bloc de données fait 256 octets et les blocs sont numérotés sur 2 octets ;
* les différentes actions possibles sur le système de fichiers sont :
** <code>TYPE</code> pour créer un fichier si possible, le nom du fichier suit la commande, le contenu du fichier est donné en entrée standard de l'exécutable ;
** <code>CAT</code> pour afficher un fichier, le nom du fichier suit la commande ;
** <code>RM</code> pour détruire un fichier, le nom du fichier suit la commande ;
** <code>MV</code> pour renommer un fichier, les noms original et nouveau du fichier suivent la commande ;
** <code>CP</code> pour copier un fichier, les noms de l'original et de la copie du fichier suivent la commande ;

= Matériel nécessaire =

Un PC sous Linux.

= Travail réalisé =

== Semaine 1 ==

ReX : attention, ce micro-système de fichiers est prévu pour un microcontrôleur, vos variables globales ne peuvent pas dépasser quelques centaines d'octets.

ReX : pour la création du système de fichiers la commande <code>dd</code> suffit, vous voulez dire le formatage du système de fichiers ?

* création du programme programme.c contenant les différentes structures et les différentes fonctions.
* Piste d'amélioration: faire en sorte que la fonction CAT affiche le contenu exact des fichiers passés en argument.

Le code fourni est un programme en langage C qui simule un système de fichiers basique. Ce programme permet aux utilisateurs d'effectuer diverses actions telles que créer, afficher, supprimer, renommer et copier des fichiers dans un système de fichiers simulé. Le système de fichiers est stocké dans un fichier binaire.

ReX : vous n'avez pas tenu compte de la première remarque, vous chargez tout le superbloc et le répertoire racine, votre code ne convient pas.

ReX : vos structures utilisent des types entiers dont la taille n'est pas explicitée, utilisez les types de <code>stdint.h</code>.

ReX : la création de fichier n'est pas fonctionnelle, vous ne cherchez pas les blocs libres, vous ne copiez pas le contenu du fichier dans les blocs, même remarque pour toutes les autres fonctions.

ReX : il manque les fonctions d'accès aux pages du système de fichiers.

'''Explication du programme programme.c'''

Voici une brève explication des principaux éléments et fonctions du code :

# Structures :
#* Fichier : Représente un fichier dans le système de fichiers. Il contient un nom (nom) avec une longueur maximale de 16 caractères, un tableau de numéros de bloc (blocs) où le contenu du fichier est stocké (jusqu'à 2040 blocs), et le nombre de blocs utilisés par le fichier (nbBlocs).
#* Repertoire : Représente le répertoire principal du système de fichiers. Il contient un tableau de fichiers (<code>fichiers</code>) et le nombre de fichiers dans le répertoire (<code>nbFichiers</code>).
# Fonctions :
#* <code>chargerSystemeFichiers</code> : Charge le système de fichiers à partir d'un fichier binaire donné (chemin) dans une structure Repertoire.
#* <code>sauvegarderSystemeFichiers</code> : Sauvegarde le système de fichiers stocké dans la structure Repertoire dans un fichier binaire (chemin).
#* <code>creerFichier</code> : Crée un nouveau fichier dans le système de fichiers avec un nom et un contenu donnés. Le contenu du fichier est simulé en le divisant en blocs.
#* <code>afficherFichier</code> : Affiche le contenu d'un fichier avec le nom spécifié.
#* <code>detruireFichier</code> : Supprime un fichier avec le nom spécifié du système de fichiers.
#* <code>renommerFichier</code> : Renomme un fichier avec l'ancien nom spécifié en un nouveau nom.
#* <code>copierFichier</code> : Copie un fichier avec le nom spécifié en créant un nouveau fichier avec le nom de copie spécifié.
# Fonction <code>main</code> :
#* La fonction <code>main</code> est le point d'entrée du programme.
#* Elle prend des arguments en ligne de commande : <code><chemin_systeme_fichiers></code> et <code><action></code>.
#* <code><chemin_systeme_fichiers></code> est le chemin vers le fichier binaire où le système de fichiers est stocké.
#* <code><action></code> détermine quelle opération effectuer, comme <code>TYPE</code>, <code>CAT</code>, <code>RM</code>, <code>MV</code> ou <code>CP</code>.
#* En fonction de l'action spécifiée, le programme appelle la fonction correspondante pour effectuer l'opération souhaitée sur le système de fichiers.
Remarque : Le code fourni une simulation basique d'un système de fichiers et de ses opérations, mais il n'interagit pas réellement avec un système de fichiers réel sur le disque.

'''Comment utiliser le programme programme.c'''

étape 1: création du système de fichiers respectant le cahier des charges:

dd if=/dev/zero of=systeme_fichiers.bin bs=1M count=8

étape 2: compilation du programme C:

gcc programme.c -o gestionnaire_fs

étape 3: création d'un fichier dans le système de fichier:

./gestionnaire_fs systeme_fichiers.bin TYPE fichier1.txt

-> entrer le texte en entrée standard

étape 4: manipulation des différentes fonctions. Exemples:

./gestionnaire_fs systeme_fichiers.bin CAT fichier1.txt
./gestionnaire_fs systeme_fichiers.bin CP fichier1.txt copie.txt
./gestionnaire_fs systeme_fichiers.bin RM copie.txt
./gestionnaire_fs systeme_fichiers.bin MV fichier1.txt fichier2.txt

== Semaine 2 ==

Amine: Merci pour vos remarques. Désolé de ne pas avoir suivi votre première remarque, je pensais avoir compris ce qu'il fallait faire mais je me rend compte que non. Je vais tout reprendre depuis le début afin de repartir sur de bonnes bases.

'''Création du système de fichier avec la commande "dd"'''

A quoi sert la commande dd?

La commande <code>dd</code> permet de copier tout ou partie d'un disque par blocs d'octets, indépendamment de la structure du contenu du disque en fichiers et en répertoires (source : [https://doc.ubuntu-fr.org/dd]).

Structure de la commande

dd if=<nowiki><source> of=<cible> bs=<taille des blocs></nowiki>

<code>source</code> = données à copier

<code>cible</code> = endroit où les copier

<code>if</code> = input file

<code>of</code> = output file

<code>bs</code> = block size, habituellement une puissance de 2 supérieure ou égale à 512, représentant un nombre d'octets

Choix de la commande:

Pour la source, on prends <code>/dev/zero</code>: cela permet de créer un fichier rempli de 0. Ce fichier servira de base pour notre système de fichiers.

Pour la cible, on va l'appeler <code>filesystem.bin</Code> : ce sera notre système de fichier.

Pour la taille des blocs, on veut des blocs de données de 256 octets d'après l'enoncé. On va donc prendre <code>bs=256</code>.

Enfin, on veut que le système de fichier réside dans un fichier de 8 Mo. On va donc ajouter <code>count=31250</code>: cela indique que nous voulons écrire 32768 blocs de données dans le fichier (31250 * 256 octets = 8 Mo).

Résultat:

dd if=/dev/zero of=filesystem.bin bs=256 count=31250

Question pour M. Redon : j'ai ici essayé de respecter votre remarque "pour la création du système de fichiers la commande <code>dd</code> suffit". Cependant, pour votre seconde remarque "vous chargez tout le superbloc et le répertoire racine, votre code ne convient pas.", je ne suis pas sûr de comprendre où je fais cela: est-ce lors de la commande dd ou est-ce par la suite avec mon programme C? J'ai un peu modifié la commande dd comme vous pouvez le voir ci-dessus. Ai-je corrigé mon erreur avec cette nouvelle commande? J'ai essayé de justifier au maximum la commande dd que j'ai choisie.

ReX : Pas de problème avec la commande <code>dd</code> (mettez tous les extraits de code entre des balises <code>code</code>). Le problème est au niveau du programme C.

Amine: Ok je comprends mieux merci. Je vais donc reprendre le code étape par étape afin de mieux répondre au cahier des charges.

Gestion du système de fichier par un programme C

'''Création des structures'''
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>

// Structure pour représenter un bloc de données

struct DataBlock {
uint8_t data[256]; // 256 octets pour chaque bloc de données
};

// Structure pour représenter un fichier

struct File {
char filename[17]; // 16 caractères pour le nom du fichier + 1 caractère null-terminator
struct DataBlock data_blocks[2040]; // Tableau de blocs de données pour stocker le contenu du fichier
uint16_t num_data_blocks; // Nombre de blocs de données utilisés par le fichier
};

// Structure pour représenter un répertoire

struct Directory {
struct File files[64]; // Tableau de fichiers pour le répertoire principal
uint8_t num_files; // Nombre de fichiers dans le répertoire principal
};

Modification faite : suite à votre remarque, j'ai explicité la taille des entiers grâce aux types de <code>stdint.h.</code> (j'ai également mis les variables en anglais)

ReX : Vous ne pouvez pas utiliser ces structures, une instanciation d'une de ces structure prend trop d'espace mémoire, vous devez faire sans structure. Par ailleurs la façon dont vous représentez vos fichiers ne convient pas, la description d'un fichier contient des numéros de blocs, pas les blocs eux-même. Faites aussi attention qu'un fichier soit décrit par un nombre entier de blocs.

Question pratique: je n'arrive pas à mettre tout le code dans le même bloc comme vous l'avez fait ci-dessus dans l'étape 4 de la semaine 1. Je vois que c'est en format "préformaté" mais j'obtiens des blocs séparés lorsque j'applique ce format à mon code.

ReX : j'ai corrigé, pour un code entier la syntaxe n'est pas la même (un espace en début de chaque ligne), la balise c'est uniquement pour de très courts extraits de code.

=== Fonction <code>readBlock</code>===
Cette fonction est utilisée pour lire un bloc de données à partir du fichier <code>filesystem.bin</code> et le stocker dans un tableau de caractères (<code>storage</code>).

Fonction:

#define BLOCK_SIZE 256
// Fonction pour lire un bloc de données
void readBlock(unsigned int num, int offset, unsigned char *storage, int size) {
FILE *file = fopen("filesystem.bin", "rb");
if (file == NULL) {
perror("Erreur lors de l'ouverture du fichier");
return;
}
fseek(file, num * BLOCK_SIZE + offset, SEEK_SET);
fread(storage, 1, size, file);
fclose(file);
}

Paramètres :

* <code>num</code> : Numéro du bloc à lire. Chaque bloc contient 256 octets (1 bloc = 256 octets).
* <code>offset</code> : Décalage (en octets) à partir du début du bloc pour commencer la lecture.
* <code>storage</code> : Pointeur vers un tableau de caractères où les données lues seront stockées.
* <code>size</code> : Taille du tableau de caractères <code>storage</code>.

Fonctionnement :

* La fonction commence par ouvrir le fichier <code>filesystem.bin</code> en mode lecture binaire (<code>"rb"</code>).
* Elle utilise <code>fseek</code> pour positionner le curseur de lecture dans le fichier à l'endroit approprié pour commencer la lecture du bloc spécifié (<code>num</code>) à partir de l'offset (<code>offset</code>).
* Elle utilise ensuite <code>fread</code> pour lire <code>size</code> octets à partir du fichier et les stocker dans le tableau <code>storage</code>.
* Enfin, elle ferme le fichier avec <code>fclose</code>.

Note : Le paramètre <code>offset</code> est utilisé pour spécifier à partir de quel octet du bloc on souhaite commencer la lecture. Si <code>offset</code> est égal à 0, la lecture commencera depuis le début du bloc. Si <code>offset</code> est différent de 0, la lecture commencera à l'octet spécifié.

Remarque: dans votre mail, vous définissez "readBlock(unsigned int num,int offset,unsigned storage,int size)": storage n'est alors pas un pointeur vers un tableau de caractère. Je me suis donc permis de faire la modification.

ReX : OK pour la fonction, pas la peine d'en mettre autant dans le Wiki pour une fonction aussi simple.

=== Fonction <code>writeBlock</code> ===
Cette fonction est utilisée pour écrire un bloc de données dans le fichier <code>filesystem.bin</code> à partir d'un tableau de caractères (<code>storage</code>).

Fonction:

// Fonction pour écrire un bloc de données
void writeBlock(unsigned int num, int offset, const unsigned char *storage, int size) {
FILE *file = fopen("filesystem.bin", "rb+");
if (file == NULL) {
perror("Erreur lors de l'ouverture du fichier");
return;
}
fseek(file, num * BLOCK_SIZE + offset, SEEK_SET);
fwrite(storage, 1, size, file);
fclose(file);
}

Paramètres :

* <code>num</code> : Numéro du bloc où écrire.
* <code>offset</code> : Décalage (en octets) à partir du début du bloc pour commencer l'écriture.
* <code>storage</code> : Pointeur vers un tableau de caractères contenant les données à écrire dans le fichier.
* <code>size</code> : Taille du tableau de caractères <code>storage</code>.

Fonctionnement :

* La fonction commence par ouvrir le fichier <code>filesystem.bin</code> en mode lecture et écriture binaire (<code>"rb+"</code>).
* Elle utilise <code>fseek</code> pour positionner le curseur de lecture/écriture dans le fichier à l'endroit approprié pour commencer l'écriture du bloc spécifié (<code>num</code>) à partir de l'offset (<code>offset</code>).
* Elle utilise ensuite <code>fwrite</code> pour écrire <code>size</code> octets à partir du tableau <code>storage</code> dans le fichier.
* Enfin, elle ferme le fichier avec <code>fclose</code>.

ReX : Même remarque que pour la fonction précédente.

'''Etape 4: test des fonctions <code>readBlock</code> et <code>writeBlock</code> dans le main'''
// Exemple de fonction principale pour tester les opérations de lecture et d'écriture
int main() {
unsigned char data[BLOCK_SIZE];
// Test de la fonction readBlock
readBlock(0, 0, data, BLOCK_SIZE);
printf("Block 0, offset 0: ");
for (int i = 0; i < BLOCK_SIZE; i++) {
printf("%02x ", data[i]);
}
printf("\n");
// Test de la fonction writeBlock
unsigned char newData[BLOCK_SIZE] = {
0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88,
// ... Autres données du bloc ...
};
writeBlock(1, 0, newData, BLOCK_SIZE);
// Lecture du bloc nouvellement écrit pour vérifier
readBlock(1, 0, data, BLOCK_SIZE);
printf("Block 1, offset 0: ");
for (int i = 0; i < BLOCK_SIZE; i++) {
printf("%02x ", data[i]);
}
printf("\n");
return 0;
}

Fonctionnement :

* On déclare tout d'abord un tableau de caractères <code>data</code> de taille <code>BLOCK_SIZE</code> pour stocker les données lues du bloc.
* Ensuite, la fonction <code>readBlock</code> est appelée avec les arguments (0, 0, data, BLOCK_SIZE) pour lire le premier bloc du fichier (<code>num=0</code>, <code>offset=0</code>) et stocker les données dans <code>data</code>.
* Ensuite, la fonction <code>printf</code> est utilisée pour afficher les données lues du bloc (<code>data</code>) en format hexadécimal.
* Ensuite, un nouveau tableau de caractères <code>newData</code> est créé avec des données spécifiques pour tester la fonction <code>writeBlock</code>.
* La fonction <code>writeBlock</code> est appelée avec les arguments (1, 0, newData, BLOCK_SIZE) pour écrire le tableau <code>newData</code> dans le deuxième bloc du fichier (<code>num=1</code>, <code>offset=0</code>).
* Enfin, la fonction <code>readBlock</code> est appelée à nouveau pour lire le deuxième bloc nouvellement écrit et afficher les données lues en format hexadécimal.

Question générale : ce que j'avais la première semaine n'est plus forcément d'actualité. Puis-je supprimer les choses qui ne le sont plus afin d'alléger la page ou préférez-vous que je laisse?

ReX : Laissez.

Pour la suite : j'ai donc pour l'instant crée deux fonctions, l'une permettant la lecture et l'autre l'écriture d'un bloc, de manière à économiser la mémoire. Pour la suite, je vais essayer de créer la fonction <code>LS</code> en utilisant la fonction <code>readBlock</code>.

ReX : Oui c'est le début du projet. Mais si vous n'avez pas une bonne description de fichier cela ne donnera rien. Voir remarques plus haut.

'''Etape 5: fonction <code>LS</code>'''

Objectif: créer la fonction <code>LS</code> avec la fonction readBlock.

Question: Souhaitez-vous la fonction <code>LS</code> classique, c'est à dire la fonction <code>LS</code> qui affiche simplement le nom des fichiers présent dans le répertoire ?

ReX : Oui. Tu peux ajouter la taille si tu trouves cela trop simple.

Piste : si c'est ce que vous voulez:

* il va tout d'abord falloir que je crée des fichiers, un fichier étant composé d'un nom et de blocs (création d'une fonction createFile)
* Il faudra ensuite que je stocke ces fichiers dans le répertoire (création d'une fonction addFileToDirectory par exemple)
* enfin, il faudra que j'affiche le nom des fichiers. Pour cela, il faudra que je parcours le répertoire (structure "Directory"), puis que pour chaque fichier présent dans le répertoire que j'affiche son nom (création de la fonction LS)

Je devrais surement utiliser la fonction readBlock afin de transférer les blocs dans le fichier au travers de la variable "storage".

ReX : Créer des fichiers n'est pas nécessaire tout de suite je verrais bien si ton code est bon sans test. Laisse tomber <code>createFile</code> et <code>addFileToDirectory</code> pour l'instant.

ReX : Ton algorithme ne fonctionne pas pour un microcontrôleur où il faut économiser la mémoire, tu ne peux pas t'aider de structures. Il faudra que tu charges les noms et seulement les noms, pour la taille il faudra se baser sur le nombre de blocs.

'''Etape 6: rectification du code suite à vos remarques'''

Modifications apportées:

* suppression des structures afin d’économiser de la mémoire.

* le problème quant à la description des fichiers est normalement résolu puisque plus de structures. On ne charge plus les blocs mais seulement les noms de fichiers.

ReX : Non car si les noms ne sont pas répartis de façon régulière dans les blocs de 256 octets tu vas avoir du mal à les charger. Mais écrit la fonction <code>LS</code> et tu verras ce que je veux dire.

J'ai également ajouté deux nouvelles fonctions:

# <code>void readFileName(unsigned int file_num, char *file_name)</code>: Cette fonction permet de lire le nom du fichier associé au numéro de fichier donné (<code>file_num</code>). Elle stocke le nom du fichier lu dans le tableau <code>file_name</code>.
# <code>void writeFileName(unsigned int file_num, const char *file_name)</code>: Cette fonction permet d'écrire le nom du fichier dans le système de fichiers, associé au numéro de fichier donné (<code>file_num</code>). Elle prend en entrée le nom du fichier à écrire (<code>file_name</code>).

Suite: si vous validez cette base, je pourrai passer à la création de la fonction LS.

ReX : tu peux y aller. Je ne vois pas le code des tes deux fonctions <code>readFileName</code> et <code>writeFileName</code>.

Voici le code des fonctions <code>readFileName</code> et <code>writeFileName</code> :

'''Fonction readFileName:'''
// Fonction pour lire le nom du fichier
void readFileName(unsigned int file_num, char *file_name) {
readBlock(file_num, 0, (unsigned char *)file_name, MAX_FILENAME_LENGTH);
file_name[MAX_FILENAME_LENGTH] = '\0'; // Ajout du caractère null-terminator pour former une chaîne de caractères
}

ReX : Non, aucune raison que le fichier de numéro n soit au bloc n. Dessine la représentation d'un fichier sur le SF en comptant les octets si cela peut aider.

'''Fonction writeFileName:'''
// Fonction pour écrire le nom du fichier
void writeFileName(unsigned int file_num, const char *file_name) {
writeBlock(file_num, 0, (const unsigned char *)file_name, MAX_FILENAME_LENGTH);
}

ReX : Faux et inutile pour l'instant. Problème avec la constante MAX_FILENAME_LENGTH.

=== Fonction LS version 1 ===
// Fonction LS pour afficher les fichiers présents dans le système de fichiers
void LS(const char *filesystem_path) {
FILE *file = fopen(filesystem_path, "rb");
if (file == NULL) {
perror("Erreur lors de l'ouverture du fichier système");
return;
}
uint16_t num_files;
fread(&num_files, sizeof(uint16_t), 1, file); // Lecture du nombre de fichiers dans le système
char filename[17];
printf("Fichiers présents dans le système de fichiers:\n");
for (int i = 0; i < num_files; i++) {
readFileName(i, filename); // Lecture du nom du fichier
printf("%s\n", filename); // Affichage du nom du fichier
}
fclose(file);
}
La fonction <code>LS</code> ouvre le fichier système, lit le nombre de fichiers qu'il contient, puis affiche les noms des fichiers un par un, chacun sur une ligne séparée.

ReX : Il y a le nombre de fichiers dans ton superbloc ? Un dessin du format du superbloc avec les numéros des octets ?

ReX : Tout accès au système de fichiers doit se faire avec les deux fonctions <code>readBlock</code> et <code>writeBlock</code>.

== Semaine 3 ==
Question 1: cela fait plusieurs fois que vous mentionnez dans le wiki un "superbloc". Celui-ci n'étant pas clairement défini dans le sujet, je me demande s'il s'agit du bloc crée grâce à la fonction dd, c'est à dire que le superbloc serait en faite le bloc constitué des 31250 blocs de taille 256 octets, où s'il s'agit d'un bloc qui vient en entête, celui contenant alors des informations décrivant le système de fichier (les noms de fichiers...).

ReX : Pour ton pico système de fichiers, le superbloc consiste en les premiers blocs (de 256 octets) qui définissent les 64 fichiers possibles.

Proposition de structure: on pourrait réserver les premiers blocs du système de fichiers aux noms de fichiers ainsi qu'aux numéros des blocs correspondant à chaque fichier.

ReX : Oui c'est évident.

On sait que les noms de fichiers font au maximum 16 caractères + 1 caractère pour le '\0' (donc 17 octets car 1 char=1 octet).

ReX : Non, 16 octets suffisent, des '\0' en fin de nom uniquement si le nom fait moins de 16 caractères.

On sait également qu'un fichier contient au maximum 2040 blocs, chaque bloc étant numéroté sur 2 octets. On pourrait donc avoir en début du système de fichier: 17 octets+2 octets*2040 blocs = 4097 octets pour la description d'un fichier.

ReX : Non, 4096 octets soit 16 blocs de 256.

Or d'après l'une de vos remarques dans le wiki, un fichier doit être décrit par un nombre entier de blocs. Pour un fichier, il nous faudra donc 4097/256=16.004 soit 17 blocs. Il peut y avoir jusqu'à 64 fichiers dans le répertoire, il nous faudra donc 17 blocs*64 fichiers= 1088 blocs pour la description des fichiers.

ReX : Non 1024 blocs de 256 octets dans le superbloc.

Ainsi, pour la fonction LS, il suffira de lire les premiers caractères tous les 17 blocs ( du premier caractère au caractère '\0').

ReX : Non, tous les 16 blocs.

Question 2: Ne faudrait-il pas également stocker quelque part le nombre de fichier qu'il y a dans le répertoire afin de savoir jusqu'à quel bloc la fonction LS doit aller ?

ReX : Non, un fichier dont le nom n'est constitué que de '\0' est réputé ne pas exister.

Question 3: on a donc vu que les 1088 premiers blocs au maximum serviraient à la description du système de fichier. Il reste donc 31250-1088=30132 blocs dans le système de fichier.

ReX : Non, 32768-1024=31744 blocs.

Comment utiliser ces blocs? Ces blocs doivent-ils stocker le contenu des fichiers ?

ReX : Oui, c'et évident.

En effet, avec la fonction TYPE, nous allons créer des fichiers et ces fichiers devront être stockés quelque part. Cependant, étant donné que ce pico système de fichiers est prévu pour un microcontrôleur, je ne sais pas si c'est le contenu des fichiers qui doit être stocké dans les blocs ou autre chose (peut être l'adresse des fichiers, le fichiers se trouvant autre part). En effet, je me dis que si un fichier est très volumineux, il ne pourra pas rentrer dans le système de fichier, ce dernier étant composé d'un nombre limité de blocs, et les blocs étant eux même limité en nombre d'octets.

ReX : Je ne comprend pas ton problème. De tout façon comme dit plus haut, les 31744 blocs suivant le superbloc doivent contenir les données des fichiers.

Désolé de poser des questions peut être basique aussi tard, mais je pense qu'une fois que j'aurai ces réponses, cela ira beaucoup mieux pour la suite. Merci d'avance pour vos réponses.

ReX : Les questions sont effectivement triviales et il est effectivement inquiétant que voir que la travail n'avance pas.

Amine: merci pour vos corrections.

D'après votre commentaire "32768-1024=31744 blocs", j'en déduis qu'il faut que je modifie ma commande dd (qui est actuellement "dd if=/dev/zero of=filesystem.bin bs=256 count=31250" pour avoir le bon filesystem).

ReX : Je comprends pas d'où tu sors le 31250. D'autant plus que la commande ci-dessous est bonne.

Amine : 31250 car 31250 blocs * 256 octets = 8 Mo.

ReX : Haaaa je vois tu utilises le système métrique international où le mégaoctet vaut 10^6 octets, sauf qu'aucun informaticien n'utilisera cette norme hors sol. Quand je parle de 8 Mo c'est 8x1024x1024 octets. Tout simplement parce qu'une puce mémoire de 8 Mo c'est bien 8x1024x1024 octets.

Amine: D'accord merci pour l'information !

'''Nouvelle commande dd:'''

dd if=/dev/zero of=filesystem.bin bs=256 count=32768

=== Fonction LS version 2 ===

Dans notre structure du système de fichier, le superbloc est constitué de 1024 blocs (16 blocs * 64 fichiers), un fichier étant décrit par 16 blocs. Le nom du fichier est donc écrit au début de tous les blocs multiples de 16. Par exemple, le nom du premier fichier est dans les 16 premiers octets du premier bloc, le nom du 2ème fichier est dans les 16 premiers octets du 32ème bloc et ainsi de suite, tant que des fichiers existent. Lorsque qu'il n'y a plus de fichier, le nom du premier caractère du bloc multiple de 16 est un 0.

Voici le code:
// Fonction pour lister les noms de fichiers présents dans le système de fichiers
void LS() {
unsigned char buffer[BLOCK_SIZE];
int fileCount = 0;

for (int blockNum = 1; blockNum <= MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, BLOCK_SIZE);

// Vérifier si le bloc est vide
if (buffer[0] == 0) {
break; // Plus de fichiers à lire
}

char filename[MAX_FILENAME_LENGTH];
memcpy(filename, buffer, MAX_FILENAME_LENGTH);

// Afficher le nom du fichier
printf("%s\n", filename);
fileCount++;
}

if (fileCount == 0) {
printf("Aucun fichier trouvé.\n");
}
}

ReX : Tu supposes que si un fichier a un nom vide, les suivants auront aussi un nom vide. C'est possible mais dans ce cas la commande <code>RM</code> ca être plus compliquée à écrire.

ReX : Tu ne sembles pas comprendre que la mémoire d'un microcontrôleur est limitée. Pourquoi lire le premier bloc de description d'un fichier en entier ? Dit autrement c'est quoi l'intérêt de lire 256 octets alors que 16 suffisent ?

ReX : Pourquoi tu ne lis pas le premier fichier ? Autrement dit pourquoi décaler tout d'un bloc ?

Amine: Merci pour vos remarques. J'ai apporté les modifications à LS dans la section "Semaine 4" du wiki.

'''Réflexion par rapport aux autres fonctions:'''

J'ai créé les fonctions TYPE et CAT mais il y a malheureusement un problème pour l'instant. Vous pouvez les retrouver en pièce jointe dans l'archive du fichier programme.c.

Le problème que j'ai est que lorsque j'affiche le contenu du fichier créé avec TYPE, j'obtiens plein de caractères spéciaux. Par exemple, je créé le fichier "mon_fichier.txt" avec la fonction TYPE, et je mets en entré standard "hello". Ensuite, je veux afficher le contenu de ce fichier grâce à la fonction CAT. Cependant, ce qui s'affiche dans le terminal n'est pas ce que je veux. De la même manière, lorsque je fais la commande "cat filesystem.bin" dans le terminal, c'est la même chose s'affiche, des donnés parasites.

ReX : Avant même de lire ton code je vais te poser la question de savoir comment tu récupères un bloc libre ? Quel algorithme tu utilises. Personnellement je ne sais pas faire sans ajouter au superbloc un tableau bit à bit des blocs libres. Pour avoir un bit pour chaque bloc du système de fichiers, il faut 32768/8=4096 octets soit 16 blocs.

Amine: ok je vais donc ajouter ce tableau de 16 blocs à la suite de mes premiers 1024 blocs servant à la description de fichier. Le superbloc fera maintenant 1024+16=1040 blocs (plus de détail à la fonction RM de la semaine 4).

Question 1: est ce que la fonction CAT que je dois créer doit renvoyer la même chose que "cat filesystem.bin" ?

ReX : Je préfère ne pas répondre tellement la question montre un manque de réflexion.

Question 2: comment savoir combien de blocs doivent etre attribué à un fichier? Par exemple, si je créé un fichier "mon_fichier.txt" et que je mets en entrée standard le texte "hello", un seul bloc suffi pour stocker ce texte. Cependant, si j'avais mis beaucoup de texte en entrée standard, il aurait fallu plus de blocs. Doit-on calculer la taille de l'entrée standard ou doit-on attribuer toujours le meme nombre de blocs à un fichier? Peut-etre ainsi attribuer 2040 blocs par fichier, meme s'il n'en utilise que 1.

ReX : Là encore c'est une question stupéfiante tellement la réponse est évidente. Il suffit de lire les données sur l'entrée standard et de passer au bloc de données suivant dès que le bloc courant est rempli. La question à poser c'était de se demander comment il est possible d'avoir la taille exacte du fichier pour un <code>CAT</code>. Il est uniquement possible de l'avoir à 256 octets près puisque rien n'indique si le dernier block est vide. Le mieux aurait été de prévoir 4 octets dans la description d'un fichier pour stocker la taille. En l'espèce on considérera que les fichiers sont des fichiers ASCII et qu'ils seront terminés par des <code>\'0</code> qui ne seront pas affichés.

== Semaine 4 ==

Voici un bilan de ce que j'ai fait à ce stade du projet:

* j'ai choisi une structure du système de fichier
* j'ai créé les fonctions readBlock et writeBlock permettant de lire et d'écrire des blocs
* j'ai crée la fonction LS permettant d'afficher le nom des fichiers présents dans le système de fichiers
* j'ai programmer un main permettant d'utiliser les fonctions (LS, TYPE...) depuis le terminal
* j'ai réflechi aux fonctions TYPE et CAT.

Actuellement, je suis en train de créer les fonctions TYPE et CAT.

=== Fonction LS version 3 ===
void LS() {
unsigned char buffer[MAX_FILENAME_LENGTH];
int fileCount = 0;

// Parcourir tous les 16 blocs de 0 jusqu'à MAX_FILES_IN_DIRECTORY
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, MAX_FILENAME_LENGTH);

// Vérifier si le nom de fichier est vide
if (buffer[0] != 0) {

// Afficher le nom du fichier
printf("%s\n", buffer);
fileCount++;
}
}

if (fileCount == 0) {
printf("Aucun fichier trouvé.\n");
}
}
Suite à vos remarques, j'ai effectué les modifications suivantes de la fonction LS:

* Je ne suppose plus que si un fichier a un nom vide, les autres auront aussi un nom vide.
* Je ne lis plus les 256 octets mais seulement les 16 premiers octets car cela suffit.
* Je ne lisais en effet pas le premier bloc. Je pensais que le premier bloc était d'indice 1 mais ce n'est pas le cas.

ReX : Ouiiii ! Une fonction correcte. Passe à <code>RM</code> maintenant, c'est la plus facile à faire concernant l'image bit à bit des blocs libres.

=== Fonction setBlockAvailability version 1 ===

Comme vous l'avez indiqué dans votre remarque, il faut un tableau dans le superbloc qui nous permettra de connaitre la disponibilité bit par bit de chaque bloc. Sachant qu'il y a dans notre système de fichiers 32768 blocs, et qu'il faut 1 bit par bloc, nous avons besoin de 32768 bits, soit 32768/8=4096 octets soit 4096/256=16 blocs. Notre superbloc sera donc comme suit: les 1024 premiers blocs servent à la description des fichiers, c'est à dire à leur nom suivi des numéros de blocs qui leur sont associés, puis ces 1024 blocs sont suivi de 16 blocs listant la disponibilité de chaque bloc.

ReX : Bien résumé.

Nous allons tout d'abord écrire la fonction "setBlockAvailability" prenant en paramètre le numéro du bloc à traiter (<code>blockNum</code>) et la disponibilité souhaitée pour ce bloc (<code>availability</code>). Cette fonction permet de marquer la disponibilité d'un bloc spécifique dans le système de fichiers. Nous utiliserons la convention suivante: un bloc disponible sera marqué par un 1 tandis qu'un bloc non disponible par un 0.
#define SUPERBLOCK_START_BLOCK 1024

void setBlockAvailability(int blockNum, int availability) {
// Calculer l'index du byte et le bit offset correspondant
int byteIndex = blockNum / 8;
int bitOffset = blockNum % 8;

// Lire le byte existant du bloc de disponibilité des blocs
unsigned char buffer[1];
readBlock(SUPERBLOCK_START_BLOCK + byteIndex, 0, buffer, 1);

// Mettre à jour le bit d'offset correspondant
if (availability) {
buffer[0] |= (1 << bitOffset);
} else {
buffer[0] &= ~(1 << bitOffset);
}

// Écrire le byte mis à jour dans le bloc de disponibilité des blocs
writeBlock(SUPERBLOCK_START_BLOCK + byteIndex, 0, buffer, 1);
}

ReX : Un tableau de un octet c'est un octet (variable <code>buffer</code>).

Amine: je vais utiliser un <code>unsigned char buffer.</code> Je suis conscient qu'un char vaut un octet mais je ne pense pas qu'il y ait un type de donnée de la taille d'un bit, c'est pourquoi je travaille avec un octet mais je modifie les bits de cet octet grâce aux algorithmes.

ReX : Il faut bien que tu travailles sur un octet vu que l'état des blocs est stocké sous la forme d'octets. Je disais juste qu'un tableau de 1 élément n'a pas d'intérêt par rapport à l'élément lui-même.

Amine: c'est vrai, modification faite.

ReX : Non il faut calculer le numéro du bloc avant de faire le <code>readBlock</code>.

Amine: ok je vais calculer le numéro de bloc avant.

ReX : La mise à jour du bit est correcte mais le block et le déplacement dans le block ne sont pas correctement calculés.

Amine: je vais vous expliquer le raisonnement que j'avais. Prenons un exemple concret, imaginons que je veuille marquer le bloc 1030 comme disponible:

# Calcul de l'index de l'octet et du bit offset :
#* <code>blockNum</code> = 1030
#* Index du byte = 1030 / 8 = 128
#* Bit offset = 1030 % 8 = 6
# Lecture de l'octet existant de disponibilité:
#* Nous lisons l'octet existant à l'index 128 dans les blocs de disponibilité.
# Mise à jour du bit de disponibilité :
#* Nous voulons marquer le bloc 1030 comme disponible, donc nous utilisons le masque <code>(1 << 6)</code> pour définir le bit 6 à 1 dans l'octet. Le résultat sera, par exemple, <code>00100000</code>.
# Écriture du byte mis à jour :
#* Nous écrivons le byte mis à jour <code>00100000</code> à l'index 128 dans les blocs de disponibilité.

ReX : Ben non, un vrai exemple :
* Il faut prendre un n° de bloc plus grand : 3072 ;
* Numéro d'octet dans la carte des blocs libres : 3072/8=384 ;
* Numéro du bloc dans la carte des blocs libres : 384/256=1 ;
* Numéro du bit <code>b</code> dans l'octet n° 384-256=128 du bloc 1 : 3072%8=0 ;
* Il faut donc lire l'octet <code>o</code> de numéro 128 du bloc 1, puis modifier cet octet par <code>o |= (1<<b)</code> ou <code>o &= ~(1<<b)</code> ;
* Enfin il faut écrire l'octet modifié dans le bloc 1.
Amine: merci pour cet exemple! J'ai compris d'où vient mon erreur. Voir fonction setBlockAvailability version 3.

Remarque: par convention, j'apellerai dans la suite de ce projet "premier superbloc" le superbloc correspondant à la description des fichiers, c'est à dire les 1024 premiers blocs, et j'appellerai "second superbloc" les 16 blocs qui suivent servant à décrire la disponibilité des blocs (du bloc 1024 au bloc 1039 inclu). Le reste des blocs servira à stocker les données.

ReX : Non, le superblc est l'ensemble des informations hors blocs de données, tu ne peux pas utiliser un vocabulaire au hasard. Parle de blocs de description des fichiers ou de carte des blocs libres.

Amine: ok

Je pense que le problème qui se pose est que l'indice du bit dans le second superbloc ne correspond pas à l'indice du bloc dans le système de fichier. Par exemple, nous voudrions que si le bloc 1030 est disponible dans le système de fichier, alors le bit numéro 1030 du deuxième superbloc soit à 1, ce qui n'est pas le cas ici. En effet, on se trouve bien dans le bon octet avec ma méthode mais l'écriture du bit se fait de la droite vers la gauche alors qu'on voudrait l'inverse. Ainsi, si le 6ème bit de l'octet doit être à 1, alors il faudrait qu'on obtienne <code>00000100</code> et non <code>00100000.</code> L'indice du bit coinciderait ainsi avec le numéro du bloc.

ReX : Non, réfléchit à nouveau.

Voir plus bas la nouvelle version de setBlockAvailability.

Explication de l'algorithme pour mettre le bit à 1 ou 0:

* <code>buffer[0] |= (1 << bitOffset);</code> : Cette ligne utilise l'opérateur OR bit à bit (<code>|=</code>) pour activer (mettre à 1) le bit spécifié par <code>bitOffset</code> dans le premier octet (<code>buffer[0]</code>). Cela se fait en décalant le bit 1 vers la gauche de <code>bitOffset</code> positions, puis en effectuant une opération OR bit à bit avec le contenu actuel de <code>buffer[0]</code>. Cette opération modifie uniquement le bit ciblé, laissant les autres bits inchangés.

ReX : Oui ça c'est bon.

* <code>buffer[0] &= ~(1 << bitOffset);</code> : Cette ligne utilise l'opérateur AND bit à bit (<code>&=</code>) pour désactiver (mettre à 0) le bit spécifié par <code>bitOffset</code> dans <code>buffer[0]</code>. Pour ce faire, l'expression <code>~(1 << bitOffset)</code> est utilisée pour créer un masque où tous les bits sont à 1, sauf celui correspondant à <code>bitOffset</code>, qui est à 0. En effectuant ensuite une opération AND bit à bit entre le masque et le contenu actuel de <code>buffer[0]</code>, on met à 0 le bit ciblé sans affecter les autres bits.

ReX : Ca aussi.

=== Fonction setBlockAvailability version 2 ===

void setBlockAvailability(int blockNum, int availability) {
// Calculer l'indice de l'octet et le bit offset correspondant
int byteIndex = blockNum / 8;
int bitOffset = 7 - (blockNum % 8); // Inversion de l'ordre des bits

// Calculer le numéro du bloc du super bloc où se trouve l'octet de disponibilité correspondant
int availabilityBlockNum = SUPERBLOCK_START_BLOCK + byteIndex;

// Lire l'octet existant dans le bloc de disponibilité du super bloc
unsigned char buffer;
readBlock(availabilityBlockNum, 0, &buffer, 1);

// Mettre à jour le bit d'offset correspondant :
if (availability) {
buffer |= (1 << bitOffset);
} else {
buffer &= ~(1 << bitOffset);
}

// Écrire l'octet mis à jour dans le bloc de disponibilité du super bloc
writeBlock(availabilityBlockNum, 0, &buffer, 1);
}
J'ai modifié la ligne <code>int bitOffset = 7 - (blockNum % 8);</code> pour inverser l'ordre des bits sélectionnés, de sorte que le bit correspondant au bloc disponible soit correct.

ReX : Encore plus faux.

Si on veut rendre le bloc 1030 indisponible alors que les autres blocs sont disponibles:

ReX : Pardon ? Le bloc de données est libre ou pas suivant la carte des blocs libres. Le rendre disponible n'est possible que si un fichier le comportant est détruit.

# Calcul de l'indice de l'octet et du bit offset correspondant :
#* <code>blockNum = 1030</code>
#* <code>byteIndex = 1030 / 8 = 128</code>
#* <code>bitOffset = 7 - 1030 % 8 = 1</code> Cela signifie que le bit d'intérêt se trouve à la position 2 dans l'octet.
# Calcul du numéro du bloc du super bloc où se trouve l'octet de disponibilité correspondant :
#* <code>availabilityBlockNum = SUPERBLOCK_START_BLOCK + 128 = 1024 + 128 = 1152</code> Donc, nous devons accéder à l'octet 1152 pour mettre à jour la disponibilité du bloc 1030.
# Lecture de l'octet existant dans le bloc de disponibilité du super bloc :
#* Le contenu de l'octet dans le bloc 1152 avant la mise à jour : 11111111 (en binaire)
# Mise à jour du bit d'offset correspondant :
#* Supposons que nous voulions marquer le bloc 1030 comme non disponible (<code>availability = 0</code>).
#* Le bitOffset est 1.
#* Nous effectuons une opération AND avec le complément du bit à la position 1 : <code>11111111 & 11111101 = 11111101</code>
# Écriture de l'octet mis à jour dans le bloc de disponibilité du super bloc :
#* Le contenu de l'octet 128 du second superbloc après la mise à jour : 11111101 (en binaire)

ReX : Toujours aussi faux.

Maintenant, le bit d'indice 1 du 128 ème octet du second superbloc est mis à 0, indiquant que le bloc 1030 n'est plus disponible. Les autres bits restent inchangés car nous avons effectué un AND avec un masque binaire qui avait des 1 partout sauf à la position du bit que nous souhaitions mettre à 0.

ReX : Erreur sur erreur.

=== Fonction setBlockAvailability version 3 ===
J'ai compris d'où vient l'erreur. La fonction readBlock prends en premier paramètre le numéro du bloc à lire, je ne peux donc pas lui donner la valeur "SUPERBLOCK_START_BLOCK + byteIndex" car byteIndex s'exprime en octet alors qu'on s'attend à un nombre de bloc ici. Il faut donc divisé byteIndex par 256 pour être en unité "bloc", et préciser le bit qu'on veut lire grâce à l'offset.

Pour obtenir l'octet que l'on veut, il faut prendre le reste de la division de byteIndex par 256. On va ensuite stocker cet octet dans notre "buffer".

Pour savoir quel bit modifier dans ce "buffer", on va prendre le reste de la division du bloc dont on veut mettre à jour la disponibilité par 8. On va ainsi pouvoir modifier ce bit grâce à l'algorithme, puis réécrire l'octet à son emplacement d'origine.

Cette fonction gère la carte de disponibilités des blocs. Si un bloc est disponible, alors elle le met un 0, si il est indisponible, elle met un 1.
#define SUPERBLOCK_START_BLOCK 1024

void setBlockAvailability(int blockNum, int availability) {

int byteIndexInCard = blockNum / 8; //Numéro d'octet dans la carte des blocs libres
int blockIndexInCard = byteIndexInCard / 256; //Numéro du bloc dans la carte des blocs libres
int byteIndexInBlock = byteIndexInCard % 256; //Numéro d'octet dans le bloc contenant le bit de disponibilité
int bitOffset = blockNum % 8; //Numéro du bit dans l'octet n°byteIndexInBlock du bloc blockIndexInCard

//indice du bloc contenant le bit à mettre à jour dans le bloc de description
int availabilityBlockNum = FIRST_DISPONIBILITY_CARD_BLOCK + blockIndexInCard;

// Lire l'octet existant dans le bloc de disponibilité du super bloc
unsigned char buffer;
readBlock(availabilityBlockNum, byteIndexInBlock, &buffer, 1);

// Mettre à jour le bit d'offset correspondant :
if (availability==1) { // indisponible
buffer |= (1 << bitOffset); // Mettre le bit à 1

} else { // disponible
buffer &= ~(1 << bitOffset); // Mettre le bit à 0
}

// Écrire l'octet mis à jour dans le bloc de disponibilité du super bloc
writeBlock(availabilityBlockNum, byteIndexInBlock, &buffer, 1);
}

ReX : Ben voila, c'est pas possible de te taxer d'excès de vitesse mais c'est bon.

update: j'ai fait une petite modification, maintenant un bloc disponible est marqué d'un 0 et un bloc indisponible est marqué d'un 1. C'est mieux dans la mesure où initialement, tous les blocs sont disponibles et tous les blocs sont à 0. Cela évite de devoir créer une fonction qui initialise toute la carte de disponibilités à 1 pour dire que tous les blocs sont disponibles.

=== Fonction RM version 1 ===

void RM(const char *filesystem_path, const char *filename) {
unsigned char buffer[BLOCK_SIZE];
int fileNum = -1;

// Parcourir les blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (memcmp(filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {
// Effacer le nom du fichier dans le superbloc
memset(filenameBuffer, 0, MAX_FILENAME_LENGTH);
writeBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

unsigned char fileBuffer[MAX_BLOCKS_PER_FILE * 2];
readBlock(blockNum, MAX_FILENAME_LENGTH, fileBuffer, MAX_BLOCKS_PER_FILE * 2);

// Libérer les blocs associés au fichier et réinitialiser les numéros de blocs
for (int i = 0; i < MAX_BLOCKS_PER_FILE * 2; i += 2) {
int blockNum = ((int)fileBuffer[i] << 8) + (int)fileBuffer[i + 1];
if (blockNum == 0) {
break; // Fin du fichier
}
setBlockAvailability(blockNum, 0); // Marquer le bloc comme disponible
fileBuffer[i] = 0;
fileBuffer[i + 1] = 0;
}

// Mettre à jour les numéros de blocs associés au fichier
writeBlock(blockNum, MAX_FILENAME_LENGTH, fileBuffer, MAX_BLOCKS_PER_FILE * 2);

fileNum = blockNum;
break; // Fichier trouvé, sortir de la boucle
}
}

// Afficher le résultat de l'opération
if (fileNum == -1) {
printf("Le fichier \"%s\" n'a pas été trouvé.\n", filename);
} else {
printf("Le fichier \"%s\" a été supprimé avec succès.\n", filename);
}
}

ReX : Vous utilisez <code>strcmp</code> comme <code>strncmp</code>. C'est bien la dernière qu'il faut utiliser mais en précisant la longueur du nom en paramètre, pas la taille maximale.

Amine: vous voulez dire que j'utilise memcmp au lieu de strncmp ? Ok je vais utiliser strncmp, c'est vrai que c'est plus adapté pour la comparaison de chaines de caractère.

ReX : Ha oui c'est <code>memcmp</code> que tu utilises. Ca ne peut effectivement pas marcher. Effectivement avec <code>strncmp</code> cela peut marcher vu qu'il s'arrête au premier 0 contrairement à <code>memcmp</code>.

Cependant, pourquoi doit-on passer la taille exacte du nom du fichier en paramètre, et non la taille maximale d'un nom de fichier? En effet, cela semble fonctionner en mettant la taille maximale en paramètre, tandis que lorsque l'on met la taille exacte du nom du fichier, cela pose un problème: on ne compare plus toute la chaîne de caractère mais seulement une portion du nom complet. Ainsi, si je crée par exemple un fichier que j'appelle "file1", puis que j’exécute la fonction RM "/picofs filesystem.bin RM file" par exemple, alors le fichier file1 va être supprimé quand même car on ne comparera que strlen(file)=4 premiers caractères, qui sont les mêmes, donc la fonction considérera ces chaines comme identiques. On pourrait alors se dire qu'il faudrait alors prendre plutôt comme taille en paramètre de la fonction strlen la taille du nom du fichier se trouvant dans le système de fichier plutôt que celle du nom donné en paramètre de RM. Cependant, le même problème se pose si la taille du nom du fichier du système de fichier est plus petite que celle du nom du fichier passé en paramètre. Par exemple, si le fichier présent dans système de fichier est "file", et qu'on met la longueur de file en paramètre de la fonction strcmp, puis qu'on exécute la commande "/picofs filesystem.bin RM file5", alors file sera quand même supprimé, car on ne comparera que les strlen(file)=4 premiers caractère. Finalement, une solution serait de rajouter une condition qui vérifie que les deux chaînes sont de taille identiques pour pouvoir réaliser la comparaison sur la taille exacte du nom du fichier. Cependant, il me semble qu'en mettant MAX_FILENAME_LENGTH qui vaut 16 en paramètre, cela fonctionne directement. Vous pouvez tester cela en testant mon programme.

ReX : Ok pour <code>strncmp</code> avec la taille maximale d'un nom de fichier.

etape 1: créer un fichier :
./picofs filesystem.bin TYPE fichier.txt

etape 2: verifier que le fichier a bien été créé :
./picofs filesystem.bin LS

Le terminal renvoie bien "fichier.txt"

etape 3: essayer de supprimer le fichier en mettant une chaine troncature du nom du fichier créé :
./picofs filesystem.bin RM fich

le terminal renvoi <<Le fichier "fich" n'a pas été trouvé.>>, le fichier n'a donc pas été supprimé .

etape 4: essayer de supprimer le fichier en mettant un nom plus grand incluant "fichier.txt" :
./picofs filesystem.bin RM fichier.txtt

terminal renvoi <<Le fichier "fichier.txtt" n'a pas été trouvé.>>

etape 5: enfin, tester en mettant le nom exacte du fichier que l'on veut supprimer :
./picofs filesystem.bin RM fichier.txt

terminal renvoi <<Le fichier "fichier.txt" a été supprimé avec succès.>>

Finalement, on voit que cela fonctionne avec la taille maximale mise en paramètre. On pourrait reprocher à cette méthode de comparer des caractères dans le vide, ce qui n'est pas optimal dans une optique d'économie de mémoire qui est la notre, mais la taille maximale d'un nom de fichier étant relativement faible (16 octets), on peut peut-être négliger cela au vu de l'économie d'une opération supplémentaire (comparaison de la taille des chaines de caractères).

ReX : Le parcours des blocs de données du fichier est atroce. Il faut parcourir les numéros de blocs dans le premier bloc du fichier derrière le nom du fichier puis il faut parcourir le 15 autres blocs.

Amine: Ok, je vais corriger cela dans la version 2 de RM (voir semaine 5).

Fonctionnement de la fonction RM:

* Parcours des blocs réservés pour la description des fichiers (superbloc) à partir du bloc 0, en incrémentant de 16 à chaque itération pour accéder aux blocs de noms de fichiers.

ReX : OK.

* Dans chaque bloc de noms de fichiers, la fonction compare le nom de fichier recherché avec les noms stockés dans les 16 octets de chaque bloc.

ReX : Non la fonction ne fait pas ça par contre il faudrait, oui.

Amine: Je pensais que c'était ce que je faisais avec "memcmp(filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0)".

* Si le nom de fichier est trouvé, la fonction efface le nom du fichier dans le superbloc en remplaçant les 16 octets du bloc par des zéros.

ReX : OK.

* Ensuite, la fonction accède aux octets suivants du même bloc pour obtenir les numéros de blocs associés au fichier.

ReX : Non, la boucle sort largement du premier bloc.

* Pour chaque paire de numéros de blocs (2 octets chacun), la fonction convertit les octets en un numéro de bloc. Si le numéro de bloc est nul, cela signifie la fin des blocs associés au fichier, sinon, la fonction marque ce bloc comme disponible en utilisant la fonction <code>setBlockAvailability</code> et réinitialise les numéros de blocs dans le tableau à zéro.
* Les numéros de blocs réinitialisés sont ensuite réécrits dans le bloc de description du fichier.

ReX : L'idée est là mais vu que la boucle n'est pas bonne, rien ne peut marcher.

* La fonction affiche ensuite un message indiquant le résultat de l'opération : soit que le fichier a été supprimé avec succès, soit que le fichier n'a pas été trouvé.

== Semaine 5 ==

=== Fonction RM version 2 ===

Concernant les remarques que vous m'avez faites précédemment:

* j'utilise maintenant la fonction <code>strncmp</code> pour la comparaison des chaines de caractères
* j'ai normalement corrigé le parcours des blocs. Je parcours maintenant d'abord les blocs multiples de 16 à la recherche du bloc contenant le nom du fichier à supprimer. Puis je parcours les 16 blocs de description du fichier à supprimer, afin de récupérer les numéros de blocs, libérer ces blocs dans la carte de disponibilité et de réinitialiser ces blocs dans les blocs de données.

void RM(const char *filesystem_path, const char *filename) {
int fileFound = -1;
int offset;

// Parcourir les blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char*)filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {

// Effacer le nom du fichier dans le superbloc
memset(filenameBuffer, 0, MAX_FILENAME_LENGTH);
writeBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);
fileFound = 1;
offset = blockNum;
break;
}

}

// Fin de fonction si fichier inexistant
if (fileFound == -1) {
printf("Le fichier \"%s\" n'a pas été trouvé.\n", filename);
return;
}

unsigned char buffer[BLOCK_SIZE];
//bloc que l'on va remplir de 0 et mettre à la place des blocs de données
memset(buffer, 0, BLOCK_SIZE); //on rempli buffer de 0

for (int blockNum=offset; blockNum<offset + 16; blockNum++) {

//premier bloc de description, celui contenant le nom du fichier dans les 16 premiers octets
if (blockNum == offset) {

unsigned char fileBuffer[BLOCK_SIZE-MAX_FILENAME_LENGTH];
//bloc dans lequel on va stocker les blocs de description de fichier
readBlock(blockNum, MAX_FILENAME_LENGTH, fileBuffer, BLOCK_SIZE-MAX_FILENAME_LENGTH);

// Libérer les blocs associés au fichier dans la carte de disponibilités
// et dans les blocs de description
for (int i = MAX_FILENAME_LENGTH; i < BLOCK_SIZE-MAX_FILENAME_LENGTH; i += 2) {
int blockNumData = ((int)fileBuffer[i] << 8) + (int)fileBuffer[i + 1];
if (blockNumData == 0) {
break; // Fin du fichier
}
setBlockAvailability(blockNumData, 0); // Marquer le bloc comme disponible
fileBuffer[i] = 0;
fileBuffer[i + 1] = 0;
writeBlock(blockNumData, 0, buffer, BLOCK_SIZE); //on efface les blocs de données
}
writeBlock(blockNum, MAX_FILENAME_LENGTH, fileBuffer, BLOCK_SIZE-MAX_FILENAME_LENGTH);
//on efface le premier bloc de description

} else {
unsigned char fileBuffer[BLOCK_SIZE];
readBlock(blockNum, 0, fileBuffer, BLOCK_SIZE);

// Libérer les blocs associés au fichier dans la carte de disponibilités et dans les blocs de description
for (int i = 0; i < BLOCK_SIZE; i += 2) {
int blockNumData = ((int)fileBuffer[i] << 8) + (int)fileBuffer[i + 1];
if (blockNumData == 0) {
break; // Fin du fichier
}
setBlockAvailability(blockNumData, 0); // Marquer le bloc comme disponible
fileBuffer[i] = 0;
fileBuffer[i + 1] = 0;
writeBlock(blockNumData, 0, buffer, BLOCK_SIZE); //on efface les blocs de données
}
writeBlock(blockNum, 0, fileBuffer, BLOCK_SIZE); //on efface le bloc de description
}
}
printf("Le fichier \"%s\" a été supprimé avec succès.\n", filename);
}

ReX : Pour construire le nombre sur 16 bits utiliser le OU plutôt que l'addition.

ReX : Heu non, je ne lis pas cette fonction avec tout ce code dupliqué, la seule différence entre les deux alternative est la position de début de l'adresse du premier bloc de données (<code>MAX_FILENAME_LENGTH</code> dans un cas et 0 dans l'autre). Donc l'alternative ne doit servir qu'à initialiser ce début, le reste du code doit être factorisé.

ReX : Et corrige le code, tu utilises deux tableaux de blocs (perte mémoire), tu écris le bloc à zéro dans l'itération (perte CPU).

=== Fonction RM version 3 ===

Suite à vos remarques, j'ai réalisé les modifications suivantes:

* j'utilise maintenant le OU plutôt que l'addition pour construire le nombre sur 16 bits.

* j'ai factorisé le code grâce à la création de la variable <code>startOffset</code> valant 16 lorsqu'on se trouve dans le bloc contenant le nom du fichier et valant 0 lorsqu'on se trouve dans les autres.

* Pour ce qui est du fait que j'utilise 2 tableaux de blocs, j'ai du mal à voir comment faire avec 1 seul tableau de blocs car ces deux tableaux n'ont pas du tout le même rôle. Le tableau <code>fileBuffer</code> permet de stocker les 16 blocs de description d'un fichier un à un. Lorsqu'on stocke un bloc dans <code>fileBuffer</code>, on lit ensuite les octets un à un de ce bloc afin de former des numéros de blocs, et pour chaque numéro de bloc créé, on va réinitialiser le bloc correspondant dans les blocs de données. Pour cela, on a donc besoin d'un autre bloc qui viendra écraser les anciens blocs de données. C'est pourquoi j'ai créé un bloc <code>buffer</code>qui est composé de 0 et qui va écraser les blocs de données. On ne peut pas utiliser <code>fileBuffer</code> car on a besoin d'un bloc de zéros, et si on réinitialise <code>fileBuffer</code> on perd toute les données qui s'y trouvent. Une possibilité serait de relire le bloc de donné à chaque itération de la deuxième boucle for imbriquée; cela permettrait de pouvoir réinitialiser le tableau fileBuffer à chaque itérations de cette boucle afin de stocker ce bloc de 0 dans les blocs de données, puis de restocker dans ce même tableau le bloc de description. Cependant, je ne pense pas que ce soit optimal de faire autant appel à la fonction readBlock.

* j'ai créé une fonction resetBock qui permet comme son nom l'indique de reset un bloc en le remplissant de 0. Cela nous évite de créer deux tableaux de blocs dans RM, bien que je pense que cela revienne au même car on fait appel à une fonction qui créé un tableau de blocs. Quoi qu'il en soit, cela allège le code et cette fonction pourra surement me resservir par la suite.

void RM(const char *filesystem_path, const char *filename) {
int fileFound = -1;
int offset;
unsigned char fileBuffer[BLOCK_SIZE];

// Parcourir les blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char *)filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {
// Effacer le nom du fichier dans le superbloc
memset(filenameBuffer, 0, MAX_FILENAME_LENGTH);
writeBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);
fileFound = 1;
offset = blockNum;
break;
}
}

// Fin de fonction si fichier inexistant
if (fileFound == -1) {
printf("Le fichier \"%s\" n'a pas été trouvé.\n", filename);
return;
}

for (int blockNum = offset; blockNum < offset + 16; blockNum++) {
int startOffset = 0;
if (blockNum == offset) {
startOffset = MAX_FILENAME_LENGTH;
}
readBlock(blockNum, startOffset, fileBuffer, BLOCK_SIZE - startOffset);

// Libérer les blocs associés au fichier dans la carte de disponibilités et dans les blocs de description
for (int i = 0; i < BLOCK_SIZE - startOffset; i += 2) {
int blockNumData = (fileBuffer[i] << 8) | fileBuffer[i + 1];
if (blockNumData == 0) {
break; // Fin du fichier
}
setBlockAvailability(blockNumData, 0); // Marquer le bloc comme disponible
fileBuffer[i] = 0;
fileBuffer[i + 1] = 0;
resetBlock(blockNumData); //on efface les blocs de données
}
writeBlock(blockNum, startOffset, fileBuffer, BLOCK_SIZE - startOffset);
}
printf("Le fichier \"%s\" a été supprimé avec succès.\n", filename);
}
'''Fonction resetBlock'''
void resetBlock(unsigned int blockNum) {
unsigned char buffer[BLOCK_SIZE];
memset(buffer, 0, BLOCK_SIZE);

// Utiliser writeBlock pour écrire les données du buffer dans le bloc
writeBlock(blockNum, 0, buffer, BLOCK_SIZE);
}

ReX : Ca s'améliore. Mais pourquoi cette fonction <code>resetBlock</code> ? Tu crois que dans qu'un système de fichiers perd du temps à mettre à zéro les blocs de données libérés ? Si oui, regarde la page de manual de la commande <code>shred</code>, ça manque à ta culture.

Amine: Après avoir consulter le manual de la commande <code>shred</code>, je vois que cette commande écrit des données aléatoires sur l'emplacement du fichier sur le disque. Par défaut, <code>shred</code> effectue un certain nombre de passes (par exemple, 3 passes) pendant lesquelles il écrit des données aléatoires sur l'emplacement du fichier sur le disque. Après avoir écrit les données aléatoires, <code>shred</code> peut effectuer des passes supplémentaires pendant lesquelles il écrit des données nulles (des zéros) sur le même emplacement. L'objectif de <code>shred</code> est d'augmenter la sécurité en rendant plus difficile la récupération des données supprimées à l'aide d'outils de récupération de données.

Cependant, j'ai aussi consulté comment fonctionne la commande <code>rm</code> de linux, et je vois que cette commande libère l'espace occupé par le fichier en marquant les blocs associés comme disponibles. Cela signifie que les données peuvent encore être récupérées à l'aide d'outils de récupération de données, à moins que des mesures supplémentaires ne soient prises pour écraser physiquement l'espace avec des données aléatoires (c'est ce que fait l'utilitaire <code>shred</code>).

On va donc opter pour la deuxième option, c'est à dire qu'on ne va pas perdre notre temps à remettre à zéro les blocs de données libérés, on va simplement marquer les blocs correspondants comme étant disponibles. Cela nous permettra de nous émanciper de la fonction resetBlock et de n'avoir plus qu'un seul tableau de blocs.

ReX : Sinon lire un bloc complet de pointeurs de blocs de données en mémoire n'est pas forcément optimal. L'idéal serait de lire ces blocs morceau par morceau (de 64 octets par exemple). Certes un bloc serait traité en 4 lectures/écritures (ce qui ralentirait le traitement) mais on gagne en mémoire. Le mieux serait de mettre la taille des morceaux en constante pour pouvoir choisir entre vitesse d'exécution et utilisation mémoire.

Amine: d'accord je comprends. Je vais modifier la fonction pour qu'on puisse découper la lecture/écriture en plusieurs blocs.

=== Fonction RM version 4 ===
Modifications apportées:

* je ne réinitialise plus les blocs de données, je supprime simplement le pointeur du fichier vers les blocs de données et je désigne les blocs comme "disponible" dans le carte de disponibilités. J'ai donc supprimé la fonction resetBlock.

* je ne lis plus les blocs en une seule fois mais en plusieurs fois via la variable CHUNK_SIZE:

# J'ai introduit la constante <code>CHUNK_SIZE</code> pour définir la taille de chaque morceau que nous allons lire/écrire à la fois. Cela permet de découper les opérations en blocs plus petits.
# Dans la boucle <code>for</code> où on parcours les blocs à partir de <code>offset</code>, j'ai ajouté une boucle interne qui parcourt les données du bloc en morceaux de taille <code>CHUNK_SIZE</code>.
# À l'intérieur de la boucle interne, j'ai calculé la taille réelle du morceau (<code>chunkSize</code>) en prenant le minimum entre <code>CHUNK_SIZE</code> et la quantité de données restant à lire/écrire dans le bloc.
# J'ai modifié la fonction <code>readBlock</code> pour lire seulement la quantité de données spécifiée par <code>chunkSize</code> à partir de <code>chunkStart</code>. Ces données sont stockées dans le tableau <code>fileBuffer</code>.
# Ensuite, j'ai effectué les mêmes opérations de libération des blocs associés au fichier, en parcourant les données du morceau et en marquant les blocs comme disponibles.
# Finalement, j'ai utilisé la fonction <code>writeBlock</code> pour écrire le morceau de données modifié dans le bloc, en utilisant la même <code>chunkStart</code> pour déterminer où écrire les données.

#define CHUNK_SIZE 64

int min(int a, int b) {
return a < b ? a : b;
}

void RM(const char *filesystem_path, const char *filename) {
int fileFound = -1;
int offset;
unsigned char fileBuffer[BLOCK_SIZE];

// Parcourir les blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char *)filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {
// Effacer le nom du fichier dans le superbloc
memset(filenameBuffer, 0, MAX_FILENAME_LENGTH);
writeBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);
fileFound = 1;
offset = blockNum;
break;
}
}

// Fin de fonction si fichier inexistant
if (fileFound == -1) {
printf("Le fichier \"%s\" n'a pas été trouvé.\n", filename);
return;
}

for (int blockNum = offset; blockNum < offset + 16; blockNum++) {
int startOffset = 0;

if (blockNum == offset) {
startOffset = MAX_FILENAME_LENGTH;
}

for (int chunkStart = startOffset; chunkStart < BLOCK_SIZE; chunkStart += CHUNK_SIZE) {
int chunkSize = min(CHUNK_SIZE, BLOCK_SIZE - chunkStart);
readBlock(blockNum, chunkStart, fileBuffer, chunkSize);

for (int i = 0; i < chunkSize; i += 2) {
int blockNumData = (fileBuffer[i] << 8) | fileBuffer[i + 1];
if (blockNumData == 0) {
writeBlock(blockNum, chunkStart, fileBuffer, chunkSize);
printf("Le fichier \"%s\" a été supprimé avec succès.\n", filename);
return; // Sortir des boucles
}
setBlockAvailability(blockNumData, 0); // Marquer le bloc comme disponible
fileBuffer[i] = 0;
fileBuffer[i + 1] = 0;
}

writeBlock(blockNum, chunkStart, fileBuffer, chunkSize);
}
}

printf("Le fichier \"%s\" a été supprimé avec succès.\n", filename);
}

ReX : Si on trouve un n° de bloc de données à 0, il faut sortir des deux boucles les plus externes après avoir fait le <code>writeBlock</code>.

Amine: Modification faites ci-dessus. Maintenant, dès qu'on trouve un n° de bloc de données à 0 dans la boucle la plus interne, on effectue le <code>writeBlock</code> et ensuite on utilise <code>return</code> pour sortir des deux boucles les plus externes. Cela permet d'optimiser le code en évitant de continuer à traiter inutilement le reste des blocs.

ReX : Pas très propre (duplication de code) mais nous allons nous en contenter.

=== Fonction intermédiaire TYPE version 1 ===

J'ai également commencé à réfléchir à la fonction TYPE. Pour l'instant, elle ne fait qu'ajouter les noms de fichier dans le superbloc. Cela permet de pouvoir tester les fonctions LS et RM (voir dans la rubrique compilation et exécution comment utiliser le programme).
// Fonction pour créer un fichier avec le nom donné et le contenu fourni en entrée standard
void TYPE(const char *filesystem_path, const char *filename) {
unsigned char buffer[MAX_FILENAME_LENGTH];
// Parcours des blocs réservés pour la description des fichiers
for (int blockNum = 0; blockNum <= MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, MAX_FILENAME_LENGTH);
// Vérifier si le bloc est vide (pas de nom de fichier)
if (buffer[0] == 0) {
// Écrire le nom du fichier dans l'emplacement vide du superbloc
writeBlock(blockNum, 0, (const unsigned char *)filename, MAX_FILENAME_LENGTH);
break; // Fichier créé, sortir de la boucle
}
}
printf("Le fichier \"%s\" a été créé avec succès.\n", filename);
}

ReX : Si la boucle se termine sans trouver de slot libre le message de succès s'affiche tout de même.

ReX : Le paramètre <code>filename</code> n'a pas forcément une taille de <code>MAX_FILENAME_LENGTH</code>.

Selon moi, la fonction TYPE devra respecter 3 étapes:

# Enregistrement du Nom du Fichier: L'ajout du nom du fichier dans un des blocs de la première partie du superbloc.
# Stockage des Données du Fichier: La récupération des données saisies en entrée standard par l'utilisateur et leur stockage dans des blocs du système de fichiers à partir d'une certaine position, comme le bloc 1040.
# Mise à Jour de la Disponibilité des Blocs: L'indication que les blocs dans lesquels les données ont été écrites ne sont plus disponibles en modifiant les bits correspondants dans la deuxième partie du superbloc (les 16 derniers blocs du super bloc).

ReX : Relis le point 3 et dit moi si tu te comprends toi même ?

Amine: Ma phrase n'est effectivement pas très claire. Je voulais dire que la fonction TYPE devra mettre à jour la carte de disponibilité du superbloc. C'est à dire que lorsqu'elle écrira des données dans des blocs, elle devra indiquer dans la carte de disponibilités que ces blocs ne sont plus disponibles.

=== Fonction intermédiaire TYPE version 2 ===

Suite à vos remarques, j'ai apporté les modifications suivantes à la fonction TYPE:

* j'ai ajouté une condition pour l'affichage du message de succès de la création d'un fichier (placeFound).

* le paramètre <code>filename</code> n'ayant pas forcément une taille de <code>MAX_FILENAME_LENGTH</code>, je calcule maintenant la longueur de filename, afin d'écrire seulement le nom du fichier avec la fonction writeBlock.

Il fonction n'est bien évidemment pas fini, elle ajoute seulement le nom du fichier dans le superbloc pour l'instant. Cela me permet de tester les fonctions LS et RM.
void TYPE(const char *filesystem_path, const char *filename) {
size_t sizeFilename = strlen(filename);
printf("size filename=%d\n", sizeFilename);
unsigned char buffer[MAX_FILENAME_LENGTH];
int placeFound = 0;

if (sizeFilename > MAX_FILENAME_LENGTH) {
printf("Impossible de créer le fichier, nom trop long\n");
return;
}

// Parcours des blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, MAX_FILENAME_LENGTH);
// Vérifier si le bloc est vide (pas de nom de fichier)
if (buffer[0] == 0) {
// Écrire le nom du fichier dans l'emplacement vide du superbloc
if (sizeFilename < MAX_FILENAME_LENGTH) {
sizeFilename+=1;
}
writeBlock(blockNum, 0, (const unsigned char *)filename, sizeFilename);
placeFound = 1;
break; // Fichier créé, sortir de la boucle
}
}
if (placeFound == 1) {
printf("Le fichier \"%s\" a été créé avec succès.\n", filename);
} else {
printf("Plus de place dans le système de fichier pour créer ce fichier.\n", filename);
}
}

ReX : Mieux, attention il faut copier aussi le <code>\'0</code> final du nom, donc <code>sizeFilename+1</code>. Sinon tu n'es pas sûr qu'il y ait un zéro final. Et attention n°2, il ne faut pas copier ce <code>\'0</code> si le nom fait la taille maximale.

Amine: ok j'ai modifié la fonction TYPE ci-dessus. J'ai ajouté une condition: si le nom du fichier est inférieur à la taille maximale de nom de fichier, alors on incrémente de 1 la taille du nom de fichier. Cela nous permet d'écrire le '\0' dans le bloc de description. Dans le cas où le nom du fichier est de la taille maximale, nous n'avons pas besoin d'écrire le '\0', on n'incrémente donc pas la taille de 1.

J'ai également ajouté une condition: si le nom du fichier est supérieur à la taille maximale, alors un message d'erreur s'affiche et le fichier n'est pas créé.

ReX : OK. L'embryon de fonction <code>TYPE</code> est correct, il manque juste le principal : la création des blocs de données.

=== Fonction MV version 1 ===

J'ai ici créé la fonction MV qui permet de changer le nom d'un fichier. Pour ce faire, la fonction parcourt les blocs de descriptions à la recherche du fichier dont on veut changer le nom. Lorsque ce fichier est trouvé, on supprime l'ancien nom en mettant des 0 sur 16 octets, puis on vient réécrire le nouveau nom dans le même emplacement. Enfin, on sort de la boucle et on affiche le succès ou non de l'opération.
// Fonction qui modifie le nom du fichier
void MV(const char *filesystem_path, const char *old_filename, const char *new_filename) {
size_t sizeNew_filename = strlen(new_filename);
size_t sizeOld_filename = strlen(old_filename);
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
int fileFound = 0;
// Parcourir les blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);
// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char*)filenameBuffer, old_filename, MAX_FILENAME_LENGTH) == 0) {
// Effacer le nom du fichier dans le superbloc
memset(filenameBuffer, 0, MAX_FILENAME_LENGTH);
writeBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);
// Écrire le nom du fichier dans l'emplacement
writeBlock(blockNum, 0, (const unsigned char *)new_filename, sizeNew_filename);
fileFound=1;
break; // Nom modifié, sortir de la boucle
}
}
if (fileFound == 1) {
printf("Le nom du fichier \"%s\" a été renommé avec succès.\n", old_filename);
} else {
printf("Le fichier \"%s\" n'a pas été trouvé.\n", old_filename);
}
}

ReX : Inutile d'écraser l'ancien nom avec des zéros. Il suffit de copier le nouveau en s'assurant qu'il y ait un zéro final sauf si le nouveau nom fait la taille maximale.

Amine: ok, je vais faire les modifications dans la version 2.

== Semaine 6 ==

=== Fonction MV version 2 ===
Dans cette nouvelle version de la fonction MV, j'ai effectué les modifications suivantes:

* je n'écrase plus l'ancien nom avec des 0
* Je colle simplement le nouveau nom par dessus l'ancien, en m'assurant qu'il y ait bien le '\0' à la fin lorsque la taille du nom du fichier est inférieur à la taille maximale. Comme précédemment, afin de m'assurer de la présence de ce '\0' à la fin du nom, j'incrémente la taille de 1 lorsque qu'elle est inférieur à la taille max. Cependant, je ne suis pas sûr à 100% que ce soit la bonne manière de faire.

// Fonction qui modifie le nom du fichier
void MV(const char *filesystem_path, const char *old_filename, const char *new_filename) {
size_t sizeNew_filename = strlen(new_filename);
size_t sizeOld_filename = strlen(old_filename);
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
int fileFound = 0;

// Parcourir les blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {

readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char*)filenameBuffer, old_filename, MAX_FILENAME_LENGTH) == 0) {

if (sizeNew_filename < MAX_FILENAME_LENGTH) {
sizeNew_filename+=1;
}

// Écrire le nom du fichier dans l'emplacement
writeBlock(blockNum, 0, (const unsigned char *)new_filename, sizeNew_filename);

fileFound=1;

break; // Nom modifié, sortir de la boucle
}
}
if (fileFound == 1) {
printf("Le nom du fichier \"%s\" a été renommé avec succès.\n", old_filename);
} else {
printf("Le fichier \"%s\" n'a pas été trouvé.\n", old_filename);
}
}

ReX : C'est bon. La fonction était triviale.

=== Fonction TYPE version 1 ===
void TYPE(const char *filesystem_path, const char *filename) {
size_t sizeFilename = strlen(filename);
unsigned char buffer[MAX_FILENAME_LENGTH];
int placeFound = -1;

if (sizeFilename > MAX_FILENAME_LENGTH) {
printf("Impossible de créer le fichier, nom trop long\n");
return;
}

// Parcours des blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, MAX_FILENAME_LENGTH);
// Vérifier si le bloc est vide (pas de nom de fichier)
if (buffer[0] == 0) {
// Écrire le nom du fichier dans l'emplacement vide du superbloc
if (sizeFilename < MAX_FILENAME_LENGTH) {
sizeFilename += 1; // Ajouter '\0' s'il y a de la place
}
writeBlock(blockNum, 0, (const unsigned char *)filename, sizeFilename);
placeFound = blockNum;

// Lire les données depuis l'entrée standard
unsigned char dataBuffer[BLOCK_SIZE];
size_t bytesRead;
int dataBlockNum = findAvailableBlock(); // Premier bloc de données à partir du bloc 1040
printf("dataBlockNum%d\n",dataBlockNum);
int blockSizeUsed = 0; // Compteur d'octets dans le bloc actuel
int dataBlocksNeeded = 1; // Nombre de blocs de données nécessaires

while ((bytesRead = fread(dataBuffer + blockSizeUsed, 1, BLOCK_SIZE - blockSizeUsed, stdin)) > 0) {
blockSizeUsed += bytesRead;

// Si le bloc actuel est plein, passer au bloc suivant
if (blockSizeUsed == BLOCK_SIZE) {
// printf("dataBlockNum=%d\n",dataBlockNum);
writeBlock(dataBlockNum, 0, dataBuffer, BLOCK_SIZE);
setBlockAvailability(dataBlockNum, 1);

dataBlockNum++; // Passer au bloc suivant
blockSizeUsed = 0; // Réinitialiser la taille utilisée
dataBlocksNeeded++;
}
}

// Écrire le dernier bloc partiel, s'il y en a un
if (blockSizeUsed > 0) {
writeBlock(dataBlockNum, 0, dataBuffer, blockSizeUsed);
setBlockAvailability(dataBlockNum, 1);
}

// Écrire les numéros de blocs utilisés dans le bloc de description
unsigned char blockNumberBuffer[2];
int currentBlockNum = 1040;

for (int i = 0; i < dataBlocksNeeded; i++) {
blockNumberBuffer[0] = (currentBlockNum >> 8) & 0xFF;
blockNumberBuffer[1] = currentBlockNum & 0xFF;
writeBlock(placeFound, MAX_FILENAME_LENGTH + i * 2, blockNumberBuffer, 2);
currentBlockNum++;
}

break; // Fichier créé, sortir de la boucle
}
}

if (placeFound != -1) {
printf("Le fichier \"%s\" a été créé avec succès.\n", filename);
} else {
printf("Plus de place dans le système de fichier pour créer ce fichier.\n");
}
}

ReX : La constante 1040 ne doit pas apparaître en numérique, ce doit être une constante calculée à partir des autres constantes.

Amine: Ok. Je ne l'avais pas défini comme une constante car il s'agit dans la fonction ci-dessus d'une variable qui est incrémenté à chaque itération.

ReX : Je suis las de te répéter que le mémoire est comptée : tu utilises encore un bloc de <code>BLOCK_SIZE</code> octets, c'est trop.

Amine: Comment utiliser des blocs plus petit sachant qu'il s'agit là de blocs de données et qu'un bloc fait 256 octets d'après l'énoncé ? Dois-je les subdiviser en plusieurs blocs plus petit comme fait dans la fonction RM, en 4 blocs de 64 octets par exemple ?

Fonctionnement de la fonction TYPE:

* étape 1: on parcourt les blocs de descriptions à la recherche d'un bloc disponible. Si on ne trouve pas de bloc disponible, on renvoie un message d'erreur, sinon on passe à l'étape suivante.
* étape 2: Si on trouve un emplacement libre dans les blocs de disponibilité, on écrit le nom du fichier dans cet emplacement.

ReX : Dans les blocs de description de fichiers pas dans les blocs de disponibilité.

Amine: Oui autant pour moi.

* étape 3: Ensuite, on lit le texte entré par l'utilisateur en entrée standard, on le répartit dans des blocs de taille BLOCK_SIZE, on met à jour la disponibilité des blocs utilisés.

ReX : Non, il faut appeler <code>findAvailableBlock</code> pour chaque bloc de données à utiliser, aucune certitudes que les blocs libres soient en séquence.

Amine: ok, je ferai cela dans la version 2

* étape 4: Enfin, on écrit les numéros des blocs de données utilisés dans les blocs de description de ce fichier, les numéros étant écris sur deux octets.

ReX : Non cela doit se faire au fur et à mesure des appels à <code>findAvailableBlock</code> et les numéros des blocs de données peuvent s'étaler sur les 16 blocs de description du fichier. Confusion totale sur ce point. Vous n'avez pas compris le mécanisme.

Amine: je corrige cela dans la version 2. J'ai bien compris le mécanisme mais ce n'est pas facile à traduire en code.

=== Fonction TYPE version 2 ===
Dans cette nouvelle version de TYPE, j'ai fait les modifications suivantes:

* j'appelle maintenant <code>findAvailableBlock</code> pour chaque bloc de données à utiliser
* j'écris maintenant les numéros de blocs au fur et à mesures des appels à <code>findAvailableBlock</code>
* je n'utilise plus de tableaux de taille 256 octets mais des tableaux de tailles CHUNK_SIZE. J'ai choisi ici CHUNK_SIZE = 64 octets.

J'utilise toujours un bloc de taille BLOCK_SIZE en attendant de comprendre si je dois diviser ce bloc en plusieurs blocs de taille plus petite ou s'il y a un moyen de ne pas du tout utiliser ces blocs.
void TYPE(const char *filesystem_path, const char *filename) {
size_t sizeFilename = strlen(filename);
unsigned char buffer[MAX_FILENAME_LENGTH];
int placeFound = -1;

if (sizeFilename > MAX_FILENAME_LENGTH) {
printf("Impossible de créer le fichier, nom trop long\n");
return;
}

// Parcours des blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, MAX_FILENAME_LENGTH);
// Vérifier si le bloc est vide (pas de nom de fichier)
if (buffer[0] == 0) {
// Écrire le nom du fichier dans l'emplacement vide du superbloc
if (sizeFilename < MAX_FILENAME_LENGTH) {
sizeFilename += 1; // Ajouter '\0' s'il y a de la place
}
writeBlock(blockNum, 0, (const unsigned char *)filename, sizeFilename);
placeFound = blockNum;

// Lire les données depuis l'entrée standard et écrire dans le fichier
int dataBlockNum = findAvailableBlock(); // Premier bloc de données à partir du bloc 1040
printf("Premier bloc dans lequel on écrit = %d\n", dataBlockNum);
int blockSizeUsed = 0; // Compteur d'octets dans le bloc actuel

unsigned char chunkBuffer[CHUNK_SIZE];
size_t bytesRead;

while ((bytesRead = fread(chunkBuffer, 1, CHUNK_SIZE, stdin)) > 0) {
// Écrire le chunk dans le bloc de données
writeBlock(dataBlockNum, blockSizeUsed, chunkBuffer, bytesRead);
setBlockAvailability(dataBlockNum, 1);

// Écrire le numéro du bloc actuel dans la description du fichier
unsigned char blockNumberBuffer[2];
blockNumberBuffer[0] = (dataBlockNum >> 8) & 0xFF;
blockNumberBuffer[1] = dataBlockNum & 0xFF;
writeBlock(placeFound, MAX_FILENAME_LENGTH + dataBlockNum * 2, blockNumberBuffer, 2);

blockSizeUsed += bytesRead;

// Si le bloc actuel est plein, passer au bloc suivant
if (blockSizeUsed == BLOCK_SIZE) {
dataBlockNum = findAvailableBlock(); // Passer au bloc suivant
blockSizeUsed = 0; // Réinitialiser la taille utilisée
}
}

break; // Fichier créé, sortir de la boucle
}
}

if (placeFound != -1) {
printf("Le fichier \"%s\" a été créé avec succès.\n", filename);
} else {
printf("Plus de place dans le système de fichier pour créer ce fichier.\n");
}
}

=== Fonction findAvailableBlock ===
Cette fonction renvoie l'indice du premier bloc disponible. Je me sers de cette fonction dans la fonction TYPE.
#define FIRST_DATA_BLOCK 1040
#define FIRST_DISPONIBILITY_CARD_BLOCK 1024

// Renvoie le premier bloc de donné disponible
int findAvailableBlock() {
unsigned char availabilityBuffer[BLOCK_SIZE];
int offset;

// Lire la carte de disponibilité (à partir du bloc 1)
for (int blockNum = FIRST_DISPONIBILITY_CARD_BLOCK; blockNum < FIRST_DATA_BLOCK; blockNum++) {
readBlock(blockNum, 0, availabilityBuffer, BLOCK_SIZE);

if (blockNum==FIRST_DISPONIBILITY_CARD_BLOCK) {
offset=FIRST_DATA_BLOCK/8;
} else {
offset=0;
}

// Parcourir les octets de la carte de disponibilité
for (int byteIndex = offset; byteIndex < BLOCK_SIZE - offset; byteIndex++) {
unsigned char byte = availabilityBuffer[byteIndex];

// Parcourir les bits de chaque octet
for (int bitIndex = 0; bitIndex < 8; bitIndex++) {
// Vérifier si le bit est à 0 (bloc disponible)
if ((byte & (1 << bitIndex)) == 0) {
// Calculer l'indice du bloc en fonction du bloc et du bit
int blockIndex = byteIndex * 8 + bitIndex;
return blockIndex;
}
}
}
}

// Aucun bloc disponible trouvé
return -1;
}

ReX : Même remarque que précédement sur les nombres 1024 et 1040.

Amine: Ok, j'ai remplacé 1024 par la constante FIRST_DISPONIBILITY_CARD_BLOCK et 1040 par la constante FIRST_DATA_BLOCK dans la fonction ci-dessus.

ReX : Vous n'avez toujours pas compris la contrainte sur la mémoire.

Amine: dois-je découper le bloc de taille BLOCK_SIZE en quatre blocs de taille 64 octets par exemple ?

ReX : Je ne vois pas ce que vous voulez faire avec <code>if (blockNum==1024) offset=1040/8; else offset=0;</code>.

Amine: dans la carte de disponibilité, chaque bit correspond à un bloc. Ainsi, les bits de 0 à 1040 dans la carte de disponibilité décrivent la disponibilité des blocs 0 à 1040. Or ces blocs correspondent au superbloc, et dans cette fonction, on veut connaître le premier bloc de données disponible. On ne s'intéresse donc pas au 1040 premiers bits de la carte de disponibilité. Je crée donc un offset égal à 1040/8 afin de ne pas prendre en compte les 1040 premiers bits soit les 1040/8=130 premiers octets. Cet offset ne s'applique que lorsqu'on se trouve dans le premier des 16 blocs de la carte de disponibilité, d'où la condition <code>if (blockNum==1024)</code>.

=== Fonction CAT version 1 ===
void CAT(const char *filesystem_path, const char *filename) {
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
unsigned char buffer[BLOCK_SIZE];
unsigned char blockNumberBuffer[2];
unsigned char dataBuffer[BLOCK_SIZE];
int offset;

// Parcours des blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char *)filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {
// Le nom du fichier a été trouvé

// Parcours les blocs de description
for (int descrBlockNum=0; descrBlockNum<MAX_BLOCKS_PER_FILE_DESCRIPTION; descrBlockNum++) {
if (descrBlockNum==0) {
offset=16;
} else {
offset=0;
}
readBlock(descrBlockNum+blockNum, offset, buffer, BLOCK_SIZE-offset);

// Lire les numéros de blocs associés à ce fichier depuis les blocs de description
unsigned char octet1 = buffer[offset];
unsigned char octet2 = buffer[offset+1];

int dataBlockNum = (octet1 << 8) | octet2;
printf("dataBlockNum=%d\n",dataBlockNum);

// Vérifier si le numéro de bloc est valide (non nul)
if (dataBlockNum == 0) {
return; // Fin du fichier
}

// Lire et afficher le contenu du bloc de données
readBlock(dataBlockNum, 0, dataBuffer, BLOCK_SIZE);
fwrite(dataBuffer, 1, BLOCK_SIZE, stdout);
}

return; // Fichier affiché, sortie de la fonction
}
}

// Si le fichier n'a pas été trouvé
printf("Le fichier \"%s\" n'a pas été trouvé.\n", filename);
}

ReX : Encore mieux : deux blocs de <code>BLOCK_SIZE</code> en mémoire.

ReX : Le <code>break</code> ne sort pas de la boucle externe.

Amine: Oui c'est vrai. J'ai remplacé le break pas un return ci-dessus.

Voici ma fonction <code>CAT</code>. Elle fonctionne en plusieurs étape:

* étape 1: on cherche dans les blocs de descriptions si le fichier dont on veut afficher le contenu existe. Si le nom de fichier est trouvé, on passe à l'étape 2. Sinon, on renvoie un message d'erreur.
* étape 2: si le fichier est trouvé, on parcours les 16 blocs de description de ce fichier.
* étape 3: grâce aux opérations de masquage et de décalage, on joint les octets deux par deux pour former un entier qui contient le numéro du bloc de données correspondant au fichier. Si cet entier vaut 0, alors cela signifie qu'il n'y a plus de blocs associé à ce fichier, on peut donc quitter la fonction. Si cet entier est différent de 0, alors on va lire le bloc correspondant à ce numéro et on affiche son contenu dans le terminal.

== Semaine 7 ==

=== Fonction CP version 1 ===
Voici ma fonction CP, qui permet de créer une copie d'un fichier existant. L'idée est la suivante: pour copier un fichier, on doit créer un nouveau fichier et lui attribuer les mêmes blocs de descriptions que le fichier source. Ainsi, le fichier source et le fichier destination pointeront vers les mêmes blocs de données, et auront le même contenu.

ReX : Perdu. Ce n'est absolument pas la fonction de copie de fichiers d'un système de fichiers.

Amine: Après avoir fait des recherches et après réflexion, je me rends compte que cette fonction CP présente un problème: en faisant pointé les blocs de données du fichier destination vers ceux du fichier source, toutes modifications du fichier source impactera le fichier destination, or ce n'est pas ce qu'on veut faire. Je vous propose donc une nouvelle version de la fonction CP ci-dessous qui remédie à ce problème.

void CP(const char *filesystem_path, const char *source_filename, const char *destination_filename) {
unsigned char source_filenameBuffer[MAX_FILENAME_LENGTH];
unsigned char destination_filenameBuffer[MAX_FILENAME_LENGTH];
unsigned char descriptionBuffer[BLOCK_SIZE];
int destination_offset;
int offset;

// Recherche du fichier source
int source_offset = -1;
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, source_filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier source
if (strncmp((const char *)source_filenameBuffer, source_filename, MAX_FILENAME_LENGTH) == 0) {
source_offset = blockNum;
break;
}
}

if (source_offset == -1) {
printf("Le fichier source \"%s\" n'a pas été trouvé.\n", source_filename);
return;
}

// Recherche d'un emplacement libre pour le fichier destination
destination_offset = -1;
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, destination_filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc est vide (pas de nom de fichier)
if (destination_filenameBuffer[0] == 0) {
destination_offset = blockNum;
break;
}
}

if (destination_offset == -1) {
printf("Plus de place dans le système de fichier pour créer la copie de \"%s\".\n", source_filename);
return;
}

// Ecrit le nom de la copie dans le bloc de description
writeBlock(destination_offset, 0, (const unsigned char *)destination_filename, strlen(destination_filename));

// Copier les blocs de description associés au fichier source dans les blocs de description du fichier destination
for (int i = 0; i < MAX_BLOCKS_PER_FILE_DESCRIPTION; i++) {
if (i==0) {
offset = MAX_FILENAME_LENGTH;
} else {
offset = 0;
}

readBlock(source_offset+i, offset, descriptionBuffer, BLOCK_SIZE-offset);
if (descriptionBuffer[offset]==0) {
return;
} else {
writeBlock(destination_offset+i, offset, descriptionBuffer, BLOCK_SIZE-offset);
}
}

printf("La copie de \"%s\" sous le nom \"%s\" a été créée avec succès.\n", source_filename, destination_filename);
}

== Semaine 8 ==
A ce stade du projet, les fonctions suivantes ont été validé par Monsieur Redon:

* fonction LS
* fonction RM
* fonction MV

Il reste donc les fonctions suivantes à terminer:

* fonction CAT
* fonction CP
* fonction TYPE

=== Fonction CAT version 2 ===
Suite à vos remarques sur la version 1, j'ai fais les modifications suivantes:

* je n'utilise non plus 2 tableaux de taille BLOCK_SIZE, mais 1 seul. Idéalement il faudrait en utiliser 0, je réfléchi donc à m’émanciper de ce tableau en le remplaçant par plusieurs plus petits tableaux.
* J'ai remplacé le <code>break</code> par un return

Cette fonction permet d'afficher le contenu d'un fichier créé avec la fonction TYPE. Pour se faire, on parcours tout d'abord les blocs de descriptions pour trouver le fichier dont ont veut afficher le contenu. Une fois ce fichier trouvé, on parcours les 16 blocs de description de ce fichier 1 à 1. Pour chacun de ces blocs de description, on va stocker récupéré les octets deux par deux afin de former des entiers. Pour se faire, on utilise la fonction <code>reconsituteNumber</code> que l'on détaillera juste après. Ces entiers correspondent aux blocs dans lesquels la donné du fichier se trouve. Une fois l'entier reconstitué, on affiche le contenu du bloc correspondant.
void CAT(const char *filesystem_path, const char *filename) {
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
unsigned char byteBuffer[2];
unsigned char dataBuffer[BLOCK_SIZE];
int offset;

// Parcours des blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char *)filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {
// Le nom du fichier a été trouvé

// Parcours les blocs de description
for (int descrBlockNum=0; descrBlockNum<MAX_BLOCKS_PER_FILE_DESCRIPTION; descrBlockNum++) {
if (descrBlockNum==0) {
offset=MAX_FILENAME_LENGTH;
} else {
offset=0;
}

// Lecture des octets deux par deux
for (int i=0; i<BLOCK_SIZE;i+=2) {
readBlock(descrBlockNum+blockNum, offset+i, byteBuffer, 2);

// Lire les numéros de blocs associés à ce fichier depuis les blocs de description
int dataBlockNum = reconsituteNumber(byteBuffer);

// Vérifier si le numéro de bloc est valide (non nul)
if (dataBlockNum == 0) {
return; // Fin du fichier
}

// Lire et afficher le contenu du bloc de données
readBlock(dataBlockNum, 0, dataBuffer, BLOCK_SIZE);
fwrite(dataBuffer, 1, BLOCK_SIZE, stdout);
}
}

return; // Fichier affiché, sortie de la fonction
}
}

// Si le fichier n'a pas été trouvé
printf("Le fichier \"%s\" n'a pas été trouvé.\n", filename);
}

=== Fonction reconsituteNumber ===
Cette fonction permet de reconstituer un numéro de bloc à partir de deux octets.
// Fonction qui reconstitue le numéro de bloc à partir du tableau
int reconsituteNumber(unsigned char blockNumberBuffer[2]) {
unsigned char octet1 = blockNumberBuffer[0];
unsigned char octet2 = blockNumberBuffer[1];
int dataBlockNum = (octet1 << 8) | octet2;
return dataBlockNum;
}

=== Fonction CP version 2 ===
Voici une version mise à jour de notre fonction CP. Dans la version précédente, on faisait pointer le fichier source vers les même blocs que le fichier destination. Cela posait un problème: toute modification du fichier source impactait le fichier destination. Ainsi, dans cette nouvelle version, on fait une duplication des blocs de données du fichier source vers le fichier destination. Cela implique donc une mise à jour de la carte de disponibilité, ainsi que l'adaptation des blocs de descriptions. En effet, seulement les blocs de données sont maintenant identiques, plus les blocs de description.

Piste d'amélioration: comme pour la fonction CAT ci-dessus, j'utilise toujours un bloc de taille 256 octets, je vais devoir y remédier.
void CP(const char *filesystem_path, const char *source_filename, const char *destination_filename) {
unsigned char source_filenameBuffer[MAX_FILENAME_LENGTH];
unsigned char destination_filenameBuffer[MAX_FILENAME_LENGTH];
unsigned char descriptionBuffer[BLOCK_SIZE];
unsigned char numBuffer[2];
int destination_offset;
int source_offset;
int offset;
int numDataBlock;

// Recherche du fichier source
source_offset = -1;
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, source_filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier source
if (strncmp((const char *)source_filenameBuffer, source_filename, MAX_FILENAME_LENGTH) == 0) {
source_offset = blockNum;
break;
}
}

if (source_offset == -1) {
printf("Le fichier source \"%s\" n'a pas été trouvé.\n", source_filename);
return;
}

// Recherche d'un emplacement libre pour le fichier destination
destination_offset = -1;
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, destination_filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc est vide (pas de nom de fichier)
if (destination_filenameBuffer[0] == 0) {
destination_offset = blockNum;
break;
}
}

if (destination_offset == -1) {
printf("Plus de place dans le système de fichier pour créer la copie de \"%s\".\n", source_filename);
return;
}

// Copie du nom de la copie dans le bloc de description
writeBlock(destination_offset, 0, (const unsigned char *)destination_filename, strlen(destination_filename));

// Copier les blocs de données associés au fichier source dans de nouveaux blocs de données pour le fichier destination
for (int i = 0; i < MAX_BLOCKS_PER_FILE_DESCRIPTION; i++) {
if (i == 0) { offset = MAX_FILENAME_LENGTH; }
else { offset = 0; }

// Lecture des numéros de bloc dans les blocs de description
for (int byteNum=0; byteNum<BLOCK_SIZE; byteNum+=2) {
readBlock(source_offset + i, offset + byteNum, numBuffer, 2);

numDataBlock = reconsituteNumber(numBuffer);
if (numDataBlock == 0) {
return;
}

// On stocke le bloc de données associé au fichier source dans descriptionBuffer
readBlock(numDataBlock, 0, descriptionBuffer, BLOCK_SIZE);

// Trouver un nouveau bloc de données disponible
int newDataBlock = findAvailableBlock();

// Ecriture du bloc de données dans le premier bloc disponible
writeBlock(newDataBlock, 0, descriptionBuffer, BLOCK_SIZE);

// Mise à jour de la carte de disponibilités
setBlockAvailability(newDataBlock, 1);

// Ecriture du numéro de bloc dans la description du fichier
numBuffer[0] = (newDataBlock >> 8) & 0xFF;
numBuffer[1] = newDataBlock & 0xFF;
writeBlock(destination_offset+i, offset+byteNum, numBuffer, 2);
}
}

printf("La copie de \"%s\" sous le nom \"%s\" a été créée avec succès.\n", source_filename, destination_filename);
}

= Compilation et exécution =
'''Création du système de fichiers :'''
dd if=/dev/zero of=filesystem.bin bs=256 count=32768

'''Compilation :'''

gcc picofs.c -o picofs

'''Exécution de LS, TYPE, CAT, RM, MV ou CP :'''

./picofs filesystem.bin LS
./picofs filesystem.bin TYPE mon_fichier.txt
./picofs filesystem.bin CAT mon_fichier.txt
./picofs filesystem.bin RM mon_fichier.txt
./picofs filesystem.bin MV mon_fichier.txt mon_fichier2.txt
./picofs filesystem.bin CP mon_fichier.txt mon_fichier2.txt

= Documents Rendus =
[[Fichier:Pcfs.c.tar|vignette]]

SE4 2022/2023 EC1

2023-09-02T11:38:39Z

Asellali : /* Fonction CP version 2 */

= Objectifs =

Il vous est demandé de :
* réaliser un micro système de fichiers ;
* le système de fichiers doit résider dans un fichier de 8 Mo ;
* le système de fichiers est géré par un exécutable obtenu à partir d'un programme C ;
* L'éxécutable prend deux arguments, le premier est le chemin du fichier dans lequel réside le système de fichiers, les paramètres suivants concernent l'action à appliquer sur le système de fichiers ;
* le micro système de fichier ne comporte qu'un répertoire : le répertoire principal, le répertoire principal peut comporter au maximum 64 fichiers, un fichier est caractérisé par un nom de 16 caractères au maximum et ses blocs de données, un fichier peut comporter au maximum 2040 blocs de données ;
* un bloc de données fait 256 octets et les blocs sont numérotés sur 2 octets ;
* les différentes actions possibles sur le système de fichiers sont :
** <code>TYPE</code> pour créer un fichier si possible, le nom du fichier suit la commande, le contenu du fichier est donné en entrée standard de l'exécutable ;
** <code>CAT</code> pour afficher un fichier, le nom du fichier suit la commande ;
** <code>RM</code> pour détruire un fichier, le nom du fichier suit la commande ;
** <code>MV</code> pour renommer un fichier, les noms original et nouveau du fichier suivent la commande ;
** <code>CP</code> pour copier un fichier, les noms de l'original et de la copie du fichier suivent la commande ;

= Matériel nécessaire =

Un PC sous Linux.

= Travail réalisé =

== Semaine 1 ==

ReX : attention, ce micro-système de fichiers est prévu pour un microcontrôleur, vos variables globales ne peuvent pas dépasser quelques centaines d'octets.

ReX : pour la création du système de fichiers la commande <code>dd</code> suffit, vous voulez dire le formatage du système de fichiers ?

* création du programme programme.c contenant les différentes structures et les différentes fonctions.
* Piste d'amélioration: faire en sorte que la fonction CAT affiche le contenu exact des fichiers passés en argument.

Le code fourni est un programme en langage C qui simule un système de fichiers basique. Ce programme permet aux utilisateurs d'effectuer diverses actions telles que créer, afficher, supprimer, renommer et copier des fichiers dans un système de fichiers simulé. Le système de fichiers est stocké dans un fichier binaire.

ReX : vous n'avez pas tenu compte de la première remarque, vous chargez tout le superbloc et le répertoire racine, votre code ne convient pas.

ReX : vos structures utilisent des types entiers dont la taille n'est pas explicitée, utilisez les types de <code>stdint.h</code>.

ReX : la création de fichier n'est pas fonctionnelle, vous ne cherchez pas les blocs libres, vous ne copiez pas le contenu du fichier dans les blocs, même remarque pour toutes les autres fonctions.

ReX : il manque les fonctions d'accès aux pages du système de fichiers.

'''Explication du programme programme.c'''

Voici une brève explication des principaux éléments et fonctions du code :

# Structures :
#* Fichier : Représente un fichier dans le système de fichiers. Il contient un nom (nom) avec une longueur maximale de 16 caractères, un tableau de numéros de bloc (blocs) où le contenu du fichier est stocké (jusqu'à 2040 blocs), et le nombre de blocs utilisés par le fichier (nbBlocs).
#* Repertoire : Représente le répertoire principal du système de fichiers. Il contient un tableau de fichiers (<code>fichiers</code>) et le nombre de fichiers dans le répertoire (<code>nbFichiers</code>).
# Fonctions :
#* <code>chargerSystemeFichiers</code> : Charge le système de fichiers à partir d'un fichier binaire donné (chemin) dans une structure Repertoire.
#* <code>sauvegarderSystemeFichiers</code> : Sauvegarde le système de fichiers stocké dans la structure Repertoire dans un fichier binaire (chemin).
#* <code>creerFichier</code> : Crée un nouveau fichier dans le système de fichiers avec un nom et un contenu donnés. Le contenu du fichier est simulé en le divisant en blocs.
#* <code>afficherFichier</code> : Affiche le contenu d'un fichier avec le nom spécifié.
#* <code>detruireFichier</code> : Supprime un fichier avec le nom spécifié du système de fichiers.
#* <code>renommerFichier</code> : Renomme un fichier avec l'ancien nom spécifié en un nouveau nom.
#* <code>copierFichier</code> : Copie un fichier avec le nom spécifié en créant un nouveau fichier avec le nom de copie spécifié.
# Fonction <code>main</code> :
#* La fonction <code>main</code> est le point d'entrée du programme.
#* Elle prend des arguments en ligne de commande : <code><chemin_systeme_fichiers></code> et <code><action></code>.
#* <code><chemin_systeme_fichiers></code> est le chemin vers le fichier binaire où le système de fichiers est stocké.
#* <code><action></code> détermine quelle opération effectuer, comme <code>TYPE</code>, <code>CAT</code>, <code>RM</code>, <code>MV</code> ou <code>CP</code>.
#* En fonction de l'action spécifiée, le programme appelle la fonction correspondante pour effectuer l'opération souhaitée sur le système de fichiers.
Remarque : Le code fourni une simulation basique d'un système de fichiers et de ses opérations, mais il n'interagit pas réellement avec un système de fichiers réel sur le disque.

'''Comment utiliser le programme programme.c'''

étape 1: création du système de fichiers respectant le cahier des charges:

dd if=/dev/zero of=systeme_fichiers.bin bs=1M count=8

étape 2: compilation du programme C:

gcc programme.c -o gestionnaire_fs

étape 3: création d'un fichier dans le système de fichier:

./gestionnaire_fs systeme_fichiers.bin TYPE fichier1.txt

-> entrer le texte en entrée standard

étape 4: manipulation des différentes fonctions. Exemples:

./gestionnaire_fs systeme_fichiers.bin CAT fichier1.txt
./gestionnaire_fs systeme_fichiers.bin CP fichier1.txt copie.txt
./gestionnaire_fs systeme_fichiers.bin RM copie.txt
./gestionnaire_fs systeme_fichiers.bin MV fichier1.txt fichier2.txt

== Semaine 2 ==

Amine: Merci pour vos remarques. Désolé de ne pas avoir suivi votre première remarque, je pensais avoir compris ce qu'il fallait faire mais je me rend compte que non. Je vais tout reprendre depuis le début afin de repartir sur de bonnes bases.

'''Création du système de fichier avec la commande "dd"'''

A quoi sert la commande dd?

La commande <code>dd</code> permet de copier tout ou partie d'un disque par blocs d'octets, indépendamment de la structure du contenu du disque en fichiers et en répertoires (source : [https://doc.ubuntu-fr.org/dd]).

Structure de la commande

dd if=<nowiki><source> of=<cible> bs=<taille des blocs></nowiki>

<code>source</code> = données à copier

<code>cible</code> = endroit où les copier

<code>if</code> = input file

<code>of</code> = output file

<code>bs</code> = block size, habituellement une puissance de 2 supérieure ou égale à 512, représentant un nombre d'octets

Choix de la commande:

Pour la source, on prends <code>/dev/zero</code>: cela permet de créer un fichier rempli de 0. Ce fichier servira de base pour notre système de fichiers.

Pour la cible, on va l'appeler <code>filesystem.bin</Code> : ce sera notre système de fichier.

Pour la taille des blocs, on veut des blocs de données de 256 octets d'après l'enoncé. On va donc prendre <code>bs=256</code>.

Enfin, on veut que le système de fichier réside dans un fichier de 8 Mo. On va donc ajouter <code>count=31250</code>: cela indique que nous voulons écrire 32768 blocs de données dans le fichier (31250 * 256 octets = 8 Mo).

Résultat:

dd if=/dev/zero of=filesystem.bin bs=256 count=31250

Question pour M. Redon : j'ai ici essayé de respecter votre remarque "pour la création du système de fichiers la commande <code>dd</code> suffit". Cependant, pour votre seconde remarque "vous chargez tout le superbloc et le répertoire racine, votre code ne convient pas.", je ne suis pas sûr de comprendre où je fais cela: est-ce lors de la commande dd ou est-ce par la suite avec mon programme C? J'ai un peu modifié la commande dd comme vous pouvez le voir ci-dessus. Ai-je corrigé mon erreur avec cette nouvelle commande? J'ai essayé de justifier au maximum la commande dd que j'ai choisie.

ReX : Pas de problème avec la commande <code>dd</code> (mettez tous les extraits de code entre des balises <code>code</code>). Le problème est au niveau du programme C.

Amine: Ok je comprends mieux merci. Je vais donc reprendre le code étape par étape afin de mieux répondre au cahier des charges.

Gestion du système de fichier par un programme C

'''Création des structures'''
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>

// Structure pour représenter un bloc de données

struct DataBlock {
uint8_t data[256]; // 256 octets pour chaque bloc de données
};

// Structure pour représenter un fichier

struct File {
char filename[17]; // 16 caractères pour le nom du fichier + 1 caractère null-terminator
struct DataBlock data_blocks[2040]; // Tableau de blocs de données pour stocker le contenu du fichier
uint16_t num_data_blocks; // Nombre de blocs de données utilisés par le fichier
};

// Structure pour représenter un répertoire

struct Directory {
struct File files[64]; // Tableau de fichiers pour le répertoire principal
uint8_t num_files; // Nombre de fichiers dans le répertoire principal
};

Modification faite : suite à votre remarque, j'ai explicité la taille des entiers grâce aux types de <code>stdint.h.</code> (j'ai également mis les variables en anglais)

ReX : Vous ne pouvez pas utiliser ces structures, une instanciation d'une de ces structure prend trop d'espace mémoire, vous devez faire sans structure. Par ailleurs la façon dont vous représentez vos fichiers ne convient pas, la description d'un fichier contient des numéros de blocs, pas les blocs eux-même. Faites aussi attention qu'un fichier soit décrit par un nombre entier de blocs.

Question pratique: je n'arrive pas à mettre tout le code dans le même bloc comme vous l'avez fait ci-dessus dans l'étape 4 de la semaine 1. Je vois que c'est en format "préformaté" mais j'obtiens des blocs séparés lorsque j'applique ce format à mon code.

ReX : j'ai corrigé, pour un code entier la syntaxe n'est pas la même (un espace en début de chaque ligne), la balise c'est uniquement pour de très courts extraits de code.

=== Fonction <code>readBlock</code>===
Cette fonction est utilisée pour lire un bloc de données à partir du fichier <code>filesystem.bin</code> et le stocker dans un tableau de caractères (<code>storage</code>).

Fonction:

#define BLOCK_SIZE 256
// Fonction pour lire un bloc de données
void readBlock(unsigned int num, int offset, unsigned char *storage, int size) {
FILE *file = fopen("filesystem.bin", "rb");
if (file == NULL) {
perror("Erreur lors de l'ouverture du fichier");
return;
}
fseek(file, num * BLOCK_SIZE + offset, SEEK_SET);
fread(storage, 1, size, file);
fclose(file);
}

Paramètres :

* <code>num</code> : Numéro du bloc à lire. Chaque bloc contient 256 octets (1 bloc = 256 octets).
* <code>offset</code> : Décalage (en octets) à partir du début du bloc pour commencer la lecture.
* <code>storage</code> : Pointeur vers un tableau de caractères où les données lues seront stockées.
* <code>size</code> : Taille du tableau de caractères <code>storage</code>.

Fonctionnement :

* La fonction commence par ouvrir le fichier <code>filesystem.bin</code> en mode lecture binaire (<code>"rb"</code>).
* Elle utilise <code>fseek</code> pour positionner le curseur de lecture dans le fichier à l'endroit approprié pour commencer la lecture du bloc spécifié (<code>num</code>) à partir de l'offset (<code>offset</code>).
* Elle utilise ensuite <code>fread</code> pour lire <code>size</code> octets à partir du fichier et les stocker dans le tableau <code>storage</code>.
* Enfin, elle ferme le fichier avec <code>fclose</code>.

Note : Le paramètre <code>offset</code> est utilisé pour spécifier à partir de quel octet du bloc on souhaite commencer la lecture. Si <code>offset</code> est égal à 0, la lecture commencera depuis le début du bloc. Si <code>offset</code> est différent de 0, la lecture commencera à l'octet spécifié.

Remarque: dans votre mail, vous définissez "readBlock(unsigned int num,int offset,unsigned storage,int size)": storage n'est alors pas un pointeur vers un tableau de caractère. Je me suis donc permis de faire la modification.

ReX : OK pour la fonction, pas la peine d'en mettre autant dans le Wiki pour une fonction aussi simple.

=== Fonction <code>writeBlock</code> ===
Cette fonction est utilisée pour écrire un bloc de données dans le fichier <code>filesystem.bin</code> à partir d'un tableau de caractères (<code>storage</code>).

Fonction:

// Fonction pour écrire un bloc de données
void writeBlock(unsigned int num, int offset, const unsigned char *storage, int size) {
FILE *file = fopen("filesystem.bin", "rb+");
if (file == NULL) {
perror("Erreur lors de l'ouverture du fichier");
return;
}
fseek(file, num * BLOCK_SIZE + offset, SEEK_SET);
fwrite(storage, 1, size, file);
fclose(file);
}

Paramètres :

* <code>num</code> : Numéro du bloc où écrire.
* <code>offset</code> : Décalage (en octets) à partir du début du bloc pour commencer l'écriture.
* <code>storage</code> : Pointeur vers un tableau de caractères contenant les données à écrire dans le fichier.
* <code>size</code> : Taille du tableau de caractères <code>storage</code>.

Fonctionnement :

* La fonction commence par ouvrir le fichier <code>filesystem.bin</code> en mode lecture et écriture binaire (<code>"rb+"</code>).
* Elle utilise <code>fseek</code> pour positionner le curseur de lecture/écriture dans le fichier à l'endroit approprié pour commencer l'écriture du bloc spécifié (<code>num</code>) à partir de l'offset (<code>offset</code>).
* Elle utilise ensuite <code>fwrite</code> pour écrire <code>size</code> octets à partir du tableau <code>storage</code> dans le fichier.
* Enfin, elle ferme le fichier avec <code>fclose</code>.

ReX : Même remarque que pour la fonction précédente.

'''Etape 4: test des fonctions <code>readBlock</code> et <code>writeBlock</code> dans le main'''
// Exemple de fonction principale pour tester les opérations de lecture et d'écriture
int main() {
unsigned char data[BLOCK_SIZE];
// Test de la fonction readBlock
readBlock(0, 0, data, BLOCK_SIZE);
printf("Block 0, offset 0: ");
for (int i = 0; i < BLOCK_SIZE; i++) {
printf("%02x ", data[i]);
}
printf("\n");
// Test de la fonction writeBlock
unsigned char newData[BLOCK_SIZE] = {
0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88,
// ... Autres données du bloc ...
};
writeBlock(1, 0, newData, BLOCK_SIZE);
// Lecture du bloc nouvellement écrit pour vérifier
readBlock(1, 0, data, BLOCK_SIZE);
printf("Block 1, offset 0: ");
for (int i = 0; i < BLOCK_SIZE; i++) {
printf("%02x ", data[i]);
}
printf("\n");
return 0;
}

Fonctionnement :

* On déclare tout d'abord un tableau de caractères <code>data</code> de taille <code>BLOCK_SIZE</code> pour stocker les données lues du bloc.
* Ensuite, la fonction <code>readBlock</code> est appelée avec les arguments (0, 0, data, BLOCK_SIZE) pour lire le premier bloc du fichier (<code>num=0</code>, <code>offset=0</code>) et stocker les données dans <code>data</code>.
* Ensuite, la fonction <code>printf</code> est utilisée pour afficher les données lues du bloc (<code>data</code>) en format hexadécimal.
* Ensuite, un nouveau tableau de caractères <code>newData</code> est créé avec des données spécifiques pour tester la fonction <code>writeBlock</code>.
* La fonction <code>writeBlock</code> est appelée avec les arguments (1, 0, newData, BLOCK_SIZE) pour écrire le tableau <code>newData</code> dans le deuxième bloc du fichier (<code>num=1</code>, <code>offset=0</code>).
* Enfin, la fonction <code>readBlock</code> est appelée à nouveau pour lire le deuxième bloc nouvellement écrit et afficher les données lues en format hexadécimal.

Question générale : ce que j'avais la première semaine n'est plus forcément d'actualité. Puis-je supprimer les choses qui ne le sont plus afin d'alléger la page ou préférez-vous que je laisse?

ReX : Laissez.

Pour la suite : j'ai donc pour l'instant crée deux fonctions, l'une permettant la lecture et l'autre l'écriture d'un bloc, de manière à économiser la mémoire. Pour la suite, je vais essayer de créer la fonction <code>LS</code> en utilisant la fonction <code>readBlock</code>.

ReX : Oui c'est le début du projet. Mais si vous n'avez pas une bonne description de fichier cela ne donnera rien. Voir remarques plus haut.

'''Etape 5: fonction <code>LS</code>'''

Objectif: créer la fonction <code>LS</code> avec la fonction readBlock.

Question: Souhaitez-vous la fonction <code>LS</code> classique, c'est à dire la fonction <code>LS</code> qui affiche simplement le nom des fichiers présent dans le répertoire ?

ReX : Oui. Tu peux ajouter la taille si tu trouves cela trop simple.

Piste : si c'est ce que vous voulez:

* il va tout d'abord falloir que je crée des fichiers, un fichier étant composé d'un nom et de blocs (création d'une fonction createFile)
* Il faudra ensuite que je stocke ces fichiers dans le répertoire (création d'une fonction addFileToDirectory par exemple)
* enfin, il faudra que j'affiche le nom des fichiers. Pour cela, il faudra que je parcours le répertoire (structure "Directory"), puis que pour chaque fichier présent dans le répertoire que j'affiche son nom (création de la fonction LS)

Je devrais surement utiliser la fonction readBlock afin de transférer les blocs dans le fichier au travers de la variable "storage".

ReX : Créer des fichiers n'est pas nécessaire tout de suite je verrais bien si ton code est bon sans test. Laisse tomber <code>createFile</code> et <code>addFileToDirectory</code> pour l'instant.

ReX : Ton algorithme ne fonctionne pas pour un microcontrôleur où il faut économiser la mémoire, tu ne peux pas t'aider de structures. Il faudra que tu charges les noms et seulement les noms, pour la taille il faudra se baser sur le nombre de blocs.

'''Etape 6: rectification du code suite à vos remarques'''

Modifications apportées:

* suppression des structures afin d’économiser de la mémoire.

* le problème quant à la description des fichiers est normalement résolu puisque plus de structures. On ne charge plus les blocs mais seulement les noms de fichiers.

ReX : Non car si les noms ne sont pas répartis de façon régulière dans les blocs de 256 octets tu vas avoir du mal à les charger. Mais écrit la fonction <code>LS</code> et tu verras ce que je veux dire.

J'ai également ajouté deux nouvelles fonctions:

# <code>void readFileName(unsigned int file_num, char *file_name)</code>: Cette fonction permet de lire le nom du fichier associé au numéro de fichier donné (<code>file_num</code>). Elle stocke le nom du fichier lu dans le tableau <code>file_name</code>.
# <code>void writeFileName(unsigned int file_num, const char *file_name)</code>: Cette fonction permet d'écrire le nom du fichier dans le système de fichiers, associé au numéro de fichier donné (<code>file_num</code>). Elle prend en entrée le nom du fichier à écrire (<code>file_name</code>).

Suite: si vous validez cette base, je pourrai passer à la création de la fonction LS.

ReX : tu peux y aller. Je ne vois pas le code des tes deux fonctions <code>readFileName</code> et <code>writeFileName</code>.

Voici le code des fonctions <code>readFileName</code> et <code>writeFileName</code> :

'''Fonction readFileName:'''
// Fonction pour lire le nom du fichier
void readFileName(unsigned int file_num, char *file_name) {
readBlock(file_num, 0, (unsigned char *)file_name, MAX_FILENAME_LENGTH);
file_name[MAX_FILENAME_LENGTH] = '\0'; // Ajout du caractère null-terminator pour former une chaîne de caractères
}

ReX : Non, aucune raison que le fichier de numéro n soit au bloc n. Dessine la représentation d'un fichier sur le SF en comptant les octets si cela peut aider.

'''Fonction writeFileName:'''
// Fonction pour écrire le nom du fichier
void writeFileName(unsigned int file_num, const char *file_name) {
writeBlock(file_num, 0, (const unsigned char *)file_name, MAX_FILENAME_LENGTH);
}

ReX : Faux et inutile pour l'instant. Problème avec la constante MAX_FILENAME_LENGTH.

=== Fonction LS version 1 ===
// Fonction LS pour afficher les fichiers présents dans le système de fichiers
void LS(const char *filesystem_path) {
FILE *file = fopen(filesystem_path, "rb");
if (file == NULL) {
perror("Erreur lors de l'ouverture du fichier système");
return;
}
uint16_t num_files;
fread(&num_files, sizeof(uint16_t), 1, file); // Lecture du nombre de fichiers dans le système
char filename[17];
printf("Fichiers présents dans le système de fichiers:\n");
for (int i = 0; i < num_files; i++) {
readFileName(i, filename); // Lecture du nom du fichier
printf("%s\n", filename); // Affichage du nom du fichier
}
fclose(file);
}
La fonction <code>LS</code> ouvre le fichier système, lit le nombre de fichiers qu'il contient, puis affiche les noms des fichiers un par un, chacun sur une ligne séparée.

ReX : Il y a le nombre de fichiers dans ton superbloc ? Un dessin du format du superbloc avec les numéros des octets ?

ReX : Tout accès au système de fichiers doit se faire avec les deux fonctions <code>readBlock</code> et <code>writeBlock</code>.

== Semaine 3 ==
Question 1: cela fait plusieurs fois que vous mentionnez dans le wiki un "superbloc". Celui-ci n'étant pas clairement défini dans le sujet, je me demande s'il s'agit du bloc crée grâce à la fonction dd, c'est à dire que le superbloc serait en faite le bloc constitué des 31250 blocs de taille 256 octets, où s'il s'agit d'un bloc qui vient en entête, celui contenant alors des informations décrivant le système de fichier (les noms de fichiers...).

ReX : Pour ton pico système de fichiers, le superbloc consiste en les premiers blocs (de 256 octets) qui définissent les 64 fichiers possibles.

Proposition de structure: on pourrait réserver les premiers blocs du système de fichiers aux noms de fichiers ainsi qu'aux numéros des blocs correspondant à chaque fichier.

ReX : Oui c'est évident.

On sait que les noms de fichiers font au maximum 16 caractères + 1 caractère pour le '\0' (donc 17 octets car 1 char=1 octet).

ReX : Non, 16 octets suffisent, des '\0' en fin de nom uniquement si le nom fait moins de 16 caractères.

On sait également qu'un fichier contient au maximum 2040 blocs, chaque bloc étant numéroté sur 2 octets. On pourrait donc avoir en début du système de fichier: 17 octets+2 octets*2040 blocs = 4097 octets pour la description d'un fichier.

ReX : Non, 4096 octets soit 16 blocs de 256.

Or d'après l'une de vos remarques dans le wiki, un fichier doit être décrit par un nombre entier de blocs. Pour un fichier, il nous faudra donc 4097/256=16.004 soit 17 blocs. Il peut y avoir jusqu'à 64 fichiers dans le répertoire, il nous faudra donc 17 blocs*64 fichiers= 1088 blocs pour la description des fichiers.

ReX : Non 1024 blocs de 256 octets dans le superbloc.

Ainsi, pour la fonction LS, il suffira de lire les premiers caractères tous les 17 blocs ( du premier caractère au caractère '\0').

ReX : Non, tous les 16 blocs.

Question 2: Ne faudrait-il pas également stocker quelque part le nombre de fichier qu'il y a dans le répertoire afin de savoir jusqu'à quel bloc la fonction LS doit aller ?

ReX : Non, un fichier dont le nom n'est constitué que de '\0' est réputé ne pas exister.

Question 3: on a donc vu que les 1088 premiers blocs au maximum serviraient à la description du système de fichier. Il reste donc 31250-1088=30132 blocs dans le système de fichier.

ReX : Non, 32768-1024=31744 blocs.

Comment utiliser ces blocs? Ces blocs doivent-ils stocker le contenu des fichiers ?

ReX : Oui, c'et évident.

En effet, avec la fonction TYPE, nous allons créer des fichiers et ces fichiers devront être stockés quelque part. Cependant, étant donné que ce pico système de fichiers est prévu pour un microcontrôleur, je ne sais pas si c'est le contenu des fichiers qui doit être stocké dans les blocs ou autre chose (peut être l'adresse des fichiers, le fichiers se trouvant autre part). En effet, je me dis que si un fichier est très volumineux, il ne pourra pas rentrer dans le système de fichier, ce dernier étant composé d'un nombre limité de blocs, et les blocs étant eux même limité en nombre d'octets.

ReX : Je ne comprend pas ton problème. De tout façon comme dit plus haut, les 31744 blocs suivant le superbloc doivent contenir les données des fichiers.

Désolé de poser des questions peut être basique aussi tard, mais je pense qu'une fois que j'aurai ces réponses, cela ira beaucoup mieux pour la suite. Merci d'avance pour vos réponses.

ReX : Les questions sont effectivement triviales et il est effectivement inquiétant que voir que la travail n'avance pas.

Amine: merci pour vos corrections.

D'après votre commentaire "32768-1024=31744 blocs", j'en déduis qu'il faut que je modifie ma commande dd (qui est actuellement "dd if=/dev/zero of=filesystem.bin bs=256 count=31250" pour avoir le bon filesystem).

ReX : Je comprends pas d'où tu sors le 31250. D'autant plus que la commande ci-dessous est bonne.

Amine : 31250 car 31250 blocs * 256 octets = 8 Mo.

ReX : Haaaa je vois tu utilises le système métrique international où le mégaoctet vaut 10^6 octets, sauf qu'aucun informaticien n'utilisera cette norme hors sol. Quand je parle de 8 Mo c'est 8x1024x1024 octets. Tout simplement parce qu'une puce mémoire de 8 Mo c'est bien 8x1024x1024 octets.

Amine: D'accord merci pour l'information !

'''Nouvelle commande dd:'''

dd if=/dev/zero of=filesystem.bin bs=256 count=32768

=== Fonction LS version 2 ===

Dans notre structure du système de fichier, le superbloc est constitué de 1024 blocs (16 blocs * 64 fichiers), un fichier étant décrit par 16 blocs. Le nom du fichier est donc écrit au début de tous les blocs multiples de 16. Par exemple, le nom du premier fichier est dans les 16 premiers octets du premier bloc, le nom du 2ème fichier est dans les 16 premiers octets du 32ème bloc et ainsi de suite, tant que des fichiers existent. Lorsque qu'il n'y a plus de fichier, le nom du premier caractère du bloc multiple de 16 est un 0.

Voici le code:
// Fonction pour lister les noms de fichiers présents dans le système de fichiers
void LS() {
unsigned char buffer[BLOCK_SIZE];
int fileCount = 0;

for (int blockNum = 1; blockNum <= MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, BLOCK_SIZE);

// Vérifier si le bloc est vide
if (buffer[0] == 0) {
break; // Plus de fichiers à lire
}

char filename[MAX_FILENAME_LENGTH];
memcpy(filename, buffer, MAX_FILENAME_LENGTH);

// Afficher le nom du fichier
printf("%s\n", filename);
fileCount++;
}

if (fileCount == 0) {
printf("Aucun fichier trouvé.\n");
}
}

ReX : Tu supposes que si un fichier a un nom vide, les suivants auront aussi un nom vide. C'est possible mais dans ce cas la commande <code>RM</code> ca être plus compliquée à écrire.

ReX : Tu ne sembles pas comprendre que la mémoire d'un microcontrôleur est limitée. Pourquoi lire le premier bloc de description d'un fichier en entier ? Dit autrement c'est quoi l'intérêt de lire 256 octets alors que 16 suffisent ?

ReX : Pourquoi tu ne lis pas le premier fichier ? Autrement dit pourquoi décaler tout d'un bloc ?

Amine: Merci pour vos remarques. J'ai apporté les modifications à LS dans la section "Semaine 4" du wiki.

'''Réflexion par rapport aux autres fonctions:'''

J'ai créé les fonctions TYPE et CAT mais il y a malheureusement un problème pour l'instant. Vous pouvez les retrouver en pièce jointe dans l'archive du fichier programme.c.

Le problème que j'ai est que lorsque j'affiche le contenu du fichier créé avec TYPE, j'obtiens plein de caractères spéciaux. Par exemple, je créé le fichier "mon_fichier.txt" avec la fonction TYPE, et je mets en entré standard "hello". Ensuite, je veux afficher le contenu de ce fichier grâce à la fonction CAT. Cependant, ce qui s'affiche dans le terminal n'est pas ce que je veux. De la même manière, lorsque je fais la commande "cat filesystem.bin" dans le terminal, c'est la même chose s'affiche, des donnés parasites.

ReX : Avant même de lire ton code je vais te poser la question de savoir comment tu récupères un bloc libre ? Quel algorithme tu utilises. Personnellement je ne sais pas faire sans ajouter au superbloc un tableau bit à bit des blocs libres. Pour avoir un bit pour chaque bloc du système de fichiers, il faut 32768/8=4096 octets soit 16 blocs.

Amine: ok je vais donc ajouter ce tableau de 16 blocs à la suite de mes premiers 1024 blocs servant à la description de fichier. Le superbloc fera maintenant 1024+16=1040 blocs (plus de détail à la fonction RM de la semaine 4).

Question 1: est ce que la fonction CAT que je dois créer doit renvoyer la même chose que "cat filesystem.bin" ?

ReX : Je préfère ne pas répondre tellement la question montre un manque de réflexion.

Question 2: comment savoir combien de blocs doivent etre attribué à un fichier? Par exemple, si je créé un fichier "mon_fichier.txt" et que je mets en entrée standard le texte "hello", un seul bloc suffi pour stocker ce texte. Cependant, si j'avais mis beaucoup de texte en entrée standard, il aurait fallu plus de blocs. Doit-on calculer la taille de l'entrée standard ou doit-on attribuer toujours le meme nombre de blocs à un fichier? Peut-etre ainsi attribuer 2040 blocs par fichier, meme s'il n'en utilise que 1.

ReX : Là encore c'est une question stupéfiante tellement la réponse est évidente. Il suffit de lire les données sur l'entrée standard et de passer au bloc de données suivant dès que le bloc courant est rempli. La question à poser c'était de se demander comment il est possible d'avoir la taille exacte du fichier pour un <code>CAT</code>. Il est uniquement possible de l'avoir à 256 octets près puisque rien n'indique si le dernier block est vide. Le mieux aurait été de prévoir 4 octets dans la description d'un fichier pour stocker la taille. En l'espèce on considérera que les fichiers sont des fichiers ASCII et qu'ils seront terminés par des <code>\'0</code> qui ne seront pas affichés.

== Semaine 4 ==

Voici un bilan de ce que j'ai fait à ce stade du projet:

* j'ai choisi une structure du système de fichier
* j'ai créé les fonctions readBlock et writeBlock permettant de lire et d'écrire des blocs
* j'ai crée la fonction LS permettant d'afficher le nom des fichiers présents dans le système de fichiers
* j'ai programmer un main permettant d'utiliser les fonctions (LS, TYPE...) depuis le terminal
* j'ai réflechi aux fonctions TYPE et CAT.

Actuellement, je suis en train de créer les fonctions TYPE et CAT.

=== Fonction LS version 3 ===
void LS() {
unsigned char buffer[MAX_FILENAME_LENGTH];
int fileCount = 0;

// Parcourir tous les 16 blocs de 0 jusqu'à MAX_FILES_IN_DIRECTORY
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, MAX_FILENAME_LENGTH);

// Vérifier si le nom de fichier est vide
if (buffer[0] != 0) {

// Afficher le nom du fichier
printf("%s\n", buffer);
fileCount++;
}
}

if (fileCount == 0) {
printf("Aucun fichier trouvé.\n");
}
}
Suite à vos remarques, j'ai effectué les modifications suivantes de la fonction LS:

* Je ne suppose plus que si un fichier a un nom vide, les autres auront aussi un nom vide.
* Je ne lis plus les 256 octets mais seulement les 16 premiers octets car cela suffit.
* Je ne lisais en effet pas le premier bloc. Je pensais que le premier bloc était d'indice 1 mais ce n'est pas le cas.

ReX : Ouiiii ! Une fonction correcte. Passe à <code>RM</code> maintenant, c'est la plus facile à faire concernant l'image bit à bit des blocs libres.

=== Fonction setBlockAvailability version 1 ===

Comme vous l'avez indiqué dans votre remarque, il faut un tableau dans le superbloc qui nous permettra de connaitre la disponibilité bit par bit de chaque bloc. Sachant qu'il y a dans notre système de fichiers 32768 blocs, et qu'il faut 1 bit par bloc, nous avons besoin de 32768 bits, soit 32768/8=4096 octets soit 4096/256=16 blocs. Notre superbloc sera donc comme suit: les 1024 premiers blocs servent à la description des fichiers, c'est à dire à leur nom suivi des numéros de blocs qui leur sont associés, puis ces 1024 blocs sont suivi de 16 blocs listant la disponibilité de chaque bloc.

ReX : Bien résumé.

Nous allons tout d'abord écrire la fonction "setBlockAvailability" prenant en paramètre le numéro du bloc à traiter (<code>blockNum</code>) et la disponibilité souhaitée pour ce bloc (<code>availability</code>). Cette fonction permet de marquer la disponibilité d'un bloc spécifique dans le système de fichiers. Nous utiliserons la convention suivante: un bloc disponible sera marqué par un 1 tandis qu'un bloc non disponible par un 0.
#define SUPERBLOCK_START_BLOCK 1024

void setBlockAvailability(int blockNum, int availability) {
// Calculer l'index du byte et le bit offset correspondant
int byteIndex = blockNum / 8;
int bitOffset = blockNum % 8;

// Lire le byte existant du bloc de disponibilité des blocs
unsigned char buffer[1];
readBlock(SUPERBLOCK_START_BLOCK + byteIndex, 0, buffer, 1);

// Mettre à jour le bit d'offset correspondant
if (availability) {
buffer[0] |= (1 << bitOffset);
} else {
buffer[0] &= ~(1 << bitOffset);
}

// Écrire le byte mis à jour dans le bloc de disponibilité des blocs
writeBlock(SUPERBLOCK_START_BLOCK + byteIndex, 0, buffer, 1);
}

ReX : Un tableau de un octet c'est un octet (variable <code>buffer</code>).

Amine: je vais utiliser un <code>unsigned char buffer.</code> Je suis conscient qu'un char vaut un octet mais je ne pense pas qu'il y ait un type de donnée de la taille d'un bit, c'est pourquoi je travaille avec un octet mais je modifie les bits de cet octet grâce aux algorithmes.

ReX : Il faut bien que tu travailles sur un octet vu que l'état des blocs est stocké sous la forme d'octets. Je disais juste qu'un tableau de 1 élément n'a pas d'intérêt par rapport à l'élément lui-même.

Amine: c'est vrai, modification faite.

ReX : Non il faut calculer le numéro du bloc avant de faire le <code>readBlock</code>.

Amine: ok je vais calculer le numéro de bloc avant.

ReX : La mise à jour du bit est correcte mais le block et le déplacement dans le block ne sont pas correctement calculés.

Amine: je vais vous expliquer le raisonnement que j'avais. Prenons un exemple concret, imaginons que je veuille marquer le bloc 1030 comme disponible:

# Calcul de l'index de l'octet et du bit offset :
#* <code>blockNum</code> = 1030
#* Index du byte = 1030 / 8 = 128
#* Bit offset = 1030 % 8 = 6
# Lecture de l'octet existant de disponibilité:
#* Nous lisons l'octet existant à l'index 128 dans les blocs de disponibilité.
# Mise à jour du bit de disponibilité :
#* Nous voulons marquer le bloc 1030 comme disponible, donc nous utilisons le masque <code>(1 << 6)</code> pour définir le bit 6 à 1 dans l'octet. Le résultat sera, par exemple, <code>00100000</code>.
# Écriture du byte mis à jour :
#* Nous écrivons le byte mis à jour <code>00100000</code> à l'index 128 dans les blocs de disponibilité.

ReX : Ben non, un vrai exemple :
* Il faut prendre un n° de bloc plus grand : 3072 ;
* Numéro d'octet dans la carte des blocs libres : 3072/8=384 ;
* Numéro du bloc dans la carte des blocs libres : 384/256=1 ;
* Numéro du bit <code>b</code> dans l'octet n° 384-256=128 du bloc 1 : 3072%8=0 ;
* Il faut donc lire l'octet <code>o</code> de numéro 128 du bloc 1, puis modifier cet octet par <code>o |= (1<<b)</code> ou <code>o &= ~(1<<b)</code> ;
* Enfin il faut écrire l'octet modifié dans le bloc 1.
Amine: merci pour cet exemple! J'ai compris d'où vient mon erreur. Voir fonction setBlockAvailability version 3.

Remarque: par convention, j'apellerai dans la suite de ce projet "premier superbloc" le superbloc correspondant à la description des fichiers, c'est à dire les 1024 premiers blocs, et j'appellerai "second superbloc" les 16 blocs qui suivent servant à décrire la disponibilité des blocs (du bloc 1024 au bloc 1039 inclu). Le reste des blocs servira à stocker les données.

ReX : Non, le superblc est l'ensemble des informations hors blocs de données, tu ne peux pas utiliser un vocabulaire au hasard. Parle de blocs de description des fichiers ou de carte des blocs libres.

Amine: ok

Je pense que le problème qui se pose est que l'indice du bit dans le second superbloc ne correspond pas à l'indice du bloc dans le système de fichier. Par exemple, nous voudrions que si le bloc 1030 est disponible dans le système de fichier, alors le bit numéro 1030 du deuxième superbloc soit à 1, ce qui n'est pas le cas ici. En effet, on se trouve bien dans le bon octet avec ma méthode mais l'écriture du bit se fait de la droite vers la gauche alors qu'on voudrait l'inverse. Ainsi, si le 6ème bit de l'octet doit être à 1, alors il faudrait qu'on obtienne <code>00000100</code> et non <code>00100000.</code> L'indice du bit coinciderait ainsi avec le numéro du bloc.

ReX : Non, réfléchit à nouveau.

Voir plus bas la nouvelle version de setBlockAvailability.

Explication de l'algorithme pour mettre le bit à 1 ou 0:

* <code>buffer[0] |= (1 << bitOffset);</code> : Cette ligne utilise l'opérateur OR bit à bit (<code>|=</code>) pour activer (mettre à 1) le bit spécifié par <code>bitOffset</code> dans le premier octet (<code>buffer[0]</code>). Cela se fait en décalant le bit 1 vers la gauche de <code>bitOffset</code> positions, puis en effectuant une opération OR bit à bit avec le contenu actuel de <code>buffer[0]</code>. Cette opération modifie uniquement le bit ciblé, laissant les autres bits inchangés.

ReX : Oui ça c'est bon.

* <code>buffer[0] &= ~(1 << bitOffset);</code> : Cette ligne utilise l'opérateur AND bit à bit (<code>&=</code>) pour désactiver (mettre à 0) le bit spécifié par <code>bitOffset</code> dans <code>buffer[0]</code>. Pour ce faire, l'expression <code>~(1 << bitOffset)</code> est utilisée pour créer un masque où tous les bits sont à 1, sauf celui correspondant à <code>bitOffset</code>, qui est à 0. En effectuant ensuite une opération AND bit à bit entre le masque et le contenu actuel de <code>buffer[0]</code>, on met à 0 le bit ciblé sans affecter les autres bits.

ReX : Ca aussi.

=== Fonction setBlockAvailability version 2 ===

void setBlockAvailability(int blockNum, int availability) {
// Calculer l'indice de l'octet et le bit offset correspondant
int byteIndex = blockNum / 8;
int bitOffset = 7 - (blockNum % 8); // Inversion de l'ordre des bits

// Calculer le numéro du bloc du super bloc où se trouve l'octet de disponibilité correspondant
int availabilityBlockNum = SUPERBLOCK_START_BLOCK + byteIndex;

// Lire l'octet existant dans le bloc de disponibilité du super bloc
unsigned char buffer;
readBlock(availabilityBlockNum, 0, &buffer, 1);

// Mettre à jour le bit d'offset correspondant :
if (availability) {
buffer |= (1 << bitOffset);
} else {
buffer &= ~(1 << bitOffset);
}

// Écrire l'octet mis à jour dans le bloc de disponibilité du super bloc
writeBlock(availabilityBlockNum, 0, &buffer, 1);
}
J'ai modifié la ligne <code>int bitOffset = 7 - (blockNum % 8);</code> pour inverser l'ordre des bits sélectionnés, de sorte que le bit correspondant au bloc disponible soit correct.

ReX : Encore plus faux.

Si on veut rendre le bloc 1030 indisponible alors que les autres blocs sont disponibles:

ReX : Pardon ? Le bloc de données est libre ou pas suivant la carte des blocs libres. Le rendre disponible n'est possible que si un fichier le comportant est détruit.

# Calcul de l'indice de l'octet et du bit offset correspondant :
#* <code>blockNum = 1030</code>
#* <code>byteIndex = 1030 / 8 = 128</code>
#* <code>bitOffset = 7 - 1030 % 8 = 1</code> Cela signifie que le bit d'intérêt se trouve à la position 2 dans l'octet.
# Calcul du numéro du bloc du super bloc où se trouve l'octet de disponibilité correspondant :
#* <code>availabilityBlockNum = SUPERBLOCK_START_BLOCK + 128 = 1024 + 128 = 1152</code> Donc, nous devons accéder à l'octet 1152 pour mettre à jour la disponibilité du bloc 1030.
# Lecture de l'octet existant dans le bloc de disponibilité du super bloc :
#* Le contenu de l'octet dans le bloc 1152 avant la mise à jour : 11111111 (en binaire)
# Mise à jour du bit d'offset correspondant :
#* Supposons que nous voulions marquer le bloc 1030 comme non disponible (<code>availability = 0</code>).
#* Le bitOffset est 1.
#* Nous effectuons une opération AND avec le complément du bit à la position 1 : <code>11111111 & 11111101 = 11111101</code>
# Écriture de l'octet mis à jour dans le bloc de disponibilité du super bloc :
#* Le contenu de l'octet 128 du second superbloc après la mise à jour : 11111101 (en binaire)

ReX : Toujours aussi faux.

Maintenant, le bit d'indice 1 du 128 ème octet du second superbloc est mis à 0, indiquant que le bloc 1030 n'est plus disponible. Les autres bits restent inchangés car nous avons effectué un AND avec un masque binaire qui avait des 1 partout sauf à la position du bit que nous souhaitions mettre à 0.

ReX : Erreur sur erreur.

=== Fonction setBlockAvailability version 3 ===
J'ai compris d'où vient l'erreur. La fonction readBlock prends en premier paramètre le numéro du bloc à lire, je ne peux donc pas lui donner la valeur "SUPERBLOCK_START_BLOCK + byteIndex" car byteIndex s'exprime en octet alors qu'on s'attend à un nombre de bloc ici. Il faut donc divisé byteIndex par 256 pour être en unité "bloc", et préciser le bit qu'on veut lire grâce à l'offset.

Pour obtenir l'octet que l'on veut, il faut prendre le reste de la division de byteIndex par 256. On va ensuite stocker cet octet dans notre "buffer".

Pour savoir quel bit modifier dans ce "buffer", on va prendre le reste de la division du bloc dont on veut mettre à jour la disponibilité par 8. On va ainsi pouvoir modifier ce bit grâce à l'algorithme, puis réécrire l'octet à son emplacement d'origine.

Cette fonction gère la carte de disponibilités des blocs. Si un bloc est disponible, alors elle le met un 0, si il est indisponible, elle met un 1.
#define SUPERBLOCK_START_BLOCK 1024

void setBlockAvailability(int blockNum, int availability) {

int byteIndexInCard = blockNum / 8; //Numéro d'octet dans la carte des blocs libres
int blockIndexInCard = byteIndexInCard / 256; //Numéro du bloc dans la carte des blocs libres
int byteIndexInBlock = byteIndexInCard % 256; //Numéro d'octet dans le bloc contenant le bit de disponibilité
int bitOffset = blockNum % 8; //Numéro du bit dans l'octet n°byteIndexInBlock du bloc blockIndexInCard

//indice du bloc contenant le bit à mettre à jour dans le bloc de description
int availabilityBlockNum = FIRST_DISPONIBILITY_CARD_BLOCK + blockIndexInCard;

// Lire l'octet existant dans le bloc de disponibilité du super bloc
unsigned char buffer;
readBlock(availabilityBlockNum, byteIndexInBlock, &buffer, 1);

// Mettre à jour le bit d'offset correspondant :
if (availability==1) { // indisponible
buffer |= (1 << bitOffset); // Mettre le bit à 1

} else { // disponible
buffer &= ~(1 << bitOffset); // Mettre le bit à 0
}

// Écrire l'octet mis à jour dans le bloc de disponibilité du super bloc
writeBlock(availabilityBlockNum, byteIndexInBlock, &buffer, 1);
}

ReX : Ben voila, c'est pas possible de te taxer d'excès de vitesse mais c'est bon.

update: j'ai fait une petite modification, maintenant un bloc disponible est marqué d'un 0 et un bloc indisponible est marqué d'un 1. C'est mieux dans la mesure où initialement, tous les blocs sont disponibles et tous les blocs sont à 0. Cela évite de devoir créer une fonction qui initialise toute la carte de disponibilités à 1 pour dire que tous les blocs sont disponibles.

=== Fonction RM version 1 ===

void RM(const char *filesystem_path, const char *filename) {
unsigned char buffer[BLOCK_SIZE];
int fileNum = -1;

// Parcourir les blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (memcmp(filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {
// Effacer le nom du fichier dans le superbloc
memset(filenameBuffer, 0, MAX_FILENAME_LENGTH);
writeBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

unsigned char fileBuffer[MAX_BLOCKS_PER_FILE * 2];
readBlock(blockNum, MAX_FILENAME_LENGTH, fileBuffer, MAX_BLOCKS_PER_FILE * 2);

// Libérer les blocs associés au fichier et réinitialiser les numéros de blocs
for (int i = 0; i < MAX_BLOCKS_PER_FILE * 2; i += 2) {
int blockNum = ((int)fileBuffer[i] << 8) + (int)fileBuffer[i + 1];
if (blockNum == 0) {
break; // Fin du fichier
}
setBlockAvailability(blockNum, 0); // Marquer le bloc comme disponible
fileBuffer[i] = 0;
fileBuffer[i + 1] = 0;
}

// Mettre à jour les numéros de blocs associés au fichier
writeBlock(blockNum, MAX_FILENAME_LENGTH, fileBuffer, MAX_BLOCKS_PER_FILE * 2);

fileNum = blockNum;
break; // Fichier trouvé, sortir de la boucle
}
}

// Afficher le résultat de l'opération
if (fileNum == -1) {
printf("Le fichier \"%s\" n'a pas été trouvé.\n", filename);
} else {
printf("Le fichier \"%s\" a été supprimé avec succès.\n", filename);
}
}

ReX : Vous utilisez <code>strcmp</code> comme <code>strncmp</code>. C'est bien la dernière qu'il faut utiliser mais en précisant la longueur du nom en paramètre, pas la taille maximale.

Amine: vous voulez dire que j'utilise memcmp au lieu de strncmp ? Ok je vais utiliser strncmp, c'est vrai que c'est plus adapté pour la comparaison de chaines de caractère.

ReX : Ha oui c'est <code>memcmp</code> que tu utilises. Ca ne peut effectivement pas marcher. Effectivement avec <code>strncmp</code> cela peut marcher vu qu'il s'arrête au premier 0 contrairement à <code>memcmp</code>.

Cependant, pourquoi doit-on passer la taille exacte du nom du fichier en paramètre, et non la taille maximale d'un nom de fichier? En effet, cela semble fonctionner en mettant la taille maximale en paramètre, tandis que lorsque l'on met la taille exacte du nom du fichier, cela pose un problème: on ne compare plus toute la chaîne de caractère mais seulement une portion du nom complet. Ainsi, si je crée par exemple un fichier que j'appelle "file1", puis que j’exécute la fonction RM "/picofs filesystem.bin RM file" par exemple, alors le fichier file1 va être supprimé quand même car on ne comparera que strlen(file)=4 premiers caractères, qui sont les mêmes, donc la fonction considérera ces chaines comme identiques. On pourrait alors se dire qu'il faudrait alors prendre plutôt comme taille en paramètre de la fonction strlen la taille du nom du fichier se trouvant dans le système de fichier plutôt que celle du nom donné en paramètre de RM. Cependant, le même problème se pose si la taille du nom du fichier du système de fichier est plus petite que celle du nom du fichier passé en paramètre. Par exemple, si le fichier présent dans système de fichier est "file", et qu'on met la longueur de file en paramètre de la fonction strcmp, puis qu'on exécute la commande "/picofs filesystem.bin RM file5", alors file sera quand même supprimé, car on ne comparera que les strlen(file)=4 premiers caractère. Finalement, une solution serait de rajouter une condition qui vérifie que les deux chaînes sont de taille identiques pour pouvoir réaliser la comparaison sur la taille exacte du nom du fichier. Cependant, il me semble qu'en mettant MAX_FILENAME_LENGTH qui vaut 16 en paramètre, cela fonctionne directement. Vous pouvez tester cela en testant mon programme.

ReX : Ok pour <code>strncmp</code> avec la taille maximale d'un nom de fichier.

etape 1: créer un fichier :
./picofs filesystem.bin TYPE fichier.txt

etape 2: verifier que le fichier a bien été créé :
./picofs filesystem.bin LS

Le terminal renvoie bien "fichier.txt"

etape 3: essayer de supprimer le fichier en mettant une chaine troncature du nom du fichier créé :
./picofs filesystem.bin RM fich

le terminal renvoi <<Le fichier "fich" n'a pas été trouvé.>>, le fichier n'a donc pas été supprimé .

etape 4: essayer de supprimer le fichier en mettant un nom plus grand incluant "fichier.txt" :
./picofs filesystem.bin RM fichier.txtt

terminal renvoi <<Le fichier "fichier.txtt" n'a pas été trouvé.>>

etape 5: enfin, tester en mettant le nom exacte du fichier que l'on veut supprimer :
./picofs filesystem.bin RM fichier.txt

terminal renvoi <<Le fichier "fichier.txt" a été supprimé avec succès.>>

Finalement, on voit que cela fonctionne avec la taille maximale mise en paramètre. On pourrait reprocher à cette méthode de comparer des caractères dans le vide, ce qui n'est pas optimal dans une optique d'économie de mémoire qui est la notre, mais la taille maximale d'un nom de fichier étant relativement faible (16 octets), on peut peut-être négliger cela au vu de l'économie d'une opération supplémentaire (comparaison de la taille des chaines de caractères).

ReX : Le parcours des blocs de données du fichier est atroce. Il faut parcourir les numéros de blocs dans le premier bloc du fichier derrière le nom du fichier puis il faut parcourir le 15 autres blocs.

Amine: Ok, je vais corriger cela dans la version 2 de RM (voir semaine 5).

Fonctionnement de la fonction RM:

* Parcours des blocs réservés pour la description des fichiers (superbloc) à partir du bloc 0, en incrémentant de 16 à chaque itération pour accéder aux blocs de noms de fichiers.

ReX : OK.

* Dans chaque bloc de noms de fichiers, la fonction compare le nom de fichier recherché avec les noms stockés dans les 16 octets de chaque bloc.

ReX : Non la fonction ne fait pas ça par contre il faudrait, oui.

Amine: Je pensais que c'était ce que je faisais avec "memcmp(filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0)".

* Si le nom de fichier est trouvé, la fonction efface le nom du fichier dans le superbloc en remplaçant les 16 octets du bloc par des zéros.

ReX : OK.

* Ensuite, la fonction accède aux octets suivants du même bloc pour obtenir les numéros de blocs associés au fichier.

ReX : Non, la boucle sort largement du premier bloc.

* Pour chaque paire de numéros de blocs (2 octets chacun), la fonction convertit les octets en un numéro de bloc. Si le numéro de bloc est nul, cela signifie la fin des blocs associés au fichier, sinon, la fonction marque ce bloc comme disponible en utilisant la fonction <code>setBlockAvailability</code> et réinitialise les numéros de blocs dans le tableau à zéro.
* Les numéros de blocs réinitialisés sont ensuite réécrits dans le bloc de description du fichier.

ReX : L'idée est là mais vu que la boucle n'est pas bonne, rien ne peut marcher.

* La fonction affiche ensuite un message indiquant le résultat de l'opération : soit que le fichier a été supprimé avec succès, soit que le fichier n'a pas été trouvé.

== Semaine 5 ==

=== Fonction RM version 2 ===

Concernant les remarques que vous m'avez faites précédemment:

* j'utilise maintenant la fonction <code>strncmp</code> pour la comparaison des chaines de caractères
* j'ai normalement corrigé le parcours des blocs. Je parcours maintenant d'abord les blocs multiples de 16 à la recherche du bloc contenant le nom du fichier à supprimer. Puis je parcours les 16 blocs de description du fichier à supprimer, afin de récupérer les numéros de blocs, libérer ces blocs dans la carte de disponibilité et de réinitialiser ces blocs dans les blocs de données.

void RM(const char *filesystem_path, const char *filename) {
int fileFound = -1;
int offset;

// Parcourir les blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char*)filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {

// Effacer le nom du fichier dans le superbloc
memset(filenameBuffer, 0, MAX_FILENAME_LENGTH);
writeBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);
fileFound = 1;
offset = blockNum;
break;
}

}

// Fin de fonction si fichier inexistant
if (fileFound == -1) {
printf("Le fichier \"%s\" n'a pas été trouvé.\n", filename);
return;
}

unsigned char buffer[BLOCK_SIZE];
//bloc que l'on va remplir de 0 et mettre à la place des blocs de données
memset(buffer, 0, BLOCK_SIZE); //on rempli buffer de 0

for (int blockNum=offset; blockNum<offset + 16; blockNum++) {

//premier bloc de description, celui contenant le nom du fichier dans les 16 premiers octets
if (blockNum == offset) {

unsigned char fileBuffer[BLOCK_SIZE-MAX_FILENAME_LENGTH];
//bloc dans lequel on va stocker les blocs de description de fichier
readBlock(blockNum, MAX_FILENAME_LENGTH, fileBuffer, BLOCK_SIZE-MAX_FILENAME_LENGTH);

// Libérer les blocs associés au fichier dans la carte de disponibilités
// et dans les blocs de description
for (int i = MAX_FILENAME_LENGTH; i < BLOCK_SIZE-MAX_FILENAME_LENGTH; i += 2) {
int blockNumData = ((int)fileBuffer[i] << 8) + (int)fileBuffer[i + 1];
if (blockNumData == 0) {
break; // Fin du fichier
}
setBlockAvailability(blockNumData, 0); // Marquer le bloc comme disponible
fileBuffer[i] = 0;
fileBuffer[i + 1] = 0;
writeBlock(blockNumData, 0, buffer, BLOCK_SIZE); //on efface les blocs de données
}
writeBlock(blockNum, MAX_FILENAME_LENGTH, fileBuffer, BLOCK_SIZE-MAX_FILENAME_LENGTH);
//on efface le premier bloc de description

} else {
unsigned char fileBuffer[BLOCK_SIZE];
readBlock(blockNum, 0, fileBuffer, BLOCK_SIZE);

// Libérer les blocs associés au fichier dans la carte de disponibilités et dans les blocs de description
for (int i = 0; i < BLOCK_SIZE; i += 2) {
int blockNumData = ((int)fileBuffer[i] << 8) + (int)fileBuffer[i + 1];
if (blockNumData == 0) {
break; // Fin du fichier
}
setBlockAvailability(blockNumData, 0); // Marquer le bloc comme disponible
fileBuffer[i] = 0;
fileBuffer[i + 1] = 0;
writeBlock(blockNumData, 0, buffer, BLOCK_SIZE); //on efface les blocs de données
}
writeBlock(blockNum, 0, fileBuffer, BLOCK_SIZE); //on efface le bloc de description
}
}
printf("Le fichier \"%s\" a été supprimé avec succès.\n", filename);
}

ReX : Pour construire le nombre sur 16 bits utiliser le OU plutôt que l'addition.

ReX : Heu non, je ne lis pas cette fonction avec tout ce code dupliqué, la seule différence entre les deux alternative est la position de début de l'adresse du premier bloc de données (<code>MAX_FILENAME_LENGTH</code> dans un cas et 0 dans l'autre). Donc l'alternative ne doit servir qu'à initialiser ce début, le reste du code doit être factorisé.

ReX : Et corrige le code, tu utilises deux tableaux de blocs (perte mémoire), tu écris le bloc à zéro dans l'itération (perte CPU).

=== Fonction RM version 3 ===

Suite à vos remarques, j'ai réalisé les modifications suivantes:

* j'utilise maintenant le OU plutôt que l'addition pour construire le nombre sur 16 bits.

* j'ai factorisé le code grâce à la création de la variable <code>startOffset</code> valant 16 lorsqu'on se trouve dans le bloc contenant le nom du fichier et valant 0 lorsqu'on se trouve dans les autres.

* Pour ce qui est du fait que j'utilise 2 tableaux de blocs, j'ai du mal à voir comment faire avec 1 seul tableau de blocs car ces deux tableaux n'ont pas du tout le même rôle. Le tableau <code>fileBuffer</code> permet de stocker les 16 blocs de description d'un fichier un à un. Lorsqu'on stocke un bloc dans <code>fileBuffer</code>, on lit ensuite les octets un à un de ce bloc afin de former des numéros de blocs, et pour chaque numéro de bloc créé, on va réinitialiser le bloc correspondant dans les blocs de données. Pour cela, on a donc besoin d'un autre bloc qui viendra écraser les anciens blocs de données. C'est pourquoi j'ai créé un bloc <code>buffer</code>qui est composé de 0 et qui va écraser les blocs de données. On ne peut pas utiliser <code>fileBuffer</code> car on a besoin d'un bloc de zéros, et si on réinitialise <code>fileBuffer</code> on perd toute les données qui s'y trouvent. Une possibilité serait de relire le bloc de donné à chaque itération de la deuxième boucle for imbriquée; cela permettrait de pouvoir réinitialiser le tableau fileBuffer à chaque itérations de cette boucle afin de stocker ce bloc de 0 dans les blocs de données, puis de restocker dans ce même tableau le bloc de description. Cependant, je ne pense pas que ce soit optimal de faire autant appel à la fonction readBlock.

* j'ai créé une fonction resetBock qui permet comme son nom l'indique de reset un bloc en le remplissant de 0. Cela nous évite de créer deux tableaux de blocs dans RM, bien que je pense que cela revienne au même car on fait appel à une fonction qui créé un tableau de blocs. Quoi qu'il en soit, cela allège le code et cette fonction pourra surement me resservir par la suite.

void RM(const char *filesystem_path, const char *filename) {
int fileFound = -1;
int offset;
unsigned char fileBuffer[BLOCK_SIZE];

// Parcourir les blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char *)filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {
// Effacer le nom du fichier dans le superbloc
memset(filenameBuffer, 0, MAX_FILENAME_LENGTH);
writeBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);
fileFound = 1;
offset = blockNum;
break;
}
}

// Fin de fonction si fichier inexistant
if (fileFound == -1) {
printf("Le fichier \"%s\" n'a pas été trouvé.\n", filename);
return;
}

for (int blockNum = offset; blockNum < offset + 16; blockNum++) {
int startOffset = 0;
if (blockNum == offset) {
startOffset = MAX_FILENAME_LENGTH;
}
readBlock(blockNum, startOffset, fileBuffer, BLOCK_SIZE - startOffset);

// Libérer les blocs associés au fichier dans la carte de disponibilités et dans les blocs de description
for (int i = 0; i < BLOCK_SIZE - startOffset; i += 2) {
int blockNumData = (fileBuffer[i] << 8) | fileBuffer[i + 1];
if (blockNumData == 0) {
break; // Fin du fichier
}
setBlockAvailability(blockNumData, 0); // Marquer le bloc comme disponible
fileBuffer[i] = 0;
fileBuffer[i + 1] = 0;
resetBlock(blockNumData); //on efface les blocs de données
}
writeBlock(blockNum, startOffset, fileBuffer, BLOCK_SIZE - startOffset);
}
printf("Le fichier \"%s\" a été supprimé avec succès.\n", filename);
}
'''Fonction resetBlock'''
void resetBlock(unsigned int blockNum) {
unsigned char buffer[BLOCK_SIZE];
memset(buffer, 0, BLOCK_SIZE);

// Utiliser writeBlock pour écrire les données du buffer dans le bloc
writeBlock(blockNum, 0, buffer, BLOCK_SIZE);
}

ReX : Ca s'améliore. Mais pourquoi cette fonction <code>resetBlock</code> ? Tu crois que dans qu'un système de fichiers perd du temps à mettre à zéro les blocs de données libérés ? Si oui, regarde la page de manual de la commande <code>shred</code>, ça manque à ta culture.

Amine: Après avoir consulter le manual de la commande <code>shred</code>, je vois que cette commande écrit des données aléatoires sur l'emplacement du fichier sur le disque. Par défaut, <code>shred</code> effectue un certain nombre de passes (par exemple, 3 passes) pendant lesquelles il écrit des données aléatoires sur l'emplacement du fichier sur le disque. Après avoir écrit les données aléatoires, <code>shred</code> peut effectuer des passes supplémentaires pendant lesquelles il écrit des données nulles (des zéros) sur le même emplacement. L'objectif de <code>shred</code> est d'augmenter la sécurité en rendant plus difficile la récupération des données supprimées à l'aide d'outils de récupération de données.

Cependant, j'ai aussi consulté comment fonctionne la commande <code>rm</code> de linux, et je vois que cette commande libère l'espace occupé par le fichier en marquant les blocs associés comme disponibles. Cela signifie que les données peuvent encore être récupérées à l'aide d'outils de récupération de données, à moins que des mesures supplémentaires ne soient prises pour écraser physiquement l'espace avec des données aléatoires (c'est ce que fait l'utilitaire <code>shred</code>).

On va donc opter pour la deuxième option, c'est à dire qu'on ne va pas perdre notre temps à remettre à zéro les blocs de données libérés, on va simplement marquer les blocs correspondants comme étant disponibles. Cela nous permettra de nous émanciper de la fonction resetBlock et de n'avoir plus qu'un seul tableau de blocs.

ReX : Sinon lire un bloc complet de pointeurs de blocs de données en mémoire n'est pas forcément optimal. L'idéal serait de lire ces blocs morceau par morceau (de 64 octets par exemple). Certes un bloc serait traité en 4 lectures/écritures (ce qui ralentirait le traitement) mais on gagne en mémoire. Le mieux serait de mettre la taille des morceaux en constante pour pouvoir choisir entre vitesse d'exécution et utilisation mémoire.

Amine: d'accord je comprends. Je vais modifier la fonction pour qu'on puisse découper la lecture/écriture en plusieurs blocs.

=== Fonction RM version 4 ===
Modifications apportées:

* je ne réinitialise plus les blocs de données, je supprime simplement le pointeur du fichier vers les blocs de données et je désigne les blocs comme "disponible" dans le carte de disponibilités. J'ai donc supprimé la fonction resetBlock.

* je ne lis plus les blocs en une seule fois mais en plusieurs fois via la variable CHUNK_SIZE:

# J'ai introduit la constante <code>CHUNK_SIZE</code> pour définir la taille de chaque morceau que nous allons lire/écrire à la fois. Cela permet de découper les opérations en blocs plus petits.
# Dans la boucle <code>for</code> où on parcours les blocs à partir de <code>offset</code>, j'ai ajouté une boucle interne qui parcourt les données du bloc en morceaux de taille <code>CHUNK_SIZE</code>.
# À l'intérieur de la boucle interne, j'ai calculé la taille réelle du morceau (<code>chunkSize</code>) en prenant le minimum entre <code>CHUNK_SIZE</code> et la quantité de données restant à lire/écrire dans le bloc.
# J'ai modifié la fonction <code>readBlock</code> pour lire seulement la quantité de données spécifiée par <code>chunkSize</code> à partir de <code>chunkStart</code>. Ces données sont stockées dans le tableau <code>fileBuffer</code>.
# Ensuite, j'ai effectué les mêmes opérations de libération des blocs associés au fichier, en parcourant les données du morceau et en marquant les blocs comme disponibles.
# Finalement, j'ai utilisé la fonction <code>writeBlock</code> pour écrire le morceau de données modifié dans le bloc, en utilisant la même <code>chunkStart</code> pour déterminer où écrire les données.

#define CHUNK_SIZE 64

int min(int a, int b) {
return a < b ? a : b;
}

void RM(const char *filesystem_path, const char *filename) {
int fileFound = -1;
int offset;
unsigned char fileBuffer[BLOCK_SIZE];

// Parcourir les blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char *)filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {
// Effacer le nom du fichier dans le superbloc
memset(filenameBuffer, 0, MAX_FILENAME_LENGTH);
writeBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);
fileFound = 1;
offset = blockNum;
break;
}
}

// Fin de fonction si fichier inexistant
if (fileFound == -1) {
printf("Le fichier \"%s\" n'a pas été trouvé.\n", filename);
return;
}

for (int blockNum = offset; blockNum < offset + 16; blockNum++) {
int startOffset = 0;

if (blockNum == offset) {
startOffset = MAX_FILENAME_LENGTH;
}

for (int chunkStart = startOffset; chunkStart < BLOCK_SIZE; chunkStart += CHUNK_SIZE) {
int chunkSize = min(CHUNK_SIZE, BLOCK_SIZE - chunkStart);
readBlock(blockNum, chunkStart, fileBuffer, chunkSize);

for (int i = 0; i < chunkSize; i += 2) {
int blockNumData = (fileBuffer[i] << 8) | fileBuffer[i + 1];
if (blockNumData == 0) {
writeBlock(blockNum, chunkStart, fileBuffer, chunkSize);
printf("Le fichier \"%s\" a été supprimé avec succès.\n", filename);
return; // Sortir des boucles
}
setBlockAvailability(blockNumData, 0); // Marquer le bloc comme disponible
fileBuffer[i] = 0;
fileBuffer[i + 1] = 0;
}

writeBlock(blockNum, chunkStart, fileBuffer, chunkSize);
}
}

printf("Le fichier \"%s\" a été supprimé avec succès.\n", filename);
}

ReX : Si on trouve un n° de bloc de données à 0, il faut sortir des deux boucles les plus externes après avoir fait le <code>writeBlock</code>.

Amine: Modification faites ci-dessus. Maintenant, dès qu'on trouve un n° de bloc de données à 0 dans la boucle la plus interne, on effectue le <code>writeBlock</code> et ensuite on utilise <code>return</code> pour sortir des deux boucles les plus externes. Cela permet d'optimiser le code en évitant de continuer à traiter inutilement le reste des blocs.

ReX : Pas très propre (duplication de code) mais nous allons nous en contenter.

=== Fonction intermédiaire TYPE version 1 ===

J'ai également commencé à réfléchir à la fonction TYPE. Pour l'instant, elle ne fait qu'ajouter les noms de fichier dans le superbloc. Cela permet de pouvoir tester les fonctions LS et RM (voir dans la rubrique compilation et exécution comment utiliser le programme).
// Fonction pour créer un fichier avec le nom donné et le contenu fourni en entrée standard
void TYPE(const char *filesystem_path, const char *filename) {
unsigned char buffer[MAX_FILENAME_LENGTH];
// Parcours des blocs réservés pour la description des fichiers
for (int blockNum = 0; blockNum <= MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, MAX_FILENAME_LENGTH);
// Vérifier si le bloc est vide (pas de nom de fichier)
if (buffer[0] == 0) {
// Écrire le nom du fichier dans l'emplacement vide du superbloc
writeBlock(blockNum, 0, (const unsigned char *)filename, MAX_FILENAME_LENGTH);
break; // Fichier créé, sortir de la boucle
}
}
printf("Le fichier \"%s\" a été créé avec succès.\n", filename);
}

ReX : Si la boucle se termine sans trouver de slot libre le message de succès s'affiche tout de même.

ReX : Le paramètre <code>filename</code> n'a pas forcément une taille de <code>MAX_FILENAME_LENGTH</code>.

Selon moi, la fonction TYPE devra respecter 3 étapes:

# Enregistrement du Nom du Fichier: L'ajout du nom du fichier dans un des blocs de la première partie du superbloc.
# Stockage des Données du Fichier: La récupération des données saisies en entrée standard par l'utilisateur et leur stockage dans des blocs du système de fichiers à partir d'une certaine position, comme le bloc 1040.
# Mise à Jour de la Disponibilité des Blocs: L'indication que les blocs dans lesquels les données ont été écrites ne sont plus disponibles en modifiant les bits correspondants dans la deuxième partie du superbloc (les 16 derniers blocs du super bloc).

ReX : Relis le point 3 et dit moi si tu te comprends toi même ?

Amine: Ma phrase n'est effectivement pas très claire. Je voulais dire que la fonction TYPE devra mettre à jour la carte de disponibilité du superbloc. C'est à dire que lorsqu'elle écrira des données dans des blocs, elle devra indiquer dans la carte de disponibilités que ces blocs ne sont plus disponibles.

=== Fonction intermédiaire TYPE version 2 ===

Suite à vos remarques, j'ai apporté les modifications suivantes à la fonction TYPE:

* j'ai ajouté une condition pour l'affichage du message de succès de la création d'un fichier (placeFound).

* le paramètre <code>filename</code> n'ayant pas forcément une taille de <code>MAX_FILENAME_LENGTH</code>, je calcule maintenant la longueur de filename, afin d'écrire seulement le nom du fichier avec la fonction writeBlock.

Il fonction n'est bien évidemment pas fini, elle ajoute seulement le nom du fichier dans le superbloc pour l'instant. Cela me permet de tester les fonctions LS et RM.
void TYPE(const char *filesystem_path, const char *filename) {
size_t sizeFilename = strlen(filename);
printf("size filename=%d\n", sizeFilename);
unsigned char buffer[MAX_FILENAME_LENGTH];
int placeFound = 0;

if (sizeFilename > MAX_FILENAME_LENGTH) {
printf("Impossible de créer le fichier, nom trop long\n");
return;
}

// Parcours des blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, MAX_FILENAME_LENGTH);
// Vérifier si le bloc est vide (pas de nom de fichier)
if (buffer[0] == 0) {
// Écrire le nom du fichier dans l'emplacement vide du superbloc
if (sizeFilename < MAX_FILENAME_LENGTH) {
sizeFilename+=1;
}
writeBlock(blockNum, 0, (const unsigned char *)filename, sizeFilename);
placeFound = 1;
break; // Fichier créé, sortir de la boucle
}
}
if (placeFound == 1) {
printf("Le fichier \"%s\" a été créé avec succès.\n", filename);
} else {
printf("Plus de place dans le système de fichier pour créer ce fichier.\n", filename);
}
}

ReX : Mieux, attention il faut copier aussi le <code>\'0</code> final du nom, donc <code>sizeFilename+1</code>. Sinon tu n'es pas sûr qu'il y ait un zéro final. Et attention n°2, il ne faut pas copier ce <code>\'0</code> si le nom fait la taille maximale.

Amine: ok j'ai modifié la fonction TYPE ci-dessus. J'ai ajouté une condition: si le nom du fichier est inférieur à la taille maximale de nom de fichier, alors on incrémente de 1 la taille du nom de fichier. Cela nous permet d'écrire le '\0' dans le bloc de description. Dans le cas où le nom du fichier est de la taille maximale, nous n'avons pas besoin d'écrire le '\0', on n'incrémente donc pas la taille de 1.

J'ai également ajouté une condition: si le nom du fichier est supérieur à la taille maximale, alors un message d'erreur s'affiche et le fichier n'est pas créé.

ReX : OK. L'embryon de fonction <code>TYPE</code> est correct, il manque juste le principal : la création des blocs de données.

=== Fonction MV version 1 ===

J'ai ici créé la fonction MV qui permet de changer le nom d'un fichier. Pour ce faire, la fonction parcourt les blocs de descriptions à la recherche du fichier dont on veut changer le nom. Lorsque ce fichier est trouvé, on supprime l'ancien nom en mettant des 0 sur 16 octets, puis on vient réécrire le nouveau nom dans le même emplacement. Enfin, on sort de la boucle et on affiche le succès ou non de l'opération.
// Fonction qui modifie le nom du fichier
void MV(const char *filesystem_path, const char *old_filename, const char *new_filename) {
size_t sizeNew_filename = strlen(new_filename);
size_t sizeOld_filename = strlen(old_filename);
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
int fileFound = 0;
// Parcourir les blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);
// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char*)filenameBuffer, old_filename, MAX_FILENAME_LENGTH) == 0) {
// Effacer le nom du fichier dans le superbloc
memset(filenameBuffer, 0, MAX_FILENAME_LENGTH);
writeBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);
// Écrire le nom du fichier dans l'emplacement
writeBlock(blockNum, 0, (const unsigned char *)new_filename, sizeNew_filename);
fileFound=1;
break; // Nom modifié, sortir de la boucle
}
}
if (fileFound == 1) {
printf("Le nom du fichier \"%s\" a été renommé avec succès.\n", old_filename);
} else {
printf("Le fichier \"%s\" n'a pas été trouvé.\n", old_filename);
}
}

ReX : Inutile d'écraser l'ancien nom avec des zéros. Il suffit de copier le nouveau en s'assurant qu'il y ait un zéro final sauf si le nouveau nom fait la taille maximale.

Amine: ok, je vais faire les modifications dans la version 2.

== Semaine 6 ==

=== Fonction MV version 2 ===
Dans cette nouvelle version de la fonction MV, j'ai effectué les modifications suivantes:

* je n'écrase plus l'ancien nom avec des 0
* Je colle simplement le nouveau nom par dessus l'ancien, en m'assurant qu'il y ait bien le '\0' à la fin lorsque la taille du nom du fichier est inférieur à la taille maximale. Comme précédemment, afin de m'assurer de la présence de ce '\0' à la fin du nom, j'incrémente la taille de 1 lorsque qu'elle est inférieur à la taille max. Cependant, je ne suis pas sûr à 100% que ce soit la bonne manière de faire.

// Fonction qui modifie le nom du fichier
void MV(const char *filesystem_path, const char *old_filename, const char *new_filename) {
size_t sizeNew_filename = strlen(new_filename);
size_t sizeOld_filename = strlen(old_filename);
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
int fileFound = 0;

// Parcourir les blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {

readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char*)filenameBuffer, old_filename, MAX_FILENAME_LENGTH) == 0) {

if (sizeNew_filename < MAX_FILENAME_LENGTH) {
sizeNew_filename+=1;
}

// Écrire le nom du fichier dans l'emplacement
writeBlock(blockNum, 0, (const unsigned char *)new_filename, sizeNew_filename);

fileFound=1;

break; // Nom modifié, sortir de la boucle
}
}
if (fileFound == 1) {
printf("Le nom du fichier \"%s\" a été renommé avec succès.\n", old_filename);
} else {
printf("Le fichier \"%s\" n'a pas été trouvé.\n", old_filename);
}
}

ReX : C'est bon. La fonction était triviale.

=== Fonction TYPE version 1 ===
void TYPE(const char *filesystem_path, const char *filename) {
size_t sizeFilename = strlen(filename);
unsigned char buffer[MAX_FILENAME_LENGTH];
int placeFound = -1;

if (sizeFilename > MAX_FILENAME_LENGTH) {
printf("Impossible de créer le fichier, nom trop long\n");
return;
}

// Parcours des blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, MAX_FILENAME_LENGTH);
// Vérifier si le bloc est vide (pas de nom de fichier)
if (buffer[0] == 0) {
// Écrire le nom du fichier dans l'emplacement vide du superbloc
if (sizeFilename < MAX_FILENAME_LENGTH) {
sizeFilename += 1; // Ajouter '\0' s'il y a de la place
}
writeBlock(blockNum, 0, (const unsigned char *)filename, sizeFilename);
placeFound = blockNum;

// Lire les données depuis l'entrée standard
unsigned char dataBuffer[BLOCK_SIZE];
size_t bytesRead;
int dataBlockNum = findAvailableBlock(); // Premier bloc de données à partir du bloc 1040
printf("dataBlockNum%d\n",dataBlockNum);
int blockSizeUsed = 0; // Compteur d'octets dans le bloc actuel
int dataBlocksNeeded = 1; // Nombre de blocs de données nécessaires

while ((bytesRead = fread(dataBuffer + blockSizeUsed, 1, BLOCK_SIZE - blockSizeUsed, stdin)) > 0) {
blockSizeUsed += bytesRead;

// Si le bloc actuel est plein, passer au bloc suivant
if (blockSizeUsed == BLOCK_SIZE) {
// printf("dataBlockNum=%d\n",dataBlockNum);
writeBlock(dataBlockNum, 0, dataBuffer, BLOCK_SIZE);
setBlockAvailability(dataBlockNum, 1);

dataBlockNum++; // Passer au bloc suivant
blockSizeUsed = 0; // Réinitialiser la taille utilisée
dataBlocksNeeded++;
}
}

// Écrire le dernier bloc partiel, s'il y en a un
if (blockSizeUsed > 0) {
writeBlock(dataBlockNum, 0, dataBuffer, blockSizeUsed);
setBlockAvailability(dataBlockNum, 1);
}

// Écrire les numéros de blocs utilisés dans le bloc de description
unsigned char blockNumberBuffer[2];
int currentBlockNum = 1040;

for (int i = 0; i < dataBlocksNeeded; i++) {
blockNumberBuffer[0] = (currentBlockNum >> 8) & 0xFF;
blockNumberBuffer[1] = currentBlockNum & 0xFF;
writeBlock(placeFound, MAX_FILENAME_LENGTH + i * 2, blockNumberBuffer, 2);
currentBlockNum++;
}

break; // Fichier créé, sortir de la boucle
}
}

if (placeFound != -1) {
printf("Le fichier \"%s\" a été créé avec succès.\n", filename);
} else {
printf("Plus de place dans le système de fichier pour créer ce fichier.\n");
}
}

ReX : La constante 1040 ne doit pas apparaître en numérique, ce doit être une constante calculée à partir des autres constantes.

Amine: Ok. Je ne l'avais pas défini comme une constante car il s'agit dans la fonction ci-dessus d'une variable qui est incrémenté à chaque itération.

ReX : Je suis las de te répéter que le mémoire est comptée : tu utilises encore un bloc de <code>BLOCK_SIZE</code> octets, c'est trop.

Amine: Comment utiliser des blocs plus petit sachant qu'il s'agit là de blocs de données et qu'un bloc fait 256 octets d'après l'énoncé ? Dois-je les subdiviser en plusieurs blocs plus petit comme fait dans la fonction RM, en 4 blocs de 64 octets par exemple ?

Fonctionnement de la fonction TYPE:

* étape 1: on parcourt les blocs de descriptions à la recherche d'un bloc disponible. Si on ne trouve pas de bloc disponible, on renvoie un message d'erreur, sinon on passe à l'étape suivante.
* étape 2: Si on trouve un emplacement libre dans les blocs de disponibilité, on écrit le nom du fichier dans cet emplacement.

ReX : Dans les blocs de description de fichiers pas dans les blocs de disponibilité.

Amine: Oui autant pour moi.

* étape 3: Ensuite, on lit le texte entré par l'utilisateur en entrée standard, on le répartit dans des blocs de taille BLOCK_SIZE, on met à jour la disponibilité des blocs utilisés.

ReX : Non, il faut appeler <code>findAvailableBlock</code> pour chaque bloc de données à utiliser, aucune certitudes que les blocs libres soient en séquence.

Amine: ok, je ferai cela dans la version 2

* étape 4: Enfin, on écrit les numéros des blocs de données utilisés dans les blocs de description de ce fichier, les numéros étant écris sur deux octets.

ReX : Non cela doit se faire au fur et à mesure des appels à <code>findAvailableBlock</code> et les numéros des blocs de données peuvent s'étaler sur les 16 blocs de description du fichier. Confusion totale sur ce point. Vous n'avez pas compris le mécanisme.

Amine: je corrige cela dans la version 2. J'ai bien compris le mécanisme mais ce n'est pas facile à traduire en code.

=== Fonction TYPE version 2 ===
Dans cette nouvelle version de TYPE, j'ai fait les modifications suivantes:

* j'appelle maintenant <code>findAvailableBlock</code> pour chaque bloc de données à utiliser
* j'écris maintenant les numéros de blocs au fur et à mesures des appels à <code>findAvailableBlock</code>
* je n'utilise plus de tableaux de taille 256 octets mais des tableaux de tailles CHUNK_SIZE. J'ai choisi ici CHUNK_SIZE = 64 octets.

J'utilise toujours un bloc de taille BLOCK_SIZE en attendant de comprendre si je dois diviser ce bloc en plusieurs blocs de taille plus petite ou s'il y a un moyen de ne pas du tout utiliser ces blocs.
void TYPE(const char *filesystem_path, const char *filename) {
size_t sizeFilename = strlen(filename);
unsigned char buffer[MAX_FILENAME_LENGTH];
int placeFound = -1;

if (sizeFilename > MAX_FILENAME_LENGTH) {
printf("Impossible de créer le fichier, nom trop long\n");
return;
}

// Parcours des blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, MAX_FILENAME_LENGTH);
// Vérifier si le bloc est vide (pas de nom de fichier)
if (buffer[0] == 0) {
// Écrire le nom du fichier dans l'emplacement vide du superbloc
if (sizeFilename < MAX_FILENAME_LENGTH) {
sizeFilename += 1; // Ajouter '\0' s'il y a de la place
}
writeBlock(blockNum, 0, (const unsigned char *)filename, sizeFilename);
placeFound = blockNum;

// Lire les données depuis l'entrée standard et écrire dans le fichier
int dataBlockNum = findAvailableBlock(); // Premier bloc de données à partir du bloc 1040
printf("Premier bloc dans lequel on écrit = %d\n", dataBlockNum);
int blockSizeUsed = 0; // Compteur d'octets dans le bloc actuel

unsigned char chunkBuffer[CHUNK_SIZE];
size_t bytesRead;

while ((bytesRead = fread(chunkBuffer, 1, CHUNK_SIZE, stdin)) > 0) {
// Écrire le chunk dans le bloc de données
writeBlock(dataBlockNum, blockSizeUsed, chunkBuffer, bytesRead);
setBlockAvailability(dataBlockNum, 1);

// Écrire le numéro du bloc actuel dans la description du fichier
unsigned char blockNumberBuffer[2];
blockNumberBuffer[0] = (dataBlockNum >> 8) & 0xFF;
blockNumberBuffer[1] = dataBlockNum & 0xFF;
writeBlock(placeFound, MAX_FILENAME_LENGTH + dataBlockNum * 2, blockNumberBuffer, 2);

blockSizeUsed += bytesRead;

// Si le bloc actuel est plein, passer au bloc suivant
if (blockSizeUsed == BLOCK_SIZE) {
dataBlockNum = findAvailableBlock(); // Passer au bloc suivant
blockSizeUsed = 0; // Réinitialiser la taille utilisée
}
}

break; // Fichier créé, sortir de la boucle
}
}

if (placeFound != -1) {
printf("Le fichier \"%s\" a été créé avec succès.\n", filename);
} else {
printf("Plus de place dans le système de fichier pour créer ce fichier.\n");
}
}

=== Fonction findAvailableBlock ===
Cette fonction renvoie l'indice du premier bloc disponible. Je me sers de cette fonction dans la fonction TYPE.
#define FIRST_DATA_BLOCK 1040
#define FIRST_DISPONIBILITY_CARD_BLOCK 1024

// Renvoie le premier bloc de donné disponible
int findAvailableBlock() {
unsigned char availabilityBuffer[BLOCK_SIZE];
int offset;

// Lire la carte de disponibilité (à partir du bloc 1)
for (int blockNum = FIRST_DISPONIBILITY_CARD_BLOCK; blockNum < FIRST_DATA_BLOCK; blockNum++) {
readBlock(blockNum, 0, availabilityBuffer, BLOCK_SIZE);

if (blockNum==FIRST_DISPONIBILITY_CARD_BLOCK) {
offset=FIRST_DATA_BLOCK/8;
} else {
offset=0;
}

// Parcourir les octets de la carte de disponibilité
for (int byteIndex = offset; byteIndex < BLOCK_SIZE - offset; byteIndex++) {
unsigned char byte = availabilityBuffer[byteIndex];

// Parcourir les bits de chaque octet
for (int bitIndex = 0; bitIndex < 8; bitIndex++) {
// Vérifier si le bit est à 0 (bloc disponible)
if ((byte & (1 << bitIndex)) == 0) {
// Calculer l'indice du bloc en fonction du bloc et du bit
int blockIndex = byteIndex * 8 + bitIndex;
return blockIndex;
}
}
}
}

// Aucun bloc disponible trouvé
return -1;
}

ReX : Même remarque que précédement sur les nombres 1024 et 1040.

Amine: Ok, j'ai remplacé 1024 par la constante FIRST_DISPONIBILITY_CARD_BLOCK et 1040 par la constante FIRST_DATA_BLOCK dans la fonction ci-dessus.

ReX : Vous n'avez toujours pas compris la contrainte sur la mémoire.

Amine: dois-je découper le bloc de taille BLOCK_SIZE en quatre blocs de taille 64 octets par exemple ?

ReX : Je ne vois pas ce que vous voulez faire avec <code>if (blockNum==1024) offset=1040/8; else offset=0;</code>.

Amine: dans la carte de disponibilité, chaque bit correspond à un bloc. Ainsi, les bits de 0 à 1040 dans la carte de disponibilité décrivent la disponibilité des blocs 0 à 1040. Or ces blocs correspondent au superbloc, et dans cette fonction, on veut connaître le premier bloc de données disponible. On ne s'intéresse donc pas au 1040 premiers bits de la carte de disponibilité. Je crée donc un offset égal à 1040/8 afin de ne pas prendre en compte les 1040 premiers bits soit les 1040/8=130 premiers octets. Cet offset ne s'applique que lorsqu'on se trouve dans le premier des 16 blocs de la carte de disponibilité, d'où la condition <code>if (blockNum==1024)</code>.

=== Fonction CAT version 1 ===
void CAT(const char *filesystem_path, const char *filename) {
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
unsigned char buffer[BLOCK_SIZE];
unsigned char blockNumberBuffer[2];
unsigned char dataBuffer[BLOCK_SIZE];
int offset;

// Parcours des blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char *)filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {
// Le nom du fichier a été trouvé

// Parcours les blocs de description
for (int descrBlockNum=0; descrBlockNum<MAX_BLOCKS_PER_FILE_DESCRIPTION; descrBlockNum++) {
if (descrBlockNum==0) {
offset=16;
} else {
offset=0;
}
readBlock(descrBlockNum+blockNum, offset, buffer, BLOCK_SIZE-offset);

// Lire les numéros de blocs associés à ce fichier depuis les blocs de description
unsigned char octet1 = buffer[offset];
unsigned char octet2 = buffer[offset+1];

int dataBlockNum = (octet1 << 8) | octet2;
printf("dataBlockNum=%d\n",dataBlockNum);

// Vérifier si le numéro de bloc est valide (non nul)
if (dataBlockNum == 0) {
return; // Fin du fichier
}

// Lire et afficher le contenu du bloc de données
readBlock(dataBlockNum, 0, dataBuffer, BLOCK_SIZE);
fwrite(dataBuffer, 1, BLOCK_SIZE, stdout);
}

return; // Fichier affiché, sortie de la fonction
}
}

// Si le fichier n'a pas été trouvé
printf("Le fichier \"%s\" n'a pas été trouvé.\n", filename);
}

ReX : Encore mieux : deux blocs de <code>BLOCK_SIZE</code> en mémoire.

ReX : Le <code>break</code> ne sort pas de la boucle externe.

Amine: Oui c'est vrai. J'ai remplacé le break pas un return ci-dessus.

Voici ma fonction <code>CAT</code>. Elle fonctionne en plusieurs étape:

* étape 1: on cherche dans les blocs de descriptions si le fichier dont on veut afficher le contenu existe. Si le nom de fichier est trouvé, on passe à l'étape 2. Sinon, on renvoie un message d'erreur.
* étape 2: si le fichier est trouvé, on parcours les 16 blocs de description de ce fichier.
* étape 3: grâce aux opérations de masquage et de décalage, on joint les octets deux par deux pour former un entier qui contient le numéro du bloc de données correspondant au fichier. Si cet entier vaut 0, alors cela signifie qu'il n'y a plus de blocs associé à ce fichier, on peut donc quitter la fonction. Si cet entier est différent de 0, alors on va lire le bloc correspondant à ce numéro et on affiche son contenu dans le terminal.

== Semaine 7 ==

=== Fonction CP version 1 ===
Voici ma fonction CP, qui permet de créer une copie d'un fichier existant. L'idée est la suivante: pour copier un fichier, on doit créer un nouveau fichier et lui attribuer les mêmes blocs de descriptions que le fichier source. Ainsi, le fichier source et le fichier destination pointeront vers les mêmes blocs de données, et auront le même contenu.

ReX : Perdu. Ce n'est absolument pas la fonction de copie de fichiers d'un système de fichiers.

Amine: Après avoir fait des recherches et après réflexion, je me rends compte que cette fonction CP présente un problème: en faisant pointé les blocs de données du fichier destination vers ceux du fichier source, toutes modifications du fichier source impactera le fichier destination, or ce n'est pas ce qu'on veut faire. Je vous propose donc une nouvelle version de la fonction CP ci-dessous qui remédie à ce problème.

void CP(const char *filesystem_path, const char *source_filename, const char *destination_filename) {
unsigned char source_filenameBuffer[MAX_FILENAME_LENGTH];
unsigned char destination_filenameBuffer[MAX_FILENAME_LENGTH];
unsigned char descriptionBuffer[BLOCK_SIZE];
int destination_offset;
int offset;

// Recherche du fichier source
int source_offset = -1;
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, source_filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier source
if (strncmp((const char *)source_filenameBuffer, source_filename, MAX_FILENAME_LENGTH) == 0) {
source_offset = blockNum;
break;
}
}

if (source_offset == -1) {
printf("Le fichier source \"%s\" n'a pas été trouvé.\n", source_filename);
return;
}

// Recherche d'un emplacement libre pour le fichier destination
destination_offset = -1;
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, destination_filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc est vide (pas de nom de fichier)
if (destination_filenameBuffer[0] == 0) {
destination_offset = blockNum;
break;
}
}

if (destination_offset == -1) {
printf("Plus de place dans le système de fichier pour créer la copie de \"%s\".\n", source_filename);
return;
}

// Ecrit le nom de la copie dans le bloc de description
writeBlock(destination_offset, 0, (const unsigned char *)destination_filename, strlen(destination_filename));

// Copier les blocs de description associés au fichier source dans les blocs de description du fichier destination
for (int i = 0; i < MAX_BLOCKS_PER_FILE_DESCRIPTION; i++) {
if (i==0) {
offset = MAX_FILENAME_LENGTH;
} else {
offset = 0;
}

readBlock(source_offset+i, offset, descriptionBuffer, BLOCK_SIZE-offset);
if (descriptionBuffer[offset]==0) {
return;
} else {
writeBlock(destination_offset+i, offset, descriptionBuffer, BLOCK_SIZE-offset);
}
}

printf("La copie de \"%s\" sous le nom \"%s\" a été créée avec succès.\n", source_filename, destination_filename);
}

== Semaine 8 ==
A ce stade du projet, les fonctions suivantes ont été validé par Monsieur Redon:

* fonction LS
* fonction RM
* fonction MV

Il reste donc les fonctions suivantes à terminer:

* fonction CAT
* fonction CP
* fonction TYPE

=== Fonction CAT version 2 ===
Suite à vos remarques sur la version 1, j'ai fais les modifications suivantes:

* je n'utilise non plus 2 tableaux de taille BLOCK_SIZE, mais 1 seul. Idéalement il faudrait en utiliser 0, je réfléchi donc à m’émanciper de ce tableau en le remplaçant par plusieurs plus petits tableaux.
* J'ai remplacé le <code>break</code> par un return

Cette fonction permet d'afficher le contenu d'un fichier créé avec la fonction TYPE. Pour se faire, on parcours tout d'abord les blocs de descriptions pour trouver le fichier dont ont veut afficher le contenu. Une fois ce fichier trouvé, on parcours les 16 blocs de description de ce fichier 1 à 1. Pour chacun de ces blocs de description, on va stocker récupéré les octets deux par deux afin de former des entiers. Pour se faire, on utilise la fonction <code>reconsituteNumber</code> que l'on détaillera juste après. Ces entiers correspondent aux blocs dans lesquels la donné du fichier se trouve. Une fois l'entier reconstitué, on affiche le contenu du bloc correspondant.
void CAT(const char *filesystem_path, const char *filename) {
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
unsigned char byteBuffer[2];
unsigned char dataBuffer[BLOCK_SIZE];
int offset;

// Parcours des blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char *)filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {
// Le nom du fichier a été trouvé

// Parcours les blocs de description
for (int descrBlockNum=0; descrBlockNum<MAX_BLOCKS_PER_FILE_DESCRIPTION; descrBlockNum++) {
if (descrBlockNum==0) {
offset=MAX_FILENAME_LENGTH;
} else {
offset=0;
}

// Lecture des octets deux par deux
for (int i=0; i<BLOCK_SIZE;i+=2) {
readBlock(descrBlockNum+blockNum, offset+i, byteBuffer, 2);

// Lire les numéros de blocs associés à ce fichier depuis les blocs de description
int dataBlockNum = reconsituteNumber(byteBuffer);

// Vérifier si le numéro de bloc est valide (non nul)
if (dataBlockNum == 0) {
return; // Fin du fichier
}

// Lire et afficher le contenu du bloc de données
readBlock(dataBlockNum, 0, dataBuffer, BLOCK_SIZE);
fwrite(dataBuffer, 1, BLOCK_SIZE, stdout);
}
}

return; // Fichier affiché, sortie de la fonction
}
}

// Si le fichier n'a pas été trouvé
printf("Le fichier \"%s\" n'a pas été trouvé.\n", filename);
}

=== Fonction reconsituteNumber ===
Cette fonction permet de reconstituer un numéro de bloc à partir de deux octets.
// Fonction qui reconstitue le numéro de bloc à partir du tableau
int reconsituteNumber(unsigned char blockNumberBuffer[2]) {
unsigned char octet1 = blockNumberBuffer[0];
unsigned char octet2 = blockNumberBuffer[1];
int dataBlockNum = (octet1 << 8) | octet2;
return dataBlockNum;
}

=== Fonction CP version 2 ===
Voici une version mise à jour de notre fonction CP qui duplique réellement les blocs de données du fichier source vers le fichier de destination. Cela implique d'attribuer de nouveaux blocs de données au fichier de destination et de mettre à jour la carte de disponibilité des blocs.
void CP(const char *filesystem_path, const char *source_filename, const char *destination_filename) {
unsigned char source_filenameBuffer[MAX_FILENAME_LENGTH];
unsigned char destination_filenameBuffer[MAX_FILENAME_LENGTH];
unsigned char descriptionBuffer[BLOCK_SIZE];
int destination_offset;
int source_offset;

// Recherche du fichier source
source_offset = -1;
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, source_filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier source
if (strncmp((const char *)source_filenameBuffer, source_filename, MAX_FILENAME_LENGTH) == 0) {
source_offset = blockNum;
break;
}
}

if (source_offset == -1) {
printf("Le fichier source \"%s\" n'a pas été trouvé.\n", source_filename);
return;
}

// Recherche d'un emplacement libre pour le fichier destination
destination_offset = -1;
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, destination_filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc est vide (pas de nom de fichier)
if (destination_filenameBuffer[0] == 0) {
destination_offset = blockNum;
break;
}
}

if (destination_offset == -1) {
printf("Plus de place dans le système de fichier pour créer la copie de \"%s\".\n", source_filename);
return;
}

// Copie du nom de la copie dans le bloc de description
writeBlock(destination_offset, 0, (const unsigned char *)destination_filename, strlen(destination_filename));

// Copier les blocs de données associés au fichier source dans de nouveaux blocs de données pour le fichier destination
for (int i = 0; i < MAX_BLOCKS_PER_FILE_DESCRIPTION; i++) {
if (i == 0) {
int offset = MAX_FILENAME_LENGTH;
readBlock(source_offset + i, offset, descriptionBuffer, BLOCK_SIZE - offset);
if (descriptionBuffer[offset] == 0) {
break;
}
int newDataBlock = findAvailableBlock(); // Trouver un nouveau bloc de données disponible
writeBlock(destination_offset + i, offset, descriptionBuffer, BLOCK_SIZE - offset);
setBlockAvailability(newDataBlock, 1); // Marquer le nouveau bloc de données comme utilisé
} else {
int offset = 0;
readBlock(source_offset + i, offset, descriptionBuffer, BLOCK_SIZE);
if (descriptionBuffer[offset] == 0) {
break;
}
int newDataBlock = findAvailableBlock(); // Trouver un nouveau bloc de données disponible
writeBlock(destination_offset + i, offset, descriptionBuffer, BLOCK_SIZE);
setBlockAvailability(newDataBlock, 1); // Marquer le nouveau bloc de données comme utilisé
}
}

printf("La copie de \"%s\" sous le nom \"%s\" a été créée avec succès.\n", source_filename, destination_filename);
}

= Compilation et exécution =
'''Création du système de fichiers :'''
dd if=/dev/zero of=filesystem.bin bs=256 count=32768

'''Compilation :'''

gcc picofs.c -o picofs

'''Exécution de LS, TYPE, CAT, RM, MV ou CP :'''

./picofs filesystem.bin LS
./picofs filesystem.bin TYPE mon_fichier.txt
./picofs filesystem.bin CAT mon_fichier.txt
./picofs filesystem.bin RM mon_fichier.txt
./picofs filesystem.bin MV mon_fichier.txt mon_fichier2.txt
./picofs filesystem.bin CP mon_fichier.txt mon_fichier2.txt

= Documents Rendus =
[[Fichier:Pcfs.c.tar|vignette]]

SE4 2022/2023 EC1

2023-09-02T11:37:31Z

Asellali : /* Semaine 8 */

= Objectifs =

Il vous est demandé de :
* réaliser un micro système de fichiers ;
* le système de fichiers doit résider dans un fichier de 8 Mo ;
* le système de fichiers est géré par un exécutable obtenu à partir d'un programme C ;
* L'éxécutable prend deux arguments, le premier est le chemin du fichier dans lequel réside le système de fichiers, les paramètres suivants concernent l'action à appliquer sur le système de fichiers ;
* le micro système de fichier ne comporte qu'un répertoire : le répertoire principal, le répertoire principal peut comporter au maximum 64 fichiers, un fichier est caractérisé par un nom de 16 caractères au maximum et ses blocs de données, un fichier peut comporter au maximum 2040 blocs de données ;
* un bloc de données fait 256 octets et les blocs sont numérotés sur 2 octets ;
* les différentes actions possibles sur le système de fichiers sont :
** <code>TYPE</code> pour créer un fichier si possible, le nom du fichier suit la commande, le contenu du fichier est donné en entrée standard de l'exécutable ;
** <code>CAT</code> pour afficher un fichier, le nom du fichier suit la commande ;
** <code>RM</code> pour détruire un fichier, le nom du fichier suit la commande ;
** <code>MV</code> pour renommer un fichier, les noms original et nouveau du fichier suivent la commande ;
** <code>CP</code> pour copier un fichier, les noms de l'original et de la copie du fichier suivent la commande ;

= Matériel nécessaire =

Un PC sous Linux.

= Travail réalisé =

== Semaine 1 ==

ReX : attention, ce micro-système de fichiers est prévu pour un microcontrôleur, vos variables globales ne peuvent pas dépasser quelques centaines d'octets.

ReX : pour la création du système de fichiers la commande <code>dd</code> suffit, vous voulez dire le formatage du système de fichiers ?

* création du programme programme.c contenant les différentes structures et les différentes fonctions.
* Piste d'amélioration: faire en sorte que la fonction CAT affiche le contenu exact des fichiers passés en argument.

Le code fourni est un programme en langage C qui simule un système de fichiers basique. Ce programme permet aux utilisateurs d'effectuer diverses actions telles que créer, afficher, supprimer, renommer et copier des fichiers dans un système de fichiers simulé. Le système de fichiers est stocké dans un fichier binaire.

ReX : vous n'avez pas tenu compte de la première remarque, vous chargez tout le superbloc et le répertoire racine, votre code ne convient pas.

ReX : vos structures utilisent des types entiers dont la taille n'est pas explicitée, utilisez les types de <code>stdint.h</code>.

ReX : la création de fichier n'est pas fonctionnelle, vous ne cherchez pas les blocs libres, vous ne copiez pas le contenu du fichier dans les blocs, même remarque pour toutes les autres fonctions.

ReX : il manque les fonctions d'accès aux pages du système de fichiers.

'''Explication du programme programme.c'''

Voici une brève explication des principaux éléments et fonctions du code :

# Structures :
#* Fichier : Représente un fichier dans le système de fichiers. Il contient un nom (nom) avec une longueur maximale de 16 caractères, un tableau de numéros de bloc (blocs) où le contenu du fichier est stocké (jusqu'à 2040 blocs), et le nombre de blocs utilisés par le fichier (nbBlocs).
#* Repertoire : Représente le répertoire principal du système de fichiers. Il contient un tableau de fichiers (<code>fichiers</code>) et le nombre de fichiers dans le répertoire (<code>nbFichiers</code>).
# Fonctions :
#* <code>chargerSystemeFichiers</code> : Charge le système de fichiers à partir d'un fichier binaire donné (chemin) dans une structure Repertoire.
#* <code>sauvegarderSystemeFichiers</code> : Sauvegarde le système de fichiers stocké dans la structure Repertoire dans un fichier binaire (chemin).
#* <code>creerFichier</code> : Crée un nouveau fichier dans le système de fichiers avec un nom et un contenu donnés. Le contenu du fichier est simulé en le divisant en blocs.
#* <code>afficherFichier</code> : Affiche le contenu d'un fichier avec le nom spécifié.
#* <code>detruireFichier</code> : Supprime un fichier avec le nom spécifié du système de fichiers.
#* <code>renommerFichier</code> : Renomme un fichier avec l'ancien nom spécifié en un nouveau nom.
#* <code>copierFichier</code> : Copie un fichier avec le nom spécifié en créant un nouveau fichier avec le nom de copie spécifié.
# Fonction <code>main</code> :
#* La fonction <code>main</code> est le point d'entrée du programme.
#* Elle prend des arguments en ligne de commande : <code><chemin_systeme_fichiers></code> et <code><action></code>.
#* <code><chemin_systeme_fichiers></code> est le chemin vers le fichier binaire où le système de fichiers est stocké.
#* <code><action></code> détermine quelle opération effectuer, comme <code>TYPE</code>, <code>CAT</code>, <code>RM</code>, <code>MV</code> ou <code>CP</code>.
#* En fonction de l'action spécifiée, le programme appelle la fonction correspondante pour effectuer l'opération souhaitée sur le système de fichiers.
Remarque : Le code fourni une simulation basique d'un système de fichiers et de ses opérations, mais il n'interagit pas réellement avec un système de fichiers réel sur le disque.

'''Comment utiliser le programme programme.c'''

étape 1: création du système de fichiers respectant le cahier des charges:

dd if=/dev/zero of=systeme_fichiers.bin bs=1M count=8

étape 2: compilation du programme C:

gcc programme.c -o gestionnaire_fs

étape 3: création d'un fichier dans le système de fichier:

./gestionnaire_fs systeme_fichiers.bin TYPE fichier1.txt

-> entrer le texte en entrée standard

étape 4: manipulation des différentes fonctions. Exemples:

./gestionnaire_fs systeme_fichiers.bin CAT fichier1.txt
./gestionnaire_fs systeme_fichiers.bin CP fichier1.txt copie.txt
./gestionnaire_fs systeme_fichiers.bin RM copie.txt
./gestionnaire_fs systeme_fichiers.bin MV fichier1.txt fichier2.txt

== Semaine 2 ==

Amine: Merci pour vos remarques. Désolé de ne pas avoir suivi votre première remarque, je pensais avoir compris ce qu'il fallait faire mais je me rend compte que non. Je vais tout reprendre depuis le début afin de repartir sur de bonnes bases.

'''Création du système de fichier avec la commande "dd"'''

A quoi sert la commande dd?

La commande <code>dd</code> permet de copier tout ou partie d'un disque par blocs d'octets, indépendamment de la structure du contenu du disque en fichiers et en répertoires (source : [https://doc.ubuntu-fr.org/dd]).

Structure de la commande

dd if=<nowiki><source> of=<cible> bs=<taille des blocs></nowiki>

<code>source</code> = données à copier

<code>cible</code> = endroit où les copier

<code>if</code> = input file

<code>of</code> = output file

<code>bs</code> = block size, habituellement une puissance de 2 supérieure ou égale à 512, représentant un nombre d'octets

Choix de la commande:

Pour la source, on prends <code>/dev/zero</code>: cela permet de créer un fichier rempli de 0. Ce fichier servira de base pour notre système de fichiers.

Pour la cible, on va l'appeler <code>filesystem.bin</Code> : ce sera notre système de fichier.

Pour la taille des blocs, on veut des blocs de données de 256 octets d'après l'enoncé. On va donc prendre <code>bs=256</code>.

Enfin, on veut que le système de fichier réside dans un fichier de 8 Mo. On va donc ajouter <code>count=31250</code>: cela indique que nous voulons écrire 32768 blocs de données dans le fichier (31250 * 256 octets = 8 Mo).

Résultat:

dd if=/dev/zero of=filesystem.bin bs=256 count=31250

Question pour M. Redon : j'ai ici essayé de respecter votre remarque "pour la création du système de fichiers la commande <code>dd</code> suffit". Cependant, pour votre seconde remarque "vous chargez tout le superbloc et le répertoire racine, votre code ne convient pas.", je ne suis pas sûr de comprendre où je fais cela: est-ce lors de la commande dd ou est-ce par la suite avec mon programme C? J'ai un peu modifié la commande dd comme vous pouvez le voir ci-dessus. Ai-je corrigé mon erreur avec cette nouvelle commande? J'ai essayé de justifier au maximum la commande dd que j'ai choisie.

ReX : Pas de problème avec la commande <code>dd</code> (mettez tous les extraits de code entre des balises <code>code</code>). Le problème est au niveau du programme C.

Amine: Ok je comprends mieux merci. Je vais donc reprendre le code étape par étape afin de mieux répondre au cahier des charges.

Gestion du système de fichier par un programme C

'''Création des structures'''
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>

// Structure pour représenter un bloc de données

struct DataBlock {
uint8_t data[256]; // 256 octets pour chaque bloc de données
};

// Structure pour représenter un fichier

struct File {
char filename[17]; // 16 caractères pour le nom du fichier + 1 caractère null-terminator
struct DataBlock data_blocks[2040]; // Tableau de blocs de données pour stocker le contenu du fichier
uint16_t num_data_blocks; // Nombre de blocs de données utilisés par le fichier
};

// Structure pour représenter un répertoire

struct Directory {
struct File files[64]; // Tableau de fichiers pour le répertoire principal
uint8_t num_files; // Nombre de fichiers dans le répertoire principal
};

Modification faite : suite à votre remarque, j'ai explicité la taille des entiers grâce aux types de <code>stdint.h.</code> (j'ai également mis les variables en anglais)

ReX : Vous ne pouvez pas utiliser ces structures, une instanciation d'une de ces structure prend trop d'espace mémoire, vous devez faire sans structure. Par ailleurs la façon dont vous représentez vos fichiers ne convient pas, la description d'un fichier contient des numéros de blocs, pas les blocs eux-même. Faites aussi attention qu'un fichier soit décrit par un nombre entier de blocs.

Question pratique: je n'arrive pas à mettre tout le code dans le même bloc comme vous l'avez fait ci-dessus dans l'étape 4 de la semaine 1. Je vois que c'est en format "préformaté" mais j'obtiens des blocs séparés lorsque j'applique ce format à mon code.

ReX : j'ai corrigé, pour un code entier la syntaxe n'est pas la même (un espace en début de chaque ligne), la balise c'est uniquement pour de très courts extraits de code.

=== Fonction <code>readBlock</code>===
Cette fonction est utilisée pour lire un bloc de données à partir du fichier <code>filesystem.bin</code> et le stocker dans un tableau de caractères (<code>storage</code>).

Fonction:

#define BLOCK_SIZE 256
// Fonction pour lire un bloc de données
void readBlock(unsigned int num, int offset, unsigned char *storage, int size) {
FILE *file = fopen("filesystem.bin", "rb");
if (file == NULL) {
perror("Erreur lors de l'ouverture du fichier");
return;
}
fseek(file, num * BLOCK_SIZE + offset, SEEK_SET);
fread(storage, 1, size, file);
fclose(file);
}

Paramètres :

* <code>num</code> : Numéro du bloc à lire. Chaque bloc contient 256 octets (1 bloc = 256 octets).
* <code>offset</code> : Décalage (en octets) à partir du début du bloc pour commencer la lecture.
* <code>storage</code> : Pointeur vers un tableau de caractères où les données lues seront stockées.
* <code>size</code> : Taille du tableau de caractères <code>storage</code>.

Fonctionnement :

* La fonction commence par ouvrir le fichier <code>filesystem.bin</code> en mode lecture binaire (<code>"rb"</code>).
* Elle utilise <code>fseek</code> pour positionner le curseur de lecture dans le fichier à l'endroit approprié pour commencer la lecture du bloc spécifié (<code>num</code>) à partir de l'offset (<code>offset</code>).
* Elle utilise ensuite <code>fread</code> pour lire <code>size</code> octets à partir du fichier et les stocker dans le tableau <code>storage</code>.
* Enfin, elle ferme le fichier avec <code>fclose</code>.

Note : Le paramètre <code>offset</code> est utilisé pour spécifier à partir de quel octet du bloc on souhaite commencer la lecture. Si <code>offset</code> est égal à 0, la lecture commencera depuis le début du bloc. Si <code>offset</code> est différent de 0, la lecture commencera à l'octet spécifié.

Remarque: dans votre mail, vous définissez "readBlock(unsigned int num,int offset,unsigned storage,int size)": storage n'est alors pas un pointeur vers un tableau de caractère. Je me suis donc permis de faire la modification.

ReX : OK pour la fonction, pas la peine d'en mettre autant dans le Wiki pour une fonction aussi simple.

=== Fonction <code>writeBlock</code> ===
Cette fonction est utilisée pour écrire un bloc de données dans le fichier <code>filesystem.bin</code> à partir d'un tableau de caractères (<code>storage</code>).

Fonction:

// Fonction pour écrire un bloc de données
void writeBlock(unsigned int num, int offset, const unsigned char *storage, int size) {
FILE *file = fopen("filesystem.bin", "rb+");
if (file == NULL) {
perror("Erreur lors de l'ouverture du fichier");
return;
}
fseek(file, num * BLOCK_SIZE + offset, SEEK_SET);
fwrite(storage, 1, size, file);
fclose(file);
}

Paramètres :

* <code>num</code> : Numéro du bloc où écrire.
* <code>offset</code> : Décalage (en octets) à partir du début du bloc pour commencer l'écriture.
* <code>storage</code> : Pointeur vers un tableau de caractères contenant les données à écrire dans le fichier.
* <code>size</code> : Taille du tableau de caractères <code>storage</code>.

Fonctionnement :

* La fonction commence par ouvrir le fichier <code>filesystem.bin</code> en mode lecture et écriture binaire (<code>"rb+"</code>).
* Elle utilise <code>fseek</code> pour positionner le curseur de lecture/écriture dans le fichier à l'endroit approprié pour commencer l'écriture du bloc spécifié (<code>num</code>) à partir de l'offset (<code>offset</code>).
* Elle utilise ensuite <code>fwrite</code> pour écrire <code>size</code> octets à partir du tableau <code>storage</code> dans le fichier.
* Enfin, elle ferme le fichier avec <code>fclose</code>.

ReX : Même remarque que pour la fonction précédente.

'''Etape 4: test des fonctions <code>readBlock</code> et <code>writeBlock</code> dans le main'''
// Exemple de fonction principale pour tester les opérations de lecture et d'écriture
int main() {
unsigned char data[BLOCK_SIZE];
// Test de la fonction readBlock
readBlock(0, 0, data, BLOCK_SIZE);
printf("Block 0, offset 0: ");
for (int i = 0; i < BLOCK_SIZE; i++) {
printf("%02x ", data[i]);
}
printf("\n");
// Test de la fonction writeBlock
unsigned char newData[BLOCK_SIZE] = {
0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88,
// ... Autres données du bloc ...
};
writeBlock(1, 0, newData, BLOCK_SIZE);
// Lecture du bloc nouvellement écrit pour vérifier
readBlock(1, 0, data, BLOCK_SIZE);
printf("Block 1, offset 0: ");
for (int i = 0; i < BLOCK_SIZE; i++) {
printf("%02x ", data[i]);
}
printf("\n");
return 0;
}

Fonctionnement :

* On déclare tout d'abord un tableau de caractères <code>data</code> de taille <code>BLOCK_SIZE</code> pour stocker les données lues du bloc.
* Ensuite, la fonction <code>readBlock</code> est appelée avec les arguments (0, 0, data, BLOCK_SIZE) pour lire le premier bloc du fichier (<code>num=0</code>, <code>offset=0</code>) et stocker les données dans <code>data</code>.
* Ensuite, la fonction <code>printf</code> est utilisée pour afficher les données lues du bloc (<code>data</code>) en format hexadécimal.
* Ensuite, un nouveau tableau de caractères <code>newData</code> est créé avec des données spécifiques pour tester la fonction <code>writeBlock</code>.
* La fonction <code>writeBlock</code> est appelée avec les arguments (1, 0, newData, BLOCK_SIZE) pour écrire le tableau <code>newData</code> dans le deuxième bloc du fichier (<code>num=1</code>, <code>offset=0</code>).
* Enfin, la fonction <code>readBlock</code> est appelée à nouveau pour lire le deuxième bloc nouvellement écrit et afficher les données lues en format hexadécimal.

Question générale : ce que j'avais la première semaine n'est plus forcément d'actualité. Puis-je supprimer les choses qui ne le sont plus afin d'alléger la page ou préférez-vous que je laisse?

ReX : Laissez.

Pour la suite : j'ai donc pour l'instant crée deux fonctions, l'une permettant la lecture et l'autre l'écriture d'un bloc, de manière à économiser la mémoire. Pour la suite, je vais essayer de créer la fonction <code>LS</code> en utilisant la fonction <code>readBlock</code>.

ReX : Oui c'est le début du projet. Mais si vous n'avez pas une bonne description de fichier cela ne donnera rien. Voir remarques plus haut.

'''Etape 5: fonction <code>LS</code>'''

Objectif: créer la fonction <code>LS</code> avec la fonction readBlock.

Question: Souhaitez-vous la fonction <code>LS</code> classique, c'est à dire la fonction <code>LS</code> qui affiche simplement le nom des fichiers présent dans le répertoire ?

ReX : Oui. Tu peux ajouter la taille si tu trouves cela trop simple.

Piste : si c'est ce que vous voulez:

* il va tout d'abord falloir que je crée des fichiers, un fichier étant composé d'un nom et de blocs (création d'une fonction createFile)
* Il faudra ensuite que je stocke ces fichiers dans le répertoire (création d'une fonction addFileToDirectory par exemple)
* enfin, il faudra que j'affiche le nom des fichiers. Pour cela, il faudra que je parcours le répertoire (structure "Directory"), puis que pour chaque fichier présent dans le répertoire que j'affiche son nom (création de la fonction LS)

Je devrais surement utiliser la fonction readBlock afin de transférer les blocs dans le fichier au travers de la variable "storage".

ReX : Créer des fichiers n'est pas nécessaire tout de suite je verrais bien si ton code est bon sans test. Laisse tomber <code>createFile</code> et <code>addFileToDirectory</code> pour l'instant.

ReX : Ton algorithme ne fonctionne pas pour un microcontrôleur où il faut économiser la mémoire, tu ne peux pas t'aider de structures. Il faudra que tu charges les noms et seulement les noms, pour la taille il faudra se baser sur le nombre de blocs.

'''Etape 6: rectification du code suite à vos remarques'''

Modifications apportées:

* suppression des structures afin d’économiser de la mémoire.

* le problème quant à la description des fichiers est normalement résolu puisque plus de structures. On ne charge plus les blocs mais seulement les noms de fichiers.

ReX : Non car si les noms ne sont pas répartis de façon régulière dans les blocs de 256 octets tu vas avoir du mal à les charger. Mais écrit la fonction <code>LS</code> et tu verras ce que je veux dire.

J'ai également ajouté deux nouvelles fonctions:

# <code>void readFileName(unsigned int file_num, char *file_name)</code>: Cette fonction permet de lire le nom du fichier associé au numéro de fichier donné (<code>file_num</code>). Elle stocke le nom du fichier lu dans le tableau <code>file_name</code>.
# <code>void writeFileName(unsigned int file_num, const char *file_name)</code>: Cette fonction permet d'écrire le nom du fichier dans le système de fichiers, associé au numéro de fichier donné (<code>file_num</code>). Elle prend en entrée le nom du fichier à écrire (<code>file_name</code>).

Suite: si vous validez cette base, je pourrai passer à la création de la fonction LS.

ReX : tu peux y aller. Je ne vois pas le code des tes deux fonctions <code>readFileName</code> et <code>writeFileName</code>.

Voici le code des fonctions <code>readFileName</code> et <code>writeFileName</code> :

'''Fonction readFileName:'''
// Fonction pour lire le nom du fichier
void readFileName(unsigned int file_num, char *file_name) {
readBlock(file_num, 0, (unsigned char *)file_name, MAX_FILENAME_LENGTH);
file_name[MAX_FILENAME_LENGTH] = '\0'; // Ajout du caractère null-terminator pour former une chaîne de caractères
}

ReX : Non, aucune raison que le fichier de numéro n soit au bloc n. Dessine la représentation d'un fichier sur le SF en comptant les octets si cela peut aider.

'''Fonction writeFileName:'''
// Fonction pour écrire le nom du fichier
void writeFileName(unsigned int file_num, const char *file_name) {
writeBlock(file_num, 0, (const unsigned char *)file_name, MAX_FILENAME_LENGTH);
}

ReX : Faux et inutile pour l'instant. Problème avec la constante MAX_FILENAME_LENGTH.

=== Fonction LS version 1 ===
// Fonction LS pour afficher les fichiers présents dans le système de fichiers
void LS(const char *filesystem_path) {
FILE *file = fopen(filesystem_path, "rb");
if (file == NULL) {
perror("Erreur lors de l'ouverture du fichier système");
return;
}
uint16_t num_files;
fread(&num_files, sizeof(uint16_t), 1, file); // Lecture du nombre de fichiers dans le système
char filename[17];
printf("Fichiers présents dans le système de fichiers:\n");
for (int i = 0; i < num_files; i++) {
readFileName(i, filename); // Lecture du nom du fichier
printf("%s\n", filename); // Affichage du nom du fichier
}
fclose(file);
}
La fonction <code>LS</code> ouvre le fichier système, lit le nombre de fichiers qu'il contient, puis affiche les noms des fichiers un par un, chacun sur une ligne séparée.

ReX : Il y a le nombre de fichiers dans ton superbloc ? Un dessin du format du superbloc avec les numéros des octets ?

ReX : Tout accès au système de fichiers doit se faire avec les deux fonctions <code>readBlock</code> et <code>writeBlock</code>.

== Semaine 3 ==
Question 1: cela fait plusieurs fois que vous mentionnez dans le wiki un "superbloc". Celui-ci n'étant pas clairement défini dans le sujet, je me demande s'il s'agit du bloc crée grâce à la fonction dd, c'est à dire que le superbloc serait en faite le bloc constitué des 31250 blocs de taille 256 octets, où s'il s'agit d'un bloc qui vient en entête, celui contenant alors des informations décrivant le système de fichier (les noms de fichiers...).

ReX : Pour ton pico système de fichiers, le superbloc consiste en les premiers blocs (de 256 octets) qui définissent les 64 fichiers possibles.

Proposition de structure: on pourrait réserver les premiers blocs du système de fichiers aux noms de fichiers ainsi qu'aux numéros des blocs correspondant à chaque fichier.

ReX : Oui c'est évident.

On sait que les noms de fichiers font au maximum 16 caractères + 1 caractère pour le '\0' (donc 17 octets car 1 char=1 octet).

ReX : Non, 16 octets suffisent, des '\0' en fin de nom uniquement si le nom fait moins de 16 caractères.

On sait également qu'un fichier contient au maximum 2040 blocs, chaque bloc étant numéroté sur 2 octets. On pourrait donc avoir en début du système de fichier: 17 octets+2 octets*2040 blocs = 4097 octets pour la description d'un fichier.

ReX : Non, 4096 octets soit 16 blocs de 256.

Or d'après l'une de vos remarques dans le wiki, un fichier doit être décrit par un nombre entier de blocs. Pour un fichier, il nous faudra donc 4097/256=16.004 soit 17 blocs. Il peut y avoir jusqu'à 64 fichiers dans le répertoire, il nous faudra donc 17 blocs*64 fichiers= 1088 blocs pour la description des fichiers.

ReX : Non 1024 blocs de 256 octets dans le superbloc.

Ainsi, pour la fonction LS, il suffira de lire les premiers caractères tous les 17 blocs ( du premier caractère au caractère '\0').

ReX : Non, tous les 16 blocs.

Question 2: Ne faudrait-il pas également stocker quelque part le nombre de fichier qu'il y a dans le répertoire afin de savoir jusqu'à quel bloc la fonction LS doit aller ?

ReX : Non, un fichier dont le nom n'est constitué que de '\0' est réputé ne pas exister.

Question 3: on a donc vu que les 1088 premiers blocs au maximum serviraient à la description du système de fichier. Il reste donc 31250-1088=30132 blocs dans le système de fichier.

ReX : Non, 32768-1024=31744 blocs.

Comment utiliser ces blocs? Ces blocs doivent-ils stocker le contenu des fichiers ?

ReX : Oui, c'et évident.

En effet, avec la fonction TYPE, nous allons créer des fichiers et ces fichiers devront être stockés quelque part. Cependant, étant donné que ce pico système de fichiers est prévu pour un microcontrôleur, je ne sais pas si c'est le contenu des fichiers qui doit être stocké dans les blocs ou autre chose (peut être l'adresse des fichiers, le fichiers se trouvant autre part). En effet, je me dis que si un fichier est très volumineux, il ne pourra pas rentrer dans le système de fichier, ce dernier étant composé d'un nombre limité de blocs, et les blocs étant eux même limité en nombre d'octets.

ReX : Je ne comprend pas ton problème. De tout façon comme dit plus haut, les 31744 blocs suivant le superbloc doivent contenir les données des fichiers.

Désolé de poser des questions peut être basique aussi tard, mais je pense qu'une fois que j'aurai ces réponses, cela ira beaucoup mieux pour la suite. Merci d'avance pour vos réponses.

ReX : Les questions sont effectivement triviales et il est effectivement inquiétant que voir que la travail n'avance pas.

Amine: merci pour vos corrections.

D'après votre commentaire "32768-1024=31744 blocs", j'en déduis qu'il faut que je modifie ma commande dd (qui est actuellement "dd if=/dev/zero of=filesystem.bin bs=256 count=31250" pour avoir le bon filesystem).

ReX : Je comprends pas d'où tu sors le 31250. D'autant plus que la commande ci-dessous est bonne.

Amine : 31250 car 31250 blocs * 256 octets = 8 Mo.

ReX : Haaaa je vois tu utilises le système métrique international où le mégaoctet vaut 10^6 octets, sauf qu'aucun informaticien n'utilisera cette norme hors sol. Quand je parle de 8 Mo c'est 8x1024x1024 octets. Tout simplement parce qu'une puce mémoire de 8 Mo c'est bien 8x1024x1024 octets.

Amine: D'accord merci pour l'information !

'''Nouvelle commande dd:'''

dd if=/dev/zero of=filesystem.bin bs=256 count=32768

=== Fonction LS version 2 ===

Dans notre structure du système de fichier, le superbloc est constitué de 1024 blocs (16 blocs * 64 fichiers), un fichier étant décrit par 16 blocs. Le nom du fichier est donc écrit au début de tous les blocs multiples de 16. Par exemple, le nom du premier fichier est dans les 16 premiers octets du premier bloc, le nom du 2ème fichier est dans les 16 premiers octets du 32ème bloc et ainsi de suite, tant que des fichiers existent. Lorsque qu'il n'y a plus de fichier, le nom du premier caractère du bloc multiple de 16 est un 0.

Voici le code:
// Fonction pour lister les noms de fichiers présents dans le système de fichiers
void LS() {
unsigned char buffer[BLOCK_SIZE];
int fileCount = 0;

for (int blockNum = 1; blockNum <= MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, BLOCK_SIZE);

// Vérifier si le bloc est vide
if (buffer[0] == 0) {
break; // Plus de fichiers à lire
}

char filename[MAX_FILENAME_LENGTH];
memcpy(filename, buffer, MAX_FILENAME_LENGTH);

// Afficher le nom du fichier
printf("%s\n", filename);
fileCount++;
}

if (fileCount == 0) {
printf("Aucun fichier trouvé.\n");
}
}

ReX : Tu supposes que si un fichier a un nom vide, les suivants auront aussi un nom vide. C'est possible mais dans ce cas la commande <code>RM</code> ca être plus compliquée à écrire.

ReX : Tu ne sembles pas comprendre que la mémoire d'un microcontrôleur est limitée. Pourquoi lire le premier bloc de description d'un fichier en entier ? Dit autrement c'est quoi l'intérêt de lire 256 octets alors que 16 suffisent ?

ReX : Pourquoi tu ne lis pas le premier fichier ? Autrement dit pourquoi décaler tout d'un bloc ?

Amine: Merci pour vos remarques. J'ai apporté les modifications à LS dans la section "Semaine 4" du wiki.

'''Réflexion par rapport aux autres fonctions:'''

J'ai créé les fonctions TYPE et CAT mais il y a malheureusement un problème pour l'instant. Vous pouvez les retrouver en pièce jointe dans l'archive du fichier programme.c.

Le problème que j'ai est que lorsque j'affiche le contenu du fichier créé avec TYPE, j'obtiens plein de caractères spéciaux. Par exemple, je créé le fichier "mon_fichier.txt" avec la fonction TYPE, et je mets en entré standard "hello". Ensuite, je veux afficher le contenu de ce fichier grâce à la fonction CAT. Cependant, ce qui s'affiche dans le terminal n'est pas ce que je veux. De la même manière, lorsque je fais la commande "cat filesystem.bin" dans le terminal, c'est la même chose s'affiche, des donnés parasites.

ReX : Avant même de lire ton code je vais te poser la question de savoir comment tu récupères un bloc libre ? Quel algorithme tu utilises. Personnellement je ne sais pas faire sans ajouter au superbloc un tableau bit à bit des blocs libres. Pour avoir un bit pour chaque bloc du système de fichiers, il faut 32768/8=4096 octets soit 16 blocs.

Amine: ok je vais donc ajouter ce tableau de 16 blocs à la suite de mes premiers 1024 blocs servant à la description de fichier. Le superbloc fera maintenant 1024+16=1040 blocs (plus de détail à la fonction RM de la semaine 4).

Question 1: est ce que la fonction CAT que je dois créer doit renvoyer la même chose que "cat filesystem.bin" ?

ReX : Je préfère ne pas répondre tellement la question montre un manque de réflexion.

Question 2: comment savoir combien de blocs doivent etre attribué à un fichier? Par exemple, si je créé un fichier "mon_fichier.txt" et que je mets en entrée standard le texte "hello", un seul bloc suffi pour stocker ce texte. Cependant, si j'avais mis beaucoup de texte en entrée standard, il aurait fallu plus de blocs. Doit-on calculer la taille de l'entrée standard ou doit-on attribuer toujours le meme nombre de blocs à un fichier? Peut-etre ainsi attribuer 2040 blocs par fichier, meme s'il n'en utilise que 1.

ReX : Là encore c'est une question stupéfiante tellement la réponse est évidente. Il suffit de lire les données sur l'entrée standard et de passer au bloc de données suivant dès que le bloc courant est rempli. La question à poser c'était de se demander comment il est possible d'avoir la taille exacte du fichier pour un <code>CAT</code>. Il est uniquement possible de l'avoir à 256 octets près puisque rien n'indique si le dernier block est vide. Le mieux aurait été de prévoir 4 octets dans la description d'un fichier pour stocker la taille. En l'espèce on considérera que les fichiers sont des fichiers ASCII et qu'ils seront terminés par des <code>\'0</code> qui ne seront pas affichés.

== Semaine 4 ==

Voici un bilan de ce que j'ai fait à ce stade du projet:

* j'ai choisi une structure du système de fichier
* j'ai créé les fonctions readBlock et writeBlock permettant de lire et d'écrire des blocs
* j'ai crée la fonction LS permettant d'afficher le nom des fichiers présents dans le système de fichiers
* j'ai programmer un main permettant d'utiliser les fonctions (LS, TYPE...) depuis le terminal
* j'ai réflechi aux fonctions TYPE et CAT.

Actuellement, je suis en train de créer les fonctions TYPE et CAT.

=== Fonction LS version 3 ===
void LS() {
unsigned char buffer[MAX_FILENAME_LENGTH];
int fileCount = 0;

// Parcourir tous les 16 blocs de 0 jusqu'à MAX_FILES_IN_DIRECTORY
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, MAX_FILENAME_LENGTH);

// Vérifier si le nom de fichier est vide
if (buffer[0] != 0) {

// Afficher le nom du fichier
printf("%s\n", buffer);
fileCount++;
}
}

if (fileCount == 0) {
printf("Aucun fichier trouvé.\n");
}
}
Suite à vos remarques, j'ai effectué les modifications suivantes de la fonction LS:

* Je ne suppose plus que si un fichier a un nom vide, les autres auront aussi un nom vide.
* Je ne lis plus les 256 octets mais seulement les 16 premiers octets car cela suffit.
* Je ne lisais en effet pas le premier bloc. Je pensais que le premier bloc était d'indice 1 mais ce n'est pas le cas.

ReX : Ouiiii ! Une fonction correcte. Passe à <code>RM</code> maintenant, c'est la plus facile à faire concernant l'image bit à bit des blocs libres.

=== Fonction setBlockAvailability version 1 ===

Comme vous l'avez indiqué dans votre remarque, il faut un tableau dans le superbloc qui nous permettra de connaitre la disponibilité bit par bit de chaque bloc. Sachant qu'il y a dans notre système de fichiers 32768 blocs, et qu'il faut 1 bit par bloc, nous avons besoin de 32768 bits, soit 32768/8=4096 octets soit 4096/256=16 blocs. Notre superbloc sera donc comme suit: les 1024 premiers blocs servent à la description des fichiers, c'est à dire à leur nom suivi des numéros de blocs qui leur sont associés, puis ces 1024 blocs sont suivi de 16 blocs listant la disponibilité de chaque bloc.

ReX : Bien résumé.

Nous allons tout d'abord écrire la fonction "setBlockAvailability" prenant en paramètre le numéro du bloc à traiter (<code>blockNum</code>) et la disponibilité souhaitée pour ce bloc (<code>availability</code>). Cette fonction permet de marquer la disponibilité d'un bloc spécifique dans le système de fichiers. Nous utiliserons la convention suivante: un bloc disponible sera marqué par un 1 tandis qu'un bloc non disponible par un 0.
#define SUPERBLOCK_START_BLOCK 1024

void setBlockAvailability(int blockNum, int availability) {
// Calculer l'index du byte et le bit offset correspondant
int byteIndex = blockNum / 8;
int bitOffset = blockNum % 8;

// Lire le byte existant du bloc de disponibilité des blocs
unsigned char buffer[1];
readBlock(SUPERBLOCK_START_BLOCK + byteIndex, 0, buffer, 1);

// Mettre à jour le bit d'offset correspondant
if (availability) {
buffer[0] |= (1 << bitOffset);
} else {
buffer[0] &= ~(1 << bitOffset);
}

// Écrire le byte mis à jour dans le bloc de disponibilité des blocs
writeBlock(SUPERBLOCK_START_BLOCK + byteIndex, 0, buffer, 1);
}

ReX : Un tableau de un octet c'est un octet (variable <code>buffer</code>).

Amine: je vais utiliser un <code>unsigned char buffer.</code> Je suis conscient qu'un char vaut un octet mais je ne pense pas qu'il y ait un type de donnée de la taille d'un bit, c'est pourquoi je travaille avec un octet mais je modifie les bits de cet octet grâce aux algorithmes.

ReX : Il faut bien que tu travailles sur un octet vu que l'état des blocs est stocké sous la forme d'octets. Je disais juste qu'un tableau de 1 élément n'a pas d'intérêt par rapport à l'élément lui-même.

Amine: c'est vrai, modification faite.

ReX : Non il faut calculer le numéro du bloc avant de faire le <code>readBlock</code>.

Amine: ok je vais calculer le numéro de bloc avant.

ReX : La mise à jour du bit est correcte mais le block et le déplacement dans le block ne sont pas correctement calculés.

Amine: je vais vous expliquer le raisonnement que j'avais. Prenons un exemple concret, imaginons que je veuille marquer le bloc 1030 comme disponible:

# Calcul de l'index de l'octet et du bit offset :
#* <code>blockNum</code> = 1030
#* Index du byte = 1030 / 8 = 128
#* Bit offset = 1030 % 8 = 6
# Lecture de l'octet existant de disponibilité:
#* Nous lisons l'octet existant à l'index 128 dans les blocs de disponibilité.
# Mise à jour du bit de disponibilité :
#* Nous voulons marquer le bloc 1030 comme disponible, donc nous utilisons le masque <code>(1 << 6)</code> pour définir le bit 6 à 1 dans l'octet. Le résultat sera, par exemple, <code>00100000</code>.
# Écriture du byte mis à jour :
#* Nous écrivons le byte mis à jour <code>00100000</code> à l'index 128 dans les blocs de disponibilité.

ReX : Ben non, un vrai exemple :
* Il faut prendre un n° de bloc plus grand : 3072 ;
* Numéro d'octet dans la carte des blocs libres : 3072/8=384 ;
* Numéro du bloc dans la carte des blocs libres : 384/256=1 ;
* Numéro du bit <code>b</code> dans l'octet n° 384-256=128 du bloc 1 : 3072%8=0 ;
* Il faut donc lire l'octet <code>o</code> de numéro 128 du bloc 1, puis modifier cet octet par <code>o |= (1<<b)</code> ou <code>o &= ~(1<<b)</code> ;
* Enfin il faut écrire l'octet modifié dans le bloc 1.
Amine: merci pour cet exemple! J'ai compris d'où vient mon erreur. Voir fonction setBlockAvailability version 3.

Remarque: par convention, j'apellerai dans la suite de ce projet "premier superbloc" le superbloc correspondant à la description des fichiers, c'est à dire les 1024 premiers blocs, et j'appellerai "second superbloc" les 16 blocs qui suivent servant à décrire la disponibilité des blocs (du bloc 1024 au bloc 1039 inclu). Le reste des blocs servira à stocker les données.

ReX : Non, le superblc est l'ensemble des informations hors blocs de données, tu ne peux pas utiliser un vocabulaire au hasard. Parle de blocs de description des fichiers ou de carte des blocs libres.

Amine: ok

Je pense que le problème qui se pose est que l'indice du bit dans le second superbloc ne correspond pas à l'indice du bloc dans le système de fichier. Par exemple, nous voudrions que si le bloc 1030 est disponible dans le système de fichier, alors le bit numéro 1030 du deuxième superbloc soit à 1, ce qui n'est pas le cas ici. En effet, on se trouve bien dans le bon octet avec ma méthode mais l'écriture du bit se fait de la droite vers la gauche alors qu'on voudrait l'inverse. Ainsi, si le 6ème bit de l'octet doit être à 1, alors il faudrait qu'on obtienne <code>00000100</code> et non <code>00100000.</code> L'indice du bit coinciderait ainsi avec le numéro du bloc.

ReX : Non, réfléchit à nouveau.

Voir plus bas la nouvelle version de setBlockAvailability.

Explication de l'algorithme pour mettre le bit à 1 ou 0:

* <code>buffer[0] |= (1 << bitOffset);</code> : Cette ligne utilise l'opérateur OR bit à bit (<code>|=</code>) pour activer (mettre à 1) le bit spécifié par <code>bitOffset</code> dans le premier octet (<code>buffer[0]</code>). Cela se fait en décalant le bit 1 vers la gauche de <code>bitOffset</code> positions, puis en effectuant une opération OR bit à bit avec le contenu actuel de <code>buffer[0]</code>. Cette opération modifie uniquement le bit ciblé, laissant les autres bits inchangés.

ReX : Oui ça c'est bon.

* <code>buffer[0] &= ~(1 << bitOffset);</code> : Cette ligne utilise l'opérateur AND bit à bit (<code>&=</code>) pour désactiver (mettre à 0) le bit spécifié par <code>bitOffset</code> dans <code>buffer[0]</code>. Pour ce faire, l'expression <code>~(1 << bitOffset)</code> est utilisée pour créer un masque où tous les bits sont à 1, sauf celui correspondant à <code>bitOffset</code>, qui est à 0. En effectuant ensuite une opération AND bit à bit entre le masque et le contenu actuel de <code>buffer[0]</code>, on met à 0 le bit ciblé sans affecter les autres bits.

ReX : Ca aussi.

=== Fonction setBlockAvailability version 2 ===

void setBlockAvailability(int blockNum, int availability) {
// Calculer l'indice de l'octet et le bit offset correspondant
int byteIndex = blockNum / 8;
int bitOffset = 7 - (blockNum % 8); // Inversion de l'ordre des bits

// Calculer le numéro du bloc du super bloc où se trouve l'octet de disponibilité correspondant
int availabilityBlockNum = SUPERBLOCK_START_BLOCK + byteIndex;

// Lire l'octet existant dans le bloc de disponibilité du super bloc
unsigned char buffer;
readBlock(availabilityBlockNum, 0, &buffer, 1);

// Mettre à jour le bit d'offset correspondant :
if (availability) {
buffer |= (1 << bitOffset);
} else {
buffer &= ~(1 << bitOffset);
}

// Écrire l'octet mis à jour dans le bloc de disponibilité du super bloc
writeBlock(availabilityBlockNum, 0, &buffer, 1);
}
J'ai modifié la ligne <code>int bitOffset = 7 - (blockNum % 8);</code> pour inverser l'ordre des bits sélectionnés, de sorte que le bit correspondant au bloc disponible soit correct.

ReX : Encore plus faux.

Si on veut rendre le bloc 1030 indisponible alors que les autres blocs sont disponibles:

ReX : Pardon ? Le bloc de données est libre ou pas suivant la carte des blocs libres. Le rendre disponible n'est possible que si un fichier le comportant est détruit.

# Calcul de l'indice de l'octet et du bit offset correspondant :
#* <code>blockNum = 1030</code>
#* <code>byteIndex = 1030 / 8 = 128</code>
#* <code>bitOffset = 7 - 1030 % 8 = 1</code> Cela signifie que le bit d'intérêt se trouve à la position 2 dans l'octet.
# Calcul du numéro du bloc du super bloc où se trouve l'octet de disponibilité correspondant :
#* <code>availabilityBlockNum = SUPERBLOCK_START_BLOCK + 128 = 1024 + 128 = 1152</code> Donc, nous devons accéder à l'octet 1152 pour mettre à jour la disponibilité du bloc 1030.
# Lecture de l'octet existant dans le bloc de disponibilité du super bloc :
#* Le contenu de l'octet dans le bloc 1152 avant la mise à jour : 11111111 (en binaire)
# Mise à jour du bit d'offset correspondant :
#* Supposons que nous voulions marquer le bloc 1030 comme non disponible (<code>availability = 0</code>).
#* Le bitOffset est 1.
#* Nous effectuons une opération AND avec le complément du bit à la position 1 : <code>11111111 & 11111101 = 11111101</code>
# Écriture de l'octet mis à jour dans le bloc de disponibilité du super bloc :
#* Le contenu de l'octet 128 du second superbloc après la mise à jour : 11111101 (en binaire)

ReX : Toujours aussi faux.

Maintenant, le bit d'indice 1 du 128 ème octet du second superbloc est mis à 0, indiquant que le bloc 1030 n'est plus disponible. Les autres bits restent inchangés car nous avons effectué un AND avec un masque binaire qui avait des 1 partout sauf à la position du bit que nous souhaitions mettre à 0.

ReX : Erreur sur erreur.

=== Fonction setBlockAvailability version 3 ===
J'ai compris d'où vient l'erreur. La fonction readBlock prends en premier paramètre le numéro du bloc à lire, je ne peux donc pas lui donner la valeur "SUPERBLOCK_START_BLOCK + byteIndex" car byteIndex s'exprime en octet alors qu'on s'attend à un nombre de bloc ici. Il faut donc divisé byteIndex par 256 pour être en unité "bloc", et préciser le bit qu'on veut lire grâce à l'offset.

Pour obtenir l'octet que l'on veut, il faut prendre le reste de la division de byteIndex par 256. On va ensuite stocker cet octet dans notre "buffer".

Pour savoir quel bit modifier dans ce "buffer", on va prendre le reste de la division du bloc dont on veut mettre à jour la disponibilité par 8. On va ainsi pouvoir modifier ce bit grâce à l'algorithme, puis réécrire l'octet à son emplacement d'origine.

Cette fonction gère la carte de disponibilités des blocs. Si un bloc est disponible, alors elle le met un 0, si il est indisponible, elle met un 1.
#define SUPERBLOCK_START_BLOCK 1024

void setBlockAvailability(int blockNum, int availability) {

int byteIndexInCard = blockNum / 8; //Numéro d'octet dans la carte des blocs libres
int blockIndexInCard = byteIndexInCard / 256; //Numéro du bloc dans la carte des blocs libres
int byteIndexInBlock = byteIndexInCard % 256; //Numéro d'octet dans le bloc contenant le bit de disponibilité
int bitOffset = blockNum % 8; //Numéro du bit dans l'octet n°byteIndexInBlock du bloc blockIndexInCard

//indice du bloc contenant le bit à mettre à jour dans le bloc de description
int availabilityBlockNum = FIRST_DISPONIBILITY_CARD_BLOCK + blockIndexInCard;

// Lire l'octet existant dans le bloc de disponibilité du super bloc
unsigned char buffer;
readBlock(availabilityBlockNum, byteIndexInBlock, &buffer, 1);

// Mettre à jour le bit d'offset correspondant :
if (availability==1) { // indisponible
buffer |= (1 << bitOffset); // Mettre le bit à 1

} else { // disponible
buffer &= ~(1 << bitOffset); // Mettre le bit à 0
}

// Écrire l'octet mis à jour dans le bloc de disponibilité du super bloc
writeBlock(availabilityBlockNum, byteIndexInBlock, &buffer, 1);
}

ReX : Ben voila, c'est pas possible de te taxer d'excès de vitesse mais c'est bon.

update: j'ai fait une petite modification, maintenant un bloc disponible est marqué d'un 0 et un bloc indisponible est marqué d'un 1. C'est mieux dans la mesure où initialement, tous les blocs sont disponibles et tous les blocs sont à 0. Cela évite de devoir créer une fonction qui initialise toute la carte de disponibilités à 1 pour dire que tous les blocs sont disponibles.

=== Fonction RM version 1 ===

void RM(const char *filesystem_path, const char *filename) {
unsigned char buffer[BLOCK_SIZE];
int fileNum = -1;

// Parcourir les blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (memcmp(filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {
// Effacer le nom du fichier dans le superbloc
memset(filenameBuffer, 0, MAX_FILENAME_LENGTH);
writeBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

unsigned char fileBuffer[MAX_BLOCKS_PER_FILE * 2];
readBlock(blockNum, MAX_FILENAME_LENGTH, fileBuffer, MAX_BLOCKS_PER_FILE * 2);

// Libérer les blocs associés au fichier et réinitialiser les numéros de blocs
for (int i = 0; i < MAX_BLOCKS_PER_FILE * 2; i += 2) {
int blockNum = ((int)fileBuffer[i] << 8) + (int)fileBuffer[i + 1];
if (blockNum == 0) {
break; // Fin du fichier
}
setBlockAvailability(blockNum, 0); // Marquer le bloc comme disponible
fileBuffer[i] = 0;
fileBuffer[i + 1] = 0;
}

// Mettre à jour les numéros de blocs associés au fichier
writeBlock(blockNum, MAX_FILENAME_LENGTH, fileBuffer, MAX_BLOCKS_PER_FILE * 2);

fileNum = blockNum;
break; // Fichier trouvé, sortir de la boucle
}
}

// Afficher le résultat de l'opération
if (fileNum == -1) {
printf("Le fichier \"%s\" n'a pas été trouvé.\n", filename);
} else {
printf("Le fichier \"%s\" a été supprimé avec succès.\n", filename);
}
}

ReX : Vous utilisez <code>strcmp</code> comme <code>strncmp</code>. C'est bien la dernière qu'il faut utiliser mais en précisant la longueur du nom en paramètre, pas la taille maximale.

Amine: vous voulez dire que j'utilise memcmp au lieu de strncmp ? Ok je vais utiliser strncmp, c'est vrai que c'est plus adapté pour la comparaison de chaines de caractère.

ReX : Ha oui c'est <code>memcmp</code> que tu utilises. Ca ne peut effectivement pas marcher. Effectivement avec <code>strncmp</code> cela peut marcher vu qu'il s'arrête au premier 0 contrairement à <code>memcmp</code>.

Cependant, pourquoi doit-on passer la taille exacte du nom du fichier en paramètre, et non la taille maximale d'un nom de fichier? En effet, cela semble fonctionner en mettant la taille maximale en paramètre, tandis que lorsque l'on met la taille exacte du nom du fichier, cela pose un problème: on ne compare plus toute la chaîne de caractère mais seulement une portion du nom complet. Ainsi, si je crée par exemple un fichier que j'appelle "file1", puis que j’exécute la fonction RM "/picofs filesystem.bin RM file" par exemple, alors le fichier file1 va être supprimé quand même car on ne comparera que strlen(file)=4 premiers caractères, qui sont les mêmes, donc la fonction considérera ces chaines comme identiques. On pourrait alors se dire qu'il faudrait alors prendre plutôt comme taille en paramètre de la fonction strlen la taille du nom du fichier se trouvant dans le système de fichier plutôt que celle du nom donné en paramètre de RM. Cependant, le même problème se pose si la taille du nom du fichier du système de fichier est plus petite que celle du nom du fichier passé en paramètre. Par exemple, si le fichier présent dans système de fichier est "file", et qu'on met la longueur de file en paramètre de la fonction strcmp, puis qu'on exécute la commande "/picofs filesystem.bin RM file5", alors file sera quand même supprimé, car on ne comparera que les strlen(file)=4 premiers caractère. Finalement, une solution serait de rajouter une condition qui vérifie que les deux chaînes sont de taille identiques pour pouvoir réaliser la comparaison sur la taille exacte du nom du fichier. Cependant, il me semble qu'en mettant MAX_FILENAME_LENGTH qui vaut 16 en paramètre, cela fonctionne directement. Vous pouvez tester cela en testant mon programme.

ReX : Ok pour <code>strncmp</code> avec la taille maximale d'un nom de fichier.

etape 1: créer un fichier :
./picofs filesystem.bin TYPE fichier.txt

etape 2: verifier que le fichier a bien été créé :
./picofs filesystem.bin LS

Le terminal renvoie bien "fichier.txt"

etape 3: essayer de supprimer le fichier en mettant une chaine troncature du nom du fichier créé :
./picofs filesystem.bin RM fich

le terminal renvoi <<Le fichier "fich" n'a pas été trouvé.>>, le fichier n'a donc pas été supprimé .

etape 4: essayer de supprimer le fichier en mettant un nom plus grand incluant "fichier.txt" :
./picofs filesystem.bin RM fichier.txtt

terminal renvoi <<Le fichier "fichier.txtt" n'a pas été trouvé.>>

etape 5: enfin, tester en mettant le nom exacte du fichier que l'on veut supprimer :
./picofs filesystem.bin RM fichier.txt

terminal renvoi <<Le fichier "fichier.txt" a été supprimé avec succès.>>

Finalement, on voit que cela fonctionne avec la taille maximale mise en paramètre. On pourrait reprocher à cette méthode de comparer des caractères dans le vide, ce qui n'est pas optimal dans une optique d'économie de mémoire qui est la notre, mais la taille maximale d'un nom de fichier étant relativement faible (16 octets), on peut peut-être négliger cela au vu de l'économie d'une opération supplémentaire (comparaison de la taille des chaines de caractères).

ReX : Le parcours des blocs de données du fichier est atroce. Il faut parcourir les numéros de blocs dans le premier bloc du fichier derrière le nom du fichier puis il faut parcourir le 15 autres blocs.

Amine: Ok, je vais corriger cela dans la version 2 de RM (voir semaine 5).

Fonctionnement de la fonction RM:

* Parcours des blocs réservés pour la description des fichiers (superbloc) à partir du bloc 0, en incrémentant de 16 à chaque itération pour accéder aux blocs de noms de fichiers.

ReX : OK.

* Dans chaque bloc de noms de fichiers, la fonction compare le nom de fichier recherché avec les noms stockés dans les 16 octets de chaque bloc.

ReX : Non la fonction ne fait pas ça par contre il faudrait, oui.

Amine: Je pensais que c'était ce que je faisais avec "memcmp(filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0)".

* Si le nom de fichier est trouvé, la fonction efface le nom du fichier dans le superbloc en remplaçant les 16 octets du bloc par des zéros.

ReX : OK.

* Ensuite, la fonction accède aux octets suivants du même bloc pour obtenir les numéros de blocs associés au fichier.

ReX : Non, la boucle sort largement du premier bloc.

* Pour chaque paire de numéros de blocs (2 octets chacun), la fonction convertit les octets en un numéro de bloc. Si le numéro de bloc est nul, cela signifie la fin des blocs associés au fichier, sinon, la fonction marque ce bloc comme disponible en utilisant la fonction <code>setBlockAvailability</code> et réinitialise les numéros de blocs dans le tableau à zéro.
* Les numéros de blocs réinitialisés sont ensuite réécrits dans le bloc de description du fichier.

ReX : L'idée est là mais vu que la boucle n'est pas bonne, rien ne peut marcher.

* La fonction affiche ensuite un message indiquant le résultat de l'opération : soit que le fichier a été supprimé avec succès, soit que le fichier n'a pas été trouvé.

== Semaine 5 ==

=== Fonction RM version 2 ===

Concernant les remarques que vous m'avez faites précédemment:

* j'utilise maintenant la fonction <code>strncmp</code> pour la comparaison des chaines de caractères
* j'ai normalement corrigé le parcours des blocs. Je parcours maintenant d'abord les blocs multiples de 16 à la recherche du bloc contenant le nom du fichier à supprimer. Puis je parcours les 16 blocs de description du fichier à supprimer, afin de récupérer les numéros de blocs, libérer ces blocs dans la carte de disponibilité et de réinitialiser ces blocs dans les blocs de données.

void RM(const char *filesystem_path, const char *filename) {
int fileFound = -1;
int offset;

// Parcourir les blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char*)filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {

// Effacer le nom du fichier dans le superbloc
memset(filenameBuffer, 0, MAX_FILENAME_LENGTH);
writeBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);
fileFound = 1;
offset = blockNum;
break;
}

}

// Fin de fonction si fichier inexistant
if (fileFound == -1) {
printf("Le fichier \"%s\" n'a pas été trouvé.\n", filename);
return;
}

unsigned char buffer[BLOCK_SIZE];
//bloc que l'on va remplir de 0 et mettre à la place des blocs de données
memset(buffer, 0, BLOCK_SIZE); //on rempli buffer de 0

for (int blockNum=offset; blockNum<offset + 16; blockNum++) {

//premier bloc de description, celui contenant le nom du fichier dans les 16 premiers octets
if (blockNum == offset) {

unsigned char fileBuffer[BLOCK_SIZE-MAX_FILENAME_LENGTH];
//bloc dans lequel on va stocker les blocs de description de fichier
readBlock(blockNum, MAX_FILENAME_LENGTH, fileBuffer, BLOCK_SIZE-MAX_FILENAME_LENGTH);

// Libérer les blocs associés au fichier dans la carte de disponibilités
// et dans les blocs de description
for (int i = MAX_FILENAME_LENGTH; i < BLOCK_SIZE-MAX_FILENAME_LENGTH; i += 2) {
int blockNumData = ((int)fileBuffer[i] << 8) + (int)fileBuffer[i + 1];
if (blockNumData == 0) {
break; // Fin du fichier
}
setBlockAvailability(blockNumData, 0); // Marquer le bloc comme disponible
fileBuffer[i] = 0;
fileBuffer[i + 1] = 0;
writeBlock(blockNumData, 0, buffer, BLOCK_SIZE); //on efface les blocs de données
}
writeBlock(blockNum, MAX_FILENAME_LENGTH, fileBuffer, BLOCK_SIZE-MAX_FILENAME_LENGTH);
//on efface le premier bloc de description

} else {
unsigned char fileBuffer[BLOCK_SIZE];
readBlock(blockNum, 0, fileBuffer, BLOCK_SIZE);

// Libérer les blocs associés au fichier dans la carte de disponibilités et dans les blocs de description
for (int i = 0; i < BLOCK_SIZE; i += 2) {
int blockNumData = ((int)fileBuffer[i] << 8) + (int)fileBuffer[i + 1];
if (blockNumData == 0) {
break; // Fin du fichier
}
setBlockAvailability(blockNumData, 0); // Marquer le bloc comme disponible
fileBuffer[i] = 0;
fileBuffer[i + 1] = 0;
writeBlock(blockNumData, 0, buffer, BLOCK_SIZE); //on efface les blocs de données
}
writeBlock(blockNum, 0, fileBuffer, BLOCK_SIZE); //on efface le bloc de description
}
}
printf("Le fichier \"%s\" a été supprimé avec succès.\n", filename);
}

ReX : Pour construire le nombre sur 16 bits utiliser le OU plutôt que l'addition.

ReX : Heu non, je ne lis pas cette fonction avec tout ce code dupliqué, la seule différence entre les deux alternative est la position de début de l'adresse du premier bloc de données (<code>MAX_FILENAME_LENGTH</code> dans un cas et 0 dans l'autre). Donc l'alternative ne doit servir qu'à initialiser ce début, le reste du code doit être factorisé.

ReX : Et corrige le code, tu utilises deux tableaux de blocs (perte mémoire), tu écris le bloc à zéro dans l'itération (perte CPU).

=== Fonction RM version 3 ===

Suite à vos remarques, j'ai réalisé les modifications suivantes:

* j'utilise maintenant le OU plutôt que l'addition pour construire le nombre sur 16 bits.

* j'ai factorisé le code grâce à la création de la variable <code>startOffset</code> valant 16 lorsqu'on se trouve dans le bloc contenant le nom du fichier et valant 0 lorsqu'on se trouve dans les autres.

* Pour ce qui est du fait que j'utilise 2 tableaux de blocs, j'ai du mal à voir comment faire avec 1 seul tableau de blocs car ces deux tableaux n'ont pas du tout le même rôle. Le tableau <code>fileBuffer</code> permet de stocker les 16 blocs de description d'un fichier un à un. Lorsqu'on stocke un bloc dans <code>fileBuffer</code>, on lit ensuite les octets un à un de ce bloc afin de former des numéros de blocs, et pour chaque numéro de bloc créé, on va réinitialiser le bloc correspondant dans les blocs de données. Pour cela, on a donc besoin d'un autre bloc qui viendra écraser les anciens blocs de données. C'est pourquoi j'ai créé un bloc <code>buffer</code>qui est composé de 0 et qui va écraser les blocs de données. On ne peut pas utiliser <code>fileBuffer</code> car on a besoin d'un bloc de zéros, et si on réinitialise <code>fileBuffer</code> on perd toute les données qui s'y trouvent. Une possibilité serait de relire le bloc de donné à chaque itération de la deuxième boucle for imbriquée; cela permettrait de pouvoir réinitialiser le tableau fileBuffer à chaque itérations de cette boucle afin de stocker ce bloc de 0 dans les blocs de données, puis de restocker dans ce même tableau le bloc de description. Cependant, je ne pense pas que ce soit optimal de faire autant appel à la fonction readBlock.

* j'ai créé une fonction resetBock qui permet comme son nom l'indique de reset un bloc en le remplissant de 0. Cela nous évite de créer deux tableaux de blocs dans RM, bien que je pense que cela revienne au même car on fait appel à une fonction qui créé un tableau de blocs. Quoi qu'il en soit, cela allège le code et cette fonction pourra surement me resservir par la suite.

void RM(const char *filesystem_path, const char *filename) {
int fileFound = -1;
int offset;
unsigned char fileBuffer[BLOCK_SIZE];

// Parcourir les blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char *)filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {
// Effacer le nom du fichier dans le superbloc
memset(filenameBuffer, 0, MAX_FILENAME_LENGTH);
writeBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);
fileFound = 1;
offset = blockNum;
break;
}
}

// Fin de fonction si fichier inexistant
if (fileFound == -1) {
printf("Le fichier \"%s\" n'a pas été trouvé.\n", filename);
return;
}

for (int blockNum = offset; blockNum < offset + 16; blockNum++) {
int startOffset = 0;
if (blockNum == offset) {
startOffset = MAX_FILENAME_LENGTH;
}
readBlock(blockNum, startOffset, fileBuffer, BLOCK_SIZE - startOffset);

// Libérer les blocs associés au fichier dans la carte de disponibilités et dans les blocs de description
for (int i = 0; i < BLOCK_SIZE - startOffset; i += 2) {
int blockNumData = (fileBuffer[i] << 8) | fileBuffer[i + 1];
if (blockNumData == 0) {
break; // Fin du fichier
}
setBlockAvailability(blockNumData, 0); // Marquer le bloc comme disponible
fileBuffer[i] = 0;
fileBuffer[i + 1] = 0;
resetBlock(blockNumData); //on efface les blocs de données
}
writeBlock(blockNum, startOffset, fileBuffer, BLOCK_SIZE - startOffset);
}
printf("Le fichier \"%s\" a été supprimé avec succès.\n", filename);
}
'''Fonction resetBlock'''
void resetBlock(unsigned int blockNum) {
unsigned char buffer[BLOCK_SIZE];
memset(buffer, 0, BLOCK_SIZE);

// Utiliser writeBlock pour écrire les données du buffer dans le bloc
writeBlock(blockNum, 0, buffer, BLOCK_SIZE);
}

ReX : Ca s'améliore. Mais pourquoi cette fonction <code>resetBlock</code> ? Tu crois que dans qu'un système de fichiers perd du temps à mettre à zéro les blocs de données libérés ? Si oui, regarde la page de manual de la commande <code>shred</code>, ça manque à ta culture.

Amine: Après avoir consulter le manual de la commande <code>shred</code>, je vois que cette commande écrit des données aléatoires sur l'emplacement du fichier sur le disque. Par défaut, <code>shred</code> effectue un certain nombre de passes (par exemple, 3 passes) pendant lesquelles il écrit des données aléatoires sur l'emplacement du fichier sur le disque. Après avoir écrit les données aléatoires, <code>shred</code> peut effectuer des passes supplémentaires pendant lesquelles il écrit des données nulles (des zéros) sur le même emplacement. L'objectif de <code>shred</code> est d'augmenter la sécurité en rendant plus difficile la récupération des données supprimées à l'aide d'outils de récupération de données.

Cependant, j'ai aussi consulté comment fonctionne la commande <code>rm</code> de linux, et je vois que cette commande libère l'espace occupé par le fichier en marquant les blocs associés comme disponibles. Cela signifie que les données peuvent encore être récupérées à l'aide d'outils de récupération de données, à moins que des mesures supplémentaires ne soient prises pour écraser physiquement l'espace avec des données aléatoires (c'est ce que fait l'utilitaire <code>shred</code>).

On va donc opter pour la deuxième option, c'est à dire qu'on ne va pas perdre notre temps à remettre à zéro les blocs de données libérés, on va simplement marquer les blocs correspondants comme étant disponibles. Cela nous permettra de nous émanciper de la fonction resetBlock et de n'avoir plus qu'un seul tableau de blocs.

ReX : Sinon lire un bloc complet de pointeurs de blocs de données en mémoire n'est pas forcément optimal. L'idéal serait de lire ces blocs morceau par morceau (de 64 octets par exemple). Certes un bloc serait traité en 4 lectures/écritures (ce qui ralentirait le traitement) mais on gagne en mémoire. Le mieux serait de mettre la taille des morceaux en constante pour pouvoir choisir entre vitesse d'exécution et utilisation mémoire.

Amine: d'accord je comprends. Je vais modifier la fonction pour qu'on puisse découper la lecture/écriture en plusieurs blocs.

=== Fonction RM version 4 ===
Modifications apportées:

* je ne réinitialise plus les blocs de données, je supprime simplement le pointeur du fichier vers les blocs de données et je désigne les blocs comme "disponible" dans le carte de disponibilités. J'ai donc supprimé la fonction resetBlock.

* je ne lis plus les blocs en une seule fois mais en plusieurs fois via la variable CHUNK_SIZE:

# J'ai introduit la constante <code>CHUNK_SIZE</code> pour définir la taille de chaque morceau que nous allons lire/écrire à la fois. Cela permet de découper les opérations en blocs plus petits.
# Dans la boucle <code>for</code> où on parcours les blocs à partir de <code>offset</code>, j'ai ajouté une boucle interne qui parcourt les données du bloc en morceaux de taille <code>CHUNK_SIZE</code>.
# À l'intérieur de la boucle interne, j'ai calculé la taille réelle du morceau (<code>chunkSize</code>) en prenant le minimum entre <code>CHUNK_SIZE</code> et la quantité de données restant à lire/écrire dans le bloc.
# J'ai modifié la fonction <code>readBlock</code> pour lire seulement la quantité de données spécifiée par <code>chunkSize</code> à partir de <code>chunkStart</code>. Ces données sont stockées dans le tableau <code>fileBuffer</code>.
# Ensuite, j'ai effectué les mêmes opérations de libération des blocs associés au fichier, en parcourant les données du morceau et en marquant les blocs comme disponibles.
# Finalement, j'ai utilisé la fonction <code>writeBlock</code> pour écrire le morceau de données modifié dans le bloc, en utilisant la même <code>chunkStart</code> pour déterminer où écrire les données.

#define CHUNK_SIZE 64

int min(int a, int b) {
return a < b ? a : b;
}

void RM(const char *filesystem_path, const char *filename) {
int fileFound = -1;
int offset;
unsigned char fileBuffer[BLOCK_SIZE];

// Parcourir les blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char *)filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {
// Effacer le nom du fichier dans le superbloc
memset(filenameBuffer, 0, MAX_FILENAME_LENGTH);
writeBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);
fileFound = 1;
offset = blockNum;
break;
}
}

// Fin de fonction si fichier inexistant
if (fileFound == -1) {
printf("Le fichier \"%s\" n'a pas été trouvé.\n", filename);
return;
}

for (int blockNum = offset; blockNum < offset + 16; blockNum++) {
int startOffset = 0;

if (blockNum == offset) {
startOffset = MAX_FILENAME_LENGTH;
}

for (int chunkStart = startOffset; chunkStart < BLOCK_SIZE; chunkStart += CHUNK_SIZE) {
int chunkSize = min(CHUNK_SIZE, BLOCK_SIZE - chunkStart);
readBlock(blockNum, chunkStart, fileBuffer, chunkSize);

for (int i = 0; i < chunkSize; i += 2) {
int blockNumData = (fileBuffer[i] << 8) | fileBuffer[i + 1];
if (blockNumData == 0) {
writeBlock(blockNum, chunkStart, fileBuffer, chunkSize);
printf("Le fichier \"%s\" a été supprimé avec succès.\n", filename);
return; // Sortir des boucles
}
setBlockAvailability(blockNumData, 0); // Marquer le bloc comme disponible
fileBuffer[i] = 0;
fileBuffer[i + 1] = 0;
}

writeBlock(blockNum, chunkStart, fileBuffer, chunkSize);
}
}

printf("Le fichier \"%s\" a été supprimé avec succès.\n", filename);
}

ReX : Si on trouve un n° de bloc de données à 0, il faut sortir des deux boucles les plus externes après avoir fait le <code>writeBlock</code>.

Amine: Modification faites ci-dessus. Maintenant, dès qu'on trouve un n° de bloc de données à 0 dans la boucle la plus interne, on effectue le <code>writeBlock</code> et ensuite on utilise <code>return</code> pour sortir des deux boucles les plus externes. Cela permet d'optimiser le code en évitant de continuer à traiter inutilement le reste des blocs.

ReX : Pas très propre (duplication de code) mais nous allons nous en contenter.

=== Fonction intermédiaire TYPE version 1 ===

J'ai également commencé à réfléchir à la fonction TYPE. Pour l'instant, elle ne fait qu'ajouter les noms de fichier dans le superbloc. Cela permet de pouvoir tester les fonctions LS et RM (voir dans la rubrique compilation et exécution comment utiliser le programme).
// Fonction pour créer un fichier avec le nom donné et le contenu fourni en entrée standard
void TYPE(const char *filesystem_path, const char *filename) {
unsigned char buffer[MAX_FILENAME_LENGTH];
// Parcours des blocs réservés pour la description des fichiers
for (int blockNum = 0; blockNum <= MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, MAX_FILENAME_LENGTH);
// Vérifier si le bloc est vide (pas de nom de fichier)
if (buffer[0] == 0) {
// Écrire le nom du fichier dans l'emplacement vide du superbloc
writeBlock(blockNum, 0, (const unsigned char *)filename, MAX_FILENAME_LENGTH);
break; // Fichier créé, sortir de la boucle
}
}
printf("Le fichier \"%s\" a été créé avec succès.\n", filename);
}

ReX : Si la boucle se termine sans trouver de slot libre le message de succès s'affiche tout de même.

ReX : Le paramètre <code>filename</code> n'a pas forcément une taille de <code>MAX_FILENAME_LENGTH</code>.

Selon moi, la fonction TYPE devra respecter 3 étapes:

# Enregistrement du Nom du Fichier: L'ajout du nom du fichier dans un des blocs de la première partie du superbloc.
# Stockage des Données du Fichier: La récupération des données saisies en entrée standard par l'utilisateur et leur stockage dans des blocs du système de fichiers à partir d'une certaine position, comme le bloc 1040.
# Mise à Jour de la Disponibilité des Blocs: L'indication que les blocs dans lesquels les données ont été écrites ne sont plus disponibles en modifiant les bits correspondants dans la deuxième partie du superbloc (les 16 derniers blocs du super bloc).

ReX : Relis le point 3 et dit moi si tu te comprends toi même ?

Amine: Ma phrase n'est effectivement pas très claire. Je voulais dire que la fonction TYPE devra mettre à jour la carte de disponibilité du superbloc. C'est à dire que lorsqu'elle écrira des données dans des blocs, elle devra indiquer dans la carte de disponibilités que ces blocs ne sont plus disponibles.

=== Fonction intermédiaire TYPE version 2 ===

Suite à vos remarques, j'ai apporté les modifications suivantes à la fonction TYPE:

* j'ai ajouté une condition pour l'affichage du message de succès de la création d'un fichier (placeFound).

* le paramètre <code>filename</code> n'ayant pas forcément une taille de <code>MAX_FILENAME_LENGTH</code>, je calcule maintenant la longueur de filename, afin d'écrire seulement le nom du fichier avec la fonction writeBlock.

Il fonction n'est bien évidemment pas fini, elle ajoute seulement le nom du fichier dans le superbloc pour l'instant. Cela me permet de tester les fonctions LS et RM.
void TYPE(const char *filesystem_path, const char *filename) {
size_t sizeFilename = strlen(filename);
printf("size filename=%d\n", sizeFilename);
unsigned char buffer[MAX_FILENAME_LENGTH];
int placeFound = 0;

if (sizeFilename > MAX_FILENAME_LENGTH) {
printf("Impossible de créer le fichier, nom trop long\n");
return;
}

// Parcours des blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, MAX_FILENAME_LENGTH);
// Vérifier si le bloc est vide (pas de nom de fichier)
if (buffer[0] == 0) {
// Écrire le nom du fichier dans l'emplacement vide du superbloc
if (sizeFilename < MAX_FILENAME_LENGTH) {
sizeFilename+=1;
}
writeBlock(blockNum, 0, (const unsigned char *)filename, sizeFilename);
placeFound = 1;
break; // Fichier créé, sortir de la boucle
}
}
if (placeFound == 1) {
printf("Le fichier \"%s\" a été créé avec succès.\n", filename);
} else {
printf("Plus de place dans le système de fichier pour créer ce fichier.\n", filename);
}
}

ReX : Mieux, attention il faut copier aussi le <code>\'0</code> final du nom, donc <code>sizeFilename+1</code>. Sinon tu n'es pas sûr qu'il y ait un zéro final. Et attention n°2, il ne faut pas copier ce <code>\'0</code> si le nom fait la taille maximale.

Amine: ok j'ai modifié la fonction TYPE ci-dessus. J'ai ajouté une condition: si le nom du fichier est inférieur à la taille maximale de nom de fichier, alors on incrémente de 1 la taille du nom de fichier. Cela nous permet d'écrire le '\0' dans le bloc de description. Dans le cas où le nom du fichier est de la taille maximale, nous n'avons pas besoin d'écrire le '\0', on n'incrémente donc pas la taille de 1.

J'ai également ajouté une condition: si le nom du fichier est supérieur à la taille maximale, alors un message d'erreur s'affiche et le fichier n'est pas créé.

ReX : OK. L'embryon de fonction <code>TYPE</code> est correct, il manque juste le principal : la création des blocs de données.

=== Fonction MV version 1 ===

J'ai ici créé la fonction MV qui permet de changer le nom d'un fichier. Pour ce faire, la fonction parcourt les blocs de descriptions à la recherche du fichier dont on veut changer le nom. Lorsque ce fichier est trouvé, on supprime l'ancien nom en mettant des 0 sur 16 octets, puis on vient réécrire le nouveau nom dans le même emplacement. Enfin, on sort de la boucle et on affiche le succès ou non de l'opération.
// Fonction qui modifie le nom du fichier
void MV(const char *filesystem_path, const char *old_filename, const char *new_filename) {
size_t sizeNew_filename = strlen(new_filename);
size_t sizeOld_filename = strlen(old_filename);
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
int fileFound = 0;
// Parcourir les blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);
// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char*)filenameBuffer, old_filename, MAX_FILENAME_LENGTH) == 0) {
// Effacer le nom du fichier dans le superbloc
memset(filenameBuffer, 0, MAX_FILENAME_LENGTH);
writeBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);
// Écrire le nom du fichier dans l'emplacement
writeBlock(blockNum, 0, (const unsigned char *)new_filename, sizeNew_filename);
fileFound=1;
break; // Nom modifié, sortir de la boucle
}
}
if (fileFound == 1) {
printf("Le nom du fichier \"%s\" a été renommé avec succès.\n", old_filename);
} else {
printf("Le fichier \"%s\" n'a pas été trouvé.\n", old_filename);
}
}

ReX : Inutile d'écraser l'ancien nom avec des zéros. Il suffit de copier le nouveau en s'assurant qu'il y ait un zéro final sauf si le nouveau nom fait la taille maximale.

Amine: ok, je vais faire les modifications dans la version 2.

== Semaine 6 ==

=== Fonction MV version 2 ===
Dans cette nouvelle version de la fonction MV, j'ai effectué les modifications suivantes:

* je n'écrase plus l'ancien nom avec des 0
* Je colle simplement le nouveau nom par dessus l'ancien, en m'assurant qu'il y ait bien le '\0' à la fin lorsque la taille du nom du fichier est inférieur à la taille maximale. Comme précédemment, afin de m'assurer de la présence de ce '\0' à la fin du nom, j'incrémente la taille de 1 lorsque qu'elle est inférieur à la taille max. Cependant, je ne suis pas sûr à 100% que ce soit la bonne manière de faire.

// Fonction qui modifie le nom du fichier
void MV(const char *filesystem_path, const char *old_filename, const char *new_filename) {
size_t sizeNew_filename = strlen(new_filename);
size_t sizeOld_filename = strlen(old_filename);
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
int fileFound = 0;

// Parcourir les blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {

readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char*)filenameBuffer, old_filename, MAX_FILENAME_LENGTH) == 0) {

if (sizeNew_filename < MAX_FILENAME_LENGTH) {
sizeNew_filename+=1;
}

// Écrire le nom du fichier dans l'emplacement
writeBlock(blockNum, 0, (const unsigned char *)new_filename, sizeNew_filename);

fileFound=1;

break; // Nom modifié, sortir de la boucle
}
}
if (fileFound == 1) {
printf("Le nom du fichier \"%s\" a été renommé avec succès.\n", old_filename);
} else {
printf("Le fichier \"%s\" n'a pas été trouvé.\n", old_filename);
}
}

ReX : C'est bon. La fonction était triviale.

=== Fonction TYPE version 1 ===
void TYPE(const char *filesystem_path, const char *filename) {
size_t sizeFilename = strlen(filename);
unsigned char buffer[MAX_FILENAME_LENGTH];
int placeFound = -1;

if (sizeFilename > MAX_FILENAME_LENGTH) {
printf("Impossible de créer le fichier, nom trop long\n");
return;
}

// Parcours des blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, MAX_FILENAME_LENGTH);
// Vérifier si le bloc est vide (pas de nom de fichier)
if (buffer[0] == 0) {
// Écrire le nom du fichier dans l'emplacement vide du superbloc
if (sizeFilename < MAX_FILENAME_LENGTH) {
sizeFilename += 1; // Ajouter '\0' s'il y a de la place
}
writeBlock(blockNum, 0, (const unsigned char *)filename, sizeFilename);
placeFound = blockNum;

// Lire les données depuis l'entrée standard
unsigned char dataBuffer[BLOCK_SIZE];
size_t bytesRead;
int dataBlockNum = findAvailableBlock(); // Premier bloc de données à partir du bloc 1040
printf("dataBlockNum%d\n",dataBlockNum);
int blockSizeUsed = 0; // Compteur d'octets dans le bloc actuel
int dataBlocksNeeded = 1; // Nombre de blocs de données nécessaires

while ((bytesRead = fread(dataBuffer + blockSizeUsed, 1, BLOCK_SIZE - blockSizeUsed, stdin)) > 0) {
blockSizeUsed += bytesRead;

// Si le bloc actuel est plein, passer au bloc suivant
if (blockSizeUsed == BLOCK_SIZE) {
// printf("dataBlockNum=%d\n",dataBlockNum);
writeBlock(dataBlockNum, 0, dataBuffer, BLOCK_SIZE);
setBlockAvailability(dataBlockNum, 1);

dataBlockNum++; // Passer au bloc suivant
blockSizeUsed = 0; // Réinitialiser la taille utilisée
dataBlocksNeeded++;
}
}

// Écrire le dernier bloc partiel, s'il y en a un
if (blockSizeUsed > 0) {
writeBlock(dataBlockNum, 0, dataBuffer, blockSizeUsed);
setBlockAvailability(dataBlockNum, 1);
}

// Écrire les numéros de blocs utilisés dans le bloc de description
unsigned char blockNumberBuffer[2];
int currentBlockNum = 1040;

for (int i = 0; i < dataBlocksNeeded; i++) {
blockNumberBuffer[0] = (currentBlockNum >> 8) & 0xFF;
blockNumberBuffer[1] = currentBlockNum & 0xFF;
writeBlock(placeFound, MAX_FILENAME_LENGTH + i * 2, blockNumberBuffer, 2);
currentBlockNum++;
}

break; // Fichier créé, sortir de la boucle
}
}

if (placeFound != -1) {
printf("Le fichier \"%s\" a été créé avec succès.\n", filename);
} else {
printf("Plus de place dans le système de fichier pour créer ce fichier.\n");
}
}

ReX : La constante 1040 ne doit pas apparaître en numérique, ce doit être une constante calculée à partir des autres constantes.

Amine: Ok. Je ne l'avais pas défini comme une constante car il s'agit dans la fonction ci-dessus d'une variable qui est incrémenté à chaque itération.

ReX : Je suis las de te répéter que le mémoire est comptée : tu utilises encore un bloc de <code>BLOCK_SIZE</code> octets, c'est trop.

Amine: Comment utiliser des blocs plus petit sachant qu'il s'agit là de blocs de données et qu'un bloc fait 256 octets d'après l'énoncé ? Dois-je les subdiviser en plusieurs blocs plus petit comme fait dans la fonction RM, en 4 blocs de 64 octets par exemple ?

Fonctionnement de la fonction TYPE:

* étape 1: on parcourt les blocs de descriptions à la recherche d'un bloc disponible. Si on ne trouve pas de bloc disponible, on renvoie un message d'erreur, sinon on passe à l'étape suivante.
* étape 2: Si on trouve un emplacement libre dans les blocs de disponibilité, on écrit le nom du fichier dans cet emplacement.

ReX : Dans les blocs de description de fichiers pas dans les blocs de disponibilité.

Amine: Oui autant pour moi.

* étape 3: Ensuite, on lit le texte entré par l'utilisateur en entrée standard, on le répartit dans des blocs de taille BLOCK_SIZE, on met à jour la disponibilité des blocs utilisés.

ReX : Non, il faut appeler <code>findAvailableBlock</code> pour chaque bloc de données à utiliser, aucune certitudes que les blocs libres soient en séquence.

Amine: ok, je ferai cela dans la version 2

* étape 4: Enfin, on écrit les numéros des blocs de données utilisés dans les blocs de description de ce fichier, les numéros étant écris sur deux octets.

ReX : Non cela doit se faire au fur et à mesure des appels à <code>findAvailableBlock</code> et les numéros des blocs de données peuvent s'étaler sur les 16 blocs de description du fichier. Confusion totale sur ce point. Vous n'avez pas compris le mécanisme.

Amine: je corrige cela dans la version 2. J'ai bien compris le mécanisme mais ce n'est pas facile à traduire en code.

=== Fonction TYPE version 2 ===
Dans cette nouvelle version de TYPE, j'ai fait les modifications suivantes:

* j'appelle maintenant <code>findAvailableBlock</code> pour chaque bloc de données à utiliser
* j'écris maintenant les numéros de blocs au fur et à mesures des appels à <code>findAvailableBlock</code>
* je n'utilise plus de tableaux de taille 256 octets mais des tableaux de tailles CHUNK_SIZE. J'ai choisi ici CHUNK_SIZE = 64 octets.

J'utilise toujours un bloc de taille BLOCK_SIZE en attendant de comprendre si je dois diviser ce bloc en plusieurs blocs de taille plus petite ou s'il y a un moyen de ne pas du tout utiliser ces blocs.
void TYPE(const char *filesystem_path, const char *filename) {
size_t sizeFilename = strlen(filename);
unsigned char buffer[MAX_FILENAME_LENGTH];
int placeFound = -1;

if (sizeFilename > MAX_FILENAME_LENGTH) {
printf("Impossible de créer le fichier, nom trop long\n");
return;
}

// Parcours des blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, MAX_FILENAME_LENGTH);
// Vérifier si le bloc est vide (pas de nom de fichier)
if (buffer[0] == 0) {
// Écrire le nom du fichier dans l'emplacement vide du superbloc
if (sizeFilename < MAX_FILENAME_LENGTH) {
sizeFilename += 1; // Ajouter '\0' s'il y a de la place
}
writeBlock(blockNum, 0, (const unsigned char *)filename, sizeFilename);
placeFound = blockNum;

// Lire les données depuis l'entrée standard et écrire dans le fichier
int dataBlockNum = findAvailableBlock(); // Premier bloc de données à partir du bloc 1040
printf("Premier bloc dans lequel on écrit = %d\n", dataBlockNum);
int blockSizeUsed = 0; // Compteur d'octets dans le bloc actuel

unsigned char chunkBuffer[CHUNK_SIZE];
size_t bytesRead;

while ((bytesRead = fread(chunkBuffer, 1, CHUNK_SIZE, stdin)) > 0) {
// Écrire le chunk dans le bloc de données
writeBlock(dataBlockNum, blockSizeUsed, chunkBuffer, bytesRead);
setBlockAvailability(dataBlockNum, 1);

// Écrire le numéro du bloc actuel dans la description du fichier
unsigned char blockNumberBuffer[2];
blockNumberBuffer[0] = (dataBlockNum >> 8) & 0xFF;
blockNumberBuffer[1] = dataBlockNum & 0xFF;
writeBlock(placeFound, MAX_FILENAME_LENGTH + dataBlockNum * 2, blockNumberBuffer, 2);

blockSizeUsed += bytesRead;

// Si le bloc actuel est plein, passer au bloc suivant
if (blockSizeUsed == BLOCK_SIZE) {
dataBlockNum = findAvailableBlock(); // Passer au bloc suivant
blockSizeUsed = 0; // Réinitialiser la taille utilisée
}
}

break; // Fichier créé, sortir de la boucle
}
}

if (placeFound != -1) {
printf("Le fichier \"%s\" a été créé avec succès.\n", filename);
} else {
printf("Plus de place dans le système de fichier pour créer ce fichier.\n");
}
}

=== Fonction findAvailableBlock ===
Cette fonction renvoie l'indice du premier bloc disponible. Je me sers de cette fonction dans la fonction TYPE.
#define FIRST_DATA_BLOCK 1040
#define FIRST_DISPONIBILITY_CARD_BLOCK 1024

// Renvoie le premier bloc de donné disponible
int findAvailableBlock() {
unsigned char availabilityBuffer[BLOCK_SIZE];
int offset;

// Lire la carte de disponibilité (à partir du bloc 1)
for (int blockNum = FIRST_DISPONIBILITY_CARD_BLOCK; blockNum < FIRST_DATA_BLOCK; blockNum++) {
readBlock(blockNum, 0, availabilityBuffer, BLOCK_SIZE);

if (blockNum==FIRST_DISPONIBILITY_CARD_BLOCK) {
offset=FIRST_DATA_BLOCK/8;
} else {
offset=0;
}

// Parcourir les octets de la carte de disponibilité
for (int byteIndex = offset; byteIndex < BLOCK_SIZE - offset; byteIndex++) {
unsigned char byte = availabilityBuffer[byteIndex];

// Parcourir les bits de chaque octet
for (int bitIndex = 0; bitIndex < 8; bitIndex++) {
// Vérifier si le bit est à 0 (bloc disponible)
if ((byte & (1 << bitIndex)) == 0) {
// Calculer l'indice du bloc en fonction du bloc et du bit
int blockIndex = byteIndex * 8 + bitIndex;
return blockIndex;
}
}
}
}

// Aucun bloc disponible trouvé
return -1;
}

ReX : Même remarque que précédement sur les nombres 1024 et 1040.

Amine: Ok, j'ai remplacé 1024 par la constante FIRST_DISPONIBILITY_CARD_BLOCK et 1040 par la constante FIRST_DATA_BLOCK dans la fonction ci-dessus.

ReX : Vous n'avez toujours pas compris la contrainte sur la mémoire.

Amine: dois-je découper le bloc de taille BLOCK_SIZE en quatre blocs de taille 64 octets par exemple ?

ReX : Je ne vois pas ce que vous voulez faire avec <code>if (blockNum==1024) offset=1040/8; else offset=0;</code>.

Amine: dans la carte de disponibilité, chaque bit correspond à un bloc. Ainsi, les bits de 0 à 1040 dans la carte de disponibilité décrivent la disponibilité des blocs 0 à 1040. Or ces blocs correspondent au superbloc, et dans cette fonction, on veut connaître le premier bloc de données disponible. On ne s'intéresse donc pas au 1040 premiers bits de la carte de disponibilité. Je crée donc un offset égal à 1040/8 afin de ne pas prendre en compte les 1040 premiers bits soit les 1040/8=130 premiers octets. Cet offset ne s'applique que lorsqu'on se trouve dans le premier des 16 blocs de la carte de disponibilité, d'où la condition <code>if (blockNum==1024)</code>.

=== Fonction CAT version 1 ===
void CAT(const char *filesystem_path, const char *filename) {
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
unsigned char buffer[BLOCK_SIZE];
unsigned char blockNumberBuffer[2];
unsigned char dataBuffer[BLOCK_SIZE];
int offset;

// Parcours des blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char *)filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {
// Le nom du fichier a été trouvé

// Parcours les blocs de description
for (int descrBlockNum=0; descrBlockNum<MAX_BLOCKS_PER_FILE_DESCRIPTION; descrBlockNum++) {
if (descrBlockNum==0) {
offset=16;
} else {
offset=0;
}
readBlock(descrBlockNum+blockNum, offset, buffer, BLOCK_SIZE-offset);

// Lire les numéros de blocs associés à ce fichier depuis les blocs de description
unsigned char octet1 = buffer[offset];
unsigned char octet2 = buffer[offset+1];

int dataBlockNum = (octet1 << 8) | octet2;
printf("dataBlockNum=%d\n",dataBlockNum);

// Vérifier si le numéro de bloc est valide (non nul)
if (dataBlockNum == 0) {
return; // Fin du fichier
}

// Lire et afficher le contenu du bloc de données
readBlock(dataBlockNum, 0, dataBuffer, BLOCK_SIZE);
fwrite(dataBuffer, 1, BLOCK_SIZE, stdout);
}

return; // Fichier affiché, sortie de la fonction
}
}

// Si le fichier n'a pas été trouvé
printf("Le fichier \"%s\" n'a pas été trouvé.\n", filename);
}

ReX : Encore mieux : deux blocs de <code>BLOCK_SIZE</code> en mémoire.

ReX : Le <code>break</code> ne sort pas de la boucle externe.

Amine: Oui c'est vrai. J'ai remplacé le break pas un return ci-dessus.

Voici ma fonction <code>CAT</code>. Elle fonctionne en plusieurs étape:

* étape 1: on cherche dans les blocs de descriptions si le fichier dont on veut afficher le contenu existe. Si le nom de fichier est trouvé, on passe à l'étape 2. Sinon, on renvoie un message d'erreur.
* étape 2: si le fichier est trouvé, on parcours les 16 blocs de description de ce fichier.
* étape 3: grâce aux opérations de masquage et de décalage, on joint les octets deux par deux pour former un entier qui contient le numéro du bloc de données correspondant au fichier. Si cet entier vaut 0, alors cela signifie qu'il n'y a plus de blocs associé à ce fichier, on peut donc quitter la fonction. Si cet entier est différent de 0, alors on va lire le bloc correspondant à ce numéro et on affiche son contenu dans le terminal.

== Semaine 7 ==

=== Fonction CP version 1 ===
Voici ma fonction CP, qui permet de créer une copie d'un fichier existant. L'idée est la suivante: pour copier un fichier, on doit créer un nouveau fichier et lui attribuer les mêmes blocs de descriptions que le fichier source. Ainsi, le fichier source et le fichier destination pointeront vers les mêmes blocs de données, et auront le même contenu.

ReX : Perdu. Ce n'est absolument pas la fonction de copie de fichiers d'un système de fichiers.

Amine: Après avoir fait des recherches et après réflexion, je me rends compte que cette fonction CP présente un problème: en faisant pointé les blocs de données du fichier destination vers ceux du fichier source, toutes modifications du fichier source impactera le fichier destination, or ce n'est pas ce qu'on veut faire. Je vous propose donc une nouvelle version de la fonction CP ci-dessous qui remédie à ce problème.

void CP(const char *filesystem_path, const char *source_filename, const char *destination_filename) {
unsigned char source_filenameBuffer[MAX_FILENAME_LENGTH];
unsigned char destination_filenameBuffer[MAX_FILENAME_LENGTH];
unsigned char descriptionBuffer[BLOCK_SIZE];
int destination_offset;
int offset;

// Recherche du fichier source
int source_offset = -1;
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, source_filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier source
if (strncmp((const char *)source_filenameBuffer, source_filename, MAX_FILENAME_LENGTH) == 0) {
source_offset = blockNum;
break;
}
}

if (source_offset == -1) {
printf("Le fichier source \"%s\" n'a pas été trouvé.\n", source_filename);
return;
}

// Recherche d'un emplacement libre pour le fichier destination
destination_offset = -1;
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, destination_filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc est vide (pas de nom de fichier)
if (destination_filenameBuffer[0] == 0) {
destination_offset = blockNum;
break;
}
}

if (destination_offset == -1) {
printf("Plus de place dans le système de fichier pour créer la copie de \"%s\".\n", source_filename);
return;
}

// Ecrit le nom de la copie dans le bloc de description
writeBlock(destination_offset, 0, (const unsigned char *)destination_filename, strlen(destination_filename));

// Copier les blocs de description associés au fichier source dans les blocs de description du fichier destination
for (int i = 0; i < MAX_BLOCKS_PER_FILE_DESCRIPTION; i++) {
if (i==0) {
offset = MAX_FILENAME_LENGTH;
} else {
offset = 0;
}

readBlock(source_offset+i, offset, descriptionBuffer, BLOCK_SIZE-offset);
if (descriptionBuffer[offset]==0) {
return;
} else {
writeBlock(destination_offset+i, offset, descriptionBuffer, BLOCK_SIZE-offset);
}
}

printf("La copie de \"%s\" sous le nom \"%s\" a été créée avec succès.\n", source_filename, destination_filename);
}

=== Fonction CP version 2 ===
Voici une version mise à jour de notre fonction CP qui duplique réellement les blocs de données du fichier source vers le fichier de destination. Cela implique d'attribuer de nouveaux blocs de données au fichier de destination et de mettre à jour la carte de disponibilité des blocs.
void CP(const char *filesystem_path, const char *source_filename, const char *destination_filename) {
unsigned char source_filenameBuffer[MAX_FILENAME_LENGTH];
unsigned char destination_filenameBuffer[MAX_FILENAME_LENGTH];
unsigned char descriptionBuffer[BLOCK_SIZE];
int destination_offset;
int source_offset;

// Recherche du fichier source
source_offset = -1;
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, source_filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier source
if (strncmp((const char *)source_filenameBuffer, source_filename, MAX_FILENAME_LENGTH) == 0) {
source_offset = blockNum;
break;
}
}

if (source_offset == -1) {
printf("Le fichier source \"%s\" n'a pas été trouvé.\n", source_filename);
return;
}

// Recherche d'un emplacement libre pour le fichier destination
destination_offset = -1;
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, destination_filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc est vide (pas de nom de fichier)
if (destination_filenameBuffer[0] == 0) {
destination_offset = blockNum;
break;
}
}

if (destination_offset == -1) {
printf("Plus de place dans le système de fichier pour créer la copie de \"%s\".\n", source_filename);
return;
}

// Copie du nom de la copie dans le bloc de description
writeBlock(destination_offset, 0, (const unsigned char *)destination_filename, strlen(destination_filename));

// Copier les blocs de données associés au fichier source dans de nouveaux blocs de données pour le fichier destination
for (int i = 0; i < MAX_BLOCKS_PER_FILE_DESCRIPTION; i++) {
if (i == 0) {
int offset = MAX_FILENAME_LENGTH;
readBlock(source_offset + i, offset, descriptionBuffer, BLOCK_SIZE - offset);
if (descriptionBuffer[offset] == 0) {
break;
}
int newDataBlock = findAvailableBlock(); // Trouver un nouveau bloc de données disponible
writeBlock(destination_offset + i, offset, descriptionBuffer, BLOCK_SIZE - offset);
setBlockAvailability(newDataBlock, 1); // Marquer le nouveau bloc de données comme utilisé
} else {
int offset = 0;
readBlock(source_offset + i, offset, descriptionBuffer, BLOCK_SIZE);
if (descriptionBuffer[offset] == 0) {
break;
}
int newDataBlock = findAvailableBlock(); // Trouver un nouveau bloc de données disponible
writeBlock(destination_offset + i, offset, descriptionBuffer, BLOCK_SIZE);
setBlockAvailability(newDataBlock, 1); // Marquer le nouveau bloc de données comme utilisé
}
}

printf("La copie de \"%s\" sous le nom \"%s\" a été créée avec succès.\n", source_filename, destination_filename);
}

== Semaine 8 ==
A ce stade du projet, les fonctions suivantes ont été validé par Monsieur Redon:

* fonction LS
* fonction RM
* fonction MV

Il reste donc les fonctions suivantes à terminer:

* fonction CAT
* fonction CP
* fonction TYPE

=== Fonction CAT version 2 ===
Suite à vos remarques sur la version 1, j'ai fais les modifications suivantes:

* je n'utilise non plus 2 tableaux de taille BLOCK_SIZE, mais 1 seul. Idéalement il faudrait en utiliser 0, je réfléchi donc à m’émanciper de ce tableau en le remplaçant par plusieurs plus petits tableaux.
* J'ai remplacé le <code>break</code> par un return

Cette fonction permet d'afficher le contenu d'un fichier créé avec la fonction TYPE. Pour se faire, on parcours tout d'abord les blocs de descriptions pour trouver le fichier dont ont veut afficher le contenu. Une fois ce fichier trouvé, on parcours les 16 blocs de description de ce fichier 1 à 1. Pour chacun de ces blocs de description, on va stocker récupéré les octets deux par deux afin de former des entiers. Pour se faire, on utilise la fonction <code>reconsituteNumber</code> que l'on détaillera juste après. Ces entiers correspondent aux blocs dans lesquels la donné du fichier se trouve. Une fois l'entier reconstitué, on affiche le contenu du bloc correspondant.
void CAT(const char *filesystem_path, const char *filename) {
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
unsigned char byteBuffer[2];
unsigned char dataBuffer[BLOCK_SIZE];
int offset;

// Parcours des blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char *)filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {
// Le nom du fichier a été trouvé

// Parcours les blocs de description
for (int descrBlockNum=0; descrBlockNum<MAX_BLOCKS_PER_FILE_DESCRIPTION; descrBlockNum++) {
if (descrBlockNum==0) {
offset=MAX_FILENAME_LENGTH;
} else {
offset=0;
}

// Lecture des octets deux par deux
for (int i=0; i<BLOCK_SIZE;i+=2) {
readBlock(descrBlockNum+blockNum, offset+i, byteBuffer, 2);

// Lire les numéros de blocs associés à ce fichier depuis les blocs de description
int dataBlockNum = reconsituteNumber(byteBuffer);

// Vérifier si le numéro de bloc est valide (non nul)
if (dataBlockNum == 0) {
return; // Fin du fichier
}

// Lire et afficher le contenu du bloc de données
readBlock(dataBlockNum, 0, dataBuffer, BLOCK_SIZE);
fwrite(dataBuffer, 1, BLOCK_SIZE, stdout);
}
}

return; // Fichier affiché, sortie de la fonction
}
}

// Si le fichier n'a pas été trouvé
printf("Le fichier \"%s\" n'a pas été trouvé.\n", filename);
}

=== Fonction reconsituteNumber ===
Cette fonction permet de reconstituer un numéro de bloc à partir de deux octets.
// Fonction qui reconstitue le numéro de bloc à partir du tableau
int reconsituteNumber(unsigned char blockNumberBuffer[2]) {
unsigned char octet1 = blockNumberBuffer[0];
unsigned char octet2 = blockNumberBuffer[1];
int dataBlockNum = (octet1 << 8) | octet2;
return dataBlockNum;
}

= Compilation et exécution =
'''Création du système de fichiers :'''
dd if=/dev/zero of=filesystem.bin bs=256 count=32768

'''Compilation :'''

gcc picofs.c -o picofs

'''Exécution de LS, TYPE, CAT, RM, MV ou CP :'''

./picofs filesystem.bin LS
./picofs filesystem.bin TYPE mon_fichier.txt
./picofs filesystem.bin CAT mon_fichier.txt
./picofs filesystem.bin RM mon_fichier.txt
./picofs filesystem.bin MV mon_fichier.txt mon_fichier2.txt
./picofs filesystem.bin CP mon_fichier.txt mon_fichier2.txt

= Documents Rendus =
[[Fichier:Pcfs.c.tar|vignette]]

SE4 2022/2023 EC1

2023-09-02T11:36:27Z

Asellali : /* Fonction CAT version 2 */

= Objectifs =

Il vous est demandé de :
* réaliser un micro système de fichiers ;
* le système de fichiers doit résider dans un fichier de 8 Mo ;
* le système de fichiers est géré par un exécutable obtenu à partir d'un programme C ;
* L'éxécutable prend deux arguments, le premier est le chemin du fichier dans lequel réside le système de fichiers, les paramètres suivants concernent l'action à appliquer sur le système de fichiers ;
* le micro système de fichier ne comporte qu'un répertoire : le répertoire principal, le répertoire principal peut comporter au maximum 64 fichiers, un fichier est caractérisé par un nom de 16 caractères au maximum et ses blocs de données, un fichier peut comporter au maximum 2040 blocs de données ;
* un bloc de données fait 256 octets et les blocs sont numérotés sur 2 octets ;
* les différentes actions possibles sur le système de fichiers sont :
** <code>TYPE</code> pour créer un fichier si possible, le nom du fichier suit la commande, le contenu du fichier est donné en entrée standard de l'exécutable ;
** <code>CAT</code> pour afficher un fichier, le nom du fichier suit la commande ;
** <code>RM</code> pour détruire un fichier, le nom du fichier suit la commande ;
** <code>MV</code> pour renommer un fichier, les noms original et nouveau du fichier suivent la commande ;
** <code>CP</code> pour copier un fichier, les noms de l'original et de la copie du fichier suivent la commande ;

= Matériel nécessaire =

Un PC sous Linux.

= Travail réalisé =

== Semaine 1 ==

ReX : attention, ce micro-système de fichiers est prévu pour un microcontrôleur, vos variables globales ne peuvent pas dépasser quelques centaines d'octets.

ReX : pour la création du système de fichiers la commande <code>dd</code> suffit, vous voulez dire le formatage du système de fichiers ?

* création du programme programme.c contenant les différentes structures et les différentes fonctions.
* Piste d'amélioration: faire en sorte que la fonction CAT affiche le contenu exact des fichiers passés en argument.

Le code fourni est un programme en langage C qui simule un système de fichiers basique. Ce programme permet aux utilisateurs d'effectuer diverses actions telles que créer, afficher, supprimer, renommer et copier des fichiers dans un système de fichiers simulé. Le système de fichiers est stocké dans un fichier binaire.

ReX : vous n'avez pas tenu compte de la première remarque, vous chargez tout le superbloc et le répertoire racine, votre code ne convient pas.

ReX : vos structures utilisent des types entiers dont la taille n'est pas explicitée, utilisez les types de <code>stdint.h</code>.

ReX : la création de fichier n'est pas fonctionnelle, vous ne cherchez pas les blocs libres, vous ne copiez pas le contenu du fichier dans les blocs, même remarque pour toutes les autres fonctions.

ReX : il manque les fonctions d'accès aux pages du système de fichiers.

'''Explication du programme programme.c'''

Voici une brève explication des principaux éléments et fonctions du code :

# Structures :
#* Fichier : Représente un fichier dans le système de fichiers. Il contient un nom (nom) avec une longueur maximale de 16 caractères, un tableau de numéros de bloc (blocs) où le contenu du fichier est stocké (jusqu'à 2040 blocs), et le nombre de blocs utilisés par le fichier (nbBlocs).
#* Repertoire : Représente le répertoire principal du système de fichiers. Il contient un tableau de fichiers (<code>fichiers</code>) et le nombre de fichiers dans le répertoire (<code>nbFichiers</code>).
# Fonctions :
#* <code>chargerSystemeFichiers</code> : Charge le système de fichiers à partir d'un fichier binaire donné (chemin) dans une structure Repertoire.
#* <code>sauvegarderSystemeFichiers</code> : Sauvegarde le système de fichiers stocké dans la structure Repertoire dans un fichier binaire (chemin).
#* <code>creerFichier</code> : Crée un nouveau fichier dans le système de fichiers avec un nom et un contenu donnés. Le contenu du fichier est simulé en le divisant en blocs.
#* <code>afficherFichier</code> : Affiche le contenu d'un fichier avec le nom spécifié.
#* <code>detruireFichier</code> : Supprime un fichier avec le nom spécifié du système de fichiers.
#* <code>renommerFichier</code> : Renomme un fichier avec l'ancien nom spécifié en un nouveau nom.
#* <code>copierFichier</code> : Copie un fichier avec le nom spécifié en créant un nouveau fichier avec le nom de copie spécifié.
# Fonction <code>main</code> :
#* La fonction <code>main</code> est le point d'entrée du programme.
#* Elle prend des arguments en ligne de commande : <code><chemin_systeme_fichiers></code> et <code><action></code>.
#* <code><chemin_systeme_fichiers></code> est le chemin vers le fichier binaire où le système de fichiers est stocké.
#* <code><action></code> détermine quelle opération effectuer, comme <code>TYPE</code>, <code>CAT</code>, <code>RM</code>, <code>MV</code> ou <code>CP</code>.
#* En fonction de l'action spécifiée, le programme appelle la fonction correspondante pour effectuer l'opération souhaitée sur le système de fichiers.
Remarque : Le code fourni une simulation basique d'un système de fichiers et de ses opérations, mais il n'interagit pas réellement avec un système de fichiers réel sur le disque.

'''Comment utiliser le programme programme.c'''

étape 1: création du système de fichiers respectant le cahier des charges:

dd if=/dev/zero of=systeme_fichiers.bin bs=1M count=8

étape 2: compilation du programme C:

gcc programme.c -o gestionnaire_fs

étape 3: création d'un fichier dans le système de fichier:

./gestionnaire_fs systeme_fichiers.bin TYPE fichier1.txt

-> entrer le texte en entrée standard

étape 4: manipulation des différentes fonctions. Exemples:

./gestionnaire_fs systeme_fichiers.bin CAT fichier1.txt
./gestionnaire_fs systeme_fichiers.bin CP fichier1.txt copie.txt
./gestionnaire_fs systeme_fichiers.bin RM copie.txt
./gestionnaire_fs systeme_fichiers.bin MV fichier1.txt fichier2.txt

== Semaine 2 ==

Amine: Merci pour vos remarques. Désolé de ne pas avoir suivi votre première remarque, je pensais avoir compris ce qu'il fallait faire mais je me rend compte que non. Je vais tout reprendre depuis le début afin de repartir sur de bonnes bases.

'''Création du système de fichier avec la commande "dd"'''

A quoi sert la commande dd?

La commande <code>dd</code> permet de copier tout ou partie d'un disque par blocs d'octets, indépendamment de la structure du contenu du disque en fichiers et en répertoires (source : [https://doc.ubuntu-fr.org/dd]).

Structure de la commande

dd if=<nowiki><source> of=<cible> bs=<taille des blocs></nowiki>

<code>source</code> = données à copier

<code>cible</code> = endroit où les copier

<code>if</code> = input file

<code>of</code> = output file

<code>bs</code> = block size, habituellement une puissance de 2 supérieure ou égale à 512, représentant un nombre d'octets

Choix de la commande:

Pour la source, on prends <code>/dev/zero</code>: cela permet de créer un fichier rempli de 0. Ce fichier servira de base pour notre système de fichiers.

Pour la cible, on va l'appeler <code>filesystem.bin</Code> : ce sera notre système de fichier.

Pour la taille des blocs, on veut des blocs de données de 256 octets d'après l'enoncé. On va donc prendre <code>bs=256</code>.

Enfin, on veut que le système de fichier réside dans un fichier de 8 Mo. On va donc ajouter <code>count=31250</code>: cela indique que nous voulons écrire 32768 blocs de données dans le fichier (31250 * 256 octets = 8 Mo).

Résultat:

dd if=/dev/zero of=filesystem.bin bs=256 count=31250

Question pour M. Redon : j'ai ici essayé de respecter votre remarque "pour la création du système de fichiers la commande <code>dd</code> suffit". Cependant, pour votre seconde remarque "vous chargez tout le superbloc et le répertoire racine, votre code ne convient pas.", je ne suis pas sûr de comprendre où je fais cela: est-ce lors de la commande dd ou est-ce par la suite avec mon programme C? J'ai un peu modifié la commande dd comme vous pouvez le voir ci-dessus. Ai-je corrigé mon erreur avec cette nouvelle commande? J'ai essayé de justifier au maximum la commande dd que j'ai choisie.

ReX : Pas de problème avec la commande <code>dd</code> (mettez tous les extraits de code entre des balises <code>code</code>). Le problème est au niveau du programme C.

Amine: Ok je comprends mieux merci. Je vais donc reprendre le code étape par étape afin de mieux répondre au cahier des charges.

Gestion du système de fichier par un programme C

'''Création des structures'''
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>

// Structure pour représenter un bloc de données

struct DataBlock {
uint8_t data[256]; // 256 octets pour chaque bloc de données
};

// Structure pour représenter un fichier

struct File {
char filename[17]; // 16 caractères pour le nom du fichier + 1 caractère null-terminator
struct DataBlock data_blocks[2040]; // Tableau de blocs de données pour stocker le contenu du fichier
uint16_t num_data_blocks; // Nombre de blocs de données utilisés par le fichier
};

// Structure pour représenter un répertoire

struct Directory {
struct File files[64]; // Tableau de fichiers pour le répertoire principal
uint8_t num_files; // Nombre de fichiers dans le répertoire principal
};

Modification faite : suite à votre remarque, j'ai explicité la taille des entiers grâce aux types de <code>stdint.h.</code> (j'ai également mis les variables en anglais)

ReX : Vous ne pouvez pas utiliser ces structures, une instanciation d'une de ces structure prend trop d'espace mémoire, vous devez faire sans structure. Par ailleurs la façon dont vous représentez vos fichiers ne convient pas, la description d'un fichier contient des numéros de blocs, pas les blocs eux-même. Faites aussi attention qu'un fichier soit décrit par un nombre entier de blocs.

Question pratique: je n'arrive pas à mettre tout le code dans le même bloc comme vous l'avez fait ci-dessus dans l'étape 4 de la semaine 1. Je vois que c'est en format "préformaté" mais j'obtiens des blocs séparés lorsque j'applique ce format à mon code.

ReX : j'ai corrigé, pour un code entier la syntaxe n'est pas la même (un espace en début de chaque ligne), la balise c'est uniquement pour de très courts extraits de code.

=== Fonction <code>readBlock</code>===
Cette fonction est utilisée pour lire un bloc de données à partir du fichier <code>filesystem.bin</code> et le stocker dans un tableau de caractères (<code>storage</code>).

Fonction:

#define BLOCK_SIZE 256
// Fonction pour lire un bloc de données
void readBlock(unsigned int num, int offset, unsigned char *storage, int size) {
FILE *file = fopen("filesystem.bin", "rb");
if (file == NULL) {
perror("Erreur lors de l'ouverture du fichier");
return;
}
fseek(file, num * BLOCK_SIZE + offset, SEEK_SET);
fread(storage, 1, size, file);
fclose(file);
}

Paramètres :

* <code>num</code> : Numéro du bloc à lire. Chaque bloc contient 256 octets (1 bloc = 256 octets).
* <code>offset</code> : Décalage (en octets) à partir du début du bloc pour commencer la lecture.
* <code>storage</code> : Pointeur vers un tableau de caractères où les données lues seront stockées.
* <code>size</code> : Taille du tableau de caractères <code>storage</code>.

Fonctionnement :

* La fonction commence par ouvrir le fichier <code>filesystem.bin</code> en mode lecture binaire (<code>"rb"</code>).
* Elle utilise <code>fseek</code> pour positionner le curseur de lecture dans le fichier à l'endroit approprié pour commencer la lecture du bloc spécifié (<code>num</code>) à partir de l'offset (<code>offset</code>).
* Elle utilise ensuite <code>fread</code> pour lire <code>size</code> octets à partir du fichier et les stocker dans le tableau <code>storage</code>.
* Enfin, elle ferme le fichier avec <code>fclose</code>.

Note : Le paramètre <code>offset</code> est utilisé pour spécifier à partir de quel octet du bloc on souhaite commencer la lecture. Si <code>offset</code> est égal à 0, la lecture commencera depuis le début du bloc. Si <code>offset</code> est différent de 0, la lecture commencera à l'octet spécifié.

Remarque: dans votre mail, vous définissez "readBlock(unsigned int num,int offset,unsigned storage,int size)": storage n'est alors pas un pointeur vers un tableau de caractère. Je me suis donc permis de faire la modification.

ReX : OK pour la fonction, pas la peine d'en mettre autant dans le Wiki pour une fonction aussi simple.

=== Fonction <code>writeBlock</code> ===
Cette fonction est utilisée pour écrire un bloc de données dans le fichier <code>filesystem.bin</code> à partir d'un tableau de caractères (<code>storage</code>).

Fonction:

// Fonction pour écrire un bloc de données
void writeBlock(unsigned int num, int offset, const unsigned char *storage, int size) {
FILE *file = fopen("filesystem.bin", "rb+");
if (file == NULL) {
perror("Erreur lors de l'ouverture du fichier");
return;
}
fseek(file, num * BLOCK_SIZE + offset, SEEK_SET);
fwrite(storage, 1, size, file);
fclose(file);
}

Paramètres :

* <code>num</code> : Numéro du bloc où écrire.
* <code>offset</code> : Décalage (en octets) à partir du début du bloc pour commencer l'écriture.
* <code>storage</code> : Pointeur vers un tableau de caractères contenant les données à écrire dans le fichier.
* <code>size</code> : Taille du tableau de caractères <code>storage</code>.

Fonctionnement :

* La fonction commence par ouvrir le fichier <code>filesystem.bin</code> en mode lecture et écriture binaire (<code>"rb+"</code>).
* Elle utilise <code>fseek</code> pour positionner le curseur de lecture/écriture dans le fichier à l'endroit approprié pour commencer l'écriture du bloc spécifié (<code>num</code>) à partir de l'offset (<code>offset</code>).
* Elle utilise ensuite <code>fwrite</code> pour écrire <code>size</code> octets à partir du tableau <code>storage</code> dans le fichier.
* Enfin, elle ferme le fichier avec <code>fclose</code>.

ReX : Même remarque que pour la fonction précédente.

'''Etape 4: test des fonctions <code>readBlock</code> et <code>writeBlock</code> dans le main'''
// Exemple de fonction principale pour tester les opérations de lecture et d'écriture
int main() {
unsigned char data[BLOCK_SIZE];
// Test de la fonction readBlock
readBlock(0, 0, data, BLOCK_SIZE);
printf("Block 0, offset 0: ");
for (int i = 0; i < BLOCK_SIZE; i++) {
printf("%02x ", data[i]);
}
printf("\n");
// Test de la fonction writeBlock
unsigned char newData[BLOCK_SIZE] = {
0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88,
// ... Autres données du bloc ...
};
writeBlock(1, 0, newData, BLOCK_SIZE);
// Lecture du bloc nouvellement écrit pour vérifier
readBlock(1, 0, data, BLOCK_SIZE);
printf("Block 1, offset 0: ");
for (int i = 0; i < BLOCK_SIZE; i++) {
printf("%02x ", data[i]);
}
printf("\n");
return 0;
}

Fonctionnement :

* On déclare tout d'abord un tableau de caractères <code>data</code> de taille <code>BLOCK_SIZE</code> pour stocker les données lues du bloc.
* Ensuite, la fonction <code>readBlock</code> est appelée avec les arguments (0, 0, data, BLOCK_SIZE) pour lire le premier bloc du fichier (<code>num=0</code>, <code>offset=0</code>) et stocker les données dans <code>data</code>.
* Ensuite, la fonction <code>printf</code> est utilisée pour afficher les données lues du bloc (<code>data</code>) en format hexadécimal.
* Ensuite, un nouveau tableau de caractères <code>newData</code> est créé avec des données spécifiques pour tester la fonction <code>writeBlock</code>.
* La fonction <code>writeBlock</code> est appelée avec les arguments (1, 0, newData, BLOCK_SIZE) pour écrire le tableau <code>newData</code> dans le deuxième bloc du fichier (<code>num=1</code>, <code>offset=0</code>).
* Enfin, la fonction <code>readBlock</code> est appelée à nouveau pour lire le deuxième bloc nouvellement écrit et afficher les données lues en format hexadécimal.

Question générale : ce que j'avais la première semaine n'est plus forcément d'actualité. Puis-je supprimer les choses qui ne le sont plus afin d'alléger la page ou préférez-vous que je laisse?

ReX : Laissez.

Pour la suite : j'ai donc pour l'instant crée deux fonctions, l'une permettant la lecture et l'autre l'écriture d'un bloc, de manière à économiser la mémoire. Pour la suite, je vais essayer de créer la fonction <code>LS</code> en utilisant la fonction <code>readBlock</code>.

ReX : Oui c'est le début du projet. Mais si vous n'avez pas une bonne description de fichier cela ne donnera rien. Voir remarques plus haut.

'''Etape 5: fonction <code>LS</code>'''

Objectif: créer la fonction <code>LS</code> avec la fonction readBlock.

Question: Souhaitez-vous la fonction <code>LS</code> classique, c'est à dire la fonction <code>LS</code> qui affiche simplement le nom des fichiers présent dans le répertoire ?

ReX : Oui. Tu peux ajouter la taille si tu trouves cela trop simple.

Piste : si c'est ce que vous voulez:

* il va tout d'abord falloir que je crée des fichiers, un fichier étant composé d'un nom et de blocs (création d'une fonction createFile)
* Il faudra ensuite que je stocke ces fichiers dans le répertoire (création d'une fonction addFileToDirectory par exemple)
* enfin, il faudra que j'affiche le nom des fichiers. Pour cela, il faudra que je parcours le répertoire (structure "Directory"), puis que pour chaque fichier présent dans le répertoire que j'affiche son nom (création de la fonction LS)

Je devrais surement utiliser la fonction readBlock afin de transférer les blocs dans le fichier au travers de la variable "storage".

ReX : Créer des fichiers n'est pas nécessaire tout de suite je verrais bien si ton code est bon sans test. Laisse tomber <code>createFile</code> et <code>addFileToDirectory</code> pour l'instant.

ReX : Ton algorithme ne fonctionne pas pour un microcontrôleur où il faut économiser la mémoire, tu ne peux pas t'aider de structures. Il faudra que tu charges les noms et seulement les noms, pour la taille il faudra se baser sur le nombre de blocs.

'''Etape 6: rectification du code suite à vos remarques'''

Modifications apportées:

* suppression des structures afin d’économiser de la mémoire.

* le problème quant à la description des fichiers est normalement résolu puisque plus de structures. On ne charge plus les blocs mais seulement les noms de fichiers.

ReX : Non car si les noms ne sont pas répartis de façon régulière dans les blocs de 256 octets tu vas avoir du mal à les charger. Mais écrit la fonction <code>LS</code> et tu verras ce que je veux dire.

J'ai également ajouté deux nouvelles fonctions:

# <code>void readFileName(unsigned int file_num, char *file_name)</code>: Cette fonction permet de lire le nom du fichier associé au numéro de fichier donné (<code>file_num</code>). Elle stocke le nom du fichier lu dans le tableau <code>file_name</code>.
# <code>void writeFileName(unsigned int file_num, const char *file_name)</code>: Cette fonction permet d'écrire le nom du fichier dans le système de fichiers, associé au numéro de fichier donné (<code>file_num</code>). Elle prend en entrée le nom du fichier à écrire (<code>file_name</code>).

Suite: si vous validez cette base, je pourrai passer à la création de la fonction LS.

ReX : tu peux y aller. Je ne vois pas le code des tes deux fonctions <code>readFileName</code> et <code>writeFileName</code>.

Voici le code des fonctions <code>readFileName</code> et <code>writeFileName</code> :

'''Fonction readFileName:'''
// Fonction pour lire le nom du fichier
void readFileName(unsigned int file_num, char *file_name) {
readBlock(file_num, 0, (unsigned char *)file_name, MAX_FILENAME_LENGTH);
file_name[MAX_FILENAME_LENGTH] = '\0'; // Ajout du caractère null-terminator pour former une chaîne de caractères
}

ReX : Non, aucune raison que le fichier de numéro n soit au bloc n. Dessine la représentation d'un fichier sur le SF en comptant les octets si cela peut aider.

'''Fonction writeFileName:'''
// Fonction pour écrire le nom du fichier
void writeFileName(unsigned int file_num, const char *file_name) {
writeBlock(file_num, 0, (const unsigned char *)file_name, MAX_FILENAME_LENGTH);
}

ReX : Faux et inutile pour l'instant. Problème avec la constante MAX_FILENAME_LENGTH.

=== Fonction LS version 1 ===
// Fonction LS pour afficher les fichiers présents dans le système de fichiers
void LS(const char *filesystem_path) {
FILE *file = fopen(filesystem_path, "rb");
if (file == NULL) {
perror("Erreur lors de l'ouverture du fichier système");
return;
}
uint16_t num_files;
fread(&num_files, sizeof(uint16_t), 1, file); // Lecture du nombre de fichiers dans le système
char filename[17];
printf("Fichiers présents dans le système de fichiers:\n");
for (int i = 0; i < num_files; i++) {
readFileName(i, filename); // Lecture du nom du fichier
printf("%s\n", filename); // Affichage du nom du fichier
}
fclose(file);
}
La fonction <code>LS</code> ouvre le fichier système, lit le nombre de fichiers qu'il contient, puis affiche les noms des fichiers un par un, chacun sur une ligne séparée.

ReX : Il y a le nombre de fichiers dans ton superbloc ? Un dessin du format du superbloc avec les numéros des octets ?

ReX : Tout accès au système de fichiers doit se faire avec les deux fonctions <code>readBlock</code> et <code>writeBlock</code>.

== Semaine 3 ==
Question 1: cela fait plusieurs fois que vous mentionnez dans le wiki un "superbloc". Celui-ci n'étant pas clairement défini dans le sujet, je me demande s'il s'agit du bloc crée grâce à la fonction dd, c'est à dire que le superbloc serait en faite le bloc constitué des 31250 blocs de taille 256 octets, où s'il s'agit d'un bloc qui vient en entête, celui contenant alors des informations décrivant le système de fichier (les noms de fichiers...).

ReX : Pour ton pico système de fichiers, le superbloc consiste en les premiers blocs (de 256 octets) qui définissent les 64 fichiers possibles.

Proposition de structure: on pourrait réserver les premiers blocs du système de fichiers aux noms de fichiers ainsi qu'aux numéros des blocs correspondant à chaque fichier.

ReX : Oui c'est évident.

On sait que les noms de fichiers font au maximum 16 caractères + 1 caractère pour le '\0' (donc 17 octets car 1 char=1 octet).

ReX : Non, 16 octets suffisent, des '\0' en fin de nom uniquement si le nom fait moins de 16 caractères.

On sait également qu'un fichier contient au maximum 2040 blocs, chaque bloc étant numéroté sur 2 octets. On pourrait donc avoir en début du système de fichier: 17 octets+2 octets*2040 blocs = 4097 octets pour la description d'un fichier.

ReX : Non, 4096 octets soit 16 blocs de 256.

Or d'après l'une de vos remarques dans le wiki, un fichier doit être décrit par un nombre entier de blocs. Pour un fichier, il nous faudra donc 4097/256=16.004 soit 17 blocs. Il peut y avoir jusqu'à 64 fichiers dans le répertoire, il nous faudra donc 17 blocs*64 fichiers= 1088 blocs pour la description des fichiers.

ReX : Non 1024 blocs de 256 octets dans le superbloc.

Ainsi, pour la fonction LS, il suffira de lire les premiers caractères tous les 17 blocs ( du premier caractère au caractère '\0').

ReX : Non, tous les 16 blocs.

Question 2: Ne faudrait-il pas également stocker quelque part le nombre de fichier qu'il y a dans le répertoire afin de savoir jusqu'à quel bloc la fonction LS doit aller ?

ReX : Non, un fichier dont le nom n'est constitué que de '\0' est réputé ne pas exister.

Question 3: on a donc vu que les 1088 premiers blocs au maximum serviraient à la description du système de fichier. Il reste donc 31250-1088=30132 blocs dans le système de fichier.

ReX : Non, 32768-1024=31744 blocs.

Comment utiliser ces blocs? Ces blocs doivent-ils stocker le contenu des fichiers ?

ReX : Oui, c'et évident.

En effet, avec la fonction TYPE, nous allons créer des fichiers et ces fichiers devront être stockés quelque part. Cependant, étant donné que ce pico système de fichiers est prévu pour un microcontrôleur, je ne sais pas si c'est le contenu des fichiers qui doit être stocké dans les blocs ou autre chose (peut être l'adresse des fichiers, le fichiers se trouvant autre part). En effet, je me dis que si un fichier est très volumineux, il ne pourra pas rentrer dans le système de fichier, ce dernier étant composé d'un nombre limité de blocs, et les blocs étant eux même limité en nombre d'octets.

ReX : Je ne comprend pas ton problème. De tout façon comme dit plus haut, les 31744 blocs suivant le superbloc doivent contenir les données des fichiers.

Désolé de poser des questions peut être basique aussi tard, mais je pense qu'une fois que j'aurai ces réponses, cela ira beaucoup mieux pour la suite. Merci d'avance pour vos réponses.

ReX : Les questions sont effectivement triviales et il est effectivement inquiétant que voir que la travail n'avance pas.

Amine: merci pour vos corrections.

D'après votre commentaire "32768-1024=31744 blocs", j'en déduis qu'il faut que je modifie ma commande dd (qui est actuellement "dd if=/dev/zero of=filesystem.bin bs=256 count=31250" pour avoir le bon filesystem).

ReX : Je comprends pas d'où tu sors le 31250. D'autant plus que la commande ci-dessous est bonne.

Amine : 31250 car 31250 blocs * 256 octets = 8 Mo.

ReX : Haaaa je vois tu utilises le système métrique international où le mégaoctet vaut 10^6 octets, sauf qu'aucun informaticien n'utilisera cette norme hors sol. Quand je parle de 8 Mo c'est 8x1024x1024 octets. Tout simplement parce qu'une puce mémoire de 8 Mo c'est bien 8x1024x1024 octets.

Amine: D'accord merci pour l'information !

'''Nouvelle commande dd:'''

dd if=/dev/zero of=filesystem.bin bs=256 count=32768

=== Fonction LS version 2 ===

Dans notre structure du système de fichier, le superbloc est constitué de 1024 blocs (16 blocs * 64 fichiers), un fichier étant décrit par 16 blocs. Le nom du fichier est donc écrit au début de tous les blocs multiples de 16. Par exemple, le nom du premier fichier est dans les 16 premiers octets du premier bloc, le nom du 2ème fichier est dans les 16 premiers octets du 32ème bloc et ainsi de suite, tant que des fichiers existent. Lorsque qu'il n'y a plus de fichier, le nom du premier caractère du bloc multiple de 16 est un 0.

Voici le code:
// Fonction pour lister les noms de fichiers présents dans le système de fichiers
void LS() {
unsigned char buffer[BLOCK_SIZE];
int fileCount = 0;

for (int blockNum = 1; blockNum <= MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, BLOCK_SIZE);

// Vérifier si le bloc est vide
if (buffer[0] == 0) {
break; // Plus de fichiers à lire
}

char filename[MAX_FILENAME_LENGTH];
memcpy(filename, buffer, MAX_FILENAME_LENGTH);

// Afficher le nom du fichier
printf("%s\n", filename);
fileCount++;
}

if (fileCount == 0) {
printf("Aucun fichier trouvé.\n");
}
}

ReX : Tu supposes que si un fichier a un nom vide, les suivants auront aussi un nom vide. C'est possible mais dans ce cas la commande <code>RM</code> ca être plus compliquée à écrire.

ReX : Tu ne sembles pas comprendre que la mémoire d'un microcontrôleur est limitée. Pourquoi lire le premier bloc de description d'un fichier en entier ? Dit autrement c'est quoi l'intérêt de lire 256 octets alors que 16 suffisent ?

ReX : Pourquoi tu ne lis pas le premier fichier ? Autrement dit pourquoi décaler tout d'un bloc ?

Amine: Merci pour vos remarques. J'ai apporté les modifications à LS dans la section "Semaine 4" du wiki.

'''Réflexion par rapport aux autres fonctions:'''

J'ai créé les fonctions TYPE et CAT mais il y a malheureusement un problème pour l'instant. Vous pouvez les retrouver en pièce jointe dans l'archive du fichier programme.c.

Le problème que j'ai est que lorsque j'affiche le contenu du fichier créé avec TYPE, j'obtiens plein de caractères spéciaux. Par exemple, je créé le fichier "mon_fichier.txt" avec la fonction TYPE, et je mets en entré standard "hello". Ensuite, je veux afficher le contenu de ce fichier grâce à la fonction CAT. Cependant, ce qui s'affiche dans le terminal n'est pas ce que je veux. De la même manière, lorsque je fais la commande "cat filesystem.bin" dans le terminal, c'est la même chose s'affiche, des donnés parasites.

ReX : Avant même de lire ton code je vais te poser la question de savoir comment tu récupères un bloc libre ? Quel algorithme tu utilises. Personnellement je ne sais pas faire sans ajouter au superbloc un tableau bit à bit des blocs libres. Pour avoir un bit pour chaque bloc du système de fichiers, il faut 32768/8=4096 octets soit 16 blocs.

Amine: ok je vais donc ajouter ce tableau de 16 blocs à la suite de mes premiers 1024 blocs servant à la description de fichier. Le superbloc fera maintenant 1024+16=1040 blocs (plus de détail à la fonction RM de la semaine 4).

Question 1: est ce que la fonction CAT que je dois créer doit renvoyer la même chose que "cat filesystem.bin" ?

ReX : Je préfère ne pas répondre tellement la question montre un manque de réflexion.

Question 2: comment savoir combien de blocs doivent etre attribué à un fichier? Par exemple, si je créé un fichier "mon_fichier.txt" et que je mets en entrée standard le texte "hello", un seul bloc suffi pour stocker ce texte. Cependant, si j'avais mis beaucoup de texte en entrée standard, il aurait fallu plus de blocs. Doit-on calculer la taille de l'entrée standard ou doit-on attribuer toujours le meme nombre de blocs à un fichier? Peut-etre ainsi attribuer 2040 blocs par fichier, meme s'il n'en utilise que 1.

ReX : Là encore c'est une question stupéfiante tellement la réponse est évidente. Il suffit de lire les données sur l'entrée standard et de passer au bloc de données suivant dès que le bloc courant est rempli. La question à poser c'était de se demander comment il est possible d'avoir la taille exacte du fichier pour un <code>CAT</code>. Il est uniquement possible de l'avoir à 256 octets près puisque rien n'indique si le dernier block est vide. Le mieux aurait été de prévoir 4 octets dans la description d'un fichier pour stocker la taille. En l'espèce on considérera que les fichiers sont des fichiers ASCII et qu'ils seront terminés par des <code>\'0</code> qui ne seront pas affichés.

== Semaine 4 ==

Voici un bilan de ce que j'ai fait à ce stade du projet:

* j'ai choisi une structure du système de fichier
* j'ai créé les fonctions readBlock et writeBlock permettant de lire et d'écrire des blocs
* j'ai crée la fonction LS permettant d'afficher le nom des fichiers présents dans le système de fichiers
* j'ai programmer un main permettant d'utiliser les fonctions (LS, TYPE...) depuis le terminal
* j'ai réflechi aux fonctions TYPE et CAT.

Actuellement, je suis en train de créer les fonctions TYPE et CAT.

=== Fonction LS version 3 ===
void LS() {
unsigned char buffer[MAX_FILENAME_LENGTH];
int fileCount = 0;

// Parcourir tous les 16 blocs de 0 jusqu'à MAX_FILES_IN_DIRECTORY
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, MAX_FILENAME_LENGTH);

// Vérifier si le nom de fichier est vide
if (buffer[0] != 0) {

// Afficher le nom du fichier
printf("%s\n", buffer);
fileCount++;
}
}

if (fileCount == 0) {
printf("Aucun fichier trouvé.\n");
}
}
Suite à vos remarques, j'ai effectué les modifications suivantes de la fonction LS:

* Je ne suppose plus que si un fichier a un nom vide, les autres auront aussi un nom vide.
* Je ne lis plus les 256 octets mais seulement les 16 premiers octets car cela suffit.
* Je ne lisais en effet pas le premier bloc. Je pensais que le premier bloc était d'indice 1 mais ce n'est pas le cas.

ReX : Ouiiii ! Une fonction correcte. Passe à <code>RM</code> maintenant, c'est la plus facile à faire concernant l'image bit à bit des blocs libres.

=== Fonction setBlockAvailability version 1 ===

Comme vous l'avez indiqué dans votre remarque, il faut un tableau dans le superbloc qui nous permettra de connaitre la disponibilité bit par bit de chaque bloc. Sachant qu'il y a dans notre système de fichiers 32768 blocs, et qu'il faut 1 bit par bloc, nous avons besoin de 32768 bits, soit 32768/8=4096 octets soit 4096/256=16 blocs. Notre superbloc sera donc comme suit: les 1024 premiers blocs servent à la description des fichiers, c'est à dire à leur nom suivi des numéros de blocs qui leur sont associés, puis ces 1024 blocs sont suivi de 16 blocs listant la disponibilité de chaque bloc.

ReX : Bien résumé.

Nous allons tout d'abord écrire la fonction "setBlockAvailability" prenant en paramètre le numéro du bloc à traiter (<code>blockNum</code>) et la disponibilité souhaitée pour ce bloc (<code>availability</code>). Cette fonction permet de marquer la disponibilité d'un bloc spécifique dans le système de fichiers. Nous utiliserons la convention suivante: un bloc disponible sera marqué par un 1 tandis qu'un bloc non disponible par un 0.
#define SUPERBLOCK_START_BLOCK 1024

void setBlockAvailability(int blockNum, int availability) {
// Calculer l'index du byte et le bit offset correspondant
int byteIndex = blockNum / 8;
int bitOffset = blockNum % 8;

// Lire le byte existant du bloc de disponibilité des blocs
unsigned char buffer[1];
readBlock(SUPERBLOCK_START_BLOCK + byteIndex, 0, buffer, 1);

// Mettre à jour le bit d'offset correspondant
if (availability) {
buffer[0] |= (1 << bitOffset);
} else {
buffer[0] &= ~(1 << bitOffset);
}

// Écrire le byte mis à jour dans le bloc de disponibilité des blocs
writeBlock(SUPERBLOCK_START_BLOCK + byteIndex, 0, buffer, 1);
}

ReX : Un tableau de un octet c'est un octet (variable <code>buffer</code>).

Amine: je vais utiliser un <code>unsigned char buffer.</code> Je suis conscient qu'un char vaut un octet mais je ne pense pas qu'il y ait un type de donnée de la taille d'un bit, c'est pourquoi je travaille avec un octet mais je modifie les bits de cet octet grâce aux algorithmes.

ReX : Il faut bien que tu travailles sur un octet vu que l'état des blocs est stocké sous la forme d'octets. Je disais juste qu'un tableau de 1 élément n'a pas d'intérêt par rapport à l'élément lui-même.

Amine: c'est vrai, modification faite.

ReX : Non il faut calculer le numéro du bloc avant de faire le <code>readBlock</code>.

Amine: ok je vais calculer le numéro de bloc avant.

ReX : La mise à jour du bit est correcte mais le block et le déplacement dans le block ne sont pas correctement calculés.

Amine: je vais vous expliquer le raisonnement que j'avais. Prenons un exemple concret, imaginons que je veuille marquer le bloc 1030 comme disponible:

# Calcul de l'index de l'octet et du bit offset :
#* <code>blockNum</code> = 1030
#* Index du byte = 1030 / 8 = 128
#* Bit offset = 1030 % 8 = 6
# Lecture de l'octet existant de disponibilité:
#* Nous lisons l'octet existant à l'index 128 dans les blocs de disponibilité.
# Mise à jour du bit de disponibilité :
#* Nous voulons marquer le bloc 1030 comme disponible, donc nous utilisons le masque <code>(1 << 6)</code> pour définir le bit 6 à 1 dans l'octet. Le résultat sera, par exemple, <code>00100000</code>.
# Écriture du byte mis à jour :
#* Nous écrivons le byte mis à jour <code>00100000</code> à l'index 128 dans les blocs de disponibilité.

ReX : Ben non, un vrai exemple :
* Il faut prendre un n° de bloc plus grand : 3072 ;
* Numéro d'octet dans la carte des blocs libres : 3072/8=384 ;
* Numéro du bloc dans la carte des blocs libres : 384/256=1 ;
* Numéro du bit <code>b</code> dans l'octet n° 384-256=128 du bloc 1 : 3072%8=0 ;
* Il faut donc lire l'octet <code>o</code> de numéro 128 du bloc 1, puis modifier cet octet par <code>o |= (1<<b)</code> ou <code>o &= ~(1<<b)</code> ;
* Enfin il faut écrire l'octet modifié dans le bloc 1.
Amine: merci pour cet exemple! J'ai compris d'où vient mon erreur. Voir fonction setBlockAvailability version 3.

Remarque: par convention, j'apellerai dans la suite de ce projet "premier superbloc" le superbloc correspondant à la description des fichiers, c'est à dire les 1024 premiers blocs, et j'appellerai "second superbloc" les 16 blocs qui suivent servant à décrire la disponibilité des blocs (du bloc 1024 au bloc 1039 inclu). Le reste des blocs servira à stocker les données.

ReX : Non, le superblc est l'ensemble des informations hors blocs de données, tu ne peux pas utiliser un vocabulaire au hasard. Parle de blocs de description des fichiers ou de carte des blocs libres.

Amine: ok

Je pense que le problème qui se pose est que l'indice du bit dans le second superbloc ne correspond pas à l'indice du bloc dans le système de fichier. Par exemple, nous voudrions que si le bloc 1030 est disponible dans le système de fichier, alors le bit numéro 1030 du deuxième superbloc soit à 1, ce qui n'est pas le cas ici. En effet, on se trouve bien dans le bon octet avec ma méthode mais l'écriture du bit se fait de la droite vers la gauche alors qu'on voudrait l'inverse. Ainsi, si le 6ème bit de l'octet doit être à 1, alors il faudrait qu'on obtienne <code>00000100</code> et non <code>00100000.</code> L'indice du bit coinciderait ainsi avec le numéro du bloc.

ReX : Non, réfléchit à nouveau.

Voir plus bas la nouvelle version de setBlockAvailability.

Explication de l'algorithme pour mettre le bit à 1 ou 0:

* <code>buffer[0] |= (1 << bitOffset);</code> : Cette ligne utilise l'opérateur OR bit à bit (<code>|=</code>) pour activer (mettre à 1) le bit spécifié par <code>bitOffset</code> dans le premier octet (<code>buffer[0]</code>). Cela se fait en décalant le bit 1 vers la gauche de <code>bitOffset</code> positions, puis en effectuant une opération OR bit à bit avec le contenu actuel de <code>buffer[0]</code>. Cette opération modifie uniquement le bit ciblé, laissant les autres bits inchangés.

ReX : Oui ça c'est bon.

* <code>buffer[0] &= ~(1 << bitOffset);</code> : Cette ligne utilise l'opérateur AND bit à bit (<code>&=</code>) pour désactiver (mettre à 0) le bit spécifié par <code>bitOffset</code> dans <code>buffer[0]</code>. Pour ce faire, l'expression <code>~(1 << bitOffset)</code> est utilisée pour créer un masque où tous les bits sont à 1, sauf celui correspondant à <code>bitOffset</code>, qui est à 0. En effectuant ensuite une opération AND bit à bit entre le masque et le contenu actuel de <code>buffer[0]</code>, on met à 0 le bit ciblé sans affecter les autres bits.

ReX : Ca aussi.

=== Fonction setBlockAvailability version 2 ===

void setBlockAvailability(int blockNum, int availability) {
// Calculer l'indice de l'octet et le bit offset correspondant
int byteIndex = blockNum / 8;
int bitOffset = 7 - (blockNum % 8); // Inversion de l'ordre des bits

// Calculer le numéro du bloc du super bloc où se trouve l'octet de disponibilité correspondant
int availabilityBlockNum = SUPERBLOCK_START_BLOCK + byteIndex;

// Lire l'octet existant dans le bloc de disponibilité du super bloc
unsigned char buffer;
readBlock(availabilityBlockNum, 0, &buffer, 1);

// Mettre à jour le bit d'offset correspondant :
if (availability) {
buffer |= (1 << bitOffset);
} else {
buffer &= ~(1 << bitOffset);
}

// Écrire l'octet mis à jour dans le bloc de disponibilité du super bloc
writeBlock(availabilityBlockNum, 0, &buffer, 1);
}
J'ai modifié la ligne <code>int bitOffset = 7 - (blockNum % 8);</code> pour inverser l'ordre des bits sélectionnés, de sorte que le bit correspondant au bloc disponible soit correct.

ReX : Encore plus faux.

Si on veut rendre le bloc 1030 indisponible alors que les autres blocs sont disponibles:

ReX : Pardon ? Le bloc de données est libre ou pas suivant la carte des blocs libres. Le rendre disponible n'est possible que si un fichier le comportant est détruit.

# Calcul de l'indice de l'octet et du bit offset correspondant :
#* <code>blockNum = 1030</code>
#* <code>byteIndex = 1030 / 8 = 128</code>
#* <code>bitOffset = 7 - 1030 % 8 = 1</code> Cela signifie que le bit d'intérêt se trouve à la position 2 dans l'octet.
# Calcul du numéro du bloc du super bloc où se trouve l'octet de disponibilité correspondant :
#* <code>availabilityBlockNum = SUPERBLOCK_START_BLOCK + 128 = 1024 + 128 = 1152</code> Donc, nous devons accéder à l'octet 1152 pour mettre à jour la disponibilité du bloc 1030.
# Lecture de l'octet existant dans le bloc de disponibilité du super bloc :
#* Le contenu de l'octet dans le bloc 1152 avant la mise à jour : 11111111 (en binaire)
# Mise à jour du bit d'offset correspondant :
#* Supposons que nous voulions marquer le bloc 1030 comme non disponible (<code>availability = 0</code>).
#* Le bitOffset est 1.
#* Nous effectuons une opération AND avec le complément du bit à la position 1 : <code>11111111 & 11111101 = 11111101</code>
# Écriture de l'octet mis à jour dans le bloc de disponibilité du super bloc :
#* Le contenu de l'octet 128 du second superbloc après la mise à jour : 11111101 (en binaire)

ReX : Toujours aussi faux.

Maintenant, le bit d'indice 1 du 128 ème octet du second superbloc est mis à 0, indiquant que le bloc 1030 n'est plus disponible. Les autres bits restent inchangés car nous avons effectué un AND avec un masque binaire qui avait des 1 partout sauf à la position du bit que nous souhaitions mettre à 0.

ReX : Erreur sur erreur.

=== Fonction setBlockAvailability version 3 ===
J'ai compris d'où vient l'erreur. La fonction readBlock prends en premier paramètre le numéro du bloc à lire, je ne peux donc pas lui donner la valeur "SUPERBLOCK_START_BLOCK + byteIndex" car byteIndex s'exprime en octet alors qu'on s'attend à un nombre de bloc ici. Il faut donc divisé byteIndex par 256 pour être en unité "bloc", et préciser le bit qu'on veut lire grâce à l'offset.

Pour obtenir l'octet que l'on veut, il faut prendre le reste de la division de byteIndex par 256. On va ensuite stocker cet octet dans notre "buffer".

Pour savoir quel bit modifier dans ce "buffer", on va prendre le reste de la division du bloc dont on veut mettre à jour la disponibilité par 8. On va ainsi pouvoir modifier ce bit grâce à l'algorithme, puis réécrire l'octet à son emplacement d'origine.

Cette fonction gère la carte de disponibilités des blocs. Si un bloc est disponible, alors elle le met un 0, si il est indisponible, elle met un 1.
#define SUPERBLOCK_START_BLOCK 1024

void setBlockAvailability(int blockNum, int availability) {

int byteIndexInCard = blockNum / 8; //Numéro d'octet dans la carte des blocs libres
int blockIndexInCard = byteIndexInCard / 256; //Numéro du bloc dans la carte des blocs libres
int byteIndexInBlock = byteIndexInCard % 256; //Numéro d'octet dans le bloc contenant le bit de disponibilité
int bitOffset = blockNum % 8; //Numéro du bit dans l'octet n°byteIndexInBlock du bloc blockIndexInCard

//indice du bloc contenant le bit à mettre à jour dans le bloc de description
int availabilityBlockNum = FIRST_DISPONIBILITY_CARD_BLOCK + blockIndexInCard;

// Lire l'octet existant dans le bloc de disponibilité du super bloc
unsigned char buffer;
readBlock(availabilityBlockNum, byteIndexInBlock, &buffer, 1);

// Mettre à jour le bit d'offset correspondant :
if (availability==1) { // indisponible
buffer |= (1 << bitOffset); // Mettre le bit à 1

} else { // disponible
buffer &= ~(1 << bitOffset); // Mettre le bit à 0
}

// Écrire l'octet mis à jour dans le bloc de disponibilité du super bloc
writeBlock(availabilityBlockNum, byteIndexInBlock, &buffer, 1);
}

ReX : Ben voila, c'est pas possible de te taxer d'excès de vitesse mais c'est bon.

update: j'ai fait une petite modification, maintenant un bloc disponible est marqué d'un 0 et un bloc indisponible est marqué d'un 1. C'est mieux dans la mesure où initialement, tous les blocs sont disponibles et tous les blocs sont à 0. Cela évite de devoir créer une fonction qui initialise toute la carte de disponibilités à 1 pour dire que tous les blocs sont disponibles.

=== Fonction RM version 1 ===

void RM(const char *filesystem_path, const char *filename) {
unsigned char buffer[BLOCK_SIZE];
int fileNum = -1;

// Parcourir les blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (memcmp(filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {
// Effacer le nom du fichier dans le superbloc
memset(filenameBuffer, 0, MAX_FILENAME_LENGTH);
writeBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

unsigned char fileBuffer[MAX_BLOCKS_PER_FILE * 2];
readBlock(blockNum, MAX_FILENAME_LENGTH, fileBuffer, MAX_BLOCKS_PER_FILE * 2);

// Libérer les blocs associés au fichier et réinitialiser les numéros de blocs
for (int i = 0; i < MAX_BLOCKS_PER_FILE * 2; i += 2) {
int blockNum = ((int)fileBuffer[i] << 8) + (int)fileBuffer[i + 1];
if (blockNum == 0) {
break; // Fin du fichier
}
setBlockAvailability(blockNum, 0); // Marquer le bloc comme disponible
fileBuffer[i] = 0;
fileBuffer[i + 1] = 0;
}

// Mettre à jour les numéros de blocs associés au fichier
writeBlock(blockNum, MAX_FILENAME_LENGTH, fileBuffer, MAX_BLOCKS_PER_FILE * 2);

fileNum = blockNum;
break; // Fichier trouvé, sortir de la boucle
}
}

// Afficher le résultat de l'opération
if (fileNum == -1) {
printf("Le fichier \"%s\" n'a pas été trouvé.\n", filename);
} else {
printf("Le fichier \"%s\" a été supprimé avec succès.\n", filename);
}
}

ReX : Vous utilisez <code>strcmp</code> comme <code>strncmp</code>. C'est bien la dernière qu'il faut utiliser mais en précisant la longueur du nom en paramètre, pas la taille maximale.

Amine: vous voulez dire que j'utilise memcmp au lieu de strncmp ? Ok je vais utiliser strncmp, c'est vrai que c'est plus adapté pour la comparaison de chaines de caractère.

ReX : Ha oui c'est <code>memcmp</code> que tu utilises. Ca ne peut effectivement pas marcher. Effectivement avec <code>strncmp</code> cela peut marcher vu qu'il s'arrête au premier 0 contrairement à <code>memcmp</code>.

Cependant, pourquoi doit-on passer la taille exacte du nom du fichier en paramètre, et non la taille maximale d'un nom de fichier? En effet, cela semble fonctionner en mettant la taille maximale en paramètre, tandis que lorsque l'on met la taille exacte du nom du fichier, cela pose un problème: on ne compare plus toute la chaîne de caractère mais seulement une portion du nom complet. Ainsi, si je crée par exemple un fichier que j'appelle "file1", puis que j’exécute la fonction RM "/picofs filesystem.bin RM file" par exemple, alors le fichier file1 va être supprimé quand même car on ne comparera que strlen(file)=4 premiers caractères, qui sont les mêmes, donc la fonction considérera ces chaines comme identiques. On pourrait alors se dire qu'il faudrait alors prendre plutôt comme taille en paramètre de la fonction strlen la taille du nom du fichier se trouvant dans le système de fichier plutôt que celle du nom donné en paramètre de RM. Cependant, le même problème se pose si la taille du nom du fichier du système de fichier est plus petite que celle du nom du fichier passé en paramètre. Par exemple, si le fichier présent dans système de fichier est "file", et qu'on met la longueur de file en paramètre de la fonction strcmp, puis qu'on exécute la commande "/picofs filesystem.bin RM file5", alors file sera quand même supprimé, car on ne comparera que les strlen(file)=4 premiers caractère. Finalement, une solution serait de rajouter une condition qui vérifie que les deux chaînes sont de taille identiques pour pouvoir réaliser la comparaison sur la taille exacte du nom du fichier. Cependant, il me semble qu'en mettant MAX_FILENAME_LENGTH qui vaut 16 en paramètre, cela fonctionne directement. Vous pouvez tester cela en testant mon programme.

ReX : Ok pour <code>strncmp</code> avec la taille maximale d'un nom de fichier.

etape 1: créer un fichier :
./picofs filesystem.bin TYPE fichier.txt

etape 2: verifier que le fichier a bien été créé :
./picofs filesystem.bin LS

Le terminal renvoie bien "fichier.txt"

etape 3: essayer de supprimer le fichier en mettant une chaine troncature du nom du fichier créé :
./picofs filesystem.bin RM fich

le terminal renvoi <<Le fichier "fich" n'a pas été trouvé.>>, le fichier n'a donc pas été supprimé .

etape 4: essayer de supprimer le fichier en mettant un nom plus grand incluant "fichier.txt" :
./picofs filesystem.bin RM fichier.txtt

terminal renvoi <<Le fichier "fichier.txtt" n'a pas été trouvé.>>

etape 5: enfin, tester en mettant le nom exacte du fichier que l'on veut supprimer :
./picofs filesystem.bin RM fichier.txt

terminal renvoi <<Le fichier "fichier.txt" a été supprimé avec succès.>>

Finalement, on voit que cela fonctionne avec la taille maximale mise en paramètre. On pourrait reprocher à cette méthode de comparer des caractères dans le vide, ce qui n'est pas optimal dans une optique d'économie de mémoire qui est la notre, mais la taille maximale d'un nom de fichier étant relativement faible (16 octets), on peut peut-être négliger cela au vu de l'économie d'une opération supplémentaire (comparaison de la taille des chaines de caractères).

ReX : Le parcours des blocs de données du fichier est atroce. Il faut parcourir les numéros de blocs dans le premier bloc du fichier derrière le nom du fichier puis il faut parcourir le 15 autres blocs.

Amine: Ok, je vais corriger cela dans la version 2 de RM (voir semaine 5).

Fonctionnement de la fonction RM:

* Parcours des blocs réservés pour la description des fichiers (superbloc) à partir du bloc 0, en incrémentant de 16 à chaque itération pour accéder aux blocs de noms de fichiers.

ReX : OK.

* Dans chaque bloc de noms de fichiers, la fonction compare le nom de fichier recherché avec les noms stockés dans les 16 octets de chaque bloc.

ReX : Non la fonction ne fait pas ça par contre il faudrait, oui.

Amine: Je pensais que c'était ce que je faisais avec "memcmp(filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0)".

* Si le nom de fichier est trouvé, la fonction efface le nom du fichier dans le superbloc en remplaçant les 16 octets du bloc par des zéros.

ReX : OK.

* Ensuite, la fonction accède aux octets suivants du même bloc pour obtenir les numéros de blocs associés au fichier.

ReX : Non, la boucle sort largement du premier bloc.

* Pour chaque paire de numéros de blocs (2 octets chacun), la fonction convertit les octets en un numéro de bloc. Si le numéro de bloc est nul, cela signifie la fin des blocs associés au fichier, sinon, la fonction marque ce bloc comme disponible en utilisant la fonction <code>setBlockAvailability</code> et réinitialise les numéros de blocs dans le tableau à zéro.
* Les numéros de blocs réinitialisés sont ensuite réécrits dans le bloc de description du fichier.

ReX : L'idée est là mais vu que la boucle n'est pas bonne, rien ne peut marcher.

* La fonction affiche ensuite un message indiquant le résultat de l'opération : soit que le fichier a été supprimé avec succès, soit que le fichier n'a pas été trouvé.

== Semaine 5 ==

=== Fonction RM version 2 ===

Concernant les remarques que vous m'avez faites précédemment:

* j'utilise maintenant la fonction <code>strncmp</code> pour la comparaison des chaines de caractères
* j'ai normalement corrigé le parcours des blocs. Je parcours maintenant d'abord les blocs multiples de 16 à la recherche du bloc contenant le nom du fichier à supprimer. Puis je parcours les 16 blocs de description du fichier à supprimer, afin de récupérer les numéros de blocs, libérer ces blocs dans la carte de disponibilité et de réinitialiser ces blocs dans les blocs de données.

void RM(const char *filesystem_path, const char *filename) {
int fileFound = -1;
int offset;

// Parcourir les blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char*)filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {

// Effacer le nom du fichier dans le superbloc
memset(filenameBuffer, 0, MAX_FILENAME_LENGTH);
writeBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);
fileFound = 1;
offset = blockNum;
break;
}

}

// Fin de fonction si fichier inexistant
if (fileFound == -1) {
printf("Le fichier \"%s\" n'a pas été trouvé.\n", filename);
return;
}

unsigned char buffer[BLOCK_SIZE];
//bloc que l'on va remplir de 0 et mettre à la place des blocs de données
memset(buffer, 0, BLOCK_SIZE); //on rempli buffer de 0

for (int blockNum=offset; blockNum<offset + 16; blockNum++) {

//premier bloc de description, celui contenant le nom du fichier dans les 16 premiers octets
if (blockNum == offset) {

unsigned char fileBuffer[BLOCK_SIZE-MAX_FILENAME_LENGTH];
//bloc dans lequel on va stocker les blocs de description de fichier
readBlock(blockNum, MAX_FILENAME_LENGTH, fileBuffer, BLOCK_SIZE-MAX_FILENAME_LENGTH);

// Libérer les blocs associés au fichier dans la carte de disponibilités
// et dans les blocs de description
for (int i = MAX_FILENAME_LENGTH; i < BLOCK_SIZE-MAX_FILENAME_LENGTH; i += 2) {
int blockNumData = ((int)fileBuffer[i] << 8) + (int)fileBuffer[i + 1];
if (blockNumData == 0) {
break; // Fin du fichier
}
setBlockAvailability(blockNumData, 0); // Marquer le bloc comme disponible
fileBuffer[i] = 0;
fileBuffer[i + 1] = 0;
writeBlock(blockNumData, 0, buffer, BLOCK_SIZE); //on efface les blocs de données
}
writeBlock(blockNum, MAX_FILENAME_LENGTH, fileBuffer, BLOCK_SIZE-MAX_FILENAME_LENGTH);
//on efface le premier bloc de description

} else {
unsigned char fileBuffer[BLOCK_SIZE];
readBlock(blockNum, 0, fileBuffer, BLOCK_SIZE);

// Libérer les blocs associés au fichier dans la carte de disponibilités et dans les blocs de description
for (int i = 0; i < BLOCK_SIZE; i += 2) {
int blockNumData = ((int)fileBuffer[i] << 8) + (int)fileBuffer[i + 1];
if (blockNumData == 0) {
break; // Fin du fichier
}
setBlockAvailability(blockNumData, 0); // Marquer le bloc comme disponible
fileBuffer[i] = 0;
fileBuffer[i + 1] = 0;
writeBlock(blockNumData, 0, buffer, BLOCK_SIZE); //on efface les blocs de données
}
writeBlock(blockNum, 0, fileBuffer, BLOCK_SIZE); //on efface le bloc de description
}
}
printf("Le fichier \"%s\" a été supprimé avec succès.\n", filename);
}

ReX : Pour construire le nombre sur 16 bits utiliser le OU plutôt que l'addition.

ReX : Heu non, je ne lis pas cette fonction avec tout ce code dupliqué, la seule différence entre les deux alternative est la position de début de l'adresse du premier bloc de données (<code>MAX_FILENAME_LENGTH</code> dans un cas et 0 dans l'autre). Donc l'alternative ne doit servir qu'à initialiser ce début, le reste du code doit être factorisé.

ReX : Et corrige le code, tu utilises deux tableaux de blocs (perte mémoire), tu écris le bloc à zéro dans l'itération (perte CPU).

=== Fonction RM version 3 ===

Suite à vos remarques, j'ai réalisé les modifications suivantes:

* j'utilise maintenant le OU plutôt que l'addition pour construire le nombre sur 16 bits.

* j'ai factorisé le code grâce à la création de la variable <code>startOffset</code> valant 16 lorsqu'on se trouve dans le bloc contenant le nom du fichier et valant 0 lorsqu'on se trouve dans les autres.

* Pour ce qui est du fait que j'utilise 2 tableaux de blocs, j'ai du mal à voir comment faire avec 1 seul tableau de blocs car ces deux tableaux n'ont pas du tout le même rôle. Le tableau <code>fileBuffer</code> permet de stocker les 16 blocs de description d'un fichier un à un. Lorsqu'on stocke un bloc dans <code>fileBuffer</code>, on lit ensuite les octets un à un de ce bloc afin de former des numéros de blocs, et pour chaque numéro de bloc créé, on va réinitialiser le bloc correspondant dans les blocs de données. Pour cela, on a donc besoin d'un autre bloc qui viendra écraser les anciens blocs de données. C'est pourquoi j'ai créé un bloc <code>buffer</code>qui est composé de 0 et qui va écraser les blocs de données. On ne peut pas utiliser <code>fileBuffer</code> car on a besoin d'un bloc de zéros, et si on réinitialise <code>fileBuffer</code> on perd toute les données qui s'y trouvent. Une possibilité serait de relire le bloc de donné à chaque itération de la deuxième boucle for imbriquée; cela permettrait de pouvoir réinitialiser le tableau fileBuffer à chaque itérations de cette boucle afin de stocker ce bloc de 0 dans les blocs de données, puis de restocker dans ce même tableau le bloc de description. Cependant, je ne pense pas que ce soit optimal de faire autant appel à la fonction readBlock.

* j'ai créé une fonction resetBock qui permet comme son nom l'indique de reset un bloc en le remplissant de 0. Cela nous évite de créer deux tableaux de blocs dans RM, bien que je pense que cela revienne au même car on fait appel à une fonction qui créé un tableau de blocs. Quoi qu'il en soit, cela allège le code et cette fonction pourra surement me resservir par la suite.

void RM(const char *filesystem_path, const char *filename) {
int fileFound = -1;
int offset;
unsigned char fileBuffer[BLOCK_SIZE];

// Parcourir les blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char *)filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {
// Effacer le nom du fichier dans le superbloc
memset(filenameBuffer, 0, MAX_FILENAME_LENGTH);
writeBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);
fileFound = 1;
offset = blockNum;
break;
}
}

// Fin de fonction si fichier inexistant
if (fileFound == -1) {
printf("Le fichier \"%s\" n'a pas été trouvé.\n", filename);
return;
}

for (int blockNum = offset; blockNum < offset + 16; blockNum++) {
int startOffset = 0;
if (blockNum == offset) {
startOffset = MAX_FILENAME_LENGTH;
}
readBlock(blockNum, startOffset, fileBuffer, BLOCK_SIZE - startOffset);

// Libérer les blocs associés au fichier dans la carte de disponibilités et dans les blocs de description
for (int i = 0; i < BLOCK_SIZE - startOffset; i += 2) {
int blockNumData = (fileBuffer[i] << 8) | fileBuffer[i + 1];
if (blockNumData == 0) {
break; // Fin du fichier
}
setBlockAvailability(blockNumData, 0); // Marquer le bloc comme disponible
fileBuffer[i] = 0;
fileBuffer[i + 1] = 0;
resetBlock(blockNumData); //on efface les blocs de données
}
writeBlock(blockNum, startOffset, fileBuffer, BLOCK_SIZE - startOffset);
}
printf("Le fichier \"%s\" a été supprimé avec succès.\n", filename);
}
'''Fonction resetBlock'''
void resetBlock(unsigned int blockNum) {
unsigned char buffer[BLOCK_SIZE];
memset(buffer, 0, BLOCK_SIZE);

// Utiliser writeBlock pour écrire les données du buffer dans le bloc
writeBlock(blockNum, 0, buffer, BLOCK_SIZE);
}

ReX : Ca s'améliore. Mais pourquoi cette fonction <code>resetBlock</code> ? Tu crois que dans qu'un système de fichiers perd du temps à mettre à zéro les blocs de données libérés ? Si oui, regarde la page de manual de la commande <code>shred</code>, ça manque à ta culture.

Amine: Après avoir consulter le manual de la commande <code>shred</code>, je vois que cette commande écrit des données aléatoires sur l'emplacement du fichier sur le disque. Par défaut, <code>shred</code> effectue un certain nombre de passes (par exemple, 3 passes) pendant lesquelles il écrit des données aléatoires sur l'emplacement du fichier sur le disque. Après avoir écrit les données aléatoires, <code>shred</code> peut effectuer des passes supplémentaires pendant lesquelles il écrit des données nulles (des zéros) sur le même emplacement. L'objectif de <code>shred</code> est d'augmenter la sécurité en rendant plus difficile la récupération des données supprimées à l'aide d'outils de récupération de données.

Cependant, j'ai aussi consulté comment fonctionne la commande <code>rm</code> de linux, et je vois que cette commande libère l'espace occupé par le fichier en marquant les blocs associés comme disponibles. Cela signifie que les données peuvent encore être récupérées à l'aide d'outils de récupération de données, à moins que des mesures supplémentaires ne soient prises pour écraser physiquement l'espace avec des données aléatoires (c'est ce que fait l'utilitaire <code>shred</code>).

On va donc opter pour la deuxième option, c'est à dire qu'on ne va pas perdre notre temps à remettre à zéro les blocs de données libérés, on va simplement marquer les blocs correspondants comme étant disponibles. Cela nous permettra de nous émanciper de la fonction resetBlock et de n'avoir plus qu'un seul tableau de blocs.

ReX : Sinon lire un bloc complet de pointeurs de blocs de données en mémoire n'est pas forcément optimal. L'idéal serait de lire ces blocs morceau par morceau (de 64 octets par exemple). Certes un bloc serait traité en 4 lectures/écritures (ce qui ralentirait le traitement) mais on gagne en mémoire. Le mieux serait de mettre la taille des morceaux en constante pour pouvoir choisir entre vitesse d'exécution et utilisation mémoire.

Amine: d'accord je comprends. Je vais modifier la fonction pour qu'on puisse découper la lecture/écriture en plusieurs blocs.

=== Fonction RM version 4 ===
Modifications apportées:

* je ne réinitialise plus les blocs de données, je supprime simplement le pointeur du fichier vers les blocs de données et je désigne les blocs comme "disponible" dans le carte de disponibilités. J'ai donc supprimé la fonction resetBlock.

* je ne lis plus les blocs en une seule fois mais en plusieurs fois via la variable CHUNK_SIZE:

# J'ai introduit la constante <code>CHUNK_SIZE</code> pour définir la taille de chaque morceau que nous allons lire/écrire à la fois. Cela permet de découper les opérations en blocs plus petits.
# Dans la boucle <code>for</code> où on parcours les blocs à partir de <code>offset</code>, j'ai ajouté une boucle interne qui parcourt les données du bloc en morceaux de taille <code>CHUNK_SIZE</code>.
# À l'intérieur de la boucle interne, j'ai calculé la taille réelle du morceau (<code>chunkSize</code>) en prenant le minimum entre <code>CHUNK_SIZE</code> et la quantité de données restant à lire/écrire dans le bloc.
# J'ai modifié la fonction <code>readBlock</code> pour lire seulement la quantité de données spécifiée par <code>chunkSize</code> à partir de <code>chunkStart</code>. Ces données sont stockées dans le tableau <code>fileBuffer</code>.
# Ensuite, j'ai effectué les mêmes opérations de libération des blocs associés au fichier, en parcourant les données du morceau et en marquant les blocs comme disponibles.
# Finalement, j'ai utilisé la fonction <code>writeBlock</code> pour écrire le morceau de données modifié dans le bloc, en utilisant la même <code>chunkStart</code> pour déterminer où écrire les données.

#define CHUNK_SIZE 64

int min(int a, int b) {
return a < b ? a : b;
}

void RM(const char *filesystem_path, const char *filename) {
int fileFound = -1;
int offset;
unsigned char fileBuffer[BLOCK_SIZE];

// Parcourir les blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char *)filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {
// Effacer le nom du fichier dans le superbloc
memset(filenameBuffer, 0, MAX_FILENAME_LENGTH);
writeBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);
fileFound = 1;
offset = blockNum;
break;
}
}

// Fin de fonction si fichier inexistant
if (fileFound == -1) {
printf("Le fichier \"%s\" n'a pas été trouvé.\n", filename);
return;
}

for (int blockNum = offset; blockNum < offset + 16; blockNum++) {
int startOffset = 0;

if (blockNum == offset) {
startOffset = MAX_FILENAME_LENGTH;
}

for (int chunkStart = startOffset; chunkStart < BLOCK_SIZE; chunkStart += CHUNK_SIZE) {
int chunkSize = min(CHUNK_SIZE, BLOCK_SIZE - chunkStart);
readBlock(blockNum, chunkStart, fileBuffer, chunkSize);

for (int i = 0; i < chunkSize; i += 2) {
int blockNumData = (fileBuffer[i] << 8) | fileBuffer[i + 1];
if (blockNumData == 0) {
writeBlock(blockNum, chunkStart, fileBuffer, chunkSize);
printf("Le fichier \"%s\" a été supprimé avec succès.\n", filename);
return; // Sortir des boucles
}
setBlockAvailability(blockNumData, 0); // Marquer le bloc comme disponible
fileBuffer[i] = 0;
fileBuffer[i + 1] = 0;
}

writeBlock(blockNum, chunkStart, fileBuffer, chunkSize);
}
}

printf("Le fichier \"%s\" a été supprimé avec succès.\n", filename);
}

ReX : Si on trouve un n° de bloc de données à 0, il faut sortir des deux boucles les plus externes après avoir fait le <code>writeBlock</code>.

Amine: Modification faites ci-dessus. Maintenant, dès qu'on trouve un n° de bloc de données à 0 dans la boucle la plus interne, on effectue le <code>writeBlock</code> et ensuite on utilise <code>return</code> pour sortir des deux boucles les plus externes. Cela permet d'optimiser le code en évitant de continuer à traiter inutilement le reste des blocs.

ReX : Pas très propre (duplication de code) mais nous allons nous en contenter.

=== Fonction intermédiaire TYPE version 1 ===

J'ai également commencé à réfléchir à la fonction TYPE. Pour l'instant, elle ne fait qu'ajouter les noms de fichier dans le superbloc. Cela permet de pouvoir tester les fonctions LS et RM (voir dans la rubrique compilation et exécution comment utiliser le programme).
// Fonction pour créer un fichier avec le nom donné et le contenu fourni en entrée standard
void TYPE(const char *filesystem_path, const char *filename) {
unsigned char buffer[MAX_FILENAME_LENGTH];
// Parcours des blocs réservés pour la description des fichiers
for (int blockNum = 0; blockNum <= MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, MAX_FILENAME_LENGTH);
// Vérifier si le bloc est vide (pas de nom de fichier)
if (buffer[0] == 0) {
// Écrire le nom du fichier dans l'emplacement vide du superbloc
writeBlock(blockNum, 0, (const unsigned char *)filename, MAX_FILENAME_LENGTH);
break; // Fichier créé, sortir de la boucle
}
}
printf("Le fichier \"%s\" a été créé avec succès.\n", filename);
}

ReX : Si la boucle se termine sans trouver de slot libre le message de succès s'affiche tout de même.

ReX : Le paramètre <code>filename</code> n'a pas forcément une taille de <code>MAX_FILENAME_LENGTH</code>.

Selon moi, la fonction TYPE devra respecter 3 étapes:

# Enregistrement du Nom du Fichier: L'ajout du nom du fichier dans un des blocs de la première partie du superbloc.
# Stockage des Données du Fichier: La récupération des données saisies en entrée standard par l'utilisateur et leur stockage dans des blocs du système de fichiers à partir d'une certaine position, comme le bloc 1040.
# Mise à Jour de la Disponibilité des Blocs: L'indication que les blocs dans lesquels les données ont été écrites ne sont plus disponibles en modifiant les bits correspondants dans la deuxième partie du superbloc (les 16 derniers blocs du super bloc).

ReX : Relis le point 3 et dit moi si tu te comprends toi même ?

Amine: Ma phrase n'est effectivement pas très claire. Je voulais dire que la fonction TYPE devra mettre à jour la carte de disponibilité du superbloc. C'est à dire que lorsqu'elle écrira des données dans des blocs, elle devra indiquer dans la carte de disponibilités que ces blocs ne sont plus disponibles.

=== Fonction intermédiaire TYPE version 2 ===

Suite à vos remarques, j'ai apporté les modifications suivantes à la fonction TYPE:

* j'ai ajouté une condition pour l'affichage du message de succès de la création d'un fichier (placeFound).

* le paramètre <code>filename</code> n'ayant pas forcément une taille de <code>MAX_FILENAME_LENGTH</code>, je calcule maintenant la longueur de filename, afin d'écrire seulement le nom du fichier avec la fonction writeBlock.

Il fonction n'est bien évidemment pas fini, elle ajoute seulement le nom du fichier dans le superbloc pour l'instant. Cela me permet de tester les fonctions LS et RM.
void TYPE(const char *filesystem_path, const char *filename) {
size_t sizeFilename = strlen(filename);
printf("size filename=%d\n", sizeFilename);
unsigned char buffer[MAX_FILENAME_LENGTH];
int placeFound = 0;

if (sizeFilename > MAX_FILENAME_LENGTH) {
printf("Impossible de créer le fichier, nom trop long\n");
return;
}

// Parcours des blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, MAX_FILENAME_LENGTH);
// Vérifier si le bloc est vide (pas de nom de fichier)
if (buffer[0] == 0) {
// Écrire le nom du fichier dans l'emplacement vide du superbloc
if (sizeFilename < MAX_FILENAME_LENGTH) {
sizeFilename+=1;
}
writeBlock(blockNum, 0, (const unsigned char *)filename, sizeFilename);
placeFound = 1;
break; // Fichier créé, sortir de la boucle
}
}
if (placeFound == 1) {
printf("Le fichier \"%s\" a été créé avec succès.\n", filename);
} else {
printf("Plus de place dans le système de fichier pour créer ce fichier.\n", filename);
}
}

ReX : Mieux, attention il faut copier aussi le <code>\'0</code> final du nom, donc <code>sizeFilename+1</code>. Sinon tu n'es pas sûr qu'il y ait un zéro final. Et attention n°2, il ne faut pas copier ce <code>\'0</code> si le nom fait la taille maximale.

Amine: ok j'ai modifié la fonction TYPE ci-dessus. J'ai ajouté une condition: si le nom du fichier est inférieur à la taille maximale de nom de fichier, alors on incrémente de 1 la taille du nom de fichier. Cela nous permet d'écrire le '\0' dans le bloc de description. Dans le cas où le nom du fichier est de la taille maximale, nous n'avons pas besoin d'écrire le '\0', on n'incrémente donc pas la taille de 1.

J'ai également ajouté une condition: si le nom du fichier est supérieur à la taille maximale, alors un message d'erreur s'affiche et le fichier n'est pas créé.

ReX : OK. L'embryon de fonction <code>TYPE</code> est correct, il manque juste le principal : la création des blocs de données.

=== Fonction MV version 1 ===

J'ai ici créé la fonction MV qui permet de changer le nom d'un fichier. Pour ce faire, la fonction parcourt les blocs de descriptions à la recherche du fichier dont on veut changer le nom. Lorsque ce fichier est trouvé, on supprime l'ancien nom en mettant des 0 sur 16 octets, puis on vient réécrire le nouveau nom dans le même emplacement. Enfin, on sort de la boucle et on affiche le succès ou non de l'opération.
// Fonction qui modifie le nom du fichier
void MV(const char *filesystem_path, const char *old_filename, const char *new_filename) {
size_t sizeNew_filename = strlen(new_filename);
size_t sizeOld_filename = strlen(old_filename);
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
int fileFound = 0;
// Parcourir les blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);
// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char*)filenameBuffer, old_filename, MAX_FILENAME_LENGTH) == 0) {
// Effacer le nom du fichier dans le superbloc
memset(filenameBuffer, 0, MAX_FILENAME_LENGTH);
writeBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);
// Écrire le nom du fichier dans l'emplacement
writeBlock(blockNum, 0, (const unsigned char *)new_filename, sizeNew_filename);
fileFound=1;
break; // Nom modifié, sortir de la boucle
}
}
if (fileFound == 1) {
printf("Le nom du fichier \"%s\" a été renommé avec succès.\n", old_filename);
} else {
printf("Le fichier \"%s\" n'a pas été trouvé.\n", old_filename);
}
}

ReX : Inutile d'écraser l'ancien nom avec des zéros. Il suffit de copier le nouveau en s'assurant qu'il y ait un zéro final sauf si le nouveau nom fait la taille maximale.

Amine: ok, je vais faire les modifications dans la version 2.

== Semaine 6 ==

=== Fonction MV version 2 ===
Dans cette nouvelle version de la fonction MV, j'ai effectué les modifications suivantes:

* je n'écrase plus l'ancien nom avec des 0
* Je colle simplement le nouveau nom par dessus l'ancien, en m'assurant qu'il y ait bien le '\0' à la fin lorsque la taille du nom du fichier est inférieur à la taille maximale. Comme précédemment, afin de m'assurer de la présence de ce '\0' à la fin du nom, j'incrémente la taille de 1 lorsque qu'elle est inférieur à la taille max. Cependant, je ne suis pas sûr à 100% que ce soit la bonne manière de faire.

// Fonction qui modifie le nom du fichier
void MV(const char *filesystem_path, const char *old_filename, const char *new_filename) {
size_t sizeNew_filename = strlen(new_filename);
size_t sizeOld_filename = strlen(old_filename);
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
int fileFound = 0;

// Parcourir les blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {

readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char*)filenameBuffer, old_filename, MAX_FILENAME_LENGTH) == 0) {

if (sizeNew_filename < MAX_FILENAME_LENGTH) {
sizeNew_filename+=1;
}

// Écrire le nom du fichier dans l'emplacement
writeBlock(blockNum, 0, (const unsigned char *)new_filename, sizeNew_filename);

fileFound=1;

break; // Nom modifié, sortir de la boucle
}
}
if (fileFound == 1) {
printf("Le nom du fichier \"%s\" a été renommé avec succès.\n", old_filename);
} else {
printf("Le fichier \"%s\" n'a pas été trouvé.\n", old_filename);
}
}

ReX : C'est bon. La fonction était triviale.

=== Fonction TYPE version 1 ===
void TYPE(const char *filesystem_path, const char *filename) {
size_t sizeFilename = strlen(filename);
unsigned char buffer[MAX_FILENAME_LENGTH];
int placeFound = -1;

if (sizeFilename > MAX_FILENAME_LENGTH) {
printf("Impossible de créer le fichier, nom trop long\n");
return;
}

// Parcours des blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, MAX_FILENAME_LENGTH);
// Vérifier si le bloc est vide (pas de nom de fichier)
if (buffer[0] == 0) {
// Écrire le nom du fichier dans l'emplacement vide du superbloc
if (sizeFilename < MAX_FILENAME_LENGTH) {
sizeFilename += 1; // Ajouter '\0' s'il y a de la place
}
writeBlock(blockNum, 0, (const unsigned char *)filename, sizeFilename);
placeFound = blockNum;

// Lire les données depuis l'entrée standard
unsigned char dataBuffer[BLOCK_SIZE];
size_t bytesRead;
int dataBlockNum = findAvailableBlock(); // Premier bloc de données à partir du bloc 1040
printf("dataBlockNum%d\n",dataBlockNum);
int blockSizeUsed = 0; // Compteur d'octets dans le bloc actuel
int dataBlocksNeeded = 1; // Nombre de blocs de données nécessaires

while ((bytesRead = fread(dataBuffer + blockSizeUsed, 1, BLOCK_SIZE - blockSizeUsed, stdin)) > 0) {
blockSizeUsed += bytesRead;

// Si le bloc actuel est plein, passer au bloc suivant
if (blockSizeUsed == BLOCK_SIZE) {
// printf("dataBlockNum=%d\n",dataBlockNum);
writeBlock(dataBlockNum, 0, dataBuffer, BLOCK_SIZE);
setBlockAvailability(dataBlockNum, 1);

dataBlockNum++; // Passer au bloc suivant
blockSizeUsed = 0; // Réinitialiser la taille utilisée
dataBlocksNeeded++;
}
}

// Écrire le dernier bloc partiel, s'il y en a un
if (blockSizeUsed > 0) {
writeBlock(dataBlockNum, 0, dataBuffer, blockSizeUsed);
setBlockAvailability(dataBlockNum, 1);
}

// Écrire les numéros de blocs utilisés dans le bloc de description
unsigned char blockNumberBuffer[2];
int currentBlockNum = 1040;

for (int i = 0; i < dataBlocksNeeded; i++) {
blockNumberBuffer[0] = (currentBlockNum >> 8) & 0xFF;
blockNumberBuffer[1] = currentBlockNum & 0xFF;
writeBlock(placeFound, MAX_FILENAME_LENGTH + i * 2, blockNumberBuffer, 2);
currentBlockNum++;
}

break; // Fichier créé, sortir de la boucle
}
}

if (placeFound != -1) {
printf("Le fichier \"%s\" a été créé avec succès.\n", filename);
} else {
printf("Plus de place dans le système de fichier pour créer ce fichier.\n");
}
}

ReX : La constante 1040 ne doit pas apparaître en numérique, ce doit être une constante calculée à partir des autres constantes.

Amine: Ok. Je ne l'avais pas défini comme une constante car il s'agit dans la fonction ci-dessus d'une variable qui est incrémenté à chaque itération.

ReX : Je suis las de te répéter que le mémoire est comptée : tu utilises encore un bloc de <code>BLOCK_SIZE</code> octets, c'est trop.

Amine: Comment utiliser des blocs plus petit sachant qu'il s'agit là de blocs de données et qu'un bloc fait 256 octets d'après l'énoncé ? Dois-je les subdiviser en plusieurs blocs plus petit comme fait dans la fonction RM, en 4 blocs de 64 octets par exemple ?

Fonctionnement de la fonction TYPE:

* étape 1: on parcourt les blocs de descriptions à la recherche d'un bloc disponible. Si on ne trouve pas de bloc disponible, on renvoie un message d'erreur, sinon on passe à l'étape suivante.
* étape 2: Si on trouve un emplacement libre dans les blocs de disponibilité, on écrit le nom du fichier dans cet emplacement.

ReX : Dans les blocs de description de fichiers pas dans les blocs de disponibilité.

Amine: Oui autant pour moi.

* étape 3: Ensuite, on lit le texte entré par l'utilisateur en entrée standard, on le répartit dans des blocs de taille BLOCK_SIZE, on met à jour la disponibilité des blocs utilisés.

ReX : Non, il faut appeler <code>findAvailableBlock</code> pour chaque bloc de données à utiliser, aucune certitudes que les blocs libres soient en séquence.

Amine: ok, je ferai cela dans la version 2

* étape 4: Enfin, on écrit les numéros des blocs de données utilisés dans les blocs de description de ce fichier, les numéros étant écris sur deux octets.

ReX : Non cela doit se faire au fur et à mesure des appels à <code>findAvailableBlock</code> et les numéros des blocs de données peuvent s'étaler sur les 16 blocs de description du fichier. Confusion totale sur ce point. Vous n'avez pas compris le mécanisme.

Amine: je corrige cela dans la version 2. J'ai bien compris le mécanisme mais ce n'est pas facile à traduire en code.

=== Fonction TYPE version 2 ===
Dans cette nouvelle version de TYPE, j'ai fait les modifications suivantes:

* j'appelle maintenant <code>findAvailableBlock</code> pour chaque bloc de données à utiliser
* j'écris maintenant les numéros de blocs au fur et à mesures des appels à <code>findAvailableBlock</code>
* je n'utilise plus de tableaux de taille 256 octets mais des tableaux de tailles CHUNK_SIZE. J'ai choisi ici CHUNK_SIZE = 64 octets.

J'utilise toujours un bloc de taille BLOCK_SIZE en attendant de comprendre si je dois diviser ce bloc en plusieurs blocs de taille plus petite ou s'il y a un moyen de ne pas du tout utiliser ces blocs.
void TYPE(const char *filesystem_path, const char *filename) {
size_t sizeFilename = strlen(filename);
unsigned char buffer[MAX_FILENAME_LENGTH];
int placeFound = -1;

if (sizeFilename > MAX_FILENAME_LENGTH) {
printf("Impossible de créer le fichier, nom trop long\n");
return;
}

// Parcours des blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, MAX_FILENAME_LENGTH);
// Vérifier si le bloc est vide (pas de nom de fichier)
if (buffer[0] == 0) {
// Écrire le nom du fichier dans l'emplacement vide du superbloc
if (sizeFilename < MAX_FILENAME_LENGTH) {
sizeFilename += 1; // Ajouter '\0' s'il y a de la place
}
writeBlock(blockNum, 0, (const unsigned char *)filename, sizeFilename);
placeFound = blockNum;

// Lire les données depuis l'entrée standard et écrire dans le fichier
int dataBlockNum = findAvailableBlock(); // Premier bloc de données à partir du bloc 1040
printf("Premier bloc dans lequel on écrit = %d\n", dataBlockNum);
int blockSizeUsed = 0; // Compteur d'octets dans le bloc actuel

unsigned char chunkBuffer[CHUNK_SIZE];
size_t bytesRead;

while ((bytesRead = fread(chunkBuffer, 1, CHUNK_SIZE, stdin)) > 0) {
// Écrire le chunk dans le bloc de données
writeBlock(dataBlockNum, blockSizeUsed, chunkBuffer, bytesRead);
setBlockAvailability(dataBlockNum, 1);

// Écrire le numéro du bloc actuel dans la description du fichier
unsigned char blockNumberBuffer[2];
blockNumberBuffer[0] = (dataBlockNum >> 8) & 0xFF;
blockNumberBuffer[1] = dataBlockNum & 0xFF;
writeBlock(placeFound, MAX_FILENAME_LENGTH + dataBlockNum * 2, blockNumberBuffer, 2);

blockSizeUsed += bytesRead;

// Si le bloc actuel est plein, passer au bloc suivant
if (blockSizeUsed == BLOCK_SIZE) {
dataBlockNum = findAvailableBlock(); // Passer au bloc suivant
blockSizeUsed = 0; // Réinitialiser la taille utilisée
}
}

break; // Fichier créé, sortir de la boucle
}
}

if (placeFound != -1) {
printf("Le fichier \"%s\" a été créé avec succès.\n", filename);
} else {
printf("Plus de place dans le système de fichier pour créer ce fichier.\n");
}
}

=== Fonction findAvailableBlock ===
Cette fonction renvoie l'indice du premier bloc disponible. Je me sers de cette fonction dans la fonction TYPE.
#define FIRST_DATA_BLOCK 1040
#define FIRST_DISPONIBILITY_CARD_BLOCK 1024

// Renvoie le premier bloc de donné disponible
int findAvailableBlock() {
unsigned char availabilityBuffer[BLOCK_SIZE];
int offset;

// Lire la carte de disponibilité (à partir du bloc 1)
for (int blockNum = FIRST_DISPONIBILITY_CARD_BLOCK; blockNum < FIRST_DATA_BLOCK; blockNum++) {
readBlock(blockNum, 0, availabilityBuffer, BLOCK_SIZE);

if (blockNum==FIRST_DISPONIBILITY_CARD_BLOCK) {
offset=FIRST_DATA_BLOCK/8;
} else {
offset=0;
}

// Parcourir les octets de la carte de disponibilité
for (int byteIndex = offset; byteIndex < BLOCK_SIZE - offset; byteIndex++) {
unsigned char byte = availabilityBuffer[byteIndex];

// Parcourir les bits de chaque octet
for (int bitIndex = 0; bitIndex < 8; bitIndex++) {
// Vérifier si le bit est à 0 (bloc disponible)
if ((byte & (1 << bitIndex)) == 0) {
// Calculer l'indice du bloc en fonction du bloc et du bit
int blockIndex = byteIndex * 8 + bitIndex;
return blockIndex;
}
}
}
}

// Aucun bloc disponible trouvé
return -1;
}

ReX : Même remarque que précédement sur les nombres 1024 et 1040.

Amine: Ok, j'ai remplacé 1024 par la constante FIRST_DISPONIBILITY_CARD_BLOCK et 1040 par la constante FIRST_DATA_BLOCK dans la fonction ci-dessus.

ReX : Vous n'avez toujours pas compris la contrainte sur la mémoire.

Amine: dois-je découper le bloc de taille BLOCK_SIZE en quatre blocs de taille 64 octets par exemple ?

ReX : Je ne vois pas ce que vous voulez faire avec <code>if (blockNum==1024) offset=1040/8; else offset=0;</code>.

Amine: dans la carte de disponibilité, chaque bit correspond à un bloc. Ainsi, les bits de 0 à 1040 dans la carte de disponibilité décrivent la disponibilité des blocs 0 à 1040. Or ces blocs correspondent au superbloc, et dans cette fonction, on veut connaître le premier bloc de données disponible. On ne s'intéresse donc pas au 1040 premiers bits de la carte de disponibilité. Je crée donc un offset égal à 1040/8 afin de ne pas prendre en compte les 1040 premiers bits soit les 1040/8=130 premiers octets. Cet offset ne s'applique que lorsqu'on se trouve dans le premier des 16 blocs de la carte de disponibilité, d'où la condition <code>if (blockNum==1024)</code>.

=== Fonction CAT version 1 ===
void CAT(const char *filesystem_path, const char *filename) {
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
unsigned char buffer[BLOCK_SIZE];
unsigned char blockNumberBuffer[2];
unsigned char dataBuffer[BLOCK_SIZE];
int offset;

// Parcours des blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char *)filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {
// Le nom du fichier a été trouvé

// Parcours les blocs de description
for (int descrBlockNum=0; descrBlockNum<MAX_BLOCKS_PER_FILE_DESCRIPTION; descrBlockNum++) {
if (descrBlockNum==0) {
offset=16;
} else {
offset=0;
}
readBlock(descrBlockNum+blockNum, offset, buffer, BLOCK_SIZE-offset);

// Lire les numéros de blocs associés à ce fichier depuis les blocs de description
unsigned char octet1 = buffer[offset];
unsigned char octet2 = buffer[offset+1];

int dataBlockNum = (octet1 << 8) | octet2;
printf("dataBlockNum=%d\n",dataBlockNum);

// Vérifier si le numéro de bloc est valide (non nul)
if (dataBlockNum == 0) {
return; // Fin du fichier
}

// Lire et afficher le contenu du bloc de données
readBlock(dataBlockNum, 0, dataBuffer, BLOCK_SIZE);
fwrite(dataBuffer, 1, BLOCK_SIZE, stdout);
}

return; // Fichier affiché, sortie de la fonction
}
}

// Si le fichier n'a pas été trouvé
printf("Le fichier \"%s\" n'a pas été trouvé.\n", filename);
}

ReX : Encore mieux : deux blocs de <code>BLOCK_SIZE</code> en mémoire.

ReX : Le <code>break</code> ne sort pas de la boucle externe.

Amine: Oui c'est vrai. J'ai remplacé le break pas un return ci-dessus.

Voici ma fonction <code>CAT</code>. Elle fonctionne en plusieurs étape:

* étape 1: on cherche dans les blocs de descriptions si le fichier dont on veut afficher le contenu existe. Si le nom de fichier est trouvé, on passe à l'étape 2. Sinon, on renvoie un message d'erreur.
* étape 2: si le fichier est trouvé, on parcours les 16 blocs de description de ce fichier.
* étape 3: grâce aux opérations de masquage et de décalage, on joint les octets deux par deux pour former un entier qui contient le numéro du bloc de données correspondant au fichier. Si cet entier vaut 0, alors cela signifie qu'il n'y a plus de blocs associé à ce fichier, on peut donc quitter la fonction. Si cet entier est différent de 0, alors on va lire le bloc correspondant à ce numéro et on affiche son contenu dans le terminal.

== Semaine 7 ==

=== Fonction CP version 1 ===
Voici ma fonction CP, qui permet de créer une copie d'un fichier existant. L'idée est la suivante: pour copier un fichier, on doit créer un nouveau fichier et lui attribuer les mêmes blocs de descriptions que le fichier source. Ainsi, le fichier source et le fichier destination pointeront vers les mêmes blocs de données, et auront le même contenu.

ReX : Perdu. Ce n'est absolument pas la fonction de copie de fichiers d'un système de fichiers.

Amine: Après avoir fait des recherches et après réflexion, je me rends compte que cette fonction CP présente un problème: en faisant pointé les blocs de données du fichier destination vers ceux du fichier source, toutes modifications du fichier source impactera le fichier destination, or ce n'est pas ce qu'on veut faire. Je vous propose donc une nouvelle version de la fonction CP ci-dessous qui remédie à ce problème.

void CP(const char *filesystem_path, const char *source_filename, const char *destination_filename) {
unsigned char source_filenameBuffer[MAX_FILENAME_LENGTH];
unsigned char destination_filenameBuffer[MAX_FILENAME_LENGTH];
unsigned char descriptionBuffer[BLOCK_SIZE];
int destination_offset;
int offset;

// Recherche du fichier source
int source_offset = -1;
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, source_filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier source
if (strncmp((const char *)source_filenameBuffer, source_filename, MAX_FILENAME_LENGTH) == 0) {
source_offset = blockNum;
break;
}
}

if (source_offset == -1) {
printf("Le fichier source \"%s\" n'a pas été trouvé.\n", source_filename);
return;
}

// Recherche d'un emplacement libre pour le fichier destination
destination_offset = -1;
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, destination_filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc est vide (pas de nom de fichier)
if (destination_filenameBuffer[0] == 0) {
destination_offset = blockNum;
break;
}
}

if (destination_offset == -1) {
printf("Plus de place dans le système de fichier pour créer la copie de \"%s\".\n", source_filename);
return;
}

// Ecrit le nom de la copie dans le bloc de description
writeBlock(destination_offset, 0, (const unsigned char *)destination_filename, strlen(destination_filename));

// Copier les blocs de description associés au fichier source dans les blocs de description du fichier destination
for (int i = 0; i < MAX_BLOCKS_PER_FILE_DESCRIPTION; i++) {
if (i==0) {
offset = MAX_FILENAME_LENGTH;
} else {
offset = 0;
}

readBlock(source_offset+i, offset, descriptionBuffer, BLOCK_SIZE-offset);
if (descriptionBuffer[offset]==0) {
return;
} else {
writeBlock(destination_offset+i, offset, descriptionBuffer, BLOCK_SIZE-offset);
}
}

printf("La copie de \"%s\" sous le nom \"%s\" a été créée avec succès.\n", source_filename, destination_filename);
}

=== Fonction CP version 2 ===
Voici une version mise à jour de notre fonction CP qui duplique réellement les blocs de données du fichier source vers le fichier de destination. Cela implique d'attribuer de nouveaux blocs de données au fichier de destination et de mettre à jour la carte de disponibilité des blocs.
void CP(const char *filesystem_path, const char *source_filename, const char *destination_filename) {
unsigned char source_filenameBuffer[MAX_FILENAME_LENGTH];
unsigned char destination_filenameBuffer[MAX_FILENAME_LENGTH];
unsigned char descriptionBuffer[BLOCK_SIZE];
int destination_offset;
int source_offset;

// Recherche du fichier source
source_offset = -1;
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, source_filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier source
if (strncmp((const char *)source_filenameBuffer, source_filename, MAX_FILENAME_LENGTH) == 0) {
source_offset = blockNum;
break;
}
}

if (source_offset == -1) {
printf("Le fichier source \"%s\" n'a pas été trouvé.\n", source_filename);
return;
}

// Recherche d'un emplacement libre pour le fichier destination
destination_offset = -1;
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, destination_filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc est vide (pas de nom de fichier)
if (destination_filenameBuffer[0] == 0) {
destination_offset = blockNum;
break;
}
}

if (destination_offset == -1) {
printf("Plus de place dans le système de fichier pour créer la copie de \"%s\".\n", source_filename);
return;
}

// Copie du nom de la copie dans le bloc de description
writeBlock(destination_offset, 0, (const unsigned char *)destination_filename, strlen(destination_filename));

// Copier les blocs de données associés au fichier source dans de nouveaux blocs de données pour le fichier destination
for (int i = 0; i < MAX_BLOCKS_PER_FILE_DESCRIPTION; i++) {
if (i == 0) {
int offset = MAX_FILENAME_LENGTH;
readBlock(source_offset + i, offset, descriptionBuffer, BLOCK_SIZE - offset);
if (descriptionBuffer[offset] == 0) {
break;
}
int newDataBlock = findAvailableBlock(); // Trouver un nouveau bloc de données disponible
writeBlock(destination_offset + i, offset, descriptionBuffer, BLOCK_SIZE - offset);
setBlockAvailability(newDataBlock, 1); // Marquer le nouveau bloc de données comme utilisé
} else {
int offset = 0;
readBlock(source_offset + i, offset, descriptionBuffer, BLOCK_SIZE);
if (descriptionBuffer[offset] == 0) {
break;
}
int newDataBlock = findAvailableBlock(); // Trouver un nouveau bloc de données disponible
writeBlock(destination_offset + i, offset, descriptionBuffer, BLOCK_SIZE);
setBlockAvailability(newDataBlock, 1); // Marquer le nouveau bloc de données comme utilisé
}
}

printf("La copie de \"%s\" sous le nom \"%s\" a été créée avec succès.\n", source_filename, destination_filename);
}

== Semaine 8 ==
A ce stade du projet, les fonctions suivantes ont été validé par Monsieur Redon:

* fonction LS
* fonction RM
* fonction MV

Il reste donc les fonctions suivantes à terminer:

* fonction TYPE
* fonction CAT
* fonction CP

=== Fonction CAT version 2 ===
Suite à vos remarques sur la version 1, j'ai fais les modifications suivantes:

* je n'utilise non plus 2 tableaux de taille BLOCK_SIZE, mais 1 seul. Idéalement il faudrait en utiliser 0, je réfléchi donc à m’émanciper de ce tableau en le remplaçant par plusieurs plus petits tableaux.
* J'ai remplacé le <code>break</code> par un return

Cette fonction permet d'afficher le contenu d'un fichier créé avec la fonction TYPE. Pour se faire, on parcours tout d'abord les blocs de descriptions pour trouver le fichier dont ont veut afficher le contenu. Une fois ce fichier trouvé, on parcours les 16 blocs de description de ce fichier 1 à 1. Pour chacun de ces blocs de description, on va stocker récupéré les octets deux par deux afin de former des entiers. Pour se faire, on utilise la fonction <code>reconsituteNumber</code> que l'on détaillera juste après. Ces entiers correspondent aux blocs dans lesquels la donné du fichier se trouve. Une fois l'entier reconstitué, on affiche le contenu du bloc correspondant.
void CAT(const char *filesystem_path, const char *filename) {
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
unsigned char byteBuffer[2];
unsigned char dataBuffer[BLOCK_SIZE];
int offset;

// Parcours des blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char *)filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {
// Le nom du fichier a été trouvé

// Parcours les blocs de description
for (int descrBlockNum=0; descrBlockNum<MAX_BLOCKS_PER_FILE_DESCRIPTION; descrBlockNum++) {
if (descrBlockNum==0) {
offset=MAX_FILENAME_LENGTH;
} else {
offset=0;
}

// Lecture des octets deux par deux
for (int i=0; i<BLOCK_SIZE;i+=2) {
readBlock(descrBlockNum+blockNum, offset+i, byteBuffer, 2);

// Lire les numéros de blocs associés à ce fichier depuis les blocs de description
int dataBlockNum = reconsituteNumber(byteBuffer);

// Vérifier si le numéro de bloc est valide (non nul)
if (dataBlockNum == 0) {
return; // Fin du fichier
}

// Lire et afficher le contenu du bloc de données
readBlock(dataBlockNum, 0, dataBuffer, BLOCK_SIZE);
fwrite(dataBuffer, 1, BLOCK_SIZE, stdout);
}
}

return; // Fichier affiché, sortie de la fonction
}
}

// Si le fichier n'a pas été trouvé
printf("Le fichier \"%s\" n'a pas été trouvé.\n", filename);
}

=== Fonction reconsituteNumber ===
Cette fonction permet de reconstituer un numéro de bloc à partir de deux octets.
// Fonction qui reconstitue le numéro de bloc à partir du tableau
int reconsituteNumber(unsigned char blockNumberBuffer[2]) {
unsigned char octet1 = blockNumberBuffer[0];
unsigned char octet2 = blockNumberBuffer[1];
int dataBlockNum = (octet1 << 8) | octet2;
return dataBlockNum;
}

= Compilation et exécution =
'''Création du système de fichiers :'''
dd if=/dev/zero of=filesystem.bin bs=256 count=32768

'''Compilation :'''

gcc picofs.c -o picofs

'''Exécution de LS, TYPE, CAT, RM, MV ou CP :'''

./picofs filesystem.bin LS
./picofs filesystem.bin TYPE mon_fichier.txt
./picofs filesystem.bin CAT mon_fichier.txt
./picofs filesystem.bin RM mon_fichier.txt
./picofs filesystem.bin MV mon_fichier.txt mon_fichier2.txt
./picofs filesystem.bin CP mon_fichier.txt mon_fichier2.txt

= Documents Rendus =
[[Fichier:Pcfs.c.tar|vignette]]

SE4 2022/2023 EC1

2023-08-28T14:32:24Z

Asellali : /* Fonction findAvailableBlock */

= Objectifs =

Il vous est demandé de :
* réaliser un micro système de fichiers ;
* le système de fichiers doit résider dans un fichier de 8 Mo ;
* le système de fichiers est géré par un exécutable obtenu à partir d'un programme C ;
* L'éxécutable prend deux arguments, le premier est le chemin du fichier dans lequel réside le système de fichiers, les paramètres suivants concernent l'action à appliquer sur le système de fichiers ;
* le micro système de fichier ne comporte qu'un répertoire : le répertoire principal, le répertoire principal peut comporter au maximum 64 fichiers, un fichier est caractérisé par un nom de 16 caractères au maximum et ses blocs de données, un fichier peut comporter au maximum 2040 blocs de données ;
* un bloc de données fait 256 octets et les blocs sont numérotés sur 2 octets ;
* les différentes actions possibles sur le système de fichiers sont :
** <code>TYPE</code> pour créer un fichier si possible, le nom du fichier suit la commande, le contenu du fichier est donné en entrée standard de l'exécutable ;
** <code>CAT</code> pour afficher un fichier, le nom du fichier suit la commande ;
** <code>RM</code> pour détruire un fichier, le nom du fichier suit la commande ;
** <code>MV</code> pour renommer un fichier, les noms original et nouveau du fichier suivent la commande ;
** <code>CP</code> pour copier un fichier, les noms de l'original et de la copie du fichier suivent la commande ;

= Matériel nécessaire =

Un PC sous Linux.

= Travail réalisé =

== Semaine 1 ==

ReX : attention, ce micro-système de fichiers est prévu pour un microcontrôleur, vos variables globales ne peuvent pas dépasser quelques centaines d'octets.

ReX : pour la création du système de fichiers la commande <code>dd</code> suffit, vous voulez dire le formatage du système de fichiers ?

* création du programme programme.c contenant les différentes structures et les différentes fonctions.
* Piste d'amélioration: faire en sorte que la fonction CAT affiche le contenu exact des fichiers passés en argument.

Le code fourni est un programme en langage C qui simule un système de fichiers basique. Ce programme permet aux utilisateurs d'effectuer diverses actions telles que créer, afficher, supprimer, renommer et copier des fichiers dans un système de fichiers simulé. Le système de fichiers est stocké dans un fichier binaire.

ReX : vous n'avez pas tenu compte de la première remarque, vous chargez tout le superbloc et le répertoire racine, votre code ne convient pas.

ReX : vos structures utilisent des types entiers dont la taille n'est pas explicitée, utilisez les types de <code>stdint.h</code>.

ReX : la création de fichier n'est pas fonctionnelle, vous ne cherchez pas les blocs libres, vous ne copiez pas le contenu du fichier dans les blocs, même remarque pour toutes les autres fonctions.

ReX : il manque les fonctions d'accès aux pages du système de fichiers.

'''Explication du programme programme.c'''

Voici une brève explication des principaux éléments et fonctions du code :

# Structures :
#* Fichier : Représente un fichier dans le système de fichiers. Il contient un nom (nom) avec une longueur maximale de 16 caractères, un tableau de numéros de bloc (blocs) où le contenu du fichier est stocké (jusqu'à 2040 blocs), et le nombre de blocs utilisés par le fichier (nbBlocs).
#* Repertoire : Représente le répertoire principal du système de fichiers. Il contient un tableau de fichiers (<code>fichiers</code>) et le nombre de fichiers dans le répertoire (<code>nbFichiers</code>).
# Fonctions :
#* <code>chargerSystemeFichiers</code> : Charge le système de fichiers à partir d'un fichier binaire donné (chemin) dans une structure Repertoire.
#* <code>sauvegarderSystemeFichiers</code> : Sauvegarde le système de fichiers stocké dans la structure Repertoire dans un fichier binaire (chemin).
#* <code>creerFichier</code> : Crée un nouveau fichier dans le système de fichiers avec un nom et un contenu donnés. Le contenu du fichier est simulé en le divisant en blocs.
#* <code>afficherFichier</code> : Affiche le contenu d'un fichier avec le nom spécifié.
#* <code>detruireFichier</code> : Supprime un fichier avec le nom spécifié du système de fichiers.
#* <code>renommerFichier</code> : Renomme un fichier avec l'ancien nom spécifié en un nouveau nom.
#* <code>copierFichier</code> : Copie un fichier avec le nom spécifié en créant un nouveau fichier avec le nom de copie spécifié.
# Fonction <code>main</code> :
#* La fonction <code>main</code> est le point d'entrée du programme.
#* Elle prend des arguments en ligne de commande : <code><chemin_systeme_fichiers></code> et <code><action></code>.
#* <code><chemin_systeme_fichiers></code> est le chemin vers le fichier binaire où le système de fichiers est stocké.
#* <code><action></code> détermine quelle opération effectuer, comme <code>TYPE</code>, <code>CAT</code>, <code>RM</code>, <code>MV</code> ou <code>CP</code>.
#* En fonction de l'action spécifiée, le programme appelle la fonction correspondante pour effectuer l'opération souhaitée sur le système de fichiers.
Remarque : Le code fourni une simulation basique d'un système de fichiers et de ses opérations, mais il n'interagit pas réellement avec un système de fichiers réel sur le disque.

'''Comment utiliser le programme programme.c'''

étape 1: création du système de fichiers respectant le cahier des charges:

dd if=/dev/zero of=systeme_fichiers.bin bs=1M count=8

étape 2: compilation du programme C:

gcc programme.c -o gestionnaire_fs

étape 3: création d'un fichier dans le système de fichier:

./gestionnaire_fs systeme_fichiers.bin TYPE fichier1.txt

-> entrer le texte en entrée standard

étape 4: manipulation des différentes fonctions. Exemples:

./gestionnaire_fs systeme_fichiers.bin CAT fichier1.txt
./gestionnaire_fs systeme_fichiers.bin CP fichier1.txt copie.txt
./gestionnaire_fs systeme_fichiers.bin RM copie.txt
./gestionnaire_fs systeme_fichiers.bin MV fichier1.txt fichier2.txt

== Semaine 2 ==

Amine: Merci pour vos remarques. Désolé de ne pas avoir suivi votre première remarque, je pensais avoir compris ce qu'il fallait faire mais je me rend compte que non. Je vais tout reprendre depuis le début afin de repartir sur de bonnes bases.

'''Création du système de fichier avec la commande "dd"'''

A quoi sert la commande dd?

La commande <code>dd</code> permet de copier tout ou partie d'un disque par blocs d'octets, indépendamment de la structure du contenu du disque en fichiers et en répertoires (source : [https://doc.ubuntu-fr.org/dd]).

Structure de la commande

dd if=<nowiki><source> of=<cible> bs=<taille des blocs></nowiki>

<code>source</code> = données à copier

<code>cible</code> = endroit où les copier

<code>if</code> = input file

<code>of</code> = output file

<code>bs</code> = block size, habituellement une puissance de 2 supérieure ou égale à 512, représentant un nombre d'octets

Choix de la commande:

Pour la source, on prends <code>/dev/zero</code>: cela permet de créer un fichier rempli de 0. Ce fichier servira de base pour notre système de fichiers.

Pour la cible, on va l'appeler <code>filesystem.bin</Code> : ce sera notre système de fichier.

Pour la taille des blocs, on veut des blocs de données de 256 octets d'après l'enoncé. On va donc prendre <code>bs=256</code>.

Enfin, on veut que le système de fichier réside dans un fichier de 8 Mo. On va donc ajouter <code>count=31250</code>: cela indique que nous voulons écrire 32768 blocs de données dans le fichier (31250 * 256 octets = 8 Mo).

Résultat:

dd if=/dev/zero of=filesystem.bin bs=256 count=31250

Question pour M. Redon : j'ai ici essayé de respecter votre remarque "pour la création du système de fichiers la commande <code>dd</code> suffit". Cependant, pour votre seconde remarque "vous chargez tout le superbloc et le répertoire racine, votre code ne convient pas.", je ne suis pas sûr de comprendre où je fais cela: est-ce lors de la commande dd ou est-ce par la suite avec mon programme C? J'ai un peu modifié la commande dd comme vous pouvez le voir ci-dessus. Ai-je corrigé mon erreur avec cette nouvelle commande? J'ai essayé de justifier au maximum la commande dd que j'ai choisie.

ReX : Pas de problème avec la commande <code>dd</code> (mettez tous les extraits de code entre des balises <code>code</code>). Le problème est au niveau du programme C.

Amine: Ok je comprends mieux merci. Je vais donc reprendre le code étape par étape afin de mieux répondre au cahier des charges.

Gestion du système de fichier par un programme C

'''Création des structures'''
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>

// Structure pour représenter un bloc de données

struct DataBlock {
uint8_t data[256]; // 256 octets pour chaque bloc de données
};

// Structure pour représenter un fichier

struct File {
char filename[17]; // 16 caractères pour le nom du fichier + 1 caractère null-terminator
struct DataBlock data_blocks[2040]; // Tableau de blocs de données pour stocker le contenu du fichier
uint16_t num_data_blocks; // Nombre de blocs de données utilisés par le fichier
};

// Structure pour représenter un répertoire

struct Directory {
struct File files[64]; // Tableau de fichiers pour le répertoire principal
uint8_t num_files; // Nombre de fichiers dans le répertoire principal
};

Modification faite : suite à votre remarque, j'ai explicité la taille des entiers grâce aux types de <code>stdint.h.</code> (j'ai également mis les variables en anglais)

ReX : Vous ne pouvez pas utiliser ces structures, une instanciation d'une de ces structure prend trop d'espace mémoire, vous devez faire sans structure. Par ailleurs la façon dont vous représentez vos fichiers ne convient pas, la description d'un fichier contient des numéros de blocs, pas les blocs eux-même. Faites aussi attention qu'un fichier soit décrit par un nombre entier de blocs.

Question pratique: je n'arrive pas à mettre tout le code dans le même bloc comme vous l'avez fait ci-dessus dans l'étape 4 de la semaine 1. Je vois que c'est en format "préformaté" mais j'obtiens des blocs séparés lorsque j'applique ce format à mon code.

ReX : j'ai corrigé, pour un code entier la syntaxe n'est pas la même (un espace en début de chaque ligne), la balise c'est uniquement pour de très courts extraits de code.

=== Fonction <code>readBlock</code>===
Cette fonction est utilisée pour lire un bloc de données à partir du fichier <code>filesystem.bin</code> et le stocker dans un tableau de caractères (<code>storage</code>).

Fonction:

#define BLOCK_SIZE 256
// Fonction pour lire un bloc de données
void readBlock(unsigned int num, int offset, unsigned char *storage, int size) {
FILE *file = fopen("filesystem.bin", "rb");
if (file == NULL) {
perror("Erreur lors de l'ouverture du fichier");
return;
}
fseek(file, num * BLOCK_SIZE + offset, SEEK_SET);
fread(storage, 1, size, file);
fclose(file);
}

Paramètres :

* <code>num</code> : Numéro du bloc à lire. Chaque bloc contient 256 octets (1 bloc = 256 octets).
* <code>offset</code> : Décalage (en octets) à partir du début du bloc pour commencer la lecture.
* <code>storage</code> : Pointeur vers un tableau de caractères où les données lues seront stockées.
* <code>size</code> : Taille du tableau de caractères <code>storage</code>.

Fonctionnement :

* La fonction commence par ouvrir le fichier <code>filesystem.bin</code> en mode lecture binaire (<code>"rb"</code>).
* Elle utilise <code>fseek</code> pour positionner le curseur de lecture dans le fichier à l'endroit approprié pour commencer la lecture du bloc spécifié (<code>num</code>) à partir de l'offset (<code>offset</code>).
* Elle utilise ensuite <code>fread</code> pour lire <code>size</code> octets à partir du fichier et les stocker dans le tableau <code>storage</code>.
* Enfin, elle ferme le fichier avec <code>fclose</code>.

Note : Le paramètre <code>offset</code> est utilisé pour spécifier à partir de quel octet du bloc on souhaite commencer la lecture. Si <code>offset</code> est égal à 0, la lecture commencera depuis le début du bloc. Si <code>offset</code> est différent de 0, la lecture commencera à l'octet spécifié.

Remarque: dans votre mail, vous définissez "readBlock(unsigned int num,int offset,unsigned storage,int size)": storage n'est alors pas un pointeur vers un tableau de caractère. Je me suis donc permis de faire la modification.

ReX : OK pour la fonction, pas la peine d'en mettre autant dans le Wiki pour une fonction aussi simple.

=== Fonction <code>writeBlock</code> ===
Cette fonction est utilisée pour écrire un bloc de données dans le fichier <code>filesystem.bin</code> à partir d'un tableau de caractères (<code>storage</code>).

Fonction:

// Fonction pour écrire un bloc de données
void writeBlock(unsigned int num, int offset, const unsigned char *storage, int size) {
FILE *file = fopen("filesystem.bin", "rb+");
if (file == NULL) {
perror("Erreur lors de l'ouverture du fichier");
return;
}
fseek(file, num * BLOCK_SIZE + offset, SEEK_SET);
fwrite(storage, 1, size, file);
fclose(file);
}

Paramètres :

* <code>num</code> : Numéro du bloc où écrire.
* <code>offset</code> : Décalage (en octets) à partir du début du bloc pour commencer l'écriture.
* <code>storage</code> : Pointeur vers un tableau de caractères contenant les données à écrire dans le fichier.
* <code>size</code> : Taille du tableau de caractères <code>storage</code>.

Fonctionnement :

* La fonction commence par ouvrir le fichier <code>filesystem.bin</code> en mode lecture et écriture binaire (<code>"rb+"</code>).
* Elle utilise <code>fseek</code> pour positionner le curseur de lecture/écriture dans le fichier à l'endroit approprié pour commencer l'écriture du bloc spécifié (<code>num</code>) à partir de l'offset (<code>offset</code>).
* Elle utilise ensuite <code>fwrite</code> pour écrire <code>size</code> octets à partir du tableau <code>storage</code> dans le fichier.
* Enfin, elle ferme le fichier avec <code>fclose</code>.

ReX : Même remarque que pour la fonction précédente.

'''Etape 4: test des fonctions <code>readBlock</code> et <code>writeBlock</code> dans le main'''
// Exemple de fonction principale pour tester les opérations de lecture et d'écriture
int main() {
unsigned char data[BLOCK_SIZE];
// Test de la fonction readBlock
readBlock(0, 0, data, BLOCK_SIZE);
printf("Block 0, offset 0: ");
for (int i = 0; i < BLOCK_SIZE; i++) {
printf("%02x ", data[i]);
}
printf("\n");
// Test de la fonction writeBlock
unsigned char newData[BLOCK_SIZE] = {
0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88,
// ... Autres données du bloc ...
};
writeBlock(1, 0, newData, BLOCK_SIZE);
// Lecture du bloc nouvellement écrit pour vérifier
readBlock(1, 0, data, BLOCK_SIZE);
printf("Block 1, offset 0: ");
for (int i = 0; i < BLOCK_SIZE; i++) {
printf("%02x ", data[i]);
}
printf("\n");
return 0;
}

Fonctionnement :

* On déclare tout d'abord un tableau de caractères <code>data</code> de taille <code>BLOCK_SIZE</code> pour stocker les données lues du bloc.
* Ensuite, la fonction <code>readBlock</code> est appelée avec les arguments (0, 0, data, BLOCK_SIZE) pour lire le premier bloc du fichier (<code>num=0</code>, <code>offset=0</code>) et stocker les données dans <code>data</code>.
* Ensuite, la fonction <code>printf</code> est utilisée pour afficher les données lues du bloc (<code>data</code>) en format hexadécimal.
* Ensuite, un nouveau tableau de caractères <code>newData</code> est créé avec des données spécifiques pour tester la fonction <code>writeBlock</code>.
* La fonction <code>writeBlock</code> est appelée avec les arguments (1, 0, newData, BLOCK_SIZE) pour écrire le tableau <code>newData</code> dans le deuxième bloc du fichier (<code>num=1</code>, <code>offset=0</code>).
* Enfin, la fonction <code>readBlock</code> est appelée à nouveau pour lire le deuxième bloc nouvellement écrit et afficher les données lues en format hexadécimal.

Question générale : ce que j'avais la première semaine n'est plus forcément d'actualité. Puis-je supprimer les choses qui ne le sont plus afin d'alléger la page ou préférez-vous que je laisse?

ReX : Laissez.

Pour la suite : j'ai donc pour l'instant crée deux fonctions, l'une permettant la lecture et l'autre l'écriture d'un bloc, de manière à économiser la mémoire. Pour la suite, je vais essayer de créer la fonction <code>LS</code> en utilisant la fonction <code>readBlock</code>.

ReX : Oui c'est le début du projet. Mais si vous n'avez pas une bonne description de fichier cela ne donnera rien. Voir remarques plus haut.

'''Etape 5: fonction <code>LS</code>'''

Objectif: créer la fonction <code>LS</code> avec la fonction readBlock.

Question: Souhaitez-vous la fonction <code>LS</code> classique, c'est à dire la fonction <code>LS</code> qui affiche simplement le nom des fichiers présent dans le répertoire ?

ReX : Oui. Tu peux ajouter la taille si tu trouves cela trop simple.

Piste : si c'est ce que vous voulez:

* il va tout d'abord falloir que je crée des fichiers, un fichier étant composé d'un nom et de blocs (création d'une fonction createFile)
* Il faudra ensuite que je stocke ces fichiers dans le répertoire (création d'une fonction addFileToDirectory par exemple)
* enfin, il faudra que j'affiche le nom des fichiers. Pour cela, il faudra que je parcours le répertoire (structure "Directory"), puis que pour chaque fichier présent dans le répertoire que j'affiche son nom (création de la fonction LS)

Je devrais surement utiliser la fonction readBlock afin de transférer les blocs dans le fichier au travers de la variable "storage".

ReX : Créer des fichiers n'est pas nécessaire tout de suite je verrais bien si ton code est bon sans test. Laisse tomber <code>createFile</code> et <code>addFileToDirectory</code> pour l'instant.

ReX : Ton algorithme ne fonctionne pas pour un microcontrôleur où il faut économiser la mémoire, tu ne peux pas t'aider de structures. Il faudra que tu charges les noms et seulement les noms, pour la taille il faudra se baser sur le nombre de blocs.

'''Etape 6: rectification du code suite à vos remarques'''

Modifications apportées:

* suppression des structures afin d’économiser de la mémoire.

* le problème quant à la description des fichiers est normalement résolu puisque plus de structures. On ne charge plus les blocs mais seulement les noms de fichiers.

ReX : Non car si les noms ne sont pas répartis de façon régulière dans les blocs de 256 octets tu vas avoir du mal à les charger. Mais écrit la fonction <code>LS</code> et tu verras ce que je veux dire.

J'ai également ajouté deux nouvelles fonctions:

# <code>void readFileName(unsigned int file_num, char *file_name)</code>: Cette fonction permet de lire le nom du fichier associé au numéro de fichier donné (<code>file_num</code>). Elle stocke le nom du fichier lu dans le tableau <code>file_name</code>.
# <code>void writeFileName(unsigned int file_num, const char *file_name)</code>: Cette fonction permet d'écrire le nom du fichier dans le système de fichiers, associé au numéro de fichier donné (<code>file_num</code>). Elle prend en entrée le nom du fichier à écrire (<code>file_name</code>).

Suite: si vous validez cette base, je pourrai passer à la création de la fonction LS.

ReX : tu peux y aller. Je ne vois pas le code des tes deux fonctions <code>readFileName</code> et <code>writeFileName</code>.

Voici le code des fonctions <code>readFileName</code> et <code>writeFileName</code> :

'''Fonction readFileName:'''
// Fonction pour lire le nom du fichier
void readFileName(unsigned int file_num, char *file_name) {
readBlock(file_num, 0, (unsigned char *)file_name, MAX_FILENAME_LENGTH);
file_name[MAX_FILENAME_LENGTH] = '\0'; // Ajout du caractère null-terminator pour former une chaîne de caractères
}

ReX : Non, aucune raison que le fichier de numéro n soit au bloc n. Dessine la représentation d'un fichier sur le SF en comptant les octets si cela peut aider.

'''Fonction writeFileName:'''
// Fonction pour écrire le nom du fichier
void writeFileName(unsigned int file_num, const char *file_name) {
writeBlock(file_num, 0, (const unsigned char *)file_name, MAX_FILENAME_LENGTH);
}

ReX : Faux et inutile pour l'instant. Problème avec la constante MAX_FILENAME_LENGTH.

=== Fonction LS version 1 ===
// Fonction LS pour afficher les fichiers présents dans le système de fichiers
void LS(const char *filesystem_path) {
FILE *file = fopen(filesystem_path, "rb");
if (file == NULL) {
perror("Erreur lors de l'ouverture du fichier système");
return;
}
uint16_t num_files;
fread(&num_files, sizeof(uint16_t), 1, file); // Lecture du nombre de fichiers dans le système
char filename[17];
printf("Fichiers présents dans le système de fichiers:\n");
for (int i = 0; i < num_files; i++) {
readFileName(i, filename); // Lecture du nom du fichier
printf("%s\n", filename); // Affichage du nom du fichier
}
fclose(file);
}
La fonction <code>LS</code> ouvre le fichier système, lit le nombre de fichiers qu'il contient, puis affiche les noms des fichiers un par un, chacun sur une ligne séparée.

ReX : Il y a le nombre de fichiers dans ton superbloc ? Un dessin du format du superbloc avec les numéros des octets ?

ReX : Tout accès au système de fichiers doit se faire avec les deux fonctions <code>readBlock</code> et <code>writeBlock</code>.

== Semaine 3 ==
Question 1: cela fait plusieurs fois que vous mentionnez dans le wiki un "superbloc". Celui-ci n'étant pas clairement défini dans le sujet, je me demande s'il s'agit du bloc crée grâce à la fonction dd, c'est à dire que le superbloc serait en faite le bloc constitué des 31250 blocs de taille 256 octets, où s'il s'agit d'un bloc qui vient en entête, celui contenant alors des informations décrivant le système de fichier (les noms de fichiers...).

ReX : Pour ton pico système de fichiers, le superbloc consiste en les premiers blocs (de 256 octets) qui définissent les 64 fichiers possibles.

Proposition de structure: on pourrait réserver les premiers blocs du système de fichiers aux noms de fichiers ainsi qu'aux numéros des blocs correspondant à chaque fichier.

ReX : Oui c'est évident.

On sait que les noms de fichiers font au maximum 16 caractères + 1 caractère pour le '\0' (donc 17 octets car 1 char=1 octet).

ReX : Non, 16 octets suffisent, des '\0' en fin de nom uniquement si le nom fait moins de 16 caractères.

On sait également qu'un fichier contient au maximum 2040 blocs, chaque bloc étant numéroté sur 2 octets. On pourrait donc avoir en début du système de fichier: 17 octets+2 octets*2040 blocs = 4097 octets pour la description d'un fichier.

ReX : Non, 4096 octets soit 16 blocs de 256.

Or d'après l'une de vos remarques dans le wiki, un fichier doit être décrit par un nombre entier de blocs. Pour un fichier, il nous faudra donc 4097/256=16.004 soit 17 blocs. Il peut y avoir jusqu'à 64 fichiers dans le répertoire, il nous faudra donc 17 blocs*64 fichiers= 1088 blocs pour la description des fichiers.

ReX : Non 1024 blocs de 256 octets dans le superbloc.

Ainsi, pour la fonction LS, il suffira de lire les premiers caractères tous les 17 blocs ( du premier caractère au caractère '\0').

ReX : Non, tous les 16 blocs.

Question 2: Ne faudrait-il pas également stocker quelque part le nombre de fichier qu'il y a dans le répertoire afin de savoir jusqu'à quel bloc la fonction LS doit aller ?

ReX : Non, un fichier dont le nom n'est constitué que de '\0' est réputé ne pas exister.

Question 3: on a donc vu que les 1088 premiers blocs au maximum serviraient à la description du système de fichier. Il reste donc 31250-1088=30132 blocs dans le système de fichier.

ReX : Non, 32768-1024=31744 blocs.

Comment utiliser ces blocs? Ces blocs doivent-ils stocker le contenu des fichiers ?

ReX : Oui, c'et évident.

En effet, avec la fonction TYPE, nous allons créer des fichiers et ces fichiers devront être stockés quelque part. Cependant, étant donné que ce pico système de fichiers est prévu pour un microcontrôleur, je ne sais pas si c'est le contenu des fichiers qui doit être stocké dans les blocs ou autre chose (peut être l'adresse des fichiers, le fichiers se trouvant autre part). En effet, je me dis que si un fichier est très volumineux, il ne pourra pas rentrer dans le système de fichier, ce dernier étant composé d'un nombre limité de blocs, et les blocs étant eux même limité en nombre d'octets.

ReX : Je ne comprend pas ton problème. De tout façon comme dit plus haut, les 31744 blocs suivant le superbloc doivent contenir les données des fichiers.

Désolé de poser des questions peut être basique aussi tard, mais je pense qu'une fois que j'aurai ces réponses, cela ira beaucoup mieux pour la suite. Merci d'avance pour vos réponses.

ReX : Les questions sont effectivement triviales et il est effectivement inquiétant que voir que la travail n'avance pas.

Amine: merci pour vos corrections.

D'après votre commentaire "32768-1024=31744 blocs", j'en déduis qu'il faut que je modifie ma commande dd (qui est actuellement "dd if=/dev/zero of=filesystem.bin bs=256 count=31250" pour avoir le bon filesystem).

ReX : Je comprends pas d'où tu sors le 31250. D'autant plus que la commande ci-dessous est bonne.

Amine : 31250 car 31250 blocs * 256 octets = 8 Mo.

ReX : Haaaa je vois tu utilises le système métrique international où le mégaoctet vaut 10^6 octets, sauf qu'aucun informaticien n'utilisera cette norme hors sol. Quand je parle de 8 Mo c'est 8x1024x1024 octets. Tout simplement parce qu'une puce mémoire de 8 Mo c'est bien 8x1024x1024 octets.

Amine: D'accord merci pour l'information !

'''Nouvelle commande dd:'''

dd if=/dev/zero of=filesystem.bin bs=256 count=32768

=== Fonction LS version 2 ===

Dans notre structure du système de fichier, le superbloc est constitué de 1024 blocs (16 blocs * 64 fichiers), un fichier étant décrit par 16 blocs. Le nom du fichier est donc écrit au début de tous les blocs multiples de 16. Par exemple, le nom du premier fichier est dans les 16 premiers octets du premier bloc, le nom du 2ème fichier est dans les 16 premiers octets du 32ème bloc et ainsi de suite, tant que des fichiers existent. Lorsque qu'il n'y a plus de fichier, le nom du premier caractère du bloc multiple de 16 est un 0.

Voici le code:
// Fonction pour lister les noms de fichiers présents dans le système de fichiers
void LS() {
unsigned char buffer[BLOCK_SIZE];
int fileCount = 0;

for (int blockNum = 1; blockNum <= MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, BLOCK_SIZE);

// Vérifier si le bloc est vide
if (buffer[0] == 0) {
break; // Plus de fichiers à lire
}

char filename[MAX_FILENAME_LENGTH];
memcpy(filename, buffer, MAX_FILENAME_LENGTH);

// Afficher le nom du fichier
printf("%s\n", filename);
fileCount++;
}

if (fileCount == 0) {
printf("Aucun fichier trouvé.\n");
}
}

ReX : Tu supposes que si un fichier a un nom vide, les suivants auront aussi un nom vide. C'est possible mais dans ce cas la commande <code>RM</code> ca être plus compliquée à écrire.

ReX : Tu ne sembles pas comprendre que la mémoire d'un microcontrôleur est limitée. Pourquoi lire le premier bloc de description d'un fichier en entier ? Dit autrement c'est quoi l'intérêt de lire 256 octets alors que 16 suffisent ?

ReX : Pourquoi tu ne lis pas le premier fichier ? Autrement dit pourquoi décaler tout d'un bloc ?

Amine: Merci pour vos remarques. J'ai apporté les modifications à LS dans la section "Semaine 4" du wiki.

'''Réflexion par rapport aux autres fonctions:'''

J'ai créé les fonctions TYPE et CAT mais il y a malheureusement un problème pour l'instant. Vous pouvez les retrouver en pièce jointe dans l'archive du fichier programme.c.

Le problème que j'ai est que lorsque j'affiche le contenu du fichier créé avec TYPE, j'obtiens plein de caractères spéciaux. Par exemple, je créé le fichier "mon_fichier.txt" avec la fonction TYPE, et je mets en entré standard "hello". Ensuite, je veux afficher le contenu de ce fichier grâce à la fonction CAT. Cependant, ce qui s'affiche dans le terminal n'est pas ce que je veux. De la même manière, lorsque je fais la commande "cat filesystem.bin" dans le terminal, c'est la même chose s'affiche, des donnés parasites.

ReX : Avant même de lire ton code je vais te poser la question de savoir comment tu récupères un bloc libre ? Quel algorithme tu utilises. Personnellement je ne sais pas faire sans ajouter au superbloc un tableau bit à bit des blocs libres. Pour avoir un bit pour chaque bloc du système de fichiers, il faut 32768/8=4096 octets soit 16 blocs.

Amine: ok je vais donc ajouter ce tableau de 16 blocs à la suite de mes premiers 1024 blocs servant à la description de fichier. Le superbloc fera maintenant 1024+16=1040 blocs (plus de détail à la fonction RM de la semaine 4).

Question 1: est ce que la fonction CAT que je dois créer doit renvoyer la même chose que "cat filesystem.bin" ?

ReX : Je préfère ne pas répondre tellement la question montre un manque de réflexion.

Question 2: comment savoir combien de blocs doivent etre attribué à un fichier? Par exemple, si je créé un fichier "mon_fichier.txt" et que je mets en entrée standard le texte "hello", un seul bloc suffi pour stocker ce texte. Cependant, si j'avais mis beaucoup de texte en entrée standard, il aurait fallu plus de blocs. Doit-on calculer la taille de l'entrée standard ou doit-on attribuer toujours le meme nombre de blocs à un fichier? Peut-etre ainsi attribuer 2040 blocs par fichier, meme s'il n'en utilise que 1.

ReX : Là encore c'est une question stupéfiante tellement la réponse est évidente. Il suffit de lire les données sur l'entrée standard et de passer au bloc de données suivant dès que le bloc courant est rempli. La question à poser c'était de se demander comment il est possible d'avoir la taille exacte du fichier pour un <code>CAT</code>. Il est uniquement possible de l'avoir à 256 octets près puisque rien n'indique si le dernier block est vide. Le mieux aurait été de prévoir 4 octets dans la description d'un fichier pour stocker la taille. En l'espèce on considérera que les fichiers sont des fichiers ASCII et qu'ils seront terminés par des <code>\'0</code> qui ne seront pas affichés.

== Semaine 4 ==

Voici un bilan de ce que j'ai fait à ce stade du projet:

* j'ai choisi une structure du système de fichier
* j'ai créé les fonctions readBlock et writeBlock permettant de lire et d'écrire des blocs
* j'ai crée la fonction LS permettant d'afficher le nom des fichiers présents dans le système de fichiers
* j'ai programmer un main permettant d'utiliser les fonctions (LS, TYPE...) depuis le terminal
* j'ai réflechi aux fonctions TYPE et CAT.

Actuellement, je suis en train de créer les fonctions TYPE et CAT.

=== Fonction LS version 3 ===
void LS() {
unsigned char buffer[MAX_FILENAME_LENGTH];
int fileCount = 0;

// Parcourir tous les 16 blocs de 0 jusqu'à MAX_FILES_IN_DIRECTORY
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, MAX_FILENAME_LENGTH);

// Vérifier si le nom de fichier est vide
if (buffer[0] != 0) {

// Afficher le nom du fichier
printf("%s\n", buffer);
fileCount++;
}
}

if (fileCount == 0) {
printf("Aucun fichier trouvé.\n");
}
}
Suite à vos remarques, j'ai effectué les modifications suivantes de la fonction LS:

* Je ne suppose plus que si un fichier a un nom vide, les autres auront aussi un nom vide.
* Je ne lis plus les 256 octets mais seulement les 16 premiers octets car cela suffit.
* Je ne lisais en effet pas le premier bloc. Je pensais que le premier bloc était d'indice 1 mais ce n'est pas le cas.

ReX : Ouiiii ! Une fonction correcte. Passe à <code>RM</code> maintenant, c'est la plus facile à faire concernant l'image bit à bit des blocs libres.

=== Fonction setBlockAvailability version 1 ===

Comme vous l'avez indiqué dans votre remarque, il faut un tableau dans le superbloc qui nous permettra de connaitre la disponibilité bit par bit de chaque bloc. Sachant qu'il y a dans notre système de fichiers 32768 blocs, et qu'il faut 1 bit par bloc, nous avons besoin de 32768 bits, soit 32768/8=4096 octets soit 4096/256=16 blocs. Notre superbloc sera donc comme suit: les 1024 premiers blocs servent à la description des fichiers, c'est à dire à leur nom suivi des numéros de blocs qui leur sont associés, puis ces 1024 blocs sont suivi de 16 blocs listant la disponibilité de chaque bloc.

ReX : Bien résumé.

Nous allons tout d'abord écrire la fonction "setBlockAvailability" prenant en paramètre le numéro du bloc à traiter (<code>blockNum</code>) et la disponibilité souhaitée pour ce bloc (<code>availability</code>). Cette fonction permet de marquer la disponibilité d'un bloc spécifique dans le système de fichiers. Nous utiliserons la convention suivante: un bloc disponible sera marqué par un 1 tandis qu'un bloc non disponible par un 0.
#define SUPERBLOCK_START_BLOCK 1024

void setBlockAvailability(int blockNum, int availability) {
// Calculer l'index du byte et le bit offset correspondant
int byteIndex = blockNum / 8;
int bitOffset = blockNum % 8;

// Lire le byte existant du bloc de disponibilité des blocs
unsigned char buffer[1];
readBlock(SUPERBLOCK_START_BLOCK + byteIndex, 0, buffer, 1);

// Mettre à jour le bit d'offset correspondant
if (availability) {
buffer[0] |= (1 << bitOffset);
} else {
buffer[0] &= ~(1 << bitOffset);
}

// Écrire le byte mis à jour dans le bloc de disponibilité des blocs
writeBlock(SUPERBLOCK_START_BLOCK + byteIndex, 0, buffer, 1);
}

ReX : Un tableau de un octet c'est un octet (variable <code>buffer</code>).

Amine: je vais utiliser un <code>unsigned char buffer.</code> Je suis conscient qu'un char vaut un octet mais je ne pense pas qu'il y ait un type de donnée de la taille d'un bit, c'est pourquoi je travaille avec un octet mais je modifie les bits de cet octet grâce aux algorithmes.

ReX : Il faut bien que tu travailles sur un octet vu que l'état des blocs est stocké sous la forme d'octets. Je disais juste qu'un tableau de 1 élément n'a pas d'intérêt par rapport à l'élément lui-même.

Amine: c'est vrai, modification faite.

ReX : Non il faut calculer le numéro du bloc avant de faire le <code>readBlock</code>.

Amine: ok je vais calculer le numéro de bloc avant.

ReX : La mise à jour du bit est correcte mais le block et le déplacement dans le block ne sont pas correctement calculés.

Amine: je vais vous expliquer le raisonnement que j'avais. Prenons un exemple concret, imaginons que je veuille marquer le bloc 1030 comme disponible:

# Calcul de l'index de l'octet et du bit offset :
#* <code>blockNum</code> = 1030
#* Index du byte = 1030 / 8 = 128
#* Bit offset = 1030 % 8 = 6
# Lecture de l'octet existant de disponibilité:
#* Nous lisons l'octet existant à l'index 128 dans les blocs de disponibilité.
# Mise à jour du bit de disponibilité :
#* Nous voulons marquer le bloc 1030 comme disponible, donc nous utilisons le masque <code>(1 << 6)</code> pour définir le bit 6 à 1 dans l'octet. Le résultat sera, par exemple, <code>00100000</code>.
# Écriture du byte mis à jour :
#* Nous écrivons le byte mis à jour <code>00100000</code> à l'index 128 dans les blocs de disponibilité.

ReX : Ben non, un vrai exemple :
* Il faut prendre un n° de bloc plus grand : 3072 ;
* Numéro d'octet dans la carte des blocs libres : 3072/8=384 ;
* Numéro du bloc dans la carte des blocs libres : 384/256=1 ;
* Numéro du bit <code>b</code> dans l'octet n° 384-256=128 du bloc 1 : 3072%8=0 ;
* Il faut donc lire l'octet <code>o</code> de numéro 128 du bloc 1, puis modifier cet octet par <code>o |= (1<<b)</code> ou <code>o &= ~(1<<b)</code> ;
* Enfin il faut écrire l'octet modifié dans le bloc 1.
Amine: merci pour cet exemple! J'ai compris d'où vient mon erreur. Voir fonction setBlockAvailability version 3.

Remarque: par convention, j'apellerai dans la suite de ce projet "premier superbloc" le superbloc correspondant à la description des fichiers, c'est à dire les 1024 premiers blocs, et j'appellerai "second superbloc" les 16 blocs qui suivent servant à décrire la disponibilité des blocs (du bloc 1024 au bloc 1039 inclu). Le reste des blocs servira à stocker les données.

ReX : Non, le superblc est l'ensemble des informations hors blocs de données, tu ne peux pas utiliser un vocabulaire au hasard. Parle de blocs de description des fichiers ou de carte des blocs libres.

Amine: ok

Je pense que le problème qui se pose est que l'indice du bit dans le second superbloc ne correspond pas à l'indice du bloc dans le système de fichier. Par exemple, nous voudrions que si le bloc 1030 est disponible dans le système de fichier, alors le bit numéro 1030 du deuxième superbloc soit à 1, ce qui n'est pas le cas ici. En effet, on se trouve bien dans le bon octet avec ma méthode mais l'écriture du bit se fait de la droite vers la gauche alors qu'on voudrait l'inverse. Ainsi, si le 6ème bit de l'octet doit être à 1, alors il faudrait qu'on obtienne <code>00000100</code> et non <code>00100000.</code> L'indice du bit coinciderait ainsi avec le numéro du bloc.

ReX : Non, réfléchit à nouveau.

Voir plus bas la nouvelle version de setBlockAvailability.

Explication de l'algorithme pour mettre le bit à 1 ou 0:

* <code>buffer[0] |= (1 << bitOffset);</code> : Cette ligne utilise l'opérateur OR bit à bit (<code>|=</code>) pour activer (mettre à 1) le bit spécifié par <code>bitOffset</code> dans le premier octet (<code>buffer[0]</code>). Cela se fait en décalant le bit 1 vers la gauche de <code>bitOffset</code> positions, puis en effectuant une opération OR bit à bit avec le contenu actuel de <code>buffer[0]</code>. Cette opération modifie uniquement le bit ciblé, laissant les autres bits inchangés.

ReX : Oui ça c'est bon.

* <code>buffer[0] &= ~(1 << bitOffset);</code> : Cette ligne utilise l'opérateur AND bit à bit (<code>&=</code>) pour désactiver (mettre à 0) le bit spécifié par <code>bitOffset</code> dans <code>buffer[0]</code>. Pour ce faire, l'expression <code>~(1 << bitOffset)</code> est utilisée pour créer un masque où tous les bits sont à 1, sauf celui correspondant à <code>bitOffset</code>, qui est à 0. En effectuant ensuite une opération AND bit à bit entre le masque et le contenu actuel de <code>buffer[0]</code>, on met à 0 le bit ciblé sans affecter les autres bits.

ReX : Ca aussi.

=== Fonction setBlockAvailability version 2 ===

void setBlockAvailability(int blockNum, int availability) {
// Calculer l'indice de l'octet et le bit offset correspondant
int byteIndex = blockNum / 8;
int bitOffset = 7 - (blockNum % 8); // Inversion de l'ordre des bits

// Calculer le numéro du bloc du super bloc où se trouve l'octet de disponibilité correspondant
int availabilityBlockNum = SUPERBLOCK_START_BLOCK + byteIndex;

// Lire l'octet existant dans le bloc de disponibilité du super bloc
unsigned char buffer;
readBlock(availabilityBlockNum, 0, &buffer, 1);

// Mettre à jour le bit d'offset correspondant :
if (availability) {
buffer |= (1 << bitOffset);
} else {
buffer &= ~(1 << bitOffset);
}

// Écrire l'octet mis à jour dans le bloc de disponibilité du super bloc
writeBlock(availabilityBlockNum, 0, &buffer, 1);
}
J'ai modifié la ligne <code>int bitOffset = 7 - (blockNum % 8);</code> pour inverser l'ordre des bits sélectionnés, de sorte que le bit correspondant au bloc disponible soit correct.

ReX : Encore plus faux.

Si on veut rendre le bloc 1030 indisponible alors que les autres blocs sont disponibles:

ReX : Pardon ? Le bloc de données est libre ou pas suivant la carte des blocs libres. Le rendre disponible n'est possible que si un fichier le comportant est détruit.

# Calcul de l'indice de l'octet et du bit offset correspondant :
#* <code>blockNum = 1030</code>
#* <code>byteIndex = 1030 / 8 = 128</code>
#* <code>bitOffset = 7 - 1030 % 8 = 1</code> Cela signifie que le bit d'intérêt se trouve à la position 2 dans l'octet.
# Calcul du numéro du bloc du super bloc où se trouve l'octet de disponibilité correspondant :
#* <code>availabilityBlockNum = SUPERBLOCK_START_BLOCK + 128 = 1024 + 128 = 1152</code> Donc, nous devons accéder à l'octet 1152 pour mettre à jour la disponibilité du bloc 1030.
# Lecture de l'octet existant dans le bloc de disponibilité du super bloc :
#* Le contenu de l'octet dans le bloc 1152 avant la mise à jour : 11111111 (en binaire)
# Mise à jour du bit d'offset correspondant :
#* Supposons que nous voulions marquer le bloc 1030 comme non disponible (<code>availability = 0</code>).
#* Le bitOffset est 1.
#* Nous effectuons une opération AND avec le complément du bit à la position 1 : <code>11111111 & 11111101 = 11111101</code>
# Écriture de l'octet mis à jour dans le bloc de disponibilité du super bloc :
#* Le contenu de l'octet 128 du second superbloc après la mise à jour : 11111101 (en binaire)

ReX : Toujours aussi faux.

Maintenant, le bit d'indice 1 du 128 ème octet du second superbloc est mis à 0, indiquant que le bloc 1030 n'est plus disponible. Les autres bits restent inchangés car nous avons effectué un AND avec un masque binaire qui avait des 1 partout sauf à la position du bit que nous souhaitions mettre à 0.

ReX : Erreur sur erreur.

=== Fonction setBlockAvailability version 3 ===
J'ai compris d'où vient l'erreur. La fonction readBlock prends en premier paramètre le numéro du bloc à lire, je ne peux donc pas lui donner la valeur "SUPERBLOCK_START_BLOCK + byteIndex" car byteIndex s'exprime en octet alors qu'on s'attend à un nombre de bloc ici. Il faut donc divisé byteIndex par 256 pour être en unité "bloc", et préciser le bit qu'on veut lire grâce à l'offset.

Pour obtenir l'octet que l'on veut, il faut prendre le reste de la division de byteIndex par 256. On va ensuite stocker cet octet dans notre "buffer".

Pour savoir quel bit modifier dans ce "buffer", on va prendre le reste de la division du bloc dont on veut mettre à jour la disponibilité par 8. On va ainsi pouvoir modifier ce bit grâce à l'algorithme, puis réécrire l'octet à son emplacement d'origine.

Cette fonction gère la carte de disponibilités des blocs. Si un bloc est disponible, alors elle le met un 0, si il est indisponible, elle met un 1.
#define SUPERBLOCK_START_BLOCK 1024

void setBlockAvailability(int blockNum, int availability) {

int byteIndexInCard = blockNum / 8; //Numéro d'octet dans la carte des blocs libres
int blockIndexInCard = byteIndexInCard / 256; //Numéro du bloc dans la carte des blocs libres
int byteIndexInBlock = byteIndexInCard % 256; //Numéro d'octet dans le bloc contenant le bit de disponibilité
int bitOffset = blockNum % 8; //Numéro du bit dans l'octet n°byteIndexInBlock du bloc blockIndexInCard

//indice du bloc contenant le bit à mettre à jour dans le bloc de description
int availabilityBlockNum = FIRST_DISPONIBILITY_CARD_BLOCK + blockIndexInCard;

// Lire l'octet existant dans le bloc de disponibilité du super bloc
unsigned char buffer;
readBlock(availabilityBlockNum, byteIndexInBlock, &buffer, 1);

// Mettre à jour le bit d'offset correspondant :
if (availability==1) { // indisponible
buffer |= (1 << bitOffset); // Mettre le bit à 1

} else { // disponible
buffer &= ~(1 << bitOffset); // Mettre le bit à 0
}

// Écrire l'octet mis à jour dans le bloc de disponibilité du super bloc
writeBlock(availabilityBlockNum, byteIndexInBlock, &buffer, 1);
}

ReX : Ben voila, c'est pas possible de te taxer d'excès de vitesse mais c'est bon.

update: j'ai fait une petite modification, maintenant un bloc disponible est marqué d'un 0 et un bloc indisponible est marqué d'un 1. C'est mieux dans la mesure où initialement, tous les blocs sont disponibles et tous les blocs sont à 0. Cela évite de devoir créer une fonction qui initialise toute la carte de disponibilités à 1 pour dire que tous les blocs sont disponibles.

=== Fonction RM version 1 ===

void RM(const char *filesystem_path, const char *filename) {
unsigned char buffer[BLOCK_SIZE];
int fileNum = -1;

// Parcourir les blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (memcmp(filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {
// Effacer le nom du fichier dans le superbloc
memset(filenameBuffer, 0, MAX_FILENAME_LENGTH);
writeBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

unsigned char fileBuffer[MAX_BLOCKS_PER_FILE * 2];
readBlock(blockNum, MAX_FILENAME_LENGTH, fileBuffer, MAX_BLOCKS_PER_FILE * 2);

// Libérer les blocs associés au fichier et réinitialiser les numéros de blocs
for (int i = 0; i < MAX_BLOCKS_PER_FILE * 2; i += 2) {
int blockNum = ((int)fileBuffer[i] << 8) + (int)fileBuffer[i + 1];
if (blockNum == 0) {
break; // Fin du fichier
}
setBlockAvailability(blockNum, 0); // Marquer le bloc comme disponible
fileBuffer[i] = 0;
fileBuffer[i + 1] = 0;
}

// Mettre à jour les numéros de blocs associés au fichier
writeBlock(blockNum, MAX_FILENAME_LENGTH, fileBuffer, MAX_BLOCKS_PER_FILE * 2);

fileNum = blockNum;
break; // Fichier trouvé, sortir de la boucle
}
}

// Afficher le résultat de l'opération
if (fileNum == -1) {
printf("Le fichier \"%s\" n'a pas été trouvé.\n", filename);
} else {
printf("Le fichier \"%s\" a été supprimé avec succès.\n", filename);
}
}

ReX : Vous utilisez <code>strcmp</code> comme <code>strncmp</code>. C'est bien la dernière qu'il faut utiliser mais en précisant la longueur du nom en paramètre, pas la taille maximale.

Amine: vous voulez dire que j'utilise memcmp au lieu de strncmp ? Ok je vais utiliser strncmp, c'est vrai que c'est plus adapté pour la comparaison de chaines de caractère.

ReX : Ha oui c'est <code>memcmp</code> que tu utilises. Ca ne peut effectivement pas marcher. Effectivement avec <code>strncmp</code> cela peut marcher vu qu'il s'arrête au premier 0 contrairement à <code>memcmp</code>.

Cependant, pourquoi doit-on passer la taille exacte du nom du fichier en paramètre, et non la taille maximale d'un nom de fichier? En effet, cela semble fonctionner en mettant la taille maximale en paramètre, tandis que lorsque l'on met la taille exacte du nom du fichier, cela pose un problème: on ne compare plus toute la chaîne de caractère mais seulement une portion du nom complet. Ainsi, si je crée par exemple un fichier que j'appelle "file1", puis que j’exécute la fonction RM "/picofs filesystem.bin RM file" par exemple, alors le fichier file1 va être supprimé quand même car on ne comparera que strlen(file)=4 premiers caractères, qui sont les mêmes, donc la fonction considérera ces chaines comme identiques. On pourrait alors se dire qu'il faudrait alors prendre plutôt comme taille en paramètre de la fonction strlen la taille du nom du fichier se trouvant dans le système de fichier plutôt que celle du nom donné en paramètre de RM. Cependant, le même problème se pose si la taille du nom du fichier du système de fichier est plus petite que celle du nom du fichier passé en paramètre. Par exemple, si le fichier présent dans système de fichier est "file", et qu'on met la longueur de file en paramètre de la fonction strcmp, puis qu'on exécute la commande "/picofs filesystem.bin RM file5", alors file sera quand même supprimé, car on ne comparera que les strlen(file)=4 premiers caractère. Finalement, une solution serait de rajouter une condition qui vérifie que les deux chaînes sont de taille identiques pour pouvoir réaliser la comparaison sur la taille exacte du nom du fichier. Cependant, il me semble qu'en mettant MAX_FILENAME_LENGTH qui vaut 16 en paramètre, cela fonctionne directement. Vous pouvez tester cela en testant mon programme.

ReX : Ok pour <code>strncmp</code> avec la taille maximale d'un nom de fichier.

etape 1: créer un fichier :
./picofs filesystem.bin TYPE fichier.txt

etape 2: verifier que le fichier a bien été créé :
./picofs filesystem.bin LS

Le terminal renvoie bien "fichier.txt"

etape 3: essayer de supprimer le fichier en mettant une chaine troncature du nom du fichier créé :
./picofs filesystem.bin RM fich

le terminal renvoi <<Le fichier "fich" n'a pas été trouvé.>>, le fichier n'a donc pas été supprimé .

etape 4: essayer de supprimer le fichier en mettant un nom plus grand incluant "fichier.txt" :
./picofs filesystem.bin RM fichier.txtt

terminal renvoi <<Le fichier "fichier.txtt" n'a pas été trouvé.>>

etape 5: enfin, tester en mettant le nom exacte du fichier que l'on veut supprimer :
./picofs filesystem.bin RM fichier.txt

terminal renvoi <<Le fichier "fichier.txt" a été supprimé avec succès.>>

Finalement, on voit que cela fonctionne avec la taille maximale mise en paramètre. On pourrait reprocher à cette méthode de comparer des caractères dans le vide, ce qui n'est pas optimal dans une optique d'économie de mémoire qui est la notre, mais la taille maximale d'un nom de fichier étant relativement faible (16 octets), on peut peut-être négliger cela au vu de l'économie d'une opération supplémentaire (comparaison de la taille des chaines de caractères).

ReX : Le parcours des blocs de données du fichier est atroce. Il faut parcourir les numéros de blocs dans le premier bloc du fichier derrière le nom du fichier puis il faut parcourir le 15 autres blocs.

Amine: Ok, je vais corriger cela dans la version 2 de RM (voir semaine 5).

Fonctionnement de la fonction RM:

* Parcours des blocs réservés pour la description des fichiers (superbloc) à partir du bloc 0, en incrémentant de 16 à chaque itération pour accéder aux blocs de noms de fichiers.

ReX : OK.

* Dans chaque bloc de noms de fichiers, la fonction compare le nom de fichier recherché avec les noms stockés dans les 16 octets de chaque bloc.

ReX : Non la fonction ne fait pas ça par contre il faudrait, oui.

Amine: Je pensais que c'était ce que je faisais avec "memcmp(filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0)".

* Si le nom de fichier est trouvé, la fonction efface le nom du fichier dans le superbloc en remplaçant les 16 octets du bloc par des zéros.

ReX : OK.

* Ensuite, la fonction accède aux octets suivants du même bloc pour obtenir les numéros de blocs associés au fichier.

ReX : Non, la boucle sort largement du premier bloc.

* Pour chaque paire de numéros de blocs (2 octets chacun), la fonction convertit les octets en un numéro de bloc. Si le numéro de bloc est nul, cela signifie la fin des blocs associés au fichier, sinon, la fonction marque ce bloc comme disponible en utilisant la fonction <code>setBlockAvailability</code> et réinitialise les numéros de blocs dans le tableau à zéro.
* Les numéros de blocs réinitialisés sont ensuite réécrits dans le bloc de description du fichier.

ReX : L'idée est là mais vu que la boucle n'est pas bonne, rien ne peut marcher.

* La fonction affiche ensuite un message indiquant le résultat de l'opération : soit que le fichier a été supprimé avec succès, soit que le fichier n'a pas été trouvé.

== Semaine 5 ==

=== Fonction RM version 2 ===

Concernant les remarques que vous m'avez faites précédemment:

* j'utilise maintenant la fonction <code>strncmp</code> pour la comparaison des chaines de caractères
* j'ai normalement corrigé le parcours des blocs. Je parcours maintenant d'abord les blocs multiples de 16 à la recherche du bloc contenant le nom du fichier à supprimer. Puis je parcours les 16 blocs de description du fichier à supprimer, afin de récupérer les numéros de blocs, libérer ces blocs dans la carte de disponibilité et de réinitialiser ces blocs dans les blocs de données.

void RM(const char *filesystem_path, const char *filename) {
int fileFound = -1;
int offset;

// Parcourir les blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char*)filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {

// Effacer le nom du fichier dans le superbloc
memset(filenameBuffer, 0, MAX_FILENAME_LENGTH);
writeBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);
fileFound = 1;
offset = blockNum;
break;
}

}

// Fin de fonction si fichier inexistant
if (fileFound == -1) {
printf("Le fichier \"%s\" n'a pas été trouvé.\n", filename);
return;
}

unsigned char buffer[BLOCK_SIZE];
//bloc que l'on va remplir de 0 et mettre à la place des blocs de données
memset(buffer, 0, BLOCK_SIZE); //on rempli buffer de 0

for (int blockNum=offset; blockNum<offset + 16; blockNum++) {

//premier bloc de description, celui contenant le nom du fichier dans les 16 premiers octets
if (blockNum == offset) {

unsigned char fileBuffer[BLOCK_SIZE-MAX_FILENAME_LENGTH];
//bloc dans lequel on va stocker les blocs de description de fichier
readBlock(blockNum, MAX_FILENAME_LENGTH, fileBuffer, BLOCK_SIZE-MAX_FILENAME_LENGTH);

// Libérer les blocs associés au fichier dans la carte de disponibilités
// et dans les blocs de description
for (int i = MAX_FILENAME_LENGTH; i < BLOCK_SIZE-MAX_FILENAME_LENGTH; i += 2) {
int blockNumData = ((int)fileBuffer[i] << 8) + (int)fileBuffer[i + 1];
if (blockNumData == 0) {
break; // Fin du fichier
}
setBlockAvailability(blockNumData, 0); // Marquer le bloc comme disponible
fileBuffer[i] = 0;
fileBuffer[i + 1] = 0;
writeBlock(blockNumData, 0, buffer, BLOCK_SIZE); //on efface les blocs de données
}
writeBlock(blockNum, MAX_FILENAME_LENGTH, fileBuffer, BLOCK_SIZE-MAX_FILENAME_LENGTH);
//on efface le premier bloc de description

} else {
unsigned char fileBuffer[BLOCK_SIZE];
readBlock(blockNum, 0, fileBuffer, BLOCK_SIZE);

// Libérer les blocs associés au fichier dans la carte de disponibilités et dans les blocs de description
for (int i = 0; i < BLOCK_SIZE; i += 2) {
int blockNumData = ((int)fileBuffer[i] << 8) + (int)fileBuffer[i + 1];
if (blockNumData == 0) {
break; // Fin du fichier
}
setBlockAvailability(blockNumData, 0); // Marquer le bloc comme disponible
fileBuffer[i] = 0;
fileBuffer[i + 1] = 0;
writeBlock(blockNumData, 0, buffer, BLOCK_SIZE); //on efface les blocs de données
}
writeBlock(blockNum, 0, fileBuffer, BLOCK_SIZE); //on efface le bloc de description
}
}
printf("Le fichier \"%s\" a été supprimé avec succès.\n", filename);
}

ReX : Pour construire le nombre sur 16 bits utiliser le OU plutôt que l'addition.

ReX : Heu non, je ne lis pas cette fonction avec tout ce code dupliqué, la seule différence entre les deux alternative est la position de début de l'adresse du premier bloc de données (<code>MAX_FILENAME_LENGTH</code> dans un cas et 0 dans l'autre). Donc l'alternative ne doit servir qu'à initialiser ce début, le reste du code doit être factorisé.

ReX : Et corrige le code, tu utilises deux tableaux de blocs (perte mémoire), tu écris le bloc à zéro dans l'itération (perte CPU).

=== Fonction RM version 3 ===

Suite à vos remarques, j'ai réalisé les modifications suivantes:

* j'utilise maintenant le OU plutôt que l'addition pour construire le nombre sur 16 bits.

* j'ai factorisé le code grâce à la création de la variable <code>startOffset</code> valant 16 lorsqu'on se trouve dans le bloc contenant le nom du fichier et valant 0 lorsqu'on se trouve dans les autres.

* Pour ce qui est du fait que j'utilise 2 tableaux de blocs, j'ai du mal à voir comment faire avec 1 seul tableau de blocs car ces deux tableaux n'ont pas du tout le même rôle. Le tableau <code>fileBuffer</code> permet de stocker les 16 blocs de description d'un fichier un à un. Lorsqu'on stocke un bloc dans <code>fileBuffer</code>, on lit ensuite les octets un à un de ce bloc afin de former des numéros de blocs, et pour chaque numéro de bloc créé, on va réinitialiser le bloc correspondant dans les blocs de données. Pour cela, on a donc besoin d'un autre bloc qui viendra écraser les anciens blocs de données. C'est pourquoi j'ai créé un bloc <code>buffer</code>qui est composé de 0 et qui va écraser les blocs de données. On ne peut pas utiliser <code>fileBuffer</code> car on a besoin d'un bloc de zéros, et si on réinitialise <code>fileBuffer</code> on perd toute les données qui s'y trouvent. Une possibilité serait de relire le bloc de donné à chaque itération de la deuxième boucle for imbriquée; cela permettrait de pouvoir réinitialiser le tableau fileBuffer à chaque itérations de cette boucle afin de stocker ce bloc de 0 dans les blocs de données, puis de restocker dans ce même tableau le bloc de description. Cependant, je ne pense pas que ce soit optimal de faire autant appel à la fonction readBlock.

* j'ai créé une fonction resetBock qui permet comme son nom l'indique de reset un bloc en le remplissant de 0. Cela nous évite de créer deux tableaux de blocs dans RM, bien que je pense que cela revienne au même car on fait appel à une fonction qui créé un tableau de blocs. Quoi qu'il en soit, cela allège le code et cette fonction pourra surement me resservir par la suite.

void RM(const char *filesystem_path, const char *filename) {
int fileFound = -1;
int offset;
unsigned char fileBuffer[BLOCK_SIZE];

// Parcourir les blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char *)filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {
// Effacer le nom du fichier dans le superbloc
memset(filenameBuffer, 0, MAX_FILENAME_LENGTH);
writeBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);
fileFound = 1;
offset = blockNum;
break;
}
}

// Fin de fonction si fichier inexistant
if (fileFound == -1) {
printf("Le fichier \"%s\" n'a pas été trouvé.\n", filename);
return;
}

for (int blockNum = offset; blockNum < offset + 16; blockNum++) {
int startOffset = 0;
if (blockNum == offset) {
startOffset = MAX_FILENAME_LENGTH;
}
readBlock(blockNum, startOffset, fileBuffer, BLOCK_SIZE - startOffset);

// Libérer les blocs associés au fichier dans la carte de disponibilités et dans les blocs de description
for (int i = 0; i < BLOCK_SIZE - startOffset; i += 2) {
int blockNumData = (fileBuffer[i] << 8) | fileBuffer[i + 1];
if (blockNumData == 0) {
break; // Fin du fichier
}
setBlockAvailability(blockNumData, 0); // Marquer le bloc comme disponible
fileBuffer[i] = 0;
fileBuffer[i + 1] = 0;
resetBlock(blockNumData); //on efface les blocs de données
}
writeBlock(blockNum, startOffset, fileBuffer, BLOCK_SIZE - startOffset);
}
printf("Le fichier \"%s\" a été supprimé avec succès.\n", filename);
}
'''Fonction resetBlock'''
void resetBlock(unsigned int blockNum) {
unsigned char buffer[BLOCK_SIZE];
memset(buffer, 0, BLOCK_SIZE);

// Utiliser writeBlock pour écrire les données du buffer dans le bloc
writeBlock(blockNum, 0, buffer, BLOCK_SIZE);
}

ReX : Ca s'améliore. Mais pourquoi cette fonction <code>resetBlock</code> ? Tu crois que dans qu'un système de fichiers perd du temps à mettre à zéro les blocs de données libérés ? Si oui, regarde la page de manual de la commande <code>shred</code>, ça manque à ta culture.

Amine: Après avoir consulter le manual de la commande <code>shred</code>, je vois que cette commande écrit des données aléatoires sur l'emplacement du fichier sur le disque. Par défaut, <code>shred</code> effectue un certain nombre de passes (par exemple, 3 passes) pendant lesquelles il écrit des données aléatoires sur l'emplacement du fichier sur le disque. Après avoir écrit les données aléatoires, <code>shred</code> peut effectuer des passes supplémentaires pendant lesquelles il écrit des données nulles (des zéros) sur le même emplacement. L'objectif de <code>shred</code> est d'augmenter la sécurité en rendant plus difficile la récupération des données supprimées à l'aide d'outils de récupération de données.

Cependant, j'ai aussi consulté comment fonctionne la commande <code>rm</code> de linux, et je vois que cette commande libère l'espace occupé par le fichier en marquant les blocs associés comme disponibles. Cela signifie que les données peuvent encore être récupérées à l'aide d'outils de récupération de données, à moins que des mesures supplémentaires ne soient prises pour écraser physiquement l'espace avec des données aléatoires (c'est ce que fait l'utilitaire <code>shred</code>).

On va donc opter pour la deuxième option, c'est à dire qu'on ne va pas perdre notre temps à remettre à zéro les blocs de données libérés, on va simplement marquer les blocs correspondants comme étant disponibles. Cela nous permettra de nous émanciper de la fonction resetBlock et de n'avoir plus qu'un seul tableau de blocs.

ReX : Sinon lire un bloc complet de pointeurs de blocs de données en mémoire n'est pas forcément optimal. L'idéal serait de lire ces blocs morceau par morceau (de 64 octets par exemple). Certes un bloc serait traité en 4 lectures/écritures (ce qui ralentirait le traitement) mais on gagne en mémoire. Le mieux serait de mettre la taille des morceaux en constante pour pouvoir choisir entre vitesse d'exécution et utilisation mémoire.

Amine: d'accord je comprends. Je vais modifier la fonction pour qu'on puisse découper la lecture/écriture en plusieurs blocs.

=== Fonction RM version 4 ===
Modifications apportées:

* je ne réinitialise plus les blocs de données, je supprime simplement le pointeur du fichier vers les blocs de données et je désigne les blocs comme "disponible" dans le carte de disponibilités. J'ai donc supprimé la fonction resetBlock.

* je ne lis plus les blocs en une seule fois mais en plusieurs fois via la variable CHUNK_SIZE:

# J'ai introduit la constante <code>CHUNK_SIZE</code> pour définir la taille de chaque morceau que nous allons lire/écrire à la fois. Cela permet de découper les opérations en blocs plus petits.
# Dans la boucle <code>for</code> où on parcours les blocs à partir de <code>offset</code>, j'ai ajouté une boucle interne qui parcourt les données du bloc en morceaux de taille <code>CHUNK_SIZE</code>.
# À l'intérieur de la boucle interne, j'ai calculé la taille réelle du morceau (<code>chunkSize</code>) en prenant le minimum entre <code>CHUNK_SIZE</code> et la quantité de données restant à lire/écrire dans le bloc.
# J'ai modifié la fonction <code>readBlock</code> pour lire seulement la quantité de données spécifiée par <code>chunkSize</code> à partir de <code>chunkStart</code>. Ces données sont stockées dans le tableau <code>fileBuffer</code>.
# Ensuite, j'ai effectué les mêmes opérations de libération des blocs associés au fichier, en parcourant les données du morceau et en marquant les blocs comme disponibles.
# Finalement, j'ai utilisé la fonction <code>writeBlock</code> pour écrire le morceau de données modifié dans le bloc, en utilisant la même <code>chunkStart</code> pour déterminer où écrire les données.

#define CHUNK_SIZE 64

int min(int a, int b) {
return a < b ? a : b;
}

void RM(const char *filesystem_path, const char *filename) {
int fileFound = -1;
int offset;
unsigned char fileBuffer[BLOCK_SIZE];

// Parcourir les blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char *)filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {
// Effacer le nom du fichier dans le superbloc
memset(filenameBuffer, 0, MAX_FILENAME_LENGTH);
writeBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);
fileFound = 1;
offset = blockNum;
break;
}
}

// Fin de fonction si fichier inexistant
if (fileFound == -1) {
printf("Le fichier \"%s\" n'a pas été trouvé.\n", filename);
return;
}

for (int blockNum = offset; blockNum < offset + 16; blockNum++) {
int startOffset = 0;

if (blockNum == offset) {
startOffset = MAX_FILENAME_LENGTH;
}

for (int chunkStart = startOffset; chunkStart < BLOCK_SIZE; chunkStart += CHUNK_SIZE) {
int chunkSize = min(CHUNK_SIZE, BLOCK_SIZE - chunkStart);
readBlock(blockNum, chunkStart, fileBuffer, chunkSize);

for (int i = 0; i < chunkSize; i += 2) {
int blockNumData = (fileBuffer[i] << 8) | fileBuffer[i + 1];
if (blockNumData == 0) {
writeBlock(blockNum, chunkStart, fileBuffer, chunkSize);
printf("Le fichier \"%s\" a été supprimé avec succès.\n", filename);
return; // Sortir des boucles
}
setBlockAvailability(blockNumData, 0); // Marquer le bloc comme disponible
fileBuffer[i] = 0;
fileBuffer[i + 1] = 0;
}

writeBlock(blockNum, chunkStart, fileBuffer, chunkSize);
}
}

printf("Le fichier \"%s\" a été supprimé avec succès.\n", filename);
}

ReX : Si on trouve un n° de bloc de données à 0, il faut sortir des deux boucles les plus externes après avoir fait le <code>writeBlock</code>.

Amine: Modification faites ci-dessus. Maintenant, dès qu'on trouve un n° de bloc de données à 0 dans la boucle la plus interne, on effectue le <code>writeBlock</code> et ensuite on utilise <code>return</code> pour sortir des deux boucles les plus externes. Cela permet d'optimiser le code en évitant de continuer à traiter inutilement le reste des blocs.

ReX : Pas très propre (duplication de code) mais nous allons nous en contenter.

=== Fonction intermédiaire TYPE version 1 ===

J'ai également commencé à réfléchir à la fonction TYPE. Pour l'instant, elle ne fait qu'ajouter les noms de fichier dans le superbloc. Cela permet de pouvoir tester les fonctions LS et RM (voir dans la rubrique compilation et exécution comment utiliser le programme).
// Fonction pour créer un fichier avec le nom donné et le contenu fourni en entrée standard
void TYPE(const char *filesystem_path, const char *filename) {
unsigned char buffer[MAX_FILENAME_LENGTH];
// Parcours des blocs réservés pour la description des fichiers
for (int blockNum = 0; blockNum <= MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, MAX_FILENAME_LENGTH);
// Vérifier si le bloc est vide (pas de nom de fichier)
if (buffer[0] == 0) {
// Écrire le nom du fichier dans l'emplacement vide du superbloc
writeBlock(blockNum, 0, (const unsigned char *)filename, MAX_FILENAME_LENGTH);
break; // Fichier créé, sortir de la boucle
}
}
printf("Le fichier \"%s\" a été créé avec succès.\n", filename);
}

ReX : Si la boucle se termine sans trouver de slot libre le message de succès s'affiche tout de même.

ReX : Le paramètre <code>filename</code> n'a pas forcément une taille de <code>MAX_FILENAME_LENGTH</code>.

Selon moi, la fonction TYPE devra respecter 3 étapes:

# Enregistrement du Nom du Fichier: L'ajout du nom du fichier dans un des blocs de la première partie du superbloc.
# Stockage des Données du Fichier: La récupération des données saisies en entrée standard par l'utilisateur et leur stockage dans des blocs du système de fichiers à partir d'une certaine position, comme le bloc 1040.
# Mise à Jour de la Disponibilité des Blocs: L'indication que les blocs dans lesquels les données ont été écrites ne sont plus disponibles en modifiant les bits correspondants dans la deuxième partie du superbloc (les 16 derniers blocs du super bloc).

ReX : Relis le point 3 et dit moi si tu te comprends toi même ?

Amine: Ma phrase n'est effectivement pas très claire. Je voulais dire que la fonction TYPE devra mettre à jour la carte de disponibilité du superbloc. C'est à dire que lorsqu'elle écrira des données dans des blocs, elle devra indiquer dans la carte de disponibilités que ces blocs ne sont plus disponibles.

=== Fonction intermédiaire TYPE version 2 ===

Suite à vos remarques, j'ai apporté les modifications suivantes à la fonction TYPE:

* j'ai ajouté une condition pour l'affichage du message de succès de la création d'un fichier (placeFound).

* le paramètre <code>filename</code> n'ayant pas forcément une taille de <code>MAX_FILENAME_LENGTH</code>, je calcule maintenant la longueur de filename, afin d'écrire seulement le nom du fichier avec la fonction writeBlock.

Il fonction n'est bien évidemment pas fini, elle ajoute seulement le nom du fichier dans le superbloc pour l'instant. Cela me permet de tester les fonctions LS et RM.
void TYPE(const char *filesystem_path, const char *filename) {
size_t sizeFilename = strlen(filename);
printf("size filename=%d\n", sizeFilename);
unsigned char buffer[MAX_FILENAME_LENGTH];
int placeFound = 0;

if (sizeFilename > MAX_FILENAME_LENGTH) {
printf("Impossible de créer le fichier, nom trop long\n");
return;
}

// Parcours des blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, MAX_FILENAME_LENGTH);
// Vérifier si le bloc est vide (pas de nom de fichier)
if (buffer[0] == 0) {
// Écrire le nom du fichier dans l'emplacement vide du superbloc
if (sizeFilename < MAX_FILENAME_LENGTH) {
sizeFilename+=1;
}
writeBlock(blockNum, 0, (const unsigned char *)filename, sizeFilename);
placeFound = 1;
break; // Fichier créé, sortir de la boucle
}
}
if (placeFound == 1) {
printf("Le fichier \"%s\" a été créé avec succès.\n", filename);
} else {
printf("Plus de place dans le système de fichier pour créer ce fichier.\n", filename);
}
}

ReX : Mieux, attention il faut copier aussi le <code>\'0</code> final du nom, donc <code>sizeFilename+1</code>. Sinon tu n'es pas sûr qu'il y ait un zéro final. Et attention n°2, il ne faut pas copier ce <code>\'0</code> si le nom fait la taille maximale.

Amine: ok j'ai modifié la fonction TYPE ci-dessus. J'ai ajouté une condition: si le nom du fichier est inférieur à la taille maximale de nom de fichier, alors on incrémente de 1 la taille du nom de fichier. Cela nous permet d'écrire le '\0' dans le bloc de description. Dans le cas où le nom du fichier est de la taille maximale, nous n'avons pas besoin d'écrire le '\0', on n'incrémente donc pas la taille de 1.

J'ai également ajouté une condition: si le nom du fichier est supérieur à la taille maximale, alors un message d'erreur s'affiche et le fichier n'est pas créé.

ReX : OK. L'embryon de fonction <code>TYPE</code> est correct, il manque juste le principal : la création des blocs de données.

=== Fonction MV version 1 ===

J'ai ici créé la fonction MV qui permet de changer le nom d'un fichier. Pour ce faire, la fonction parcourt les blocs de descriptions à la recherche du fichier dont on veut changer le nom. Lorsque ce fichier est trouvé, on supprime l'ancien nom en mettant des 0 sur 16 octets, puis on vient réécrire le nouveau nom dans le même emplacement. Enfin, on sort de la boucle et on affiche le succès ou non de l'opération.
// Fonction qui modifie le nom du fichier
void MV(const char *filesystem_path, const char *old_filename, const char *new_filename) {
size_t sizeNew_filename = strlen(new_filename);
size_t sizeOld_filename = strlen(old_filename);
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
int fileFound = 0;
// Parcourir les blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);
// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char*)filenameBuffer, old_filename, MAX_FILENAME_LENGTH) == 0) {
// Effacer le nom du fichier dans le superbloc
memset(filenameBuffer, 0, MAX_FILENAME_LENGTH);
writeBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);
// Écrire le nom du fichier dans l'emplacement
writeBlock(blockNum, 0, (const unsigned char *)new_filename, sizeNew_filename);
fileFound=1;
break; // Nom modifié, sortir de la boucle
}
}
if (fileFound == 1) {
printf("Le nom du fichier \"%s\" a été renommé avec succès.\n", old_filename);
} else {
printf("Le fichier \"%s\" n'a pas été trouvé.\n", old_filename);
}
}

ReX : Inutile d'écraser l'ancien nom avec des zéros. Il suffit de copier le nouveau en s'assurant qu'il y ait un zéro final sauf si le nouveau nom fait la taille maximale.

Amine: ok, je vais faire les modifications dans la version 2.

== Semaine 6 ==

=== Fonction MV version 2 ===
Dans cette nouvelle version de la fonction MV, j'ai effectué les modifications suivantes:

* je n'écrase plus l'ancien nom avec des 0
* Je colle simplement le nouveau nom par dessus l'ancien, en m'assurant qu'il y ait bien le '\0' à la fin lorsque la taille du nom du fichier est inférieur à la taille maximale. Comme précédemment, afin de m'assurer de la présence de ce '\0' à la fin du nom, j'incrémente la taille de 1 lorsque qu'elle est inférieur à la taille max. Cependant, je ne suis pas sûr à 100% que ce soit la bonne manière de faire.

// Fonction qui modifie le nom du fichier
void MV(const char *filesystem_path, const char *old_filename, const char *new_filename) {
size_t sizeNew_filename = strlen(new_filename);
size_t sizeOld_filename = strlen(old_filename);
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
int fileFound = 0;

// Parcourir les blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {

readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char*)filenameBuffer, old_filename, MAX_FILENAME_LENGTH) == 0) {

if (sizeNew_filename < MAX_FILENAME_LENGTH) {
sizeNew_filename+=1;
}

// Écrire le nom du fichier dans l'emplacement
writeBlock(blockNum, 0, (const unsigned char *)new_filename, sizeNew_filename);

fileFound=1;

break; // Nom modifié, sortir de la boucle
}
}
if (fileFound == 1) {
printf("Le nom du fichier \"%s\" a été renommé avec succès.\n", old_filename);
} else {
printf("Le fichier \"%s\" n'a pas été trouvé.\n", old_filename);
}
}

ReX : C'est bon. La fonction était triviale.

=== Fonction TYPE version 1 ===
void TYPE(const char *filesystem_path, const char *filename) {
size_t sizeFilename = strlen(filename);
unsigned char buffer[MAX_FILENAME_LENGTH];
int placeFound = -1;

if (sizeFilename > MAX_FILENAME_LENGTH) {
printf("Impossible de créer le fichier, nom trop long\n");
return;
}

// Parcours des blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, MAX_FILENAME_LENGTH);
// Vérifier si le bloc est vide (pas de nom de fichier)
if (buffer[0] == 0) {
// Écrire le nom du fichier dans l'emplacement vide du superbloc
if (sizeFilename < MAX_FILENAME_LENGTH) {
sizeFilename += 1; // Ajouter '\0' s'il y a de la place
}
writeBlock(blockNum, 0, (const unsigned char *)filename, sizeFilename);
placeFound = blockNum;

// Lire les données depuis l'entrée standard
unsigned char dataBuffer[BLOCK_SIZE];
size_t bytesRead;
int dataBlockNum = findAvailableBlock(); // Premier bloc de données à partir du bloc 1040
printf("dataBlockNum%d\n",dataBlockNum);
int blockSizeUsed = 0; // Compteur d'octets dans le bloc actuel
int dataBlocksNeeded = 1; // Nombre de blocs de données nécessaires

while ((bytesRead = fread(dataBuffer + blockSizeUsed, 1, BLOCK_SIZE - blockSizeUsed, stdin)) > 0) {
blockSizeUsed += bytesRead;

// Si le bloc actuel est plein, passer au bloc suivant
if (blockSizeUsed == BLOCK_SIZE) {
// printf("dataBlockNum=%d\n",dataBlockNum);
writeBlock(dataBlockNum, 0, dataBuffer, BLOCK_SIZE);
setBlockAvailability(dataBlockNum, 1);

dataBlockNum++; // Passer au bloc suivant
blockSizeUsed = 0; // Réinitialiser la taille utilisée
dataBlocksNeeded++;
}
}

// Écrire le dernier bloc partiel, s'il y en a un
if (blockSizeUsed > 0) {
writeBlock(dataBlockNum, 0, dataBuffer, blockSizeUsed);
setBlockAvailability(dataBlockNum, 1);
}

// Écrire les numéros de blocs utilisés dans le bloc de description
unsigned char blockNumberBuffer[2];
int currentBlockNum = 1040;

for (int i = 0; i < dataBlocksNeeded; i++) {
blockNumberBuffer[0] = (currentBlockNum >> 8) & 0xFF;
blockNumberBuffer[1] = currentBlockNum & 0xFF;
writeBlock(placeFound, MAX_FILENAME_LENGTH + i * 2, blockNumberBuffer, 2);
currentBlockNum++;
}

break; // Fichier créé, sortir de la boucle
}
}

if (placeFound != -1) {
printf("Le fichier \"%s\" a été créé avec succès.\n", filename);
} else {
printf("Plus de place dans le système de fichier pour créer ce fichier.\n");
}
}

ReX : La constante 1040 ne doit pas apparaître en numérique, ce doit être une constante calculée à partir des autres constantes.

Amine: Ok. Je ne l'avais pas défini comme une constante car il s'agit dans la fonction ci-dessus d'une variable qui est incrémenté à chaque itération.

ReX : Je suis las de te répéter que le mémoire est comptée : tu utilises encore un bloc de <code>BLOCK_SIZE</code> octets, c'est trop.

Amine: Comment utiliser des blocs plus petit sachant qu'il s'agit là de blocs de données et qu'un bloc fait 256 octets d'après l'énoncé ? Dois-je les subdiviser en plusieurs blocs plus petit comme fait dans la fonction RM, en 4 blocs de 64 octets par exemple ?

Fonctionnement de la fonction TYPE:

* étape 1: on parcourt les blocs de descriptions à la recherche d'un bloc disponible. Si on ne trouve pas de bloc disponible, on renvoie un message d'erreur, sinon on passe à l'étape suivante.
* étape 2: Si on trouve un emplacement libre dans les blocs de disponibilité, on écrit le nom du fichier dans cet emplacement.

ReX : Dans les blocs de description de fichiers pas dans les blocs de disponibilité.

Amine: Oui autant pour moi.

* étape 3: Ensuite, on lit le texte entré par l'utilisateur en entrée standard, on le répartit dans des blocs de taille BLOCK_SIZE, on met à jour la disponibilité des blocs utilisés.

ReX : Non, il faut appeler <code>findAvailableBlock</code> pour chaque bloc de données à utiliser, aucune certitudes que les blocs libres soient en séquence.

Amine: ok, je ferai cela dans la version 2

* étape 4: Enfin, on écrit les numéros des blocs de données utilisés dans les blocs de description de ce fichier, les numéros étant écris sur deux octets.

ReX : Non cela doit se faire au fur et à mesure des appels à <code>findAvailableBlock</code> et les numéros des blocs de données peuvent s'étaler sur les 16 blocs de description du fichier. Confusion totale sur ce point. Vous n'avez pas compris le mécanisme.

Amine: je corrige cela dans la version 2. J'ai bien compris le mécanisme mais ce n'est pas facile à traduire en code.

=== Fonction TYPE version 2 ===
Dans cette nouvelle version de TYPE, j'ai fait les modifications suivantes:

* j'appelle maintenant <code>findAvailableBlock</code> pour chaque bloc de données à utiliser
* j'écris maintenant les numéros de blocs au fur et à mesures des appels à <code>findAvailableBlock</code>
* je n'utilise plus de tableaux de taille 256 octets mais des tableaux de tailles CHUNK_SIZE. J'ai choisi ici CHUNK_SIZE = 64 octets.

J'utilise toujours un bloc de taille BLOCK_SIZE en attendant de comprendre si je dois diviser ce bloc en plusieurs blocs de taille plus petite ou s'il y a un moyen de ne pas du tout utiliser ces blocs.
void TYPE(const char *filesystem_path, const char *filename) {
size_t sizeFilename = strlen(filename);
unsigned char buffer[MAX_FILENAME_LENGTH];
int placeFound = -1;

if (sizeFilename > MAX_FILENAME_LENGTH) {
printf("Impossible de créer le fichier, nom trop long\n");
return;
}

// Parcours des blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, MAX_FILENAME_LENGTH);
// Vérifier si le bloc est vide (pas de nom de fichier)
if (buffer[0] == 0) {
// Écrire le nom du fichier dans l'emplacement vide du superbloc
if (sizeFilename < MAX_FILENAME_LENGTH) {
sizeFilename += 1; // Ajouter '\0' s'il y a de la place
}
writeBlock(blockNum, 0, (const unsigned char *)filename, sizeFilename);
placeFound = blockNum;

// Lire les données depuis l'entrée standard et écrire dans le fichier
int dataBlockNum = findAvailableBlock(); // Premier bloc de données à partir du bloc 1040
printf("Premier bloc dans lequel on écrit = %d\n", dataBlockNum);
int blockSizeUsed = 0; // Compteur d'octets dans le bloc actuel

unsigned char chunkBuffer[CHUNK_SIZE];
size_t bytesRead;

while ((bytesRead = fread(chunkBuffer, 1, CHUNK_SIZE, stdin)) > 0) {
// Écrire le chunk dans le bloc de données
writeBlock(dataBlockNum, blockSizeUsed, chunkBuffer, bytesRead);
setBlockAvailability(dataBlockNum, 1);

// Écrire le numéro du bloc actuel dans la description du fichier
unsigned char blockNumberBuffer[2];
blockNumberBuffer[0] = (dataBlockNum >> 8) & 0xFF;
blockNumberBuffer[1] = dataBlockNum & 0xFF;
writeBlock(placeFound, MAX_FILENAME_LENGTH + dataBlockNum * 2, blockNumberBuffer, 2);

blockSizeUsed += bytesRead;

// Si le bloc actuel est plein, passer au bloc suivant
if (blockSizeUsed == BLOCK_SIZE) {
dataBlockNum = findAvailableBlock(); // Passer au bloc suivant
blockSizeUsed = 0; // Réinitialiser la taille utilisée
}
}

break; // Fichier créé, sortir de la boucle
}
}

if (placeFound != -1) {
printf("Le fichier \"%s\" a été créé avec succès.\n", filename);
} else {
printf("Plus de place dans le système de fichier pour créer ce fichier.\n");
}
}

=== Fonction findAvailableBlock ===
Cette fonction renvoie l'indice du premier bloc disponible. Je me sers de cette fonction dans la fonction TYPE.
#define FIRST_DATA_BLOCK 1040
#define FIRST_DISPONIBILITY_CARD_BLOCK 1024

// Renvoie le premier bloc de donné disponible
int findAvailableBlock() {
unsigned char availabilityBuffer[BLOCK_SIZE];
int offset;

// Lire la carte de disponibilité (à partir du bloc 1)
for (int blockNum = FIRST_DISPONIBILITY_CARD_BLOCK; blockNum < FIRST_DATA_BLOCK; blockNum++) {
readBlock(blockNum, 0, availabilityBuffer, BLOCK_SIZE);

if (blockNum==FIRST_DISPONIBILITY_CARD_BLOCK) {
offset=FIRST_DATA_BLOCK/8;
} else {
offset=0;
}

// Parcourir les octets de la carte de disponibilité
for (int byteIndex = offset; byteIndex < BLOCK_SIZE - offset; byteIndex++) {
unsigned char byte = availabilityBuffer[byteIndex];

// Parcourir les bits de chaque octet
for (int bitIndex = 0; bitIndex < 8; bitIndex++) {
// Vérifier si le bit est à 0 (bloc disponible)
if ((byte & (1 << bitIndex)) == 0) {
// Calculer l'indice du bloc en fonction du bloc et du bit
int blockIndex = byteIndex * 8 + bitIndex;
return blockIndex;
}
}
}
}

// Aucun bloc disponible trouvé
return -1;
}

ReX : Même remarque que précédement sur les nombres 1024 et 1040.

Amine: Ok, j'ai remplacé 1024 par la constante FIRST_DISPONIBILITY_CARD_BLOCK et 1040 par la constante FIRST_DATA_BLOCK dans la fonction ci-dessus.

ReX : Vous n'avez toujours pas compris la contrainte sur la mémoire.

Amine: dois-je découper le bloc de taille BLOCK_SIZE en quatre blocs de taille 64 octets par exemple ?

ReX : Je ne vois pas ce que vous voulez faire avec <code>if (blockNum==1024) offset=1040/8; else offset=0;</code>.

Amine: dans la carte de disponibilité, chaque bit correspond à un bloc. Ainsi, les bits de 0 à 1040 dans la carte de disponibilité décrivent la disponibilité des blocs 0 à 1040. Or ces blocs correspondent au superbloc, et dans cette fonction, on veut connaître le premier bloc de données disponible. On ne s'intéresse donc pas au 1040 premiers bits de la carte de disponibilité. Je crée donc un offset égal à 1040/8 afin de ne pas prendre en compte les 1040 premiers bits soit les 1040/8=130 premiers octets. Cet offset ne s'applique que lorsqu'on se trouve dans le premier des 16 blocs de la carte de disponibilité, d'où la condition <code>if (blockNum==1024)</code>.

=== Fonction CAT ===
void CAT(const char *filesystem_path, const char *filename) {
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
unsigned char buffer[BLOCK_SIZE];
unsigned char blockNumberBuffer[2];
unsigned char dataBuffer[BLOCK_SIZE];
int offset;

// Parcours des blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char *)filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {
// Le nom du fichier a été trouvé

// Parcours les blocs de description
for (int descrBlockNum=0; descrBlockNum<MAX_BLOCKS_PER_FILE_DESCRIPTION; descrBlockNum++) {
if (descrBlockNum==0) {
offset=16;
} else {
offset=0;
}
readBlock(descrBlockNum+blockNum, offset, buffer, BLOCK_SIZE-offset);

// Lire les numéros de blocs associés à ce fichier depuis les blocs de description
unsigned char octet1 = buffer[offset];
unsigned char octet2 = buffer[offset+1];

int dataBlockNum = (octet1 << 8) | octet2;
printf("dataBlockNum=%d\n",dataBlockNum);

// Vérifier si le numéro de bloc est valide (non nul)
if (dataBlockNum == 0) {
return; // Fin du fichier
}

// Lire et afficher le contenu du bloc de données
readBlock(dataBlockNum, 0, dataBuffer, BLOCK_SIZE);
fwrite(dataBuffer, 1, BLOCK_SIZE, stdout);
}

return; // Fichier affiché, sortie de la fonction
}
}

// Si le fichier n'a pas été trouvé
printf("Le fichier \"%s\" n'a pas été trouvé.\n", filename);
}

ReX : Encore mieux : deux blocs de <code>BLOCK_SIZE</code> en mémoire.

ReX : Le <code>break</code> ne sort pas de la boucle externe.

Amine: Oui c'est vrai. J'ai remplacé le break pas un return ci-dessus.

Voici ma fonction <code>CAT</code>. Elle fonctionne en plusieurs étape:

* étape 1: on cherche dans les blocs de descriptions si le fichier dont on veut afficher le contenu existe. Si le nom de fichier est trouvé, on passe à l'étape 2. Sinon, on renvoie un message d'erreur.
* étape 2: si le fichier est trouvé, on parcours les 16 blocs de description de ce fichier.
* étape 3: grâce aux opérations de masquage et de décalage, on joint les octets deux par deux pour former un entier qui contient le numéro du bloc de données correspondant au fichier. Si cet entier vaut 0, alors cela signifie qu'il n'y a plus de blocs associé à ce fichier, on peut donc quitter la fonction. Si cet entier est différent de 0, alors on va lire le bloc correspondant à ce numéro et on affiche son contenu dans le terminal.

== Semaine 7 ==

=== Fonction CP version 1 ===
Voici ma fonction CP, qui permet de créer une copie d'un fichier existant. L'idée est la suivante: pour copier un fichier, on doit créer un nouveau fichier et lui attribuer les mêmes blocs de descriptions que le fichier source. Ainsi, le fichier source et le fichier destination pointeront vers les mêmes blocs de données, et auront le même contenu.

ReX : Perdu. Ce n'est absolument pas la fonction de copie de fichiers d'un système de fichiers.

Amine: Après avoir fait des recherches et après réflexion, je me rends compte que cette fonction CP présente un problème: en faisant pointé les blocs de données du fichier destination vers ceux du fichier source, toutes modifications du fichier source impactera le fichier destination, or ce n'est pas ce qu'on veut faire. Je vous propose donc une nouvelle version de la fonction CP ci-dessous qui remédie à ce problème.

void CP(const char *filesystem_path, const char *source_filename, const char *destination_filename) {
unsigned char source_filenameBuffer[MAX_FILENAME_LENGTH];
unsigned char destination_filenameBuffer[MAX_FILENAME_LENGTH];
unsigned char descriptionBuffer[BLOCK_SIZE];
int destination_offset;
int offset;

// Recherche du fichier source
int source_offset = -1;
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, source_filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier source
if (strncmp((const char *)source_filenameBuffer, source_filename, MAX_FILENAME_LENGTH) == 0) {
source_offset = blockNum;
break;
}
}

if (source_offset == -1) {
printf("Le fichier source \"%s\" n'a pas été trouvé.\n", source_filename);
return;
}

// Recherche d'un emplacement libre pour le fichier destination
destination_offset = -1;
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, destination_filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc est vide (pas de nom de fichier)
if (destination_filenameBuffer[0] == 0) {
destination_offset = blockNum;
break;
}
}

if (destination_offset == -1) {
printf("Plus de place dans le système de fichier pour créer la copie de \"%s\".\n", source_filename);
return;
}

// Ecrit le nom de la copie dans le bloc de description
writeBlock(destination_offset, 0, (const unsigned char *)destination_filename, strlen(destination_filename));

// Copier les blocs de description associés au fichier source dans les blocs de description du fichier destination
for (int i = 0; i < MAX_BLOCKS_PER_FILE_DESCRIPTION; i++) {
if (i==0) {
offset = MAX_FILENAME_LENGTH;
} else {
offset = 0;
}

readBlock(source_offset+i, offset, descriptionBuffer, BLOCK_SIZE-offset);
if (descriptionBuffer[offset]==0) {
return;
} else {
writeBlock(destination_offset+i, offset, descriptionBuffer, BLOCK_SIZE-offset);
}
}

printf("La copie de \"%s\" sous le nom \"%s\" a été créée avec succès.\n", source_filename, destination_filename);
}

=== Fonction CP version 2 ===
Voici une version mise à jour de notre fonction CP qui duplique réellement les blocs de données du fichier source vers le fichier de destination. Cela implique d'attribuer de nouveaux blocs de données au fichier de destination et de mettre à jour la carte de disponibilité des blocs.
void CP(const char *filesystem_path, const char *source_filename, const char *destination_filename) {
unsigned char source_filenameBuffer[MAX_FILENAME_LENGTH];
unsigned char destination_filenameBuffer[MAX_FILENAME_LENGTH];
unsigned char descriptionBuffer[BLOCK_SIZE];
int destination_offset;
int source_offset;

// Recherche du fichier source
source_offset = -1;
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, source_filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier source
if (strncmp((const char *)source_filenameBuffer, source_filename, MAX_FILENAME_LENGTH) == 0) {
source_offset = blockNum;
break;
}
}

if (source_offset == -1) {
printf("Le fichier source \"%s\" n'a pas été trouvé.\n", source_filename);
return;
}

// Recherche d'un emplacement libre pour le fichier destination
destination_offset = -1;
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, destination_filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc est vide (pas de nom de fichier)
if (destination_filenameBuffer[0] == 0) {
destination_offset = blockNum;
break;
}
}

if (destination_offset == -1) {
printf("Plus de place dans le système de fichier pour créer la copie de \"%s\".\n", source_filename);
return;
}

// Copie du nom de la copie dans le bloc de description
writeBlock(destination_offset, 0, (const unsigned char *)destination_filename, strlen(destination_filename));

// Copier les blocs de données associés au fichier source dans de nouveaux blocs de données pour le fichier destination
for (int i = 0; i < MAX_BLOCKS_PER_FILE_DESCRIPTION; i++) {
if (i == 0) {
int offset = MAX_FILENAME_LENGTH;
readBlock(source_offset + i, offset, descriptionBuffer, BLOCK_SIZE - offset);
if (descriptionBuffer[offset] == 0) {
break;
}
int newDataBlock = findAvailableBlock(); // Trouver un nouveau bloc de données disponible
writeBlock(destination_offset + i, offset, descriptionBuffer, BLOCK_SIZE - offset);
setBlockAvailability(newDataBlock, 1); // Marquer le nouveau bloc de données comme utilisé
} else {
int offset = 0;
readBlock(source_offset + i, offset, descriptionBuffer, BLOCK_SIZE);
if (descriptionBuffer[offset] == 0) {
break;
}
int newDataBlock = findAvailableBlock(); // Trouver un nouveau bloc de données disponible
writeBlock(destination_offset + i, offset, descriptionBuffer, BLOCK_SIZE);
setBlockAvailability(newDataBlock, 1); // Marquer le nouveau bloc de données comme utilisé
}
}

printf("La copie de \"%s\" sous le nom \"%s\" a été créée avec succès.\n", source_filename, destination_filename);
}

= Compilation et exécution =
'''Création du système de fichiers :'''
dd if=/dev/zero of=filesystem.bin bs=256 count=32768

'''Compilation :'''

gcc picofs.c -o picofs

'''Exécution de LS, TYPE, CAT, RM, MV ou CP :'''

./picofs filesystem.bin LS
./picofs filesystem.bin TYPE mon_fichier.txt
./picofs filesystem.bin CAT mon_fichier.txt
./picofs filesystem.bin RM mon_fichier.txt
./picofs filesystem.bin MV mon_fichier.txt mon_fichier2.txt
./picofs filesystem.bin CP mon_fichier.txt mon_fichier2.txt

= Documents Rendus =
[[Fichier:Pcfs.c.tar|vignette]]

SE4 2022/2023 EC1

2023-08-28T14:02:44Z

Asellali : /* Fonction TYPE version 2 */

= Objectifs =

Il vous est demandé de :
* réaliser un micro système de fichiers ;
* le système de fichiers doit résider dans un fichier de 8 Mo ;
* le système de fichiers est géré par un exécutable obtenu à partir d'un programme C ;
* L'éxécutable prend deux arguments, le premier est le chemin du fichier dans lequel réside le système de fichiers, les paramètres suivants concernent l'action à appliquer sur le système de fichiers ;
* le micro système de fichier ne comporte qu'un répertoire : le répertoire principal, le répertoire principal peut comporter au maximum 64 fichiers, un fichier est caractérisé par un nom de 16 caractères au maximum et ses blocs de données, un fichier peut comporter au maximum 2040 blocs de données ;
* un bloc de données fait 256 octets et les blocs sont numérotés sur 2 octets ;
* les différentes actions possibles sur le système de fichiers sont :
** <code>TYPE</code> pour créer un fichier si possible, le nom du fichier suit la commande, le contenu du fichier est donné en entrée standard de l'exécutable ;
** <code>CAT</code> pour afficher un fichier, le nom du fichier suit la commande ;
** <code>RM</code> pour détruire un fichier, le nom du fichier suit la commande ;
** <code>MV</code> pour renommer un fichier, les noms original et nouveau du fichier suivent la commande ;
** <code>CP</code> pour copier un fichier, les noms de l'original et de la copie du fichier suivent la commande ;

= Matériel nécessaire =

Un PC sous Linux.

= Travail réalisé =

== Semaine 1 ==

ReX : attention, ce micro-système de fichiers est prévu pour un microcontrôleur, vos variables globales ne peuvent pas dépasser quelques centaines d'octets.

ReX : pour la création du système de fichiers la commande <code>dd</code> suffit, vous voulez dire le formatage du système de fichiers ?

* création du programme programme.c contenant les différentes structures et les différentes fonctions.
* Piste d'amélioration: faire en sorte que la fonction CAT affiche le contenu exact des fichiers passés en argument.

Le code fourni est un programme en langage C qui simule un système de fichiers basique. Ce programme permet aux utilisateurs d'effectuer diverses actions telles que créer, afficher, supprimer, renommer et copier des fichiers dans un système de fichiers simulé. Le système de fichiers est stocké dans un fichier binaire.

ReX : vous n'avez pas tenu compte de la première remarque, vous chargez tout le superbloc et le répertoire racine, votre code ne convient pas.

ReX : vos structures utilisent des types entiers dont la taille n'est pas explicitée, utilisez les types de <code>stdint.h</code>.

ReX : la création de fichier n'est pas fonctionnelle, vous ne cherchez pas les blocs libres, vous ne copiez pas le contenu du fichier dans les blocs, même remarque pour toutes les autres fonctions.

ReX : il manque les fonctions d'accès aux pages du système de fichiers.

'''Explication du programme programme.c'''

Voici une brève explication des principaux éléments et fonctions du code :

# Structures :
#* Fichier : Représente un fichier dans le système de fichiers. Il contient un nom (nom) avec une longueur maximale de 16 caractères, un tableau de numéros de bloc (blocs) où le contenu du fichier est stocké (jusqu'à 2040 blocs), et le nombre de blocs utilisés par le fichier (nbBlocs).
#* Repertoire : Représente le répertoire principal du système de fichiers. Il contient un tableau de fichiers (<code>fichiers</code>) et le nombre de fichiers dans le répertoire (<code>nbFichiers</code>).
# Fonctions :
#* <code>chargerSystemeFichiers</code> : Charge le système de fichiers à partir d'un fichier binaire donné (chemin) dans une structure Repertoire.
#* <code>sauvegarderSystemeFichiers</code> : Sauvegarde le système de fichiers stocké dans la structure Repertoire dans un fichier binaire (chemin).
#* <code>creerFichier</code> : Crée un nouveau fichier dans le système de fichiers avec un nom et un contenu donnés. Le contenu du fichier est simulé en le divisant en blocs.
#* <code>afficherFichier</code> : Affiche le contenu d'un fichier avec le nom spécifié.
#* <code>detruireFichier</code> : Supprime un fichier avec le nom spécifié du système de fichiers.
#* <code>renommerFichier</code> : Renomme un fichier avec l'ancien nom spécifié en un nouveau nom.
#* <code>copierFichier</code> : Copie un fichier avec le nom spécifié en créant un nouveau fichier avec le nom de copie spécifié.
# Fonction <code>main</code> :
#* La fonction <code>main</code> est le point d'entrée du programme.
#* Elle prend des arguments en ligne de commande : <code><chemin_systeme_fichiers></code> et <code><action></code>.
#* <code><chemin_systeme_fichiers></code> est le chemin vers le fichier binaire où le système de fichiers est stocké.
#* <code><action></code> détermine quelle opération effectuer, comme <code>TYPE</code>, <code>CAT</code>, <code>RM</code>, <code>MV</code> ou <code>CP</code>.
#* En fonction de l'action spécifiée, le programme appelle la fonction correspondante pour effectuer l'opération souhaitée sur le système de fichiers.
Remarque : Le code fourni une simulation basique d'un système de fichiers et de ses opérations, mais il n'interagit pas réellement avec un système de fichiers réel sur le disque.

'''Comment utiliser le programme programme.c'''

étape 1: création du système de fichiers respectant le cahier des charges:

dd if=/dev/zero of=systeme_fichiers.bin bs=1M count=8

étape 2: compilation du programme C:

gcc programme.c -o gestionnaire_fs

étape 3: création d'un fichier dans le système de fichier:

./gestionnaire_fs systeme_fichiers.bin TYPE fichier1.txt

-> entrer le texte en entrée standard

étape 4: manipulation des différentes fonctions. Exemples:

./gestionnaire_fs systeme_fichiers.bin CAT fichier1.txt
./gestionnaire_fs systeme_fichiers.bin CP fichier1.txt copie.txt
./gestionnaire_fs systeme_fichiers.bin RM copie.txt
./gestionnaire_fs systeme_fichiers.bin MV fichier1.txt fichier2.txt

== Semaine 2 ==

Amine: Merci pour vos remarques. Désolé de ne pas avoir suivi votre première remarque, je pensais avoir compris ce qu'il fallait faire mais je me rend compte que non. Je vais tout reprendre depuis le début afin de repartir sur de bonnes bases.

'''Création du système de fichier avec la commande "dd"'''

A quoi sert la commande dd?

La commande <code>dd</code> permet de copier tout ou partie d'un disque par blocs d'octets, indépendamment de la structure du contenu du disque en fichiers et en répertoires (source : [https://doc.ubuntu-fr.org/dd]).

Structure de la commande

dd if=<nowiki><source> of=<cible> bs=<taille des blocs></nowiki>

<code>source</code> = données à copier

<code>cible</code> = endroit où les copier

<code>if</code> = input file

<code>of</code> = output file

<code>bs</code> = block size, habituellement une puissance de 2 supérieure ou égale à 512, représentant un nombre d'octets

Choix de la commande:

Pour la source, on prends <code>/dev/zero</code>: cela permet de créer un fichier rempli de 0. Ce fichier servira de base pour notre système de fichiers.

Pour la cible, on va l'appeler <code>filesystem.bin</Code> : ce sera notre système de fichier.

Pour la taille des blocs, on veut des blocs de données de 256 octets d'après l'enoncé. On va donc prendre <code>bs=256</code>.

Enfin, on veut que le système de fichier réside dans un fichier de 8 Mo. On va donc ajouter <code>count=31250</code>: cela indique que nous voulons écrire 32768 blocs de données dans le fichier (31250 * 256 octets = 8 Mo).

Résultat:

dd if=/dev/zero of=filesystem.bin bs=256 count=31250

Question pour M. Redon : j'ai ici essayé de respecter votre remarque "pour la création du système de fichiers la commande <code>dd</code> suffit". Cependant, pour votre seconde remarque "vous chargez tout le superbloc et le répertoire racine, votre code ne convient pas.", je ne suis pas sûr de comprendre où je fais cela: est-ce lors de la commande dd ou est-ce par la suite avec mon programme C? J'ai un peu modifié la commande dd comme vous pouvez le voir ci-dessus. Ai-je corrigé mon erreur avec cette nouvelle commande? J'ai essayé de justifier au maximum la commande dd que j'ai choisie.

ReX : Pas de problème avec la commande <code>dd</code> (mettez tous les extraits de code entre des balises <code>code</code>). Le problème est au niveau du programme C.

Amine: Ok je comprends mieux merci. Je vais donc reprendre le code étape par étape afin de mieux répondre au cahier des charges.

Gestion du système de fichier par un programme C

'''Création des structures'''
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>

// Structure pour représenter un bloc de données

struct DataBlock {
uint8_t data[256]; // 256 octets pour chaque bloc de données
};

// Structure pour représenter un fichier

struct File {
char filename[17]; // 16 caractères pour le nom du fichier + 1 caractère null-terminator
struct DataBlock data_blocks[2040]; // Tableau de blocs de données pour stocker le contenu du fichier
uint16_t num_data_blocks; // Nombre de blocs de données utilisés par le fichier
};

// Structure pour représenter un répertoire

struct Directory {
struct File files[64]; // Tableau de fichiers pour le répertoire principal
uint8_t num_files; // Nombre de fichiers dans le répertoire principal
};

Modification faite : suite à votre remarque, j'ai explicité la taille des entiers grâce aux types de <code>stdint.h.</code> (j'ai également mis les variables en anglais)

ReX : Vous ne pouvez pas utiliser ces structures, une instanciation d'une de ces structure prend trop d'espace mémoire, vous devez faire sans structure. Par ailleurs la façon dont vous représentez vos fichiers ne convient pas, la description d'un fichier contient des numéros de blocs, pas les blocs eux-même. Faites aussi attention qu'un fichier soit décrit par un nombre entier de blocs.

Question pratique: je n'arrive pas à mettre tout le code dans le même bloc comme vous l'avez fait ci-dessus dans l'étape 4 de la semaine 1. Je vois que c'est en format "préformaté" mais j'obtiens des blocs séparés lorsque j'applique ce format à mon code.

ReX : j'ai corrigé, pour un code entier la syntaxe n'est pas la même (un espace en début de chaque ligne), la balise c'est uniquement pour de très courts extraits de code.

=== Fonction <code>readBlock</code>===
Cette fonction est utilisée pour lire un bloc de données à partir du fichier <code>filesystem.bin</code> et le stocker dans un tableau de caractères (<code>storage</code>).

Fonction:

#define BLOCK_SIZE 256
// Fonction pour lire un bloc de données
void readBlock(unsigned int num, int offset, unsigned char *storage, int size) {
FILE *file = fopen("filesystem.bin", "rb");
if (file == NULL) {
perror("Erreur lors de l'ouverture du fichier");
return;
}
fseek(file, num * BLOCK_SIZE + offset, SEEK_SET);
fread(storage, 1, size, file);
fclose(file);
}

Paramètres :

* <code>num</code> : Numéro du bloc à lire. Chaque bloc contient 256 octets (1 bloc = 256 octets).
* <code>offset</code> : Décalage (en octets) à partir du début du bloc pour commencer la lecture.
* <code>storage</code> : Pointeur vers un tableau de caractères où les données lues seront stockées.
* <code>size</code> : Taille du tableau de caractères <code>storage</code>.

Fonctionnement :

* La fonction commence par ouvrir le fichier <code>filesystem.bin</code> en mode lecture binaire (<code>"rb"</code>).
* Elle utilise <code>fseek</code> pour positionner le curseur de lecture dans le fichier à l'endroit approprié pour commencer la lecture du bloc spécifié (<code>num</code>) à partir de l'offset (<code>offset</code>).
* Elle utilise ensuite <code>fread</code> pour lire <code>size</code> octets à partir du fichier et les stocker dans le tableau <code>storage</code>.
* Enfin, elle ferme le fichier avec <code>fclose</code>.

Note : Le paramètre <code>offset</code> est utilisé pour spécifier à partir de quel octet du bloc on souhaite commencer la lecture. Si <code>offset</code> est égal à 0, la lecture commencera depuis le début du bloc. Si <code>offset</code> est différent de 0, la lecture commencera à l'octet spécifié.

Remarque: dans votre mail, vous définissez "readBlock(unsigned int num,int offset,unsigned storage,int size)": storage n'est alors pas un pointeur vers un tableau de caractère. Je me suis donc permis de faire la modification.

ReX : OK pour la fonction, pas la peine d'en mettre autant dans le Wiki pour une fonction aussi simple.

=== Fonction <code>writeBlock</code> ===
Cette fonction est utilisée pour écrire un bloc de données dans le fichier <code>filesystem.bin</code> à partir d'un tableau de caractères (<code>storage</code>).

Fonction:

// Fonction pour écrire un bloc de données
void writeBlock(unsigned int num, int offset, const unsigned char *storage, int size) {
FILE *file = fopen("filesystem.bin", "rb+");
if (file == NULL) {
perror("Erreur lors de l'ouverture du fichier");
return;
}
fseek(file, num * BLOCK_SIZE + offset, SEEK_SET);
fwrite(storage, 1, size, file);
fclose(file);
}

Paramètres :

* <code>num</code> : Numéro du bloc où écrire.
* <code>offset</code> : Décalage (en octets) à partir du début du bloc pour commencer l'écriture.
* <code>storage</code> : Pointeur vers un tableau de caractères contenant les données à écrire dans le fichier.
* <code>size</code> : Taille du tableau de caractères <code>storage</code>.

Fonctionnement :

* La fonction commence par ouvrir le fichier <code>filesystem.bin</code> en mode lecture et écriture binaire (<code>"rb+"</code>).
* Elle utilise <code>fseek</code> pour positionner le curseur de lecture/écriture dans le fichier à l'endroit approprié pour commencer l'écriture du bloc spécifié (<code>num</code>) à partir de l'offset (<code>offset</code>).
* Elle utilise ensuite <code>fwrite</code> pour écrire <code>size</code> octets à partir du tableau <code>storage</code> dans le fichier.
* Enfin, elle ferme le fichier avec <code>fclose</code>.

ReX : Même remarque que pour la fonction précédente.

'''Etape 4: test des fonctions <code>readBlock</code> et <code>writeBlock</code> dans le main'''
// Exemple de fonction principale pour tester les opérations de lecture et d'écriture
int main() {
unsigned char data[BLOCK_SIZE];
// Test de la fonction readBlock
readBlock(0, 0, data, BLOCK_SIZE);
printf("Block 0, offset 0: ");
for (int i = 0; i < BLOCK_SIZE; i++) {
printf("%02x ", data[i]);
}
printf("\n");
// Test de la fonction writeBlock
unsigned char newData[BLOCK_SIZE] = {
0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88,
// ... Autres données du bloc ...
};
writeBlock(1, 0, newData, BLOCK_SIZE);
// Lecture du bloc nouvellement écrit pour vérifier
readBlock(1, 0, data, BLOCK_SIZE);
printf("Block 1, offset 0: ");
for (int i = 0; i < BLOCK_SIZE; i++) {
printf("%02x ", data[i]);
}
printf("\n");
return 0;
}

Fonctionnement :

* On déclare tout d'abord un tableau de caractères <code>data</code> de taille <code>BLOCK_SIZE</code> pour stocker les données lues du bloc.
* Ensuite, la fonction <code>readBlock</code> est appelée avec les arguments (0, 0, data, BLOCK_SIZE) pour lire le premier bloc du fichier (<code>num=0</code>, <code>offset=0</code>) et stocker les données dans <code>data</code>.
* Ensuite, la fonction <code>printf</code> est utilisée pour afficher les données lues du bloc (<code>data</code>) en format hexadécimal.
* Ensuite, un nouveau tableau de caractères <code>newData</code> est créé avec des données spécifiques pour tester la fonction <code>writeBlock</code>.
* La fonction <code>writeBlock</code> est appelée avec les arguments (1, 0, newData, BLOCK_SIZE) pour écrire le tableau <code>newData</code> dans le deuxième bloc du fichier (<code>num=1</code>, <code>offset=0</code>).
* Enfin, la fonction <code>readBlock</code> est appelée à nouveau pour lire le deuxième bloc nouvellement écrit et afficher les données lues en format hexadécimal.

Question générale : ce que j'avais la première semaine n'est plus forcément d'actualité. Puis-je supprimer les choses qui ne le sont plus afin d'alléger la page ou préférez-vous que je laisse?

ReX : Laissez.

Pour la suite : j'ai donc pour l'instant crée deux fonctions, l'une permettant la lecture et l'autre l'écriture d'un bloc, de manière à économiser la mémoire. Pour la suite, je vais essayer de créer la fonction <code>LS</code> en utilisant la fonction <code>readBlock</code>.

ReX : Oui c'est le début du projet. Mais si vous n'avez pas une bonne description de fichier cela ne donnera rien. Voir remarques plus haut.

'''Etape 5: fonction <code>LS</code>'''

Objectif: créer la fonction <code>LS</code> avec la fonction readBlock.

Question: Souhaitez-vous la fonction <code>LS</code> classique, c'est à dire la fonction <code>LS</code> qui affiche simplement le nom des fichiers présent dans le répertoire ?

ReX : Oui. Tu peux ajouter la taille si tu trouves cela trop simple.

Piste : si c'est ce que vous voulez:

* il va tout d'abord falloir que je crée des fichiers, un fichier étant composé d'un nom et de blocs (création d'une fonction createFile)
* Il faudra ensuite que je stocke ces fichiers dans le répertoire (création d'une fonction addFileToDirectory par exemple)
* enfin, il faudra que j'affiche le nom des fichiers. Pour cela, il faudra que je parcours le répertoire (structure "Directory"), puis que pour chaque fichier présent dans le répertoire que j'affiche son nom (création de la fonction LS)

Je devrais surement utiliser la fonction readBlock afin de transférer les blocs dans le fichier au travers de la variable "storage".

ReX : Créer des fichiers n'est pas nécessaire tout de suite je verrais bien si ton code est bon sans test. Laisse tomber <code>createFile</code> et <code>addFileToDirectory</code> pour l'instant.

ReX : Ton algorithme ne fonctionne pas pour un microcontrôleur où il faut économiser la mémoire, tu ne peux pas t'aider de structures. Il faudra que tu charges les noms et seulement les noms, pour la taille il faudra se baser sur le nombre de blocs.

'''Etape 6: rectification du code suite à vos remarques'''

Modifications apportées:

* suppression des structures afin d’économiser de la mémoire.

* le problème quant à la description des fichiers est normalement résolu puisque plus de structures. On ne charge plus les blocs mais seulement les noms de fichiers.

ReX : Non car si les noms ne sont pas répartis de façon régulière dans les blocs de 256 octets tu vas avoir du mal à les charger. Mais écrit la fonction <code>LS</code> et tu verras ce que je veux dire.

J'ai également ajouté deux nouvelles fonctions:

# <code>void readFileName(unsigned int file_num, char *file_name)</code>: Cette fonction permet de lire le nom du fichier associé au numéro de fichier donné (<code>file_num</code>). Elle stocke le nom du fichier lu dans le tableau <code>file_name</code>.
# <code>void writeFileName(unsigned int file_num, const char *file_name)</code>: Cette fonction permet d'écrire le nom du fichier dans le système de fichiers, associé au numéro de fichier donné (<code>file_num</code>). Elle prend en entrée le nom du fichier à écrire (<code>file_name</code>).

Suite: si vous validez cette base, je pourrai passer à la création de la fonction LS.

ReX : tu peux y aller. Je ne vois pas le code des tes deux fonctions <code>readFileName</code> et <code>writeFileName</code>.

Voici le code des fonctions <code>readFileName</code> et <code>writeFileName</code> :

'''Fonction readFileName:'''
// Fonction pour lire le nom du fichier
void readFileName(unsigned int file_num, char *file_name) {
readBlock(file_num, 0, (unsigned char *)file_name, MAX_FILENAME_LENGTH);
file_name[MAX_FILENAME_LENGTH] = '\0'; // Ajout du caractère null-terminator pour former une chaîne de caractères
}

ReX : Non, aucune raison que le fichier de numéro n soit au bloc n. Dessine la représentation d'un fichier sur le SF en comptant les octets si cela peut aider.

'''Fonction writeFileName:'''
// Fonction pour écrire le nom du fichier
void writeFileName(unsigned int file_num, const char *file_name) {
writeBlock(file_num, 0, (const unsigned char *)file_name, MAX_FILENAME_LENGTH);
}

ReX : Faux et inutile pour l'instant. Problème avec la constante MAX_FILENAME_LENGTH.

=== Fonction LS version 1 ===
// Fonction LS pour afficher les fichiers présents dans le système de fichiers
void LS(const char *filesystem_path) {
FILE *file = fopen(filesystem_path, "rb");
if (file == NULL) {
perror("Erreur lors de l'ouverture du fichier système");
return;
}
uint16_t num_files;
fread(&num_files, sizeof(uint16_t), 1, file); // Lecture du nombre de fichiers dans le système
char filename[17];
printf("Fichiers présents dans le système de fichiers:\n");
for (int i = 0; i < num_files; i++) {
readFileName(i, filename); // Lecture du nom du fichier
printf("%s\n", filename); // Affichage du nom du fichier
}
fclose(file);
}
La fonction <code>LS</code> ouvre le fichier système, lit le nombre de fichiers qu'il contient, puis affiche les noms des fichiers un par un, chacun sur une ligne séparée.

ReX : Il y a le nombre de fichiers dans ton superbloc ? Un dessin du format du superbloc avec les numéros des octets ?

ReX : Tout accès au système de fichiers doit se faire avec les deux fonctions <code>readBlock</code> et <code>writeBlock</code>.

== Semaine 3 ==
Question 1: cela fait plusieurs fois que vous mentionnez dans le wiki un "superbloc". Celui-ci n'étant pas clairement défini dans le sujet, je me demande s'il s'agit du bloc crée grâce à la fonction dd, c'est à dire que le superbloc serait en faite le bloc constitué des 31250 blocs de taille 256 octets, où s'il s'agit d'un bloc qui vient en entête, celui contenant alors des informations décrivant le système de fichier (les noms de fichiers...).

ReX : Pour ton pico système de fichiers, le superbloc consiste en les premiers blocs (de 256 octets) qui définissent les 64 fichiers possibles.

Proposition de structure: on pourrait réserver les premiers blocs du système de fichiers aux noms de fichiers ainsi qu'aux numéros des blocs correspondant à chaque fichier.

ReX : Oui c'est évident.

On sait que les noms de fichiers font au maximum 16 caractères + 1 caractère pour le '\0' (donc 17 octets car 1 char=1 octet).

ReX : Non, 16 octets suffisent, des '\0' en fin de nom uniquement si le nom fait moins de 16 caractères.

On sait également qu'un fichier contient au maximum 2040 blocs, chaque bloc étant numéroté sur 2 octets. On pourrait donc avoir en début du système de fichier: 17 octets+2 octets*2040 blocs = 4097 octets pour la description d'un fichier.

ReX : Non, 4096 octets soit 16 blocs de 256.

Or d'après l'une de vos remarques dans le wiki, un fichier doit être décrit par un nombre entier de blocs. Pour un fichier, il nous faudra donc 4097/256=16.004 soit 17 blocs. Il peut y avoir jusqu'à 64 fichiers dans le répertoire, il nous faudra donc 17 blocs*64 fichiers= 1088 blocs pour la description des fichiers.

ReX : Non 1024 blocs de 256 octets dans le superbloc.

Ainsi, pour la fonction LS, il suffira de lire les premiers caractères tous les 17 blocs ( du premier caractère au caractère '\0').

ReX : Non, tous les 16 blocs.

Question 2: Ne faudrait-il pas également stocker quelque part le nombre de fichier qu'il y a dans le répertoire afin de savoir jusqu'à quel bloc la fonction LS doit aller ?

ReX : Non, un fichier dont le nom n'est constitué que de '\0' est réputé ne pas exister.

Question 3: on a donc vu que les 1088 premiers blocs au maximum serviraient à la description du système de fichier. Il reste donc 31250-1088=30132 blocs dans le système de fichier.

ReX : Non, 32768-1024=31744 blocs.

Comment utiliser ces blocs? Ces blocs doivent-ils stocker le contenu des fichiers ?

ReX : Oui, c'et évident.

En effet, avec la fonction TYPE, nous allons créer des fichiers et ces fichiers devront être stockés quelque part. Cependant, étant donné que ce pico système de fichiers est prévu pour un microcontrôleur, je ne sais pas si c'est le contenu des fichiers qui doit être stocké dans les blocs ou autre chose (peut être l'adresse des fichiers, le fichiers se trouvant autre part). En effet, je me dis que si un fichier est très volumineux, il ne pourra pas rentrer dans le système de fichier, ce dernier étant composé d'un nombre limité de blocs, et les blocs étant eux même limité en nombre d'octets.

ReX : Je ne comprend pas ton problème. De tout façon comme dit plus haut, les 31744 blocs suivant le superbloc doivent contenir les données des fichiers.

Désolé de poser des questions peut être basique aussi tard, mais je pense qu'une fois que j'aurai ces réponses, cela ira beaucoup mieux pour la suite. Merci d'avance pour vos réponses.

ReX : Les questions sont effectivement triviales et il est effectivement inquiétant que voir que la travail n'avance pas.

Amine: merci pour vos corrections.

D'après votre commentaire "32768-1024=31744 blocs", j'en déduis qu'il faut que je modifie ma commande dd (qui est actuellement "dd if=/dev/zero of=filesystem.bin bs=256 count=31250" pour avoir le bon filesystem).

ReX : Je comprends pas d'où tu sors le 31250. D'autant plus que la commande ci-dessous est bonne.

Amine : 31250 car 31250 blocs * 256 octets = 8 Mo.

ReX : Haaaa je vois tu utilises le système métrique international où le mégaoctet vaut 10^6 octets, sauf qu'aucun informaticien n'utilisera cette norme hors sol. Quand je parle de 8 Mo c'est 8x1024x1024 octets. Tout simplement parce qu'une puce mémoire de 8 Mo c'est bien 8x1024x1024 octets.

Amine: D'accord merci pour l'information !

'''Nouvelle commande dd:'''

dd if=/dev/zero of=filesystem.bin bs=256 count=32768

=== Fonction LS version 2 ===

Dans notre structure du système de fichier, le superbloc est constitué de 1024 blocs (16 blocs * 64 fichiers), un fichier étant décrit par 16 blocs. Le nom du fichier est donc écrit au début de tous les blocs multiples de 16. Par exemple, le nom du premier fichier est dans les 16 premiers octets du premier bloc, le nom du 2ème fichier est dans les 16 premiers octets du 32ème bloc et ainsi de suite, tant que des fichiers existent. Lorsque qu'il n'y a plus de fichier, le nom du premier caractère du bloc multiple de 16 est un 0.

Voici le code:
// Fonction pour lister les noms de fichiers présents dans le système de fichiers
void LS() {
unsigned char buffer[BLOCK_SIZE];
int fileCount = 0;

for (int blockNum = 1; blockNum <= MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, BLOCK_SIZE);

// Vérifier si le bloc est vide
if (buffer[0] == 0) {
break; // Plus de fichiers à lire
}

char filename[MAX_FILENAME_LENGTH];
memcpy(filename, buffer, MAX_FILENAME_LENGTH);

// Afficher le nom du fichier
printf("%s\n", filename);
fileCount++;
}

if (fileCount == 0) {
printf("Aucun fichier trouvé.\n");
}
}

ReX : Tu supposes que si un fichier a un nom vide, les suivants auront aussi un nom vide. C'est possible mais dans ce cas la commande <code>RM</code> ca être plus compliquée à écrire.

ReX : Tu ne sembles pas comprendre que la mémoire d'un microcontrôleur est limitée. Pourquoi lire le premier bloc de description d'un fichier en entier ? Dit autrement c'est quoi l'intérêt de lire 256 octets alors que 16 suffisent ?

ReX : Pourquoi tu ne lis pas le premier fichier ? Autrement dit pourquoi décaler tout d'un bloc ?

Amine: Merci pour vos remarques. J'ai apporté les modifications à LS dans la section "Semaine 4" du wiki.

'''Réflexion par rapport aux autres fonctions:'''

J'ai créé les fonctions TYPE et CAT mais il y a malheureusement un problème pour l'instant. Vous pouvez les retrouver en pièce jointe dans l'archive du fichier programme.c.

Le problème que j'ai est que lorsque j'affiche le contenu du fichier créé avec TYPE, j'obtiens plein de caractères spéciaux. Par exemple, je créé le fichier "mon_fichier.txt" avec la fonction TYPE, et je mets en entré standard "hello". Ensuite, je veux afficher le contenu de ce fichier grâce à la fonction CAT. Cependant, ce qui s'affiche dans le terminal n'est pas ce que je veux. De la même manière, lorsque je fais la commande "cat filesystem.bin" dans le terminal, c'est la même chose s'affiche, des donnés parasites.

ReX : Avant même de lire ton code je vais te poser la question de savoir comment tu récupères un bloc libre ? Quel algorithme tu utilises. Personnellement je ne sais pas faire sans ajouter au superbloc un tableau bit à bit des blocs libres. Pour avoir un bit pour chaque bloc du système de fichiers, il faut 32768/8=4096 octets soit 16 blocs.

Amine: ok je vais donc ajouter ce tableau de 16 blocs à la suite de mes premiers 1024 blocs servant à la description de fichier. Le superbloc fera maintenant 1024+16=1040 blocs (plus de détail à la fonction RM de la semaine 4).

Question 1: est ce que la fonction CAT que je dois créer doit renvoyer la même chose que "cat filesystem.bin" ?

ReX : Je préfère ne pas répondre tellement la question montre un manque de réflexion.

Question 2: comment savoir combien de blocs doivent etre attribué à un fichier? Par exemple, si je créé un fichier "mon_fichier.txt" et que je mets en entrée standard le texte "hello", un seul bloc suffi pour stocker ce texte. Cependant, si j'avais mis beaucoup de texte en entrée standard, il aurait fallu plus de blocs. Doit-on calculer la taille de l'entrée standard ou doit-on attribuer toujours le meme nombre de blocs à un fichier? Peut-etre ainsi attribuer 2040 blocs par fichier, meme s'il n'en utilise que 1.

ReX : Là encore c'est une question stupéfiante tellement la réponse est évidente. Il suffit de lire les données sur l'entrée standard et de passer au bloc de données suivant dès que le bloc courant est rempli. La question à poser c'était de se demander comment il est possible d'avoir la taille exacte du fichier pour un <code>CAT</code>. Il est uniquement possible de l'avoir à 256 octets près puisque rien n'indique si le dernier block est vide. Le mieux aurait été de prévoir 4 octets dans la description d'un fichier pour stocker la taille. En l'espèce on considérera que les fichiers sont des fichiers ASCII et qu'ils seront terminés par des <code>\'0</code> qui ne seront pas affichés.

== Semaine 4 ==

Voici un bilan de ce que j'ai fait à ce stade du projet:

* j'ai choisi une structure du système de fichier
* j'ai créé les fonctions readBlock et writeBlock permettant de lire et d'écrire des blocs
* j'ai crée la fonction LS permettant d'afficher le nom des fichiers présents dans le système de fichiers
* j'ai programmer un main permettant d'utiliser les fonctions (LS, TYPE...) depuis le terminal
* j'ai réflechi aux fonctions TYPE et CAT.

Actuellement, je suis en train de créer les fonctions TYPE et CAT.

=== Fonction LS version 3 ===
void LS() {
unsigned char buffer[MAX_FILENAME_LENGTH];
int fileCount = 0;

// Parcourir tous les 16 blocs de 0 jusqu'à MAX_FILES_IN_DIRECTORY
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, MAX_FILENAME_LENGTH);

// Vérifier si le nom de fichier est vide
if (buffer[0] != 0) {

// Afficher le nom du fichier
printf("%s\n", buffer);
fileCount++;
}
}

if (fileCount == 0) {
printf("Aucun fichier trouvé.\n");
}
}
Suite à vos remarques, j'ai effectué les modifications suivantes de la fonction LS:

* Je ne suppose plus que si un fichier a un nom vide, les autres auront aussi un nom vide.
* Je ne lis plus les 256 octets mais seulement les 16 premiers octets car cela suffit.
* Je ne lisais en effet pas le premier bloc. Je pensais que le premier bloc était d'indice 1 mais ce n'est pas le cas.

ReX : Ouiiii ! Une fonction correcte. Passe à <code>RM</code> maintenant, c'est la plus facile à faire concernant l'image bit à bit des blocs libres.

=== Fonction setBlockAvailability version 1 ===

Comme vous l'avez indiqué dans votre remarque, il faut un tableau dans le superbloc qui nous permettra de connaitre la disponibilité bit par bit de chaque bloc. Sachant qu'il y a dans notre système de fichiers 32768 blocs, et qu'il faut 1 bit par bloc, nous avons besoin de 32768 bits, soit 32768/8=4096 octets soit 4096/256=16 blocs. Notre superbloc sera donc comme suit: les 1024 premiers blocs servent à la description des fichiers, c'est à dire à leur nom suivi des numéros de blocs qui leur sont associés, puis ces 1024 blocs sont suivi de 16 blocs listant la disponibilité de chaque bloc.

ReX : Bien résumé.

Nous allons tout d'abord écrire la fonction "setBlockAvailability" prenant en paramètre le numéro du bloc à traiter (<code>blockNum</code>) et la disponibilité souhaitée pour ce bloc (<code>availability</code>). Cette fonction permet de marquer la disponibilité d'un bloc spécifique dans le système de fichiers. Nous utiliserons la convention suivante: un bloc disponible sera marqué par un 1 tandis qu'un bloc non disponible par un 0.
#define SUPERBLOCK_START_BLOCK 1024

void setBlockAvailability(int blockNum, int availability) {
// Calculer l'index du byte et le bit offset correspondant
int byteIndex = blockNum / 8;
int bitOffset = blockNum % 8;

// Lire le byte existant du bloc de disponibilité des blocs
unsigned char buffer[1];
readBlock(SUPERBLOCK_START_BLOCK + byteIndex, 0, buffer, 1);

// Mettre à jour le bit d'offset correspondant
if (availability) {
buffer[0] |= (1 << bitOffset);
} else {
buffer[0] &= ~(1 << bitOffset);
}

// Écrire le byte mis à jour dans le bloc de disponibilité des blocs
writeBlock(SUPERBLOCK_START_BLOCK + byteIndex, 0, buffer, 1);
}

ReX : Un tableau de un octet c'est un octet (variable <code>buffer</code>).

Amine: je vais utiliser un <code>unsigned char buffer.</code> Je suis conscient qu'un char vaut un octet mais je ne pense pas qu'il y ait un type de donnée de la taille d'un bit, c'est pourquoi je travaille avec un octet mais je modifie les bits de cet octet grâce aux algorithmes.

ReX : Il faut bien que tu travailles sur un octet vu que l'état des blocs est stocké sous la forme d'octets. Je disais juste qu'un tableau de 1 élément n'a pas d'intérêt par rapport à l'élément lui-même.

Amine: c'est vrai, modification faite.

ReX : Non il faut calculer le numéro du bloc avant de faire le <code>readBlock</code>.

Amine: ok je vais calculer le numéro de bloc avant.

ReX : La mise à jour du bit est correcte mais le block et le déplacement dans le block ne sont pas correctement calculés.

Amine: je vais vous expliquer le raisonnement que j'avais. Prenons un exemple concret, imaginons que je veuille marquer le bloc 1030 comme disponible:

# Calcul de l'index de l'octet et du bit offset :
#* <code>blockNum</code> = 1030
#* Index du byte = 1030 / 8 = 128
#* Bit offset = 1030 % 8 = 6
# Lecture de l'octet existant de disponibilité:
#* Nous lisons l'octet existant à l'index 128 dans les blocs de disponibilité.
# Mise à jour du bit de disponibilité :
#* Nous voulons marquer le bloc 1030 comme disponible, donc nous utilisons le masque <code>(1 << 6)</code> pour définir le bit 6 à 1 dans l'octet. Le résultat sera, par exemple, <code>00100000</code>.
# Écriture du byte mis à jour :
#* Nous écrivons le byte mis à jour <code>00100000</code> à l'index 128 dans les blocs de disponibilité.

ReX : Ben non, un vrai exemple :
* Il faut prendre un n° de bloc plus grand : 3072 ;
* Numéro d'octet dans la carte des blocs libres : 3072/8=384 ;
* Numéro du bloc dans la carte des blocs libres : 384/256=1 ;
* Numéro du bit <code>b</code> dans l'octet n° 384-256=128 du bloc 1 : 3072%8=0 ;
* Il faut donc lire l'octet <code>o</code> de numéro 128 du bloc 1, puis modifier cet octet par <code>o |= (1<<b)</code> ou <code>o &= ~(1<<b)</code> ;
* Enfin il faut écrire l'octet modifié dans le bloc 1.
Amine: merci pour cet exemple! J'ai compris d'où vient mon erreur. Voir fonction setBlockAvailability version 3.

Remarque: par convention, j'apellerai dans la suite de ce projet "premier superbloc" le superbloc correspondant à la description des fichiers, c'est à dire les 1024 premiers blocs, et j'appellerai "second superbloc" les 16 blocs qui suivent servant à décrire la disponibilité des blocs (du bloc 1024 au bloc 1039 inclu). Le reste des blocs servira à stocker les données.

ReX : Non, le superblc est l'ensemble des informations hors blocs de données, tu ne peux pas utiliser un vocabulaire au hasard. Parle de blocs de description des fichiers ou de carte des blocs libres.

Amine: ok

Je pense que le problème qui se pose est que l'indice du bit dans le second superbloc ne correspond pas à l'indice du bloc dans le système de fichier. Par exemple, nous voudrions que si le bloc 1030 est disponible dans le système de fichier, alors le bit numéro 1030 du deuxième superbloc soit à 1, ce qui n'est pas le cas ici. En effet, on se trouve bien dans le bon octet avec ma méthode mais l'écriture du bit se fait de la droite vers la gauche alors qu'on voudrait l'inverse. Ainsi, si le 6ème bit de l'octet doit être à 1, alors il faudrait qu'on obtienne <code>00000100</code> et non <code>00100000.</code> L'indice du bit coinciderait ainsi avec le numéro du bloc.

ReX : Non, réfléchit à nouveau.

Voir plus bas la nouvelle version de setBlockAvailability.

Explication de l'algorithme pour mettre le bit à 1 ou 0:

* <code>buffer[0] |= (1 << bitOffset);</code> : Cette ligne utilise l'opérateur OR bit à bit (<code>|=</code>) pour activer (mettre à 1) le bit spécifié par <code>bitOffset</code> dans le premier octet (<code>buffer[0]</code>). Cela se fait en décalant le bit 1 vers la gauche de <code>bitOffset</code> positions, puis en effectuant une opération OR bit à bit avec le contenu actuel de <code>buffer[0]</code>. Cette opération modifie uniquement le bit ciblé, laissant les autres bits inchangés.

ReX : Oui ça c'est bon.

* <code>buffer[0] &= ~(1 << bitOffset);</code> : Cette ligne utilise l'opérateur AND bit à bit (<code>&=</code>) pour désactiver (mettre à 0) le bit spécifié par <code>bitOffset</code> dans <code>buffer[0]</code>. Pour ce faire, l'expression <code>~(1 << bitOffset)</code> est utilisée pour créer un masque où tous les bits sont à 1, sauf celui correspondant à <code>bitOffset</code>, qui est à 0. En effectuant ensuite une opération AND bit à bit entre le masque et le contenu actuel de <code>buffer[0]</code>, on met à 0 le bit ciblé sans affecter les autres bits.

ReX : Ca aussi.

=== Fonction setBlockAvailability version 2 ===

void setBlockAvailability(int blockNum, int availability) {
// Calculer l'indice de l'octet et le bit offset correspondant
int byteIndex = blockNum / 8;
int bitOffset = 7 - (blockNum % 8); // Inversion de l'ordre des bits

// Calculer le numéro du bloc du super bloc où se trouve l'octet de disponibilité correspondant
int availabilityBlockNum = SUPERBLOCK_START_BLOCK + byteIndex;

// Lire l'octet existant dans le bloc de disponibilité du super bloc
unsigned char buffer;
readBlock(availabilityBlockNum, 0, &buffer, 1);

// Mettre à jour le bit d'offset correspondant :
if (availability) {
buffer |= (1 << bitOffset);
} else {
buffer &= ~(1 << bitOffset);
}

// Écrire l'octet mis à jour dans le bloc de disponibilité du super bloc
writeBlock(availabilityBlockNum, 0, &buffer, 1);
}
J'ai modifié la ligne <code>int bitOffset = 7 - (blockNum % 8);</code> pour inverser l'ordre des bits sélectionnés, de sorte que le bit correspondant au bloc disponible soit correct.

ReX : Encore plus faux.

Si on veut rendre le bloc 1030 indisponible alors que les autres blocs sont disponibles:

ReX : Pardon ? Le bloc de données est libre ou pas suivant la carte des blocs libres. Le rendre disponible n'est possible que si un fichier le comportant est détruit.

# Calcul de l'indice de l'octet et du bit offset correspondant :
#* <code>blockNum = 1030</code>
#* <code>byteIndex = 1030 / 8 = 128</code>
#* <code>bitOffset = 7 - 1030 % 8 = 1</code> Cela signifie que le bit d'intérêt se trouve à la position 2 dans l'octet.
# Calcul du numéro du bloc du super bloc où se trouve l'octet de disponibilité correspondant :
#* <code>availabilityBlockNum = SUPERBLOCK_START_BLOCK + 128 = 1024 + 128 = 1152</code> Donc, nous devons accéder à l'octet 1152 pour mettre à jour la disponibilité du bloc 1030.
# Lecture de l'octet existant dans le bloc de disponibilité du super bloc :
#* Le contenu de l'octet dans le bloc 1152 avant la mise à jour : 11111111 (en binaire)
# Mise à jour du bit d'offset correspondant :
#* Supposons que nous voulions marquer le bloc 1030 comme non disponible (<code>availability = 0</code>).
#* Le bitOffset est 1.
#* Nous effectuons une opération AND avec le complément du bit à la position 1 : <code>11111111 & 11111101 = 11111101</code>
# Écriture de l'octet mis à jour dans le bloc de disponibilité du super bloc :
#* Le contenu de l'octet 128 du second superbloc après la mise à jour : 11111101 (en binaire)

ReX : Toujours aussi faux.

Maintenant, le bit d'indice 1 du 128 ème octet du second superbloc est mis à 0, indiquant que le bloc 1030 n'est plus disponible. Les autres bits restent inchangés car nous avons effectué un AND avec un masque binaire qui avait des 1 partout sauf à la position du bit que nous souhaitions mettre à 0.

ReX : Erreur sur erreur.

=== Fonction setBlockAvailability version 3 ===
J'ai compris d'où vient l'erreur. La fonction readBlock prends en premier paramètre le numéro du bloc à lire, je ne peux donc pas lui donner la valeur "SUPERBLOCK_START_BLOCK + byteIndex" car byteIndex s'exprime en octet alors qu'on s'attend à un nombre de bloc ici. Il faut donc divisé byteIndex par 256 pour être en unité "bloc", et préciser le bit qu'on veut lire grâce à l'offset.

Pour obtenir l'octet que l'on veut, il faut prendre le reste de la division de byteIndex par 256. On va ensuite stocker cet octet dans notre "buffer".

Pour savoir quel bit modifier dans ce "buffer", on va prendre le reste de la division du bloc dont on veut mettre à jour la disponibilité par 8. On va ainsi pouvoir modifier ce bit grâce à l'algorithme, puis réécrire l'octet à son emplacement d'origine.

Cette fonction gère la carte de disponibilités des blocs. Si un bloc est disponible, alors elle le met un 0, si il est indisponible, elle met un 1.
#define SUPERBLOCK_START_BLOCK 1024

void setBlockAvailability(int blockNum, int availability) {

int byteIndexInCard = blockNum / 8; //Numéro d'octet dans la carte des blocs libres
int blockIndexInCard = byteIndexInCard / 256; //Numéro du bloc dans la carte des blocs libres
int byteIndexInBlock = byteIndexInCard % 256; //Numéro d'octet dans le bloc contenant le bit de disponibilité
int bitOffset = blockNum % 8; //Numéro du bit dans l'octet n°byteIndexInBlock du bloc blockIndexInCard

//indice du bloc contenant le bit à mettre à jour dans le bloc de description
int availabilityBlockNum = FIRST_DISPONIBILITY_CARD_BLOCK + blockIndexInCard;

// Lire l'octet existant dans le bloc de disponibilité du super bloc
unsigned char buffer;
readBlock(availabilityBlockNum, byteIndexInBlock, &buffer, 1);

// Mettre à jour le bit d'offset correspondant :
if (availability==1) { // indisponible
buffer |= (1 << bitOffset); // Mettre le bit à 1

} else { // disponible
buffer &= ~(1 << bitOffset); // Mettre le bit à 0
}

// Écrire l'octet mis à jour dans le bloc de disponibilité du super bloc
writeBlock(availabilityBlockNum, byteIndexInBlock, &buffer, 1);
}

ReX : Ben voila, c'est pas possible de te taxer d'excès de vitesse mais c'est bon.

update: j'ai fait une petite modification, maintenant un bloc disponible est marqué d'un 0 et un bloc indisponible est marqué d'un 1. C'est mieux dans la mesure où initialement, tous les blocs sont disponibles et tous les blocs sont à 0. Cela évite de devoir créer une fonction qui initialise toute la carte de disponibilités à 1 pour dire que tous les blocs sont disponibles.

=== Fonction RM version 1 ===

void RM(const char *filesystem_path, const char *filename) {
unsigned char buffer[BLOCK_SIZE];
int fileNum = -1;

// Parcourir les blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (memcmp(filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {
// Effacer le nom du fichier dans le superbloc
memset(filenameBuffer, 0, MAX_FILENAME_LENGTH);
writeBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

unsigned char fileBuffer[MAX_BLOCKS_PER_FILE * 2];
readBlock(blockNum, MAX_FILENAME_LENGTH, fileBuffer, MAX_BLOCKS_PER_FILE * 2);

// Libérer les blocs associés au fichier et réinitialiser les numéros de blocs
for (int i = 0; i < MAX_BLOCKS_PER_FILE * 2; i += 2) {
int blockNum = ((int)fileBuffer[i] << 8) + (int)fileBuffer[i + 1];
if (blockNum == 0) {
break; // Fin du fichier
}
setBlockAvailability(blockNum, 0); // Marquer le bloc comme disponible
fileBuffer[i] = 0;
fileBuffer[i + 1] = 0;
}

// Mettre à jour les numéros de blocs associés au fichier
writeBlock(blockNum, MAX_FILENAME_LENGTH, fileBuffer, MAX_BLOCKS_PER_FILE * 2);

fileNum = blockNum;
break; // Fichier trouvé, sortir de la boucle
}
}

// Afficher le résultat de l'opération
if (fileNum == -1) {
printf("Le fichier \"%s\" n'a pas été trouvé.\n", filename);
} else {
printf("Le fichier \"%s\" a été supprimé avec succès.\n", filename);
}
}

ReX : Vous utilisez <code>strcmp</code> comme <code>strncmp</code>. C'est bien la dernière qu'il faut utiliser mais en précisant la longueur du nom en paramètre, pas la taille maximale.

Amine: vous voulez dire que j'utilise memcmp au lieu de strncmp ? Ok je vais utiliser strncmp, c'est vrai que c'est plus adapté pour la comparaison de chaines de caractère.

ReX : Ha oui c'est <code>memcmp</code> que tu utilises. Ca ne peut effectivement pas marcher. Effectivement avec <code>strncmp</code> cela peut marcher vu qu'il s'arrête au premier 0 contrairement à <code>memcmp</code>.

Cependant, pourquoi doit-on passer la taille exacte du nom du fichier en paramètre, et non la taille maximale d'un nom de fichier? En effet, cela semble fonctionner en mettant la taille maximale en paramètre, tandis que lorsque l'on met la taille exacte du nom du fichier, cela pose un problème: on ne compare plus toute la chaîne de caractère mais seulement une portion du nom complet. Ainsi, si je crée par exemple un fichier que j'appelle "file1", puis que j’exécute la fonction RM "/picofs filesystem.bin RM file" par exemple, alors le fichier file1 va être supprimé quand même car on ne comparera que strlen(file)=4 premiers caractères, qui sont les mêmes, donc la fonction considérera ces chaines comme identiques. On pourrait alors se dire qu'il faudrait alors prendre plutôt comme taille en paramètre de la fonction strlen la taille du nom du fichier se trouvant dans le système de fichier plutôt que celle du nom donné en paramètre de RM. Cependant, le même problème se pose si la taille du nom du fichier du système de fichier est plus petite que celle du nom du fichier passé en paramètre. Par exemple, si le fichier présent dans système de fichier est "file", et qu'on met la longueur de file en paramètre de la fonction strcmp, puis qu'on exécute la commande "/picofs filesystem.bin RM file5", alors file sera quand même supprimé, car on ne comparera que les strlen(file)=4 premiers caractère. Finalement, une solution serait de rajouter une condition qui vérifie que les deux chaînes sont de taille identiques pour pouvoir réaliser la comparaison sur la taille exacte du nom du fichier. Cependant, il me semble qu'en mettant MAX_FILENAME_LENGTH qui vaut 16 en paramètre, cela fonctionne directement. Vous pouvez tester cela en testant mon programme.

ReX : Ok pour <code>strncmp</code> avec la taille maximale d'un nom de fichier.

etape 1: créer un fichier :
./picofs filesystem.bin TYPE fichier.txt

etape 2: verifier que le fichier a bien été créé :
./picofs filesystem.bin LS

Le terminal renvoie bien "fichier.txt"

etape 3: essayer de supprimer le fichier en mettant une chaine troncature du nom du fichier créé :
./picofs filesystem.bin RM fich

le terminal renvoi <<Le fichier "fich" n'a pas été trouvé.>>, le fichier n'a donc pas été supprimé .

etape 4: essayer de supprimer le fichier en mettant un nom plus grand incluant "fichier.txt" :
./picofs filesystem.bin RM fichier.txtt

terminal renvoi <<Le fichier "fichier.txtt" n'a pas été trouvé.>>

etape 5: enfin, tester en mettant le nom exacte du fichier que l'on veut supprimer :
./picofs filesystem.bin RM fichier.txt

terminal renvoi <<Le fichier "fichier.txt" a été supprimé avec succès.>>

Finalement, on voit que cela fonctionne avec la taille maximale mise en paramètre. On pourrait reprocher à cette méthode de comparer des caractères dans le vide, ce qui n'est pas optimal dans une optique d'économie de mémoire qui est la notre, mais la taille maximale d'un nom de fichier étant relativement faible (16 octets), on peut peut-être négliger cela au vu de l'économie d'une opération supplémentaire (comparaison de la taille des chaines de caractères).

ReX : Le parcours des blocs de données du fichier est atroce. Il faut parcourir les numéros de blocs dans le premier bloc du fichier derrière le nom du fichier puis il faut parcourir le 15 autres blocs.

Amine: Ok, je vais corriger cela dans la version 2 de RM (voir semaine 5).

Fonctionnement de la fonction RM:

* Parcours des blocs réservés pour la description des fichiers (superbloc) à partir du bloc 0, en incrémentant de 16 à chaque itération pour accéder aux blocs de noms de fichiers.

ReX : OK.

* Dans chaque bloc de noms de fichiers, la fonction compare le nom de fichier recherché avec les noms stockés dans les 16 octets de chaque bloc.

ReX : Non la fonction ne fait pas ça par contre il faudrait, oui.

Amine: Je pensais que c'était ce que je faisais avec "memcmp(filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0)".

* Si le nom de fichier est trouvé, la fonction efface le nom du fichier dans le superbloc en remplaçant les 16 octets du bloc par des zéros.

ReX : OK.

* Ensuite, la fonction accède aux octets suivants du même bloc pour obtenir les numéros de blocs associés au fichier.

ReX : Non, la boucle sort largement du premier bloc.

* Pour chaque paire de numéros de blocs (2 octets chacun), la fonction convertit les octets en un numéro de bloc. Si le numéro de bloc est nul, cela signifie la fin des blocs associés au fichier, sinon, la fonction marque ce bloc comme disponible en utilisant la fonction <code>setBlockAvailability</code> et réinitialise les numéros de blocs dans le tableau à zéro.
* Les numéros de blocs réinitialisés sont ensuite réécrits dans le bloc de description du fichier.

ReX : L'idée est là mais vu que la boucle n'est pas bonne, rien ne peut marcher.

* La fonction affiche ensuite un message indiquant le résultat de l'opération : soit que le fichier a été supprimé avec succès, soit que le fichier n'a pas été trouvé.

== Semaine 5 ==

=== Fonction RM version 2 ===

Concernant les remarques que vous m'avez faites précédemment:

* j'utilise maintenant la fonction <code>strncmp</code> pour la comparaison des chaines de caractères
* j'ai normalement corrigé le parcours des blocs. Je parcours maintenant d'abord les blocs multiples de 16 à la recherche du bloc contenant le nom du fichier à supprimer. Puis je parcours les 16 blocs de description du fichier à supprimer, afin de récupérer les numéros de blocs, libérer ces blocs dans la carte de disponibilité et de réinitialiser ces blocs dans les blocs de données.

void RM(const char *filesystem_path, const char *filename) {
int fileFound = -1;
int offset;

// Parcourir les blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char*)filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {

// Effacer le nom du fichier dans le superbloc
memset(filenameBuffer, 0, MAX_FILENAME_LENGTH);
writeBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);
fileFound = 1;
offset = blockNum;
break;
}

}

// Fin de fonction si fichier inexistant
if (fileFound == -1) {
printf("Le fichier \"%s\" n'a pas été trouvé.\n", filename);
return;
}

unsigned char buffer[BLOCK_SIZE];
//bloc que l'on va remplir de 0 et mettre à la place des blocs de données
memset(buffer, 0, BLOCK_SIZE); //on rempli buffer de 0

for (int blockNum=offset; blockNum<offset + 16; blockNum++) {

//premier bloc de description, celui contenant le nom du fichier dans les 16 premiers octets
if (blockNum == offset) {

unsigned char fileBuffer[BLOCK_SIZE-MAX_FILENAME_LENGTH];
//bloc dans lequel on va stocker les blocs de description de fichier
readBlock(blockNum, MAX_FILENAME_LENGTH, fileBuffer, BLOCK_SIZE-MAX_FILENAME_LENGTH);

// Libérer les blocs associés au fichier dans la carte de disponibilités
// et dans les blocs de description
for (int i = MAX_FILENAME_LENGTH; i < BLOCK_SIZE-MAX_FILENAME_LENGTH; i += 2) {
int blockNumData = ((int)fileBuffer[i] << 8) + (int)fileBuffer[i + 1];
if (blockNumData == 0) {
break; // Fin du fichier
}
setBlockAvailability(blockNumData, 0); // Marquer le bloc comme disponible
fileBuffer[i] = 0;
fileBuffer[i + 1] = 0;
writeBlock(blockNumData, 0, buffer, BLOCK_SIZE); //on efface les blocs de données
}
writeBlock(blockNum, MAX_FILENAME_LENGTH, fileBuffer, BLOCK_SIZE-MAX_FILENAME_LENGTH);
//on efface le premier bloc de description

} else {
unsigned char fileBuffer[BLOCK_SIZE];
readBlock(blockNum, 0, fileBuffer, BLOCK_SIZE);

// Libérer les blocs associés au fichier dans la carte de disponibilités et dans les blocs de description
for (int i = 0; i < BLOCK_SIZE; i += 2) {
int blockNumData = ((int)fileBuffer[i] << 8) + (int)fileBuffer[i + 1];
if (blockNumData == 0) {
break; // Fin du fichier
}
setBlockAvailability(blockNumData, 0); // Marquer le bloc comme disponible
fileBuffer[i] = 0;
fileBuffer[i + 1] = 0;
writeBlock(blockNumData, 0, buffer, BLOCK_SIZE); //on efface les blocs de données
}
writeBlock(blockNum, 0, fileBuffer, BLOCK_SIZE); //on efface le bloc de description
}
}
printf("Le fichier \"%s\" a été supprimé avec succès.\n", filename);
}

ReX : Pour construire le nombre sur 16 bits utiliser le OU plutôt que l'addition.

ReX : Heu non, je ne lis pas cette fonction avec tout ce code dupliqué, la seule différence entre les deux alternative est la position de début de l'adresse du premier bloc de données (<code>MAX_FILENAME_LENGTH</code> dans un cas et 0 dans l'autre). Donc l'alternative ne doit servir qu'à initialiser ce début, le reste du code doit être factorisé.

ReX : Et corrige le code, tu utilises deux tableaux de blocs (perte mémoire), tu écris le bloc à zéro dans l'itération (perte CPU).

=== Fonction RM version 3 ===

Suite à vos remarques, j'ai réalisé les modifications suivantes:

* j'utilise maintenant le OU plutôt que l'addition pour construire le nombre sur 16 bits.

* j'ai factorisé le code grâce à la création de la variable <code>startOffset</code> valant 16 lorsqu'on se trouve dans le bloc contenant le nom du fichier et valant 0 lorsqu'on se trouve dans les autres.

* Pour ce qui est du fait que j'utilise 2 tableaux de blocs, j'ai du mal à voir comment faire avec 1 seul tableau de blocs car ces deux tableaux n'ont pas du tout le même rôle. Le tableau <code>fileBuffer</code> permet de stocker les 16 blocs de description d'un fichier un à un. Lorsqu'on stocke un bloc dans <code>fileBuffer</code>, on lit ensuite les octets un à un de ce bloc afin de former des numéros de blocs, et pour chaque numéro de bloc créé, on va réinitialiser le bloc correspondant dans les blocs de données. Pour cela, on a donc besoin d'un autre bloc qui viendra écraser les anciens blocs de données. C'est pourquoi j'ai créé un bloc <code>buffer</code>qui est composé de 0 et qui va écraser les blocs de données. On ne peut pas utiliser <code>fileBuffer</code> car on a besoin d'un bloc de zéros, et si on réinitialise <code>fileBuffer</code> on perd toute les données qui s'y trouvent. Une possibilité serait de relire le bloc de donné à chaque itération de la deuxième boucle for imbriquée; cela permettrait de pouvoir réinitialiser le tableau fileBuffer à chaque itérations de cette boucle afin de stocker ce bloc de 0 dans les blocs de données, puis de restocker dans ce même tableau le bloc de description. Cependant, je ne pense pas que ce soit optimal de faire autant appel à la fonction readBlock.

* j'ai créé une fonction resetBock qui permet comme son nom l'indique de reset un bloc en le remplissant de 0. Cela nous évite de créer deux tableaux de blocs dans RM, bien que je pense que cela revienne au même car on fait appel à une fonction qui créé un tableau de blocs. Quoi qu'il en soit, cela allège le code et cette fonction pourra surement me resservir par la suite.

void RM(const char *filesystem_path, const char *filename) {
int fileFound = -1;
int offset;
unsigned char fileBuffer[BLOCK_SIZE];

// Parcourir les blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char *)filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {
// Effacer le nom du fichier dans le superbloc
memset(filenameBuffer, 0, MAX_FILENAME_LENGTH);
writeBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);
fileFound = 1;
offset = blockNum;
break;
}
}

// Fin de fonction si fichier inexistant
if (fileFound == -1) {
printf("Le fichier \"%s\" n'a pas été trouvé.\n", filename);
return;
}

for (int blockNum = offset; blockNum < offset + 16; blockNum++) {
int startOffset = 0;
if (blockNum == offset) {
startOffset = MAX_FILENAME_LENGTH;
}
readBlock(blockNum, startOffset, fileBuffer, BLOCK_SIZE - startOffset);

// Libérer les blocs associés au fichier dans la carte de disponibilités et dans les blocs de description
for (int i = 0; i < BLOCK_SIZE - startOffset; i += 2) {
int blockNumData = (fileBuffer[i] << 8) | fileBuffer[i + 1];
if (blockNumData == 0) {
break; // Fin du fichier
}
setBlockAvailability(blockNumData, 0); // Marquer le bloc comme disponible
fileBuffer[i] = 0;
fileBuffer[i + 1] = 0;
resetBlock(blockNumData); //on efface les blocs de données
}
writeBlock(blockNum, startOffset, fileBuffer, BLOCK_SIZE - startOffset);
}
printf("Le fichier \"%s\" a été supprimé avec succès.\n", filename);
}
'''Fonction resetBlock'''
void resetBlock(unsigned int blockNum) {
unsigned char buffer[BLOCK_SIZE];
memset(buffer, 0, BLOCK_SIZE);

// Utiliser writeBlock pour écrire les données du buffer dans le bloc
writeBlock(blockNum, 0, buffer, BLOCK_SIZE);
}

ReX : Ca s'améliore. Mais pourquoi cette fonction <code>resetBlock</code> ? Tu crois que dans qu'un système de fichiers perd du temps à mettre à zéro les blocs de données libérés ? Si oui, regarde la page de manual de la commande <code>shred</code>, ça manque à ta culture.

Amine: Après avoir consulter le manual de la commande <code>shred</code>, je vois que cette commande écrit des données aléatoires sur l'emplacement du fichier sur le disque. Par défaut, <code>shred</code> effectue un certain nombre de passes (par exemple, 3 passes) pendant lesquelles il écrit des données aléatoires sur l'emplacement du fichier sur le disque. Après avoir écrit les données aléatoires, <code>shred</code> peut effectuer des passes supplémentaires pendant lesquelles il écrit des données nulles (des zéros) sur le même emplacement. L'objectif de <code>shred</code> est d'augmenter la sécurité en rendant plus difficile la récupération des données supprimées à l'aide d'outils de récupération de données.

Cependant, j'ai aussi consulté comment fonctionne la commande <code>rm</code> de linux, et je vois que cette commande libère l'espace occupé par le fichier en marquant les blocs associés comme disponibles. Cela signifie que les données peuvent encore être récupérées à l'aide d'outils de récupération de données, à moins que des mesures supplémentaires ne soient prises pour écraser physiquement l'espace avec des données aléatoires (c'est ce que fait l'utilitaire <code>shred</code>).

On va donc opter pour la deuxième option, c'est à dire qu'on ne va pas perdre notre temps à remettre à zéro les blocs de données libérés, on va simplement marquer les blocs correspondants comme étant disponibles. Cela nous permettra de nous émanciper de la fonction resetBlock et de n'avoir plus qu'un seul tableau de blocs.

ReX : Sinon lire un bloc complet de pointeurs de blocs de données en mémoire n'est pas forcément optimal. L'idéal serait de lire ces blocs morceau par morceau (de 64 octets par exemple). Certes un bloc serait traité en 4 lectures/écritures (ce qui ralentirait le traitement) mais on gagne en mémoire. Le mieux serait de mettre la taille des morceaux en constante pour pouvoir choisir entre vitesse d'exécution et utilisation mémoire.

Amine: d'accord je comprends. Je vais modifier la fonction pour qu'on puisse découper la lecture/écriture en plusieurs blocs.

=== Fonction RM version 4 ===
Modifications apportées:

* je ne réinitialise plus les blocs de données, je supprime simplement le pointeur du fichier vers les blocs de données et je désigne les blocs comme "disponible" dans le carte de disponibilités. J'ai donc supprimé la fonction resetBlock.

* je ne lis plus les blocs en une seule fois mais en plusieurs fois via la variable CHUNK_SIZE:

# J'ai introduit la constante <code>CHUNK_SIZE</code> pour définir la taille de chaque morceau que nous allons lire/écrire à la fois. Cela permet de découper les opérations en blocs plus petits.
# Dans la boucle <code>for</code> où on parcours les blocs à partir de <code>offset</code>, j'ai ajouté une boucle interne qui parcourt les données du bloc en morceaux de taille <code>CHUNK_SIZE</code>.
# À l'intérieur de la boucle interne, j'ai calculé la taille réelle du morceau (<code>chunkSize</code>) en prenant le minimum entre <code>CHUNK_SIZE</code> et la quantité de données restant à lire/écrire dans le bloc.
# J'ai modifié la fonction <code>readBlock</code> pour lire seulement la quantité de données spécifiée par <code>chunkSize</code> à partir de <code>chunkStart</code>. Ces données sont stockées dans le tableau <code>fileBuffer</code>.
# Ensuite, j'ai effectué les mêmes opérations de libération des blocs associés au fichier, en parcourant les données du morceau et en marquant les blocs comme disponibles.
# Finalement, j'ai utilisé la fonction <code>writeBlock</code> pour écrire le morceau de données modifié dans le bloc, en utilisant la même <code>chunkStart</code> pour déterminer où écrire les données.

#define CHUNK_SIZE 64

int min(int a, int b) {
return a < b ? a : b;
}

void RM(const char *filesystem_path, const char *filename) {
int fileFound = -1;
int offset;
unsigned char fileBuffer[BLOCK_SIZE];

// Parcourir les blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char *)filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {
// Effacer le nom du fichier dans le superbloc
memset(filenameBuffer, 0, MAX_FILENAME_LENGTH);
writeBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);
fileFound = 1;
offset = blockNum;
break;
}
}

// Fin de fonction si fichier inexistant
if (fileFound == -1) {
printf("Le fichier \"%s\" n'a pas été trouvé.\n", filename);
return;
}

for (int blockNum = offset; blockNum < offset + 16; blockNum++) {
int startOffset = 0;

if (blockNum == offset) {
startOffset = MAX_FILENAME_LENGTH;
}

for (int chunkStart = startOffset; chunkStart < BLOCK_SIZE; chunkStart += CHUNK_SIZE) {
int chunkSize = min(CHUNK_SIZE, BLOCK_SIZE - chunkStart);
readBlock(blockNum, chunkStart, fileBuffer, chunkSize);

for (int i = 0; i < chunkSize; i += 2) {
int blockNumData = (fileBuffer[i] << 8) | fileBuffer[i + 1];
if (blockNumData == 0) {
writeBlock(blockNum, chunkStart, fileBuffer, chunkSize);
printf("Le fichier \"%s\" a été supprimé avec succès.\n", filename);
return; // Sortir des boucles
}
setBlockAvailability(blockNumData, 0); // Marquer le bloc comme disponible
fileBuffer[i] = 0;
fileBuffer[i + 1] = 0;
}

writeBlock(blockNum, chunkStart, fileBuffer, chunkSize);
}
}

printf("Le fichier \"%s\" a été supprimé avec succès.\n", filename);
}

ReX : Si on trouve un n° de bloc de données à 0, il faut sortir des deux boucles les plus externes après avoir fait le <code>writeBlock</code>.

Amine: Modification faites ci-dessus. Maintenant, dès qu'on trouve un n° de bloc de données à 0 dans la boucle la plus interne, on effectue le <code>writeBlock</code> et ensuite on utilise <code>return</code> pour sortir des deux boucles les plus externes. Cela permet d'optimiser le code en évitant de continuer à traiter inutilement le reste des blocs.

ReX : Pas très propre (duplication de code) mais nous allons nous en contenter.

=== Fonction intermédiaire TYPE version 1 ===

J'ai également commencé à réfléchir à la fonction TYPE. Pour l'instant, elle ne fait qu'ajouter les noms de fichier dans le superbloc. Cela permet de pouvoir tester les fonctions LS et RM (voir dans la rubrique compilation et exécution comment utiliser le programme).
// Fonction pour créer un fichier avec le nom donné et le contenu fourni en entrée standard
void TYPE(const char *filesystem_path, const char *filename) {
unsigned char buffer[MAX_FILENAME_LENGTH];
// Parcours des blocs réservés pour la description des fichiers
for (int blockNum = 0; blockNum <= MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, MAX_FILENAME_LENGTH);
// Vérifier si le bloc est vide (pas de nom de fichier)
if (buffer[0] == 0) {
// Écrire le nom du fichier dans l'emplacement vide du superbloc
writeBlock(blockNum, 0, (const unsigned char *)filename, MAX_FILENAME_LENGTH);
break; // Fichier créé, sortir de la boucle
}
}
printf("Le fichier \"%s\" a été créé avec succès.\n", filename);
}

ReX : Si la boucle se termine sans trouver de slot libre le message de succès s'affiche tout de même.

ReX : Le paramètre <code>filename</code> n'a pas forcément une taille de <code>MAX_FILENAME_LENGTH</code>.

Selon moi, la fonction TYPE devra respecter 3 étapes:

# Enregistrement du Nom du Fichier: L'ajout du nom du fichier dans un des blocs de la première partie du superbloc.
# Stockage des Données du Fichier: La récupération des données saisies en entrée standard par l'utilisateur et leur stockage dans des blocs du système de fichiers à partir d'une certaine position, comme le bloc 1040.
# Mise à Jour de la Disponibilité des Blocs: L'indication que les blocs dans lesquels les données ont été écrites ne sont plus disponibles en modifiant les bits correspondants dans la deuxième partie du superbloc (les 16 derniers blocs du super bloc).

ReX : Relis le point 3 et dit moi si tu te comprends toi même ?

Amine: Ma phrase n'est effectivement pas très claire. Je voulais dire que la fonction TYPE devra mettre à jour la carte de disponibilité du superbloc. C'est à dire que lorsqu'elle écrira des données dans des blocs, elle devra indiquer dans la carte de disponibilités que ces blocs ne sont plus disponibles.

=== Fonction intermédiaire TYPE version 2 ===

Suite à vos remarques, j'ai apporté les modifications suivantes à la fonction TYPE:

* j'ai ajouté une condition pour l'affichage du message de succès de la création d'un fichier (placeFound).

* le paramètre <code>filename</code> n'ayant pas forcément une taille de <code>MAX_FILENAME_LENGTH</code>, je calcule maintenant la longueur de filename, afin d'écrire seulement le nom du fichier avec la fonction writeBlock.

Il fonction n'est bien évidemment pas fini, elle ajoute seulement le nom du fichier dans le superbloc pour l'instant. Cela me permet de tester les fonctions LS et RM.
void TYPE(const char *filesystem_path, const char *filename) {
size_t sizeFilename = strlen(filename);
printf("size filename=%d\n", sizeFilename);
unsigned char buffer[MAX_FILENAME_LENGTH];
int placeFound = 0;

if (sizeFilename > MAX_FILENAME_LENGTH) {
printf("Impossible de créer le fichier, nom trop long\n");
return;
}

// Parcours des blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, MAX_FILENAME_LENGTH);
// Vérifier si le bloc est vide (pas de nom de fichier)
if (buffer[0] == 0) {
// Écrire le nom du fichier dans l'emplacement vide du superbloc
if (sizeFilename < MAX_FILENAME_LENGTH) {
sizeFilename+=1;
}
writeBlock(blockNum, 0, (const unsigned char *)filename, sizeFilename);
placeFound = 1;
break; // Fichier créé, sortir de la boucle
}
}
if (placeFound == 1) {
printf("Le fichier \"%s\" a été créé avec succès.\n", filename);
} else {
printf("Plus de place dans le système de fichier pour créer ce fichier.\n", filename);
}
}

ReX : Mieux, attention il faut copier aussi le <code>\'0</code> final du nom, donc <code>sizeFilename+1</code>. Sinon tu n'es pas sûr qu'il y ait un zéro final. Et attention n°2, il ne faut pas copier ce <code>\'0</code> si le nom fait la taille maximale.

Amine: ok j'ai modifié la fonction TYPE ci-dessus. J'ai ajouté une condition: si le nom du fichier est inférieur à la taille maximale de nom de fichier, alors on incrémente de 1 la taille du nom de fichier. Cela nous permet d'écrire le '\0' dans le bloc de description. Dans le cas où le nom du fichier est de la taille maximale, nous n'avons pas besoin d'écrire le '\0', on n'incrémente donc pas la taille de 1.

J'ai également ajouté une condition: si le nom du fichier est supérieur à la taille maximale, alors un message d'erreur s'affiche et le fichier n'est pas créé.

ReX : OK. L'embryon de fonction <code>TYPE</code> est correct, il manque juste le principal : la création des blocs de données.

=== Fonction MV version 1 ===

J'ai ici créé la fonction MV qui permet de changer le nom d'un fichier. Pour ce faire, la fonction parcourt les blocs de descriptions à la recherche du fichier dont on veut changer le nom. Lorsque ce fichier est trouvé, on supprime l'ancien nom en mettant des 0 sur 16 octets, puis on vient réécrire le nouveau nom dans le même emplacement. Enfin, on sort de la boucle et on affiche le succès ou non de l'opération.
// Fonction qui modifie le nom du fichier
void MV(const char *filesystem_path, const char *old_filename, const char *new_filename) {
size_t sizeNew_filename = strlen(new_filename);
size_t sizeOld_filename = strlen(old_filename);
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
int fileFound = 0;
// Parcourir les blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);
// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char*)filenameBuffer, old_filename, MAX_FILENAME_LENGTH) == 0) {
// Effacer le nom du fichier dans le superbloc
memset(filenameBuffer, 0, MAX_FILENAME_LENGTH);
writeBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);
// Écrire le nom du fichier dans l'emplacement
writeBlock(blockNum, 0, (const unsigned char *)new_filename, sizeNew_filename);
fileFound=1;
break; // Nom modifié, sortir de la boucle
}
}
if (fileFound == 1) {
printf("Le nom du fichier \"%s\" a été renommé avec succès.\n", old_filename);
} else {
printf("Le fichier \"%s\" n'a pas été trouvé.\n", old_filename);
}
}

ReX : Inutile d'écraser l'ancien nom avec des zéros. Il suffit de copier le nouveau en s'assurant qu'il y ait un zéro final sauf si le nouveau nom fait la taille maximale.

Amine: ok, je vais faire les modifications dans la version 2.

== Semaine 6 ==

=== Fonction MV version 2 ===
Dans cette nouvelle version de la fonction MV, j'ai effectué les modifications suivantes:

* je n'écrase plus l'ancien nom avec des 0
* Je colle simplement le nouveau nom par dessus l'ancien, en m'assurant qu'il y ait bien le '\0' à la fin lorsque la taille du nom du fichier est inférieur à la taille maximale. Comme précédemment, afin de m'assurer de la présence de ce '\0' à la fin du nom, j'incrémente la taille de 1 lorsque qu'elle est inférieur à la taille max. Cependant, je ne suis pas sûr à 100% que ce soit la bonne manière de faire.

// Fonction qui modifie le nom du fichier
void MV(const char *filesystem_path, const char *old_filename, const char *new_filename) {
size_t sizeNew_filename = strlen(new_filename);
size_t sizeOld_filename = strlen(old_filename);
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
int fileFound = 0;

// Parcourir les blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {

readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char*)filenameBuffer, old_filename, MAX_FILENAME_LENGTH) == 0) {

if (sizeNew_filename < MAX_FILENAME_LENGTH) {
sizeNew_filename+=1;
}

// Écrire le nom du fichier dans l'emplacement
writeBlock(blockNum, 0, (const unsigned char *)new_filename, sizeNew_filename);

fileFound=1;

break; // Nom modifié, sortir de la boucle
}
}
if (fileFound == 1) {
printf("Le nom du fichier \"%s\" a été renommé avec succès.\n", old_filename);
} else {
printf("Le fichier \"%s\" n'a pas été trouvé.\n", old_filename);
}
}

ReX : C'est bon. La fonction était triviale.

=== Fonction TYPE version 1 ===
void TYPE(const char *filesystem_path, const char *filename) {
size_t sizeFilename = strlen(filename);
unsigned char buffer[MAX_FILENAME_LENGTH];
int placeFound = -1;

if (sizeFilename > MAX_FILENAME_LENGTH) {
printf("Impossible de créer le fichier, nom trop long\n");
return;
}

// Parcours des blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, MAX_FILENAME_LENGTH);
// Vérifier si le bloc est vide (pas de nom de fichier)
if (buffer[0] == 0) {
// Écrire le nom du fichier dans l'emplacement vide du superbloc
if (sizeFilename < MAX_FILENAME_LENGTH) {
sizeFilename += 1; // Ajouter '\0' s'il y a de la place
}
writeBlock(blockNum, 0, (const unsigned char *)filename, sizeFilename);
placeFound = blockNum;

// Lire les données depuis l'entrée standard
unsigned char dataBuffer[BLOCK_SIZE];
size_t bytesRead;
int dataBlockNum = findAvailableBlock(); // Premier bloc de données à partir du bloc 1040
printf("dataBlockNum%d\n",dataBlockNum);
int blockSizeUsed = 0; // Compteur d'octets dans le bloc actuel
int dataBlocksNeeded = 1; // Nombre de blocs de données nécessaires

while ((bytesRead = fread(dataBuffer + blockSizeUsed, 1, BLOCK_SIZE - blockSizeUsed, stdin)) > 0) {
blockSizeUsed += bytesRead;

// Si le bloc actuel est plein, passer au bloc suivant
if (blockSizeUsed == BLOCK_SIZE) {
// printf("dataBlockNum=%d\n",dataBlockNum);
writeBlock(dataBlockNum, 0, dataBuffer, BLOCK_SIZE);
setBlockAvailability(dataBlockNum, 1);

dataBlockNum++; // Passer au bloc suivant
blockSizeUsed = 0; // Réinitialiser la taille utilisée
dataBlocksNeeded++;
}
}

// Écrire le dernier bloc partiel, s'il y en a un
if (blockSizeUsed > 0) {
writeBlock(dataBlockNum, 0, dataBuffer, blockSizeUsed);
setBlockAvailability(dataBlockNum, 1);
}

// Écrire les numéros de blocs utilisés dans le bloc de description
unsigned char blockNumberBuffer[2];
int currentBlockNum = 1040;

for (int i = 0; i < dataBlocksNeeded; i++) {
blockNumberBuffer[0] = (currentBlockNum >> 8) & 0xFF;
blockNumberBuffer[1] = currentBlockNum & 0xFF;
writeBlock(placeFound, MAX_FILENAME_LENGTH + i * 2, blockNumberBuffer, 2);
currentBlockNum++;
}

break; // Fichier créé, sortir de la boucle
}
}

if (placeFound != -1) {
printf("Le fichier \"%s\" a été créé avec succès.\n", filename);
} else {
printf("Plus de place dans le système de fichier pour créer ce fichier.\n");
}
}

ReX : La constante 1040 ne doit pas apparaître en numérique, ce doit être une constante calculée à partir des autres constantes.

Amine: Ok. Je ne l'avais pas défini comme une constante car il s'agit dans la fonction ci-dessus d'une variable qui est incrémenté à chaque itération.

ReX : Je suis las de te répéter que le mémoire est comptée : tu utilises encore un bloc de <code>BLOCK_SIZE</code> octets, c'est trop.

Amine: Comment utiliser des blocs plus petit sachant qu'il s'agit là de blocs de données et qu'un bloc fait 256 octets d'après l'énoncé ? Dois-je les subdiviser en plusieurs blocs plus petit comme fait dans la fonction RM, en 4 blocs de 64 octets par exemple ?

Fonctionnement de la fonction TYPE:

* étape 1: on parcourt les blocs de descriptions à la recherche d'un bloc disponible. Si on ne trouve pas de bloc disponible, on renvoie un message d'erreur, sinon on passe à l'étape suivante.
* étape 2: Si on trouve un emplacement libre dans les blocs de disponibilité, on écrit le nom du fichier dans cet emplacement.

ReX : Dans les blocs de description de fichiers pas dans les blocs de disponibilité.

Amine: Oui autant pour moi.

* étape 3: Ensuite, on lit le texte entré par l'utilisateur en entrée standard, on le répartit dans des blocs de taille BLOCK_SIZE, on met à jour la disponibilité des blocs utilisés.

ReX : Non, il faut appeler <code>findAvailableBlock</code> pour chaque bloc de données à utiliser, aucune certitudes que les blocs libres soient en séquence.

Amine: ok, je ferai cela dans la version 2

* étape 4: Enfin, on écrit les numéros des blocs de données utilisés dans les blocs de description de ce fichier, les numéros étant écris sur deux octets.

ReX : Non cela doit se faire au fur et à mesure des appels à <code>findAvailableBlock</code> et les numéros des blocs de données peuvent s'étaler sur les 16 blocs de description du fichier. Confusion totale sur ce point. Vous n'avez pas compris le mécanisme.

Amine: je corrige cela dans la version 2. J'ai bien compris le mécanisme mais ce n'est pas facile à traduire en code.

=== Fonction TYPE version 2 ===
Dans cette nouvelle version de TYPE, j'ai fait les modifications suivantes:

* j'appelle maintenant <code>findAvailableBlock</code> pour chaque bloc de données à utiliser
* j'écris maintenant les numéros de blocs au fur et à mesures des appels à <code>findAvailableBlock</code>
* je n'utilise plus de tableaux de taille 256 octets mais des tableaux de tailles CHUNK_SIZE. J'ai choisi ici CHUNK_SIZE = 64 octets.

J'utilise toujours un bloc de taille BLOCK_SIZE en attendant de comprendre si je dois diviser ce bloc en plusieurs blocs de taille plus petite ou s'il y a un moyen de ne pas du tout utiliser ces blocs.
void TYPE(const char *filesystem_path, const char *filename) {
size_t sizeFilename = strlen(filename);
unsigned char buffer[MAX_FILENAME_LENGTH];
int placeFound = -1;

if (sizeFilename > MAX_FILENAME_LENGTH) {
printf("Impossible de créer le fichier, nom trop long\n");
return;
}

// Parcours des blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, buffer, MAX_FILENAME_LENGTH);
// Vérifier si le bloc est vide (pas de nom de fichier)
if (buffer[0] == 0) {
// Écrire le nom du fichier dans l'emplacement vide du superbloc
if (sizeFilename < MAX_FILENAME_LENGTH) {
sizeFilename += 1; // Ajouter '\0' s'il y a de la place
}
writeBlock(blockNum, 0, (const unsigned char *)filename, sizeFilename);
placeFound = blockNum;

// Lire les données depuis l'entrée standard et écrire dans le fichier
int dataBlockNum = findAvailableBlock(); // Premier bloc de données à partir du bloc 1040
printf("Premier bloc dans lequel on écrit = %d\n", dataBlockNum);
int blockSizeUsed = 0; // Compteur d'octets dans le bloc actuel

unsigned char chunkBuffer[CHUNK_SIZE];
size_t bytesRead;

while ((bytesRead = fread(chunkBuffer, 1, CHUNK_SIZE, stdin)) > 0) {
// Écrire le chunk dans le bloc de données
writeBlock(dataBlockNum, blockSizeUsed, chunkBuffer, bytesRead);
setBlockAvailability(dataBlockNum, 1);

// Écrire le numéro du bloc actuel dans la description du fichier
unsigned char blockNumberBuffer[2];
blockNumberBuffer[0] = (dataBlockNum >> 8) & 0xFF;
blockNumberBuffer[1] = dataBlockNum & 0xFF;
writeBlock(placeFound, MAX_FILENAME_LENGTH + dataBlockNum * 2, blockNumberBuffer, 2);

blockSizeUsed += bytesRead;

// Si le bloc actuel est plein, passer au bloc suivant
if (blockSizeUsed == BLOCK_SIZE) {
dataBlockNum = findAvailableBlock(); // Passer au bloc suivant
blockSizeUsed = 0; // Réinitialiser la taille utilisée
}
}

break; // Fichier créé, sortir de la boucle
}
}

if (placeFound != -1) {
printf("Le fichier \"%s\" a été créé avec succès.\n", filename);
} else {
printf("Plus de place dans le système de fichier pour créer ce fichier.\n");
}
}

=== Fonction findAvailableBlock ===
Cette fonction renvoie l'indice du premier bloc disponible. Je me sers de cette fonction dans la fonction TYPE.
#define FIRST_DATA_BLOCK 1040
#define FIRST_DISPONIBILITY_CARD_BLOCK 1024

// Renvoie le premier bloc de donné disponible
int findAvailableBlock() {
unsigned char availabilityBuffer[BLOCK_SIZE];
int offset;

// Lire la carte de disponibilité (à partir du bloc 1)
for (int blockNum = FIRST_DISPONIBILITY_CARD_BLOCK; blockNum < FIRST_DATA_BLOCK; blockNum++) {
readBlock(blockNum, 0, availabilityBuffer, BLOCK_SIZE);

if (blockNum==FIRST_DISPONIBILITY_CARD_BLOCK) {
offset=FIRST_DATA_BLOCK/8;
} else {
offset=0;
}

// Parcourir les octets de la carte de disponibilité
for (int byteIndex = offset; byteIndex < BLOCK_SIZE; byteIndex++) {
unsigned char byte = availabilityBuffer[byteIndex];

// Parcourir les bits de chaque octet
for (int bitIndex = 0; bitIndex < 8; bitIndex++) {
// Vérifier si le bit est à 0 (bloc disponible)
if ((byte & (1 << bitIndex)) == 0) {
// Calculer l'indice du bloc en fonction du bloc et du bit
int blockIndex = byteIndex * 8 + bitIndex;
return blockIndex;
}
}
}
}

// Aucun bloc disponible trouvé
return -1;
}

ReX : Même remarque que précédement sur les nombres 1024 et 1040.

Amine: Ok, j'ai remplacé 1024 par la constante FIRST_DISPONIBILITY_CARD_BLOCK et 1040 par la constante FIRST_DATA_BLOCK dans la fonction ci-dessus.

ReX : Vous n'avez toujours pas compris la contrainte sur la mémoire.

Amine: dois-je découper le bloc de taille BLOCK_SIZE en quatre blocs de taille 64 octets par exemple ?

ReX : Je ne vois pas ce que vous voulez faire avec <code>if (blockNum==1024) offset=1040/8; else offset=0;</code>.

Amine: dans la carte de disponibilité, chaque bit correspond à un bloc. Ainsi, les bits de 0 à 1040 dans la carte de disponibilité décrivent la disponibilité des blocs 0 à 1040. Or ces blocs correspondent au superbloc, et dans cette fonction, on veut connaître le premier bloc de données disponible. On ne s'intéresse donc pas au 1040 premiers bits de la carte de disponibilité. Je crée donc un offset égal à 1040/8 afin de ne pas prendre en compte les 1040 premiers bits soit les 1040/8=130 premiers octets. Cet offset ne s'applique que lorsqu'on se trouve dans le premier des 16 blocs de la carte de disponibilité, d'où la condition <code>if (blockNum==1024)</code>.

=== Fonction CAT ===
void CAT(const char *filesystem_path, const char *filename) {
unsigned char filenameBuffer[MAX_FILENAME_LENGTH];
unsigned char buffer[BLOCK_SIZE];
unsigned char blockNumberBuffer[2];
unsigned char dataBuffer[BLOCK_SIZE];
int offset;

// Parcours des blocs réservés pour la description des fichiers (superbloc)
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier recherché
if (strncmp((const char *)filenameBuffer, filename, MAX_FILENAME_LENGTH) == 0) {
// Le nom du fichier a été trouvé

// Parcours les blocs de description
for (int descrBlockNum=0; descrBlockNum<MAX_BLOCKS_PER_FILE_DESCRIPTION; descrBlockNum++) {
if (descrBlockNum==0) {
offset=16;
} else {
offset=0;
}
readBlock(descrBlockNum+blockNum, offset, buffer, BLOCK_SIZE-offset);

// Lire les numéros de blocs associés à ce fichier depuis les blocs de description
unsigned char octet1 = buffer[offset];
unsigned char octet2 = buffer[offset+1];

int dataBlockNum = (octet1 << 8) | octet2;
printf("dataBlockNum=%d\n",dataBlockNum);

// Vérifier si le numéro de bloc est valide (non nul)
if (dataBlockNum == 0) {
return; // Fin du fichier
}

// Lire et afficher le contenu du bloc de données
readBlock(dataBlockNum, 0, dataBuffer, BLOCK_SIZE);
fwrite(dataBuffer, 1, BLOCK_SIZE, stdout);
}

return; // Fichier affiché, sortie de la fonction
}
}

// Si le fichier n'a pas été trouvé
printf("Le fichier \"%s\" n'a pas été trouvé.\n", filename);
}

ReX : Encore mieux : deux blocs de <code>BLOCK_SIZE</code> en mémoire.

ReX : Le <code>break</code> ne sort pas de la boucle externe.

Amine: Oui c'est vrai. J'ai remplacé le break pas un return ci-dessus.

Voici ma fonction <code>CAT</code>. Elle fonctionne en plusieurs étape:

* étape 1: on cherche dans les blocs de descriptions si le fichier dont on veut afficher le contenu existe. Si le nom de fichier est trouvé, on passe à l'étape 2. Sinon, on renvoie un message d'erreur.
* étape 2: si le fichier est trouvé, on parcours les 16 blocs de description de ce fichier.
* étape 3: grâce aux opérations de masquage et de décalage, on joint les octets deux par deux pour former un entier qui contient le numéro du bloc de données correspondant au fichier. Si cet entier vaut 0, alors cela signifie qu'il n'y a plus de blocs associé à ce fichier, on peut donc quitter la fonction. Si cet entier est différent de 0, alors on va lire le bloc correspondant à ce numéro et on affiche son contenu dans le terminal.

== Semaine 7 ==

=== Fonction CP version 1 ===
Voici ma fonction CP, qui permet de créer une copie d'un fichier existant. L'idée est la suivante: pour copier un fichier, on doit créer un nouveau fichier et lui attribuer les mêmes blocs de descriptions que le fichier source. Ainsi, le fichier source et le fichier destination pointeront vers les mêmes blocs de données, et auront le même contenu.

ReX : Perdu. Ce n'est absolument pas la fonction de copie de fichiers d'un système de fichiers.

Amine: Après avoir fait des recherches et après réflexion, je me rends compte que cette fonction CP présente un problème: en faisant pointé les blocs de données du fichier destination vers ceux du fichier source, toutes modifications du fichier source impactera le fichier destination, or ce n'est pas ce qu'on veut faire. Je vous propose donc une nouvelle version de la fonction CP ci-dessous qui remédie à ce problème.

void CP(const char *filesystem_path, const char *source_filename, const char *destination_filename) {
unsigned char source_filenameBuffer[MAX_FILENAME_LENGTH];
unsigned char destination_filenameBuffer[MAX_FILENAME_LENGTH];
unsigned char descriptionBuffer[BLOCK_SIZE];
int destination_offset;
int offset;

// Recherche du fichier source
int source_offset = -1;
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, source_filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier source
if (strncmp((const char *)source_filenameBuffer, source_filename, MAX_FILENAME_LENGTH) == 0) {
source_offset = blockNum;
break;
}
}

if (source_offset == -1) {
printf("Le fichier source \"%s\" n'a pas été trouvé.\n", source_filename);
return;
}

// Recherche d'un emplacement libre pour le fichier destination
destination_offset = -1;
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, destination_filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc est vide (pas de nom de fichier)
if (destination_filenameBuffer[0] == 0) {
destination_offset = blockNum;
break;
}
}

if (destination_offset == -1) {
printf("Plus de place dans le système de fichier pour créer la copie de \"%s\".\n", source_filename);
return;
}

// Ecrit le nom de la copie dans le bloc de description
writeBlock(destination_offset, 0, (const unsigned char *)destination_filename, strlen(destination_filename));

// Copier les blocs de description associés au fichier source dans les blocs de description du fichier destination
for (int i = 0; i < MAX_BLOCKS_PER_FILE_DESCRIPTION; i++) {
if (i==0) {
offset = MAX_FILENAME_LENGTH;
} else {
offset = 0;
}

readBlock(source_offset+i, offset, descriptionBuffer, BLOCK_SIZE-offset);
if (descriptionBuffer[offset]==0) {
return;
} else {
writeBlock(destination_offset+i, offset, descriptionBuffer, BLOCK_SIZE-offset);
}
}

printf("La copie de \"%s\" sous le nom \"%s\" a été créée avec succès.\n", source_filename, destination_filename);
}

=== Fonction CP version 2 ===
Voici une version mise à jour de notre fonction CP qui duplique réellement les blocs de données du fichier source vers le fichier de destination. Cela implique d'attribuer de nouveaux blocs de données au fichier de destination et de mettre à jour la carte de disponibilité des blocs.
void CP(const char *filesystem_path, const char *source_filename, const char *destination_filename) {
unsigned char source_filenameBuffer[MAX_FILENAME_LENGTH];
unsigned char destination_filenameBuffer[MAX_FILENAME_LENGTH];
unsigned char descriptionBuffer[BLOCK_SIZE];
int destination_offset;
int source_offset;

// Recherche du fichier source
source_offset = -1;
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, source_filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc contient le nom du fichier source
if (strncmp((const char *)source_filenameBuffer, source_filename, MAX_FILENAME_LENGTH) == 0) {
source_offset = blockNum;
break;
}
}

if (source_offset == -1) {
printf("Le fichier source \"%s\" n'a pas été trouvé.\n", source_filename);
return;
}

// Recherche d'un emplacement libre pour le fichier destination
destination_offset = -1;
for (int blockNum = 0; blockNum < MAX_FILES_IN_DIRECTORY; blockNum += 16) {
readBlock(blockNum, 0, destination_filenameBuffer, MAX_FILENAME_LENGTH);

// Vérifier si le bloc est vide (pas de nom de fichier)
if (destination_filenameBuffer[0] == 0) {
destination_offset = blockNum;
break;
}
}

if (destination_offset == -1) {
printf("Plus de place dans le système de fichier pour créer la copie de \"%s\".\n", source_filename);
return;
}

// Copie du nom de la copie dans le bloc de description
writeBlock(destination_offset, 0, (const unsigned char *)destination_filename, strlen(destination_filename));

// Copier les blocs de données associés au fichier source dans de nouveaux blocs de données pour le fichier destination
for (int i = 0; i < MAX_BLOCKS_PER_FILE_DESCRIPTION; i++) {
if (i == 0) {
int offset = MAX_FILENAME_LENGTH;
readBlock(source_offset + i, offset, descriptionBuffer, BLOCK_SIZE - offset);
if (descriptionBuffer[offset] == 0) {
break;
}
int newDataBlock = findAvailableBlock(); // Trouver un nouveau bloc de données disponible
writeBlock(destination_offset + i, offset, descriptionBuffer, BLOCK_SIZE - offset);
setBlockAvailability(newDataBlock, 1); // Marquer le nouveau bloc de données comme utilisé
} else {
int offset = 0;
readBlock(source_offset + i, offset, descriptionBuffer, BLOCK_SIZE);
if (descriptionBuffer[offset] == 0) {
break;
}
int newDataBlock = findAvailableBlock(); // Trouver un nouveau bloc de données disponible
writeBlock(destination_offset + i, offset, descriptionBuffer, BLOCK_SIZE);
setBlockAvailability(newDataBlock, 1); // Marquer le nouveau bloc de données comme utilisé
}
}

printf("La copie de \"%s\" sous le nom \"%s\" a été créée avec succès.\n", source_filename, destination_filename);
}

= Compilation et exécution =
'''Création du système de fichiers :'''
dd if=/dev/zero of=filesystem.bin bs=256 count=32768

'''Compilation :'''

gcc picofs.c -o picofs

'''Exécution de LS, TYPE, CAT, RM, MV ou CP :'''

./picofs filesystem.bin LS
./picofs filesystem.bin TYPE mon_fichier.txt
./picofs filesystem.bin CAT mon_fichier.txt
./picofs filesystem.bin RM mon_fichier.txt
./picofs filesystem.bin MV mon_fichier.txt mon_fichier2.txt
./picofs filesystem.bin CP mon_fichier.txt mon_fichier2.txt

= Documents Rendus =
[[Fichier:Pcfs.c.tar|vignette]]