Tipi di file system: qual è la differenza tra FAT32, NTFS ed exFAT. Cosa fare se mancano i dati

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

Leggi i file system in questo articolo.

Il sistema di gestione dei file è il principale nella stragrande maggioranza dei moderni sistemi operativi. Tutti i moderni sistemi operativi utilizzano file e software associato per lavorare con essi. Il fatto è che, in primo luogo, molti programmi di elaborazione del sistema comunicano attraverso il file system in base ai dati. In secondo luogo, con l'aiuto di questo sistema, vengono risolti i problemi di allocazione centralizzata dello spazio su disco e di gestione dei dati. Infine, gli utenti ottengono modi più semplici per accedere ai propri dati, che ospitano su dispositivi di archiviazione esterni.

Esiste un gran numero di file system creati per diversi dispositivi di memoria esterni e diversi sistemi operativi. Utilizzano, rispettivamente, diversi principi di posizionamento dei dati sul supporto. Questi sono i sistemi FAT, FAT32 e NTFS.

Possiamo dire che lo scopo principale del file system e del corrispondente file management system è quello di fornire un comodo accesso ai dati organizzati sotto forma di file, cioè invece di un accesso di basso livello ai dati che indicano indirizzi fisici specifici del record che noi bisogno, usiamo l'accesso logico indicando il nome del file e registrare in lui.

Il file system FAT (File Allocation Table) prende il nome da una semplice tabella che specifica:

• sezioni di un disco logico direttamente indirizzabili, destinate a collocarvi file o loro frammenti; Aree libere di spazio su disco;
• aree difettose del disco (queste aree contengono aree difettose e non garantiscono la lettura e la scrittura di dati senza errori).

Nel file system FAT, lo spazio su disco di qualsiasi disco logico è diviso in due aree (Fig.) area di sistema e area dati.

L'area di sistema del disco logico viene creata e inizializzata durante la formattazione e successivamente aggiornata quando si lavora con la struttura del file. L'area dati di un disco logico contiene file regolari e file di directory; questi oggetti formano una gerarchia subordinata alla directory principale. Una voce di directory descrive un oggetto file, che può essere un file normale o un file di directory. L'area dati, a differenza dell'area di sistema, è accessibile tramite l'interfaccia utente del sistema operativo. L'area di sistema è costituita dai seguenti componenti (posizionati uno dietro l'altro in uno spazio di indirizzi logico):

• Registro di avvio (BR)
• settori riservati (Settori Riservati, ResSec);
• Tabella di allocazione dei file (FAT)
• Directory principale (RDir).

La tabella di allocazione dei file è una struttura di informazioni molto importante. Possiamo dire che è una mappa di indirizzi dell'area dati, che descrive lo stato di ciascuna sezione dell'area dati e la sua appartenenza a uno o un altro oggetto file,

L'intera area dati è suddivisa in cosiddetti cluster. Un cluster è uno o più settori contigui in uno spazio di indirizzi del disco logico (più precisamente, solo nell'area dati). Un cluster è la più piccola unità indirizzabile di spazio su disco allocata a un file (o directory non root). I cluster sono stati introdotti per ridurre il numero di unità indirizzabili nell'area dati di un disco logico.

Ogni file occupa un numero intero di cluster. In questo caso, l'ultimo cluster potrebbe non essere completamente coinvolto, il che, con un cluster di grandi dimensioni, può portare a una notevole perdita di spazio su disco. Sui dischi floppy, un cluster occupa uno o due settori e sui dischi rigidi la sua dimensione dipende dal volume della partizione. Nella tabella FAT, i cluster appartenenti allo stesso file (o directory di file) sono collegati in catene. Una parola a 16 bit viene utilizzata per indicare il numero di cluster nel file system FAT16, quindi è possibile avere fino a 2 16 = 65 536 cluster (con numeri da 0 a 65 535).

