Общие принципы устройства файловой системы fat. Файловая система - что такое? Файловая система NTFS, FAT, RAW, UDF

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 - «таблица размещения файлов»)- классическая архитектура файловой системы, которая из-за своей простоты всё ещё широко используется для флеш-накопителей. Используется в дискетах, и некоторых других носителях информации. Ранее использовалась и на жестких дисках.

Файловая система была разработана Биллом Гейтсом и Марком Мак Дональдом в 1977 году и первоначально использовалась в операционной системе 86-DOS. В дальнейшем 86-DOS была приобретена Microsoft и стала основой для ОС MS-DOS 1.0, выпущенной в августе 1981 года. FAT была предназначена для работы с гибкими дисками размером менее 1 Мб, и вначале не предусматривала поддержки жестких дисков.

Сейчас существует четыре версии FAT - FAT8, FAT12 , FAT16 и FAT32 . Они отличаются разрядностью записей в дисковой структуре, то есть количеством бит, отведённых для хранения номера кластера . FAT12 применяется в основном для дискет, FAT16 - для дисков малого объёма, FAT32- для жестких дисков. На основе FAT была разработана новая файловая система exFAT (extended FAT), используемая преимущественно для флеш-накопителей.

Файловая система FAT заполняет свободное место на диске последовательно от начала к концу. При создании нового файла или увеличении уже существующего она ищет первый свободный кластер в таблице размещения файлов. Если одни файлы были удалены, а другие изменились в размере, то появляющиеся в результате пустые кластеры будут рассеяны по диску. Если кластеры, содержащие данные файла, расположены не подряд, то файл оказывается фрагментированным . Сильно фрагментированные файлы значительно снижают эффективность работы, так как головки чтения/записи при поиске очередной записи файла должны будут перемещаться от одной области диска к другой. Желательно, чтобы кластеры, выделенные для хранения файла, шли подрят, так, как это позволяет сократить время его поиска. Однако, это можно сделать только с помощью специальной программы, подобная процедура получила название дефрагментации файла.

Недостатком FAT так же является то, что ее производительность зависит от количества файлов, находящихся в одном каталоге. При большом количестве файлов (около тысячи), выполнение операции считывания списка файлов в каталоге может занять несколько минут. FAT не предусматривает хранения такой информации, как сведения о владельце или полномочия доступа к файлу.

FAT - простая файловая система, не предотвращающая порчи файлов из-за ненормального завершения работы компьютера, она является одной из самых распространенных файловых систем, и ее поддерживают большинство ОС.

Организация файловой системы fat

Все современные дисковые операционные системы обеспечивают создание файловой системы, предназначенной для хранения данных на дисках и обеспечения доступа к ним.. Для того, чтобы данные могли быть записаны на диск, его поверхность необходимо структурировать -т.е. разделить на сектора и дорожки .

A- дорожка

C- кластер

Рисунок 1- Структура диска

Дорожки - это концентрические окружности, покрывающие поверхность диска. Ближайшей к краю диска дорожке присвоен номер 0, следующей за ней - 1 и т.д. Если дискета двусторонняя, то пронумерованы обе ее стороны. Номер первой стороны - 0, номер второй - 1.

Каждая дорожка разбивается на участки, называемые секторами . Секторам также присваиваются номера. Первому сектору на дорожке присваивается номер 1, второму - 2 и т.д.

Жесткий диск состоит из одной или нескольких круглых пластин. Для хранения информации используются обе поверхности пластины. Каждая поверхность разбивается на дорожки, дорожки, в свою очередь, - на сектора. Дорожки одинакового радиуса составляют цилиндр . Таким образом, все нулевые дорожки составляют цилиндр с номером ноль, дорожки с номером 1 - цилиндр с номером 1 и т.д.

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

Каждый раз, когда пользуюсь либой FatFs думаю, что неплохо бы разобраться с тем, как все устроено внутри. Долго откладывал этот вопрос, наконец лед тронулся. Итак, глобальная цель это раскуривание карт памяти, если получится то детально, текущая цель разобраться с файловой системой.

