ReactOS-Freeldr磁盘及文件管理

 

Freeldr提供了对fat12、fat32、fatx、ntfs等文件系统的只读功能。这部分代码主要集中在boot/freeldr/freeldr/fs/fs.c文件中。

首先计算机加电后会把mbr读取到物理内存的0x7c00位置，mbr搜索活动分区并加载活动分区根目录下的Freeldr.sys文件。加载后跳入Freeldr入口start。Freeldr进行32为初始化后跳入主初始化函数BootMain(boot/freeldr/freeldr/Freeldr.c)中。

VOID BootMain(LPSTR CmdLine)
{

     ......

     MachInit(CmdLine);

     FsInit();
     ......
     RunLoader();
}

BootMain会对硬件(MachInit)和文件系统(FsInit)进行检测和初始化。所有准备工作进行完毕后就会调用RunLoader进行系统的加载工作。

Fs初始化和DEVICE、FILEDATA结构

下面看一下文件系统的初始化 FsInit(boot/freeldr/freeldr/fs/fs.c)

VOID FsInit(VOID)
{
    ULONG i;
    RtlZeroMemory(FileData, sizeof(FileData));
    for (i = 0; i < MAX_FDS; i++)
        FileData[i].DeviceId = (ULONG)-1;

    InitializeListHead(&DeviceListHead);
}

FsInit初始化FileData数组。和一个和磁盘分区相关的链表DeviceListHead。

首先fs.c维护了一个MAX_FDS(60)大小的数组 static FILEDATA FileData[MAX_FDS];

typedef struct tagDEVVTBL
{
  ARC_CLOSE Close;
  ARC_GET_FILE_INFORMATION GetFileInformation;
  ARC_OPEN Open;
  ARC_READ Read;
  ARC_SEEK Seek;
  LPCWSTR ServiceName;
} DEVVTBL;

typedef struct tagFILEDATA
{
    ULONG DeviceId;                        // 文件所在磁盘的磁盘文件句柄, 同样也是FileData的索引
    ULONG ReferenceCount;             // 引用计数
    const DEVVTBL* FuncTable;       // 对文件进行读写的指针
    const DEVVTBL* FileFuncTable;  // 对文件进行读写的函数数组
    VOID* Specific;                         // 文件系统自定义指针
} FILEDATA;

每一个成功打开的文件会返回一个文件句柄，这个句柄实际上就是FileData数组的索引。所以每个打开的文件都有一个对应的FileData。这个结构就类似windows中的FILE_OBJECT

FileData中DeviceId是文件所在磁盘的句柄。这个句柄同样也是FileData数组的索引，通过这个句柄可以找到"磁盘文件"，对"磁盘文件"的读写就是直接对相应的磁盘或磁盘分区的读写。类似Windows中直接对磁盘分区进行CreateFile返回的句柄。 "磁盘文件"的DeviceId没有意义。

ReferenceCount是该文件的引用计数。

FuncTable这是一个函数数组指针，里面存放了对文件进行读写、SEEK等操作的函数指针。

FileFuncTable只对"磁盘文件"有意义。当Freeldr确定了磁盘文件对应的分区的分区格式后，会把与分区格式相关的函数指针数组放到这个字段里面。如Fat12分区"磁盘文件"的FileFuncTable字段存放的就是FatFuncTable指针。

Specific存放于文件有关的结构。磁盘文件就是DISKCONTEXT指针，fat12下的文件就是FAT_FILE_INFO指针 等等。

之后是DeviceListHead，这是DEVICE结构的链表头

typedef struct tagDEVICE
{
    LIST_ENTRY ListEntry;                // 链表节点
    const DEVVTBL* FuncTable;       // 操作该分区的函数表
    CHAR* Prefix;                           // 分区对应的ArcName
    ULONG DeviceId;                       // FILEDATA中该分区对应的句柄
    ULONG ReferenceCount;            // 引用计数
} DEVICE;

用户电脑中的每一个硬盘和硬盘中的每一分区都对应了一个DEVICE结构。

FuncTable里面存放了对该分区进行读写等操作的指针，对于硬盘而言这个数组就是DiskVtbl。

Prefix是该分区或硬盘的ArcName。(如multi(0)disk(0)rdisk(0)partition(0))。 Freeldr中的文件路径都是Arc形式的路径。而且0号分区代表整个硬盘，真正的分区从1号开始。如multi(0)disk(0)rdisk(0)partition(0)便代表第0块硬盘本身。multi(0)disk(0)rdisk(0)partition(1)代表第0块硬盘的第0个分区。

