Архитектура файловой системы FAT. Особенности файловых систем FAT32, NTFS и exFAT

1. Структура сектора FSInfo struct fat_boot_fsinfo:
   • __u32 signature1 – сигнатура 0x41615252;
   • __u32 signature2 – сигнатура 0x61417272;
   • __u32 free_clusters – количество свободных кластеров. Если поле содержит -1, поиск свободных кластеров нужно начинать с кластера номер 2.
2. Структура элемента каталога короткого имени struct msdos_dir_entry:
   • __s8 name,ext – имя и расширение файла;
   • __u8 attr – атрибуты файла;
   • __u8 ctime_ms – это поле уточняет время создания файла до мс (используется только FAT32);
   • __u16 ctime – время создания файла (используется только FAT32);
   • __u16 cdate – дата создания файла (используется только FAT32);
   • __u16 adate – дата последнего доступа к файлу (используется только FAT32);
   • __u16 starthi – старшие 16 бит номера первого кластера файла (используется только FAT32);
   • __u16 time,date,start – время и дата создания файла, номер первого кластер файла;
   • __u32 size – размер файла (в байтах).
3. Структура элемента каталога длинного имени:
   • __u8 id – номер элемента;
   • __u8 name0_4 – символы 1 – 5 имени;
   • __u8 attr – атрибуты файла;
   • __u8 alias_checksum – контрольная сумма короткого имени;
   • __u8 name5_10 – символы 6 – 11 имени;
   • __u8 name11_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 *fat16; // сюда копируем таблицу FAT16

U16 sector_size; // размер сектора (из FAT16)

U16 dir_entries; // число 32-байтных дескрипторов

// в root-каталоге (0 для FAT32)

U16 sectors; // общее число секторов в разделе

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

U32 root_size; // размер корневого каталога

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

U16 next_cluster; // очередной кластер в цепочке

int fat;

Начнём рассмотрение с главной функции:

int main()

Int num;

Задаем полное имя файла, содержимое которого мы хотим прочитать. Напомню, что мы работаем только с короткими именами файлов. Порядок работы с длинными именами в данной статье не рассматривается.

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

Открываем файл устройства:

Hard = open(FAT16_PART_NAME, O_RDONLY);

