კომპიუტერის ფაილური სისტემა არის fat ntfs. ფაილური სისტემები. ფაილური სისტემის სტრუქტურა. FAT ფაილური სისტემები

1. FSinfo სექტორის სტრუქტურა 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 id- ელემენტის ნომერი;
   • __u8 სახელი0_4- სახელის 1 - 5 სიმბოლოები;
   • __u8 attr- ფაილის ატრიბუტები;
   • __u8 alias_checksum– მოკლე სახელის საკონტროლო ჯამი;
   • __u8 სახელი5_10- სახელის 6 - 11 სიმბოლოები;
   • __u8 სახელი11_12- სახელის 12 - 13 სიმბოლოები.

მოდით გავაგრძელოთ ალგორითმის პროგრამული განხორციელების განხილვა და განვსაზღვროთ დანაყოფის სახელი, რომელზეც შეიქმნა FAT16 ფაილური სისტემა:

#ifndef FAT16_PART_NAME

#define FAT16_PART_NAME "/dev/hda1"

#დაასრულე თუ

გლობალური სტრუქტურები:

struct fat_boot_sector fbs; // ჩატვირთვის სექტორის სტრუქტურა

struct msdos_dir_entry dentry; // დირექტორია ელემენტის სტრუქტურა

გლობალური ცვლადები:

U16 * fat16; // დააკოპირეთ FAT16 ცხრილი აქ

U16 სექტორი_ზომა; // სექტორის ზომა (FAT16-დან)

U16 dir_entries; // 32-ბაიტიანი აღწერების რაოდენობა

// root დირექტორიაში (0 FAT32-ისთვის)

U16 სექტორები; // სექტორების საერთო რაოდენობა დანაყოფში

U32 fat16_size; // FAT16 ზომა

U32 root_size; // root დირექტორიას ზომა

U16 ბაიტი_თითო კლასტერში; // კლასტერის ზომა ბაიტებში

U16 შემდეგი_კლასტერი; // შემდეგი კლასტერი ჯაჭვში

int ცხიმი;

დავიწყოთ ძირითადი ფუნქციით:

int main()

int num;

