1. Štruktúra sektora FSInfo struct fat_boot_fsinfo:
   • __u32 podpis1– podpis 0x41615252;
   • __u32 podpis2– podpis 0x61417272;
   • __u32 free_clusters je počet voľných zhlukov. Ak pole obsahuje -1, vyhľadávanie voľných klastrov by malo začať od klastra číslo 2.
2. Stručný názov štruktúry položky adresára msdos_dir_entry:
   • __s8 meno, ext– názov a prípona súboru;
   • __u8 attr– atribúty súboru;
   • __u8 ctime_ms– toto pole určuje čas vytvorenia súboru do ms (používa sa iba FAT32);
   • __u16 ctime– čas vytvorenia súboru (používa sa iba FAT32);
   • __u16 cdate– dátum vytvorenia súboru (používa sa iba FAT32);
   • __u16 dátum– dátum posledného prístupu k súboru (používa sa len FAT32);
   • __u16 štarthi– horných 16 bitov čísla prvého klastra súboru (používa sa len FAT32);
   • __u16čas, dátum, začiatok– čas a dátum vytvorenia súboru, číslo prvého klastra súborov;
   • Veľkosť __u32– veľkosť súboru (v bajtoch).
3. Štruktúra záznamu v adresári s dlhým názvom:
   • __u8 id– číslo prvku;
   • __u8 meno0_4- znaky 1 - 5 mena;
   • __u8 attr– atribúty súboru;
   • __u8 alias_checksum– kontrolný súčet krátkeho názvu;
   • __u8 meno5_10- znaky 6 - 11 mena;
   • __u8 meno11_12- znaky 12 - 13 mena.

Pokračujme v úvahách o softvérovej implementácii algoritmu a určme názov oddielu, na ktorom bol vytvorený súborový systém FAT16:

#ifndef FAT16_PART_NAME

#define FAT16_PART_NAME "/dev/hda1"

#koniec Ak

Globálne štruktúry:

struct fat_boot_sector fbs; // štruktúra boot sektora

struct msdos_dir_entry dentry; // štruktúra prvkov adresára

Globálne premenné:

U16 *tuk16; // tu skopírujte tabuľku FAT16

U16 sektor_veľkosť; // veľkosť sektora (z FAT16)

U16 dir_entries; // počet 32-bajtových deskriptorov

// v koreňovom adresári (0 pre FAT32)

sektory U16; // celkový počet sektorov v oddiele

U32 fat16_veľkosť; // Veľkosť FAT16

U32 root_size; // veľkosť koreňového adresára

U16 byte_per_cluster; // veľkosť klastra v bajtoch

U16 ďalší_klaster; // ďalší klaster v reťazci

int tuk;

Začnime s hlavnou funkciou:

int main()

int num;

Nastavíme úplný názov súboru, ktorého obsah chceme čítať. Pripomínam, že pracujeme len s krátkymi názvami súborov. Postup pri práci s dlhými názvami sa v tomto článku nezaoberá.

U8 *úplná_cesta = "/Priečinok1/Priečinok2/text.txt";

Otvorte súbor zariadenia:

Hard = open(FAT16_PART_NAME, O_RDONLY);

