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

Вконтакте

Форматирование флэш-накопителя - это не только быстрый способ очищения его от ненужных файлов, но и выбор определенной файловой системы, которая позволит без проблем считывать информацию с этого носителя самым разнообразным устройствам: ПК, лаптопам, магнитолам, телевизорам, DVD-проигрывателям, игровым приставкам и т.д. Поэтому для начала разберем, в какой системе форматировать флешку лучше всего именно для вас, коснувшись особенностей каждой. Затем подробно остановимся на алгоритмах форматирования для популярных FAT32 и NTFS.

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

Файловой системой называется вариант организации данных на том или ином носителе. У каждой ОС (а ею обладает даже музыкальный проигрыватель) своя такая система, с ней гармонично совместимая. Или даже несколько. Таким образом, форматируя внешний или жесткий диск в определенной файловой системе, вы прежде всего определяетесь, какая ОС сможет его прочесть.

Многие считают, что возможно только форматировать флешку в FAT32 или NTFS, однако это заблуждение. Файловых систем гораздо больше. Перечислим наиболее известные:

• На Windows: FAT32, exFAT, NTFS.
• На Mac OS: HFS+.
• На Linux: EXT2, EXT3.

Познакомимся с каждой из них поподробнее.

FAT32

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

Это тот редкий формат, который поддерживается всеми ОС и практически всеми игровыми консолями и прочими устройствами с USB. Но FAT32 ставит следующие ограничения: размер одного файла на диске не должен быть более 4 Гб, а одного раздела - не более 8 Тб.

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

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

NTFS

Еще один продукт "Майкрософт". Работать с флэш-накопителем, отформатированным в этой системе, может в основном Windows, иногда - Linux. "Яблочная" техника сможет его только прочесть, а игровые приставки и вовсе не поддерживают (Xbox, PS). NTFS допускает размер одного файла на носителе большего размера, чем существующие на сегодня флэш-носители, а ограничение для раздела - 16 Eb!

Кроме того, файловая система подразумевает и следующие возможности:

• запись изменений для восстановления системы в случае краха;
• установление прав доступа к хранящимся файлам;
• дисковые квоты;
• шифрование и др.

Таким образом, форматирование съемного диска в этой системе не практично, т.к. она более заточена для жестких дисков и на работу с Windows, а не с другими ОС.

exFAT

Разбираясь, где лучше форматировать флешку - в FAT32 или NTFS, многие обходят вниманием более современную exFAT, тоже детище "Виндоуз". А она позволяет записывать файлы практически неограниченного объема, ставя ограничение для одного раздела в космические 64 Zb! Хорошо с ней сотрудничает Windows, последние версии "яблочных" ОС и Linux при установке дополнительных пакетов. Современные версии игровых консолей также поддерживают exFAT, что не сказать о Xbox 360 и Playstation 3.

Итак, exFAT - это самая современная файловая система от "Окон", вобравшая в себя возможности совместимости FAT32 и более широкий функционал NTFS. Один недостаток - она работает только с последними версиями существующих ОС и бесполезна на устройствах с устаревшей начинкой.

EXT2, 3 и HFS+

HFS+ - файловая система, разработанная Mac OS. С ней работает также Linux и Xbox, "Виндоуз" она не поддерживается. Ограничений для объема одного файла здесь практически нет, для раздела - 8 Eb.

EXT2, 3 - продукт Linux. Предельный размер файла на флешке, отформатированной в этой системе - 16 Гб, для раздела - 32 Тб. Среди сторонних ОС работает с этим форматом только Xbox.

Как форматировать флешку в FAT32

Алгоритм очень несложный:

1. Подсоедините внешний накопитель к компьютеру, после того как система его увидит, зайдите в "Мой компьютер". Никаких программ для форматирования для этой системы не требуется.
2. ПКМ по нужной флешке - "Отформатировать".
3. Нужная система, как правило, уже выбрана по умолчанию - вам останется только кликнуть на "Начать".
4. Через некоторое время компьютер уведомит вас, что форматирование завершилось. Вот и все!

Как отформатировать флешку в NTFS

Форматирование в этой файловой системе сложнее, т. к. она, по сути, не предназначена для Для процедуры вам будет нужна сама флешка и ПК:

