Architettura del file system FAT. Funzionalità dei file system FAT32, NTFS ed exFAT

1. Struttura del settore FSInfo struct fat_boot_fsinfo:
   • __u32 firma1- firma 0x41615252;
   • __u32 firma2- firma 0x61417272;
   • __u32 free_clusters- il numero di cluster liberi. Se il campo contiene -1, la ricerca dei cluster liberi dovrebbe essere avviata dal cluster numero 2.
2. La struttura della voce di directory del nome breve struct msdos_dir_entry:
   • __s8 nome, ext- nome ed estensione del file;
   • __u8 attr- attributi del file;
   • __u8 ctime_ms- questo campo specifica il tempo di creazione del file fino a ms (viene utilizzato solo FAT32);
   • __u16 ctime- ora di creazione del file (viene utilizzato solo FAT32);
   • __u16 cdate- data di creazione del file (viene utilizzato solo FAT32);
   • __u16 adate- data dell'ultimo accesso al file (viene utilizzato solo FAT32);
   • __u16 inizia- alto 16 bit del numero del primo cluster del file (viene utilizzato solo FAT32);
   • __u16 ora, data, inizio- ora e data di creazione del file, numero del primo cluster del file;
   • __dimensione u32- dimensione del file (in byte).
3. Struttura degli elementi della directory con nomi lunghi:
   • ID __u8- codice articolo;
   • __u8 nome0_4- caratteri 1 - 5 del nome;
   • __u8 attr- attributi del file;
   • __u8 alias_checksum- checksum del nome breve;
   • __u8 nome5_10- caratteri 6 - 11 del nome;
   • __u8 nome11_12- caratteri 12 - 13 del nome.

Continuiamo a rivedere l'implementazione software dell'algoritmo e definiamo il nome della partizione su cui viene creato il file system FAT16:

#ifndef FAT16_PART_NAME

#define FAT16_PART_NAME "/ dev / hda1"

#finisci se

Strutture globali:

struct fat_boot_sector fbs; // struttura del settore di avvio

struct msdos_dir_entry dentry; // struttura degli elementi della directory

Variabili globali:

U16 * grasso16; // copia qui la tabella FAT16

U16 dimensione_settore; // dimensione del settore (da FAT16)

U16 dir_entries; // numero di descrittori a 32 byte

// nella directory principale (0 per FAT32)

settori U16; // numero totale di settori nella sezione

U32 fat16_size; // Dimensione FAT16

U32 root_size; // dimensione della directory principale

U16 byte_per_cluster; // dimensione del cluster in byte

U16 next_cluster; // prossimo cluster nella catena

int grasso;

Iniziamo con la funzione principale:

intero principale ()

numero interno;

Impostiamo il nome completo del file, di cui vogliamo leggere il contenuto. Lascia che ti ricordi che lavoriamo solo con nomi di file brevi. La procedura per lavorare con i nomi lunghi non è trattata in questo articolo.

U8 * full_path = "/Folder1/Folder2/text.txt";

Apri il file del dispositivo:

Difficile = aperto (FAT16_PART_NAME, O_RDONLY);

