Hva er forskjellen mellom FAT32, NTFS og exFAT. Formatere en USB-flash-stasjon til FAT32 eller NTFS - hva er bedre? Filsystem NTFS - beskrivelse, applikasjon og nøkkelegenskaper

1. FSInfo sektorstruktur struktur fat_boot_fsinfo:
   • __u32 signatur1- signatur 0x41615252;
   • __u32 signatur2- signatur 0x61417272;
   • __u32 free_clusters- antall ledige klynger. Hvis feltet inneholder -1, bør søket etter ledige klynger startes fra klynge nummer 2.
2. Strukturen til katalogoppføringen til kortnavnstrukturen msdos_dir_entry:
   • __s8 navn, ext- filnavn og filtype;
   • __u8 attr- filattributter;
   • __u8 ctime_ms- dette feltet spesifiserer tidspunktet for filoppretting opp til ms (kun FAT32 brukes);
   • __u16 ctime- filopprettingstid (kun FAT32 brukes);
   • __u16 cdate- filopprettelsesdato (kun FAT32 brukes);
   • __u16 adate- dato for siste tilgang til filen (kun FAT32 brukes);
   • __u16 starthi- høye 16 biter av nummeret til den første klyngen i filen (kun FAT32 brukes);
   • __u16 tid, dato, start- tid og dato for filoppretting, nummeret til den første klyngen av filen;
   • __u32 størrelse- filstørrelse (i byte).
3. Lang navn katalogelementstruktur:
   • __u8 id- artikkelnummer;
   • __u8 navn0_4- tegn 1 - 5 i navnet;
   • __u8 attr- filattributter;
   • __u8 alias_sjekksum- sjekksum av det korte navnet;
   • __u8 navn5_10- tegn 6 - 11 i navnet;
   • __u8 navn11_12- tegnene 12 - 13 i navnet.

La oss fortsette å gjennomgå programvareimplementeringen av algoritmen og definere navnet på partisjonen som FAT16-filsystemet er opprettet på:

#ifndef FAT16_PART_NAME

#define FAT16_PART_NAME "/ dev / hda1"

#slutt om

Globale strukturer:

struct fat_boot_sector fbs; // oppstartssektorstruktur

struct msdos_dir_entry dentry; // katalogelementstruktur

Globale variabler:

U16 * fett16; // kopier FAT16-tabellen her

U16 sektor_størrelse; // sektorstørrelse (fra FAT16)

U16 dir_entries; // antall 32-byte deskriptorer

// i rotkatalogen (0 for FAT32)

U16 sektorer; // totalt antall sektorer i seksjon

U32 fett16_størrelse; // FAT16 størrelse

U32 root_size; // størrelsen på rotkatalogen

U16 byte_per_cluster; // klyngestørrelse i byte

U16 neste_klynge; // neste klynge i kjeden

int fett;

La oss starte med hovedfunksjonen:

int main ()

Int num;

Vi angir det fulle navnet på filen, hvis innhold vi ønsker å lese. La meg minne deg på at vi kun jobber med korte filnavn. Prosedyren for å jobbe med lange navn er ikke dekket i denne artikkelen.

U8 * full_path = "/Mappe1/Mappe2/tekst.txt";

Åpne enhetsfilen:

Hard = åpen (FAT16_PART_NAME, O_RDONLY);