1. В "Панели управления" зайдите в "Систему".
2. В "Свойствах" нужна вкладка "Оборудование", а затем "Диспетчер устройств".
3. Далее - "Дисковые устройства" - двойной клик по нужной флешке для открытия ее свойств.
4. Затем "Политика" и "Оптимизировать для выполнения". Подтвердите действие и закройте окна.
5. Теперь зайдите в "Мой компьютер", выберите нужный съемный диск.
6. ПКМ по его названию, далее - "Отформатировать".
7. Как отформатировать флешку в NTFS? В выпадающем меню "Файловая система" теперь появилось искомое наименование - выберите его.
8. Отформатируйте накопитель, нажав на "Начать".
9. В "Моем компьютере" зайдите в системы".
10. Далее - "Оборудование", "Диспетчер устройств" - "Дисковые".
11. Выберите отформатированный съемный диск, затем перейдите в его "Свойства".
12. В "Политике" отметьте "Оптимизировать для быстрого удаления", подтвердите выбор.

Что проще: форматировать флешку в FAT32 или NTFS? Ответ очевиден.

Вспомогательные программы

Чтобы отформатировать накопитель в редкой файловой системе, порой недостаточно возможностей одной ОС. Представим вспомогательные программы для форматирования:

• В NTFS - convert.exe (встроенная утилита Windows), HP USB Disk Storage Format Tool, Format USB Or Flash Drive Software.
• В HFS+ и для карт SD, SHDC, SDXC, SD-C, LLC - SD Formatter.
• Для JetFlash, Transcend и A-DATA - JetFlash Recovery Tool.
• Поддержка всех файловых систем - MiniTool Partition Wizard.

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

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

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

Данная статья адресована тем, кто желает восполнить этот пробел в своих знаниях.

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

Файловая структура или File system была разработана в 70-х годах прошлого столетия компанией Microsoft и представляла собой определенный порядок организации пространства для хранения и доступа к данным на компьютерах и других цифровых устройствах.

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

Структурно вся область дискового пространства поделена на кластеры, как лист бумаги в клетку. Каждая клетка – это блок, размер которого задается при форматировании и должен быть кратным 2. Минимальный размер может быть 512 байт (у флешки), для жесткого диска он составляет 32 Кб. Один файл может занимать несколько таких кластеров. Образно можно представить дисковое пространство в виде тетради, где кластер – это буква, файл – слово, а файловая структура – оглавление тетради.

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

1. Свободный, готовый к записи данных.
2. Занятый, который хранит часть информации и имеющий в метке данные о следующем кластере в цепочке, при этом последний помечается особой меткой.
3. BAD-блок – кластер с ошибками, который стане недоступен после форматирования.

Размер метки определяется видом файловой структуры: для FAT32 он равен 32 байтам.

Вся файловая система состоит из следующих частей:

• загрузочного сектора, который располагается в начале диска, активируется после загрузки ОС и хранит параметры раздела;
• таблицы размещения файлов («оглавления»), хранящей метки кластеров;
• копии таблицы размещения файлов, чтобы восстановить данные при повреждении файловой структуры;
• корневого каталога;
• области данных;
• цилиндра для выполнения операций чтения/записи.

Всего существует три типа файловой системы FAT: FAT12, FAT16 и FAT32. На смену FAT пришла NTFS, а exFAT является расширенной версией FAT32 и используется в основном для флеш-накопителей.

Достоинства и недостатки файловых структур FAT32, NTFS и exFAT

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

FAT32

Среди трех рассматриваемых файловых структур FAT32 является самой старшей. Она пришла на смену FAT16 и до недавнего времени была наиболее прогрессивной. Выход FAT32 приурочили к выпуску операционной системы Windows 95 OSR2 в 1996 году. Главные отличительные особенности: 32-разрядная адресация кластеров и ограничения в размерах: файла не более 4 Гб и тома в 128 Гб.

Достоинства

Несмотря на некоторую моральную отсталость, FAT32 обладает рядом преимуществ перед другими файловыми системами. Ее главная привлекательность - совместимость и универсальность. FAT32 работает со всеми версиями операционных систем, включая Windows (сравнение всех версий), Linux и MacOS, подходит к любыми игровым консолям и прочим гаджетам с USB портом. Сегодня она используется во всех внешних накопителях (флешках, CD-картах) по умолчанию, так как многие старые устройства: ПК, ноутбуки, приставки с USB-входом могут работать только с FAT32.

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