Сразу скажу, у меня не было цели писать свой драйвер или детально разбираться в тонкостях, мне было просто интересно. Задача довольно простая для понимания, поэтому «кодов» здесь не будет.

Итак, первое что мы должны понять, при общении с картой памяти напрямую, мы можем либо прочитать, либо записать 512 байт, других действий не дано. Так как файлы мы постоянно что то копируем, удаляем, а размеры файлов всегда разные, то на карте будут образовываться пустые участки в перемешку с записанными. Чтобы пользователю не запариваться с размещением данных, существует прослойка которая берет на себя эти заботы, это и есть файловая система.

Как было уже выше сказано, записать и прочитать можно только кратно 512 байтам, т.е. 1 сектор. Также есть понятие — кластер это тупо несколько секторов, например если размер кластера 16кБ, то значит что в нем 16000/512 = 31.25, точнее 32 сектора, а реальный размер кластера 16384 байта. Все файлы занимают размер кратно размеру кластера. Даже если файл размером 1кБ, а кластер 16кБ, то файл будет занимать все 16кБ.

Логично было бы делать кластеры, маленького размера, то тут вступает в дело ограничение на максимальное количество файлов и на их размер. FAT16 оперирует 16 битными данными, поэтому нельзя запихать больше чем 2^16 кластеров. Поэтому чем меньше их размер, тем более эффективно используется место под мелкие файлы, но тем меньше информации можно запихать на диск. И наоборот, чем больше размер, тем больше информации можно впихать, но тем менее эффективно используется место под мелкие файлы. Максимальный размер кластера 64кБ, поэтому максимум для FAT16 64кб*2^16 = 4Гб.

Исходные данные: имеется карта памяти micro SD на 1Гб. Имеет метку MYDISK, отформатирована полностью, размер кластера 16кБ.

Понадобится Hex редактор, но любой не подойдет, нужен такой, который может просматривать диск целиком, а не только файлы на диске. Из того что мне удалось найти: WinHex самый годный, но платный; HxD простой, бесплатный, но мне так и не удалось заставить его сохранять изменения на диске; DMDE — немного не user friendly, бесплатный и позволяет сохранить изменения. В общем я остановился на HxD.

Для начала стоит рассмотреть структуру FAT16, картинка показывает в каком порядке расположены различные части файловой системы.

В загрузочном секторе хранится вся служебная информация. Внутри области FAT хранится инфорция о том, как расположены данные файлов на диске. В корневом каталоге информация о том, какие файлы есть в корне диска. Область данных содержит информацию содержащуюся внутри файлов. Все области строго следуют друг за другом подряд, т.е. после загрузочного сектора сразу начинается область FAT. Подробности рассмотрим ниже.

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

Наиболее интересные данные указаны в таблице

Первое что нам нужно, это узнать размер загрузочной области. Смотрим адрес 0x0E и видим, что под загрузочную область выделено 4 сектора, т.е. с адреса 4*512 = 0x800 начинается область FAT.

Количество таблиц FAT можно определить по адресу 0x10 загрузочной области. В нашем примере их две, почему две, потому что каждая таблица дублируется резервной, что бы в случае сбоя можно было восстановить данные. Размер таблицы указан по адресу 0x16. Таким образом размер фата 512*2*0xEE = 0x3B800, а корневой каталог начинается с адреса: 0x800 + 0x3B800 = 0x3C000

Внутри корневого каталога все элементы разбиты по 32 байта. Первый элемент, это метка тома, а вот последующие элементы это файлы и папки. Если название файла начинается с 0xE5, то это значит что файл удален. Если название начинается с 0x00, то это значит, что предыдущий файл был последним.

Довольно интересная структура корневого каталога получилась у меня. Карта была отформатирована полностью, затем создано 2 текстовых файла, которые переименованы в MyFile.txt и BigFile.txt.

