精华内容
下载资源
问答
  • fat12文件系统

    2020-11-02 21:22:05
    fat12文件系统fat12文件系统简介文件系统结构 图片来源于网络 fat12文件系统简介 FAT文件系统遵行已用了多年的软件方法来进行规范。它在1977年由比尔·盖茨和马斯·麦当劳为了管理磁盘而发明,并在1980年被添·...

    图片来源于网络

    fat12文件系统简介

    FAT文件系统遵行已用了多年的软件方法来进行规范。它在1977年由比尔·盖茨和马斯·麦当劳为了管理磁盘而发明,并在1980年被添·彼得逊的86-DOS操作系统采用。这也是86-DOS操作系统与CP/M操作系统最大的不同点,若非此项差异,86-DOS操作系统与CP/M操作系统几乎可说完全相同。

    初期的FAT就是现在俗称的FAT12。作为软盘的文件系统,它有几项限制:不支持分层性结构,簇定址只有12位(这使得控制FAT有些棘手)而且只支持最多32M(216)的分区。当时入门级的磁盘是5.25"、单面、40磁道、每个磁道8个扇区、容量略少于160KB。上面的限制超过了这个容量一个或几个数量级,同时允许将所有的控制结构放在第一个磁道,这样在读写操作时移动磁头。这些限制在随后的几年时间里被逐步增大。由于唯一的根目录也必须放在第一个磁道,能够存放的文件个数就限制在几十个。

    文件系统结构

    在这里插入图片描述
    简单来说,一个fat12文件系统由保留区(保留区一般只有主引导区)、fat1表,fat2表、根目录、数据区构成。

    在这里插入图片描述主引导区结构:
    在这里插入图片描述
    主引导区的重要参数如下:
    在这里插入图片描述

    fat1表记录了文件系统的所有簇号,fat2表是对fat1表的复制。一般来说,fat表第一个簇号和第二个簇号不能使用,所以簇号从第2个开始计算,即一个簇号位于3号位置,那么数据从第1簇开始储存。(簇号指向下一个簇的位置);

    在这里插入图片描述

    根目录中条目结构:
    在这里插入图片描述
    以下为fat12镜像文件中的的根目录,其中含有FAT.PDF和BLOCK.C两个长度不为零的文件,后面以此二例介绍如何根据簇号寻找文件储存的地址:
    在这里插入图片描述
    由前面分析得到:
    此fat12文件系统扇区大小为512字节,
    保留区占1个扇区
    含有fat表2个,每个fat表占3个扇区
    根目录最多有512个条目,已知每个条目长度32字节,换算成扇区大小,即根目录占32个扇区
    而FAT.PDF首簇号为06,查找fat表,为007。

    在这里插入图片描述易看出fat表中簇号依次为:
    ff8 fff 000 004 fff fff 007 008 009 00a 00b 00c 00d……
    找到第6号位置上的簇号007,说明下一段文件保存在第7号位置,找到第7号位置上的簇号,发现下一段文件保存在第8号位置,一次类推,知道得到下个位置上的簇号为ff8-fff,文件簇表结束。

    有点扯远了,知道了文件存储的首簇号,可以算出文件存储偏移地址,ff8 fff两个位置不用,故FAT.PDF从第4簇开始存储:
    (1+2*3+32)*512+ (6-2)* 4* 512=0x6600
    即:
    (保留区占扇区数+fat表数量*fat表占扇区数+根目录占扇区数)*扇区占字节数+(首簇号位置-不用的簇号数量)*每个簇占扇区数*扇区占字节数

    到0x6600位置,发现文件就从那里开始存储
    在这里插入图片描述

    同理,BLOCK.C文件偏移地址:
    (1+2*3+32)*512+(3-2)*4*512=0x5600

    在这里插入图片描述

    示例(提取fat12中的pdf):

    #include<stdio.h>
    #include<stdlib.h>
    #include<string.h>
    	
    	
    unsigned short secBytes;//每个扇区的字节数
    unsigned char secPerClus;//每个簇的扇区数
    unsigned char rsvdSecCnt;//保留区所用扇区数 
    unsigned char fatCnt;//fat表数量 
    unsigned char fatSecCnt;//fat表占的扇区数 
    unsigned short rootEntCnt;//根目录最大文件条目数
    unsigned char name_ext[3];//文件扩展名 
    unsigned short firstClus;//pdf首簇号 
    unsigned int size;//pdf文档大小
    
    
    //由当前簇号查询下一簇号 
    int getNextClus(FILE*fp_in,unsigned short thisClus,unsigned short*nextClus){
    	unsigned char tmp[3]={0};
    	if(thisClus%2==0){
    		fseek(fp_in,rsvdSecCnt*secBytes+thisClus*3/2,0);
    		fread(&tmp[0],1,1,fp_in);
    		fread(&tmp[1],1,1,fp_in);
    		*nextClus=tmp[0]+((tmp[1]&0xf)<<8);
    	}
    	else{
    		fseek(fp_in,rsvdSecCnt*secBytes+(thisClus-1)*3/2+1,0);
    		fread(&tmp[0],1,1,fp_in);
    		fread(&tmp[1],1,1,fp_in);
    		*nextClus=((tmp[0]&0xf0)>>4)+(tmp[1]<<4);
    	}
    }
    
    
    int main(){
    	int start=0,end=0;
    	FILE *fp_in,*fp_out;
    	if((fp_in=fopen("d:\\fat12.img","rb"))==NULL){
    		perror("can not open file_in:");
    		return -1;
    	}
    	if((fp_out=fopen("d:\\test.pdf","wb"))==NULL){
    		perror("can not open file_out:");
    		return -1;
    	}
    		
    	//开始读取fat镜像文件参数 
    	fseek(fp_in,0xb,0);
    	fread(&secBytes,2,1,fp_in);
    	fseek(fp_in,0xd,0);	
    	fread(&secPerClus,1,1,fp_in);
    	fseek(fp_in,0xe,0);
    	fread(&rsvdSecCnt,1,1,fp_in);	
    	fseek(fp_in,0x10,0);
    	fread(&fatCnt,1,1,fp_in);
    	fseek(fp_in,0x11,0);
    	fread(&rootEntCnt,2,1,fp_in);
    	fseek(fp_in,0x16,0);
    	fread(&fatSecCnt,1,1,fp_in);
    	printf("secBytes: %d\n",secBytes);
    	printf("secPerClus: %d\n",secPerClus);
    	printf("rsvdSecCnt: %d\n",rsvdSecCnt);	
    	printf("fatCnt: %d\n",fatCnt);
    	printf("rootEntCnt: %d\n",rootEntCnt);
    	printf("fatSecCnt: %d\n",fatSecCnt);
    	
    	fseek(fp_in,(rsvdSecCnt+fatCnt*fatSecCnt)*secBytes,0);
    	while(strncmp((char*)name_ext,"PDF",3)){  //查找文件后缀名到PDF为止 
    		fseek(fp_in,0x8,1);
    		fread(name_ext,3,1,fp_in);
    		fseek(fp_in,21,1);
    	}
    	fseek(fp_in,-6,1);
    	fread(&firstClus,2,1,fp_in);
    	fread(&size,4,1,fp_in);
    	printf("firstClus: %d\n",firstClus);
    	printf("size: %d\n",size);
    	
    	unsigned short tmpClus,nextClus; 
    	unsigned char data[secPerClus*secBytes+1];//储存每簇中的数据 
    	tmpClus=firstClus;
    	while(tmpClus<0xff8){ //如果不为簇尾,则继续读 
    		memset(data,0,sizeof(data));
    		fseek(fp_in,(rsvdSecCnt+fatCnt*fatSecCnt+(tmpClus-2)*secPerClus)*secBytes+rootEntCnt*32,0);
    		if(!fread(data,secPerClus*secBytes,1,fp_in))
    			return -1;
    		fwrite(data,1,secPerClus*secBytes,fp_out);
    		getNextClus(fp_in,tmpClus,&nextClus);
    		tmpClus=nextClus;
    	}
    		
    	fclose(fp_in);
    	fclose(fp_out);
    	printf("\npdf读取完毕!\n");
    	return 0;
    }
    
    展开全文
  • FAT12 文件系统

    2019-10-27 23:25:11
    FAT12 文件系统 FAT 简介 FAT全称File Allocation Table,是一种计算机文件系统体系结构。最初于1977年设计用于软盘,20年来,fat很快被广泛应用于整个dos和windows 9x时代的硬盘上。[4]随着磁盘驱动器的发展,文件...

    FAT12 文件系统

    FAT 简介

    FAT全称File Allocation Table,是一种计算机文件系统体系结构。最初于1977年设计用于软盘,20年来,fat很快被广泛应用于整个dos和windows 9x时代的硬盘上。[4]随着磁盘驱动器的发展,文件系统的功能也相应地得到了扩展,产生了三种主要的文件系统变体:fat12、fat16和fat32。

    本文主要探讨FAT12文件系统。

    FAT 结构

    FAT文件系统把存储介质看成一维的数组,基本单位是簇(cluster)。存储介质被划分为3个区域:boot record、FAT、directory和data area。

    一个簇包含一个扇区,大小为512B。

    Boot Record

    引导扇区包含了数据和代码,数据被称为BPB(BIOS Parameter Block)。

    Offset (decimal)Offset (hex)Size (bytes)Meaning
    00x0003前三个字节EB 3C 90分解为JMP SHORT 3C NOP。(3C值可能有所不同)这样做的原因是要“翻阅磁盘格式信息(BPB和EBPB)。由于磁盘的第一个扇区已加载到0x0000:0x7c00位置的ram中,并且已执行, 如果没有这种跳转,处理器将尝试执行非代码数据,即使对于不可引导的卷,Windows和OS X都必须提供与模式匹配的代码(或使用E9跳转选项)。 为了满足要求,可以在此处放置带有字节EB FE 90的无限循环。
    30x0038OEM标识符。(后面看不看无所谓) 前8个字节(3-10)是所使用的DOS版本。 接下来的八个字节29 3A 63 7E 2D 49 48和43读出版本名称。 Microsoft的官方FAT规范说,该字段实际上是没有意义的,MS FAT驱动程序将忽略它,但是它确实建议使用值“ MSWIN4.1”,因为某些第三方驱动程序应该检查并期望它具有该值。 DOS的较旧版本也报告MSDOS5.1,Linux格式的软盘可能在此处带有“ mkdosfs”,而FreeDOS格式的磁盘在此处具有“ FRDOS5.1”。
    110x00B2每个扇区的字节数
    130x00D1每个簇的扇区数
    140x00E2保留的扇区数,boot record的扇区包含在其中;也可以说是boot record占用的扇区数。
    160x0101FAT的数量,一般为2
    170x0112根目录文件数(的最大值,must be set so that the root directory occupies entire sectors)。
    190x0132扇区数。如果此值为0,则说明这个卷有超过65535个扇区,真实的数量将存在0x20处
    210x0151此字节指示媒体描述符类型
    220x0162每个FAT的扇区数。仅FAT12/FAT16使用。
    240x0182每个磁道的扇区数
    260x01A2存储介质上的磁头或磁头数
    280x01C4隐藏扇区数(即分区开头的LBA)
    320x0204大扇区数。当卷中超过65535个扇区(在0x13出放不下,仅2 byte)时设置。
    360x0241驱动器号。 此处的值应与BIOS中断Ox13返回的值相同,或与DL寄存器中传递的值相同。 即软盘为0x00,硬盘为Ox80。 该编号无用,因为该介质很可能会移动到另一台计算机上,并插入到具有不同驱动器编号的驱动器中。
    370x0251Windows NT中的标志;否则保留(不使用)。
    380x0261Signature,必须为0x28或0x29
    390x0274卷ID“序列号”。 用于跟踪计算机之间的卷。 如果你想的话,可以忽略它。
    430x02B11卷标签字符串。该字段用空格填充。
    540x0368系统标识符字符串。 该字段是FAT文件系统类型的字符串表示形式。 它用空格填充。 规范说永远不要相信此字符串的内容用于任何用途
    620x03E448Boot代码
    5100x1FE2可启动分区签名0xAA55

    Boot Record占据了第一个扇区。

    展开全文
  • FAT12文件系统

    千次阅读 2019-03-31 13:27:56
    FAT12文件系统 转载自 https://blog.csdn.net/begginghard/article/details/7284834 感谢 一、 FAT12 FAT12是DOS时代就开始使用的文件系统(File System),直到现在仍然在软盘上使用,FAT12软盘...

    FAT12文件系统

    转载自 https://blog.csdn.net/begginghard/article/details/7284834 感谢

    一、 FAT12

    FAT12是DOS时代就开始使用的文件系统(File System),直到现在仍然在软盘上使用,FAT12软盘的被格式化后为:有两个磁头,每个磁头80个柱面(磁道),每个柱面有18个扇区,每个扇区512个字节空间。所以标准软盘的总空间为:

    2 * 80 *18 * 512=1474560B=1440K=1.44M

    下面是FAT12的结构图:


    1、引导扇区

    操作系统之所以认识FAT12格式的磁盘,其秘密就在于逻辑0扇区这512B上。如果这512字节的最后两个字节的内容分别是55和AA(0xAA55低字节在前,高字节在后)的话,BIOS在启动时会将这个扇区读取到0:7C00h-0:7DFFh处,然后跳转到0:7C00h处继续执行指令,操作系统即用此来达到引导系统的目的,而这个磁盘就称为引导磁盘。

    操作系统标识FAT12文件系统是因为在逻辑0扇区(即引导扇区)处还存储着一个特定的数据结构,此结构有固定的格式,在操作系统将此磁盘格式化时自动生成,具体数据结构如下表所示:

     

    名称

    开始字节

    长度

    内容

    参考值

    BS_jmpBOOT

    0

    3

    一个短跳转指令

    jmp short LABEL_START

    nop

    BS_OEMName

    3

    8

    厂商名

    'ZGH'

    BPB_BytesPerSec

    11

    2

    每扇区字节数(Bytes/Sector)

    0x200

    BPB_SecPerClus

    13

    1

    每簇扇区数(Sector/Cluster)

    0x1

    BPB_ResvdSecCnt

    14

    2

    Boot记录占用多少扇区

    ox1

    BPB_NumFATs

    16

    1

    共有多少FAT表

    0x2

    BPB_RootEntCnt

    17

    2

    根目录区文件最大数

    0xE0

    BPB_TotSec16

    19

    2

    扇区总数

    0xB40

    BPB_Media

    21

    1

    介质描述符

    0xF0

    BPB_FATSz16

    22

    2

    每个FAT表所占扇区数

    0x9

    BPB_SecPerTrk

    24

    2

    每磁道扇区数(Sector/track)

    0x12

    BPB_NumHeads

    26

    2

    磁头数(面数)

    0x2

    BPB_HiddSec

    28

    4

    隐藏扇区数

    0

    BPB_TotSec32

    32

    4

    如果BPB_TotSec16=0,则由这里给出扇区数

    0

    BS_DrvNum

    36

    1

    INT 13H的驱动器号

    0

    BS_Reserved1

    37

    1

    保留,未使用

    0

    BS_BootSig

    38

    1

    扩展引导标记(29h)

    0x29

    BS_VolID

    39

    4

    卷序列号

    0

    BS_VolLab

    43

    11

    卷标

    'ZGH'

    BS_FileSysType

    54

    8

    文件系统类型

    'FAT12'

    引导代码及其他内容

    62

    448

    引导代码及其他数据

    引导代码(剩余空间用0填充)

    结束标志0xAA55

    510

    2

    第510字节为0x55,第511字节为0xAA

    0xAA55


    下面我们介绍其中的一些变量的含义:

    BS_jmpBoot:是跳转指令,偏移0处的跳转指令必须是合法的可执行的基于x86的CPU指令,如:jmp start,这样可以生成3字节长的指令,(加关键字short的短跳转指令的长度是2字节),指向操作系统引导代码部分。Windows和MS-DOS生成的FAT12启动扇区中的跳转指令是短跳转,如:jmp short LABEL_START,然后加一个nop的空指令来保持3字节的长度。

    BPB_BytsPerSec:每扇区的字节数,类型是双字节长,标准分区上的每扇区字节数一般是512B, FAT12的格式下设置为512(0x200h)。

    BPB_SecPerClus:每簇扇区数,偏移13处,类型是字节,簇是数据存储的最小单位,在FAT12格式下一般为1,即每簇只有1个扇区(512字节)。

    BPB_RsvdSecCnt:Boot记录占用多少扇区,即在FAT1之前的 引导扇区,一般情况下,引导扇区占用1个扇区。

    BPB_NumFATs:共有多少个FAT表,默认情况下此字段的值为2,也就是有两个FAT表,FAT1和FAT2的内容相同,当FAT1表出错的时候可以使用FAT2来恢复文件分配表。

    BPB_RootEntCnt:根目录文件数最大值,默认为224,每个目录条目占用32B的空间,因此根目录的大小为:224*32/512=14,即占用14个扇区。

    BPB_TotSec16:扇区总数=0xB40=2880

    BPB_FATSz16:每个FAT占用的扇区数=0x9=9,即FAT1占用1—9逻辑扇区,FAT2占用10—18逻辑扇区。

    BPB_SecPerTrk:每磁道扇区数=0x12=18,即标准FAT12文件系统中,每个磁道的扇区数就是为18。

    BPB_NumHeads:磁头数=0x2=2,该磁盘包括2个磁头,也就是面数是2。

    2、FAT表

             FAT1和FAT2是两个完全相同的FAT表,每个FAT占用9个扇区。其中FAT1占用1—9扇区,FAT2占用10—18扇区。具体详细介绍看下面4。

    3、根目录区

    根目录区的开始扇区号是19,它是由若干个目录条目(Directory Entry)组成,条目最多有BPB_RootEntCnt个,由于根目录区的大小是依赖于BPB_RootEntCnt的,所以长度不固定。

             在本FAT12中,因为BPB_RootEntCnt=0xE0=14*16+0=244,即条目最多为244个,又因为每个条目占用32个字节,故244*32/512=14,即该根目录区占14个扇区,即19—32。

             根目录区中的每个条目占用32字节,它的格式如下图:


    这里主要定义了文件的名字,属性,最后写入的时间和日期,文件的开始簇数以及文件大小。

    下面我们通过实例来认识这些内容,

    1、 首先创建一个虚拟软盘,在这里我们使用WinImage,具体下载地址在我的下载资源中。

    打开WinImage:

    选择文件—》新建


    新建一个虚拟软盘之后,需要向里面添加文件,我们需要提前写好下面几个文件

    RIVER.TXT,内容为riverriverriver

    FLOWER.TXT,内容为flowerflower………flower,至少要100个flower,使得数据空间大于512个字节,这样该文件将占用两个连续的扇区。

    TREE.TXT,内容为treetreetree

    再添加一个HOUSE目录,然后在目录\HOUSE下添加两个文本文件:

    CAT.TXT,内容为catcatcat

    DOG.TXT,内容为dogdogdog

    选择映像—》加入,依次加入RIVER.TXT,FLOWER.TXT,TREE.TXT三个文件


    映像—》创建文件夹  HOUSE


    添加HOUSE目录


    双击house,进入house的文件夹内,然后添加CAT.TXT,DOG.TXT两个文件



    添加文件完成,然后保存,其中注意事项,保存类型为:虚拟软盘映像(*.vfd),我不知道这个类型与IMG有什么区别,但是我知道这个类型得到的结果是对的。呵呵!文件名为FLOOPY,这样我们就创建了一个虚拟软盘FLOOPY.vfd


    然后使用UltraEdit打开FLOOPY.vfd,由于根目录区是从第19扇区开始的,每个扇区512个字节,所以其第一个字节位于偏移19*512=9278=0x2600处,好的,现在就让我们去定位到0x2600处看看到底Directory Entry为何物?


    RIVER.TXT的各项值:


    在这里,我们只需要关心RIVER.TXT的DIR_FstClus,即文件的开始簇号,由于本FAT12中的BPB_SecPerClus=1,故一个簇为一个扇区,DIR_FstClus=2,意味着该文件的在数据区的起始扇区号为2。在这里需要注意的是,数据区的第一个簇的簇号是2,而不是0或者1,故该文件的数据开始于数据区的第一个簇,也就是第一个扇区。

    那么数据区的第一个扇区在哪里呢?

    首先计算根目录区所占有的扇区数:

    RootDirSectors =((BPB_RootEntCnt*32)+(BPB_BytsPerSec-1))/BPB_BytsPerSec。

    之所以分子要加上(BPB_BytsPerSec-1),是为了保证此公式在根目录区无法填满整数扇区时仍然成立。

    在本例中,因为BPB_RootEntCnt=224,计算得到根目录区所占有的扇区为14个。所以

    数据区开始的扇区号=根目录区开始的扇区号+14=19+14=33。

    现在就让我们跳入到第33扇区的偏移量是512*33=16896=0x00004200,让我们看看这里的内容:


    果然是riverriverriver。

    4、FAT表

    在这里,由于RIVER.TXT小于512字节,所以我们不需要FAT表就在数据区中找到了RIVER.TXT的内容,但是对于大于512字节的文件来说,就没有这么简单了,需要使用FAT表来寻找到该文件占用的所有数据区扇区。

    下面让我们跳入FAT1的内容,FAT1的开始扇区号是1,故偏移为1*512=512=0x200。


    一堆看不懂的符号,好像很多F。其实并不复杂,它有点像是一个位图,其中,每12位成为一个FAT项(FAT Entry),代表一个数据区中的簇。第0个和第1个FAT项始终不使用,第2个FAT项开始表示数据区的每一个簇,也就是说,第2个FAT项表示数据区第一个簇,依次类推。前文说过,数据区的第一个簇的簇号是2,和这里相呼应。

    要注意,由于每一个FAT项占12位,包含一个字节和另一个字节的一般,所以觉得特别别扭。具体情况是这样的,假设连续3个字节分别是如图所示:


    通常,FAT项的值代表的是文件的下一个簇号,但如果值大于或等于0xFF8,则表示当前簇已经是文件的最后一个簇了。如果值为0xFF7,表示它是一个坏簇。

    文件RIVER.TXT的开始簇号为2,对应的FAT表中的值为0xFFF,表示这个簇已经是最后一个。

    文件FLOWER.TXT的开始簇号为3,对应的FAT表中的值为0x004,表示文件还没有结束,下一个簇号是0x004,然后我们再看FAT表中第4个簇相对应的FAT值为0xFFF,则表示该是最后一个簇,则文件FLOWER.TXT占用第3、4簇。

    如果想使文件内容分存在不连续的扇区内,有一个方法可以做到,就是先将该文件加入到软盘驱动中,然后在进行添加相同的文件,进行覆盖。当然该文件的大小必须大于512个字节。

    《自己动手写操作系统》读后感                    http://blog.csdn.net/zgh1988/article/details/7059936

    全面剖析《自己动手写操作系统》第一章       http://blog.csdn.net/zgh1988/article/details/7060032

    全面剖析《自己动手写操作系统》第二章       http://blog.csdn.net/zgh1988/article/details/7062065

    全面剖析《自己动手写操作系统》第三章1     http://blog.csdn.net/zgh1988/article/details/7098981

    全面剖析《自己动手写操作系统》--“实模式--保护模式--实模式”       http://write.blog.csdn.net/postedit/7256254

    全面剖析《自己动手写操作系统》--堆栈段的工作方式   http://blog.csdn.net/zgh1988/article/details/7256254

    全面剖析《自己动手写操作系统》---特权级 以及 不同特权级代码段之间的跳转规则     http://blog.csdn.net/zgh1988/article/details/7262901

    全面剖析《自己动手写操作系统》--分页机制     http://blog.csdn.net/zgh1988/article/details/7270748

    全面剖析《自己动手写操作系统》--中断机制    http://blog.csdn.net/zgh1988/article/details/7276259












    调试记录

    简单说一下,直接tree 一下,我手动模拟的

    \------river.txt    (<512byte)
     ------flower.txt (1024byte)
     ------tree.txt     (<512byte)
     ------HOUSE
             --------cat.txt (<512byte)
             --------dog.txt (<512byte)
             #思考一下   ..   or .
             #上一个目录 和当前目录 在这里应该分配目录项吗???
    

    这里只说2个地方:
    一个地方是 flower.txt 这个要用2个簇 所以会涉及到 fat 链表知识,具体来讲就是先找到 对应目录项的 0x1a偏移处的簇信息,看了 03 ,好了可以查看 14 * 512+19 * 512+(03-02)* 512 = 0x4400h ,一定能找到我写的 aaaaaa...内容 ,然后我们还要去 fat[03]处去看一下,下一个簇号(针对数据区从2开始编号的,所以才会有上面的03-02去帮助我们找位置)可以发现 这个位置的12bit 写的是 04 ,说明剩下的内容在 数据区04区,其实和上面是连着的,有时候并不是连续的,这里只是刚好而已。这一部分也要对应一个 fat[04],去看一下,看到了 FFF,说明flower.txt结束了

    另外一个地方是 HOUSE,可以看到去对用的簇是 06 ,但是去 fat[06]看一下发现的是 FFF,但是这个不重要,应该去数据区 06 区,下面的第三幅图,一看便知,自己搞了一套 子目录信息 记录,里面可以看到 子文件 在数据区的储存位置 07 08 什么的,计算一下都可以找到我们在文件所写的内容。

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • 详解FAT12文件系统

    千次阅读 2019-03-16 11:04:23
    1、详解FAT12文件系统 2、实验 1、向虚拟软盘写入文件 2、读取软盘文件系统信息 3、在根目录中查找目标文件 4、读取目标文件到内存 3、小结 1、FAT12文件系统 文件系统 -存储介质上组织文件数据的方法...

    目录

    1、详解FAT12文件系统

    2、实验

    1、向虚拟软盘写入文件

    2、读取软盘文件系统信息

    3、在根目录中查找目标文件

    4、读取目标文件到内存

    3、小结


    1、FAT12文件系统

    文件系统

        - 存储介质上组织文件数据的方法(数据组织的方式

    文件系统示例

        - FAT12是DOS时代的早期文件系统

        - FAT12结构非常简单,一直沿用于软盘

        - FAT12的基本组织单位

               字节(Byte):基本数据单位

               扇区(Sector):磁盘中的最小数据单元

               簇(Cluster):一个或多个扇区

    深入FAT12文件系统

              FAT12文件系统由引导区,FAT表,根目录项表和文件数据区组成。

    FAT12的主引导区

                主引导区存储的比较重要的信息是文件系统的类型,文件系统逻辑扇区总数,

                每簇包含的扇区数等。主引导区最后以0x55AA两个字节作为结束,共占用一个扇区。

    二进制分析:(data.img由后文生成)

    根目录区的大小和位置

                                                           可以看到根目录区起始于第19扇区

    根目录区的目录项

            根目录区由目录项构成,每一个目录项代表根目录中的一个文件索引。

    //创建 RootEntry 结构体类型
    struct RootEntry
    {
        char DIR_Name[11];
        uchar DIR_Attr;
        uchar reserve[10];
        ushort DIR_WrtTime;
        ushort DIR_WrtDate;
        ushort DIR_FstClus;
        uint DIR_FileSize;
    };

    FAT表 - FAT12的数据组织核心

        - FAT1和FAT2是相互备份的关系 ,数据内容完全一致

        - FAT表是一个关系图,记录了文件数据的先后关系

        - 每一个FAT表项占用12比特

        - FAT表的前2个表项规定不使用

     

    FAT表中的先后关系

        - 以簇(扇区)为单位存储文件数据(这里一簇等于一扇区大小)

        - 每个表项(vec[i])表示文件数据的实际位置(簇)

        (1)DIR_FstClus表示文件第0簇(扇区)的位置

        (2)vec[DIR_FstClus]表示文件第1簇(扇区)的位置

        (3)vec[vec[DIR_FstClus]]表示文件第2簇(扇区)的位置...

     

    FAT12数据物理组织示意

    FAT12数据逻辑组织示意


    2、实验

    模拟Boot 查找目标文件(Loader),并读取文件的内容!- 突破Boot512字节限制的解决方案

    解决方案(★)

        - 使用FAT12对软盘(data.img)进行格式化

        - 编写可执行程序(Loader),并将其拷贝到软盘中

        - 主引导程序(Boot)在文件系统中查找Loader

        - 将Loader复制到内存中,并跳转到入口处执行


    1、向虚拟软盘写入文件

    实验:往虚拟软盘中写入文件

        - 原材料:FreeDos,Bochs,bximage

        - 步骤:

                 ① 创建虚拟软盘data.img

                 ② 在FreeDos中进行格式化(FAT12)

                 ③ 将data.img挂载到Linux中,并写入文件

    1、先创建一个虚拟软盘 data.img

    2、修改bochsrc 配置文件,freedos.img 作为启动软盘(A盘),将软盘data.img作为B盘插入

    ###############################################################
    # Configuration file for Bochs
    ###############################################################
    
    # how much memory the emulated machine will have
    megs: 32
    
    # filename of ROM images
    romimage: file=/usr/local/share/bochs/BIOS-bochs-latest
    vgaromimage: file=/usr/share/vgabios/vgabios.bin
    
    # what disk images will be used
    floppya: 1_44=freedos.img, status=inserted
    floppyb: 1_44=data.img, status=inserted
    
    # choose the boot disk.
    boot: floppy
    
    # where do we send log messages?
    # log: bochsout.txt
    
    # disable the mouse
    mouse: enabled=0
    
    # enable key mapping, using US layout as default.
    keyboard_mapping: enabled=1, map=/usr/local/share/bochs/keymaps/x11-pc-us.map

    启动bochs

    3、将data.img挂载到Linux中,并写入loader文件

                                         成功向FAT12格式的软盘写入文件


    2、读取软盘文件系统信息

    实验:读取data.img中的文件系统信息

    步骤:

            创建Fat12Header结构体类型

            使用文件流读取前512字节的内容

            解析并打印相关的信息

    #include <QtCore/QCoreApplication>
    #include <QFile>
    #include <QDataStream>
    #include <QDebug>
    
    #pragma pack(push)
    #pragma pack(1)
    
    struct Fat12Header
    {
        char BS_OEMName[8];    // OEM字符串,必须为8个字符,不足以空格填空
        ushort BPB_BytsPerSec; // 每扇区字节数
        uchar BPB_SecPerClus;  // 每簇占用的扇区数
        ushort BPB_RsvdSecCnt; // Boot占用的扇区数
        uchar BPB_NumFATs;     // FAT表的记录数
        ushort BPB_RootEntCnt; // 最大根目录文件数
        ushort BPB_TotSec16;   // 每个FAT占用扇区数
        uchar BPB_Media;       // 媒体描述符
        ushort BPB_FATSz16;    // 每个FAT占用扇区数
        ushort BPB_SecPerTrk;  // 每个磁道扇区数
        ushort BPB_NumHeads;   // 磁头数
        uint BPB_HiddSec;      // 隐藏扇区数
        uint BPB_TotSec32;     // 如果BPB_TotSec16是0,则在这里记录
        uchar BS_DrvNum;       // 中断13的驱动器号
        uchar BS_Reserved1;    // 未使用
        uchar BS_BootSig;      // 扩展引导标志
        uint BS_VolID;         // 卷序列号
        char BS_VolLab[11];    // 卷标,必须是11个字符,不足以空格填充
        char BS_FileSysType[8];// 文件系统类型,必须是8个字符,不足填充空格
    };
    
    #pragma pack(pop)
    
    void PrintHeader(Fat12Header& rf, QString p)
    {
        QFile file(p);
    
        if( file.open(QIODevice::ReadOnly) )
        {
            QDataStream in(&file);
    
            file.seek(3);
    
            in.readRawData(reinterpret_cast<char*>(&rf), sizeof(rf));
    
            rf.BS_OEMName[7] = 0;
            rf.BS_VolLab[10] = 0;
            rf.BS_FileSysType[7] = 0;
    
            qDebug() << "BS_OEMName: " << rf.BS_OEMName;
            qDebug() << "BPB_BytsPerSec: " << hex << rf.BPB_BytsPerSec;
            qDebug() << "BPB_SecPerClus: " << hex << rf.BPB_SecPerClus;
            qDebug() << "BPB_RsvdSecCnt: " << hex << rf.BPB_RsvdSecCnt;
            qDebug() << "BPB_NumFATs: " << hex << rf.BPB_NumFATs;
            qDebug() << "BPB_RootEntCnt: " << hex << rf.BPB_RootEntCnt;
            qDebug() << "BPB_TotSec16: " << hex << rf.BPB_TotSec16;
            qDebug() << "BPB_Media: " << hex << rf.BPB_Media;
            qDebug() << "BPB_FATSz16: " << hex << rf.BPB_FATSz16;
            qDebug() << "BPB_SecPerTrk: " << hex << rf.BPB_SecPerTrk;
            qDebug() << "BPB_NumHeads: " << hex << rf.BPB_NumHeads;
            qDebug() << "BPB_HiddSec: " << hex << rf.BPB_HiddSec;
            qDebug() << "BPB_TotSec32: " << hex << rf.BPB_TotSec32;
            qDebug() << "BS_DrvNum: " << hex << rf.BS_DrvNum;
            qDebug() << "BS_Reserved1: " << hex << rf.BS_Reserved1;
            qDebug() << "BS_BootSig: " << hex << rf.BS_BootSig;
            qDebug() << "BS_VolID: " << hex << rf.BS_VolID;
            qDebug() << "BS_VolLab: " << rf.BS_VolLab;
            qDebug() << "BS_FileSysType: " << rf.BS_FileSysType;
    
            file.seek(510);
    
            uchar b510 = 0;
            uchar b511 = 0;
    
            in.readRawData(reinterpret_cast<char*>(&b510), sizeof(b510));
            in.readRawData(reinterpret_cast<char*>(&b511), sizeof(b511));
    
            qDebug() << "Byte 510: " << hex << b510;
            qDebug() << "Byte 511: " << hex << b511;
        }
    
        file.close();
    }
    
    int main(int argc, char *argv[])
    {
        QCoreApplication a(argc, argv);
    
        Fat12Header f12;
    
        PrintHeader(f12, "E:\\data.img");
        
        return a.exec();
    }
    

                                      200H = 512

    实验结论

    1.FreeDos中的format程序在格式化软盘的时候自动在第0扇区生成了一个主引导程序,这个主引导程序只打印一个字符串

    2.文件格式和文件系统都是用于定义数据如何存放的规则,只要遵循这个规则就能够成功读写目标数据(参考PE文件结构


    3、在根目录中查找目标文件

    如何在FAT12根目录中查找是否存在目标文件?

    实验:读取FAT12文件系统的根目录信息

    #include <QtCore/QCoreApplication>
    #include <QFile>
    #include <QDataStream>
    #include <QDebug>
    #include <QVector>
    #include <QByteArray>
    #include <stdio.h>
    
    #pragma pack(push)
    #pragma pack(1)
    
    struct Fat12Header
    {
        char BS_OEMName[8];
        ushort BPB_BytsPerSec;
        uchar BPB_SecPerClus;
        ushort BPB_RsvdSecCnt;
        uchar BPB_NumFATs;
        ushort BPB_RootEntCnt;
        ushort BPB_TotSec16;
        uchar BPB_Media;
        ushort BPB_FATSz16;
        ushort BPB_SecPerTrk;
        ushort BPB_NumHeads;
        uint BPB_HiddSec;
        uint BPB_TotSec32;
        uchar BS_DrvNum;
        uchar BS_Reserved1;
        uchar BS_BootSig;
        uint BS_VolID;
        char BS_VolLab[11];
        char BS_FileSysType[8];
    };
    
    struct RootEntry
    {
        char DIR_Name[11];
        uchar DIR_Attr;
        uchar reserve[10];
        ushort DIR_WrtTime;
        ushort DIR_WrtDate;
        ushort DIR_FstClus;
        uint DIR_FileSize;
    };
    
    #pragma pack(pop)
    
    void PrintHeader(Fat12Header& rf, QString p)
    {
        QFile file(p);
    
        if( file.open(QIODevice::ReadOnly) )
        {
            QDataStream in(&file);
    
            file.seek(3);
    
            in.readRawData(reinterpret_cast<char*>(&rf), sizeof(rf));
    
            rf.BS_OEMName[7] = 0;
            rf.BS_VolLab[10] = 0;
            rf.BS_FileSysType[7] = 0;
    
            qDebug() << "BS_OEMName: " << rf.BS_OEMName;
            qDebug() << "BPB_BytsPerSec: " << hex << rf.BPB_BytsPerSec;
            qDebug() << "BPB_SecPerClus: " << hex << rf.BPB_SecPerClus;
            qDebug() << "BPB_RsvdSecCnt: " << hex << rf.BPB_RsvdSecCnt;
            qDebug() << "BPB_NumFATs: " << hex << rf.BPB_NumFATs;
            qDebug() << "BPB_RootEntCnt: " << hex << rf.BPB_RootEntCnt;
            qDebug() << "BPB_TotSec16: " << hex << rf.BPB_TotSec16;
            qDebug() << "BPB_Media: " << hex << rf.BPB_Media;
            qDebug() << "BPB_FATSz16: " << hex << rf.BPB_FATSz16;
            qDebug() << "BPB_SecPerTrk: " << hex << rf.BPB_SecPerTrk;
            qDebug() << "BPB_NumHeads: " << hex << rf.BPB_NumHeads;
            qDebug() << "BPB_HiddSec: " << hex << rf.BPB_HiddSec;
            qDebug() << "BPB_TotSec32: " << hex << rf.BPB_TotSec32;
            qDebug() << "BS_DrvNum: " << hex << rf.BS_DrvNum;
            qDebug() << "BS_Reserved1: " << hex << rf.BS_Reserved1;
            qDebug() << "BS_BootSig: " << hex << rf.BS_BootSig;
            qDebug() << "BS_VolID: " << hex << rf.BS_VolID;
            qDebug() << "BS_VolLab: " << rf.BS_VolLab;
            qDebug() << "BS_FileSysType: " << rf.BS_FileSysType;
    
            file.seek(510);
    
            uchar b510 = 0;
            uchar b511 = 0;
    
            in.readRawData(reinterpret_cast<char*>(&b510), sizeof(b510));
            in.readRawData(reinterpret_cast<char*>(&b511), sizeof(b511));
    
            qDebug() << "Byte 510: " << hex << b510;
            qDebug() << "Byte 511: " << hex << b511;
        }
    
        file.close();
    }
    
    // 返回第i个目录项
    RootEntry FindRootEntry(Fat12Header& rf, QString p, int i)
    {
        RootEntry ret = {{0}};
    
        QFile file(p);
    
        // BPB_RootEntCnt:目录项个数
        if( file.open(QIODevice::ReadOnly) && (0 <= i) && (i < rf.BPB_RootEntCnt) )
        {
            QDataStream in(&file);
    
            // 定位到第i个目录项
            file.seek(19 * rf.BPB_BytsPerSec + i * sizeof(RootEntry));
    
            in.readRawData(reinterpret_cast<char*>(&ret), sizeof(ret));
        }
    
        file.close();
    
        return ret;
    }
    
    
    // 根据文件名查找目录项
    RootEntry FindRootEntry(Fat12Header& rf, QString p, QString fn)
    {
        RootEntry ret = {{0}};
    
        for(int i=0; i<rf.BPB_RootEntCnt; i++)
        {
            RootEntry re = FindRootEntry(rf, p, i);
    
            if( re.DIR_Name[0] != '\0' )
            {
                int d = fn.lastIndexOf(".");
                QString name = QString(re.DIR_Name).trimmed();
    
                if( d >= 0 )
                {
                    QString n = fn.mid(0, d);
                    QString p = fn.mid(d + 1);
    
                    if( name.startsWith(n) && name.endsWith(p) )
                    {
                        ret = re;
                        break;
                    }
                }
                else
                {
                    if( fn == name )
                    {
                        ret = re;
                        break;
                    }
                }
            }
        }
    
        return ret;
    }
    
    void PrintRootEntry(Fat12Header& rf, QString p)
    {
        for(int i=0; i<rf.BPB_RootEntCnt; i++)
        {
            RootEntry re = FindRootEntry(rf, p, i);
    
            if( re.DIR_Name[0] != '\0' )
            {
                qDebug() << i << ":";
                qDebug() << "DIR_Name: " << hex << re.DIR_Name;
                qDebug() << "DIR_Attr: " << hex << re.DIR_Attr;
                qDebug() << "DIR_WrtDate: " << hex << re.DIR_WrtDate;
                qDebug() << "DIR_WrtTime: " << hex << re.DIR_WrtTime;
                qDebug() << "DIR_FstClus: " << hex << re.DIR_FstClus;
                qDebug() << "DIR_FileSize: " << hex << re.DIR_FileSize;
            }
        }
    }
    
    
    int main(int argc, char *argv[])
    {
        QCoreApplication a(argc, argv);
    
        QString img = "E:\\data.img";
    
        Fat12Header f12;
    
        qDebug() << "Read Header:";
    
        PrintHeader(f12, img);
    
        qDebug() << endl;
    
        qDebug() << "Print Root Entry:";
    
        PrintRootEntry(f12, img);
    
        qDebug() << endl;
    
        RootEntry r = FindRootEntry(f12, img, "LOADER.TXT");
    
        qDebug() << "DIR_Name: " << hex << r.DIR_Name;
        qDebug() << "DIR_Attr: " << hex << r.DIR_Attr;
        qDebug() << "DIR_WrtDate: " << hex << r.DIR_WrtDate;
        qDebug() << "DIR_WrtTime: " << hex << r.DIR_WrtTime;
        qDebug() << "DIR_FstClus: " << hex << r.DIR_FstClus;
        qDebug() << "DIR_FileSize: " << hex << r.DIR_FileSize;
    
        return a.exec();
    }
    

     

                对于多出来的目录项不必理会

    文件以簇为单位存储,Fat12文件系统1簇等于1扇区,那么一个文件大于512字节如何存储?


    4、读取目标文件到内存

    实验:加载FAT12中的文件数据

        - 步骤:

        (1)在根目录区查找目标文件对应的项

        (2)获取目标文件的起始簇号和文件大小

        (3)根据FAT表中记录的逻辑先后关系读取数据

    小贴士

        - FAT表中的每个表项只占用12比特(1.5字节

        - FAT表一共记录了BPB_BytsPerSec * 9 * 2 / 3个表项 (9个扇区 * 512 /1.5)

        - 可以使用一个short表示一个表项的值

        - 如果表项值大于等于0xFF8,则说明已经到达最后一个簇

        - 如果表项值等于0xFF7,则说明当前簇已经损坏

     

        - 数据区起始簇(扇区)号为33,地址为0x4200(33 * 512)

        - 数据区起始地址所对应的编号为2(不为0)(有了起始地址,这里可以用偏移地址)

        - 因此,DIR_FstClus对应的地址为:0×4200+(DIR_FstClus-2)*512

    编程实验

    读取指定文件内容

    #include <QtCore/QCoreApplication>
    #include <QFile>
    #include <QDataStream>
    #include <QDebug>
    #include <QVector>
    #include <QByteArray>
    
    #pragma pack(push)
    #pragma pack(1)
    
    struct Fat12Header
    {
        char BS_OEMName[8];
        ushort BPB_BytsPerSec;
        uchar BPB_SecPerClus;
        ushort BPB_RsvdSecCnt;
        uchar BPB_NumFATs;
        ushort BPB_RootEntCnt;
        ushort BPB_TotSec16;
        uchar BPB_Media;
        ushort BPB_FATSz16;
        ushort BPB_SecPerTrk;
        ushort BPB_NumHeads;
        uint BPB_HiddSec;
        uint BPB_TotSec32;
        uchar BS_DrvNum;
        uchar BS_Reserved1;
        uchar BS_BootSig;
        uint BS_VolID;
        char BS_VolLab[11];
        char BS_FileSysType[8];
    };
    
    struct RootEntry
    {
        char DIR_Name[11];
        uchar DIR_Attr;
        uchar reserve[10];
        ushort DIR_WrtTime;
        ushort DIR_WrtDate;
        ushort DIR_FstClus;
        uint DIR_FileSize;
    };
    
    #pragma pack(pop)
    
    void PrintHeader(Fat12Header& rf, QString p)
    {
        QFile file(p);
    
        if( file.open(QIODevice::ReadOnly) )
        {
            QDataStream in(&file);
    
            file.seek(3);
    
            in.readRawData(reinterpret_cast<char*>(&rf), sizeof(rf));
    
            rf.BS_OEMName[7] = 0;
            rf.BS_VolLab[10] = 0;
            rf.BS_FileSysType[7] = 0;
    
            qDebug() << "BS_OEMName: " << rf.BS_OEMName;
            qDebug() << "BPB_BytsPerSec: " << hex << rf.BPB_BytsPerSec;
            qDebug() << "BPB_SecPerClus: " << hex << rf.BPB_SecPerClus;
            qDebug() << "BPB_RsvdSecCnt: " << hex << rf.BPB_RsvdSecCnt;
            qDebug() << "BPB_NumFATs: " << hex << rf.BPB_NumFATs;
            qDebug() << "BPB_RootEntCnt: " << hex << rf.BPB_RootEntCnt;
            qDebug() << "BPB_TotSec16: " << hex << rf.BPB_TotSec16;
            qDebug() << "BPB_Media: " << hex << rf.BPB_Media;
            qDebug() << "BPB_FATSz16: " << hex << rf.BPB_FATSz16;
            qDebug() << "BPB_SecPerTrk: " << hex << rf.BPB_SecPerTrk;
            qDebug() << "BPB_NumHeads: " << hex << rf.BPB_NumHeads;
            qDebug() << "BPB_HiddSec: " << hex << rf.BPB_HiddSec;
            qDebug() << "BPB_TotSec32: " << hex << rf.BPB_TotSec32;
            qDebug() << "BS_DrvNum: " << hex << rf.BS_DrvNum;
            qDebug() << "BS_Reserved1: " << hex << rf.BS_Reserved1;
            qDebug() << "BS_BootSig: " << hex << rf.BS_BootSig;
            qDebug() << "BS_VolID: " << hex << rf.BS_VolID;
            qDebug() << "BS_VolLab: " << rf.BS_VolLab;
            qDebug() << "BS_FileSysType: " << rf.BS_FileSysType;
    
            file.seek(510);
    
            uchar b510 = 0;
            uchar b511 = 0;
    
            in.readRawData(reinterpret_cast<char*>(&b510), sizeof(b510));
            in.readRawData(reinterpret_cast<char*>(&b511), sizeof(b511));
    
            qDebug() << "Byte 510: " << hex << b510;
            qDebug() << "Byte 511: " << hex << b511;
        }
    
        file.close();
    }
    
    RootEntry FindRootEntry(Fat12Header& rf, QString p, int i)
    {
        RootEntry ret = {{0}};
    
        QFile file(p);
    
        if( file.open(QIODevice::ReadOnly) && (0 <= i) && (i < rf.BPB_RootEntCnt) )
        {
            QDataStream in(&file);
    
            file.seek(19 * rf.BPB_BytsPerSec + i * sizeof(RootEntry));
    
            in.readRawData(reinterpret_cast<char*>(&ret), sizeof(ret));
        }
    
        file.close();
    
        return ret;
    }
    
    // 根据文件名找到对应目录项
    RootEntry FindRootEntry(Fat12Header& rf, QString p, QString fn)
    {
        RootEntry ret = {{0}};
    
        for(int i=0; i<rf.BPB_RootEntCnt; i++)
        {
            RootEntry re = FindRootEntry(rf, p, i);
    
            if( re.DIR_Name[0] != '\0' )
            {
                int d = fn.lastIndexOf(".");
                QString name = QString(re.DIR_Name).trimmed();
    
                if( d >= 0 )
                {
                    QString n = fn.mid(0, d);
                    QString p = fn.mid(d + 1);
    
                    if( name.startsWith(n) && name.endsWith(p) )
                    {
                        ret = re;
                        break;
                    }
                }
                else
                {
                    if( fn == name )
                    {
                        ret = re;
                        break;
                    }
                }
            }
        }
    
        return ret;
    }
    
    // 打印存在的目录项各属性
    void PrintRootEntry(Fat12Header& rf, QString p)
    {
        for(int i=0; i<rf.BPB_RootEntCnt; i++)
        {
            RootEntry re = FindRootEntry(rf, p, i);
    
            if( re.DIR_Name[0] != '\0' )
            {
                qDebug() << i << ":";
                qDebug() << "DIR_Name: " << hex << re.DIR_Name;
                qDebug() << "DIR_Attr: " << hex << re.DIR_Attr;
                qDebug() << "DIR_WrtDate: " << hex << re.DIR_WrtDate;
                qDebug() << "DIR_WrtTime: " << hex << re.DIR_WrtTime;
                qDebug() << "DIR_FstClus: " << hex << re.DIR_FstClus;
                qDebug() << "DIR_FileSize: " << hex << re.DIR_FileSize;
            }
        }
    }
    
    // 返回FAT表所有表项
    QVector<ushort> ReadFat(Fat12Header& rf, QString p)
    {
        QFile file(p);
    
        // FAT表大小
        int size = rf.BPB_BytsPerSec * 9;
    
    
        uchar* fat = new uchar[size];
    
    
        QVector<ushort> ret(size * 2 / 3, 0xFFFF); // FAT表项个数和默认值
    
        if( file.open(QIODevice::ReadOnly) )
        {
            QDataStream in(&file);
    
            // 定位到FAT表的起始位置(主引导区后面的扇区)
            file.seek(rf.BPB_BytsPerSec * 1);
    
            in.readRawData(reinterpret_cast<char*>(fat), size);
    
            for(int i=0, j=0; i<size; i+=3, j+=2)
            {
                ret[j] = static_cast<ushort>((fat[i+1] & 0x0F) << 8) | fat[i];
                ret[j+1] = static_cast<ushort>(fat[i+2] << 4) | ((fat[i+1] >> 4) & 0x0F);
            }
        }
    
        file.close();
    
        delete[] fat;
    
        return ret;
    }
    
    // 读取指定文件名的内容
    QByteArray ReadFileContent(Fat12Header& rf, QString p, QString fn)
    {
        QByteArray ret;
        RootEntry re = FindRootEntry(rf, p, fn);
    
        if( re.DIR_Name[0] != '\0' )
        {
            QVector<ushort> vec = ReadFat(rf, p);
            QFile file(p);
    
            if( file.open(QIODevice::ReadOnly) )
            {
                char buf[512] = {0};
                QDataStream in(&file);
                int count = 0;
    
                ret.resize(re.DIR_FileSize);
    
                for(int i=0, j=re.DIR_FstClus; j<0xFF7; i+=512, j=vec[j])
                {
                    file.seek(rf.BPB_BytsPerSec * (33 + j - 2));
    
                    in.readRawData(buf, sizeof(buf));
    
                    for(uint k=0; k<sizeof(buf); k++)
                    {
                        if( count < ret.size() )
                        {
                            ret[i+k] = buf[k];
                            count++;
                        }
                    }
                }
            }
    
            file.close();
        }
    
        return ret;
    }
    
    int main(int argc, char *argv[])
    {
        QCoreApplication a(argc, argv);
        QString img = "E:\\data.img";
        Fat12Header f12;
    
        qDebug() << "Read Header:";
    
        PrintHeader(f12, img);
    
        qDebug() << endl;
    
        qDebug() << "Print Root Entry:";
    
        PrintRootEntry(f12, img);
    
        qDebug() << endl;
    
        qDebug() << "Print File Content:";
    
        QString content = QString(ReadFileContent(f12, img, "LOADER.TXT"));
    
        qDebug() << content;
    
        return a.exec();
    }
    

     

    3、小结

    加载新程序需要依赖于文件系统

    FAT12是一种早期用于软盘的简单文件系统

    FAT12文件系统的重要信息存储于0扇区

    FAT12根目录区记录了文件的起始簇号和长度

    通过查找根目录区能够确定是否存在目标文件

    FAT12文件数据的组织使用了单链表的思想

         - 文件数据离散的分布于存储介质中

         - 文件数据通过FAT项进行关联

     

    展开全文
  • FAT12文件系统介绍

    2020-03-31 21:37:21
    FAT12文件系统是指:在磁盘上规定一种特定的存储格式,这种存储格式高效方便,功能强大,因此形成了统一的规定。 基础知识 具体来说FAT12文件系统为1.44M的软盘设计。1.44M的软盘有2880个扇区,一个扇区有512个字节...
  • FAT12文件系统简介

    2013-01-30 15:10:47
    详细介绍了FAT12文件系统的启动扇区,FAT区和根目录区。尤其对FAT表的解读很独到
  • 参考链接: 《FAT12文件系统》 《全面剖析《自己动手写操作系统》第四章--FAT12文件系统
  • 【文件系统】FAT12文件系统简介

    千次阅读 2015-10-10 20:33:43
    1.FAT12文件系统扇区分配 FAT12文件系统由引导区、FAT表、根目录项表和文件数据区组成,其中引导区程序占用扇区[0],FAT表1占用扇区[1]~[9],FAT表2占用扇区[10]~[18],根目录项表存储于扇区[19]~[32],用户存储的...
  • 实验十三 扫描 FAT12 文件系统管理的软盘 一、*实验目的* l 通过查看 FAT12 文件系统的扫描数据,并调试扫描的过程,理解 FAT12 文件系统管理软盘的方式。 l 通过改进 FAT12 文件系统的扫描功能,加深对 FAT12 文件...
  • 很好的fat12文件系统

    2008-10-12 09:42:38
    fat12文件系统,是了解fat32和其他文件系统的基础.
  • 在上一章节《FAT12文件系统剖析1》中,我们把a.img启动软盘使用FreeDos系统格式化为FAT12文件系统的组织方式,并且向a.img软盘写入两个文件,同时通过FreeDos操作系统也查看了a.img软盘中的文件。之所以这么做,是因...
  • FAT12文件系统之引导扇区结构 文件系统即文件管理系统,是操作系统的重要组成部分之一,如果需要开发底层磁盘驱动或编写自己的操作系统,就必须详细了解文件系统。   FAT12是Microsoft公司DOS操作系统所...
  • FAT12文件系统之引导扇区结构 文件系统即文件管理系统,是操作系统的重要组成部分之一,如果需要开发底层磁盘驱动或编写自己的操作系统,就必须详细了解文件系统。 FAT12是Microsoft公司DOS操作系统所支持的文件...
  • 软磁盘的文件系统FAT12,0~1个扇区是引导扇区,1~9和10~18是两个相同的FAT表,后面是根目录区(每个条目占32字节)和数据区。 其中FAT表每项占12位,代表一个簇,第0,1个FAT项始终不使用。第二项开始表示数据...
  • C语言实现读取FAT12文件系统

    万次阅读 热门讨论 2013-04-07 18:58:26
    假设要读取的FAT12文件系统的映像文件为跟程序在同一目录下的 a.img : /*文件名不支持中文及符号。*/ #include #include #include typedef unsigned char u8; //1字节 typedef unsigned short u16; //2字节 ...
  • FAT12文件系统之数据存储方式详解

    千次阅读 2014-03-21 13:40:43
    FAT12文件系统之数据存储方式详解    FAT12文件系统共分为四部分:引导扇区、FAT文件分配表1和2、根目录区、用户数据区,在前面的文章中详细介绍了FAT12格式的引导扇区数据结构,详情请浏览:  地址是:...
  • Day01_FAT12 文件系统

    2021-05-18 17:13:06
    FAT12是DOS时代就开始使用的文件系统(File System),直到现在仍然在软盘上使用,FAT12软盘的被格式化后为: 有两个磁头,每个磁头80个柱面(磁道),每个柱面有18个扇区,每个扇区512个字节空间。 所以标准软盘的总...
  • FAT12是Microsoft公司DOS操作系统所支持的文件系统之一,此外还有FAT16和FAT32,之后会分别详述这些文件系统。当软盘被标准格式化后,磁盘被格式化为:每磁头80个柱面(磁道),每个柱面有18个扇区,每个扇区有512...
  • FAT12文件系统镜像查看工具linux下的实现(nasm、g++联合编译)简介构思简介附加链接最终实现截图代码Makefile代码my_print.asm代码main.cpp代码 简介 FAT12的这次project实现在linux上用nasm和C++联合编译。 本文...
  • FAT12文件系统镜像查看工具windows下的实现(ls、cat命令)简介构思简介附加链接最终实现截图代码 简介 FAT12的这次project最终是要实现在linux上用nasm和C++联合编译。 本文代码是属于中间产品,是一开始在windows...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,144
精华内容 457
关键字:

fat12文件系统