Недостатки

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

Размер файла не должен превышать 4 ГБ, таким образом, максимальный размер диска при размере кластера для таблицы размещения файлов в 32 КБ будет около 8 ТБ.

При форматировании диска средством ScanDisk, являющимся 16-разрядной программой, с учетом самих таблиц FAT и при максимальном размере кластера в 32 КБ размер тома ограничивается 128-ю гигабайтами.

С учетом того, что не многие компьютерные устройства оснащены винчестером объемом более 8 Тб, этот недостаток не будет ощутимым для большинства пользователей. Однако тот момент, что FAT32 работает с файлами размером до 4 Гб, является существенным минусом, так как большинство качественных видеофайлов современного формата 4К сегодня имеют размер свыше этих 4 Гб, а значит, не совместимы с данной файловой системой.

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

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

Главное применение файловой системы FAT32 сегодня – это переносные флешки и SD-карты (особенности), которые содержат не много файлов и совместимы с разнообразными цифровыми устройствами.

NTFS

Данная файловая система была разработана компанией Microsoft в 1993 году и представлена вместе версией Windows NT 3.1. В самом названии new technology file system , что означает файловая система новой технологии , заложена ее прогрессивная сущность.

После форматирования диска в системе NTFS он делится на три зоны:

• MFT - зона или общая таблица файлов (Master File Table), где хранится информация о файлах и каталогах;
• данные пользователя;
• метафайлы, в которых содержится служебная информация.

Каждый из метафайлов ответственен за определённую область. Например, LogFile - это файл журналирования, в котором выполняется запись всех операций в журнал, Boot – загрузочный сектор, Bitmap контролирует свободное место в разделе и т.п. Такая структура надежно защищает файлы от любых сбоев, будь то зависания ОС или отключение электричества.

Достоинства

В отличие от FAT32 в данной файловой структуре практически отсутствуют ограничения в объеме файлов и каталогов. Размер кластера может варьироваться от 512 байт до 64 Кб, оптимальным считается размер в 4 Кб.

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

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

Недостатки

Главным минусом системы NTFS является несовместимость со всеми операционными системами ниже Windows NT, а также ограничения в совместимости с прочими ОС. Так, Mac OS читает файлы с дисков NTFS, но не может выполнять их запись, такая же ситуация с совместимостью файлов Linux. Самые популярные игровые консоли Playstation и Xbox 360 не работают с NTFS, только Xbox One может с ней взаимодействовать.

Среди недостатков NTFS можно назвать также высокие требования к объему оперативной памяти, более низкая скорость по сравнению с FAT32 и трудности управления каталогами среднего объема.

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

exFAT

Эта файловая система является последней из рассматриваемых по времени выпуска. Она появилась в 2008 году с очередными обновлениями к Windows XP и является, по сути, расширенной версией FAT32.

Главная цель разработчиков – создать производительную, удобную и универсальную файловую структуру для переносных накопительных устройств: флешек, SD-карт и съемных жестких дисков.

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

• Простая организация без специализированных особенностей и ограничений в размерах файлов и раздела.
• Отличная совместимость со всеми ОС Windows, а также Mac OS и Linux. В последнем варианте необходима установка дополнительного софта.
• Поддержка со стороны всех современных яблочных девайсов, а также игровых приставок Xbox One и Playstation 4.

Основным недостатком файловой организации exFAT является лицензионная политика Microsoft, запрещающая ее бесплатное использование в открытом доступе.

Наиболее оптимальная файловая структура

Рассмотрев описания трех популярных файловых систем, можно сделать следующие выводы:

• для компьютерных устройств с операционной системой выше Windows NT целесообразнее будет форматирование жесткого диска в системе NTFS;
• для старых устройств, а также с целью совместимости с разными современными цифровыми гаджетами, оптимальным вариантом станет выбор FAT32;
• для любых съемных носителей идеальной будет применение системы

И последнее: информацию о том, какая файловая структура реализована на ваших дисках, можно узнать во вкладке «Общие» (правая клавиша мышки «Свойства»).