通过DeviceId字段可以找到该DEVICE的文件句柄。这个字段和FILEDATA相互配合，使系统可以遍历DEVICE结构快速找到某个分区的文件句柄。

DEVICE(磁盘及分区)的检测

上面说到Freeldr操作的路径都是存储在DEVICE结构中的ArcPath。那么这些DEVICE是怎么来的呢？

首先我们看一下DEVICE的注册函数，FsRegisterDevice(boot/freeldr/freeldr/fs/fs.c)

VOID FsRegisterDevice(CHAR* Prefix, const DEVVTBL* FuncTable)
{
    DEVICE* pNewEntry;
    ULONG dwLength;

    dwLength = strlen(Prefix) + 1;
    pNewEntry = MmHeapAlloc(sizeof(DEVICE) + dwLength);
    if (!pNewEntry)
        return;
    pNewEntry->FuncTable = FuncTable;
    pNewEntry->ReferenceCount = 0;
    pNewEntry->Prefix = (CHAR*)(pNewEntry + 1);
    memcpy(pNewEntry->Prefix, Prefix, dwLength);

    InsertHeadList(&DeviceListHead, &pNewEntry->ListEntry);
}

这么函数非常简单。Prefix就是Arc路径，FuncTable是操作这个分区（磁盘）对应的函数数组。FsRegisterDevice生成了一个DEVICE结构，把ArcName和FuncTable复制进去。之后连入了DeviceListHead链表。

那么又是谁调用的FsRegisterDevice呢？是DetectBiosDisks(boot/freeldr/freeldr/arch/i386/hardware.c)函数。虽然这一部分已经不属于FS的范畴，还是在这里简单讲一下便于理解。这里我略去了不必要的代码。

DetectBiosDisks的调用顺序是  RunLoader -> MachHwDetect ( PcHwDetect )-> DetectISABios  -> DetectBiosDisks

static VOID
DetectBiosDisks(PCONFIGURATION_COMPONENT_DATA BusKey)
{
    BOOLEAN BootDriveReported = FALSE;
    ULONG i;
      ULONG DiskCount = GetDiskCount(BusKey);
    CHAR BootPath[512];

    ...... 

     for (i = 0; i < DiskCount; i++)

    {
        ULONG Size;
        CHAR Identifier[20];

        ......

        if (BootDrive == 0x80 + i)
            BootDriveReported = TRUE;

        /* Get disk values */
          GetHarddiskIdentifier(Identifier, 0x80 + i);
    }

}

首先使用GetDiskCount从Freeldr注册表的System键中读取硬盘总数。System键的初始化在DetectSystem(freeldr/freeldr/arch/i386/hardware.c)中，一会儿再看。

于是进入一个for循环，为每个硬盘调用GetHarddiskIdentifier函数。在BIOS中硬盘号是从0x80开始的，所以GetHarddiskIdentifier的硬盘号加了0x80。

GetHarddiskIdentifier的作用是为制定硬盘生成一个唯一的ID，并通过Identifier参数返回。但这个函数名起得并不好，因为生成ID其实只是这个函数的功能之一。另外的一大功能是检测硬盘，并且为硬盘本身和硬盘分区调用FsRegisterDevice函数进行注册。通过这个注册后硬盘才能真正被文件系统识别。

freeldr/freeldr/arch/i386/hardware.c中

