1. Structure du secteur FSInfo struct fat_boot_fsinfo :
   • __u32 signature1– signature 0x41615252 ;
   • __u32 signature2– signature 0x61417272 ;
   • __u32 clusters_gratuits– nombre de clusters libres. Si le champ contient -1, la recherche des clusters libres doit commencer par le cluster numéro 2.
2. Structure de structure d'élément de répertoire de nom court msdos_dir_entry :
   • Nom __s8, poste– nom et extension du fichier ;
   • __u8 attr– les attributs du fichier ;
   • __u8 ctime_ms– ce champ précise le temps de création du fichier en ms (seul FAT32 est utilisé) ;
   • __u16 heure– heure de création du fichier (seul FAT32 est utilisé) ;
   • __u16 date– date de création du fichier (seul FAT32 est utilisé) ;
   • __u16 date– date du dernier accès au fichier (seul FAT32 est utilisé) ;
   • __u16 starthi– les 16 bits de poids fort du premier numéro de cluster du fichier (seul FAT32 est utilisé) ;
   • __u16 heure, date, début– heure et date de création du fichier, numéro du premier cluster du fichier ;
   • __u32 taille– taille du fichier (en octets).
3. Structure des éléments de répertoire de noms longs :
   • __u8 identifiant– numéro d'élément;
   • __u8 nom0_4– les caractères 1 à 5 du nom ;
   • __u8 attr– les attributs du fichier ;
   • __u8 alias_checksum– somme de contrôle du nom court ;
   • __u8 nom5_10– les symboles 6 à 11 du nom ;
   • __u8 nom11_12– les symboles 12 – 13 du nom.

Continuons à considérer l'implémentation logicielle de l'algorithme et déterminons le nom de la partition sur laquelle le système de fichiers FAT16 a été créé :

#ifndef FAT16_PART_NAME

#define FAT16_PART_NAME "/dev/hda1"

#fin si

Structures mondiales :

struct fat_boot_sector fbs; // structure du secteur de démarrage

struct msdos_dir_entry dentry ; // structure des éléments de répertoire

Variables globales:

U16 *gros16 ; // copie la table FAT16 ici

Taille_secteur U16 ; // taille du secteur (à partir de FAT16)

U16 répertoire_entrées ; // nombre de descripteurs de 32 octets

// dans le répertoire racine (0 pour FAT32)

Secteurs U16 ; // nombre total de secteurs dans la partition

U32 fat16_size; // Taille FAT16

U32 taille_racine ; // taille du répertoire racine

U16 octet_per_cluster ; // taille du cluster en octets

U16 next_cluster ; // cluster suivant dans la chaîne

entier gras;

Commençons par la fonction principale :

int main()

Numéro int ;

Nous spécifions le nom complet du fichier dont nous voulons lire le contenu. Je vous rappelle que nous travaillons uniquement avec des noms de fichiers courts. La procédure à suivre pour travailler avec des noms longs n'est pas abordée dans cet article.

U8 *full_path = "/Dossier1/Dossier2/text.txt";

Ouvrez le fichier de l'appareil :

Difficile = ouvert (FAT16_PART_NAME, O_RDONLY);