Poiché i file sul disco cambiano (elimina, sposta, aumenta o diminuisce), la regola menzionata per l'allocazione del primo cluster libero per un nuovo pezzo di dati porta a frammentazione file, ovvero i dati di un file possono trovarsi non in cluster contigui, ma a volte molto distanti tra loro, formando catene complesse. Naturalmente, questo porta a un significativo rallentamento nel lavoro con i file.

A causa del fatto che la tabella FAT viene utilizzata molto intensamente quando si accede al disco, di solito viene caricata nella RAM (nei buffer di I/O o nella cache) e vi rimane il più a lungo possibile. Se la tabella è grande, ma la cache dei file, d'altra parte, è relativamente piccola, vengono archiviati in memoria solo i frammenti di questa tabella a cui è stato effettuato l'accesso di recente.

Chiunque abbia mai installato un sistema operativo si è imbattuto nel fatto che nella fase di formattazione della partizione di installazione di un disco rigido, il programma offre di scegliere il tipo di file system FAT o NTFS.

E chi è capitato di formattare un'unità flash o un altro dispositivo di archiviazione esterno ha dovuto decidere tra i tre file system FAT32, NTFS ed exFAT. Molto spesso, gli utenti scelgono la formattazione predefinita perché non sanno quale sia la differenza.

Questo articolo è rivolto a coloro che desiderano colmare questa lacuna nelle loro conoscenze.

Struttura del file FAT: principi e scopo

Struttura del file o File systemè stato sviluppato negli anni '70 del secolo scorso da Microsoft e ha rappresentato un certo ordine di organizzazione dello spazio per l'archiviazione e l'accesso ai dati su computer e altri dispositivi digitali.

Lo scopo della funzionalità è fornire all'utente una comoda gestione delle informazioni memorizzate su un disco o un gadget esterno. Il file system include file, cartelle e directory, nonché un insieme di strumenti di sistema che interagiscono con essi per eseguire le funzioni di lettura-scrittura, creazione-eliminazione, copia, denominazione, ecc. Inoltre, questa struttura organizza l'accesso congiunto alle informazioni tra gli utenti e fornisce protezione contro azioni non autorizzate mediante crittografia, lavoro in modalità "sola lettura" e così via.

Strutturalmente, l'intera area dello spazio su disco è divisa in gruppi, come un foglio di carta in una gabbia. Ogni cella è un blocco, la cui dimensione viene specificata durante la formattazione e deve essere un multiplo di 2. La dimensione minima può essere 512 byte (per un'unità flash), per un disco rigido è 32 KB. Un file può occupare diversi cluster di questo tipo. In senso figurato, puoi immaginare lo spazio su disco sotto forma di un taccuino, dove un cluster è una lettera, un file è una parola e la struttura del file è un sommario di un taccuino.

Quando si accede a un file, il sistema operativo deve trovarlo in più cluster situati in punti diversi del disco, formando così una catena di cluster. Ogni cluster ha la sua etichetta, che lo definisce come uno dei tre tipi:

1. Gratuito, pronto per scrivere dati.
2. Occupato, che memorizza alcune informazioni e contiene nell'etichetta i dati relativi al cluster successivo della catena, mentre quest'ultimo è contrassegnato da un'etichetta speciale.
3. BAD-block - un cluster con errori, che diventa non disponibile dopo la formattazione.

La dimensione dell'etichetta è determinata dal tipo di struttura del file: per FAT32 è 32 byte.

L'intero file system è costituito dalle seguenti parti:

• il settore di avvio, che si trova all'inizio del disco, viene attivato dopo l'avvio del sistema operativo e memorizza i parametri della partizione;
• una tabella di allocazione dei file ("tabella dei contenuti") che memorizza le etichette dei cluster;
• copie della tabella di allocazione dei file per recuperare i dati in caso di danneggiamento della struttura dei file;
• root directory;
• aree dati;
• cilindro per eseguire operazioni di lettura/scrittura.

Esistono tre tipi di file system FAT in totale: FAT12, FAT16 e FAT32. FAT è stato sostituito da NTFS ed exFAT è una versione estesa di FAT32 ed è utilizzato principalmente per le unità flash.

Vantaggi e svantaggi delle strutture di file FAT32, NTFS ed exFAT

