Esistono molti modi per memorizzare informazioni e programmi sul disco rigido. Un sistema molto conosciuto che salva varie informazioni sotto forma di file, raggruppandole in cartelle con un compito univoco. Tuttavia, poche persone hanno pensato a come avviene effettivamente l'archiviazione fisica delle informazioni su un supporto.
Per salvare le informazioni su un supporto fisico, è necessario prepararle per l'uso in un sistema operativo per computer. Il sistema operativo alloca uno spazio libero su disco per salvare le informazioni. Per fare ciò, è necessario dividere il disco in piccoli contenitori - settori. La formattazione del disco di basso livello assegna una dimensione specifica per ogni settore. Il sistema operativo raggruppa questi settori in cluster. La formattazione di primo livello imposta tutti i cluster della stessa dimensione, solitamente nell'intervallo da 2 a 16 settori. In futuro, per ogni file verranno allocati uno o più cluster. La dimensione del cluster dipende dal sistema operativo, dalla capacità del disco e dalla velocità operativa richiesta.
Oltre all'area per l'archiviazione dei file sul disco, sono presenti aree necessarie per il funzionamento del sistema operativo. Queste aree servono per memorizzare le informazioni di avvio e le informazioni per mappare gli indirizzi dei file nelle posizioni fisiche sul disco. L'area di avvio viene utilizzata per avviare il sistema operativo. Dopo l'avvio del BIOS, legge ed esegue l'area di avvio del disco per avviare il sistema operativo.
File system FAT
Il file system FAT è apparso insieme al sistema operativo Microsoft DOS, dopo di che è stato migliorato più volte. Ha le versioni FAT12, FAT16 e FAT32. Il nome stesso FAT deriva dall'uso di una sorta di database da parte del file system sotto forma di "Tabella di allocazione file", che contiene una voce per ogni cluster su disco. I numeri di versione si riferiscono al numero di bit utilizzati nei numeri di articolo in una tabella. Pertanto, il file system ha un limite alla dimensione del disco supportata. Nel 1987, non supportava un disco più grande di 32 MB. Con l'avvento di Windows 95, è uscita una nuova versione del file system FAT32 con supporto teorico per unità fino a 2 TB. Compaiono problemi costanti con il supporto di dischi di grandi dimensioni a causa della cardinalità fissa, limitata dal numero di bit utilizzati per determinare la posizione del cluster. Ad esempio, la versione FAT16 non supporta più di 2 16 o 65536 cluster. Anche il numero di settori in un cluster è limitato.
Un altro problema con le unità di grandi dimensioni era l'impossibilità di utilizzare l'enorme spazio riservato ai file di piccole dimensioni. A causa del numero limitato di cluster, la loro dimensione è aumentata per coprire l'intera capacità del disco. Ciò si traduce in un uso inefficiente dello spazio di archiviazione per la maggior parte dei file che non sono un multiplo della dimensione del cluster. Ad esempio, FAT32 alloca cluster da 16 KB per partizioni del disco che vanno da 16 GB a 32 GB. Per archiviare un file da 20 KB, avrai bisogno di due cluster da 16 KB, che occuperanno 32 KB su disco. I file di 1 KB occupano 16 KB di spazio su disco. Pertanto, in media, il 30-40% della dimensione della capacità del disco viene sprecato per l'archiviazione di file di piccole dimensioni. Il partizionamento di un disco in piccole partizioni può ridurre le dimensioni del cluster, ma in pratica non viene utilizzato per dischi con una capacità superiore a 200 GB.
Anche la frammentazione dei file non è un problema minore nel file system. Poiché potrebbero essere necessari più cluster per ospitare un file e potrebbero non essere fisicamente sequenziali, il tempo necessario per la lettura rallenta i programmi. Pertanto, c'è un bisogno costante di.
File system NTFS
All'inizio degli anni '90, Microsoft ha iniziato a sviluppare software completamente nuovo progettato per ambienti che consumano più risorse rispetto ai normali utenti domestici. Per esigenze aziendali e industriali, le risorse fornite dai sistemi operativi Windows basati su DOS non sono più sufficienti. Microsoft ha stretto una partnership con IBM per sviluppare OS/2 con il file system High Performance File System (HPFS). Lo sviluppo aziendale non ha avuto successo e presto ogni azienda ha ripreso la propria strada. Microsoft ha sviluppato varie versioni del sistema operativo Windows NT basate su Windows 2000 e Windows XP. Ognuno di loro utilizza la propria versione del file system NTFS, che continua ad evolversi.
NTFS (New Technology File System) è il file system standard per i sistemi operativi basati su Windows NT. È stato progettato per sostituire FAT. NTFS è più flessibile di FAT. Le sue aree di sistema memorizzano principalmente file, piuttosto che strutture fisse come in FAT, che consente loro di essere modificati, espansi o riposizionati durante l'uso. Un semplice esempio è la Master File Table (MFT). MFT è una sorta di database con varie informazioni sui file su disco. File di piccole dimensioni (1 KB o meno) possono essere archiviati direttamente nell'MFT. Per file di grandi dimensioni, NTFS alloca i cluster, ma a differenza di FAT, la dimensione del cluster di solito non supera i 4 KB e il metodo di compressione integrato elimina i problemi con lo spazio inutilizzato allocato per i file. Puoi anche usare NTFS.
Il file system NTFS è progettato per un ambiente multiutente e dispone di meccanismi incorporati per proteggere e differenziare i diritti di accesso. Ad esempio, i sistemi operativi Windows 2000 e Windows XP (ad eccezione di "Home Edition") consentono di impostare i permessi di accesso ai singoli file e di crittografarli. Tuttavia, l'elevato livello di sicurezza rende difficile l'utilizzo del computer da parte degli utenti ordinari. Prestare estrema attenzione durante l'impostazione delle password e dei permessi dei file per evitare di perdere dati importanti.
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!
Analizziamo i tipi di file system per un'unità flash, quale è il migliore. Un utente mi ha inviato una foto con l'errore "Il file è troppo grande per il file system di destinazione" e ha deciso di scrivere un articolo in quali casi si dovrebbero usare i sistemi FAT32, NTFS ed exFAT. Ha spostato un file più grande di 4 GB su una chiavetta da 8 GB. Il fatto è che il sistema FAT32 non è in grado di elaborare informazioni superiori a 4 GB, se l'unità flash ha un volume di 32 GB e il suo file system è FAT32, non è possibile scrivere un file superiore a 4 GB. Diamo un'occhiata a tutti e tre i file system in Windows, diamo un'occhiata ai loro pro e contro.
FAT32
La vecchia modalità del file system, che viene solitamente utilizzata quando si acquista un'unità flash USB da un negozio, e la ragione di ciò è la compatibilità. La compatibilità è che FAT32 può essere utilizzato su qualsiasi MAC, Windows, Linux, vecchi PC. La più grande limitazione è che ha un limite di dimensione del file di 4 GB, che oggi ha problemi con formati come video 4k, Blu-ray. In breve, se lavorerai con file di dimensioni inferiori a 4 GB e l'unità flash viene utilizzata su computer diversi con sistemi operativi diversi, il file system FAT32 è molto adatto.
exFAT
File system aggiornato creato da Microsoft per sostituire FAT32. Avviato con Windows Vista SP1 e ha una dimensione massima del file di 16 exabyte (EB), ovvero 1 EB = 10 18 byte. Compatibile con Mac OS e Windows, è un ottimo sistema per lo scambio di file di grandi dimensioni.
Svantaggi:
- Non ha alcun tipo di funzionalità di registrazione in cui tutte le modifiche ai file su disco vengono registrate prima che vengano effettivamente eseguite.
- Non supportato da Time Machine di Apple. In breve, non sarai in grado di eseguire il backup da Apple utilizzando il software Time Machine.
- Una struttura molto complessa che richiede più potenza di calcolo.
Professionisti:
- Sovrascrive lo stesso settore meno volte, il che è importante per le unità flash, allungando la vita delle celle di memoria. Come sai, le unità flash hanno un numero N di riscritture, quindi falliscono.
- Limite di file di grandi dimensioni di 16 exabyte.
- La dimensione del cluster è di 32 megabyte.
- Allocazione migliorata dello spazio libero, che riduce la deframmentazione del disco.
NTFS
Il file system più recente creato da Microsoft è la struttura moderna di oggi per quasi tutti i moderni dischi rigidi interni, unità flash o dischi SSD. NTFS è una nuova tecnologia di file system. Windows può essere installato solo su NTFS. È l'impostazione predefinita per i dischi del sistema operativo grazie alla sua versatilità. Ha tutte le tecnologie Microsoft: registrazione, nessun limite di dimensione dei file, supporto per la compressione dei file, nomi lunghi, controllo dell'accesso ai file per gli amministratori del server e molto altro. A casa, questa è l'opzione migliore per utilizzare questo sistema su dischi e unità flash. C'è un problema, quando si inserisce un'unità flash USB in Mac OS, è possibile copiare le informazioni da un'unità flash USB, ma nessuna modifica.
Conclusione:
Per le chiavette USB, è necessario utilizzare exFAT, se sei costantemente in ambiente Mac OS, Windows, spostando l'unità flash USB da un sistema operativo all'altro. Se usi solo Windows, NTSF è un'ottima soluzione.
VLADIMIR MESHKOV
Architettura del file system FAT
Caratteristiche generali del file system FAT. Struttura della partizione FAT
Il file system FAT (File Allocation Table) è stato sviluppato da Bill Gates e Mark MacDonald nel 1977 ed è stato originariamente utilizzato nel sistema operativo 86-DOS. Per ottenere la portabilità dei programmi dal sistema operativo CP / M a 86-DOS, sono state mantenute le restrizioni precedentemente adottate sui nomi dei file. Successivamente 86-DOS fu acquisito da Microsoft e divenne la base per MS-DOS 1.0, rilasciato nell'agosto 1981. FAT è stato progettato per funzionare con dischi floppy di dimensioni inferiori a 1 MB e inizialmente non supportava i dischi rigidi.
La struttura della partizione FAT è mostrata in figura.
Nel file system FAT, lo spazio su disco di una partizione logica è diviso in due aree: l'area di sistema e l'area dati (vedere la Figura 1). L'area di sistema viene creata e inizializzata durante la formattazione e successivamente aggiornata quando viene manipolata la struttura del file. L'area di sistema dei file system FAT è costituita dai seguenti componenti:
- record di avvio (BR);
- zona di riserva;
- tabelle di allocazione dei file;
- area della directory principale (non esiste in FAT32).
L'area dati di un disco logico contiene file e directory subordinate alla radice ed è divisa in sezioni della stessa dimensione: cluster. Un cluster può essere costituito da uno o più settori posizionati in sequenza sul disco. Il numero di settori in un cluster deve essere un multiplo di 2N e può assumere valori da 1 a 64. La dimensione del cluster dipende dal tipo di file system utilizzato e dalla dimensione del disco logico.
Scopo, struttura e tipi di tabella di allocazione dei file
FAT ha preso il nome dalla tabella di allocazione dei file con lo stesso nome - File Allocation Table, FAT. La tabella di allocazione dei file memorizza le informazioni sui cluster di un disco logico. Ogni cluster corrisponde a un elemento della tabella FAT, che contiene informazioni sul fatto che questo cluster sia libero o occupato da dati di file. Se il cluster è occupato da un file, l'indirizzo del cluster contenente la parte successiva del file è indicato nell'elemento corrispondente della tabella di allocazione dei file. Il numero di cluster iniziale occupato da un file è memorizzato nella voce di directory che contiene la voce del file. L'ultimo elemento dell'elenco dei cluster contiene la fine del file (EOF - End Of File). I primi due elementi FAT sono riservati.
Il file system FAT riempie sempre lo spazio libero su disco in sequenza dall'inizio alla fine. Quando si crea un nuovo file o se ne aumenta uno esistente, cerca il primo cluster libero nella tabella di allocazione dei file. Se durante l'operazione alcuni file sono stati eliminati e altri hanno cambiato dimensione, i cluster vuoti risultanti verranno sparsi sul disco. Se i cluster contenenti i dati del file non sono disposti in una riga, il file viene frammentato.
Esistono i seguenti tipi di FAT: FAT12, FAT16, FAT32. I nomi dei tipi FAT derivano dalla dimensione dell'elemento: FAT12 è 12 bit (1,5 byte), FAT16 è 16 bit (2 byte), FAT32 è 32 bit (4 byte). In FAT32, i quattro bit più significativi sono riservati e ignorati dal sistema operativo.
Root directory
Le tabelle di allocazione dei file sono seguite dalla directory principale. Ogni file e sottodirectory nella directory principale ha una voce di directory a 32 byte contenente il nome del file, gli attributi del file (archiviato, nascosto, di sistema e di sola lettura), la data e l'ora di creazione (o l'ultima modifica) e altre informazioni . Per i file system FAT12 e FAT16, la posizione della directory principale sulla partizione e la sua dimensione sono rigidamente fissate. In FAT32, la directory principale può essere posizionata ovunque nell'area dati della partizione ed essere di dimensioni arbitrarie.
Formati dei nomi dei file
Una delle caratteristiche delle prime versioni di FAT (FAT12 e FAT16) è l'uso di nomi di file brevi. Il nome breve è costituito da due campi: un campo da 8 byte contenente il nome del file effettivo e un campo da 3 byte contenente l'estensione (formato "8.3"). Se il nome del file inserito dall'utente è inferiore a 8 caratteri, viene riempito con spazi (codice 0x20); se l'estensione inserita è più corta di tre byte, viene riempita anche di spazi.
La struttura della voce di directory per un nome di file breve è mostrata nella Tabella 1.
Il primo byte del nome breve serve come segno che la directory è occupata:
- se il primo byte è 0xE5, la voce della directory è libera e può essere utilizzata durante la creazione di un nuovo file;
- se il primo byte è 0x00, allora la voce della directory è libera ed è l'inizio di un'area di directory pulita (non c'è alcuna voce dopo di essa).
Tabella 1. Struttura di una voce di directory per un nome di file breve
Pregiudizio |
Dimensione (byte) | Contenuto |
0x00 | 11 | Nome file breve |
0x0B | 1 | Attributi del file |
0x0C | 1 | Riservato per Windows NT. |
0x0D | 1 | Il campo che specifica l'ora di creazione del file (contiene decine di millisecondi). Il campo viene elaborato solo in FAT32 |
0x0E | 1 | L'ora in cui è stato creato il file. Il campo viene elaborato solo in FAT32 |
0x10 | 2 | La data di creazione del file. Il campo viene elaborato solo in FAT32 |
0x12 | 2 | La data dell'ultimo accesso al file per la scrittura o la lettura dei dati. Il campo viene elaborato solo in FAT32 |
0x14 | 2 | La parola più importante del primo numero di cluster nel file. Il campo viene elaborato solo in FAT32 |
0x16 | 2 | Ora dell'ultima scrittura sul file |
0x18 | 2 | Data dell'ultima scrittura sul file |
0x1A | 2 | La parola meno significativa del numero del primo cluster del file |
0x1C | 4 | Dimensione del file in byte |
Vengono imposte una serie di restrizioni all'uso dei caratteri ASCII in un nome breve:
- non è possibile utilizzare caratteri con codici inferiori a 0x20 (tranne il codice 0x05 nel primo byte di un nome breve);
- non è possibile utilizzare simboli con codici 0x22, 0x2A, 0x2B, 0x2C, 0x2E, 0x2F, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F, 0x5B, 0x5C, 0x5D, 0x7C;
- non è possibile utilizzare uno spazio (0x20) nel primo byte del nome.
I file system FAT32 e VFAT (virtuale FAT, estensione FAT16) supportano i nomi di file lunghi (LFN). Per memorizzare il nome lungo, vengono utilizzati gli elementi della directory adiacenti all'elemento principale. Il nome del file non è scritto in caratteri ASCII, ma in Unicode. Un blocco di fino a 13 caratteri Unicode può essere memorizzato in una voce di catalogo. La parte inutilizzata dell'ultimo frammento viene riempita con codici 0xFFFF. La struttura della voce di directory per un nome di file lungo è mostrata nella Tabella 2.
Tabella 2. Struttura di una voce di directory per un nome di file lungo
Pregiudizio | Dimensione (byte) | Contenuto |
0x00 | 1 | Numero del frammento |
0x01 | 10 | Caratteri del nome file Unicode 1-5 |
0x0B | 1 | Attributi del file |
0x0C | 1 | Flag byte |
0x0D | 1 | Checksum del nome breve |
0x0E | 12 | Caratteri 6-11 del nome del file Unicode |
0x1A | 2 | Primo numero di cluster (riempito con zeri) |
0x1C | 4 | Caratteri 12-13 del nome file Unicode |
Settore di avvio
Il primo settore di un disco logico FAT contiene un settore di avvio e un blocco di parametri BIOS. La sezione iniziale di questo blocco è identica per tutti i tipi di FAT (tabella 3). Le differenze nella struttura dei settori di avvio per i diversi tipi di FAT iniziano con l'offset 0x24. Per FAT12 e FAT16, la struttura è mostrata nella tabella 4, per FAT32 - nella tabella 5.
Tabella 3. Sezione iniziale del settore di avvio
Pregiudizio | Dimensione, byte | Descrizione |
0x00 | 3 | Salto incondizionato (jmp) al codice di avvio |
0x03 | 8 | ID produttore |
0x0B | 2 | Byte di settore (512) |
0x0D | 1 | Numero di settori in un cluster |
0x0E | 2 | Il numero di settori liberi nell'area libera della partizione, a partire dal primo settore della partizione |
0x10 | 1 | Numero di tabelle (copie) FAT |
0x11 | 2 | Per FAT12 / FAT16, il numero di descrittori di file a 32 byte nella directory principale; per FAT32 questo campo ha il valore 0 |
0x13 | 2 | Il numero totale di settori nella partizione; se questo campo contiene 0, quindi il numero di settori è impostato dal campo all'offset 0x20 |
0x15 | 1 | Tipo di supporto. Per il disco rigido, il valore è 0xF8; per floppy disk (2 lati, 18 settori per traccia) - 0xF0 |
0x16 | 2 | Per FAT12 / FAT16 questo campo contiene il numero di settori, occupato da una copia di FAT; per FAT32 questo campo ha il valore 0 |
0x18 | 2 | Il numero di settori per traccia (per interrupt 0x13) |
0x1A | 2 | Numero di piani di lavoro (per interruzione 0x13) |
0x1C | 4 | Numero di settori nascosti prima della partizione |
0x20 | 4 | Il numero totale di settori nella partizione. Il campo viene utilizzato se la sezione oltre 65535 settori, altrimenti il campo contiene 0. |
Tabella 4. Struttura del settore di avvio FAT12 / FAT16
Pregiudizio Dimensione, byte Descrizione 0x24 1 Interrompere il numero di unità 0x13 0x25 1 0x26 1 Flag record di avvio esteso (0x29) 0x27 4 Numero di disco logico 0x2B 11 Etichetta disco 0x36 8 Una stringa di testo con un'abbreviazione per il tipo di file system
Tabella 5. Struttura del settore di avvio FAT32
Dimensione, byte Descrizione 4 Numero di settori occupati da una copia di FAT 2 Numero FAT attivo 2 Numero di versione FAT32: byte alto - numero di versione,junior - numero di revisione. Il valore attualmente utilizzato è 0: 0 4 Numero di cluster per il primo cluster della directory principale 2 Il numero di settore della struttura FSINFO nell'area di riserva del disco logico 2 Numero di settore (nell'area di riserva del disco logico) utilizzatoper archiviare un backup del settore di avvio 12 Riservato (contiene 0)
Pregiudizio |
0x24 |
0x28 |
0x2A |
0x2C |
0x30 |
0x32 |
0x34 |
Oltre ai campi elencati nelle tabelle 2 e 3, il settore zero di un disco logico deve contenere il codice 0x55 nel byte con offset 0x1FE, e il codice 0xAA nel byte successivo (offset 0x1FF). I due byte elencati sono un identificatore del disco di avvio.
Pertanto, il settore di avvio svolge due importanti funzioni: descrive la struttura dei dati sul disco e consente anche di avviare il sistema operativo.
Su un disco logico con organizzazione FAT32, è inoltre presente una struttura FSInfo situata nel primo settore dell'area di riserva. Questa struttura contiene informazioni sul numero di cluster liberi su disco e sul numero del primo cluster libero nella tabella FAT. Il formato della struttura è descritto nella Tabella 6.
Tabella 6. Struttura del settore FSInfo e del settore di avvio del backup FAT32
Dimensione, byte Descrizione 4 Il valore 0x41615252 è una firma che indica che questo settore contiene una struttura FSInfo 480 Riservato (contiene 0) 4 Valore 0x61417272 (firma) 4 Contiene il numero corrente di cluster liberi su disco. Se il campo contiene il valore 0xFFFFFFFF, il numero di cluster liberi è sconosciuto e deve essere calcolato 4 Contiene il numero di cluster da cui il driver del disco dovrebbe iniziare a cercare i cluster liberi. Se il campo contiene il valore 0xFFFFFFFF, allora la ricerca dei cluster liberi dovrebbe essere avviata dal cluster numero 2 12 Riservato (contiene 0) 4 Firma 0xAA550000 - segno della fine della struttura FSInfo
Pregiudizio |
0x000 |
0x004 |
0x1E4 |
0x1E8 |
0x1EC |
0x1F0 |
0x1FC |
Per accedere al contenuto di un file che si trova su una partizione con il file system FAT, è necessario ottenere il numero del primo cluster del file. Questo numero, come abbiamo già stabilito, fa parte della voce di directory contenente la voce del file. Il primo numero di cluster corrisponde a una voce nella tabella FAT, che memorizza l'indirizzo del cluster contenente la parte successiva del file. L'elemento FAT corrispondente all'ultimo cluster della catena contiene la firma di fine file. Per FAT12 questo valore è 0xFFF, per FAT16 è 0xFFFF, per FAT32 è 0xFFFFFFFF.
Diamo un'occhiata all'implementazione software dell'algoritmo di lettura per ciascun tipo FAT e iniziamo con FAT16.
Tutti i testi di partenza considerati nell'articolo sono disponibili sul sito web della rivista.
Implementazione software dell'algoritmo per la lettura di un file da una partizione logica con il file system FAT16
Sviluppiamo un modulo che legga i primi N cluster di un file creato su una partizione con file system FAT16. Il parametro N (numero di cluster da leggere) è variabile ed è definito dall'utente. Il nome del file corrisponde al formato "8.3", ad es. è corto. Il modulo funziona con il sistema operativo Linux.
Definiamo i file di intestazione richiesti:
#includere
#includere
#includere
#includere
#includere
#include "split.h"
Il file di intestazione split.h ha il seguente contenuto:
#includere
#define SHORT_NAME 13 // lunghezza massima di un nome file breve
struttura split_name (
nome U8; // Nome del file
U8 esterno; // estensione del file
Int name_len, // lunghezza del nome del file
Ext_len; // lunghezza dell'estensione del file
La struttura split_name ha lo scopo di memorizzare le parti costitutive del nome breve del file (nome ed estensione) e la loro lunghezza.
Il file di intestazione definisce i tipi strutturali che descrivono i componenti principali del file system FAT: settore di avvio, settore FSInfo, strutture di elementi di directory per nomi di file brevi e lunghi.
Consideriamo brevemente i campi che sono inclusi in ciascuna di queste strutture.
- Struttura del settore di avvio struct fat_boot_sector:
- __s8 system_id- identificatore di sistema;
- __u8 dimensione_settore - dimensione del settore in byte;
- __u8 cluster_size- la dimensione del cluster in settori;
- __u16 riservato- il numero di settori liberi nell'area libera della partizione;
- __u8 grassi- numero di copie FAT;
- __u8 dir_entries- il numero di descrittori di file a 32 byte nella directory principale;
- __u8 settori- il numero di settori per partizione; se questo campo è 0, viene utilizzato il campo total_sect;
- __u8 media- il tipo di supporto su cui viene creato il file system;
- __u16 fat_length- Dimensione FAT in settori;
- __u32 sezione_totale- dimensione della partizione FAT in settori (se i settori del campo == 0).
- __u32 fat32_length- Dimensione FAT32 a settori;
- __u32 root_cluster- numero del primo cluster della directory radice;
- __u16 info_sector- numero del settore contenente la struttura FSInfo.
I seguenti campi in questa struttura sono utilizzati solo da FAT32:
- 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.
- 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).
- 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
Pregiudizio | Dimensione, byte | Contenuto |
0x00 | 1 | Segno attivo (0 - la sezione non è attiva, 0x80 - la sezione è attiva) |
0x01 | 1 | Numero della testina del disco da cui inizia la partizione |
0x02 | 2 | Numero del cilindro e numero del settore da cui inizia la sezione |
0x04 | 1 | Codice tipo sezione ID sistema |
0x05 | 1 | Il numero della testina del disco in cui termina la partizione |
0x06 | 2 | Numero del cilindro e numero del settore che termina la sezione |
0x08 | 4 | Il numero assoluto (logico) del settore iniziale della partizione |
0x0C | 4 | Dimensione della partizione (numero di settori) |
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:
- V. Kulakov. Programmazione hardware: un riferimento speciale. 2a ed. / - SPb.: Pietro, 2003 - 848 p.
- A.V. Gordeev, A. Yu. Molchanov. Software di sistema / - SPb.: Peter - 2002
- 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
Implementato e utilizzato dalla maggior parte dei sistemi operativi (MS-DOS, Windows 98, Windows NT, OS/2, UNIX). |
Sul questo momento supportato solo su Windows 95 OSR2 e Windows 98. |
Molto efficiente per unità logiche inferiori a 256 MB. |
Non funziona con unità inferiori a 512 MB. |
Supporta la compressione del disco, come DriveSpace. |
Non supporta la compressione del disco. |
Elabora un massimo di 65.525 cluster, la cui dimensione dipende dalla dimensione del disco logico. Poiché la dimensione massima del cluster è 32 KB, FAT16 può gestire unità logiche fino a 2 GB. |
In grado di lavorare con dischi logici fino a 2.047 GB con una dimensione massima del cluster di 32 KB. |
Maggiore è la dimensione del disco logico, meno efficiente è l'archiviazione dei file nel sistema FAT "16, poiché aumenta anche la dimensione dei cluster. Lo spazio per i file viene allocato dai cluster e quindi, con il volume massimo di un logico disco, un file di 10 KB richiederà 32 KB e 22 KB di spazio su disco saranno sprecati. |
Sulle unità logiche inferiori a 8 GB, i cluster sono 4 KB. |
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
Volume del disco |
Dimensione del cluster in FAT16, KB |
Dimensione del cluster in FAT32, KB |
256 MB-511 MB |
Non supportato |
|
512 MB -1023 MB | ||
1024 MB - 2 GB | ||
2 GB - 8 GB |
Non supportato | |
8 GB-16 GB |
Non supportato | |
16 GB-32 GB |
Non supportato | |
Più di 32 GB |
Non supportato |
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.