Изберете заявки в Access

1. Структура на сектора FSInfo struct fat_boot_fsinfo:
   • __u32 подпис1- подпис 0x41615252;
   • __u32 подпис2- подпис 0x61417272;
   • __u32 свободни_клъстери- броят на свободните клъстери. Ако полето съдържа -1, търсенето на свободни клъстери трябва да започне от клъстер номер 2.
2. Структурата на записа в директорията на краткото име struct msdos_dir_entry:
   • __s8 име, вътр- име и разширение на файла;
   • __u8 attr- файлови атрибути;
   • __u8 ctime_ms- това поле посочва времето на създаване на файла до ms (използва се само FAT32);
   • __u16 cвреме- време за създаване на файл (използва се само FAT32);
   • __u16 cdate- дата на създаване на файла (използва се само FAT32);
   • __u16 adate- дата на последния достъп до файла (използва се само FAT32);
   • __u16 starthi- високи 16 бита от номера на първия клъстер на файла (използва се само FAT32);
   • __u16 час, дата, начало- час и дата на създаване на файла, номер на първия клъстер на файла;
   • __u32 размер- размер на файла (в байтове).
3. Структура на елемент от директорията с дълго име:
   • __u8 id- Номер на артикул;
   • __u8 име0_4- знаци 1 - 5 от името;
   • __u8 attr- файлови атрибути;
   • __u8 псевдоним_контролна сума- контролна сума на краткото име;
   • __u8 име5_10- знаци 6 - 11 от името;
   • __u8 име11_12- знаци 12 - 13 от името.

Нека продължим да разглеждаме софтуерната реализация на алгоритъма и да дефинираме името на дяла, на който е създадена файловата система FAT16:

#ifndef FAT16_PART_NAME

#define FAT16_PART_NAME "/ dev / hda1"

#endif

Глобални структури:

struct fat_boot_sector fbs; // структура на зареждащия сектор

struct msdos_dir_entry dentry; // структура на елемент от директорията

Глобални променливи:

U16 * мазнини 16; // копирайте таблицата FAT16 тук

U16 сектор_размер; // размер на сектора (от FAT16)

U16 dir_entries; // брой 32-байтови дескриптори

// в основната директория (0 за FAT32)

сектори U16; // общ брой сектори в секцията

U32 fat16_size; // размер FAT16

U32 root_size; // размер на основната директория

U16 byte_per_cluster; // размер на клъстера в байтове

U16 следващ_клъстер; // следващ клъстер във веригата

вътрешност мазнини;

Нека започнем с основната функция:

int main ()

Int num;

Задаваме пълното име на файла, чието съдържание искаме да прочетем. Нека ви напомня, че работим само с кратки имена на файлове. Процедурата за работа с дълги имена не е разгледана в тази статия.

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

Отворете файла на устройството:

Твърд = отворен (FAT16_PART_NAME, O_RDONLY);