Как можно увидеть, что помимо моих двух файлов, создалось еще куча левых, о происхождении которых можно только догадываться.

Самое важное, что можно здесь подчерпнуть, это адрес первого кластера, с которого начинаются данные нашего файла. Адрес всегда находится по смещению 0x1A. Например, имя нашего файла MyFile.txt расположено по адресу 0x3C100, к нему прибавляем 0x1A, там видим номер первого кластера. = 0x0002 т.е. второй кластер. Для файла BigFile.txt, данные начинаются с третьего кластера.

Также в корневом каталоге можно узнать еще дату и время, последнего редактирования файла, мне этот вопрос был не очень интересен, поэтому обойду его стороной. Последнее полезное, что может сказать корневой каталог, это свой размер, дабы мы могли найти то, откуда начинаются данные.

Размер указан в загрузочном секторе по адресу 0x11(2байта) = 0x0200*32 = 0x4000 или 16384 байт.

Прибавим к адресу корня его размер: 3С000 + 4000 = 40000 это адрес первого кластера данных, но нам нужен второй, чтобы найти MyFile.txt. Количество секторов в кластере 32, размер кластера = 32*512 = 16384 или 0x4000, поэтому прибавим к адресу первого кластера, его размер т.е. с 0x44000 по идее должен начаться второй кластер.

Идем по адресу 0x44000 и видим, что данные принадлежат BigFile.txt (в нем просто мусор)

Оказывается есть небольшая тонкость, нумерация кластеров начинается со второго, не понятно зачем так сделано но факт, т.е. на самом деле мы перешли на третий кластер. Вернемся на один кластер назад на адрес 0x40000 и видим ожидаемые данные.

Теперь спрашивается. Зачем же нам нужна таблица FAT? Дело в том, что данные могут быть фрагментированы, т.е. начало файла может находиться в одном кластере, а конец в совсем другом. Причем это могут быть совершенно разные кластеры. Их может быть несколько, разбросанных в разных областях данных. Таблица FAT это своего рода карта, которая нам указывает, как нам перемещаться между кластерами.

Приведем пример, в файле BigFile.txt запихано куча рандомного мусора, чтобы занимал не один кластер, а несколько. Идем туда, где начинается таблица FAT и смотрим ее содержание.

Первые восемь байт 0xF8FFFFFF это идентификатор начала таблицы фат. Дальше идет 2 байта, которые относятся к MyFile.txt, то что в них записано 0xFFFF означает, что файл занимает всего один кластер. А вот следующий файл BigFile.txt начинается в третьем кластере, это мы помним из корневой директории, продолжается в четвертом, далее идет в 5,6,7… и заканчивается в 12, т.е. занимает 10 кластеров.

Проверим, действительно ли это так. Файл весить 163кБ, т.е. занимает 163000/(32*512) = 9.9 кластеров, что вполне походит на ожидаемое. Повторимся еще раз, что один элемент в таблице FAT занимает 2 байта, т.е. 16 бит, отсюда и пошло название FAT16. Соответственно максимальный адрес равен 0xFFFF, т.е. максимальный объем для FAT16 0xFFFF*размер кластера.

Перейдем к FAT32. Загрузочная часть немного изменена.

Есть некоторые принципиальные изменения. Имя файловой системы перекочевало по адресу 0x52, размер корневого теперь игнорируется. Область данных находится сразу за таблицами FAT, корневой каталог находится внутри области данных. Кроме того корневой каталог не имеет фиксированного размера.

Адрес области данных вычисляется:
размер загрузочного сектора + таблицы FAT, в моем случае получилось:
746496 + (3821056 * 2) = 0x800000

Адрес корневого каталога вычисляется:
(номер первого кластера корневого каталога — 2) * размер кластера + адрес начала области данных,
т.е. в данном примере он будет совпадать с началом области данных.

