Este necesar sistemul de fișiere NTFS. Sisteme de fișiere FAT, FAT16, FAT32

1. Structura sectorului FSInfo struct fat_boot_fsinfo:
   • __u32 semnătură1- semnătura 0x41615252;
   • __u32 semnătură2- semnatura 0x61417272;
   • __u32 clustere_gratuite- Numărul de clustere libere. Dacă câmpul este setat la -1, căutați mai multe clustere după ce începeți de la clusterul numărul 2.
2. Structura elementului director de nume scurt struct msdos_dir_entry:
   • __s8 nume,ext- Am extins fișierul;
   • __u8 attr- Atributul fișierului;
   • __u8 ctime_ms– acest câmp specifică ora la care a fost creat fișierul în ms (Vikorist doar FAT32);
   • __u16 ctime- timpul de creare a fișierului (doar FAT32);
   • __u16 data– data creării fișierului (doar FAT32);
   • __u16 data– data rămasă de acces la fișier (doar FAT32);
   • __u16 starthi- Numere mai mari de 16 biți ale primului cluster din fișier (sunt revizuite doar cele FAT32);
   • __u16 ora, data, începerea– ora și data creării fișierului, numărul primului fișier din cluster;
   • dimensiune __u32- Dimensiunea fișierului (în octeți).
3. Structura elementului director cu nume lung:
   • __u8 id- Numărul de articol;
   • __u8 nume0_4– simboluri 1 – 5 nume;
   • __u8 attr- Atributul fișierului;
   • __u8 alias_checksum- Suma de control al numelui scurt;
   • __u8 nume5_10- Simboluri 6 - 11 nume;
   • __u8 nume11_12– simboluri 12 – 13 nume.

Să continuăm cu o privire asupra implementării software a algoritmului și ceea ce este important este partiția pe care este creat sistemul de fișiere FAT16:

#ifndef FAT16_PART_NAME

#define FAT16_PART_NAME „/dev/hda1”

#endif

Structuri globale:

struct fat_boot_sector fbs; // structura sectorului de avangardă

struct msdos_dir_entry dentry; // Structura elementului director

Schimbări globale:

U16*gras16; // copiați tabelul FAT16 aici

Mărimea_sectorului U16; // Dimensiunea sectorului (cu FAT16)

U16 dir_entries; // Numărul de descriptori de 32 de octeți

// la catalizatorul de rădăcină (0 pentru FAT32)

sectoare U16; // număr limitat de sectoare într-o secțiune

U32 fat16_size; // dimensiunea FAT16

U32 dimensiunea_rădăcină; // Dimensiunea directorului rădăcină

U16 byte_per_cluster; // Dimensiunea clusterului în octeți

U16 următorul_cluster; // cluster chergovy la lantsyuzhku

int grăsime;

Să aruncăm o privire mai atentă la funcția cap:

int main()

Int num;

Specificați un nume de fișier în loc de ceea ce doriți să citiți. Voi ghici ce facem cu nume scurte de fișiere. Ordinea de lucru cu numele lungi a acestui articol nu este clară.

U8 *full_path = "/Folder1/Folder2/text.txt";

Să deschidem fișierul atașat:

Hard = Deschis(FAT16_PART_NAME, O_RDONLY);