Ak (tvrdé< 0) {

error(FAT16_PART_NAME);

Exit(-1);

Čítame prvých 10 zhlukov súboru. Čítanie vykonáva funkcia fat16_read_file(). Parametre funkcie sú úplný názov súboru a počet klastrov na čítanie. Funkcia vráti počet prečítaných klastrov alebo -1, ak sa pri čítaní vyskytla chyba:

Num = fat16_read_file(úplná_cesta, 10);

Ak(č< 0) perror("fat16_read_file");

Else printf("Prečítať %d klastre ", num);

Zatvorte súbor zariadenia a ukončite:

zavrieť (tvrdo);

návrat 0;

Funkcia na čítanie klastrov súborov je nasledovná:

int fat16_read_file(__u8 *úplná_cesta, int num)

Struct split_name sn; // štruktúra na ukladanie častí súboru

U8 tmp_name_buff; // buffer na dočasné uloženie zložených prvkov celej cesty k súboru

Statické int i = 1;

int n;

U8 *tmp_buff;

U16 start_cluster, next_cluster;

Parametre funkcie sme uviedli pri zvažovaní hlavnej funkcie.

Prípravné operácie - resetujte vyrovnávaciu pamäť tmp_name_buff a štruktúru split_name sn:

Prvý znak v absolútnej ceste k súboru musí byť lomka (/). Pozrime sa na to:

Prečítajte si zavádzací sektor z oddielu:

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

Čítací zavádzací sektor je teraz v globálnej štruktúre struct fat_boot_sector fbs. Skopírujte z tejto štruktúry veľkosť sektora, počet záznamov v koreňovom adresári a celkový počet sektorov na oddiele:

Určite veľkosť klastra v bajtoch:

Byte_per_cluster = fbs.cluster_size * 512

Zobrazme informácie v zavádzacom sektore:

Printf("ID systému - %s ", fbs.id_systému);

Printf("Veľkosť sektora - %d ", veľkosť_sektora);

Printf("Veľkosť klastra - %d ", fbs.veľkosť_klastra);

Printf("Rezervované - %d ", fbs.rezervované);

Printf("číslo FAT - %d ",fbs.fats);

Printf("Položky adresára - %d ", položky_adresára);

Printf("Sektory - %d ", sektory);

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

Printf("dĺžka FAT16 - %u ", fbs.fat_length);

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

Printf("Bajt na klaster - %d ", byte_na_klaster);

Vypočítame veľkosť FAT16 v bajtoch a prečítame:

fat16_size = fbs.fat_length * 512;

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

Čítanie koreňového adresára:

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

Ukazovateľ dir_entry je teraz umiestnený do oblasti pamäte obsahujúcej položky koreňového adresára. Veľkosť tejto oblasti pamäte sa rovná veľkosti koreňového adresára (veľkosť_korena).

Uložte (pre kontrolu) obsah koreňového adresára do samostatného súboru:

#ifdef DEBUG

blízko(tuk);

#koniec Ak

Vypočítajte začiatok oblasti údajov:

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

So všetkými položkami v koreňovom adresári sa môžeme dostať k obsahu súboru test.txt. Za týmto účelom organizujeme cyklus. V tele cyklu rozoberieme celý názov súboru, pričom zvýrazníme jeho prvky – podadresáre (máme ich dva, Folder1 a Folder2) a názov požadovaného súboru (test.txt).

Kým (1) (

Memset(tmp_name_buff, 0, SHORT_NAME);

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

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

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

I++;

prestávka;

tmp_name_buff[n] = "?";

Štruktúru struct split_name sn naplníme príslušnými informáciami. Vypĺňanie sa vykonáva funkciou split_name a kontroluje sa, či je názov súboru v súlade s formátom "8.3":

< 0) {

printf("neplatné meno");

návrat -1;

Pre každý prvok úplného názvu súboru určujeme počiatočný klaster. Aby sme to dosiahli, hľadáme v prvkoch adresára (začínajúc od koreňového adresára) položku zodpovedajúcu prvku s úplným názvom a prečítame si túto položku. Vyhľadávaciu procedúru vykonáva funkcia get_dentry():

If(get_dentry(&sn)< 0) {

Printf("Žiadny takýto súbor!");

návrat -1;

Kontrola atribútov súboru. Ak je to adresár, prečítajte si jeho obsah a pokračujte v slučke:

If(dentry.attr & 0x10) (

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

ďalej;

Ak ide o súbor, čítame prvé num klastre. Pre kontrolu sa načítané informácie uložia do samostatného súboru:

If(dentry.attr & 0x20) (

Start_cluster = dentry.start;

tmp_buff = (__u8 *)malloc(byte_per_cluster); // tu sa prečíta obsah klastra

N = open("clust", O_CREAT|O_RDWR, 0600); // uložte prečítané informácie do tohto súboru

Ak(n< 0) {

error("otvoriť");

návrat -1;

Na čítanie zhlukov súboru organizujeme slučku:

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

Načítame obsah klastra do vyrovnávacej pamäte tmp_buff a uložíme ho do samostatného súboru:

< 0) return -1;

< 0) {

chyba("zapis");

close(n);

návrat -1;

Z FAT16 čítame číslo nasledujúceho klastra obsadeného týmto súborom. Ak je toto posledný klaster, prerušíme cyklus a vrátime sa k hlavnej funkcii:

#ifdef DEBUG

Printf("OK. Čítať");

Printf("ďalší klaster súboru - 0x%X .. ", ďalší_klaster);

#koniec Ak

If(next_cluster == EOF_FAT16) (

#ifdef DEBUG

Printf("posledný klaster.");

#koniec Ak

Free(tmp_buff);

close(n);

Návrat ++i;

#ifdef DEBUG

printf("zastaviť čítanie");

#koniec Ak

Návrat i;

Zavádzací sektor FAT16 je načítaný funkciou read_fbs(). Výsledok je umiestnený v globálnej štruktúre fbs:

int read_fbs()

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

návrat 0;

Čítanie alokačnej tabuľky súborov systému súborov FAT16 sa vykonáva funkciou read_fat16():

int read_fat16()

U64 hľadať = (__u64)(fbs.rezervované) * 512; // posun na FAT16 od začiatku oddielu

Fat16 = (void *)malloc(fat16_size);

If(pred64(tvrdý, (__u8 *)tučný16, tučný16_veľkosť, hľadať)< 0) return -1;

návrat 0;

Koreňový adresár číta funkcia read_root_dentry():

int read_root_dentry()

U64 seek = (__u64)fbs.rezervované * 512 + fat16_size * fbs.fats; // posun do koreňového adresára od začiatku sekcie

Root_size = 32 * dir_entries; // výpočet veľkosti koreňového adresára

dir_entry = (__u8 *)malloc (veľkosť_korena);

If(!dir_entry) return -1;

Memset(položka_adresára, 0, veľkosť_korena);

If(pred64(tvrdé, adresár, veľkosť_korena, hľadať)< 0) return -1;

návrat 0;

Čítanie klastra patriacemu súboru sa vykonáva funkciou read_cluster(). Vstupnými parametrami funkcie sú číslo klastra cluster_num a ukazovateľ na vyrovnávaciu pamäť __u8 *tmp_buff, do ktorej by sa mal umiestniť výsledok čítania. Odsadenie klastra na oddiele sa vypočíta podľa vzorca (pozri):

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

• HĽADAŤ– offset do klastra na oddiele
• DATA_START– začiatok dátovej oblasti
• CLUSTER_NUM– poradové číslo klastra
• BYTE_PER_CLUSTER– veľkosť klastra v bajtoch

int read_cluster(__u16 cluster_num, __u8 *tmp_buff)

U64 seek = (__u64)(byte_per_cluster) * (cluster_num - 2) + data_start; // výpočet posunu klastra

< 0) return -1;

návrat 0;

Funkcia read_directory načíta položky adresára (nie koreňového adresára) a umiestni výsledok do oblasti pamäte, na ktorú ukazuje ukazovateľ dir_entry:

int read_directory(__u16 start_cluster)

Int i = 1;

U16 ďalší_klaster;

Pre (; ;i++) (

Alokujeme pamäť na uloženie obsahu adresára, prečítame obsah štartovacieho klastra a získame hodnotu nasledujúceho klastra z tabuľky FAT16:

If(!dir_entry) return -1;

< 0) return -1;

Ďalší_klaster = tuk16;

Uložme obsah adresára do samostatného súboru (pre kontrolu):

#ifdef DEBUG

Printf("Ďalší klaster - 0x%X", ďalší_klaster);

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

Write(fat, dir_entry, root_size);

blízko(tuk);

#koniec Ak

Ak sa dosiahne posledný klaster, ukončite cyklus, inak pokračujte v čítaní adresára zväčšením veľkosti vyrovnávacej pamäte dir_entry o jeden ďalší klaster:

If(next_cluster & EOF_FAT16) break;

start_cluster = dalsi_klaster;

návrat 0;

Funkcia get_dentry() vykoná v obsahu adresára vyhľadávanie prvku zodpovedajúceho hľadanému súboru. Vstupné parametre tejto funkcie sú ukazovateľ na štruktúru split_name *sn, ktorá obsahuje prvky krátkeho názvu súboru:

Int i = 0;

Globálna vyrovnávacia pamäť dir_entry obsahuje pole položiek adresára, v ktorom budeme hľadať položku súboru (alebo adresára). Na vyhľadávanie organizujeme cyklus. V tele cyklu skopírujeme prvky katalógu do globálnej štruktúry dentry a porovnáme hodnotu polí name a ext tejto štruktúry s príslušnými poľami štruktúry split_name *sn. Zhoda týchto polí znamená, že sme našli záznam požadovaného súboru v poli prvkov adresára:

pre (; ; i++) (

If(!(memcmp(dentry.name, sn->meno, sn->meno_len)) &&

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

prestávka;

If(!dentry.name) return -1;

#ifdef DEBUG

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

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

Printf("veľkosť súboru - %u ", dentry.size);

Printf("attrib súboru - 0x%X ", dentry.attr);

#koniec Ak

návrat 0;

Všetok vyššie uvedený kód sa nachádza v adresári FAT16, súbor fat16.c. Ak chcete získať spustiteľný modul, vytvorte súbor Makefile s nasledujúcim obsahom:

INCDIR = /usr/src/linux/include

PHONY=čistý

Tuk16: tuk16.o rozdelený.o

Gcc -I$(INCDIR) $^ -g -o $@

%.o: %.c

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

čisté:

Rm -f *.o

Rm -f ./tuk16

Softvérová implementácia algoritmu na čítanie súboru z logického oddielu so súborovým systémom FAT12

Vo všeobecnosti je algoritmus na čítanie súboru z oblasti FAT12 identický s algoritmom na čítanie súboru z oblasti FAT16. Rozdiel spočíva v postupe čítania prvkov z tabuľky FAT12. Tabuľku FAT16 sme považovali za jednoduché pole 16-bitových prvkov. Na čítanie prvkov tabuľky FAT12 sa navrhuje nasledujúci algoritmus:

• vynásobte číslo prvku číslom 1,5;
• extrahovať 16-bitové slovo z FAT použitím výsledku predchádzajúcej operácie ako ofsetu;
• ak je číslo prvku párne, vykonajte operáciu AND na prečítanom slove a maske 0x0FFF. Ak je číslo nepárne, posuňte prečítané slovo z tabuľky o 4 bity smerom k najmenej významným bitom.

Na základe tohto algoritmu implementujeme funkciu čítania prvkov z tabuľky FAT12:

int get_cluster(__u16 cluster_num)

U16 hľadať;

klaster U16;

Vypočítame offset v tabuľke FAT12 a prečítame 16-bitové slovo z tabuľky:

Hľadať = (cluster_num * 3) / 2;

Memcpy((__u8 *)&clust, (__u8 *)(tuk12 + hľadať), 2);

Ak je počiatočné číslo klastra párne, posunieme hodnotu načítanú z tabuľky o 4 bity smerom k nižším bitom, ak je nepárne, pripočítame ju 0x0FFF:

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

Else zhluk &= 0x0FFF;

Tento úryvok je možné implementovať aj v assembleri:

" xorw %%ax, %%ax "

"btw $0, %%cx"

"jnc 1f"

"shrw $4, %%dx"

"jmp2f"

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

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

:"=a" (ďalší)

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

Vrátime výsledok:

návratový klaster;

Pozrime sa bližšie na samotný algoritmus. Predpokladajme, že súbor bol vytvorený na oddiele FAT12, ktorý zaberá 9. a 10. klaster. Každý prvok FAT12 má 12 bitov. Pretože z tabuľky načítame 16-bitové prvky, potom sa posun k 9. prvku bude rovnať 13 bajtom (9 * 1,5 = 13, zvyšok zahoďte), pričom spodné 4 bity budú patriť 8. prvku FAT. Musia byť vyradené a na to stačí posunúť čítací prvok o 4 bity smerom k nižším bitom, čo zabezpečuje algoritmus. Posun k 10. prvku bude 15 bajtov a vysoké 4 bity budú patriť 11. prvku FAT. Na ich vyradenie je potrebné vykonať operáciu AND na 10. prvku a maske 0x0FFF, čo tiež zodpovedá vyššie uvedenému algoritmu.

Zdrojové texty modulu na čítanie súboru z FAT12 partície sa nachádzajú v adresári FAT12, súbor fat12.c.

Softvérová implementácia algoritmu na čítanie súboru z logického oddielu so systémom súborov FAT32

Algoritmus na čítanie súboru z oddielu so súborovým systémom FAT32 je prakticky rovnaký ako pre FAT16, až na to, že v systéme FAT32 môže byť koreňový adresár umiestnený kdekoľvek na oddiele a môže mať ľubovoľnú veľkosť. Preto, aby to bolo zaujímavejšie, skomplikujme si úlohu – predpokladajme, že poznáme iba číslo partície so súborovým systémom FAT32. Ak chcete prečítať informácie z tohto oddielu, musíte najskôr určiť jeho súradnice - posun k oddielu od začiatku disku. A na to musíte mať predstavu o logickej štruktúre pevného disku.

Logická štruktúra pevného disku

Zoberme si logickú štruktúru pevného disku, ktorá zodpovedá štandardu spoločnosti Microsoft - "hlavný oddiel - rozšírený oddiel - oddiely mimo DOS".

Priestor na pevnom disku môže byť usporiadaný do jedného alebo viacerých oddielov a oddiely môžu obsahovať jednu alebo viacero logických jednotiek.

Na pevnom disku na fyzickej adrese 0-0-1 je hlavný zavádzací záznam (Master Boot Record, MBR). Štruktúra MBR obsahuje nasledujúce prvky:

• nesystémový bootloader (nesystémový bootstrap - NSB);
• tabuľka popisu oblastí disku (tabuľka oblastí, tabuľka oblastí, PT). Nachádza sa v MBR s posunom 0x1BE a zaberá 64 bajtov;
• Podpis MBR. Posledné dva bajty MBR musia obsahovať číslo 0xAA55.

Tabuľka oblastí popisuje umiestnenie a charakteristiky oblastí na pevnom disku. Diskové oddiely môžu byť dvoch typov - primárne (primárne, hlavné) a rozšírené (rozšírené). Maximálny počet primárnych oddielov je štyri. Prítomnosť aspoň jedného primárneho oddielu na disku je povinná. Rozšírený oddiel môže byť rozdelený na veľké množstvo podsekcií - logických jednotiek. Zjednodušená štruktúra MBR je uvedená v tabuľke 7. Tabuľka oddielov sa nachádza na konci MBR, na popis oddielu v tabuľke je pridelených 16 bajtov.

Tabuľka 7. Štruktúra MBR

Zaujatosť Veľkosť, bajty 0 446 0x1BE 16 0x1CE 16 0x1DE 16 0x1EE 16 0x1FE 2

Štruktúra záznamu tabuľky oddielov je uvedená v tabuľke 8.

Tabuľka 8. Štruktúra záznamu tabuľky oddielov

Prvý bajt v prvku sekcie je príznak aktivity sekcie (0 - neaktívny, 0x80 - aktívny). Slúži na zistenie, či je partícia zavádzacou oblasťou systému a či je potrebné z nej pri štarte počítača zaviesť operačný systém. Aktívna môže byť iba jedna sekcia. Za príznakom aktivity oddielu nasledujú súradnice začiatku oddielu – tri bajty, označujúce číslo hlavy, číslo sektora a číslo cylindra. Čísla valcov a sektorov sa uvádzajú vo formáte prerušenia Int 0x13, t.j. bity 0-5 obsahujú číslo sektora, bity 6-7 sú dva najvýznamnejšie bity 10-bitového čísla cylindra, bity 8-15 sú najmenej významných osem bitov čísla cylindra. Potom nasleduje kódový identifikátor System ID, ktorý označuje, že tento oddiel patrí do jedného alebo druhého operačného systému. Identifikátor zaberá jeden bajt. Za systémovým identifikátorom sú súradnice konca sekcie - tri bajty obsahujúce čísla hlavy, sektora a valca, resp. Ďalšie štyri bajty predstavujú počet sektorov pred oddielom a posledné štyri bajty predstavujú veľkosť oddielu v sektoroch.

Prvok tabuľky oddielov teda možno opísať pomocou nasledujúcej štruktúry:

struct pt_struct(

bootovateľný U8; // príznak aktivity sekcie

U8 štart_part; // súradnice začiatku úseku

U8 typ_diel; // systémový identifikátor

U8 koncová_časť; // súradnice konca úseku

U32 sekta_pred; // počet sektorov pred rozdelením

U32 sek_total; // veľkosť oddielu v sektoroch (počet sektorov v oddiele)

Prvok primárneho oddielu okamžite ukazuje na zavádzací sektor logického disku (v primárnom oddiele je vždy len jeden logický disk) a prvok rozšíreného oddielu ukazuje na zoznam logických diskov tvorený štruktúrami nazývanými sekundárne MBR (sekundárny MBR, SMBR).

Každý disk v rozšírenej partícii má svoj vlastný blok SMBR. SMBR má štruktúru podobnú MBR, ale nemá zavádzací záznam (vyplnený nulami) a používajú sa iba dve zo štyroch polí deskriptora oddielu. Prvý prvok oddielu ukazuje na logickú jednotku, druhý prvok ukazuje na ďalšiu štruktúru SMBR v zozname. Posledný SMBR v zozname obsahuje kód sekcie nula v druhom prvku.

Vráťme sa k úvahe o module na čítanie súboru z oblasti FAT32.

Hlavičkové súbory:

#include

#include

#include

#include

#include

Podpis MBR:

#define PODPIS 0xAA55

Súbor zariadenia, z ktorého sa budú čítať informácie o oddiele:

#define DEVICE "/dev/hda"

Veľkosť položky tabuľky oddielov (16 bajtov):

#define PT_SIZE 0x10

Nasledujúce pole štruktúr mapuje kód typu sekcie na jej mapovanie znakov:

struct systypes (

U8 časť_typ;

U8 *názov_časti;

struct systypes i386_sys_types = (

(0x00, "Prázdne"),

(0x01, "FAT12"),

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

(0x05, "Rozšírené"),

(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 rozšírený"),

(0x07, HPFS/NTFS)

Poďme určiť počet prvkov v poli i386_sys_types pomocou makra PART_NUM:

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

Nastavte limit počtu logických jednotiek:

#define MAX_PART 20

Nasledujúce štruktúrne pole bude obsahovať informácie o logických jednotkách na zariadení (pevnom disku):

struct pt_struct(

bootovateľný U8;

U8 štart_part;

U8 typ_diel;

U8 koncová_časť;

U32 sekta_pred;

U32 sekta_celkom;

)pt_t;

inthard; // deskriptor súboru zariadenia

U8mbr; // tu spočítajte MBR

Číslo oddielu, na ktorom bol vytvorený súborový systém FAT32:

#define FAT32_PART_NUM 5

Zavádzací sektor, sektor FSInfo a štruktúry záznamu adresára (definované v súbore ):

struct fat_boot_sector fbs;

struct fat_boot_fsinfo fsinfo;

struct msdos_dir_entry dentry;

U32 *tuk32 = NULL; // tu skopírujte tabuľku FAT32

U16 sektor_veľkosť; // veľkosť sektora (z FAT32)

U16 dir_entries; // 0 pre FAT32

sektory U16; // počet sektorov na oddiel

U32 fat32_size; // Veľkosť FAT32

U32 data_start; // začiatok dátovej oblasti

U16 byte_per_cluster; // koľko bajtov je v klastri (veľkosť klastra v bajtoch)

U32 ďalší_klaster; // ďalší klaster v reťazci

U32 root_cluster; // ROOT klaster - počiatočný klaster koreňového adresára

U8 *dir_entry = NULL; // ukazovateľ na položky adresára

U64 start_seek = 0; // odsadenie začiatku do sekcie (v bajtoch)

Hlavná funkcia:

int main()

int num = 0;

int cluster_num = 5; // koľko klastrov sa má čítať zo súboru

U8 *plná_cesta = "/Priečinok1/Priečinok2/readme"; // súbor na čítanie

Otvoríme zariadenie, získame informácie o tabuľke oddielov na zariadení a zobrazíme informácie o oddieloch:

Hard = open(DEV_NAME, O_RDONLY);

Ak (tvrdé< 0) {

chyba(DEV_NAME);

Exit(-1);

If(get_pt_info(tvrdé)< 0) {

error("get_pt_info");

Exit(-1);

Show_pt_info();

Vypočítajte počiatočný posun k oddielu:

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

Prečítajte si klastre patriace k súboru:

Num = fat32_read_file(úplná_cesta, číslo_klastra);

Ak(č< 0) perror("fat32_read_file");

Else printf("Prečítať %d klastre\n", num);

zavrieť (tvrdo);

návrat 0;

Informácie o tabuľke oddielov číta funkcia get_pt_info():

int get_pt_info (int hard)

Int i = 0;

U64 hľadať;

Čítame tabuľku oddielov z MBR a skontrolujeme podpis:

Read_main_ptable(hard);

If(check_sign()< 0) {

Printf("Neplatný podpis!\n");

návrat -1;

Hľadáme identifikátor rozšíreného úseku. Ak existuje, vypočítame posun k rozšírenému oddielu a prečítame informácie o logických jednotkách:

pre (;i< 4; i++) {

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

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

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

Hľadať = (__u64)pt_t[i].sect_before * 512;

Read_ext_ptable(tvrdé, hľadať);

prestávka;

návrat 0;

Funkcia čítania tabuľky oddielov read_main_ptable():

void read_main_ptable (int hard)

If(read(hard, mbr, 512)< 0) {

error("prečítať");

zavrieť (tvrdo);

Exit(-1);

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

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

návrat;

Funkcia kontroly podpisu check_sign():

int check_sign()

znak U16 = 0;

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

#ifdef DEBUG

Printf("Podpis - 0x%X\n", znamienko);

#koniec Ak

If(znamienko != PODPIS) return -1;

návrat 0;

Funkcia čítania rozšírenej tabuľky oddielov:

void read_ext_ptable (int ťažké, __u64 hľadať)

Int num = 4; // od tejto pozície sa pole štruktúr pt_t zaplní informáciami o logických jednotkách

U8 smbr;

Vstupné Data:

• ťažké– deskriptor súboru zariadenia;
• hľadať– posun k rozšírenému oddielu od začiatku disku (v bajtoch).

Na získanie informácií o logických diskoch organizujeme slučku:

Pre(;;num++) (

Čítame SMBR nachádzajúce sa pri posune vyhľadávania od začiatku disku:

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

pred64(tvrde, smbr, 512, hladat);

Vyplníme dva prvky tabuľky pt_t, počnúc od pozície č. Prvý prvok bude ukazovať na logickú jednotku a druhý prvok bude ukazovať na nasledujúcu štruktúru SMBR:

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

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

Vykonávame zmenu v poli „Číslo počiatočného sektora“ - odpočítavanie je od začiatku disku:

Pt_t.sect_before += (hľadať / 512);

Ak je kód typu oddielu nula, potom už neexistujú žiadne logické disky:

If(!(pt_t.type_part)) break;

Vypočítajte posun k ďalšiemu SMBR:

Hľadať = ((__u64)(pt_t.sect_before + pt_t.sect_total)) * 512;

návrat;

Funkcia show_pt_info() zobrazuje informácie o nájdených logických jednotkách v zariadení:

void show_pt_info()

Int i = 0, n;

#ifdef DEBUG

Printf("Počet oblastí na disku - %d\n", PART_NUM);

#koniec Ak

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

If(!pt_t[i].type_part) break;

Printf("\nTyp oblasti %d - ", i);

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

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

Printf("%s\n", i386_sys_types[n].názov_časti);

prestávka;

If(n == ČASŤ_NUM) printf("neznámy typ\n");

Printf("Boot flag - 0x%X\n", pt_t[i].bootable);

Printf("Sektory v sekcii %d - %d\n", i, pt_t[i].sect_total);

Printf("Sektory pred sekciou %d - %d\n\n", i, pt_t[i].sect_before);

návrat;

Čítanie zhlukov súborov z oblasti FAT32 sa vykonáva pomocou funkcie fat32_read_file(). Táto funkcia má veľa spoločného s funkciou fat16_read_file(), takže podrobné komentáre nájdete v bode 6:

int fat32_read_file(__u8 *úplná_cesta, int num)

Struct split_name sn;

U8 tmp_name_buff;

Int i = 1, n;

U32 start_cluster, next_cluster;

U8 *tmp_buff;

Prípravné operácie - vyčistite vyrovnávaciu pamäť, štruktúru a skontrolujte prvú lomku:

Memset(tmp_name_buff, 0, SHORT_NAME);

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

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

Čítanie zavádzacieho sektora:

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

Memcpy((void *)&veľkosť_sektora, (void *)fbs.veľkosť_sektora, 2);

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

Memcpy((void *)§ors, (void *)fbs.sectors, 2);

Čítame štruktúru FSInfo a zobrazujeme v nej podpis:

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

Printf("Podpis1 - 0x%X\n", fsinfo.podpis1);

Printf("Podpis2 - 0x%X\n", fsinfo.podpis2);

Fat32_size = fbs.fat32_length * 512; // Veľkosť FAT32 v bajtoch

data_start = 512 * fbs.reserved + fat32_size * 2; // začiatok dátového poľa

Byte_per_cluster = fbs.cluster_size * 512; // veľkosť klastra v bajtoch

root_cluster = fbs.root_cluster; // číslo klastra koreňového adresára

Prečítajte si FAT32:

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

Pridelenie pamäte pre záznamy v adresári:

Dir_entry = (__u8 *)malloc(byte_per_cluster);

If(!dir_entry) return -1;

Čítanie koreňového adresára:

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

Analyzujeme celú cestu k súboru a rozdelíme každý prvok na komponenty:

Kým (1) (

Memset(tmp_name_buff, 0, SHORT_NAME);

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

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

tmp_name_buff[n] = úplná_cesta[i];

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

I++;

prestávka;

tmp_name_buff[n] = "\0";

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

Printf("neplatné meno\n");

návrat -1;

If(get_dentry(&sn)< 0) {

Printf("Žiadny takýto súbor!\n");

návrat -1;

Ak chcete získať počiatočné číslo klastra v systéme súborov FAT32, musíte použiť vysoké slovo prvého čísla klastra súboru - pole starthi štruktúry dentry:

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

Kontrola bajtu atribútu:

If(dentry.attr & 0x10) ( // toto je adresár

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

ďalej;

If(dentry.attr & 0x20) ( // a toto je súbor

tmp_buff = (__u8 *)malloc(byte_per_cluster);

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

Ak(n< 0) {

error("otvoriť");

návrat -1;

Printf("prvý klaster súboru - 0x%X .. ", start_cluster);

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

Memset(tmp_buff, 0, byte_per_cluster);

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

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

chyba("zapis");

návrat -1;

If(next_cluster == EOF_FAT32) (

Free(tmp_buff);

close(n);

Návrat ++i;

start_cluster = dalsi_klaster;

Návrat i;

Účelom nasledujúcich troch funkcií je získať obsah systémovej oblasti, t.j. boot sektor, štruktúra FSInfo a tabuľka FAT32:

1) funkcia read_fbs() číta boot sektor:

int read_fbs()

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

návrat 0;

2) funkcia read_fs_info() číta štruktúru FSInfo:

int read_fs_info()

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

If(pred64(tvrdé, (__u8 *)&fsinfo, sizeof(fsinfo), hľadať)< 0) return -1;

návrat 0;

3) funkcia read_fat32() číta tabuľku FAT32:

int read_fat32()

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

Fat32 = (void *)malloc(veľkosť_tuku32);

If(!fat32) vráti -1;

If(pred64(tvrdé, (__u8 *)tuk32, veľkosť_tuku32, hľadať)< 0) return -1;

návrat 0;

Funkcia read_cluster() načíta klaster so zadaným číslom:

int read_cluster(__u32 cluster_num, __u8 *tmp_buff)

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

If(pred64(tvrdé, tmp_buff, byte_per_cluster, seek)< 0) return -1;

návrat 0;

Čítanie adresárov (vrátane koreňového) je obsluhované funkciou read_directory():

int read_directory(__u32 start_cluster)

int i = 2;

U32 ďalší_klaster;

Parametre funkcie sú štartovací katalógový klaster. Načítame obsah adresára do globálnej vyrovnávacej pamäte dir_entry:

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

Ďalší_klaster = tuk32;

Ak adresár zaberá jeden klaster, ukončite ho, ak nie, zväčšite veľkosť pamäte a pokračujte v čítaní:

Pre (; ;i++) (

start_cluster = dalsi_klaster;

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

If(!dir_entry) return -1;

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

Ďalší_klaster = tuk32;

If((ďalší_klaster == EOF_FAT32) || (ďalší_klaster == 0xFFFFFF8)) return 0;

návrat 0;

Posledná funkcia, na ktorú sa pozrieme, hľadá v obsahu adresára prvok, ktorý sa zhoduje s hľadaným súborom:

int get_dentry(struct split_name *sn)

Int i = 0;

Ukazovateľ dir_entry je nastavený na oblasť pamäte obsahujúcu pole adresárových položiek, v ktorých budeme hľadať súbor (alebo adresár). Na vyhľadávanie zorganizujeme slučku a nájdený záznam umiestnime do globálnej zubnej štruktúry:

Pre(;;i++) (

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

If(!(memcmp(dentry.name, sn->meno, sn->meno_len)) &&

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

prestávka;

If(!dentry.name) return -1;

návrat 0;

Týmto končíme našu úvahu o module na čítanie súboru z oblasti FAT32.

Zdrojový kód modulu sa nachádza v adresári FAT32, súbor fat32.c.

Rozdiely v organizácii ukladania záznamov o súboroch v adresároch pre súborové systémy FAT a EXT2

Niekoľko slov o rozdieloch v organizácii ukladania záznamov o súboroch v adresároch pre súborové systémy FAT a EXT2. Štruktúra súborového systému EXT2 bola pokrytá v .

Práve sme sa zoznámili s FAT - v ňom majú všetky prvky adresára pevnú hodnotu. Pri vytváraní súboru ovládač súborového systému hľadá prvú prázdnu pozíciu a vyplní ju informáciami o súbore. Ak sa dĺžka adresára nezmestí do jedného klastra, pridelí sa mu ďalší klaster atď.

Zvážte, ako sa veci majú v EXT2.

Predpokladajme, že máme oddiel so súborovým systémom EXT2, veľkosť bloku je 4096 bajtov. V tejto časti vytvoríme adresár. Veľkosť adresára sa bude rovnať veľkosti bloku - 4096 bajtov. V adresári operačný systém vytvorí hneď dva záznamy – záznam pre aktuálny adresár a záznam pre nadradený adresár. Aktuálna položka adresára bude mať 12 bajtov, zatiaľ čo položka nadradeného adresára bude mať dĺžku 4084 bajtov. V tomto adresári vytvoríme súbor. Potom budú v adresári tri položky – aktuálna položka v adresári má dĺžku 12 bajtov, položka nadradeného adresára už má dĺžku 12 bajtov a položka vytvoreného súboru má, uhádli ste, 4072 bajtov. Ak vytvorený súbor vymažeme, dĺžka položky nadradeného adresára sa opäť zvýši na 4084 bajtov.

Pri vytváraní súboru teda ovládač systému súborov EXT2 vyhľadá v adresári položku s maximálnou dĺžkou a rozdelí ju, čím pridelí priestor pre novú položku. Ak stále nie je dostatok miesta, adresáru sa pridelí ďalší blok a dĺžka adresára sa rovná 8192 bajtom.

A na záver - malá úprava článku "Architektúra súborového systému EXT2".

Táto úprava sa týka funkcie get_i_num() na určenie čísla inódu z názvu súboru. Stará verzia tejto funkcie vyzerala takto:

int get_i_num(char *meno)

int i = 0, rec_len = 0;

Štruktúra ext2_dir_entry_2dent;

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

If(!memcmp(dent.name, name, dent.name_len)) break;

Rec_len += dent.rec_len;

Return dent.inode;

Opravená verzia:

int get_i_num(char *meno)

* Parametre funkcie - názov súboru. Návratová hodnota je číslo inódu súboru.

int rec_len = 0;

Štruktúra ext2_dir_entry_2dent; // táto štruktúra popisuje formát položky koreňového adresára:

* Globálna vyrovnávacia pamäť obsahuje pole položiek adresára. Ak chcete určiť číslo inódu súboru, musíte nájsť

* v tomto poli je položka s názvom tohto súboru. Na tento účel organizujeme cyklus:

Pre(;;) (

/* Skopírujte položky adresára do štruktúry dent: */

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

* Dĺžka súboru nula znamená, že sme prešli všetky položky adresára

* a položky s názvom nášho súboru sa nenašli. Takže je čas vrátiť sa:

If(!dent.name_len) return -1;

/* Vyhľadávanie sa vykonáva porovnaním názvov súborov. Ak sa mená zhodujú, ukončite cyklus: */

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

/* Ak sa mená nezhodujú, prejdite na ďalšiu položku: */

Rec_len += dent.rec_len;

/* Ak je to úspešné, vráťte číslo inodu súboru: */

Return dent.inode;

Literatúra:

1. V. Kulakov. Programovanie na úrovni hardvéru: špeciálna referencia. 2. vyd. / - Petrohrad: Peter, 2003 - 848 s.
2. A.V.Gordeev, A.Yu.Molchanov. Systémový softvér / - Petrohrad: Peter - 2002
3. Meshkov V. Architektúra súborového systému ext2. - Časopis "Správca systému", číslo 11 (12), november 2003 - 26-32 s.

V kontakte s

V systéme FAT sú názvy súborov vo formáte 8.3 a pozostávajú iba zo znakov ASCII. Do VFAT bola pridaná podpora pre dlhé (až 255 znakov) názvy súborov. Dlhý názov súboru, LFN) kódované v UTF-16LE, pričom LFN sú uložené v rovnakom čase ako mená 8.3, spätne označované ako SFN. Krátky názov súboru). V LFN sa pri vyhľadávaní nerozlišujú veľké a malé písmená, avšak na rozdiel od SFN, ktoré sú uložené veľkými písmenami, si LFN zachovávajú veľkosť písmen zadanú pri vytváraní súboru.

Štruktúra systému FAT

V systéme súborov FAT sú súvislé sektory disku spojené do jednotiek nazývaných klastre. Počet sektorov v klastri sa rovná mocnine dvoch (pozri nižšie). Na ukladanie údajov o súboroch je pridelený celočíselný počet klastrov (aspoň jeden), takže ak je veľkosť súboru 40 bajtov a veľkosť klastra 4 kbajty, v skutočnosti bude obsadené iba 1 % priestoru, ktorý je preň pridelený. podľa informácií o súbore. Aby ste predišli takýmto situáciám, je vhodné zmenšiť veľkosť klastrov a naopak, aby ste znížili množstvo informácií o adrese a zvýšili rýchlosť operácií so súbormi. V praxi sa volí určitý kompromis. Keďže kapacita disku nemusí byť vyjadrená v celočíselnom počte klastrov, na konci zväzku sú zvyčajne takzvané „jednotky“. prebytočné sektory – „zvyšok“ s veľkosťou menšou ako klaster, ktorý OS nemôže prideliť na ukladanie informácií.

Objemový priestor FAT32 je logicky rozdelený do troch súvislých oblastí:

• vyhradenej oblasti. Obsahuje servisné štruktúry, ktoré patria k bootovaciemu záznamu oddielu (Partition Boot Record - PBR, na odlíšenie od Master Boot Record - hlavného spúšťacieho záznamu disku; tiež PBR sa často nesprávne nazýva boot sektor) a používajú sa pri inicializácii zväzku. ;
• Oblasť tabuľky FAT obsahujúca pole indexových ukazovateľov ("buniek") zodpovedajúcich klastrom oblasti údajov. Z dôvodu spoľahlivosti sú na disku zvyčajne dve kópie tabuľky FAT;
• Dátová oblasť, kde sa zaznamenáva skutočný obsah súborov – teda text textových súborov, kódovaný obrázok pri obrazových súboroch, digitalizovaný zvuk pri zvukových súboroch atď. – ako aj tzv. metadáta - informácie o názvoch súborov a priečinkov, ich atribútoch, časoch vytvorenia a úprav, veľkosti a umiestnení na disku.

FAT12 a FAT16 majú tiež vyhradenú oblasť pre koreňový adresár. Má pevnú pozíciu (hneď po poslednom zázname v tabuľke FAT) a pevnú veľkosť v sektoroch.

Ak klaster patrí do súboru, potom jemu zodpovedajúca bunka obsahuje číslo nasledujúceho klastra toho istého súboru. Ak bunka zodpovedá poslednému zhluku súboru, potom obsahuje špeciálnu hodnotu (FFFF 16 pre FAT16). Takto sa vytvorí reťazec klastrov súborov. Nuly zodpovedajú nepoužitým klastrom v tabuľke. "Zlé" klastre (ktoré sú vylúčené zo spracovania, napríklad preto, že zodpovedajúca oblasť zariadenia je nečitateľná) majú tiež špeciálny kód.

Po odstránení súboru sa prvý znak názvu nahradí špeciálnym kódom E5 16 a reťazec klastrov súborov v alokačnej tabuľke sa vynuluje. Keďže informácia o veľkosti súboru (ktorá sa nachádza v adresári vedľa názvu súboru) zostáva nedotknutá, ak sa zhluky súborov nachádzali na disku postupne a neboli prepísané novými informáciami, je možné vymazaný súbor obnoviť .

zavádzací záznam

Prvá štruktúra zväzku FAT sa nazýva BPB. Blok parametrov systému BIOS ) a nachádza sa vo vyhradenej oblasti, v sektore nula. Táto štruktúra obsahuje informácie identifikujúce typ súborového systému a fyzické vlastnosti média (disketa alebo oblasť pevného disku).

Blok parametrov systému BIOS

BPB v zásade chýbal vo FAT, ktorý slúžil MS-DOS 1.x, keďže v tom čase sa predpokladali len dva rôzne typy zväzku - jedno- a obojstranné päťpalcové 360 kb diskety a formát zväzku bol určený prvým bytom oblasti FAT. BPB bol predstavený v MS-DOS 2.x začiatkom roku 1983 ako povinná štruktúra zavádzacieho sektora, z ktorej sa odteraz určoval formát zväzku; stará schéma detekcie prvého bajtu FAT už nie je podporovaná. Aj v MS-DOS 2.0 bola zavedená hierarchia súborov a priečinkov (predtým boli všetky súbory uložené v koreňovom adresári).

Štruktúra BPB v MS-DOS 2.x obsahovala 16-bitové pole „celkový počet sektorov“, čo znamenalo, že táto verzia FAT bola zásadne nepoužiteľná pre objemy väčšie ako 2 16 = 65 536 sektorov, teda viac ako 32 MB so štandardnou veľkosťou sektora 512 bajtov. V MS-DOS 4.0 (1988) bolo vyššie uvedené pole BPB rozšírené na 32 bitov, čo znamenalo zvýšenie teoretickej veľkosti objemu na 232 = 4 294 967 296 sektorov, teda až 2 TB s 512-bajtovým sektorom.

Ďalšia modifikácia BPB sa objavila s Windows 95 OSR2, ktorý zaviedol FAT32 (v auguste 1996). Dvojgigabajtový limit veľkosti zväzku bol odstránený, zväzok FAT32 môže mať teoreticky veľkosť až 8 TB. Veľkosť každého jednotlivého súboru však nemôže presiahnuť 4 GB. Blok parametrov BIOS FAT32 opakuje BPB FAT16 až po pole BPB_TotSec32 vrátane kvôli kompatibilite so staršími verziami FAT, po ktorých nasledujú rozdiely.

"Boot sektor" FAT32 sú vlastne tri 512-bajtové sektory - sektory 0, 1 a 2. Každý z nich obsahuje podpis 0xAA55 na adrese 0x1FE, teda v posledných dvoch bajtoch, ak je veľkosť sektora 512 bajtov. Ak je veľkosť sektora väčšia ako 512 bajtov, podpis je obsiahnutý na adrese 0x1FE aj v posledných dvoch bajtoch nulového sektora, to znamená, že je duplikovaný.

FSInfo

Zavádzací záznam oddielu FAT32 obsahuje štruktúru tzv FSInfo, slúži na uloženie hodnoty počtu voľných klastrov na zväzku. FSInfo spravidla zaberá sektor 1 (pozri pole BPB_FSInfo) a má nasledujúcu štruktúru (adresy vzhľadom na začiatok sektora):

• FSI_LeadSig. 4-bajtový podpis 0x41615252 označuje, že sektor sa používa pre štruktúru FSInfo.
• FSI_Reserved1. Interval od 4. do 483. bajtu sektora vrátane sa vynuluje.
• FSI_StrucSig. Ďalší podpis sa nachádza na 0x1E4 a obsahuje hodnotu 0x61417272.
• FSI_Free_Count. Štvorbajtové pole na adrese 0x1E8 obsahuje posledný počet voľných klastrov na zväzku, ktorý je systému známy. Hodnota 0xFFFFFFFF znamená, že počet voľných klastrov je neznámy a musí sa vypočítať.
• FSI_Nxt_Free. Štvorbajtové pole na adrese 0x1EC obsahuje číslo klastra, od ktorého by malo začať vyhľadávanie voľných klastrov v tabuľke ukazovateľov indexu. Toto pole zvyčajne obsahuje číslo posledného klastra FAT priradeného na uloženie súboru. Hodnota 0xFFFFFFFF znamená, že hľadanie voľného klastra by sa malo vykonávať od samého začiatku tabuľky FAT, teda od druhého klastra.
• FSI_Reserved2. Vyhradené 12-bajtové pole na adrese 0x1F0.
• FSI_TrailSig. Podpis 0xAA550000 - posledné 4 bajty sektora FSInfo.

Cieľom zavedenia FSInfo je optimalizovať výkon systému, pretože v systéme FAT32 môže byť tabuľka ukazovateľa indexu veľká a jej vyhľadávanie po byte môže trvať značné množstvo času. Hodnoty polí FSI_Free_Count a FSI_Nxt_Free však nemusia zodpovedať skutočnosti a mali by sa skontrolovať, či sú adekvátne. Navyše sa neaktualizujú ani v zálohe FSInfo, ktorá sa zvyčajne nachádza v sektore 7.

Určenie typu objemu FAT

Určenie typu objemu FAT (to znamená výber medzi FAT12, FAT16 a FAT32) vykonáva operačný systém na základe počtu klastrov v objeme, ktorý sa zase určuje z polí BPB. Najprv sa vypočíta počet sektorov koreňového adresára:

RootDirSectors = (BPB_RootEntCnt * 32) / BPB_BytsPerSec

DataSec = TotSec - (BPB_ResvdSecCnt + (BPB_NumFAT * FATSz) + RootDirSectors)

Nakoniec sa určí počet klastrov dátových oblastí:

CountofClusters = DataSec / BPB_SecPerClus

Podľa počtu klastrov existuje vzájomná korešpondencia so systémom súborov:

• CountofClusters< 4085 - FAT12
• CountofClusters = 4085 ÷ 65524 - FAT16
• Počet klastrov > 65524 - FAT32

Podľa oficiálnej špecifikácie je to jediný platný spôsob určenia typu FAT. Umelé vytvorenie zväzku, ktorý porušuje špecifikované pravidlá mapovania, spôsobí, že ho systém Windows spracuje nesprávne. Odporúča sa však vyhnúť sa hodnotám CountofClusters, ktoré sú blízko kritickým hodnotám (4085 a 65525), aby bolo možné správne určiť typ súborového systému pomocou akýchkoľvek, často nesprávne napísaných ovládačov.

Postupom času sa FAT stal široko používaným v rôznych zariadeniach kvôli kompatibilite medzi DOS, Windows, OS / 2, Linux. Microsoft nepreukázal žiadny úmysel nútiť ich, aby boli licencované [ špecifikovať] .

Vo februári 2009 Microsoft zažaloval TomTom, výrobcu navigačných systémov do auta založených na Linuxe, za porušenie patentu.

Poznámky

1. http://cd.textfiles.com/megademo2/INFO/OS2_HPFS.TXT
2. www.microsoft.com/mscorp/ip/tech/fathist.asp na archive.org
3. Špecifikácia systému súborov FAT32 spoločnosti Microsoft Extensible Firmware Initiative 1.03. Microsoft (6. decembra 2000). - Dokument vo formáte Microsoft Word, 268 Kb. Archivované
4. A čo VFAT? . Archív TechNet. Microsoft (15. októbra 1999). Archivované z originálu 22. augusta 2011. Získané 5. apríla 2010.
5. Nezamieňajte príponu systému súborov VFAT s ovládačom systému súborov s rovnakým názvom, ktorý sa objavil v systéme Windows for Workgroups 3.11 a je určený na spracovanie volaní funkcií systému MS-DOS (INT 21h) v chránenom režime (pozri: KB126746: História verzií systému Windows for Workgroups . VERZIA 3.11 → Nesieťové funkcie. Microsoft (14. november 2003). Archivované z originálu 22. augusta 2011. Získané 5. apríla 2010.)
6. Federálny patentový súd vyhlasuje FAT patent spoločnosti Microsoft za neplatný. heise online. Heise Zeitschriften Verlag (2. marca 2007). Archivované
7. Brian Kahin. Microsoft hýbe svetom vďaka patentom FAT. The Huffington Post (10. marec 2009). Archivované z originálu 22. augusta 2011. Získané 10. marca 2009.
8. Ryan Paul.Žaloba Microsoftu na patenty FAT by mohla otvoriť OSS Pandora's Box (anglicky). Ars Technica. Publikácie Condé Nast (25. februára 2009). archivované
9. Glyn Moody.(Angličtina) . Computerworld UK. IDG (5. marca 2009). Archivované z originálu 22. augusta 2011. Získané 9. marca 2009.
10. Steven J. Vaughan-Nichols. Linuxové spoločnosti podpisujú pakty Microsoft o ochrane patentov. Blogy. IDG (5. marca 2009). Archivované z originálu 22. augusta 2011. Získané 9. marca 2009.
11. Erika Oggová. TomTom žaluje Microsoft v patentovom spore. CNet (19. marca 2009). Archivované z originálu 22. augusta 2011. Získané 20. marca 2009.

Odkazy

• ECMA-107 FAT štandard

Súborový systém poskytuje spôsob, ako usporiadať disk. Definuje, ako sa údaje ukladajú na disk a aké typy informácií môžu byť pripojené k súborom – názvy súborov, oprávnenia a ďalšie atribúty.

Windows podporuje tri rôzne súborové systémy. NTFS- najmodernejší súborový systém. Systém Windows používa systém NTFS pre svoju systémovú jednotku a štandardne pre väčšinu pevných jednotiek. FAT32 je starší súborový systém, ktorý nie je taký efektívny ako NTFS a nepodporuje veľkú sadu funkcií, ale poskytuje väčšiu kompatibilitu s inými operačnými systémami. exFAT je modernou náhradou FAT32 a podporuje viac zariadení a operačných systémov ako NTFS – nie je však taký rozšírený ako FAT32.

Systém súborov NT (NTFS)

NTFS je moderný súborový systém, ktorú systém Windows uprednostňuje štandardne používať. Počas inštalácie systém Windows naformátuje systémovú jednotku na formát systému súborov NTFS. NTFS má také obrovské limity veľkosti súboru a oddielu, že je nepravdepodobné, že by ste sa s nimi niekedy stretli. NTFS sa prvýkrát objavil v spotrebiteľskej verzii Windows XP, hoci pôvodne debutoval vo Windows NT.

NTFS je nabitý modernými funkciami, ktoré nie sú dostupné pre FAT32 a exFAT. NTFS podporuje oprávnenia súborov na zabezpečenie, protokol zmien, ktorý vám môže pomôcť rýchlo sa zotaviť z chýb v prípade zlyhania počítača, tieňové kópie pre zálohy, šifrovanie, limity diskových kvót, pevné odkazy a rôzne ďalšie funkcie. Mnohé z nich sú kritické pre jednotku operačného systému, najmä povolenia súborov.

Systémový oddiel Windows musí byť vo formáte NTFS. Ak máte ďalší disk so systémom Windows a plánujete naň inštalovať programy, najlepšie je naformátovať ho na systém NTFS. A ak máte nejaké disky, pre ktoré nie je problém s kompatibilitou – pretože viete, že ich budete používať v systémoch Windows – môžete si vybrať NTFS.

Napriek svojim výhodám, NTFS nemá kompatibilitu. Bude fungovať so všetkými najnovšími verziami systému Windows – až po Windows XP vrátane – má však obmedzenú kompatibilitu s inými operačnými systémami. V predvolenom nastavení môže Mac OS X čítať iba disky NTFS, nie zapisovať údaje. Niektoré distribúcie Linuxu môžu obsahovať podporu zápisu NTFS, ale iné môžu byť len na čítanie. Žiadna z konzol Sony PlayStation nepodporuje NTFS. Dokonca aj konzola Xbox 360 od Microsoftu nedokáže čítať jednotky NTFS, s výnimkou Xbox One. Ostatné zariadenia podporujú NTFS ešte menej.

Kompatibilita: Funguje so všetkými verziami Windowsu, ale na Macu je len na čítanie a v niektorých distribúciách Linuxu môže byť len na čítanie. Ostatné zariadenia, s výnimkou Microsoft Xbox One, pravdepodobne nebudú podporovať NTFS.

Obmedzenia: Nereálny limit veľkosti súboru a veľkosti oddielu.

Ideálne využitie: Toto použite pre systémový disk Windows a ďalšie interné disky, ktoré sa budú používať iba so systémom Windows.

Tabuľka prideľovania súborov 32 (FAT32)

FAT32 je najstarší z troch súborových systémov dostupných v systéme Windows. Bol predstavený vo Windows 95 a nahradil starý súborový systém FAT16 používaný v MS-DOS a Windows 3.

Vek súborového systému FAT32 má svoje výhody aj nevýhody. Veľkou výhodou je, že FAT32 je de facto štandard. Zabalené flash disky sú často naformátované ako FAT32 pre maximálnu kompatibilitu nielen s modernými počítačmi, ale aj s inými zariadeniami, ako sú herné konzoly a čokoľvek s USB portom.

Jeho obmedzenia sú však spojené aj s vekom. Jednotlivé súbory na jednotke FAT32 nemôžu byť väčšie ako 4 GB – toto je maximum. Oddiel FAT32 musí byť tiež menší ako 8 TB. Toto sú hranice, ku ktorým sa moderné používateľské zariadenia priblížili.

FAT32 je vhodný pre USB flash disky a iné externé médiá – najmä ak viete, že ich budete používať na inom počítači bez systému Windows. Tento súborový systém nemá oprávnenia a ďalšie bezpečnostné funkcie zabudované do modernejšieho systému súborov NTFS. Moderné verzie systému Windows už nie je možné nainštalovať na jednotku naformátovanú systémom FAT32; musia byť nainštalované na jednotky naformátované systémom NTFS.

Kompatibilita Odpoveď: Funguje so všetkými verziami Windows, Mac a Linux, hernými konzolami a prakticky akýmkoľvek zariadením s portom USB.

Obmedzenia: Maximálna veľkosť súboru 4 GB, maximálna veľkosť oddielu 8 TB.

Ideálne využitie: Používajte na vymeniteľných jednotkách, kde potrebujete maximálnu kompatibilitu so širokou škálou zariadení, pokiaľ nepoužívate súbory s veľkosťou 4 GB alebo viac.

Rozšírená tabuľka prideľovania súborov (exFAT)

súborový systém exFAT bol predstavený v roku 2006 a bol pridaný do starších verzií systému Windows s aktualizáciami pre systémy Windows XP a Windows Vista. exFAT je súborový systém optimalizovaný pre flash- Navrhnuté na zachovanie kompatibility FAT32, ale bez dodatočných funkcií NTFS a bez obmedzení FAT32.

Rovnako ako NTFS, exFAT má veľmi veľké limity veľkosti súborov a oddielov, čo umožňuje ukladať súbory oveľa väčšie ako 4 GB povolené vo FAT32.

Aj keď exFAT presne nezodpovedá kompatibilite FAT32, je kompatibilnejší ako NTFS. Dokonca aj Mac OS ponúka plnú podporu exFAT čítania/zápisu. Jednotky exFAT sú dostupné v systéme Linux po inštalácii príslušného softvéru. S inými zariadeniami je to trochu komplikovanejšie: PlayStation 4 podporuje exFAT; PlayStation 3 nepodporuje; Xbox One áno, ale Xbox 360 nie.

Kompatibilita: Funguje so všetkými verziami systému Windows a modernými verziami systému Mac X, ale v systéme Linux vyžaduje ďalší softvér. Viac zariadení podporuje exFAT, ale niektoré - najmä staršie - fungujú iba s FAT32.

Obmedzenia: Nereálne limity veľkosti súborov a oddielov.

Ideálne využitie: použite ho, keď potrebujete ukladať veľké súbory a keď potrebujete širokú kompatibilitu. Za predpokladu, že každé zariadenie, ktoré chcete použiť, podporuje exFAT, mali by ste svoje zariadenie naformátovať pomocou exFAT namiesto FAT32.

NTFS je ideálny pre interné disky, zatiaľ čo exFAT je zvyčajne ideálny pre flash disky. Niekedy však môže byť potrebné naformátovať externý disk na FAT32, ak exFAT nie je podporovaný na zariadení, s ktorým ho chcete použiť.

Okrem všetkých ostatných úloh plní svoj hlavný účel – organizuje prácu s dátami podľa určitej štruktúry. Na tieto účely sa používa súborový systém. Čo je FS a čo to môže byť, ako aj ďalšie informácie o ňom budú uvedené nižšie.

všeobecný popis

Súborový systém je časť operačného systému, ktorá je zodpovedná za umiestňovanie, ukladanie, odstraňovanie informácií na médiu, poskytovanie týchto informácií používateľom a aplikáciám a zabezpečenie ich bezpečného používania. Navyše práve ona pomáha pri obnove dát v prípade zlyhania hardvéru alebo softvéru. Preto je systém súborov taký dôležitý. Čo je FS a čo to môže byť? Existuje niekoľko typov:

Pre pevné disky, teda zariadenia s náhodným prístupom;

Pre magnetické pásky, teda zariadenia so sériovým prístupom;

Pre optické médiá;

Virtuálne systémy;

Sieťové systémy.5

Logickou jednotkou ukladania údajov v systéme súborov je súbor, teda usporiadaná kolekcia údajov, ktorá má špecifický názov. Všetky údaje používané operačným systémom sú prezentované vo forme súborov: programy, obrázky, texty, hudba, videá, ako aj ovládače, knižnice atď. Každý takýto prvok má názov, typ, rozšírenie, atribúty a veľkosť. Takže, teraz už viete, systém súborov je zbierka takýchto prvkov, ako aj spôsobov, ako s nimi pracovať. V závislosti od formy, v akej sa používa a aké princípy sa na ňu vzťahujú, možno rozlíšiť niekoľko hlavných typov FS.

Programový prístup

Ak sa teda uvažuje o súborovom systéme (čo to je a ako s ním pracovať), potom treba poznamenať, že ide o viacúrovňovú štruktúru, na jej najvyššej úrovni je prepínač súborového systému, ktorý poskytuje rozhranie medzi systém a konkrétnu aplikáciu. Prevádza požiadavky na súbory do formátu, ktorý akceptuje ďalšia úroveň – ovládače. Na druhej strane odkazujú na konkrétne ovládače zariadení, v ktorých sú uložené potrebné informácie.

Pre aplikácie klient-server sú požiadavky na výkon súborového systému dosť vysoké. Moderné systémy sú navrhnuté tak, aby poskytovali efektívny prístup, podporu pre veľké objemy médií, ochranu údajov pred neoprávneným prístupom a udržiavanie integrity informácií.

súborový systém FAT

Tento typ vyvinuli už v roku 1977 Bill Gates a Mark McDonald. Pôvodne sa používal v OS 86-DOS. Ak hovoríme o tom, čo je súborový systém FAT, potom stojí za zmienku, že spočiatku nebol schopný podporovať pevné disky, ale pracoval iba s flexibilnými médiami do 1 megabajtu. Teraz toto obmedzenie už nie je relevantné a tento FS použil Microsoft pre MS-DOS 1.0 a nasledujúce verzie. FAT používa určité konvencie pre pomenovanie súborov:

Názov musí začínať písmenom alebo číslom a okrem medzier a špeciálnych prvkov môže obsahovať ľubovoľný znak ASCII;

Dĺžka názvu by nemala byť väčšia ako 8 znakov, za ním sa umiestni bodka a potom sa uvedie prípona, ktorá pozostáva z troch písmen;

Názvy súborov môžu používať akékoľvek malé a veľké písmená a nerozlišujú sa ani sa nezachovávajú.

Keďže FAT bol pôvodne navrhnutý pre jednoužívateľský operačný systém DOS, neumožňoval ukladať údaje o vlastníkovi ani prístupové práva. V súčasnosti je tento súborový systém najrozšírenejší, väčšina ho v tej či onej miere podporuje a jeho všestrannosť umožňuje jeho použitie na zväzkoch, s ktorými pracujú rôzne operačné systémy. Ide o jednoduchý FS, ktorý nie je schopný zabrániť poškodeniu súborov v dôsledku nesprávneho vypnutia počítača. V rámci operačných systémov, ktoré sú na ňom založené, existujú špeciálne nástroje, ktoré kontrolujú štruktúru a opravujú nezrovnalosti súborov.

súborový systém NTFS

Tento FS je najviac preferovaný pre prácu s Windows NT, pretože bol vyvinutý špeciálne preň. OS obsahuje pomôcku na konverziu, ktorá konvertuje zväzky s FAT a HPFS na zväzky NTFS. Ak hovoríme o tom, čo je súborový systém NTFS, stojí za zmienku, že výrazne rozšíril možnosť kontroly prístupu k určitým adresárom a súborom, zaviedol množstvo atribútov, implementoval nástroje dynamickej kompresie súborov, odolnosť proti chybám a podporuje požiadavky štandard POSIX. V tomto FS môžete použiť mená dlhé až 255 znakov, pričom krátky názov sa v ňom generuje rovnako ako vo VFAT. Pochopenie toho, čo je súborový systém NTFS, stojí za zmienku, že v prípade zlyhania operačného systému je schopný sa sám obnoviť, takže objem disku zostane k dispozícii a adresárová štruktúra neutrpí.

Vlastnosti NTFS

Na zväzku NTFS je každý súbor reprezentovaný záznamom v tabuľke MFT. Prvých 16 záznamov tabuľky je rezervovaných samotným súborovým systémom na ukladanie špeciálnych informácií. Hneď prvý záznam popisuje samotnú tabuľku súborov. Keď je prvý záznam zničený, prečíta sa druhý, aby sa našiel zrkadlový súbor MFT, kde je prvý záznam identický s hlavnou tabuľkou. Logický stred disku obsahuje kópiu bootstrap súboru. Tretia položka v tabuľke obsahuje protokolový súbor, ktorý sa používa na obnovu dát. Sedemnásta a nasledujúce položky tabuľky súborov obsahujú informácie o súboroch a adresároch, ktoré sú na pevnom disku.

Protokol transakcií obsahuje kompletný súbor operácií, ktoré menia štruktúru zväzku, vrátane operácií na vytváranie súborov, ako aj všetkých príkazov, ktoré ovplyvňujú štruktúru adresárov. Denník transakcií je určený na obnovenie systému NTFS po zlyhaní systému. Záznam pre koreňový adresár obsahuje zoznam adresárov a súborov, ktoré sú v koreňovom adresári.

Funkcie EFS

Encrypting File System (EFS) je funkcia systému Windows, ktorá dokáže ukladať informácie na pevný disk v zašifrovanom formáte. Šifrovanie sa stalo najsilnejšou ochranou, akú môže tento operačný systém ponúknuť. V tomto prípade je šifrovanie pre používateľa pomerne jednoduchá akcia, preto stačí začiarknuť políčko vo vlastnostiach priečinka alebo súboru. Môžete určiť, kto môže čítať takéto súbory. Súbory sú po zatvorení šifrované a po otvorení sú automaticky pripravené na použitie.

Vlastnosti RAW

Zariadenia určené na ukladanie dát sú najzraniteľnejšie komponenty, ktoré najčastejšie podliehajú poškodeniu nielen fyzicky, ale aj logicky. Niektoré hardvérové ​​problémy môžu byť fatálne, zatiaľ čo iné majú riešenia. Niekedy majú používatelia otázku: "Čo je to súborový systém RAW?"

Ako viete, na zapisovanie akýchkoľvek informácií na pevný disk alebo flash disk musí mať disk súborový systém. Najbežnejšie sú FAT a NTFS. A RAW nie je ani súborový systém, o ktorom zvyčajne uvažujeme. V skutočnosti ide o logickú chybu už nainštalovaného systému, teda o jeho skutočnú absenciu pre Windows. Najčastejšie je RAW spojený s deštrukciou štruktúry súborového systému. Potom OS nielen pristupuje k údajom, ale nezobrazuje ani technické informácie o zariadení.

Vlastnosti UDF

Universal Disk Format (UDF) je navrhnutý tak, aby nahradil CDFS a pridal podporu pre DVD-ROM zariadenia. Ak hovoríme o tom, čo to je, potom je to nová implementácia starej verzie, pre ktorú spĺňa požiadavky. Vyznačuje sa určitými vlastnosťami:

Názvy súborov môžu mať dĺžku až 255 znakov;

Meno môže byť malé alebo veľké;

Maximálna dĺžka cesty je 1023 znakov.

Počnúc systémom Windows XP je tento súborový systém určený na čítanie/zápis.

Tento FS sa používa pre flash disky, ktoré sa majú používať pri práci s rôznymi počítačmi s rôznymi operačnými systémami, najmä Windows a Linux. Bol to EXFAT, ktorý sa stal „mostom“ medzi nimi, pretože je schopný pracovať s údajmi prijatými z OS, z ktorých každý má svoj vlastný súborový systém. Čo to je a ako to funguje, bude jasné v praxi.

závery

Ako je zrejmé z vyššie uvedeného, ​​každý operačný systém používa určité súborové systémy. Sú určené na ukladanie usporiadaných dátových štruktúr na fyzické médiá. Ak zrazu pri používaní počítača máte otázku, aký je konečný systém súborov, je celkom možné, že keď ste sa pokúsili skopírovať určitý súbor na médium, dostali ste správu o prekročení povolenej veľkosti. Preto je potrebné vedieť, v ktorom súborovom systéme sa aká veľkosť súboru považuje za prijateľnú, aby ste pri prenose informácií nenarazili na problémy.