Vad är skillnaden mellan FAT32, NTFS och exFAT. Formatera ett USB-minne till FAT32 eller NTFS - vilket är bättre? Filsystem NTFS - beskrivning, applikation och nyckelegenskaper

1. FSInfo sektorstruktur struktur fat_boot_fsinfo:
   • __u32 signatur1- signatur 0x41615252;
   • __u32 signatur2- signatur 0x61417272;
   • __u32 gratis_kluster- antalet fria kluster. Om fältet innehåller -1 ska sökningen efter fria kluster startas från kluster nummer 2.
2. Strukturen för katalogposten för kortnamnsstrukturen msdos_dir_entry:
   • __s8 namn, ext- filnamn och filtillägg;
   • __u8 attr- filattribut;
   • __u8 ctime_ms- detta fält anger tidpunkten för filskapande upp till ms (endast FAT32 används);
   • __u16 ctime- tid för att skapa filer (endast FAT32 används);
   • __u16 cdate- filskapande datum (endast FAT32 används);
   • __u16 adate- datum för senaste åtkomst till filen (endast FAT32 används);
   • __u16 starthi- höga 16 bitar av numret för det första klustret i filen (endast FAT32 används);
   • __u16 tid, datum, start- tid och datum för skapandet av filen, nummer på filens första kluster;
   • __u32 storlek- Filstorlek (i byte).
3. Långt namn katalogobjektstruktur:
   • __u8 id- artikelnummer;
   • __u8 namn0_4- tecken 1 - 5 i namnet;
   • __u8 attr- filattribut;
   • __u8 alias_checksum- kontrollsumma för det korta namnet;
   • __u8 namn5_10- tecken 6 - 11 i namnet;
   • __u8 namn11_12- tecken 12 - 13 i namnet.

Låt oss fortsätta att granska mjukvaruimplementeringen av algoritmen och definiera namnet på partitionen som FAT16-filsystemet skapas på:

#ifndef FAT16_PART_NAME

#define FAT16_PART_NAME "/ dev / hda1"

#endif

Globala strukturer:

struct fat_boot_sector fbs; // bootsektorstruktur

struct msdos_dir_entry dentry; // katalogobjektstruktur

Globala variabler:

U16 * fett16; // kopiera FAT16-tabellen här

U16 sektor_storlek; // sektorstorlek (från FAT16)

U16 dir_entries; // antal 32-byte deskriptorer

// i rotkatalogen (0 för FAT32)

U16-sektorer; // Totala numret sektorer i avsnitt

U32 fat16_size; // FAT16 storlek

U32 root_size; // storleken på rotkatalogen

U16 byte_per_cluster; // klusterstorlek i byte

U16 nästa_kluster; // nästa kluster i kedjan

int fett;

Låt oss börja med huvudfunktionen:

int main ()

Int num;

Vi anger det fullständiga namnet på filen, vars innehåll vi vill läsa. Låt mig påminna om att vi bara arbetar med korta filnamn. Proceduren för att arbeta med långa namn täcks inte av den här artikeln.

U8 * full_path = "/Mapp1/Mapp2/text.txt";

Öppna enhetsfilen:

Hard = öppen (FAT16_PART_NAME, O_RDONLY);