Se (difficile< 0) {

Errore (FAT16_PART_NAME);

Esci (-1);

Leggiamo i primi 10 cluster del file. La lettura viene eseguita dalla funzione fat16_read_file(). I parametri della funzione sono il nome completo del file e il numero di cluster da leggere. La funzione restituisce il numero di cluster letti, o -1 se si è verificato un errore durante la lettura:

Num = fat16_read_file (full_path, 10);

Se (num< 0) perror("fat16_read_file");

Altrimenti printf ("Leggi% d cluster", num);

Chiudi il file del dispositivo ed esci:

Chiudi (difficile);

Ritorna 0;

La funzione per leggere i cluster di file è simile a questa:

int fat16_read_file (__ u8 * full_path, int num)

Struttura split_name sn; // struttura per memorizzare le parti costitutive del file

U8 tmp_name_buff; // buffer per la memorizzazione temporanea degli elementi composti del percorso completo del file

int statico i = 1;

interno n;

U8 * tmp_buff;

U16 start_cluster, next_cluster;

Abbiamo elencato i parametri della funzione quando si considera la funzione principale.

Operazioni preparatorie - azzeramento del buffer tmp_name_buff e della struttura struct split_name sn:

Il primo carattere in un percorso assoluto deve essere una barra (/). Controlliamo questo:

Leggiamo il settore di avvio dalla partizione:

Se (leggi_fbs ()< 0) return -1;

Il settore di avvio letto è ora nella struttura globale fat_boot_sector fbs. Copiamo da questa struttura la dimensione del settore, il numero di voci nella directory principale e il numero totale di settori nella partizione:

Determiniamo la dimensione del cluster in byte:

Byte_per_cluster = fbs.cluster_size * 512

Mostriamo le informazioni nel settore di avvio:

Printf ("ID sistema -% s", fbs.system_id);

Printf ("Dimensione settore -% d", dimensione_settore);

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

Printf ("Riservato -% d", fbs.reserved);

Printf ("Numero FAT -% d", fbs.fats);

Printf ("Voci dir -% d", voci_dir);

Printf ("Settori -% d", settori);

Printf ("Media - 0x% X", fbs.media);

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

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

Printf ("Byte per cluster -% d", byte_per_cluster);

Calcola la dimensione di FAT16 in byte e leggila:

Fat16_size = fbs.fat_length * 512;

Se (leggi_fat16 ()< 0) return -1;

Leggiamo la directory principale:

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

Il puntatore dir_entry è ora posizionato nell'area di memoria contenente le voci della directory principale. La dimensione di questa area di memoria è uguale alla dimensione della directory radice (root_size).

Salviamo (per controllo) il contenuto della directory principale in un file separato:

#ifdef DEBUG

Chiudi (grasso);

#finisci se

Calcoliamo l'inizio dell'area dati:

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

Con tutte le voci nella directory principale a posto, possiamo arrivare al contenuto del file test.txt. A tal fine, organizzeremo un ciclo. Nel corpo del ciclo, analizziamo il nome completo del file, evidenziando i suoi elementi: le sottodirectory (ne abbiamo due, Folder1 e Folder2) e il nome del file richiesto (test.txt).

Mentre (1) (

Memset (tmp_name_buff, 0, SHORT_NAME);

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

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

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

io++;

Rottura;

Tmp_name_buff [n] = "?";

Compila la struttura split_name sn con le informazioni appropriate. Il riempimento viene eseguito dalla funzione split_name, mentre il nome del file viene confrontato con il formato "8.3":

< 0) {

Printf ("nome non valido");

Ritorno -1;

Per ogni elemento del nome completo del file, definiamo un cluster iniziale. Per fare ciò, cerca negli elementi della directory (a partire dalla radice) una voce corrispondente all'elemento del nome completo e leggi questa voce. La funzione get_dentry() esegue la procedura di ricerca:

If (get_dentry (& sn)< 0) {

Printf ("Nessun file simile!");

Ritorno -1;

Controllo degli attributi del file. Se è una directory, leggi il suo contenuto e continua il ciclo:

If (dentry.attr & 0x10) (

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

Continua;

Se questo è un file, leggi i primi num cluster. Per controllo, salveremo le informazioni lette in un file separato:

If (dentry.attr & 0x20) (

Start_cluster = dentry.start;

Tmp_buff = (__u8 *) malloc (byte_per_cluster); // il contenuto del cluster verrà letto qui

N = aperto ("clust", O_CREAT | O_RDWR, 0600); // salva le informazioni lette in questo file

Se (n< 0) {

Errore ("aperto");

Ritorno -1;

Per leggere i cluster di file, organizzeremo un ciclo:

Per (i = 0; i< num; i++) {

Leggiamo il contenuto del cluster nel buffer tmp_buff e lo salviamo in un file separato:

< 0) return -1;

< 0) {

Errore ("scrivi");

Chiudi (n);

Ritorno -1;

Leggiamo da FAT16 il numero del cluster successivo occupato da questo file. Se questo è l'ultimo cluster, interrompiamo il ciclo e torniamo alla funzione principale:

#ifdef DEBUG

Printf ("OK. Letto");

Printf ("cluster successivo del file - 0x% X ..", cluster_successivo);

#finisci se

If (cluster_successivo == EOF_FAT16) (

#ifdef DEBUG

Printf ("ultimo cluster.");

#finisci se

Gratuito (tmp_buff);

Chiudi (n);

Ritorna ++ i;

#ifdef DEBUG

Printf ("ferma lettura");

#finisci se

Ritorno io;

La lettura del settore di avvio FAT16 viene eseguita dalla funzione read_fbs(). Il risultato viene inserito nella struttura fbs globale:

int read_fbs ()

If (read (hard, (__ u8 *) & fbs, sizeof (fbs))< 0) return -1;

Ritorna 0;

La lettura della tabella di allocazione dei file del file system FAT16 viene eseguita dalla funzione read_fat16():

int read_fat16 ()

U64 ricerca = (__u64) (fbs.reserved) * 512; // offset a FAT16 dall'inizio della partizione

Fat16 = (void *) malloc (fat16_size);

If (pread64 (hard, (__u8 *) fat16, fat16_size, search)< 0) return -1;

Ritorna 0;

La lettura della directory principale viene eseguita dalla funzione read_root_dentry():

int read_root_dentry ()

U64 ricerca = (__u64) fbs.reserved * 512 + fat16_size * fbs.fats; // offset alla directory principale dall'inizio della sezione

Root_size = 32 * dir_entries; // calcola la dimensione della directory principale

Dir_entry = (__u8 *) malloc (root_size);

If (! Dir_entry) return -1;

Memset (dir_entry, 0, root_size);

If (pread64 (hard, dir_entry, root_size, search)< 0) return -1;

Ritorna 0;

La lettura di un cluster appartenente a un file viene eseguita dalla funzione read_cluster(). I parametri di input della funzione sono il numero del cluster cluster_num e un puntatore al buffer __u8 * tmp_buff, dove dovrebbe essere posizionato il risultato della lettura. L'offset al cluster sulla sezione è calcolato dalla formula (vedi):

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

• CERCARE- offset al cluster sulla partizione
• DATA_START- inizio area dati
• CLUSTER_NUM- numero progressivo del cluster
• BYTE_PER_CLUSTER- dimensione del cluster in byte

int read_cluster (__ u16 cluster_num, __u8 * tmp_buff)

U64 ricerca = (__u64) (byte_per_cluster) * (cluster_num - 2) + data_start; // calcola l'offset rispetto al cluster

< 0) return -1;

Ritorna 0;

La funzione read_directory legge le voci nella directory (non nella radice) e inserisce il risultato nell'area di memoria su cui è impostato il puntatore dir_entry:

int read_directory (__ u16 start_cluster)

Int i = 1;

U16 next_cluster;

Per (;; io ++) (

Allochiamo memoria per memorizzare il contenuto della directory, leggiamo il contenuto del cluster di partenza e otteniamo il valore del cluster successivo dalla tabella FAT16:

If (! Dir_entry) return -1;

< 0) return -1;

Next_cluster = fat16;

Salviamo il contenuto della directory in un file separato (per il controllo):

#ifdef DEBUG

Printf ("Cluster successivo - 0x% X", cluster_successivo);

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

Scrivi (grasso, dir_entry, root_size);

Chiudi (grasso);

#finisci se

Se viene raggiunto l'ultimo cluster, esci dal ciclo, altrimenti continua a leggere la directory, aumentando la dimensione del buffer dir_entry di un altro cluster:

If (next_cluster & EOF_FAT16) break;

Start_cluster = next_cluster;

Ritorna 0;

La funzione get_dentry() ricerca nel contenuto della directory un elemento che corrisponda al file che stai cercando. Gli input a questa funzione sono un puntatore a una struttura split_name * sn contenente gli elementi del nome file breve:

Int i = 0;

Il buffer globale dir_entry contiene un array di voci di directory in cui cercheremo una voce di file (o directory). Per la ricerca, organizzeremo un ciclo. Nel corpo del ciclo, copiare le voci della directory nella struttura dentry globale e confrontare il valore dei campi name ed ext di questa struttura con i campi corrispondenti della struttura struct split_name * sn. La coincidenza di questi campi significa che abbiamo trovato la voce del file richiesto nell'array di elementi del catalogo:

per (;; io ++) (

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

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

Rottura;

If (! Dentry.name) return -1;

#ifdef DEBUG

Printf ("nome -% s", dent.nome);

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

Printf ("dimensione file -% u", dentry.size);

Printf ("file attributo - 0x% X", dentry.attr);

#finisci se

Ritorna 0;

Tutto il codice sopra si trova nella directory FAT16, file fat16.c. Per ottenere il modulo eseguibile, crea un Makefile con il seguente contenuto:

INCDIR = / usr / src / linux / include

FALSO = pulito

Fat16: fat16.o split.o

Gcc -I $ (INCDIR) $ ^ -g -o [e-mail protetta]

% .o:% .c

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

Pulito:

Rm -f * .o

Rm -f ./grasso16

Implementazione software dell'algoritmo per la lettura di un file da una partizione logica con il file system FAT12

In generale, l'algoritmo per leggere un file da una partizione FAT12 è identico all'algoritmo per leggere un file da una partizione FAT16. La differenza sta nella procedura di lettura degli elementi dalla tabella FAT12. Abbiamo considerato la tabella FAT16 come un semplice array di elementi a 16 bit. Per la lettura degli elementi della tabella FAT12 viene proposto il seguente algoritmo:

• moltiplicare il numero dell'elemento per 1,5;
• estrarre una parola a 16 bit da FAT utilizzando come offset il risultato dell'operazione precedente;
• se il numero dell'elemento è pari, eseguire l'operazione AND sulla parola letta e mascherare 0x0FFF. Se il numero è dispari, sposta la parola letta dalla tabella di 4 bit verso i bit meno significativi.

Sulla base di questo algoritmo, implementeremo la funzione di lettura degli elementi dalla tabella FAT12:

int get_cluster (__ u16 cluster_num)

U16 cerca;

gruppo U16;

Calcola l'offset nella tabella FAT12 e leggi la parola a 16 bit dalla tabella:

Cerca = (cluster_num * 3) / 2;

Memcpy ((__ u8 *) & cluster, (__u8 *) (fat12 + ricerca), 2);

Se il numero iniziale del cluster è un numero pari, spostiamo il valore letto dalla tabella di 4 bit verso le cifre inferiori, se è dispari lo aggiungiamo a 0x0FFF:

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

Else cluster & = 0x0FFF;

Questo frammento può essere implementato anche in assembler:

"xorw %% ax, %% ax"

"tra $ 0, %% cx"

"jnc 1f"

"shw $ 4, %% dx"

"jmp2f"

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

"2: movw %% dx, %% ax"

: "= a" (successivo)

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

Restituiamo il risultato:

Gruppo di ritorno;

Soffermiamoci un po' di più sull'algoritmo stesso. Supponiamo che venga creato un file su una partizione FAT12 che occupa il 9° e il 10° cluster. Ogni elemento FAT12 è lungo 12 bit. Perché leggiamo elementi a 16 bit dalla tabella, quindi l'offset al 9° elemento sarà di 13 byte (9 * 1.5 = 13, scartiamo il resto), mentre i 4 bit meno significativi apparterranno all'8° elemento di FAT. Devono essere scartati e per questo è sufficiente spostare l'elemento letto di 4 bit verso le cifre inferiori, fornite dall'algoritmo. L'offset al decimo elemento sarà di 15 byte e i 4 bit più significativi apparterranno all'undicesimo elemento del FAT. Per scartarli è necessario eseguire l'operazione AND sul decimo elemento e la maschera 0x0FFF, che corrisponde anche all'algoritmo di cui sopra.

I codici sorgente del modulo per la lettura del file dalla partizione FAT12 si trovano nella directory FAT12, file fat12.c.

Implementazione software dell'algoritmo per la lettura di un file da una partizione logica con il file system FAT32

L'algoritmo per leggere un file da una partizione con il file system FAT32 praticamente non differisce dall'algoritmo per FAT16, tranne per il fatto che in FAT32 la directory principale può trovarsi in qualsiasi punto della partizione e avere una dimensione arbitraria. Pertanto, per renderlo più interessante, complichiamo il compito: supponiamo di conoscere solo il numero di partizione con il file system FAT32. Per leggere le informazioni da questa sezione, devi prima determinarne le coordinate: l'offset rispetto alla sezione dall'inizio del disco. E per questo è necessario avere un'idea della struttura logica del disco rigido.

Struttura logica del disco rigido

Considera la struttura logica di un disco rigido conforme allo standard Microsoft: "partizione principale - partizione estesa - partizioni non DOS".

Lo spazio su disco rigido può essere organizzato come una o più partizioni e le partizioni possono contenere una o più unità logiche.

L'hard disk all'indirizzo fisico 0-0-1 contiene il Master Boot Record (MBR). La struttura MBR contiene i seguenti elementi:

• bootstrap non di sistema (NSB);
• tabella di descrizione delle partizioni del disco (tabella delle partizioni, PT). Situato nell'MBR all'offset 0x1BE e occupa 64 byte;
• Firma MBR. Gli ultimi due byte dell'MBR devono contenere il numero 0xAA55.

La tabella delle partizioni descrive la posizione e le caratteristiche delle partizioni disponibili sul disco rigido. Le partizioni del disco possono essere di due tipi: primaria ed estesa. Il numero massimo di partizioni primarie è quattro. È obbligatorio avere almeno una partizione primaria sul disco. Una partizione estesa può essere suddivisa in un gran numero di sottosezioni: unità logiche. Una struttura semplificata dell'MBR è mostrata nella Tabella 7. La tabella delle partizioni si trova alla fine dell'MBR, 16 byte sono allocati per la descrizione della partizione nella tabella.

Tabella 7. Struttura MBR

Pregiudizio Dimensione, byte 0 446 0x1BE 16 0x1CE 16 0x1DE 16 0x1EE 16 0x1FE 2

La struttura della voce della tabella delle partizioni è mostrata nella Tabella 8.

Tabella 8. Struttura della voce dell'elemento della tabella delle partizioni

Il primo byte nell'elemento della sezione è il flag di attività della sezione (0 - inattivo, 0x80 - attivo). Serve a determinare se la partizione è un sistema avviabile e se è necessario avviare il sistema operativo da essa all'avvio del computer. Può essere attiva una sola sezione. Il flag della partizione attiva è seguito dalle coordinate dell'inizio della partizione - tre byte, ovvero il numero di testa, il numero di settore e il numero di cilindro. I numeri di cilindro e settore sono specificati nel formato di interruzione Int 0x13, ad es. i bit 0-5 contengono il numero del settore, i bit 6-7 sono i due bit più significativi del numero del cilindro a 10 bit e i bit 8-15 sono gli otto bit meno significativi del numero del cilindro. Questo è seguito dall'ID di sistema, che identifica il sistema operativo per questa partizione. L'identificatore è un byte. Dietro l'identificatore di sistema ci sono le coordinate della fine della sezione: tre byte contenenti rispettivamente i numeri della testa, del settore e del cilindro. I successivi quattro byte sono il numero di settori prima della partizione e gli ultimi quattro byte sono la dimensione della partizione in settori.

Pertanto, un elemento della tabella di sezione può essere descritto utilizzando la seguente struttura:

struttura pt_struct (

U8 avviabile; // flag di attività della sezione

U8 inizio_parte; // coordinate dell'inizio della sezione

U8 type_part; // identificatore di sistema

U8 parte_finale; // coordinate della fine della sezione

U32 sezione_prima; // numero di settori prima della sezione

U32 sez_totale; // dimensione della partizione in settori (numero di settori nella partizione)

L'elemento della partizione primaria punta direttamente al settore di avvio del disco logico (c'è sempre un solo disco logico nella partizione primaria), e l'elemento della partizione estesa punta a un elenco di dischi logici composto da strutture chiamate secondarie MBR (SMBR).

Ogni disco della partizione estesa ha il proprio blocco SMBR. SMBR ha una struttura simile a MBR, ma non ha un record di avvio (riempito con zeri) e vengono utilizzati solo due dei quattro campi del descrittore di partizione. Il primo elemento della partizione punta al disco logico, il secondo elemento punta alla struttura SMBR successiva nell'elenco. L'ultimo SMBR dell'elenco contiene il codice della sezione zero nel secondo elemento.

Torniamo al modulo per la lettura di un file da una partizione FAT32.

File di intestazione:

#includere

#includere

#includere

#includere

#includere

Firma MBR:

#define FIRMA 0xAA55

File del dispositivo da cui verranno lette le informazioni sulle partizioni:

#define DISPOSITIVO "/ dev / hda"

Dimensione dell'elemento della tabella delle partizioni (16 byte):

#define PT_SIZE 0x10

Il seguente array di strutture imposta la corrispondenza tra il codice del tipo di sezione e la sua rappresentazione simbolica:

struct systypes (

U8 tipo_parte;

U8 * nome_parte;

struct systypes i386_sys_types = (

(0x00, "Vuoto"),

(0x01, "FAT12"),

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

(0x05, "Esteso"),

(0x06, "FAT16"),

(0x0b, "Win95 FAT32"),

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

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

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

(0x82, "Linux swap"),

(0x83, "Linux"),

(0x85, "Linux esteso"),

(0x07, "HPFS/NTFS")

Determinare il numero di elementi nell'array i386_sys_types utilizzando la macro PART_NUM:

#define NUM_PART (sizeof (i386_sys_types) / sizeof (i386_sys_types))

Impostiamo un limite al numero di dischi logici:

#define MAX_PART 20

Il seguente array di strutture conterrà informazioni sui dischi logici sul dispositivo (disco rigido):

struttura pt_struct (

U8 avviabile;

U8 inizio_parte;

U8 type_part;

U8 parte_finale;

U32 sezione_prima;

U32 sez_totale;

) pt_t;

int difficile; // descrittore di file dispositivo

U8 MB; // conta MBR qui

Numero di partizione su cui viene creato il file system FAT32:

#define FAT32_PART_NUM 5

Settore di avvio, settore FSInfo e strutture di voci di catalogo (definite nel file ):

struct fat_boot_sector fbs;

struct fat_boot_fsinfo fsinfo;

struct msdos_dir_entry dentry;

U32 * fat32 = NULL; // copia qui la tabella FAT32

U16 dimensione_settore; // dimensione del settore (da FAT32)

U16 dir_entries; // 0 per FAT32

settori U16; // numero di settori per partizione

U32 fat32_size; // Dimensione FAT32

U32 data_start; // inizio dell'area dati

U16 byte_per_cluster; // quanti byte ci sono nel cluster (dimensioni del cluster in byte)

U32 next_cluster; // prossimo cluster nella catena

U32 root_cluster; // Cluster ROOT - cluster radice iniziale

U8 * voce_dir = NULL; // puntatore alle voci della directory

U64 start_seek = 0; // offset iniziale della sezione (in byte)

Funzione principale:

intero principale ()

Int numero = 0;

Int numero_cluster = 5; // quanti cluster leggere dal file

U8 * full_path = "/ Folder1 / Folder2 / readme"; // file da leggere

Apriamo il dispositivo, otteniamo informazioni sulla tabella delle partizioni sul dispositivo e visualizziamo le informazioni sulle partizioni:

Difficile = aperto (DEV_NAME, O_RDONLY);

Se (difficile< 0) {

Errore (DEV_NAME);

Esci (-1);

If (get_pt_info (difficile)< 0) {

Errore ("get_pt_info");

Esci (-1);

Mostra_pt_info ();

Calcoliamo l'offset iniziale per la sezione:

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

Leggiamo i cluster appartenenti al file:

Num = fat32_read_file (full_path, cluster_num);

Se (num< 0) perror("fat32_read_file");

Altrimenti printf ("Leggi% d cluster \ n", num);

Chiudi (difficile);

Ritorna 0;

Le informazioni sulla tabella delle partizioni vengono lette dalla funzione get_pt_info():

int get_pt_info (int hard)

Int i = 0;

U64 cerca;

Leggiamo la tabella delle partizioni dall'MBR e controlliamo la firma:

Read_main_ptable (difficile);

Se (segno_di_controllo ()< 0) {

Printf ("Firma non valida! \ N");

Ritorno -1;

Stiamo cercando l'identificatore della sezione estesa. Se ce n'è uno, calcoliamo l'offset rispetto alla partizione estesa e leggiamo le informazioni sui dischi logici:

per (; io< 4; i++) {

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

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

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

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

Read_ext_ptable (difficile, cerca);

Rottura;

Ritorna 0;

Funzione Read_main_ptable() per leggere la tabella delle partizioni:

void read_main_ptable (int hard)

If (leggi (difficile, mbr, 512)< 0) {

Errore ("leggere");

Chiudi (difficile);

Esci (-1);

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

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

Ritorno;

Funzione di controllo della firma check_sign():

int check_sign()

segno U16 = 0;

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

#ifdef DEBUG

Printf ("Firma - 0x% X \ n", segno);

#finisci se

If (segno! = FIRMA) return -1;

Ritorna 0;

Funzione di lettura della tabella delle partizioni estesa:

void read_ext_ptable (int hard, __u64 ricerca)

Int numero = 4; // partendo da questa posizione, l'array di strutture pt_t sarà riempito con informazioni sui dischi logici

U8 smbr;

Dati in ingresso:

• duro- descrittore di file del dispositivo;
• cercare- offset alla partizione estesa dall'inizio del disco (in byte).

Per ottenere informazioni sui dischi logici, organizziamo un ciclo:

Per (;; numero ++) (

Leggiamo l'SMBR situato alla ricerca dell'offset dall'inizio del disco:

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

Pread64 (hard, smbr, 512, see);

Riempiamo due elementi della tabella pt_t, partendo dalla posizione num. Il primo elemento punterà all'unità logica e il secondo alla seguente struttura SMBR:

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

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

Apportiamo una modifica al campo "Numero del settore iniziale" - il conteggio parte dall'inizio del disco:

Pt_t.sect_before + = (cerca / 512);

Se il codice del tipo di partizione è zero, non ci sono più unità logiche:

If (! (Pt_t.type_part)) break;

Calcola l'offset per il prossimo SMBR:

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

Ritorno;

La funzione show_pt_info() visualizza le informazioni sulle unità logiche trovate sul dispositivo:

void show_pt_info ()

Int i = 0, n;

#ifdef DEBUG

Printf ("Numero di partizioni sul disco -% d \ n", PART_NUM);

#finisci se

Per (; io< MAX_PART; i++) {

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

Printf ("\ nTipo di sezione% d -", i);

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

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

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

Rottura;

If (n == PART_NUM) printf ("tipo sconosciuto \ n");

Printf ("Segno di avvio - 0x% X \ n", pt_t [i] .bootable);

Printf ("Settori nella sezione% d -% d \ n", i, pt_t [i] .sect_total);

Printf ("Settori prima della sezione% d -% d \ n \ n", i, pt_t [i] .sect_before);

Ritorno;

La lettura dei cluster di file da una partizione FAT32 viene eseguita dalla funzione fat32_read_file(). Questa funzione ha molto in comune con la funzione fat16_read_file(), quindi vedere la sezione 6 per commenti dettagliati:

int fat32_read_file (__ u8 * full_path, int num)

Struttura split_name sn;

U8 tmp_name_buff;

Int i = 1, n;

U32 start_cluster, next_cluster;

U8 * tmp_buff;

Operazioni preparatorie: cancella il buffer, struttura e controlla la prima barra:

Memset (tmp_name_buff, 0, SHORT_NAME);

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

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

Leggiamo il settore di avvio:

Se (leggi_fbs ()< 0) return -1;

Memcpy ((void *) & dimensione_settore, (void *) fbs.sector_size, 2);

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

Memcpy ((void *) & settori, (void *) fbs.sectors, 2);

Leggiamo la struttura FSInfo e visualizziamo la firma in essa contenuta:

If (leggi_fs_info ()< 0) return -1;

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

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

Fat32_size = fbs.fat32_length * 512; // Dimensione FAT32 in byte

Data_start = 512 * fbs.reserved + fat32_size * 2; // inizio del campo dati

Byte_per_cluster = fbs.cluster_size * 512; // dimensione del cluster in byte

Root_cluster = fbs.root_cluster; // numero di cluster della directory radice

Leggiamo FAT32:

Se (leggi_fat32 ()< 0) return -1;

Allocare memoria per le voci della rubrica:

Dir_entry = (__u8 *) malloc (byte_per_cluster);

If (! Dir_entry) return -1;

Leggiamo la directory principale:

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

Analizziamo il percorso completo del file e dividiamo ogni elemento nei suoi componenti:

Mentre (1) (

Memset (tmp_name_buff, 0, SHORT_NAME);

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

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

Tmp_name_buff [n] = full_path [i];

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

io++;

Rottura;

Tmp_name_buff [n] = "\ 0";

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

Printf ("nome non valido \ n");

Ritorno -1;

If (get_dentry (& sn)< 0) {

Printf ("Nessun file simile! \ N");

Ritorno -1;

Per ottenere il numero iniziale di un cluster nel file system FAT32, è necessario utilizzare la parola più significativa del numero del primo cluster del file - il campo starthi della struttura dell'odontoiatria:

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

Controllo del byte dell'attributo:

If (dentry.attr & 0x10) (// questa è una directory

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

Continua;

If (dentry.attr & 0x20) (// e questo è un file

Tmp_buff = (__u8 *) malloc (byte_per_cluster);

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

Se (n< 0) {

Errore ("aperto");

Ritorno -1;

Printf ("primo cluster del file - 0x% X ..", start_cluster);

Per (i = 0; i< num; i++) {

Memset (tmp_buff, 0, byte_per_cluster);

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

If (scrivi (n, tmp_buff, byte_per_cluster)< 0) {

Errore ("scrivi");

Ritorno -1;

If (cluster_successivo == EOF_FAT32) (

Gratuito (tmp_buff);

Chiudi (n);

Ritorna ++ i;

Start_cluster = next_cluster;

Ritorno io;

Lo scopo delle prossime tre funzioni è ottenere i contenuti dell'area di sistema, ad es. settore di avvio, struttura FSInfo e tabella FAT32:

1) la funzione read_fbs() legge il settore di avvio:

int read_fbs ()

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

Ritorna 0;

2) la funzione read_fs_info() legge la struttura FSInfo:

int read_fs_info ()

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

If (pread64 (hard, (__u8 *) & fsinfo, sizeof (fsinfo), see)< 0) return -1;

Ritorna 0;

3) la funzione read_fat32() legge la tabella FAT32:

int read_fat32 ()

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

Fat32 = (void *) malloc (fat32_size);

If (! Fat32) restituisce -1;

If (pread64 (hard, (__u8 *) fat32, fat32_size, search)< 0) return -1;

Ritorna 0;

La funzione read_cluster() legge il cluster con il numero specificato:

int read_cluster (__ u32 cluster_num, __u8 * tmp_buff)

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

If (pread64 (hard, tmp_buff, byte_per_cluster, see)< 0) return -1;

Ritorna 0;

La lettura delle directory (inclusa quella radice) è gestita dalla funzione read_directory():

int read_directory (__ u32 start_cluster)

Int io = 2;

U32 next_cluster;

Parametri della funzione: avvio del cluster di directory. Leggiamo il contenuto della directory nel buffer globale dir_entry:

If (leggi_cluster (start_cluster, dir_entry)< 0) return -1;

Next_cluster = fat32;

Se la directory occupa un cluster - esci, in caso contrario - aumenta la dimensione della memoria e continua a leggere:

Per (;; io ++) (

Start_cluster = next_cluster;

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

If (! Dir_entry) return -1;

If (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)) return 0;

Ritorna 0;

L'ultima funzione che esamineremo cerca nel contenuto di una directory un elemento che corrisponda al file che stai cercando:

int get_dentry (struct split_name * sn)

Int i = 0;

Il puntatore dir_entry è impostato su un'area di memoria contenente un array di voci di directory in cui andremo a cercare un file (o una directory). Per la ricerca, organizziamo un ciclo e inseriamo il record trovato nella struttura globale dell'odontoiatria:

Per (;; io ++) (

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

Rottura;

If (! Dentry.name) return -1;

Ritorna 0;

Questo conclude la revisione del modulo per la lettura di un file da una partizione FAT32.

I codici sorgente del modulo si trovano nella directory FAT32, file fat32.c.

Differenze nell'organizzazione della memorizzazione dei record di file nelle directory per i file system FAT e EXT2

Qualche parola sulle differenze nell'organizzazione della memorizzazione dei record di file nelle directory per i file system FAT ed EXT2. La struttura del file system EXT2 è stata discussa in.

Abbiamo appena fatto conoscenza con FAT: in esso tutti gli elementi del catalogo hanno una dimensione fissa. Quando si crea un file, il driver del file system cerca la prima posizione libera e la riempie con le informazioni sul file. Se la lunghezza della directory non rientra in un cluster, viene allocato un altro cluster, ecc.

Vediamo come stanno le cose in EXT2.

Supponiamo di avere una partizione con il file system EXT2, la dimensione del blocco è 4096 byte. In questa sezione creiamo una directory. La dimensione della directory sarà uguale alla dimensione del blocco - 4096 byte. Il sistema operativo crea immediatamente due voci nella directory: la voce per la directory corrente e la voce per la directory padre. La voce della directory corrente occuperà 12 byte, mentre la voce padre sarà di 4084 byte. Creiamo un file in questa directory. Dopodiché, la directory conterrà tre voci: la voce della directory corrente è lunga 12 byte, la voce della directory padre è già lunga 12 byte e la voce del file creato è, come probabilmente intuito, lunga 4072 byte. Se eliminiamo il file creato, la lunghezza della voce della directory padre aumenterà di nuovo a 4084 byte.

Pertanto, durante la creazione di un file, il driver del file system EXT2 cerca nella directory una voce di lunghezza massima e la divide, facendo spazio a una nuova voce. Bene, se, dopo tutto, non c'è abbastanza spazio, viene allocato un altro blocco per la directory e la lunghezza della directory diventa pari a 8192 byte.

E in conclusione - una piccola correzione all'articolo "Architettura del file system EXT2".

Questa revisione riguarda la funzione get_i_num() per determinare il numero di inode in base al nome del file. La vecchia versione di questa funzione aveva questo aspetto:

int get_i_num (char * nome)

Int i = 0, rec_len = 0;

Struct ext2_dir_entry_2 dent;

Per (; io< 700; i++) {

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

Rec_len + = dent.rec_len;

Restituire dent.inode;

Versione corretta:

int get_i_num (char * nome)

* Parametro funzione - nome file. Il valore restituito è il numero di inode del file.

Int rec_len = 0;

Struct ext2_dir_entry_2 dent; // questa struttura descrive il formato della voce della directory principale:

* Il buff globale contiene un array di voci di directory. Per determinare il numero di serie dell'inode del file, è necessario trovare

* in questo array, una voce con il nome di questo file. Per fare questo, organizzeremo un ciclo:

Per (;;) (

/ * Copia le voci della directory nella struttura dent: * /

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

* La lunghezza del nome del file uguale a zero significa che abbiamo enumerato tutte le voci della directory

* e non sono stati trovati record con il nome del nostro file. Quindi è ora di tornare indietro:

If (! Dent.name_len) return -1;

/ * La ricerca viene eseguita confrontando i nomi dei file. Se i nomi corrispondono, esci dal ciclo: * /

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

/ * Se i nomi non corrispondono, passa alla voce successiva: * /

Rec_len + = dent.rec_len;

/ * In caso di successo, restituisce il numero di inode del file: * /

Restituire dent.inode;

Letteratura:

1. V. Kulakov. Programmazione hardware: un riferimento speciale. 2a ed. / - SPb.: Pietro, 2003 - 848 p.
2. A.V. Gordeev, A. Yu. Molchanov. Software di sistema / - SPb.: Peter - 2002
3. Meshkov V. Architettura del file system ext2. - Rivista "Amministratore di sistema", n. 11 (12), novembre 2003 - 26-32 p.

In contatto con

FAT - File Allocation Table - Questo termine si riferisce a uno dei modi per organizzare il file system su un disco. Questa tabella memorizza le informazioni sui file sul disco rigido come una sequenza di numeri che determinano la posizione di ciascuna parte di ciascun file. Con il suo aiuto, il sistema operativo scopre quali cluster occupa il file richiesto. FAT è il file system più comune ed è supportato dalla stragrande maggioranza dei sistemi operativi. FAT era originariamente a 12 bit e consentiva dischi floppy e unità logiche fino a 16 MB di dimensione. In MS-DOS 3.0, il FAT è a 16 bit per supportare unità più grandi e il FAT a 32 bit viene utilizzato per unità fino a 2.047 GB.

FAT32 è un file system più recente basato sul formato FAT ed è supportato da Windows 95 OSR2, Windows 98 e Windows Millennium Edition. FAT32 utilizza identificatori di cluster a 32 bit, ma riserva i 4 bit superiori, quindi la dimensione effettiva dell'identificatore di cluster è di 28 bit. Poiché la dimensione massima dei cluster FAT32 è 32 KB, in teoria FAT32 può gestire volumi da 8 TB. Windows 2000 limita la dimensione dei nuovi volumi FAT32 a 32 GB, sebbene supporti volumi EAT32 esistenti più grandi (creati con altri sistemi operativi). Il maggior numero di cluster supportati da FAT32 consente di gestire i dischi in modo più efficiente rispetto a FAT 16. FAT32 può utilizzare cluster da 512 byte per volumi fino a 128 MB.

Il file system FAT 32 in Windows 98 viene utilizzato come file system principale. Questo sistema operativo è dotato di un programma speciale per convertire un disco da FAT 16 a FAT 32. Windows NT e Windows 2000 possono anche utilizzare il file system FAT, quindi è possibile avviare il computer da un disco DOS e avere pieno accesso a tutti i file . Tuttavia, alcune delle funzionalità più avanzate di Windows NT e Windows 2000 sono fornite dal proprio file system NT, ntfs. ntfs consente partizioni del disco fino a 2 TB (come FAT 32), ma dispone anche di compressione dei file, sicurezza e auditing integrati per la rete. E in Windows 2000, è implementato il supporto per il file system FAT 32. L'installazione del sistema operativo Windows NT inizia su un disco FAT, ma alla fine dell'installazione, i dati sul disco possono essere convertiti in formato ntfs.

È possibile farlo in un secondo momento utilizzando l'utilità Convert.exe fornita con il sistema operativo. La partizione del disco convertita in ntfs diventa inaccessibile ad altri sistemi operativi. Per tornare a DOS, Windows 3.1 o Windows 9x, devi eliminare la partizione ntfs e creare invece una partizione FAT. Windows 2000 può essere installato su un disco con file system FAT 32 e ntfs.

Le capacità dei file system EAT32 sono molto più ampie di quelle di FAT16. La caratteristica più importante è che supporta unità fino a 2.047 GB e funziona con cluster più piccoli, riducendo così significativamente la quantità di spazio su disco sprecato. Ad esempio, un disco rigido da 2 GB in FAT16 utilizza cluster da 32 KB, mentre FAT32 utilizza cluster da 4 KB. Per mantenere il più possibile la compatibilità con i programmi, le reti e i driver di dispositivo esistenti, FAT32 è stato implementato con modifiche minime nell'architettura, nelle API, nelle strutture dati interne e nel formato del disco. Tuttavia, poiché la dimensione degli elementi della tabella FAT32 è ora di quattro byte, molte strutture di dati interne e su disco, nonché le API, hanno dovuto essere riviste o ampliate. Alcune API sui dischi EAT32 sono bloccate per evitare che le utility del disco legacy danneggino il contenuto dei dischi FAT32. La maggior parte dei programmi non sarà interessata da queste modifiche. Gli strumenti e i driver esistenti funzioneranno anche su unità FAT32. Tuttavia, i driver di dispositivo a blocchi MS-DOS (come Aspidisk.sys) e le utilità del disco devono essere modificati per supportare FAT32. Tutte le utilità del disco fornite da Microsoft (Format, Fdisk, Defrag e ScanDisk per le modalità reale e protetta) sono state riprogettate per supportare completamente FAT32. Inoltre, Microsoft sta aiutando i principali fornitori di utility disco e driver di dispositivo a modificare i propri prodotti per supportare FAT32. FAT32 è più efficiente di FAT16 quando si lavora con dischi più grandi e non richiede il partizionamento in partizioni da 2 GB. Windows 98 supporta necessariamente FAT16, poiché questo particolare file system è compatibile con altri sistemi operativi, incluse società di terze parti. Nella modalità reale di MS-DOS e nella modalità provvisoria di Windows 98, FAT32 è significativamente più lento di FAT16. Pertanto, quando si avviano programmi in modalità MS DOS, è consigliabile includere un comando per caricare Smartdrv.exe nel file Autoexec.bat o PIF, che velocizzerà le operazioni del disco. Alcuni programmi legacy progettati per la specifica FAT16 potrebbero riportare informazioni errate sulla quantità di spazio libero o totale su disco se è superiore a 2 GB. Windows 98 fornisce nuove API per MS-DOS e Win32 che consentono di definire correttamente queste metriche. Tavolo 1 mostra le caratteristiche comparative di FAT16 e FAT32.

Tabella 1. Confronto tra file system FAT16 e FAT32

La lunghezza massima possibile del file in FAT32 è 4 GB meno 2 byte. Le applicazioni Win32 possono aprire file di questa lunghezza senza alcuna elaborazione speciale. Altre applicazioni dovrebbero utilizzare l'interrupt Int 21h, funzione 716C (FAT32) con il flag aperto EXTEND-SIZE (1000h).

Nel file system FAT32, sono allocati 4 byte per ogni cluster nella tabella di allocazione dei file, mentre in FAT16 - 2 e in FAT12 - 1.5.

I 4 bit più significativi dell'elemento a 32 bit della tabella FAT32 sono riservati e non partecipano alla formazione del numero di cluster. I programmi che leggono direttamente la tabella PAT32 devono mascherare questi bit e proteggerli dalla modifica quando vengono scritti nuovi valori.

Quindi, FAT32 presenta i seguenti vantaggi rispetto alle precedenti implementazioni del file system FAT:

Supporta dischi fino a 2 TB;

organizza lo spazio su disco in modo più efficiente. FAT32 utilizza cluster più piccoli (4 KB per unità fino a 8 GB), che possono risparmiare fino al 10-15% di spazio su unità di grandi dimensioni rispetto a FAT;

la directory principale di FAT 32, come tutte le altre directory, ora è illimitata, è costituita da una catena di cluster e può essere posizionata ovunque sul disco;

ha una maggiore affidabilità: FAT32 è in grado di spostare la directory principale e lavorare con un backup FAT, inoltre, il record di avvio sui dischi FAT32 è stato ampliato per includere un backup di strutture dati critiche, il che significa che i dischi FAT32 sono meno sensibili a il verificarsi di sezioni danneggiate separate rispetto ai volumi FAT esistenti;

i programmi si caricano il 50% più velocemente.

Tabella 2. Confronto delle dimensioni dei cluster

Un'utilità di deframmentazione del disco migliorata ottimizza il posizionamento dei file dell'applicazione caricati al momento dell'avvio dell'applicazione. È possibile convertire il disco in EAT32 utilizzando l'utility Drive Converter (FAT32), ma successivamente si consiglia di eseguire l'utility Disk Defragmenter, altrimenti il ​​computer funzionerà con il disco più lentamente di prima. L'utilizzo di FAT32 rende impossibile configurare Windows 98 e Windows NT 4.0 Alternate Boot perché quest'ultimo non supporta FAT32. FAT32 alloca lo spazio su disco in modo molto più economico rispetto alle versioni precedenti del file system FAT. Questo può liberare decine o addirittura centinaia di megabyte su dischi di grandi dimensioni e, se combinato con l'utility avanzata di deframmentazione del disco FAT32, riduce significativamente i tempi di caricamento delle applicazioni. La conversione del file system del disco rigido in FAT32 utilizzando Drive Converter (FAT32) è semplice. Per fare ciò, aprire il menu Start, il sottomenu Programmi, Accessori, Strumenti di sistema e selezionare il comando Convertitore di unità (FAT32). La conversione può influire sulle funzionalità di ibernazione (salvataggio dello stato del computer su disco) fornite in molti computer. I sistemi in cui la modalità di sospensione è implementata tramite il BIOS ARM o ACPI (Advanced Configuration and Power Interface) S4 / BIOS devono supportare FAT32 - solo allora funzioneranno correttamente in Windows 98.

La maggior parte dei produttori di BIOS include una protezione antivirus che monitora le modifiche al Master Boot Record (MBR). Inoltre, le utilità antivirus legacy installate come TSR o driver in modalità reale possono rilevare le modifiche MBR all'avvio di MS-DOS. Poiché la conversione in FAT32 modificherà inevitabilmente l'MBR, alcuni antivirus potrebbero erroneamente considerarlo un segno di infezione del sistema. Pertanto, se l'utilità antivirus rileva una modifica nell'MBR, si offre di "curarla". È meglio disinstallare il software antivirus e disabilitare la protezione antivirus integrata del BIOS prima di convertire l'unità in FAT32. È quindi possibile reinstallare l'utilità antivirus e attivare la protezione antivirus integrata nel BIOS.