Wat is het verschil tussen FAT32, NTFS en exFAT. Een USB-flashstation formatteren naar FAT32 of NTFS - wat is beter? Bestandssysteem NTFS - beschrijving, toepassing en sleuteleigenschappen

1. FSInfo sectorstructuur struct fat_boot_fsinfo:
   • __u32 handtekening1- handtekening 0x41615252;
   • __u32 handtekening2- handtekening 0x61417272;
   • __u32 free_clusters- het aantal vrije clusters. Als het veld -1 bevat, moet het zoeken naar vrije clusters worden gestart vanaf cluster nummer 2.
2. De structuur van het directory-item van de korte naam struct msdos_dir_entry:
   • __s8 naam, ext- bestandsnaam en extensie;
   • __u8 attr- bestandskenmerken;
   • __u8 ctime_ms- dit veld specificeert de tijd van het aanmaken van bestanden tot ms (alleen FAT32 wordt gebruikt);
   • __u16 ctime- aanmaaktijd van bestanden (alleen FAT32 wordt gebruikt);
   • __u16 cd-datum- aanmaakdatum van het bestand (alleen FAT32 wordt gebruikt);
   • __u16 adate- datum van de laatste toegang tot het bestand (alleen FAT32 wordt gebruikt);
   • __u16 starthi- hoge 16 bits van het nummer van de eerste cluster van het bestand (alleen FAT32 wordt gebruikt);
   • __u16 tijd, datum, start- tijd en datum van aanmaak van het bestand, nummer van de eerste cluster van het bestand;
   • __u32 maat- bestandsgrootte (in bytes).
3. Lange naam directory itemstructuur:
   • __u8 id- item nummer;
   • __u8 naam0_4- karakters 1 - 5 van de naam;
   • __u8 attr- bestandskenmerken;
   • __u8 alias_checksum- controlesom van de korte naam;
   • __u8 naam5_10- karakters 6 - 11 van de naam;
   • __u8 naam11_12- tekens 12 - 13 van de naam.

Laten we doorgaan met het bekijken van de software-implementatie van het algoritme en de naam definiëren van de partitie waarop het FAT16-bestandssysteem is gemaakt:

#ifndef FAT16_PART_NAME

#define FAT16_PART_NAME "/ dev / hda1"

#stop als

Globale structuren:

struct fat_boot_sector fbs; // opstartsectorstructuur

struct msdos_dir_entry tandheelkunde; // directory-itemstructuur

Globale variabelen:

U16 * vet16; // kopieer de FAT16-tabel hier

U16 sector_grootte; // sectorgrootte (vanaf FAT16)

U16 dir_entries; // aantal 32-byte descriptors

// in de hoofdmap (0 voor FAT32)

U16 sectoren; // totaal aantal sectoren in sectie

U32 fat16_maat; // FAT16-formaat

U32 root_grootte; // grootte van de hoofdmap

U16 byte_per_cluster; // clustergrootte in bytes

U16 volgende_cluster; // volgende cluster in de keten

int vet;

Laten we beginnen met de hoofdfunctie:

int hoofd ()

Int. aantal;

We stellen de volledige naam van het bestand in, waarvan we de inhoud willen lezen. Ik wil u eraan herinneren dat we alleen met korte bestandsnamen werken. De procedure voor het werken met lange namen wordt in dit artikel niet behandeld.

U8 * full_path = "/Map1/Map2/tekst.txt";

Open het apparaatbestand:

Hard = open (FAT16_PART_NAME, O_RDONLY);