Per determinare la scelta del file system più ottimale per la formattazione, considerare le descrizioni di tutte e tre le opzioni, concentrandosi sui vantaggi e gli svantaggi di ciascuna.

FAT32

Delle tre strutture di file in esame, FAT32 è la più vecchia. Ha sostituito FAT16 e fino a poco tempo fa era il più progressista. Il rilascio di FAT32 è stato programmato in concomitanza con il rilascio del sistema operativo Windows 95 OSR2 nel 1996. Le principali caratteristiche distintive sono: indirizzamento del cluster a 32 bit e limiti di dimensione: un file non più di 4 GB e un volume di 128 GB.

Dignità

Nonostante una certa arretratezza morale, FAT32 presenta numerosi vantaggi rispetto ad altri file system. La sua principale attrazione è la compatibilità e la versatilità. FAT32 funziona con tutte le versioni dei sistemi operativi, incluso Windows (confronto di tutte le versioni), Linux e MacOS, adatto a qualsiasi console di gioco e altri gadget con una porta USB. Oggi è utilizzato in tutte le unità esterne (unità flash, schede CD) per impostazione predefinita, poiché molti vecchi dispositivi: PC, laptop, set-top box con ingresso USB possono funzionare solo con FAT32.

Altri importanti vantaggi del file system sono: prestazioni ad alta velocità, basse richieste di quantità di RAM, lavoro produttivo con file di medie e piccole dimensioni, nonché bassa usura del disco dovuta a meno movimenti della testa. Tuttavia, è anche soggetto a frammentazione e la deframmentazione periodica sicuramente non farà male.

Screpolatura

Il principale svantaggio di questo file system sono i suoi limiti di dimensione. Per i cluster, non può essere superiore a 64 KB, altrimenti alcune applicazioni potrebbero calcolare in modo errato lo spazio su disco.

La dimensione del file non deve superare i 4 GB, quindi la dimensione massima del disco per un cluster di tabelle di allocazione file da 32 KB sarebbe di circa 8 TB.

Quando si formatta il disco con ScanDisk, che è un programma a 16 bit, tenendo conto delle tabelle FAT stesse e con una dimensione massima del cluster di 32 KB, il volume è limitato a 128 GB.

Dato che non molti dispositivi informatici sono dotati di un disco rigido con una capacità superiore a 8 TB, questo svantaggio non sarà percepibile per la maggior parte degli utenti. Tuttavia, il fatto che FAT32 funzioni con file di dimensioni fino a 4 GB è uno svantaggio significativo, poiché la maggior parte dei file video di alta qualità del moderno formato 4K oggi sono più grandi di questi 4 GB, il che significa che non sono compatibili con questo file system.

Oltre ai limiti di dimensione, FAT32 presenta altri svantaggi. Non supporta nomi di file lunghi, il che è scomodo per gli utenti che desiderano identificare logicamente i file in base al loro contenuto. Ci sono lamentele sul sistema di sicurezza (uno scanner antivirus aggiuntivo non interferirà) e sulla sicurezza dei file in caso di guasti (in particolare i dischi rigidi), nonché sulla bassa velocità quando si lavora con directory contenenti molti file.

Pertanto, FAT32 è più adatto per dispositivi portatili non molto capienti e vecchi computer. Le ultime versioni di Windows non possono più essere installate su un'unità formattata FAT32, è necessario riformattare in NTFS.

L'applicazione principale del file system FAT32 oggi sono unità flash portatili e schede SD (caratteristiche), che contengono pochi file e sono compatibili con una varietà di dispositivi digitali.

NTFS

Questo file system è stato sviluppato da Microsoft nel 1993 e introdotto insieme a Windows NT 3.1. Nel nome stesso nuovo file system tecnologico che significa nuovo file system tecnologico, la sua essenza progressiva è posta.

Dopo aver formattato il disco in NTFS, è diviso in tre zone:

• MFT - tabella di file di zona o generale (Master File Table), in cui sono archiviate le informazioni su file e directory;
• dati utente;
• metafile contenenti informazioni sul servizio.

