目录

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文件系统

转载自 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、引导扇区

调试记录

简单说一下，直接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 什么的，计算一下都可以找到我们在文件所写的内容。

概述

文件系统是操作系统用于明确存储设备或分区上的文件的方法和数据结构。FAT（File Allocation Table，文件配置表）是Microsoft发明的文件系统。初期的FAT就是现在所称的FAT12，后来还有FAT16，FAT32和NTFS，FAT也被Linux所支持。
FAT12包含以下四个部分：引导扇区，FAT表，根目录区和数据区。下面分别介绍。

引导扇区

引导扇区包含引导程序和FAT12文件系统的整个组成结构信息，这些信息描述了FAT文件系统对磁盘扇区的管理情况。结构如下图所示。

第一个字段是一个跳转指令：

jmp short Label_Start
nop

因为BS_jmpBoot后面不是可执行程序，所以需要跳过这一部分。

FAT表

FAT表一般有两个，FAT1是活动FAT，FAT2是备份FAT，FAT2存在的意义就是修复FAT1。所以这里只介绍FAT1。
首先需要明确簇的概念。在磁盘中最小的单位是簇，它由几个扇区组成。也就是说，就算你放一个1字节的文件，也需要占据一个簇。
注意此处所说的簇是数据区的组织方式。从前面的表中可以看出：
BPB_BytePerSec（每扇区字节数）为512
BPB_SecPerClus（每簇扇区数）为1
因此在FAT12中每个簇就是512个字节。
另一方面，如果文件比较大，需要占据多个簇时，文件不一定在连续的簇内，这时就需要一种方法寻找到完整的文件，这个功能由FAT表完成。
FAT表中，表项位宽和FAT类型有关，FAT12对应的表项位宽就是12。
表项0和1的值是无关紧要的。其他表项每个对应数据区的一个簇，而表里保存的数据是下一个簇的簇号，这样，就形成了一个链表一样的结构了。具体的，表项保存的数据有以下的取值：

• 000h：可用簇
• 002h-FEFh：已用簇，标识下一个簇的簇号
• FF0h-FF6h：保留簇
• FF7h：坏簇
• FF8h-FFFh：文件最后一个簇

根目录区和数据区

根目录的开始扇区号是19，它由最多BPB_RootEntCnt个目录项。这些目录项可能存储了指向文件和目录的信息。目录项是一个32B的结构体。它的结构如下：

数据区不仅可以保存目录项信息，也可以保存文件内的数据。对于树状的目录结构，树的层级结构可以通过目录的目录项简历起来，从根目录开始，经过目录项的逐层嵌套，形成了树状结构。

参考文献：
1.《一个64位操作系统的设计与实现》
2.FAT12文件系统介绍
3.fat文件系统