Als (moeilijk)< 0) {

Perror (FAT16_PART_NAME);

Afsluiten (-1);

We lezen de eerste 10 clusters van het bestand. Het lezen wordt uitgevoerd door de functie fat16_read_file (). De functieparameters zijn de volledige bestandsnaam en het aantal te lezen clusters. De functie retourneert het aantal gelezen clusters, of -1 als er een fout is opgetreden tijdens het lezen:

Num = fat16_read_file (volledig_pad, 10);

Als (aantal< 0) perror("fat16_read_file");

Anders printf ("Read% d clusters", num);

Sluit het apparaatbestand en sluit af:

Sluiten (hard);

Retour 0;

De functie voor het lezen van bestandsclusters ziet er als volgt uit:

int fat16_read_file (__ u8 * full_path, int num)

Struct split_name sn; // structuur voor het opslaan van de samenstellende delen van het bestand

U8 tmp_name_buff; // buffer voor tijdelijke opslag van de samengestelde elementen van het volledige pad van het bestand

Statisch int i = 1;

Int n;

U8 * tmp_buff;

U16 start_cluster, volgende_cluster;

We hebben de parameters van de functie opgesomd bij het beschouwen van de hoofdfunctie.

Voorbereidende bewerkingen - het op nul zetten van de tmp_name_buff buffer en de struct split_name sn structuur:

Het eerste teken in een absolute padnaam moet een schuine streep (/) zijn. Wij controleren dit:

We lezen de opstartsector van de partitie:

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

De read-bootsector bevindt zich nu in de globale struct fat_boot_sector fbs. Laten we van deze structuur de sectorgrootte, het aantal items in de rootdirectory en het totale aantal sectoren op de partitie kopiëren:

Laten we de grootte van het cluster in bytes bepalen:

Byte_per_cluster = fbs.cluster_size * 512

Laten we de informatie in de opstartsector weergeven:

Printf ("Systeem-id -% s", fbs.system_id);

Printf ("Sectorgrootte -% d", sector_grootte);

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

Printf ("Gereserveerd -% d", fbs.gereserveerd);

Printf ("FATs-getal -% d", fbs.fats);

Printf ("Dir-invoer -% d", dir_entries);

Printf ("Sectors -% d", sectoren);

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

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

Printf ("Totaal sekte -% u", fbs.total_sect);

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

Bereken de grootte van FAT16 in bytes en lees het af:

Fat16_size = fbs.fat_length * 512;

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

We lezen de hoofdmap:

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

De dir_entry-aanwijzer is nu gepositioneerd naar het geheugengebied dat de hoofddirectory-items bevat. De grootte van dit geheugengebied is gelijk aan de grootte van de rootdirectory (root_size).

Laten we (voor controle) de inhoud van de hoofdmap opslaan in een apart bestand:

#ifdef DEBUG

Sluiten (vet);

#stop als

We berekenen het begin van het gegevensgebied:

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

Met alle vermeldingen in de hoofdmap op hun plaats, kunnen we bij de inhoud van het test.txt-bestand komen. Hiervoor organiseren we een cyclus. Laten we in de hoofdtekst van de lus de volledige bestandsnaam ontleden, met de nadruk op de elementen - submappen (we hebben er twee, Folder1 en Folder2) en de naam van het vereiste bestand (test.txt).

Terwijl (1) (

Memset (tmp_name_buff, 0, SHORT_NAME);

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

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

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

ik ++;

Pauze;

Tmp_name_buff [n] = "?";

Vul de struct split_name sn in met de juiste informatie. De vulling wordt uitgevoerd door de functie split_name, terwijl de bestandsnaam wordt vergeleken met het "8.3"-formaat:

< 0) {

Printf ("ongeldige naam");

Retour -1;

Voor elk element van de volledige bestandsnaam definiëren we een eerste cluster. Om dit te doen, zoekt u in de directory-elementen (beginnend bij de root) naar een item dat overeenkomt met het volledige naamelement en leest u dit item. De functie get_dentry () voert de zoekprocedure uit:

Als (get_dentry (& sn)< 0) {

Printf ("Geen dergelijk bestand!");

Retour -1;

De bestandskenmerken controleren. Als het een map is, lees dan de inhoud en ga verder met de lus:

Als (dentry.attr & 0x10) (

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

Doorgaan met;

Als dit een bestand is, lees dan het eerste aantal clusters. Ter controle slaan we de uitgelezen informatie op in een apart bestand:

Als (dentry.attr & 0x20) (

Start_cluster = tandheelkunde.start;

Tmp_buff = (__u8 *) malloc (byte_per_cluster); // de inhoud van het cluster wordt hier gelezen

N = open ("clust", O_CREAT | O_RDWR, 0600); // sla de gelezen informatie op in dit bestand

Als (n< 0) {

Perror ("open");

Retour -1;

Om de dossierclusters te lezen, organiseren we een cyclus:

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

We lezen de inhoud van het cluster in de tmp_buff buffer en slaan het op in een apart bestand:

< 0) return -1;

< 0) {

Perror ("schrijven");

Sluiten (n);

Retour -1;

We lezen uit FAT16 het nummer van het volgende cluster dat door dit bestand wordt ingenomen. Als dit het laatste cluster is, onderbreken we de lus en keren we terug naar de hoofdfunctie:

#ifdef DEBUG

Printf ("OK. Gelezen");

Printf ("bestand`s volgende cluster - 0x% X ..", next_cluster);

#stop als

Als (volgende_cluster == EOF_FAT16) (

#ifdef DEBUG

Printf ("laatste cluster.");

#stop als

Gratis (tmp_buff);

Sluiten (n);

Retour ++ i;

#ifdef DEBUG

Printf ("stop met lezen");

#stop als

Retour ik;

Het lezen van de FAT16-opstartsector wordt uitgevoerd door de functie read_fbs (). Het resultaat wordt in de globale fbs-structuur geplaatst:

int read_fbs ()

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

Retour 0;

Het lezen van de bestandstoewijzingstabel van het FAT16-bestandssysteem wordt uitgevoerd door de functie read_fat16 ():

int read_fat16 ()

U64 zoeken = (__u64) (fbs.gereserveerd) * 512; // offset naar FAT16 vanaf het begin van de partitie

Fat16 = (void *) malloc (fat16_size);

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

Retour 0;

Het lezen van de hoofdmap wordt uitgevoerd door de functie read_root_dentry ():

int read_root_dentry ()

U64 seek = (__u64) fbs.reserved * 512 + fat16_size * fbs.fats; // offset naar de hoofdmap vanaf het begin van de sectie

Root_size = 32 * dir_entries; // bereken de grootte van de hoofdmap

Dir_entry = (__u8 *) malloc (root_size);

Als (! Dir_entry) retourneert -1;

Memset (dir_entry, 0, root_size);

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

Retour 0;

Het lezen van een cluster dat bij een bestand hoort, wordt uitgevoerd door de functie read_cluster (). De invoerparameters van de functie zijn het nummer van het cluster cluster_num en een pointer naar de __u8 * tmp_buff buffer, waar het leesresultaat moet worden geplaatst. De offset naar het cluster op de sectie wordt berekend met de formule (zie):

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

• ZOEKEN- offset naar het cluster op de partitie
• DATA_START- begin van gegevensgebied
• CLUSTER_NUM- volgnummer van het cluster
• BYTE_PER_CLUSTER- clustergrootte in bytes

int read_cluster (__ u16 cluster_num, __u8 * tmp_buff)

U64 seek = (__u64) (byte_per_cluster) * (cluster_num - 2) + data_start; // bereken de offset naar het cluster

< 0) return -1;

Retour 0;

De functie read_directory leest de items in de directory (niet de root) en plaatst het resultaat in het geheugengebied waarop de dir_entry-aanwijzer is ingesteld:

int leesmap (__ u16 start_cluster)

Int i = 1;

U16 volgende_cluster;

Voor (;; ik ++) (

We wijzen geheugen toe om de inhoud van de map op te slaan, lezen de inhoud van het startcluster en halen de waarde van het volgende cluster uit de FAT16-tabel:

Als (! Dir_entry) retourneert -1;

< 0) return -1;

Volgende_cluster = fat16;

Laten we de inhoud van de map in een apart bestand opslaan (voor controle):

#ifdef DEBUG

Printf ("Volgende cluster - 0x% X", volgende_cluster);

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

Schrijven (vet, dir_entry, root_size);

Sluiten (vet);

#stop als

Als het laatste cluster is bereikt, verlaat u de lus, anders gaat u verder met het lezen van de map en vergroot u de grootte van de dir_entry-buffer met nog een cluster:

Als (next_cluster & EOF_FAT16) breken;

Start_cluster = volgende_cluster;

Retour 0;

De functie get_dentry () zoekt in de directory-inhoud naar een item dat overeenkomt met het bestand dat u zoekt. De invoer voor deze functie is een verwijzing naar een struct split_name * sn die de elementen van de korte bestandsnaam bevat:

Int i = 0;

De globale buffer dir_entry bevat een reeks directory-items waarin we gaan zoeken naar een bestands- (of directory-) item. Om te zoeken, organiseren we een cyclus. Kopieer in de hoofdtekst van de lus de directory-ingangen naar de globale dentry-structuur en vergelijk de waarde van de naam- en ext-velden van deze structuur met de overeenkomstige velden van de structuur struct split_name * sn. Het samenvallen van deze velden betekent dat we de invoer van het vereiste bestand hebben gevonden in de reeks cataloguselementen:

voor (;; ik ++) (

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

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

Pauze;

Als (! Dentry.name) retourneert -1;

#ifdef DEBUG

Printf ("naam -% s", dentry.naam);

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

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

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

#stop als

Retour 0;

Alle bovenstaande code staat in de FAT16-directory, bestand fat16.c. Om de uitvoerbare module te krijgen, maakt u een Makefile met de volgende inhoud:

INCDIR = / usr / src / linux / include

PHONY = schoon

Fat16: fat16.o gesplitst.o

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

% .o:% .c

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

Schoon:

Rm -f * .o

Rm -f./fat16

Software-implementatie van het algoritme voor het lezen van een bestand van een logische partitie met het FAT12-bestandssysteem

Over het algemeen is het algoritme voor het lezen van een bestand van een FAT12-partitie identiek aan het algoritme voor het lezen van een bestand van een FAT16-partitie. Het verschil zit hem in de procedure voor het uitlezen van elementen uit de FAT12-tabel. We beschouwden de FAT16-tabel als een eenvoudige array van 16-bits elementen. Het volgende algoritme wordt voorgesteld voor het lezen van elementen van de FAT12-tabel:

• vermenigvuldig het elementnummer met 1,5;
• extraheer een 16-bits woord uit FAT met behulp van het resultaat van de vorige bewerking als een offset;
• als het elementnummer even is, voer dan de AND-bewerking uit op het leeswoord en maskeer 0x0FFF. Als het getal oneven is, verschuift u het uit de tabel gelezen woord met 4 bits naar de minst significante bits.

Op basis van dit algoritme zullen we de functie van het lezen van elementen uit de FAT12-tabel implementeren:

int get_cluster (__ u16 cluster_num)

U16 zoeken;

U16-cluster;

Bereken de offset in de FAT12-tabel en lees het 16-bits woord uit de tabel:

Zoeken = (cluster_num * 3) / 2;

Memcpy ((__ u8 *) & clust, (__u8 *) (fat12 + zoeken), 2);

Als het startnummer van het cluster een even getal is, verschuiven we de waarde die uit de tabel wordt gelezen met 4 bits naar de lagere cijfers, als het oneven is, tellen we het op bij 0x0FFF:

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

Anders cluster & = 0x0FFF;

Dit fragment kan ook in assembler worden geïmplementeerd:

"xorw %% bijl, %% bijl"

"BTW $ 0, %% cx"

"jnc 1f"

"shrw $ 4, %% dx"

"jmp 2f"

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

"2: movw %% dx, %% bijl"

: "= een" (volgende)

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

We geven het resultaat terug:

retourcluster;

Laten we wat meer stilstaan ​​​​bij het algoritme zelf. Laten we aannemen dat een bestand is gemaakt op een FAT12-partitie die de 9e en 10e clusters bezet. Elk FAT12-element is 12 bits lang. Omdat we lezen 16-bits elementen uit de tabel, dan is de offset naar het 9e element 13 bytes (9 * 1.5 = 13, we negeren de rest), terwijl de minst significante 4 bits behoren tot het 8e element van FAT. Ze moeten worden weggegooid en hiervoor is het voldoende om het leeselement met 4 bits naar de lagere cijfers te verschuiven, wat wordt geleverd door het algoritme. De offset naar het 10e element zal 15 bytes zijn en de meest significante 4 bits zullen behoren tot het 11e element van de FAT. Om ze te verwijderen, is het noodzakelijk om de EN-bewerking uit te voeren op het 10e element en het masker 0x0FFF, wat ook overeenkomt met het bovenstaande algoritme.

De broncodes van de module voor het lezen van het bestand van de FAT12-partitie bevinden zich in de FAT12-directory, bestand fat12.c.

Software-implementatie van het algoritme voor het lezen van een bestand van een logische partitie met het FAT32-bestandssysteem

Het algoritme voor het lezen van een bestand van een partitie met het FAT32-bestandssysteem verschilt praktisch niet van het algoritme voor FAT16, behalve dat in FAT32 de rootdirectory zich overal op de partitie kan bevinden en een willekeurige grootte kan hebben. Laten we de taak daarom, om het interessanter te maken, ingewikkelder maken - laten we aannemen dat we alleen het partitienummer kennen met het FAT32-bestandssysteem. Om informatie uit deze sectie te lezen, moet u eerst de coördinaten bepalen - de offset naar de sectie vanaf het begin van de schijf. En daarvoor moet je een idee hebben van de logische opbouw van de harde schijf.

Logische structuur van de harde schijf

Overwegen logische structuur harde schijf die voldoet aan de Microsoft-standaard - "primaire partitie - uitgebreide partitie - niet-DOS-partities."

De ruimte op de harde schijf kan worden georganiseerd als een of meer partities en partities kunnen een of meer logische stations bevatten.

De harde schijf op fysiek adres 0-0-1 bevat het Master Boot Record (MBR). De MBR-structuur bevat de volgende elementen:

• niet-systeem bootstrap (NSB);
• (partitietabel, PT). Bevindt zich in de MBR op offset 0x1BE en neemt 64 bytes in beslag;
• MBR-handtekening. De laatste twee bytes van de MBR moeten het nummer 0xAA55 bevatten.

De partitietabel beschrijft de locatie en kenmerken van de partities die beschikbaar zijn op de harde schijf. Schijfpartities kunnen van twee typen zijn: primair en uitgebreid. Het maximum aantal primaire partities is vier. Het is verplicht om ten minste één primaire partitie op de schijf te hebben. Een uitgebreide partitie kan worden onderverdeeld in een groot aantal subsecties - logische stations. Vereenvoudigd MBR-structuur wordt weergegeven in Tabel 7. De partitietabel bevindt zich aan het einde van de MBR, 16 bytes zijn toegewezen voor de beschrijving van de partitie in de tabel.

Tabel 7. MBR-structuur

Vooroordeel Grootte, bytes 0 446 0x1BE 16 0x1CE 16 0x1DE 16 0x1EE 16 0x1FE 2

De structuur van de invoer van de partitietabelinvoer wordt getoond in Tabel 8.

Tabel 8. Structuur van de invoer van het partitietabelelement

De eerste byte in het sectie-element is de sectie-activiteitsvlag (0 - inactief, 0x80 - actief). Het dient om te bepalen of de partitie een opstartbaar systeem is en of het nodig is om het besturingssysteem ervan op te starten wanneer de computer opstart. Er kan slechts één sectie actief zijn. De partitie actieve vlag wordt gevolgd door de coördinaten van het begin van de partitie - drie bytes, wat het kopnummer, sectornummer en cilindernummer betekent. Cilinder- en sectornummers worden gespecificeerd in het Int 0x13 interrupt-formaat, d.w.z. bits 0-5 bevatten het sectornummer, bits 6-7 zijn de meest significante twee bits van het 10-bits cilindernummer en bits 8-15 zijn de minst significante acht bits van het cilindernummer. Dit wordt gevolgd door de systeem-ID, die aangeeft dat het toebehoort aan: van deze sectie naar een bepaald besturingssysteem. De identifier is één byte. Achter de systeem-ID bevinden zich de coördinaten van het einde van de sectie - drie bytes die respectievelijk de nummers van de kop, sector en cilinder bevatten. De volgende vier bytes zijn het aantal sectoren vóór de partitie en de laatste vier bytes zijn de grootte van de partitie in sectoren.

Een sectietabelelement kan dus worden beschreven met behulp van de volgende structuur:

struct pt_struct (

U8 opstartbaar; // sectie activiteit vlag

U8 start_part; // coördinaten van het begin van de sectie

U8 type_onderdeel; // systeem-ID

U8 eind_deel; // coördinaten van het einde van de sectie

U32 sekte_voor; // aantal sectoren vóór de sectie

U32 sec_totaal; // partitiegrootte in sectoren (aantal sectoren in de partitie)

Het element van de primaire partitie verwijst rechtstreeks naar de opstartsector van de logische schijf (er is altijd maar één logische schijf in de primaire partitie), en het element van de uitgebreide partitie verwijst naar een lijst met logische schijven die bestaat uit structuren die secundaire MBR (SMBR).

Elke schijf van de uitgebreide partitie heeft zijn eigen SMBR-blok. SMBR heeft een structuur die lijkt op MBR, maar het heeft geen opstartrecord (gevuld met nullen) en er worden slechts twee van de vier partitiedescriptorvelden gebruikt. Het eerste element van de partitie verwijst naar de logische schijf, het tweede element verwijst naar de volgende SMBR-structuur in de lijst. De laatste SMBR van de lijst bevat de nulsectiecode in het tweede element.

Laten we teruggaan naar de module voor het lezen van een bestand van een FAT32-partitie.

Header-bestanden:

#erbij betrekken

#erbij betrekken

#erbij betrekken

#erbij betrekken

#erbij betrekken

MBR-handtekening:

#define HANDTEKENING 0xAA55

Apparaatbestand waaruit informatie over partities wordt gelezen:

#define APPARAAT "/ dev / hda"

Grootte van partitietabelelement (16 bytes):

#define PT_SIZE 0x10

De volgende reeks structuren bepaalt de overeenkomst tussen de sectietypecode en de symbolische weergave ervan:

systypes structureren (

U8 onderdeel_type;

U8 * part_name;

struct systypes i386_sys_types = (

(0x00, "Leeg"),

(0x01, "FAT12"),

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

(0x05, "Uitgebreid"),

(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 uitgebreid"),

(0x07, "HPFS / NTFS")

Bepaal het aantal elementen in de array i386_sys_types met behulp van de macro PART_NUM:

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

Laten we een limiet stellen aan het aantal logische schijven:

#define MAX_PART 20

De volgende structuurarray bevat informatie over logische schijven op het apparaat (harde schijf):

struct pt_struct (

U8 opstartbaar;

U8 start_part;

U8 type_onderdeel;

U8 eind_deel;

U32 sekte_voor;

U32 sec_totaal;

) pt_t;

int hard; // apparaat bestandsdescriptor

U8 mbr; // tel hier MBR

Partitienummer waarop het FAT32-bestandssysteem is aangemaakt:

#define FAT32_PART_NUM 5

Bootsector, FSInfo-sector en catalogusinvoerstructuren (gedefinieerd in het bestand ):

struct fat_boot_sector fbs;

struct fat_boot_fsinfo fsinfo;

struct msdos_dir_entry tandheelkunde;

U32 * fat32 = NULL; // kopieer de FAT32-tabel hier

U16 sector_grootte; // sectorgrootte (vanaf FAT32)

U16 dir_entries; // 0 voor FAT32

U16 sectoren; // aantal sectoren per partitie

U32 fat32_grootte; // FAT32-formaat

U32 data_start; // begin van gegevensgebied

U16 byte_per_cluster; // hoeveel bytes zitten er in het cluster (clustergrootte in bytes)

U32 volgende_cluster; // volgende cluster in de keten

U32 root_cluster; // ROOT cluster - initiële root cluster

U8 * dir_entry = NULL; // aanwijzer naar directory-items

U64 start_seek = 0; // begin offset naar sectie (in bytes)

Hoofdfunctie:

int hoofd ()

Int aantal = 0;

Int cluster_num = 5; // hoeveel clusters uit het bestand moeten worden gelezen

U8 * full_path = "/ Folder1 / Folder2 / readme"; // bestand om te lezen

We openen het apparaat, krijgen informatie over de partitietabel op het apparaat en geven informatie over de partities weer:

Hard = open (DEV_NAME, O_RDONLY);

Als (moeilijk)< 0) {

Perror (DEV_NAME);

Afsluiten (-1);

Als (get_pt_info (moeilijk)< 0) {

Perror ("get_pt_info");

Afsluiten (-1);

Show_pt_info ();

We berekenen de startoffset voor de sectie:

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

We lezen de clusters die bij het bestand horen:

Num = fat32_read_file (volledig_pad, cluster_num);

Als (aantal< 0) perror("fat32_read_file");

Anders printf ("Lees% d clusters \ n", num);

Sluiten (hard);

Retour 0;

Informatie over de partitietabel wordt gelezen door de functie get_pt_info ():

int get_pt_info (int moeilijk)

Int i = 0;

U64 zoeken;

We lezen de partitietabel van de MBR en controleren de handtekening:

Read_main_ptable (hard);

Als (check_sign ()< 0) {

Printf ("Niet geldige handtekening! \ N");

Retour -1;

We zijn op zoek naar de identifier van de uitgebreide sectie. Als die er is, berekenen we de offset naar de uitgebreide partitie en lezen we de informatie over de logische schijven:

voor (; ik< 4; i++) {

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

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

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

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

Read_ext_ptable (hard, zoeken);

Pauze;

Retour 0;

Read_main_ptable () functie voor het lezen van de partitietabel:

void read_main_ptable (int hard)

Als (lees (hard, mbr, 512)< 0) {

Perror ("lezen");

Sluiten (hard);

Afsluiten (-1);

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

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

Opbrengst;

Handtekeningcontrolefunctie check_sign ():

int check_sign ()

U16-teken = 0;

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

#ifdef DEBUG

Printf ("Handtekening - 0x% X \ n", teken);

#stop als

Als (teken! = HANDTEKENING) retourneert -1;

Retour 0;

Leesfunctie van uitgebreide partitietabel:

void read_ext_ptable (int hard, __u64 seek)

Int aantal = 4; // vanaf deze positie wordt de array van pt_t-structuren gevuld met informatie over logische schijven

U8 sbr;

Invoergegevens:

• moeilijk- apparaatbestandsbeschrijving;
• zoeken- offset naar de uitgebreide partitie vanaf het begin van de schijf (in bytes).

Om informatie over logische schijven te verkrijgen, organiseren we een cyclus:

Voor (;; aantal ++) (

We lezen de SMBR die zich op de offset-zoekopdracht bevindt vanaf het begin van de schijf:

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

Pread64 (hard, sbr, 512, zoeken);

We vullen twee elementen van de tabel pt_t, beginnend bij positie num. Het eerste item verwijst naar de logische schijfeenheid en het tweede naar de volgende SMBR-structuur:

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

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

We maken een wijziging in het veld "Nummer van de startsector" - het tellen is vanaf het begin van de schijf:

Pt_t.sect_before + = (zoeken / 512);

Als de partitietypecode nul is, zijn er geen logische schijven meer:

Als (! (Pt_t.type_part)) breken;

Bereken de offset naar de volgende SMBR:

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

Opbrengst;

De functie show_pt_info () geeft informatie weer over de gevonden logische stations op het apparaat:

ongeldig show_pt_info ()

Int i = 0, n;

#ifdef DEBUG

Printf ("Aantal partities op de schijf -% d \ n", PART_NUM);

#stop als

Voor (; i< MAX_PART; i++) {

Als (! Pt_t [i] .type_part) breken;

Printf ("\ nSectietype% d -", i);

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

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

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

Pauze;

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

Printf ("Opstartteken - 0x% X \ n", pt_t [i] .opstartbaar);

Printf ("Sectors in sectie% d -% d \ n", i, pt_t [i] .sect_total);

Printf ("Sektoren voor sectie% d -% d \ n \ n", i, pt_t [i] .sect_before);

Opbrengst;

Het lezen van bestandsclusters van een FAT32-partitie wordt uitgevoerd door de functie fat32_read_file (). Deze functie heeft veel gemeen met de fat16_read_file () functie, dus zie sectie 6 voor gedetailleerde opmerkingen:

int fat32_read_file (__ u8 * full_path, int num)

Struct split_name sn;

U8 tmp_name_buff;

Int i = 1, n;

U32 start_cluster, volgende_cluster;

U8 * tmp_buff;

Voorbereidende handelingen - wis de buffer, structuur en controleer de eerste schuine streep:

Memset (tmp_name_buff, 0, SHORT_NAME);

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

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

We lezen de bootsector:

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

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

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

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

We lezen de FSInfo-structuur en geven de handtekening weer die erin zit:

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

Printf ("Handtekening1 - 0x% X \ n", fsinfo.handtekening1);

Printf ("Handtekening2 - 0x% X \ n", fsinfo.handtekening2);

Fat32_size = fbs.fat32_length * 512; // FAT32-grootte in bytes

Data_start = 512 * fbs.reserved + fat32_size * 2; // begin van gegevensveld

Byte_per_cluster = fbs.cluster_size * 512; // clustergrootte in bytes

Root_cluster = fbs.root_cluster; // clusternummer van de hoofdmap

We lezen FAT32:

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

Wijs geheugen toe voor directory-items:

Dir_entry = (__u8 *) malloc (byte_per_cluster);

Als (! Dir_entry) retourneert -1;

We lezen de hoofdmap:

Als (leesmap (root_cluster)< 0) return -1;

We ontleden het volledige pad van het bestand en verdelen elk element in zijn componenten:

Terwijl (1) (

Memset (tmp_name_buff, 0, SHORT_NAME);

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

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

Tmp_name_buff [n] = volledig_pad [i];

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

ik ++;

Pauze;

Tmp_name_buff [n] = "\ 0";

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

Printf ("ongeldige naam \ n");

Retour -1;

Als (get_dentry (& sn)< 0) {

Printf ("Niet zo'n bestand! \ N");

Retour -1;

Om het startnummer van een cluster in het FAT32-bestandssysteem te krijgen, moet u het meest significante woord van het nummer van het eerste cluster van het bestand gebruiken - het starthi-veld van de dentry-structuur:

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

De attribuutbyte controleren:

If (dentry.attr & 0x10) (// dit is een directory

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

Doorgaan met;

If (dentry.attr & 0x20) (// en dit is een bestand

Tmp_buff = (__u8 *) malloc (byte_per_cluster);

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

Als (n< 0) {

Perror ("open");

Retour -1;

Printf ("eerste cluster van bestand - 0x% X ..", start_cluster);

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

Memset (tmp_buff, 0, byte_per_cluster);

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

Als (schrijf (n, tmp_buff, byte_per_cluster)< 0) {

Perror ("schrijven");

Retour -1;

Als (next_cluster == EOF_FAT32) (

Gratis (tmp_buff);

Sluiten (n);

Retour ++ i;

Start_cluster = volgende_cluster;

Retour ik;

Het doel van de volgende drie functies is om de inhoud van het systeemgebied te krijgen, d.w.z. opstartsector, FSInfo-structuur en FAT32-tabel:

1) de functie read_fbs () leest de opstartsector:

int read_fbs ()

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

Retour 0;

2) de functie read_fs_info () leest de FSInfo-structuur:

int read_fs_info ()

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

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

Retour 0;

3) de functie read_fat32 () leest de FAT32-tabel:

int read_fat32 ()

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

Fat32 = (void *) malloc (fat32_size);

Als (! Fat32) -1 retourneert;

Als (pread64 (hard, (__u8 *) fat32, fat32_size, seek)< 0) return -1;

Retour 0;

De functie read_cluster () leest het cluster met het opgegeven nummer:

int read_cluster (__ u32 cluster_num, __u8 * tmp_buff)

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

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

Retour 0;

Het lezen van mappen (inclusief de hoofdmap) wordt afgehandeld door de functie read_directory () :

int leesmap (__ u32 start_cluster)

Int i = 2;

U32 volgende_cluster;

Functieparameters - startende directorycluster. We lezen de inhoud van de directory in de globale buffer dir_entry:

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

Volgende_cluster = fat32;

Als de map één cluster in beslag neemt - sluit af, zo niet - vergroot de geheugengrootte en lees verder:

Voor (;; ik ++) (

Start_cluster = volgende_cluster;

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

Als (! Dir_entry) retourneert -1;

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

Volgende_cluster = fat32;

Als ((next_cluster == EOF_FAT32) || (next_cluster == 0xFFFFFF8)) retourneert 0;

Retour 0;

De laatste functie die we zullen bekijken, zoekt in de inhoud van een map naar een element dat overeenkomt met het bestand dat u zoekt:

int get_dentry (struct split_name * sn)

Int i = 0;

De dir_entry-aanwijzer is ingesteld op een geheugengebied dat een reeks directory-items bevat waarin we naar een bestand (of directory) gaan zoeken. Om te zoeken, organiseren we een cyclus en plaatsen we het gevonden record in de globale tandstructuur:

Voor (;; ik ++) (

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

Pauze;

Als (! Dentry.name) retourneert -1;

Retour 0;

Hiermee is de review van de module voor het lezen van een bestand van een FAT32-partitie afgerond.

De broncodes van de module bevinden zich in de FAT32-directory, bestand fat32.c.

Verschillen in de organisatie van het opslaan van bestandsrecords in mappen voor FAT- en EXT2-bestandssystemen

Een paar woorden over de verschillen in de organisatie van het opslaan van bestandsrecords in mappen voor FAT- en EXT2-bestandssystemen. De structuur van het EXT2-bestandssysteem werd besproken in.

We hebben net kennis gemaakt met FAT - daarin hebben alle elementen van de catalogus een vaste grootte. Bij het maken van een bestand zoekt het stuurprogramma van het bestandssysteem naar de eerste onbezette positie en vult deze met informatie over het bestand. Als de lengte van de directory niet in het ene cluster past, wordt er een ander cluster voor toegewezen, enz.

Laten we eens kijken hoe de dingen zijn in EXT2.

Stel dat we een partitie hebben met het EXT2-bestandssysteem, dan is de blokgrootte 4096 bytes. In deze sectie maken we een directory aan. De mapgrootte is gelijk aan de blokgrootte - 4096 bytes. Het besturingssysteem maakt onmiddellijk twee vermeldingen in de map aan: de vermelding voor de huidige map en de vermelding voor de bovenliggende map. Het huidige directory-item duurt 12 bytes, terwijl het bovenliggende item 4084 bytes is. Laten we een bestand maken in deze map. Daarna zal de directory drie items bevatten - het huidige directory-item is 12 bytes lang, het bovenliggende directory-item is al 12 bytes lang en het aangemaakte bestandsitem is, zoals je waarschijnlijk al vermoedde, 4072 bytes lang. Als we het aangemaakte bestand verwijderen, zal de lengte van het bovenliggende directory-item weer groeien tot 4084 bytes.

Dus bij het maken van een bestand, zoekt het EXT2-bestandssysteemstuurprogramma in de map naar een item met een maximale lengte en splitst het, zodat er ruimte ontstaat voor nieuwe invoer... Welnu, als er toch niet genoeg ruimte is, wordt er nog een blok aan de directory toegewezen en wordt de lengte van de directory gelijk aan 8192 bytes.

En tot slot - een kleine correctie op het artikel "Architectuur van het EXT2-bestandssysteem".

Deze herziening betreft de functie get_i_num () voor het bepalen van het inodenummer op bestandsnaam. Oude variant deze functie zag er als volgt uit:

int get_i_num (char * naam)

Int i = 0, rec_len = 0;

Struct ext2_dir_entry_2 deuk;

Voor (; i< 700; i++) {

Als (! Memcmp (dent.name, name, dent.name_len)) breken;

Rec_len + = deuk.rec_len;

Retour dent.inode;

Gecorrigeerde versie:

int get_i_num (char * naam)

* Functieparameter - bestandsnaam. De retourwaarde is het inodenummer van het bestand.

Int rec_len = 0;

Struct ext2_dir_entry_2 deuk; // deze structuur beschrijft het formaat van de root directory entry:

* De globale buff bevat een reeks directory-items. Om het serienummer van de inode van het bestand te bepalen, moet u zoeken naar:

* in deze array, een item met de naam van dit bestand. Hiervoor organiseren we een cyclus:

Voor (;;) (

/ * Kopieer directory-items in deukstructuur: * /

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

* De lengte van de bestandsnaam gelijk aan nul betekent dat we alle directory-items hebben opgesomd

* en records met de naam van ons bestand zijn niet gevonden. Dus het is tijd om terug te gaan:

Als (! Dent.name_len) retourneert -1;

/ * Zoeken wordt uitgevoerd door bestandsnamen te vergelijken. Als de namen overeenkomen, verlaat u de lus: * /

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

/ * Als de namen niet overeenkomen, gaat u naar het volgende item: * /

Rec_len + = deuk.rec_len;

/ * Indien succesvol, retourneer het inodenummer van het bestand: * /

Retour dent.inode;

Literatuur:

1. V. Kulakov. Hardwareprogrammering: een speciale referentie. 2e ed. / - SPb .: Peter, 2003 - 848 d.
2. AV Gordeev, A.Yu Molchanov. Systeemsoftware / - SPb .: Peter - 2002
3. Meshkov V. Architectuur van het ext2-bestandssysteem. - Tijdschrift " Systeem administrator", nr. 11 (12), november 2003 - 26-32 p.

In contact met

In dit artikel wordt het gebruik van verschillende bestandssystemen op externe opslagmedia besproken: flashdrives, geheugenkaarten, externe harde schijven, enz. Tegenwoordig worden dus de volgende bestandssystemen gebruikt voor schijven: ...

* FAT32
* NTFS
* exFAT

Laten we ze allemaal in detail doornemen en de voordelen, nadelen en kenmerken van gebruik op verschillende apparaten bekijken.

Een bestandssysteem gemaakt door Microsoft om de stervende FAT16 te vervangen. Momenteel het meest voorkomende systeem. De meeste geheugenkaarten en flashdrives worden geleverd in FAT32. Bovendien werkt het bij het formatteren van een medium in een consumentenapparaat, zoals een camera, in dit bestandssysteem. Dit is het belangrijkste voordeel: compatibiliteit. Door zo'n drive in een huishoudelijke dvd-speler, mediaspeler of fotoprinter te plaatsen, weet je zeker dat alle bestanden beschikbaar zijn en normaal kunnen worden gelezen. Dit is waar de profs eindigen.

Het belangrijkste nadeel van dit systeem is de beperking van de bestandsgrootte van 4 GB. Schrijf daarom groot bestand(bijvoorbeeld een back-up van de systeemschijf of een video die is overschreven vanaf een camera) zal niet werken. Bovendien heeft Windows een limiet van 32 GB voor de partitiegrootte. U kunt de laatste beperking omzeilen door het HP USB-hulpprogramma te downloaden Schijfopslag Format Tool, waarmee u elke externe harde schijf in FAT32 kunt formatteren.

Als u dergelijke grote bestanden echter niet hoeft op te nemen en over te dragen, en ook als u een klein mediaformaat heeft: 4, 8 of zelfs 16 GB, dan kunt u deze zonder aarzelen in FAT32 formatteren.
Overigens formatteert het bedrijf Transcend, dat mobiele datadragers produceert, zijn externe harde schijven in FAT32.

Een modern, betrouwbaar bestandssysteem dat teruggaat tot Windows NT.
In vaste computers en laptops verving het FAT32. Controleer of je nog steeds FAT32 hebt geïnstalleerd (klik op klik met de rechtermuisknop op de schijf in Deze computer en selecteer Eigenschappen), raad ik u ten zeerste aan deze te vervangen door NTFS.

Hoe FAT32 naar NTFS te converteren zonder gegevensverlies

Dit kan als volgt. Typ bij de opdrachtprompt (Start-Run)

converteer e: / fs: ntfs

In plaats van e: kunt u de vereiste schijf vervangen. Hierdoor wordt het bestandssysteem gewijzigd in NTFS geen gegevensverlies.

NTFS werkt echter iets anders op flashdrives en externe harde schijven. Bij het kopiëren naar een dergelijke schijf zet Windows het caching-mechanisme aan, wanneer bestanden eerst worden gekopieerd naar speciaal geheugen(de zogenaamde cache), en vervolgens naar de uiteindelijke media. Bij stationaire harde schijven kunt u hiermee een hogere kopieersnelheid behalen en vertragingen wegwerken. Op mobiele apparaten ziet het er zo uit. In het begin zal de kopieersnelheid erg hoog zijn en kan 100 MB / s bereiken (theoretisch gelijk aan de leessnelheid van de harde schijf waarvan u kopieert), en wanneer het cachegeheugen opraakt, daalt de snelheid tot een kritiek punt lage waarde. Bovendien moet het systeem, voordat het doorgaat met het kopiëren van het volgende bestand, het huidige uit de cache toevoegen. Daarom kan het lijken alsof de kopie vastzit op 99 procent, hoewel de indicator van de harde schijf activiteit aangeeft. Als we de kopieersnelheid met en zonder cache vergelijken, blijkt deze vrijwel identiek te zijn. Dat wil zeggen, bij het gebruik van NTFS verliezen we bijna niets, behalve de onjuiste kopieersnelheid en informatie over het tijdstip van voltooiing. Hoewel een deel van deze "informatieve inhoud" de zenuwen kan rafelen.

Dit is de kopieersnelheid die \ "ontwikkelt \"
USB 2.0 harde schijf in NTFS

NTFS \ "werkt wonderen \", kopiëren naar een flashstation van 512 MB,
waarvan de echte schrijfsnelheid enkele MB / s is

Aan de andere kant is NTFS een uiterst betrouwbaar bestandssysteem dat bestand is tegen meer dan één plotselinge reset. Deze betrouwbaarheid wordt geleverd door journaling. Hierdoor zal het systeem vaker toegang krijgen tot bepaalde delen van de schijf. Voor flashdrives en geheugenkaarten is deze benadering van cruciaal belang. Ze zullen sneller verslijten.

Nieuw bestandssysteem van Microsoft. In de eerste plaats ontworpen voor flashdrives. Overdrijvend kunnen we zeggen dat dit FAT32 is met verwijderde beperkingen. De grootte van bestanden en partities kan kosmische waarden bereiken en het aantal bestanden in één map is niet langer beperkt. Naar mijn mening ideaal voor flashdrives en geheugenkaarten.

Maar dit systeem heeft ook een nadeel. Veel consumentenapparaten ondersteunen het niet, en computers met Windows XP zullen dergelijke media ook niet zien. Microsoft heeft echter patch KB955704 uitgebracht om exFAT op Windows XP te kunnen gebruiken. Windows Vista en Windows 7 zijn vrienden met dit systeem zonder enige extra manipulatie.

Maar als u vaak een flashstation gebruikt verschillende computers als u Windows XP gebruikt, moet u een extra USB-flashstation met stuurprogramma's meenemen. Dit is gewoon belachelijk.

Maar als je alleen computers hebt met Windows 7 of als je een USB-flashdrive / schijf op slechts 2-3 plaatsen bij je hebt waar het mogelijk is om de bovenstaande update te installeren, dan is exFAT perfect.

Toevoeging
Het artikel is afkomstig uit open bronnen: http://winitpro.ru/index.php/2011/06/20/fajlovaya-sistema-exfat/
ExFAT-bestandssysteem

Samen met de release van Vista SP1 introduceerde Microsoft een nieuw bestandssysteem. ExFAT (Extended File Allocation Table) is de opvolger van het oude FAT32-bestandssysteem. Dus wat zijn de belangrijkste voor- en nadelen van het exFAT-bestandssysteem. Wat zijn de verschillen tussen exFAT en FAT32? En wanneer is het beter om exFAT over NTFS te gebruiken?

Het FAT32-bestandssysteem is een vrij oud en vertrouwd bestandssysteem, maar het heeft een aantal belangrijke nadelen: het ondersteunt geen partities groter dan 2 TB en bestanden groter dan 4 GB. Om de beschreven problemen in FAT32 op te lossen, is het exFAT-bestandssysteem gemaakt. ExFAT is Microsoft-ontwikkeling voornamelijk ontworpen voor mobiele media (flashdrives, SSD-drives, smartcards). Er moet meteen worden opgemerkt dat ExFAT niet wordt gebruikt om harde schijven te formatteren. Alles laatste versies Zowel Windows als Mac OS X ondersteunen dit bestandssysteem. ExFAT wordt ook vaak FAT64 genoemd, wat de mogelijkheid betekent om met schijven en bestanden te werken grotere maat.

De belangrijkste voordelen van het exFAT-bestandssysteem:

* Maximale clustergrootte verhoogd tot 32 MB
* Toegenomen maximumgrootte bestand in exFAT van 4GB tot 264 bytes (16 EB).
* Geen limiet op het aantal bestanden in een map
* Ondersteuning voor bestands- / maprechten
* Transactie-ondersteuning bij schrijven (indien ondersteund door fysiek apparaat)
* Effectief gebruik vrije ruimte, wat helpt om schijffragmentatie aanzienlijk te verminderen.

Het is vermeldenswaard dat bij het formatteren in exFAT de hoeveelheid beschikbare ruimte op opslagapparaten groter is dan bij gebruik van FAT32. Als u bijvoorbeeld een USB-stick van 4 GB (nominale capaciteit 4023 MB) formatteert in verschillende bestandssystemen, krijgt u het volgende:

* FAT32 - 4014 MB
* HFS + - 3997 MB
* NTFS - 3974 MB
* exFAT - 4022 MB

ExFAT is geoptimaliseerd voor het werken met flash-drives, zoals USB-flashdrives, geheugenkaarten en SSD-drives, de clustergrootte van 32 KB is zeer geschikt voor grote kaarten en apparaten met verhoogde slijtage bij het uitvoeren van lees-schrijfbewerkingen. Het exFAT-systeem heeft ook de mogelijkheid om toegangsrechten tot bestanden / mappen te beheren en de toegangstijd tot gegevens is afgenomen. Een van de belangrijkste nadelen van het exFAT-systeem is dat deze technologie wordt gedekt door het Microsoft-licentiebeleid en op geen enkele manier open source beslissingen, kan het niet worden toegepast. Om het in elk besturingssysteem te gebruiken, moet u licentiekosten betalen aan Microsoft (deze regel is niet van toepassing op simple mobiele toestellen zoals camera's, spelers, enz.).

exFAT op moderne Windows 7-besturingssystemen

De nieuwe versie van Microsoft Windows 7 ondersteunt het exFAT-bestandssysteem en al zijn functies volledig in zowel 32- als 64-bits versies. Bovendien kunnen externe flashdrives die in exFAT zijn geformatteerd, worden gebruikt om met ReadyBoost-technologie te werken (en er zal geen limiet van 4 GB meer zijn).

Windows Vista

Windows Vista ondersteunt alleen exFAT vanaf Service Pack 1. Daarnaast worden sommige functies, zoals toegangscontrole, ook niet ondersteund. In tegenstelling tot Windows 7 worden exFAT-apparaten in Vista niet ondersteund voor ReadyBoost.

Windows XP

ExFAT wordt niet ondersteund in Windows XP, maar het stuurprogramma kan worden gedownload van de Microsoft-website (beschrijving in KB 9555704 - http://support.microsoft.com/kb/955704), maar hiervoor moet Service Pack 2 worden geïnstalleerd .

Voor oudere versies van Windows is er geen officiële ondersteuning voor exFAT.

Windows-server

ExFAT wordt volledig ondersteund op Windows Server 2008 en door de bovenstaande driver ook op Windows Server 2003 te installeren.

Sneeuwluipaard

Mac OS X ondersteunt exFAT sinds versie 10.6.4 (15 juni 2010), maar alleen op Macs met een SDXC-kaartlezer. Mac mini en iMac zijn exFAT-compatibel.

Linux-systemen ondersteunen geen exFAT, hoewel er verschillende oplossingen zijn, maar de meeste zijn betaald of onhandig, bovendien steekt Microsoft met zijn eigen licentie een spaak in de wielen van onafhankelijke ontwikkelaars.

ExFAT en FAT32

Bij testen op Windows 7 vertoonde het dezelfde prestaties als FAT32, maar NTFS is nog steeds iets sneller. Zal exFAT FAT32 vervangen? Dit zal waarschijnlijk pas gebeuren na een massale upgrade naar Windows 7 of nieuwere versies van Windows. Voor consumenten is het belangrijkste voordeel van exFAT het overwinnen van de FAT32-bestandsbeperkingen (het vergroten van de bestandsgrootte in exFat).

We moeten ook onthouden dat het exFAT-bestandssysteem een ​​nieuwere versie van het besturingssysteem vereist (hardware-upgrade kan nodig zijn), evenals het feit dat exFAT gewoon niet wordt ondersteund op oudere apparaten (camera's, mp3-spelers).

exFat of NTFS

ExFAT kan worden beschouwd als een concurrent van NTFS op systemen met beperkte verwerkingskracht en geheugen. Bovendien is het NTFS-bestandssysteem op flash-kaarten erg onhandig en ineffectief in gebruik (de werksnelheid neemt af en de levensduur van flash-geheugen), en het is ExFAT dat het ideale bestandssysteem zal zijn voor dergelijke apparaten.

Tot slot zal ik er een paar geven algemene aanbevelingen door het meest geschikte bestandssysteem te kiezen. Als je een kleine flashdrive hebt, formatteer deze dan naar FAT32. Formatteer flashdrives met exFAT, aangezien "snelheidssprongen" vooral op hen zullen opvallen. Externe harde schijven zijn meestal groot en performant (vooral die met USB-aansluitingen 3.0), dus het is het beste om ze te formatteren met NTFS.

Het artikel is afkomstig uit open bronnen: http://pc-hard.ru/softarticles/1-fat32-ntfs-exfat-comparsion.html

Laten we eens kijken naar de soorten bestandssystemen voor een flashstation, welke beter is. Een gebruiker stuurde me een foto met de foutmelding "Het bestand is te groot voor het doelbestandssysteem" en besloot een artikel te schrijven in welke gevallen men FAT32-, NTFS- en exFAT-systemen zou moeten gebruiken. Hij verplaatste een bestand groter dan 4 GB naar een 8 GB-stick. Het feit is dat het FAT32-systeem geen informatie van meer dan 4 GB kan verwerken, als uw flashstation een volume van 32 GB heeft en het bestandssysteem FAT32 is, dan kunt u er geen bestand van meer dan 4 GB naar schrijven. Laten we eens kijken naar alle drie de bestandssystemen in Windows, laten we eens kijken naar hun voor- en nadelen.

FAT32

De oude bestandssysteemmodus, die meestal wordt gebruikt bij het kopen van een USB-flashstation in een winkel, en de reden hiervoor is compatibiliteit. Compatibiliteit is dat FAT32 kan worden gebruikt op elke MAC, Windows, Linux, oude pc's. De grootste beperking is dat het een bestandsgroottelimiet van 4 GB heeft, die tegenwoordig problemen heeft met formaten zoals 4k-video, Blu-ray. Kortom, ga je met bestanden werken die kleiner zijn dan 4 GB en wordt de flashdrive op verschillende computers met verschillende besturingssystemen gebruikt, dan is het FAT32 bestandssysteem zeer geschikt.

exFAT

Bijgewerkt bestandssysteem gemaakt door microsoft om FAT32 te vervangen. Begonnen met Windows Vista SP1 en heeft een maximale bestandsgrootte van 16 exabytes (EB), dat is 1 EB = 10 18 bytes. Compatibel met Mac OS en Windows, het is een zeer goed systeem voor het uitwisselen van grote bestanden.

minpuntjes:

• Het heeft geen enkele logfunctie waarbij alle wijzigingen aan bestanden op de schijf worden vastgelegd voordat ze daadwerkelijk worden uitgevoerd.
• Niet ondersteund door Time Machine bij Apple. Kortom, u kunt geen back-up van Apple maken met Time Machine-software.
• Een zeer complexe structuur die meer rekenkracht vereist.

Voordelen:

• Overschrijft dezelfde sector minder vaak, wat belangrijk is voor flashdrives, waardoor de levensduur van geheugencellen wordt verlengd. Zoals u weet, hebben flashdrives een N-aantal herschrijvingen en mislukken dan.
• Maximale bestandsgrootte van 16 exabytes.
• De clustergrootte is 32 megabyte.
• Verbeterde toewijzing van vrije ruimte, waardoor schijfdefragmentatie wordt verminderd.

NTFS

Nieuwste bestandssysteem gemaakt door Microsoft en is een moderne structuur vandaag voor bijna elke moderne interne harde schijf, flash drive of ssd drive. NTFS is een nieuwe bestandssysteemtechnologie. Windows kan alleen op NTFS worden geïnstalleerd. Het is de standaard voor schijven van besturingssystemen vanwege zijn veelzijdigheid. Het heeft alle Microsoft-technologieën: logboekregistratie, geen bestandsgroottelimiet, ondersteuning voor bestandscompressie, lange namen, bestandstoegangscontrole voor serverbeheerders en nog veel meer. Thuis is dit de beste optie om dit systeem op schijven en flashdrives te gebruiken. Er is één nadeel: wanneer u een USB-flashstation in Mac OS plaatst, kunt u informatie van een USB-flashstation kopiëren, maar geen verandering.

Uitgang:

Voor USB-sticks moet u gebruiken exFAT, als u zich constant in de Mac OS-, Windows-omgeving bevindt en de USB-flashdrive van het ene besturingssysteem naar het andere verplaatst. Gebruik je alleen Windows, dan is NTSF een prima oplossing.

vfat is een implementatie van MS-DOS FAT / FAT32-bestandssystemen in Linux. man berg (8)

Een typische set vfat-mount-opties voor een UTF-8-landinstelling (opties weglaten, waarvan de standaardwaarde verouderd is):

uid = gebruikersnaam, gid = groepsnaam, fmask = 0113, dmask = 0002, codepagina = 866, utf8, korte naam = winnt, stil

Voor een niet-UTF8-landinstelling, en dit is hoogstwaarschijnlijk een KOI8-R-landinstelling (niet te vergeten nu de "utf8 = no" verplicht voor RHEL / CentOS):

uid = gebruikersnaam, gid = groepsnaam, fmask = 0113, dmask = 0002, codepage = 866, iocharset = koi8-r, utf8 = nee, korte naam = winnt, stil

of overwegende dat "uni_xlate" "utf8" uitschakelt, des te beter is het om de gecodeerde namen van bestanden / mappen te zien waarmee u op de een of andere manier kunt omgaan dan niet te onderscheiden regels van "?":

uid = gebruikersnaam, gid = groepsnaam, fmask = 0113, dmask = 0002, codepage = 866, iocharset = koi8-r, uni_xlate, korte naam = winnt, stil

gebruikersnaam en groepsnaam - gebruikersnamen en groepsnamen die lees-/schrijftoegang krijgen tot de aangekoppelde FAT / FAT32-partitie in overeenstemming met de ingestelde fmask en dmask

De algemene aankoppelopties variëren afhankelijk van of u via de opdrachtregel aankoppelt of door te schrijven naar / etc / fstab, of dat u automatisch moet koppelen in boot-, rw / ro-modus, of dat gebruikers een partitie moeten aankoppelen / ontkoppelen. Algemeen gebruikt: rw, asynchrone
Om veiligheidsredenen kunt u voor FAT/FAT32-partities expliciet het volgende specificeren: nodev, nosuid, noexec
Om te versnellen, kunt u gebruik maken van: noatime, nodiratime

Mount opties staan ​​vermeld in man mount (8) onder "Mount opties voor vet" en "Mount opties voor vfat".
Montageopties voor vet
=====================

blokgrootte = 512 / blokgrootte = 1024 / blokgrootte = 2048
Stel blokgrootte in (standaard 512).
I / O-blokgrootte.

uid = waarde en gid = waarde
Stel de eigenaar en groep van alle bestanden in. (Standaard: de uid en gid van het huidige proces.)

Aangezien FAT / FAT32 eigendom en toegang tot bestanden en mappen niet ondersteunt, zijn alle
de partitie is standaard gemount met de uid en gid van de proceseigenaar
montage. U kunt de gewenste gebruiker en groep opgeven namens welke
de FAT / FAT32-partitie wordt gemount. Dit kunnen numerieke waarden van identifiers zijn
dus en gebruikers- / groepsnamen, in ieder geval vanaf de opdrachtregel is er een eenvoudige
gebruikers-/groepsnaam instellen.

umask = waarde
Stel de umask in (het bitmasker van de rechten die niet aanwezig zijn). De standaard is de umask
van het huidige proces. De waarde wordt gegeven in octaal.

dmask = waarde
Stel de umask alleen in op mappen. De standaard is de umask van het huidige proces.
De waarde wordt gegeven in octaal.

fmask = waarde
Stel de umask alleen in op gewone bestanden. De standaard is de umask van het huidige proces.
De waarde wordt gegeven in octaal.

umask, dmask, fmask - permissiemaskers voor bestanden / mappen (umask) of afzonderlijk voor
mappen (dmask) en afzonderlijk voor bestanden (fmask). In feite worden door hen rechten gevestigd
eigenaar (u), groep (g) en andere gebruikers (o) voor alle bestanden en mappen op de mount
sectie vfat. Gespecificeerd als een octaal getal. (Trouwens, het schrijven van de octale waarde
hoeft niet bij nul te beginnen.)

check = waarde
Er kan worden gekozen voor drie verschillende niveaus van kieskeurigheid:
R
Hoofdletters en kleine letters worden geaccepteerd en equivalent, lange naamdelen worden afgekapt
(bijv. verylongname.foobar wordt verylong.foo), leidende en ingesloten spaties zijn
geaccepteerd in elk naamgedeelte (naam en extensie).
N
Zoals "relaxed", maar veel speciale tekens (*,?, Dit is de standaard.
s
Zoals "normaal", maar namen mogen geen lange delen en speciale tekens bevatten die
worden soms gebruikt op Linux, maar worden niet geaccepteerd door MS-DOS worden afgewezen.
(+, =, spaties, enz.)

Regelt de controle van de gegenereerde bestands- / mapnamen op de vfat-partitie om overeen te komen
FAT / FAT32 regels en beperkingen. De standaardwaarde is "n".

codepagina = waarde
Stelt de codetabel in voor het converteren naar korte naamtekens op FAT- en VFAT-bestandssystemen.
Standaard wordt codetabel 437 gebruikt.

Het is beter om de parameter mount op te geven. Stelt de dos-codepagina in waarin:
de gemaakte korte (in 8.3-indeling) DOS-bestands- en directorynamen worden opgeslagen.
Voor degenen die nog steeds in DOS werkten en het hebben opgezet, mag dit cijfer niet worden vergeten - voor een normale
Russische namen lezen / opslaan - codepagina = 866

conv = b / conv = t / conv = a
Het vette bestandssysteem kan CRLFNL-conversie (MS-DOS-tekstindeling naar UNIX-tekstindeling) uitvoeren
in de kern. De volgende conversiemodi zijn beschikbaar:
binair - Er wordt geen vertaling uitgevoerd. Dit is de standaardinstelling.
tekst - CRLFNL-vertaling wordt uitgevoerd op alle bestanden.
auto - CRLFNL-vertaling wordt uitgevoerd op alle bestanden die geen "algemeen"
binaire "extensie. De lijst met bekende extensies vindt u aan het begin
van fs / fat / misc.c (vanaf 2.0 is de lijst:
exe, com, bin, app, sys, drv, ovl, ovr, obj, lib, dll, pif, arc, zip, lha, lzh,
dierentuin, teer, z, arj, tz, taz, tzp, tpz, gz, tgz, deb, gif, bmp, tif, gl, jpg, pcx,
tfm, vf, gf, pk, pxl, dvi).
Programma's die wel berekende lseeks doen, houden niet van in-kernel tekstconversie.
Verschillende mensen hebben hun gegevens verpest door deze vertaling. Pas op!
Voor bestandssystemen die in binaire modus zijn gemonteerd, is een conversietool (fromdos / todos) beschikbaar.

Pogingen om de overdracht van tekstbestanden van UNIX-achtige systemen naar MS-DOS te vergemakkelijken door middel van automatische
vervangt CRLFNL on the fly. Het is beter om, indien nodig, de opdracht voor specifieke bestanden te gebruiken
hulpprogramma's voor het converteren van dos2unix en unix2dos uit de pakketten met dezelfde naam, of de universele iconv
inbegrepen in het glibc-common-pakket.

cvf_format = module
Dwingt de driver om de CVF (Compressed Volume File) module cvf_module te gebruiken in plaats van
automatische detectie. Als de kernel kmod ondersteunt, regelt de optie cvf_format = xxx ook

cvf_option = optie
Optie doorgegeven aan de CVF-module.

cvf_format, cvf_option - parameters die een specifieke CVF-module en zijn opties aangeven
voor het laden door de kernel. Ik wil niet begrijpen wat het is.

debuggen
Schakel de foutopsporingsvlag in. Er wordt een versiereeks en een lijst met bestandssysteemparameters afgedrukt
(deze gegevens worden ook afgedrukt als de parameters inconsistent lijken).

Afgaande op de beschrijving, wordt de uitvoer van een regel met de versie en parameters van het bestandssysteem ingeschakeld wanneer:
een FAT / FAT32-partitie aankoppelen.

vet = 12 / vet = 16 / vet = 32
Geef een 12, 16 of 32 bit vet op. Dit heft de automatische detectieroutine van het FAT-type op.
Voorzichtig gebruiken!

In plaats van het FAT-type automatisch te detecteren, kunt u er een specifieke versie van specificeren.

iocharset = waarde
Tekenset die moet worden gebruikt voor het converteren tussen 8-bits tekens en 16-bits Unicode-tekens.
De standaardwaarde is iso8859-1.
Lange bestandsnamen worden op schijf opgeslagen in Unicode-indeling.

Deze parameter moet worden opgegeven als een niet-UTF8-gebruiker/systeemlandinstelling wordt gebruikt.
Zoals geschreven, worden lange bestands- en directorynamen opgeslagen in de VFAT-sectie in Unicode-indeling.
Om ervoor te zorgen dat bij het overzetten naar een niet-UTF8-geconfigureerde landinstelling van de gebruikerstoepassing,
Unicode-tekens zijn geconverteerd naar een acht-bits code die geschikt is voor deze landinstelling, u moet
stel de vereiste iocharset-transformatietabel in.
Standaard, indien niet gespecificeerd, iocharset = ascii, d.w.z. lange namen worden aangenomen
bestanden / mappen bestaan ​​uit tekens uit de ASCII-set, waarvoor de triviale
(één-op-één) omzetten van Unicode ASCII-codes.
Voor de KOI8-R-landinstelling moet u een tabel specificeren voor het converteren van tekens naar KOI8-R-codes van tekens
Unicode - iocharset = koi8-r (zie /usr/share/i18n/charmaps/KOI8-R.gz).
De iocharset-toewijzing is alleen zinvol als het systeem (of voor een specifieke gebruiker,
waarvoor de partitie wordt aangekoppeld) gebruikt een niet-UTF8-landinstelling.
Voor UTF-8 locale, sla de iosharset optie over en mount de partitie met een special
ontworpen voor deze gelegenheid standalone optie"utf8" (zie beschrijving hieronder).

stil
Zet de stille vlag aan. Pogingen tot chown- of chmod-bestanden leveren geen fouten op, hoewel ze mislukken.
Voorzichtig gebruiken!

Onderdrukt foutmeldingen bij het "chownen" of "chmod" bestanden op een partitie
VET / FAT32. In het algemeen, hoewel ze waarschuwen om deze optie met de nodige voorzichtigheid te gebruiken, doet het dat wel
dagelijks werk met vfat-partities handiger, applicatieverzoeken transparant overslaan
om niet-ondersteunde FAT / FAT32-functies uit te voeren die van tijd tot tijd constant verschijnen.
Bijvoorbeeld bij het maken van een back-up van een bewerkt bestand in gedit of bij het gebruik van rsync
met de gebruikelijke "-a" optie. U hoeft alleen te onthouden dat de partitie waarmee u werkt FAT / FAT32 is en dat
houd er rekening mee dat de bestanden die erop worden geplaatst altijd de eigenaar en de opgegeven toegangsmodus krijgen
bij montage. Bij het ontbreken van deze optie moet je dit ook onthouden, omdat constant
u krijgt fouten tijdens de back-upbewerking (u moet bijvoorbeeld speciaal rsync-opties registreren)
of waarschuwingen bij het verplaatsen van bestanden vanwege de onmogelijkheid om hun eigenaar en tijd te wijzigen.
Voorzichtigheid is geboden wanneer u het tegenovergestelde doet - bestanden ophalen van vfat-partities
met eigen installatie.

sys_immutable, showexec, dots, nodots, dotsOK =
Verschillende misplaatste pogingen om Unix- of DOS-conventies op een FAT-bestandssysteem te forceren.

Diverse pogingen, met wisselend succes, om Unix- en DOS-conventies voor
FAT-bestandssysteem. Een voorbeeld en beschrijving van het gebruik van de parameter "showexec" is te vinden in dit een van de zeldzame artikelen die geen foutieve informatie bevat: http://citkit.ru/articles/147/

Mount opties voor vfat
======================

uni_xlate
Vertaal onverwerkte Unicode-tekens naar speciale escape-reeksen. Hiermee kunt u een back-up maken
en herstel bestandsnamen die zijn gemaakt met Unicode-tekens. Zonder deze optie,
een '?' wordt gebruikt als er geen vertaling mogelijk is. Het escape-teken is ’:’ omdat het is
anders illegaal op het vfat-bestandssysteem. De escape-reeks die wordt gebruikt, waarbij u is
het unicode-teken is: ':', (u & 0x3f), ((u >> 6) & 0x3f), (u >> 12).

Het is te handige optie wanneer u werkt in een niet-UTF8-landinstelling. In lange bestands- / mapnamen
alle Unicode-tekens kunnen worden gevonden, inclusief degenen die niet in die set van 256 . vallen
tekens, die is opgegeven in de conversietabel in de parameter iocharset =. dergelijke symbolen
weergegeven als '?', of indien opgegeven deze optie ze lijken speciaal te zijn
ontsnappingsreeksen. Het escape-teken is een dubbele punt ':' omdat het verboden is
in DOS-namen en komt er zeker nooit in voor. Mogelijk met dit ingeschakeld
opties kunnen worden gemanipuleerd met bestanden waarvan de naam een ​​van de Unicode-tekens bevat.
De namen zien er grappig uit: er wordt bijvoorbeeld een bestand met de naam "test" getoond
zoals ": 0442: 0435: 0441: 0442". Een bestand met deze naam kan worden aangemaakt, gekopieerd,
schrijf, hernoem bijvoorbeeld naar ": 0442: 0435: 0441: 0441", en dit wordt de DOS-naam "tess".
Maar bijvoorbeeld mappen synchroniseren met dergelijke escape-reeksen in de naam
het gebruik van rsync zal niet werken, uiteraard omdat rsync niets weet over soortgelijke
naam conversies.

positief
Sta twee bestanden toe met namen die alleen verschillen in hoofdletters.

Maakt het mogelijk om twee bestanden te maken waarvan de namen alleen verschillen in het geval dat.

nonumtail
Probeer eerst een korte naam te maken zonder volgnummer, voordat je naam ~ num.ext probeert.

Bij het maken van een korte do-naam probeert het deze eerst te maken zonder de gebruikelijke tildes
met een cijfer aan het einde van de naam.

utf8
UTF8 is de bestandssysteemveilige 8-bits codering van Unicode die door de console wordt gebruikt.
Met deze optie kan het voor het bestandssysteem worden ingeschakeld.
Als 'uni_xlate' wordt ingesteld, wordt UTF8 uitgeschakeld.

Schakelt UTF-8-codering van Unicode-tekens in wanneer doorgegeven aan aangepaste toepassingen
werken in UTF-8-landinstellingen. Uiteraard is dit wat nodig is onder normale omstandigheden.
Als de optie "uni_xlate" is ingesteld, is de optie "utf8" uitgeschakeld.

Theoretisch kun je in een UTF-8-landinstelling de optie "utf8" niet gebruiken, maar stel iocharset = utf8 in.
In de fs / fat / inode.c bronnen zien we de volgende waarschuwing:
1105 / * UTF-8 biedt geen FAT-semantiek * /
1106 if (! Strcmp (opts-> iocharset, "utf8")) (
1107 printk (KERN_ERR "FAT: utf8 is geen aanbevolen IO-tekenset"
1108 "voor FAT-bestandssystemen is het bestandssysteem hoofdlettergevoelig! \ N");
1109 }
korte naam =
Definieert het gedrag voor het maken en weergeven van bestandsnamen die passen in 8,3 tekens.
Als er een lange naam voor een bestand bestaat, zal deze altijd de voorkeur hebben voor weergave. Er zijn vier modi:
lager - Forceer de korte naam in kleine letters bij weergave;
win95 - Forceer de korte naam in hoofdletters bij weergave;
sla een lange naam op als de korte naam niet alleen uit hoofdletters bestaat.
winnt - Toon de korte naam zoals deze is;
sla een lange naam op als de korte naam niet alleen uit kleine letters of alleen uit hoofdletters bestaat.
gemengd - Toon de korte naam zoals deze is;
sla een lange naam op als de korte naam niet alleen uit hoofdletters bestaat.
De standaard is "lager".

Bepaalt hoe de namen van bestanden en mappen op zichzelf worden gemaakt en weergegeven
zijn in 8.3-formaat. Als er een lange naam voor het bestand bestaat, wordt deze weergegeven,
sinds heeft altijd voorrang. Er zijn vier modi zoals beschreven. De standaard is "lager".
Het lijkt natuurlijker om "winnt" te gebruiken.

Na het aankoppelen van de partitie kun je de opties waarmee deze is aangekoppeld controleren door middel van "cat / proc / mounts".

Een bijzonderheid valt op in RedHat / CentOS: een vfat-partitie wordt altijd aangekoppeld met de optie "utf8" ingeschakeld, zelfs als deze niet is opgegeven op de opdrachtregel. Dit gebeurt ook in niet-UTF8-landinstellingen, wat ertoe leidt dat bestandsnamen die bestaan ​​uit niet-ascii-tekens onjuist worden weergegeven (zoals het er meestal uitziet wanneer u probeert een Unicode-tekenreeks uit te voeren met behulp van een codetabel van 256 acht-bits tekens). Dit is het resultaat van de Anaconda bug-patch https://bugzilla.redhat.com/show_bug.cgi?id=181963, toen we in plaats van een fout in de installatie-instellingen te herstellen, we gewoon de kernel hebben gepatcht zodat standaard vfat-partities werden gemonteerd met de optie "utf8" ingeschakeld, dat wil zeggen .To. typ allemaal hetzelfde al een lange tijd werkt alleen in UTF-8-landinstellingen. Maar tegelijkertijd vergaten ze in de man-pagina te vermelden hoe je deze optie kunt uitschakelen https://bugzilla.redhat.com/show_bug.cgi?id=515149

In dezelfde fs / fat / inode.c kun je de ongedocumenteerde parameters zien die kunnen worden ingesteld om opties te besturen, inclusief om "utf8" uit te schakelen:
905 statische match_table_t vfat_tokens = (
906 (Opt_charset, "iocharset =% s"),
907 (Opt_shortname_lower, "korte naam = lager"),
908 (Opt_shortname_win95, "korte naam = win95"),
909 (Opt_shortname_winnt, "shortname = winnt"),
910 (Opt_shortname_mixed, "korte naam = gemengd"),
911 (Opt_utf8_no, "utf8 = 0"), / * 0 of nee of onwaar * /
912 (Opt_utf8_no, "utf8 = nee"),
913 (Opt_utf8_no, "utf8 = false"),
914 (Opt_utf8_yes, "utf8 = 1"), / * leeg of 1 of ja of waar * /
915 (Opt_utf8_yes, "utf8 = ja"),
916 (Opt_utf8_yes, "utf8 = true"),
917 (Opt_utf8_ja, "utf8"),
918 (Opt_uni_xl_no, "uni_xlate = 0"), / * 0 of nee of false * /
919 (Opt_uni_xl_no, "uni_xlate = nee"),
920 (Opt_uni_xl_no, "uni_xlate = false"),
921 (Opt_uni_xl_yes, "uni_xlate = 1"), / * leeg of 1 of ja of waar * /
922 (Opt_uni_xl_yes, "uni_xlate = yes"),
923 (Opt_uni_xl_yes, "uni_xlate = true"),
924 (Opt_uni_xl_yes, "uni_xlate"),
925 (Opt_nonumtail_no, "nonumtail = 0"), / * 0 of nee of false * /
926 (Opt_nonumtail_no, "nonumtail = nee"),
927 (Opt_nonumtail_no, "nonumtail = false"),
928 (Opt_nonumtail_yes, "nonumtail = 1"), / * leeg of 1 of ja of waar * /
929 (Opt_nonumtail_yes, "nonumtail = ja"),
930 (Opt_nonumtail_yes, "nonumtail = true"),
931 (Opt_nonumtail_ja, "nonumtail"),
932 (Opt_err, NULL)
933 };

Je hebt vast wel eens gehoord van bestandssystemen zoals: FAT32, NTFS en exFAT... Maar wat is het verschil tussen hen? Elk type heeft zijn eigen eigen set voors en tegens. Daarom is er niet één optie. In dit artikel zullen we de belangrijkste verschillen tussen de drie bestandssystemen opsplitsen.

Over het Windows-besturingssysteem gesproken, we weten zeker dat het alleen op een logische partitie in NTFS-indeling is geïnstalleerd. Verwisselbare schijven en andere op USB gebaseerde opslagapparaten gebruiken het FAT32-type.

Een van de formaten die gebruikt kunnen worden om Flash-drives te formatteren is exFAT, de opvolger van het oude FAT32-bestandssysteem.

We hebben dus drie hoofdformaten voor gegevensopslag die vaak worden gebruikt voor zowel Windows als voor verschillende soorten opslagmedia.

Wat is een bestandssysteem?

Een bestandssysteem is een reeks regels die bepalen hoe documenten die op een apparaat zijn opgeslagen, worden opgeslagen en opgehaald. Dit kan een harde schijf, flashstation of SD-kaart zijn.

Laten we voor een beter begrip als voorbeeld het kantoor van een gewoon bedrijf nemen. Fragmenten van geïnstalleerde documenten worden op een bepaalde plaats bewaard, bijvoorbeeld in een bureaulade. En wanneer het nodig is om ze te openen, opent het bestandssysteem de bestanden in een poging om informatie te lezen.

Handige artikelen

Laten we even aannemen dat zo'n systeem niet werkt en we onmiddellijk een enorme hoeveelheid niet-geïdentificeerde gegevens krijgen, die we niet kunnen bestuderen.

In feite zijn er een groot aantal bestandssystemen, bijvoorbeeld Flash Bestandssysteem, Tape File System en Disk File System, we zullen ons echter alleen concentreren op de belangrijkste - FAT32, NTFS en exFAT.

Wat is FAT32

Het FAT32-bestandssysteem is het oudste en meest ervaren in de geschiedenis van computertechnologie. Zijn reis begon met het originele 8-bits FAT-systeem in 1977, dat functioneerde in een autonome schijf. Microsoft Standalone Disk Basic-80... Het is speciaal gelanceerd voor Intel 8080 NCR 7200 in 1977/1978, werkend als een data-entry terminal met 8-inch diskettes.

Na gesprekken over de introductie van het systeem met Microsoft-oprichter Bill Gates, werd de code geschreven door de eerste medewerker van het bedrijf, Mark MacDonald.

De belangrijkste taak van het FAT-bestandssysteem was om te werken met gegevens in het Microsoft 8080/Z80-besturingssysteem op basis van het MDOS/MIDAS-platform, geschreven door Mark MacDonald.

In de toekomst heeft FAT enkele veranderingen ondergaan, waarbij het geleidelijk overging van zijn oorspronkelijke vorm naar FAT12, FAT16 en ten slotte FAT32, waarvan de naam nu nauw verbonden is met externe schijven.

Het belangrijkste verschil tussen FAT32 en zijn voorgangers is het overwinnen van de beperkte hoeveelheid informatie die beschikbaar is voor opslag. 32-bits Het systeem werd uitgebracht in augustus 1995 met de release van Windows 95 en verhoogde in de update de bovengrenzen voor bestands- en opslaggroottes tot 4 GB en 16 TB.

FAT32 is dus niet ontworpen voor het opslaan van grote hoeveelheden gegevens en het installeren van zware applicaties. Het is om deze reden dat het bestandssysteem wordt gebruikt op harde schijven. NTFS waarmee gebruikers kunnen stoppen met nadenken over de hoeveelheid informatie die wordt gedownload.

Samenvattend is het FAT32-systeem ideaal voor het opslaan van gegevens die niet groter zijn dan 4 GB op verwisselbare media. Zijn populariteit is niet alleen beperkt tot het computerveld. Het wordt gebruikt in gameconsoles, tv's met hoge kwaliteit afbeeldingen, dvd-spelers, Blu-ray-spelers en alle andere apparaten met een USB-poort. FAT32 wordt ondersteund door alle versies van Windows, Linux en MacOS.

Wat is NTFS

In 1993 introduceerde Microsoft een nieuw bestandssysteem NTFS(New Technology File System) parallel met de opkomst van het besturingssysteem Windows NT 3.1.

Het belangrijkste kenmerk van het NTFS-systeem is de afwezigheid van beperkingen op de grootte van geüploade bestanden. Zelfs als we probeerden deze limiet te overschrijden, zouden we gefaald hebben - het is zo geweldig.

De ontwikkeling begon in het midden van de jaren tachtig tijdens een samenwerking tussen Microsoft en IBM, met als doel een nieuw besturingssysteem te creëren dat de vorige overtreft op het gebied van grafische prestaties.

Toch duurde de unie van de twee bedrijven niet lang en, zonder het gemeenschappelijke project af te ronden, besloten ze de samenwerking te beëindigen. Vervolgens concentreerden Microsoft en IBM zich op het maken van hun eigen bestandssystemen.

Voor computertechnologie zag 1989 de oprichting van IBM's HPFS, die werd gebruikt voor het OS / 2-besturingssysteem. Een paar jaar later, in 1993, lanceerde Microsoft NTFS v1.0 dat het officiële bestandssysteem voor Windows NT 3.1 werd.

De theoretische NTFS-bestandsgrootte is 16 EB - 1 KB, dat is 18 446 744 073 709 550 502 bytes. Het ontwikkelingsteam bestond uit Tom Miller, Harry Kimura, Brian Andrew, David Gebel.

De volgende versie van het bestandssysteem was NTFS v3.1 speciaal gelanceerd voor Microsoft Windows XP. In de toekomst heeft het geen speciale veranderingen ondergaan, hoewel er veel verschillende toevoegingen aan zijn gedaan. Zo verscheen de mogelijkheid om logische partities, herstel en symbolische NTFS-koppelingen te comprimeren. Bovendien was de initiële capaciteit van het bestandssysteem slechts 256 MB van de maar liefst 16 EB - 1 KB in nieuwere versies die werden gelanceerd met de release van Windows 8.

Enkele van de handige functies die in NTFS v3.1 zijn geïntroduceerd, zijn de uitbreiding van ondersteunde bestandsindelingen, quota voor schijfgebruik, bestandscodering en reparse-punten. Opvallend is het feit dat de nieuwere versies van NTFS volledig compatibel zijn met de vorige.

Het NTFS-bestandssysteem heeft een belangrijke functie als het gaat om het herstellen van elke vorm van schade. Het bevat een specifieke gegevensstructuur die eventuele wijzigingen in het systeem bijhoudt en waarmee u NTFS altijd weer aan het werk kunt zetten.

Dit bestandssysteem wordt ondersteund door alle versies van Windows vanaf Windows XP. Helaas deelt macOS niet de compatibiliteitsschijf die wordt gepromoot door Microsoft. Apple heeft gebruikers de mogelijkheid gegeven om gegevens van NTFS-schijven te lezen, maar ze kunnen er niet naar schrijven. Ondersteuning voor dit bestandssysteem van Linux is beperkt tot slechts enkele van zijn versies.

Wat is exFAT

ExFAT(Extended FAT) is een nieuw, uitgebreid bestandssysteem van Microsoft dat met succes zijn voorganger in het veld vervangt als het gaat om grote hoeveelheden informatie.

Zoals u waarschijnlijk weet, gebruiken de meeste moderne digitale camera's het exFAT-systeem, omdat het aanzienlijk lichter is dan NTFS, maar tegelijkertijd kan het bestanden opslaan die groter zijn dan 4 GB, in tegenstelling tot FAT32.

Als u dus een document van 6 GB kopieert naar een flashstation met het exFAT-bestandssysteem, zult u niet worden geconfronteerd met de negatieve gevolgen die kunnen worden waargenomen met de vorige versie van het systeem.

Het exFAT-formaat wint aan populariteit en wordt voornamelijk gebruikt bij SDXC-geheugenkaarten met hoge capaciteit. De belangrijkste reden hiervoor is de kleine omvang van het bestandssysteem en, zoals eerder beschreven, de mogelijkheid om documenten groter dan 4 GB op te slaan.

Een interessant feit is dat Microsoft in het bezit is van het Amerikaanse patent 8321439, waarmee je snel een bestand kunt vinden met een hash van de naam. Dankzij deze functie is elk document vele malen sneller terug te vinden.

Het is vermeldenswaard dat voor het exFAT-bestandssysteem niet alle beschikbare add-ons zijn vrijgegeven voor het publiek. Leveranciers moeten een beperkte licentie van Microsoft kopen om ze te kopen.

Deze actie is genomen om te voorkomen dat leveranciers geld proberen te verdienen Microsoft-product door zichzelf te markeren als onderdeel van het bedrijf omdat ze de broncode van het bestandssysteem beschikbaar zouden hebben.

Omdat Microsoft onveranderd is in zijn koppigheid, begonnen veel gebruikers hun eigen wijzigingen van exFAT te maken, waaronder een: exfat-zekering... Het biedt lees- en schrijfbewerkingen voor: Linux-distributies inclusief FreeBSD.

Het exFAT-bestandssysteem dat in 2006 is gemaakt en dat een algemene limiet heeft voor de hoeveelheid informatie die NTFS doet, is lichter, omdat het niet allerlei toevoegingen bevat, zoals het tweede.

ExFAT ondersteunt lezen, schrijven en is compatibel met Mac-, Android- en Windows-besturingssystemen. Voor Linux heb je ondersteunende software nodig.

Vergelijking van bestandssystemen

FAT32:

• Compatibiliteit: Windows, MacOS, Linux, spelcomputers en apparaten met een USB-poort.
• Voordelen: platformonafhankelijke compatibiliteit, lichtgewicht bestandssysteem.
• minpuntjes: bestandsgroottebeperkingen (documenten tot 4 GB zijn beschikbaar) en partitiegroottes tot 16 TB.
• Doel: verwijderbare schijven. Wordt gebruikt om Flash-drives te formatteren, maar exFAT heeft de voorkeur.

NTFS:

• Compatibiliteit: Windows, MacOS (alleen-lezen), Linux (alleen-lezen voor sommige distributies), Xbox One.
• Voordelen: geen beperkingen op de grootte van bestanden en secties.
• minpuntjes: beperkte platformonafhankelijke compatibiliteit.
• Doel: zeer geschikt voor interne harde schijven, omdat je er grote hoeveelheden informatie mee kunt opslaan die andere bestandssystemen niet aankunnen.

exFAT:

• Compatibiliteit: Windows XP en meer latere versies, MacOS 10.6.5 en hoger, Linux (met FUSE), Android.
• Voordelen: heeft algemene positieve effecten van FAT32 en NTFS, waaronder de mogelijkheid om bestanden groter dan 4 GB op te slaan.
• minpuntjes: Microsoft beperkt het gebruik van de licentie.
• Doel: Elimineert bestandsgroottebeperkingen voor verwisselbare opslagapparaten. Veel te verkiezen boven zijn voorganger FAT32.

Als u een logische partitie met een onbekend, beschadigd of verwijderd bestandssysteem moet herstellen, zullen de Starus Recovery-tools u helpen.

Hulpmiddel Starus Partitie Herstel, of zijn analogen, Starus VET herstel, Starus NTFS Recovery, zijn ontworpen om te werken met specifieke bestandssystemen - FAT en NTFS. De hoofdsoftware kan met beide communiceren. U kunt gratis programma's downloaden en uitproberen om FAT32- en NTFS-bestandssystemen te herstellen!