Как и прежде данные в корневом занимают 32байта, как и прежде «удаленные» магические файлы, предполагаю это временные файлы блокнота.

А вот начало первого кластера в MYFILE.txt определяется теперь двумя байтами, старший по смещению 0x14, младший как и прежде 1A. Поэтому номер первого кластера данных для файла будет:
8000A0 + 0x14 = 0x8000B4 — старший байт
8000A0 + 0x1A = 0x8000BA — младший байт
В моем случае карта была всего с одним файлом, поэтому это третий кластер.

Таблица FAT ищется как и в предыдущем случае, только теперь элементы занимают 4 байта, отсюда и название FAT32. Идеология расположения элементов в точности как в предыдущем случае.

Полезняшки для таблицы
F8 FF FF F0 — первый кластер
FF FF FF 0F — последний кластер
FF FF FF F7 — поврежденный кластер

Где же находятся данные?
начало области данных + размер кластера * (номер кластера корневого — 1)
= 0x800000 + (2*4096) = 0x801000

Надеюсь в общих чертах стало понятно, вроде как ничего сверхестественного нет. Кто прочитал и повторил может скушать печеньку 🙂

NTFS, FAT или exFAT это совершенно разные файловые системы, которые могут использоваться для хранения данных на различных носителях. Обе созданы в компании Microsoft и в основном используются для Windows, но поддержка в ядре Linux для них тоже есть.

Чаще всего NTFS используется для установки операционной системы Windows или разделов Windows для файлов, в то время как FAT часто применяется на флешках или других внешних накопителях. Также FAT может часто использоваться в качестве основной файловой системы для Android. В этой статье мы рассмотрим различия FAT и NTFS, подробно разберем чем они отличаются и зачем нужны.

Файловая система устанавливает основные правила того как будут организованны данные при записи на носитель, независимо от того, что это - жесткий диск или флеш накопитель. Файловая система описывает каким образом будут организованы папки.

Определенная часть данных под названием файл размещается в нужной области накопителя. Файловая система выполняет все необходимые вычисления, а также определяет минимальный неделимый размер блока данных, максимальный размер файла, следит за фрагментацией. Существует множество различных типов файловых систем, это, например, файловые системы для установки ОС, для внешних носителей, для оптических дисков, распределенные файловые системы. Но в этой статье мы только выполним сравнение fat и ntfs.

Что такое файловая система FAT?

Файловые системы fat32 и ntfs очень сильно отличаются. FAT расшифровывается как File Allocation Table. Это очень давняя файловая система в истории вычислительных систем. Ее история началась в 1977 году. Тогда была разработана 8 битная файловая система, которая использовалась в NCR 7200 на основе Intel 8080. Это был терминал ввода, который работал с гибкими дисками. Файловая система была написана сотрудником Microsoft, Марком Макдональдом после обсуждения ее концепции с Билом Гейтсом.

Затем файловая система FAT начала использоваться в операционной системе MDOS для платформы Z80. Спустя несколько лет были выпущены новые версии, такие как FAT12, FAT16 и FAT32.

FAT32 увеличила максимальный размер тома до 16 Тб, по сравнению с FAT16. Также был увеличен размер файла до 4 Гб. File Allocation Table 32 бит вышла в августе 1995 года для Windows 95. Но эта файловая система все еще не может использоваться для установки тяжелых приложений или хранения больших файлов. Поэтому Microsoft разработала новую файловую систему - NTFS, которая лишена таких недостатков.

FAT32 - это отличная файловая система для внешних носителей, если вам нужно передавать файлы размером не более чем 4 Гб. Она поддерживается множеством различных устройств, таких как фотоаппараты, камеры, музыкальные плееры. Все версии Windows и дистрибутивы Linux полностью поддерживают FAT32. Даже Apple MacOS ее поддерживает.

Что такое файловая система NTFS?

