1. Struktur sektor FInfo struct fat_boot_fsinfo:
   • __u32 tanda tangan1– tanda tangan 0x41615252;
   • __u32 tanda tangan2– tanda tangan 0x61417272;
   • __u32 cluster_gratis– jumlah cluster gratis. Jika field berisi -1, pencarian cluster gratis harus dimulai dengan cluster nomor 2.
2. Struktur elemen direktori nama pendek struct msdos_dir_entry:
   • __s8 nama, ekst– nama file dan ekstensi;
   • __u8 attr– atribut berkas;
   • __u8 waktu_ms– bidang ini menentukan waktu pembuatan file dalam ms (hanya FAT32 yang digunakan);
   • __u16 waktu– waktu pembuatan file (hanya FAT32 yang digunakan);
   • __u16 tanggal– tanggal pembuatan file (hanya FAT32 yang digunakan);
   • __u16 tanggal– tanggal akses terakhir ke file (hanya FAT32 yang digunakan);
   • __u16 mulai– 16 bit paling signifikan dari nomor cluster pertama file (hanya FAT32 yang digunakan);
   • __u16 waktu,tanggal,mulai– waktu dan tanggal pembuatan file, nomor cluster pertama file;
   • __u32 ukuran– ukuran file (dalam byte).
3. Struktur elemen direktori nama panjang:
   • __u8 identitas– nomor elemen;
   • __u8 nama0_4– karakter 1 – 5 dari nama;
   • __u8 attr– atribut berkas;
   • __u8 alias_checksum– checksum nama pendek;
   • __u8 nama5_10– simbol 6 – 11 dari nama;
   • __u8 nama11_12– simbol 12 – 13 dari nama.

Mari kita terus mempertimbangkan implementasi perangkat lunak dari algoritme dan menentukan nama partisi tempat sistem file FAT16 dibuat:

#ifndef FAT16_PART_NAME

#definisikan FAT16_PART_NAME "/dev/hda1"

#endif

Struktur global:

struct fat_boot_sector fbs; // struktur sektor boot

struct msdos_dir_entry gigi; // struktur elemen direktori

Variabel global:

U16 *gemuk16; // salin tabel FAT16 di sini

ukuran_sektor U16; // ukuran sektor (dari FAT16)

entri_dir_U16; // jumlah deskriptor 32-byte

// di direktori root (0 untuk FAT32)

sektor U16; // jumlah total sektor dalam partisi

U32 fat16_size; // ukuran FAT16

ukuran_root U32; // ukuran direktori root

U16 byte_per_cluster; // ukuran cluster dalam byte

U16 cluster_berikutnya; // cluster berikutnya dalam rantai

ke dalam lemak;

Mari kita mulai dengan fungsi utama:

ke dalam utama()

Nomor masuk;

Kita tentukan nama lengkap file yang isinya ingin kita baca. Izinkan saya mengingatkan Anda bahwa kami hanya bekerja dengan nama file pendek. Prosedur untuk bekerja dengan nama panjang tidak dibahas dalam artikel ini.

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

Buka file perangkat:

Keras = terbuka(FAT16_PART_NAME, O_RDONLY);