Om (svårt< 0) {

Fel (FAT16_PART_NAME);

Avsluta (-1);

Vi läser de första 10 klustren i filen. Avläsningen utförs av funktionen fat16_read_file (). Funktionsparametrarna är det fullständiga filnamnet och antalet kluster som ska läsas. Funktionen returnerar antalet lästa kluster, eller -1 om ett fel inträffade under läsningen:

Num = fat16_read_file (full_path, 10);

Om (antal< 0) perror("fat16_read_file");

Else printf ("Läs% d kluster", num);

Stäng enhetsfilen och avsluta:

Stäng (hårt);

Returnera 0;

Funktionen för att läsa filkluster ser ut så här:

int fat16_read_file (__ u8 * full_path, int num)

Struktur split_name sn; // struktur för att lagra de ingående delarna av filen

U8 tmp_name_buff; // buffert för tillfällig lagring av de sammansatta elementen i filens fullständiga sökväg

Statisk int i = 1;

Int n;

U8 * tmp_buff;

U16 start_kluster, nästa_kluster;

Vi har listat funktionens parametrar när vi överväger huvudfunktionen.

Förberedande operationer - nollställning av bufferten tmp_name_buff och strukturen split_name sn-strukturen:

Det första tecknet i ett absolut sökväg måste vara ett snedstreck (/). Vi kollar detta:

Vi läser startsektorn från partitionen:

Om (läs_fbs ()< 0) return -1;

Lässtartsektorn är nu i den globala strukturen fat_boot_sector fbs. Låt oss kopiera från denna struktur sektorstorleken, antalet poster i rotkatalogen och det totala antalet sektorer på partitionen:

Låt oss bestämma storleken på klustret i byte:

Byte_per_cluster = fbs.cluster_size * 512

Låt oss visa informationen i startsektorn:

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

Printf ("Sektorstorlek -% d", sektorstorlek);

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

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

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

Printf ("Direktionsposter -% d", katalogposter);

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

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

Printf ("FAT16 längd -% u", fbs.fat_length);

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

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

Beräkna storleken på FAT16 i byte och läs det:

Fat16_size = fbs.fat_length * 512;

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

Vi läser rotkatalogen:

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

Katalogpostpekaren är nu placerad i minnesområdet som innehåller rotkatalogposterna. Storleken på detta minnesområde är lika med storleken på rotkatalogen (root_size).

Låt oss spara (för kontroll) innehållet i rotkatalogen i en separat fil:

#ifdef DEBUG

Stäng (fett);

#endif

Vi beräknar början av dataområdet:

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

Med alla poster i rotkatalogen på plats kan vi komma till innehållet i test.txt-filen. För detta ändamål kommer vi att organisera en cykel. Låt oss analysera hela filnamnet i slingans kropp och markera dess element - underkataloger (vi har två av dem, Folder1 och Folder2) och namnet på den önskade filen (test.txt).

Medan (1) (

Memset (tmp_name_buff, 0, SHORT_NAME);

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

För (n = 0; n< SHORT_NAME; n++, i++) {

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

I ++;

Ha sönder;

Tmp_name_buff [n] = "?";

Fyll i strukturen split_name sn med lämplig information. Fyllningen utförs av funktionen split_name, medan filnamnet kontrolleras mot formatet "8.3":

< 0) {

Printf ("ej giltigt namn");

Returnera -1;

För varje element i det fullständiga filnamnet definierar vi ett initialt kluster. För att göra detta, leta i katalogelementen (med början från roten) efter en post som motsvarar elementet för fullständigt namn, och läs denna post. Funktionen get_dentry () utför sökproceduren:

If (get_dentry (& sn)< 0) {

Printf ("Ingen sådan fil!");

Returnera -1;

Kontrollerar filattributen. Om det är en katalog, läs dess innehåll och fortsätt loopen:

If (dentry.attr & 0x10) (

If (läs_katalog (dentry.start)< 0) return -1;

Fortsätta;

Om det här är en fil, läs de första num-klustren. För kontroll kommer vi att spara den lästa informationen i en separat fil:

If (dentry.attr & 0x20) (

Start_kluster = dentry.start;

Tmp_buff = (__u8 *) malloc (byte_per_kluster); // innehållet i klustret kommer att läsas här

N = öppen ("klust", O_CREAT | O_RDWR, 0600); // spara den lästa informationen i den här filen

Om (n< 0) {

Perror ("öppen");

Returnera -1;

För att läsa filklustren kommer vi att organisera en cykel:

För (i = 0; i< num; i++) {

Vi läser in innehållet i klustret i tmp_buff-bufferten och sparar det i en separat fil:

< 0) return -1;

< 0) {

Perror ("skriva");

Stäng (n);

Returnera -1;

Vi läser från FAT16 numret på nästa kluster som upptas av denna fil. Om detta är det sista klustret avbryter vi slingan och återgår till huvudfunktionen:

#ifdef DEBUG

Printf ("OK. Läst");

Printf ("filens nästa kluster - 0x% X ..", nästa_kluster);

#endif

Om (nästa_kluster == EOF_FAT16) (

#ifdef DEBUG

Printf ("sista kluster.");

#endif

Gratis (tmp_buff);

Stäng (n);

Returnera ++ i;

#ifdef DEBUG

Printf ("sluta läsa");

#endif

Returnera i;

Läsning av FAT16-startsektorn utförs av funktionen read_fbs (). Resultatet placeras i den globala fbs-strukturen:

int read_fbs ()

Om (läs (hårt, (__ u8 *) & fbs, storlek på (fbs))< 0) return -1;

Returnera 0;

Att läsa filallokeringstabellen för FAT16-filsystemet utförs av funktionen read_fat16 ():

int read_fat16 ()

U64 sök = (__u64) (fbs.reserverad) * 512; // offset till FAT16 från början av partitionen

Fat16 = (void *) malloc (fat16_size);

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

Returnera 0;

Att läsa rotkatalogen utförs av funktionen read_root_dentry ():

int read_root_dentry ()

U64 seek = (__u64) fbs.reserved * 512 + fat16_size * fbs.fats; // offset till rotkatalogen från början av avsnittet

Root_size = 32 * dir_entries; // beräkna storleken på rotkatalogen

Dir_entry = (__u8 *) malloc (root_size);

Om (! Dir_entry) returnerar -1;

Memset (katalogpost, 0, rotstorlek);

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

Returnera 0;

Att läsa ett kluster som tillhör en fil utförs av funktionen read_cluster (). Funktionens ingångsparametrar är numret på klustret cluster_num och en pekare till bufferten __u8 *tmp_buff, där läsresultatet ska placeras. Förskjutningen till klustret på sektionen beräknas med formeln (se):

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

• SÖKA- offset till klustret på partitionen
• DATA_START- start av dataområde
• CLUSTER_NUM- sekvensnummer för klustret
• BYTE_PER_CLUSTER- klusterstorlek i byte

int read_cluster (__ u16 cluster_num, __u8 * tmp_buff)

U64 seek = (__u64) (byte_per_cluster) * (kluster_num - 2) + data_start; // beräkna offset till klustret

< 0) return -1;

Returnera 0;

Read_directory-funktionen läser posterna i katalogen (inte roten) och placerar resultatet i minnesområdet som dir_entry-pekaren är inställd på:

int read_directory (__ u16 start_cluster)

Int i = 1;

U16 nästa_kluster;

För (;; i ++) (

Vi allokerar minne för att lagra innehållet i katalogen, läser innehållet i startklustret och hämtar värdet för nästa kluster från FAT16-tabellen:

Om (! Dir_entry) returnerar -1;

< 0) return -1;

Next_cluster = fat16;

Låt oss spara innehållet i katalogen i en separat fil (för kontroll):

#ifdef DEBUG

Printf ("Nästa kluster - 0x% X", nästa_kluster);

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

Skriv (fat, dir_entry, root_size);

Stäng (fett);

#endif

Om det sista klustret nås, lämna slingan, annars fortsätter du att läsa katalogen, öka storleken på dir_entry-bufferten med ytterligare ett kluster:

Om (nästa_kluster & EOF_FAT16) bryter;

Start_kluster = nästa_kluster;

Returnera 0;

Funktionen get_dentry () söker i katalogens innehåll efter ett objekt som matchar filen du letar efter. Ingångarna till denna funktion är en pekare till en struktur split_name * sn som innehåller elementen i det korta filnamnet:

Int i = 0;

Den globala bufferten dir_entry innehåller en array av katalogposter där vi ska söka efter en fil (eller katalog)post. För att söka kommer vi att organisera en cykel. I slingans brödtext kopierar du katalogposterna till den globala dentry-strukturen och jämför värdet på namn- och ext-fälten för denna struktur med motsvarande fält i strukturen split_name * sn-struktur. Sammanträffandet av dessa fält betyder att vi hittade posten för den nödvändiga filen i arrayen av katalogelement:

för (;; i ++) (

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

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

Ha sönder;

Om (! Dentry.name) returnerar -1;

#ifdef DEBUG

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

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

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

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

#endif

Returnera 0;

All ovanstående kod finns i FAT16-katalogen, filen fat16.c. För att få den körbara modulen, skapa en Makefile med följande innehåll:

INCDIR = / usr / src / linux / include

PHONY = ren

Fett16: fett16.o split.o

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

% .o: % .c

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

Rena:

Rm -f * .o

Rm -f ./fett16

Programvaruimplementering av algoritmen för att läsa en fil från en logisk partition med filsystemet FAT12

Generellt sett är algoritmen för att läsa en fil från en FAT12-partition identisk med algoritmen för att läsa en fil från en FAT16-partition. Skillnaden ligger i proceduren för att läsa element från FAT12-tabellen. Vi betraktade FAT16-tabellen som en enkel array av 16-bitars element. Följande algoritm föreslås för att läsa element i FAT12-tabellen:

• multiplicera elementnumret med 1,5;
• extrahera ett 16-bitars ord från FAT genom att använda resultatet av föregående operation som en offset;
• om elementnumret är jämnt, utför AND-operationen på det lästa ordet och masken 0x0FFF. Om talet är udda, flytta ordet som läses från tabellen med 4 bitar mot de minst signifikanta bitarna.

Baserat på denna algoritm kommer vi att implementera funktionen för att läsa element från FAT12-tabellen:

int get_cluster (__ u16 kluster_num)

U16 söker;

U16 klunga;

Beräkna offset i FAT12-tabellen och läs 16-bitarsordet från tabellen:

Sök = (kluster_num * 3) / 2;

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

Om startnumret för klustret är ett jämnt tal, flyttar vi värdet som läses från tabellen med 4 bitar mot de lägre siffrorna, om det är udda lägger vi till det till 0x0FFF:

Om (kluster_num% 2) kluster >> = 4;

Else klust & = 0x0FFF;

Det här utdraget kan också implementeras i assembler:

"xorw %% yxa, %% yxa"

"btw $ 0, %% cx"

"jnc 1f"

"shrw $ 4, %% dx"

"jmp 2f"

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

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

: "= a" (nästa)

: "d" (klust), "c" (kluster_num));

Vi returnerar resultatet:

Returnera kluster;

Låt oss uppehålla oss lite mer vid själva algoritmen. Låt oss anta att en fil skapas på en FAT12-partition som upptar det 9:e och 10:e klustret. Varje FAT12-element är 12 bitar långt. Eftersom vi läser 16-bitars element från tabellen, då kommer offseten till det 9:e elementet att vara 13 byte (9 * 1,5 = 13, vi kasserar resten), medan de minst signifikanta 4 bitarna kommer att tillhöra det 8:e elementet i FAT. De måste kasseras, och för detta räcker det att flytta läselementet med 4 bitar mot de lägre siffrorna, som tillhandahålls av algoritmen. Förskjutningen till det 10:e elementet kommer att vara 15 byte, och de mest signifikanta 4 bitarna kommer att tillhöra det 11:e elementet i FAT. För att kassera dem är det nödvändigt att utföra AND-operationen på det 10:e elementet och masken 0x0FFF, vilket också motsvarar ovanstående algoritm.

Källkoderna för modulen för att läsa filen från FAT12-partitionen finns i FAT12-katalogen, filen fat12.c.

Programvaruimplementering av algoritmen för att läsa en fil från en logisk partition med filsystemet FAT32

Algoritmen för att läsa en fil från en partition med filsystemet FAT32 skiljer sig praktiskt taget inte från algoritmen för FAT16, förutom att i FAT32 kan rotkatalogen finnas var som helst på partitionen och ha godtycklig storlek. Därför, för att göra det mer intressant, låt oss komplicera uppgiften - låt oss anta att vi bara känner till partitionsnumret med FAT32-filsystemet. För att läsa information från detta avsnitt måste du först bestämma dess koordinater - förskjutningen till avsnittet från början av skivan. Och för detta måste du ha en uppfattning om den logiska strukturen på hårddisken.

Hårddiskens logiska struktur

Överväga logisk struktur hårddisk som överensstämmer med Microsofts standard - "primär partition - utökad partition - icke-DOS-partitioner."

Hårddiskutrymme kan organiseras som en eller flera partitioner och partitioner kan innehålla en eller flera logiska enheter.

Hårddisken på den fysiska adressen 0-0-1 innehåller Master Boot Record (MBR). MBR-strukturen innehåller följande element:

• icke-system bootstrap (NSB);
• (partitionstabell, PT). Ligger i MBR vid offset 0x1BE och upptar 64 byte;
• MBR-signatur. De två sista byten av MBR måste innehålla numret 0xAA55.

Partitionstabellen beskriver platsen och egenskaperna för de partitioner som är tillgängliga på hårddisken. Diskpartitioner kan vara av två typer - primära och utökade. Det maximala antalet primära partitioner är fyra. Det är obligatoriskt att ha minst en primär partition på disken. En utökad partition kan delas in i ett stort antal undersektioner - logiska enheter. Förenklat MBR-struktur presenteras i tabell 7. Partitionstabellen finns i slutet av MBR, 16 byte tilldelas för beskrivningen av partitionen i tabellen.

Tabell 7. MBR-struktur

Partiskhet Storlek, byte 0 446 0x1BE 16 0x1CE 16 0x1DE 16 0x1EE 16 0x1FE 2

Strukturen för posten i partitionstabellposten visas i tabell 8.

Tabell 8. Struktur för posten av partitionstabellelementet

Den första byten i sektionselementet är sektionsaktivitetsflaggan (0 - inaktiv, 0x80 - aktiv). Det tjänar till att avgöra om partitionen är en systemstartbar och om det finns ett behov av att starta operativsystemet från den när datorn startar. Endast en sektion kan vara aktiv. Den aktiva partitionens flagga följs av koordinaterna för början av partitionen - tre byte, vilket betyder huvudnummer, sektornummer och cylindernummer. Cylinder- och sektornummer anges i avbrottsformatet Int 0x13, d.v.s. bitarna 0-5 innehåller sektornumret, bitarna 6-7 är de två mest signifikanta bitarna av 10-bitars cylindernummer och bitarna 8-15 är de minst signifikanta åtta bitarna av cylindernumret. Detta följs av System-ID, som indikerar att det tillhör av detta avsnitt till ett visst operativsystem. Identifieraren är en byte. Bakom systemidentifieraren finns koordinaterna för slutet av sektionen - tre byte som innehåller numren på huvudet, sektorn respektive cylindern. De nästa fyra byten är antalet sektorer före partitionen, och de sista fyra byten är storleken på partitionen i sektorer.

Således kan ett sektionstabellelement beskrivas med hjälp av följande struktur:

struct pt_struct (

U8 startbar; // sektionsaktivitetsflagga

U8 start_del; // koordinater för början av avsnittet

U8 typ_del; // systemidentifierare

U8 slutdel; // koordinater för slutet av avsnittet

U32 sect_before; // antal sektorer före avsnittet

U32 sect_total; // partitionsstorlek i sektorer (antal sektorer i partitionen)

Elementet i den primära partitionen pekar direkt till startsektorn för den logiska disken (det finns alltid bara en logisk disk i den primära partitionen), och elementet i den utökade partitionen pekar på en lista med logiska diskar som består av strukturer som kallas sekundära MBR (SMBR).

Varje disk i den utökade partitionen har sitt eget SMBR-block. SMBR har en struktur som liknar MBR, men den har ingen startpost (fylld med nollor), och endast två av de fyra partitionsbeskrivningsfälten används. Det första elementet i partitionen pekar på den logiska disken, det andra elementet pekar på nästa SMBR-struktur i listan. Den sista SMBR i listan innehåller nollsektionskoden i det andra elementet.

Låt oss gå tillbaka till modulen för att läsa en fil från en FAT32-partition.

Rubrikfiler:

#omfatta

#omfatta

#omfatta

#omfatta

#omfatta

MBR-signatur:

#define SIGNATUR 0xAA55

Enhetsfil från vilken information om partitioner kommer att läsas:

#define DEVICE "/ dev / hda"

Partitionstabellelementstorlek (16 byte):

#define PT_SIZE 0x10

Följande uppsättning strukturer ställer in överensstämmelsen mellan sektionstypkoden och dess symboliska representation:

struktur systyper (

U8 del_typ;

U8 * delnamn;

struct systypes i386_sys_types = (

(0x00, "Tom"),

(0x01, "FAT12"),

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

(0x05, "Utökad"),

(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 utökad"),

(0x07, "HPFS / NTFS")

Bestäm antalet element i i386_sys_types-matrisen med hjälp av makrot PART_NUM:

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

Låt oss sätta en gräns för antalet logiska diskar:

#define MAX_DEL 20

Följande strukturmatris kommer att innehålla information om logiska diskar på enheten (hårddisk):

struct pt_struct (

U8 startbar;

U8 start_del;

U8 typ_del;

U8 slutdel;

U32 sect_before;

U32 sect_total;

) pt_t;

int hårt; // enhetsfilbeskrivning

U8 mbr; // räkna MBR här

Partitionsnummer som FAT32-filsystemet skapas på:

#define FAT32_PART_NUM 5

Bootsektor, FSInfo-sektor och katalogpoststrukturer (definierade i filen ):

struct fat_boot_sector fbs;

struct fat_boot_fsinfo fsinfo;

struct msdos_dir_entry dentry;

U32 * fat32 = NULL; // kopiera FAT32-tabellen här

U16 sektor_storlek; // sektorstorlek (från FAT32)

U16 dir_entries; // 0 för FAT32

U16-sektorer; // antal sektorer per partition

U32 fat32_size; // FAT32 storlek

U32 data_start; // start av dataområde

U16 byte_per_cluster; // hur många byte finns i klustret (klusterstorlek i byte)

U32 nästa_kluster; // nästa kluster i kedjan

U32 root_cluster; // ROOT-kluster - initialt rotkluster

U8 * dir_entry = NULL; // pekare till katalogposter

U64 start_seek = 0; // startoffset till sektion (i byte)

Huvudfunktion:

int main ()

Int num = 0;

Int kluster_num = 5; // hur många kluster som ska läsas från filen

U8 * full_path = "/ Folder1 / Folder2 / readme"; // fil att läsa

Vi öppnar enheten, får information om partitionstabellen på enheten och visar information om partitionerna:

Hard = öppen (DEV_NAME, O_RDONLY);

Om (svårt< 0) {

Fel (DEV_NAME);

Avsluta (-1);

If (get_pt_info (hårt)< 0) {

Perror ("get_pt_info");

Avsluta (-1);

Show_pt_info ();

Vi beräknar startoffset för sektionen:

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

Vi läser klustren som hör till filen:

Num = fat32_read_file (full_path, cluster_num);

Om (antal< 0) perror("fat32_read_file");

Else printf ("Läs% d kluster \ n", num);

Stäng (hårt);

Returnera 0;

Information om partitionstabellen läses av funktionen get_pt_info ():

int get_pt_info (int hard)

Int i = 0;

U64 söker;

Vi läser partitionstabellen från MBR och kontrollerar signaturen:

Read_main_ptable (hårt);

If (check_sign ()< 0) {

Printf ("Ogiltig signatur! \ N");

Returnera -1;

Vi letar efter identifieraren för den utökade sektionen. Om det finns en, beräknar vi offset till den utökade partitionen och läser informationen om de logiska diskarna:

för (; jag< 4; i++) {

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

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

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

Sök = (__u64) pt_t [i] .sect_before * 512;

Read_ext_ptable (hårt, sök);

Ha sönder;

Returnera 0;

Read_main_ptable () funktion för att läsa partitionstabellen:

void read_main_ptable (int hard)

Om (läs (hård, mbr, 512)< 0) {

Perror ("läs");

Stäng (hårt);

Avsluta (-1);

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

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

Lämna tillbaka;

Signaturkontrollfunktion check_sign ():

int check_sign ()

U16 tecken = 0;

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

#ifdef DEBUG

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

#endif

Om (tecken! = SIGNATUR) returnerar -1;

Returnera 0;

Läsfunktionen för utökad partitionstabell:

void read_ext_ptable (int hard, __u64 seek)

Int num = 4; // från denna position kommer arrayen av pt_t-strukturer att fyllas med information om logiska diskar

U8 smbr;

Indata:

• hård- enhetsfilbeskrivning;
• söka- offset till den utökade partitionen från början av disken (i byte).

För att få information om logiska diskar organiserar vi en cykel:

För (;; num ++) (

Vi läser SMBR som finns vid offsetsökningen från början av skivan:

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

Pread64 (hård, smbr, 512, sök);

Vi fyller två element i tabellen pt_t, med start från position num. Det första objektet pekar på den logiska enheten och det andra på följande SMBR-struktur:

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

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

Vi gör en ändring av fältet "Nummer på startsektorn" - räkningen är från början av skivan:

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

Om partitionstypens kod är noll, finns det inga fler logiska enheter:

Om (! (Pt_t.type_part)) bryta;

Beräkna offset till nästa SMBR:

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

Lämna tillbaka;

Funktionen show_pt_info () visar information om de hittade logiska enheterna på enheten:

void show_pt_info ()

Int i = 0, n;

#ifdef DEBUG

Printf ("Antal partitioner på disken -% d \ n", PART_NUM);

#endif

För (; jag< MAX_PART; i++) {

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

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

För (n = 0; n< PART_NUM; n++) {

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

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

Ha sönder;

If (n == PART_NUM) printf ("okänd typ \ n");

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

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

Printf ("Sektorer före avsnitt% d -% d \ n \ n", i, pt_t [i] .sect_before);

Lämna tillbaka;

Att läsa filkluster från en FAT32-partition utförs av funktionen fat32_read_file (). Den här funktionen har mycket gemensamt med funktionen fat16_read_file (), så se avsnitt 6 för detaljerade kommentarer:

int fat32_read_file (__ u8 * full_path, int num)

Struktur split_name sn;

U8 tmp_name_buff;

Int i = 1, n;

U32 start_kluster, nästa_kluster;

U8 * tmp_buff;

Förberedande åtgärder - rensa bufferten, strukturera och kontrollera det första snedstrecket:

Memset (tmp_name_buff, 0, SHORT_NAME);

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

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

Vi läser bootsektorn:

Om (läs_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 läser FSInfo-strukturen och visar signaturen som finns i den:

Om (läs_fs_info ()< 0) return -1;

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

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

Fat32_size = fbs.fat32_length * 512; // FAT32-storlek i byte

Data_start = 512 * fbs.reserved + fat32_size * 2; // start av datafält

Byte_per_cluster = fbs.cluster_size * 512; // klusterstorlek i byte

Root_cluster = fbs.root_cluster; // klusternummer för rotkatalogen

Vi läser FAT32:

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

Tilldela minne för katalogposter:

Dir_entry = (__u8 *) malloc (byte_per_cluster);

Om (! Dir_entry) returnerar -1;

Vi läser rotkatalogen:

If (läs_katalog (root_kluster)< 0) return -1;

Vi analyserar hela sökvägen för filen och delar upp varje element i dess komponenter:

Medan (1) (

Memset (tmp_name_buff, 0, SHORT_NAME);

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

För (n = 0; n< SHORT_NAME; n++, i++) {

Tmp_name_buff [n] = fullständig_sökväg [i];

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

I ++;

Ha sönder;

Tmp_name_buff [n] = "\ 0";

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

Printf ("ogiltigt namn \ n");

Returnera -1;

If (get_dentry (& sn)< 0) {

Printf ("Ingen sådan fil! \ N");

Returnera -1;

För att få startnumret för ett kluster i FAT32-filsystemet, måste du använda det mest signifikanta ordet av numret för det första klustret i filen - starthi-fältet för tandbehandlingsstrukturen:

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

Kontrollera attributbyten:

If (dentry.attr & 0x10) (// detta är en katalog

If (läs_katalog (start_kluster)< 0) return -1;

Fortsätta;

If (dentry.attr & 0x20) (// och detta är en fil

Tmp_buff = (__u8 *) malloc (byte_per_kluster);

N = öppen ("klust", O_CREAT | O_RDWR, 0600);

Om (n< 0) {

Perror ("öppen");

Returnera -1;

Printf ("filens första kluster - 0x% X ..", start_cluster);

För (i = 0; i< num; i++) {

Memset (tmp_buff, 0, byte_per_cluster);

If (läs_kluster (start_kluster, tmp_buff)< 0) return -1;

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

Perror ("skriva");

Returnera -1;

Om (nästa_kluster == EOF_FAT32) (

Gratis (tmp_buff);

Stäng (n);

Returnera ++ i;

Start_kluster = nästa_kluster;

Returnera i;

Syftet med de kommande tre funktionerna är att få fram innehållet i systemområdet, d.v.s. bootsektor, FSInfo-struktur och FAT32-tabell:

1) funktionen read_fbs () läser uppstartssektorn:

int read_fbs ()

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

Returnera 0;

2) funktionen read_fs_info () läser FSInfo-strukturen:

int read_fs_info ()

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

If (pread64 (hård, (__u8 *) & fsinfo, sizeof (fsinfo), sök)< 0) return -1;

Returnera 0;

3) funktionen read_fat32 () läser FAT32-tabellen:

int read_fat32 ()

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

Fat32 = (void *) malloc (fat32_size);

Om (! Fat32) returnerar -1;

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

Returnera 0;

Funktionen read_cluster () läser klustret med det angivna numret:

int read_cluster (__ u32 cluster_num, __u8 * tmp_buff)

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

If (pread64 (hård, tmp_buff, byte_per_cluster, seek)< 0) return -1;

Returnera 0;

Att läsa kataloger (inklusive roten) hanteras av funktionen read_directory ():

int read_directory (__ u32 start_cluster)

Int i = 2;

U32 nästa_kluster;

Funktionsparametrar - startkatalogkluster. Vi läser in innehållet i katalogen i den globala bufferten dir_entry:

If (läs_kluster (start_kluster, dir_entry)< 0) return -1;

Next_cluster = fat32;

Om katalogen upptar ett kluster - avsluta, om inte - öka minnesstorleken och fortsätt läsa:

För (;; i ++) (

Start_kluster = nästa_kluster;

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

Om (! Dir_entry) returnerar -1;

If (läs_kluster (start_kluster, (dir_entry + (i - 1) * byte_per_cluster))< 0) return -1;

Next_cluster = fat32;

Om ((nästa_kluster == EOF_FAT32) || (nästa_kluster == 0xFFFFFF8)) returnerar 0;

Returnera 0;

Den sista funktionen vi tittar på söker igenom innehållet i en katalog efter ett element som matchar filen du letar efter:

int get_dentry (struktur split_name * sn)

Int i = 0;

dir_entry-pekaren är inställd på ett minnesområde som innehåller en rad katalogposter där vi ska söka efter en fil (eller katalog). För att söka organiserar vi en cykel och lägger in den hittade posten i den globala tandvårdsstrukturen:

För (;; i ++) (

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

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

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

Ha sönder;

Om (! Dentry.name) returnerar -1;

Returnera 0;

Detta avslutar granskningen av modulen för att läsa en fil från en FAT32-partition.

Modulens källkoder finns i FAT32-katalogen, filen fat32.c.

Skillnader i organisationen av att lagra filposter i kataloger för FAT- och EXT2-filsystem

Några ord om skillnaderna i organisationen av att lagra filposter i kataloger för FAT- och EXT2-filsystem. EXT2-filsystemstrukturen diskuterades i.

Vi har precis bekantat oss med FAT - i den har alla delar av katalogen en fast storlek. När du skapar en fil letar filsystemdrivrutinen efter den första lediga positionen och fyller den med information om filen. Om längden på katalogen inte passar i ett kluster, tilldelas ett annat kluster för det, etc.

Låt oss se hur det är i EXT2.

Anta att vi har en partition med filsystemet EXT2, blockstorleken är 4096 byte. I det här avsnittet skapar vi en katalog. Katalogstorleken kommer att vara lika med blockstorleken - 4096 byte. Operativsystemet skapar omedelbart två poster i katalogen - posten för den aktuella katalogen och posten för den överordnade katalogen. Den aktuella katalogposten kommer att ta 12 byte, medan den överordnade posten kommer att vara 4084 byte. Låt oss skapa en fil i den här katalogen. Därefter kommer katalogen att innehålla tre poster - den aktuella katalogposten är 12 byte lång, den överordnade katalogposten är redan 12 byte lång, och den skapade filposten är, som du säkert gissat, 4072 byte lång. Om vi ​​tar bort den skapade filen kommer längden på den överordnade katalogposten att växa igen till 4084 byte.

När du skapar en fil letar EXT2 filsystemdrivrutinen i katalogen efter en post med maximal längd och delar upp den, vilket ger plats för nytt inlägg... Tja, om det trots allt inte finns tillräckligt med utrymme tilldelas ytterligare ett block för katalogen, och katalogens längd blir lika med 8192 byte.

Och avslutningsvis - en liten korrigering till artikeln "Arkitektur för EXT2-filsystemet".

Denna revision gäller funktionen get_i_num () för att bestämma inodnumret efter filnamn. Gammal variant denna funktion såg ut så här:

int get_i_num (char * namn)

Int i = 0, rec_len = 0;

Struktur ext2_dir_entry_2 buckla;

För (; jag< 700; i++) {

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

Rec_len + = dent.rec_len;

Returnera dent.inode;

Korrigerad version:

int get_i_num (char * namn)

* Funktionsparameter - filnamn. Returvärdet är filens inodnummer.

Int rec_len = 0;

Struktur ext2_dir_entry_2 buckla; // den här strukturen beskriver formatet för rotkatalogposten:

* Den globala buffen innehåller en rad katalogposter. För att bestämma serienumret på filens inod måste du hitta

* i denna array, en post med namnet på denna fil. För att göra detta kommer vi att organisera en cykel:

För (;;) (

/ * Kopiera katalogposter till dentstruktur: * /

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

* Längden på filnamnet lika med noll betyder att vi har räknat upp alla katalogposter

* och poster med namnet på vår fil hittades inte. Så det är dags att gå tillbaka:

Om (! Dent.name_len) returnerar -1;

/ * Sökning utförs genom att jämföra filnamn. Om namnen matchar, lämna loopen: * /

Om (! Memcmp (dent.namn, namn, strlen (namn))) bryter;

/ * Om namnen inte stämmer överens, gå till nästa post: * /

Rec_len + = dent.rec_len;

/ * Om det lyckas, returnera inodnumret för filen: * /

Returnera dent.inode;

Litteratur:

1. V. Kulakov. Hårdvaruprogrammering: En speciell referens. 2:a uppl. / - SPb .: Peter, 2003 - 848 sid.
2. A.V. Gordeev, A.Yu. Molchanov. Systemprogramvara / - SPb .: Peter - 2002
3. Meshkov V. Arkitektur för ext2-filsystemet. - Tidning" Systemadministratör", nr 11 (12), november 2003 - 26-32 sid.

I kontakt med

Den här artikeln kommer att diskutera användningen av olika filsystem på externa lagringsmedia: flash-enheter, minneskort, externa hårddiskar, etc. Så idag används följande filsystem för enheter: ...

* FAT32
* NTFS
* exFAT

Låt oss gå igenom var och en av dem i detalj och överväga fördelarna, nackdelarna och funktionerna för användning på olika enheter.

Ett filsystem skapat av Microsoft för att ersätta den döende FAT16. För närvarande det vanligaste systemet. De flesta minneskort och flashenheter levereras i FAT32. Dessutom, när du formaterar ett medium i en konsumentenhet, till exempel en kamera, kommer det att fungera i detta filsystem. Detta är dess främsta fördel - kompatibilitet. Genom att sätta in en sådan enhet i en hushålls DVD-spelare, mediaspelare eller fotoskrivare kan du vara säker på att alla filer är tillgängliga och kan läsas normalt. Det är här proffsen slutar.

Den största nackdelen med detta system är begränsningen på 4 GB filstorlek. Skriv därför stor fil(till exempel en säkerhetskopia av systemdisken eller en video som skrivits över från en kamera) kommer inte att fungera. Dessutom har Windows en partitionsstorlek på 32 GB. Du kan komma runt den sista begränsningen genom att ladda ner HP USB Utility Disklagring Format Tool, som låter dig formatera valfri extern hårddisk i FAT32.

Men om du inte behöver spela in och överföra så stora filer, och även om du har en liten mediastorlek: 4, 8 eller till och med 16 GB, kan du formatera den i FAT32 utan att tveka.
Företaget Transcend, som tillverkar mobila databärare, formaterar förresten sina externa hårddiskar i FAT32.

Ett modernt, pålitligt filsystem som går tillbaka till Windows NT.
I stationära datorer och bärbara datorer ersatte den FAT32. Kontrollera om du fortfarande har FAT32 installerat (klicka Högerklicka på disken i Den här datorn och välj Egenskaper), rekommenderar jag starkt att du ersätter den med NTFS.

Hur man konverterar FAT32 till NTFS utan dataförlust

Detta kan göras enligt följande. Vid kommandotolken (Start-Run) skriv

konvertera e: / fs: ntfs

Istället för e: kan du ersätta den nödvändiga disken. Detta kommer att ändra filsystemet till NTFS ingen dataförlust.

NTFS fungerar dock något annorlunda på flash-enheter och externa hårddiskar. När du kopierar till en sådan enhet aktiverar Windows cachningsmekanismen när filer först kopieras till speciellt minne(den så kallade cachen), och sedan till det slutliga mediet. I stationära hårddiskar låter detta dig få en vinst i kopieringshastighet och jämna ut förseningar. På mobila enheter kommer det att se ut så här. Till en början kommer kopieringshastigheten att vara mycket hög och kan nå 100 MB/s (teoretiskt lika med läshastigheten på hårddisken som du kopierar från), sedan när cacheminnet tar slut kommer hastigheten att sjunka till en kritisk lågt värde. Dessutom, innan du fortsätter att kopiera nästa fil, måste systemet lägga till den nuvarande från cachen. Därför kan det se ut som att kopian har fastnat till 99 procent, även om hårddiskindikatorn visar aktivitet. Om vi ​​jämför kopieringshastigheten med och utan cache visar det sig att den är nästan identisk. Det vill säga, när vi använder NTFS förlorar vi nästan ingenting, förutom den felaktiga kopieringshastigheten och information om tidpunkten för dess slutförande. Även om en del av detta "informationsinnehåll" kan slita nerver.

Detta är kopieringshastigheten som \ "utvecklas\"
USB 2.0 hårddisk i NTFS

NTFS \ "verkar underverk", kopiering till en 512 MB flash-enhet,
vars verkliga skrivhastighet är flera MB/s

Å andra sidan är NTFS ett extremt pålitligt filsystem som tål mer än en plötslig återställning. Denna tillförlitlighet tillhandahålls av journalföring. Detta kommer att få systemet att komma åt vissa delar av enheten oftare. För flashenheter och minneskort är detta tillvägagångssätt kritisk. De kommer att slitas ut snabbare.

Nytt filsystem från Microsoft. Designad främst för flash-enheter. Om man överdriver kan vi säga att detta är FAT32 med borttagna restriktioner. Storleken på filer och partitioner kan nå kosmiska värden, och antalet filer i en mapp är inte längre begränsat. Enligt min mening, perfekt för flash-enheter och minneskort.

Men detta system har också en nackdel. Många konsumentenheter stöder inte det, och datorer med Windows XP kommer inte heller att se sådana media. Microsoft har dock släppt patch KB955704 för att göra det möjligt för exFAT att användas på Windows XP. Windows Vista och Windows 7 är vänner med detta system utan ytterligare manipulation.

Men om du ofta använder en flash-enhet på olika datorer När du använder Windows XP måste du ha en extra USB-flashenhet med drivrutiner. Det här är bara löjligt.

Men om du bara har datorer med Windows 7 eller du bär ett USB-minne/disk på endast 2-3 ställen där det är möjligt att installera ovanstående uppdatering, så är exFAT perfekt.

Tillägg
Artikeln är hämtad från öppna källor: http://winitpro.ru/index.php/2011/06/20/fajlovaya-sistema-exfat/
ExFAT filsystem

Tillsammans med lanseringen av Vista SP1 introducerade Microsoft ett nytt filsystem. ExFAT (Extended File Allocation Table) är efterföljaren till det gamla FAT32-filsystemet. Så vad är de främsta fördelarna och nackdelarna med exFAT-filsystemet. Vad är skillnaderna mellan exFAT och FAT32? Och när är det bättre att använda exFAT över NTFS?

FAT32-filsystemet är ett ganska gammalt och välbekant filsystem, men det har ett antal betydande nackdelar: det stöder inte partitioner större än 2 TB och filer större än 4 GB. För att lösa de beskrivna problemen i FAT32 skapades exFAT-filsystemet. ExFAT är Microsoft utveckling designad främst för mobila media (flash-enheter, SSD-enheter, smartkort). Det bör genast noteras att ExFAT inte används för att formatera hårddiskar. Allt senaste versionerna Windows såväl som Mac OS X stöder detta filsystem. ExFAT kallas också ofta för FAT64, vilket innebär möjligheten att arbeta med enheter och filer större storlek.

De viktigaste fördelarna med exFAT-filsystemet:

* Maximal klusterstorlek ökad till 32 MB
* Ökade maximal storlek fil i exFAT från 4 GB till 264 byte (16 EB).
* Ingen begränsning på antalet filer i en katalog
* Stöd för fil-/katalogbehörigheter
* Transaktionsstöd vid skrivning (om det stöds av fysisk enhet)
* Effektiv användning ledigt utrymme, vilket bidrar till att avsevärt minska diskfragmenteringen.

Det är värt att notera att vid formatering i exFAT är mängden tillgängligt utrymme på lagringsenheter större än när man använder FAT32. Om du till exempel formaterar ett 4 GB USB-minne (nominell kapacitet 4023 MB) i olika filsystem får du följande:

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

ExFAT är optimerat för att arbeta med flash-enheter, såsom USB-minnen, minneskort och SSD-enheter, klusterstorleken på 32 KB lämpar sig väl för stora kort och enheter med ökat slitage när man utför läs- och skrivoperationer. ExFAT-systemet har också möjlighet att hantera åtkomsträttigheter till filer/kataloger, och dataåtkomsttiden har minskat. En av de största nackdelarna med exFAT-systemet är att denna teknik omfattas av Microsofts licenspolicy och inte på något sätt öppen källa beslut kan den inte tillämpas. För att använda det i vilket operativsystem som helst måste du betala licensavgifter till Microsoft (denna regel gäller inte för enkla Mobil enheter som kameror, spelare, etc.).

exFAT på moderna Windows 7-operativsystem

Den nya versionen av Microsoft Windows 7 stöder fullt ut exFAT-filsystemet och alla dess funktioner i både 32- och 64-bitarsversioner. Dessutom kan externa flashenheter formaterade i exFAT användas för att arbeta med ReadyBoost-tekniken (och det kommer inte att finnas fler 4 GB-gränser).

Windows Vista

Windows Vista stöder endast exFAT från och med Service Pack 1. Dessutom stöds inte vissa funktioner såsom åtkomstkontroll. Till skillnad från Windows 7 stöds inte exFAT-enheter i Vista för ReadyBoost.

Windows XP

ExFAT stöds inte i Windows XP, men drivrutinen kan laddas ner från Microsofts webbplats (beskrivning i KB 9555704 - http://support.microsoft.com/kb/955704), men det kräver att Service Pack 2 är installerat .

För äldre versioner av Windows finns det inget officiellt stöd för exFAT.

Windows Server

ExFAT stöds fullt ut på Windows Server 2008, och genom att installera drivrutinen ovan, även på Windows Server 2003.

Snöleopard

Mac OS X stöder exFAT sedan version 10.6.4 (15 juni 2010), men endast på Mac-datorer med SDXC-kortläsare. Mac mini och iMac är exFAT-kompatibla.

Linux-system stöder inte exFAT, även om det finns flera lösningar, men de flesta av dem är betalda eller obekväma, dessutom sätter Microsoft, med sin egenutvecklade licens, en eker i hjulen på oberoende utvecklare.

ExFAT och FAT32

När den testades på Windows 7 visade den samma prestanda som FAT32, men NTFS är fortfarande något snabbare. Kommer exFAT att ersätta FAT32? Detta kommer sannolikt att hända först efter en massiv uppgradering till Windows 7 eller nyare versioner av Windows. För konsumenter kommer den största fördelen med exFAT att vara att övervinna FAT32-filbegränsningarna (ökning av filstorleken i exFat).

Vi måste också komma ihåg att exFAT-filsystemet kräver en nyare OS-version (hårdvaruuppgradering kan krävas), liksom det faktum att exFAT helt enkelt inte stöds på äldre enheter (kameror, mp3-spelare).

exFat eller NTFS

ExFAT kan betraktas som en konkurrent till NTFS på system med begränsad processorkraft och minne. Dessutom är NTFS-filsystemet på flashkort mycket obekvämt och ineffektivt att använda (arbetshastigheten minskar och flashminnets livslängd), och det är ExFAT som kommer att vara det ideala filsystemet för sådana enheter.

Avslutningsvis ska jag ge några allmänna rekommendationer genom att välja det mest lämpliga filsystemet. Om du har en liten flash-enhet, formatera den till FAT32. Formatera flashenheter med exFAT, eftersom "hastighetshopp" kommer att märkas särskilt på dem. Externa hårddiskar är vanligtvis stora och presterande (särskilt de med USB-kontakter 3.0), så det är bäst att formatera dem med NTFS.

Artikeln är hämtad från öppna källor: http://pc-hard.ru/softarticles/1-fat32-ntfs-exfat-comparsion.html

Låt oss analysera typerna av filsystem för en flash-enhet, vilken är bättre. En användare skickade ett foto till mig med felet "Filen är för stor för målfilsystemet" och bestämde sig för att skriva en artikel i vilka fall man skulle använda FAT32, NTFS och exFAT-system. Han flyttade en fil större än 4 GB till en 8 GB-sticka. Faktum är att FAT32-systemet inte kan behandla information över 4 GB, om din flashenhet har en volym på 32 GB och dess filsystem är FAT32, kan du inte skriva en fil över 4 GB till den. Låt oss ta en titt på alla tre filsystemen i Windows, låt oss titta på deras för- och nackdelar.

FAT32

Det gamla filsystemläget, som vanligtvis används när man köper ett USB-minne från en butik, och anledningen till detta är kompatibilitet. Kompatibilitet är att FAT32 kan användas på alla MAC, Windows, Linux, gamla datorer. Den största begränsningen är att den har en filstorleksgräns på 4GB, vilket idag har problem med format som 4k-video, Blu-ray. Kort sagt, om du ska arbeta med filer som är mindre än 4 GB och flashenheten används på olika datorer med olika operativsystem, så är filsystemet FAT32 mycket lämpligt.

exFAT

Uppdaterat filsystem skapat av microsoft för att ersätta FAT32. Började med Windows Vista SP1 och har en maximal filstorlek på 16 exabyte (EB), vilket är 1 EB = 10 18 byte. Kompatibel med Mac OS och Windows, det är ett mycket bra system för att utbyta stora filer.

Minus:

• Den har ingen form av loggningsfunktion där alla ändringar av filer på disken loggas innan de faktiskt utförs.
• Stöds inte av Time Machine hos Apple. Kort sagt, du kommer inte att kunna säkerhetskopiera från Apple med programvaran Time Machine.
• En mycket komplex struktur som kräver mer datorkraft.

Fördelar:

• Skriver över samma sektor färre gånger, vilket är viktigt för flashenheter, vilket förlänger minnescellernas livslängd. Som du vet har flash-enheter N-antal omskrivningar och misslyckas sedan.
• Stor filstorleksgräns på 16 exabyte.
• Klusterstorleken är 32 megabyte.
• Förbättrad tilldelning av ledigt utrymme, vilket minskar diskdefragmentering.

NTFS

Det senaste filsystemet skapat av Microsoft och är en modern struktur i dag för nästan vilken modern intern hårddisk, flash-enhet eller ssd-enhet som helst. NTFS är en ny filsystemsteknik. Windows kan bara installeras på NTFS. Det är standard för operativsystemdiskar på grund av dess mångsidighet. Den har alla Microsoft-teknologier: loggning, ingen filstorleksgräns, filkomprimeringsstöd, långa namn, filåtkomstkontroll för serveradministratörer och mycket mer. Hemma är detta det bästa alternativet för att använda detta system på diskar och flashenheter. Det finns en hake, när du sätter i ett USB-minne i Mac OS kan du kopiera information från ett USB-minne, men ingen förändring.

Produktion:

För USB-minnen måste du använda exFAT, om du ständigt är i Mac OS, Windows-miljön och flyttar USB-flashenheten från ett operativsystem till ett annat. Om du bara använder Windows är NTSF en bra lösning.

vfat är en implementering av MS-DOS FAT / FAT32 filsystem i Linux. manfäste (8)

En typisk uppsättning vfat-monteringsalternativ för en UTF-8-lokal (som utelämnar alternativ, vars standardvärde är föråldrat):

uid = användarnamn, gid = gruppnamn, fmask = 0113, dmask = 0002, kodsida = 866, utf8, kortnamn = winnt, tyst

För en icke-UTF8-lokal, och detta är troligen en KOI8-R-lokal (inte att glömma nu "utf8 = no" som är obligatoriskt för RHEL / CentOS):

uid = användarnamn, gid = gruppnamn, fmask = 0113, dmask = 0002, kodsida = 866, iocharset = koi8-r, utf8 = nej, kortnamn = winnt, tyst

eller med tanke på att "uni_xlate" inaktiverar "utf8", desto mer är det bättre att se de kodade namnen på filer/kataloger som du på något sätt kan hantera än rader som inte kan skiljas från "?":

uid = användarnamn, gid = gruppnamn, fmask = 0113, dmask = 0002, kodsida = 866, iocharset = koi8-r, uni_xlate, kortnamn = winnt, tyst

användarnamn och gruppnamn - användarnamn och gruppnamn som beviljas läs-/skrivbehörighet till den monterade FAT/FAT32-partitionen i enlighet med uppsättningen fmask och dmask

De allmänna monteringsalternativen varierar beroende på om du monterar via kommandoraden eller genom att skriva till / etc / fstab, eller om du behöver automontera vid start, rw / ro-läge eller tillåta användare att montera / avmontera en partition. Vanligen använd: rw, asynkron
Av säkerhetsskäl, för FAT / FAT32-partitioner, kan du uttryckligen ange: nodev, nosuid, noexec
För att snabba upp kan du använda: noatime, nodiratime

Monteringsalternativ är listade i man mount (8) under "Monteringsalternativ för fett" och "Monteringsalternativ för vfat".
Monteringsalternativ för fett
=====================

blockstorlek = 512 / blockstorlek = 1024 / blockstorlek = 2048
Ställ in blockstorlek (standard 512).
I/O-blockstorlek.

uid = värde och gid = värde
Ställ in ägare och grupp för alla filer. (Standard: uid och gid för den aktuella processen.)

Eftersom FAT / FAT32 inte stöder ägande och åtkomst till filer och kataloger, allt
partitionen är monterad som standard med processägarens uid och gid
montering. Du kan ange önskad användare och grupp på uppdrag av vilken
FAT / FAT32-partitionen kommer att monteras. Dessa kan vara som numeriska värden för identifierare
så och användar- / gruppnamn, åtminstone från kommandoraden finns en enkel
ställa in användar-/gruppnamn.

umask = värde
Ställ in umask (bitmasken för de behörigheter som inte finns). Standard är umask
av den pågående processen. Värdet anges i oktal.

dmask = värde
Ställ in umasken som endast tillämpas på kataloger. Standard är umasken för den aktuella processen.
Värdet anges i oktal.

fmask = värde
Ställ in umasken som endast tillämpas på vanliga filer. Standard är umasken för den aktuella processen.
Värdet anges i oktal.

umask, dmask, fmask - behörighetsmasker för filer/kataloger (umask) eller separat för
kataloger (dmask) och separat för filer (fmask). I själva verket etableras rättigheter genom dem
ägare (u), grupp (g) och andra användare (o) för alla filer och kataloger på fästet
avsnitt vfat. Anges som ett oktalt tal. (Förresten, att skriva det oktala värdet
behöver inte börja på noll.)

check = värde
Tre olika nivåer av kräsenhet kan väljas:
r
Versaler och gemener accepteras och likvärdiga, långa namndelar är trunkerade
(t.ex. verylongname.foobar blir verylong.foo), ledande och inbäddade utrymmen är
accepteras i varje namndel (namn och tillägg).
n
Som "avslappnad", men många specialtecken (*,?, Detta är standard.
s
Som "normalt", men namn får inte innehålla långa delar och specialtecken som
används ibland på Linux, men accepteras inte av MS-DOS avvisas.
(+, =, mellanslag, etc.)

Styr kontrollen av de genererade fil-/katalognamnen på vfat-partitionen för att matcha
FAT / FAT32 regler och begränsningar. Standard är "n".

teckentabell = värde
Ställer in teckentabellen för konvertering till kortnamnstecken på FAT- och VFAT-filsystem.
Som standard används teckentabell 437.

Det är bättre att ange monteringsparametern. Ställer in dos-kodsidan där
de skapade korta (i 8.3-format) DOS-fil- och katalognamnen sparas.
För de som fortfarande arbetade i DOS och satte upp det bör denna siffra inte glömmas bort - för en normal
läsa / spara ryska namn - teckentabell = 866

conv = b / conv = t / conv = a
Fettfilsystemet kan utföra CRLFNL (MS-DOS textformat till UNIX textformat) konvertering
i kärnan. Följande konverteringslägen är tillgängliga:
binär - Ingen översättning utförs. Detta är standard.
text - CRLFNL-översättning utförs på alla filer.
auto - CRLFNL-översättning utförs på alla filer som inte har en "välkänd
binär "tillägg. Listan över kända tillägg kan hittas i början
av fs / fat / misc.c (från och med 2.0 är listan:
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).
Program som gör beräknade lseeks gillar inte textkonvertering i kärnan.
Flera personer har fått sina uppgifter förstörda av denna översättning. Akta sig!
För filsystem monterade i binärt läge finns ett konverteringsverktyg (fromdos / todos) tillgängligt.

Försöker att underlätta överföringen av textfiler från UNIX-liknande system till MS-DOS med hjälp av automatisk
ersätter CRLFNL i farten. Det är bättre att använda om nödvändigt för specifika filer kommando
verktyg för att konvertera dos2unix och unix2dos från paketen med samma namn, eller den universella iconv
ingår i glibc-common-paketet.

cvf_format = modul
Tvingar föraren att använda CVF-modulen (Compressed Volume File) cvf_module istället för
automatisk upptäckt. Om kärnan stöder kmod, styr alternativet cvf_format = xxx också

cvf_option = alternativ
Alternativet skickas till CVF-modulen.

cvf_format, cvf_option - parametrar som indikerar en specifik CVF-modul och dess alternativ
för laddning av kärnan. Jag vill inte förstå vad det är.

felsöka
Slå på felsökningsflaggan. En versionssträng och en lista över filsystemparametrar kommer att skrivas ut
(dessa data skrivs också ut om parametrarna verkar vara inkonsekventa).

Att döma av beskrivningen slår den på utdata från en rad med filsystemets version och parametrar när
montering av en FAT / FAT32-partition.

fett = 12 / fett = 16 / fett = 32
Ange ett 12, 16 eller 32 bitars fett. Detta åsidosätter den automatiska FAT-typdetekteringsrutinen.
Använd med försiktighet!

Istället för att automatiskt detektera FAT-typen kan du ange en specifik version av den.

iocharset = värde
Teckenuppsättning för att konvertera mellan 8-bitars tecken och 16-bitars Unicode-tecken.
Standard är iso8859-1.
Långa filnamn lagras på disken i Unicode-format.

Denna parameter bör anges om en icke-UTF8-användare/systemlokal används.
Som skrivet sparas långa fil- och katalognamn i VFAT-sektionen i Unicode-format.
För att säkerställa att när du överför till en icke-UTF8-konfigurerad lokal för användarapplikation,
Unicode-tecken konverterades till en åttabitars kod som lämpar sig för detta språk, du måste
ställ in den nödvändiga transformationstabellen för iocharset.
Som standard, om inte specificerat, iocharset = ascii, dvs. långa namn antas
filer / kataloger består av tecken från ASCII-uppsättningen, för vilka den triviala
(en-till-en) konverterar Unicode ASCII-koder.
För KOI8-R-lokalen måste du ange en tabell för att konvertera tecken till KOI8-R-koder från tecken
Unicode - iocharset = koi8-r (se /usr/share/i18n/charmaps/KOI8-R.gz).
Iocharset-tilldelningen är bara meningsfull om systemet (eller för en specifik användare,
för vilken partitionen monteras) använder en icke-UTF8-lokal.
För UTF-8-språk, hoppa över alternativet iosharset och montera partitionen med en special
designad för detta tillfälle fristående alternativ"utf8" (se beskrivning nedan).

tyst
Slå på den tysta flaggan. Försök att chown- eller chmod-filer ger inga fel, även om de misslyckas.
Använd med försiktighet!

Undertrycker felmeddelanden när du försöker "chown" eller "chmod" filer på en partition
FAT / FAT32. I allmänhet, även om de varnar för att använda det här alternativet med försiktighet, gör det det
det dagliga arbetet med vfat-partitioner är bekvämare, och hoppar över applikationsförfrågningar på ett transparent sätt
att utföra FAT / FAT32-funktioner som inte stöds som ständigt dyker upp då och då.
Till exempel när du säkerhetskopierar en redigerad fil i gedit eller använder rsync
med det vanliga alternativet "-a". Du behöver bara komma ihåg att partitionen du arbetar med är FAT / FAT32 och
ta hänsyn till att filerna som placeras på den alltid får ägaren och det angivna åtkomstläget
vid montering. I avsaknad av detta alternativ måste du också komma ihåg detta, eftersom ständigt
du får fel under säkerhetskopieringen (du måste till exempel registrera rsync-alternativ speciellt)
eller varningar när filer flyttas på grund av omöjligheten att byta ägare och tid.
Försiktighet bör iakttas när du gör det motsatta - hämta filer från vfat-partitioner
med ägarinstallation.

sys_immutable, showexec, dots, nodots, dotsOK =
Olika missriktade försök att tvinga in Unix- eller DOS-konventioner på ett FAT-filsystem.

Olika försök, med varierande grad av framgång, att harmonisera Unix- och DOS-konventioner för
FAT filsystem. Ett exempel och en beskrivning av användningen av parametern "showexec" finns i den här en av de sällsynta artikeln som inte innehåller felaktig information: http://citkit.ru/articles/147/

Monteringsalternativ för vfat
======================

uni_xlate
Översätt obehandlade Unicode-tecken till speciella escaped-sekvenser. Detta låter dig säkerhetskopiera
och återställ filnamn som skapats med alla Unicode-tecken. Utan detta alternativ,
ett "?" används när ingen översättning är möjlig. Escape-karaktären är ':' eftersom det är det
annars olagligt på vfat-filsystemet. Utrymningssekvensen som används, där u är
Unicode-tecknet är: ':', (u & 0x3f), ((u >> 6) & 0x3f), (u >> 12).

Det är det visst användbart alternativ när du arbetar i en icke-UTF8-lokal. I långa fil-/katalognamn
alla Unicode-tecken kan hittas, inklusive de som inte ingår i den uppsättningen av 256
tecken, som anges i omvandlingstabellen i parametern iocharset =. Sådana symboler
visas som '?', eller om det anges detta alternativ de verkar vara speciella
flyktsekvenser. Escape-karaktären är ett kolon ':' eftersom det är förbjudet
i DOS-namn och förekommer absolut aldrig i dem. Potentiellt med detta aktiverat
alternativ kan manipuleras med filer vars namn innehåller något av Unicode-tecken.
Namnen ser roliga ut: till exempel kommer en fil med namnet "test" att visas
som ": 0442: 0435: 0441: 0442". En fil med detta namn kan skapas, kopieras,
skriv, byt namn till exempel till ": 0442: 0435: 0441: 0441", och detta kommer att bli DOS-namnet "tess".
Men till exempel att synkronisera kataloger med sådana escape-sekvenser i namnet
att använda rsync kommer inte att fungera, uppenbarligen eftersom rsync inte vet något om liknande
namnkonverteringar.

posix
Tillåt två filer med namn som bara skiljer sig åt i fallet.

Tillåter skapande av två filer med olika namn endast i fall.

nonumtail
Försök först skapa ett kort namn utan sekvensnummer, innan du försöker namn ~ num.ext.

När du skapar ett kort dos-namn försöker den skapa det först utan de vanliga tildes
med en siffra i slutet av namnet.

utf8
UTF8 är den filsystemssäkra 8-bitarskodningen av Unicode som används av konsolen.
Det kan aktiveras för filsystemet med detta alternativ.
Om 'uni_xlate' ställs in, inaktiveras UTF8.

Aktiverar UTF-8-kodning av Unicode-tecken när de skickas till anpassade applikationer
arbetar i UTF-8-lokaler. Uppenbarligen är detta vad som behövs under normala förhållanden.
Om alternativet "uni_xlate" är inställt, är alternativet "utf8" inaktiverat.

Teoretiskt, i en UTF-8-lokal, kan du inte använda alternativet "utf8", utan ställa in iocharset = utf8.
I fs / fat / inode.c-källorna ser vi följande varning:
1105 / * UTF-8 tillhandahåller inte FAT-semantik * /
1106 if (! Strcmp (opts-> iocharset, "utf8")) (
1107 printk (KERN_ERR "FAT: utf8 är inte en rekommenderad IO-teckenuppsättning"
1108 "för FAT-filsystem kommer filsystemet att vara skiftlägeskänsligt! \ N");
1109 }
kortnamn =
Definierar beteendet för att skapa och visa filnamn som ryms i 8,3 tecken.
Om det finns ett långt namn för en fil, kommer den alltid att vara att föredra. Det finns fyra lägen:
lägre - Tvinga det korta namnet till gemener vid visning;
win95 - Tvinga det korta namnet till versaler vid visning;
lagra ett långt namn när det korta namnet inte bara består av versaler.
winnt - Visa kortnamnet som det är;
lagra ett långt namn när det korta namnet inte bara är gemener eller bara versaler.
blandat - Visa det korta namnet som det är;
lagra ett långt namn när det korta namnet inte bara består av versaler.
Standardinställningen är "lägre".

Bestämmer hur namnen på filer och kataloger skapas och visas på egen hand
är i 8.3-format. Om det finns ett långt namn för filen kommer det att visas,
eftersom alltid har företräde. Det finns fyra lägen enligt beskrivningen. Standardinställningen är "lägre".
Det verkar mer naturligt att använda "winnt".

Efter att ha monterat partitionen kan du kontrollera alternativen med vilka den monterades med "cat / proc / mounts".

En egenhet märks i RedHat / CentOS: en vfat-partition är alltid monterad med alternativet "utf8" aktiverat, även om det inte anges på kommandoraden. Detta händer även i icke-UTF8-lokaler, vilket leder till att filnamn som består av icke-ascii-tecken visas felaktigt (som det vanligtvis ser ut när man försöker mata ut en Unicode-sträng med en kodtabell med 256 8-bitars tecken). Detta är resultatet av Anaconda-felkorrigeringen https://bugzilla.redhat.com/show_bug.cgi?id=181963, när vi istället för att fixa ett fel i installationsinställningarna, helt enkelt patchade kärnan så att vfat-partitionerna som standard var monterad med alternativet "utf8" aktiverat, dvs .To. skriv allt detsamma under lång tid fungerar redan bara i UTF-8-språk. Men samtidigt glömde de att nämna i man-sidan hur man inaktiverar det här alternativet https://bugzilla.redhat.com/show_bug.cgi?id=515149

I samma fs / fat / inode.c kan du se de odokumenterade parametrarna som kan ställas in för kontrollalternativ, inklusive för att inaktivera "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 = mixed"),
911 (Opt_utf8_no, "utf8 = 0"), / * 0 eller nej eller falskt * /
912 (Opt_utf8_no, "utf8 = nej"),
913 (Opt_utf8_no, "utf8 = false"),
914 (Opt_utf8_yes, "utf8 = 1"), / * tomt eller 1 eller ja eller sant * /
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 nej eller falskt * /
919 (Opt_uni_xl_no, "uni_xlate = nej"),
920 (Opt_uni_xl_no, "uni_xlate = false"),
921 (Opt_uni_xl_yes, "uni_xlate = 1"), / * tomt eller 1 eller ja eller sant * /
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 nej eller falskt * /
926 (Opt_nonumtail_no, "nonumtail = no"),
927 (Opt_nonumtail_no, "nonumtail = false"),
928 (Opt_nonumtail_yes, "nonumtail = 1"), / * tomt eller 1 eller ja eller sant * /
929 (Opt_nonumtail_yes, "nonumtail = yes"),
930 (Opt_nonumtail_yes, "nonumtail = true"),
931 (Opt_nonumtail_yes, "nonumtail"),
932 (Opt_err, NULL)
933 };

Du måste ha hört talas om filsystem som t.ex FAT32, NTFS och exFAT... Men vad är skillnaden mellan dem? Varje typ har sin egen eget set fördelar och nackdelar. Det är därför det inte finns något enskilt alternativ. I den här artikeln kommer vi att bryta ner de viktigaste skillnaderna mellan de tre filsystemen.

På tal om Windows-operativsystemet vet vi säkert att det bara är installerat på en logisk partition i NTFS-format. Flyttbara enheter och andra USB-baserade lagringsenheter använder FAT32-typen.

Ett av formaten som kan användas för att formatera flash-enheter är exFAT, efterföljaren till det gamla FAT32-filsystemet.

Således har vi tre huvudsakliga datalagringsformat som vanligtvis används både för Windows och för olika typer av lagringsmedia.

Vad är ett filsystem

Ett filsystem är en uppsättning regler som styr hur dokument som lagras på en enhet lagras och hämtas. Detta kan vara en hårddisk, flash-enhet eller SD-kort.

För en bättre förståelse, låt oss som exempel ta ett vanligt företags kontor. Fragment av installerade dokument lagras på en specifik plats, till exempel i en skrivbordslåda. Och när det är nödvändigt att öppna dem, kommer filsystemet åt filerna i ett försök att läsa information.

Användbara artiklar

Låt oss för en sekund anta att ett sådant system är ur funktion och omedelbart får vi en enorm mängd oidentifierade data, som det inte kommer att finnas något sätt att studera.

Faktum är att det finns ett stort antal filsystem, till exempel Flash Filsystem, Tape File System och Disk File System, men vi kommer bara att fokusera på de viktigaste - FAT32, NTFS och exFAT.

Vad är FAT32

FAT32-filsystemet är det äldsta och mest erfarna i datorteknikens historia. Dess resa började med det ursprungliga 8-bitars FAT-systemet 1977, som fungerade inuti en autonom disk. Microsoft Fristående Disk Basic-80... Den lanserades specifikt för Intel 8080 NCR 7200 1977/1978, arbetade som en datainmatningsterminal med 8-tums disketter.

Efter diskussioner om att införa systemet med Microsofts grundare Bill Gates, skrevs koden av företagets första medarbetare, Mark MacDonald.

Huvuduppgiften för FAT-filsystemet var att arbeta med data i operativsystemet Microsoft 8080 / Z80 baserat på MDOS / MIDAS-plattformen, skriven av Mark MacDonald.

I framtiden har FAT genomgått vissa förändringar och gradvis flyttats från sin ursprungliga form till FAT12, FAT16 och slutligen FAT32, vars namn nu är nära förknippat med externa enheter.

Den största skillnaden mellan FAT32 och dess föregångare är att övervinna den begränsade mängd information som finns tillgänglig för lagring. 32-bitars Systemet släpptes i augusti 1995 med lanseringen av Windows 95 och höjde i sin uppdatering de övre gränserna för fil- och lagringsstorlekar till 4GB och 16TB.

FAT32 är alltså inte designad för att lagra stora mängder data och installera tunga applikationer. Det är av denna anledning som filsystemet används på hårddiskar. NTFS som tillåter användare att sluta tänka på mängden information som laddas ner.

Sammanfattningsvis är FAT32-systemet idealiskt för att lagra data som inte överstiger 4 GB på något flyttbart medium. Dess popularitet är inte begränsad bara till datorområdet. Den används i spelkonsoler, TV-apparater med högupplöst bilder, DVD-spelare, Blu-ray-spelare och andra enheter med USB-port. FAT32 stöds av alla versioner av Windows, Linux och MacOS.

Vad är NTFS

1993 introducerade Microsoft ett nytt filsystem NTFS(New Technology File System) parallellt med uppkomsten av operativsystemet Windows NT 3.1.

Huvudfunktionen i NTFS-systemet är frånvaron av några begränsningar för storleken på uppladdade filer. Även om vi försökt överskrida den här gränsen skulle vi ha misslyckats – det är så fantastiskt.

Utvecklingen började i mitten av 1980-talet under ett samarbete mellan Microsoft och IBM, vars mål var att skapa ett nytt operativsystem som överträffar tidigare vad gäller grafikprestanda.

Ändå varade inte föreningen mellan de två företagen länge och utan att slutföra det gemensamma projektet beslutade de att avsluta samarbetet. Därefter koncentrerade sig Microsoft och IBM på att göra sina egna filsystem.

För datorteknik skapades 1989 IBMs HPFS, som användes för operativsystemet OS / 2. Några år senare, 1993, lanserade Microsoft NTFS v1.0 som blev det officiella filsystemet för Windows NT 3.1.

Den teoretiska NTFS-filstorleken är 16 EB - 1 KB, vilket är 18 446 744 073 709 550 502 byte. Utvecklingsteamet inkluderade Tom Miller, Harry Kimura, Brian Andrew, David Gebel.

Nästa version av filsystemet var NTFS v3.1 lanserades specifikt för Microsoft Windows XP. I framtiden genomgick den inga speciella förändringar, även om många olika tillägg gjordes till den. Till exempel dök möjligheten att komprimera logiska partitioner, återställning och NTFS symboliska länkar upp. Dessutom var den initiala filsystemets kapacitet bara 256 MB av de enorma 16 EB - 1 KB i nyare versioner som lanserades med lanseringen av Windows 8.

Några av de användbara funktionerna som introduceras i NTFS v3.1 inkluderar utökning av filformat som stöds, diskanvändningskvoter, filkryptering och repareringspunkter. Anmärkningsvärt är det faktum att de nyare versionerna av NTFS är helt kompatibla med de tidigare.

NTFS-filsystemet har en viktig funktion när det gäller att återställa det från någon form av skada. Den innehåller en specifik datastruktur som spårar eventuella ändringar i systemet och med vilken du alltid kan återställa NTFS att fungera.

Detta filsystem stöds av alla versioner av Windows från och med Windows XP. Tyvärr delar inte macOS kompatibilitetsenheten som marknadsförs av Microsoft. Apple har lämnat användarna möjligheten att läsa data från NTFS-enheter, men de kommer inte att kunna skriva till dem. Stödet för detta filsystem från Linux är begränsat till endast ett fåtal av dess versioner.

Vad är exFAT

ExFAT(Extended FAT) är ett nytt, utökat filsystem från Microsoft som framgångsrikt ersätter sin föregångare på området när det kommer till stora mängder information.

Som du säkert vet använder de flesta moderna digitalkameror exFAT-systemet, eftersom det är betydligt lättare än NTFS, men samtidigt kan det lagra filer som är större än 4 GB, till skillnad från FAT32.

Om du kopierar ett 6 GB-dokument till en flash-enhet med exFAT-filsystemet kommer du inte att möta de negativa konsekvenserna som kan observeras med den tidigare versionen av systemet.

ExFAT-formatet blir allt mer populärt och används främst med SDXC-minneskort med hög kapacitet. Den främsta anledningen till detta är den lilla storleken på filsystemet och, som tidigare beskrivits, möjligheten att lagra dokument som är större än 4 GB.

Ett intressant faktum är att Microsoft har det amerikanska patentet 8321439, vilket gör att du snabbt kan hitta en fil med hjälp av en hash av namnet. Tack vare denna funktion kan alla dokument hittas många gånger snabbare.

Det är värt att notera att för exFAT-filsystemet har alla tillgängliga tillägg inte släppts för allmänheten. Leverantörer måste köpa en begränsad licens från Microsoft för att köpa dem.

Denna åtgärd vidtogs för att säkerställa att leverantörer inte försöker tjäna pengar Microsoft produkt genom att markera sig som en del av företaget då de skulle ha källkoden för filsystemet tillgänglig.

Eftersom Microsoft är oförändrat i sin envishet började många användare skapa sina egna modifieringar av exFAT, varav en var exfat-säkring... Den tillhandahåller läs- och skrivoperationer för Linux-distributioner inklusive FreeBSD.

ExFAT-filsystemet som skapades 2006, som har en generell gräns för mängden information som NTFS gör, är lättare, eftersom det inte innehåller alla typer av tillägg, som det andra.

ExFAT stöder läsning, skrivning och är kompatibel med Mac, Android och Windows operativsystem. För Linux behöver du stödjande programvara.

Jämförelse av filsystem

FAT32:

• Kompatibilitet: Windows, MacOS, Linux, spel konsoler och enheter med en USB-port.
• Fördelar: plattformsöverskridande kompatibilitet, lätt filsystem.
• Minus: filstorleksbegränsningar (dokument upp till 4 GB är tillgängliga) och partitionsstorlekar upp till 16 TB.
• Ändamål: flyttbara enheter. Används för att formatera flash-enheter, men exFAT är att föredra.

NTFS:

• Kompatibilitet: Windows, MacOS (skrivskyddat), Linux (skrivskyddat för vissa distributioner), Xbox One.
• Fördelar: inga begränsningar för storleken på filer och sektioner.
• Minus: begränsad plattformsoberoende kompatibilitet.
• Ändamål: väl lämpad för interna hårddiskar, eftersom det låter dig lagra stora mängder information som andra filsystem inte klarar av.

exFAT:

• Kompatibilitet: Windows XP och mer senare versioner, MacOS 10.6.5 och senare, Linux (med FUSE), Android.
• Fördelar: har vanliga positiva effekter från FAT32 och NTFS, som inkluderar möjligheten att lagra filer större än 4 GB.
• Minus: Microsoft begränsar användningen av licensen.
• Ändamål: Eliminerar filstorleksbegränsningar för flyttbara lagringsenheter. Mycket att föredra framför sin föregångare FAT32.

Om du behöver återställa en logisk partition med ett okänt, skadat eller raderat filsystem, hjälper Starus Recovery-verktyg dig.

Verktyg Starus Partition Recovery, eller dess analoger, Starus FAT Återhämtning, Starus NTFS Recovery, är designade för att fungera med specifika filsystem - FAT och NTFS. Huvudmjukvaran kan interagera med båda. Du kan ladda ner och prova program för att återställa FAT32- och NTFS-filsystem gratis!