Ако (трудно< 0) {

Грешка (FAT16_PART_NAME);

Изход (-1);

Четем първите 10 клъстера от файла. Четенето се извършва от функцията fat16_read_file (). Параметрите на функцията са пълното име на файла и броят на клъстерите за четене. Функцията връща броя на прочетените клъстери или -1, ако е възникнала грешка при четене:

Брой = fat16_read_file (пълен_път, 10);

Ако (бр< 0) perror("fat16_read_file");

Else printf ("Четене% d клъстери", брой);

Затворете файла на устройството и излезте:

Затвори (твърдо);

Връщане 0;

Функцията за четене на клъстери от файлове изглежда така:

int fat16_read_file (__ u8 * пълен_път, int num)

Структура split_name sn; // структура за съхранение на съставните части на файла

U8 tmp_name_buff; // буфер за временно съхранение на съставните елементи на пълния път на файла

Статично int i = 1;

Int n;

U8 * tmp_buff;

U16 начален_клъстер, следващ_клъстер;

Изброихме параметрите на функцията, когато разглеждаме основната функция.

Подготвителни операции - нулиране на буфера tmp_name_buff и структурата struct split_name sn:

Първият знак в абсолютния път трябва да бъде наклонена черта (/). Проверяваме това:

Четем сектора за зареждане от дяла:

Ако (read_fbs ()< 0) return -1;

Секторът за четене вече е в глобалната структура fat_boot_sector fbs. Нека копираме от тази структура размера на сектора, броя на записи в основната директория и общия брой сектори в дяла:

Нека определим размера на клъстера в байтове:

Byte_per_cluster = fbs.cluster_size * 512

Нека покажем информацията в сектора за зареждане:

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

Printf ("Размер на сектор -% d", размер_сектор);

Printf ("Размер на клъстера -% d", fbs.cluster_size);

Printf ("Запазено -% d", fbs.reserved);

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

Printf ("Записи в директория -% d", dir_entries);

Printf ("Сектори -% d", сектори);

Printf ("Медия - 0x% X", fbs.media);

Printf ("FAT16 дължина -% u", fbs.fat_length);

Printf ("Общо секта -% u", fbs.total_sect);

Printf ("Байт на клъстер -% d", byte_per_cluster);

Изчислете размера на FAT16 в байтове и го прочетете:

Fat16_size = fbs.fat_length * 512;

Ако (read_fat16 ()< 0) return -1;

Четем главната директория:

Ако (read_root_dentry ()< 0) return -1;

Указателят на dir_entry вече е позициониран в областта на паметта, съдържаща записите в основната директория. Размерът на тази област на паметта е равен на размера на главната директория (root_size).

Нека запазим (за контрол) съдържанието на основната директория в отделен файл:

#ifdef ОТГРАНЯВАНЕ НА БЪГИ

Близки (мазнини);

#endif

Изчисляваме началото на областта с данни:

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

С всички записи в главната директория на място, можем да стигнем до съдържанието на файла test.txt. За целта ще организираме цикъл. В тялото на цикъла нека анализираме пълното име на файла, като подчертаем неговите елементи - поддиректории (имаме две от тях, Folder1 и Folder2) и името на необходимия файл (test.txt).

Докато (1) (

Memset (tmp_name_buff, 0, SHORT_NAME);

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

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

Ако ((tmp_name_buff [n] == "/") || (tmp_name_buff [n] == "?")) (

I ++;

Пауза;

Tmp_name_buff [n] = "?";

Попълнете структурата split_name sn с подходящата информация. Попълването се извършва от функцията split_name, докато името на файла се проверява спрямо формата "8.3":

< 0) {

Printf ("невалидно име");

Връщане -1;

За всеки елемент от пълното име на файла, ние дефинираме начален клъстер. За да направите това, потърсете в елементите на директорията (започвайки от корена) за запис, съответстващ на елемента с пълно име, и прочетете този запис. Функцията get_dentry () изпълнява процедурата за търсене:

Ако (get_dentry (& sn)< 0) {

Printf ("Няма такъв файл!");

Връщане -1;

Проверка на атрибутите на файла. Ако това е директория, прочетете съдържанието й и продължете цикъла:

Ако (dentry.attr & 0x10) (

Ако (read_directory (dentry.start)< 0) return -1;

Продължи;

Ако това е файл, прочетете първия брой клъстери. За контрол ще запазим прочетената информация в отделен файл:

Ако (dentry.attr & 0x20) (

Start_cluster = dentry.start;

Tmp_buff = (__u8 *) malloc (byte_per_cluster); // съдържанието на клъстера ще бъде прочетено тук

N = отворен ("клъст", O_CREAT | O_RDWR, 0600); // запазване на прочетената информация в този файл

Ако (n< 0) {

Perror ("отворен");

Връщане -1;

За да четем файловите клъстери, ще организираме цикъл:

За (i = 0; i< num; i++) {

Четем съдържанието на клъстера в буфера tmp_buff и го записваме в отделен файл:

< 0) return -1;

< 0) {

Perror ("пишете");

Затвори (n);

Връщане -1;

От FAT16 четем номера на следващия клъстер, зает от този файл. Ако това е последният клъстер, прекъсваме цикъла и се връщаме към основната функция:

#ifdef ОТГРАНЯВАНЕ НА БЪГИ

Printf ("OK. Прочетено");

Printf ("следващият клъстер на файла - 0x% X ..", next_cluster);

#endif

Ако (следващ_клъстер == EOF_FAT16) (

#ifdef ОТГРАНЯВАНЕ НА БЪГИ

Printf ("последен клъстер.");

#endif

Безплатно (tmp_buff);

Затвори (n);

Връщане ++ i;

#ifdef ОТГРАНЯВАНЕ НА БЪГИ

Printf ("спри да четеш");

#endif

Върнете i;

Четенето на сектора за зареждане на FAT16 се извършва от функцията read_fbs (). Резултатът се поставя в глобалната fbs структура:

int read_fbs ()

Ако (прочетете (твърдо, (__ u8 *) & fbs, sizeof (fbs))< 0) return -1;

Връщане 0;

Четенето на таблицата за разпределение на файлове на файловата система FAT16 се извършва от функцията read_fat16 ():

int read_fat16 ()

U64 търсене = (__u64) (fbs.reserved) * 512; // изместване към FAT16 от началото на дяла

Fat16 = (недействителен *) malloc (fat16_size);

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

Връщане 0;

Четенето на главната директория се извършва от функцията read_root_dentry ():

int read_root_dentry ()

U64 търсене = (__u64) fbs.reserved * 512 + fat16_size * fbs.fats; // отместване към основната директория от началото на секцията

Root_size = 32 * dir_entries; // изчисляване на размера на основната директория

Dir_entry = (__u8 *) malloc (root_size);

Ако (! Dir_entry) върне -1;

Memset (dir_entry, 0, root_size);

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

Връщане 0;

Четенето на клъстер, принадлежащ на файл, се извършва от функцията read_cluster (). Входните параметри на функцията са номера на клъстера cluster_num и указател към буфера __u8 * tmp_buff, където трябва да се постави резултатът от четенето. Отместването към клъстера в секцията се изчислява по формулата (вижте):

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

• ТЪРСЕТЕ- изместване към клъстера на дяла
• DATA_START- начало на областта с данни
• CLUSTER_NUM- пореден номер на клъстера
• BYTE_PER_CLUSTER- размер на клъстера в байтове

int read_cluster (__ u16 cluster_num, __u8 * tmp_buff)

U64 seek = (__u64) (byte_per_cluster) * (cluster_num - 2) + data_start; // изчисляване на отместването към клъстера

< 0) return -1;

Връщане 0;

Функцията read_directory чете записите в директорията (не в основната) и поставя резултата в областта на паметта, на която е зададен указателят dir_entry:

int read_directory (__ u16 start_cluster)

Int i = 1;

U16 следващ_клъстер;

За (;; i ++) (

Разпределяме памет за съхраняване на съдържанието на директорията, четем съдържанието на началния клъстер и получаваме стойността на следващия клъстер от таблицата FAT16:

Ако (! Dir_entry) върне -1;

< 0) return -1;

Следващ_клъстер = fat16;

Нека запишем съдържанието на директорията в отделен файл (за контрол):

#ifdef ОТГРАНЯВАНЕ НА БЪГИ

Printf ("Следващ клъстер - 0x% X", следващ_клъстер);

Fat = отворен ("dir16", O_CREAT | O_WRONLY, 0600);

Напишете (fat, dir_entry, root_size);

Близки (мазнини);

#endif

Ако се достигне последният клъстер, излезте от цикъла, в противен случай продължете да четете директорията, увеличавайки размера на буфера dir_entry с още един клъстер:

Ако (следващ_клъстер и EOF_FAT16) се повреди;

Начален_клъстер = следващ_клъстер;

Връщане 0;

Функцията get_dentry () търси в съдържанието на директорията елемент, който съответства на файла, който търсите. Входните данни за тази функция са указател към структура split_name * sn, съдържаща елементите на краткото име на файл:

Int i = 0;

Глобалният буфер dir_entry съдържа масив от записи в директорията, в които ще търсим запис на файл (или директория). За търсене ще организираме цикъл. В тялото на цикъла копирайте записите в директорията в глобалната структура на dentry и сравнете стойността на полетата name и ext на тази структура със съответните полета на структурата struct split_name * sn. Съвпадението на тези полета означава, че открихме записа на необходимия файл в масива от каталожни елементи:

за (;; i ++) (

Ако (! (Memcmp (dentry.name, sn-> name, sn-> name_len)) &&

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

Пауза;

Ако (! Dentry.name) върне -1;

#ifdef ОТГРАНЯВАНЕ НА БЪГИ

Printf ("име -% s", dentry.name);

Printf ("стартов клъстер - 0x% X", dentry.start);

Printf ("размер на файла -% u", dentry.size);

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

#endif

Връщане 0;

Целият код по-горе се намира в директорията FAT16, файл fat16.c. За да получите изпълнимия модул, създайте Makefile със следното съдържание:

INCDIR = / usr / src / linux / включва

ФОНИЯ = чист

Fat16: fat16.o split.o

Gcc -I $ (INCDIR) $ ^ -g -o [защитен с имейл]

% .o: % .c

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

чисти:

Rm -f * .o

Rm -f ./fat16

Софтуерна реализация на алгоритъма за четене на файл от логически дял с файловата система FAT12

Като цяло, алгоритъмът за четене на файл от FAT12 дял е идентичен с алгоритъма за четене на файл от FAT16 дял. Разликата е в процедурата за четене на елементи от таблицата FAT12. Ние разглеждахме таблицата FAT16 като прост масив от 16-битови елементи. Предлага се следният алгоритъм за четене на елементи от таблицата FAT12:

• умножете номера на елемента по 1,5;
• извличане на 16-битова дума от FAT, използвайки резултата от предишната операция като отместване;
• ако номерът на елемента е четен, извършете операцията И върху прочетената дума и маска 0x0FFF. Ако числото е нечетно, изместете прочетената дума от таблицата с 4 бита към най-малките битове.

Въз основа на този алгоритъм ще реализираме функцията за четене на елементи от таблицата FAT12:

int get_cluster (__ u16 cluster_num)

U16 търсене;

U16 куп;

Изчислете отместването в таблицата FAT12 и прочетете 16-битовата дума от таблицата:

Търсене = (номер_клъстер * 3) / 2;

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

Ако началният номер на клъстера е четно число, изместваме прочетената стойност от таблицата с 4 бита към по-ниските цифри, ако е нечетна, я добавяме към 0x0FFF:

Ако (cluster_num% 2) клъст >> = 4;

Друга група & = 0x0FFF;

Този фрагмент може да бъде реализиран и в асемблер:

"xorw %% ax, %% ax"

"btw $ 0, %% cx"

"jnc 1f"

"shrw $ 4, %% dx"

"jmp 2f"

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

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

: "= a" (следващ)

: "d" (клъст), "c" (номер_клъстер));

Връщаме резултата:

Обратна група;

Нека се спрем малко повече на самия алгоритъм. Да приемем, че файл е създаден на FAT12 дял, който заема 9-ия и 10-ия клъстер. Всеки FAT12 елемент е с дължина 12 бита. Защото четем 16-битови елементи от таблицата, тогава отместването към 9-ия елемент ще бъде 13 байта (9 * 1,5 = 13, изхвърляме остатъка), докато най-малко значимите 4 бита ще принадлежат на 8-ия елемент на FAT. Те трябва да бъдат изхвърлени и за това е достатъчно прочетеният елемент да се измести с 4 бита към по-ниските цифри, което се осигурява от алгоритъма. Отместването към 10-ия елемент ще бъде 15 байта, а най-значимите 4 бита ще принадлежат на 11-ия елемент на FAT. За да ги изхвърлите, е необходимо да извършите операцията И върху 10-ия елемент и маската 0x0FFF, която също отговаря на горния алгоритъм.

Изходните кодове на модула за четене на файла от FAT12 дяла се намират в директорията FAT12, файл fat12.c.

Софтуерна реализация на алгоритъма за четене на файл от логически дял с файловата система FAT32

Алгоритъмът за четене на файл от дял с файловата система FAT32 практически не се различава от алгоритъма за FAT16, с изключение на това, че при FAT32 главната директория може да се намира навсякъде в дяла и да бъде с произволен размер. Затова, за да стане по-интересно, нека усложним задачата – да приемем, че знаем само номера на дяла с файловата система FAT32. За да прочетете информация от този раздел, първо трябва да определите неговите координати - отместването към секцията от началото на диска. И за това трябва да имате представа за логическата структура на твърдия диск.

Логическа структура на твърдия диск

Помислете за логическата структура на твърдия диск, който отговаря на стандарта на Microsoft - "главен дял - разширен дял - дялове извън DOS".

Пространството на твърдия диск може да бъде организирано като един или повече дялове, а дяловете могат да съдържат едно или повече логически устройства.

Твърдият диск с физически адрес 0-0-1 съдържа главния запис за зареждане (MBR). Структурата на MBR съдържа следните елементи:

• несистемно зареждане (NSB);
• таблица с описание на дялове на диска (таблица на дялове, PT). Намира се в MBR при отместване 0x1BE и заема 64 байта;
• MBR подпис. Последните два байта на MBR трябва да съдържат числото 0xAA55.

Таблицата на дяловете описва местоположението и характеристиките на наличните дялове на твърдия диск. Дисковите дялове могат да бъдат два вида - първични и разширени. Максималният брой първични дялове е четири. Задължително е да имате поне един първичен дял на диска. Разширеният дял може да бъде разделен на голям брой подсекции - логически устройства. Опростена структура на MBR е показана в Таблица 7. Таблицата на дяловете се намира в края на MBR, 16 байта са разпределени за описанието на дяла в таблицата.

Таблица 7. Структура на MBR

пристрастие Размер, байтове 0 446 0x1BE 16 0x1CE 16 0x1DE 16 0x1EE 16 0x1FE 2

Структурата на записа на записа в таблицата на дяловете е показана в Таблица 8.

Таблица 8. Структура на записа на елемента на таблицата на дяловете

Първият байт в елемента на секцията е флагът за активност на секцията (0 - неактивен, 0x80 - активен). Той служи за определяне дали дялът е системен за стартиране и дали има нужда от зареждане на операционната система от него при стартиране на компютъра. Само една секция може да бъде активна. Активният флаг на дяла е последван от координатите на началото на дяла - три байта, което означава номер на главата, номер на сектор и номер на цилиндъра. Номерата на цилиндъра и секторите са посочени във формата за прекъсване Int 0x13, т.е. битове 0-5 съдържат номера на сектора, битове 6-7 са най-значимите два бита от 10-битовия номер на цилиндъра, а битовете 8-15 са осем най-малко значими бита от номера на цилиндъра. Това е последвано от системния идентификатор, който идентифицира операционната система за този дял. Идентификаторът е един байт. Зад системния идентификатор се намират координатите на края на секцията - три байта, съдържащи съответно номерата на главата, сектора и цилиндъра. Следващите четири байта са броят на секторите преди дяла, а последните четири байта са размерът на дяла в сектори.

По този начин елемент от таблицата на разделите може да бъде описан със следната структура:

структура pt_struct (

U8 зареждащ; // флаг за активност на раздел

U8 начална_част; // координати на началото на участъка

U8 тип_част; // системен идентификатор

U8 крайна_част; // координати на края на секцията

U32 sect_before; // брой сектори преди секцията

U32 sect_total; // размер на дяла в сектори (брой сектори в дяла)

Елементът на основния дял сочи директно към сектора за зареждане на логическия диск (винаги има само един логически диск в първичния дял), а елементът на разширения дял сочи към списък с логически дискове, съставен от структури, наречени вторични MBR (SMBR).

Всеки диск на разширения дял има собствен SMBR блок. SMBR има структура, подобна на MBR, но няма запис за зареждане (запълнен с нули) и се използват само две от четирите полета за дескриптор на дял. Първият елемент на дяла сочи към логическия диск, вторият елемент сочи към следващата SMBR структура в списъка. Последният SMBR от списъка съдържа кода на нулевата секция във втория елемент.

Нека се върнем към модула за четене на файл от FAT32 дял.

Заглавни файлове:

#включи

#включи

#включи

#включи

#включи

MBR подпис:

#define ПОДПИС 0xAA55

Файл на устройството, от който ще се чете информация за дяловете:

#define DEVICE "/ dev / hda"

Размер на елемента на таблицата с дялове (16 байта):

#define PT_SIZE 0x10

Следният масив от структури задава съответствието между кода на типа раздел и неговото символно представяне:

структурни системни типове (

U8 тип_част;

U8 * име на частта;

struct systypes i386_sys_types = (

(0x00, "Празно"),

(0x01, "FAT12"),

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

(0x05, "Разширено"),

(0x06, "FAT16"),

(0x0b, "Win95 FAT32"),

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

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

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

(0x82, "размяна на Linux"),

(0x83, "Linux"),

(0x85, "Linux разширен"),

(0x07, "HPFS / NTFS")

Определете броя на елементите в масива i386_sys_types с помощта на макроса PART_NUM:

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

Нека зададем ограничение за броя на логическите дискове:

#define MAX_PART 20

Следният структурен масив ще съдържа информация за логически дискове на устройството (твърд диск):

структура pt_struct (

U8 зареждащ;

U8 начална_част;

U8 тип_част;

U8 крайна_част;

U32 sect_before;

U32 sect_total;

) pt_t;

int трудно; // файлов дескриптор на устройството

U8 mbr; // пребройте MBR тук

Номер на дяла, на който е създадена файловата система FAT32:

#define FAT32_PART_NUM 5

Зареждащият сектор, секторът FSInfo и структурите за вписване в каталог (дефинирани във файла ):

struct fat_boot_sector fbs;

struct fat_boot_fsinfo fsinfo;

struct msdos_dir_entry dentry;

U32 * fat32 = NULL; // копирайте таблицата FAT32 тук

U16 сектор_размер; // размер на сектора (от FAT32)

U16 dir_entries; // 0 за FAT32

сектори U16; // брой сектори на дял

U32 fat32_size; // размер FAT32

U32 начало_данни; // начало на областта с данни

U16 byte_per_cluster; // колко байта има в клъстера (размер на клъстера в байтове)

U32 следващ_клъстер; // следващ клъстер във веригата

U32 root_cluster; // ROOT cluster - начален коренен клъстер

U8 * dir_entry = NULL; // указател към записи в директорията

U64 start_seek = 0; // начално отместване към секция (в байтове)

Главна функция:

int main ()

Int брой = 0;

Int cluster_num = 5; // колко клъстера да прочетем от файла

U8 * full_path = "/ Папка1 / Папка2 / readme"; // файл за четене

Отваряме устройството, получаваме информация за таблицата на дяловете на устройството и показваме информация за дяловете:

Твърд = отворен (DEV_NAME, O_RDONLY);

Ако (трудно< 0) {

Грешка (DEV_NAME);

Изход (-1);

Ако (get_pt_info (трудно)< 0) {

Грешка ("get_pt_info");

Изход (-1);

Show_pt_info ();

Изчисляваме началното отместване за секцията:

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

Четем клъстерите, принадлежащи към файла:

Брой = fat32_read_file (пълен_път, номер_клъстер);

Ако (бр< 0) perror("fat32_read_file");

Else printf ("Прочетени% d клъстери \ n", брой);

Затвори (твърдо);

Връщане 0;

Информацията за таблицата на дяловете се чете от функцията get_pt_info ():

int get_pt_info (int hard)

Int i = 0;

U64 търсене;

Четем таблицата на дяловете от MBR и проверяваме подписа:

Read_main_ptable (твърдо);

Ако (check_sign ()< 0) {

Printf ("Невалиден подпис! \ N");

Връщане -1;

Търсим идентификатора на разширения раздел. Ако има такъв, изчисляваме отместването към разширения дял и четем информацията за логическите дискове:

за (; i< 4; i++) {

Ако ((pt_t [i] .type_part == 0xF) || \

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

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

Търсене = (__u64) pt_t [i] .sect_before * 512;

Read_ext_ptable (трудно, търсене);

Пауза;

Връщане 0;

Функция Read_main_ptable () за четене на таблицата на дяловете:

void read_main_ptable (int hard)

Ако (прочетете (твърдо, mbr, 512)< 0) {

Грешка ("четене");

Затвори (твърдо);

Изход (-1);

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

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

Връщане;

Функция за проверка на подписа check_sign ():

int check_sign ()

U16 знак = 0;

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

#ifdef ОТГРАНЯВАНЕ НА БЪГИ

Printf ("Подпис - 0x% X \ n", знак);

#endif

Ако (знак! = ПОДПИС) върнете -1;

Връщане 0;

Функция за четене на разширената таблица на дяловете:

void read_ext_ptable (int hard, __u64 seek)

Int брой = 4; // започвайки от тази позиция, масивът от pt_t структури ще бъде изпълнен с информация за логически дискове

U8 smbr;

Входни данни:

• трудно- файлов дескриптор на устройството;
• търси- отместване към разширения дял от началото на диска (в байтове).

За да получим информация за логически дискове, ние организираме цикъл:

За (;; num ++) (

Четем SMBR, разположен в търсенето на отместване от началото на диска:

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

Pread64 (твърдо, smbr, 512, търсене);

Попълваме два елемента от таблицата pt_t, започвайки от позиция номер. Първият елемент ще сочи към логическото устройство, а вторият към следната SMBR структура:

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

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

Правим поправка в полето "Номер на началния сектор" - броенето е от началото на диска:

Pt_t.sect_before + = (търси / 512);

Ако кодът на типа на дяла е нула, тогава няма повече логически устройства:

Ако (! (Pt_t.type_part)) прекъсва;

Изчислете отместването към следващия SMBR:

Търсене = ((__u64) (pt_t.sect_before + pt_t.sect_total)) * 512;

Връщане;

Функцията show_pt_info () показва информация за намерените логически устройства на устройството:

void show_pt_info ()

Int i = 0, n;

#ifdef ОТГРАНЯВАНЕ НА БЪГИ

Printf ("Брой дялове на диска -% d \ n", PART_NUM);

#endif

За (; i< MAX_PART; i++) {

Ако (! Pt_t [i] .type_part) прекъсва;

Printf ("\ nТип на секция% d -", i);

За (n = 0; n< PART_NUM; n++) {

Ако (pt_t [i] .type_part == i386_sys_types [n] .part_type) (

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

Пауза;

Ако (n == PART_NUM) printf ("неизвестен тип \ n");

Printf ("Знакът за стартиране - 0x% X \ n", pt_t [i] .bootable);

Printf ("Сектори в секция% d -% d \ n", i, pt_t [i] .sect_total);

Printf ("Сектори преди раздел% d -% d \ n \ n", i, pt_t [i] .sect_before);

Връщане;

Четенето на файлови клъстери от FAT32 дял се извършва от функцията fat32_read_file (). Тази функция има много общо с функцията fat16_read_file (), така че вижте раздел 6 за подробни коментари:

int fat32_read_file (__ u8 * пълен_път, int num)

Структура split_name sn;

U8 tmp_name_buff;

Int i = 1, n;

U32 начален_клъстер, следващ_клъстер;

U8 * tmp_buff;

Подготвителни операции - изчистете буфера, структурата и проверете първата наклонена черта:

Memset (tmp_name_buff, 0, SHORT_NAME);

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

Ако (пълен_път! = "/") Връщане -1;

Четем сектора за зареждане:

Ако (read_fbs ()< 0) return -1;

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

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

Memcpy ((void *) & сектори, (void *) fbs.sectors, 2);

Четем структурата FSInfo и показваме подписа, съдържащ се в нея:

Ако (read_fs_info ()< 0) return -1;

Printf ("Подпис1 - 0x% X \ n", fsinfo.signature1);

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

Fat32_size = fbs.fat32_length * 512; // FAT32 размер в байтове

Data_start = 512 * fbs.reserved + fat32_size * 2; // начало на полето с данни

Byte_per_cluster = fbs.cluster_size * 512; // размер на клъстера в байтове

Root_cluster = fbs.root_cluster; // номер на клъстера на основната директория

Четем FAT32:

Ако (read_fat32 ()< 0) return -1;

Разпределете памет за записи в директорията:

Dir_entry = (__u8 *) malloc (byte_per_cluster);

Ако (! Dir_entry) върне -1;

Четем главната директория:

Ако (директория за четене (корен_клъстер)< 0) return -1;

Анализираме пълния път на файла и разделяме всеки елемент на неговите компоненти:

Докато (1) (

Memset (tmp_name_buff, 0, SHORT_NAME);

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

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

Tmp_name_buff [n] = пълен_път [i];

Ако ((tmp_name_buff [n] == "/") || (tmp_name_buff [n] == "\ 0")) (

I ++;

Пауза;

Tmp_name_buff [n] = "\ 0";

Ако (split_name (tmp_name_buff, & sn)< 0) {

Printf ("невалидно име \ n");

Връщане -1;

Ако (get_dentry (& sn)< 0) {

Printf ("Няма такъв файл! \ N");

Връщане -1;

За да получите началния номер на клъстер във файловата система FAT32, трябва да използвате най-значимата дума от номера на първия клъстер на файла - полето starthi на структурата на dentry:

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

Проверка на байта на атрибута:

Ако (dentry.attr & 0x10) (// това е директория

Ако (директория за четене (начален_клъстер)< 0) return -1;

Продължи;

Ако (dentry.attr & 0x20) (// и това е файл

Tmp_buff = (__u8 *) malloc (byte_per_cluster);

N = отворен ("клъст", O_CREAT | O_RDWR, 0600);

Ако (n< 0) {

Perror ("отворен");

Връщане -1;

Printf ("първият клъстер на файла - 0x% X ..", start_cluster);

За (i = 0; i< num; i++) {

Memset (tmp_buff, 0, byte_per_cluster);

Ако (read_cluster (start_cluster, tmp_buff)< 0) return -1;

Ако (пишете (n, tmp_buff, byte_per_cluster)< 0) {

Perror ("пишете");

Връщане -1;

Ако (следващ_клъстер == EOF_FAT32) (

Безплатно (tmp_buff);

Затвори (n);

Връщане ++ i;

Начален_клъстер = следващ_клъстер;

Върнете i;

Целта на следващите три функции е да получат съдържанието на системната област, т.е. зареждащ сектор, структура FSInfo и таблица FAT32:

1) функцията read_fbs () чете сектора за зареждане:

int read_fbs ()

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

Връщане 0;

2) функцията read_fs_info () чете структурата FSInfo:

int read_fs_info ()

U64 търсене = (__u64) fbs.info_sector * 512 + start_seek;

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

Връщане 0;

3) функцията read_fat32 () чете таблицата FAT32:

int read_fat32 ()

U64 търсене = (__u64) fbs.reserved * 512 + start_seek;

Fat32 = (void *) malloc (fat32_size);

Ако (! Fat32) върне -1;

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

Връщане 0;

Функцията read_cluster () чете клъстера с посочения номер:

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;

Връщане 0;

Четенето на директории (включително основната) се обработва от функцията read_directory ():

int read_directory (__ u32 start_cluster)

Int i = 2;

U32 следващ_клъстер;

Параметри на функцията - начален клъстер на директории. Ние четем съдържанието на директорията в глобалния буфер dir_entry:

Ако (read_cluster (start_cluster, dir_entry)< 0) return -1;

Следващ_клъстер = fat32;

Ако директорията заема един клъстер - излезте, ако не - увеличете размера на паметта и продължете да четете:

За (;; i ++) (

Начален_клъстер = следващ_клъстер;

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

Ако (! Dir_entry) върне -1;

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

Следващ_клъстер = fat32;

Ако ((следващ_клъстер == EOF_FAT32) || (следващ_клъстер == 0xFFFFFF8)) върне 0;

Връщане 0;

Последната функция, която ще разгледаме, търси в съдържанието на директория елемент, който съответства на файла, който търсите:

int get_dentry (struct split_name * sn)

Int i = 0;

Показателят dir_entry е настроен на област от паметта, съдържаща масив от записи в директорията, в която ще търсим файл (или директория). За търсене организираме цикъл и поставяме намерения запис в глобалната структура на dentry:

За (;; i ++) (

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

Ако (! (Memcmp (dentry.name, sn-> name, sn-> name_len)) &&

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

Пауза;

Ако (! Dentry.name) върне -1;

Връщане 0;

С това приключваме прегледа на модула за четене на файл от FAT32 дял.

Изходните кодове на модула се намират в директорията FAT32, файл fat32.c.

Разлики в организацията на съхранение на файлови записи в директории за файлови системи FAT и EXT2

Няколко думи за разликите в организацията на съхранение на файлови записи в директории за файлови системи FAT и EXT2. Структурата на файловата система EXT2 беше обсъдена в.

Току-що се запознахме с FAT - в него всички елементи на каталога имат фиксиран размер. Когато създава файл, драйверът на файловата система търси първата незаета позиция и я запълва с информация за файла. Ако дължината на директорията не се побира в един клъстер, тогава за нея се разпределя друг клъстер и т.н.

Да видим как стоят нещата в EXT2.

Да предположим, че имаме дял с файловата система EXT2, размерът на блока е 4096 байта. В този раздел създаваме директория. Размерът на директорията ще бъде равен на размера на блока - 4096 байта. Операционната система веднага създава два записа в директорията - записът за текущата директория и записът за родителската директория. Текущият запис в директорията ще отнеме 12 байта, докато родителският запис ще бъде 4084 байта. Нека създадем файл в тази директория. След това директорията ще съдържа три записа - текущият запис в директорията е с дължина 12 байта, записът в родителската директория вече е дълъг 12 байта, а създаденият файл е, както вероятно се досещате, дълъг 4072 байта. Ако изтрием създадения файл, дължината на записа в родителската директория отново ще нарасне до 4084 байта.

По този начин, когато създава файл, драйверът на файловата система EXT2 търси в директорията запис с максимална дължина и го разделя, оставяйки място за нов запис. Е, ако все пак няма достатъчно място, за директорията се разпределя още един блок и дължината на директорията става равна на 8192 байта.

И в заключение - малка корекция към статията "Архитектура на файловата система EXT2".

Тази ревизия се отнася до функцията get_i_num () за определяне на номера на inode по име на файл. Старата версия на тази функция изглеждаше така:

int get_i_num (char * име)

Int i = 0, rec_len = 0;

Структура ext2_dir_entry_2 вдлъбнатина;

За (; i< 700; i++) {

Ако (! Memcmp (dent.name, name, dent.name_len)) прекъсва;

Rec_len + = dent.rec_len;

Връщане на dent.inode;

Коригирана версия:

int get_i_num (char * име)

* Параметър на функцията - име на файла. Връщаната стойност е номерът на inode на файла.

Int rec_len = 0;

Структура ext2_dir_entry_2 вдлъбнатина; // тази структура описва формата на записа в основната директория:

* Глобалният buff съдържа масив от записи в директорията. За да определите серийния номер на inode на файла, трябва да намерите

* в този масив, запис с името на този файл. За да направите това, ще организираме цикъл:

За (;;) (

/ * Копирайте записи в директорията в структурата на вдлъбнатината: * /

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

* Дължината на името на файла, равна на нула, означава, че сме изброили всички записи в директорията

* и записи с името на нашия файл не бяха намерени. Така че е време да се върнем:

Ако (! Dent.name_len) върне -1;

/ * Търсенето се извършва чрез сравняване на имена на файлове. Ако имената съвпадат, излезте от цикъла: * /

Ако (! Memcmp (dent.name, name, strlen (name))) break;

/ * Ако имената не съвпадат, преминете към следващия запис: * /

Rec_len + = dent.rec_len;

/ * Ако е успешно, върнете номера на inode на файла: * /

Връщане на dent.inode;

литература:

1. В. Кулаков. Хардуерно програмиране: Специална справка. 2-ро изд. / - SPb .: Петър, 2003 - 848 с.
2. А. В. Гордеев, А. Ю. Молчанов. Системен софтуер / - SPb .: Петър - 2002
3. Мешков В. Архитектура на файловата система ext2. - сп. "Системен администратор", бр. 11 (12), ноември 2003 г. - 26-32 с.

Във връзка с

Файловата система FAT16 датира от преди MS-DOS и се поддържа от всички операционни системи на Microsoft за съвместимост. Името му File Allocation Table перфектно отразява физическата организация на файловата система, чиито основни характеристики включват факта, че максималният размер на поддържан том (твърд диск или дял на твърдия диск) не надвишава 4095 MB. В дните на MS-DOS твърдите дискове от 4 GB изглеждаха като невероятна мечта (20-40 MB бяха лукс), така че този марж беше напълно оправдан.

Том, форматиран за използване на FAT16, е разделен на клъстери. Размерът на клъстера по подразбиране зависи от размера на тома и може да варира от 512 байта до 64 KB. Таблица Фигура 2 показва как размерът на клъстера зависи от размера на обема. Имайте предвид, че размерът на клъстера може да бъде различен от стандартния, но трябва да бъде една от стойностите, показани в таблицата. 2.

Не се препоръчва използването на файловата система FAT16 на обеми по-големи от 511 MB, тъй като дисковото пространство ще се използва изключително неефективно за относително малки файлове (файл от 1 байт ще заеме 64 KB). Независимо от размера на клъстера, файловата система FAT16 не се поддържа за обеми по-големи от 4 GB.

Започвайки с Microsoft Windows 95 OEM Service Release 2 (OSR2), към Windows беше добавена поддръжка на 32-битова FAT. За системи, базирани на Windows NT, тази файлова система се поддържа за първи път в Microsoft Windows 2000. Докато FAT16 може да поддържа обеми до 4GB, FAT32 може да обработва обеми до 2TB. Размерът на клъстера във FAT32 може да варира от 1 (512 байта) до 64 сектора (32 KB). Стойностите на клъстера FAT32 изискват 4 байта за съхранение (32 бита, а не 16, както в FAT16). Това означава по-специално, че някои файлови помощни програми, предназначени за FAT16, не могат да работят с FAT32.

Основната разлика между FAT32 и FAT16 е, че размерът на логическия дял на диска се е променил. FAT32 поддържа обеми до 127GB. В същото време, ако използването на FAT16 с 2 GB дискове изисква 32 KB клъстер, то във FAT32 клъстер от 4 KB е подходящ за дискове от 512 MB до 8 GB (Таблица 4).

Това съответно означава по-ефективно използване на дисковото пространство – колкото по-малък е клъстерът, толкова по-малко място е необходимо за съхранение на файла и в резултат на това дискът става по-малко фрагментиран.

Когато използвате FAT32, максималният размер на файла може да бъде до 4 GB минус 2 байта. Докато се използва FAT16, максималният брой записи в основната директория беше ограничен до 512, след това FAT32 позволява този брой да бъде увеличен до 65 535.

FAT32 налага ограничения върху минималния размер на тома - той трябва да бъде най-малко 65 527 клъстера. В същото време размерът на клъстера не може да бъде такъв, че FAT да заема повече от 16 MB – 64 KB / 4 или 4 милиона клъстера.

Когато използвате дълги имена на файлове, данните, необходими за достъп от FAT16 и FAT32, не се припокриват. Когато се създаде файл с дълго име на файл, Windows създава съответно име 8.3 и един или повече записа в директорията за съхраняване на дългото име (13 знака от дългото име на файла за всяко събитие). Всяко следващо събитие съхранява съответната част от името на файла във формат Unicode. Такива записи имат атрибутите "идентификатор на тома", "само за четене", "система" и "скрит" - набор, който се игнорира от MS-DOS; в тази операционна система файлът е достъпен от неговия "псевдоним" във формат 8.3.

Microsoft Windows 2000 включва поддръжка за новата версия на файловата система NTFS, която по-специално осигурява работа с директорийни услуги на Active Directory, точки за повторна обработка, инструменти за информационна сигурност, контрол на достъпа и редица други функции.

Както при FAT, основната единица информация в NTFS е клъстерът. Таблица 5 показва размерите на клъстерите по подразбиране за обеми с различен капацитет.

Когато файловата система NTFS е изградена, формататорът създава файл с основна файлова таблица (MTF) и други области за съхранение на метаданни. Метаданните се използват от NTFS за реализиране на файловата структура. Първите 16 записа в MFT са запазени от самата NTFS. Местоположението на файловете с метаданни $ Mft и $ MftMirr се записва в сектора за зареждане на диска. Ако първият запис в MFT е повреден, NTFS чете втория запис, за да намери копие на първия. Пълно копие на сектора за зареждане се намира в края на тома. Таблица 6 изброява основните метаданни, съхранявани в MFT.

Останалите MFT записи съдържат записи за всеки файл и директория, разположени в даден том.

Обикновено един файл използва един запис в MFT, но ако файлът има голям набор от атрибути или стане твърде фрагментиран, тогава може да са необходими допълнителни записи за съхраняване на информация за него. В този случай първият запис във файла, наречен основен запис, съхранява местоположението на другите записи. Малките файлове и директории (до 1500 байта) се съдържат изцяло в първия запис.

Всеки зает сектор в NTFS том принадлежи на един или друг файл. Дори метаданните на файловата система са част от файла. NTFS третира всеки файл (или директория) като набор от файлови атрибути. Елементи като името на файла, информацията за сигурността и дори данните в него са атрибути на файла. Всеки атрибут се идентифицира с специфичен код на типа и, по избор, име на атрибут.

Ако файловите атрибути се вписват във файлов запис, те се наричат ​​резидентни атрибути. Тези атрибути винаги са името на файла и датата на създаването му. В случаите, когато информацията за даден файл е твърде голяма, за да се побере в един MFT запис, някои от атрибутите на файла стават нерезидентни. Резидентните атрибути се съхраняват в един или повече клъстери и представляват поток от алтернативни данни за текущия обем (повече за това по-долу). NTFS създава атрибут Attribute List, за да опише местоположението на резидентни и нерезидентни атрибути.

Таблица 7 показва основните файлови атрибути, дефинирани в NTFS. Този списък може да бъде разширен в бъдеще.

Windows 2000 осигурява поддръжка за файловата система CDFS, която отговаря на стандарта ISO'9660 за местоположението на информация на CD-ROM. Дългите имена на файлове се поддържат според ISO'9660 ниво 2.

Когато създавате CD-ROM за използване под Windows 2000, имайте предвид следното:

• всички имена на директории и файлове трябва да са по-малко от 32 знака;
• всички имена на директории и файлове трябва да съдържат само главни букви;
• дълбочината на директорията не трябва да надвишава 8 нива от корена;
• използването на разширения за имена на файлове не е задължително.

Сравнение на файлови системи

Microsoft Windows 2000 може да използва FAT16, FAT32, NTFS или техните комбинации. Изборът на операционна система зависи от следните критерии:

• как се използва компютърът;
• хардуерна платформа;
• размера и броя на твърдите дискове;
• информационна сигурност

FAT файлови системи

Както може би сте забелязали, числата в имената на файловите системи - FAT16 и FAT32 - показват броя на битовете, необходими за съхраняване на информация за номерата на клъстерите, използвани от файла. Така че във FAT16 се използва 16-битово адресиране и съответно е възможно да се използват до 2-16 адреса. В Windows 2000 първите четири бита от таблицата за местоположение на файловете FAT32 са необходими за тяхна собствена употреба, така че във FAT32 броят на адресите достига 2 28.

Таблица 8 показва размерите на клъстерите за файлови системи FAT16 и FAT32.

В допълнение към значителните разлики в размера на клъстера, FAT32 също така позволява на главната директория да се разшири (FAT16 ограничава броя на записи до 512 и дори може да бъде по-нисък при използване на дълги имена на файлове).

Предимства на FAT16

Сред предимствата на FAT16 са следните:

• файловата система се поддържа от MS-DOS, Windows 95, Windows 98, Windows NT, Windows 2000, както и някои операционни системи UNIX;
• има голям брой програми, които ви позволяват да коригирате грешки в тази файлова система и да възстановите данни;
• ако има проблеми със зареждането от твърдия диск, системата може да се зареди от флопи диск;
• тази файлова система е достатъчно ефективна за обеми под 256 MB.

Недостатъци на FAT16

Основните недостатъци на FAT16 включват:

• основната директория не може да съдържа повече от 512 записа. Използването на дълги имена на файлове драстично намалява броя на тези елементи;
• FAT16 поддържа максимум 65 536 клъстера и тъй като някои клъстери са запазени от операционната система, броят на наличните клъстери е 65 524. Всеки клъстер е с фиксиран размер за даден LUN. Когато максималният брой клъстери бъде достигнат при максималния им размер (32 KB), максималният поддържан обем е 4 GB (под Windows 2000). За да се поддържа съвместимост с MS-DOS, Windows 95 и Windows 98, обемът под FAT16 не трябва да надвишава 2 GB;
• FAT16 не поддържа вградена защита и компресиране на файлове;
• големите дискове се губят с много място чрез използване на максималния размер на клъстера. Мястото за файла се разпределя въз основа на размера не на файла, а на клъстера.

Предимства на FAT32

Сред предимствата на FAT32 са следните:

• разпределението на дисковото пространство е по-ефективно, особено за големи дискове;
• главната директория във FAT32 е редовна верига от клъстери и може да се намира навсякъде на диска. Поради това FAT32 не налага никакви ограничения върху броя на елементите в основната директория;
• поради използването на по-малки клъстери (4 KB на дискове до 8 GB), заетото дисково пространство обикновено е с 10-15% по-малко, отколкото при FAT16;
• FAT32 е по-надеждна файлова система. По-специално, той поддържа възможността за преместване на основната директория и използване на резервно копие на FAT. Освен това записът за зареждане съдържа редица данни, които са критични за файловата система.

Недостатъци на FAT32

Основните недостатъци на FAT32:

• размерът на тома при използване на FAT32 под Windows 2000 е ограничен до 32 GB;
• FAT32 томовете не са достъпни от други операционни системи - само от Windows 95 OSR2 и Windows 98;
• Архивиране на сектора за стартиране не се поддържа;
• FAT32 не поддържа вградена защита и компресиране на файлове.

Файлова система NTFS

Когато работите в Windows 2000, Microsoft препоръчва форматиране на всички дялове на твърдия диск за NTFS, с изключение на онези конфигурации, когато се използват няколко операционни системи (с изключение на Windows 2000 и Windows NT). Използването на NTFS вместо FAT ви позволява да използвате функциите, налични в NTFS. Те включват по-специално:

• възможността за възстановяване. Тази възможност е вградена във файловата система. NTFS гарантира безопасността на данните поради факта, че използва протокола и някои алгоритми за възстановяване на данни. В случай на системна повреда, NTFS използва протокола и допълнителна информация за автоматично възстановяване на целостта на файловата система;
• компресиране на информация. За NTFS томове, Windows 2000 поддържа компресиране на отделни файлове. Такива компресирани файлове могат да се използват от Windows приложения без предварително разопаковане, което се случва автоматично при четене от файл. Когато се затвори и запази, файлът се компресира отново;
• в допълнение могат да се подчертаят следните предимства на NTFS:

Някои функции на операционната система изискват NTFS;

Скоростта на достъп е много по-висока - NTFS минимизира броя на достъпите до диска, необходими за намиране на файл;

Защита на файлове и директории. Само на NTFS томове е възможно да зададете атрибути за достъп до файлове и папки;

Когато се използва NTFS, Windows 2000 поддържа обеми до 2 TB;

Файловата система поддържа резервно копие на сектора за зареждане — той се намира в края на тома;

NTFS поддържа шифрованата файлова система (EFS), която предпазва от неоторизиран достъп до файловото съдържание;

С помощта на квоти можете да ограничите количеството дисково пространство, което потребителите използват.

Недостатъци на NTFS

Говорейки за недостатъците на файловата система NTFS, трябва да се отбележи, че:

• NTFS томовете не са налични в MS-DOS, Windows 95 и Windows 98. В допълнение, редица функции, които са внедрени в NTFS под Windows 2000, не са налични в Windows 4.0 и по-стари;
• малки томове, съдържащи много малки файлове, може да изпитат влошаване на производителността в сравнение с FAT.

Файлова система и скорост

Както вече разбрахме, за малки обеми FAT16 или FAT32 осигуряват по-бърз достъп до файлове в сравнение с NTFS, защото:

• FAT има по-проста структура;
• размерът на директориите е по-малък;
• FAT не поддържа защита на файлове от неоторизиран достъп - системата не трябва да проверява разрешенията за файлове.

NTFS минимизира броя на достъпа до диска и времето, необходимо за намиране на файл. Освен това, ако директорията е достатъчно малка, за да се побере в един MFT запис, целият запис се чете наведнъж.

Един запис на FAT съдържа номера на клъстера за първия клъстер в директорията. За да видите FAT файл, трябва да търсите в цялата файлова структура.

Когато се сравнява скоростта на операциите, извършвани за директории, съдържащи кратки и дълги имена на файлове, трябва да се има предвид, че скоростта на операциите за FAT зависи от самата операция и размера на директорията. Ако FAT търси несъществуващ файл, той търси в цялата директория - тази операция отнема повече време от търсенето в B-дървото на NTFS. Средното време, необходимо за намиране на файл, се изразява като функция от N / 2 в FAT и log N в NTFS, където N е броят на файловете.

Редица от следните фактори влияят върху скоростта на четене и запис на файлове под Windows 2000:

• фрагментация на файла. Ако файлът е силно фрагментиран, NTFS обикновено изисква по-малко достъпи до диск от FAT, за да намери всички фрагменти;
• размер на клъстера. И за двете файлови системи размерът на клъстера по подразбиране зависи от размера на тома и винаги се изразява като степен 2. Адресите във FAT16 са 16-битови, във FAT32 - 32-битови, в NTFS - 64-битови;
• Размерът на клъстера по подразбиране във FAT се основава на факта, че таблицата за местоположение на файла може да има максимум 65 535 записа - размерът на клъстера е функция на обема, разделен на 65 535. По този начин размерът на клъстера по подразбиране за FAT том винаги е по-голям . от размера на клъстера за NTFS том със същия размер. Имайте предвид, че по-големият размер на клъстера за FAT томовете означава, че FAT томовете могат да бъдат по-малко фрагментирани;
• местоположение на малки файлове. Когато използвате NTFS, малките файлове се съдържат в MFT записа. Размерът на файл, който се вписва в един MFT запис, зависи от броя на атрибутите в този файл.

Максимален размер на NTFS томовете

На теория NTFS поддържа томове с до 2 32 клъстера. Но въпреки това, в допълнение към липсата на твърди дискове с този размер, има и други ограничения за максималния размер на тома.

Едно такова ограничение е таблицата на дяловете. Индустриалните стандарти ограничават размера на таблицата за дялове 2 до 32 сектора. Друго ограничение е размерът на сектора, който обикновено е 512 байта. Тъй като размерът на сектора може да се промени в бъдеще, текущият размер дава ограничение за размера на един том - 2 TB (2 32 x 512 байта = 2 41). По този начин 2 TB е практическо ограничение за физически и логически обеми на NTFS.

Таблица 11 показва основните ограничения на NTFS.

Контрол на достъпа до файлове и директории

Когато използвате NTFS томове, можете да зададете разрешения за файлове и директории. Тези права за достъп показват кои потребители и групи имат достъп до тях и какво ниво на достъп е разрешено. Тези права за достъп се прилагат както за потребители, работещи на компютъра, на който се намират файловете, така и за потребители, които осъществяват достъп до файловете през мрежата, когато файлът се намира в директория, отворена за отдалечен достъп.

Под NTFS можете също да зададете разрешения за отдалечен достъп, комбинирани с разрешения за файлове и директории. В допълнение, файловите атрибути (само за четене, скрит, системни) също ограничават достъпа до файла.

Под FAT16 и FAT32 също е възможно да зададете файлови атрибути, но те не предоставят разрешения за файлове.

Версията на NTFS, използвана в Windows 2000, въвежда нов тип разрешение за достъп - наследени разрешения. Разделът Защита съдържа опцията Разрешаване на наследствени разрешения от родител да се разпространяват към този файлов обекткойто е активен по подразбиране. Тази опция значително намалява времето, необходимо за промяна на правата за достъп до файлове и поддиректории. Например, за да промените правата за достъп до дърво, съдържащо стотици поддиректории и файлове, просто активирайте тази опция - в Windows NT 4 трябва да промените атрибутите на всеки отделен файл и поддиректория.

На фиг. 5 показва диалоговия прозорец Свойства и раздела Защита (Разширени раздел) - изброява разширените разрешения за файлове.

Припомнете си, че за томовете FAT можете да контролирате достъпа само на нивото на силата на звука и този контрол е възможен само с отдалечен достъп.

Компресиране на файлове и директории

Windows 2000 поддържа компресиране на файлове и директории, разположени в NTFS томове. Компресираните файлове са достъпни за четене и запис от всяко приложение на Windows. За това не е необходимо първо да ги разопаковате. Използваният алгоритъм за компресиране е подобен на този, използван в DoubleSpace (MS-DOS 6.0) и DriveSpace (MS-DOS 6.22), но има една съществена разлика - при MS-DOS се компресира цял първичен дял или логическо устройство, докато под NTFS можете да опаковате отделни файлове и директории.

Алгоритъмът за компресия в NTFS е проектиран да поддържа клъстери с размер до 4KB. Ако размерът на клъстера е по-голям от 4 KB, функциите за компресиране на NTFS стават недостъпни.

Самовъзстановяващ се NTFS

Файловата система NTFS се самовъзстановява и може да поддържа своята цялост чрез използването на протокола за извършени действия и редица други механизми.

NTFS третира всяка операция, която променя системните файлове в NTFS томове, като транзакция и съхранява информация за такава транзакция в дневник. Стартираната транзакция може да бъде или напълно завършена (commit), или връщана назад (rollback). В последния случай обемът на NTFS се връща в състоянието преди началото на транзакцията. За да управлява транзакциите, NTFS записва всички операции, включени в транзакцията, в регистрационен файл, преди да запише на диск. След приключване на транзакцията се извършват всички операции. По този начин не може да има неизпълнени операции под контрола на NTFS. В случай на повреда на диска, висящите операции просто се анулират.

NTFS също така изпълнява операции, които позволяват идентифициране в движение на дефектни клъстери и разпределя нови клъстери за файлови операции. Този механизъм се нарича пренасочване на клъстери.

В този преглед ние разгледахме различните файлови системи, поддържани в Microsoft Windows 2000, обсъдихме структурата на всяка от тях, отбелязахме техните предимства и недостатъци. Най-обещаващата файлова система е NTFS, която има голям набор от функции, които не са налични в други файлови системи. Новата версия на NTFS, поддържана от Microsoft Windows 2000, има още повече функционалност и затова се препоръчва за използване при инсталиране на операционната система Win 2000.

ComputerPres 7 "2000 г