Arkitektura e sistemit të skedarëve FAT. Karakteristikat e sistemeve të skedarëve FAT32, NTFS dhe exFAT

1. Struktura e sektorit FSIinfo Struktura fat_boot_fsinfo:
   • __u32 nënshkrimi1- firma 0x41615252;
   • __u32 nënshkrimi2- firma 0x61417272;
   • __u32 grupime të lira- numri i grupimeve të lira. Nëse fusha përmban -1, kërkimi për grupe të lira duhet të fillojë nga grupi numër 2.
2. Struktura e hyrjes së drejtorisë së emrit të shkurtër struct msdos_dir_entry:
   • __s8 emri, ek- emri dhe shtrirja e skedarit;
   • __u8 attr- atributet e skedarit;
   • __u8 ctime_ms- kjo fushë specifikon kohën e krijimit të skedarit deri në ms (përdoret vetëm FAT32);
   • __u16 ckohë- koha e krijimit të skedarit (përdoret vetëm FAT32);
   • __u16 cdate- data e krijimit të skedarit (përdoret vetëm FAT32);
   • __u16 adate- data e hyrjes së fundit në skedar (përdoret vetëm FAT32);
   • __u16 starthi- 16 bit i lartë i numrit të grupit të parë të skedarit (përdoret vetëm FAT32);
   • __u16 ora, data, fillimi- koha dhe data e krijimit të skedarit, numri i grupit të parë të skedarit;
   • madhësia __u32- madhësia e skedarit (në bajt).
3. Struktura e artikullit të drejtorisë së emrit të gjatë:
   • __u8 id- numri i artikullit;
   • __u8 emri0_4- karakteret 1 - 5 të emrit;
   • __u8 attr- atributet e skedarit;
   • __u8 alias_checksum- kontrolli i emrit të shkurtër;
   • __u8 emri5_10- personazhet 6 - 11 të emrit;
   • __u8 emri11_12- personazhet 12 - 13 të emrit.

Le të vazhdojmë të shqyrtojmë zbatimin e softuerit të algoritmit dhe të përcaktojmë emrin e ndarjes në të cilën është krijuar sistemi i skedarëve FAT16:

#ifndef FAT16_PART_NAME

#define FAT16_PART_NAME "/ dev / hda1"

#përfundim

Strukturat globale:

struct fat_boot_sector fbs; // Struktura e sektorit të nisjes

struct msdos_dir_entry dentry; // Struktura e artikullit të drejtorisë

Variablat globalë:

U16 * yndyrë16; // kopjoni tabelën FAT16 këtu

U16 sektori_madhësia; // madhësia e sektorit (nga FAT16)

U16 dir_hyrjet; // numri i përshkruesve 32 bajt

// në direktorinë rrënjë (0 për FAT32)

Sektorët U16; // numri i përgjithshëm i sektorëve në seksion

U32 yndyrë16_madhësi; // Madhësia FAT16

U32 madhësia e rrënjës; // madhësia e direktoriumit rrënjë

U16 byte_per_cluster; // madhësia e grupit në bajt

U16 grupi i ardhshëm; // grupi tjetër në zinxhir

yndyrë int;

Le të fillojmë me funksionin kryesor:

int main ()

Int num;

Vendosëm emrin e plotë të skedarit, përmbajtjen e të cilit duam të lexojmë. Më lejoni t'ju kujtoj se ne punojmë vetëm me emra të shkurtër skedarësh. Procedura për të punuar me emra të gjatë nuk mbulohet në këtë artikull.

U8 * shtegu i plotë = "/Folder1/Folder2/text.txt";

Hapni skedarin e pajisjes:

E fortë = e hapur (FAT16_PART_NAME, O_RDONLY);

