معماری سیستم فایل FAT ویژگی های فایل سیستم های FAT32، NTFS و exFAT

1. ساختار بخش FSIinfo struct fat_boot_fsinfo:
   • __u32 امضاء1– امضا 0x41615252;
   • __u32 امضا2– امضا 0x61417272;
   • __u32 رایگان_خوشه- تعداد خوشه های رایگان. اگر فیلد حاوی 1- باشد، جستجو برای خوشه های آزاد باید با خوشه شماره 2 آغاز شود.
2. ساختار عنصر فهرست نام کوتاه msdos_dir_entry:
   • __s8 نام، قسمت– نام و پسوند فایل؛
   • __u8 attr- ویژگی های فایل؛
   • __u8 ctime_ms– این فیلد زمان ایجاد فایل را به ms مشخص می کند (فقط FAT32 استفاده می شود).
   • __u16 ساعت- زمان ایجاد فایل (فقط FAT32 استفاده می شود)؛
   • تاریخ __u16- تاریخ ایجاد فایل (فقط FAT32 استفاده می شود)؛
   • تاریخ __u16- تاریخ آخرین دسترسی به فایل (فقط FAT32 استفاده می شود)؛
   • __u16 starthi- مهم ترین 16 بیت از شماره کلاستر اول فایل (فقط FAT32 استفاده می شود).
   • __u16 ساعت، تاریخ، شروع– زمان و تاریخ ایجاد فایل، شماره اولین خوشه فایل.
   • اندازه __u32- اندازه فایل (به بایت).
3. ساختار عنصر دایرکتوری نام طولانی:
   • __u8 شناسه- شماره عنصر؛
   • __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; // اندازه بخش (از FAT16)

U16 dir_entries; // تعداد توصیفگرهای 32 بایتی

// در دایرکتوری ریشه (0 برای FAT32)

بخش های U16; // تعداد کل بخش ها در پارتیشن

U32 fat16_size; // اندازه FAT16

U32 root_size; // اندازه دایرکتوری ریشه

U16 byte_per_cluster; // اندازه خوشه بر حسب بایت

U16 next_cluster; // خوشه بعدی در زنجیره

چربی بین المللی؛

بیایید با تابع اصلی شروع کنیم:

int main()

عدد داخلی

نام کامل فایلی را که می خواهیم محتوای آن را بخوانیم مشخص می کنیم. اجازه دهید یادآوری کنم که ما فقط با نام فایل های کوتاه کار می کنیم. روش کار با نام های طولانی در این مقاله مورد بحث قرار نگرفته است.

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

فایل دستگاه را باز کنید:

سخت = باز (FAT16_PART_NAME، O_RDONLY)؛