Hvis (hardt< 0) {

Feil (FAT16_PART_NAME);

Avslutt (-1);

Vi leser de første 10 klyngene i filen. Lesing utføres av funksjonen fat16_read_file (). Funksjonsparametrene er det fullstendige filnavnet og antall klynger som skal leses. Funksjonen returnerer antall klynger som er lest, eller -1 hvis det oppstod en feil under lesing:

Num = fat16_read_file (full_path, 10);

Hvis (antall< 0) perror("fat16_read_file");

Else printf ("Les% d klynger", num);

Lukk enhetsfilen og avslutt:

Lukk (hardt);

Returner 0;

Funksjonen for å lese filklynger ser slik ut:

int fat16_read_file (__ u8 * full_path, int num)

Struktur split_name sn; // struktur for lagring av bestandsdelene av filen

U8 tmp_name_buff; // buffer for midlertidig lagring av de sammensatte elementene i hele banen til filen

Statisk int i = 1;

Int n;

U8 * tmp_buff;

U16 start_cluster, next_cluster;

Vi har listet opp parameterne til funksjonen når vi vurderer hovedfunksjonen.

Forberedende operasjoner - nullstilling av tmp_name_buff-bufferen og strukturen split_name sn-strukturen:

Det første tegnet i et absolutt banenavn må være en skråstrek (/). Sjekk det ut:

Vi leser oppstartssektoren fra partisjonen:

Hvis (les_fbs ()< 0) return -1;

Leseoppstartssektoren er nå i den globale strukturen fat_boot_sector fbs. La oss kopiere fra denne strukturen sektorstørrelsen, antall oppføringer i rotkatalogen og det totale antallet sektorer på partisjonen:

La oss bestemme størrelsen på klyngen i byte:

Byte_per_cluster = fbs.cluster_size * 512

La oss vise informasjonen i oppstartssektoren:

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

Printf ("Sektorstørrelse -% d", sektorstørrelse);

Printf ("Klyngestørrelse -% d", fbs.cluster_size);

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

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

Printf ("Dir-oppføringer -% d", dir_oppføringer);

Printf ("Sektorer -% d", sektorer);

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

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

Printf ("Total sekt -% u", fbs.total_sect);

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

Beregn størrelsen på FAT16 i byte og les den:

Fat16_size = fbs.fat_length * 512;

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

Vi leser rotkatalogen:

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

dir_entry-pekeren er nå plassert på minneområdet som inneholder rotkatalogoppføringene. Størrelsen på dette minneområdet er lik størrelsen på rotkatalogen (root_size).

La oss lagre (for kontroll) innholdet i rotkatalogen i en egen fil:

#ifdef DEBUG

Lukk (fett);

#slutt om

Vi beregner begynnelsen av dataområdet:

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

Med alle oppføringene i rotkatalogen kan vi komme til innholdet i test.txt-filen. For dette formålet vil vi organisere en syklus. La oss analysere hele filnavnet i syklusens brødtekst, fremheve elementene - underkataloger (vi har to av dem, Folder1 og Folder2) og navnet på den ønskede filen (test.txt).

Mens (1) (

Memset (tmp_name_buff, 0, SHORT_NAME);

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

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

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

I ++;

Gå i stykker;

Tmp_name_buff [n] = "?";

Fyll inn strukturen split_name sn med riktig informasjon. Utfyllingen utføres av funksjonen split_name, mens filnavnet kontrolleres mot "8.3"-formatet:

< 0) {

Printf ("ikke gyldig navn");

Returner -1;

For hvert element i det fullstendige filnavnet definerer vi en innledende klynge. For å gjøre dette, søk i katalogelementene (starter fra roten) etter en oppføring som tilsvarer elementet for fullt navn, og les denne oppføringen. Get_dentry ()-funksjonen utfører søkeprosedyren:

If (get_dentry (& sn)< 0) {

Printf ("Ingen slik fil!");

Returner -1;

Kontrollerer filattributtene. Hvis det er en katalog, les innholdet og fortsett løkken:

If (dentry.attr & 0x10) (

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

Fortsette;

Hvis dette er en fil, les de første num-klyngene. For kontroll vil vi lagre den leste informasjonen i en egen fil:

If (dentry.attr & 0x20) (

Start_cluster = dentry.start;

Tmp_buff = (__u8 *) malloc (byte_per_cluster); // innholdet i klyngen vil bli lest her

N = åpen ("clust", O_CREAT | O_RDWR, 0600); // lagre den leste informasjonen i denne filen

Hvis (n< 0) {

Perror ("åpen");

Returner -1;

For å lese filklyngene, organiserer vi en syklus:

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

Vi leser innholdet i klyngen inn i tmp_buff-bufferen og lagrer det i en egen fil:

< 0) return -1;

< 0) {

Perror ("skriv");

Lukk (n);

Returner -1;

Vi leser fra FAT16 nummeret til den neste klyngen som er okkupert av denne filen. Hvis dette er den siste klyngen, avbryter vi løkken og går tilbake til hovedfunksjonen:

#ifdef DEBUG

Printf ("OK. Lest");

Printf ("filens neste klynge - 0x% X ..", neste_klynge);

#slutt om

Hvis (neste_klynge == EOF_FAT16) (

#ifdef DEBUG

Printf ("siste klynge.");

#slutt om

Gratis (tmp_buff);

Lukk (n);

Returner ++ i;

#ifdef DEBUG

Printf ("slutt å lese");

#slutt om

Returner i;

Lesing av FAT16-oppstartssektoren utføres av read_fbs ()-funksjonen. Resultatet er plassert i den globale fbs-strukturen:

int read_fbs ()

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

Returner 0;

Lesing av filallokeringstabellen til FAT16-filsystemet utføres av read_fat16 ()-funksjonen:

int read_fat16 ()

U64 søk = (__u64) (fbs.reserved) * 512; // offset til FAT16 fra begynnelsen av partisjonen

Fat16 = (ugyldig *) malloc (fett16_størrelse);

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

Returner 0;

Lesing av rotkatalogen utføres av funksjonen read_root_dentry ():

int read_root_dentry ()

U64 søk = (__u64) fbs.reserved * 512 + fat16_size * fbs.fats; // offset til rotkatalogen fra begynnelsen av delen

Root_size = 32 * dir_entries; // beregne størrelsen på rotkatalogen

Dir_entry = (__u8 *) malloc (root_size);

Hvis (! Dir_entry) returnerer -1;

Memset (dir_entry, 0, root_size);

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

Returner 0;

Lesing av en klynge som tilhører en fil utføres av funksjonen read_cluster (). Inndataparameterne til funksjonen er nummeret til cluster cluster_num og en peker til __u8 *tmp_buff bufferen der leseresultatet skal plasseres. Forskyvningen til klyngen på seksjonen beregnes av formelen (se):

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

• SØKE- forskyvning til klyngen på partisjonen
• DATA_START- start av dataområde
• CLUSTER_NUM- sekvensnummeret til klyngen
• BYTE_PER_CLUSTER- klyngestørrelse i byte

int read_cluster (__ u16 cluster_num, __u8 * tmp_buff)

U64 søk = (__u64) (byte_per_cluster) * (cluster_num - 2) + data_start; // beregne offset til klyngen

< 0) return -1;

Returner 0;

Read_directory-funksjonen leser oppføringene i katalogen (ikke roten) og plasserer resultatet i minneområdet som dir_entry-pekeren er satt til:

int read_directory (__ u16 start_cluster)

Int i = 1;

U16 neste_klynge;

For (;; i ++) (

Vi tildeler minne for å lagre innholdet i katalogen, lese innholdet i startklyngen og hente verdien til neste klynge fra FAT16-tabellen:

Hvis (! Dir_entry) returnerer -1;

< 0) return -1;

Next_cluster = fat16;

La oss lagre innholdet i katalogen i en egen fil (for kontroll):

#ifdef DEBUG

Printf ("Neste klynge - 0x% X", neste_klynge);

Fett = åpen ("dir16", O_CREAT | O_WRONLY, 0600);

Skriv (fett, dir_entry, root_size);

Lukk (fett);

#slutt om

Hvis den siste klyngen er nådd, gå ut av løkken, ellers fortsett å lese katalogen, øke størrelsen på dir_entry-bufferen med en klynge til:

Hvis (neste_klynge & EOF_FAT16) bryter;

Start_cluster = neste_cluster;

Returner 0;

Get_dentry ()-funksjonen søker i innholdet i katalogen etter et element som samsvarer med filen du leter etter. Inndataene til denne funksjonen er en peker til en struktur split_name * sn som inneholder elementene i det korte filnavnet:

Int i = 0;

Den globale bufferen dir_entry inneholder en rekke katalogoppføringer der vi skal søke etter en fil (eller katalog)oppføring. For å søke, vil vi organisere en syklus. Kopier katalogoppføringene til den globale dentry-strukturen i hoveddelen av loopen og sammenlign verdien av navn- og ext-feltene til denne strukturen med de tilsvarende feltene til strukturen split_name * sn. Tilfeldighetene til disse feltene betyr at vi har funnet registreringen av den nødvendige filen i utvalget av katalogelementer:

for (;; i ++) (

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

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

Gå i stykker;

Hvis (! Dentry.name) returnerer -1;

#ifdef DEBUG

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

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

Printf ("filstørrelse -% u", dentry.size);

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

#slutt om

Returner 0;

All koden ovenfor er i FAT16-katalogen, filen fat16.c. For å få den kjørbare modulen, lag en Makefile med følgende innhold:

INCDIR = / usr / src / linux / include

PHONY = rent

Fett16: fett16.o splitt.o

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

% .o: % .c

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

Ren:

Rm -f * .o

Rm -f ./fett16

Programvareimplementering av algoritmen for å lese en fil fra en logisk partisjon med FAT12-filsystemet

Generelt er algoritmen for å lese en fil fra en FAT12-partisjon identisk med algoritmen for å lese en fil fra en FAT16-partisjon. Forskjellen ligger i prosedyren for å lese elementer fra FAT12-tabellen. Vi betraktet FAT16-tabellen som en enkel rekke 16-bits elementer. For å lese elementene i FAT12-tabellen, foreslås følgende algoritme:

• multipliser elementnummeret med 1,5;
• trekke ut et 16-bits ord fra FAT ved å bruke resultatet av forrige operasjon som en offset;
• hvis elementnummeret er partall, utfør OG-operasjonen på det leste ordet og masken 0x0FFF. Hvis tallet er oddetall, flytt ordet lest fra tabellen med 4 biter mot de minst signifikante bitene.

Basert på denne algoritmen implementerer vi funksjonen til å lese elementer fra FAT12-tabellen:

int get_cluster (__ u16 cluster_num)

U16 søker;

U16 klynge;

Beregn forskyvningen i FAT12-tabellen og les 16-bits ordet fra tabellen:

Søk = (cluster_num * 3) / 2;

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

Hvis startnummeret til klyngen er et partall, flytter vi verdien lest fra tabellen med 4 biter mot de nedre sifrene, hvis det er oddetall, legger vi det til 0x0FFF:

Hvis (cluster_num% 2) clust >> = 4;

Else clust & = 0x0FFF;

Denne kodebiten kan også implementeres i assembler:

"xorw %% øks, %% øks"

"btw $ 0, %% cx"

"jnc 1f"

"shrw $ 4, %% dx"

"jmp 2f"

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

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

: "= a" (neste)

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

Vi returnerer resultatet:

Retur klynge;

La oss dvele litt mer ved selve algoritmen. La oss anta at en fil er opprettet på en FAT12-partisjon som okkuperer 9. og 10. klynge. Hvert FAT12-element er 12 bits langt. Fordi vi leser 16-bits elementer fra tabellen, så vil forskyvningen til det 9. elementet være 13 byte (9 * 1,5 = 13, vi forkaster resten), mens de nederste 4 bitene vil tilhøre det 8. elementet i FAT. De må forkastes, og for dette er det nok å flytte leseelementet med 4 biter mot de nedre sifrene, som leveres av algoritmen. Forskyvningen til det 10. elementet vil være 15 byte, og de mest signifikante 4 bitene vil tilhøre det 11. elementet i FAT. For å forkaste dem, er det nødvendig å utføre OG-operasjonen på det 10. elementet og masken 0x0FFF, som også tilsvarer algoritmen ovenfor.

Kildekodene til modulen for å lese filen fra FAT12-partisjonen er plassert i FAT12-katalogen, filen fat12.c.

Programvareimplementering av algoritmen for å lese en fil fra en logisk partisjon med FAT32-filsystemet

Algoritmen for å lese en fil fra en partisjon med FAT32-filsystemet skiller seg praktisk talt ikke fra algoritmen for FAT16, bortsett fra at i FAT32 kan rotkatalogen være lokalisert hvor som helst på partisjonen og være av vilkårlig størrelse. Derfor, for å gjøre det mer interessant, la oss komplisere oppgaven - la oss anta at vi bare kjenner partisjonsnummeret med FAT32-filsystemet. For å lese informasjon fra denne delen, må du først bestemme dens koordinater - forskyvning til delen fra begynnelsen av disken. Og for dette må du ha en ide om den logiske strukturen til harddisken.

Logisk struktur på harddisken

Ta i betraktning logisk struktur harddisk som samsvarer med Microsoft-standarden - "primær partisjon - utvidet partisjon - ikke-DOS-partisjoner."

Harddiskplass kan organiseres som én eller flere partisjoner, og partisjoner kan inneholde én eller flere logiske stasjoner.

Harddisken på den fysiske adressen 0-0-1 er Master Boot Record (MBR). MBR-strukturen inneholder følgende elementer:

• ikke-system bootstrap (NSB);
• (partisjonstabell, PT). Plassert i MBR ved offset 0x1BE og opptar 64 byte;
• MBR signatur. De to siste bytene til MBR må inneholde tallet 0xAA55.

Partisjonstabellen beskriver plasseringen og egenskapene til partisjonene som er tilgjengelige på harddisken. Diskpartisjoner kan være av to typer - primære og utvidede. Maksimalt antall primære partisjoner er fire. Det er obligatorisk å ha minst én primær partisjon på disken. En utvidet partisjon kan deles inn i et stort antall underseksjoner - logiske stasjoner. Forenklet MBR struktur er presentert i tabell 7. Partisjonstabellen er plassert på slutten av MBR, 16 byte er tildelt for beskrivelsen av partisjonen i tabellen.

Tabell 7. MBR-struktur

Partiskhet Størrelse, bytes 0 446 0x1BE 16 0x1CE 16 0x1DE 16 0x1EE 16 0x1FE 2

Strukturen til oppføringen av partisjonstabellelementet er vist i tabell 8.

Tabell 8. Struktur for oppføringen av partisjonstabellelementet

Den første byten i seksjonselementet er seksjonsaktivitetsflagget (0 - inaktiv, 0x80 - aktiv). Den tjener til å avgjøre om partisjonen er systemets oppstartbar og om det er behov for å starte opp operativsystemet fra den når datamaskinen starter. Bare én seksjon kan være aktiv. Det aktive partisjonsflagget etterfølges av koordinatene til begynnelsen av partisjonen - tre byte, som betyr hodenummer, sektornummer og sylindernummer. Sylinder- og sektornummer er spesifisert i Int 0x13 avbruddsformat, dvs. bitene 0-5 inneholder sektornummeret, bitene 6-7 er de mest signifikante to bitene av 10-bits sylindernummeret, og bitene 8-15 er de minst signifikante åtte bitene av sylindernummeret. Dette etterfølges av system-ID, som indikerer at det tilhører av denne delen til et bestemt operativsystem. Identifikatoren er én byte. Bak systemidentifikatoren er koordinatene til slutten av seksjonen - tre byte som inneholder tallene til henholdsvis hodet, sektor og sylinder. De neste fire bytene er antall sektorer før partisjonen, og de fire siste bytene er størrelsen på partisjonen i sektorer.

Dermed kan et seksjonstabellelement beskrives ved hjelp av følgende struktur:

struct pt_struct (

U8 oppstartbar; // seksjonsaktivitetsflagg

U8 start_del; // koordinater for begynnelsen av seksjonen

U8 type_del; // systemidentifikator

U8 sluttdel; // koordinater til slutten av seksjonen

U32 sect_before; // antall sektorer før seksjonen

U32 sekt_total; // partisjonsstørrelse i sektorer (antall sektorer i partisjonen)

Elementet til primærpartisjonen peker direkte til oppstartssektoren til den logiske disken (det er alltid bare én logisk disk i primærpartisjonen), og elementet til den utvidede partisjonen peker til listen over logiske disker som består av strukturer kalt sekundære MBR-er (sekundær MBR, SMBR).

Hver disk i den utvidede partisjonen har sin egen SMBR-blokk. SMBR har en struktur som ligner på MBR, men den har ikke en oppstartsrecord (fylt med nuller), og bare to av de fire partisjonsbeskrivelsesfeltene brukes. Det første elementet i partisjonen peker til den logiske disken, det andre elementet peker til neste SMBR-struktur i listen. Den siste SMBR-en på listen inneholder null-seksjonskoden i det andre elementet.

La oss gå tilbake til modulen for å lese filen fra FAT32-partisjonen.

Overskriftsfiler:

#inkludere

#inkludere

#inkludere

#inkludere

#inkludere

MBR signatur:

#define SIGNATUR 0xAA55

Enhetsfil som informasjon om partisjoner vil bli lest fra:

#define DEVICE "/ dev / hda"

Partisjonstabellelementstørrelse (16 byte):

#define PT_SIZE 0x10

Følgende rekke strukturer setter samsvaret mellom seksjonstypekoden og dens symbolske representasjon:

struct systypes (

U8 del_type;

U8 * delnavn;

struct systypes i386_sys_types = (

(0x00, "Tom"),

(0x01, "FAT12"),

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

(0x05, "Utvidet"),

(0x06, "FAT16"),

(0x0b, "Win95 FAT32"),

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

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

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

(0x82, "Linux-bytte"),

(0x83, "Linux"),

(0x85, "Linux utvidet"),

(0x07, "HPFS / NTFS")

Bestem antall elementer i i386_sys_types-matrisen ved å bruke PART_NUM-makroen:

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

La oss sette en grense for antall logiske disker:

#define MAX_DEL 20

Følgende strukturarray vil inneholde informasjon om logiske disker på enheten (harddisk):

struct pt_struct (

U8 oppstartbar;

U8 start_del;

U8 type_del;

U8 sluttdel;

U32 sect_before;

U32 sekt_total;

) pt_t;

int hardt; // enhetsfilbeskrivelse

U8 mbr; // tell MBR her

Partisjonsnummer som FAT32-filsystemet er opprettet på:

#define FAT32_PART_NUM 5

Strukturene til oppstartssektoren, FSInfo-sektoren og katalogoppføringen (definert i filen ):

struct fat_boot_sector fbs;

struct fat_boot_fsinfo fsinfo;

struct msdos_dir_entry dentry;

U32 * fat32 = NULL; // kopier FAT32-tabellen her

U16 sektor_størrelse; // sektorstørrelse (fra FAT32)

U16 dir_entries; // 0 for FAT32

U16 sektorer; // antall sektorer per partisjon

U32 fat32_størrelse; // FAT32 størrelse

U32 data_start; // start av dataområde

U16 byte_per_cluster; // hvor mange byte er i klyngen (klyngestørrelse i byte)

U32 neste_klynge; // neste klynge i kjeden

U32 root_cluster; // ROT-klynge - innledende rotklynge

U8 * dir_entry = NULL; // peker til katalogoppføringer

U64 startsøk = 0; // startforskyvning til seksjon (i byte)

Hovedfunksjon:

int main ()

Int num = 0;

Int cluster_num = 5; // hvor mange klynger som skal leses fra filen

U8 * full_path = "/ Mappe1 / Mappe2 / readme"; // fil å lese

Vi åpner enheten, får informasjon om partisjonstabellen på enheten og viser informasjon om partisjonene:

Hard = åpen (DEV_NAME, O_RDONLY);

Hvis (hardt< 0) {

Feil (DEV_NAME);

Avslutt (-1);

If (get_pt_info (hard)< 0) {

Perror ("get_pt_info");

Avslutt (-1);

Show_pt_info ();

Vi beregner startforskyvningen til seksjonen:

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

Vi leser klyngene som tilhører filen:

Num = fat32_read_file (full_path, cluster_num);

Hvis (antall< 0) perror("fat32_read_file");

Else printf ("Les% d klynger \ n", num);

Lukk (hardt);

Returner 0;

Informasjon om partisjonstabellen leses av get_pt_info () funksjonen:

int get_pt_info (int hard)

Int i = 0;

U64 søker;

Vi leser partisjonstabellen fra MBR og sjekker signaturen:

Read_main_ptable (hard);

If (check_sign ()< 0) {

Printf ("Ikke gyldig signatur! \ N");

Returner -1;

Vi ser etter identifikatoren til den utvidede delen. Hvis det er en, kalkuler forskyvningen til den utvidede partisjonen og les informasjonen om de logiske diskene:

for (; jeg< 4; i++) {

If ((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, søk);

Gå i stykker;

Returner 0;

Read_main_ptable () funksjon for å lese partisjonstabellen:

void read_main_ptable (int hard)

Hvis (les (hard, mbr, 512)< 0) {

Perror ("les");

Lukk (hardt);

Avslutt (-1);

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

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

Komme tilbake;

Signaturkontrollfunksjon check_sign ():

int check_sign ()

U16 tegn = 0;

Memcpy ((ugyldig *) & tegn, (ugyldig *) (mbr + 0x1FE), 2);

#ifdef DEBUG

Printf ("Signatur - 0x% X \ n", tegn);

#slutt om

Hvis (tegn! = SIGNATUR) returnerer -1;

Returner 0;

Lesefunksjonen til utvidet partisjonstabell:

void read_ext_ptable (int hard, __u64 seek)

Int num = 4; // fra denne posisjonen vil utvalget av pt_t-strukturer fylles med informasjon om logiske disker

U8 smbr;

Inndata:

• hard- enhetsfilbeskrivelse;
• søke- forskyvning til den utvidede partisjonen fra begynnelsen av disken (i byte).

For å få informasjon om logiske disker organiserer vi en syklus:

For (;; num ++) (

Vi leser SMBR som ligger ved offsetsøket fra begynnelsen av disken:

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

Pread64 (hard, smbr, 512, søk);

Vi fyller to elementer i pt_t-tabellen, med utgangspunkt i posisjon num. Det første elementet vil peke til den logiske stasjonen, og det andre vil peke til følgende SMBR-struktur:

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

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

Vi gjør en endring i feltet "Nummer på startsektoren" - tellingen er fra begynnelsen av disken:

Pt_t.sect_before + = (søk / 512);

Hvis partisjonstypekoden er null, er det ingen flere logiske stasjoner:

Hvis (! (Pt_t.type_part)) bryte;

Vi beregner offset til neste SMBR:

Søk = ((__u64) (pt_t.sect_before + pt_t.sect_total)) * 512;

Komme tilbake;

Funksjonen show_pt_info () viser informasjon om de logiske stasjonene som er funnet på enheten:

void show_pt_info ()

Int i = 0, n;

#ifdef DEBUG

Printf ("Antall partisjoner på disken -% d \ n", PART_NUM);

#slutt om

For (; jeg< MAX_PART; i++) {

Hvis (! Pt_t [i] .type_part) bryte;

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

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

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

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

Gå i stykker;

If (n == DEL_NUM) printf ("ukjent type \ n");

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

Printf ("Sektorer i seksjon% d -% d \ n", i, pt_t [i] .sect_total);

Printf ("Sektorer før seksjon% d -% d \ n \ n", i, pt_t [i] .sect_before);

Komme tilbake;

Lesing av filklynger fra en FAT32-partisjon utføres av funksjonen fat32_read_file (). Denne funksjonen har mye til felles med fat16_read_file () funksjonen, så se avsnitt 6 for detaljerte kommentarer:

int fat32_read_file (__ u8 * full_path, int num)

Struktur split_name sn;

U8 tmp_name_buff;

Int i = 1, n;

U32 start_cluster, next_cluster;

U8 * tmp_buff;

Forberedende operasjoner - tøm bufferen, strukturer og kontroller den første skråstreken:

Memset (tmp_name_buff, 0, SHORT_NAME);

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

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

Vi leser oppstartssektoren:

Hvis (les_fbs ()< 0) return -1;

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

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

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

Vi leser FSInfo-strukturen og viser signaturen i den:

Hvis (les_fs_info ()< 0) return -1;

Printf ("Signatur1 - 0x% X \ n", fsinfo.signatur1);

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

Fat32_size = fbs.fat32_length * 512; // FAT32-størrelse i byte

Data_start = 512 * fbs.reserved + fat32_size * 2; // start av datafelt

Byte_per_cluster = fbs.cluster_size * 512; // klyngestørrelse i byte

Root_cluster = fbs.root_cluster; // klyngenummer for rotkatalogen

Vi leser FAT32:

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

Tildel minne for katalogoppføringer:

Dir_entry = (__u8 *) malloc (byte_per_cluster);

Hvis (! Dir_entry) returnerer -1;

Vi leser rotkatalogen:

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

Vi analyserer hele banen til filen og deler hvert element inn i dets komponenter:

Mens (1) (

Memset (tmp_name_buff, 0, SHORT_NAME);

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

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

Tmp_name_buff [n] = full_bane [i];

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

I ++;

Gå i stykker;

Tmp_name_buff [n] = "\ 0";

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

Printf ("ikke gyldig navn \ n");

Returner -1;

If (get_dentry (& sn)< 0) {

Printf ("Ingen slik fil! \ N");

Returner -1;

For å få startnummeret til en klynge i FAT32-filsystemet, er det nødvendig å bruke det mest betydningsfulle ordet av nummeret til den første klyngen i filen - starthi-feltet til tannbehandlingsstrukturen:

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

Kontrollerer attributtbyten:

If (dentry.attr & 0x10) (// dette er en katalog

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

Fortsette;

If (dentry.attr & 0x20) (// og dette er en fil

Tmp_buff = (__u8 *) malloc (byte_per_cluster);

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

Hvis (n< 0) {

Perror ("åpen");

Returner -1;

Printf ("filens første klynge - 0x% X ..", start_cluster);

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

Memset (tmp_buff, 0, byte_per_cluster);

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

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

Perror ("skriv");

Returner -1;

Hvis (neste_klynge == EOF_FAT32) (

Gratis (tmp_buff);

Lukk (n);

Returner ++ i;

Start_cluster = neste_cluster;

Returner i;

Hensikten med de tre neste funksjonene er å få inn innholdet i systemområdet, d.v.s. oppstartssektor, FSInfo-struktur og FAT32-tabell:

1) funksjonen read_fbs () leser oppstartssektoren:

int read_fbs ()

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

Returner 0;

2) funksjonen read_fs_info () leser FSInfo-strukturen:

int read_fs_info ()

U64 søk = (__u64) fbs.info_sector * 512 + start_seek;

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

Returner 0;

3) funksjonen read_fat32 () leser FAT32-tabellen:

int read_fat32 ()

U64 søk = (__u64) fbs.reserved * 512 + start_seek;

Fat32 = (ugyldig *) malloc (fat32_size);

Hvis (! Fat32) returnerer -1;

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

Returner 0;

Read_cluster ()-funksjonen leser klyngen med det angitte tallet:

int read_cluster (__ u32 cluster_num, __u8 * tmp_buff)

U64 søk = (__u64) (byte_per_cluster) * (cluster_num - 2) + data_start + start_seek;

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

Returner 0;

Lesekataloger (inkludert roten) håndteres av funksjonen read_directory ():

int read_directory (__ u32 start_cluster)

Int i = 2;

U32 neste_klynge;

Funksjonsparametere - startklynge av katalogen. Vi leser innholdet i katalogen inn i den globale bufferen dir_entry:

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

Next_cluster = fat32;

Hvis katalogen opptar en klynge - avslutt, hvis ikke - øk minnestørrelsen og fortsett å lese:

For (;; i ++) (

Start_cluster = neste_cluster;

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

Hvis (! Dir_entry) returnerer -1;

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

Next_cluster = fat32;

Hvis ((neste_klynge == EOF_FAT32) || (neste_klynge == 0xFFFFFF8)) returnerer 0;

Returner 0;

Den siste funksjonen vi skal se på ser etter et element i innholdet i en katalog som samsvarer med filen du leter etter:

int get_dentry (struktur delt_navn * sn)

Int i = 0;

Dir_entry-pekeren er satt til et minneområde som inneholder en rekke katalogoppføringer der vi skal søke etter en fil (eller katalog). For å søke, organiserer vi en syklus og legger den funnet posten inn i den globale tannbehandlingsstrukturen:

For (;; i ++) (

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

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

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

Gå i stykker;

Hvis (! Dentry.name) returnerer -1;

Returner 0;

Dette avslutter gjennomgangen av modulen for å lese en fil fra en FAT32-partisjon.

Kildekodene til modulen er plassert i FAT32-katalogen, filen fat32.c.

Forskjeller i organiseringen av lagring av filposter i kataloger for FAT- og EXT2-filsystemer

Noen få ord om forskjellene i organiseringen av lagring av filposter i kataloger for FAT- og EXT2-filsystemer. EXT2-filsystemstrukturen ble diskutert i.

Vi har nettopp blitt kjent med FAT - i den har alle elementene i katalogen en fast størrelse. Når du oppretter en fil, ser filsystemdriveren etter den første ledige posisjonen og fyller den med informasjon om filen. Hvis lengden på katalogen ikke passer i en klynge, blir en annen klynge tildelt den, og så videre.

La oss se hvordan ting er i EXT2.

Anta at vi har en partisjon med EXT2-filsystemet, blokkstørrelsen er 4096 byte. I denne delen lager vi en katalog. Katalogstørrelsen vil være lik blokkstørrelsen - 4096 byte. Operativsystemet oppretter umiddelbart to oppføringer i katalogen - oppføringen for gjeldende katalog og oppføringen for overordnet katalog. Den nåværende katalogoppføringen vil ta 12 byte, mens den overordnede oppføringen vil være 4084 byte. La oss lage en fil i denne katalogen. Etter det vil katalogen inneholde tre oppføringer - den gjeldende katalogoppføringen er 12 byte lang, den overordnede katalogoppføringen er allerede 12 byte lang, og den opprettede filoppføringen er, som du sikkert gjettet, 4072 byte lang. Hvis vi sletter den opprettede filen, vil lengden på den overordnede katalogoppføringen vokse igjen til 4084 byte.

Når du oppretter en fil, ser derfor EXT2-filsystemdriveren i katalogen etter en oppføring med maksimal lengde og deler den, slik at det blir plass til Ny inngang... Vel, hvis det tross alt ikke er nok plass, blir en blokk til tildelt katalogen, og lengden på katalogen blir lik 8192 byte.

Og avslutningsvis - en liten korreksjon til artikkelen "Arkitektur av EXT2-filsystemet".

Denne revisjonen gjelder funksjonen get_i_num () for å bestemme inodenummeret etter filnavn. Gammel variant denne funksjonen så slik ut:

int get_i_num (tegn * navn)

Int i = 0, rec_len = 0;

Struktur ext2_dir_entry_2 bulk;

For (; jeg< 700; i++) {

Hvis (! Memcmp (dent.name, name, dent.name_len)) bryter;

Rec_len + = dent.rec_len;

Retur dent.inode;

Korrigert versjon:

int get_i_num (tegn * navn)

* Funksjonsparameter - filnavn. Returverdien er inodenummeret til filen.

Int rec_len = 0;

Struktur ext2_dir_entry_2 bulk; // denne strukturen beskriver formatet til rotkatalogoppføringen:

* Den globale buff inneholder en rekke katalogoppføringer. For å bestemme serienummeret til inoden til filen, må du finne

* i denne matrisen er det en oppføring med navnet på denne filen. For å gjøre dette, vil vi organisere en syklus:

For (;;) (

/ * Kopier katalogoppføringer til bulkstruktur: * /

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

* Lengden på filnavnet lik null betyr at vi har talt opp alle katalogoppføringene

* og poster med navnet på filen vår ble ikke funnet. Så det er på tide å gå tilbake:

Hvis (! Dent.name_len) returnerer -1;

/ * Søk utføres ved å sammenligne filnavn. Hvis navnene samsvarer, gå ut av loopen: * /

Hvis (! Memcmp (dent.navn, navn, strlen (navn))) bryter;

/ * Hvis navnene ikke stemmer, gå til neste oppføring: * /

Rec_len + = dent.rec_len;

/ * Hvis vellykket, returner inodenummeret til filen: * /

Retur dent.inode;

Litteratur:

1. V. Kulakov. Maskinvareprogrammering: En spesiell referanse. 2. utg. / - SPb .: Peter, 2003 - 848 s.
2. A.V. Gordeev, A.Yu. Molchanov. Systemprogramvare / - SPb .: Peter - 2002
3. Meshkov V. Arkitektur av ext2-filsystemet. - Blad " Systemadministrator", nr. 11 (12), november 2003 - 26-32 s.

I kontakt med

Denne artikkelen vil diskutere bruken av forskjellige filsystemer på eksterne lagringsmedier: flash-stasjoner, minnekort, eksterne harddisker, etc. Så i dag brukes følgende filsystemer for stasjoner: ...

* FAT32
* NTFS
* exFAT

La oss gå gjennom hver av dem i detalj og vurdere fordelene, ulempene og funksjonene ved bruk på forskjellige enheter.

Et filsystem laget av Microsoft for å erstatte den døende FAT16. Foreløpig det vanligste systemet. De fleste minnekort og flash-stasjoner leveres i FAT32. I tillegg, når du formaterer et medium i en forbrukerenhet, for eksempel et kamera, vil det fungere i dette filsystemet. Dette er dens viktigste fordel - kompatibilitet. Ved å sette inn en slik stasjon i en husholdnings DVD-spiller, mediespiller eller fotoskriver, vil du være sikker på at alle filene er tilgjengelige og kan leses normalt. Det er her proffene slutter.

Den største ulempen med dette systemet er begrensningen på 4 GB filstørrelse. Skriv derfor stor fil(for eksempel en sikkerhetskopi av systemdisken eller en video som er overskrevet fra et kamera) vil ikke fungere. I tillegg har Windows en grense på 32 GB partisjonsstørrelse. Du kan omgå den siste begrensningen ved å laste ned HP USB-verktøyet Disklagring Format Tool, som lar deg formatere hvilken som helst ekstern harddisk i FAT32.

Men hvis du ikke trenger å ta opp og overføre så store filer, og også hvis du har en liten mediestørrelse: 4, 8 eller til og med 16 GB, kan du formatere den i FAT32 uten å nøle.
Selskapet Transcend, som produserer mobile databærere, formaterer forresten sine eksterne harddisker i FAT32.

Et moderne, pålitelig filsystem som dateres tilbake til Windows NT.
I stasjonære datamaskiner og bærbare datamaskiner erstattet den FAT32. Sjekk om du fortsatt har FAT32 installert (klikk Høyreklikk på disken i Min datamaskin og velg Egenskaper), anbefaler jeg på det sterkeste å erstatte den med NTFS.

Hvordan konvertere FAT32 til NTFS uten tap av data

Dette kan gjøres som følger. Skriv inn på kommandolinjen (Start-Run).

konverter e: / fs: ntfs

I stedet for e: kan du erstatte den nødvendige disken. Dette vil endre filsystemet til NTFS ikke tap av data.

NTFS fungerer imidlertid noe annerledes på flash-stasjoner og eksterne harddisker. Når du kopierer til en slik stasjon, slår Windows på hurtigbuffermekanismen når filene først kopieres til spesielt minne(den såkalte cachen), og deretter til det endelige mediet. I stasjonære harddisker lar dette deg få en gevinst i kopieringshastighet og jevne ut forsinkelser. På mobile enheter vil det se slik ut. Først vil kopieringshastigheten være veldig høy og kan nå 100 MB/s (teoretisk lik lesehastigheten til harddisken du kopierer fra), så når hurtigbufferminnet går tomt, vil hastigheten synke til en kritisk lav verdi. Dessuten, før du fortsetter å kopiere neste fil, må systemet legge til den nåværende fra hurtigbufferen. Derfor kan det se ut til at kopien sitter fast på 99 prosent, selv om harddiskindikatoren vil vise aktivitet. Sammenligner vi kopieringshastigheten med og uten cache, viser det seg at den er nesten identisk. Det vil si at når vi bruker NTFS, mister vi nesten ikke noe, bortsett fra feil kopieringshastighet og informasjon om tidspunktet for fullføringen. Selv om noe av dette "informasjonsinnholdet" kan slite nerver.

Dette er kopieringshastigheten som \ "utvikler seg\"
USB 2.0-harddisk i NTFS

NTFS \ "verker underverker", kopiering til en 512 MB flash-stasjon,
den reelle skrivehastigheten er flere MB/s

På den annen side er NTFS et ekstremt pålitelig filsystem som tåler mange plutselige tilbakestillinger. Denne påliteligheten er gitt av journalføring. Dette vil føre til at systemet får tilgang til visse områder av stasjonen oftere. For flash-stasjoner og minnekort er denne tilnærmingen kritisk. De vil slites ut raskere.

Nytt filsystem fra Microsoft. Designet primært for flash-stasjoner. Ved å overdrive kan vi si at dette er FAT32 med fjernede restriksjoner. Størrelsene på filer og partisjoner kan nå kosmiske verdier, og antall filer i én mappe er ikke lenger begrenset. Etter min mening, ideell for flash-stasjoner og minnekort.

Men dette systemet har også en ulempe. Mange forbrukerenheter støtter det ikke, og datamaskiner med Windows XP vil heller ikke se slike medier. Imidlertid har Microsoft gitt ut KB955704-oppdateringen for å tillate bruk av exFAT på Windows XP. Windows Vista og Windows 7 er venner med dette systemet uten ytterligere manipulasjon.

Men hvis du ofte bruker en flash-stasjon på forskjellige datamaskiner bruker Windows XP, må du ha med deg en ekstra USB-flash-stasjon med drivere. Dette er bare latterlig.

Men hvis du bare har datamaskiner med Windows 7 eller du bærer en USB-flash-stasjon/disk på bare 2-3 steder hvor det er mulig å installere oppdateringen ovenfor, så er exFAT perfekt.

Addisjon
Artikkelen er hentet fra åpne kilder: http://winitpro.ru/index.php/2011/06/20/fajlovaya-sistema-exfat/
ExFAT filsystem

Sammen med utgivelsen av Vista SP1 introduserte Microsoft et nytt filsystem. ExFAT (Extended File Allocation Table) er etterfølgeren til det gamle FAT32-filsystemet. Så hva er de viktigste fordelene og ulempene med exFAT-filsystemet. Hva er forskjellene mellom exFAT og FAT32? Og når er det bedre å bruke exFAT over NTFS?

FAT32-filsystemet er et ganske gammelt og kjent filsystem, men det har en rekke betydelige ulemper: det støtter ikke partisjoner større enn 2 TB, og filer større enn 4 GB. For å løse de beskrevne problemene i FAT32 ble exFAT-filsystemet opprettet. ExFAT er Microsoft utvikling designet hovedsakelig for mobile medier (flash-stasjoner, SSD-stasjoner, smartkort). Det bør bemerkes med en gang at ExFAT ikke brukes til å formatere harddisker. Alt siste versjoner Windows så vel som Mac OS X støtter dette filsystemet. ExFAT blir også ofte referert til som FAT64, som innebærer muligheten til å jobbe med stasjoner og filer større størrelse.

De viktigste fordelene med exFAT-filsystemet:

* Maksimal klyngestørrelse økt til 32 MB
* Økt maksimal størrelse fil i exFAT fra 4 GB til 264 byte (16 EB).
* Ingen begrensning på antall filer i en katalog
* Støtte for fil-/katalogtillatelser
* Transaksjonsstøtte ved skriving (hvis støttet av fysisk enhet)
* Effektiv bruk ledig plass, noe som bidrar til å redusere diskfragmentering betydelig.

Det skal bemerkes at når du formaterer i exFAT, er mengden tilgjengelig plass på lagringsenheter større enn når du bruker FAT32. For eksempel, hvis du formaterer en 4 GB USB-pinne (nominell kapasitet 4023 MB) i forskjellige filsystemer, får du følgende:

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

ExFAT er optimert for å fungere med flash-stasjoner, som USB-flash-stasjoner, minnekort og SSD-stasjoner, klyngestørrelsen på 32 KB er godt egnet for store kort og enheter med økt slitasje ved utføring av lese-skrive-operasjoner. exFAT-systemet har også muligheten til å administrere tilgangsrettigheter til filer/kataloger, og datatilgangstiden har gått ned. En av hovedulempene med exFAT-systemet er at denne teknologien er dekket av Microsofts lisenspolicy, og på ingen måte åpen kilde vedtak, kan den ikke anvendes. For å bruke det i et hvilket som helst operativsystem, må du betale lisensavgifter til Microsoft (denne regelen gjelder ikke for enkle mobile enheter som kameraer, spillere osv.).

exFAT på moderne Windows 7-operativsystemer

Den nye versjonen av Microsoft Windows 7 støtter fullt ut exFAT-filsystemet og alle dets funksjoner i både 32- og 64-biters versjoner. I tillegg kan eksterne flash-stasjoner formatert i exFAT brukes til å jobbe med ReadyBoost-teknologi (og det vil ikke være mer 4 GB-grense).

Windows Vista

Windows Vista støtter kun exFAT fra og med Service Pack 1. I tillegg støttes ikke enkelte funksjoner som tilgangskontroll. I motsetning til Windows 7, støttes ikke exFAT-enheter i Vista for ReadyBoost.

Windows XP

ExFAT støttes ikke i Windows XP, men en driver kan lastes ned fra Microsofts nettsted (beskrivelse i KB 9555704 - http://support.microsoft.com/kb/955704), men det krever at Service Pack 2 er installert.

For eldre versjoner av Windows er det ingen offisiell støtte for exFAT.

Windows Server

ExFAT støttes fullt ut i Windows Server 2008, og når driveren ovenfor er installert, i Windows Server 2003.

Snøleopard

Mac OS X støtter exFAT siden versjon 10.6.4 (15. juni 2010), men bare på Mac-er med SDXC-kortleser. Mac mini og iMac er exFAT-kompatible.

Linux-systemer støtter ikke exFAT, selv om det er flere løsninger, men de fleste av dem er betalte eller upraktiske, i tillegg setter Microsoft, med sin proprietære lisens, en eiker i hjulene til uavhengige utviklere.

ExFAT og FAT32

Når den ble testet på Windows 7, viste den samme ytelse som FAT32, men NTFS er fortsatt litt raskere. Vil exFAT erstatte FAT32? Dette vil sannsynligvis bare skje etter en massiv oppgradering til Windows 7 eller nyere versjoner av Windows. For forbrukere vil hovedfordelen med exFAT være å overvinne FAT32-filbegrensningene (øke filstørrelsen i exFat).

Vi må også huske at exFAT-filsystemet krever en nyere OS-versjon (maskinvareoppgradering kan være nødvendig), samt det faktum at exFAT rett og slett ikke støttes på eldre enheter (kameraer, mp3-spillere).

exFat eller NTFS

ExFAT kan betraktes som en konkurrent til NTFS på systemer med begrenset prosessorkraft og minne. I tillegg er NTFS-filsystemet på flash-kort svært upraktisk og ineffektivt å bruke (driftshastigheten reduseres og levetiden til flash-minnet reduseres), og det er ExFAT som vil være det ideelle filsystemet for slike enheter.

Avslutningsvis vil jeg gi noen generelle anbefalinger ved å velge det mest passende filsystemet. Hvis du har en liten flash-stasjon, formater den til FAT32. Formater store flash-stasjoner exFAT, da "hastighetshopp" vil være spesielt merkbare på dem. Eksterne harddisker er vanligvis store og ytende (spesielt de med USB-kontakter 3.0), så det er best å formatere dem til NTFS.

Artikkelen er hentet fra åpne kilder: http://pc-hard.ru/softarticles/1-fat32-ntfs-exfat-comparsion.html

La oss analysere typene filsystem for en flash-stasjon, hvilken er bedre. En bruker sendte meg et bilde med feilen "Filen er for stor for det endelige filsystemet" og bestemte seg for å skrive en artikkel i hvilke tilfeller man skulle bruke FAT32, NTFS og exFAT-systemer. Han flyttet en fil større enn 4 GB til en 8 GB-pinne. Faktum er at FAT32-systemet ikke kan behandle informasjon over 4 GB, hvis flash-stasjonen har et volum på 32 GB og filsystemet er FAT32, kan du ikke skrive en fil over 4 GB til den. La oss ta en titt på alle tre filsystemene i Windows, la oss se på fordeler og ulemper.

FAT32

Den gamle filsystemmodusen, som vanligvis brukes når du kjøper en USB-flash-stasjon fra en butikk, og årsaken til dette er kompatibilitet. Kompatibiliteten ligger i det faktum at FAT32 kan brukes på alle datamaskiner som kjører MAC, Windows, Linux, gamle PC-er. Den største begrensningen er at den har en filstørrelsesgrense på 4 GB, som i dag har problemer med formater som 4k-video, Blu-ray. Kort sagt, hvis du skal jobbe med filer som er mindre enn 4 GB og flash-stasjonen brukes på forskjellige datamaskiner med forskjellige operativsystemer, så er FAT32-filsystemet veldig egnet.

exFAT

Oppdatert filsystem opprettet av Microsoft for å erstatte FAT32. Startet med Windows Vista SP1 og har en maksimal filstørrelse på 16 exabyte (EB), som er 1 EB = 10 18 byte. Kompatibel med Mac OS og Windows, er det et veldig godt system for å dele store filer.

Minuser:

• Den har ikke noen form for loggingsfunksjonalitet der alle endringer i filer på disk logges før de faktisk utføres.
• Støttes ikke av Apples Time Machine. Kort sagt, du vil ikke kunne sikkerhetskopiere fra Apple ved å bruke Time Machine-programvaren.
• En svært kompleks struktur som krever mer datakraft.

Fordeler:

• Overskriver den samme sektoren færre ganger, noe som er viktig for flash-stasjoner, og forlenger levetiden til minnecellene. Som du vet, har flash-stasjoner N-antall omskrivinger, og mislykkes deretter.
• Stor filstørrelsesgrense på 16 exabyte.
• Klyngestørrelsen er 32 megabyte.
• Forbedret tildeling av ledig plass, noe som reduserer diskdefragmentering.

NTFS

Det nyeste filsystemet laget av Microsoft og er en moderne struktur i dag for nesten enhver moderne intern harddisk, flash-stasjon eller ssd-stasjon. NTFS er en ny filsystemteknologi. Windows kan bare installeres på NTFS. Det er standard for operativsystemdisker på grunn av allsidigheten. Den har alle Microsoft-teknologier: logging, ingen filstørrelsesgrense, filkomprimeringsstøtte, lange navn, filtilgangskontroll for serveradministratorer og mye mer. Hjemme er dette det beste alternativet for å bruke dette systemet på disker og flash-stasjoner. Det er en hake, når du setter inn en USB-flash-stasjon i Mac OS, kan du kopiere informasjon fra en USB-flash-stasjon, men ingen endring.

Produksjon:

For USB-pinner må du bruke exFAT, hvis du hele tiden er i Mac OS, Windows-miljøet, flytter du USB-flashstasjonen fra ett operativsystem til et annet. Hvis du kun bruker windows, så er NTSF en flott løsning.

vfat er en implementering av MS-DOS FAT / FAT32 filsystemer i Linux. mannfeste (8)

Et typisk sett med vfat-monteringsalternativer for en UTF-8-lokalitet (utelater alternativer, hvis standardverdi er foreldet):

uid = brukernavn, gid = gruppenavn, fmask = 0113, dmask = 0002, kodeside = 866, utf8, kortnavn = winnt, stille

For en ikke-UTF8-lokale, og dette er mest sannsynlig en KOI8-R-lokale (for ikke å glemme nå "utf8 = no" obligatorisk for RHEL / CentOS):

uid = brukernavn, gid = gruppenavn, fmask = 0113, dmask = 0002, kodeside = 866, iocharset = koi8-r, utf8 = nei, shortname = winnt, stille

eller med tanke på at "uni_xlate" deaktiverer "utf8", jo mer at det er bedre å se de kodede navnene på filer/kataloger som du på en eller annen måte kan håndtere enn linjer som ikke kan skilles fra "?":

uid = brukernavn, gid = gruppenavn, fmask = 0113, dmask = 0002, kodetall = 866, iocharset = koi8-r, uni_xlate, shortname = winnt, stille

brukernavn og gruppenavn - brukernavn og gruppenavn som gis lese-/skrivetilgang til den monterte FAT/FAT32-partisjonen i samsvar med settet fmask og dmask

De generelle monteringsalternativene varierer avhengig av om du monterer via kommandolinjen eller ved å skrive til / etc / fstab, eller om du trenger å automatisk montere ved oppstart, rw / ro-modus, eller tillate brukere å montere / avmontere en partisjon. Ofte brukt: rw, asynkron
Av sikkerhetsgrunner, for FAT / FAT32-partisjoner, kan du eksplisitt spesifisere: nodev, nosuid, noexec
For å øke hastigheten kan du bruke: noatime, nodiratime

Monteringsalternativer er oppført i man mount (8) under "Monteringsalternativer for fett" og "Monteringsalternativer for vfat".
Monteringsalternativer for fett
=====================

blokkstørrelse = 512 / blokkstørrelse = 1024 / blokkstørrelse = 2048
Angi blokkstørrelse (standard 512).
I/O-blokkstørrelse.

uid = verdi og gid = verdi
Angi eier og gruppe for alle filer. (Standard: uid og gid for gjeldende prosess.)

Siden FAT / FAT32 ikke støtter eierskap og tilgang til filer og kataloger, alt
partisjonen er montert som standard med uid og gid til prosesseieren
montering. Du kan spesifisere ønsket bruker og gruppe på vegne av denne
FAT / FAT32-partisjonen vil bli montert. Disse kan være som numeriske verdier av identifikatorer
så og bruker / gruppe navn, i det minste fra kommandolinjen er det en enkel
angi bruker-/gruppenavn.

umask = verdi
Angi umask (bitmasken for tillatelsene som ikke er tilstede). Standard er umask
av den nåværende prosessen. Verdien er gitt i oktal.

dmask = verdi
Angi umask som bare brukes på kataloger. Standard er umasken til gjeldende prosess.
Verdien er gitt i oktal.

fmask = verdi
Angi umasken som bare brukes på vanlige filer. Standard er umasken til gjeldende prosess.
Verdien er gitt i oktal.

umask, dmask, fmask - tillatelsesmasker for filer / kataloger (umask) eller separat for
kataloger (dmask) og separat for filer (fmask). Faktisk etableres rettigheter gjennom dem
eier (u), gruppe (g) og andre brukere (o) for alle filer og kataloger på mount
seksjon vfat. Spesifisert som et oktalt tall. (Forresten, skriv den oktale verdien
trenger ikke starte på null.)

sjekk = verdi
Tre ulike nivåer av kresenhet kan velges:
r
Store og små bokstaver er akseptert og tilsvarende, lange navnedeler er avkortet
(f.eks. verylongname.foobar blir verylong.foo), ledende og innebygde mellomrom er
akseptert i hver navnedel (navn og utvidelse).
n
Som "avslappet", men mange spesialtegn (*,?, Dette er standard.
s
Som "normal", men navn kan ikke inneholde lange deler og spesialtegn som
noen ganger brukes på Linux, men er ikke akseptert av MS-DOS avvises.
(+, =, mellomrom osv.)

Kontrollerer kontrollen av genererte fil-/katalognavn på vfat-partisjonen for å matche
FAT / FAT32 regler og restriksjoner. Standard er "n".

kodetall = verdi
Angir kodesiden for konvertering til kortnavntegn på FAT- og VFAT-filsystemer.
Som standard brukes kodetall 437.

Det er bedre å spesifisere monteringsparameteren. Angir dos-kodesiden der
de opprettede korte (i 8.3-format) DOS-fil- og katalognavnene lagres.
For de som fortsatt jobbet i DOS og satt det opp, bør denne figuren ikke glemmes - for en normal
lese / lagre russiske navn - kodeside = 866

konv = b / konv = t / konv = a
Fettfilsystemet kan utføre CRLFNL (MS-DOS tekstformat til UNIX tekstformat) konvertering
i kjernen. Følgende konverteringsmoduser er tilgjengelige:
binær - Ingen oversettelse utføres. Dette er standard.
tekst - CRLFNL-oversettelse utføres på alle filer.
auto - CRLFNL-oversettelse utføres på alle filer som ikke har en "velkjent
binær "utvidelse. Listen over kjente utvidelser finner du i begynnelsen
av fs / fat / misc.c (fra og med 2.0 er listen:
exe, com, bin, app, sys, drv, ovl, ovr, obj, lib, dll, pif, arc, zip, lha, lzh,
zoo, tar, z, arj, tz, taz, tzp, tpz, gz, tgz, deb, gif, bmp, tif, gl, jpg, pcx,
tfm, vf, gf, pk, pxl, dvi).
Programmer som utfører beregnede lseeks vil ikke like tekstkonvertering i kjernen.
Flere personer har fått dataene sine ødelagt av denne oversettelsen. Pass på!
For filsystemer montert i binær modus er et konverteringsverktøy (fromdos / todos) tilgjengelig.

Forsøk på å forenkle overføring av tekstfiler fra UNIX-lignende systemer til MS-DOS automatisk
erstatter CRLFNL på farten. Det er bedre å bruke om nødvendig for spesifikke filer kommando
verktøy for å konvertere dos2unix og unix2dos fra pakkene med samme navn, eller den universelle iconv
inkludert i glibc-common-pakken.

cvf_format = modul
Tvinger driveren til å bruke CVF-modulen (Compressed Volume File) cvf_module i stedet for
automatisk gjenkjenning. Hvis kjernen støtter kmod, kontrollerer alternativet cvf_format = xxx også

cvf_option = alternativ
Alternativ overført til CVF-modulen.

cvf_format, cvf_option - parametere som indikerer en spesifikk CVF-modul og dens alternativer
for lasting av kjernen. Jeg vil ikke forstå hva det er.

feilsøke
Slå på feilsøkingsflagget. En versjonsstreng og en liste over filsystemparametere vil bli skrevet ut
(disse dataene skrives også ut hvis parametrene ser ut til å være inkonsekvente).

Etter beskrivelsen å dømme, slår den på utdata fra en linje med versjonen og parametrene til filsystemet når
montering av en FAT / FAT32-partisjon.

fett = 12 / fett = 16 / fett = 32
Spesifiser en 12, 16 eller 32 bit fett. Dette overstyrer den automatiske FAT-typedeteksjonsrutinen.
Bruk med forsiktighet!

I stedet for å automatisk oppdage FAT-typen, kan du spesifisere en spesifikk versjon av den.

iocharset = verdi
Tegnsett som skal brukes for å konvertere mellom 8-biters tegn og 16-biters Unicode-tegn.
Standard er iso8859-1.
Lange filnavn lagres på disken i Unicode-format.

Denne parameteren bør spesifiseres hvis en ikke-UTF8-bruker/systemlokale brukes.
Som skrevet lagres lange fil- og katalognavn i VFAT-delen i Unicode-format.
For å sikre at når du overfører til en ikke-UTF8-konfigurert brukerapplikasjonslokale,
Unicode-tegn ble konvertert til en åtte-bits kode som passer for denne lokaliteten, du må
angi den nødvendige transformasjonstabellen for iocharset.
Som standard, hvis ikke spesifisert, iocharset = ascii, dvs. lange navn antas
filer / kataloger består av tegn fra ASCII-settet som det trivielle
(en-til-en) konvertering av Unicode ASCII-koder.
For KOI8-R-lokaliteten må du spesifisere en tabell for konvertering av tegn til KOI8-R-koder fra tegn
Unicode - iocharset = koi8-r (se /usr/share/i18n/charmaps/KOI8-R.gz).
iocharset-tildelingen er bare meningsfull hvis systemet (eller for en spesifikk bruker,
som partisjonen blir montert for) bruker en ikke-UTF8-lokale.
For UTF-8-lokale hopper vi over iosharset-alternativet og monterer partisjonen med en spesiell
designet for denne anledningen frittstående alternativ"utf8" (se beskrivelse nedenfor).

stille
Slå på det stille flagget. Forsøk på chown- eller chmod-filer gir ikke feil, selv om de mislykkes.
Bruk med forsiktighet!

Undertrykker feilmeldinger når du prøver å "chown" eller "chmod" filer på en partisjon
FAT / FAT32. Generelt, selv om de advarer om å bruke dette alternativet med forsiktighet, gjør det det
daglig arbeid med vfat-partisjoner mer praktisk, hopper transparent over applikasjonsforespørsler
å utføre ikke-støttede FAT / FAT32-funksjoner som konstant vises fra tid til annen.
For eksempel når du sikkerhetskopierer en redigert fil i gedit eller bruker rsync
med det vanlige alternativet "-a". Du trenger bare å huske at partisjonen du jobber med er FAT / FAT32 og
ta hensyn til at filene som er plassert på den alltid får eieren og tilgangsmodusen som er spesifisert
ved montering. I fravær av dette alternativet, må du også huske dette, fordi hele tiden
du får feil under sikkerhetskopieringen (du må for eksempel registrere rsync-alternativer spesielt)
eller advarsler ved flytting av filer på grunn av manglende evne til å endre eier og tidspunkt.
Forsiktighet bør utvises når du utfører omvendte operasjoner - henter filer fra vfat-partisjoner
med eierinstallasjon.

sys_immutable, showexec, dots, nodots, dotsOK =
Ulike feilsøkte forsøk på å tvinge Unix- eller DOS-konvensjoner inn i et FAT-filsystem.

Ulike forsøk, med ulik grad av suksess, for å harmonisere Unix- og DOS-konvensjoner for
FAT filsystem. Et eksempel og beskrivelse av bruken av parameteren "showexec" finner du i denne en av de sjeldne artikkelen som ikke inneholder feilaktig informasjon: http://citkit.ru/articles/147/

Monteringsmuligheter for vfat
======================

uni_xlate
Oversett ubehandlede Unicode-tegn til spesielle escapede sekvenser. Dette lar deg sikkerhetskopiere
og gjenopprett filnavn som er opprettet med alle Unicode-tegn. Uten dette alternativet,
en "?" brukes når ingen oversettelse er mulig. Rømningskarakteren er ':' fordi den er det
ellers ulovlig på vfat-filsystemet. Rømningssekvensen som blir brukt, hvor u er
Unicode-tegnet er: ':', (u & 0x3f), ((u >> 6) & 0x3f), (u >> 12).

Det er også nyttig alternativ når du arbeider i en ikke-UTF8-lokale. I lange fil-/katalognavn
alle Unicode-tegn kan bli funnet, inkludert de som ikke faller inn i det settet med 256
tegn spesifisert i konverteringstabellen i parameteren iocharset =. Slike symboler
vist som '?', eller hvis spesifisert dette alternativet de ser ut til å være spesielle
rømningssekvenser. Escape-karakteren er et kolon ':' fordi det er forbudt
i DOS-navn og forekommer absolutt aldri i dem. Potensielt med dette aktivert
alternativer kan manipuleres med filer hvis navn inneholder noen av Unicode-tegnene.
Navnene ser morsomme ut: for eksempel vil en fil med navnet "test" vises
som ": 0442: 0435: 0441: 0442". En fil med dette navnet kan opprettes, kopieres,
skriv, gi for eksempel nytt navn til ": 0442: 0435: 0441: 0441", og dette vil være DOS-navnet "tess".
Men for eksempel å synkronisere kataloger med slike escape-sekvenser i navnet
bruk av rsync vil ikke fungere, åpenbart fordi rsync ikke vet noe om lignende
navnekonverteringer.

posix
Tillat to filer med navn som bare er forskjellige i tilfelle.

Tillater opprettelse av to filer med navn som er forskjellige bare i tilfelle.

nonumtail
Prøv først å lage et kort navn uten sekvensnummer, før du prøver navn ~ num.ext.

Når du oppretter et kort dos-navn, prøver den å lage det først uten de vanlige tildene
med et tall på slutten av navnet.

utf8
UTF8 er den filsystemsikre 8-biters kodingen av Unicode som brukes av konsollen.
Det kan aktiveres for filsystemet med dette alternativet.
Hvis 'uni_xlate' blir satt, blir UTF8 deaktivert.

Aktiverer UTF-8-koding av Unicode-tegn når de sendes til tilpassede applikasjoner
arbeider i UTF-8-lokaliteter. Det er åpenbart dette som trengs under normale forhold.
Hvis alternativet "uni_xlate" er satt, er alternativet "utf8" deaktivert.

Teoretisk sett, i en UTF-8-lokale, kan du ikke bruke "utf8"-alternativet, men sette iocharset = utf8.
I fs / fat / inode.c-kildene ser vi følgende advarsel:
1105 / * UTF-8 gir ikke "FETT semantikk * /
1106 if (! Strcmp (opts-> iocharset, "utf8")) (
1107 printk (KERN_ERR "FAT: utf8 er ikke et anbefalt IO-tegnsett"
1108 "for FAT-filsystemer vil filsystemet skille mellom store og små bokstaver! \ N");
1109 }
kortnavn =
Definerer virkemåten for opprettelse og visning av filnavn som passer inn i 8,3 tegn.
Hvis det finnes et langt navn for en fil, vil det alltid være foretrukket visning. Det er fire moduser:
lavere - Tving det korte navnet til små bokstaver ved visning;
win95 - Tving det korte navnet til store bokstaver ved visning;
lagre et langt navn når det korte navnet ikke består av store bokstaver.
winnt - Vis kortnavnet som det er;
lagre et langt navn når det korte navnet ikke består av små eller store bokstaver.
blandet - Vis det korte navnet som det er;
lagre et langt navn når det korte navnet ikke består av store bokstaver.
Standard er "lavere".

Bestemmer hvordan navnene på filer og kataloger opprettes og vises på egen hånd
er i 8.3-format. Hvis det finnes et langt navn for filen, vil det vises,
siden har alltid forrang. Det er fire moduser som beskrevet. Standard er "lavere".
Det virker mer naturlig å bruke "winnt".

Etter å ha montert partisjonen, kan du sjekke alternativene som den ble montert med ved "cat / proc / mounts".

En særegenhet blir lagt merke til i RedHat / CentOS: en vfat-partisjon er alltid montert med "utf8"-alternativet aktivert, selv om det ikke er spesifisert på kommandolinjen. Dette skjer også i ikke-UTF8-lokaliteter, noe som fører til at filnavn som består av ikke-ascii-tegn vises feil (slik det vanligvis ser ut når man prøver å sende ut en Unicode-streng ved å bruke en hvilken som helst kodetabell med 256 8-biters tegn). Dette er resultatet av Anaconda-feiloppdateringen https://bugzilla.redhat.com/show_bug.cgi?id=181963, da vi i stedet for å fikse en feil i installasjonsinnstillingene, rett og slett lappet kjernen slik at vfat-partisjoner som standard var montert med "utf8"-alternativet aktivert, dvs. .To. skriv alt det samme alt i lang tid fungerer allerede bare i UTF-8-lokaliteter. Men samtidig glemte de å nevne på man-siden hvordan du deaktiverer dette alternativet https://bugzilla.redhat.com/show_bug.cgi?id=515149

I samme fs / fat / inode.c kan du se de udokumenterte parameterne som kan settes for å kontrollere alternativer, inkludert å deaktivere "utf8":
905 static match_table_t vfat_tokens = (
906 (Opt_charset, "iocharset =% s"),
907 (Opt_shortname_lower, "shortname = lower"),
908 (Opt_shortname_win95, "shortname = win95"),
909 (Opt_shortname_winnt, "shortname = winnt"),
910 (Opt_shortname_mixed, "shortname = blandet"),
911 (Opt_utf8_no, "utf8 = 0"), / * 0 eller nei eller usann * /
912 (Opt_utf8_no, "utf8 = nei"),
913 (Opt_utf8_no, "utf8 = usann"),
914 (Opt_utf8_yes, "utf8 = 1"), / * tom eller 1 eller yes eller true * /
915 (Opt_utf8_yes, "utf8 = yes"),
916 (Opt_utf8_yes, "utf8 = sant"),
917 (Opt_utf8_yes, "utf8"),
918 (Opt_uni_xl_no, "uni_xlate = 0"), / * 0 eller nei eller falsk * /
919 (Opt_uni_xl_no, "uni_xlate = no"),
920 (Opt_uni_xl_no, "uni_xlate = falsk"),
921 (Opt_uni_xl_yes, "uni_xlate = 1"), / * tom eller 1 eller yes eller true * /
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 eller nei eller falsk * /
926 (Opt_nonumtail_no, "nonumtail = no"),
927 (Opt_nonumtail_no, "nonumtail = false"),
928 (Opt_nonumtail_yes, "nonumtail = 1"), / * tom eller 1 eller yes eller true * /
929 (Opt_nonumtail_yes, "nonumtail = yes"),
930 (Opt_nonumtail_yes, "nonumtail = true"),
931 (Opt_nonumtail_yes, "nonumtail"),
932 (Opt_err, NULL)
933 };

Du må ha hørt om filsystemer som f.eks FAT32, NTFS og exFAT... Men hva er forskjellen mellom dem? Hver type har sin egen eget sett fordeler og ulemper. Dette er grunnen til at det ikke er noe enkelt alternativ. I denne artikkelen vil vi bryte ned hovedforskjellene mellom de tre filsystemene.

Når vi snakker om Windows-operativsystemet, vet vi med sikkerhet at det bare er installert på en logisk partisjon i NTFS-format. Flyttbare stasjoner og andre USB-baserte lagringsenheter bruker FAT32-typen.

Et av formatene som kan brukes til å formatere flash-stasjoner er exFAT, etterfølgeren til det gamle FAT32-filsystemet.

Dermed har vi tre hovedformater for datalagring som vanligvis brukes både for Windows og for ulike typer lagringsmedier.

Hva er et filsystem

Et filsystem er et sett med regler som styrer hvordan dokumenter som er lagret på en enhet lagres og hentes. Dette kan være en harddisk, Flash-stasjon eller SD-kort.

For en bedre forståelse, la oss som eksempel ta kontoret til et vanlig selskap. Fragmenter av installerte dokumenter lagres på et bestemt sted, for eksempel i en skrivebordsskuff. Og når det er nødvendig å åpne dem, får filsystemet tilgang til filene i et forsøk på å lese informasjon.

Nyttige artikler

La oss anta for et sekund at et slikt system er ute av drift, og umiddelbart får vi en enorm mengde uidentifiserte data, som det ikke vil være mulig å studere.

Faktisk er det et stort antall filsystemer som Flash Filsystem, Tape File System og Disk File System, men vi vil kun fokusere på de viktigste - FAT32, NTFS og exFAT.

Hva er FAT32

FAT32-filsystemet er det eldste og mest erfarne i datateknologiens historie. Reisen begynte med det originale 8-bits FAT-systemet i 1977, som fungerte inne i en autonom disk. Microsoft Standalone Disk Basic-80... Den ble lansert spesielt for Intel 8080 NCR 7200 i 1977/1978, jobbet som en dataterminal med 8-tommers disketter.

Etter diskusjoner om å introdusere systemet med Microsoft-grunnlegger Bill Gates, ble koden skrevet av selskapets første ansatt, Mark MacDonald.

Hovedoppgaven til FAT-filsystemet var å jobbe med data i operativsystemet Microsoft 8080 / Z80 basert på MDOS / MIDAS-plattformen, skrevet av Mark MacDonald.

I fremtiden har FAT gjennomgått noen endringer, og gradvis flyttet fra sin opprinnelige form til FAT12, FAT16 og til slutt FAT32, hvis navn nå er nært knyttet til eksterne stasjoner.

Hovedforskjellen mellom FAT32 og forgjengerne er å overvinne den begrensede mengden informasjon som er tilgjengelig for lagring. 32-bit Systemet ble utgitt i august 1995 med utgivelsen av Windows 95 og økte i oppdateringen de øvre grensene for fil- og lagringsstørrelser til 4GB og 16TB.

Dermed er ikke FAT32 designet for å lagre store datamengder og installere tunge applikasjoner. Det er av denne grunn at filsystemet brukes på harddisker. NTFS som lar brukere slutte å tenke på mengden informasjon som lastes ned.

Oppsummert er FAT32-systemet ideelt for lagring av data som ikke overstiger 4 GB på noe flyttbart medium. Dens popularitet er ikke begrenset til datamaskinfeltet. Den brukes i spillkonsoller, TV-er med høy oppløsning bilder, DVD-spillere, Blu-ray-spillere og andre enheter med USB-port. FAT32 støttes av alle versjoner av Windows, Linux og MacOS.

Hva er NTFS

I 1993 introduserte Microsoft et nytt filsystem NTFS(New Technology File System) parallelt med fremveksten av operativsystemet Windows NT 3.1.

Hovedtrekket til NTFS-systemet er fraværet av noen restriksjoner på størrelsen på opplastede filer. Selv om vi prøvde å overskride denne grensen, ville vi ha mislyktes – det er så flott.

Utviklingen startet på midten av 1980-tallet under et samarbeid mellom Microsoft og IBM, hvor målet var å lage et nytt operativsystem som overgår tidligere når det gjelder grafikkytelse.

Foreningen av de to selskapene varte imidlertid ikke lenge, og uten å fullføre det felles prosjektet bestemte de seg for å stoppe samarbeidet. Deretter konsentrerte Microsoft og IBM seg om å produsere sine egne filsystemer.

For datateknologi ble det i 1989 opprettet IBMs HPFS, som ble brukt til operativsystemet OS / 2. Noen år senere, i 1993, lanserte Microsoft NTFS v1.0 som ble det offisielle filsystemet for Windows NT 3.1.

Den teoretiske NTFS-filstørrelsen er 16 EB - 1 KB, som er 18 446 744 073 709 550 502 byte. Utviklingsteamet inkluderte Tom Miller, Harry Kimura, Brian Andrew, David Gebel.

Den neste versjonen av filsystemet var NTFS v3.1 lansert spesielt for Microsoft Windows XP. I fremtiden gjennomgikk den ingen spesielle endringer, selv om det ble gjort mange forskjellige tillegg til den. For eksempel dukket muligheten til å komprimere logiske partisjoner, gjenoppretting og NTFS symbolske lenker opp. I tillegg var den opprinnelige filsystemkapasiteten bare 256 MB av de enorme 16 EB - 1 KB i nyere versjoner lansert med utgivelsen av Windows 8.

Noen av de nyttige funksjonene introdusert i NTFS v3.1 inkluderer utvidelse av støttede filformater, diskbrukskvoter, filkryptering og reparasjonspunkter. Bemerkelsesverdig er det faktum at de nyere versjonene av NTFS er fullt kompatible med de forrige.

NTFS-filsystemet har en viktig funksjon når det gjelder å gjenopprette det fra enhver form for skade. Den inneholder en spesifikk datastruktur som sporer eventuelle endringer i systemet og som du alltid kan gjenopprette NTFS til å fungere med.

Dette filsystemet støttes av alle Windows-versjoner fra Windows XP. Dessverre deler ikke macOS kompatibilitetsstasjonen som fremmes av Microsoft. Apple ga brukerne muligheten til å lese data fra NTFS-disker, men de vil ikke kunne skrive til dem. Støtte for dette filsystemet fra Linux er begrenset til bare noen få av versjonene.

Hva er exFAT

ExFAT(Extended FAT) er et nytt, utvidet filsystem fra Microsoft som med suksess erstatter sin forgjenger på feltet når det kommer til store mengder informasjon.

Som du sikkert vet, bruker de fleste moderne digitalkameraer exFAT-systemet, siden det er betydelig lettere enn NTFS, men samtidig kan det lagre filer større enn 4 GB, i motsetning til FAT32.

Hvis du kopierer et 6 GB-dokument til en flash-stasjon med exFAT-filsystemet, vil du ikke møte de negative konsekvensene som kan observeres ved å bruke den forrige versjonen av systemet.

ExFAT-formatet blir stadig mer populært og brukes først og fremst med SDXC-minnekort med høy kapasitet. Hovedårsaken til dette er den lille størrelsen på filsystemet og, som tidligere beskrevet, muligheten til å lagre dokumenter større enn 4 GB.

Et interessant faktum er at Microsoft har amerikansk patent 8321439, som lar deg raskt finne en fil ved å bruke en hash av navnet. Takket være denne funksjonen kan ethvert dokument bli funnet mange ganger raskere.

Det er verdt å merke seg at for exFAT-filsystemet har ikke alle tilgjengelige tillegg blitt utgitt for offentligheten. For å kjøpe dem må leverandører kjøpe en begrenset lisens fra Microsoft.

Denne handlingen ble tatt for å sikre at leverandører ikke prøver å tjene penger Microsoft-produkt, og markerer seg som en del av selskapet, siden de ville ha kildekoden til filsystemet tilgjengelig.

Siden Microsoft er uendret i sin stahet, begynte mange brukere å lage sine egne modifikasjoner av exFAT, hvorav en var eksfett-sikring... Den gir lese- og skriveoperasjoner for Linux-distribusjoner inkludert FreeBSD.

ExFAT-filsystemet opprettet i 2006, som har en generell grense for mengden informasjon som NTFS gjør, er lettere, siden det ikke inneholder alle slags tillegg, som det andre.

ExFAT støtter lesing, skriving og er kompatibel med Mac, Android og Windows operativsystemer. For Linux trenger du støtteprogramvare.

Sammenligning av filsystemer

FAT32:

• Kompatibilitet: Windows, MacOS, Linux, spillkonsoller og enheter med USB-port.
• Fordeler: kompatibilitet på tvers av plattformer, lett filsystem.
• Minuser: filstørrelsesbegrensninger (dokumenter på opptil 4 GB er tilgjengelige) og partisjonsstørrelser på opptil 16 TB.
• Hensikt: flyttbare stasjoner. Brukes til å formatere flash-stasjoner, men exFAT foretrekkes.

NTFS:

• Kompatibilitet: Windows, MacOS (skrivebeskyttet), Linux (skrivebeskyttet for enkelte distribusjoner), Xbox One.
• Fordeler: ingen restriksjoner på størrelsen på filer og seksjoner.
• Minuser: begrenset kompatibilitet på tvers av plattformer.
• Hensikt: godt egnet for interne harddisker, da det lar deg lagre store mengder informasjon som andre filsystemer ikke kan takle.

exFAT:

• Kompatibilitet: Windows XP og mer senere versjoner, MacOS 10.6.5 og nyere, Linux (bruker FUSE), Android.
• Fordeler: har vanlige positive effekter fra FAT32 og NTFS, som inkluderer muligheten til å lagre filer større enn 4 GB.
• Minuser: Microsoft begrenser bruken av lisensen.
• Hensikt: Eliminerer filstørrelsesbegrensninger for flyttbare lagringsenheter. Mye å foretrekke fremfor forgjengeren FAT32.

Hvis du trenger å gjenopprette en logisk partisjon med et ukjent, skadet eller slettet filsystem, vil Starus Recovery-verktøyene hjelpe deg.

Verktøy Starus-partisjonsgjenoppretting, eller dets analoger, Starus FAT Recovery, Starus NTFS Recovery, er designet for å fungere med spesifikke filsystemer - FAT og NTFS. Hovedprogramvaren er i stand til å samhandle med begge. Du kan laste ned og prøve programmer for å gjenopprette FAT32- og NTFS-filsystemer gratis!