Dacă (greu< 0) {

Eroare (FAT16_PART_NAME);

Ieșire (-1);

Sunt citite primele 10 clustere din fișier. Funcția fat16_read_file() este folosită pentru a citi pictograma. Parametrii funcției sunt în afara numelui fișierului și a numărului de clustere pentru citire. Funcția rotește numărul de grupuri de citire sau -1, dacă timpul de citire a devenit mai mic:

Num = fat16_read_file(full_path, 10);

Dacă (num< 0) perror("fat16_read_file");

Else printf("Citiți %d clustere", num);

Voi închide fișierul și îl voi atașa:

Închide (greu);

Returnează 0;

Funcția de citire a clusterelor dintr-un fișier arată astfel:

int fat16_read_file(__u8 *full_path, int num)

Struct split_name sn; // structură pentru stocarea părților de stocare ale fișierului

U8 tmp_name_buff; // tampon pentru salvarea din timp la oră a elementelor depozitului pentru totdeauna în fișier

Static int i = 1;

Int n;

U8 * tmp_buff;

U16 start_cluster, următorul_cluster;

Parametrii funcției au fost modificați atunci când ne uităm la funcția principală.

Operație pregătitoare – bufferul tmp_name_buff și structura struct split_name sn sunt resetate:

Primul caracter din calea absolută a unui fișier este o bară oblică (/). Să verificăm asta:

Sectorul avantajos este luat în considerare în această secțiune:

Dacă(citește_fbs()< 0) return -1;

Sectorul important este acum situat în structura globală struct fat_boot_sector fbs. Copiem din această structură dimensiunea sectorului, numărul de înregistrări din directorul rădăcină și numărul de sectoare pe partiție:

Mărimea clusterului în octeți este semnificativă:

Byte_per_cluster = fbs.cluster_size * 512

Iată informațiile disponibile sectorului de bijuterii:

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

Printf("Dimensiunea sectorului - %d", dimensiune_sector);

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

Printf("Rezervat - %d", fbs.rezervat);

Printf("Numărul FATs - %d ",fbs.fats);

Printf("Dir intrări - %d", dir_entries);

Printf("Sectoare - %d", sectoare);

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

Printf("lungime FAT16 - %u", fbs.lungime_grasă);

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

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

Calculăm dimensiunea FAT16 în octeți și o citim:

Fat16_size = fbs.fat_length * 512;

Dacă(read_fat16()< 0) return -1;

Citiți directorul rădăcină:

Dacă(citește_rădăcină_dentry()< 0) return -1;

Indicatorul dir_entry este o zonă de memorie pozițională care va plasa intrări în directorul rădăcină. Dimensiunea acestei zone de memorie este egală cu dimensiunea directorului rădăcină (root_size).

Salvați (pentru control) în loc de directorul rădăcină din fișierul însoțitor:

#ifdef DEBUG

Închide (gras);

#endif

Să calculăm începutul zonei de date:

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

Dacă toate intrările sunt în directorul rădăcină, le putem localiza în fișierul test.txt. Cu această metodă organizăm un ciclu. În acest ciclu, vom analiza numele fișierului, văzând elementele acestuia - subdirectoare (avem două dintre ele, Folder1 și Folder2) și numele fișierului (test.txt).

În timp ce(1) (

Memset(tmp_name_buff, 0, SHORT_NAME);

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

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

Dacă((tmp_name_buff[n] == "/") || (tmp_name_buff[n] == "?")) (

I++;

Pauză;

Tmp_name_buff[n] = "?";

Umplem structura struct split_name sn cu informații suplimentare. Funcția split_name a fost actualizată, care verifică dacă numele fișierului respectă formatul „8.3”:

< 0) {

Printf("nume nevalid");

Retur-1;

Pentru elementul skin, numele comun al fișierului este cluster cob. În acest scop, căutăm în elementele directorului (începând de la rădăcină) o intrare care să corespundă numelui real al elementului și citim această intrare. Procedura de căutare este finalizată de funcția get_dentry():

If(get_dentry(&sn)< 0) {

Printf("Nu există un astfel de fișier!");

Retur-1;

Verificăm atributele fișierului. Deoarece acesta este un director, îl citim în schimb și continuăm ciclul:

Dacă(dentry.attr & 0x10) (

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

Continua;

Ca fișier, sunt citite primele clustere num. Pentru a controla informațiile tratate, acestea sunt salvate într-un fișier separat:

Dacă(dentry.attr & 0x20) (

Start_cluster = dentry.start;

Tmp_buff = (__u8 *) malloc (byte_per_cluster); // citiți aici în loc de cluster

N = open("clust", O_CREAT | O_RDWR, 0600); // Informațiile acestui fișier sunt dezinfectate cu atenție

Dacă (n< 0) {

Eroare ("deschis");

Retur-1;

Pentru a citi clustere într-un fișier, organizăm un ciclu:

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

În loc să citiți clusterul în buffer-ul tmp_buff și să îl salvați într-un fișier separat:

< 0) return -1;

< 0) {

Eroare ("scrie");

Închidere(n);

Retur-1;

Numărul cluster-ului de atac ocupat de acest fișier este citit din FAT16. Ca rezultat al clusterului rămas, repetăm ​​ciclul și ne întoarcem la funcția principală:

#ifdef DEBUG

Printf("OK. Citit");

Printf("următorul cluster al fișierului - 0x%X..", următorul_cluster);

#endif

Dacă(clusterul următor == EOF_FAT16) (

#ifdef DEBUG

Printf(„ultimul cluster.”);

#endif

Gratuit(tmp_buff);

Închidere(n);

Returnează ++i;

#ifdef DEBUG

Printf("opriți citirea");

#endif

Întoarce i;

Citirea sectorului FAT16 este modificată de funcția read_fbs(). Rezultatul este situat în structura globală fbs:

int read_fbs()

Dacă(citește (tare,(__u8 *)&fbs, dimensiunea(fbs))< 0) return -1;

Returnează 0;

Pentru a citi tabelul de alocare a fișierelor din sistemul de fișiere FAT16, utilizați funcția read_fat16():

int read_fat16()

U64 seek = (__u64) (fbs.reserved) * 512; // Treceți la FAT16 în prima secțiune

Fat16 = (void *) malloc(fat16_size);

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

Returnează 0;

Funcția read_root_dentry() este utilizată pentru a citi directorul rădăcină:

int read_root_dentry()

U64 seek = (__u64) fbs.reserved * 512 + fat16_size * fbs.fats; // Înlocuire în directorul rădăcină în prima secțiune

Root_size = 32* dir_entries; // calculează dimensiunea directorului rădăcină

Dir_entry = (__u8 *) malloc(root_size);

Dacă(!dir_entry) returnează -1;

Memset(dir_entry, 0, root_size);

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

Returnează 0;

Citirea cluster-ului care aparține fișierului este specificată de funcția read_cluster(). Parametrii de intrare ai funcției sunt numărul cluster cluster_num și intrarea în buffer-ul __u8 *tmp_buff, unde ar trebui plasat rezultatul citirii. Deplasările la un cluster dintr-o partiție sunt calculate folosind următoarea formulă (div.):

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

• CĂUTA- Deplasare la cluster pe partiție
• DATA_START- Zona de date cob
• CLUSTER_NUM– numărul de serie al clusterului
• BYTE_PER_CLUSTER- Dimensiunea clusterului în octeți

int read_cluster(__u16 cluster_num, __u8 *tmp_buff)

U64 seek = (__u64) (byte_per_cluster) * (cluster_num - 2) + data_start; // calculează suma pentru cluster

< 0) return -1;

Returnează 0;

Funcția read_directory limitează intrările citite în director (nu în directorul rădăcină) și plasează rezultatul în zona de memorie, deoarece indexul dir_entry a fost ajustat:

int read_directory(__u16 start_cluster)

Int i = 1;

U16 următorul_cluster;

Pentru(; ;i++) (

Putem vedea memoria pentru salvare în director, citim în locul clusterului de pornire și citim din tabelul FAT16 valorile clusterului de pornire:

Dacă(!dir_entry) returnează -1;

< 0) return -1;

Următorul_cluster = fat16;

Salvat în locul unui director într-un fișier separat (pentru control):

#ifdef DEBUG

Printf("Următorul cluster - 0x%X", următorul_cluster);

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

Write(fat, dir_entry, root_size);

Închide (gras);

#endif

Odată atins clusterul rămas, ieșim din buclă, în caz contrar continuăm să citim directorul, mărind dimensiunea buffer-ului dir_entry cu încă un cluster:

If(next_cluster & EOF_FAT16) break;

Start_cluster = următorul_cluster;

Returnează 0;

Funcția get_dentry() caută directorul elementului care corespunde fișierului. Parametrii de intrare ai acestei funcții sunt indicatorul de structură struct split_name *sn, care plasează elementele numelui scurt de fișier:

Int i = 0;

Bufferul global dir_entry conține o matrice de elemente în directorul în care selectăm intrarea pentru fișier (sau director). Pentru a căuta, organizăm un ciclu. Acest ciclu lucrează pentru a copia elementele directorului în structura globală dentry și pentru a egaliza valorile câmpurilor nume și ext ale structurii cu câmpurile aferente structurii struct split_name *sn. Absența acestor câmpuri înseamnă că am găsit o intrare pentru fișierul căutat în matricea de elemente din director:

pentru(; ; i++) (

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

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

Pauză;

Dacă(!dentry.name) returnează -1;

#ifdef DEBUG

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

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

Printf("dimensiunea fișierului - %u", dentry.size);

Printf("fișier atrib - 0x%X", dentry.attr);

#endif

Returnează 0;

Toate codurile de ghidare se află în catalogul FAT16, fișierul fat16.c. Pentru a crea un modul nou, creați un Makefile ca acesta:

INCDIR = /usr/src/linux/include

PHONY = curat

Fat16: fat16.o split.o

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

%.o: %.c

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

Curat:

Rm -f *.o

Rm-f./fat16

Implementarea software a algoritmului pentru citirea unui fișier dintr-o partiție logică din sistemul de fișiere FAT12

Algoritmul pentru citirea unui fișier cu o partiție FAT12 este identic cu algoritmul pentru citirea unui fișier cu o partiție FAT16. Importanța constă în procedura de citire a elementelor din tabelul FAT12. Tabelul FAT16 a fost văzut ca o simplă matrice de elemente pe 16 biți. Pentru a citi elementele tabelului FAT12, se aplică următorul algoritm:

• înmulțiți numărul elementului cu 1,5;
• trageți un cuvânt de 16 biți din FAT, vikorista, deoarece rezultatul operației anterioare este deplasat;
• Dacă numărul elementului este diferit, efectuați operația AND pe cuvântul tratat și masca 0x0FFF. Dacă numărul este neîmperecheat, distrugeți cuvântul din tabel cu 4 biți în rândurile inferioare.

Pe baza acestui algoritm, implementăm funcția de citire a elementelor din tabelul FAT12:

int get_cluster(__u16 cluster_num)

U16 caută;

Clust U16;

Decalajele sunt calculate din tabelul FAT12 și un cuvânt de 16 biți este citit din tabel:

Seek=(cluster_num*3)/2;

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

Dacă numărul de pornire al clusterului este același număr, valoarea citită din tabel este distrusă cu 4 biți din cifrele cele mai mici, iar dacă nu este același număr, se presupune că este 0x0FFF:

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

Else cluster &= 0x0FFF;

Acest fragment poate fi implementat și în limbaj de asamblare:

" xorw %%ax, %%ax "

" de altfel $0, %%cx "

"jnc 1f"

" shrw $4, %%dx "

"jmp 2f"

„1: și w $0x0FFF, %%dx”

„2: movw %%dx, %%ax”

:"=a" (următorul)

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

Să întoarcem rezultatul:

Returnclust;

Vom petrece puțin timp raportând algoritmul. Să presupunem că un fișier a fost creat pe o partiție FAT12 care ocupă al 9-lea și al 10-lea cluster. Elementul de piele FAT12 ocupă 12 biți. Deoarece Din tabel numărăm elementele de 16 biți, apoi trecerea la al 9-lea element adaugă 13 octeți (9 * 1,5 = 13, excesul este aruncat), cu cele mai tinere 4 cifre situate pe al 8-lea element FAT. Ele trebuie aruncate, iar apoi elementul de tratare trebuie distrus cu 4 biți din descărcările mai tinere, așa cum este transmis de algoritm. Deplasarea până la al 10-lea element este de 15 octeți, iar cei mai semnificativi 4 octeți sunt în al 11-lea element FAT. Pentru a le elimina, trebuie să părăsiți operația AND pe al 10-lea element și masca 0x0FFF, care corespunde algoritmului de mai sus.

Textele de ieșire ale modulului care citește un fișier din secțiunea FAT12 se află în directorul FAT12, fișierul fat12.c.

Implementarea software a algoritmului pentru citirea unui fișier dintr-o partiție logică din sistemul de fișiere FAT32

Algoritmul pentru citirea unui fișier dintr-o partiție cu sistemul de fișiere FAT32 practic nu diferă de algoritmul pentru FAT16, cu excepția faptului că directorul rădăcină FAT32 poate fi extins în orice partiție și, prin urmare, de o dimensiune mai mare. Prin urmare, pentru a fi mai simplu, este acceptabil să știm doar numărul partiției cu sistemul de fișiere FAT32. Pentru a obține informații din această secțiune, determinați coordonatele acesteia - deplasarea la secțiunea din stiuletul discului. Și pentru nevoia acestei mame, declarația despre structura logică a hard disk-ului.

Structura logică a hard diskului

Să aruncăm o privire la structura logică a hard disk-ului, care corespunde standardului Microsoft - "secțiunea principală - secțiuni de extensie - secțiuni non-DOS".

Spațiul pe hard disk poate fi organizat în una sau mai multe partiții, iar partițiile pot găzdui unul sau mai multe discuri.

Pe hard disk, în spatele adresei fizice 0-0-1, există un Master Boot Record (MBR). Structura MBR are următoarele elemente:

• bootstrap non-sistem (NSB);
• tabel care descrie partițiile de disc (tabel de partiții, PT). Extins la MBR la offset 0x1BE și durează 64 de octeți;
• Semnătura MBR. Cei doi octeți rămași ai MBR pot conține numărul 0xAA55.

Tabelul de partiții arată locația și caracteristicile partițiilor găsite pe hard disk. Partițiile de disc pot fi de două tipuri – primare (primare, principale) și extinse (extensii). Numărul maxim de partiții primare este același. Ar trebui să existe o partiție primară pe disc și o partiție primară. O partiție extinsă poate fi împărțită într-un număr mare de sub-partiții - unități logice. Structura simplificată a MBR este prezentată în Tabelul 7. Tabelul de partiții este extins ca MBR, 16 octeți sunt furnizați pentru a descrie partiția tabelului.

Tabelul 7. Structura MBR

Substituţie Dimensiune, octet 0 446 0x1BE 16 0x1CE 16 0x1DE 16 0x1EE 16 0x1FE 2

Structura intrării elementului tabelului de secțiuni este prezentată în Tabelul 8.

Tabelul 8. Structura unei intrări de elemente din tabelul de secțiuni

Primul octet al elementului de secțiune indică activitatea secțiunii (0 – inactiv, 0x80 – activ). Este important de remarcat importanța secțiunii de backup a sistemului și necesitatea de a reporni sistemul de operare la pornirea computerului. O singură secțiune poate fi activă. După semnul de activitate al secțiunii sunt coordonatele capului de secțiune - trei octeți, care indică numărul capului, numărul sectorului și numărul cilindrului. Numerele cilindrului și sectorului sunt specificate în formatul de transfer Int 0x13, atunci. biții 0-5 sunt numărul sectorului, biții 6-7 sunt cei mai mari doi biți ai numărului cilindrului de 10 cifre, biții 8-15 sunt cei mai mici biți ai numărului cilindrului. Apoi urmează codul ID de sistem, care indică faptul că această secțiune aparține aceluiași sistem de operare. Identificatorul ocupă un octet. În spatele identificatorului de sistem, coordonatele sfârșitului secțiunii sunt extinse - trei octeți care conțin numerele capului, sectorului și cilindrului. Octeții actuali sunt numărul de sectoare dinaintea secțiunii, iar octeții rămași sunt dimensiunea sectorului.

În acest fel, un element de tabel de secțiuni poate fi descris folosind următoarea structură:

struct pt_struct (

U8 bootabil; // ensign de activitate pentru sectie

U8 start_part; // coordonează cob la secțiune

U8 tip_parte; // identificator de sistem

U8 end_part; // coordonatele sfârșitului secțiunii

U32 sec_înainte; // Numărul de sectoare înainte de partiție

U32 sec_total; // Dimensiunea secțiunii în sectoare (numărul de sectoare pentru secțiune)

Elementul Rozdille primar a fost la un moment dat în sectorul camulin al discului logic (primarul Zapzhdi є minciuni este un disc logi), iar etmusul Rodіl în formă de buștean - pe lista de disides în formă de buștean, plierea structurilor Iz, yaki la MBR secundar (Mbr secundar, SMBR).

Blocul său SMBR este situat la discul de piele al unei secțiuni extinse. SMBR are o structură similară cu MBR, cu excepția faptului că conține o înregistrare a unei noi zile (umplute cu zerouri), iar din patru câmpuri de descriere a secțiunilor sunt selectate doar două. Primul element al partiției indică discul logic, celălalt element indică următoarea structură SMBR a listei. În lista SMBR rămasă, plasați un alt element cu un cod de secțiune zero.

Să ne întoarcem să ne uităm la modulul de citire a fișierelor pentru partiția FAT32.

Fișiere antet:

#include

#include

#include

#include

#include

Semnătura MBR:

#define SEMNATURĂ 0xAA55

Voi atașa fișierul pentru informații despre secțiunile:

#define DEVICE „/dev/hda”

Dimensiunea elementului tabelului de partiții (16 octeți):

#define PT_SIZE 0x10

Următoarea matrice de structuri stabilește tipul de cod între tipul de secțiune și reprezentările sale simbolice:

struct systypes (

U8 tip_parte;

U8 * nume_parte;

struct systypes i386_sys_types = (

(0x00, „Gol”),

(0x01, „FAT12”),

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

(0x05, „Extins”),

(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 extins”),

(0x07, „HPFS/NTFS”)

Numărul de elemente din matricea i386_sys_types este semnificativ în spatele macrocomenzii suplimentare PART_NUM:

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

Instalarea schimbului pe un număr de discuri logice:

#define MAX_PART 20

Următoarea matrice de structură conține informații despre unitățile logice de pe dispozitiv (hard disk):

struct pt_struct (

U8 bootabil;

U8 start_part;

U8 tip_parte;

U8 end_part;

U32 sec_înainte;

U32 sec_total;

) pt_t;

int greu; // atașează un descriptor de fișier

U8 mbr; // MBR este important aici

Numărul partiției pe care este creat sistemul de fișiere FAT32:

#define FAT32_PART_NUM 5

Structuri ale sectorului privat, sector FSInfo și elemente de director (alocate fișierului ):

struct fat_boot_sector fbs;

struct fat_boot_fsinfo fsinfo;

struct msdos_dir_entry dentry;

U32 * fat32 = NULL; // copiați tabelul FAT32 aici

Mărimea_sectorului U16; // Dimensiunea sectorului (din FAT32)

U16 dir_entries; // 0 pentru FAT32

sectoare U16; // Numărul de sectoare pe partiție

U32 fat32_size; // dimensiunea FAT32

U32 data_start; // șeful zonei de date

U16 byte_per_cluster; // câți octeți are clusterul (dimensiunea clusterului în octeți)

U32 următorul_cluster; // cluster chergovy la lantsyuzhku

U32 root_cluster; // Cluster ROOT - cluster cob al directorului rădăcină

U8 * dir_entry = NULL; // indicator pe intrarea în director

U64 start_seek = 0; // începe decalarea până la jos (în octeți)

Functie principala:

int main()

Int num = 0;

Int cluster_num = 5; // câte clustere să citiți din fișier

U8 * full_path = "/Folder1/Folder2/readme"; // fișier de citit

Deschiderea dispozitivului, selectarea informațiilor despre tabelul de partiții de pe dispozitiv și afișarea informațiilor despre partiții:

Hard = Deschis(DEV_NAME, O_RDONLY);

Dacă (greu< 0) {

Eroare (DEV_NAME);

Ieșire (-1);

If(get_pt_info(hard)< 0) {

Eroare ("get_pt_info");

Ieșire (-1);

Show_pt_info();

Calculăm suma de pornire a secțiunii:

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

Citiți clusterele care aparțin fișierului:

Num = fat32_read_file(full_path, cluster_num);

Dacă (num< 0) perror("fat32_read_file");

Else printf("Citiți %d clustere\n", num);

Închide (greu);

Returnează 0;

Informațiile despre tabelul de partiții sunt citite de funcția get_pt_info():

int get_pt_info(int hard)

Int i = 0;

U64 caută;

Citim tabelul de partiții din MBR și verificăm semnătura:

Read_main_ptable(hard);

If(check_sign()< 0) {

Printf("Semnătura nevalidă!\n");

Retur-1;

Arată ca identificatorul partiției extinse. Dacă acesta este cazul, calculăm încărcarea pentru partiția extinsă și citim informații despre discurile logice:

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

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

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

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

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

Read_ext_ptable(hard, seek);

Pauză;

Returnează 0;

Funcția de citire a tabelului de partiții read_main_ptable():

void read_main_ptable(int hard)

Dacă(citește(greu, mbr, 512)< 0) {

Eroare ("citește");

Închide (greu);

Ieșire (-1);

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

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

Întoarcere;

Funcția de verificare a semnăturii check_sign():

int check_sign()

semnul U16 = 0;

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

#ifdef DEBUG

Printf("Semnătură - 0x%X\n", semn);

#endif

If(semn != SEMNATURĂ) returnează -1;

Returnează 0;

Funcția de citire a tabelului de partiții extins:

void read_ext_ptable (int hard, __u64 seek)

Int num = 4; // Pornind de la această poziție, matricea structurilor pt_t este umplută cu informații despre discuri logice

U8 smbr;

Date de intrare:

• greu- Voi atasa fisierului un descriptor;
• căuta- Deplasarea la partiția extinsă pe spațiu pe disc (în octeți).

Pentru a prelua informații despre discurile logice, organizăm un ciclu:

Pentru(;;num++) (

Citiți SMBR, care este determinat de decalajul de căutare de la marginea discului:

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

Pread64(hard, smbr, 512, seek);

Stocăm două elemente ale tabelului pt_t, începând cu poziția num. Primul element va fi plasat pe discul logic, iar celălalt va fi plasat pe structura SMBR:

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

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

Facem o modificare la câmpul „Numărul sectorului cob” - din stiulețul discului:

Pt_t.sect_before += (seek/512);

Deoarece codul tipului de partiție este egal cu zero, nu mai există discuri logice:

Dacă(!(pt_t.type_part)) break;

Să calculăm suma până la SMBR actual:

Căutare = ((__u64) (pt_t.sect_before + pt_t.sect_total)) * 512;

Întoarcere;

Funcția show_pt_info() afișează informații despre unitățile logice detectate pe dispozitiv:

void show_pt_info()

Int i = 0, n;

#ifdef DEBUG

Printf("Numărul de partiții de pe disc este %d\n", PART_NUM);

#endif

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

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

Printf("\nTipul partiției %d - ", i);

Pentru (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].nume_parte);

Pauză;

If(n == PART_NUM) printf("tip necunoscut\n");

Printf("Semnul locației - 0x%X\n", pt_t[i].bootable);

Printf("Sectoare din secțiunea %d - %d\n", i, pt_t[i].sect_total);

Printf("Sectoare înainte de secțiunea %d - %d\n\n", i, pt_t[i].sect_before);

Întoarcere;

Citirea clusterelor unui fișier într-o partiție FAT32 este configurată de funcția fat32_read_file(). Această funcție are multe în comun cu funcția fat16_read_file(), așa că pentru comentarii detaliate, mergeți la pasul 6:

int fat32_read_file(__u8 *full_path, int num)

Struct split_name sn;

U8 tmp_name_buff;

Int i = 1, n;

U32 start_cluster, următorul_cluster;

U8 * tmp_buff;

Operații pregătitoare – curățați tamponul, verificați structura și verificați prima oblică:

Memset(tmp_name_buff, 0, SHORT_NAME);

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

Dacă (cale_completă! = "/") returnează -1;

Un sector de avangardă considerabil:

Dacă(citește_fbs()< 0) return -1;

Memcpy((void *)§or_size, (void *)fbs.sector_size, 2);

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

Memcpy((void *)§oare, (void *)fbs.sectoare, 2);

Structura FSInfo poate fi citită și semnătura conținută în acesta poate fi văzută:

Dacă(citește_fs_info()< 0) return -1;

Printf("Semnătura1 - 0x%X\n", fsinfo.semnătura1);

Printf("Semnătura2 - 0x%X\n", fsinfo.semnatura2);

Fat32_size = fbs.fat32_length * 512; // Dimensiunea FAT32 în octeți

Data_start = 512*fbs.reserved+fat32_size*2; // cob de câmp tribut

Byte_per_cluster = fbs.cluster_size * 512; // Dimensiunea clusterului în octeți

Root_cluster = fbs.root_cluster; // numărul de cluster al directorului rădăcină

Citiți FAT32:

Daca(citeste_fat32()< 0) return -1;

Memoria pentru intrările din director este vizibilă:

Dir_entry = (__u8 *) malloc(byte_per_cluster);

Dacă(!dir_entry) returnează -1;

Citiți directorul rădăcină:

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

Efectuăm o selecție a întregului fișier și a secțiunii elementului skin din depozit:

În timp ce(1) (

Memset(tmp_name_buff, 0, SHORT_NAME);

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

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

Tmp_name_buff[n] = calea_completă[i];

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

I++;

Pauză;

Tmp_name_buff[n] = "\0";

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

Printf("numele nu este valid\n");

Retur-1;

If(get_dentry(&sn)< 0) {

Printf("Nu există un astfel de fișier!\n");

Retur-1;

Pentru a extrage numărul de început al unui cluster dintr-un sistem de fișiere FAT32, este necesar să introduceți cuvântul mai vechi al numărului primului cluster din fișier - câmpul starthi al structurii dentry:

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

Verificăm octetul de atribut:

If(dentry.attr & 0x10) (// acest director

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

Continua;

Dacă (dentry.attr & 0x20) (// un fișier

Tmp_buff = (__u8 *) malloc (byte_per_cluster);

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

Dacă (n< 0) {

Eroare ("deschis");

Retur-1;

Printf("primul cluster al fișierului - 0x%X..", start_cluster);

Pentru(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) {

Eroare ("scrie");

Retur-1;

If(next_cluster == EOF_FAT32) (

Gratuit(tmp_buff);

Închidere(n);

Returnează ++i;

Start_cluster = următorul_cluster;

Întoarce i;

Scopul acestor trei funcții este de a le menține în locul zonei de sistem, atunci. sectorul privat, structura FSInfo și tabelul FAT32:

1) funcția read_fbs() selectează citirea sectorului rezervat:

int read_fbs()

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

Returnează 0;

2) funcția read_fs_info() citește structura FSInfo:

int read_fs_info()

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

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

Returnează 0;

3) funcția read_fat32() citește tabelul FAT32:

int read_fat32()

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

Fat32 = (void *) malloc (fat32_size);

Dacă(!fat32) returnează -1;

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

Returnează 0;

Funcția read_cluster() selectează clusterul citit din numărul atribuit:

int read_cluster(__u32 cluster_num, __u8 *tmp_buff)

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

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

Returnează 0;

Citirea directoarelor (inclusiv directorul rădăcină) este gestionată de funcția read_directory():

int read_directory(__u32 start_cluster)

Int i = 2;

U32 următorul_cluster;

Parametrii funcției – directorul cluster de pornire. Citiți în loc de director în buffer-ul global dir_entry:

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

Următorul_cluster = fat32;

Deoarece directorul ocupă un cluster, se pare că există o dimensiune mai mare a memoriei și continuă să citească:

Pentru(; ;i++) (

Start_cluster = următorul_cluster;

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

Dacă(!dir_entry) returnează -1;

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

Următorul_cluster = fat32;

Dacă((următorul_cluster == EOF_FAT32) || (next_cluster == 0xFFFFFF8)) returnează 0;

Returnează 0;

Funcția rămasă, așa cum ne vom uita, caută un element în directorul care corespunde fișierului:

int get_dentry(struct split_name *sn)

Int i = 0;

Directorul dir_entry configurează zona de memorie pentru a plasa o serie de intrări în directorul în care salvăm fișierul (sau directorul). Pentru a căuta, organizăm un ciclu și găsim o înregistrare situată în structura globală de dentiză:

Pentru(;;i++) (

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

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

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

Pauză;

Dacă(!dentry.name) returnează -1;

Returnează 0;

În acest moment, citirea fișierului din partiția FAT32 este completă.

Textele de ieșire ale modulului se află în directorul FAT32, fișierul fat32.c.

Caracteristici în organizarea salvării înregistrărilor de fișiere în directoare pentru sistemele de fișiere FAT și EXT2

Câteva cuvinte despre importanța organizării salvării înregistrărilor fișierelor în directoare pentru sistemele de fișiere FAT și EXT2. Structura sistemului de fișiere EXT2 a fost revizuită la.

Cunoaștem bine FAT - toate elementele din catalog au o valoare fixă. Când fișierul este creat, driverul sistemului de fișiere caută prima poziție neocupată și stochează informații despre fișier. Dacă directorul curent nu se încadrează într-un cluster, atunci i se adaugă un alt cluster etc.

Să aruncăm o privire, verifică-l în EXT2.

Să presupunem că avem o partiție cu sistemul de fișiere EXT2, dimensiunea blocului este de 4096 de octeți. Pentru care secțiune creăm un catalog. Mărimea directorului este egală cu dimensiunea blocului – 4096 octeți. În catalog, sistemul de operare creează simultan două înregistrări - o înregistrare în flux și o înregistrare a catalogului tatălui. O intrare într-un director de streaming durează 12 octeți, iar la sfârșitul zilei, o intrare în Ziua Tatălui durează 4084 de octeți. Să creăm orice fișier din acest catalog. După aceasta, vor exista trei intrări în catalog - o intrare pentru directorul de flux cu 12 octeți, o intrare pentru directorul Tatălui cu 12 octeți și o intrare pentru fișierul creat cu, după cum ați ghicit melodios, 4072 octeți. De îndată ce fișierul a fost creat, îl voi adăuga în directorul Batkiv și îl voi crește la 4084 de octeți.

Astfel, atunci când un fișier este creat, driverul sistemului de fișiere EXT2 caută în catalog înregistrarea maximă și o împarte, făcând loc unei noi intrări. Ei bine, dacă spațiul încă nu funcționează, se adaugă un alt bloc în director, iar directorul primește 8192 de octeți.

Și, în sfârșit, o corectare minoră la articolul „Arhitectura sistemului de fișiere EXT2”.

Această modificare implică funcția de atribuire a numărului de inod numelui de fișier get_i_num(). Versiunea veche a acestei funcții arăta astfel:

int get_i_num(car *nume)

Int i = 0, rec_len = 0;

Struct ext2_dir_entry_2 dent;

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

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

Rec_len + = dent.rec_len;

Returnează dent.inode;

Opțiune de corectare:

int get_i_num(car *nume)

* Parametrul funcției – numele fișierului. Valoarea care se transformă este numărul inodul al fișierului.

Int rec_len = 0;

Struct ext2_dir_entry_2 dent; // Această structură determină formatul intrării directorului rădăcină:

* Buffer-ul global al bufferului conține o serie de intrări de director. Pentru a atribui un număr de serie unui fișier, trebuie să cunoașteți inodul

* Această serie de înregistrări se află în acest fișier. Pentru care organizăm un ciclu:

Pentru(;;) (

/* Copiat în structura dent a intrării de director: */

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

* Dacă numele fișierului este mai mare decât zero, înseamnă că am enumerat toate intrările din director

* Înregistrările din dosarul nostru nu au fost găsite. Deci, este timpul să ne întoarcem:

Dacă(!dent.name_len) returnează -1;

/* Căutarea se termină cu modul de aliniere a numelor fișierelor. Dacă numele sunt evitate, ieșim din buclă: */

Dacă (! memcmp (dent.nume, nume, strlen (nume))) break;

/* Dacă numele nu s-au potrivit, le vom înlocui cu intrarea curentă: */

Rec_len + = dent.rec_len;

/* Dacă reușește, numărul inodul al fișierului este rotit: */

Returnează dent.inode;

Literatură:

1. V. Kulakov. Programarea la nivel hardware: un martor deosebit. a 2-a vedere. / - Sankt Petersburg: Peter, 2003 - 848 p.
2. A.V.Gordiev, A.Yu.Molchanov. Software de sistem / - Sankt Petersburg: Peter - 2002 r.
3. Meshkov V. Arhitectura sistemului de fișiere ext2. - Revista „Administrator de sistem”, nr. 11 (12), toamna frunze 2003. - 26-32 s.

In contact cu

Când sarcina este decisă, își încheie scopul principal - organizează munca cu date în funcție de structura cântecului. Pentru ce este sistemul de fișiere? Ce este acest FS și ce poate fi, precum și alte informații despre acesta vor fi furnizate în continuare.

Descrierea Zagalny

Sistemul de fișiere face parte din sistemul de operare, care este responsabil pentru stocarea, stocarea și stocarea informațiilor pe dispozitive, oferind utilizatorilor acces la aceste informații și, de asemenea, asigurând siguranța vikoristannya. În plus, el însuși ajută cu datele actualizate în cazul unei defecțiuni hardware sau software. Acesta este motivul pentru care sistemul de fișiere este atât de important. Ce este FS și ce poate face? Există câteva tipuri:

Pentru hard disk-uri, pentru dispozitive cu acces amplu;

Pentru benzi magnetice si dispozitive cu acces last minute;

Pentru nasuri optice;

Sisteme virtuale;

sistemele Merezhevi.5

Ca unitate logică pentru stocarea datelor într-un sistem de fișiere, un fișier este utilizat pentru a organiza totalitatea datelor care pot fi denumite. Toate datele care sunt utilizate de sistemul de operare sunt prezentate sub formă de fișiere: programe, imagini, texte, muzică, videoclipuri, precum și drivere, biblioteci etc. Un astfel de element are un nume, tip, extensie, atribute și dimensiune. Ei bine, acum știți că sistemul de fișiere este o colecție de astfel de elemente, precum și modalități de a lucra cu ele. Este important de remarcat cum este discutat și care sunt principiile sale, se pot distinge o serie de tipuri principale de FS.

Abordarea software

Cu toate acestea, când ne uităm la sistemul de fișiere (ce și cum să tratăm cu el), este necesar să înțelegem că aceasta este o structură bogată, la nivelul superior există un remixer de sistem de fișiere care va oferi o interfață între sistem și un dispozitiv specific.datkom. Convertește fișierele într-un format care este acceptat de driverele actuale - drivere. Ei, în felul lor, apelează la driverele unor dispozitive specifice care salvează informațiile necesare.

Suplimentele client-server pot atinge o productivitate ridicată FS. Sistemele actuale pot asigura accesul eficient, sprijinirea obligațiilor de mare valoare, protecția datelor împotriva accesului neautorizat și păstrarea integrității informațiilor.

Sistem de fișiere FAT

Acest tip a fost dizolvat în 1977 de Bill Gates și Mark McDonald. Pagina a fost vicorizată în OS 86-DOS. Dacă vorbim despre cei cu sistem de fișiere FAT, atunci este clar că inițial nu a fost conceput pentru a suporta hard disk-uri, ci a funcționat doar cu unități mici, cu o capacitate de până la 1 megaoctet. Infecția nu mai este relevantă, iar acest FS a fost dezvoltat de Microsoft pentru MS-DOS 1.0 și versiuni ulterioare. FAT are un wiki despre melodii pentru denumirea fișierelor:

Începutul numelui poate conține o literă sau un număr, iar acesta însuși poate conține un caracter ASCII, pe lângă spații și elemente speciale;

Lungimea numelui nu poate fi mai mare de 8 caractere, după care este plasat un punct și apoi este indicată extensia, care constă din trei litere;

Numele fișierelor pot fi modificate în funcție de registru, dar pot fi modificate și salvate.

Deoarece FAT a fost conceput inițial pentru sistemul de operare DOS pentru un singur utilizator, a transferat stocarea datelor despre Vlasnik și alte accesări importante. În acest moment, acest sistem de fișiere este cel mai extins, motiv pentru care acceptă cel mai mult. Versatilitatea sa face posibilă utilizarea lui pe volume care rulează diferite sisteme de operare. Acesta este un FS simplu, deoarece nu poate salva fișiere prin completarea incorectă a computerului. Sistemele de operare care funcționează pe această bază au utilități speciale care verifică structura și corectează inconsecvența fișierelor.

Sistem de fișiere NTFS

Acest FS este cel mai bun pentru a lucra cu sistemul de operare Windows NT, iar cea mai mare parte a fost dezvoltat special pentru acesta. Sistemul de operare include utilitarul de conversie, care convertește volumele din FAT și HPFS în volume NTFS. Dacă vorbim despre sistemul de fișiere NTFS, atunci este important de menționat că acesta a extins capacitatea de a accesa directoare și fișiere vechi, a introdus absența atributelor, a implementat modalități de comprimare dinamică a fișierelor și durabilitatea Până în acest moment, acestea respectă standardul POSIX. În FS, puteți selecta nume de până la 255 de caractere, cu nume scurte fiind generate în același mod ca și în VFAT. Înțelegând ce este sistemul de fișiere NTFS, rețineți că, dacă sistemul de operare eșuează, acesta se va reporni singur, iar volumul discului nu va mai fi accesibil, dar structura directoarelor nu va fi afectată.

Caracteristicile NTFS

Pe un volum NTFS există un fișier de reprezentare cu o intrare în tabel MFT. Primele 16 înregistrări ale tabelului sunt rezervate de sistemul de fișiere pentru a salva informații speciale. Prima intrare descrie tabelul de fișiere în sine. Când prima înregistrare este ștearsă, se citește o altă căutare pentru fișierul MFT oglindă, unde prima înregistrare este identică cu tabelul principal. O copie a fișierului original se află în centrul logic al discului. A treia intrare din tabel conține fișierul de înregistrare care este utilizat pentru actualizarea datelor. A șaptesprezecea și următoarele intrări din tabelul de fișiere conțin informații despre fișierele și directoarele de pe hard disk.

Jurnalul de tranzacții conține un nou set de operațiuni care modifică structura volumului, inclusiv operațiuni de creare a fișierelor și emiterea oricăror comenzi care modifică structura directorului. Jurnalul de tranzacții al misiunilor de upgrade NTFS ca urmare a unei defecțiuni a sistemului. Intrarea pentru directorul rădăcină conține o listă de directoare și fișiere care se află în directorul rădăcină.

Caracteristicile EFS

Sistemul de fișiere criptate (EFS) este o componentă Windows, pe lângă care datele de pe hard disk pot fi salvate într-un format criptat. Criptarea a devenit cea mai puternică securitate pe care o poate oferi un sistem de operare. În acest caz, criptarea utilizatorului necesită o procedură simplă, pentru care trebuie să stabiliți permisiunea pentru autoritățile folderului sau fișierului. Puteți specifica cine poate citi astfel de fișiere. Criptarea este activată atunci când fișierele sunt închise și, dacă sunt deschise, sunt gata automat pentru a fi distruse.

Caracteristicile RAW

Dispozitivele concepute pentru a salva date au cel mai mare număr de componente, care sunt adesea mai greu de deteriorat nu numai fizic, ci și logic. Unele probleme legate de proprietate se pot dovedi a fi fatale, în timp ce altele pot necesita soluții. Uneori, jurnaliștii întreabă: „Ce este sistemul de fișiere RAW?”

Aparent, pentru a înregistra orice informație pe un hard disk sau pe o unitate flash, dispozitivul de stocare trebuie să folosească un FS. Cele mai largi sunt FAT și NTFS. Și RAW nu este sistemul de fișiere pe care îl credem noi. De fapt, este o modificare logică a sistemului deja instalat, astfel încât acesta este efectiv disponibil pentru Windows. Cel mai adesea, RAW este asociat cu modificări ale structurii sistemului de fișiere. După aceasta, sistemul de operare nu numai că furnizează date, dar nici nu afișează corect informațiile tehnice.

Caracteristicile UDF

Universal Disk Format (UDF) este disponibil pentru a înlocui CDFS și pentru a adăuga suport pentru unitățile DVD-ROM. După cum spunem despre acestea, atunci prețul unei noi implementări a versiunii vechi pentru care demonstrează beneficii. Vaughn se caracterizează prin trăsături de cânt:

Numărul maxim de nume de fișiere poate fi de 255 de caractere;

Lipsa numelui poate fi mai mică sau mai mare;

Limita maximă de numărare este de 1023 de caractere.

Începând cu Windows XP, acest sistem de fișiere acceptă citirea și scrierea.

Acest FS este conceput pentru unități flash care trebuie să funcționeze împreună cu diferite computere care funcționează sub controlul diferitelor sisteme de operare, inclusiv Windows și Linux. EXFAT în sine a devenit acest „loc” între ele, deoarece este proiectat să funcționeze cu date care sunt extrase din sistemul de operare, fiecare având propriul său sistem de fișiere. Cum funcționează acest lucru va deveni clar în practică.

Visnovki

După cum puteți vedea din cele de mai sus, fiecare sistem de operare are melodii de sistem de fișiere. Destinat pentru salvarea ordonării structurilor de date pe medii fizice de informații. Dacă sunteți conștient de faptul că sistemul de fișiere este un utilizator final atunci când utilizați un computer, este absolut posibil ca atunci când încercați să copiați un fișier pe computer, să primiți un mesaj despre depășirea dimensiunii permise. De asemenea, este necesar să știți în ce FS ce dimensiune de fișier este acceptabilă, astfel încât la transferul de informații să nu întâmpinați probleme.

Sistemul de fișiere FAT16 există încă din primele zile ale MS-DOS și este susținut de toate sistemele de operare Microsoft pentru a asigura versatilitatea. Acest nume File Allocation Table reflectă în mod clar organizarea fizică a sistemului de fișiere, ale cărui principale caracteristici includ dimensiunea maximă a volumului care poate fi suportat (hard disk sau partiția hard disk). hard disk) nu conține 4095 MB. În timpul orelor de MS-DOS, hard disk-uri de 4 GB au fost vândute în vrac (discuri mari cu o capacitate de 20-40 MB), așa că o astfel de rezervă era complet justificată.

Volumul de formate pentru FAT16 vikoristan este împărțit în grupuri. Dimensiunea cluster-ului depinde de dimensiunea volumului și poate varia de la 512 la 64 KB. In masa Figura 2 arată cum dimensiunea clusterului depinde de dimensiunea clusterului. Este semnificativ faptul că dimensiunea clusterului poate varia în funcție de valorile calculelor, dar una dintre valorile din tabel este de vină. 2.

Nu se recomandă utilizarea sistemului de fișiere FAT16 pe volume mai mari de 511 MB, deoarece pentru fișiere relativ mici, spațiul pe disc va fi folosit foarte ineficient (un fișier de 1 octet va ocupa 64 KB). Indiferent de dimensiunea clusterului, sistemul de fișiere FAT16 nu este acceptat pentru volume mai mari de 4 GB.

Începând cu Microsoft Windows 95 OEM Service Release 2 (OSR2), Windows a introdus suport pentru FAT pe 32 de biți. Pentru sistemele bazate pe Windows NT, acest sistem de fișiere a început să fie adoptat de Microsoft Windows 2000. În timp ce FAT16 poate suporta volume de până la 4 GB, FAT32 poate suporta volume de până la 2 TB. Dimensiunea clusterului FAT32 poate fi modificată de la 1 (512 octeți) la 64 de sectoare (32 KB). Pentru a salva valoarea clusterelor FAT32, sunt necesari 4 octeți (32 de biți, nu 16, ca FAT16). Aceasta înseamnă că utilitățile de fișiere care sunt acceptate de FAT16 nu pot fi procesate de FAT32.

Principala diferență dintre FAT32 și FAT16 este că schimbă dimensiunea partiției logice a discului. FAT32 acceptă o capacitate de volum de până la 127 GB. În acest caz, dacă un FAT16 cu discuri de 2 GB necesită un cluster de 32 KB, atunci un cluster FAT32 cu o dimensiune de 4 KB este potrivit pentru discuri cu un volum de 512 MB până la 8 GB (Tabelul 4).

Aceasta înseamnă o utilizare mai eficientă a spațiului pe disc - cu un cluster mai mic, este nevoie de mai puțin spațiu pentru a salva un fișier și, ca urmare, este mai puțin probabil ca discul să devină fragmentat.

Când utilizați FAT32, dimensiunea maximă a fișierului poate fi de 4 GB minus 2 octeți. În timp ce cu FAT16 numărul maxim de intrări în directorul rădăcină a fost 512, FAT32 vă permite să creșteți acest număr la 65.535.

FAT32 impune restricții asupra dimensiunii minime - există nu mai puțin de 65527 clustere. Având în vedere dimensiunea clusterului, este imposibil ca FAT să ocupe mai mult de 16 MB-64 KB/4 sau 4 milioane de clustere.

Când sunt utilizate nume de fișiere diferite, datele necesare pentru accesul de la FAT16 și FAT32 nu se suprapun. Când se creează un fișier cu nume vechi, Windows creează un nume separat în format 8.3 și una sau mai multe intrări în director pentru a salva noul nume (13 caractere fiecare din vechiul nume de fișier pe fiecare intrare). Intrarea skin salvează partea corespunzătoare a numelui fișierului în format Unicode. Astfel de intrări conțin atributele „identificator de volum”, „numai citire”, „sistem” și „accesiuni” - un set care este ignorat de MS-DOS; Acest sistem de operare are acces la fișierul sub aliasul său în format 8.3.

Microsoft Windows 2000 include suport pentru o nouă versiune a sistemului de fișiere NTFS, care va asigura funcționarea cu serviciile de directoare Active Directory, puncte de analiză, caracteristici de securitate a informațiilor, controlul accesului și o serie de alte caracteristici.

Ca și în cazul FAT, unitatea de informare principală a NTFS este clusterul. In masa 5 arată dimensiunea clusterelor după spălare pentru volume de diferite capacități.

La formatarea unui sistem de fișiere NTFS, programul de formatare creează un fișier Master File Table (MTF) și alte zone de stocare a metadatelor. Metadatele sunt compilate în NTFS pentru a implementa structura fișierului. Primele 16 intrări în MFT sunt rezervate de NTFS. Rotirea fișierelor de metadate $Mft și $MftMirr scrise în sectorul original al discului. Dacă prima intrare MFT este coruptă, NTFS citește o altă intrare pentru a găsi o copie a primei. O copie completă a sectorului păstrat este plasată pe partea laterală a volumului. In masa 6 Principalele metadate stocate în MFT au fost reproiectate.

Alte înregistrări MFT plasează înregistrări pentru fiecare fișier și director situat pe acest volum.

Luați în considerare un fișier cu o înregistrare de la MFT, dacă fișierul are un set mare de atribute sau devine foarte fragmentat, atunci pot fi necesare înregistrări suplimentare pentru a salva informații despre el. În acest caz, prima înregistrare despre fișier, numită înregistrare de bază, salvează extinderea altor înregistrări. Datele despre fișiere și directoare de dimensiuni mici (până la 1500 de octeți) sunt întotdeauna situate în prima intrare.

Același sector de pe volumul NTFS aparține aceluiași fișier. Transferați metadatele sistemului de fișiere într-un fișier parțial. NTFS vede fiecare fișier (sau director) ca un set de atribute de fișier. Elemente precum numele fișierului, informațiile despre protecție și datele din noul fișier sunt atribute. Atributul skin este identificat printr-un cod de tip skin și, opțional, prin numele atributului.

Deoarece atributele unui fișier sunt localizate în înregistrarea fișierului, ele sunt numite atribute rezidente. Astfel de atribute sunt folosite pentru a denumi fișierul și data creării acestuia. În aceste situații, dacă informațiile despre fișier sunt prea mari pentru a se încadra într-o înregistrare MFT, atributele fișierului devin nerezidente. Atributele rezidente sunt stocate în unul sau mai multe clustere și există un flux de date alternative pentru volumul fluxului (vezi mai jos). Pentru a descrie locația atributelor NTFS rezidente și nerezidente, creați atributul Attribute List.

In masa 7 arată atributele principale ale fișierului atribuite NTFS. Lista poate fi extinsă.

Windows 2000 oferă suport pentru sistemul de fișiere CDFS, care este conform cu standardul ISO'9660 care descrie distribuirea informațiilor pe un CD-ROM. Sunt acceptate toate numele de fișiere până la ISO'9660 Nivelul 2.

Când creați un CD-ROM pentru utilizare sub Windows 2000, vă rugăm să rețineți:

• Toate numele de director și fișiere trebuie să aibă cel puțin 32 de caractere;
• Toate numele directoarelor și fișierelor trebuie să fie compuse din majuscule;
• Adâncimea cataloagelor poate depăși 8 ranguri de la rădăcină;
• Diverse extensii de nume de fișiere nu sunt obligatorii.

Actualizarea sistemelor de fișiere

Sub Microsoft Windows 2000, puteți utiliza sistemele de fișiere FAT16, FAT32, NTFS sau combinațiile acestora. Alegerea sistemului de operare depinde de criteriile actuale:

• despre modul în care un computer este folosit ca vikorist;
• platforma hardware;
• dimensiunea și numărul de hard disk;
• securitatea informatiei

Sisteme de fișiere FAT

După cum probabil ați observat deja, numerele din numele sistemelor de fișiere - FAT16 și FAT32 - indică numărul de biți necesari pentru a salva informații despre numerele clusterelor selectate de fișier. Deci, FAT16 are adresare pe 16 biți și, evident, poate fi schimbat la 2-16 adrese. În Windows 2000, primii biți ai tabelului de transfer de fișiere FAT32 au cerințele de putere necesare, în timp ce în FAT32 numărul de adrese ajunge la 228.

In masa Figura 8 arată dimensiunea clusterelor pentru sistemele de fișiere FAT16 și FAT32.

Pe lângă beneficiile legate de costuri ale dimensiunii clusterului FAT32, permite, de asemenea, extinderea directorului rădăcină (FAT16 are un număr limitat de intrări de 512 și poate fi mai mic dacă se schimbă alte nume de fișiere).

Avantajele FAT16

Varianta medie FAT16 poate fi numită după cum urmează:

• Sistemul de fișiere este acceptat de MS-DOS, Windows 95, Windows 98, Windows NT, Windows 2000 și alte sisteme de operare UNIX;
• Există un număr mare de programe care vă permit să faceți modificări sistemului de fișiere și să actualizați datele;
• Dacă aveți probleme cu stocarea pe hard disk, sistemul poate fi conectat la o dischetă;
• Acest sistem de fișiere este eficient pentru volume mai mici de 256 MB.

Comenzi rapide FAT16

Principalele deficiențe ale FAT16 includ:

• Directorul rădăcină nu poate conține mai mult de 512 elemente. Schimbarea numelor vechi de fișiere reduce semnificativ numărul acestor elemente;
• FAT16 acceptă nu mai mult de 65536 clustere și, deoarece aceste clustere sunt rezervate de sistemul de operare, numărul de clustere disponibile este de 65524. Fiecare cluster are o dimensiune fixă ​​pentru un anumit dispozitiv logic. Când numărul maxim de clustere este atins la dimensiunea maximă (32 KB), volumul maxim care poate fi suportat este de 4 GB (sub Windows 2000). Pentru a menține funcționalitatea cu MS-DOS, Windows 95 și Windows 98, volumele care rulează FAT16 nu trebuie să depășească 2 GB;
• FAT16 nu acceptă protecția sau compresia fișierelor;
• pe discuri cu volum mare, se cheltuiește mult spațiu pentru costul utilizării clusterului maxim. Locația fișierului apare în funcție de dimensiunea fișierului și de cluster.

Avantajele FAT32

Semnificația FAT32 poate fi definită după cum urmează:

• Consumul de spațiu pe disc este mai eficient, în special pentru discuri cu volum mare;
• Directorul rădăcină din FAT32 este clusterul principal de clustere și poate fi localizat în orice spațiu pe disc. Prin urmare, FAT32 nu impune nicio restricție asupra numărului de elemente din cataloza rădăcinii;
• pentru clustere de dimensiuni mai mici (4 KB pe discuri de până la 8 GB), spațiul necesar pe disc este cu 10-15% mai mic decât FAT16;
• FAT32 este un sistem de fișiere mai fiabil. Cu toate acestea, acceptă posibilitatea de a muta directorul rădăcină și vikoristanul copiei de rezervă FAT. În plus, înregistrarea de rezervă va conține o serie de date critice pentru sistemul de fișiere.

Comenzi rapide FAT32

Principalele dezavantaje ale FAT32:

• dimensiunea volumului pe oră folosind FAT32 sub Windows 2000, 32 GB;
• Volumele FAT32 nu sunt disponibile din alte sisteme de operare - cu excepția Windows 95 OSR2 și Windows 98;
• O copie de rezervă a sectorului privat nu este acceptată;
• FAT32 nu acceptă protecția sau compresia fișierelor.

Sistem de fișiere NTFS

Când lucrați în Windows 2000, Microsoft recomandă formatarea tuturor partițiilor de hard disk sub NTFS, indiferent de aceste configurații, dacă utilizați mai multe sisteme de operare (cu excepția Windows 2000 și Windows NT). Utilizarea NTFS în loc de FAT vă permite să exploatați funcțiile disponibile în NTFS. În fața lor, zokrema, întinde-te:

• Posibilitate de reînnoire. Această capacitate este „infuzată” în sistemul de fișiere. NTFS garantează economii de date datorită utilizării protocolului Vickory și a algoritmilor de actualizare a informațiilor. În cazul defecțiunii sistemului, protocolul NTFS vikorist și informații suplimentare pentru actualizarea automată a integrității sistemului de fișiere;
• compresia informatiilor. Pentru volumele NTFS, Windows 2000 încurajează compresia fișierelor adiacente. Astfel de tipuri de fișiere pot fi procesate de suplimentele Windows fără a despacheta mai întâi, deoarece sunt descărcate automat imediat ce fișierul este citit. Când este închis și salvat, fișierul este din nou împachetat;
• În plus, puteți vedea următoarele avantaje ale NTFS:

Anumite funcții ale sistemului de operare vor necesita acces NTFS;

Flexibilitatea accesului este mai bogată - NTFS minimizează numărul de transferuri de disc necesare pentru a găsi un fișier;

Protejați fișierele și directoarele. Numai pe volumele NTFS este posibilă setarea atributelor de acces pentru fișiere și foldere;

Cu NTFS instalat, Windows 2000 acceptă volume de până la 2 TB;

Sistemul de fișiere menține o copie de rezervă a sectorului protejat - este situat lângă volum;

NTFS acceptă sistemul de fișiere criptate (EFS), care protejează împotriva accesului neautorizat la fișiere;

Odată ce aveți o cotă, puteți limita spațiul pe disc pe care îl ocupă contul dvs.

Deficiențele NTFS

Vorbind despre deficiențele sistemului de fișiere NTFS, rețineți că:

• NTFS nu este disponibil în MS-DOS, Windows 95 și Windows 98. În plus, o serie de funcții implementate în NTFS sub Windows 2000 nu sunt disponibile în Windows 4.0 și versiunile anterioare;
• Pentru volume mici care pot găzdui o mulțime de fișiere mici, poate exista o scădere a productivității în comparație cu FAT.

Sistem de fișiere și viteză

După cum am afirmat deja, pentru volume mici, FAT16 sau FAT32 vor oferi acces sporit la fișierele legate la NTFS, cum ar fi:

• FAT are o structură mai simplă;
• dimensiunea cataloagelor este mai mică;
• FAT nu acceptă protecția fișierelor împotriva accesului neautorizat - sistemul nu trebuie să verifice drepturile de acces pentru fișiere.

NTFS minimizează cantitatea de transfer de date pe disc și timpul necesar pentru a găsi un fișier. În plus, deoarece dimensiunea catalogului este suficient de mică pentru a se potrivi într-o singură intrare MFT, întreaga intrare este citită odată.

O intrare în FAT este să introduceți numărul clusterului pentru primul cluster din director. Pentru a vizualiza un fișier FAT, trebuie să căutați în întreaga structură a fișierului.

Consecvența operațiunilor pentru directoare care conțin nume de fișiere scurte și lungi trebuie să fie asigurată că fluiditatea operațiunilor pentru FAT depinde de operația în sine și de dimensiunea directorului. Când FAT caută un fișier irelevant, caută întregul director - această operațiune durează mai mult de o oră, pe baza structurii bazate pe arbori B, care este compilată în NTFS. Ora medie necesară unui fișier este exprimată în FAT în funcție de N/2, în NTFS ca log N, unde N este numărul de fișiere.

Factorii de atac scăzuti afectează viteza de citire și scriere a fișierelor în Windows 2000:

• Fragmentarea fișierelor. Dacă fișierul este foarte fragmentat, NTFS necesită mai puțină stocare pe disc și mai puțină stocare FAT a tuturor fragmentelor;
• Dimensiunea clusterului. Pentru ambele sisteme de fișiere, dimensiunea clusterului este determinată a fi parte a volumului și este întotdeauna exprimată ca 2. Adresele în FAT16 sunt pe 16 biți, FAT32 sunt pe 32 de biți, în NTFS sunt pe 64 de biți;
• Dimensiunea clusterului conform FAT se bazează pe faptul că tabelul de distribuție a fișierelor nu poate fi mai mult de 65535 de intrări - dimensiunea clusterului este o funcție a volumului volumului, împărțit la 65535. ovchuvannyam pentru volumul FAT mai curând , cu atât dimensiunea este mai mică de cluster pentru acel NTFS este, de asemenea, obligatoriu. Este important ca dimensiunea mai mare a clusterului pentru volumele FAT înseamnă că volumele FAT pot fi mai puțin fragmentate;
• Fișiere rotative de dimensiuni mici. Când este instalat NTFS, fișierele mici sunt stocate în înregistrările MFT. Mărimea fișierului care se poate încadra într-o înregistrare MFT depinde de numărul de atribute ale fișierului.

Dimensiunea maximă a volumelor NTFS

Teoretic, NTFS acceptă volume cu până la 232 de clustere. Pe lângă absența hard disk-urilor, există și alte restricții privind dimensiunea maximă a volumului.

Una dintre aceste limite este tabelul de împărțire. Standardele industriale limitează dimensiunea tabelului de partiții la 232 de sectoare. Alte dimensiuni includ dimensiunea sectorului, care este de 512 octeți. Unele dimensiuni de sector se pot schimba în viitor, dimensiunea actuală este limitată la dimensiunea unui volum - 2 TB (231 x 512 octeți = 241). Astfel, 2 TB reprezintă o limită practică pentru volumele NTFS fizice și logice.

In masa Figura 11 prezintă interfața principală NTFS.

Oferiți acces la fișiere și directoare

Pe volumele NTFS, puteți seta drepturi de acces la fișiere și directoare. Aceste drepturi de acces indică ce grupuri le pot accesa și ce nivel de acces este permis. Astfel de drepturi de acces sunt extinse atât utilizatorilor care lucrează la computerul pe care se află fișierele, cât și utilizatorilor care accesează fișierele printr-o barieră, dacă fișierul se află într-un director care este închis pentru acces la distanță.

În NTFS, puteți seta și permisiuni pentru acces la distanță, ceea ce înseamnă permisiuni de acces la fișiere și directoare. Mai mult decât atât, atributele fișierului (doar citire, accesare, sistem) limitează și accesul la fișier.

În FAT16 și FAT32, puteți seta și atributele fișierelor, dar nu puteți asigura drepturi de acces la fișiere.

Versiunea NTFS, care este utilizată în Windows 2000, are un nou tip de permisiuni de acces - permisiuni reduse. Fila de securitate selectați opțiunea Puteți face orice modificări de la părinte pentru a propaga în ce fișier obiect, deoarece rămâne activ în mintea lui. Această opțiune accelerează semnificativ timpul în care trebuie să modificați drepturile de acces la fișiere și subdirectoare. De exemplu, pentru a schimba drepturile de acces la un arbore care conține sute de subdirectoare și fișiere, trebuie doar să activați această opțiune - în Windows NT 4 trebuie să modificați atributele fiecărui fișier și subdirector.

În fig. Figura 5 prezintă panoul de dialog Proprietăți și fila Securitate (secțiunea Avansată) - drepturile de acces la fișiere au fost extinse.

Este clar că pentru volumele FAT accesul poate fi asigurat doar pe volume egale, iar un astfel de control este posibil doar pentru acces la distanță.

Comprimarea fișierelor și directoarelor

Windows 2000 acceptă compactarea fișierelor și directoarelor situate pe volume NTFS. Aceste fișiere pot fi citite și scrise de orice program Windows. Pentru care nu este nevoie să fie despachetat mai întâi. Algoritmul de compresie este similar cu cel utilizat în DoubleSpace (MS-DOS 6.0) și DriveSpace (MS-DOS 6.22), dar are o diferență principală - sub MS-DOS comprimarea întregii secțiuni primare sau a dispozitivului logic, cum ar fi ca în NTFS Puteți împacheta mai multe fișiere și directoare.

Algoritmul de compresie NTFS este defalcat pentru a suporta clustere de până la 4 KB. Dacă dimensiunea clusterului este mai mare de 4 KB, funcțiile de compresie NTFS devin indisponibile.

NTFS cu auto-actualizare

Sistemul de fișiere NTFS se autoactualizează și își poate menține integritatea urmând protocolul de acțiuni de concatenare și alte mecanisme.

NTFS consideră o operațiune care modifică fișierele de sistem pe volume NTFS ca o tranzacție și stochează informații despre o astfel de tranzacție în protocol. Tranzacția începută poate fi complet finalizată (commit) sau poate fi abandonată (rollback). În final, NTFS trece la etapa care transferă tranzacția la început. Pentru a gestiona tranzacțiile, NTFS înregistrează toate operațiunile care fac parte dintr-o tranzacție într-un fișier de protocol care este scris pe disc. După finalizarea tranzacției, toate operațiunile sunt finalizate. În acest fel, sub NTFS nu putem avea operațiuni neterminate. În cazul defecțiunilor de disc, operațiunile neterminate sunt pur și simplu pierdute.

Sub serverele NTFS există și operațiuni care vă permit să identificați clusterele defecte „din mers” și să introduceți noi clustere pentru operațiuni cu fișiere. Acest mecanism se numește remaparea clusterului.

În acest moment, am analizat diferitele sisteme de fișiere suportate în Microsoft Windows 2000, am discutat despre caracteristicile fiecăruia dintre ele și am identificat avantajele și dezavantajele acestora. Cel mai promițător este sistemul de fișiere NTFS, care are un set mare de funcții care nu sunt disponibile în alte sisteme de fișiere. Noua versiune de NTFS, suportată de Microsoft Windows 2000, are o funcționalitate și mai mare și, prin urmare, este recomandată pentru utilizare atunci când este instalat sistemul de operare Win 2000.

ComputerPress 7"2000

GRAS(Engleză) Fişier Alocare Masa- „File Allocation Table”) este o arhitectură clasică de sistem de fișiere care, datorită simplității sale, este încă utilizată pe scară largă pentru unitățile flash. Vikorist în dischete și alte medii. Înainte jucam pe hard disk-uri.

Sistemul de fișiere a fost defalcat de Bill Gates și Mark MacDonald în 1977 și a fost folosit inițial în sistemul de operare 86-DOS. Apoi 86-DOS a fost adăugat la Microsoft și a devenit baza sistemului de operare MS-DOS 1.0, lansat în 1981. FAT este proiectat să funcționeze cu discuri mici mai mici de 1 MB și nu acceptă inițial hard disk-uri.

Este clar că există diferite versiuni de FAT - FAT8, FAT12, FAT16і FAT32. Depinde de numărul de înregistrări din structura discului, deci numărul de biți introduși pentru a salva numărul clusterului. FAT12 este folosit în principal pentru dischete, FAT16 – pentru discuri de volum mic, FAT32 – pentru hard disk. A fost dezvoltat un nou sistem de fișiere bazat pe FAT exFAT(FAT extins), care este important pentru unitățile flash.

Sistemul de fișiere FAT umple spațiul disponibil pe disc de la început până la sfârșit. Când este creat un fișier nou sau este creat unul mai mare, este găsit primul cluster mare din tabelul de alocare a fișierelor. Pe măsură ce unele fișiere sunt șterse, iar altele își schimbă dimensiunea, clusterele goale rezultate vor fi împrăștiate pe disc. Dacă clusterele care conțin date în fișier nu sunt reinstalate, fișierul apare fragmentat. Fișierele puternic fragmentate reduc semnificativ eficiența lucrării; fragmentele capului de citire/scriere sunt forțate să se deplaseze dintr-o zonă a discului în alta în timpul căutării următoarei scrieri. Este important ca clusterele văzute în fișierul salvat să dispară, pentru ca restul timpului să poată trece. Cu toate acestea, este posibil să lucrați cu programe speciale suplimentare; se numește o procedură similară defragmentare fişier.

Un număr mic de FAT sunt și cele a căror productivitate constă în numărul de fișiere care se află într-un singur director. Cu un număr mare de fișiere (aproape de mii), operațiunea de citire a listei de fișiere din catalog poate dura mult timp. FAT nu transferă salvarea informațiilor precum informații despre utilizator și acces nou la fișier.

FAT este un sistem de fișiere simplu care nu permite transferul de fișiere prin opriri anormale ale computerului; este unul dintre cele mai răspândite sisteme de fișiere și acceptă majoritatea sistemelor de operare.

Organizarea sistemului de fișiere grase

Toate sistemele de operare moderne de disc oferă un sistem de fișiere proprietar conceput pentru a stoca date pe discuri și pentru a asigura accesul la acestea. Pentru ca datele să fie scrise pe un disc, suprafața acestuia trebuie să fie structurată. divide pe sectorі poteci.

Un camion

C-cluster

Malyunok 1- Structura discului

Cărări- Acestea sunt mize concentrice care acoperă suprafața discului. Drumului cel mai apropiat de marginea discului i se atribuie numărul 0, celui de lângă acesta i se atribuie numărul 1 etc. Deoarece discheta are două fețe, ambele părți sunt numerotate. Numărul primei părți este 0, numărul celeilalte este 1.

Calea pielii este împărțită în secțiuni, care sunt numite sectoare. Sectoarele primesc și numere. Primului sector de drum i se atribuie numărul 1, celălalt - 2 etc.

Hard disk-ul este format din una sau mai multe plăci rotunde. Pentru a păstra informațiile, suprafețele ofensatoare ale plăcilor sunt protejate. Suprafața pielii este împărțită în piste, urme, cu propriul strat - în sectoare. Urmele unei noi raze sunt pliate cilindru. În acest fel, toate pistele zero sunt setate la cilindrul numărul zero, pistele numărul 1 la cilindrul numărul 1 etc.

Suprafața hard disk-ului poate fi văzută ca o matrice trivială, care include numere suprafata, cilindruі sectoare. Sub cilindru înțelegem totalitatea tuturor pistelor care se află pe diferite suprafețe și sunt la aliniament egal cu axa de înfășurare.

De fiecare dată când dorim să formatăm o unitate flash, un card SD, un hard disk extern sau intern, ne amintim că înainte de a formata oricare dintre dispozitivele de mai sus, sistemul de operare Windows trebuie să pună întotdeauna putere în orice sistem de fișiere și doriți să formatați dispozitivul: FAT32, NTFS sau exFAT?

Evident, majoritatea cumpărătorilor nu cunosc diferența dintre ei și, prin urmare, aleg opțiunea care urmează propriile reguli. Și toate acele Windows, care furnizează energie, nu explică diferența dintre ele. Acest articol va încerca să vă explice într-un mod sensibil care este diferența dintre sistemul de fișiere FAT32, NTFS și exFAT.

FAT32 Este cel mai vechi dintre sistemele de fișiere care sunt vizualizate și cel mai des folosit pe unități flash portabile - unități flash sau carduri SD.

NTFS Windows este folosit ca sistem de fișiere principal pentru discul pe care este instalat sistemul de operare și este, de asemenea, potrivit pentru alte unități și partiții de hard disk pe un computer care rulează Windows.

exFAT Este mai mult un analog modern al vechiului sistem FAT32 și acceptă mai multe dispozitive, mai puțin decât NTFS, dar încă nu este la fel de bogat ca FAT32 „clasic”.

Acum să ne uităm la raportul despre aceste sisteme de fișiere.

Sistem de fișiere FAT32

FAT32є cel mai vechi sistem de fișiere pentru aceste articole. Ea a început să se implice activ cu Windows 95 și a venit să înlocuiască sistemul, care era și mai depășit - FAT16.

Vârsta mare a acestui sistem de fișiere are avantajele și dezavantajele sale.

În acest scop, putem adăuga și faptul că FAT32 a devenit un standard și este încă folosit în toate dispozitivele moderne. Dacă cumpărați o unitate flash sau un card SD astăzi, sistemul de fișiere FAT32 va fi instalat „din fabrică”. Acest lucru a fost făcut mai ales pentru ca înlocuirea dvs. să poată fi susținută nu numai de computere și gadget-uri moderne, ci și de dispozitive mai vechi și console de jocuri care au un port USB și folosesc doar sistemul de fișiere FAT3.

Cu toate acestea, din cauza dimensiunii sistemului, există câteva probleme minore, legate în principal de dimensiunea fișierului și așa mai departe. Fiecare fișier din acest sistem de fișiere nu poate fi mai mare de 4 gigaocteți, iar întreaga partiție din sistemul de fișiere FAT32 nu poate fi mai mare de 8 teraocteți.

Și dacă încă poți accepta pe deplin un alt dezavantaj (în timp ce puțini oameni au dispozitive de stocare mai mari de 8TB), atunci limitarea dimensiunii fișierului vine cu un dezavantaj serios - mai multe videoclipuri la capacitate mare Nu mai investesc în 4GB, mai ales că miroase în formatul actual 4K.

Cu toate acestea, acest sistem de fișiere este încă pe deplin potrivit pentru dispozitive portabile (cum ar fi unități flash și carduri SD care conțin un număr de fișiere mici), dar nu este deloc potrivit pentru hard disk-ul unui computer. În Pershu Cherga, nu o cireșă a activității flappy, yaki є în bilsh de sistemele de fișiere ale Curții Constituționale ntfs, eu, prin tse vi, nu mă apropii de prăbușirea Windows la sistemul de discuri FAT32, tu au o urmă de reformatavati yoga în NTFS.

Sustenabilitate FAT32

Dispozitivele cu sistemul de fișiere FAT32 sunt cele mai universale și compatibile cu toate versiunile sistemelor de operare Windows, Mac OS, Linux, console de jocuri și aproape orice acceptă un port USB.

Schimb FAT32

Principalul dezavantaj al acestui sistem de fișiere este limitarea dimensiunii fișierului - dimensiunea maximă a fișierului nu poate depăși 4 GB, iar dimensiunea maximă a unei secțiuni nu poate depăși 8 TB.

Zastosuvannya FAT32

Zona principală a valorii sistemului de fișiere este datele de stocare externă, care nu sunt transferate pentru a salva fișiere mari și care necesită capacitate maximă datorită numărului mare de tipuri diferite Alte dispozitive.

Sistem de fișiere NTFS

NTFS- acesta este un sistem de fișiere modern și tehnologic, ceea ce să spun este decodificarea abrevierei și a numelui - " sistem de fișiere cu tehnologie nouă". Ceea ce îmi place cel mai mult este sistemul de operare Windows, ceea ce nu este surprinzător - chiar și pe cele care au fost divizate de Microsoft.

Începând cu versiunea Microsoft a sistemului de operare numită XP, în care sistemul NTFS a devenit pentru prima dată standard, atunci când este instalată caseta de dialog Windows, este obligatoriu să vă cerem să formatați partiția de sistem în acest sistem de fișiere. În acest moment, este important să rețineți că, teoretic, nu va trebui să vă faceți griji cu privire la partajarea sistemului de fișiere NTFS pentru o lungă perioadă de timp.

Pe lângă faptul că există restricții serioase cu privire la dimensiunea unui fișier și a unei partiții, NTFS are o serie de avantaje suplimentare, cum ar fi: suport pentru drepturile de acces la fișiere (pentru o securitate sporită a datelor), înregistrarea modificărilor (pentru actualizarea structurii fișierelor). în caz de eșec), criptare, cote de disc, trimitere pe hard și alte funcții zilnice, cum ar fi ca NTFS să fie ideal pentru discul de sistem.

Însăși partiția discului pe care este instalat sistemul de operare Windows este în mod necesar responsabilă pentru formatarea în NTFS. Dacă alegeți să instalați programe pe alte partiții ale aceluiași disc sau alte hard disk-uri, acestea sunt, de asemenea, vinovate pentru sistemul de fișiere de bază.

Din păcate, NTFS nu este compatibil cu majoritatea celorlalte sisteme de operare, deoarece a fost împărțit pentru aplicațiile Windows. Toate versiunile sistemului de operare Microsoft pot funcționa cu acesta, începând cu XP și terminând cu actualul Windows 10, iar alte sisteme de operare au valori diferite atunci când lucrează cu acesta.

De exemplu, Mac OS poate citi date numai de pe discuri cu sistemul de fișiere NTFS, dar nu poate scrie pe acestea. Unele distribuții Linux rare pot scrie pe discuri cu NTFS, dar cele mai multe încă partajează informații care nu pot fi citite. Ambele versiuni ale Playstation nu pot funcționa cu NTFS, cum ar fi Xbox 360 de la Microsoft, iar noul Xbox One nu acceptă acest sistem de fișiere.

Nebunia NTFS

Fișierul Qi este un sistem de vi -prazu, versiunile rămase ale operațiunilor sistemelor Windows, este clar pentru mac os і linux, și nu prazneshistu, vina XBOX ONE.

Schimb NTFS

Calculul dimensiunii fișierelor sau partițiilor în NTFS trebuie încă să intre în limite, ceea ce se poate spune că în acest moment nu există.

Zastosuvannya NTFS

Utilizarea acestui sistem de fișiere este rezonabilă doar pe hard disk-urile și SSD-urile pe care este instalat sistemul de operare Windows, dar numai cu acesta acest format își dezvăluie toate avantajele.

sistem de fișiere exFAT

exFAT a fost introdus pentru prima dată în 2008 și este cel mai actual sistem de fișiere, așa cum se vede în acest articol, iar suportul a fost adăugat la Windows începând cu versiunea XP pentru actualizări suplimentare ale sistemului de operare.

Sistemul de fișiere exFAT a fost creat și optimizat pentru utilizare pe dispozitive de stocare externe - unități flash, carduri SD și hard disk-uri externe și a înlocuit sistemul FAT32 învechit. Este cel mai ușor și mai simplu sistem de fișiere, dar există diverse caracteristici speciale care se aplică NTFS, precum și restricții privind dimensiunea fișierului și a partiției, care este FAT32.

De asemenea, exFAT este mai puțin compatibil cu diverse sisteme de operare, altele decât NTFS, iar dispozitivele cu acesta pot fi citite și rescrise minunat atât pe Windows și Mac OS, cât și pe Linux (datorită instalării unui astfel de software).

Deoarece exFAT este acceptat implicit de sistemul de operare Mac OS, este probabil acceptat de majoritatea celorlalte dispozitive actuale care funcționează cu dispozitive Apple, de exemplu, camerele digitale.

Versiunile actuale ale consolelor de jocuri, cum ar fi Xbox One și Playstation 4, acceptă și dispozitive cu sistemul de fișiere exFAT, spre deosebire de versiunile mai vechi (Xbox 360 și Playstation 3).

exFAT nebun

exFAT funcționează minunat cu toate versiunile actuale de Windows (începând cu XP) și Mac OS. Pentru a lucra cu Linux, trebuie să instalați software suplimentar. Acest sistem de fișiere acceptă multe dispozitive diferite, inclusiv NTFS, și toate (în special versiunile mai vechi) pot fi încă folosite de cei care folosesc FAT32.

exFAT

De asemenea, ca și în cazul NTFS, încă nu există limite realiste pentru dimensiunea unui fișier sau a unei partiții în sistemul exFAT.

exFAT

Acest sistem de fișiere este perfect potrivit pentru stocarea pe o varietate de medii portabile, dimensiunea fișierelor pe care poate depăși 4 GB (hard disk-uri moderne, unități flash de mare capacitate). Deoarece toate dispozitivele pe care le utilizați, inclusiv cele actuale, puteți utiliza FAT32 pe unele unități exFAT.

Puteți utiliza următoarele configurații: NTFS este ideal pentru un hard disk de sistem care rulează Windows, exFAT este mai ușor de utilizat pe medii importante, iar FAT32 este mai ușor de utilizat în modul în care doriți. obțineți eficiență maximă cu versatilitatea dispozitivelor dvs.