Si (dur< 0) {

Erreur(FAT16_PART_NAME);

Sortie(-1);

Nous lisons les 10 premiers clusters du fichier. La lecture est effectuée par la fonction fat16_read_file(). Les paramètres de la fonction sont le nom complet du fichier et le nombre de clusters à lire. La fonction renvoie le nombre de clusters lus ou -1 si une erreur s'est produite lors de la lecture :

Num = fat16_read_file(full_path, 10);

Si (numéro< 0) perror("fat16_read_file");

Sinon printf("Lire %d clusters ", num);

Fermez le fichier de périphérique et quittez :

Fermer (dur);

Renvoie 0 ;

La fonction de lecture des clusters de fichiers a la forme suivante :

int fat16_read_file(__u8 *full_path, int num)

Structure split_name sn ; // structure pour stocker les composants du fichier

U8 tmp_name_buff; // tampon pour le stockage temporaire des composants du chemin complet du fichier

Int statique i = 1 ;

Int n;

U8 *tmp_buff;

U16 start_cluster, next_cluster ;

Nous avons répertorié les paramètres de la fonction en considérant la fonction principale.

Opérations préparatoires - réinitialiser le tampon tmp_name_buff et la structure sn struct split_name :

Le premier caractère du chemin d'accès absolu d'un fichier doit être une barre oblique (/). Vérifions ceci :

Lisez le secteur de démarrage de la partition :

Si(read_fbs()< 0) return -1;

Le secteur de démarrage en lecture se trouve désormais dans la structure globale struct fat_boot_sector fbs. Copions la taille du secteur, le nombre d'entrées dans le répertoire racine et le nombre total de secteurs sur la partition à partir de cette structure :

Déterminons la taille du cluster en octets :

Byte_per_cluster = fbs.cluster_size * 512

Affichons les informations situées dans le secteur de démarrage :

Printf("ID système - %s ", fbs.system_id);

Printf("Taille du secteur - %d ", sector_size);

Printf("Taille du cluster - %d ", fbs.cluster_size);

Printf("Réservé - %d ", fbs.réservé);

Printf("Numéro de FAT - %d ",fbs.fats);

Printf("Entrées du répertoire - %d ", dir_entries);

Printf("Secteurs - %d ", secteurs);

Printf("Médias - 0x%X ", fbs.media);

Printf("Longueur FAT16 - %u ", fbs.fat_length);

Printf("Secte totale - %u ", fbs.total_sect);

Printf("Octet par cluster - %d ", byte_per_cluster);

Nous calculons la taille de FAT16 en octets et la lisons :

Fat16_size = fbs.fat_length * 512 ;

Si(read_fat16()< 0) return -1;

Lecture du répertoire racine :

Si(read_root_dentry()< 0) return -1;

Le pointeur dir_entry est maintenant positionné à l'emplacement mémoire contenant les entrées du répertoire racine. La taille de cette zone mémoire est égale à la taille du répertoire racine (root_size).

Sauvegardons (pour contrôle) le contenu du répertoire racine dans un fichier séparé :

#ifdef DÉBOGAGE

Fermer(gros);

#fin si

Nous calculons le début de la zone de données :

Data_start = 512 * fbs.reserved + fat16_size * fbs.fats + root_size ;

Ayant toutes les entrées dans le répertoire racine, nous pouvons accéder au contenu du fichier test.txt. A cet effet, nous organisons un cycle. Dans le corps de la boucle, nous analyserons le nom complet du fichier, en mettant en évidence ses éléments - les sous-répertoires (nous en avons deux, Folder1 et Folder2) et le nom du fichier que nous recherchons (test.txt).

Tandis que(1) (

Memset(tmp_name_buff, 0, SHORT_NAME);

Memset((void *)&sn, 0, sizeof(struct split_name));

Pour(n = 0 ; n< SHORT_NAME; n++, i++) {

Si((tmp_name_buff[n] == "/") || (tmp_name_buff[n] == "?")) (

je++;

Casser;

Tmp_name_buff[n] = "?";

Nous remplissons la structure sn struct split_name avec les informations appropriées. La fonction split_name effectue le remplissage et vérifie la conformité du nom du fichier au format « 8.3 » :

< 0) {

Printf("nom non valide");

Renvoie -1 ;

Pour chaque élément du nom complet du fichier, nous définissons un cluster initial. Pour ce faire, nous recherchons dans les éléments du répertoire (en commençant par la racine) une entrée correspondant à l'élément de nom complet, et lisons cette entrée. La procédure de recherche est effectuée par la fonction get_dentry() :

Si(get_dentry(&sn)< 0) {

Printf("Aucun fichier de ce type!");

Renvoie -1 ;

Vérification des attributs du fichier. S'il s'agit d'un répertoire, lisez son contenu et continuez la boucle :

Si(dentry.attr & 0x10) (

Si (read_directory (dentry.start)< 0) return -1;

Continuer;

S'il s'agit d'un fichier, nous lisons les premiers num clusters. Pour contrôle, nous enregistrerons les informations lues dans un fichier séparé :

Si(dentry.attr & 0x20) (

Start_cluster = dentaire.start;

Tmp_buff = (__u8 *)malloc(byte_per_cluster); // le contenu du cluster sera lu ici

N = open("clust", O_CREAT|O_RDWR, 0600); // enregistre les informations lues dans ce fichier

Si(n< 0) {

Perror("ouvrir");

Renvoie -1 ;

Pour lire des clusters de fichiers, on organise une boucle :

Pour (i = 0; je< num; i++) {

Nous lisons le contenu du cluster dans le tampon tmp_buff et le sauvegardons dans un fichier séparé :

< 0) return -1;

< 0) {

Perror("écrire");

Fermer(n);

Renvoie -1 ;

Nous lisons dans FAT16 le numéro du prochain cluster occupé par ce fichier. Si c'est le dernier cluster, on interrompt la boucle et retournons à la fonction principale :

#ifdef DÉBOGAGE

Printf("OK. Lu ");

Printf("prochain cluster du fichier - 0x%X .. ", next_cluster);

#fin si

Si(next_cluster == EOF_FAT16) (

#ifdef DÉBOGAGE

Printf("dernier cluster.");

#fin si

Gratuit(tmp_buff);

Fermer(n);

Renvoie ++i;

#ifdef DÉBOGAGE

Printf("arrêter la lecture ");

#fin si

Renvoyez-moi ;

La lecture du secteur de démarrage FAT16 est effectuée par la fonction read_fbs(). Le résultat est placé dans la structure globale fbs :

int read_fbs()

Si(lire(dur,(__u8 *)&fbs, taillede(fbs))< 0) return -1;

Renvoie 0 ;

La lecture de la table d'allocation de fichiers du système de fichiers FAT16 est effectuée par la fonction read_fat16() :

int read_fat16()

Recherche U64 = (__u64)(fbs.reserved) * 512 ; // décalage vers FAT16 depuis le début de la partition

Fat16 = (void *)malloc(fat16_size);

Si(pread64(dur, (__u8 *)fat16, fat16_size, chercher)< 0) return -1;

Renvoie 0 ;

La fonction read_root_dentry() lit le répertoire racine :

int read_root_dentry()

Recherche U64 = (__u64)fbs.reserved * 512 + fat16_size * fbs.fats; // décalage vers le répertoire racine depuis le début de la partition

Root_size = 32 * dir_entries ; // calcule la taille du répertoire racine

Dir_entry = (__u8 *)malloc(root_size);

If(!dir_entry) renvoie -1 ;

Memset(dir_entry, 0, root_size);

Si (pread64 (dur, dir_entry, root_size, seek)< 0) return -1;

Renvoie 0 ;

La lecture d'un cluster appartenant à un fichier est effectuée par la fonction read_cluster(). Les paramètres d'entrée de la fonction sont le numéro de cluster cluster_num et un pointeur vers le tampon __u8 *tmp_buff, où le résultat de la lecture doit être placé. Le décalage par rapport au cluster sur la partition est calculé à l'aide de la formule (voir) :

SEEK = DATA_START + (CLUSTER_NUM - 2) * BYTE_PER_CLUSTER,

• CHERCHER– décalage par rapport au cluster sur la partition
• DATA_START– début de la zone de données
• CLUSTER_NUM– numéro de série du cluster
• BYTE_PER_CLUSTER– taille du cluster en octets

int read_cluster(__u16 cluster_num, __u8 *tmp_buff)

Recherche U64 = (__u64)(byte_per_cluster) * (cluster_num - 2) + data_start ; // calcule le décalage par rapport au cluster

< 0) return -1;

Renvoie 0 ;

La fonction read_directory lit les entrées d'un répertoire (pas du répertoire racine) et place le résultat dans l'emplacement mémoire sur lequel le pointeur dir_entry est défini :

int read_directory(__u16 start_cluster)

Int je = 1 ;

U16 next_cluster ;

Pour(; ;i++) (

Nous allouons de la mémoire pour stocker le contenu du répertoire, lisons le contenu du cluster de départ et obtenons la valeur du cluster suivant à partir de la table FAT16 :

If(!dir_entry) renvoie -1 ;

< 0) return -1;

Next_cluster = fat16 ;

Sauvegardons le contenu du répertoire dans un fichier séparé (pour contrôle) :

#ifdef DÉBOGAGE

Printf("Cluster suivant - 0x%X ", next_cluster);

Fat = open("dir16", O_CREAT|O_WRONLY, 0600);

Write(fat, dir_entry, root_size);

Fermer(gros);

#fin si

Si le dernier cluster est atteint, on sort de la boucle, sinon on continue la lecture du répertoire, en augmentant la taille du buffer dir_entry d'un cluster supplémentaire :

Si (next_cluster & EOF_FAT16) pause ;

Start_cluster = next_cluster ;

Renvoie 0 ;

La fonction get_dentry() recherche dans le contenu du répertoire un élément correspondant au fichier recherché. Les paramètres d'entrée de cette fonction sont un pointeur vers la structure struct split_name *sn contenant les éléments du nom de fichier court :

Int je = 0 ;

Le tampon global dir_entry contient un tableau d'entrées de répertoire dans lequel nous allons chercher une entrée de fichier (ou de répertoire). Pour chercher, nous organisons un cycle. Dans le corps de la boucle, nous copions les éléments du répertoire dans la structure globale dentry et comparons les valeurs des champs name et ext de cette structure avec les champs correspondants de la structure struct split_name *sn. La correspondance de ces champs signifie que nous avons trouvé une entrée pour le fichier que nous recherchons dans le tableau des éléments du répertoire :

pour(; ; i++) (

If(!(memcmp(dentry.name, sn->name, sn->name_len)) &&

!(memcmp(dentry.ext, sn->ext, sn->ext_len)))

Casser;

If(!dentry.name) renvoie -1 ;

#ifdef DÉBOGAGE

Printf("nom - %s ", dentry.name);

Printf("start cluster - 0x%X ", dentry.start);

Printf("taille du fichier - %u ", dentry.size);

Printf("attribut de fichier - 0x%X ", dentry.attr);

#fin si

Renvoie 0 ;

Tout le code ci-dessus se trouve dans le répertoire FAT16, fichier fat16.c. Pour obtenir un module exécutable, créez un Makefile avec le contenu suivant :

INCDIR = /usr/src/linux/include

PHONY = propre

Fat16 : fat16.o split.o

Gcc -I$(INCDIR) $^ -g -o $@

%.o : %.c

Gcc -I$(INCDIR) -DDEBUG -c $^

Faire le ménage:

Rm -f *.o

Rm -f ./graisse16

Implémentation logicielle de l'algorithme de lecture d'un fichier depuis une partition logique avec le système de fichiers FAT12

De manière générale, l'algorithme de lecture d'un fichier depuis une partition FAT12 est identique à l'algorithme de lecture d'un fichier depuis une partition FAT16. La différence réside dans la procédure de lecture des éléments de la table FAT12. Nous avons considéré la table FAT16 comme un simple tableau d'éléments de 16 bits. Pour lire les éléments de la table FAT12, l'algorithme suivant est proposé :

• multipliez le numéro de l'élément par 1,5 ;
• extraire un mot de 16 bits de FAT en utilisant le résultat de l'opération précédente comme décalage ;
• si le numéro de l'élément est pair, effectuer l'opération ET sur le mot lu et le masque 0x0FFF. Si le nombre est impair, décalez le mot lu dans le tableau de 4 bits vers les chiffres inférieurs.

Sur la base de cet algorithme, nous implémentons la fonction de lecture des éléments de la table FAT12 :

int get_cluster(__u16 cluster_num)

Recherche U16 ;

Grappe U16 ;

Nous calculons le décalage dans la table FAT12 et lisons un mot de 16 bits dans la table :

Recherche = (cluster_num * 3) / 2 ;

Memcpy((__u8 *)&clust, (__u8 *)(fat12 + seek), 2);

Si le numéro de départ du cluster est un nombre pair, on décale la valeur lue dans la table de 4 bits vers les bits de poids faible, s'il est impair, on la résume avec 0x0FFF :

Si(cluster_num % 2) cluster >>= 4 ;

Sinon cluster &= 0x0FFF;

Ce fragment peut également être implémenté en assembleur :

" xorw %%ax, %%ax "

" au fait 0 $, %%cx "

"jnc1f"

" Shrw 4 $, %%dx "

"jmp2f"

"1 : etw $0x0FFF, %%dx "

"2 : déplacement %%dx, %%ax "

:"=a" (suivant)

:"d" (cluster), "c" (cluster_num));

On renvoie le résultat :

Groupe de retour ;

Examinons de plus près l'algorithme lui-même. Supposons qu'un fichier ait été créé sur une partition FAT12 occupant les 9ème et 10ème clusters. Chaque élément FAT12 occupe 12 bits. Parce que dans le tableau, nous lisons des éléments de 16 bits, alors le décalage par rapport au 9ème élément sera égal à 13 octets (9 * 1,5 = 13, le reste est supprimé), tandis que les 4 bits inférieurs appartiendront au 8ème élément FAT. Ils doivent être écartés, et pour ce faire, il suffit de décaler l'élément lu de 4 bits vers les chiffres inférieurs, ce qui est fourni par l'algorithme. Le décalage par rapport au 10ème élément sera de 15 octets et les 4 bits de poids fort appartiendront au 11ème élément FAT. Pour les écarter, il faut effectuer une opération ET sur le 10ème élément et le masque 0x0FFF, qui correspond également à l'algorithme ci-dessus.

Les textes sources du module de lecture d'un fichier depuis une partition FAT12 se trouvent dans le répertoire FAT12, fichier fat12.c.

Implémentation logicielle de l'algorithme de lecture d'un fichier à partir d'une partition logique avec le système de fichiers FAT32

L'algorithme de lecture d'un fichier à partir d'une partition avec le système de fichiers FAT32 n'est pratiquement pas différent de l'algorithme pour FAT16, sauf que dans FAT32, le répertoire racine peut être situé n'importe où sur la partition et avoir une taille arbitraire. Par conséquent, pour rendre les choses plus intéressantes, compliquons la tâche - supposons que nous ne connaissions que le numéro de la partition avec le système de fichiers FAT32. Pour lire les informations de cette partition, vous devez d'abord déterminer ses coordonnées - le décalage par rapport à la partition depuis le début du disque. Et pour cela, vous devez avoir une idée de la structure logique du disque dur.

Structure logique d'un disque dur

Considérons la structure logique d'un disque dur conforme à la norme Microsoft - « partition principale – partition étendue – partitions non-DOS ».

L'espace disque dur peut être organisé en une ou plusieurs partitions, et les partitions peuvent contenir un ou plusieurs lecteurs logiques.

Le Master Boot Record (MBR) se trouve sur le disque dur à l'adresse physique 0-0-1. La structure MBR contient les éléments suivants :

• bootstrap non-système (NSB) ;
• table décrivant les partitions du disque (table de partition, PT). Situé dans le MBR au décalage 0x1BE et occupe 64 octets ;
• Signature MBR. Les deux derniers octets du MBR doivent contenir le numéro 0xAA55.

La table des partitions décrit l'emplacement et les caractéristiques des partitions disponibles sur le disque dur. Les partitions de disque peuvent être de deux types : primaires (primaire, principale) et étendues (étendues). Le nombre maximum de partitions principales est de quatre. La présence d'au moins une partition principale sur le disque est obligatoire. Une partition étendue peut être divisée en un grand nombre de sous-partitions - des lecteurs logiques. Une structure simplifiée du MBR est présentée dans le tableau 7. La table de partition est située à la fin du MBR ; 16 octets sont alloués pour décrire la partition dans la table.

Tableau 7. Structure du MBR

Biais Taille, octets 0 446 0x1BE 16 0x1CE 16 0x1DE 16 0x1EE 16 0x1FE 2

La structure des entrées de la table de partition est présentée dans le tableau 8.

Tableau 8. Structure des entrées de la table de partition

Le premier octet de l'élément section est l'indicateur d'activité de la section (0 – inactif, 0x80 – actif). Il est utilisé pour déterminer si la partition est en cours de démarrage du système et s'il est nécessaire de charger le système d'exploitation à partir de celle-ci au démarrage de l'ordinateur. Une seule section peut être active. Le drapeau d'activité de partition est suivi des coordonnées du début de la partition - trois octets indiquant le numéro de tête, le numéro de secteur et le numéro de cylindre. Les numéros de cylindre et de secteur sont spécifiés au format d'interruption Int 0x13, c'est-à-dire les bits 0 à 5 contiennent le numéro de secteur, les bits 6 à 7 – les deux bits les plus significatifs du numéro de cylindre à 10 bits, les bits 8 à 15 – les huit bits les moins significatifs du numéro de cylindre. Ceci est suivi d'un code d'identification système, indiquant que cette section appartient à un système d'exploitation particulier. L'identifiant occupe un octet. Derrière l'identifiant du système se trouvent les coordonnées de la fin de la section - trois octets contenant respectivement les numéros de la tête, du secteur et du cylindre. Les quatre octets suivants correspondent au nombre de secteurs avant la partition et les quatre derniers octets correspondent à la taille de la partition en secteurs.

Ainsi, un élément de table de partition peut être décrit en utilisant la structure suivante :

struct pt_struct (

U8 amorçable ; // indicateur d'activité de section

U8 start_part; // coordonnées du début de la section

U8 type_part; // identifiant du système

U8 end_part; // coordonnées de la fin de la section

U32 secte_avant; // nombre de secteurs avant la partition

U32 secte_total ; // taille de la partition en secteurs (nombre de secteurs dans la partition)

L'élément de partition primaire pointe directement vers le secteur de démarrage du disque logique (il n'y a toujours qu'un seul disque logique dans la partition primaire), et l'élément de partition étendue pointe directement vers une liste de disques logiques constituée de structures appelées MBR secondaire (Secondary MBR, SMBR).

Chaque disque de la partition étendue possède son propre bloc SMBR. SMBR a une structure similaire à MBR, mais il n'a pas d'enregistrement de démarrage (rempli de zéros) et seuls deux des quatre champs de descripteur de partition sont utilisés. Le premier élément de la section pointe vers le disque logique, le deuxième élément pointe vers la structure SMBR suivante dans la liste. Le dernier SMBR de la liste contient un code de partition nul dans son deuxième élément.

Revenons au module de lecture d'un fichier depuis une partition FAT32.

Fichiers d'en-tête :

#inclure

#inclure

#inclure

#inclure

#inclure

Signature MBR :

#définir SIGNATURE 0xAA55

Fichier de périphérique à partir duquel les informations de partition seront lues :

#define DEVICE "/dev/hda"

Taille de l'élément de la table de partition (16 octets) :

#définir PT_SIZE 0x10

Le tableau de structures suivant mappe le code de type d'une section à sa représentation symbolique :

types de systèmes de structure (

Type_pièce U8 ;

U8 *nom_pièce ;

struct systypes i386_sys_types = (

(0x00, "Vide"),

(0x01, "FAT12"),

(0x04, "FAT16<32M"},

(0x05, "Étendu"),

(0x06, "FAT16"),

(0x0b, "Win95 FAT32"),

(0x0c, "Win95 FAT32 (LBA)"),

(0x0e, "Win95 FAT16 (LBA)"),

(0x0f, "Win95 Ext"d (LBA)"),

(0x82, "échange Linux"),

(0x83, "Linux"),

(0x85, "Linux étendu"),

(0x07, "HPFS/NTFS")

Déterminons le nombre d'éléments dans le tableau i386_sys_types à l'aide de la macro PART_NUM :

#define PART_NUM (sizeof(i386_sys_types) / sizeof(i386_sys_types))

Fixons une limite au nombre de disques logiques :

#définir MAX_PART 20

Le tableau de structure suivant contiendra des informations sur les lecteurs logiques du périphérique (disque dur) :

struct pt_struct (

U8 amorçable ;

U8 start_part;

U8 type_part;

U8 end_part;

U32 secte_avant;

U32 secte_total ;

) pt_t;

int dur; // descripteur de fichier de périphérique

U8 membres; // compte le MBR ici

Numéro de la partition sur laquelle le système de fichiers FAT32 a été créé :

#définir FAT32_PART_NUM 5

Structures du secteur de démarrage, du secteur FSInfo et de l'entrée du répertoire (définies dans le fichier ):

struct fat_boot_sector fbs;

struct fat_boot_fsinfo fsinfo ;

struct msdos_dir_entry dentry ;

U32 *fat32 = NULL; // copie la table FAT32 ici

Taille_secteur U16 ; // taille du secteur (à partir de FAT32)

U16 répertoire_entrées ; // 0 pour FAT32

Secteurs U16 ; // nombre de secteurs sur la partition

U32 fat32_size; // Taille FAT32

U32 data_start ; // début de la zone de données

U16 octet_per_cluster ; // combien d'octets y a-t-il dans le cluster (taille du cluster en octets)

U32 next_cluster ; // cluster suivant dans la chaîne

cluster_racine U32 ; // Cluster ROOT - cluster initial du répertoire racine

U8 *dir_entry = NULL; // pointeur vers les entrées du répertoire

U64 start_seek = 0 ; // décalage de départ par rapport à la partition (en octets)

Fonction principale:

int main()

Numéro int = 0 ;

Int numéro_cluster = 5 ; // combien de clusters lire dans le fichier

U8 *full_path = "/Dossier1/Dossier2/readme"; // fichier à lire

Nous ouvrons l'appareil, obtenons des informations sur la table de partition sur l'appareil et affichons des informations sur les partitions :

Difficile = ouvert (DEV_NAME, O_RDONLY);

Si (dur< 0) {

Perreur(DEV_NAME);

Sortie(-1);

Si (get_pt_info (dur)< 0) {

Perror("get_pt_info");

Sortie(-1);

Show_pt_info();

Nous calculons le décalage de départ par rapport à la partition :

Start_seek = (__u64)(pt_t.sect_before) * 512 ;

Lisez les clusters appartenant au fichier :

Num = fat32_read_file(full_path, cluster_num);

Si (numéro< 0) perror("fat32_read_file");

Sinon printf("Lire %d clusters\n", num);

Fermer (dur);

Renvoie 0 ;

Les informations sur la table de partition sont lues par la fonction get_pt_info() :

int get_pt_info (int dur)

Int je = 0 ;

Recherche U64 ;

Nous lisons la table de partition du MBR et vérifions la signature :

Read_main_ptable(dur);

Si(check_sign()< 0) {

Printf("Signature non valide !\n");

Renvoie -1 ;

Nous recherchons l'identifiant de la section étendue. S'il y en a un, nous calculons le décalage par rapport à la partition étendue et lisons les informations sur les disques logiques :

pour (; je< 4; i++) {

Si((pt_t[i].type_part == 0xF) || \

(pt_t[i].type_part == 0x5) || \

(pt_t[i].type_part == 0x0C)) (

Rechercher = (__u64)pt_t[i].sect_before * 512;

Read_ext_ptable(dur, chercher);

Casser;

Renvoie 0 ;

Fonction de lecture de table de partition read_main_ptable() :

void read_main_ptable (int dur)

Si (lire (dur, mbr, 512)< 0) {

Perror("lire");

Fermer (dur);

Sortie(-1);

Memset((void *)pt_t, 0, (PT_SIZE * 4));

Memcpy((void *)pt_t, mbr + 0x1BE, (PT_SIZE * 4));

Retour;

Fonction de vérification de signature check_sign() :

int check_sign()

signe U16 = 0 ;

Memcpy((void *)&sign, (void *)(mbr + 0x1FE), 2);

#ifdef DÉBOGAGE

Printf("Signature - 0x%X\n", signe);

#fin si

Si(signe != SIGNATURE) renvoie -1;

Renvoie 0 ;

Fonction de lecture de table de partition étendue :

void read_ext_ptable (int dur, recherche __u64)

Numéro int = 4 ; // à partir de cette position, le tableau des structures pt_t sera rempli d'informations sur les lecteurs logiques

U8 petit groupe;

Des données d'entrée:

• dur– descripteur de fichier de dispositif ;
• chercher– décalage vers la partition étendue depuis le début du disque (en octets).

Pour obtenir des informations sur les disques logiques, nous organisons une boucle :

Pour(;;num++) (

On lit SMBR, situé au décalage de recherche par rapport au début du disque :

Memset((void *)smbr, 0, 512);

Pread64 (dur, smbr, 512, recherche) ;

Nous remplissons deux éléments de la table pt_t, en commençant par la position num. Le premier élément pointera vers le lecteur logique et le second pointera vers la structure SMBR suivante :

Memset((void *)&pt_t, 0, PT_SIZE * 2);

Memcpy((void *)&pt_t, smbr + 0x1BE, PT_SIZE * 2);

Nous apportons une modification au champ « Numéro de secteur de démarrage » - le comptage se fait à partir du début du disque :

Pt_t.sect_before += (recherche / 512);

Si le code du type de partition est zéro, alors il n'y a plus de disques logiques :

If(!(pt_t.type_part)) break;

Nous calculons le décalage par rapport au SMBR suivant :

Recherche = ((__u64)(pt_t.sect_before + pt_t.sect_total)) * 512 ;

Retour;

La fonction show_pt_info() affiche des informations sur les lecteurs logiques trouvés sur le périphérique :

vide show_pt_info()

Int je = 0, n ;

#ifdef DÉBOGAGE

Printf("Le nombre de partitions sur le disque est %d\n", PART_NUM);

#fin si

Pour (; je< MAX_PART; i++) {

If(!pt_t[i].type_part) break;

Printf("\nType de partition %d - ", i);

Pour(n = 0; n< PART_NUM; n++) {

Si(pt_t[i].type_part == i386_sys_types[n].part_type) (

Printf("%s\n", i386_sys_types[n].part_name);

Casser;

If(n == PART_NUM) printf("type inconnu\n");

Printf("Signe de démarrage - 0x%X\n", pt_t[i].bootable);

Printf("Secteurs dans la partition %d - %d\n", i, pt_t[i].sect_total);

Printf("Secteurs avant la partition %d - %d\n\n", i, pt_t[i].sect_before);

Retour;

La lecture des clusters de fichiers à partir d'une partition FAT32 est effectuée par la fonction fat32_read_file(). Cette fonction a beaucoup en commun avec la fonction fat16_read_file(), veuillez donc vous référer au point 6 pour des commentaires détaillés :

int fat32_read_file(__u8 *full_path, int num)

Structure split_name sn ;

U8 tmp_name_buff;

Int je = 1, n;

U32 start_cluster, next_cluster ;

U8 *tmp_buff;

Opérations préparatoires - nous nettoyons le tampon, la structure et vérifions la première barre oblique :

Memset(tmp_name_buff, 0, SHORT_NAME);

Memset((void *)&sn, 0, sizeof(struct split_name));

If(full_path != "/") return -1;

Lecture du secteur de démarrage :

Si(read_fbs()< 0) return -1;

Memcpy((void *)§or_size, (void *)fbs.sector_size, 2);

Memcpy((void *)&dir_entries, (void *)fbs.dir_entries, 2);

Memcpy((void *)§eurs, (void *)fbs.sectors, 2);

Nous lisons la structure FSInfo et affichons la signature qui s'y trouve :

Si(read_fs_info()< 0) return -1;

Printf("Signature1 - 0x%X\n", fsinfo.signature1);

Printf("Signature2 - 0x%X\n", fsinfo.signature2);

Fat32_size = fbs.fat32_length * 512 ; // Taille FAT32 en octets

Data_start = 512 * fbs.reserved + fat32_size * 2 ; // début du champ de données

Byte_per_cluster = fbs.cluster_size * 512 ; // taille du cluster en octets

Root_cluster = fbs.root_cluster ; // numéro de cluster du répertoire racine

Lecture de FAT32 :

Si(read_fat32()< 0) return -1;

Allouez de la mémoire pour les entrées du répertoire :

Dir_entry = (__u8 *)malloc(byte_per_cluster);

If(!dir_entry) renvoie -1 ;

Lecture du répertoire racine :

Si (read_directory (root_cluster)< 0) return -1;

Nous analysons le chemin complet du fichier et divisons chaque élément en ses composants :

Tandis que(1) (

Memset(tmp_name_buff, 0, SHORT_NAME);

Memset((void *)&sn, 0, sizeof(struct split_name));

Pour(n = 0 ; n< SHORT_NAME; n++, i++) {

Tmp_name_buff[n] = chemin_complet[i];

Si((tmp_name_buff[n] == "/") || (tmp_name_buff[n] == "\0")) (

je++;

Casser;

Tmp_name_buff[n] = "\0" ;

Si(split_name(tmp_name_buff, &sn)< 0) {

Printf("nom non valide\n");

Renvoie -1 ;

Si(get_dentry(&sn)< 0) {

Printf("Aucun fichier de ce type !\n");

Renvoie -1 ;

Pour obtenir le numéro de départ d'un cluster dans le système de fichiers FAT32, vous devez utiliser le mot le plus élevé du numéro du premier cluster du fichier - le champ starthi de la structure dentry :

Start_cluster = (((__u32)dentry.starthi<< 16) | dentry.start);

Vérification de l'octet d'attribut :

If(dentry.attr & 0x10) ( // c'est le répertoire

Si (read_directory (start_cluster)< 0) return -1;

Continuer;

If(dentry.attr & 0x20) ( // et ceci est un fichier

Tmp_buff = (__u8 *)malloc(byte_per_cluster);

N = open("clust", O_CREAT|O_RDWR, 0600);

Si(n< 0) {

Perror("ouvrir");

Renvoie -1 ;

Printf("premier cluster du fichier - 0x%X .. ", start_cluster);

Pour (i = 0; je< num; i++) {

Memset(tmp_buff, 0, byte_per_cluster);

Si (read_cluster (start_cluster, tmp_buff)< 0) return -1;

Si (write (n, tmp_buff, byte_per_cluster)< 0) {

Perror("écrire");

Renvoie -1 ;

Si(next_cluster == EOF_FAT32) (

Gratuit(tmp_buff);

Fermer(n);

Renvoie ++i;

Start_cluster = next_cluster ;

Renvoyez-moi ;

Le but des trois fonctions suivantes est d'obtenir le contenu de la zone système, c'est-à-dire secteur de démarrage, structure FSInfo et table FAT32 :

1) la fonction read_fbs() lit le secteur de démarrage :

int read_fbs()

Si(pread64(dur, (__u8 *)&fbs, sizeof(fbs), start_seek)< 0) return -1;

Renvoie 0 ;

2) la fonction read_fs_info() lit la structure FSInfo :

int read_fs_info()

Recherche U64 = (__u64)fbs.info_sector * 512 + start_seek ;

Si(pread64(dur, (__u8 *)&fsinfo, sizeof(fsinfo), seek)< 0) return -1;

Renvoie 0 ;

3) la fonction read_fat32() lit la table FAT32 :

int read_fat32()

Recherche U64 = (__u64)fbs.reserved * 512 + start_seek ;

Fat32 = (void *)malloc(fat32_size);

Si(!fat32) renvoie -1 ;

Si(pread64(dur, (__u8 *)fat32, fat32_size, chercher)< 0) return -1;

Renvoie 0 ;

La fonction read_cluster() lit le cluster avec le numéro spécifié :

int read_cluster(__u32 cluster_num, __u8 *tmp_buff)

Recherche U64 = (__u64)(byte_per_cluster) * (cluster_num - 2) + data_start + start_seek ;

Si (pread64 (dur, tmp_buff, byte_per_cluster, recherche)< 0) return -1;

Renvoie 0 ;

La fonction read_directory() permet de lire des répertoires (y compris le répertoire racine) :

int read_directory(__u32 start_cluster)

Int je = 2;

U32 next_cluster ;

Les paramètres de la fonction sont le cluster de départ du répertoire. Nous lisons le contenu du répertoire dans le buffer global dir_entry :

Si (read_cluster (start_cluster, dir_entry)< 0) return -1;

Next_cluster = fat32;

Si le répertoire occupe un cluster, quittez ; sinon, augmentez la taille de la mémoire et continuez à lire :

Pour(; ;i++) (

Start_cluster = next_cluster ;

Dir_entry = (__u8 *)realloc(dir_entry, i * byte_per_cluster);

If(!dir_entry) renvoie -1 ;

Si(read_cluster(start_cluster, (dir_entry + (i - 1) * byte_per_cluster))< 0) return -1;

Next_cluster = fat32;

If((next_cluster == EOF_FAT32) || (next_cluster == 0xFFFFFF8)) renvoie 0 ;

Renvoie 0 ;

La dernière fonction que nous examinerons recherche dans le contenu d'un répertoire un élément qui correspond au fichier que nous recherchons :

int get_dentry(struct split_name *sn)

Int je = 0 ;

Le pointeur dir_entry est positionné sur une zone de mémoire contenant un tableau d'entrées de répertoire dans lequel nous allons rechercher le fichier (ou répertoire). Pour rechercher, nous organisons un cycle et plaçons l'enregistrement trouvé dans la structure globale dentry :

Pour(;;i++) (

Memcpy((void *)&dentry, dir_entry + i * sizeof(dentry), sizeof(dentry));

If(!(memcmp(dentry.name, sn->name, sn->name_len)) &&

!(memcmp(dentry.ext, sn->ext, sn->ext_len)))

Casser;

If(!dentry.name) renvoie -1 ;

Renvoie 0 ;

Ceci conclut notre revue du module de lecture d'un fichier à partir d'une partition FAT32.

Le code source du module se trouve dans le répertoire FAT32, fichier fat32.c.

Différences dans l'organisation du stockage des enregistrements de fichiers dans des répertoires pour les systèmes de fichiers FAT et EXT2

Quelques mots sur les différences dans l'organisation du stockage des enregistrements de fichiers dans les répertoires des systèmes de fichiers FAT et EXT2. La structure du système de fichiers EXT2 a été discutée dans .

Nous venons de faire connaissance avec FAT - dans celui-ci, tous les éléments du répertoire ont une valeur fixe. Lorsqu'un fichier est créé, le pilote du système de fichiers recherche la première position inoccupée et la remplit avec des informations sur le fichier. Si la longueur du répertoire ne rentre pas dans un cluster, alors un autre cluster lui est alloué, etc.

Regardons comment les choses se passent dans EXT2.

Disons que nous avons une partition avec le système de fichiers EXT2, la taille du bloc est de 4096 octets. Dans cette section, nous créons un répertoire. La taille du répertoire sera égale à la taille du bloc - 4096 octets. Dans un répertoire, le système d'exploitation crée immédiatement deux entrées : une entrée pour le répertoire courant et une entrée pour le répertoire parent. L'entrée du répertoire actuel prendra 12 octets, tandis que l'entrée du parent fera 4 084 octets. Créons un fichier dans ce répertoire. Après cela, il y aura trois entrées dans le répertoire : une entrée du répertoire actuel d'une longueur de 12 octets, une entrée du répertoire parent d'une longueur de 12 octets et une entrée du fichier créé d'une longueur de, comme vous l'avez probablement deviné, 4072 octets. Si nous supprimons le fichier créé, la longueur de l'entrée du répertoire parent augmente à nouveau jusqu'à 4084 octets.

Ainsi, lors de la création d'un fichier, le pilote du système de fichiers EXT2 recherche l'entrée de longueur maximale dans le répertoire et la divise, laissant ainsi la place à une nouvelle entrée. Eh bien, s'il n'y a toujours pas assez d'espace, un autre bloc est alloué au répertoire et la longueur du répertoire devient 8 192 octets.

Et en conclusion, une petite modification de l'article « Architecture du système de fichiers EXT2 ».

Ce changement concerne la fonction get_i_num() permettant de déterminer le numéro d'inode par nom de fichier. L'ancienne version de cette fonction ressemblait à ceci :

int get_i_num(char *nom)

Int je = 0, rec_len = 0 ;

Structure ext2_dir_entry_2 dent ;

Pour (; je< 700; i++) {

If(!memcmp(dent.name, name, dent.name_len)) break;

Rec_len += dent.rec_len;

Renvoie dent.inode;

Version corrigée:

int get_i_num(char *nom)

* Le paramètre de fonction est le nom du fichier. La valeur de retour est le numéro d'inode du fichier.

Int rec_len = 0 ;

Structure ext2_dir_entry_2 dent ; // cette structure décrit le format de l'entrée du répertoire racine :

* Le tampon global contient un tableau d'entrées de répertoire. Pour déterminer le numéro de série du fichier inode, vous devez trouver

* dans ce tableau il y a une entrée avec le nom de ce fichier. Pour ce faire, on organise une boucle :

Pour(;;) (

/* Copie les entrées du répertoire dans la structure dent : */

Memcpy((void *)&dent, (buff + rec_len), sizeof(dent));

* Une longueur de nom de fichier de zéro signifie que nous avons parcouru toutes les entrées du répertoire

* et aucune entrée avec notre nom de fichier n'a été trouvée. Il est donc temps de revenir en arrière :

If(!dent.name_len) renvoie -1 ;

/* La recherche est effectuée en comparant les noms de fichiers. Si les noms correspondent, on sort de la boucle : */

If(!memcmp(dent.name, name, strlen(name))) break;

/* Si les noms ne correspondent pas, passez à l'entrée suivante : */

Rec_len += dent.rec_len;

/* En cas de succès, renvoie le numéro d'inode du fichier : */

Renvoie dent.inode;

Littérature:

1. V. Koulakov. Programmation au niveau matériel : un ouvrage de référence spécial. 2e éd. / – Saint-Pétersbourg : Peter, 2003 – 848 p.
2. A.V. Gordeev, A.Yu.Molchanov. Logiciel système / – Saint-Pétersbourg : Peter – 2002
3. Meshkov V. Architecture du système de fichiers ext2. – Magazine « Administrateur système », n° 11(12), novembre 2003 – 26-32 p.

En contact avec

En FAT, les noms de fichiers sont au format 8.3 et sont constitués uniquement de caractères ASCII. VFAT a ajouté la prise en charge des noms de fichiers longs (jusqu'à 255 caractères). Nom de fichier long, LFN) en codage UTF-16LE, avec des LFN stockés simultanément avec les noms 8.3, appelés rétrospectivement SFN. Nom de fichier court). Les LFN ne sont pas sensibles à la casse lors de la recherche. Cependant, contrairement aux SFN, qui sont stockés en majuscules, les LFN conservent la casse spécifiée lors de la création du fichier.

Structure du système FAT

Dans le système de fichiers FAT, les secteurs de disque contigus sont regroupés en unités appelées clusters. Le nombre de secteurs dans un cluster est égal à une puissance de deux (voir ci-dessous). Un nombre entier de clusters (au moins un) sont alloués pour stocker les données du fichier. Ainsi, par exemple, si la taille du fichier est de 40 octets et la taille du cluster de 4 Ko, seulement 1 % de l'espace qui lui est alloué sera réellement occupé. par les informations du fichier. Pour éviter de telles situations, il est conseillé de réduire la taille des clusters, de réduire la quantité d'informations d'adresse et d'augmenter la vitesse des opérations sur les fichiers, vice versa. En pratique, un compromis est choisi. Étant donné que la capacité du disque ne peut pas être exprimée en nombre entier de clusters, il y a généralement ce qu'on appelle à la fin du volume. secteurs excédentaires - un «reste» inférieur à la taille d'un cluster qui ne peut pas être alloué par le système d'exploitation pour stocker les informations.

L'espace du volume FAT32 est logiquement divisé en trois zones contiguës :

• Aire réservée. Contient les structures de service qui appartiennent à l'enregistrement de démarrage de la partition (Partition Boot Record - PBR, pour le distinguer du Master Boot Record - l'enregistrement de démarrage principal du disque ; PBR est également souvent appelé à tort secteur de démarrage) et sont utilisées lors de l'initialisation d'un volume;
• Une zone d'une table FAT contenant un tableau de pointeurs d'index (« cellules ») correspondant aux clusters de la zone de données. En règle générale, il existe deux copies de la table FAT sur le disque pour des raisons de fiabilité ;
• La zone de données dans laquelle le contenu réel des fichiers est enregistré - c'est-à-dire le texte des fichiers texte, l'image codée pour les fichiers image, le son numérisé pour les fichiers audio, etc. - ainsi que ce qu'on appelle. métadonnées - informations concernant les noms des fichiers et des dossiers, leurs attributs, les heures de création et de modification, leurs tailles et leur emplacement sur le disque.

FAT12 et FAT16 allouent également spécifiquement la zone du répertoire racine. Il a une position fixe (immédiatement après le dernier élément de la table FAT) et une taille fixe en secteurs.

Si un cluster appartient à un fichier, alors la cellule correspondante contient le numéro du cluster suivant du même fichier. Si la cellule correspond au dernier cluster du fichier, alors elle contient une valeur particulière (FFFF 16 pour FAT16). De cette façon, une chaîne de clusters de fichiers est construite. Les clusters inutilisés dans le tableau correspondent à des zéros. Les clusters « mauvais » (qui sont exclus du traitement, par exemple en raison de l'illisibilité de la zone correspondante de l'appareil) correspondent également à un code spécial.

Lorsqu'un fichier est supprimé, le premier caractère du nom est remplacé par un code spécial E5 16 et la chaîne de clusters de fichiers dans la table d'allocation est remise à zéro. Étant donné que les informations sur la taille du fichier (qui se trouvent dans le répertoire à côté du nom du fichier) restent intactes, si les clusters de fichiers se trouvaient séquentiellement sur le disque et n'ont pas été écrasés par de nouvelles informations, il est possible de restaurer le fichier supprimé.

Entrée de démarrage

La première structure de volume FAT est appelée BPB. Bloc de paramètres du BIOS ) et est situé dans une zone réservée, dans le secteur zéro. Cette structure contient des informations identifiant le type de système de fichiers et les caractéristiques physiques du support de stockage (disquette ou partition de disque dur).

Bloc de paramètres du BIOS

BPB était essentiellement absent du FAT qui servait MS-DOS 1.x, car à cette époque, il n'y avait que deux types de volumes différents : des disquettes simple face et double face de cinq pouces de 360 ​​Ko, le format de volume étant déterminé par le premier octet de la zone FAT. BPB a été introduit dans MS-DOS 2.x au début de 1983 en tant que structure de secteur de démarrage obligatoire qui déterminerait désormais le format du volume ; L'ancien système de détermination par le premier octet de FAT a perdu son support. Également dans MS-DOS 2.0, une hiérarchie de fichiers et de dossiers a été introduite (avant cela, tous les fichiers étaient stockés dans le répertoire racine).

La structure BPB dans MS-DOS 2.x contenait un champ « nombre total de secteurs » de 16 bits, ce qui signifiait que cette version de FAT était fondamentalement inapplicable pour les volumes supérieurs à 2 16 = 65 536 secteurs, soit plus de 32 Mo. avec une taille de secteur standard de 512 octets. Dans MS-DOS 4.0 (1988), le champ BPB ci-dessus a été étendu à 32 bits, ce qui signifie que la taille théorique du volume a augmenté à 232 = 4 294 967 296 secteurs, ou 2 To avec un secteur de 512 octets.

La modification suivante de BPB est apparue avec Windows 95 OSR2, qui a introduit FAT32 (en août 1996). La limite de deux Go sur la taille du volume a été supprimée ; un volume FAT32 peut théoriquement atteindre 8 To. Cependant, la taille de chaque fichier individuel ne peut pas dépasser 4 Go. Le bloc de paramètres du BIOS FAT32, pour la compatibilité avec les versions antérieures de FAT, répète le BPB FAT16 jusqu'au champ BPB_TotSec32 inclus, suivi des différences.

Le "secteur de démarrage" FAT32 est en fait composé de trois secteurs de 512 octets - les secteurs 0, 1 et 2. Chacun d'eux contient la signature 0xAA55 à l'adresse 0x1FE, c'est-à-dire dans les deux derniers octets si la taille du secteur est de 512 octets. Si la taille du secteur est supérieure à 512 octets, la signature est contenue à la fois à l'adresse 0x1FE et dans les deux derniers octets du secteur zéro, c'est-à-dire qu'elle est dupliquée.

FSInfo

L'enregistrement de démarrage d'une partition FAT32 contient une structure appelée FSInfo, utilisé pour stocker le nombre de clusters libres sur le volume. FSInfo occupe en règle générale le secteur 1 (voir le champ BPB_FSInfo) et a la structure suivante (adresses relatives au début du secteur) :

• FSI_LeadSig. La signature de 4 octets 0x41615252 indique que le secteur est utilisé pour la structure FSInfo.
• FSI_Réservé1. L'intervalle du 4ème au 483ème octet du secteur inclus est remis à zéro.
• FSI_StrucSig. Une autre signature se trouve à l'adresse 0x1E4 et contient la valeur 0x61417272.
• FSI_Free_Count. Le champ de quatre octets à l'adresse 0x1E8 contient la dernière valeur du nombre de clusters libres sur le volume connu du système. Une valeur de 0xFFFFFFFF signifie que le nombre de clusters libres est inconnu et doit être calculé.
• FSI_Nxt_Free. Le champ de quatre octets à l'adresse 0x1EC contient le numéro de cluster à partir duquel la recherche de clusters libres doit commencer dans la table des pointeurs d'index. Généralement, ce champ contient le numéro du dernier cluster FAT alloué pour stocker le fichier. La valeur 0xFFFFFFFF signifie que la recherche d'un cluster libre doit être effectuée dès le début de la table FAT, c'est-à-dire à partir du deuxième cluster.
• FSI_Réservé2. Champ réservé de 12 octets à l'adresse 0x1F0.
• FSI_TrailSig. Signature 0xAA550000 - 4 derniers octets du secteur FSInfo.

L'intérêt de l'introduction de FSInfo est d'optimiser le fonctionnement du système, car dans FAT32, la table des pointeurs d'index peut être importante et son analyse octet par octet peut prendre un temps considérable. Cependant, les valeurs des champs FSI_Free_Count et FSI_Nxt_Free peuvent ne pas être correctes et doivent être vérifiées pour leur adéquation. De plus, ils ne sont même pas mis à jour dans la sauvegarde FSInfo, qui se situe généralement dans le secteur 7.

Détermination du type de volume FAT

La détermination du type FAT d'un volume (c'est-à-dire le choix entre FAT12, FAT16 et FAT32) est effectuée par le système d'exploitation en fonction du nombre de clusters dans le volume, lui-même déterminé à partir des champs BPB. Tout d'abord, le nombre de secteurs du répertoire racine est calculé :

RootDirSectors = (BPB_RootEntCnt * 32) / BPB_BytsPerSec

DataSec = TotSec - (BPB_ResvdSecCnt + (BPB_NumFATs * FATSz) + RootDirSectors)

Enfin, le nombre de clusters de zones de données est déterminé :

Nombre de clusters = DataSec / BPB_SecPerClus

Sur la base du nombre de clusters, il existe une correspondance claire avec le système de fichiers :

• Nombre de clusters< 4085 - FAT12
• Nombre de clusters = 4085 ÷ 65524 - FAT16
• Nombre de clusters > 65524 - FAT32

Selon la spécification officielle, c'est le seul moyen valable de déterminer le type de FAT. La création artificielle d'un volume qui enfreint les règles de conformité spécifiées entraînera un traitement incorrect par Windows. Cependant, il est recommandé d'éviter les valeurs CountofClusters proches des critiques (4085 et 65525) afin de déterminer correctement le type de système de fichiers par des pilotes, souvent mal écrits.

Au fil du temps, FAT a commencé à être largement utilisé dans divers appareils pour assurer la compatibilité entre DOS, Windows, OS/2 et Linux. Microsoft n'a montré aucune intention de les forcer à obtenir une licence [ spécifier] .

En février 2009, Microsoft a poursuivi TomTom, un fabricant de systèmes de navigation automobile basés sur Linux, alléguant une violation de brevet.

Remarques

1. http://cd.textfiles.com/megademo2/INFO/OS2_HPFS.TXT
2. www.microsoft.com/mscorp/ip/tech/fathist.asp sur archive.org
3. Spécification du système de fichiers FAT32 de la Microsoft Extensible Firmware Initiative 1.03. Microsoft (6 décembre 2000). - Document au format Microsoft Word, 268 Ko. Archivé
4. Qu’en est-il du VFAT ? . Archives TechNet. Microsoft (15 octobre 1999). Archivé de l'original le 22 août 2011. Récupéré le 5 avril 2010.
5. L'extension du système de fichiers VFAT ne doit pas être confondue avec le pilote de système de fichiers du même nom, apparu dans Windows pour Workgroups 3.11 et conçu pour gérer les appels de fonction MS-DOS (INT 21h) en mode protégé (voir : KB126746 : Historique des versions de Windows pour Workgroups. VERSION 3.11 → Fonctionnalités hors réseau. Microsoft (14 novembre 2003). Archivé de l'original le 22 août 2011. Récupéré le 5 avril 2010.)
6. Le Tribunal fédéral des brevets déclare nul le brevet FAT de Microsoft (anglais). heise en ligne. Heise Zeitschriften Verlag (2 mars 2007). Archivé
7. Brian Kahin. Microsoft bouleverse le monde avec les brevets FAT. Le Huffington Post (10 mars 2009). Archivé de l'original le 22 août 2011. Récupéré le 10 mars 2009.
8. Ryan Paul. Le procès de Microsoft concernant les brevets FAT pourrait ouvrir la boîte de Pandore d'OSS (anglais). Ars Technica. Publications Condé Nast (25 février 2009). Archivé
9. Glyn Maugrey.(Anglais) . Monde informatiqueRoyaume-Uni. IDG (5 mars 2009). Archivé de l'original le 22 août 2011. Récupéré le 9 mars 2009.
10. Steven J. Vaughan-Nichols. Les entreprises Linux signent des accords de protection des brevets Microsoft (anglais). Blogs du monde informatique. IDG (5 mars 2009). Archivé de l'original le 22 août 2011. Récupéré le 9 mars 2009.
11. Érica Ogg. TomTom poursuit Microsoft dans le cadre d'un litige en matière de brevet. CNet (19 mars 2009). Archivé de l'original le 22 août 2011. Récupéré le 20 mars 2009.

Liens

• ECMA-107 (anglais) Norme FAT

Un système de fichiers permet d'organiser un disque. Il définit la manière dont les données sont stockées sur le disque et quels types d'informations peuvent être attachées aux fichiers : noms de fichiers, autorisations et autres attributs.

Windows prend en charge trois systèmes de fichiers différents. NTFS– le système de fichiers le plus moderne. Windows utilise NTFS pour son disque système et, par défaut, pour la plupart des disques fixes. FAT32 est un système de fichiers plus ancien qui n'est pas aussi efficace que NTFS et ne prend pas en charge un large éventail de fonctionnalités, mais offre une plus grande compatibilité avec d'autres systèmes d'exploitation. exFAT est un remplacement moderne de FAT32 et est pris en charge par plus d'appareils et de systèmes d'exploitation que NTFS - mais il n'est pas aussi répandu que FAT32.

Système de fichiers NT (NTFS)

NTFS est système de fichiers moderne, que Windows préfère utiliser par défaut. Lors de l'installation, Windows formate le disque système au format de système de fichiers NTFS. NTFS a des limites de taille de fichier et de taille de partition si énormes qu'il est peu probable que vous les rencontriez jamais. NTFS est apparu pour la première fois dans la version grand public de Windows XP, bien qu'il ait initialement fait ses débuts dans Windows NT.

NTFS regorge de fonctionnalités modernes non disponibles avec FAT32 et exFAT. NTFS prend en charge les autorisations de fichiers pour la sécurité, un journal des modifications qui peut vous aider à récupérer rapidement des erreurs en cas de panne de votre ordinateur, des clichés instantanés pour les sauvegardes, le cryptage, les restrictions de quota de disque, les liens physiques et diverses autres fonctionnalités. Beaucoup d'entre eux sont essentiels au disque du système d'exploitation, en particulier les autorisations de fichiers.

La partition système Windows doit être au format NTFS. Si vous disposez d'un lecteur supplémentaire avec Windows et envisagez d'y installer des programmes, il est préférable de le formater également avec NTFS. Et si vous disposez de disques pour lesquels la compatibilité ne pose pas de problème (parce que vous savez que vous les utiliserez sur des systèmes Windows), n'hésitez pas à choisir NTFS.

Malgré ses avantages, NTFS manque de compatibilité. Il fonctionnera avec toutes les dernières versions de Windows – jusqu'à Windows XP – mais sa compatibilité avec d'autres systèmes d'exploitation est limitée. Par défaut, Mac OS X ne peut lire que les lecteurs NTFS, mais pas écrire de données. Certaines distributions Linux peuvent inclure la prise en charge de l'écriture NTFS, mais d'autres peuvent être en lecture seule. Aucune des consoles Sony PlayStation ne prend en charge NTFS. Même la console Xbox 360 de Microsoft ne peut pas lire les lecteurs NTFS autres que la Xbox One. D'autres appareils sont encore moins susceptibles de prendre en charge NTFS.

Compatibilité: Fonctionne avec toutes les versions de Windows, mais est en lecture seule sur Mac et peut être en lecture seule sur certaines distributions Linux. Les autres appareils, à l'exception de la Microsoft Xbox One, ne prendront probablement pas en charge NTFS.

Restrictions: Limites irréalistes de taille de fichier et de partition.

Utilisation idéale: Utilisez-le pour votre lecteur système Windows et d'autres lecteurs internes qui ne seront utilisés qu'avec Windows.

Tableau d'allocation de fichiers 32 (FAT32)

FAT32 est le plus ancien des trois systèmes de fichiers disponibles sous Windows. Il a été introduit dans Windows 95 et a remplacé l'ancien système de fichiers FAT16 utilisé dans MS-DOS et Windows 3.

L'âge du système de fichiers FAT32 a ses avantages et ses inconvénients. Le gros avantage est que FAT32 est la norme de facto. Les clés USB prêtes à l'emploi disposent souvent d'un système de fichiers FAT32 pour une compatibilité maximale non seulement avec les ordinateurs modernes, mais également avec d'autres appareils tels que les consoles de jeux et tout ce qui possède un port USB.

Mais ses limites sont également liées à l’âge. Les fichiers individuels sur un lecteur FAT32 ne peuvent pas dépasser 4 Go - c'est le maximum. La partition FAT32 doit également être inférieure à 8 To. Ce sont les limites dont les appareils utilisateur modernes se sont rapprochés.

FAT32 convient aux clés USB et autres supports externes, surtout si vous savez que vous l'utiliserez sur un autre PC non Windows. Ce système de fichiers ne dispose pas des autorisations ni des autres fonctionnalités de sécurité intégrées au système de fichiers NTFS plus moderne. De plus, les versions modernes de Windows ne peuvent plus être installées sur un lecteur formaté en FAT32 ; ils doivent être installés sur des disques formatés avec NTFS.

Compatibilité: Fonctionne avec toutes les versions de Windows, Mac et Linux, les consoles de jeux et presque tous les appareils dotés d'un port USB.

Restrictions: La taille maximale du fichier est de 4 Go, la taille maximale de la partition est de 8 To.

Utilisation idéale: À utiliser sur des disques amovibles où vous avez besoin d'une compatibilité maximale avec une large gamme d'appareils, sauf si vous utilisez des fichiers de 4 Go ou plus.

Table d'allocation de fichiers étendue (exFAT)

système de fichiers exFAT a été introduit en 2006 et a été ajouté aux anciennes versions de Windows avec des mises à jour pour Windows XP et Windows Vista. exFAT est Système de fichiers optimisé pour Flash– conçu pour maintenir la compatibilité FAT32, mais sans les fonctionnalités supplémentaires de NTFS et sans les limitations de FAT32.

Comme NTFS, exFAT a des limites de taille de fichier et de partition très importantes, vous permettant de stocker des fichiers beaucoup plus volumineux que les 4 Go autorisés par FAT32.

Bien que exFAT ne corresponde pas exactement à la compatibilité de FAT32, il est plus largement compatible que NTFS. Même Mac OS offre une prise en charge complète de exFAT pour la lecture et l'écriture. Les disques exFAT sont accessibles sous Linux après avoir installé le logiciel approprié. C'est un peu plus compliqué avec d'autres appareils : la PlayStation 4 prend en charge exFAT ; La PlayStation 3 ne prend pas en charge ; La Xbox One le prend en charge, mais pas la Xbox 360.

Compatibilité: Fonctionne avec toutes les versions de Windows et les versions modernes de Mac X, mais nécessite un logiciel supplémentaire sous Linux. De plus en plus d'appareils prennent en charge exFAT, mais certains - en particulier les plus anciens - ne fonctionnent qu'avec FAT32.

Restrictions: Limites irréalistes de taille de fichier et de partition.

Utilisation idéale: Utilisez-le lorsque vous avez besoin de stocker des fichiers volumineux et lorsque vous avez besoin d'une compatibilité étendue. En supposant que chaque appareil que vous souhaitez utiliser prend en charge exFAT, vous devez formater votre appareil avec exFAT au lieu de FAT32.

NTFS est idéal pour les disques internes, tandis que exFAT est généralement idéal pour les lecteurs flash. Cependant, vous devrez parfois formater votre disque externe avec FAT32 si exFAT n'est pas pris en charge sur l'appareil avec lequel vous souhaitez l'utiliser.

En plus de toutes les autres tâches, il remplit son objectif principal : organiser le travail avec les données selon une certaine structure. Le système de fichiers est utilisé à ces fins. Qu'est-ce que FS et ce qu'il peut être, ainsi que d'autres informations à son sujet seront présentées ci-dessous.

description générale

Le système de fichiers fait partie du système d'exploitation qui est chargé de placer, stocker, supprimer des informations sur le support, de fournir ces informations aux utilisateurs et aux applications et d'assurer leur utilisation en toute sécurité. De plus, il aide à la récupération des données en cas de panne matérielle ou logicielle. C'est pourquoi le système de fichiers est si important. Qu’est-ce que FS et que peut-il être ? Il en existe plusieurs types :

Pour les disques durs, c’est-à-dire les périphériques à accès aléatoire ;

Pour les bandes magnétiques, c'est-à-dire les appareils à accès séquentiel ;

Pour supports optiques ;

Systèmes virtuels ;

Systèmes de réseau.5

L'unité logique de stockage des données dans un système de fichiers est un fichier, c'est-à-dire une collection ordonnée de données portant un nom spécifique. Toutes les données utilisées par le système d'exploitation sont présentées sous forme de fichiers : programmes, images, textes, musiques, vidéos, mais aussi pilotes, bibliothèques, etc. Chacun de ces éléments a un nom, un type, une extension, des attributs et une taille. Vous le savez maintenant, le système de fichiers est un ensemble de ces éléments, ainsi que des moyens de travailler avec eux. Selon la forme sous laquelle il est utilisé et les principes qui lui sont applicables, plusieurs grands types de FS peuvent être distingués.

Approche logicielle

Donc, si nous considérons un système de fichiers (qu'est-ce que c'est et comment l'utiliser), il convient de noter qu'il s'agit d'une structure à plusieurs niveaux, à son niveau supérieur se trouve un commutateur de système de fichiers qui fournit une interface entre le système et une application spécifique. Il convertit les requêtes en fichiers dans un format perçu par le niveau suivant : les pilotes. Ils accèdent à leur tour à des pilotes de périphériques spécifiques, qui stockent les informations nécessaires.

Les applications client-serveur ont des exigences assez élevées en matière de performances du système de fichiers. Les systèmes modernes sont conçus pour fournir un accès efficace, prendre en charge les médias de gros volumes, protéger les données contre tout accès non autorisé et maintenir l'intégrité des informations.

Système de fichiers FAT

Ce type a été développé en 1977 par Bill Gates et Mark McDonald. Il était initialement utilisé sous OS 86-DOS. Si nous parlons de ce qu'est le système de fichiers FAT, il convient de noter qu'au départ, il n'était pas capable de prendre en charge les disques durs, mais ne fonctionnait qu'avec des supports flexibles jusqu'à 1 mégaoctet. Désormais, cette limitation n'est plus d'actualité et ce FS a été utilisé par Microsoft pour MS-DOS 1.0 et les versions ultérieures. FAT utilise certaines conventions de dénomination de fichiers :

Le nom doit commencer par une lettre ou un chiffre, et le nom lui-même peut contenir n'importe quel caractère ASCII, en plus d'un espace et d'éléments spéciaux ;

Le nom ne doit pas comporter plus de 8 caractères, suivis d'un point, puis de l'extension, composée de trois lettres ;

Les noms de fichiers peuvent utiliser n'importe quelle casse et ne sont ni distingués ni conservés.

Étant donné que FAT a été initialement conçu pour le système d'exploitation DOS mono-utilisateur, il ne prévoyait pas le stockage de données sur le propriétaire ou les autorisations d'accès. À l'heure actuelle, ce système de fichiers est le plus répandu, la plupart des gens le supportent à un degré ou à un autre, et sa polyvalence permet de l'utiliser sur des volumes qui fonctionnent avec différents systèmes d'exploitation. Il s'agit d'un simple FS qui n'est pas capable d'empêcher la corruption de fichiers due à un arrêt incorrect de l'ordinateur. Les systèmes d'exploitation fonctionnant sur cette base incluent des utilitaires spéciaux qui vérifient la structure et corrigent les incohérences des fichiers.

Système de fichiers NTFS

Ce FS est le plus préférable pour travailler avec le système d'exploitation Windows NT, car il a été développé spécifiquement pour cela. Le système d'exploitation comprend un utilitaire de conversion qui convertit les volumes FAT et HPFS en volumes NTFS. Si nous parlons de ce qu'est le système de fichiers NTFS, il convient de noter qu'il a considérablement étendu les capacités de contrôle d'accès à certains répertoires et fichiers, introduit de nombreux attributs, implémenté des outils de compression de fichiers dynamiques, une tolérance aux pannes et prend en charge les exigences du Norme POSIX. Dans ce FS, vous pouvez utiliser des noms comportant jusqu'à 255 caractères et le nom court qu'il contient est généré de la même manière que dans VFAT. Comprenant ce qu'est le système de fichiers NTFS, il convient de noter que si le système d'exploitation tombe en panne, il est capable de se récupérer, de sorte que le volume du disque restera accessible et que la structure des répertoires ne sera pas affectée.

Caractéristiques de NTFS

Sur un volume NTFS, chaque fichier est représenté par une entrée dans la table MFT. Les 16 premières entrées de la table sont réservées par le système de fichiers lui-même pour stocker des informations spéciales. La toute première entrée décrit la table de fichiers elle-même. Lorsque le premier enregistrement est détruit, le second est lu pour rechercher un fichier MFT miroir dans lequel le premier enregistrement est identique à la table principale. Une copie du fichier de démarrage se trouve au centre logique du disque. La troisième entrée du tableau contient un fichier journal utilisé pour la récupération des données. La dix-septième entrée et les suivantes de la table de fichiers contiennent des informations sur les fichiers et répertoires présents sur le disque dur.

Le journal des transactions contient l'ensemble complet des opérations qui modifient la structure du volume, y compris les opérations de création de fichiers, ainsi que toutes les commandes affectant la structure des répertoires. Le journal des transactions est conçu pour récupérer NTFS après une panne du système. L'entrée du répertoire racine contient une liste de répertoires et de fichiers situés dans le répertoire racine.

Caractéristiques de l'EFS

Le système de fichiers de cryptage (EFS) est un composant Windows qui peut stocker des informations sur votre disque dur dans un format crypté. Le cryptage est devenu la protection la plus solide que ce système d'exploitation puisse offrir. Dans ce cas, le chiffrement pour l'utilisateur est une action assez simple : il suffit de cocher une case dans les propriétés du dossier ou du fichier. Vous pouvez spécifier qui peut lire ces fichiers. Le cryptage se produit lorsque les fichiers sont fermés et lorsqu'ils sont ouverts, ils sont automatiquement prêts à être utilisés.

Fonctionnalités RAW

Les appareils conçus pour stocker des données sont les composants les plus vulnérables, qui sont le plus souvent sujets à des dommages non seulement physiques, mais aussi logiques. Certains problèmes matériels peuvent être fatals, tandis que d'autres ont des solutions. Parfois, les utilisateurs se posent la question : « Qu'est-ce que le système de fichiers RAW ? »

Comme vous le savez, pour écrire des informations sur un disque dur ou un lecteur flash, le lecteur doit disposer d'un FS. Les plus courants sont FAT et NTFS. Et RAW n’est même pas un système de fichiers comme nous l’imaginons habituellement. En fait, il s'agit d'une erreur logique dans le système déjà installé, c'est-à-dire son absence réelle pour Windows. Le plus souvent, RAW est associé à la destruction de la structure du système de fichiers. Après cela, le système d'exploitation n'accède pas simplement aux données, mais n'affiche pas non plus d'informations techniques sur l'équipement.

Caractéristiques de l'UDF

Le format de disque universel (UDF) est conçu pour remplacer CDFS et ajouter la prise en charge des périphériques DVD-ROM. Si nous parlons de ce que c'est, il s'agit alors d'une nouvelle implémentation de l'ancienne version qui répond aux exigences. Elle se caractérise par certaines caractéristiques :

Les noms de fichiers peuvent contenir jusqu'à 255 caractères ;

Le nom peut être en minuscules ou en majuscules ;

La longueur maximale du chemin est de 1 023 caractères.

À partir de Windows XP, ce système de fichiers prend en charge la lecture et l'écriture.

Ce FS est utilisé pour les lecteurs flash, qui sont censés être utilisés lorsque vous travaillez avec différents ordinateurs exécutant différents systèmes d'exploitation, en particulier Windows et Linux. C'est EXFAT qui est devenu le « pont » entre eux, puisqu'il est capable de travailler avec les données reçues du système d'exploitation, chacun possédant son propre système de fichiers. Ce que c'est et comment cela fonctionne deviendra clair dans la pratique.

conclusions

Comme il ressort clairement de ce qui précède, chaque système d'exploitation utilise certains systèmes de fichiers. Ils sont destinés au stockage de structures de données ordonnées sur des supports de stockage physiques. Si vous vous posez soudainement une question lors de l'utilisation de votre ordinateur sur ce qu'est un système de fichiers final, il est fort possible que lorsque vous avez essayé de copier un certain fichier sur le support, vous ayez reçu un message concernant le dépassement de la taille autorisée. C'est pourquoi il est nécessaire de savoir dans quel FS quelle taille de fichier est considérée comme acceptable, afin que vous ne rencontriez pas de problèmes lors du transfert d'informations.