static VOID
GetHarddiskIdentifier(PCHAR Identifier,
                ULONG DriveNumber)
{
  PMASTER_BOOT_RECORD Mbr;
  ULONG *Buffer;
  ULONG i;
  ULONG Checksum;
  ULONG Signature;
  CHAR ArcName[256];
  PARTITION_TABLE_ENTRY PartitionTableEntry;

  /* Read the MBR */
  if (!MachDiskReadLogicalSectors(DriveNumber, 0ULL, 1, (PVOID)DISKREADBUFFER))
    {
      DPRINTM(DPRINT_HWDETECT, "Reading MBR failed/n");
      return;
    }

  Buffer = (ULONG*)DISKREADBUFFER;
  Mbr = (PMASTER_BOOT_RECORD)DISKREADBUFFER;

  Signature =  Mbr->Signature;
  DPRINTM(DPRINT_HWDETECT, "Signature: %x/n", Signature);

  /* Calculate the MBR checksum */
  Checksum = 0;
  for (i = 0; i < 128; i++)
    {
      Checksum += Buffer[i];
    }
  Checksum = ~Checksum + 1;
  DPRINTM(DPRINT_HWDETECT, "Checksum: %x/n", Checksum);

  /* Fill out the ARC disk block */
  reactos_arc_disk_info[reactos_disk_count].Signature = Signature;
  reactos_arc_disk_info[reactos_disk_count].CheckSum = Checksum;
  sprintf(ArcName, "multi(0)disk(0)rdisk(%lu)", reactos_disk_count);
  strcpy(reactos_arc_strings[reactos_disk_count], ArcName);
  reactos_arc_disk_info[reactos_disk_count].ArcName =
      reactos_arc_strings[reactos_disk_count];
  reactos_disk_count++;

  sprintf(ArcName, "multi(0)disk(0)rdisk(%lu)partition(0)", DriveNumber - 0x80);
  FsRegisterDevice(ArcName, &DiskVtbl);

  /* Add partitions */
  i = 1;
  DiskReportError(FALSE);
  while (DiskGetPartitionEntry(DriveNumber, i, &PartitionTableEntry))
  {
    if (PartitionTableEntry.SystemIndicator != PARTITION_ENTRY_UNUSED)
    {
      sprintf(ArcName, "multi(0)disk(0)rdisk(%lu)partition(%lu)", DriveNumber - 0x80, i);
      FsRegisterDevice(ArcName, &DiskVtbl);
    }
    i++;
  }
  DiskReportError(TRUE);

  /* Convert checksum and signature to identifier string */
  Identifier[0] = Hex[(Checksum >> 28) & 0x0F];
  Identifier[1] = Hex[(Checksum >> 24) & 0x0F];
  Identifier[2] = Hex[(Checksum >> 20) & 0x0F];
  Identifier[3] = Hex[(Checksum >> 16) & 0x0F];
  Identifier[4] = Hex[(Checksum >> 12) & 0x0F];
  Identifier[5] = Hex[(Checksum >> 8) & 0x0F];
  Identifier[6] = Hex[(Checksum >> 4) & 0x0F];
  Identifier[7] = Hex[Checksum & 0x0F];
  Identifier[8] = '-';
  Identifier[9] = Hex[(Signature >> 28) & 0x0F];
  Identifier[10] = Hex[(Signature >> 24) & 0x0F];
  Identifier[11] = Hex[(Signature >> 20) & 0x0F];
  Identifier[12] = Hex[(Signature >> 16) & 0x0F];
  Identifier[13] = Hex[(Signature >> 12) & 0x0F];
  Identifier[14] = Hex[(Signature >> 8) & 0x0F];
  Identifier[15] = Hex[(Signature >> 4) & 0x0F];
  Identifier[16] = Hex[Signature & 0x0F];
  Identifier[17] = '-';
  Identifier[18] = 'A';
  Identifier[19] = 0;
}

函数首先使用MachDiskReadLogicalSectors读取指定硬盘的MBR。对于PC机而言MachDiskReadLogicalSectors使用int 13h中断实现对硬盘的读操作。里面包括了16、32位代码的互转，和本节内容无关，以后再做说明。