Для своих новых систем Microsoft разработала новую файловую систему - New Technology File System или NTFS. Она появилась в 1993 году, в Windows NT 3.1. NTFS сняла многие ограничения на размеры файлов и диска. Ее разработка началась еще в далеком 1980 году, в результате объединения Microsoft и IBM для создания новой файловой системы с улучшенной производительностью.

Но сотрудничество компаний продлилось недолго, и IBM выпустила HPFS, которая использовалась в OS/2, а в Microsoft создали NTFS 1.0. Максимальный размер одного файла в NTFS может достигать 16 экзабайт, а это значит, что в ней поместятся даже самые большие файлы.

NTFS 3.1 была выпущена для Windows XP и получила множество интересных улучшений, таких как поддержку уменьшения размера разделов, автоматическое восстановление и символические ссылки, а максимальный размер диска с файловой системой увеличен до 256 ТБ. Это несмотря на максимальный размер файла в 16 Эб.

Из других интересных функций, которые были добавлены позже можно отметить отложенную запись на диск, поддержка дефрагментации, настройка дисковых квот, отслеживание ссылок и шифрование на уровне файлов. При всем этом, NTFS сохраняет совместимость с прежними версиями.

Сейчас это журналируемая файловая система, все действия с файлами заносятся в специальный журнал, с помощью которого файловая система может быть очень быстро восстановлена при повреждениях. NTFS поддерживается в Windows XP и более поздних версиях. Если сравнивать fat или ntfs, то последняя в Linux поддерживается не полностью, возможна запись и восстановление при повреждениях, а в MacOS поддерживается только чтение.

Что такое файловая система exFAT?

Файловая система exFAT - это еще один проект Microsoft по улучшению старой файловой системы. Ее можно исполосовать там, где не подходит FAT32. Она намного легче за NTFS, но поддерживает файлы размером более 4 Гб, и тоже часто применяется на флешках и накопителях. При ее разработке Microsoft использовала свою технологию поиска имен файлов по хэшу, что очень сильно улучшает производительность.

Большинство стран признают патентное право США, поэтому любая реализация exFAT невозможна в любых системах с закрытым или открытым исходным кодом. Но Microsoft хочет чтобы эта файловая система свободно распространялась и использовалась. Поэтому была разработана версия exFAT на основе FUSE под названием fuse-exfat. Она дает полный доступ на чтение и запись. Также была создана реализация на уровне ядра Linux в Samsung, которая сейчас тоже есть в открытом доступе.

Эта файловая система тоже имеет максимальное ограничение на размер файла 16 ЭБ, но она намного легче и не имеет никаких дополнительных возможностей. Если говорить про совместимость, то она полностью поддерживается в Windows, MacOS, Android и Linux.

Различия FAT и Ntfs

А теперь рассмотрим основные различия FAT и NTFS в виде краткого резюме по каждой из файловых систем:

FAT32

• Совместимость: Windows, Mac, Linux, игровые консоли, практически все устройства, имеющие USB порт;
• Плюсы: кроссплатформенность, легкость;
• Минусы: максимальный размер файла 4 ГБ и раздела 16 ГБ, не журналируемая;
• Использование: внешние носители.

NTFS

• Совместимость: Windows, Linux, Xbox One, и только чтение в Mac;
• Плюсы: журналируемая, большие лимиты на размер раздела и файла, шифрование, автоматическое восстановление;
• Минусы: ограниченная кроссплатформенность;
• Использование: для установки Windows.

exFAT

• Совместимость: Windows XP и выше, MacOS X 10.6.5, Linux (fuse), Android;
• Плюсы: большой лимит на размер раздела и файла, легкая по сравнению с NTFS;
• Минусы: Microsoft ограничивает ее использование лицензионным соглашением;
• Использование: для внешних носителей и внешних жестких дисков.

Выводы