اگر (سخت< 0) {

اشتباه (FAT16_PART_NAME)؛

خروج (-1)؛

10 خوشه اول فایل را خواندیم. خواندن توسط تابع fat16_read_file() انجام می شود. پارامترهای تابع، نام کامل فایل و تعداد خوشه هایی برای خواندن هستند. این تابع تعداد خوشه های خوانده شده یا -1 را در صورت بروز خطا در حین خواندن برمی گرداند:

Num = fat16_read_file(full_path, 10);

اگر (شماره< 0) perror("fat16_read_file");

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

فایل دستگاه را ببندید و خارج شوید:

بستن (سخت)؛

بازگشت 0;

تابع خواندن خوشه های فایل به شکل زیر است:

int fat16_read_file(__u8 *full_path، int num)

ساختار split_name sn; // ساختار برای ذخیره اجزای فایل

U8 tmp_name_buff; // بافر برای ذخیره موقت اجزای مسیر فایل کامل

استاتیک int i = 1;

Int n;

U8 *tmp_buff;

U16 start_cluster، next_cluster;

ما هنگام در نظر گرفتن تابع اصلی، پارامترهای تابع را فهرست کردیم.

عملیات آماده سازی - بافر tmp_name_buff و ساختار split_name sn را بازنشانی کنید:

اولین کاراکتر در نام مسیر مطلق یک فایل باید یک اسلش رو به جلو (/) باشد. بیایید این را بررسی کنیم:

بخش بوت را از پارتیشن بخوانید:

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

بخش read boot اکنون در ساختار جهانی fat_boot_sector fbs قرار دارد. بیایید اندازه بخش، تعداد ورودی ها در فهرست اصلی و تعداد کل بخش های پارتیشن را از این ساختار کپی کنیم:

بیایید اندازه خوشه را بر حسب بایت تعیین کنیم:

Byte_per_cluster = fbs.cluster_size * 512

بیایید اطلاعات موجود در بخش راه‌اندازی را نمایش دهیم:

Printf("شناسه سیستم - %s ", fbs.system_id);

Printf("اندازه بخش - %d "، section_size);

Printf("اندازه خوشه - %d ", fbs.cluster_size);

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

Printf("تعداد FATs - %d ",fbs.fats);

Printf(" ورودی های Dir - %d "، dir_entries);

Printf("بخش - %d "، بخش);

Printf("رسانه - 0x%X"، fbs.media);

Printf("طول FAT16 - %u "، fbs.fat_length);

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

Printf("بایت در هر خوشه - %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

بستن (چربی)؛

#endif

ما شروع منطقه داده را محاسبه می کنیم:

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

با داشتن تمام ورودی ها در دایرکتوری ریشه، می توانیم به محتویات فایل test.txt برسیم. برای این منظور یک چرخه را سازماندهی می کنیم. در بدنه حلقه، نام کامل فایل را تجزیه می‌کنیم و عناصر آن را برجسته می‌کنیم - زیر شاخه‌ها (دو تا از آنها، Folder1 و Folder2 را داریم) و نام فایل مورد نظر (test.txt).

در حالی که (1) (

Memset(tmp_name_buff, 0, SHORT_NAME);

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

برای (n = 0 ; n< SHORT_NAME; n++, i++) {

If((tmp_name_buff[n] == "/") || (tmp_name_buff[n] == "؟")) (

I++;

زنگ تفريح؛

Tmp_name_buff[n] = "?";

ساختار struct split_name sn را با اطلاعات مناسب پر می کنیم. تابع split_name پر کردن را انجام می دهد و نام فایل را برای مطابقت با فرمت "8.3" بررسی می کند:

< 0) {

Printf("نام معتبر نیست");

بازگشت -1;

برای هر عنصر از نام کامل فایل، یک خوشه اولیه تعریف می کنیم. برای انجام این کار، ما در عناصر دایرکتوری (که از ریشه شروع می شود) به دنبال ورودی مربوط به عنصر نام کامل می گردیم و این ورودی را می خوانیم. روال جستجو توسط تابع get_dentry() انجام می شود:

If(get_dentry(&sn)< 0) {

Printf ("هیچ فایلی وجود ندارد!");

بازگشت -1;

بررسی ویژگی های فایل اگر این دایرکتوری است، محتویات آن را بخوانید و حلقه را ادامه دهید:

If(dentry.attr & 0x10) (

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

ادامه هید؛

اگر این یک فایل است، اولین خوشه های num را می خوانیم. برای کنترل، اطلاعات خوانده شده را در یک فایل جداگانه ذخیره می کنیم:

If(dentry.attr & 0x20) (

Start_cluster = dentry.start;

Tmp_buff = (__u8 *)malloc(byte_per_cluster); // محتویات خوشه در اینجا خوانده می شود

N = open("clust", O_CREAT|O_RDWR, 0600); // اطلاعات خوانده شده را در این فایل ذخیره کنید

اگر (n< 0) {

Perror ("باز")؛

بازگشت -1;

برای خواندن خوشه های فایل، یک حلقه سازماندهی می کنیم:

برای (i = 0؛ i< num; i++) {

محتویات کلاستر را در بافر tmp_buff می خوانیم و آن را در یک فایل جداگانه ذخیره می کنیم:

< 0) return -1;

< 0) {

Perror ("نوشتن");

Close(n);

بازگشت -1;

ما از FAT16 تعداد خوشه بعدی اشغال شده توسط این فایل را می خوانیم. اگر این آخرین خوشه باشد، حلقه را قطع می کنیم و به تابع اصلی برمی گردیم:

#ifdef DEBUG

Printf("OK. خوانده شده");

Printf("خوشه بعدی فایل - 0x%X .. ", next_cluster);

#endif

If(next_cluster == EOF_FAT16) (

#ifdef DEBUG

Printf ("آخرین خوشه.");

#endif

رایگان (tmp_buff)؛

Close(n);

بازگشت ++i;

#ifdef DEBUG

Printf("توقف خواندن");

#endif

بازگشت i;

خواندن بخش بوت FAT16 توسط تابع read_fbs() انجام می شود. نتیجه در ساختار fbs جهانی قرار می گیرد:

int read_fbs()

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

بازگشت 0;

خواندن جدول تخصیص فایل سیستم فایل FAT16 توسط تابع read_fat16() انجام می شود:

int read_fat16()

جستجوی U64 = (__u64)(fbs.reserved) * 512; // از ابتدای پارتیشن به FAT16 افست شد

Fat16 = (void *)malloc(fat16_size);

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

بازگشت 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) بازگشت -1;

Memset(dir_entry, 0, root_size);

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

بازگشت 0;

خواندن یک کلاستر متعلق به یک فایل توسط تابع read_cluster() انجام می شود. پارامترهای ورودی تابع عبارتند از شماره خوشه cluster_num و یک اشاره گر به بافر __u8 *tmp_buff، جایی که نتیجه خواندن باید در آن قرار گیرد. افست به خوشه در پارتیشن با استفاده از فرمول محاسبه می شود (نگاه کنید به):

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

• جستجو کنید- افست به خوشه روی پارتیشن
• DATA_START– شروع ناحیه داده
• CLUSTER_NUM- شماره سریال خوشه
• BYTE_PER_CLUSTER- اندازه خوشه بر حسب بایت

int read_cluster(__u16 cluster_num, __u8 *tmp_buff)

U64 seek = (__u64)(byte_per_cluster) * (cluster_num - 2) + data_start; // محاسبه افست به خوشه

< 0) return -1;

بازگشت 0;

تابع read_directory ورودی‌های یک دایرکتوری (نه دایرکتوری ریشه) را می‌خواند و نتیجه را در محل حافظه که نشانگر dir_entry روی آن تنظیم شده است قرار می‌دهد:

int read_directory (__u16 start_cluster)

Int i = 1;

U16 next_cluster;

برای (; ;i++) (

ما حافظه را برای ذخیره محتویات دایرکتوری اختصاص می دهیم، محتویات خوشه شروع را می خوانیم و مقدار خوشه بعدی را از جدول FAT16 دریافت می کنیم:

If(!dir_entry) بازگشت -1;

< 0) return -1;

خوشه_بعدی = fat16;

بیایید محتویات دایرکتوری را در یک فایل جداگانه (برای کنترل) ذخیره کنیم:

#ifdef DEBUG

Printf("خوشه بعدی - 0x%X"، next_cluster);

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

Write (fat، dir_entry، root_size);

بستن (چربی)؛

#endif

اگر به آخرین خوشه رسید، از حلقه خارج می شویم، در غیر این صورت به خواندن دایرکتوری ادامه می دهیم و اندازه بافر dir_entry را یک خوشه دیگر افزایش می دهیم:

If(next_cluster & EOF_FAT16) break;

Start_cluster = next_cluster;

بازگشت 0;

تابع get_dentry() محتویات دایرکتوری را برای عنصر مربوط به فایل مورد جستجو جستجو می کند. پارامترهای ورودی این تابع یک اشاره گر به ساختار ساختار split_name *sn است که حاوی عناصر نام فایل کوتاه است:

Int i = 0;

بافر جهانی dir_entry شامل آرایه ای از ورودی های دایرکتوری است که در آن به دنبال یک ورودی فایل (یا دایرکتوری) هستیم. برای جستجو، یک چرخه را سازماندهی می کنیم. در بدنه حلقه، عناصر دایرکتوری را در ساختار جهانی dentry کپی می کنیم و مقادیر نام و فیلدهای ext این ساختار را با فیلدهای مربوطه ساختار split_name *sn مقایسه می کنیم. مطابقت این فیلدها به این معنی است که ما یک ورودی برای فایل مورد نظر خود در آرایه عناصر دایرکتوری پیدا کرده ایم:

برای (; ; i++) (

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

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

زنگ تفريح؛

اگر (!dentry.name) -1 را برگرداند;

#ifdef DEBUG

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

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

Printf("اندازه فایل - %u "، dentry.size);

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

#endif

بازگشت 0;

تمام کدهای بالا در پوشه FAT16، فایل fat16.c قرار دارند. برای به دست آوردن یک ماژول اجرایی، یک Makefile با محتوای زیر ایجاد کنید:

INCDIR = /usr/src/linux/include

PHONY = تمیز

Fat16: fat16.o split.o

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

%o: %c

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

تمیز:

Rm -f *.o

Rm -f ./fat16

اجرای نرم افزار الگوریتم خواندن فایل از پارتیشن منطقی با سیستم فایل FAT12

به طور کلی، الگوریتم خواندن فایل از پارتیشن FAT12 با الگوریتم خواندن فایل از پارتیشن FAT16 یکسان است. تفاوت در روش خواندن عناصر از جدول FAT12 نهفته است. ما جدول FAT16 را به عنوان یک آرایه ساده از عناصر 16 بیتی در نظر گرفتیم. برای خواندن عناصر جدول FAT12، الگوریتم زیر پیشنهاد شده است:

• عدد عنصر را در 1.5 ضرب کنید.
• استخراج یک کلمه 16 بیتی از FAT با استفاده از نتیجه عملیات قبلی به عنوان افست.
• اگر شماره عنصر زوج است، عملیات AND را روی کلمه خوانده شده و ماسک 0x0FFF انجام دهید. اگر عدد فرد است، کلمه خوانده شده از جدول را 4 بیت به سمت ارقام پایینی تغییر دهید.

بر اساس این الگوریتم، تابع خواندن عناصر را از جدول FAT12 پیاده سازی می کنیم:

int get_cluster (__u16 cluster_num)

جستجوی U16;

گروه U16;

ما افست را در جدول FAT12 محاسبه می کنیم و یک کلمه 16 بیتی را از جدول می خوانیم:

جستجو = (cluster_num * 3) / 2;

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

اگر عدد شروع خوشه یک عدد زوج باشد، مقدار خوانده شده از جدول را 4 بیت به سمت بیت های مرتبه پایین تغییر می دهیم، اگر فرد باشد، آن را با 0x0FFF جمع می کنیم:

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

گروه دیگر &= 0x0FFF;

این قطعه را می توان در اسمبلر نیز پیاده سازی کرد:

" xorw %%ax، %%ax"

"btw $0، %%cx"

"jnc 1f"

"shrw $4، %%dx"

"jmp 2f"

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

"2: movw %%dx، %%ax"

:"=a" (بعدی)

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

نتیجه را برمی گردانیم:

گروه بازگشتی

بیایید نگاهی دقیق تر به خود الگوریتم بیندازیم. فرض کنید یک فایل روی یک پارتیشن FAT12 ایجاد شده است که کلاسترهای نهم و دهم را اشغال می کند. هر عنصر FAT12 12 بیت می گیرد. زیرا از جدول عناصر 16 بیتی را می خوانیم ، سپس افست عنصر نهم برابر با 13 بایت خواهد بود (9 * 1.5 = 13 ، بقیه دور ریخته می شود) ، در حالی که 4 بیت پایین به عنصر FAT 8 تعلق دارد. آنها باید دور ریخته شوند و برای انجام این کار کافی است عنصر خوانده شده را 4 بیت به سمت ارقام پایینی که توسط الگوریتم ارائه می شود تغییر دهید. افست به عنصر دهم 15 بایت خواهد بود و مهم ترین 4 بیت متعلق به یازدهمین عنصر FAT خواهد بود. برای دور انداختن آنها لازم است یک عملیات AND روی عنصر دهم و ماسک 0x0FFF انجام شود که با الگوریتم فوق نیز مطابقت دارد.

متون منبع ماژول برای خواندن یک فایل از پارتیشن FAT12 در پوشه FAT12، فایل fat12.c قرار دارد.

اجرای نرم افزار الگوریتم خواندن فایل از پارتیشن منطقی با سیستم فایل FAT32

الگوریتم خواندن یک فایل از یک پارتیشن با سیستم فایل FAT32 عملاً هیچ تفاوتی با الگوریتم FAT16 ندارد، با این تفاوت که در FAT32 دایرکتوری ریشه می تواند در هر نقطه از پارتیشن قرار داشته باشد و اندازه دلخواه داشته باشد. بنابراین، برای جالب تر کردن آن، اجازه دهید کار را پیچیده تر کنیم - فرض کنید که ما فقط شماره پارتیشن را با سیستم فایل FAT32 می دانیم. برای خواندن اطلاعات از این پارتیشن، ابتدا باید مختصات آن را تعیین کنید - افست پارتیشن از ابتدای دیسک. و برای این شما باید یک ایده از ساختار منطقی هارد دیسک داشته باشید.

ساختار منطقی هارد دیسک

بیایید ساختار منطقی یک هارد دیسک را در نظر بگیریم که با استاندارد مایکروسافت مطابقت دارد - "پارتیشن اصلی - پارتیشن توسعه یافته - پارتیشن های غیر DOS".

فضای هارد دیسک را می توان به یک یا چند پارتیشن سازماندهی کرد و پارتیشن ها می توانند شامل یک یا چند درایو منطقی باشند.

Master Boot Record (MBR) روی هارد دیسک در آدرس فیزیکی 0-0-1 قرار دارد. ساختار MBR شامل عناصر زیر است:

• بوت استرپ غیر سیستمی (NSB)؛
• جدولی که پارتیشن های دیسک را توصیف می کند (جدول پارتیشن، PT). در MBR در افست 0x1BE قرار دارد و 64 بایت را اشغال می کند.
• امضای MBR دو بایت آخر MBR باید دارای عدد 0xAA55 باشد.

جدول پارتیشن مکان و ویژگی های پارتیشن های موجود بر روی هارد دیسک را توضیح می دهد. پارتیشن های دیسک می توانند دو نوع باشند - اولیه (اولیه، اصلی) و توسعه یافته (گسترده). حداکثر تعداد پارتیشن های اصلی چهار پارتیشن است. وجود حداقل یک پارتیشن اصلی روی دیسک الزامی است. یک پارتیشن توسعه یافته را می توان به تعداد زیادی پارتیشن فرعی - درایوهای منطقی تقسیم کرد. یک ساختار ساده شده از MBR در جدول 7 ارائه شده است. جدول پارتیشن در انتهای MBR قرار دارد.

جدول 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 - کم اهمیت ترین هشت بیت از شماره سیلندر هستند. پس از آن یک کد شناسه سیستم وجود دارد که نشان می دهد این بخش متعلق به یک سیستم عامل خاص است. شناسه یک بایت را اشغال می کند. در پشت شناسه سیستم مختصات انتهای بخش وجود دارد - سه بایت که به ترتیب شامل شماره سر، بخش و استوانه است. چهار بایت بعدی تعداد سکتورهای قبل از پارتیشن و چهار بایت آخر اندازه پارتیشن در سکتورها هستند.

بنابراین، یک عنصر جدول پارتیشن را می توان با استفاده از ساختار زیر توصیف کرد:

struct pt_struct (

U8 قابل بوت شدن؛ // پرچم فعالیت بخش

U8 start_part; // مختصات ابتدای بخش

U8 type_part; // شناسه سیستم

U8 end_part; // مختصات انتهای بخش

U32 sect_before; // تعداد سکتورها قبل از پارتیشن

U32 sect_total; // اندازه پارتیشن در سکتورها (تعداد سکتورها در پارتیشن)

عنصر پارتیشن اولیه مستقیماً به بخش بوت دیسک منطقی اشاره می کند (همیشه فقط یک دیسک منطقی در پارتیشن اصلی وجود دارد) و عنصر پارتیشن توسعه یافته مستقیماً به لیستی از دیسک های منطقی متشکل از ساختارهایی به نام MBR ثانویه اشاره می کند. MBR، SMBR).

هر دیسک از پارتیشن توسعه یافته بلوک SMBR خود را دارد. SMBR ساختاری شبیه به MBR دارد، اما رکورد بوت (پر از صفر) ندارد و از چهار فیلد توصیفگر پارتیشن فقط دو مورد استفاده می شود. عنصر اول بخش به دیسک منطقی اشاره می کند، عنصر دوم به ساختار بعدی SMBR در لیست اشاره می کند. آخرین SMBR لیست حاوی کد پارتیشن صفر در عنصر دوم آن است.

بیایید به ماژول خواندن یک فایل از پارتیشن FAT32 برگردیم.

فایل های هدر:

#عبارتند از

#عبارتند از

#عبارتند از

#عبارتند از

#عبارتند از

امضای MBR:

#define SIGNATURE 0xAA55

فایل دستگاهی که اطلاعات پارتیشن از آن خوانده می شود:

#define DEVICE "/dev/hda"

اندازه عنصر جدول پارتیشن (16 بایت):

#define PT_SIZE 0x10

آرایه ساختارهای زیر کد نوع یک بخش را به نمایش نمادین آن ترسیم می کند:

سیستم های ساختاری (

U8 part_type;

U8 *part_name;

struct systypes i386_sys_types = (

(0x00، "خالی")،

(0x01، "FAT12")،

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

(0x05، "گسترش یافته")،

(0x06، "FAT16")،

(0x0b، "Win95 FAT32")،

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

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

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

(0x82، "مبادله لینوکس")،

(0x83، "Linux")،

(0x85، "Linux توسعه یافته")،

(0x07، "HPFS/NTFS")

بیایید تعداد عناصر آرایه i386_sys_types را با استفاده از ماکرو PART_NUM تعیین کنیم:

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

بیایید محدودیتی برای تعداد درایوهای منطقی تعیین کنیم:

#define MAX_PART 20

آرایه ساختاری زیر حاوی اطلاعاتی در مورد درایوهای منطقی روی دستگاه (هارد دیسک) خواهد بود:

struct pt_struct (

U8 قابل بوت شدن؛

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

ساختارهای بخش بوت، بخش FSIinfo و ورودی دایرکتوری (تعریف شده در فایل ):

struct fat_boot_sector fbs;

struct fat_boot_fsinfo fsinfo;

struct msdos_dir_entry dentry;

U32 *fat32 = NULL; // جدول FAT32 را اینجا کپی کنید

اندازه_قطعه U16; // اندازه بخش (از FAT32)

U16 dir_entries; // 0 برای FAT32

بخش های U16; // تعداد سکتورهای روی پارتیشن

U32 fat32_size; // اندازه FAT32

U32 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"; // فایل برای خواندن

ما دستگاه را باز می کنیم، اطلاعاتی در مورد جدول پارتیشن روی دستگاه دریافت می کنیم و اطلاعات مربوط به پارتیشن ها را نمایش می دهیم:

سخت = باز (DEV_NAME، O_RDONLY)؛

اگر (سخت< 0) {

اشتباه (DEV_NAME)؛

خروج (-1)؛

If(get_pt_info(سخت)< 0) {

Perror("get_pt_info");

خروج (-1)؛

Show_pt_info();

ما افست شروع به پارتیشن را محاسبه می کنیم:

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

خوشه های متعلق به فایل را بخوانید:

Num = fat32_read_file(full_path, cluster_num);

اگر (شماره< 0) perror("fat32_read_file");

Else printf("خواندن %d خوشه\n"، num);

بستن (سخت)؛

بازگشت 0;

اطلاعات مربوط به جدول پارتیشن توسط تابع get_pt_info() خوانده می شود:

int get_pt_info (int hard)

Int i = 0;

U64 به دنبال;

جدول پارتیشن را از MBR می خوانیم و امضا را بررسی می کنیم:

Read_main_ptable(hard);

If(check_sign()< 0) {

Printf("امضای معتبر نیست!\n");

بازگشت -1;

ما به دنبال شناسه بخش توسعه یافته هستیم. اگر یکی وجود داشته باشد، افست پارتیشن توسعه یافته را محاسبه می کنیم و اطلاعات مربوط به درایوهای منطقی را می خوانیم:

برای (; i< 4; i++) {

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

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

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

جستجو = (__u64)pt_t[i].sect_before * 512;

Read_ext_ptable (سخت، جستجو)؛

زنگ تفريح؛

بازگشت 0;

تابع خواندن جدول پارتیشن read_main_ptable():

void read_main_ptable (int hard)

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

Perror ("خواندن");

بستن (سخت)؛

خروج (-1)؛

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

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

برگشت؛

تابع بررسی امضا check_sign():

int check_sign()

علامت U16 = 0;

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

#ifdef DEBUG

Printf("امضا - 0x%X\n"، sign);

#endif

If(sign != SIGNATURE) بازگشت -1;

بازگشت 0;

عملکرد خواندن جدول پارتیشن توسعه یافته:

void read_ext_ptable (int hard، __u64 seek)

Int num = 4; // با شروع از این موقعیت، آرایه ساختارهای pt_t با اطلاعات درایوهای منطقی پر می شود.

U8 smbr;

داده های ورودی:

• سخت- توصیف کننده فایل دستگاه؛
• به دنبال- افست به پارتیشن توسعه یافته از ابتدای دیسک (بر حسب بایت).

برای به دست آوردن اطلاعات در مورد درایوهای منطقی، یک حلقه سازماندهی می کنیم:

برای(;;num++) (

ما SMBR را می خوانیم که در نقطه جستجو از ابتدای دیسک قرار دارد:

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

Pread64(hard, smbr, 512, search);

دو عنصر از جدول pt_t را پر می کنیم که از موقعیت شماره شروع می کنیم. عنصر اول به درایو منطقی اشاره می کند و عنصر دوم به ساختار 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 زیر محاسبه می کنیم:

جستجو = ((__u64)(pt_t.sect_before + pt_t.sect_total)) * 512;

برگشت؛

تابع show_pt_info() اطلاعاتی در مورد درایوهای منطقی یافت شده در دستگاه نمایش می دهد:

void show_pt_info()

Int i = 0, n;

#ifdef DEBUG

Printf("تعداد پارتیشن های روی دیسک %d\n است"، PART_NUM);

#endif

برای (; i< MAX_PART; i++) {

اگر(!pt_t[i].type_part) break;

Printf("\nنوع پارتیشن %d - "، i);

برای (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);

زنگ تفريح؛

If(n == PART_NUM) printf("نوع ناشناخته\n");

Printf("Boot sign - 0x%X\n", pt_t[i].bootable);

Printf("بخش ها در پارتیشن %d - %d\n", i, pt_t[i].sect_total);

Printf("بخش های قبل از پارتیشن %d - %d\n\n"، i، pt_t[i].sect_before);

برگشت؛

خواندن خوشه های فایل از یک پارتیشن FAT32 توسط تابع fat32_read_file() انجام می شود. این تابع شباهت های زیادی با تابع fat16_read_file() دارد، بنابراین لطفاً برای نظرات دقیق به نقطه 6 مراجعه کنید:

int fat32_read_file(__u8 *full_path، int num)

ساختار 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 != "/") -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);

ساختار FSIinfo را می خوانیم و امضای واقع در آن را نمایش می دهیم:

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) بازگشت -1;

خواندن دایرکتوری ریشه:

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

ما مسیر کامل فایل را تجزیه می کنیم و هر عنصر را به اجزای آن تقسیم می کنیم:

در حالی که (1) (

Memset(tmp_name_buff, 0, SHORT_NAME);

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

برای (n = 0 ; n< SHORT_NAME; n++, i++) {

Tmp_name_buff[n] = کامل_مسیر[i];

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

I++;

زنگ تفريح؛

Tmp_name_buff[n] = "\0";

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

Printf("نام معتبر\n");

بازگشت -1;

If(get_dentry(&sn)< 0) {

Printf("هیچ فایلی وجود ندارد!\n");

بازگشت -1;

برای به دست آوردن شماره شروع یک خوشه در سیستم فایل FAT32، باید از بالاترین کلمه شماره اولین خوشه فایل - فیلد starthi ساختار دندانپزشکی استفاده کنید:

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

بررسی بایت ویژگی:

If(dentry.attr & 0x10) ( // این دایرکتوری است

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

ادامه هید؛

If(dentry.attr & 0x20) ( // و این یک فایل است

Tmp_buff = (__u8 *)malloc(byte_per_cluster);

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

اگر (n< 0) {

Perror ("باز")؛

بازگشت -1;

Printf("اولین کلاستر فایل - 0x%X .. ", start_cluster);

برای (i = 0؛ i< num; i++) {

Memset(tmp_buff، 0، byte_per_cluster)؛

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

If(write(n، tmp_buff، byte_per_cluster)< 0) {

Perror ("نوشتن");

بازگشت -1;

If(next_cluster == EOF_FAT32) (

رایگان (tmp_buff)؛

Close(n);

بازگشت ++i;

Start_cluster = next_cluster;

بازگشت i;

هدف از سه تابع بعدی بدست آوردن محتویات ناحیه سیستم است. بخش بوت، ساختار FSIinfo و جدول FAT32:

1) تابع read_fbs() بخش بوت را می خواند:

int read_fbs()

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

بازگشت 0;

2) تابع read_fs_info() ساختار FSIinfo را می خواند:

int read_fs_info()

جستجوی U64 = (__u64)fbs.info_sector * 512 + start_seek;

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

بازگشت 0;

3) تابع read_fat32() جدول FAT32 را می خواند:

int read_fat32()

جستجوی U64 = (__u64)fbs.reserved * 512 + start_seek;

Fat32 = (void *)malloc(fat32_size);

اگر (!fat32) بازگشت -1;

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

بازگشت 0;

تابع read_cluster() خوشه را با عدد مشخص شده می خواند:

int read_cluster(__u32 cluster_num, __u8 *tmp_buff)

U64 seek = (__u64)(byte_per_cluster) * (cluster_num - 2) + data_start + start_seek;

If(pread64(hard, tmp_buff, byte_per_cluster, seek)< 0) return -1;

بازگشت 0;

تابع read_directory() برای خواندن دایرکتوری ها (از جمله دایرکتوری ریشه) استفاده می شود:

int read_directory (__u32 start_cluster)

Int i = 2;

U32 next_cluster;

پارامترهای تابع، خوشه شروع دایرکتوری هستند. ما محتویات دایرکتوری را در بافر جهانی dir_entry می خوانیم:

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

خوشه_بعدی = fat32;

اگر دایرکتوری یک خوشه را اشغال می کند، در غیر این صورت از آن خارج شوید، اندازه حافظه را افزایش دهید و به خواندن ادامه دهید.

برای (; ;i++) (

Start_cluster = next_cluster;

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

If(!dir_entry) بازگشت -1;

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

خوشه_بعدی = fat32;

If((next_cluster == EOF_FAT32) || (next_cluster == 0xFFFFFF8)) 0 را برگرداند.

بازگشت 0;

آخرین تابعی که به آن نگاه خواهیم کرد، محتویات یک دایرکتوری را برای عنصری جستجو می کند که با فایل مورد نظر ما مطابقت دارد:

int get_dentry(struct split_name *sn)

Int i = 0;

نشانگر dir_entry روی ناحیه‌ای از حافظه تنظیم می‌شود که حاوی آرایه‌ای از ورودی‌های دایرکتوری است که در آن فایل (یا دایرکتوری) را جستجو می‌کنیم. برای جستجو، یک چرخه سازماندهی می کنیم و رکورد پیدا شده را در ساختار جهانی دندانپزشکی قرار می دهیم:

برای(;;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)))

زنگ تفريح؛

اگر (!dentry.name) -1 را برگرداند;

بازگشت 0;

این به بررسی ماژول برای خواندن یک فایل از یک پارتیشن FAT32 پایان می دهد.

کد منبع ماژول در پوشه FAT32، فایل fat32.c قرار دارد.

تفاوت در سازماندهی ذخیره سوابق فایل در دایرکتوری ها برای سیستم های فایل FAT و EXT2

چند کلمه در مورد تفاوت در سازماندهی ذخیره سوابق فایل در دایرکتوری ها برای سیستم های فایل FAT و EXT2. ساختار فایل سیستم EXT2 در مورد بحث قرار گرفت.

ما به تازگی با FAT آشنا شدیم - در آن، تمام عناصر دایرکتوری دارای یک مقدار ثابت هستند. هنگامی که یک فایل ایجاد می شود، درایور سیستم فایل به دنبال اولین موقعیت اشغال نشده می گردد و آن را با اطلاعات مربوط به فایل پر می کند. اگر طول دایرکتوری در یک خوشه قرار نگیرد، خوشه دیگری برای آن اختصاص داده می شود و غیره.

بیایید نگاه کنیم که اوضاع در EXT2 چگونه است.

فرض کنید یک پارتیشن با سیستم فایل EXT2 داریم، اندازه بلوک 4096 بایت است. در این بخش یک دایرکتوری ایجاد می کنیم. اندازه دایرکتوری برابر با اندازه بلوک خواهد بود - 4096 بایت. در یک فهرست، سیستم عامل بلافاصله دو ورودی ایجاد می کند - یک ورودی برای دایرکتوری فعلی و یک ورودی برای دایرکتوری والد. ورودی دایرکتوری فعلی 12 بایت طول می کشد، در حالی که ورودی والد 4084 بایت خواهد بود. بیایید یک فایل در این دایرکتوری ایجاد کنیم. پس از این، سه ورودی در دایرکتوری وجود خواهد داشت - ورودی دایرکتوری فعلی با طول 12 بایت، ورودی دایرکتوری والد با طول 12 بایت، و ورودی فایل ایجاد شده با طول، همانطور که احتمالا حدس زدید، 4072 بایت. اگر فایل ایجاد شده را حذف کنیم، طول ورودی دایرکتوری والد دوباره به 4084 بایت افزایش می یابد.

بنابراین، هنگام ایجاد یک فایل، درایور سیستم فایل EXT2 به دنبال حداکثر طول ورودی در دایرکتوری می گردد و آن را تقسیم می کند و فضا را برای ورودی جدید باز می کند. خوب، اگر هنوز فضای کافی وجود نداشته باشد، یک بلوک دیگر برای دایرکتوری اختصاص داده می شود و طول دایرکتوری 8192 بایت می شود.

و در پایان، یک ویرایش کوچک در مقاله "معماری سیستم فایل EXT2".

این تغییر مربوط به تابع get_i_num() برای تعیین شماره inode بر اساس نام فایل است. نسخه قدیمی این تابع به شکل زیر بود:

int get_i_num (char *name)

Int i = 0، rec_len = 0;

ساختار ext2_dir_entry_2 dent;

برای (; i< 700; i++) {

اگر(!memcmp(dent.name, name, dent.name_len)) break;

Rec_len += dent.rec_len;

برگرداندن dent.inode;

نسخه تصحیح شده:

int get_i_num (char *name)

* پارامتر تابع نام فایل است. مقدار برگشتی شماره inode فایل است.

Int rec_len = 0;

ساختار ext2_dir_entry_2 dent; // این ساختار فرمت ورودی دایرکتوری ریشه را توصیف می کند:

* بافر جهانی حاوی آرایه ای از ورودی های دایرکتوری است. برای تعیین شماره سریال فایل inode، باید پیدا کنید

* در این آرایه یک ورودی با نام این فایل وجود دارد. برای انجام این کار، یک حلقه را سازماندهی می کنیم:

برای(؛؛) (

/* ورودی های دایرکتوری را در ساختار دندانه دار کپی کنید: */

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

* طول نام فایل صفر به این معنی است که ما روی تمام ورودی های دایرکتوری تکرار کرده ایم

* و هیچ ورودی با نام فایل ما یافت نشد. پس وقت آن است که به عقب برگردیم:

اگر(!dent.name_len) -1 را برگرداند;

/* جستجو با مقایسه نام فایل ها انجام می شود. اگر نام ها مطابقت داشته باشند، از حلقه خارج می شویم: */

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

/* اگر نام ها مطابقت ندارند، به ورودی بعدی بروید: */

Rec_len += dent.rec_len;

/* در صورت موفقیت، شماره inode فایل را برگردانید: */

برگرداندن dent.inode;

ادبیات:

1. وی کولاکوف. برنامه نویسی در سطح سخت افزار: کتاب مرجع ویژه. ویرایش دوم / – سن پترزبورگ: پیتر، 2003 – 848 ص.
2. A.V.Gordeev، A.Yu.Molchanov. نرم افزار سیستم / – سن پترزبورگ: پیتر – 2002
3. مشکوف وی. معماری سیستم فایل ext2. – مجله “System Administrator”، شماره 11(12)، نوامبر 2003 – 26-32 p.

در تماس با

FAT - جدول تخصیص فایل - این اصطلاح به یکی از روش های سازماندهی یک سیستم فایل بر روی دیسک اشاره دارد. این جدول اطلاعات مربوط به فایل‌های روی هارد دیسک شما را به صورت دنباله‌ای از اعداد ذخیره می‌کند که تعیین می‌کند هر قسمت از هر فایل در کجا قرار دارد. با کمک آن، سیستم عامل متوجه می شود که فایل مورد نیاز کدام خوشه ها را اشغال می کند. FAT رایج ترین سیستم فایل است و توسط اکثریت قریب به اتفاق سیستم عامل ها پشتیبانی می شود. در ابتدا، FAT 12 بیتی بود و اجازه کار با فلاپی دیسک و دیسک های منطقی با ظرفیت بیش از 16 مگابایت را می داد. MS-DOS نسخه 3.0 جدول FAT را 16 بیتی برای پشتیبانی از درایوهای بزرگتر ساخته است و درایوهای تا 2047 گیگابایت از جدول FAT 32 بیتی استفاده می کنند.

سیستم FAT32 یک سیستم فایل جدیدتر بر اساس فرمت FAT است و توسط Windows 95 OSR2، Windows 98 و Windows Millennium Edition پشتیبانی می شود. FAT32 از شناسه های خوشه 32 بیتی استفاده می کند اما مهم ترین 4 بیت را ذخیره می کند، بنابراین اندازه شناسه خوشه موثر 28 بیت است. از آنجایی که حداکثر اندازه خوشه های FAT32 32 کیلوبایت است، FAT32 از نظر تئوری می تواند حجم 8 ترابایت را مدیریت کند. ویندوز 2000 اندازه حجم های جدید FAT32 را به 32 گیگابایت محدود می کند، اگرچه از حجم های بزرگتر EAT32 موجود (ایجاد شده در سیستم عامل های دیگر) پشتیبانی می کند. تعداد بیشتر خوشه های پشتیبانی شده توسط FAT32 به آن اجازه می دهد تا دیسک ها را با کارایی بیشتری نسبت به FAT 16 مدیریت کند. FAT32 می تواند از خوشه های 512 بایتی برای حجم هایی تا 128 مگابایت استفاده کند.

فایل سیستم FAT 32 به عنوان فایل سیستم پیش فرض در ویندوز 98 استفاده می شود. این سیستم عامل دارای برنامه ای ویژه برای تبدیل دیسک از FAT 16 به FAT 32 است. ویندوز NT و ویندوز 2000 نیز می توانند از سیستم فایل FAT استفاده کنند و بنابراین می توانید رایانه خود را از دیسک DOS بوت کنید و به تمام فایل ها دسترسی کامل داشته باشید. . با این حال، برخی از پیشرفته ترین ویژگی های ویندوز NT و ویندوز 2000 توسط سیستم فایل خود، ntfs (NT File System) ارائه شده است. ntfs به شما امکان می دهد تا پارتیشن های دیسک تا 2 ترابایت (مانند FAT 32) ایجاد کنید، اما علاوه بر این، دارای توابع فشرده سازی فایل داخلی، امنیت و ممیزی لازم هنگام کار در یک محیط شبکه است. و در ویندوز 2000، پشتیبانی از سیستم فایل FAT 32 اجرا می شود. نصب سیستم عامل ویندوز NT روی دیسک FAT شروع می شود، اما در صورت تمایل کاربر، در پایان نصب، می توان داده های روی دیسک را تبدیل کرد. به فرمت ntfs

می توانید این کار را بعداً با استفاده از ابزار Convert.exe ارائه شده با سیستم عامل انجام دهید. یک پارتیشن دیسک تبدیل شده به سیستم ntfs برای سایر سیستم عامل ها غیرقابل دسترسی می شود. برای بازگشت به DOS، Windows 3.1 یا Windows 9x، باید پارتیشن ntfs را حذف کنید و به جای آن یک پارتیشن FAT ایجاد کنید. ویندوز 2000 را می توان بر روی دیسک با سیستم فایل FAT 32 و ntfs نصب کرد.

قابلیت های فایل سیستم های EAT32 بسیار گسترده تر از FAT16 است. مهمترین ویژگی این است که از دیسک های تا 2047 گیگابایت پشتیبانی می کند و با کلاسترهای کوچکتر کار می کند، در نتیجه میزان فضای استفاده نشده دیسک را به میزان قابل توجهی کاهش می دهد. به عنوان مثال، یک هارد دیسک 2 گیگابایتی در FAT16 از کلاسترهای 32 کیلوبایتی استفاده می کند، در حالی که FAT32 از کلاسترهای 4 کیلوبایتی استفاده می کند. برای حفظ سازگاری با برنامه‌ها، شبکه‌ها و درایورهای دستگاه در صورت امکان، FAT32 با حداقل تغییرات در معماری، APIها، ساختارهای داده داخلی و فرمت دیسک پیاده‌سازی می‌شود. اما از آنجایی که عناصر جدول FAT32 اکنون چهار بایت هستند، بسیاری از ساختارهای داده داخلی و روی دیسک و APIها باید اصلاح یا گسترش داده شوند. برخی از APIهای درایوهای EAT32 مسدود شده‌اند تا از خراب کردن محتوای درایوهای FAT32 توسط ابزارهای دیسک قدیمی جلوگیری شود. اکثر برنامه ها تحت تأثیر این تغییرات قرار نخواهند گرفت. ابزارها و درایورهای موجود روی درایوهای FAT32 کار خواهند کرد. با این حال، درایورهای دستگاه بلوک MS-DOS (مانند Aspidisk.sys) و ابزارهای دیسک باید برای پشتیبانی از FAT32 اصلاح شوند. تمام ابزارهای دیسک ارائه شده توسط مایکروسافت (Format، Fdisk، Defrag، و ScanDisk برای حالت واقعی و محافظت شده) برای پشتیبانی کامل از FAT32 دوباره طراحی شده اند. علاوه بر این، مایکروسافت به فروشندگان پیشرو ابزار دیسک و درایور دستگاه در اصلاح محصولات خود برای پشتیبانی از FAT32 کمک می کند. FAT32 هنگام کار با دیسک های بزرگتر کارآمدتر از FAT16 است و نیازی به پارتیشن بندی آنها به پارتیشن های 2 گیگابایتی ندارد. ویندوز 98 لزوماً از FAT16 پشتیبانی می کند، زیرا این سیستم فایل است که با سایر سیستم عامل ها از جمله سیستم عامل های شخص ثالث سازگار است. در حالت واقعی MS-DOS و در حالت ایمن ویندوز 98، سیستم فایل FAT32 به طور قابل توجهی کندتر از FAT16 است. بنابراین، هنگام اجرای برنامه‌ها در حالت MS DOS، توصیه می‌شود دستوری را در فایل Autoexec.bat یا PIF برای بارگیری Smartdrv.exe قرار دهید که باعث افزایش سرعت عملیات دیسک می‌شود. برخی از برنامه های قدیمی طراحی شده برای مشخصات FAT16 ممکن است اطلاعات نادرستی در مورد مقدار فضای آزاد یا کل دیسک در صورتی که بیش از 2 گیگابایت باشد گزارش دهند. ویندوز 98 APIهای جدیدی را برای MS-DOS و Win32 ارائه می کند که به شما امکان می دهد این معیارها را به درستی تعیین کنید. روی میز شکل 1 ویژگی های مقایسه ای FAT16 و FAT32 را نشان می دهد.

جدول 1. مقایسه فایل سیستم های FAT16 و FAT32

حداکثر طول فایل ممکن در FAT32 4 گیگابایت منهای 2 بایت است. برنامه های Win32 می توانند فایل هایی با این طول را بدون پردازش خاص باز کنند. سایر برنامه‌ها باید از وقفه Int 21h، تابع 716C (FAT32) با پرچم باز تنظیم شده روی EXTEND-SIZE (1000 ساعت) استفاده کنند.

در سیستم فایل FAT32، 4 بایت برای هر خوشه در جدول تخصیص فایل اختصاص داده می شود، در حالی که در FAT16 - 2، و در FAT12 - 1.5.

مهم ترین 4 بیت عنصر جدول FAT32 32 بیتی رزرو شده است و در تشکیل شماره خوشه شرکت نمی کند. برنامه هایی که مستقیماً جدول PAT32 را می خوانند باید این بیت ها را پوشانده و از تغییر آنها در هنگام نوشتن مقادیر جدید محافظت کنند.

بنابراین، FAT32 دارای مزایای زیر نسبت به اجرای قبلی سیستم فایل FAT است:

پشتیبانی از دیسک تا 2 ترابایت؛

فضای دیسک را کارآمدتر سازماندهی می کند. FAT32 از خوشه‌های کوچک‌تری (4 کیلوبایت برای دیسک‌های تا 8 گیگابایت) استفاده می‌کند که در مقایسه با FAT بین 10 تا 15 درصد فضای دیسک‌های بزرگ را ذخیره می‌کند.

دایرکتوری ریشه FAT 32، مانند همه دایرکتوری های دیگر، اکنون نامحدود است، از زنجیره ای از خوشه ها تشکیل شده است و می تواند در هر نقطه از دیسک قرار گیرد.

قابلیت اطمینان بالاتری دارد: FAT32 قادر است دایرکتوری ریشه را جابجا کند و با یک نسخه پشتیبان FAT کار کند، علاوه بر این، رکورد بوت در درایوهای FAT32 گسترش یافته است تا یک نسخه پشتیبان از ساختارهای داده حیاتی را شامل شود، به این معنی که درایوهای FAT32 حساسیت کمتری به درایوهای FAT32 دارند. وقوع مناطق بد فردی نسبت به حجم FAT موجود؛

برنامه ها 50 درصد سریعتر بارگذاری می شوند.

جدول 2. مقایسه اندازه های خوشه

یک ابزار بهبود یافته یکپارچه سازی دیسک، قرار دادن فایل های برنامه را که هنگام راه اندازی برنامه بارگذاری می شوند، بهینه می کند. با استفاده از ابزار Drive Converter (FAT32) می توان دیسک را به EAT32 تبدیل کرد، اما پس از این توصیه می شود ابزار Disk Defragmenter را اجرا کنید - در غیر این صورت کامپیوتر با دیسک کندتر از قبل کار می کند. هنگام استفاده از FAT32، پیکربندی بوت جایگزین ویندوز 98 و ویندوز NT 4.0 غیرممکن می شود، زیرا دومی از FAT32 پشتیبانی نمی کند. FAT32 فضای دیسک را بسیار کارآمدتر از نسخه های قبلی سیستم فایل FAT اختصاص می دهد. این کار ده ها یا حتی صدها مگابایت را در درایوهای بزرگ آزاد می کند و هنگامی که با ابزار پیشرفته یکپارچه سازی دیسک FAT32 ترکیب می شود، زمان بارگذاری برنامه را به میزان قابل توجهی کاهش می دهد. روش تبدیل سیستم فایل روی هارد دیسک شما به FAT32 با استفاده از Drive Converter (FAT32) بسیار ساده است. برای انجام این کار، باید به صورت متوالی منوی استارت، برنامه های زیر منو، لوازم جانبی، ابزارهای سیستم را باز کرده و دستور Drive Converter (FAT32) را انتخاب کنید. این تبدیل ممکن است بر ویژگی‌های hibernate (ذخیره وضعیت رایانه در دیسک) که در بسیاری از رایانه‌ها وجود دارد، تأثیر بگذارد. سیستم‌هایی که در آنها حالت خواب از طریق AWS BIOS یا ACPI (پیکربندی پیشرفته و رابط برق) S4/BIOS اجرا می‌شود، باید از FAT32 پشتیبانی کنند - تنها در این صورت در ویندوز 98 به درستی کار می‌کنند.

اکثر سازندگان بایوس دارای محافظ آنتی ویروس هستند که تغییرات در MBR (Master Boot Record) را کنترل می کند. علاوه بر این، ابزارهای آنتی ویروس قدیمی نصب شده به عنوان برنامه های مقیم یا درایورهای حالت واقعی ممکن است تغییرات MBR را هنگام بوت کردن MS-DOS شناسایی کنند. از آنجا که تبدیل به FAT32 به ناچار MBR را تغییر می دهد، برخی از ابزارهای بررسی ویروس ممکن است به اشتباه این را به عنوان نشانه ای از آلوده بودن سیستم تفسیر کنند. بنابراین، اگر یک ابزار آنتی ویروس تغییری را در MBR تشخیص دهد، آن را "درمان" می کند. بهتر است قبل از تبدیل درایو به FAT32، نرم‌افزار آنتی‌ویروس خود را حذف کرده و محافظ داخلی بایوس در برابر ویروس را غیرفعال کنید. سپس می توانید ابزار آنتی ویروس را مجدداً نصب کنید و محافظ آنتی ویروس تعبیه شده در بایوس را فعال کنید.