Jika (keras< 0) {

Kesalahan(FAT16_PART_NAME);

Keluar(-1);

Kami membaca 10 cluster pertama file. Membaca dilakukan oleh fungsi fat16_read_file(). Parameter fungsinya adalah nama file lengkap dan jumlah cluster yang akan dibaca. Fungsi ini mengembalikan jumlah cluster yang dibaca atau -1 jika terjadi kesalahan saat membaca:

Angka = fat16_read_file(jalur_lengkap, 10);

Jika (angka< 0) perror("fat16_read_file");

Else printf("Baca %d cluster", num);

Tutup file perangkat dan keluar:

Tutup(keras);

Kembali 0;

Fungsi untuk membaca cluster file memiliki bentuk sebagai berikut:

int fat16_read_file(__u8 *jalur_lengkap, int angka)

Struktur split_name sn; // struktur untuk menyimpan komponen file

U8 tmp_name_buff; // buffer untuk penyimpanan sementara komponen jalur file lengkap

int statis i = 1;

Ke dalam n;

U8 *tmp_buff;

U16 start_cluster, next_cluster;

Kami mencantumkan parameter fungsi saat mempertimbangkan fungsi utama.

Operasi persiapan - setel ulang buffer tmp_name_buff dan struktur struct split_name sn:

Karakter pertama dalam nama jalur absolut suatu file harus berupa garis miring (/). Mari kita periksa ini:

Baca sektor boot dari partisi:

Jika(baca_fbs()< 0) return -1;

Sektor boot baca sekarang terletak di struktur global struct fat_boot_sector fbs. Mari kita salin ukuran sektor, jumlah entri di direktori root dan jumlah total sektor pada partisi dari struktur ini:

Mari kita tentukan ukuran cluster dalam byte:

Byte_per_cluster = fbs.cluster_size * 512

Mari kita tampilkan informasi yang terletak di sektor boot:

Printf("ID sistem - %s ", fbs.system_id);

Printf("Ukuran sektor - %d", ukuran_sektor);

Printf("Ukuran klaster - %d", fbs.cluster_size);

Printf("Dipesan - %d", fbs.dipesan);

Printf("Nomor FAT - %d",fbs.fats);

Printf("Entri direktori - %d", dir_entries);

Printf("Sektor - %d", sektor);

Printf("Media - 0x%X", fbs.media);

Printf("Panjang FAT16 - %u", fbs.fat_length);

Printf("Jumlah sekte - %u", fbs.total_sect);

Printf("Byte per cluster - %d", byte_per_cluster);

Kami menghitung ukuran FAT16 dalam byte dan membacanya:

Fat16_size = fbs.fat_length * 512;

Jika(baca_fat16()< 0) return -1;

Membaca direktori root:

Jika(baca_root_dentry()< 0) return -1;

Pointer dir_entry sekarang diposisikan di lokasi memori yang berisi entri direktori root. Ukuran area memori ini sama dengan ukuran direktori root (root_size).

Mari simpan (untuk kontrol) isi direktori root dalam file terpisah:

#ifdef DEBUG

Tutup(gemuk);

#endif

Kami menghitung awal area data:

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

Dengan memiliki semua entri di direktori root, kita dapat mengakses konten file test.txt. Untuk tujuan ini, kami mengatur sebuah siklus. Di badan loop, kami akan mengurai nama lengkap file, menyorot elemennya - subdirektori (kami memiliki dua di antaranya, Folder1 dan Folder2) dan nama file yang kami cari (test.txt).

Sementara(1) (

Memset(tmp_name_buff, 0, SHORT_NAME);

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

Untuk(n = 0 ; n< SHORT_NAME; n++, i++) {

Jika((tmp_name_buff[n] == "/") || (tmp_name_buff[n] == "?")) (

saya++;

Merusak;

Tmp_name_buff[n] = "?";

Kami mengisi struktur struct split_name sn dengan informasi yang sesuai. Pengisian dilakukan oleh fungsi split_name, yang memeriksa kesesuaian nama file dengan format "8.3":

< 0) {

Printf("Nama tidak sah");

Kembali -1;

Untuk setiap elemen nama file lengkap, kami mendefinisikan cluster awal. Untuk melakukan ini, kita mencari di elemen direktori (mulai dari root) untuk entri yang sesuai dengan elemen nama lengkap, dan membaca entri ini. Prosedur pencarian dilakukan oleh fungsi get_dentry():

Jika(get_dentry(&sn)< 0) {

Printf("Tidak ada file seperti itu!");

Kembali -1;

Memeriksa atribut file. Jika ini adalah sebuah direktori, baca isinya dan lanjutkan perulangan:

Jika(dentry.attr & 0x10) (

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

Melanjutkan;

Jika ini adalah file, kita membaca num cluster pertama. Untuk kontrol, kami akan menyimpan informasi yang dibaca dalam file terpisah:

Jika(dentry.attr & 0x20) (

Start_cluster = dentry.start;

Tmp_buff = (__u8 *)malloc(byte_per_cluster); // isi cluster akan terbaca disini

N = terbuka("kluster", O_CREAT|O_RDWR, 0600); // simpan informasi yang telah dibaca dalam file ini

Jika(n< 0) {

Kesalahan("buka");

Kembali -1;

Untuk membaca cluster file, kami mengatur loop:

Untuk(saya = 0; saya< num; i++) {

Kami membaca konten cluster ke dalam buffer tmp_buff dan menyimpannya dalam file terpisah:

< 0) return -1;

< 0) {

Kesalahan("tulis");

Tutup(n);

Kembali -1;

Kita membaca dari FAT16 nomor cluster berikutnya yang ditempati oleh file ini. Jika ini adalah cluster terakhir, kita interupsi loop dan kembali ke fungsi utama:

#ifdef DEBUG

Printf("OK. Sudah Dibaca ");

Printf("file cluster berikutnya - 0x%X .. ", next_cluster);

#endif

Jika(kluster_berikutnya == EOF_FAT16) (

#ifdef DEBUG

Printf("klaster terakhir.");

#endif

Gratis(tmp_buff);

Tutup(n);

Kembalikan ++i;

#ifdef DEBUG

Printf("berhenti membaca");

#endif

Kembalikan saya;

Membaca sektor boot FAT16 dilakukan oleh fungsi read_fbs(). Hasilnya ditempatkan di struktur fbs global:

ke dalam baca_fbs()

Jika(baca(keras,(__u8 *)&fbs, sizeof(fbs))< 0) return -1;

Kembali 0;

Membaca tabel alokasi file sistem file FAT16 dilakukan oleh fungsi read_fat16():

ke dalam baca_fat16()

U64 mencari = (__u64)(fbs.reserved) * 512; // offset ke FAT16 dari awal partisi

Fat16 = (batal *)malloc(fat16_size);

If(pread64(keras, (__u8 *)fat16, fat16_size, cari)< 0) return -1;

Kembali 0;

Fungsi read_root_dentry() membaca direktori root:

ke dalam read_root_dentry()

U64 mencari = (__u64)fbs.reserved * 512 + fat16_size * fbs.fats; // offset ke direktori root dari awal partisi

Root_size = 32 * dir_entries; // menghitung ukuran direktori root

Dir_entry = (__u8 *)malloc(ukuran_root);

Jika(!dir_entry) mengembalikan -1;

Memset(dir_entry, 0, root_size);

If(pread64(keras, dir_entry, root_size, cari)< 0) return -1;

Kembali 0;

Membaca cluster milik suatu file dilakukan oleh fungsi read_cluster(). Parameter masukan dari fungsi ini adalah nomor cluster cluster_num dan penunjuk ke buffer __u8 *tmp_buff, tempat hasil pembacaan harus ditempatkan. Offset ke cluster pada partisi dihitung menggunakan rumus (lihat):

CARI = DATA_START + (CLUSTER_NUM - 2) * BYTE_PER_CLUSTER,

• MENCARI– offset ke cluster pada partisi
• DATA_START– awal area data
• CLUSTER_NUM– nomor seri cluster
• BYTE_PER_CLUSTER– ukuran cluster dalam byte

int read_cluster(__u16 cluster_num, __u8 *tmp_buff)

U64 mencari = (__u64)(byte_per_cluster) * (cluster_num - 2) + data_start; // menghitung offset ke cluster

< 0) return -1;

Kembali 0;

Fungsi read_directory membaca entri dari direktori (bukan direktori root) dan menempatkan hasilnya di lokasi memori tempat penunjuk dir_entry diatur:

int read_directory(__u16 start_cluster)

Ke dalam saya = 1;

U16 cluster_berikutnya;

Untuk(; ;i++) (

Kami mengalokasikan memori untuk menyimpan isi direktori, membaca isi cluster awal dan mendapatkan nilai cluster berikutnya dari tabel FAT16:

Jika(!dir_entry) mengembalikan -1;

< 0) return -1;

Cluster_berikutnya = fat16;

Mari simpan isi direktori dalam file terpisah (untuk kontrol):

#ifdef DEBUG

Printf("Kluster berikutnya - 0x%X", next_cluster);

Gemuk = buka("dir16", O_CREAT|O_WRONLY, 0600);

Tulis(gemuk, dir_entry, root_size);

Tutup(gemuk);

#endif

Jika cluster terakhir tercapai, kita keluar dari loop, jika tidak kita lanjutkan membaca direktori, menambah ukuran buffer dir_entry sebanyak satu cluster lagi:

Jika(next_cluster & EOF_FAT16) rusak;

Mulai_cluster = cluster_berikutnya;

Kembali 0;

Fungsi get_dentry() mencari isi direktori untuk elemen yang sesuai dengan file yang sedang dicari. Parameter masukan dari fungsi ini adalah penunjuk ke struktur struct split_name *sn yang berisi elemen nama file pendek:

Ke dalam saya = 0;

Buffer global dir_entry berisi array entri direktori di mana kita akan mencari entri file (atau direktori). Untuk mencari, kami mengatur sebuah siklus. Di badan loop, kami menyalin elemen direktori ke dalam struktur dentry global dan membandingkan nilai bidang name dan ext dari struktur ini dengan bidang yang sesuai dari struktur struct split_name *sn. Kecocokan bidang-bidang ini berarti kita telah menemukan entri untuk file yang kita cari dalam array elemen direktori:

untuk(; ; saya++) (

If(!(memcmp(dentry.nama, sn->nama, sn->nama_len)) &&

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

Merusak;

If(!dentry.name) kembalikan -1;

#ifdef DEBUG

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

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

Printf("ukuran file - %u", dentry.ukuran);

Printf("atribut berkas - 0x%X", dentry.attr);

#endif

Kembali 0;

Semua kode di atas terletak di direktori FAT16, file fat16.c. Untuk mendapatkan modul yang dapat dieksekusi, buat Makefile dengan konten berikut:

INCDIR = /usr/src/linux/include

PHONY = bersih

Fat16: fat16.o terbelah.o

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

%.o: %.c

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

Membersihkan:

Rm -f *.o

Rm -f ./fat16

Implementasi perangkat lunak dari algoritma untuk membaca file dari partisi logis dengan sistem file FAT12

Secara umum algoritma membaca file dari partisi FAT12 identik dengan algoritma membaca file dari partisi FAT16. Perbedaannya terletak pada tata cara membaca elemen dari tabel FAT12. Kami menganggap tabel FAT16 sebagai array sederhana dari elemen 16-bit. Untuk membaca elemen tabel FAT12, algoritma berikut diusulkan:

• kalikan nomor elemen dengan 1,5;
• mengekstrak kata 16-bit dari FAT menggunakan hasil operasi sebelumnya sebagai offset;
• jika nomor elemen genap, lakukan operasi AND pada kata yang dibaca dan mask 0x0FFF. Jika angkanya ganjil, geser kata yang dibaca dari tabel sebanyak 4 bit ke arah angka yang lebih rendah.

Berdasarkan algoritma ini, kami mengimplementasikan fungsi membaca elemen dari tabel FAT12:

int get_cluster(__u16 cluster_num)

U16 mencari;

kluster U16;

Kami menghitung offset dalam tabel FAT12 dan membaca kata 16-bit dari tabel:

Cari = (cluster_num * 3) / 2;

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

Jika bilangan awal cluster adalah bilangan genap, kita geser nilai yang dibaca dari tabel sebanyak 4 bit ke arah bit orde rendah, jika ganjil kita jumlahkan dengan 0x0FFF:

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

Cluster lain &= 0x0FFF;

Fragmen ini juga dapat diimplementasikan di assembler:

" xorw %%ax, %%ax "

" omong-omong $0, %%cx "

"jnc 1f"

" shw $4, %%dx "

"jmp 2f"

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

"2: pindahkan %%dx, %%ax"

:"=a" (berikutnya)

:"d" (kluster), "c" (angka_kluster));

Kami mengembalikan hasilnya:

kelompok kembali;

Mari kita lihat lebih dekat algoritma itu sendiri. Mari kita asumsikan bahwa sebuah file telah dibuat pada partisi FAT12 yang menempati cluster ke-9 dan ke-10. Setiap elemen FAT12 membutuhkan 12 bit. Karena dari tabel kita membaca elemen 16-bit, maka offset ke elemen ke-9 akan sama dengan 13 byte (9 * 1,5 = 13, sisanya dibuang), sedangkan 4 bit terbawah akan menjadi milik elemen FAT ke-8. Mereka perlu dibuang, dan untuk melakukan ini, cukup dengan menggeser elemen baca sebanyak 4 bit ke arah digit yang lebih rendah, yang disediakan oleh algoritma. Offset ke elemen ke-10 akan menjadi 15 byte, dan 4 bit paling signifikan akan menjadi milik elemen FAT ke-11. Untuk membuangnya, perlu dilakukan operasi AND pada elemen ke-10 dan mask 0x0FFF, yang juga sesuai dengan algoritma di atas.

Teks sumber modul untuk membaca file dari partisi FAT12 terletak di direktori FAT12, file fat12.c.

Implementasi perangkat lunak dari algoritma untuk membaca file dari partisi logis dengan sistem file FAT32

Algoritma untuk membaca file dari partisi dengan sistem file FAT32 praktis tidak berbeda dengan algoritma untuk FAT16, hanya saja di FAT32 direktori root dapat ditempatkan di mana saja pada partisi dan memiliki ukuran yang berubah-ubah. Oleh karena itu, agar lebih menarik, mari kita perumit tugasnya - misalkan kita hanya mengetahui nomor partisi dengan sistem file FAT32. Untuk membaca informasi dari partisi ini, Anda harus terlebih dahulu menentukan koordinatnya - offset partisi dari awal disk. Dan untuk ini, Anda perlu memiliki gambaran tentang struktur logis hard drive.

Struktur logis dari hard drive

Mari kita pertimbangkan struktur logis dari hard drive yang sesuai dengan standar Microsoft - “partisi utama – partisi perluasan – partisi non-DOS”.

Ruang hard disk dapat diatur menjadi satu atau lebih partisi, dan partisi dapat berisi satu atau lebih drive logis.

Master Boot Record (MBR) terletak pada hard drive di alamat fisik 0-0-1. Struktur MBR berisi elemen-elemen berikut:

• bootstrap non-sistem (NSB);
• tabel yang menjelaskan partisi disk (tabel partisi, PT). Terletak di MBR pada offset 0x1BE dan menempati 64 byte;
• tanda tangan MBR. Dua byte terakhir MBR harus berisi angka 0xAA55.

Tabel partisi menjelaskan penempatan dan karakteristik partisi yang tersedia pada harddisk. Partisi disk dapat terdiri dari dua jenis - primer (primer, utama) dan diperluas (diperpanjang). Jumlah maksimum partisi primer adalah empat. Kehadiran setidaknya satu partisi utama pada disk adalah wajib. Partisi yang diperluas dapat dibagi menjadi beberapa subpartisi - drive logis. Struktur MBR yang disederhanakan disajikan pada Tabel 7. Tabel partisi terletak di akhir MBR; 16 byte dialokasikan untuk mendeskripsikan partisi dalam tabel.

Tabel 7. Struktur MBR

Bias Ukuran, byte 0 446 0x1BE 16 0x1CE 16 0x1DE 16 0x1EE 16 0x1FE 2

Struktur entri tabel partisi ditunjukkan pada Tabel 8.

Tabel 8. Struktur entri tabel partisi

Byte pertama dalam elemen bagian adalah tanda aktivitas bagian (0 – tidak aktif, 0x80 – aktif). Ini digunakan untuk menentukan apakah partisi tersebut merupakan boot sistem dan apakah ada kebutuhan untuk memuat sistem operasi dari partisi tersebut saat komputer dinyalakan. Hanya satu bagian yang dapat aktif. Bendera aktivitas partisi diikuti dengan koordinat awal partisi - tiga byte yang menunjukkan nomor kepala, nomor sektor, dan nomor silinder. Nomor silinder dan sektor ditentukan dalam format interupsi Int 0x13, mis. bit 0-5 berisi nomor sektor, bit 6-7 – dua bit paling signifikan dari nomor silinder 10-bit, bit 8-15 – delapan bit paling signifikan dari nomor silinder. Ini diikuti dengan kode ID Sistem, yang menunjukkan bahwa bagian ini milik sistem operasi tertentu. Pengidentifikasi menempati satu byte. Di belakang pengidentifikasi sistem terdapat koordinat akhir bagian - tiga byte yang masing-masing berisi nomor kepala, sektor, dan silinder. Empat byte berikutnya adalah jumlah sektor sebelum partisi, dan empat byte terakhir adalah ukuran partisi dalam sektor.

Dengan demikian, elemen tabel partisi dapat dijelaskan menggunakan struktur berikut:

struct pt_struct (

U8 dapat di-boot; // bendera aktivitas bagian

U8 bagian_mulai; //koordinat awal bagian

bagian_tipe U8; // pengenal sistem

U8 bagian_akhir; //koordinat akhir bagian

U32 sekte_sebelum; // jumlah sektor sebelum partisi

U32 sekte_total; // ukuran partisi dalam sektor (jumlah sektor dalam partisi)

Elemen partisi primer menunjuk langsung ke sektor boot dari disk logis (selalu hanya ada satu disk logis di partisi primer), dan elemen partisi diperluas menunjuk langsung ke daftar disk logis yang terdiri dari struktur yang disebut MBR sekunder (Sekunder MBR, SMBR).

Setiap disk dari partisi yang diperluas memiliki blok SMBR sendiri. SMBR memiliki struktur yang mirip dengan MBR, tetapi tidak memiliki catatan boot (diisi dengan nol), dan hanya dua dari empat bidang deskriptor partisi yang digunakan. Elemen pertama dari bagian ini menunjuk ke disk logis, elemen kedua menunjuk ke struktur SMBR berikutnya dalam daftar. SMBR terakhir dari daftar berisi kode partisi nol pada elemen kedua.

Mari kembali ke modul untuk membaca file dari partisi FAT32.

File tajuk:

#termasuk

#termasuk

#termasuk

#termasuk

#termasuk

Tanda tangan MBR:

#tentukan TANDA TANGAN 0xAA55

File perangkat tempat informasi partisi akan dibaca:

#tentukan PERANGKAT "/dev/hda"

Ukuran elemen tabel partisi (16 byte):

#tentukan PT_SIZE 0x10

Array struktur berikut memetakan kode tipe suatu bagian ke representasi simbolisnya:

tipe struct (

tipe_bagian U8;

U8 *nama_bagian;

struct systypes i386_sys_types = (

(0x00, "Kosong"),

(0x01, "FAT12"),

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

(0x05, "Diperpanjang"),

(0x06, "FAT16"),

(0x0b, "Win95 FAT32"),

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

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

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

(0x82, "pertukaran Linux"),

(0x83, "Linux"),

(0x85, "Linux diperpanjang"),

(0x07, "HPFS/NTFS")

Mari kita tentukan jumlah elemen dalam array i386_sys_types menggunakan makro PART_NUM:

#tentukan PART_NUM (sizeof(i386_sys_types) / sizeof(i386_sys_types))

Mari kita tetapkan batas jumlah drive logis:

#tentukan MAX_PART 20

Array struktur berikut akan berisi informasi tentang drive logis pada perangkat (hard drive):

struct pt_struct (

U8 dapat di-boot;

U8 bagian_mulai;

bagian_tipe U8;

U8 bagian_akhir;

U32 sekte_sebelum;

U32 sekte_total;

) pt_t;

ke dalam keras; // deskriptor file perangkat

U8 mbr; // hitung MBR di sini

Nomor partisi tempat sistem file FAT32 dibuat:

#tentukan FAT32_PART_NUM 5

Struktur sektor boot, sektor FInfo, dan entri direktori (didefinisikan dalam file ):

struct fat_boot_sector fbs;

struct fat_boot_fsinfo fsinfo;

struct msdos_dir_entry gigi;

U32 *fat32 = BATAL; // salin tabel FAT32 di sini

ukuran_sektor U16; // ukuran sektor (dari FAT32)

entri_dir_U16; // 0 untuk FAT32

sektor U16; // jumlah sektor pada partisi

U32 fat32_size; // ukuran FAT32

U32 data_mulai; // awal dari area data

U16 byte_per_cluster; // berapa banyak byte yang ada di cluster (ukuran cluster dalam byte)

U32 cluster_berikutnya; // cluster berikutnya dalam rantai

U32 root_cluster; // ROOT cluster - cluster awal dari direktori root

U8 *dir_entry = BATAL; // penunjuk ke entri direktori

U64 start_seek = 0; // memulai offset ke partisi (dalam byte)

Fungsi utama:

ke dalam utama()

Int angka = 0;

ke dalam cluster_num = 5; // berapa banyak cluster yang akan dibaca dari file

U8 *full_path = "/Folder1/Folder2/readme"; // file untuk dibaca

Kami membuka perangkat, mendapatkan informasi tentang tabel partisi pada perangkat dan menampilkan informasi tentang partisi:

Keras = terbuka(DEV_NAME, O_RDONLY);

Jika (keras< 0) {

Kesalahan(DEV_NAME);

Keluar(-1);

Jika(get_pt_info(keras)< 0) {

Kesalahan("get_pt_info");

Keluar(-1);

Tampilkan_pt_info();

Kami menghitung offset awal ke partisi:

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

Kami membaca cluster milik file:

Nomor = fat32_read_file(jalur_lengkap, nomor_klaster);

Jika (angka< 0) perror("fat32_read_file");

Lain printf("Baca %d cluster\n",angka);

Tutup(keras);

Kembali 0;

Informasi tentang tabel partisi dibaca oleh fungsi get_pt_info():

int get_pt_info(int keras)

Ke dalam saya = 0;

U64 mencari;

Kami membaca tabel partisi dari MBR dan memeriksa tanda tangannya:

Read_main_ptable(keras);

Jika(tanda_tanda()< 0) {

Printf("Tanda tangan tidak sah!\n");

Kembali -1;

Kami mencari pengidentifikasi bagian yang diperluas. Jika ada, kami menghitung offset ke partisi extended dan membaca informasi tentang drive logis:

untuk(; saya< 4; i++) {

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

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

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

Carilah = (__u64)pt_t[i].sect_before * 512;

Read_ext_ptable(keras, cari);

Merusak;

Kembali 0;

Fungsi membaca tabel partisi read_main_ptable():

batal read_main_ptable(int keras)

Jika(baca(keras, mbr, 512)< 0) {

Kesalahan("baca");

Tutup(keras);

Keluar(-1);

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

Memcpy((batal *)pt_t, mbr + 0x1BE, (PT_SIZE * 4));

Kembali;

Fungsi pemeriksaan tanda tangan check_sign():

ke dalam tanda_tanda()

Tanda U16 = 0;

Memcpy((batal *)&tanda tangan, (batal *)(mbr + 0x1FE), 2);

#ifdef DEBUG

Printf("Tanda tangan - 0x%X\n", tanda tangan);

#endif

Jika(tanda tangan!= TANDA TANGAN) kembalikan -1;

Kembali 0;

Fungsi Baca Tabel Partisi yang Diperluas:

void read_ext_ptable(int keras, __u64 mencari)

Int angka = 4; // mulai dari posisi ini, array struktur pt_t akan diisi dengan informasi tentang drive logis

U8 seseorang;

Masukan data:

• keras– deskriptor file perangkat;
• mencari– offset ke partisi extended dari awal disk (dalam byte).

Untuk memperoleh informasi tentang drive logis, kami mengatur loop:

Untuk(;;angka++) (

Kami membaca SMBR, terletak di offset pencarian dari awal disk:

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

Pread64(keras, smbr, 512, cari);

Kita mengisi dua elemen tabel pt_t, dimulai dari posisi nomor. Elemen pertama akan menunjuk ke drive logis, dan elemen kedua akan menunjuk ke struktur SMBR berikut:

Memset((batal *)&pt_t, 0, PT_SIZE * 2);

Memcpy((batal *)&pt_t, smbr + 0x1BE, PT_SIZE * 2);

Kami membuat perubahan pada bidang "Nomor sektor awal" - penghitungan dilakukan dari awal disk:

Pt_t.sect_before += (cari / 512);

Jika kode tipe partisi adalah nol, maka tidak ada lagi pengandar logis:

If(!(pt_t.type_part)) rusak;

Kami menghitung offset ke SMBR berikut:

Carilah = ((__u64)(pt_t.sect_before + pt_t.sect_total)) * 512;

Kembali;

Fungsi show_pt_info() menampilkan informasi tentang drive logis yang ditemukan pada perangkat:

batal tampilkan_pt_info()

Ke dalam saya = 0, n;

#ifdef DEBUG

Printf("Jumlah partisi pada disk adalah %d\n", PART_NUM);

#endif

Untuk(; saya< MAX_PART; i++) {

Jika(!pt_t[i].type_part) rusak;

Printf("\nJenis partisi %d - ",i);

Untuk(n = 0; n< PART_NUM; n++) {

Jika(pt_t[i].type_part == i386_sys_types[n].part_type) (

Printf("%s\n", i386_sys_types[n].nama_bagian);

Merusak;

If(n == PART_NUM) printf("tipe tidak diketahui\n");

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

Printf("Sektor dalam partisi %d - %d\n", i, pt_t[i].sect_total);

Printf("Sektor sebelum partisi %d - %d\n\n", i, pt_t[i].sect_before);

Kembali;

Membaca cluster file dari partisi FAT32 dilakukan oleh fungsi fat32_read_file(). Fungsi ini memiliki banyak kesamaan dengan fungsi fat16_read_file(), jadi silakan lihat poin 6 untuk komentar lebih detail:

int fat32_read_file(__u8 *jalur_lengkap, int angka)

Struktur split_name sn;

U8 tmp_name_buff;

Ke dalam saya = 1, n;

U32 start_cluster, next_cluster;

U8 *tmp_buff;

Operasi persiapan - kami membersihkan buffer, menyusun dan memeriksa garis miring pertama:

Memset(tmp_name_buff, 0, SHORT_NAME);

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

Jika(full_path != "/") kembali -1;

Membaca sektor boot:

Jika(baca_fbs()< 0) return -1;

Memcpy((void *)§or_size, (void *)fbs.sector_size, 2);

Memcpy((batal *)&dir_entries, (batal *)fbs.dir_entries, 2);

Memcpy((void *)§ors, (void *)fbs.sectors, 2);

Kami membaca struktur FInfo dan menampilkan tanda tangan yang terletak di dalamnya:

Jika(baca_fs_info()< 0) return -1;

Printf("Tanda Tangan1 - 0x%X\n", fsinfo.tanda tangan1);

Printf("Tanda Tangan2 - 0x%X\n", fsinfo.tanda tangan2);

Fat32_size = fbs.fat32_length * 512; // Ukuran FAT32 dalam byte

Data_start = 512 * fbs.reserved + fat32_size * 2; // awal bidang data

Byte_per_cluster = fbs.cluster_size * 512; // ukuran cluster dalam byte

Root_cluster = fbs.root_cluster; // nomor cluster dari direktori root

Membaca FAT32:

Jika(baca_fat32()< 0) return -1;

Mengalokasikan memori untuk entri direktori:

Dir_entry = (__u8 *)malloc(byte_per_cluster);

Jika(!dir_entry) mengembalikan -1;

Membaca direktori root:

Jika(direktori_baca(root_cluster)< 0) return -1;

Kami mengurai jalur lengkap file dan membagi setiap elemen menjadi komponen-komponennya:

Sementara(1) (

Memset(tmp_name_buff, 0, SHORT_NAME);

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

Untuk(n = 0 ; n< SHORT_NAME; n++, i++) {

Tmp_name_buff[n] = jalur_lengkap[i];

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

saya++;

Merusak;

Tmp_name_buff[n] = "\0";

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

Printf("Nama tidak sah\n");

Kembali -1;

Jika(get_dentry(&sn)< 0) {

Printf("Tidak ada file seperti itu!\n");

Kembali -1;

Untuk mendapatkan nomor awal cluster dalam sistem file FAT32, Anda harus menggunakan kata tertinggi dari nomor cluster pertama file - bidang starthi dari struktur dentry:

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

Memeriksa byte atribut:

If(dentry.attr & 0x10) ( // ini adalah direktorinya

Jika(baca_direktori(mulai_cluster)< 0) return -1;

Melanjutkan;

If(dentry.attr & 0x20) ( // dan ini adalah file

Tmp_buff = (__u8 *)malloc(byte_per_cluster);

N = terbuka("kluster", O_CREAT|O_RDWR, 0600);

Jika(n< 0) {

Kesalahan("buka");

Kembali -1;

Printf("file cluster pertama - 0x%X .. ", start_cluster);

Untuk(saya = 0; saya< num; i++) {

Memset(tmp_buff, 0, byte_per_cluster);

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

Jika(tulis(n, tmp_buff, byte_per_cluster)< 0) {

Kesalahan("tulis");

Kembali -1;

Jika(kluster_berikutnya == EOF_FAT32) (

Gratis(tmp_buff);

Tutup(n);

Kembalikan ++i;

Mulai_cluster = cluster_berikutnya;

Kembalikan saya;

Tujuan dari tiga fungsi berikutnya adalah untuk mendapatkan isi dari area sistem, yaitu. sektor boot, struktur FSIinfo dan tabel FAT32:

1) fungsi read_fbs() membaca sektor boot:

ke dalam baca_fbs()

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

Kembali 0;

2) fungsi read_fs_info() membaca struktur FSIinfo:

ke dalam baca_fs_info()

U64 mencari = (__u64)fbs.info_sector * 512 + start_seek;

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

Kembali 0;

3) fungsi read_fat32() membaca tabel FAT32:

ke dalam baca_fat32()

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

Fat32 = (batal *)malloc(fat32_size);

Jika(!fat32) kembali -1;

If(pread64(keras, (__u8 *)fat32, fat32_size, cari)< 0) return -1;

Kembali 0;

Fungsi read_cluster() membaca cluster dengan nomor yang ditentukan:

int read_cluster(__u32 cluster_num, __u8 *tmp_buff)

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

If(pread64(keras, tmp_buff, byte_per_cluster, cari)< 0) return -1;

Kembali 0;

Fungsi read_directory() digunakan untuk membaca direktori (termasuk direktori root):

int read_directory(__u32 start_cluster)

Ke dalam saya = 2;

U32 cluster_berikutnya;

Parameter fungsi adalah cluster awal direktori. Kami membaca isi direktori ke dalam buffer global dir_entry:

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

Cluster_berikutnya = fat32;

Jika direktori menempati satu cluster, keluar, jika tidak, tambah ukuran memori dan lanjutkan membaca:

Untuk(; ;i++) (

Mulai_cluster = cluster_berikutnya;

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

Jika(!dir_entry) mengembalikan -1;

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

Cluster_berikutnya = fat32;

If((next_cluster == EOF_FAT32) || (next_cluster == 0xFFFFFF8)) mengembalikan 0;

Kembali 0;

Fungsi terakhir yang akan kita lihat adalah mencari konten direktori untuk elemen yang cocok dengan file yang kita cari:

int get_dentry(struct split_name *sn)

Ke dalam saya = 0;

Pointer dir_entry diatur ke area memori yang berisi array entri direktori tempat kita akan mencari file (atau direktori). Untuk mencari, kami mengatur sebuah siklus dan menempatkan catatan yang ditemukan dalam struktur kedokteran gigi global:

Untuk(;;i++) (

Memcpy((void *)&dentry, dir_entry + i * sizeof(dentry), sizeof(dentry));

If(!(memcmp(dentry.nama, sn->nama, sn->nama_len)) &&

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

Merusak;

If(!dentry.name) kembalikan -1;

Kembali 0;

Ini menyimpulkan ulasan kami tentang modul untuk membaca file dari partisi FAT32.

Kode sumber modul terletak di direktori FAT32, file fat32.c.

Perbedaan organisasi penyimpanan record file dalam direktori untuk sistem file FAT dan EXT2

Sekian penjelasan tentang perbedaan pengorganisasian penyimpanan record file dalam direktori untuk sistem file FAT dan EXT2. Struktur sistem file EXT2 telah dibahas di .

Kami baru saja mengenal FAT - di dalamnya semua elemen direktori memiliki nilai tetap. Saat file dibuat, driver sistem file mencari posisi kosong pertama dan mengisinya dengan informasi tentang file tersebut. Jika panjang direktori tidak muat dalam satu cluster, maka cluster lain dialokasikan untuknya, dan seterusnya.

Mari kita lihat keadaan di EXT2.

Katakanlah kita memiliki partisi dengan sistem file EXT2, ukuran bloknya adalah 4096 byte. Di bagian ini kita membuat direktori. Ukuran direktori akan sama dengan ukuran blok - 4096 byte. Dalam sebuah direktori, sistem operasi segera membuat dua entri - sebuah entri untuk direktori saat ini dan sebuah entri untuk direktori induk. Entri direktori saat ini akan memakan waktu 12 byte, sedangkan entri induk akan berukuran 4084 byte. Mari buat file di direktori ini. Setelah ini, akan ada tiga entri dalam direktori - entri direktori saat ini dengan panjang 12 byte, entri direktori induk dengan panjang 12 byte, dan entri file yang dibuat dengan panjang, seperti yang mungkin Anda duga, 4072 byte. Jika kita menghapus file yang dibuat, panjang entri direktori induk bertambah lagi menjadi 4084 byte.

Jadi, saat membuat file, driver sistem file EXT2 mencari entri dengan panjang maksimum dalam direktori dan membaginya, memberikan ruang untuk entri baru. Nah, jika ruang masih belum cukup, blok lain dialokasikan untuk direktori tersebut, dan panjang direktori menjadi 8192 byte.

Dan sebagai kesimpulan, edit kecil pada artikel “Arsitektur sistem file EXT2”.

Perubahan ini menyangkut fungsi get_i_num() untuk menentukan nomor inode berdasarkan nama file. Versi lama dari fungsi ini terlihat seperti ini:

int get_i_num(karakter *nama)

Ke dalam i = 0, rec_len = 0;

Struktur ext2_dir_entry_2 penyok;

Untuk(; saya< 700; i++) {

If(!memcmp(penyok.nama, nama, penyok.nama_len)) rusak;

Rec_len += penyok.rec_len;

Kembalikan penyok.inode;

Versi yang diperbaiki:

int get_i_num(karakter *nama)

* Parameter fungsi adalah nama file. Nilai yang dikembalikan adalah nomor inode file.

Int rec_len = 0;

Struktur ext2_dir_entry_2 penyok; // struktur ini menjelaskan format entri direktori root:

* Buff buffer global berisi serangkaian entri direktori. Untuk menentukan nomor seri file inode, Anda perlu menemukannya

* di array ini ada entri dengan nama file ini. Untuk melakukan ini, kami mengatur perulangan:

Untuk(;;) (

/* Menyalin entri direktori ke struktur penyok: */

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

* Panjang nama file nol berarti kita telah mengulangi semua entri direktori

* dan tidak ada entri dengan nama file kami yang ditemukan. Jadi inilah waktunya untuk kembali:

Jika(!penyok.nama_len) kembalikan -1;

/* Pencarian dilakukan dengan membandingkan nama file. Jika namanya cocok, kita keluar dari loop: */

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

/* Jika nama tidak cocok, pindah ke entri berikutnya: */

Rec_len += penyok.rec_len;

/* Jika berhasil, kembalikan nomor inode file: */

Kembalikan penyok.inode;

Literatur:

1. V.Kulakov. Pemrograman di tingkat perangkat keras: buku referensi khusus. edisi ke-2. / – Sankt Peterburg: Peter, 2003 – 848 hal.
2. A.V.Gordeev, A.Yu.Molchanov. Perangkat lunak sistem / – St. Petersburg: Peter – 2002
3. Meshkov V. Arsitektur sistem file ext2. – Majalah “System Administrator”, No. 11(12), November 2003 – 26-32 hal.

Memformat flash drive bukan hanya cara cepat untuk membersihkannya dari file yang tidak diperlukan, tetapi juga memilih sistem file tertentu yang memungkinkan berbagai perangkat dengan mudah membaca informasi dari media ini: PC, laptop, radio, TV, pemutar DVD , konsol game, dll. Oleh karena itu, pertama-tama, mari kita lihat sistem mana yang terbaik untuk memformat flash drive untuk Anda, dengan menyentuh fitur masing-masing. Kemudian kita akan membahas secara rinci algoritma pemformatan untuk FAT32 dan NTFS yang populer.

Apa itu sistem file

Sistem file adalah varian pengorganisasian data pada media tertentu. Setiap OS (dan bahkan pemutar musik pun memilikinya) memiliki sistemnya sendiri yang kompatibel secara harmonis dengannya. Atau bahkan beberapa. Jadi, saat memformat eksternal atau hard drive dengan sistem file tertentu, pertama-tama Anda menentukan OS mana yang dapat membacanya.

Banyak orang percaya bahwa memformat flash drive hanya dalam FAT32 atau NTFS dapat dilakukan, tetapi ini adalah kesalahpahaman. Masih banyak lagi sistem file. Mari daftar yang paling terkenal:

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

Mari kita kenali masing-masing lebih detail.

FAT32

Sistem file ini adalah yang tertua, paling luas, dan paling dapat diandalkan - sistem ini menggantikan FAT16. Oleh karena itu, banyak orang, ketika memutuskan untuk memformat flash drive dalam FAT32 atau NTFS, biasanya memilih opsi pertama.

Ini adalah format langka yang didukung oleh semua sistem operasi dan hampir semua konsol game dan perangkat lain dengan USB. Namun FAT32 memberlakukan batasan berikut: ukuran satu file di disk tidak boleh lebih dari 4 GB, dan satu partisi tidak boleh lebih dari 8 TB.

Banyak flash drive yang dijual di toko telah menginstal FAT lama yang bagus secara default, sehingga drive ini dapat dibaca oleh perangkat modern dan lama. Sistem ini sama sekali tidak cocok untuk hard drive saat ini - untuk menginstal Windows modern, drive harus diformat setidaknya dalam NTFS.

Pilihan Anda adalah FAT32 jika Anda ingin mendapatkan flash drive yang dapat digunakan untuk menulis informasi ringan, dan dapat digunakan oleh sejumlah perangkat berbeda secara maksimal.

NTFS

Produk Microsoft lainnya. Flash drive yang diformat dalam sistem ini dapat bekerja terutama dengan Windows, terkadang dengan Linux. Teknologi Apple hanya bisa membacanya, dan konsol game tidak mendukungnya sama sekali (Xbox, PS). NTFS memungkinkan ukuran file tunggal pada media lebih besar dari media flash yang tersedia saat ini, dan batas partisi adalah 16 Eb!

Selain itu, sistem file mencakup kemampuan berikut:

• mencatat perubahan untuk memulihkan sistem jika terjadi kegagalan;
• menetapkan hak akses ke file yang disimpan;
• kuota disk;
• enkripsi, dll.

Oleh karena itu, memformat drive yang dapat dilepas pada sistem ini tidak praktis karena... ini lebih disesuaikan untuk hard drive dan bekerja dengan Windows, dibandingkan dengan sistem operasi lain.

exFAT

Saat mencari tahu di mana lebih baik memformat flash drive - di FAT32 atau NTFS, banyak yang mengabaikan exFAT yang lebih modern, juga gagasan Windows. Dan ini memungkinkan Anda untuk menulis file dengan ukuran yang hampir tidak terbatas, menetapkan batas untuk satu partisi hingga 64 Zb kosmik! Windows, versi terbaru Apple OS dan Linux berfungsi dengan baik saat menginstal paket tambahan. Konsol game versi modern juga mendukung exFAT, yang tidak dapat dikatakan tentang Xbox 360 dan Playstation 3.

Jadi, exFAT adalah sistem file paling modern dari Windows, menggabungkan kemampuan kompatibilitas FAT32 dan fungsionalitas NTFS yang lebih luas. Salah satu kelemahannya adalah ia hanya bekerja dengan versi terbaru dari OS yang ada dan tidak berguna pada perangkat dengan perangkat keras yang ketinggalan jaman.

EXT2, 3 dan HFS+

HFS+ adalah sistem file yang dikembangkan oleh Mac OS. Linux dan Xbox juga berfungsi dengannya; Windows tidak didukung. Praktis tidak ada batasan ukuran satu file; untuk satu bagian - 8 Eb.

EXT2, 3 adalah produk Linux. Ukuran file maksimum pada flash drive yang diformat dalam sistem ini adalah 16 GB, untuk satu partisi - 32 TB. Di antara OS pihak ketiga, hanya Xbox yang berfungsi dengan format ini.

Cara memformat flashdisk ke FAT32

Algoritmanya sangat sederhana:

1. Hubungkan drive eksternal ke komputer Anda, setelah sistem melihatnya, buka "Komputer Saya". Tidak diperlukan perangkat lunak pemformatan untuk sistem ini.
2. RMB pada flash drive yang diinginkan - "Format".
3. Sistem yang diinginkan, sebagai aturan, sudah dipilih secara default - yang perlu Anda lakukan hanyalah mengklik "Mulai".
4. Setelah beberapa saat, komputer akan memberi tahu Anda bahwa pemformatan telah selesai. Itu saja!

Cara memformat flashdisk ke NTFS

Memformat dalam sistem file ini lebih sulit, karena sebenarnya tidak dimaksudkan untuk itu. Untuk prosedurnya, Anda memerlukan flash drive itu sendiri dan PC:

1. Di "Panel Kontrol", buka "Sistem".
2. Di "Properti" Anda memerlukan tab "Perangkat Keras", dan kemudian "Pengelola Perangkat".
3. Berikutnya - "Perangkat disk" - klik dua kali pada flash drive yang diinginkan untuk membuka propertinya.
4. Lalu "Kebijakan" dan "Optimalkan Eksekusi". Konfirmasikan tindakan dan tutup jendela.
5. Sekarang pergi ke "My Computer", pilih drive yang dapat dilepas yang diinginkan.
6. RMB sesuai namanya, lalu “Format”.
7. Bagaimana cara memformat flash drive ke NTFS? Nama yang Anda cari sekarang muncul di menu tarik-turun "Sistem file" - pilih nama tersebut.
8. Format drive dengan mengklik "Mulai".
9. Di "Komputer Saya", buka "Sistem".
10. Selanjutnya - "Perangkat Keras", "Pengelola Perangkat" - "Disk".
11. Pilih drive yang dapat dilepas yang telah diformat, lalu buka Propertinya.
12. Di "Kebijakan" centang "Optimalkan untuk penghapusan cepat", konfirmasikan pilihan Anda.

Mana yang lebih mudah: memformat flash drive di FAT32 atau NTFS? Jawabannya jelas.

Program pendukung

Untuk memformat drive dalam sistem file yang langka, terkadang kemampuan satu OS saja tidak cukup. Mari perkenalkan beberapa program pembantu untuk pemformatan:

• Di NTFS - convert.exe (utilitas bawaan Windows), Alat Format Penyimpanan Disk USB HP, Format USB, atau Perangkat Lunak Flash Drive.
• Dalam HFS+ dan untuk kartu SD, SHDC, SDXC, SD-C, LLC - SD Formatter.
• Untuk JetFlash, Transcend dan A-DATA - Alat Pemulihan JetFlash.
• Dukungan untuk semua sistem file - MiniTool Partition Wizard.

Saat memikirkan apakah akan memformat flash drive di FAT32 atau NTFS, pertama-tama, perhatikan untuk apa Anda memerlukan drive ini - untuk menulis file besar, bekerja dengan berbagai perangkat, menyimpan data rahasia, dll. dan kekurangan sistem file ini, Anda dapat dengan mudah memilih algoritma pemformatan yang diinginkan di artikel ini.

Siapa pun yang pernah menginstal sistem operasi pasti pernah mengalami kenyataan bahwa pada tahap memformat partisi instalasi hard drive, program meminta Anda untuk memilih jenis sistem file FAT atau NTFS.

Dan mereka yang memformat flash drive atau perangkat penyimpanan eksternal lainnya perlu memutuskan antara tiga sistem file: FAT32, NTFS dan exFAT. Seringkali, pengguna memilih format default karena mereka tidak tahu apa bedanya.

Artikel ini ditujukan kepada mereka yang ingin mengisi kesenjangan pengetahuan mereka.

Struktur file FAT: prinsip dan tujuan

Struktur file atau Sistem file dikembangkan pada tahun 70-an abad terakhir oleh Microsoft dan mewakili prosedur tertentu untuk mengatur ruang untuk menyimpan dan mengakses data di komputer dan perangkat digital lainnya.

Tujuan dari fungsionalitas ini adalah untuk memberi pengguna kemudahan pengelolaan informasi yang disimpan di disk atau gadget eksternal. Sistem file mencakup file, folder dan direktori, serta seperangkat alat sistem yang berinteraksi dengannya untuk menjalankan fungsi baca-tulis, buat-hapus, salin, beri nama, dll. Selain itu, struktur ini mengatur akses bersama ke informasi antar pengguna dan memberikan perlindungan terhadap tindakan tidak sah melalui enkripsi, operasi dalam mode read-only, dll.

Secara struktural, seluruh area ruang disk dibagi menjadi beberapa kelompok, seperti selembar kertas kotak-kotak. Setiap sel adalah sebuah blok, yang ukurannya diatur selama pemformatan dan harus kelipatan 2. Ukuran minimumnya bisa 512 byte (untuk flash drive), untuk hard drive 32 KB. Satu file dapat menempati beberapa cluster tersebut. Secara kiasan Anda dapat membayangkan ruang disk sebagai sebuah buku catatan, dengan clusternya adalah sebuah huruf, file adalah sebuah kata, dan struktur file adalah daftar isi buku catatan tersebut.

Saat mengakses suatu file, sistem operasi harus menemukannya di beberapa cluster yang terletak di tempat berbeda pada disk, sehingga membentuk rantai cluster. Setiap cluster memiliki labelnya sendiri, yang mengidentifikasinya sebagai salah satu dari tiga jenis:

1. Gratis, siap merekam data.
2. Sibuk, yang menyimpan sebagian informasi dan memiliki data label tentang cluster berikutnya dalam rantai, sedangkan cluster berikutnya ditandai dengan label khusus.
3. Blok BAD adalah cluster dengan kesalahan yang tidak lagi dapat diakses setelah pemformatan.

Ukuran label ditentukan oleh jenis struktur file: untuk FAT32 adalah 32 byte.

Seluruh sistem file terdiri dari bagian-bagian berikut:

• sektor boot, yang terletak di awal disk, diaktifkan setelah OS melakukan booting dan menyimpan parameter partisi;
• tabel alokasi file (“daftar isi”) yang menyimpan label cluster;
• salinan tabel alokasi file untuk memulihkan data jika struktur file rusak;
• direktori root;
• area data;
• silinder untuk melakukan operasi baca/tulis.

Ada tiga jenis sistem file FAT: FAT12, FAT16 dan FAT32. FAT telah digantikan oleh NTFS, dan exFAT adalah versi lanjutan dari FAT32 dan terutama digunakan untuk flash drive.

Kelebihan dan kekurangan struktur file FAT32, NTFS dan exFAT

Untuk menentukan pilihan sistem file yang paling optimal untuk pemformatan, kami akan mempertimbangkan deskripsi ketiga opsi, dengan fokus pada kelebihan dan kekurangan masing-masing.

FAT32

Di antara tiga struktur file yang dipertimbangkan, FAT32 adalah yang tertua. Ini menggantikan FAT16 dan hingga saat ini merupakan yang paling progresif. Rilis FAT32 dijadwalkan bertepatan dengan rilis sistem operasi Windows 95 OSR2 pada tahun 1996. Fitur pembeda utama: pengalamatan cluster 32-bit dan batasan ukuran: file tidak lebih dari 4 GB dan volume 128 GB.

Keuntungan

Meskipun ada beberapa keterbelakangan moral, FAT32 memiliki sejumlah keunggulan dibandingkan sistem file lainnya. Daya tarik utamanya adalah kompatibilitas dan keserbagunaan. FAT32 bekerja dengan semua versi sistem operasi, termasuk Windows (perbandingan semua versi), Linux dan MacOS, dan cocok untuk semua konsol game dan gadget lain dengan port USB. Saat ini digunakan di semua drive eksternal (flash drive, kartu CD) secara default, karena banyak perangkat lama: PC, laptop, dekoder dengan input USB hanya dapat bekerja dengan FAT32.

Keuntungan penting lainnya dari sistem file adalah: kinerja kecepatan tinggi, kebutuhan jumlah RAM yang rendah, pekerjaan produktif dengan file berukuran sedang dan kecil, dan keausan disk yang rendah karena pergerakan head yang lebih kecil. Namun, ini juga dapat mengalami fragmentasi, dan defragmentasi berkala pasti tidak akan merugikan.

Kekurangan

Kerugian utama dari sistem file ini adalah keterbatasan ukurannya. Untuk cluster, ukurannya tidak boleh lebih dari 64 KB, jika tidak, beberapa aplikasi mungkin salah menghitung ruang disk.

Ukuran file tidak boleh melebihi 4 GB, sehingga ukuran disk maksimum untuk ukuran cluster untuk tabel alokasi file 32 KB adalah sekitar 8 TB.

Saat memformat disk menggunakan ScanDisk, yang merupakan program 16-bit, dengan mempertimbangkan tabel FAT itu sendiri dan dengan ukuran cluster maksimum 32 KB, ukuran volume dibatasi hingga 128 gigabyte.

Mengingat tidak banyak perangkat komputer yang dilengkapi dengan hard drive lebih besar dari 8 TB, kelemahan ini tidak akan terlihat oleh sebagian besar pengguna. Namun, fakta bahwa FAT32 berfungsi dengan file berukuran hingga 4 GB merupakan kelemahan yang signifikan, karena sebagian besar file video berkualitas tinggi dalam format 4K modern saat ini lebih besar dari 4 GB tersebut, dan oleh karena itu tidak kompatibel dengan sistem file ini.

Selain keterbatasan ukurannya, FAT32 memiliki kelemahan lain. Itu tidak mendukung nama file yang panjang, yang sangat tidak nyaman bagi pengguna yang ingin mengidentifikasi file secara logis berdasarkan isinya. Ada keluhan tentang sistem keamanan (pemindai anti-virus tambahan tidak ada salahnya) dan perlindungan file jika terjadi kegagalan (fitur hard drive), serta kecepatan rendah saat bekerja dengan direktori yang berisi banyak file.

Oleh karena itu, FAT32 lebih cocok untuk perangkat portabel berkapasitas rendah dan komputer lama. Versi terbaru Windows tidak dapat lagi diinstal pada disk yang diformat dengan sistem FAT32; versi tersebut harus diformat ulang ke NTFS.

Aplikasi utama sistem file FAT32 saat ini adalah flash drive portabel dan kartu SD (fitur), yang berisi sedikit file dan kompatibel dengan berbagai perangkat digital.

NTFS

Sistem file ini dikembangkan oleh Microsoft pada tahun 1993 dan diperkenalkan dengan Windows NT 3.1. Dalam judulnya sendiri sistem file teknologi baru, yang artinya sistem file teknologi baru, terletak esensi progresifnya.

Setelah memformat disk di NTFS, disk dibagi menjadi tiga zona:

• MFT - zona atau tabel file umum (Master File Table), tempat informasi tentang file dan direktori disimpan;
• data pengguna;
• metafile yang berisi informasi layanan.

Masing-masing metafile bertanggung jawab atas area tertentu. Misalnya, LogFile adalah file logging di mana semua operasi dicatat dalam log, Boot adalah sektor boot, Bitmap mengontrol ruang kosong di partisi, dll. Struktur ini secara andal melindungi file dari kegagalan apa pun, baik itu OS macet atau pemadaman listrik.

Keuntungan

Berbeda dengan FAT32, struktur file ini hampir tidak memiliki batasan ukuran file dan direktori. Ukuran cluster dapat bervariasi dari 512 byte hingga 64 KB, dengan ukuran optimal menjadi 4 KB.

Berkat banyak perbaikan signifikan untuk meningkatkan keamanan, seperti dukungan untuk hak akses file, kuota HPFS, enkripsi, penjurnalan, kontrol akses dan audit, hard link, dll., NTFS sangat ideal untuk memformat disk untuk area sistem. Partisi hard drive lain juga dapat diformat dalam sistem ini, karena NTFS memungkinkan penggunaan ruang disk secara optimal ketika terdapat banyak file kecil.

Keuntungan dari organisasi file ini adalah kecepatan akses yang cepat ke file kecil, kinerja tinggi saat bekerja dengan file besar, dan kemampuan untuk menggunakan nama file yang panjang.

Kekurangan

Kerugian utama dari sistem NTFS adalah ketidakcocokannya dengan semua sistem operasi di bawah Windows NT, serta keterbatasan kompatibilitas dengan sistem operasi lain. Jadi, Mac OS membaca file dari disk NTFS, tetapi tidak dapat menulisnya, situasi yang sama terjadi dengan kompatibilitas file Linux. Konsol game terpopuler Playstation dan Xbox 360 tidak bekerja dengan NTFS, hanya Xbox One yang dapat berinteraksi dengannya.

Kekurangan NTFS juga mencakup kebutuhan RAM yang tinggi, kecepatan lebih rendah dibandingkan FAT32, dan kesulitan mengelola direktori berukuran sedang.

Oleh karena itu, lebih disarankan untuk menggunakan struktur file NTFS pada hard drive, termasuk SSD, yang menjalankan Windows versi terbaru, dimulai dengan NT.

exFAT

Sistem file ini adalah yang terbaru untuk ditinjau dalam hal waktu rilis. Itu muncul pada tahun 2008 dengan pembaruan rutin untuk Windows XP dan, pada kenyataannya, merupakan versi lanjutan dari FAT32.

Tujuan utama pengembang adalah menciptakan struktur file yang produktif, nyaman, dan universal untuk perangkat penyimpanan portabel: flash drive, kartu SD, dan hard drive yang dapat dilepas.

Keuntungan:

• Organisasi sederhana tanpa fitur khusus dan batasan ukuran file dan partisi.
• Kompatibilitas luar biasa dengan semua sistem operasi Windows, serta Mac OS dan Linux. Opsi terakhir memerlukan instalasi perangkat lunak tambahan.
• Dukungan dari semua perangkat Apple modern, serta konsol game Xbox One dan Playstation 4.

Kerugian utama dari organisasi file exFAT adalah kebijakan lisensi Microsoft, yang melarang penggunaan gratisnya di domain publik.

Struktur file paling optimal

Setelah mempertimbangkan deskripsi tiga sistem file populer, kita dapat menarik kesimpulan berikut:

• untuk perangkat komputer dengan sistem operasi lebih tinggi dari Windows NT, akan lebih tepat jika memformat harddisk dalam sistem NTFS;
• untuk perangkat lama, serta untuk tujuan kompatibilitas dengan berbagai gadget digital modern, pilihan terbaik adalah memilih FAT32;
• untuk media yang dapat dipindahkan, idealnya menggunakan sistem ini

Dan terakhir: informasi tentang struktur file apa yang diterapkan pada disk Anda dapat ditemukan di tab “Umum” (tombol kanan mouse “Properti”).