Nëse (e vështirë< 0) {

Gabim (FAT16_PART_NAME);

Dalje (-1);

Lexojmë 10 grupimet e para të skedarit. Leximi kryhet nga funksioni fat16_read_file (). Parametrat e funksionit janë emri i plotë i skedarit dhe numri i grupeve për t'u lexuar. Funksioni kthen numrin e grupimeve të lexuara, ose -1 nëse ka ndodhur një gabim gjatë leximit:

Num = fat16_skedari_lexuar (shtegu i plotë, 10);

Nëse (num< 0) perror("fat16_read_file");

Else printf ("Lexo% d grupe", num);

Mbyllni skedarin e pajisjes dhe dilni:

Mbyll (e vështirë);

Kthimi 0;

Funksioni për leximin e grupimeve të skedarëve duket si ky:

int fat16_read_file (__ u8 * shtegu i plotë, int num)

Struktura split_name sn; // strukturë për ruajtjen e pjesëve përbërëse të skedarit

U8 tmp_emri_buff; // buffer për ruajtjen e përkohshme të elementeve të përbëra të shtegut të plotë të skedarit

Int statike i = 1;

Int n;

U8 * tmp_buff;

U16 start_cluster, next_cluster;

Ne kemi renditur parametrat e funksionit kur shqyrtojmë funksionin kryesor.

Operacionet përgatitore - zero tampon tmp_name_buff dhe strukturën struct split_name sn:

Karakteri i parë në një emër absolut të rrugës duhet të jetë një prerje përpara (/). Ne e kontrollojmë këtë:

Ne lexojmë sektorin e nisjes nga ndarja:

Nëse (lexo_fbs ()< 0) return -1;

Sektori i nisjes së leximit është tani në strukturën globale fat_boot_sector fbs. Le të kopjojmë nga kjo strukturë madhësinë e sektorit, numrin e hyrjeve në direktorinë rrënjë dhe numrin total të sektorëve në ndarje:

Le të përcaktojmë madhësinë e grupit në bajt:

Byte_per_cluster = fbs.cluster_size * 512

Le të shfaqim informacionin në sektorin e nisjes:

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

Printf ("Madhësia e sektorit -% d", madhësia e sektorit);

Printf ("Madhësia e grupit -% d", fbs.cluster_size);

Printf ("Rezervuar -% d", fbs.rezervuar);

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

Printf ("Hyrjet e rreme -% d", dir_hyrje);

Printf ("Sektorët -% d", sektorët);

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

Printf ("gjatësia FAT16 -% u", fbs.fat_length);

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

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

Llogaritni madhësinë e FAT16 në bajt dhe lexoni atë:

Fat16_madhësia = fbs.gjatësia_dhjami * 512;

Nëse (read_fat16 ()< 0) return -1;

Ne lexojmë direktorinë rrënjë:

Nëse (read_root_dentry ()< 0) return -1;

Treguesi dir_entry tani është i pozicionuar në zonën e memories që përmban hyrjet e direktorisë rrënjë. Madhësia e kësaj zone memorie është e barabartë me madhësinë e direktoriumit rrënjë (madhësia_rrënjë).

Le të ruajmë (për kontroll) përmbajtjen e drejtorisë rrënjësore në një skedar të veçantë:

#ifdef DEBUG

Mbylle (yndyrë);

#përfundim

Ne llogarisim fillimin e zonës së të dhënave:

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

Me të gjitha hyrjet në direktorinë rrënjë në vend, ne mund të arrijmë te përmbajtja e skedarit test.txt. Për këtë do të organizojmë një cikël. Në trupin e ciklit, le të analizojmë emrin e plotë të skedarit, duke theksuar elementët e tij - nëndrejtoritë (ne kemi dy prej tyre, Folder1 dhe Folder2) dhe emrin e skedarit të kërkuar (test.txt).

Ndërsa (1) (

Memset (tmp_name_buff, 0, SHORT_NAME);

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

Për (n = 0; n< SHORT_NAME; n++, i++) {

Nëse ((tmp_name_buff [n] == "/") || (tmp_name_buff [n] == "?")) (

Unë ++;

Pushim;

Tmp_name_buff [n] = "?";

Plotësoni strukturën split_name sn me informacionin e duhur. Mbushja kryhet nga funksioni split_name, ndërsa emri i skedarit kontrollohet në formatin "8.3":

< 0) {

Printf ("emri i pavlefshëm");

Kthimi -1;

Për çdo element të emrit të plotë të skedarit, ne përcaktojmë një grup fillestar. Për ta bërë këtë, shikoni në elementët e drejtorisë (duke filluar nga rrënja) një hyrje që korrespondon me elementin e emrit të plotë dhe lexoni këtë hyrje. Funksioni get_dentry () kryen procedurën e kërkimit:

Nëse (get_dentry (& sn)< 0) {

Printf ("Nuk ka skedar të tillë!");

Kthimi -1;

Kontrollimi i atributeve të skedarit. Nëse është një drejtori, lexoni përmbajtjen e tij dhe vazhdoni ciklin:

Nëse (dentry.attr & 0x10) (

Nëse (read_directory (dentry.start)< 0) return -1;

Vazhdo;

Nëse ky është një skedar, lexoni grupet e para numerike. Për kontroll, ne do ta ruajmë informacionin e lexuar në një skedar të veçantë:

Nëse (dentry.attr & 0x20) (

Start_cluster = dentry.start;

Tmp_buff = (__u8 *) malloc (byte_per_cluster); // Përmbajtja e grupit do të lexohet këtu

N = hapur ("clust", O_CREAT | O_RDWR, 0600); // ruani informacionin e lexuar në këtë skedar

Nëse (n< 0) {

Perror ("i hapur");

Kthimi -1;

Për të lexuar grupet e skedarëve, ne do të organizojmë një cikël:

Për (i = 0; i< num; i++) {

Ne lexojmë përmbajtjen e grupit në tampon tmp_buff dhe e ruajmë atë në një skedar të veçantë:

< 0) return -1;

< 0) {

Perror ("shkruaj");

Mbyll (n);

Kthimi -1;

Ne lexojmë nga FAT16 numrin e grupit tjetër të zënë nga ky skedar. Nëse ky është grupi i fundit, ne ndërpresim ciklin dhe kthehemi në funksionin kryesor:

#ifdef DEBUG

Printf ("OK. Lexuar");

Printf ("grupi i ardhshëm i skedarit - 0x% X ..", grupi tjetër);

#përfundim

Nëse (grupi_tjetër == EOF_FAT16) (

#ifdef DEBUG

Printf ("grupi i fundit.");

#përfundim

Falas (tmp_buff);

Mbyll (n);

Kthimi ++ i;

#ifdef DEBUG

Printf ("ndalo leximin");

#përfundim

Kthimi i;

Leximi i sektorit të nisjes FAT16 kryhet nga funksioni read_fbs (). Rezultati vendoset në strukturën globale të fbs:

int read_fbs ()

Nëse (e lexuar (e vështirë, (__ u8 *) & fbs, madhësia e (fbs))< 0) return -1;

Kthimi 0;

Leximi i tabelës së ndarjes së skedarëve të sistemit të skedarëve FAT16 kryhet nga funksioni read_fat16 ():

int read_fat16 ()

U64 kërko = (__u64) (fbs.e rezervuar) * 512; // zhvendoset në FAT16 nga fillimi i ndarjes

Fat16 = (void *) malloc (fat16_size);

Nëse (pread64 (e vështirë, (__u8 *) yndyrë16, yndyrë16_madhësi, kërko)< 0) return -1;

Kthimi 0;

Leximi i drejtorisë rrënjësore kryhet nga funksioni read_root_dentry ():

int read_root_dentry ()

U64 seek = (__u64) fbs.e rezervuar * 512 + yndyrë16_madhësi * fbs.yndyrna; // zhvendoset në direktorinë rrënjë nga fillimi i seksionit

Madhësia_rrënjë = 32 * hyrje_dir; // llogarit madhësinë e direktoriumit rrënjë

Dir_hyrja = (__u8 *) malloc (madhësia_rrënjë);

Nëse (! Dir_hyrje) kthehet -1;

Memset (dir_hyrja, 0, madhësia e rrënjës);

Nëse (pread64 (hard, dir_entry, root_size, seek)< 0) return -1;

Kthimi 0;

Leximi i një grupi që i përket një skedari kryhet nga funksioni read_cluster (). Parametrat hyrës të funksionit janë numri i grupit cluster_num dhe një tregues në buferin __u8 * tmp_buff, ku duhet të vendoset rezultati i lexuar. Kompensimi në grup në seksion llogaritet me formulën (shih):

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

• KËRKONI- zhvendosja në grup në ndarje
• DATA_START- fillimi i zonës së të dhënave
• CLUSTER_NUM- numri i sekuencës së grupit
• BYTE_PER_CLUSTER- madhësia e grupit në bajt

int read_cluster (__ u16 cluster_num, __u8 * tmp_buff)

U64 seek = (__u64) (byte_per_cluster) * (cluster_num - 2) + data_start; // llogarit kompensimin në grup

< 0) return -1;

Kthimi 0;

Funksioni read_directory lexon hyrjet në drejtori (jo rrënjën) dhe e vendos rezultatin në vendndodhjen e memories në të cilën është vendosur treguesi dir_entry:

int read_directory (__ u16 start_cluster)

Int i = 1;

U16 grupi i ardhshëm;

Për (;; i ++) (

Ne ndajmë memorie për të ruajtur përmbajtjen e drejtorisë, lexojmë përmbajtjen e grupit fillestar dhe marrim vlerën e grupit tjetër nga tabela FAT16:

Nëse (! Dir_hyrje) kthehet -1;

< 0) return -1;

Tjetër_grup = yndyrë16;

Le të ruajmë përmbajtjen e drejtorisë në një skedar të veçantë (për kontroll):

#ifdef DEBUG

Printf ("Grupi tjetër - 0x% X", grupi tjetër);

Fat = i hapur ("dir16", O_CREAT | O_WRONLY, 0600);

Shkruani (fat, dir_hyrja, rrënjë_madhësia);

Mbylle (yndyrë);

#përfundim

Nëse arrihet grupi i fundit, dilni nga cikli, përndryshe vazhdoni të lexoni direktorinë, duke rritur madhësinë e bufferit dir_entry me një grup tjetër:

Nëse (next_cluster & EOF_FAT16) prishen;

Start_cluster = grupi_tjetër;

Kthimi 0;

Funksioni get_dentry () kërkon përmbajtjen e drejtorisë për një artikull që përputhet me skedarin që po kërkoni. Hyrat e këtij funksioni janë një tregues drejt një strukture split_name * sn që përmban elementet e emrit të skedarit të shkurtër:

Int i = 0;

Buffer global dir_entry përmban një sërë hyrjesh në drejtori në të cilat ne do të kërkojmë për një hyrje skedari (ose drejtorie). Për të kërkuar, ne do të organizojmë një cikël. Në trupin e ciklit, kopjoni hyrjet e direktoriumit në strukturën globale të dhëmbëve dhe krahasoni vlerën e fushave të emrit dhe ext të kësaj strukture me fushat përkatëse të strukturës split_name * sn. Koincidenca e këtyre fushave do të thotë që kemi gjetur hyrjen e skedarit të kërkuar në grupin e elementeve të katalogut:

për (;; i ++) (

Nëse (! (Memcmp (dentry.name, sn-> emri, sn-> emri_len)) &&

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

Pushim;

Nëse (! Dentry.name) kthen -1;

#ifdef DEBUG

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

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

Printf ("madhësia e skedarit -% u", dentry.size);

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

#përfundim

Kthimi 0;

I gjithë kodi i mësipërm është në dosjen FAT16, skedari fat16.c. Për të marrë modulin e ekzekutueshëm, krijoni një Makefile me përmbajtjen e mëposhtme:

INCDIR = / usr / src / linux / përfshijnë

FONIK = i pastër

Fat16: yndyrë16.o ndarë.o

Gcc -I $ (INCDIR) $ ^ -g -o [email i mbrojtur]

% .o:% .c

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

Pastroni:

Rm -f * .o

Rm -f ./fat16

Zbatimi i softuerit të algoritmit për leximin e një skedari nga një ndarje logjike me sistemin e skedarëve FAT12

Në përgjithësi, algoritmi për leximin e një skedari nga një ndarje FAT12 është identik me algoritmin për leximin e një skedari nga një ndarje FAT16. Dallimi qëndron në procedurën e leximit të elementeve nga tabela FAT12. Ne e konsideruam tabelën FAT16 si një grup të thjeshtë elementësh 16-bitësh. Algoritmi i mëposhtëm propozohet për leximin e elementeve të tabelës FAT12:

• shumëzojeni numrin e elementit me 1,5;
• nxjerr një fjalë 16-bit nga FAT duke përdorur rezultatin e operacionit të mëparshëm si kompensim;
• nëse numri i elementit është çift, kryeni veprimin AND në fjalën e lexuar dhe maskoni 0x0FFF. Nëse numri është tek, zhvendoseni fjalën e lexuar nga tabela me 4 bit drejt bitave më pak të rëndësishëm.

Bazuar në këtë algoritëm, ne do të zbatojmë funksionin e leximit të elementeve nga tabela FAT12:

int get_cluster (__ u16 cluster_num)

U16 kërkoj;

grupi U16;

Llogaritni kompensimin në tabelën FAT12 dhe lexoni fjalën 16-bit nga tabela:

Kërko = (klaster_num * 3) / 2;

Memcpy ((__ u8 *) & clust, (__u8 *) (fat12 + kërko), 2);

Nëse numri fillestar i grupit është numër çift, vlerën e lexuar nga tabela e zhvendosim me 4 bit drejt shifrave më të ulëta, nëse është tek, e shtojmë në 0x0FFF:

Nëse (numri_grup% 2) grumbulloni >> = 4;

Përndryshe grupi & = 0x0FFF;

Ky fragment mund të zbatohet edhe në asembler:

"xorw %% sëpatë, %% sëpatë"

"btw $ 0, %% cx"

"jnc 1f"

"shrw $ 4, %% dx"

"jmp 2f"

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

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

: "= a" (tjetër)

: "d" (grumbull), "c" (grup_num));

Ne e kthejmë rezultatin:

Grupi i kthimit;

Le të ndalemi pak më shumë në vetë algoritmin. Le të supozojmë se një skedar është krijuar në një ndarje FAT12 që zë grupet e 9-të dhe të 10-të. Çdo element FAT12 është 12 bit i gjatë. Sepse ne lexojmë elementë 16-bitësh nga tabela, atëherë zhvendosja në elementin e 9-të do të jetë 13 bajt (9 * 1.5 = 13, ne e hedhim pjesën e mbetur), ndërsa 4 bitët më pak të rëndësishëm do t'i përkasin elementit të 8-të të FAT. Ato duhet të hidhen, dhe për këtë mjafton që elementi i lexuar të zhvendoset me 4 bit drejt shifrave më të ulëta, gjë që sigurohet nga algoritmi. Kompensimi në elementin e 10-të do të jetë 15 bajt, dhe 4 bitët më të rëndësishëm do t'i përkasin elementit të 11-të të FAT. Për t'i hedhur poshtë, është e nevojshme të kryhet operacioni AND në elementin e 10-të dhe maskën 0x0FFF, e cila gjithashtu korrespondon me algoritmin e mësipërm.

Kodet burimore të modulit për leximin e skedarit nga ndarja FAT12 gjenden në direktorinë FAT12, skedari fat12.c.

Zbatimi i softuerit të algoritmit për leximin e një skedari nga një ndarje logjike me sistemin e skedarëve FAT32

Algoritmi për leximin e një skedari nga një ndarje me sistemin e skedarëve FAT32 praktikisht nuk ndryshon nga algoritmi për FAT16, përveç se në FAT32 drejtoria rrënjë mund të vendoset kudo në ndarje dhe të ketë një madhësi arbitrare. Prandaj, për ta bërë më interesante, le ta komplikojmë detyrën - le të supozojmë se ne dimë vetëm numrin e ndarjes me sistemin e skedarëve FAT32. Për të lexuar informacionin nga ky seksion, së pari duhet të përcaktoni koordinatat e tij - zhvendosja në seksion nga fillimi i diskut. Dhe për këtë ju duhet të keni një ide të strukturës logjike të diskut.

Struktura logjike e hard diskut

Konsideroni strukturën logjike të një disku të ngurtë që përputhet me standardin e Microsoft - "ndarja kryesore - ndarja e zgjeruar - ndarjet jo-DOS".

Hapësira e diskut të ngurtë mund të organizohet si një ose më shumë ndarje, dhe ndarjet mund të përmbajnë një ose më shumë disqe logjike.

Disku i ngurtë në adresën fizike 0-0-1 përmban Master Boot Record (MBR). Struktura MBR përmban elementët e mëposhtëm:

• bootstrap jo-sistem (NSB);
• Tabela e përshkrimit të ndarjes së diskut (tabela e ndarjes, PT). Ndodhet në MBR në offset 0x1BE dhe zë 64 bajt;
• Nënshkrimi MBR. Dy bajtët e fundit të MBR duhet të përmbajnë numrin 0xAA55.

Tabela e ndarjeve përshkruan vendndodhjen dhe karakteristikat e ndarjeve të disponueshme në hard disk. Ndarjet e diskut mund të jenë të dy llojeve - primare dhe të zgjeruara. Numri maksimal i ndarjeve kryesore është katër. Është e detyrueshme që të ketë të paktën një ndarje primare në disk. Një ndarje e zgjeruar mund të ndahet në një numër të madh nënseksionesh - disqe logjike. Një strukturë e thjeshtuar e MBR është paraqitur në tabelën 7. Tabela e ndarjes ndodhet në fund të MBR; 16 bajt janë ndarë për përshkrimin e ndarjes në tabelë.

Tabela 7. Struktura MBR

Paragjykim Madhësia, bajt 0 446 0x1BE 16 0x1 CE 16 0x1DE 16 0x1EE 16 0x1FE 2

Struktura e hyrjes së hyrjes së tabelës së ndarjes është paraqitur në tabelën 8.

Tabela 8. Struktura e hyrjes së elementit të tabelës së ndarjes

Bajt i parë në elementin e seksionit është flamuri i aktivitetit të seksionit (0 - joaktiv, 0x80 - aktiv). Shërben për të përcaktuar nëse ndarja është një sistem bootable dhe nëse ka nevojë për të nisur sistemin operativ prej tij kur kompjuteri fillon. Vetëm një seksion mund të jetë aktiv. Flamuri aktiv i ndarjes ndiqet nga koordinatat e fillimit të ndarjes - tre bajt, që do të thotë numri i kokës, numri i sektorit dhe numri i cilindrit. Numrat e cilindrit dhe sektorit specifikohen në formatin e ndërprerjes Int 0x13, d.m.th. bitet 0-5 përmbajnë numrin e sektorit, bitet 6-7 janë dy bitet më domethënëse të numrit të cilindrit 10-bit, dhe bitet 8-15 janë tetë bitet më pak të rëndësishme të numrit të cilindrit. Kjo pasohet nga ID-ja e Sistemit, e cila identifikon sistemin operativ për këtë ndarje. Identifikuesi është një bajt. Pas identifikuesit të sistemit janë koordinatat e fundit të seksionit - tre bajt që përmbajnë përkatësisht numrat e kokës, sektorit dhe cilindrit. Katër bajtët e ardhshëm janë numri i sektorëve përpara ndarjes, dhe katër bajtët e fundit janë madhësia e ndarjes në sektorë.

Kështu, një element i tabelës së seksionit mund të përshkruhet duke përdorur strukturën e mëposhtme:

struct pt_struct (

U8 bootable; // flamuri i aktivitetit të seksionit

U8 fillimi_pjesa; // koordinatat e fillimit të seksionit

U8 tip_pjese; // identifikues i sistemit

U8 fund_pjesa; // koordinatat e fundit të seksionit

U32 sekti_para; // numri i sektorëve përpara seksionit

U32 sekti_total; // madhësia e ndarjes në sektorë (numri i sektorëve në ndarje)

Elementi i ndarjes primare drejton drejtpërsëdrejti në sektorin e nisjes së diskut logjik (gjithmonë ka vetëm një disk logjik në ndarjen parësore) dhe elementi i ndarjes së zgjeruar tregon në një listë disqesh logjike të përbërë nga struktura të quajtura sekondare MBR (SMBR).

Çdo disk i ndarjes së zgjeruar ka bllokun e vet SMBR. SMBR ka një strukturë të ngjashme me MBR, por nuk ka një rekord boot (të mbushur me zero) dhe përdoren vetëm dy nga katër fushat e përshkruesit të ndarjes. Elementi i parë i ndarjes tregon në diskun logjik, elementi i dytë tregon strukturën tjetër SMBR në listë. SMBR e fundit e listës përmban kodin e seksionit zero në elementin e dytë.

Le të kthehemi te moduli për leximin e një skedari nga një ndarje FAT32.

Skedarët e kokës:

#përfshi

#përfshi

#përfshi

#përfshi

#përfshi

Nënshkrimi MBR:

#define NËNSHKRIMI 0xAA55

Skedari i pajisjes nga i cili do të lexohen informacionet rreth ndarjeve:

#define DEVICE "/ dev / hda"

Madhësia e elementit të tabelës së ndarjes (16 bajt):

#define PT_SIZE 0x10

Vargu i mëposhtëm i strukturave vendos korrespondencën midis kodit të llojit të seksionit dhe paraqitjes së tij simbolike:

sistemet e strukturës (

Lloji i pjesës U8;

U8 * emri i pjesës;

struct systypes i386_sys_types = (

(0x00, "Bosh"),

(0x01, "FAT12"),

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

(0x05, "E zgjeruar"),

(0x06, "FAT16"),

(0x0b, "Win95 FAT32"),

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

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

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

(0x82, "Swap Linux"),

(0x83, "Linux"),

(0x85, "Linux i zgjeruar"),

(0x07, "HPFS / NTFS")

Përcaktoni numrin e elementeve në grupin i386_sys_types duke përdorur makron PART_NUM:

#define PART_NUM (madhësia e (i386_sys_types) / madhësia e (i386_sys_types))

Le të vendosim një kufi në numrin e disqeve logjike:

#define MAX_PJESA 20

Rrjeti i mëposhtëm i strukturës do të përmbajë informacione rreth disqeve logjike në pajisje (hard disk):

struct pt_struct (

U8 bootable;

U8 fillimi_pjesa;

U8 tip_pjese;

U8 fund_pjesa;

U32 sekti_para;

U32 sekti_total;

) pt_t;

int e vështirë; // përshkruesi i skedarit të pajisjes

U8 mbr; // numëro MBR këtu

Numri i ndarjes në të cilin është krijuar sistemi i skedarëve FAT32:

#define FAT32_PART_NUM 5

Sektori i nisjes, sektori FSIinfo dhe strukturat e hyrjes në katalog (të përcaktuara në skedar ):

struct fat_boot_sector fbs;

struct fat_boot_fsinfo fsinfo;

struct msdos_dir_entry dentry;

U32 * yndyrë32 = NULL; // kopjoni tabelën FAT32 këtu

U16 sektori_madhësia; // madhësia e sektorit (nga FAT32)

U16 dir_hyrjet; // 0 për FAT32

Sektorët U16; // numri i sektorëve për ndarje

U32 yndyrë32_madhësi; // Madhësia FAT32

U32 data_start; // fillimi i zonës së të dhënave

U16 byte_per_cluster; // sa bajt janë në grup (madhësia e grupit në bajt)

U32 next_cluster; // grupi tjetër në zinxhir

U32 root_cluster; // ROOT cluster - grup rrënjë fillestare

U8 * dir_hyrja = NULL; // tregues për hyrjet e drejtorisë

U64 start_seek = 0; // duke filluar nga zhvendosja në seksion (në bajt)

Funksioni kryesor:

int main ()

Int num = 0;

Int cluster_num = 5; // sa grupe për të lexuar nga skedari

U8 * full_path = "/ Folder1 / Folder2 / readme"; // skedar për të lexuar

Ne hapim pajisjen, marrim informacion në lidhje me tabelën e ndarjeve në pajisje dhe shfaqim informacione rreth ndarjeve:

E fortë = e hapur (DEV_NAME, O_RDONLY);

Nëse (e vështirë< 0) {

Gabim (DEV_NAME);

Dalje (-1);

Nëse (get_pt_info (e vështirë)< 0) {

Gabim ("get_pt_info");

Dalje (-1);

Show_pt_info ();

Ne llogarisim kompensimin fillestar për seksionin:

Fillimi_kërkimi = (__u64) (pt_t.sect_para) * 512;

Lexojmë grupet që i përkasin skedarit:

Numri = fat32_skedari_lexuar (shtegu_plotë, numri_grumbull);

Nëse (num< 0) perror("fat32_read_file");

Else printf ("Lexo% d grupe \ n", num);

Mbyll (e vështirë);

Kthimi 0;

Informacioni rreth tabelës së ndarjes lexohet nga funksioni get_pt_info ():

int get_pt_info (int vështirë)

Int i = 0;

U64 kërkoj;

Ne lexojmë tabelën e ndarjes nga MBR dhe kontrollojmë nënshkrimin:

Read_main_ptable (e vështirë);

Nëse (shenjë_kontrolloni ()< 0) {

Printf ("Nënshkrimi i pavlefshëm! \ N");

Kthimi -1;

Ne jemi duke kërkuar për identifikuesin e seksionit të zgjeruar. Nëse ka një të tillë, ne llogarisim kompensimin në ndarjen e zgjeruar dhe lexojmë informacionin në lidhje me disqet logjike:

për (; i< 4; i++) {

Nëse ((pt_t [i] .type_part == 0xF) || \

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

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

Kërko = (__u64) pt_t [i] .sekt_para * 512;

Read_ext_ptable (e vështirë, kërko);

Pushim;

Kthimi 0;

Funksioni Read_main_ptable () për leximin e tabelës së ndarjes:

void read_main_ptable (int vështirë)

Nëse (lexo (e vështirë, mbr, 512)< 0) {

Perror ("lexuar");

Mbyll (e vështirë);

Dalje (-1);

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

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

Kthimi;

Funksioni i kontrollit të nënshkrimit check_sign ():

int check_sign ()

Shenja U16 = 0;

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

#ifdef DEBUG

Printf ("Nënshkrimi - 0x% X \ n", shenjë);

#përfundim

Nëse (shenjë! = NËNSHKRIMI) kthen -1;

Kthimi 0;

Lexoni funksionin e tabelës së ndarjes së zgjeruar:

void read_ext_ptable (int vështirë, __u64 kërko)

Int num = 4; // duke u nisur nga ky pozicion, grupi i strukturave pt_t do të mbushet me informacione rreth disqeve logjike

U8 smbr;

Fut te dhenat:

• vështirë- përshkruesi i skedarit të pajisjes;
• kerkoj- zhvendosja në ndarjen e zgjeruar nga fillimi i diskut (në bajt).

Për të marrë informacion rreth disqeve logjike, ne organizojmë një cikël:

Për (;; numër ++) (

Ne lexojmë SMBR të vendosur në kërkimin e kompensimit nga fillimi i diskut:

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

Pread64 (hard, smbr, 512, kërkoj);

Plotësojmë dy elementë të tabelës pt_t, duke filluar nga pozicioni nr. Artikulli i parë do të tregojë në diskun logjik dhe i dyti në strukturën e mëposhtme SMBR:

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

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

Ne bëjmë një ndryshim në fushën "Numri i sektorit fillestar" - numërimi është nga fillimi i diskut:

Pt_t.sect_para + = (kërko / 512);

Nëse kodi i llojit të ndarjes është zero, atëherë nuk ka më disqe logjike:

Nëse (! (Pt_t.lloj_pjese)) thyejnë;

Llogaritni kompensimin në SMBR-në vijuese:

Kërko = ((__u64) (pt_t.sect_para + pt_t.sect_total)) * 512;

Kthimi;

Funksioni show_pt_info () shfaq informacion në lidhje me disqet logjike të gjetura në pajisje:

e pavlefshme show_pt_info ()

Int i = 0, n;

#ifdef DEBUG

Printf ("Numri i ndarjeve në disk -% d \ n", PART_NUM);

#përfundim

Për (; i< MAX_PART; i++) {

Nëse (! Pt_t [i] .type_pjes) thyejnë;

Printf ("\ nLloji i seksionit% d -", i);

Për (n = 0; n< PART_NUM; n++) {

Nëse (pt_t [i] .type_part == i386_sys_types [n] .part_type) (

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

Pushim;

Nëse (n == PART_NUM) printf ("lloji i panjohur \ n");

Printf ("Shenja e nisjes - 0x% X \ n", pt_t [i] .bootable);

Printf ("Sektorët në seksionin% d -% d \ n", i, pt_t [i] .sect_total);

Printf ("Sektori para seksionit% d -% d \ n \ n", i, pt_t [i] .sect_fore);

Kthimi;

Leximi i grupeve të skedarëve nga një ndarje FAT32 kryhet nga funksioni fat32_read_file (). Ky funksion ka shumë të përbashkëta me funksionin fat16_read_file (), kështu që shihni seksionin 6 për komente të hollësishme:

int fat32_read_file (__ u8 * shtegu i plotë, int num)

Struktura split_name sn;

U8 tmp_emri_buff;

Int i = 1, n;

U32 start_cluster, next_cluster;

U8 * tmp_buff;

Operacionet përgatitore - pastroni buferin, strukturën dhe kontrolloni vijën e parë:

Memset (tmp_name_buff, 0, SHORT_NAME);

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

Nëse (shtegu i plotë! = "/") Kthehu -1;

Ne lexojmë sektorin e nisjes:

Nëse (lexo_fbs ()< 0) return -1;

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

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

Memcpy ((void *) & sektorët, (void *) fbs.sectors, 2);

Ne lexojmë strukturën FSIinfo dhe shfaqim nënshkrimin që gjendet në të:

Nëse (lexo_fs_info ()< 0) return -1;

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

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

Fat32_size = fbs.fat32_length * 512; // Madhësia FAT32 në bajt

Data_start = 512 * fbs.reserved + fat32_size * 2; // fillimi i fushës së të dhënave

Byte_per_cluster = fbs.cluster_size * 512; // madhësia e grupit në bajt

Root_cluster = fbs.root_cluster; // numri i grupit të drejtorisë rrënjësore

Ne lexojmë FAT32:

Nëse (read_fat32 ()< 0) return -1;

Alokoni memorien për hyrjet në direktori:

Dir_hyrja = (__u8 *) malloc (byte_per_cluster);

Nëse (! Dir_hyrje) kthehet -1;

Ne lexojmë direktorinë rrënjë:

Nëse (read_directory (root_cluster)< 0) return -1;

Ne analizojmë rrugën e plotë të skedarit dhe ndajmë çdo element në përbërësit e tij:

Ndërsa (1) (

Memset (tmp_name_buff, 0, SHORT_NAME);

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

Për (n = 0; n< SHORT_NAME; n++, i++) {

Tmp_emri_buff [n] = shteg_plotë [i];

Nëse ((tmp_name_buff [n] == "/") || (tmp_name_buff [n] == "\ 0")) (

Unë ++;

Pushim;

Tmp_name_buff [n] = "\ 0";

Nëse (split_name (tmp_name_buff, & sn)< 0) {

Printf ("emri i pavlefshëm \ n");

Kthimi -1;

Nëse (get_dentry (& sn)< 0) {

Printf ("Nuk ka skedar të tillë! \ N");

Kthimi -1;

Për të marrë numrin fillestar të një grupi në sistemin e skedarëve FAT32, duhet të përdorni fjalën më domethënëse të numrit të grupit të parë të skedarit - fushën starthi të strukturës së dhëmbëve:

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

Kontrollimi i bajtit të atributit:

Nëse (dentry.attr & 0x10) (// kjo është një direktori

Nëse (read_directory (start_cluster)< 0) return -1;

Vazhdo;

Nëse (dentry.attr & 0x20) (// dhe ky është një skedar

Tmp_buff = (__u8 *) malloc (byte_per_cluster);

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

Nëse (n< 0) {

Perror ("i hapur");

Kthimi -1;

Printf ("grupi i parë i skedarit - 0x% X ..", start_cluster);

Për (i = 0; i< num; i++) {

Memset (tmp_buff, 0, byte_per_cluster);

Nëse (read_cluster (start_cluster, tmp_buff)< 0) return -1;

Nëse (shkruani (n, tmp_buff, byte_per_cluster)< 0) {

Perror ("shkruaj");

Kthimi -1;

Nëse (grupi_tjetër == EOF_FAT32) (

Falas (tmp_buff);

Mbyll (n);

Kthimi ++ i;

Start_cluster = grupi_tjetër;

Kthimi i;

Qëllimi i tre funksioneve të ardhshme është të marrin përmbajtjen e zonës së sistemit, d.m.th. Sektori i nisjes, struktura FSIinfo dhe tabela FAT32:

1) funksioni read_fbs () lexon sektorin e nisjes:

int read_fbs ()

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

Kthimi 0;

2) funksioni read_fs_info () lexon strukturën FSIinfo:

int read_fs_info ()

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

Nëse (pread64 (hard, (__u8 *) & fsinfo, sizeof (fsinfo), kërko)< 0) return -1;

Kthimi 0;

3) funksioni read_fat32 () lexon tabelën FAT32:

int read_fat32 ()

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

Fat32 = (void *) malloc (fat32_size);

Nëse (! Fat32) kthehet -1;

Nëse (pread64 (fort, (__u8 *) fat32, fat32_size, kërko)< 0) return -1;

Kthimi 0;

Funksioni read_cluster () lexon grupin me numrin e specifikuar:

int read_cluster (__ u32 cluster_num, __u8 * tmp_buff)

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

Nëse (pread64 (e vështirë, tmp_buff, byte_per_cluster, kërko)< 0) return -1;

Kthimi 0;

Leximi i drejtorive (duke përfshirë atë rrënjësor) trajtohet nga funksioni read_directory ():

int read_directory (__ u32 start_cluster)

Int i = 2;

U32 next_cluster;

Parametrat e funksionit - grupi fillestar i drejtorive. Ne lexojmë përmbajtjen e drejtorisë në tampon global dir_entry:

Nëse (read_cluster (start_cluster, dir_entry)< 0) return -1;

Tjetër_grup = yndyrë32;

Nëse drejtoria zë një grup - dilni, nëse jo - rritni madhësinë e kujtesës dhe vazhdoni të lexoni:

Për (;; i ++) (

Start_cluster = grupi_tjetër;

Dir_hyrja = (__u8 *) realloc (dir_hyrja, i * byte_per_cluster);

Nëse (! Dir_hyrje) kthehet -1;

Nëse (grupi_leximi (grupi_fillimi, (hyrja_direkte + (i - 1) * byte_per_cluster))< 0) return -1;

Tjetër_grup = yndyrë32;

Nëse ((grupi_tjetër == EOF_FAT32) || (grupi_tjetër == 0xFFFFFF8)) kthen 0;

Kthimi 0;

Funksioni i fundit që do të shikojmë kërkon përmbajtjen e një drejtorie për një element që përputhet me skedarin që kërkoni:

int get_dentry (struct split_name * sn)

Int i = 0;

Treguesi dir_entry vendoset në një zonë të memories që përmban një sërë hyrjesh në drejtori, në të cilën do të kërkojmë një skedar (ose drejtori). Për të kërkuar, ne organizojmë një cikël dhe vendosim rekordin e gjetur në strukturën globale të dhëmbëve:

Për (;; i ++) (

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

Nëse (! (Memcmp (dentry.name, sn-> emri, sn-> emri_len)) &&

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

Pushim;

Nëse (! Dentry.name) kthen -1;

Kthimi 0;

Kjo përfundon rishikimin e modulit për leximin e një skedari nga një ndarje FAT32.

Kodet burimore të modulit gjenden në direktorinë FAT32, skedari fat32.c.

Dallimet në organizimin e ruajtjes së të dhënave të skedarëve në drejtoritë për sistemet e skedarëve FAT dhe EXT2

Disa fjalë për ndryshimet në organizimin e ruajtjes së të dhënave të skedarëve në drejtoritë për sistemet e skedarëve FAT dhe EXT2. Struktura e sistemit të skedarëve EXT2 u diskutua në.

Sapo u njohëm me FAT - në të të gjithë elementët e katalogut kanë një madhësi fikse. Kur krijoni një skedar, drejtuesi i sistemit të skedarëve kërkon pozicionin e parë të pazënë dhe e plotëson atë me informacione rreth skedarit. Nëse gjatësia e drejtorisë nuk përshtatet në një grup, atëherë një grup tjetër ndahet për të, etj.

Le të shohim se si janë gjërat në EXT2.

Supozoni se kemi një ndarje me sistemin e skedarëve EXT2, madhësia e bllokut është 4096 byte. Në këtë seksion, ne krijojmë një direktori. Madhësia e drejtorisë do të jetë e barabartë me madhësinë e bllokut - 4096 byte. Sistemi operativ krijon menjëherë dy hyrje në drejtori - hyrjen për direktoriumin aktual dhe hyrjen për direktoriumin prind. Hyrja aktuale e drejtorisë do të marrë 12 bajt, ndërsa hyrja mëmë do të jetë 4084 bajt. Le të krijojmë një skedar në këtë direktori. Pas kësaj, drejtoria do të përmbajë tre hyrje - hyrja aktuale e drejtorisë është 12 bajt e gjatë, hyrja e drejtorisë mëmë është tashmë 12 bajt dhe hyrja e skedarit të krijuar është, siç e keni menduar ndoshta, 4072 bajt. Nëse fshijmë skedarin e krijuar, gjatësia e hyrjes së direktoriumit prind do të rritet përsëri në 4084 bajt.

Kështu, kur krijoni një skedar, drejtuesi i sistemit të skedarëve EXT2 shikon në drejtori për një hyrje me gjatësi maksimale dhe e ndan atë, duke lënë vend për një hyrje të re. Epo, nëse, në fund të fundit, nuk ka hapësirë ​​të mjaftueshme, një bllok më shumë ndahet për drejtorinë dhe gjatësia e drejtorisë bëhet e barabartë me 8192 bajt.

Dhe në përfundim - një korrigjim i vogël në artikullin "Arkitektura e sistemit të skedarëve EXT2".

Ky rishikim ka të bëjë me funksionin get_i_num () për përcaktimin e numrit inode sipas emrit të skedarit. Versioni i vjetër i këtij funksioni dukej kështu:

int get_i_num (char * emri)

Int i = 0, rec_len = 0;

Struktura ext2_dir_entry_2 dent;

Për (; i< 700; i++) {

Nëse (! Memcmp (dent.emri, emri, dent.name_len)) thyhet;

Rec_len + = dent.rec_len;

Return dent.inode;

Versioni i korrigjuar:

int get_i_num (char * emri)

* Parametri i funksionit - emri i skedarit. Vlera e kthyer është numri inode i skedarit.

Int rec_len = 0;

Struktura ext2_dir_entry_2 dent; // kjo strukturë përshkruan formatin e hyrjes së direktoriumit rrënjë:

* Buff global përmban një sërë hyrjesh në drejtori. Për të përcaktuar numrin serial të inodit të skedarit, duhet të gjeni

* në këtë grup, një hyrje me emrin e këtij skedari. Për ta bërë këtë, ne do të organizojmë një cikël:

per (;;) (

/ * Kopjoni hyrjet e drejtorisë në strukturën e dhëmbëzuar: * /

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

* Gjatësia e emrit të skedarit është e barabartë me zero do të thotë se ne kemi numëruar të gjitha hyrjet në drejtori

* dhe regjistrimet me emrin e skedarit tonë nuk u gjetën. Pra, është koha për t'u kthyer:

Nëse (! Dent.name_len) kthen -1;

/ * Kërkimi kryhet duke krahasuar emrat e skedarëve. Nëse emrat përputhen, dilni nga cikli: * /

Nëse (! Memcmp (dent.emri, emri, strlen (emri))) thyhet;

/ * Nëse emrat nuk përputhen, kaloni në hyrjen tjetër: * /

Rec_len + = dent.rec_len;

/ * Nëse ka sukses, ktheni numrin inode të skedarit: * /

Return dent.inode;

Literatura:

1. V. Kulakov. Programimi i harduerit: Një referencë speciale. 2nd ed. / - SPb .: Peter, 2003 - 848 f.
2. A.V. Gordeev, A.Yu. Molchanov. Softueri i sistemit / - SPb .: Peter - 2002
3. Meshkov V. Arkitektura e sistemit të skedarëve ext2. - Revista "Administratori i Sistemit", Nr.11 (12), Nëntor 2003 - 26-32 f.

Në kontakt me

FAT - Tabela e ndarjes së skedarëve - Ky term i referohet një prej mënyrave për të organizuar sistemin e skedarëve në një disk. Kjo tabelë ruan informacione rreth skedarëve në hard diskun tuaj si një sekuencë numrash që përcaktojnë se ku ndodhet secila pjesë e secilit skedar. Me ndihmën e tij, sistemi operativ zbulon se cilat grupime zë skedari i kërkuar. FAT është sistemi më i zakonshëm i skedarëve dhe mbështetet nga shumica dërrmuese e sistemeve operative. FAT fillimisht ishte 12-bit dhe lejonte disqe dhe disqe logjike deri në 16 MB në madhësi. Në MS-DOS 3.0, FAT është 16-bit për të mbështetur disqet më të mëdhenj dhe FAT 32-bit përdoret për disqet deri në 2047 GB.

FAT32 është një sistem skedari më i ri i bazuar në formatin FAT dhe mbështetet nga Windows 95 OSR2, Windows 98 dhe Windows Millennium Edition. FAT32 përdor identifikues grupesh 32-bitësh, por rezervon 4 bitët e sipërm, kështu që madhësia efektive e identifikuesit të grupit është 28 bit. Meqenëse madhësia maksimale e grupeve FAT32 është 32 KB, në teori FAT32 mund të trajtojë vëllime 8 TB. Windows 2000 kufizon madhësinë e vëllimeve të reja FAT32 në 32 GB, megjithëse mbështet vëllime më të mëdha ekzistuese EAT32 (të krijuara me sisteme të tjera operative). Numri më i madh i grupimeve të mbështetura nga FAT32 e lejon atë të menaxhojë disqet në mënyrë më efikase se FAT 16. FAT32 mund të përdorë grupime 512 bajt për vëllime deri në 128 MB.

Sistemi i skedarëve FAT 32 në Windows 98 përdoret si sistemi kryesor i skedarëve. Ky sistem operativ vjen me një program të veçantë për konvertimin e një disku nga FAT 16 në FAT 32. Windows NT dhe Windows 2000 mund të përdorin gjithashtu sistemin e skedarëve FAT, dhe për këtë arsye ju mund të nisni kompjuterin tuaj nga një disk DOS dhe të keni akses të plotë në të gjithë skedarët . Megjithatë, disa nga veçoritë më të avancuara të Windows NT dhe Windows 2000 ofrohen nga sistemi i tij i skedarëve NT, ntfs. ntfs lejon ndarje të diskut deri në 2 TB (si FAT 32), por gjithashtu ka kompresim të integruar të skedarëve, siguri dhe auditim për rrjetëzim. Dhe në Windows 2000 zbatohet mbështetja për sistemin e skedarëve FAT 32. Instalimi i sistemit operativ Windows NT fillon në një disk FAT, por në fund të instalimit, të dhënat në disk mund të konvertohen në formatin ntfs.

Këtë mund ta bëni më vonë duke përdorur programin Convert.exe të dhënë me sistemin operativ. Ndarja e diskut e konvertuar në ntfs bëhet e paarritshme për sistemet e tjera operative. Për t'u kthyer në DOS, Windows 3.1 ose Windows 9x, duhet të fshini ndarjen ntfs dhe në vend të kësaj të krijoni një ndarje FAT. Windows 2000 mund të instalohet në një disk me sistemin e skedarëve FAT 32 dhe ntfs.

Aftësitë e sistemeve të skedarëve EAT32 janë shumë më të gjera se ato të FAT16. Karakteristika më e rëndësishme është se mbështet disqet deri në 2,047 GB dhe punon me grupe më të vogla, duke reduktuar ndjeshëm sasinë e hapësirës së humbur në disk. Për shembull, një hard disk 2 GB në FAT16 përdor grupe 32 KB, ndërsa FAT32 përdor grupime 4 KB. Për të ruajtur sa më shumë përputhshmërinë me programet, rrjetet dhe drejtuesit e pajisjeve ekzistuese, FAT32 është zbatuar me ndryshime minimale në arkitekturë, API, struktura të brendshme të të dhënave dhe formatin e diskut. Por, meqenëse madhësia e elementeve të tabelës FAT32 tani është katër bajtë, shumë struktura të të dhënave të brendshme dhe në disk, si dhe API, duhej të rishikoheshin ose zgjeroheshin. Disa API në disqet EAT32 janë të kyçura për të parandaluar që shërbimet e vjetëruara të diskut të korruptojnë përmbajtjen e disqeve FAT32. Shumica e programeve nuk do të preken nga këto ndryshime. Mjetet dhe drejtuesit ekzistues do të funksionojnë edhe në disqet FAT32. Megjithatë, drejtuesit e pajisjes së bllokut MS-DOS (si Aspidisk.sys) dhe shërbimet e diskut duhet të modifikohen për të mbështetur FAT32. Të gjitha shërbimet e diskut të ofruara nga Microsoft (Format, Fdisk, Defrag dhe ScanDisk për mënyra reale dhe të mbrojtura) janë ridizajnuar për të mbështetur plotësisht FAT32. Përveç kësaj, Microsoft po ndihmon shitësit kryesorë të shërbimeve të disqeve dhe drejtuesve të pajisjeve të modifikojnë produktet e tyre për të mbështetur FAT32. FAT32 është më efikas se FAT16 kur punon me disqe më të mëdhenj dhe nuk kërkon ndarje në ndarje 2 GB. Windows 98 domosdoshmërisht mbështet FAT16, pasi ky sistem i veçantë skedarësh është i pajtueshëm me sisteme të tjera operative, duke përfshirë kompanitë e palëve të treta. Në MS-DOS Real Mode dhe Windows 98 Safe Mode, FAT32 është dukshëm më i ngadalshëm se FAT16. Prandaj, kur filloni programet në modalitetin MS DOS, këshillohet të përfshini një komandë për të ngarkuar Smartdrv.exe në skedarin Autoexec.bat ose PIF, i cili do të përshpejtojë funksionimin e diskut. Disa programe të vjetra të dizajnuara për specifikimin FAT16 mund të raportojnë informacion të pasaktë në lidhje me sasinë e hapësirës së lirë ose totale të diskut nëse është më shumë se 2 GB. Windows 98 ofron API të reja për MS-DOS dhe Win32 që ju lejojnë të përcaktoni saktë këto metrikë. Tabela 1 tregon karakteristikat krahasuese të FAT16 dhe FAT32.

Tabela 1. Krahasimi i sistemeve të skedarëve FAT16 dhe FAT32

Gjatësia maksimale e mundshme e skedarit në FAT32 është 4 GB minus 2 bajt. Aplikacionet Win32 mund të hapin skedarë të kësaj gjatësie pa ndonjë përpunim të veçantë. Aplikacionet e tjera duhet të përdorin ndërprerjen Int 21h, funksionin 716C (FAT32) me flamurin e hapur EXTEND-SIZE (1000h).

Në sistemin e skedarëve FAT32, në tabelën e ndarjes së skedarëve ndahen 4 bajt për çdo grupim, ndërsa në FAT16 - 2, dhe në FAT12 - 1.5.

4 bitet më domethënëse të elementit 32-bit të tabelës FAT32 janë të rezervuara dhe nuk marrin pjesë në formimin e numrit të grupimit. Programet që lexojnë drejtpërdrejt tabelën PAT32 duhet t'i maskojnë këto pjesë dhe t'i mbrojnë ato nga ndryshimi kur shkruhen vlera të reja.

Pra, FAT32 ka përparësitë e mëposhtme mbi implementimet e mëparshme të sistemit të skedarëve FAT:

Mbështet disqe deri në 2 TB;

organizon hapësirën e diskut në mënyrë më efikase. FAT32 përdor grupe më të vogla (4 KB për disqet deri në 8 GB), të cilat mund të kursejnë deri në 10-15% hapësirë ​​në disqet e mëdhenj në krahasim me FAT;

direktoria rrënjësore FAT 32, si të gjitha drejtoritë e tjera, tani është e pakufizuar, përbëhet nga një zinxhir grupimesh dhe mund të vendoset kudo në disk;

ka një besueshmëri më të lartë: FAT32 është në gjendje të lëvizë direktoriumin rrënjë dhe të punojë me një kopje rezervë FAT, përveç kësaj, rekordi i nisjes në disqet FAT32 është zgjeruar për të përfshirë një kopje rezervë të strukturave kritike të të dhënave, që do të thotë se disqet FAT32 janë më pak të ndjeshëm ndaj shfaqja e seksioneve të veçanta të këqija sesa vëllimet ekzistuese FAT;

programet ngarkohen 50% më shpejt.

Tabela 2. Krahasimi i madhësive të grupimeve

Një mjet i përmirësuar i defragmentimit të diskut optimizon vendosjen e skedarëve të aplikacionit të ngarkuar në momentin e nisjes së aplikacionit. Është e mundur të konvertohet disku në EAT32 duke përdorur programin Drive Converter (FAT32), por pas kësaj rekomandohet të ekzekutoni programin Disk Defragmenter, përndryshe kompjuteri do të punojë me diskun më ngadalë se më parë. Përdorimi i FAT32 e bën të pamundur konfigurimin e Windows 98 dhe Windows NT 4.0 Alternate Boot sepse ky i fundit nuk mbështet FAT32. FAT32 ndan hapësirën në disk shumë më ekonomikisht sesa versionet e mëparshme të sistemit të skedarëve FAT. Kjo mund të çlirojë dhjetëra apo edhe qindra megabajt në disqe të mëdhenj dhe kur kombinohet me programin e avancuar të defragmentimit të diskut FAT32, redukton ndjeshëm kohën e ngarkimit të aplikacionit. Konvertimi i sistemit të skedarëve të diskut të ngurtë në FAT32 duke përdorur Drive Converter (FAT32) është i thjeshtë. Për ta bërë këtë, hapni menynë Start, nënmenynë e programeve, Aksesorët, Veglat e Sistemit dhe zgjidhni komandën Drive Converter (FAT32). Konvertimi mund të ndikojë në veçoritë e hibernimit (duke ruajtur gjendjen e kompjuterit në disk) që ofrohen në shumë kompjuterë. Sistemet në të cilat modaliteti i gjumit zbatohet përmes ARM BIOS ose ACPI (Konfigurimi i avancuar dhe ndërfaqja e energjisë) S4 / BIOS duhet të mbështesin FAT32 - vetëm atëherë ato do të funksionojnë siç duhet në Windows 98.

Shumica e prodhuesve të BIOS përfshijnë mbrojtje antivirus që monitoron ndryshimet në Master Boot Record (MBR). Për më tepër, shërbimet e vjetra antiviruse të instaluara si TSR ose drejtues të modalitetit real mund të zbulojnë ndryshimet MBR kur MS-DOS niset. Meqenëse konvertimi në FAT32 do të modifikojë në mënyrë të pashmangshme MBR, disa skanerë virusesh mund ta konsiderojnë gabimisht këtë si një shenjë të infeksionit të sistemit. Prandaj, nëse mjeti antivirus zbulon një ndryshim në MBR, ai ofron për ta "kuruar" atë. Është më mirë të çinstaloni programin tuaj antivirus dhe të çaktivizoni mbrojtjen e integruar të BIOS-it nga viruset përpara se ta konvertoni diskun në FAT32. Më pas mund të riinstaloni programin antivirus dhe të aktivizoni mbrojtjen antivirus të integruar në BIOS.