Ciascuno dei metafile è responsabile di un'area specifica. Ad esempio, LogFile è un file di registro in cui tutte le operazioni vengono scritte nel registro, Boot è il settore di avvio, Bitmap monitora lo spazio libero nella partizione, ecc. Una tale struttura protegge in modo affidabile i file da eventuali guasti, che si tratti di un blocco del sistema operativo o di un'interruzione di corrente.

Dignità

A differenza di FAT32, questa struttura di file non ha praticamente restrizioni sulla dimensione di file e directory. La dimensione del cluster può variare da 512 byte a 64 KB, la dimensione ottimale è considerata di 4 KB.

Grazie a molti miglioramenti significativi per migliorare la sicurezza, come il supporto per autorizzazioni file, quote HPFS, crittografia, journaling, controllo e audit degli accessi, collegamenti fisici e altro, NTFS è ideale per formattare un disco per l'area di sistema. In questo sistema possono essere formattate anche altre partizioni del disco rigido, poiché NTFS consente un utilizzo ottimale dello spazio su disco in presenza di molti file di piccole dimensioni.

Il vantaggio di questa organizzazione dei file è l'accesso rapido a file di piccole dimensioni, prestazioni elevate quando si lavora con file di grandi dimensioni e la possibilità di utilizzare nomi di file lunghi.

Screpolatura

Il principale svantaggio di NTFS è l'incompatibilità con tutti i sistemi operativi inferiori a Windows NT, nonché le limitazioni nella compatibilità con altri sistemi operativi. Quindi, Mac OS legge i file dai dischi NTFS, ma non può scriverli, la stessa situazione con la compatibilità dei file Linux. Le console di gioco più popolari Playstation e Xbox 360 non funzionano con NTFS, solo Xbox One può comunicare con esso.

Tra gli svantaggi di NTFS ci sono elevati requisiti di RAM, velocità più lenta rispetto a FAT32 e difficoltà nella gestione di directory di medie dimensioni.

Pertanto, è più opportuno utilizzare la struttura dei file NTFS sui dischi rigidi, inclusi gli SSD che eseguono le ultime versioni di Windows, a partire da NT.

exFAT

Questo file system è l'ultimo da considerare per il rilascio. È apparso nel 2008 con i successivi aggiornamenti di Windows XP ed è, di fatto, una versione estesa di FAT32.

L'obiettivo principale degli sviluppatori è creare una struttura di file produttiva, comoda e versatile per dispositivi di archiviazione portatili: unità flash, schede SD e dischi rigidi rimovibili.

vantaggi:

• Organizzazione semplice senza funzionalità specializzate e restrizioni sulle dimensioni di file e partizioni.
• Eccellente compatibilità con tutti i sistemi operativi Windows, Mac OS e Linux. Quest'ultima opzione richiede l'installazione di software aggiuntivo.
• Supporto da tutti i moderni dispositivi Apple, nonché dalle console di gioco Xbox One e Playstation 4.

Il principale svantaggio dell'organizzazione dei file exFAT è la politica di licenza di Microsoft, che ne vieta l'uso gratuito nel pubblico dominio.

La struttura di file più ottimale

Dopo aver esaminato le descrizioni di tre file system popolari, è possibile trarre le seguenti conclusioni:

• per i dispositivi informatici con un sistema operativo superiore a Windows NT, sarà più opportuno formattare l'hard disk nel sistema NTFS;
• per i vecchi dispositivi, nonché per la compatibilità con vari gadget digitali moderni, l'opzione migliore sarebbe quella di scegliere FAT32;
• per qualsiasi supporto rimovibile, il sistema sarà l'ideale

E l'ultima cosa: le informazioni su quale struttura di file è implementata sui tuoi dischi possono essere trovate nella scheda "Generale" (tasto destro del mouse "Proprietà").

Saluti!

Qualunque sia il supporto di memorizzazione, sia esso un disco rigido, un'unità SSD o un'unità flash (MicroSD, microSDXC, unità flash USB, ecc.), tutti hanno bisogno di un file system in modo che possano scrivere e leggere i dati da essi.

