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 с.

Вконтакте

vfat - реализация файловых систем MS-DOS FAT/FAT32 в Linux. man mount(8)

Типичный набор опций монтирования vfat для UTF-8 локали (пропускаем опции значение по-умолчанию которых нас устаривает):

uid=user_name,gid=group_name,fmask=0113,dmask=0002,codepage=866,utf8,shortname=winnt,quiet

Для не-UTF8 локали, а это скорей всего KOI8-R локаль (не забывая теперь обязательное для RHEL/CentOS "utf8=no"):

uid=user_name,gid=group_name,fmask=0113,dmask=0002,codepage=866,iocharset=koi8-r,utf8=no,shortname=winnt,quiet

или учитывая что "uni_xlate" отключает "utf8", тем боле что уж лучше видеть закодированные имена файлов/директорий с которыми можно как-то обращаться чем неразличимые строчки из "?":

uid=user_name,gid=group_name,fmask=0113,dmask=0002,codepage=866,iocharset=koi8-r,uni_xlate,shortname=winnt,quiet

user_name и group_name - имена пользователя и группы которым предоставляется доступ на чтение/запись в монтируемый раздел FAT/FAT32 в соответствии с установленными fmask и dmask

Общие опции монтирования варьируются в зависимости от того, монтируем через командную строку или через запись в /etc/fstab, или в зависимости от необходимости автомонтирования при загрузке, режима rw/ro, или предоставления возможности монтирования/размонтирования раздела пользователями. Обычно используются: rw,async
В целях безопасности для FAT/FAT32 разделов можно явно указать: nodev,nosuid,noexec
Для ускорения можно использовать: noatime,nodiratime

Опции монтирования перечислены в man mount(8) в разделах "Mount options for fat" и "Mount options for vfat".
Mount options for fat
=====================

blocksize=512 / blocksize=1024 / blocksize=2048
Set blocksize (default 512).
Размер блока ввода/вывода.

uid=value and gid=value
Set the owner and group of all files. (Default: the uid and gid of the current process.)

Поскольку в FAT/FAT32 нет поддержки прав владения и доступа к файлам и директориям, то весь
раздел по-умолчанию монтируется с идентификаторами uid и gid владельца процесса
осуществляющего монтирование. Можно указать нужного пользователя и группу от имени которого
будет монтироваться раздел FAT/FAT32. Это могут быть как числовые значения идентификаторов
так и имена пользователя/группы, по крайней мере из командной строки проходит простое
задание имени пользователя/группы.

umask=value
Set the umask (the bitmask of the permissions that are not present). The default is the umask
of the current process. The value is given in octal.

dmask=value
Set the umask applied to directories only. The default is the umask of the current process.
The value is given in octal.

fmask=value
Set the umask applied to regular files only. The default is the umask of the current process.
The value is given in octal.

umask, dmask, fmask - маски прав доступа для файлов/директорий (umask) либо отдельно для
директорий (dmask) и отдельно для файлов (fmask). Фактически через них устанавливаются права
владельца (u), группы (g) и прочих пользователей (o) для всех файлов и дерикторий на монтируемом
разделе vfat. Задаётся в виде восьмиричного числа. (Кстати запись восьмеричного значения
не обязательно должна начинаеться с нуля.)