В этой статье мы выполнили сравнение fat и ntfs. Это очень разные файловые системы. Но понять какая файловая система лучше fat или ntfs сложно, с одной стороны NTFS имеет намного больше возможностей, но зато FAT более легкая и поддерживается везде, где это возможно. Для разделов данных в Linux, которые должны быть доступны в Windows лучше использовать FAT, а не NTFS, поскольку она поддерживается лучше. А по-вашему что лучше fat или ntfs для Linux?

Файловая система FAT (File Allocation Table - таблица размещения файлов) по­лучила свое название благодаря простой таблице, в которой указываются:

Непосредственно адресуемые участки логического диска, отведенные для раз­мещения в них файлов или их фрагментов;

Свободные области дискового пространства;

Дефектные области диска (эти области содержат дефектные участки и не га­рантируют чтение и запись данных без ошибок).

В файловой системе FAT дисковое пространство любого логического диска де­лится на две области (рис. 6.1): системную область и область данных.

Рис. 6.1. Структура логического диска в FAT

Системная область логического диска создается и инициализируется при форма­тировании, а в последующем обновляется при работе с файловой структурой. Об­ласть данных логического диска содержит обычные файлы и файлы-каталоги; эти объекты образуют иерархию, подчиненную корневому каталогу. Элемент катало-

Файловая система FAT________________________________________________ 167

га описывает файловый объект, который может быть либо обычным файлом, либо файлом-каталогом. Область данных, в отличие от системной области, доступна через пользовательский интерфейс операционной системы. Системная область состоит из следующих компонентов (расположенных в логическом адресном про­странстве друг за другом):

Загрузочной записи (Boot Record, BR);

Зарезервированных секторов (Reserved Sectors, ResSec);

Таблицы размещения файлов (File Allocation Table, FAT);

Корневого каталога (Root Directory, RDir).

Таблица размещения файлов

Таблица размещения файлов является очень важной информационной структу­рой. Можно сказать, что она представляет собой адресную карту области данных, в которой описывается и состояние каждого участка области данных, и принад­лежность его к тому или иному файловому объекту.

Всю область данных разбивают на так называемые кластеры. Кластер представля­ет собой один или несколько смежных секторов в логическом дисковом адресном пространстве (точнее - только в области данных). Кластер - это минимальная адресуемая единица дисковой памяти, выделяемая файлу (или некорневому ката­логу). Кластеры введены для того, чтобы уменьшить количество адресуемых еди­ниц в области данных логического диска.

Каждый файл занимает целое число кластеров. Последний кластер при этом мо­жет быть задействован не полностью, что при большом размере кластера может приводить к заметной потере дискового пространства. На дискетах кластер зани­мает один или два сектора, а на жестких дисках его размер зависит от объема раз­дела (табл. 6.1). В таблице FAT кластеры, принадлежащие одному файлу (или файлу-каталогу), связываются в цепочки. Для указания номера кластера в файло­вой системе FAT 16 используется 16-разрядное слово, следовательно, можно иметь до 2 10 = 65 536 кластеров (с номерами от 0 до 65 535).

Таблица 6.1 . Соотношения между размером раздела и размером кластеров в FAT16

Емкость раздела, Мбайт Количество секторов в кластере Размер кластеров, Кбайт

Заметим, что в Windows NT/2000/XP разделы файловой системы FAT могут иметь размер до 4097 Мбайт. В этом случае кластер будет объединять уже 128 секторов.

Номер кластера всегда относится к области данных диска (пространству, зарезер­вированному для файлов и подкаталогов). Номера кластеров соответствуют эле-

168____________________________________________ Глава 6, Файловые системы

ментам таблицы размещения файлов. Первый допустимый номер кластера всегда начинается с 2.

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

Прежде всего, уменьшается размер самой таблицы FAT; - уменьшается возможная фрагментация файлов;

Ускоряется доступ к файлу, так как в несколько раз сокращается длина цепочек фрагментов дискового пространства, выделенных для него.