Esistono numerosi file system, ma in questo articolo esamineremo i più popolari e, di conseguenza, utilizzati.

Le informazioni fornite saranno molto utili in situazioni in cui è necessario formattare un disco rigido (unità SSD) o una delle sue partizioni, un'unità flash USB, ecc.

File system FAT16, FAT32 - cronologia e caratteristiche

Iniziamo con il filesystem FAT16(è anche chiamato semplicemente GRASSO) - è stato creato principalmente per il sistema operativo MS DOS e il suo supporto era disponibile in Windows 95 e Windows 98. La dimensione massima di un file era limitata a 2 Gigabyte. La dimensione massima della partizione potrebbe essere esattamente la stessa.

Il dominio di FAT16 non durò a lungo; presto fu sostituito dal file system FAT32: era standard per Windows 95 e Windows 98, sebbene per motivi di compatibilità, come accennato in precedenza, questi sistemi operativi supportassero anche FAT16.

In FAT32, la dimensione massima del file era già di 4 Gigabyte. Quelli. il numero di file può essere qualsiasi, ma la dimensione di ciascuno di essi non può superare i 4 Gigabyte. E la dimensione massima della partizione poteva essere teorica di 8 Terabyte, ma in Windows era limitata artificialmente. Ad esempio, in Windows 98, la dimensione della partizione non può essere maggiore di 137 Gigabyte.

Potresti chiederti perché, dopo così tanti anni, puoi formattare unità flash e piccoli dischi rigidi in questo file system. La risposta a questa domanda è di seguito.

• Compatibilità: FAT32 è ancora ampiamente supportato dai principali sistemi operativi: Windows, MacOS, Linux, vari dispositivi stand-alone (set-top box, lettori MP3, telefoni, smartphone, ecc.) e sistemi embedded.
• Restrizioni: Se provi a scrivere un file più grande di 4 Gigabyte, non puoi farlo e verrà visualizzato un errore. Ci sono soluzioni a questo problema.

  Ci sono anche limitazioni sulla dimensione della partizione - sebbene FAT32 supporti teoricamente supporti di archiviazione fino a 8 Terabyte, in Windows XP (e successivi) non sarai in grado di formattare un disco o una partizione più grande di 32 GB in FAT32. Questa limitazione è stata introdotta da Microsoft per mantenere prestazioni ottimali quando si lavora con questo file system.

• oggi questo file system viene utilizzato con successo su unità flash e dispositivi di archiviazione al fine di garantire la massima compatibilità con la più ampia classe di dispositivi.

  Un altro vantaggio è l'assenza di scrittura/lettura ridondante di "dati tecnici" nel processo di interazione con questo file system. Questa è senza dubbio una benedizione per i dischi Flash, per i quali la risorsa di lettura/scrittura delle celle di memoria è limitata.

File system NTFS - descrizione, applicazione e proprietà chiave

File system NTFS oggi è rilevante e onnipresente. Debuttando per la prima volta in Windows XP, continua ad essere utilizzato in tutte le versioni moderne del sistema operativo di Microsoft, incluso il più recente Windows 10.

I suoi sviluppatori hanno fatto del loro meglio, dotando questo file system di molte funzionalità dettate dalle realtà moderne. Ad esempio, grazie alla registrazione delle informazioni tecniche di tutte le operazioni sui file eseguite, è stato possibile aumentare significativamente l'affidabilità della sicurezza dei dati in caso di interruzione improvvisa dell'alimentazione del supporto.

Anche in NTFS è stata aggiunta la possibilità di impostare i diritti su file e cartelle, il che aumenta notevolmente la sicurezza generale quando si lavora in Windows. Non dimenticare la possibilità di creare copie shadow di file e dati durante il funzionamento del sistema, che viene utilizzato attivamente dal sistema operativo Windows, al fine di garantire prestazioni elevate durante il backup dei dati, la crittografia e il normale funzionamento del sistema operativo .

Naturalmente, questo non è un elenco completo di ciò che offre il moderno file system NTFS.