MBR结构为。详细信息可以参考( http://en.wikipedia.org/wiki/Master_boot_record)

typedef struct _MASTER_BOOT_RECORD
{
     UCHAR               MasterBootRecordCodeAndData[0x1b8];     /* 0x000 */
     ULONG               Signature;                    /* 0x1B8 */
     USHORT               Reserved;                    /* 0x1BC */
     PARTITION_TABLE_ENTRY     PartitionTable[4];               /* 0x1BE */
     USHORT               MasterBootRecordMagic;               /* 0x1FE */
} MASTER_BOOT_RECORD, *PMASTER_BOOT_RECORD;

GetHarddiskIdentifier在获取了Signature、计算了Checksum后 。

sprintf(ArcName, "multi(0)disk(0)rdisk(%lu)partition(0)", DriveNumber - 0x80);

FsRegisterDevice(ArcName, &DiskVtbl);

生成对应硬盘的ArcName，使用FsRegisterDevice注册这块硬盘，这个函数我们已经看过。注意这里Partition为0，所以0号分区实际表示硬盘本身。

之后

  i = 1;
  while (DiskGetPartitionEntry(DriveNumber, i, &PartitionTableEntry))
  {
    if (PartitionTableEntry.SystemIndicator != PARTITION_ENTRY_UNUSED)
    {
      sprintf(ArcName, "multi(0)disk(0)rdisk(%lu)partition(%lu)", DriveNumber - 0x80, i);
      FsRegisterDevice(ArcName, &DiskVtbl);
    }
    i++;
  }

DiskGetParititionEntry将会解析DriveNumber对应磁盘的分区表，填充第i个分区的信息到PartitionTableEntry结构。如果分区存在则 使用FsRegisterDevice注册分区。

使用刚才计算的CheckSum和Signature组合一个ID返回给调用者。其实这个ID没有被使用过。。。

最后看一下调用FsRegisterDevice时的第二个参数DiskVtbl

static const DEVVTBL DiskVtbl = {
    DiskClose,
    DiskGetFileInformation,
    DiskOpen,
    DiskRead,
    DiskSeek,
}; 这里面包含了对磁盘扇区读写的全部函数。我们之后再介绍。

至此硬盘的及硬盘分区的注册完成。

执行完DetectBiosDisks后，DeviceListHead里面就存放了当前计算机所有的磁盘和分区对应的DEVICE结构。

文件系统的识别和文件的打开

这时Fs模块已经知道的硬盘数量，分区信息。下面来看看一个文件的打开流程。

首先，Freeldr使用的是Arc路径，IDE硬盘以multi(0)disk(0)rdisk(n)开头，文件也是以Arc路径表示的。打开文件的函数在Freeldr/Freeldr/fs/fs.c中。这函数比较长，我们分段阅读。

Freeldr/Freeldr/fs/fs.c

LONG ArcOpen(CHAR* Path, OPENMODE OpenMode, ULONG* FileId)
{
    ......

    *FileId = MAX_FDS;

    /* Search last ')', which delimits device and path */
    FileName = strrchr(Path, ')');
    if (!FileName)
        return EINVAL;
    FileName++;

    /* Count number of "()", which needs to be replaced by "(0)" */
    dwCount = 0;
    for (p = Path; p != FileName; p++)
        if (*p == '(' && *(p + 1) == ')')
            dwCount++;

    /* Duplicate device name, and replace "()" by "(0)" (if required) */
    dwLength = FileName - Path + dwCount;
    if (dwCount != 0)
    {
        DeviceName = MmHeapAlloc(FileName - Path + dwCount);
        if (!DeviceName)
            return ENOMEM;
        for (p = Path, q = DeviceName; p != FileName; p++)
        {
            *q++ = *p;
            if (*p == '(' && *(p + 1) == ')')
                *q++ = '0';
        }
    }
    else
        DeviceName = Path;

    ......

这个函数有三个参数Path是文件名的Arc路径，如multi(0)disk(0)rdisk(0)partition(1)Freeldr.sys就表示C盘中的Freeldr.sys文件。

OpenMode是打开模式(OpenReadOnly、OpenReadWrite等)。

如果打开成功，文件句柄将通过FileId参数返回。

首先这一部分代码分理出Arc磁盘路径中的"()"替换成"(0)"并存入DeviceName中，如multi()disk()rdisk()partition(1)Freeldr.sys处理后，DeviceName将指向multi(0)disk(0)rdisk(0)partition(1)。注意这个DeviceName是不以NULL结尾的。。。这是个很蛋疼的设计。

FileName会指向Arc路径中的文件名部分，上面的例子将是Freeldr.sys。

文件打开分为两步，第一步是开个文件所在的设备、创建设备的句柄。第二部才是打开文件本身。

这里是第一步打开设备的代码。

   ......

   pEntry = DeviceListHead.Flink;

   while (pEntry != &DeviceListHead)
    {
        pDevice = CONTAINING_RECORD(pEntry, DEVICE, ListEntry);
        if (strncmp(pDevice->Prefix, DeviceName, dwLength) == 0)
        {
            /* OK, device found. It is already opened? */
            if (pDevice->ReferenceCount == 0)
            {
                /* Search some room for the device */
                for (DeviceId = 0; DeviceId < MAX_FDS; DeviceId++)
                    if (!FileData[DeviceId].FuncTable)
                        break;
                if (DeviceId == MAX_FDS)
                    return EMFILE;
                /* Try to open the device */
                FileData[DeviceId].FuncTable = pDevice->FuncTable;
                ret = pDevice->FuncTable->Open(pDevice->Prefix, DeviceOpenMode, &DeviceId);
                if (ret != ESUCCESS)
                {
                    FileData[DeviceId].FuncTable = NULL;
                    return ret;
                }
                else if (!*FileName)
                {
                    /* Done, caller wanted to open the raw device */
                    *FileId = DeviceId;
                    pDevice->ReferenceCount++;
                    return ESUCCESS;
                }

                /* Try to detect the file system */
                 FileData[DeviceId].FileFuncTable = FatMount(DeviceId);
                if (!FileData[DeviceId].FileFuncTable)
                    FileData[DeviceId].FileFuncTable = NtfsMount(DeviceId);
                if (!FileData[DeviceId].FileFuncTable)
                    FileData[DeviceId].FileFuncTable = Ext2Mount(DeviceId);

                if (!FileData[DeviceId].FileFuncTable)
                {
                    /* Error, unable to detect file system */
                    pDevice->FuncTable->Close(DeviceId);
                    FileData[DeviceId].FuncTable = NULL;
                    return ENODEV;
                }

                pDevice->DeviceId = DeviceId;
            }
            else
            {
                DeviceId = pDevice->DeviceId;
            }
            pDevice->ReferenceCount++;
            break;
        }
        pEntry = pEntry->Flink;
    }

    if (pEntry == &DeviceListHead)

        return ENODEV;

一个循环，遍历DEVICE链表，找到DEVICE->Prefix (磁盘、分区的Arc路径，上一节说过)和刚刚分解出来的DeviceName相等的节点。如果没有则函数直接失败。

找到DEVICE节点后判断DEVICE->ReferenceCount是否为0。这个代表该DEVICE被打开的次数，如果ReferenceCount不为0，说明DEVICE已经被打开。那个直接从Device->DeviceId中获得设备的文件句柄。可以看出无论打开一个设备多少次，只会有ReferenceCount的变化，而句柄都是相同的。所以如果设备打开两次，SEEK时会相互影响。读写之前最好重新调用SEEK函数。

当DEVICE->ReferenceCount为0时是Freeldr需要调用进行打开和文件系统的识别。我们仔细读读。

                /* Search some room for the device */
                for (DeviceId = 0; DeviceId < MAX_FDS; DeviceId++)
                    if (!FileData[DeviceId].FuncTable)
                        break;
                if (DeviceId == MAX_FDS)
                    return EMFILE;

首先在FileData数组中找到空闲项，数组的索引即将成为设备句柄。

                /* Try to open the device */
                FileData[DeviceId].FuncTable = pDevice->FuncTable;
                ret = pDevice->FuncTable->Open(pDevice->Prefix, DeviceOpenMode, &DeviceId);
                if (ret != ESUCCESS)
                {
                    FileData[DeviceId].FuncTable = NULL;
                    return ret;
                }
                else if (!*FileName)
                {
                    /* Done, caller wanted to open the raw device */
                    *FileId = DeviceId;
                    pDevice->ReferenceCount++;
                    return ESUCCESS;
                }

之后把DEVICE中存储的设别操作函数数组FuncTable赋值给对应FileData中的FuncTable。之后对该句柄的读写操作将直接传递给FileData.FuncTable中的函数。

调用FuncTable->Open打开设备。上面我们看过这个函数实际是freeldr/freeldr/arch/i386/hardware.c中的DiskOpen。

打开成功后，如果FileName（需要打开的文件名）为空，说明这次请求只打开设备，于是直接返回设备的句柄。

如果不为空，则下面开始识别分区格式，打开文件的操作。

在继续读ArcOpen函数前我们先看看DiskOpen在打开设备时都做了什么。

ArcOpen -> DiskOpen (freeldr/freeldr/arch/i386/hardware.c)

static LONG DiskOpen(CHAR* Path, OPENMODE OpenMode, ULONG* FileId)
{
    ......
    if (!DissectArcPath(Path, FileName, &DriveNumber, &DrivePartition))
        return EINVAL;

    if (DrivePartition == 0xff)
    {
        /* This is a CD-ROM device */
        SectorSize = 2048;
    }
    else
    {
        SectorSize = 512;
    }

    if (DrivePartition != 0xff && DrivePartition != 0)
    {
        if (!DiskGetPartitionEntry(DriveNumber, DrivePartition, &PartitionTableEntry))
            return EINVAL;
        SectorOffset = PartitionTableEntry.SectorCountBeforePartition;
        SectorCount = PartitionTableEntry.PartitionSectorCount;
    }

    Context = MmHeapAlloc(sizeof(DISKCONTEXT));
    if (!Context)
        return ENOMEM;
    Context->DriveNumber = DriveNumber;
    Context->SectorSize = SectorSize;
    Context->SectorOffset = SectorOffset;
    Context->SectorCount = SectorCount;
    Context->SectorNumber = 0;
    FsSetDeviceSpecific(*FileId, Context);

    return ESUCCESS;
}

这个函数非常简单，使用DissectArcPath根据设备的Arc路径分解出文件名FileName、BIOS驱动器号DriveNumber、和分区号DrivePartition（第0个分区的编号是1，0代表整个硬盘）

之后确定扇区大小，分区开始的扇区号、分区扇区数等信息，存入DISKCONTEXT结构。使用FsSetDeviceSpecific和FildId相关联。

还记得FILEDATA的结构么？FsSetDeviceSpecific就是填充里面的Specific指针 ：）

VOID FsSetDeviceSpecific(ULONG FileId, VOID* Specific)
{
    if (FileId >= MAX_FDS || !FileData[FileId].FuncTable)
        return;
    FileData[FileId].Specific = Specific;
}

实际上DiskOpen的作用就是获得该设备（分区）的基本信息——BIOS驱动器号、扇区大小、开始扇区号、扇区数量和当前读写指针（SectorNumber）。生成DISKCONTENT结构使用FsSetDeviceSpecific和FileID绑定。

现在我们回到ArcOpen函数，希望你还记得 ：）

                /* Try to detect the file system */
                 FileData[DeviceId].FileFuncTable = FatMount(DeviceId);
                if (!FileData[DeviceId].FileFuncTable)
                    FileData[DeviceId].FileFuncTable = NtfsMount(DeviceId);
                if (!FileData[DeviceId].FileFuncTable)
                    FileData[DeviceId].FileFuncTable = Ext2Mount(DeviceId);

                if (!FileData[DeviceId].FileFuncTable)
                {
                    /* Error, unable to detect file system */
                    pDevice->FuncTable->Close(DeviceId);
                    FileData[DeviceId].FuncTable = NULL;
                    return ENODEV;
                }
                pDevice->DeviceId = DeviceId;

现在FileData[DeviceId]已经代表刚刚打开的设备了，开始挂载分区。啥叫挂载分区，就是让文件系统提供个接口，能让我们操作分区里面的文件。而这个接口就是个DEVVTBL指针，和直接操作硬盘的接口一样，只不过这次这个可以操作文件了。如果分区识别成功，XxxMount函数将会返回另外一个DEVVTBL指针数组，这个指针赋值给设备对象的FileFuncTable成员。使用这个指针数组就可以在文件级别操作了。比如打开freeldr.sys文件就可以调用FileData[DeviceId].FileFuncTable->open函数。FileFuncTable和FuncTable是不同的哦！ ：）

注意FileFuncTable其实是不直接使用的，这个指针的作用是为之后打开的文件对应的FileData.FileTable赋值。于是操作文件和操作磁盘都是用对应的FileData.FileTable，实现形式上的统一。而且这种架构还可以轻易的实现将一个文件虚拟成为一个分区，只要为文件对象调用XxxMount并且给FileFuncTable域赋值就可以了，非常易于扩展。Freeldr并没有实现这种功能，文件的FileData.FileFuncTable没有使用～

下面我们就来看看第二步，打开文件

首先为文件找一个空闲的FileData

    for (i = 0; i < MAX_FDS; i++)
        if (!FileData[i].FuncTable)
            break;
    if (i == MAX_FDS)
        return EMFILE;

跳过文件名开始的 "/" 字符

    if (*FileName == '//')
        FileName++;

我们前面说的，为FileData.FuncTable赋值。FileData.DeviceId是文件所在分区的句柄。FuncTable内部函数将通过这个句柄调用读写分区内容，为用户提供文件的读写接口。

    FileData[i].FuncTable = FileData[DeviceId].FileFuncTable;
    FileData[i].DeviceId = DeviceId;
    *FileId = i;
    ret = FileData[i].FuncTable->Open(FileName, OpenMode, FileId);
    if (ret != ESUCCESS)
    {
        FileData[i].FuncTable = NULL;
        *FileId = MAX_FDS;
    }

至此打开文件的操作结束。这里略去了XxxMount和文件的Open函数。以后再说。 ：）