If(hard < 0) {

Perror(FAT16_PART_NAME);

Exit(-1);

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

Num = fat16_read_file(full_path, 10);

If(num < 0) perror("fat16_read_file");

Else printf("Read %d clusters ", num);

Закрываем файл устройства и выходим:

Close(hard);

Return 0;

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

int fat16_read_file(__u8 *full_path, int num)

Struct split_name sn; // структура для хранения составных частей файла

U8 tmp_name_buff; // буфер для временного хранения составных элементов полного пути файла

Static int i = 1;

Int n;

U8 *tmp_buff;

U16 start_cluster, next_cluster;

Параметры функции мы перечислили при рассмотрении функции main.

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

Первым символом в абсолютном путевом имени файла должен быть прямой слэш (/). Проверяем это:

Считываем с раздела загрузочный сектор:

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

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

Определим размер кластера в байтах:

Byte_per_cluster = fbs.cluster_size * 512

Отобразим информацию, находящуюся в загрузочном секторе:

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

Printf("Sector size - %d ", sector_size);

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

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

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

Printf("Dir entries - %d ", dir_entries);

Printf("Sectors - %d ", sectors);

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

Printf("FAT16 length - %u ", fbs.fat_length);

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

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

Вычисляем размер FAT16 в байтах и считываем её:

Fat16_size = fbs.fat_length * 512;

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

Считываем корневой каталог:

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

Сейчас указатель dir_entry позиционирован на область памяти, содержащую записи корневого каталога. Размер этой области памяти равен размеру корневого каталога (root_size).

Сохраним (для контроля) содержимое корневого каталога в отдельном файле:

#ifdef DEBUG

Close(fat);

#endif

Вычисляем начало области данных:

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

Имея все записи корневого каталога, мы можем добраться до содержимого файла test.txt. С этой целью организуем цикл. В теле цикла проведем разбор полного имени файла, выделяя его элементы – подкаталоги (их у нас два, Folder1 и Folder2) и имя искомого файла (test.txt).

While(1) {

Memset(tmp_name_buff, 0, SHORT_NAME);

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

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

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

I++;

Break;

Tmp_name_buff[n] = "?";

Заполняем структуру struct split_name sn соответствующей информацией. Заполнение выполняет функция split_name, при этом выполняется проверка имени файла на соответствие формату «8.3»:

< 0) {

Printf("not valid name ");

Return -1;

Для каждого элемента полного имени файла определяем начальный кластер. Для этого ищем в элементах каталога (начиная с корневого) запись, соответствующую элементу полного имени, и считываем эту запись. Процедуру поиска выполняет функция get_dentry():

If(get_dentry(&sn) < 0) {

Printf("No such file! ");

Return -1;

Проверяем атрибуты файла. Если это каталог, считываем его содержимое и продолжаем цикл:

If(dentry.attr & 0x10) {

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

Continue;

Если это файл – считываем первые num кластеров. Для контроля считанную информацию сохраним в отдельном файле:

If(dentry.attr & 0x20) {

Start_cluster = dentry.start;

Tmp_buff = (__u8 *)malloc(byte_per_cluster); // сюда будет считываться содержимое кластера

N = open("clust", O_CREAT|O_RDWR, 0600); // в этом файле сохраним считанную информацию

If(n < 0) {

Perror("open");

Return -1;

Для считывания кластеров файла организуем цикл:

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

Считываем содержимое кластера в буфер tmp_buff и сохраняем его в отдельном файле:

< 0) return -1;

< 0) {

Perror("write");

Close(n);

Return -1;

Считываем из FAT16 номер следующего кластера, занятого под данный файл. Если это последний кластер – прерываем цикл и возвращаемся в главную функцию:

#ifdef DEBUG

Printf("OK. Readed ");

Printf("file`s next cluster - 0x%X .. ", next_cluster);

#endif

If(next_cluster == EOF_FAT16) {

#ifdef DEBUG

Printf("last cluster. ");

#endif

Free(tmp_buff);

Close(n);

Return ++i;

#ifdef DEBUG

Printf("stop reading ");

#endif

Return i;

Чтение загрузочного сектора FAT16 выполняет функция read_fbs(). Результат помещается в глобальную структуру fbs:

int read_fbs()

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

Return 0;

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

int read_fat16()

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

Fat16 = (void *)malloc(fat16_size);

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

Return 0;

Чтение корневого каталога выполняет функция read_root_dentry():

int read_root_dentry()

U64 seek = (__u64)fbs.reserved * 512 + fat16_size * fbs.fats; // смещение к корневому каталогу от начала раздела

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

Dir_entry = (__u8 *)malloc(root_size);

If(!dir_entry) return -1;

Memset(dir_entry, 0, root_size);

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

Return 0;

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

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

• SEEK – смещение к кластеру на разделе
• 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;

Return 0;

Функция read_directory выполняет чтение записей каталога (не корневого) и помещает результат в область памяти, на которую настроен указатель dir_entry:

int read_directory(__u16 start_cluster)

Int i = 1;

U16 next_cluster;

For(; ;i++) {

Выделяем память для хранения содержимого каталога, считываем содержимое стартового кластера и получаем из таблицы FAT16 значение очередного кластера:

If(!dir_entry) return -1;

< 0) return -1;

Next_cluster = fat16;

Сохраним содержимое каталога в отдельном файле (для контроля):

#ifdef DEBUG

Printf("Next cluster - 0x%X ", next_cluster);

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

Write(fat, dir_entry, root_size);

Close(fat);

#endif

Если достигнут последний кластер, выходим из цикла, иначе продолжаем чтение каталога, увеличив размер буфера dir_entry ещё на один кластер:

If(next_cluster & EOF_FAT16) break;

Start_cluster = next_cluster;

Return 0;

Поиск в содержимом каталога элемента, соответствующего искомому файлу, выполняет функция get_dentry(). Входные параметры этой функции – указатель на структуру struct split_name *sn, содержащую элементы короткого имени файла:

Int i = 0;

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

for(; ; i++) {

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

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

Break;

If(!dentry.name) return -1;

#ifdef DEBUG

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

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

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

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

#endif

Return 0;

Весь вышеприведенный код находится в каталоге FAT16, файл fat16.c. Для получения исполняемого модуля создадим Makefile следующего содержания:

INCDIR = /usr/src/linux/include

PHONY = clean

Fat16: fat16.o split.o

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

%.o: %.c

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

Clean:

Rm -f *.o

Rm -f ./fat16

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

В целом алгоритм чтения файла с раздела FAT12 идентичен алгоритму чтения файла с раздела FAT16. Отличие заключается в процедуре чтения элементов из таблицы FAT12. Таблица FAT16 рассматривалась нами как простой массив 16-разрядных элементов. Для чтения элементов таблицы FAT12 в предложен следующий алгоритм:

• умножить номер элемента на 1.5;
• извлечь из FAT 16-разрядное слово, используя в качестве смещения результат предыдущей операции;
• если номер элемента четный, выполнить операцию AND над считанным словом и маской 0x0FFF. Если номер нечетный, сдвинуть считанное из таблицы слово на 4 бита в сторону младших разрядов.

Базируясь на этом алгоритме, реализуем функцию чтения элементов из таблицы FAT12:

int get_cluster(__u16 cluster_num)

U16 seek;

U16 clust;

Вычисляем смещение в таблице FAT12 и считываем из таблицы 16-разрядное слово:

Seek = (cluster_num * 3) / 2;

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

Если стартовый номер кластера – четное число, сдвигаем считанное из таблицы значение на 4 бита в сторону младших разрядов, если нечетное – суммируем его с 0x0FFF:

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

Else clust &= 0x0FFF;

Этот фрагмент можно также реализовать на ассемблере:

" xorw %%ax, %%ax "

" btw $0, %%cx "

" jnc 1f "

" shrw $4, %%dx "

" jmp 2f "

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

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

:"=a" (next)

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

Возвращаем результат:

Return clust;

Остановимся чуть подробнее на самом алгоритме. Предположим, что на разделе с FAT12 создан файл, который занимает 9-й и 10-й кластеры. Каждый элемент FAT12 занимает 12 бит. Т.к. из таблицы мы считываем 16-разрядные элементы, то смещение к 9-му элементу будет равно 13 байт (9 * 1.5 = 13, остаток отбрасываем), при этом младшие 4 разряда будут принадлежать 8-му элементу FAT. Их необходимо отбросить, а для этого достаточно сдвинуть считанный элемент на 4 бита в сторону младших разрядов, что и предусмотрено алгоритмом. Смещение к 10-му элементу будет равно 15 байт, и старшие 4 бита будут принадлежать 11-му элементу FAT. Чтобы их отбросить, необходимо выполнить операцию AND над 10-м элементом и маской 0x0FFF, что так же соответствует вышеприведенному алгоритму.

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

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

Алгоритм чтения файла с раздела с файловой системой FAT32 практически не отличается от алгоритма для FAT16, за исключением того, что в FAT32 корневой каталог может располагаться в любом месте раздела и иметь произвольный размер. Поэтому, чтобы было интереснее, усложним задачу – предположим, что нам известен только номер раздела с файловой системой FAT32. Чтобы считать с этого раздела информацию, необходимо вначале определить его координаты – смещение к разделу от начала диска. А для этого надо иметь представление о логической структуре жесткого диска.

Логическая структура жесткого диска

Рассмотрим логическую структуру жесткого диска, соответствующую стандарту Microsoft – «основной раздел – расширенный раздел – разделы non-DOS».

Пространство на жестком диске может быть организовано в виде одного или нескольких разделов, а разделы могут содержать один или несколько логических дисков.

На жестком диске по физическому адресу 0-0-1 располагается главная загрузочная запись (Master Boot Record, MBR). В структуре MBR находятся следующие элементы:

• внесистемный загрузчик (non-system bootstrap – NSB);
• таблица описания разделов диска (таблица разделов, partition table, PT). Располагается в MBR по смещению 0x1BE и занимает 64 байта;
• сигнатура MBR. Последние два байта MBR должны содержать число 0xAA55.

Таблица разделов описывает размещение и характеристики имеющихся на винчестере разделов. Разделы диска могут быть двух типов – primary (первичный, основной) и extended (расширенный). Максимальное число primary-разделов равно четырем. Наличие на диске хотя бы одного primary-раздела является обязательным. Extended-раздел может быть разделен на большое количество подразделов – логических дисков. Упрощенно структура 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 – младшие восемь бит номера цилиндра. Затем следует кодовый идентификатор System ID, указывающий на принадлежность данного раздела к той или иной операционной системе. Идентификатор занимает один байт. За системным идентификатором расположены координаты конца раздела – три байта, содержащие номера головки, сектора и цилиндра соответственно. Следующие четыре байта – это число секторов перед разделом, и последние четыре байта – размер раздела в секторах.

Таким образом, элемент таблицы раздела можно описать при помощи следующей структуры:

struct pt_struct {

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

U8 start_part; // координаты начала раздела

U8 type_part; // системный идентификатор

U8 end_part; // координаты конца раздела

U32 sect_before; // число секторов перед разделом

U32 sect_total; // размер раздела в секторах (число секторов в разделе)

Элемент первичного раздела указывает сразу на загрузочный сектор логического диска (в первичном разделе всегда имеется только один логический диск), а элемент расширенного раздела – на список логических дисков, составленный из структур, которые именуются вторичными MBR (Secondary MBR, SMBR).

Свой блок SMBR имеется у каждого диска расширенного раздела. SMBR имеет структуру, аналогичную MBR, но загрузочная запись у него отсутствует (заполнена нулями), а из четырех полей описателей разделов используются только два. Первый элемент раздела при этом указывает на логический диск, второй элемент указывает на следующую структуру SMBR в списке. Последний SMBR списка содержит во втором элементе нулевой код раздела.

Вернемся к рассмотрению модуля чтения файла с раздела FAT32.

Заголовочные файлы:

#include

#include

#include

#include

#include

Сигнатура MBR:

#define SIGNATURE 0xAA55

Файл устройства, с которого будет считываться информация о разделах:

#define DEVICE "/dev/hda"

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

#define PT_SIZE 0x10

Следующий массив структур устанавливает соответствие между кодом типа раздела и его символьным отображением:

struct systypes {

U8 part_type;

U8 *part_name;

struct systypes i386_sys_types = {

{0x00, "Empty"},

{0x01, "FAT12"},

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

{0x05, "Extended"},

{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 extended"},

{0x07, "HPFS/NTFS"}

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

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

Установим ограничение на количество логических дисков:

#define MAX_PART 20

Следующий массив структуры будет содержать информацию о логических дисках на устройстве (жестком диске):

struct pt_struct {

U8 bootable;

U8 start_part;

U8 type_part;

U8 end_part;

U32 sect_before;

U32 sect_total;

} pt_t;

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

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 sector_size; // размер сектора (из FAT32)

U16 dir_entries; // 0 для FAT32

U16 sectors; // число секторов на разделе

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

U32 data_start; // начало области данных

U16 byte_per_cluster; // сколько байт в кластере (размер кластера в байтах)

U32 next_cluster; // очередной кластер в цепочке

U32 root_cluster; // ROOT cluster - начальный кластер корневого каталога

U8 *dir_entry = NULL; // указатель на записи каталога

U64 start_seek = 0; // стартовое смещение к разделу (в байтах)

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

int main()

Int num = 0;

Int cluster_num = 5; // сколько кластеров считывать из файла

U8 *full_path = "/Folder1/Folder2/readme"; // файл для считывания

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

Hard = open(DEV_NAME, O_RDONLY);

If(hard < 0) {

Perror(DEV_NAME);

Exit(-1);

If(get_pt_info(hard) < 0) {

Perror("get_pt_info");

Exit(-1);

Show_pt_info();

Вычисляем стартовое смещение к разделу:

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

Считываем кластеры, принадлежащие файлу:

Num = fat32_read_file(full_path, cluster_num);

If(num < 0) perror("fat32_read_file");

Else printf("Read %d clusters\n", num);

Close(hard);

Return 0;

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

int get_pt_info(int hard)

Int i = 0;

U64 seek;

Считываем таблицу разделов из MBR и проверяем сигнатуру:

Read_main_ptable(hard);

If(check_sign() < 0) {

Printf("Not valid signature!\n");

Return -1;

Ищем идентификатор расширенного раздела. Если таковой имеется, вычисляем смещение к расширенному разделу и считываем информацию о логических дисках:

for(; 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);

Break;

Return 0;

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

void read_main_ptable(int hard)

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

Perror("read");

Close(hard);

Exit(-1);

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

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

Return;

Функция проверки сигнатуры check_sign():

int check_sign()

U16 sign = 0;

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

#ifdef DEBUG

Printf("Signature - 0x%X\n", sign);

#endif

If(sign != SIGNATURE) return -1;

Return 0;

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

void read_ext_ptable(int hard, __u64 seek)

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

U8 smbr;

Входные данные:

• hard – дескриптор файла устройства;
• seek – смещение к расширенному разделу от начала диска (в байтах).

Для получения информации о логических дисках организуем цикл:

For(;;num++) {

Считываем SMBR, находящуюся по смещению seek от начала диска:

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

Pread64(hard, smbr, 512, seek);

Заполняем два элемента таблицы pt_t, начиная с позиции num. Первый элемент будет указывать на логический диск, а второй – на следующую структуру SMBR:

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

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

Вносим поправку в поле «Номер начального сектора» – отсчет ведется от начала диска:

Pt_t.sect_before += (seek / 512);

Если код типа раздела равен нулю, то больше логических дисков нет:

If(!(pt_t.type_part)) break;

Вычисляем смещение к следующему SMBR:

Seek = ((__u64)(pt_t.sect_before + pt_t.sect_total)) * 512;

Return;

Функция show_pt_info() отображает информацию о найденных логических дисках на устройстве:

void show_pt_info()

Int i = 0, n;

#ifdef DEBUG

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

#endif

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

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

Printf("\nТип раздела %d - ", i);

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

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

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

Break;

If(n == PART_NUM) printf("unknown type\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);

Return;

Чтение кластеров файла с раздела FAT32 выполняет функция fat32_read_file(). Эта функция имеет много общего с функцией fat16_read_file(), поэтому за подробными комментариями обратитесь к п. 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, next_cluster;

U8 *tmp_buff;

Подготовительные операции – чистим буфер, структуру и проверяем первый слэш:

Memset(tmp_name_buff, 0, SHORT_NAME);

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

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

Считываем загрузочный сектор:

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

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

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

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

Считываем структуру FSInfo и отобразим сигнатуру, находящуюся в ней:

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

Printf("Signature1 - 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:

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

Выделяем память для записей каталога:

Dir_entry = (__u8 *)malloc(byte_per_cluster);

If(!dir_entry) return -1;

Считываем корневой каталог:

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

Проводим разбор полного пути файла и разделение каждого элемента на составляющие:

While(1) {

Memset(tmp_name_buff, 0, SHORT_NAME);

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

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

Tmp_name_buff[n] = full_path[i];

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

I++;

Break;

Tmp_name_buff[n] = "\0";

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

Printf("not valid name\n");

Return -1;

If(get_dentry(&sn) < 0) {

Printf("No such file!\n");

Return -1;

Для получения стартового номера кластера в файловой системе FAT32 необходимо задействовать старшее слово номера первого кластера файла – поле starthi структуры dentry:

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

Проверяем байт атрибутов:

If(dentry.attr & 0x10) { // это каталог

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

Continue;

If(dentry.attr & 0x20) { // а это - файл

Tmp_buff = (__u8 *)malloc(byte_per_cluster);

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

If(n < 0) {

Perror("open");

Return -1;

Printf("file`s first cluster - 0x%X .. ", start_cluster);

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

Perror("write");

Return -1;

If(next_cluster == EOF_FAT32) {

Free(tmp_buff);

Close(n);

Return ++i;

Start_cluster = next_cluster;

Return i;

Назначение следующих трёх функций – получить содержимое системной области, т.е. загрузочного сектора, структуры FSInfo и таблицы FAT32:

1) функция read_fbs() выполняет чтение загрузочного сектора:

int read_fbs()

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

Return 0;

2) функция read_fs_info() считывает структуру 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;

Return 0;

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

int read_fat32()

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

Fat32 = (void *)malloc(fat32_size);

If(!fat32) return -1;

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

Return 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;

Return 0;

Чтением каталогов (в том числе и корневого) занимается функция read_directory():

int read_directory(__u32 start_cluster)

Int i = 2;

U32 next_cluster;

Параметры функции – стартовый кластер каталога. Считываем содержимое каталога в глобальный буфер dir_entry:

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

Next_cluster = fat32;

Если каталог занимает один кластер – выходим, если нет – увеличиваем размер памяти и продолжаем чтение:

For(; ;i++) {

Start_cluster = next_cluster;

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

If(!dir_entry) return -1;

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

Next_cluster = fat32;

If((next_cluster == EOF_FAT32) || (next_cluster == 0xFFFFFF8)) return 0;

Return 0;

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

int get_dentry(struct split_name *sn)

Int i = 0;

Указатель dir_entry настроен на область памяти, содержащую массив записей каталога, в котором мы собираемся искать файл (или каталог). Для поиска организуем цикл и найденную запись поместим в глобальную структуру dentry:

For(;;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)))

Break;

If(!dentry.name) return -1;

Return 0;

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

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

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

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

C FAT мы только что ознакомились – в ней все элементы каталога имеют фиксированную величину. При создании файла драйвер файловой системы ищет первую незанятую позицию и заполняет её информацией о файле. Если длина каталога не умещается в одном кластере, то под него отводится ещё один кластер и т. д.

Рассмотрим, как обстоят дела в EXT2.

Предположим, у нас есть раздел с файловой системой EXT2, размер блока равен 4096 байт. На этом разделе мы создаем каталог. Размер каталога будет равен размеру блока – 4096 байт. В каталоге операционная система сразу создаёт две записи – запись текущего и запись родительского каталогов. Запись текущего каталога займет 12 байт, в то время как длина записи родительского будет равна 4084 байта. Создадим в этом каталоге какой-нибудь файл. После этого в каталоге будут присутствовать три записи – запись текущего каталога длиной 12 байт, запись родительского каталога длиной уже 12 байт, и запись созданного файла длиной, как вы наверно догадались, 4072 байт. Если мы удалим созданный файл, длина записи родительского каталога опять возрастёт до 4084 байт.

Таким образом, при создании файла драйвер файловой системы EXT2 ищет в каталоге запись максимальной длины и расщепляет её, выделяя место для новой записи. Ну, а если всё-таки места не хватает, под каталог отводится ещё один блок, и длина каталога становится равной 8192 байт.

И в заключение – небольшая правка к статье «Архитектура файловой системы EXT2» .

Эта правка касается функции определения номера inode по имени файла get_i_num(). Старый вариант этой функции выглядел так:

int get_i_num(char *name)

Int i = 0, rec_len = 0;

Struct ext2_dir_entry_2 dent;

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

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

Rec_len += dent.rec_len;

Return dent.inode;

Исправленный вариант:

int get_i_num(char *name)

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

Int rec_len = 0;

Struct ext2_dir_entry_2 dent; // эта структура описывает формат записи корневого каталога:

* В глобальном буфере buff находится массив записей каталога. Для определения порядкового номера inode файла необходимо найти

* в этом массиве запись с именем этого файла. Для этого организуем цикл:

For(;;) {

/* Копируем в структуру dent записи каталога: */

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

* Длина имени файла равная нулю означает, что мы перебрали все записи каталога

* и записи с именем нашего файла не нашли. Значит, пора возвращаться:

If(!dent.name_len) return -1;

/* Поиск выполняется путем сравнения имен файлов. Если имена совпадают - выходим из цикла: */

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

/* Если имена не совпали - смещаемся к следующей записи: */

Rec_len += dent.rec_len;

/* В случае успеха возвращаем номер inode файла: */

Return dent.inode;

Литература:

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

Вконтакте

FAT - File Allocation Table (таблица размещения файлов) - этот термин относится к одному из способов организации файловой системы на диске. Эта таблица хранит информацию о файлах на жестком диске в виде последовательности чисел, определяющих, где находится каждая часть каждого файла. С ее помощью операционная система выясняет, какие кластеры занимает нужный файл. FAT - является самой распространенной файловой системой и поддерживается подавляющим большинством операционных систем. Сначала FAT была 12-разрядной и позволяла работать с дискетами и логическими дисками объемом не более 16 Мбайт. В MS-DOS версии 3.0 таблица FAT стала 16-разрядной для поддержки дисков большей емкости, а для дисков объемом до 2 047 Гбайт используется 32-разрядная таблица FAT.

Система FAT32 - более новая файловая система на основе формата FAT, она поддерживается Windows 95 OSR2, Windows 98 и Windows Millennium Edition. FAT32 использует 32-разрядные идентификаторы кластеров, но при этом резервирует старшие 4 бита, так что эффективный размер идентификатора кластера составляет 28 бит. Поскольку максимальный размер кластеров FAT32 равен 32 Кбайт, теоретически FAT32 может работать с 8-терабайтными томами. Windows 2000 ограничивает размер новых томов FAT32 до 32 Гбайт, хотя поддерживает существующие тома ЕАТ32 большего размера (созданные в других операционных системах). Большее число кластеров, поддерживаемое FAT32, позволяет ей управлять дисками более эффективно, чем FAT 16. FAT32 может использовать 512-байтовые кластеры для томов размером до 128 Мбайт.

Файловая система FAT 32 в Windows 98 используется в качестве основной. С этой операционной системой поставляется специальная программа преобразования диска из FAT 16 в FAT 32. Windows NT и Windows 2000 тоже могут использовать файловую систему FAT, и поэтому можно загрузить компьютер с DOS-диска и иметь полный доступ ко всем файлам. Однако некоторые из самых прогрессивных возможностей Windows NT и Windows 2000 обеспечиваются ее собственной файловой системой ntfs (NT File System). ntfs позволяет создавать на диске разделы объемом до 2 Тбайт (как и FAT 32), но, кроме этого, в нее встроены функции сжатия файлов, безопасности и аудита, необходимые при работе в сетевой среде. А в Windows 2000 реализуется поддержка файловой системы FAT 32. Установка операционной системы Windows NT начинается на диске FAT, но по желанию пользователя в конце установки данные на диске могут быть конвертированы в формат ntfs.

Можно сделать это и позже, воспользовавшись утилитой Convert.exe, поставляемой вместе с операционной системой. Преобразованный к системе ntfs раздел диска становится недоступным для других операционных систем. Чтобы вернуться в DOS, Windows 3.1 или Windows 9x, нужно удалить раздел ntfs, а вместо него создать раздел FAT. Windows 2000 можно устанавливать на диск с файловой системой FAT 32 и ntfs.

Возможности файловых систем ЕАТ32 гораздо шире возможностей FAT16. Самая важная ее особенность в том, что она поддерживает диски объемом до 2 047 Гбайт и работает с кластерами меньшего размера, благодаря чему существенно сокращает объемы неиспользуемого дискового пространства. Например, жесткий диск объемом 2 Гбайт в FAT16 использует кластеры размером по 32 Кбайт, а в FAT32 - кластеры размером по 4 Кбайт. Чтобы по возможности сохранить совместимость с существующими программами, сетями и драйверами устройств, FAT32 реализована с минимальными изменениями в архитектуре, API-интерфейсах, структурах внутренних данных и дисковом формате. Но, так как размер элементов таблицы FAT32 теперь составляет четыре байта, многие внутренние и дисковые структуры данных, а также API-интерфейсы пришлось пересмотреть или расширить. Отдельные API на ЕАТ32-дисках блокируются, чтобы унаследованные дисковые утилиты не повредили содержимое FAT32-дисков. На большинстве программ эти изменения никак не скажутся. Существующие инструментальные средства и драйверы будут работать и на FAT32-дисках. Однако драйверы блочных устройств MS-DOS (например, Aspidisk.sys) и дисковые утилиты нуждаются в модификации для поддержки FAT32. Все дисковые утилиты, поставляемые Microsoft (Format, Fdisk, Defrag, а также ScanDisk для реального и защищенного режимов), переработаны и полностью поддерживают FAT32. Кроме того, Microsoft помогает ведущим поставщикам дисковых утилит и драйверов устройств в модификации их продуктов для поддержки FAT32. FAT32 эффективнее FAT16 при работе с дисками большего объема и не требует их разбиения на разделы по 2 Гбайт. Windows 98 обязательно поддерживает FAT16, так как именно эта файловая система совместима с другими операционными системами, в том числе сторонних компании. В MS-DOS реального режима и в безопасном режиме Windows 98, файловая система FAT32 работает значительно медленнее, чем FAT16. Поэтому, при запуске программ в режиме MS DOS желательно включить в файл Autoexec.bat или PIF-файл команду для загрузки Smartdrv.exe, что ускорит дисковые операции. Некоторые устаревшие программы, рассчитанные на спецификацию FAT16, могут сообщать неправильную информацию об объеме свободного или общего дискового пространства, если он больше 2 Гбайт. Windows 98 предоставляет новые API-интерфейсы для MS-DOS и Win32, которые позволяют корректно определять эти показатели. В табл. 1 приведены сравнительные характеристики FAT16 и FAT32.

Таблица 1. Сравнение файловых систем FAT16 и FAT32

Максимально возможная длина файла в FAT32 равна 4 Гбайт за вычетом 2 байтов. Win32-приложения могут открывать файлы такой длины без специальной обработки. Остальные приложения должны использовать прерывание Int 21h, функцию 716С (FAT32) с флагом открытия, равным EXTEND-SIZE (1000h).

В файловой системе FAT32 на каждый кластер в таблице размещения файлов отводится по 4 байта, тогда как в FAT16 - по 2, а в FАТ12 - по 1,5.

Старшие 4 бита 32-разрядного элемента таблицы FAT32 зарезервированы и не участвуют в формировании номера кластера. Программы, напрямую считывающие РАТ32-таблицу, должны маскировать эти биты и предохранять их от изменения при записи новых значений.

Итак, FAT32 обладает следующими преимуществами в сравнении с прежними реализациями файловой системы FAT:

поддерживает диски объемом до 2 Тбайт;

эффективнее организует дисковое пространство. FAT32 использует кластеры меньшего размера (4 Кбайт для дисков объемом до 8 Гбайт), что позволяет сэкономить до 10-15% пространства на больших дисках по сравнению с FAT;

корневой каталог FAT 32, как и все остальные каталоги, теперь не ограничен, он состоит из цепочки кластеров и может быть расположен в любом месте диска;

имеет более высокую надежность: FAT32 способна перемещать корневой каталог и работать с резервной копией FAT, кроме того, загрузочная запись на FАТ32-дисках расширена и теперь включает резервную копию критически важных структур данных, а это означает, что FАТ32-диски менее чувствительны к возникновению отдельных сбойных участков, чем существующие FAT-тома;

программы загружаются на 50% быстрее.

Таблица 2. Сравнение размеров кластеров

Усовершенствованная утилита дефрагментации дисков оптимизирует размещение файлов приложения, загружаемых в момент его запуска. Возможно преобразование диска в ЕАТ32 с помощью утилиты Drive Converter (FAT32), но после этого рекомендуется запустить утилиту Disk Defragmenter, - иначе компьютер будет работать с диском медленнее, чем раньше. При использовании FAT32 становится невозможной конфигурация с альтернативной загрузкой Windows 98 и Windows NT 4.0, так как последняя не поддерживает FAT32. FAT32 распределяет дисковое пространство гораздо экономичнее предыдущих версий файловой системы FAT. Благодаря этому на больших дисках удается высвободить десятки и даже сотни мегабайтов, а в сочетании с усовершенствованной утилитой дефрагментации дисков FAT32 значительно сокращает время загрузки приложений. Процедура преобразования файловой системы на жестком диске в FAT32 с помощью Drive Converter (FAT32) достаточно проста. Для этого последовательно необходимо открыть меню Start (Пуск), подменю programs (Программы), Accessories (Стандартные), System Tools (Служебные) и выбрать команду Drive Converter (FAT32) (Преобразование диска в FАТ32). Преобразование может повлиять на функции спящего режима (hibernate features) (сохранения состояния компьютера на диск), предусмотренные во многих компьютерах. Системы, в которых режим сна реализован через АРМ BIOS или ACPI (Advanced Configuration and Power Interface) S4/BIOS, должны поддерживать FAT32, - только тогда они будут корректно работать в Windows 98.

Большинство изготовителей BIOS включают в нее средства защиты от вирусов, отслеживающие изменения в главной загрузочной записи MBR (Master Boot Record). Кроме того, устаревшие антивирусные утилиты, устанавливаемые как резидентные программы или драйверы реального режима, могут обнаруживать изменение MBR при загрузке MS-DOS. Так как преобразование в FAT32 приводит к неизбежной модификации MBR, некоторые средства проверки на вирусы могут ошибочно счесть это признаком инфицирования системы. Поэтому, если антивирусная утилита, обнаружив изменение MBR, предлагает "вылечить" ее. Лучше всего удалить антивирусное программное обеспечение и отключить встроенные в BIOS средства защиты от вирусов перед преобразованием диска в FAT32. Потом можно вновь установить антивирусную утилиту и активизировать встроенные в BIOS средства защиты от вирусов.