ჩვენ დავაყენეთ ფაილის სრული სახელი, რომლის შიგთავსის წაკითხვა გვინდა. შეგახსენებთ, რომ ჩვენ ვმუშაობთ მხოლოდ ფაილების მოკლე სახელებით. გრძელ სახელებთან მუშაობის პროცედურა არ არის გათვალისწინებული ამ სტატიაში.

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("%d კლასტერების წაკითხვა", 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 ბუფერი და struct split_name sn სტრუქტურა:

ფაილის აბსოლუტური გზის სახელის პირველი სიმბოლო უნდა იყოს წინ დახრილი (/). მოდით შევამოწმოთ:

წაიკითხეთ ჩატვირთვის სექტორი დანაყოფიდან:

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

წაკითხვის ჩატვირთვის სექტორი ახლა არის გლობალურ სტრუქტურაში fat_boot_sector fbs. მოდით დავაკოპიროთ სექტორის ზომა, ჩანაწერების რაოდენობა root დირექტორიაში და სექტორების მთლიანი რაოდენობა დანაყოფზე ამ სტრუქტურიდან:

განსაზღვრეთ კლასტერის ზომა ბაიტებში:

Byte_per_cluster = fbs.cluster_size * 512

მოდით ვაჩვენოთ ინფორმაცია ჩატვირთვის სექტორში:

Printf("სისტემის id - %s ", fbs.system_id);

Printf(" სექტორის ზომა - %d ", სექტორის_ზომა);

Printf("კლასტერის ზომა - %d ", fbs.cluster_size);

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

Printf("FATs ნომერი - %d ",fbs.fats);

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

Printf("სექტორები - %d ", სექტორები);

Printf("მედია - 0x%X", fbs.media);

Printf("FAT16 სიგრძე - %u ", fbs.fat_length);

Printf("სულ სექტი - %u ", fbs.total_sect);

Printf("ბაიტი კლასტერზე - %d ", ბაიტი_თითო კლასტერზე);

ჩვენ ვიანგარიშებთ FAT16-ის ზომას ბაიტებში და ვკითხულობთ მას:

fat16_size = fbs.fat_length * 512;

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

root დირექტორიას წაკითხვა:

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

dir_entry მაჩვენებელი ახლა განლაგებულია მეხსიერების ზონაში, რომელიც შეიცავს root დირექტორიას ჩანაწერებს. ამ მეხსიერების არეალის ზომა უდრის root დირექტორიას ზომას (root_size).

შეინახეთ (კონტროლისთვის) root დირექტორიას შინაარსი ცალკე ფაილში:

#ifdef გამართვა

დახურვა (ცხიმიანი);

#დაასრულე თუ

გამოთვალეთ მონაცემთა არეალის დასაწყისი:

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

root დირექტორიაში ყველა ჩანაწერით, ჩვენ შეგვიძლია მივიღოთ test.txt ფაილის შინაარსი. ამ მიზნით, ჩვენ ვაწყობთ ციკლს. ციკლის ძირითად ნაწილში ჩვენ გავაანალიზებთ ფაილის სრულ სახელს, გამოვყოფთ მის ელემენტებს - ქვედირექტორიებს (გვაქვს ორი მათგანი Folder1 და Folder2) და სასურველი ფაილის სახელს (test.txt).

სანამ (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] == "?")) (

მე++;

შესვენება;

tmp_name_buff[n] = "?";

ჩვენ ვავსებთ სტრუქტურის struct split_name sn შესაბამისი ინფორმაციით. შევსება ხორციელდება split_name ფუნქციით და ფაილის სახელი მოწმდება "8.3" ფორმატთან შესაბამისობაში:

< 0) {

printf ("არასწორი სახელი");

დაბრუნება -1;

ფაილის სრული სახელის თითოეული ელემენტისთვის, ჩვენ განვსაზღვრავთ საწყის კლასტერს. ამისათვის ჩვენ ვეძებთ დირექტორიაში ელემენტებს (ძირიდან დაწყებული) სრული სახელის ელემენტის შესაბამისი ჩანაწერი და ვკითხულობთ ამ ჩანაწერს. ძიების პროცედურა ხორციელდება get_dentry() ფუნქციით:

If(get_dentry(&sn)< 0) {

Printf ("ასეთი ფაილი არ არის!");

დაბრუნება -1;

ფაილის ატრიბუტების შემოწმება. თუ ეს დირექტორია, წაიკითხეთ მისი შინაარსი და განაგრძეთ ციკლი:

თუ (dentry.attr & 0x10) (

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

გაგრძელება;

თუ ეს არის ფაილი, ჩვენ ვკითხულობთ პირველ num კლასტერებს. კონტროლისთვის, წაკითხული ინფორმაცია შეინახება ცალკე ფაილში:

თუ (dentry.attr & 0x20) (

Start_cluster = dentry.start;

tmp_buff = (__u8 *)malloc(byte_per_cluster); // აქ წაიკითხება კლასტერის შინაარსი

N = open("cust", O_CREAT|O_RDWR, 0600); // შეინახეთ წაკითხული ინფორმაცია ამ ფაილში

თუ (n< 0) {

შეცდომა ("ღია");

დაბრუნება -1;

ფაილის კლასტერების წასაკითხად ჩვენ ვაწყობთ ციკლს:

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

ჩვენ ვკითხულობთ კლასტერის შიგთავსს tmp_buff ბუფერში და ვინახავთ მას ცალკე ფაილში:

< 0) return -1;

< 0) {

შეცდომა ("ჩაწერა");

დახურვა(n);

დაბრუნება -1;

ჩვენ ვკითხულობთ FAT16-დან ამ ფაილის მიერ დაკავებული შემდეგი კლასტერის რიცხვს. თუ ეს ბოლო კლასტერია, ჩვენ ვწყვეტთ ციკლს და ვუბრუნდებით მთავარ ფუნქციას:

#ifdef გამართვა

Printf ("OK. წაკითხვა");

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

#დაასრულე თუ

თუ (შემდეგი_კლასტერი == EOF_FAT16) (

#ifdef გამართვა

Printf ("ბოლო კლასტერი. ");

#დაასრულე თუ

უფასო (tmp_buff);

დახურვა(n);

დაბრუნება ++i;

#ifdef გამართვა

printf ("კითხვის შეწყვეტა");

#დაასრულე თუ

დაბრუნება 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(pred64(hard, (__u8 *)fat16, fat16_size, seek)< 0) return -1;

დაბრუნება 0;

root დირექტორია იკითხება read_root_dentry() ფუნქციით:

int read_root_dentry()

U64 seek = (__u64)fbs.reserved * 512 + fat16_size * fbs.fats; // გადაინაცვლა root დირექტორიაში განყოფილების დასაწყისიდან

Root_size = 32 * dir_entries; // გამოთვალეთ root დირექტორიას ზომა

dir_entry = (__u8 *)malloc(root_size);

თუ(!dir_entry) დაბრუნება -1;

Memset(dir_entry, 0, root_size);

If (pred64 (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 ძიება = (__u64)(ბაიტი_თითო კლასტერში) * (კლასტერი_რაოდენობა - 2) + მონაცემთა_დაწყება; // გამოთვალეთ ოფსეტი კლასტერში

< 0) return -1;

დაბრუნება 0;

read_directory ფუნქცია კითხულობს დირექტორიას (არა root) ჩანაწერებს და ათავსებს შედეგს მეხსიერების არეში, რომელზეც მითითებულია dir_entry მაჩვენებელი:

int read_directory (__u16 start_cluster)

Int i = 1;

U16 შემდეგი_კლასტერი;

For(; ;i++) (

ჩვენ გამოვყოფთ მეხსიერებას დირექტორიაში შიგთავსის შესანახად, ვკითხულობთ საწყისი კლასტერის შიგთავსს და ვიღებთ შემდეგი კლასტერის მნიშვნელობას FAT16 ცხრილიდან:

თუ(!dir_entry) დაბრუნება -1;

< 0) return -1;

შემდეგი_კლასტერი = fat16;

მოდით შევინახოთ დირექტორიის შინაარსი ცალკე ფაილში (კონტროლისთვის):

#ifdef გამართვა

Printf("შემდეგი კლასტერი - 0x%X", შემდეგი_კლასტერი);

Fat = ღია ("dir16", O_CREAT|O_WRONLY, 0600);

Write(fat, dir_entry, root_size);

დახურვა (ცხიმიანი);

#დაასრულე თუ

თუ ბოლო კლასტერს მიაღწევთ, გამოდით მარყუჟიდან, წინააღმდეგ შემთხვევაში გააგრძელეთ დირექტორიის კითხვა dir_entry ბუფერის ზომის კიდევ ერთი კლასტერით გაზრდით:

If(next_cluster & EOF_FAT16) break;

დაწყება_კლასტერი = შემდეგი_კლასტერი;

დაბრუნება 0;

get_dentry() ფუნქცია ახორციელებს საძიებო ფაილის შიგთავსში ელემენტის ძიებას. ამ ფუნქციის შეყვანის პარამეტრები არის მაჩვენებელი struct split_name *sn სტრუქტურაზე, რომელიც შეიცავს მოკლე ფაილის სახელის ელემენტებს:

Int i = 0;

dir_entry გლობალური ბუფერი შეიცავს დირექტორიაში ჩანაწერების მასივს, რომელშიც ჩვენ ვაპირებთ მოვძებნოთ ფაილის (ან დირექტორიაში) ჩანაწერი. საძიებლად ვაწყობთ ციკლს. მარყუჟის სხეულში, ჩვენ ვაკოპირებთ კატალოგის ელემენტებს გლობალურ დენტრიულ სტრუქტურაში და ვადარებთ ამ სტრუქტურის სახელისა და ext ველების მნიშვნელობას struct split_name *sn სტრუქტურის შესაბამის ველებთან. ამ ველების დამთხვევა ნიშნავს, რომ ჩვენ ვიპოვნეთ სასურველი ფაილის ჩანაწერი დირექტორია ელემენტების მასივში:

for(; ; i++) (

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

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

შესვენება;

If(!dentry.name) დააბრუნებს -1;

#ifdef გამართვა

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

Printf("დაწყების კლასტერი - 0x%X", dentry.start);

Printf("ფაილის ზომა - %u", dentry.size);

Printf("ფაილის attrib - 0x%X", dentry.attr);

#დაასრულე თუ

დაბრუნება 0;

ყველა ზემოთ ჩამოთვლილი კოდი მდებარეობს FAT16 დირექტორიაში, ფაილი fat16.c. შესრულებადი მოდულის მისაღებად შევქმნათ Makefile შემდეგი შინაარსით:

INCDIR = /usr/src/linux/include

PHONY=სუფთა

Fat16: fat16.o გაყოფილი.o

Gcc -I$(INCDIR) $^ -g -o [ელფოსტა დაცულია]

%.o: %.გ

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-ბიტიან სიტყვას ცხრილიდან:

ძიება = (კლასტერი_რაოდენობა * 3) / 2;

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

თუ კლასტერის საწყისი ნომერი ლუწი რიცხვია, ცხრილიდან წაკითხულ მნიშვნელობას 4 ბიტით გადავიტანთ ქვედა ბიტებისკენ, თუ კენტია, ვამატებთ 0x0FFF-ით:

If(Cluster_num % 2) კლასტერი >>= 4;

სხვა ჯგუფი &= 0x0FFF;

ეს სნიპეტი ასევე შეიძლება განხორციელდეს ასამბლერში:

" xorw %%ax, %%ax "

"btw $0, %%cx"

"jnc 1f"

" shrw $4, %%dx "

"jmp2f"

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

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

:"=a" (შემდეგი)

:"d" (ჯგუფი), "c" (კლასტერი_რაოდენობა));

ჩვენ ვაბრუნებთ შედეგს:

დაბრუნების კლასტერი;

მოდით უფრო ახლოს მივხედოთ თავად ალგორითმს. დავუშვათ, რომ ფაილი შეიქმნა FAT12 დანაყოფზე, რომელიც იკავებს მე-9 და მე-10 კლასტერებს. თითოეული FAT12 ელემენტი არის 12 ბიტი. იმიტომ რომ ჩვენ ვკითხულობთ ცხრილიდან 16-ბიტიან ელემენტებს, მაშინ მე-9 ელემენტის გადანაცვლება იქნება 13 ბაიტის ტოლი (9 * 1.5 = 13, გადააგდეთ დარჩენილი ნაწილი), ხოლო ქვედა 4 ბიტი მიეკუთვნება მე-8 FAT ელემენტს. ისინი უნდა განადგურდეს და ამისთვის საკმარისია წაკითხული ელემენტის გადატანა 4 ბიტით ქვედა ბიტებისკენ, რაც მოწოდებულია ალგორითმით. მე-10 ელემენტზე ოფსეტი იქნება 15 ბაიტი, ხოლო მაღალი 4 ბიტი მიეკუთვნება FAT-ის მე-11 ელემენტს. მათ გასაუქმებლად საჭიროა მე-10 ელემენტზე და ნიღაბი 0x0FFF-ზე AND ოპერაციის შესრულება, რომელიც ასევე შეესაბამება ზემოხსენებულ ალგორითმს.

მოდულის საწყისი ტექსტები ფაილის წასაკითხად FAT12 დანაყოფიდან განთავსებულია FAT12 დირექტორიაში, ფაილი fat12.c.

ალგორითმის პროგრამული დანერგვა ლოგიკური დანაყოფიდან ფაილის წასაკითხად FAT32 ფაილური სისტემით

FAT32 ფაილური სისტემით დანაყოფიდან ფაილის წაკითხვის ალგორითმი პრაქტიკულად იგივეა, რაც FAT16-ისთვის, გარდა იმისა, რომ FAT32-ში root დირექტორია შეიძლება განთავსდეს დანაყოფზე ნებისმიერ ადგილას და ჰქონდეს თვითნებური ზომა. ამიტომ, უფრო საინტერესო რომ გავხადოთ, დავალება გავართულოთ - დავუშვათ, რომ ჩვენ ვიცით მხოლოდ დანაყოფის ნომერი FAT32 ფაილური სისტემით. ამ დანაყოფიდან ინფორმაციის წასაკითხად, ჯერ უნდა დაადგინოთ მისი კოორდინატები - დისკის დასაწყისიდან დანაყოფის გადაადგილება. და ამისათვის თქვენ უნდა გქონდეთ წარმოდგენა მყარი დისკის ლოგიკური სტრუქტურის შესახებ.

მყარი დისკის ლოგიკური სტრუქტურა

განვიხილოთ მყარი დისკის ლოგიკური სტრუქტურა, რომელიც შეესაბამება მაიკროსოფტის სტანდარტს – „მთავარი დანაყოფი – გაფართოებული დანაყოფი – არა DOS დანაყოფები“.

მყარ დისკზე სივრცე შეიძლება ორგანიზებული იყოს ერთ ან მეტ დანაყოფად, ხოლო ტიხრები შეიძლება შეიცავდეს ერთ ან მეტ ლოგიკურ დისკს.

მყარ დისკზე ფიზიკურ მისამართზე 0-0-1 არის ჩატვირთვის ძირითადი ჩანაწერი (Master Boot Record, MBR). MBR სტრუქტურა შეიცავს შემდეგ ელემენტებს:

• არასისტემური ჩამტვირთველი (არასისტემური ჩამტვირთავი - NSB);
• დისკის დანაყოფის აღწერილობის ცხრილი (ტიხრების ცხრილი, დანაყოფების ცხრილი, PT). ის მდებარეობს MBR-ში ოფსეტური 0x1BE და იკავებს 64 ბაიტს;
• MBR ხელმოწერა. MBR-ის ბოლო ორი ბაიტი უნდა შეიცავდეს რიცხვს 0xAA55.

დანაყოფების ცხრილი აღწერს ტიხრების ადგილმდებარეობას და მახასიათებლებს მყარ დისკზე. დისკის დანაყოფები შეიძლება იყოს ორი ტიპის - პირველადი (პირველადი, ძირითადი) და გაფართოებული (გაფართოებული). ძირითადი დანაყოფების მაქსიმალური რაოდენობა არის ოთხი. დისკზე მინიმუმ ერთი ძირითადი დანაყოფის არსებობა სავალდებულოა. გაფართოებული დანაყოფი შეიძლება დაიყოს უამრავ ქვესექციად - ლოგიკურ დისკებად. MBR-ის გამარტივებული სტრუქტურა წარმოდგენილია ცხრილში 7. დანაყოფის ცხრილი მდებარეობს MBR-ის ბოლოს, 16 ბაიტი გამოყოფილია ცხრილში დანაყოფის აღსაწერად.

ცხრილი 7. MBR სტრუქტურა

მიკერძოება ზომა, ბაიტი 0 446 0x1BE 16 0x1 CE 16 0x1DE 16 0x1EE 16 0x1FE 2

დანაყოფების ცხრილის შესვლის სტრუქტურა ნაჩვენებია ცხრილში 8.

ცხრილი 8. დანაყოფი ცხრილის ჩანაწერის სტრუქტურა

განყოფილების ელემენტში პირველი ბაიტი არის სექციის აქტივობის დროშა (0 - არააქტიური, 0x80 - აქტიური). ის ემსახურება იმის დადგენას, არის თუ არა დანაყოფი სისტემის ჩატვირთვის დანაყოფი და საჭიროა თუ არა მისგან ოპერაციული სისტემის ჩატვირთვა კომპიუტერის გაშვებისას. მხოლოდ ერთი განყოფილება შეიძლება იყოს აქტიური. დანაყოფის აქტივობის დროშას მოსდევს დანაყოფის დასაწყისის კოორდინატები - სამი ბაიტი, სადაც მითითებულია სათავე ნომერი, სექტორის ნომერი და ცილინდრის ნომერი. ცილინდრისა და სექტორის ნომრები მოცემულია შეწყვეტის ფორმატში Int 0x13, ე.ი. ბიტი 0-5 შეიცავს სექტორის რიცხვს, 6-7 ბიტი არის 10-ბიტიანი ცილინდრის ყველაზე მნიშვნელოვანი ორი ბიტი, 8-15 ბიტი არის ცილინდრის ნომრის ყველაზე ნაკლებად მნიშვნელოვანი რვა ბიტი. შემდეგ მიჰყვება კოდის იდენტიფიკატორი სისტემის ID, რაც მიუთითებს, რომ ეს დანაყოფი ეკუთვნის ამა თუ იმ ოპერაციულ სისტემას. იდენტიფიკატორი იკავებს ერთ ბაიტს. სისტემის იდენტიფიკატორის უკან არის განყოფილების ბოლო კოორდინატები - სამი ბაიტი, რომელიც შეიცავს შესაბამისად თავის, სექტორისა და ცილინდრის ნომრებს. შემდეგი ოთხი ბაიტი არის სექტორების რაოდენობა დანაყოფის წინ, ხოლო ბოლო ოთხი ბაიტი არის დანაყოფის ზომა სექტორებში.

ამრიგად, დანაყოფის ცხრილის ელემენტი შეიძლება აღწერილი იყოს შემდეგი სტრუქტურის გამოყენებით:

struct pt_struct(

U8 ჩამტვირთველი; // განყოფილების აქტივობის დროშა

U8 დასაწყისი_ნაწილი; // განყოფილების დასაწყისის კოორდინატები

U8 ტიპი_ნაწილი; // სისტემის იდენტიფიკატორი

U8 ბოლო_ნაწილი; // განყოფილების ბოლოს კოორდინატები

U32 სექტა_ადრე; // სექტორების რაოდენობა დაყოფამდე

U32 სექტა_სულ; // დანაყოფის ზომა სექტორებში (სექტორების რაოდენობა დანაყოფში)

პირველადი დანაყოფის ელემენტი დაუყოვნებლივ მიუთითებს ლოგიკური დისკის ჩატვირთვის სექტორზე (პირველ დანაყოფში ყოველთვის არის მხოლოდ ერთი ლოგიკური დისკი), ხოლო გაფართოებული დანაყოფის ელემენტი მიუთითებს ლოგიკური დისკების სიაზე, რომლებიც შედგება სტრუქტურებისგან, რომელსაც ეწოდება მეორადი. MBR (მეორადი MBR, SMBR).

გაფართოებულ დანაყოფში თითოეულ დისკს აქვს საკუთარი SMBR ბლოკი. SMBR-ს აქვს MBR-ის მსგავსი სტრუქტურა, მაგრამ მას არ აქვს ჩატვირთვის ჩანაწერი (ივსება ნულებით) და დანაყოფის აღწერის ოთხი ველიდან მხოლოდ ორი გამოიყენება. დანაყოფის პირველი ელემენტი მიუთითებს ლოგიკურ დისკზე, მეორე ელემენტი მიუთითებს სიაში მომდევნო SMBR სტრუქტურაზე. სიაში ბოლო SMBR შეიცავს სექციის კოდს ნულს მეორე ელემენტში.

მოდით დავუბრუნდეთ FAT32 დანაყოფიდან ფაილის წაკითხვის მოდულის განხილვას.

სათაურის ფაილები:

#შეიცავს

#შეიცავს

#შეიცავს

#შეიცავს

#შეიცავს

MBR ხელმოწერა:

#define SIGNATURE 0xAA55

მოწყობილობის ფაილი, საიდანაც წაიკითხება დანაყოფის ინფორმაცია:

#define DEVICE "/dev/hda"

დანაყოფის ცხრილის შესვლის ზომა (16 ბაიტი):

#define PT_SIZE 0x10

სტრუქტურების შემდეგი მასივი ასახავს განყოფილების ტიპის კოდს მის სიმბოლოებთან:

სტრუქტურის სისტემის ტიპები (

U8 ნაწილი_ტიპი;

U8 *ნაწილის_სახელი;

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, "Linux swap"),

(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 დასაწყისი_ნაწილი;

U8 ტიპი_ნაწილი;

U8 ბოლო_ნაწილი;

U32 სექტა_ადრე;

U32 სექტა_სულ;

)pt_t;

შიდა; // მოწყობილობის ფაილის აღმწერი

U8mbr; // აქ დაითვალეთ 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 ბაიტი_თითო კლასტერში; // რამდენი ბაიტია კლასტერში (კლასტერის ზომა ბაიტებში)

U32 შემდეგი_კლასტერი; // შემდეგი კლასტერი ჯაჭვში

U32 root_cluster; // ROOT კლასტერი - root დირექტორიას საწყისი კლასტერი

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

შეცდომა ("get_pt_info");

გასვლა (-1);

Show_pt_info();

გამოთვალეთ დანაყოფის საწყისი ოფსეტი:

დაწყება_ძიების = (__u64)(pt_t.sect_ადრე) * 512;

წაიკითხეთ ფაილის კუთვნილი კლასტერები:

Num = fat32_read_file(სრული_გზა, კლასტერი_რიცხვი);

თუ (რ< 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);

თუ (check_sign ()< 0) {

Printf("არასწორი ხელმოწერა!\n");

დაბრუნება -1;

ჩვენ ვეძებთ გაფართოებული განყოფილების იდენტიფიკატორს. თუ არსებობს, ჩვენ ვიანგარიშებთ ოფსეტს გაფართოებულ დანაყოფზე და ვკითხულობთ ინფორმაციას ლოგიკური დისკების შესახებ:

for(; i< 4; i++) {

თუ((pt_t[i].ტიპი_ნაწილი == 0xF) || \

(pt_t[i].ტიპი_ნაწილი == 0x5) || \

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

ძიება = (__u64)pt_t[i].sect_fore * 512;

Read_ext_ptable(მძიმე, ძიება);

შესვენება;

დაბრუნება 0;

დანაყოფი ცხრილის წაკითხვის ფუნქცია read_main_ptable():

void read_main_ptable (int hard)

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

შეცდომა ("წაკითხვა");

დახურვა (მძიმე);

გასვლა (-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 გამართვა

Printf("ხელმოწერა - 0x%X\n", ნიშანი);

#დაასრულე თუ

If(sign != SIGNATURE) დაბრუნება -1;

დაბრუნება 0;

გაფართოებული დანაყოფი ცხრილის წაკითხვის ფუნქცია:

void read_ext_ptable (int hard, __u64 ძიება)

int num = 4; // ამ პოზიციიდან დაწყებული, pt_t სტრუქტურების მასივი შეივსება ლოგიკური დისკების შესახებ ინფორმაციით

U8 სმბრ;

Შესაყვანი მონაცემები:

• მძიმე– მოწყობილობის ფაილის აღმწერი;
• ეძიოს– დისკის დასაწყისიდან გაფართოებულ დანაყოფზე ოფსეტური (ბაიტებით).

ლოგიკური დისკების შესახებ ინფორმაციის მისაღებად, ჩვენ ვაწყობთ მარყუჟს:

For(;;num++) (

ჩვენ ვკითხულობთ SMBR-ს, რომელიც მდებარეობს ძებნის ოფსეტზე დისკის დასაწყისიდან:

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

pred64(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 += (ძებნა / 512);

თუ დანაყოფის ტიპის კოდი ნულია, მაშინ აღარ არის ლოგიკური დისკები:

If(!(pt_t.type_part)) break;

გამოთვალეთ ოფსეტი შემდეგ SMBR-მდე:

ძიება = ((__u64)(pt_t.sect_წინა + pt_t.sect_total)) * 512;

დაბრუნების;

ფუნქცია show_pt_info() აჩვენებს ინფორმაციას მოწყობილობაზე ნაპოვნი ლოგიკური დისკების შესახებ:

void show_pt_info()

Int i = 0, n;

#ifdef გამართვა

Printf("ტიხრების რაოდენობა დისკზე - %d\n", PART_NUM);

#დაასრულე თუ

ამისთვის (; 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].ნაწილის სახელი);

შესვენება;

If(n == PART_NUM) printf("უცნობი ტიპი\n");

Printf("Boot flag - 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_წინ);

დაბრუნების;

ფაილების კლასტერების წაკითხვა 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 != "/") 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);

ჩვენ ვკითხულობთ 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; // root დირექტორიას კლასტერული ნომერი

წაიკითხეთ FAT32:

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

მეხსიერების გამოყოფა დირექტორიაში ჩანაწერებისთვის:

Dir_entry = (__u8 *)malloc(byte_per_cluster);

თუ(!dir_entry) დაბრუნება -1;

root დირექტორიას წაკითხვა:

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

ჩვენ ვაანალიზებთ ფაილის სრულ გზას და ვყოფთ თითოეულ ელემენტს კომპონენტებად:

სანამ (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] = სრული_გზა[i];

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

მე++;

შესვენება;

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("cust", O_CREAT|O_RDWR, 0600);

თუ (n< 0) {

შეცდომა ("ღია");

დაბრუნება -1;

Printf("ფაილის პირველი კლასტერი - 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;

თუ (ჩაწერა (n, tmp_buff, ბაიტი_თითო კლასტერში)< 0) {

შეცდომა ("ჩაწერა");

დაბრუნება -1;

თუ (შემდეგი_კლასტერი == EOF_FAT32) (

უფასო (tmp_buff);

დახურვა(n);

დაბრუნება ++i;

დაწყება_კლასტერი = შემდეგი_კლასტერი;

დაბრუნება i;

შემდეგი სამი ფუნქციის მიზანია მიიღოს სისტემის არეალის შინაარსი, ე.ი. ჩატვირთვის სექტორი, FSIinfo სტრუქტურა და FAT32 ცხრილი:

1) read_fbs() ფუნქცია კითხულობს ჩატვირთვის სექტორს:

int read_fbs()

If(pred64(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(pred64(hard, (__u8 *)&fsinfo, sizeof(fsinfo), ძიება)< 0) return -1;

დაბრუნება 0;

3) read_fat32() ფუნქცია კითხულობს FAT32 ცხრილს:

int read_fat32()

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

Fat32 = (void *)malloc(fat32_size);

თუ(!fat32) დაბრუნდება -1;

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

დაბრუნება 0;

read_cluster() ფუნქცია კითხულობს კლასტერს მითითებული ნომრით:

int read_cluster (__u32 cluster_num, __u8 *tmp_buff)

U64 ძიება = (__u64)(ბაიტი_თითო კლასტერში) * (კლასტერი_რაოდენობა - 2) + მონაცემთა_დაწყება + დაწყების_ძიება;

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

დაბრუნება 0;

დირექტორიების წაკითხვა (მათ შორის ძირეული) მუშავდება read_directory() ფუნქციით:

int read_directory (__u32 start_cluster)

int i = 2;

U32 შემდეგი_კლასტერი;

ფუნქციის პარამეტრები არის საწყისი კატალოგის კლასტერი. ჩვენ ვკითხულობთ დირექტორიას შიგთავსს dir_entry გლობალურ ბუფერში:

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

შემდეგი_კლასტერი = fat32;

თუ დირექტორია ერთ კლასტერს იკავებს, გადით, თუ არა, გაზარდეთ მეხსიერების ზომა და განაგრძეთ კითხვა:

For(; ;i++) (

დაწყება_კლასტერი = შემდეგი_კლასტერი;

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

თუ(!dir_entry) დაბრუნება -1;

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

შემდეგი_კლასტერი = fat32;

If((შემდეგი_კლასტერი == EOF_FAT32) || (შემდეგი_კლასტერი == 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)))

შესვენება;

If(!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() ფუნქციას ფაილის სახელიდან ინოდის ნომრის დასადგენად. ამ ფუნქციის ძველი ვერსია ასე გამოიყურებოდა:

int get_i_num (char *name)

int i = 0, rec_len = 0;

სტრუქტურა ext2_dir_entry_2dent;

ამისთვის (; 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)

* ფუნქციის პარამეტრი - ფაილის სახელი. დაბრუნებული მნიშვნელობა არის ფაილის ინოდური ნომერი.

int rec_len = 0;

სტრუქტურა ext2_dir_entry_2dent; // ეს სტრუქტურა აღწერს root დირექტორიაში ჩანაწერის ფორმატს:

* გლობალური ბუფერული ბუფერი შეიცავს დირექტორიაში ჩანაწერების მასივს. ფაილის ინოდური ნომრის დასადგენად, თქვენ უნდა იპოვოთ

* ამ მასივში არის ჩანაწერი ამ ფაილის სახელით. ამისათვის ჩვენ ვაწყობთ ციკლს:

ამისთვის(;;) (

/* დააკოპირეთ დირექტორიაში ჩანაწერები დენტ სტრუქტურაში: */

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

* ფაილის სახელის სიგრძე ნულოვანი ნიშნავს, რომ ჩვენ გავიმეორეთ ყველა დირექტორიაში

* და ჩანაწერები ჩვენი ფაილის სახელით ვერ მოიძებნა. ასე რომ, დროა დავბრუნდეთ:

If(!dent.name_len) დააბრუნებს -1;

/* ძებნა ხდება ფაილის სახელების შედარებით. თუ სახელები ემთხვევა, გამოდით ციკლიდან: */

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

/* თუ სახელები არ ემთხვევა, გადადით შემდეგ ჩანაწერზე: */

Rec_len += dent.rec_len;

/* წარმატების შემთხვევაში, დააბრუნეთ ფაილის ინოდური ნომერი: */

Return dent.inode;

ლიტერატურა:

1. ვ.კულაკოვი. პროგრამირება აპარატურის დონეზე: სპეციალური მითითება. მე-2 გამოცემა. / - პეტერბურგი: პეტრე, 2003 - 848 გვ.
2. A.V.Gordeev, A.Yu.Molchanov. სისტემური პროგრამული უზრუნველყოფა/ - პეტერბურგი: პეტრე - 2002 წ
3. მეშკოვი ვ. ext2 ფაილური სისტემის არქიტექტურა. - ჟურნალი "სისტემის ადმინისტრატორი", No11 (12), 2003 წლის ნოემბერი - 26-32 გვ.

კონტაქტში

მყარ დისკზე ინფორმაციისა და პროგრამების შესანახად მრავალი გზა არსებობს. ძალიან ცნობილი სისტემა, რომელიც ინახავს სხვადასხვა ინფორმაციას ფაილების სახით, აჯგუფებს მათ საქაღალდეებში უნიკალური დავალებით. თუმცა, ცოტა ადამიანი ფიქრობდა იმაზე, თუ როგორ ხდება რეალურად მედიაზე ინფორმაციის ფიზიკური შენახვა.

იმისათვის, რომ ინფორმაცია შეინახოს ფიზიკურ მედიაზე, ის უნდა მომზადდეს კომპიუტერის ოპერაციულ სისტემაში გამოსაყენებლად. Ოპერაციული სისტემაგამოყოფს დისკის თავისუფალ ადგილს ინფორმაციის შესანახად. ამისათვის თქვენ უნდა დაყოთ დისკი პატარა კონტეინერებად - სექტორებად. დაბალ დონეზე დისკის ფორმატირება თითოეულ სექტორს ანიჭებს გარკვეულ ზომას. ოპერაციული სისტემა აჯგუფებს ამ სექტორებს კლასტერებად. ზედა დონის ფორმატირება აყენებს ყველა კლასტერს იმავე ზომაზე, როგორც წესი, 2-დან 16 სექტორამდე დიაპაზონში. მომავალში, ერთი ან მეტი კლასტერი გამოიყოფა თითოეულ ფაილზე. კლასტერის ზომა დამოკიდებულია ოპერაციულ სისტემაზე, დისკის მოცულობაზე და საჭირო სიჩქარეზე.

დისკზე ფაილების შესანახი არეალის გარდა, არის ოპერაციული სისტემის მუშაობისთვის აუცილებელი ადგილები. ეს ზონები შექმნილია ჩატვირთვის ინფორმაციის შესანახად და ინფორმაციის შესანახად ფაილების მისამართების ფიზიკურ მდებარეობებზე დისკზე. ჩატვირთვის ზონა გამოიყენება ოპერაციული სისტემის დასაწყებად. BIOS-ის ჩატვირთვის შემდეგ, დისკის ჩატვირთვის არე იკითხება და სრულდება ოპერაციული სისტემის დასაწყებად.

FAT ფაილური სისტემა

FAT ფაილური სისტემა გამოჩნდა Microsoft DOS ოპერაციული სისტემით, რის შემდეგაც იგი რამდენჯერმე გაუმჯობესდა. მას აქვს FAT12, FAT16 და FAT32 ვერსიები. თავად სახელი FAT მომდინარეობს ფაილური სისტემის მიერ ერთგვარი მონაცემთა ბაზის გამოყენებით "ფაილის განაწილების ცხრილის" (File Allocation Table) სახით, რომელიც შეიცავს ჩანაწერს დისკზე თითოეული კლასტერისთვის. ვერსიის ნომრები ეხება ცხრილში მოცემული ნივთების ნომრებში გამოყენებული ბიტების რაოდენობას. ამიტომ, ფაილურ სისტემას აქვს ლიმიტი მხარდაჭერილი დისკის ზომაზე. 1987 წელს მას არ უჭერდა მხარს 32 მბ-ზე დიდი დისკები. Windows 95-ის მოსვლასთან ერთად გამოვიდა ახალი ვერსია FAT32 ფაილური სისტემა 2 ტბ-მდე დისკების თეორიული მხარდაჭერით. დიდი დისკების მხარდაჭერის მუდმივი პრობლემები ჩნდება ელემენტების ფიქსირებული რაოდენობის გამო, რომელიც შემოიფარგლება კლასტერის პოზიციის განსაზღვრისას გამოყენებული ბიტების რაოდენობით. მაგალითად, FAT16 ვერსია არ უჭერს მხარს 216 ან 65536-ზე მეტ კლასტერს. ასევე შეზღუდულია კლასტერში სექტორების რაოდენობა.

დიდი დისკების კიდევ ერთი პრობლემა იყო მცირე ფაილებისთვის გამოყოფილი უზარმაზარი სივრცის გამოყენების შეუძლებლობა. იმის გამო, რომ კლასტერების რაოდენობა შეზღუდულია, მათი ზომა გაიზარდა დისკის მთელი სიმძლავრის დასაფარად. ეს იწვევს სივრცის არაეფექტურ გამოყენებას ფაილების უმეტესობის შენახვისას, რომლებიც არ არიან კლასტერის ზომის მრავალჯერადი. მაგალითად, FAT32 გამოყოფს 16 KB კლასტერებს დისკის ტიხრებისთვის 16 GB-დან 32 GB-მდე. 20 KB ფაილის შესანახად დაგჭირდებათ ორი 16 KB კლასტერი, რომელიც დაიკავებს 32 KB დისკზე. 1 კბაიტი ფაილი იკავებს 16 კბ ადგილს დისკზე. ამრიგად, საშუალოდ, დისკის ტევადობის 30-40% იხარჯება მცირე ფაილების შესანახად. დისკის მცირე დანაყოფებად დაყოფა საშუალებას გაძლევთ შეამციროთ კლასტერის ზომა, მაგრამ ის პრაქტიკაში არ გამოიყენება 200 გბ-ზე მეტი ტევადობის დისკებისთვის.

ფაილის ფრაგმენტაცია ასევე არ არის ფაილური სისტემის მცირე პრობლემა. მას შემდეგ, რაც შეიძლება საჭირო გახდეს რამდენიმე კლასტერი ფაილის დასაყენებლად, რომლებიც შეიძლება ფიზიკურად არ იყოს განთავსებული ერთმანეთის მიყოლებით, წაკითხვის დრო ანელებს პროგრამებს. ამიტომ მუდმივი საჭიროებაა.

NTFS ფაილური სისტემა

1990-იანი წლების დასაწყისში მაიკროსოფტმა დაიწყო სრულიად ახალი პროგრამული უზრუნველყოფის შემუშავება, რომელიც შექმნილია იმ გარემოებისთვის, სადაც უფრო მეტი რესურსია მოხმარებული, ვიდრე ჩვეულებრივი სახლის მომხმარებლები. ბიზნესისა და ინდუსტრიის საჭიროებისთვის, DOS-ზე დაფუძნებული Windows ოპერაციული სისტემების მიერ მოწოდებული რესურსები არასაკმარისი გახდა. Microsoft Corporation მუშაობდა IBM-თან OS/2 ოპერაციულ სისტემაზე HPFS (High Performance File System) ფაილური სისტემით. კორპორატიულმა განვითარებამ წარმატება არ მოიტანა და მალე თითოეულმა კომპანიამ კვლავ თავისი გზა წავიდა. Microsoft-მა შეიმუშავა ოპერაციების სხვადასხვა ვერსია ვინდოუსის სისტემები NT, რომელზედაც აგებულია Windows 2000 და Windows XP. თითოეული მათგანი იყენებს NTFS ფაილური სისტემის საკუთარ ვერსიას, რომელიც განაგრძობს განვითარებას.

NTFS (New Technology File System) არის სტანდარტული ფაილური სისტემა Windows NT-ზე დაფუძნებული ოპერაციული სისტემებისთვის. იგი შექმნილია ცხიმის შესაცვლელად. NTFS უფრო მოქნილია ვიდრე FAT. მისი სისტემის არეები ინახავს ძირითადად ფაილებს და არა ფიქსირებულ სტრუქტურებს, როგორიცაა FAT, რაც მათ საშუალებას აძლევს შეიცვალოს, გაფართოვდეს ან გადავიდეს გამოყენების დროს. მარტივი მაგალითია Master File Table (MFT) - "master file table". MFT არის ერთგვარი მონაცემთა ბაზა, რომელიც შეიცავს სხვადასხვა ინფორმაციას დისკზე არსებული ფაილების შესახებ. მცირე ფაილები (1 KB ან ნაკლები) შეიძლება შენახული იყოს პირდაპირ MFT-ში. დიდი ფაილებისთვის NTFS გამოყოფს კლასტერებს, მაგრამ FAT-ისგან განსხვავებით, კლასტერის ზომა ჩვეულებრივ არ აღემატება 4 კბ-ს და ჩაშენებული შეკუმშვის მეთოდი გამორიცხავს ფაილებისთვის გამოყოფილ სივრცეში არსებულ პრობლემებს. და NTFS-ში შეგიძლიათ გამოიყენოთ .

NTFS ფაილური სისტემა შექმნილია მრავალ მომხმარებლის გარემოსთვის და აქვს ჩაშენებული უსაფრთხოებისა და წვდომის კონტროლის მექანიზმები. მაგალითად, ოპერაციული სისტემები Windows 2000 და Windows XP (გარდა "Home Edition") საშუალებას გაძლევთ დააყენოთ წვდომის ნებართვები ცალკეულ ფაილებზე და დაშიფვროთ ისინი. თუმცა, უსაფრთხოების მაღალი დონე ართულებს ჩვეულებრივი მომხმარებლების მუშაობას კომპიუტერთან. ძალიან ფრთხილად უნდა იყოთ პაროლების და ფაილის ნებართვების დაყენებისას, რათა არ დაკარგოთ მნიშვნელოვანი მონაცემები.

ყველა სხვა ამოცანის გარდა, ის ასრულებს თავის მთავარ მიზანს - აწყობს სამუშაოს მონაცემებთან გარკვეული სტრუქტურის მიხედვით. ამ მიზნებისათვის გამოიყენება ფაილური სისტემა. რა არის FS და რა შეიძლება იყოს ის, ისევე როგორც სხვა ინფორმაცია მის შესახებ ქვემოთ იქნება წარმოდგენილი.

ზოგადი აღწერა

ფაილური სისტემა არის ოპერაციული სისტემის ნაწილი, რომელიც პასუხისმგებელია მედიაზე ინფორმაციის განთავსებაზე, შენახვაზე, წაშლაზე, მომხმარებლებისა და აპლიკაციების ამ ინფორმაციის მიწოდებაზე და მისი უსაფრთხო გამოყენების უზრუნველსაყოფად. გარდა ამისა, ის არის ის, ვინც ეხმარება მონაცემთა აღდგენაში ტექნიკის ან პროგრამული უზრუნველყოფის უკმარისობის შემთხვევაში. სწორედ ამიტომ არის ფაილური სისტემა ასე მნიშვნელოვანი. რა არის FS და რა შეიძლება იყოს? არსებობს რამდენიმე ტიპი:

მყარი დისკებისთვის, ანუ შემთხვევითი წვდომის მქონე მოწყობილობებისთვის;

მაგნიტური ლენტისთვის, ანუ სერიული წვდომის მქონე მოწყობილობებისთვის;

ოპტიკური მედიისთვის;

ვირტუალური სისტემები;

ქსელური სისტემები.5

ფაილურ სისტემაში მონაცემთა შენახვის ლოგიკური ერთეული არის ფაილი, ანუ მონაცემთა შეკვეთილი კოლექცია, რომელსაც აქვს კონკრეტული სახელი. ოპერაციული სისტემის მიერ გამოყენებული ყველა მონაცემი წარმოდგენილია ფაილების სახით: პროგრამები, სურათები, ტექსტები, მუსიკა, ვიდეო, ასევე დრაივერები, ბიბლიოთეკები და ა.შ. თითოეულ ასეთ ელემენტს აქვს სახელი, ტიპი, გაფართოება, ატრიბუტები და ზომა. ასე რომ, ახლა თქვენ იცით, რომ ფაილური სისტემა არის ასეთი ელემენტების კრებული, ისევე როგორც მათთან მუშაობის გზები. იმისდა მიხედვით, თუ რა ფორმით გამოიყენება და რა პრინციპები გამოიყენება მასზე, შეიძლება განვასხვავოთ FS-ის რამდენიმე ძირითადი ტიპი.

პროგრამული მიდგომა

ასე რომ, თუ განიხილება ფაილური სისტემა (რა არის და როგორ ვიმუშაოთ მასთან), მაშინ უნდა აღინიშნოს, რომ ეს არის მრავალ დონის სტრუქტურა, მის ზედა დონეზე არის ფაილური სისტემის შეცვლა, რომელიც უზრუნველყოფს ინტერფეისს სისტემა და კონკრეტული აპლიკაცია. ის გარდაქმნის ფაილის მოთხოვნებს ფორმატში, რომელიც მიიღება შემდეგი დონის - დრაივერების მიერ. ისინი, თავის მხრივ, ეხება მოწყობილობის სპეციფიკურ დრაივერებს, რომლებიც ინახავს საჭირო ინფორმაციას.

კლიენტ-სერვერის აპლიკაციებისთვის ფაილური სისტემის მუშაობის მოთხოვნები საკმაოდ მაღალია. თანამედროვე სისტემები შექმნილია ეფექტური წვდომის უზრუნველსაყოფად, დიდი მოცულობის მედიის მხარდაჭერისთვის, მონაცემთა დაცვის არაავტორიზებული წვდომისგან და ინფორმაციის მთლიანობის შესანარჩუნებლად.

FAT ფაილური სისტემა

ეს ტიპი შეიქმნა ჯერ კიდევ 1977 წელს ბილ გეითსისა და მარკ მაკდონალდის მიერ. იგი თავდაპირველად გამოიყენებოდა OS 86-DOS-ში. თუ ვსაუბრობთ იმაზე, თუ რა არის FAT ფაილური სისტემა, მაშინ აღსანიშნავია, რომ თავდაპირველად მას არ შეეძლო მყარი დისკის მხარდაჭერა, მაგრამ მუშაობდა მხოლოდ მოქნილ მედიასთან 1 მეგაბაიტამდე. ახლა ეს შეზღუდვა აღარ არის აქტუალური და ეს FS გამოიყენებოდა Microsoft-ის მიერ MS-DOS 1.0 და შემდგომი ვერსიებისთვის. FAT იყენებს ფაილების დასახელების გარკვეულ კონვენციებს:

სახელი უნდა დაიწყოს ასოთი ან ნომრით და ის შეიძლება შეიცავდეს ნებისმიერ ASCII სიმბოლოს, გარდა სივრცეებისა და სპეციალური ელემენტებისა;

სახელის სიგრძე არ უნდა აღემატებოდეს 8 სიმბოლოს, მის შემდეგ მოთავსებულია წერტილი, შემდეგ კი მითითებულია გაფართოება, რომელიც შედგება სამი ასოსგან;

ფაილის სახელებს შეუძლიათ გამოიყენონ ნებისმიერი ქეისი და არ არიან გამორჩეული ან შენახული.

ვინაიდან FAT თავდაპირველად შეიქმნა ერთი მომხმარებლის DOS ოპერაციული სისტემისთვის, ის არ ითვალისწინებდა მფლობელის ან წვდომის უფლების შესახებ მონაცემების შენახვას. ამ დროისთვის ეს ფაილური სისტემა ყველაზე გავრცელებულია, უმეტესობა მხარს უჭერს მას ამა თუ იმ ხარისხით, მისი მრავალფეროვნება შესაძლებელს ხდის გამოიყენოს ის ტომებზე, რომლებთანაც მუშაობს სხვადასხვა ოპერაციული სისტემა. ეს არის მარტივი FS, რომელსაც არ შეუძლია თავიდან აიცილოს ფაილების კორუფცია კომპიუტერის არასწორი გამორთვის გამო. როგორც მასზე დაფუძნებული ოპერაციული სისტემების ნაწილი, არსებობს სპეციალური საშუალებები, რომლებიც ამოწმებენ სტრუქტურას და ასწორებენ ფაილების შეუსაბამობას.

NTFS ფაილური სისტემა

ეს FS არის ყველაზე სასურველი Windows NT-თან მუშაობისთვის, რადგან ის სპეციალურად შეიქმნა მისთვის. OS მოიცავს კონვერტაციის პროგრამას, რომელიც გარდაქმნის ტომებს FAT და HPFS NTFS ტომებად. თუ ვსაუბრობთ იმაზე, თუ რა არის NTFS ფაილური სისტემა, აღსანიშნავია, რომ მან მნიშვნელოვნად გააფართოვა გარკვეული დირექტორიებისა და ფაილების წვდომის კონტროლის შესაძლებლობა, დანერგა მრავალი ატრიბუტი, დანერგა დინამიური ფაილების შეკუმშვის ხელსაწყოები, შეცდომების ტოლერანტობა და მხარს უჭერს მოთხოვნებს. POSIX სტანდარტი. ამ FS-ში შეგიძლიათ გამოიყენოთ 255 სიმბოლომდე სიგრძის სახელები, ხოლო მოკლე სახელი იქმნება ისევე, როგორც VFAT-ში. იმის გაგება, თუ რა არის NTFS ფაილური სისტემა, უნდა აღინიშნოს, რომ ოპერაციული სისტემის უკმარისობის შემთხვევაში, მას შეუძლია საკუთარი თავის აღდგენა, ასე რომ დისკის მოცულობა დარჩება ხელმისაწვდომი და დირექტორია სტრუქტურა არ დაზარალდება.

NTFS-ის მახასიათებლები

NTFS ტომზე, თითოეული ფაილი წარმოდგენილია ჩანაწერით MFT ცხრილში. ცხრილის პირველი 16 ჩანაწერი დაცულია თავად ფაილური სისტემის მიერ სპეციალური ინფორმაციის შესანახად. პირველივე ჩანაწერი აღწერს თავად ფაილის ცხრილს. როდესაც პირველი ჩანაწერი განადგურებულია, მეორე იკითხება სარკისებური MFT ფაილის მოსაძებნად, სადაც პირველი ჩანაწერი იდენტურია მთავარი ცხრილის. დისკის ლოგიკური ცენტრი შეიცავს bootstrap ფაილის ასლს. ცხრილის მესამე ჩანაწერი შეიცავს ჟურნალის ფაილს, რომელიც გამოიყენება მონაცემთა აღდგენისთვის. ფაილების ცხრილის მეჩვიდმეტე და მომდევნო ჩანაწერები შეიცავს ინფორმაციას მყარ დისკზე არსებული ფაილებისა და დირექტორიების შესახებ.

ტრანზაქციის ჟურნალი შეიცავს ოპერაციების სრულ კომპლექტს, რომლებიც ცვლის მოცულობის სტრუქტურას, ფაილების შექმნის ოპერაციების ჩათვლით, ისევე როგორც ნებისმიერი ბრძანება, რომელიც გავლენას ახდენს დირექტორიას სტრუქტურაზე. ტრანზაქციის ჟურნალი შექმნილია NTFS-ის აღსადგენად სისტემის ავარიიდან. root დირექტორიაში ჩანაწერი შეიცავს დირექტორიათა და ფაილების ჩამონათვალს, რომლებიც მდებარეობს root დირექტორიაში.

EFS მახასიათებლები

დაშიფვრის ფაილური სისტემა (EFS) არის Windows-ის ფუნქცია, რომელსაც შეუძლია მყარ დისკზე ინფორმაციის შენახვა დაშიფრული ფორმატით. დაშიფვრა გახდა ყველაზე ძლიერი დაცვა, რაც ამ ოპერაციულ სისტემას შეუძლია. ამ შემთხვევაში, მომხმარებლისთვის დაშიფვრა საკმაოდ მარტივი ქმედებაა, ამისათვის საჭიროა მხოლოდ საქაღალდის ან ფაილის თვისებებში ველის შემოწმება. თქვენ შეგიძლიათ მიუთითოთ ვის შეუძლია წაიკითხოს ასეთი ფაილები. ფაილები დაშიფრულია დახურვისას და გახსნისას ისინი ავტომატურად მზად არიან გამოსაყენებლად.

RAW-ის მახასიათებლები

მონაცემთა შენახვისთვის განკუთვნილი მოწყობილობები ყველაზე დაუცველი კომპონენტებია, რომლებიც ყველაზე ხშირად ზიანდება არა მხოლოდ ფიზიკურად, არამედ ლოგიკურადაც. ზოგიერთი ტექნიკის პრობლემა შეიძლება ფატალური იყოს, ხოლო სხვებს აქვთ გადაწყვეტილებები. ზოგჯერ მომხმარებლებს აქვთ შეკითხვა: "რა არის RAW ფაილური სისტემა?"

მოგეხსენებათ, მყარ დისკზე ან ფლეშ დისკზე რაიმე ინფორმაციის ჩასაწერად დისკს უნდა ჰქონდეს ფაილური სისტემა. ყველაზე გავრცელებულია FAT და NTFS. და RAW არ არის ის ფაილური სისტემა, რომელზეც ჩვეულებრივ ვფიქრობთ. სინამდვილეში, ეს არის უკვე დაინსტალირებული სისტემის ლოგიკური შეცდომა, ანუ მისი ფაქტობრივი არარსებობა Windows-ისთვის. ყველაზე ხშირად, RAW ასოცირდება ფაილური სისტემის სტრუქტურის განადგურებასთან. ამის შემდეგ, OS არა მხოლოდ წვდება მონაცემებს, არამედ არ აჩვენებს ტექნიკურ ინფორმაციას აღჭურვილობაზე.

UDF მახასიათებლები

უნივერსალური დისკის ფორმატი (UDF) შექმნილია CDFS-ის ჩასანაცვლებლად და DVD-ROM მოწყობილობების მხარდაჭერის დასამატებლად. თუ ვსაუბრობთ იმაზე, თუ რა არის ეს, მაშინ ეს არის ძველი ვერსიის ახალი იმპლემენტაცია, რომლისთვისაც ის აკმაყოფილებს მოთხოვნებს, ხასიათდება გარკვეული მახასიათებლებით:

ფაილის სახელები შეიძლება იყოს 255 სიმბოლომდე;

სახელი შეიძლება იყოს მცირე ან დიდი;

ბილიკის მაქსიმალური სიგრძეა 1023 სიმბოლო.

Windows XP-დან დაწყებული, ამ ფაილური სისტემის წაკითხვა/ჩაწერა ხდება.

ეს FS გამოიყენება ფლეშ დრაივებისთვის, რომლებიც უნდა იყოს გამოყენებული სხვადასხვა კომპიუტერთან მუშაობისას, რომლებიც მუშაობენ სხვადასხვა ოპერაციულ სისტემაზე, კერძოდ Windows და Linux. სწორედ EXFAT გახდა მათ შორის "ხიდი", რადგან მას შეუძლია იმუშაოს OS-დან მიღებულ მონაცემებთან, რომელთაგან თითოეულს აქვს საკუთარი ფაილური სისტემა. რა არის და როგორ მუშაობს, პრაქტიკაში გასაგები გახდება.

დასკვნები

როგორც ზემოაღნიშნულიდან ირკვევა, თითოეული ოპერაციული სისტემა იყენებს გარკვეულ ფაილურ სისტემებს. ისინი განკუთვნილია შეკვეთილი მონაცემთა სტრუქტურების შესანახად ფიზიკურ მედიაზე. თუ მოულოდნელად, კომპიუტერის გამოყენებისას, გაგიჩნდათ შეკითხვა, თუ რა არის საბოლოო ფაილური სისტემა, მაშინ სავსებით შესაძლებელია, რომ როდესაც ცდილობდით გარკვეული ფაილის მედიაში კოპირებას, მიიღეთ შეტყობინება დაშვებული ზომის გადამეტების შესახებ. ამიტომ აუცილებელია ვიცოდეთ რომელ ფაილურ სისტემაში რომელი ფაილის ზომა ითვლება მისაღები, რათა ინფორმაციის გადაცემისას პრობლემები არ შეგექმნათ.

ფაილების მართვის სისტემები.

Ფაილების სისტემა ცხიმიანი. ფაილური სისტემები VFATდაFAT32.

1. ლოგიკური დისკის არეები

2. ჩატვირთვის სექტორი

3. ფაილების განაწილების ცხრილი

4. Root დირექტორია

5.VFAT ფაილური სისტემა

6.FAT32 ფაილური სისტემა

FAT ფაილურ სისტემაში ნებისმიერი ლოგიკური დისკის დისკის ადგილი იყოფა ორ ზონად:

სისტემის ფართობი და

მონაცემთა არე.

სისტემის არეალიიქმნება და ინიციალიზდება ფორმატირებისას და შემდგომში განახლდება ფაილის სტრუქტურის მანიპულირებისას.

სისტემის არეალი შედგება შემდეგი კომპონენტებისგან:

· ჩატვირთვის სექტორი, რომელიც შეიცავს ჩატვირთვის ჩანაწერს (ჩატვირთვის ჩანაწერი);

რეზერვირებული სექტორები (ისინი შეიძლება არ იყვნენ);

· ფაილების განაწილების ცხრილები (FAT, File Allocation Table);

ძირეული დირექტორია (ROOT).

ეს კომპონენტები ერთმანეთის მიყოლებით განლაგებულია დისკზე.

მონაცემთა არეალიშეიცავს დირექტორია ფაილებს, რომლებიც დაქვემდებარებულია root-ს.

სისტემის ზონისგან განსხვავებით, მონაცემთა ზონა ხელმისაწვდომია DOS მომხმარებლის ინტერფეისის საშუალებით.

ჩატვირთვის სექტორი

ჩატვირთვის ჩანაწერი ყალიბდება ფორმატირების დროს (მაგალითად, FORMAT) ჩატვირთვის სექტორის ფორმატი დამოკიდებულია OS-ზე და თუნდაც ვერსიაზე.

ჩატვირთვის სექტორი პირველია ლოგიკურ დისკზე. ის შეიცავს ჩატვირთვის ჩანაწერს.

ჩატვირთვის ჩანაწერი შედგება ორი ნაწილისგან:

დისკის პარამეტრის ბლოკი - ხშირად უწოდებენ. BIOS პარამეტრის ბლოკი (BPB) ან გაფართოებული BPB (ოპერაციული სისტემის ძველი ვერსიებისთვის)

OS bootstrap პროგრამები (სისტემის ჩამტვირთავი).

ჩატვირთვის ჩანაწერის პირველი ორი ბაიტი არის ბრძანება სისტემის ჩამტვირთავზე უპირობოდ გადახტომის შესახებ - JMP 3Eh. მესამე ბაიტში - NOP (90 სთ).

ამას მოჰყვება დისკის პარამეტრების ბლოკი, შემდეგ კი - OS loader.

დისკის პარამეტრის ბლოკი შეიცავს შემდეგ ინფორმაციას

სექტორის ზომა,

სექტორების რაოდენობა კლასტერში,

რეზერვირებული სექტორების რაოდენობა,

FAT ასლების რაოდენობა,

ROOT ელემენტების მაქსიმალური რაოდენობა,

სექტორების რაოდენობა FAT ცხრილში,

სექტორების რაოდენობა ტრეკზე,

მოცულობის ეტიკეტი

ფაილური სისტემის სახელი

და სხვა პარამეტრები (საშუალების ბაიტი-აღწერილობა ოფსეტურით 0Ah = F8H- ნებისმიერი სიმძლავრის რკინიგზა; F0-ფლოპი დისკი 1.44, 3.5'').

სხვადასხვა ოპერაციული სისტემის ჩატვირთვის ჩანაწერები, როგორც წესი, განსხვავდება პარამეტრის ბლოკის სტრუქტურაში. ზოგიერთს აქვს დამატებითი ველები.

ჩატვირთვის ჩანაწერს დეტალურად გავეცნობით ლაბორატორიულ სამუშაოებში.

ჩატვირთვის სექტორსა და FAT-ს შორის შეიძლება არსებობდეს რეზერვირებული სექტორები, რომლებიც სერვისს წარმოადგენს ფაილური სისტემისთვის ან არ გამოიყენება. რეზერვირებული სექტორების რაოდენობა განისაზღვრება BPB-ში. (ფორმატში - დაჯავშნილი სექტორები დასაწყისში -თუ = 1, მაშინ ეს არის MBR)

ჩატვირთვის ჩანაწერის სანახავად და რედაქტირებისთვის, ასევე შესანახად და აღდგენისთვის შეგიძლიათ გამოიყენოთ სასარგებლოდისკის რედაქტორი.

ფაილების განაწილების ცხრილი

თ ფაილის განაწილების ცხრილი (ფაილის განაწილების ცხრილი - FAT) არსებითად არის მონაცემთა არეალის რუკა.

მონაცემთა არეალი იყოფა ე.წ. კლასტერი არის მონაცემთა არეალის ერთი ან მეტი მიმდებარე სექტორი. მეორეს მხრივ, კლასტერი არის ფაილისთვის გამოყოფილი დისკის სივრცის უმცირესი მისამართის მქონე ერთეული. იმათ. ფაილი ან დირექტორია იკავებს კლასტერების მთელ რიცხვს. დისკზე ახალი ფაილის შესაქმნელად და ჩასაწერად, ოპერაციული სისტემა გამოყოფს მას რამდენიმე უფასო დისკის კლასტერს. ეს მტევანი არ უნდა გაჰყვეს ერთმანეთს. თითოეული ფაილისთვის ინახება ამ ფაილისთვის მოწოდებული ყველა კლასტერული ნომრის სია.

ფლოპი დისკებზე კლასტერი იკავებს ერთ ან ორ სექტორს, ხოლო მყარ დისკებზე, დანაყოფის ზომის მიხედვით:

16-127 მბ ტევადობის ტიხრებისთვის - 4 სექტორი კლასტერში (კლასტერის ზომა - 2 კბ);

128-255 მბ ტევადობის ტიხრებისთვის - 8 სექტორი კლასტერში (4 კბ);

256-511 მბ ტევადობის ტიხრებისთვის - 16 სექტორი კლასტერში (8 კბ);

512-1023 მბ ტევადობის ტიხრებისთვის - 32 სექტორი კლასტერში (16 კბ);

1024-2047 MB ​​ტევადობის დანაყოფებისთვის - 64 სექტორი კლასტერში (32 KB).

სექტორების გამოყენების ნაცვლად მონაცემთა არეალის კლასტერებად დაყოფა საშუალებას გაძლევთ:

· შეამცირეთ FAT ცხრილის ზომა;

ფაილის ფრაგმენტაციის შემცირება

ამცირებს ფაილების ჯაჭვების სიგრძეს Þ დააჩქარეთ ფაილების წვდომა.

თუმცა, კლასტერის ძალიან დიდი ზომა იწვევს მონაცემთა არეალის არაეფექტურ გამოყენებას, განსაკუთრებით მცირე ზომის ფაილების დიდი რაოდენობის შემთხვევაში (ყოველივე ამის შემდეგ, კლასტერის ნახევარი იკარგება საშუალოდ თითოეული ფაილისთვის).

თანამედროვე ფაილურ სისტემებში (FAT32, HPFS, NTFS) ეს პრობლემა მოგვარებულია კლასტერის ზომის შეზღუდვით (მაქსიმუმ 4 KB)

FAT ცხრილის თითოეული ელემენტი (12, 16 ან 32 ბიტი) შეესაბამება ერთ დისკის კლასტერს და ახასიათებს მის მდგომარეობას: თავისუფალი, დაკავებული ან ცუდი კლასტერი.

· თუ კლასტერი გამოყოფილია რომელიმე ფაილზე (ანუ დაკავებულია), მაშინ შესაბამისი FAT ელემენტი შეიცავს შემდეგი ფაილების კლასტერის ნომერს;

· ფაილის ბოლო კლასტერი აღინიშნება რიცხვით FF8h - FFFh (FFF8h - FFFFh) დიაპაზონში;

· თუ კლასტერი თავისუფალია, ის შეიცავს ნულოვან მნიშვნელობას 000h (0000h);

· კლასტერი, რომელიც გამოუსადეგარია (ჩავარდა) აღინიშნება ნომრით FF7h (FFF7h).

ამრიგად, FAT ცხრილში, კლასტერები, რომლებიც მიეკუთვნება იმავე ფაილს, დაკავშირებულია ჯაჭვებად.

ცხიმის პირველი ელემენტი აღწერს ჩატვირთვის სექტორის გარემოს. მისი პირველი ბაიტი იგივეა, რაც საცავის საშუალო აღწერის ბაიტი (ოფსეტური 0 აჰ- იხილეთ ცხრილი 4) და უდრის 0F0 სთ მოქნილი მაგნიტისთვის 3.5 დმ. დისკი ან 0F8 სთ მყარი დისკისთვის. შემდეგი 5 ბაიტი (7 ბაიტი) 12-ბიტიანი (16-ბიტიანი) ფორმატისთვის შეიცავს მნიშვნელობას 0FFh .

ფაილის განაწილების ცხრილი ინახება ლოგიკური დისკის ჩატვირთვის ჩანაწერისთანავე, მისი ზუსტი ადგილმდებარეობა აღწერილია ჩატვირთვის სექტორში სპეციალურ ველში.

ის ინახება ორ იდენტურ ეგზემპლარად, რომლებიც ერთმანეთს მიჰყვება. როდესაც ცხრილის პირველი ასლი განადგურებულია, მეორე გამოიყენება.

იმის გამო, რომ FAT ძალიან ხშირად გამოიყენება დისკზე წვდომისას, ის ჩვეულებრივ იტვირთება RAM-ში (I/O ბუფერში ან ქეშში) და რჩება იქ რაც შეიძლება დიდხანს.

FAT-ის მთავარი მინუსი არის ფაილების ნელი დამუშავება. ფაილის შექმნისას მოქმედებს წესი - არჩეულია პირველი უფასო კლასტერი. ეს იწვევს დისკის ფრაგმენტაციას და ფაილების რთულ ჯაჭვებს. აქედან გამომდინარეობს ფაილებთან მუშაობის შენელება.

FAT ცხრილის სანახავად და რედაქტირებისთვის შეგიძლიათ გამოიყენოთ სასარგებლოდისკის რედაქტორი.

Root დირექტორიაROOT

თავად ფაილის შესახებ დეტალური ინფორმაცია ინახება სხვა სტრუქტურაში, რომელსაც ეწოდება root დირექტორია. თითოეულ ლოგიკურ დისკს აქვს საკუთარი root დირექტორია (ROOT, ინგლისური - root).

Root დირექტორია აღწერს ფაილებს და სხვა დირექტორიას. დირექტორია ელემენტი არის ფაილის აღმწერი (descriptor).

თითოეული ფაილისა და დირექტორიას აღწერი შეიცავს მას

სახელი (8 ბაიტი)

გაფართოება (3)

შექმნის თარიღი ან ბოლო მოდიფიკაცია (2)

შექმნის ან ბოლო მოდიფიკაციის დრო (2)

ატრიბუტები (1) (არქივი, დირექტორიას ატრიბუტი, მოცულობის ატრიბუტი, სისტემა, დამალული, მხოლოდ წაკითხვადი)

ფაილის სიგრძე (ქალაქისთვის - 0) (4)

დაცული ველი, რომელიც არ არის გამოყენებული (10)

· ფაილს ან დირექტორიას მინიჭებული კლასტერების ჯაჭვის პირველი კლასტერის ნომერი; ამ ნომრის მიღების შემდეგ, ოპერაციული სისტემა, FAT ცხრილის მითითებით, ასევე გაარკვევს ფაილების კლასტერის ყველა სხვა ნომერს (2 ბაიტი).

ასე რომ, მომხმარებელი იწყებს ფაილს შესასრულებლად. ოპერაციული სისტემა ეძებს ფაილს სასურველი სახელით მიმდინარე დირექტორიაში არსებული ფაილის აღწერილობების დათვალიერებით. როდესაც საჭირო ელემენტი მოიძებნება მიმდინარე დირექტორიაში, ოპერაციული სისტემა კითხულობს ამ ფაილის პირველი კლასტერის ნომერს და შემდეგ განსაზღვრავს დარჩენილ კლასტერის ნომრებს FAT ცხრილიდან. ამ კლასტერების მონაცემები იკითხება RAM-ში, გაერთიანებულია ერთ უწყვეტ განყოფილებაში. ოპერაციული სისტემა გადასცემს კონტროლს ფაილზე და პროგრამა იწყებს მუშაობას.

ROOT დირექტორიას სანახავად და რედაქტირებისთვის, ასევე შეგიძლიათ გამოიყენოთ სასარგებლოდისკის რედაქტორი.

კომენტარი.ბოლო დროს დისკის მექანიზმების მოცულობამ მნიშვნელოვნად გადააჭარბა FAT-ისთვის დასაშვებ მაქსიმალურ ზომას - 8,4 გბ. ეს ლიმიტი აიხსნება სექტორის მისამართის მაქსიმალური შესაძლო მნიშვნელობებით, რისთვისაც მხოლოდ 3 ბაიტია გამოყოფილი. ამიტომ, უმეტეს შემთხვევაში, Windows სისტემურ გარემოში მუშაობისას, FAT არ გამოიყენება (გამოიყენება FAT32 ან NTFS).

Ფაილების სისტემაVFAT

VFAT (ვირტუალური FAT) ფაილური სისტემა პირველად გამოჩნდა Windows-ში სამუშაო ჯგუფებისთვის 3.11 და შექმნილი იყო ფაილების I/O-სთვის დაცულ რეჟიმში.

ეს ფაილური სისტემა გამოიყენება Windows 95-ში. ის ასევე მხარდაჭერილია Windows NT 4-ში.

VFAT არის Windows95-ის "მშობლიური" 32-ბიტიანი ფაილური სისტემა. მას აკონტროლებს VFAT.VXD დრაივერი.

მართავს სხვადასხვა ფაილურ სისტემას და დაინსტალირებული აპლიკაციების ფაილური სისტემის მენეჯერს -ინსტალირებული ფაილური სისტემების მენეჯერი.

VFAT იყენებს 32-ბიტიან კოდს ყველა ფაილის ოპერაციებისთვის და შეუძლია გამოიყენოს 32-ბიტიანი დაცული რეჟიმის დრაივერები.

მაგრამ, ფაილის განაწილების ცხრილის ჩანაწერები რჩება 12- ან 16-ბიტიან, ამიტომ მონაცემთა იგივე სტრუქტურა (FAT) გამოიყენება დისკზე. იმათ. ვ ცხრილის ფორმატიVFAT იგივეა, ისევე როგორც FAT ფორმატში.

VFAT "8.3" სახელებთან ერთად მხარს უჭერს ფაილების გრძელ სახელებს. (VFAT ხშირად ამბობენ, რომ არის FAT გრძელი სახელების მხარდაჭერით).

არსებობს გრძელი სახელების მოკლედ გადაქცევის სპეციალური მექანიზმი და პირიქით.

გახსოვთ, რომ DOS-ის სახელის სიგრძე ექვემდებარება „8.3“ წესს, ანუ სახელის სიგრძე არ უნდა აღემატებოდეს 8 სიმბოლოს.ა გაფართოებები - 3. ფაილური სისტემის მთავარი მახასიათებელი Windows 95 მომხმარებლისთვის არის ის ფაილის სახელის მაქსიმალური სიგრძე in ფანჯრები 95 შეიძლება იყოს 256 სიმბოლომდე, სივრცეების ჩათვლით. ფაილის სახელის სიგრძე შემოიფარგლება ფაილისკენ მიმავალი ბილიკით: ბილიკის მთლიანი სიგრძე და ფაილის სახელი არ უნდა აღემატებოდეს 260 სიმბოლოს.

ფაილის შექმნისას მასშიWindows95 მას ერთდროულად ორ სახელს ანიჭებს -გრძელი და მოკლე (8.3). მოკლე სახელწოდება წარმოიქმნება გრძელიდან, შუალედური და სიმბოლოების ამოღებით / : * ? ""< >ᲛᲔ. რვა-სიმბოლოიანი ფაილის სახელისთვის გამოიყენება გრძელი სახელის პირველი ექვსი დარჩენილი სიმბოლო, "~" (ტილდი) სიმბოლო და სერიული ნომერი. სამი ასოანი გაფართოება იყენებს პირველ სამ სიმბოლოს ბოლო წერტილის შემდეგ გრძელი ფაილის სახელით.

მაგალითად, ფაილების მოკლე სახელები (შემდეგი თანმიმდევრობით)

სტატია Windows 95.DOS-ის შესახებ

შემდეგი სტატია Windows 95.DOS-ის შესახებ

სტატია Windows NT.DOS-ის შესახებ

Microsoft Office.HTML

Microsoft Windows. HTML

ასე გამოიყურება

ამავდროულად, ROOT სტრუქტურაში, ფაილის ან დირექტორიაში ჩვეულ დესკრიპტორთან (ე.წ. მეტსახელად) იქმნება სპეციალური დესკრიპტორები, რომლებშიც ინახება გრძელი სახელი. სპეციალური აღწერებისთვის დაყენებულია მხოლოდ წაკითხული (მხოლოდ წაკითხვა), სისტემა (სისტემა), დამალული (დამალული), მოცულობის ლეიბლი (მოცულობის ეტიკეტი) ატრიბუტები. სპეციალური აღწერების რაოდენობა დამოკიდებულია სახელის სიგრძეზე.

სპეციალური აღმწერი ეხება კლასტერულ ნომერს O. პირველი კლასტერის რეალური რიცხვი, რომელიც გამოყოფილია ფაილზე ან დირექტორიაში, არის სტანდარტული (ასევე) აღწერით, რომელიც მოყვება სპეციალურებს.

VFAT მოცულობებისთვის, თქვენ არ შეგიძლიათ გამოიყენოთ სხვა კომუნალური საშუალებები, გარდა კომუნალური საშუალებებისა, რომლებსაც „ესმით“ VFAT

VFAT-ის მთავარი მინუსი არის დიდი დანაკარგები კლასტერისთვის დიდი ლოგიკური დისკის ზომებით და შეზღუდვები თავად ლოგიკური დისკის ზომაზე.

Ფაილების სისტემაFAT32

ეს არის FAT ცხრილის გამოყენების იდეის ახალი განხორციელება.

FAT 32 არის სრულიად დამოუკიდებელი 32-ბიტიანი ფაილური სისტემა.

პირველად გამოიყენეს Windows OSR2 (OEM Service Release 2).

FAT32 ამჟამად გამოიყენება Windows 98-სა და Windows ME-ში.

იგი შეიცავს უამრავ გაუმჯობესებას და დამატებებს წინა FAT-ის დანერგვასთან შედარებით.

1. დისკის სივრცის ბევრად უფრო ეფექტური გამოყენება იმის გამო, რომ ის იყენებს უფრო მცირე კლასტერებს (4 KB) - სავარაუდოა, რომ დაზოგავს 15% -მდე.

2. აქვს გაფართოებული ჩატვირთვის ჩანაწერი, რომელიც საშუალებას გაძლევთ შექმნათ მონაცემთა კრიტიკული სტრუქტურების ასლები Þ ზრდის დისკის წინააღმდეგობას დისკის სტრუქტურების დარღვევების მიმართ

3. შეგიძლიათ გამოიყენოთ FAT სარეზერვო ასლის ნაცვლად სტანდარტული.

4. შეუძლია root დირექტორიას გადატანა, სხვა სიტყვებით რომ ვთქვათ, root დირექტორია შეიძლება იყოს თვითნებურ ადგილას Þ ხსნის root დირექტორიას ზომის ლიმიტს (512 ელემენტი, ვინაიდან ROOT უნდა დაიკავოს ერთი კლასტერი).

5. გაუმჯობესებული root დირექტორია სტრუქტურა

დამატებულია დამატებითი ველები:

შექმნის დრო (2)

შექმნის თარიღი (2)

ბოლო წვდომის თარიღი (2)

საწყისი კლასტერის რიცხვის მაღალი სიტყვა

საწყისი კლასტერის ნომრის დაბალი სიტყვა

· შემოწმების ჯამი

ჯერ კიდევ არსებობს მრავალი აღმწერი ფაილის გრძელი სახელისთვის.

FAT32 ტომებისთვის, თქვენ არ შეგიძლიათ გამოიყენოთ რაიმე სხვა კომუნალური პროგრამა, გარდა კომუნალური პროგრამებისა, რომლებსაც „ესმით“ FAT32