Come accennato in precedenza, questo file system è standard per Windows XP e successivi sistemi operativi di Microsoft. Durante l'installazione del sistema operativo, non sarai nemmeno in grado di scegliere il file system: l'hard disk o l'SSD saranno formattati rigorosamente in NTFS.

A causa della notevole complicazione dei principi del file system NTFS e di alcuni problemi di licenza, ha un supporto molto limitato da altri sistemi operativi e dispositivi.

Ad esempio, il sistema operativo MacOS può solo leggere dati da supporti su cui viene utilizzato NTFS, ma non può più scrivere dati su supporti con questo file system.

La situazione è migliore su Linux. Sebbene in modo nativo Linux possa leggere solo dati da supporti NTFS, alcune distribuzioni Linux finali aggiungono anche il supporto per la scrittura su dischi NTFS.

Per quanto riguarda i dispositivi autonomi, le console di gioco (Sony PlayStation, Xbox 360), ecc., nella maggior parte dei casi NTFS non è supportato da questi.

• Compatibilità: Pienamente supportato in tutte le versioni del sistema operativo moderno di Microsoft. Su Mac (MacOS) è supportata la sola lettura e su Linux sono supportate anche la lettura e la scrittura su alcune distribuzioni finali. Come per altri dispositivi, nella maggior parte dei casi non è affatto supportato.
• Restrizioni: Non ci sono restrizioni sul numero e sulla dimensione di file e cartelle.
• Campo di applicazione ottimale: Il file system è stato creato con un occhio all'utilizzo per i dischi rigidi (e successivamente gli SSD), principalmente in ambiente Windows.

Il file system ExFat: cos'è, per cosa è stato creato

ExFat(chiamato anche FAT64) È un file system che ha debuttato nel 2006, creato per le unità flash. Durante il suo sviluppo, è stato preso tutto il meglio da FAT32 e le sue limitazioni intrinseche sono state rimosse. ExFat non ha limiti sulla dimensione massima del file che può essere scritta su un supporto con un determinato file system.

Migliorata anche la situazione con l'eliminazione del numero eccessivo di operazioni tecniche di lettura/scrittura al fine di garantire la massima velocità delle operazioni di base sui file con il minimo impatto sulle celle di memoria, al fine di prevenirne e ritardarne il più possibile l'usura .

Se parliamo di compatibilità, la situazione è molto migliore rispetto allo stesso NTFS. MacOS ha il supporto completo per le operazioni di lettura/scrittura ed è disponibile il supporto per Linux, a condizione che si installino diversi pacchetti dal repository.

Per quanto riguarda i dispositivi esterni, la situazione con il supporto ExFat sta migliorando, ma è decisamente impossibile garantire il supporto su tutti i dispositivi.

• Compatibilità: Ha pieno supporto su Windows a partire da Windows XP, MacOS e Linux OS (potrebbe essere necessario installare un pacchetto di supporto dal repository).

  Sui vecchi dispositivi standalone (lettori MP3, fotocamere, ecc.) potrebbero non essere supportati.

• Restrizioni: Questo file system non ha restrizioni né sulla dimensione massima dei file né sul loro numero.
• Campo di applicazione ottimale: Qualsiasi unità flash e dispositivo di archiviazione (MicroSD, microSDXC, unità flash USB, ecc.), La cui dimensione è superiore a 4 Gigabyte. Un'unità flash con questo file system dimostrerà prestazioni ad alta velocità e funzionerà più a lungo rispetto a se utilizza NTFS.

Breve riassunto

Per riassumere quanto sopra, risulta che il file system NTFS dovrebbe essere utilizzato per le unità disco rigido (HDD) e SSD installate all'interno del computer e ExFat per le unità flash esterne.
E FAT32 è ottimale per le unità flash di piccole dimensioni (fino a 4 Gigabyte), nonché per le unità flash utilizzate nei vecchi dispositivi e non comprendono ExFat.

È tutto! Ci vediamo con nuovi contenuti! Per non perderli, vale la pena iscriversi!

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.