check=value
Three different levels of pickyness can be chosen:
r
Upper and lower case are accepted and equivalent, long name parts are truncated
(e.g. verylongname.foobar becomes verylong.foo), leading and embedded spaces are
accepted in each name part (name and extension).
n
Like "relaxed", but many special characters (*, ?, This is the default.
s
Like "normal", but names may not contain long parts and special characters that
are sometimes used on Linux, but are not accepted by MS-DOS are rejected.
(+, =, spaces, etc.)

Управляет проверкой создаваемых имён файлов/директорий на разделе vfat, чтоб они соответсвовали
принятым в FAT/FAT32 правилам и ограничениям. По-умолчанию "n".

codepage=value
Sets the codepage for converting to shortname characters on FAT and VFAT filesystems.
By default, codepage 437 is used.

Параметр монтирования который лучше указать. Задаёт досовскую кодовую страницу в которой
сохраняются создаваемые короткие (в формате 8.3) досовские имена файлов и директорий.
Тем кто ещё работал в досе и настраивал её эту цифру не забыть - для нормального
чтения/сохранения русских имён - codepage=866

conv=b / conv=t / conv=a
The fat file system can perform CRLFNL (MS-DOS text format to UNIX text format) conversion
in the kernel. The following conversion modes are available:
binary - No translation is performed. This is the default.
text - CRLFNL translation is performed on all files.
auto - CRLFNL translation is performed on all files that don’t have a "well-known
binary" extension. The list of known extensions can be found at the beginning
of fs/fat/misc.c (as of 2.0, the list is:
exe, com, bin, app, sys, drv, ovl, ovr, obj, lib, dll, pif, arc, zip, lha, lzh,
zoo, tar, z, arj, tz, taz, tzp, tpz, gz, tgz, deb, gif, bmp, tif, gl, jpg, pcx,
tfm, vf, gf, pk, pxl, dvi).
Programs that do computed lseeks won’t like in-kernel text conversion.
Several people have had their data ruined by this translation. Beware!
For file systems mounted in binary mode, a conversion tool (fromdos/todos) is available.

Попытки облегчить перенос текстовых файлов из UNIX-like системы в MS-DOS путём автоматичексой
замены CRLFNL на лету. Лучше пользоваться если нужно для конкретных файлов командными
утилитами конвертации dos2unix и unix2dos из одноимённых пакетов, или же универсальной iconv
идущей в составе пакета glibc-common.

cvf_format=module
Forces the driver to use the CVF (Compressed Volume File) module cvf_module instead of
auto-detection. If the kernel supports kmod, the cvf_format=xxx option also controls

cvf_option=option
Option passed to the CVF module.

cvf_format, cvf_option - параметры указывающие на конкретный модуль CVF и его опций
для загрузки ядром. Что это такое не хочется разбираться.

debug
Turn on the debug flag. A version string and a list of file system parameters will be printed
(these data are also printed if the parameters appear to be inconsistent).

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

fat=12 / fat=16 / fat=32
Specify a 12, 16 or 32 bit fat. This overrides the automatic FAT type detection routine.
Use with caution!

Вместо автоопределения типа FAT можно указать конкретную её версию.

iocharset=value
Character set to use for converting between 8 bit characters and 16 bit Unicode characters.
The default is iso8859-1.
Long filenames are stored on disk in Unicode format.

Вот этот параметр следует указать, если используется не-UTF8 пользовательская/системная локаль.
Как написано длинные имена файлов и директорий сохраняются в разделе VFAT в формате Юникод.
Для того чтобы при передаче в настроенные на не-UTF8 локаль пользовательске приложения,
символы из Юникод конвертировались в подходящий для этой локали восьмибитный код, необходимо
задать нужную табицу преобразования iocharset.
По-умолчанию, если не указывать, iocharset=ascii, т.е. подразумевается что длинные имена
файлов/каталогов состоят из символов из набора ASCII, для которых производится тривиальное
(один-в-один) преобразование кодов UnicodeASCII.
Для KOI8-R локали следует указать таблицу преобразования символов в коды KOI8-R из символов
Юникод - iocharset=koi8-r (посмотреть можно в /usr/share/i18n/charmaps/KOI8-R.gz).
Задание iocharset имеет смысл только если в системе (или для конкретного пользователя,
для которого монтируется раздел) используется не-UTF8 локаль.
Для UTF-8 локали опцию iosharset пропускаем и монтировать раздел необходимо со специально
предназанченной для этого случая самостоятельной опцией "utf8" (см. описание далее).

quiet
Turn on the quiet flag. Attempts to chown or chmod files do not return errors, although they fail.
Use with caution!

Подавляет сообщения об ошибке при попытке выполнить "chown" или "chmod" для файлов на разделе
FAT/FAT32. Вообще, хоть и предупреждают пользоваться этой опцией с осторожностью, но она делает
повседневную работу с разделами vfat более удобной, прозрачно пропуская запросы приложений
на выполнение неподдерживаемых FAT/FAT32 функций, которые время от времени постоянно возникают.
Например, при создании резервной копии редактируемого файла в gedit или при использованиий rsync
с обычной опцией "-a". Просто нужно помнить что раздел с которым работаешь - FAT/FAT32 и
учитывать, что помещённые на него файлы всегда приобретают владельца и режим доступа указанный
при монтировании. В отсутствие этой опции помнить об этом также приходится, потому что постоянно
получаешь ошибки выполнения операции бэкапа (нужно например специально прописывать опции rsync)
или предупреждения при перемещении файлов из-за невозможности сменить их владельца и время.
Осмотрительность надо проявлять при обратных операциях - получения файлов с разделов vfat
с установкой владельца.

sys_immutable, showexec, dots, nodots, dotsOK=
Various misguided attempts to force Unix or DOS conventions onto a FAT file system.

Различные с переменным успехом попытки привести в соответсвие Unix- и DOS- соглашения для
файловой системы FAT. Пример и описание использования параметра "showexec" можно посмотреть в этой одной из редких не содержащих ошибочных сведений статье: http://citkit.ru/articles/147/

Mount options for vfat
======================

uni_xlate
Translate unhandled Unicode characters to special escaped sequences. This lets you backup
and restore filenames that are created with any Unicode characters. Without this option,
a ’?’ is used when no translation is possible. The escape character is ’:’ because it is
otherwise illegal on the vfat filesystem. The escape sequence that gets used, where u is
the unicode character, is: ’:’, (u & 0x3f), ((u>>6) & 0x3f), (u>>12).

Это тоже полезная опция при работе в не-UTF8 локали. В длинных именах файлов/директорий
могут встречаться любые символы Юникод, в том числе и не попадающие в тот набор из 256
символов, который указан в таблице конвертации в параметре iocharset=. Такие символы
отображаются как ’?’, или если указана данная опция они представляются специальными
escape-последовательностями. Символ экранирования - двоеточие ’:’, потому что он запрещён
в досовских именах и точно никогда в них не встречается. Потенциально при этой включённой
опции можно управляться с файлами имена которых содержат любые из символов Юникод.
Имена выглядят забавно: например файл с именем "тест" будет показываться
как ":0442:0435:0441:0442". Фаил с таким именем можно создать, скопировать,
записать, переименовать например в ":0442:0435:0441:0441", и это будет досовское имя "тесс".
Но вот например синхронизация директорий с такими escape-последовательностями в имени
с помощью rsync не будет работать, очевидно потому что rsync ничего не знает о подобных
преобразованиях имён.

posix
Allow two files with names that only differ in case.

Разрешает создание двух файлов с именами различающимися только регистром.

nonumtail
First try to make a short name without sequence number, before trying name~num.ext.

При создании короткого досовского имени пытается сначала создать его без обычных тильды
с номером в конце имени.

utf8
UTF8 is the filesystem safe 8-bit encoding of Unicode that is used by the console.
It can be be enabled for the filesystem with this option.
If ‘uni_xlate’ gets set, UTF8 gets disabled.

Включает UTF-8 кодирование символов Юникод при передачи их в пользовательские приложения
работающие в UTF-8 локали. Очевидно что это то, что нужно в обычных условиях.
Если установлена опция "uni_xlate", то опция "utf8" отключается.

Теоретически в UTF-8 локали можно не использовать опцию "utf8", а задать iocharset=utf8.
В исходниках fs/fat/inode.c встречаем такое предупреждение:
1105 /* UTF-8 doesn"t provide FAT semantics */
1106 if (!strcmp(opts->iocharset, "utf8")) {
1107 printk(KERN_ERR "FAT: utf8 is not a recommended IO charset"
1108 " for FAT filesystems, filesystem will be case sensitive!\n");
1109 }
shortname=
Defines the behaviour for creation and display of filenames which fit into 8.3 characters.
If a long name for a file exists, it will always be preferred display. There are four modes:
lower - Force the short name to lower case upon display;
win95 - Force the short name to upper case upon display;
store a long name when the short name is not all upper case.
winnt - Display the shortname as is;
store a long name when the short name is not all lower case or all upper case.
mixed - Display the short name as is;
store a long name when the short name is not all upper case.
The default is "lower".

Определяет то, как создаются и отображаются имена файлов и директорий которые сами по себе
имеют формат 8.3. Если для файла существует длинное имя, то будет выводиться оно,
т.к. всегда имеет приоритет. Имеется четыре режима, как описано. По-умолчанию - "lower".
Думается что более естественно использовать "winnt".

После монтирования раздела проверить опции с которыми он смонтировался можно по "cat /proc/mounts".

В RedHat/CentOS замечена одна особенность: vfat раздел всегда монтируется с включённой опцией "utf8", даже если она не указана в командной строке. Это происходит также в не-UTF8 локали, что приводит к тому что имена файлов состоящие из не-ascii символов отображаются неверно (как обычно это выглядит когда юникод строку пытаются вывести с помощью какой-либо кодовой таблицы из 256 восьмибитовых символов). Это является результатом патча бага Анаконды https://bugzilla.redhat.com/show_bug.cgi?id=181963 , когда вместо исправления ошибки в настройках инсталляторя просто пропатчили ядро на предмет чтобы по умолчанию vfat разделы монтировались с включённой опцией "utf8", т.к. типа всё равно все уже давно работают только в UTF-8 локали. Но при этом забыли упомянуть в man-странице как отключать эту опцию https://bugzilla.redhat.com/show_bug.cgi?id=515149

В том же fs/fat/inode.c можно посмотреть недокументированные параметры, которые можно задать для управления опциями, в том числе для отключения "utf8":
905 static match_table_t vfat_tokens = {
906 {Opt_charset, "iocharset=%s"},
907 {Opt_shortname_lower, "shortname=lower"},
908 {Opt_shortname_win95, "shortname=win95"},
909 {Opt_shortname_winnt, "shortname=winnt"},
910 {Opt_shortname_mixed, "shortname=mixed"},
911 {Opt_utf8_no, "utf8=0"}, /* 0 or no or false */
912 {Opt_utf8_no, "utf8=no"},
913 {Opt_utf8_no, "utf8=false"},
914 {Opt_utf8_yes, "utf8=1"}, /* empty or 1 or yes or true */
915 {Opt_utf8_yes, "utf8=yes"},
916 {Opt_utf8_yes, "utf8=true"},
917 {Opt_utf8_yes, "utf8"},
918 {Opt_uni_xl_no, "uni_xlate=0"}, /* 0 or no or false */
919 {Opt_uni_xl_no, "uni_xlate=no"},
920 {Opt_uni_xl_no, "uni_xlate=false"},
921 {Opt_uni_xl_yes, "uni_xlate=1"}, /* empty or 1 or yes or true */
922 {Opt_uni_xl_yes, "uni_xlate=yes"},
923 {Opt_uni_xl_yes, "uni_xlate=true"},
924 {Opt_uni_xl_yes, "uni_xlate"},
925 {Opt_nonumtail_no, "nonumtail=0"}, /* 0 or no or false */
926 {Opt_nonumtail_no, "nonumtail=no"},
927 {Opt_nonumtail_no, "nonumtail=false"},
928 {Opt_nonumtail_yes, "nonumtail=1"}, /* empty or 1 or yes or true */
929 {Opt_nonumtail_yes, "nonumtail=yes"},
930 {Opt_nonumtail_yes, "nonumtail=true"},
931 {Opt_nonumtail_yes, "nonumtail"},
932 {Opt_err, NULL}
933 };

Эту файловую систему используют такие операционные системы, как Windows NT/2000/XP. При установке NTFS, диск разделяется на две неравные части: первая отводиться под MFT (Master File Table - общая таблица файлов), называется MFT - зоной и занимает порядка 12% от общего размера диска, вторую часть занимают собственно Ваши данные. Есть еще и третья зона, но о ней позже. Что за зверь этот MFT? Это основа NTFS. Он лежит, как было сказано ранее, в MFT - зоне т. е. в начале диска. Каждая запись в MFT соответствует какому-либо файлу и занимает около 1 Kb. По своей сути это каталог всех файлов находящихся на диске. Надо заметить, что любой элемент данных в NTFS рассматривается как файл, даже MFT. Первые 16 файлов (метафайлы) в MFT - зоне являются особой кастой. В них содержится служебная информация, они имеют фиксированное положение и они недоступны даже операционной системе. Кстати, первым из этих 16 является сам MFT - файл. Существует копия первых трех записей. Помните, я говорил о третьей зоне, так вот там она и лежит и своим положением, если можно так выразиться, делит диск пополам. Зачем это сделано? Да для надежности, в случае утери информации в MFT - файле, всегда можно восстановить информацию, а там уже дело техники, как говориться. Все остальные файлы в MFT - зоне могут располагаться произвольно. Надо заметить, что в MFT - зоне теоретически кроме служебных файлов ничего не находиться. Но бывают случаи, когда места на той части диска, что отведена для пользователя не остается:-(и тогда MFT - зона уменьшается. Соответственно появляется место во второй половине диска для записи данных. Когда же в этой зоне освобождается достаточное количество свободного места, MFT - зона опять расширяется. И вот тут то появляется проблема. В MFT - зону попадают обычные файлы и она начинает фрагментироваться. Это не смертельно конечно, но и приятного тут мало. Но вернемся к нашим баранам, то бишь метафайлам. Каждый из них отвечает за какую-либо область работы. Начинаются они с символа имени $ (тем, кто занимается программированием значок известен). Приведу пример некоторых из них:

• MFT - не что иное как сам MFT
• MFTmirr - та самая копия, что по серединке диска
• LogFile - это файл журналирования
• Boot - как видно из названия, его величество загрузочный сектор
• Bitmap - карта свободного места раздела

Ну и так далее. Информация о метафайлах находиться в MFT - файле. Сложно? Есть такое дело. Но вся эта фигня придумана для увеличения надежности NTFS и себя оправдывает. Едем дальше. NTFS практически не имеет ограничения на размеры диска (во всяком случае при нынешних технологиях производства жестких дисков). Размер кластера может варьироваться от 512 b до 64 Kb, хотя обычный его размер равен 4 Kb.

Поговорим теперь о каталоге. Это метофайл с обозначением $. . Он разделен на части в каждой из которых содержится имя файла, его атрибуты и ссылка на MFT - файл. А там уже есть вся остальная информация. Каталог представляет собой бинарное дерево. Попробуем разобраться, что это за фигня такая. В каталоге информация о данных на диске расположена таким образом, что при поиске какого-либо файла каталог разбивался на две части и ответ заключался в том, в какой именно части находиться искомое. Затем та же самая операция повторяется в выбранной половине. И так до тех пор, пока не будет найден нужный файл.

А теперь о файлах. Их как таковых нет. Нормально, да! Есть так называемые стримы, или говоря нормальным русским языком - потоки. То есть, любая единица информации представляет собой несколько потоков. Один поток - это сами данные, он является основным. Другие потоки - атрибуты файла. К любому файлу можно прикрепить любой другой файл. Проще говоря, к потокам одних данных можно прикрепить совершенно новый поток и записать туда новые данные. Вот только информация по объему файла берется по объему основного потока. Пустые или малоразмерные файлы на диске отображены только в метафайлах. Сделано это в целях экономии дискового пространства. Вообще надо отметить, что понятие файл намного глубже и шире и все свойства описать довольно сложно. Отмечу, что максимальная длина имени файла может достигать 255 символов.

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

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

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

И наконец в NTFS есть еще две такие функции, как Symbolic Links - возможность создания виртуальных каталогов, и Hard Links - поддержка нескольких имен для одного и того же файла.Вот пожалуй что и все.

На данный момент времени эта файловая система является самой распространенной, хотя и сдает постепенно свои позиции после выхода Windows XP. Поддерживают FAT 32 все операционные системы семейства Windows начиная с Windows 95 OSR2. Итак, FAT 32 (File Allocation Table) - это электронная таблица размещения файлов. Находиться она практически в самом начале диска. Структура диска FAT:

1. загрузочные секторы главного и дополнительного разделов;

2. загрузочный сектор логического диска;

3. корневой каталог;

4. область данных;

5. цилиндр для выполнения диагностических операций чтения/записи;

Основное преимущество FAT 32 перед FAT 16 заключается в том, что вместо 16 разрядных записей используются 32х разрядные. Это в свою очередь увеличивает количество кластеров в разделе до 268 435 456 (в FAT - 65 536). При использовании FAT 32 размер тома равен 2 Tb, а размер одного файла может достигать 4 Gb. Заметное отличие FAT 32 от предшествующих таблиц заключается в том, что корневой каталог не занимает фиксированного места на диске и может иметь любой размер.

Размер кластера при использовании FAT 32 в разделе размером 2 Gb с 5 000 файлами равен 4 Kb (в FAT 16 - 32 Kb), в таблице будет использоваться до 524 288 записей. При этом сама таблица будет весить порядка 2 Мb.

Сравнение NTFS и FAT 32.

Ну что, займемся неблагодарным делом - сравнением двух файловых систем.

Достоинства:

1. Быстрая скорость доступа к файлам малого размера;

2. Размер дискового пространства на сегодняшний день практически не ограничен;

3. Фрагментация файлов не влияет на саму файловую систему;

4. Высокая надежность сохранения данных и собственно самой файловой структуры;

5. Высокая производительность при работе с файлами большого размера;

Недостатки:

1. Более высокие требования к объему оперативной памяти по сравнению с FAT 32;

2. Работа с каталогами средних размеров затруднена из-за их фрагментации;

3. Более низкая скорость работы по сравнению с FAT 32

Достоинства:

1. Высокая скорость работы;

2. Низкое требование к объему оперативной памяти;

3. Эффективная работа с файлами средних и малых размеров;

4. Более низкий износ дисков, вследствие меньшего количества передвижений головок чтения/записи.

Недостатки:

1. Низкая защита от сбоев системы;

2. Не эффективная работа с файлами больших размеров;

3. Ограничение по максимальному объему раздела и файла;

4. Снижение быстродействия при фрагментации;

5. Снижение быстродействия при работе с каталогами, содержащими большое количество файлов;

Итак, некоторые соображения. Обе файловые системы хранят данные в кластерах минимальный размер которого равен 512 b. Как правило обычный размер кластера равен 4 Kb. На этом сходства пожалуй и заканчиваются. Кое-что о фрагментации: скорость работы NTFS резко снижается при заполнении диска на 80 - 90 %. Это связано с фрагментацией служебных и рабочих файлов. Чем больше Вы работаете с таким загруженным диском, тем сильнее фрагментация и тем ниже производительность. В FAT 32 фрагментация рабочей области диска происходит и на более ранних этапах. Дело тут зависит от того, насколько часто Вы записываете/стираете данные. Как и в NTFS, фрагментация сильно снижает производительность. Теперь об оперативной памяти. Объем самой электронной таблицы FAT 32 может занимать в ОЗУ порядка нескольких мегабайт. Но на помощь приходит кэширование. Что записывается в кэш:

1. Наиболее используемые каталоги;

2. Данные о всех используемых в данный момент времени файлах;

3. Данные о свободном пространстве диска;

А что же NTFS? Кэшированию трудно поддаются каталоги больших размеров, а они могут достигать размеров нескольких десятков мегабайт. Плюс MFT, плюс информация о свободном месте на диске. Хотя надо заметить, что NTFS все же довольно экономно расходует ресурсы оперативной памяти. В наличии удачная система хранения данных, в MFT каждая запись примерно равна 1 Kb. Но все же требования к объему ОЗУ выше, чем для FAT 32. Короче, если Ваша память меньше или равна 64 Mb, то эффективнее с точки зрения скорости окажется FAT 32. Если больше - разница в скорости будет маленькая, а зачастую вообще никакой. Теперь о самом жестком диске. Для использования NTFS желательно наличие Bus Mastering. Что это? Это особый режим работы драйвера и контроллера. При использовании BM обмен происходит без участия процессора. Отсутствие ВМ скажется на производительности системы. Кроме этого, вследствие использования более сложной файловой системы количество движений головок чтения/записи возрастает, что так же влияет на скорость. Наличие дискового кэша одинаково положительно сказывается, как на NTFS, так и на FAT 32.

Вы знаете, что Windows Phone использует NTFS? Почему большинство карт памяти и почти все USB-накопители по-прежнему используют старый-добрый FAT? Почему вы можете хранить полноразмерные HD-фильмы на некоторых флеш-накопителях и не можете на других? Почему некоторые устройства поддерживают только карты памяти SDHC до 32 ГБ, и что можно сделать, чтобы заставить их использовать 64 ГБ SDXC? Эти и многие другие вопросы связаны с типом файловой системы, используемой конкретным устройством хранения. Но как это связано с Windows?