Однако слишком большой размер кластера ведет к неэффективному использова­нию области данных, особенно в случае большого количества маленьких файлов. Как мы только что заметили, в среднем на каждый файл теряется около половины кластера. Из табл. 6.1 следует, что при размере кластера в 32 сектора (объем разде­ла при этом - от 512 до 1023 Мбайт), то есть 16 Кбайт, средняя величина потерь на файл равняется 8 Кбайт, и при нескольких тысячах файлов 1 потери могут со­ставлять более 100 Мбайт. Поэтому в современных файловых системах размеры кластеров ограничиваются (обычно от 512 байт до 4 Кбайт), либо предоставляет­ся возможность выбирать размер кластера.

Достаточно наглядно идею файловой системы, использующей таблицу размеще­ния файлов, иллюстрирует рис. 6.2.

Рис. 6.2. Иллюстрация основной концепции FAT

Из рисунка видно, что файл MYFILE.TXT размещается, начиная с восьмого кластера. Всего файл MYFILE.TXT занимает 12 кластеров. Цепочка (chain) кластеров для на­шего примера может быть записана следующим образом: 8, 9,0А, 0В, 15,16,17,19,

1 Например, число 10 000-15 000 файлов (или даже более, особенно когда файлы небольшого разме­ра) на логическом диске с объемом в 1000 Мбайт встречается достаточно часто.

Файловая система FAT 169

1А, 1B, 1С, 1D. Кластер с номером 18 помечен специальным кодом F7 как плохой (bad), он не может быть использован для размещения данных. При форматирова­нии обычно проверяется поверхность магнитного диска, и те сектора, при конт­рольном чтении с которых происходили ошибки, помечаются в FAT как плохие. Кластер 1D помечен кодом FF как конечный (последний в цепочке) кластер, принадлежащий данному файлу. Свободные (незанятые) кластеры помечаются кодом 00; при выделении нового кластера для записи файла берется первый сво­бодный кластер. Возможные значения, которые могут приписываться элементам таблицы FAT, приведены в табл. 6.2.

Таблица 6.2. Значения элементов FAT

Значение Описание

OOOOh Свободный кластер

fffOh-fff6h Зарезервированный кластер

fff7h Плохой кластер

fffSh-ffffh Последний кластер в цепочке

0002h-ffefh Номер следующего кластера в цепочке

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

В связи с тем, что таблица FAT используется при доступе к диску очень интенсив­но, она обычно загружается в оперативную намять (в буферы ввода-вывода или в кэш) и остается там настолько долго, насколько это возможно. Если таблица боль­шая, а файловый кэш, напротив, относительно небольшой, в памяти размещаются только фрагменты этой таблицы, к которым обращались в последнее время.

В связи с чрезвычайной важностью таблицы FAT она обычно хранится в двух иден­тичных экземплярах, второй из которых непосредственно следует за первым. Об­новляются копии FAT одновременно, используется же только первый экземпляр. Если он по каким-либо причинам окажется разрушенным, то произойдет обраще­ние ко второму экземпляру. Так, например, утилита проверки и восстановления файловой структуры ScanDisk из ОС Windows 9x при обнаружении несоответствия первичной и резервной копии FAT предлагает восстановить главную таблицу, ис­пользуя данные из копии.

Корневой каталог отличается от обычного файла-каталога тем, что он помимо раз­мещения в фиксированном месте логического диска имеет еще и фиксированное число элементов. Для каждого файла и каталога в файловой системе хранится ин­формация в соответствии со структурой, представленной в табл. 6.3.

Для работы с данными на магнитных дисках в системах DOS, которые имеют файло­вую систему FAT, удобно использовать широко известную утилиту Disk Editor из

170___________________________________________ Глава 6. Файловые системы

комплекта утилит Питера Нортона. У нее много достоинств. Прежде всего, она ком­пактна, легко размещается на системной дискете с MS DOS, снабжена встроенной системой подсказок и необходимой справочной информацией. Используя ее, можно сохранять, модифицировать и восстанавливать загрузочную запись, восстанавливать таблицу FAT в случае ее повреждения, а также выполнять много других операций. Основными недостатками этой программы на сегодняшний день являются ограниче­ния на размеры диска и разделов и отсутствие поддержки работы с такими распрост­раненными файловыми системами, как FAT32 и NTFS. Вместо нее теперь часто ис­пользуют утилиту Partition Magic, однако наилучшей альтернативой этой программе на сегодняшний день можно считать утилиту Администратор дисков от Acronis.

Таблица 6.3. Структура элемента каталога

Размер поля данных, байт Содержание поля

11 Имя файла или каталога

1 Атрибуты файла

1 Резервное поле

3 Время создания

2 Дата создания

2 Дата последнего доступа

2 Зарезервировано

2 Время последней модификации

2 Дата последней модификации

2 Номер начального кластера в FAT

4 Размер файла

Структура загрузочной записи DOS

Сектор, содержащий системный загрузчик DOS, является самым первым на логи­ческом диске С:. Напомним, что на дискете системный загрузчик размещается в са­мом первом секторе; его физический адрес равен 0-0-1. Загрузочная запись состо­ит, как мы уже знаем, из двух частей: блока параметров диска (Disk Parameter Block, DPB) и системного загрузчика (System Bootstrap, SB). Блок параметров диска слу­жит для идентификации физического и логического форматов логического диска, а системный загрузчик играет существенную роль в процессе загрузки DOS. Эта информационная структура приведена в табл. 6.4.

Первые два байта загрузочной записи занимает команда безусловного перехода (JMP) на программу SB. Третий байт содержит код 90Н (NOP - нет операции). Да­лее располагается восьмибайтовый системный идентификатор, включающий ин­формацию о фирме-разработчике и версии операционной системы. Затем следует блок параметров диска, а после него - системный загрузчик.

Для работы с загрузочной записью DOS, как и с другими служебными информа­ционными структурами, удобно использовать уже упомянутую программу Disk

Файловая система FAT________________________________________________ 171

Editor из комплекта утилит Питера Нортона. Используя ее, можно сохранять, мо­дифицировать и восстанавливать загрузочную запись, а также выполнять много других операций. Достаточно подробно работа с этой утилитой описана в .

Таблица 6.4. Структура загрузочной записи для FAT16

Смещение поля, Длина поля, Обозначение Содержимое поля
байт байт поля

ООН (0) 3 JUMP 3EH Безусловный переход на начало

системного загрузчика

ОЗН (3) 8 Системный идентификатор

ОВН (11) 2 SectSize Размер сектора, байт

ООН (13) 1 ClastSize Число секторов в кластере

0ЕН(14) 2 ResSecs Число зарезервированных секторов

10Н (16) 1 FATcnt Число копий FAT

11Н (17) 2 RootSize Максимальное число элементов Rdir

13Н (19) 2 TotSecs Число секторов на логическом диске,

если его размер не превышает 32 Мбайт; иначе 0000Н

15Н (21) 1 Media Дескриптор носителя

16Н(22) 2 FATsize Размер FAT, секторов

18Н(24) 2 TrkSecs Число секторов на дорожке

1АН(26) 2 HeadCnt Число рабочих поверхностей

1СН(28) 4 HidnSecs Число скрытых секторов

20Н (32) 4 Число секторов на логическом диске,

если его размер превышает 32 Мбайт

24Н (36) 1 Тип логического диска (ООН - гибкий,

80Н - жесткий)

25Н (37) 1 Зарезервировано

26Н (38) 1 Маркер с кодом 29Н

27Н (39) 4 Серийный номер тома 1

2ВН (43) 11 Метка тома

36Н (54) 8 Имя файловой системы

ЗЕН (62) Системный загрузчик

1FEH (510) 2 Сигнатура (слово АА55Н)

1 Том (volume) представляет собой единое логическое адресное пространство. Томом может быть обыч­ный логический диск либо несколько дисковых пространств.