ReactOS-Freeldr磁盘及文件管理2

ArcOpen的大体流程我们看过了。大致分为这几步

  1. 函数会尝试找到文件所在分区的设备句柄,如果还没有对应的句柄。那么使用DEVICE.FuncTable中的Open函数打开设备,并为这个设备分配句柄。
  1. 打开设备后条用XxxMount识别分区格式,识别成功返回另外的FuncTable,存储到设备的FileData.FileFuncTable域。
  1. 为文件分配一个句柄,在对应的FileData.DeviceId为上面创建设备句柄,FileData.FuncTable为设备的FileData.FileFuncTable。
  1. 最后调用文件的FileData.FuncTable.Open函数打开文件。

挂载分区时做了什么

之前我们忽略了XxxMount函数。现在来读读比较简单的FatMount (freeldr\freeldr\fs\fat.c)。

  1. const DEVVTBL* FatMount(ULONG DeviceId)

  2. {

  3. .**.......**

  4. // 生成一个FAT_VOLUME_INFO结构

  5. Volume = MmHeapAlloc(sizeof(FAT_VOLUME_INFO)**)**;

  6. if (**!Volume)**

  7. return NULL;

  8. RtlZeroMemory(Volume, sizeof(FAT_VOLUME_INFO)**)**;

  9. // 读第一个扇区

  10. Position.HighPart = 0;

  11. Position.LowPart = 0;

  12. ret = ArcSeek(DeviceId, &Position, SeekAbsolute)**;**

  13. if (ret !**= ESUCCESS)**

  14. {

  15. MmHeapFree(Volume)**;**

  16. return NULL;

  17. }

  18. ret = ArcRead(DeviceId, Buffer, sizeof(Buffer), &Count)**;**

  19. if (ret !**= ESUCCESS |**| Count !**= sizeof(Buffer)**)

  20. {

  21. MmHeapFree(Volume)**;**

  22. return NULL;

  23. }

  24. // 判断是否有fat分区标志

  25. if (**!RtlEqualMemory(BootSector-**>FileSystemType, “FAT12 “, 8) &**&**

  26. !RtlEqualMemory(BootSector-**>FileSystemType, “FAT16 “, 8) &**&

  27. !RtlEqualMemory(BootSector32-**>FileSystemType, “FAT32 “, 8) &**&

  28. !RtlEqualMemory(BootSectorX-**>FileSystemType, “FATX”, 4)**)

  29. {

  30. MmHeapFree(Volume)**;**

  31. return NULL;

  32. }

  33. // 获得分区大小等信息

  34. ret = ArcGetFileInformation(DeviceId, &FileInformation)**;**

  35. if (ret !**= ESUCCESS)**

  36. {

  37. MmHeapFree(Volume)**;**

  38. return NULL;

  39. }

  40. SectorCount.HighPart = FileInformation.EndingAddress.HighPart;

  41. SectorCount.LowPart = FileInformation.EndingAddress.LowPart;

  42. SectorCount.QuadPart /**= SECTOR_SIZE;**

  43. Volume-**>DeviceId = DeviceId;**

  44. // 打开分区

  45. if (**!FatOpenVolume(Volume, BootSector, SectorCount.QuadPart)**)

  46. {

  47. MmHeapFree(Volume)**;**

  48. return NULL;

  49. }

  50. // 存储FAT_VOLUME_INFO结构

  51. FatVolumes[DeviceId] = Volume;

  52. // 返回fat文件读写的FuncTable

  53. return &FatFuncTable;

  54. }

函数中的DeviceId是设备的句柄。

生成FAT_VOLUME_INFO结构。这个结构里面存储了FAT分区的基本信息。包括扇区大小,每个簇的扇区数等等。

  1. typedef struct _FAT_VOLUME_INFO

  2. {

  3. ULONG BytesPerSector; / Number of bytes per sector /

  4. ULONG SectorsPerCluster; / Number of sectors per cluster /

  5. ULONG FatSectorStart; / Starting sector of 1st FAT table /

  6. ULONG ActiveFatSectorStart; / Starting sector of active FAT table /

  7. ULONG NumberOfFats; / Number of FAT tables /

  8. ULONG SectorsPerFat; / Sectors per FAT table /

  9. ULONG RootDirSectorStart; / Starting sector of the root directory (non-fat32) /

  10. ULONG RootDirSectors; / Number of sectors of the root directory (non-fat32) /

  11. ULONG RootDirStartCluster; / Starting cluster number of the root directory (fat32 only) /

  12. ULONG DataSectorStart; / Starting sector of the data area /

  13. ULONG FatType; / FAT12, FAT16, FAT32, FATX16 or FATX32 /

  14. ULONG DeviceId;

  15. } FAT_VOLUME_INFO;

读取第一个山区,判断是否有fat标志。如果没有直接返回,挂载失败。之后使用ArcGetFileInformation获得分区大小。ArcGetFileInformation里面调用了FileData.FuncTable.GetFileInformation。因为当前DeviceId是设备句柄,所以他实际调用的是DiskGetFileInformation(freeldr\freeldr\arch\i386\hardware.c)。这个函数很简单,通过FileInformation返回分区开始和结束的地址,这里就不列出了。

这里的代码用FileInformation.EndingAddress / SECTOR_SIZE计算出了该分区的扇区数SectorCount。这里应该BUG。因为EndingAddress是分区结束地址,真的扇区数应该是 (分区开始地址 - EndingAddress ) / SECTOR_SIZE。好在SectorCount只是判断fat分区的一个依据,而且一般C盘计算出的SectorCount误差不会很大,影响不大。

最后执行FatOpenVolume真正执行分区的挂载、初始化。初始化结束后将生成的Volume放到fat.c维护的全局数组FatVolumes里,之后对fat分区进行操作(读写)时,通过设备的DeviceId就可以找到对应的FAT_VOLUME_INFO结构。

最后函数返回FatFuncTable函数数组

  1. const DEVVTBL FatFuncTable =

  2. {

  3. FatClose,

  4. FatGetFileInformation,

  5. FatOpen,

  6. FatRead,

  7. FatSeek,

  8. L”fastfat”,

  9. }**;**

用户可以通过这些函数就读写改fat分区啦。

那么FatOpenVolume都干了什么呢。

这个函数简单来说就是根据分区内容填写了Volume结构,已经算是一个分区的具体实现细节了,和整体架构无关,不多说了。这个函数在freeldr\freeldr\fs\fat.c中。

打开文件时做了什么

上一篇文章中还有一个地方没说,就是打开设备并创建完文件的句柄后,ArcOpen调用了文件对应的FileData.FuncTable.Open。对于fat分区而言这个函数是FatOpen(freeldr\freeldr\fs\fat.c). 这个函数也是和分区结构有关的了,有一点比较重要就是函数最后调用了FsSetDeviceSpecific把一个和文件相关的内部结构与文件句柄相关联。以后使用FatRead对文件句柄进行读操作时直接就可以获得这个结构啦。

  1. LONG FatOpen(CHAR* Path, OPENMODE OpenMode, ULONG* FileId)

  2. {

  3. .**.....**

  4. // 根据文件的FileId获得文件所在的设备句柄FileData.DeviceId, 从而获得FatMount时生成的Volume结构。

  5. DeviceId = FsGetDeviceId(*FileId)**;**

  6. FatVolume = FatVolumes[DeviceId]**;**

  7. // 从DeviceId设备中读取并查询fat表,判断path表示的文件是否存在

  8. RtlZeroMemory(**&TempFileInfo, sizeof(TempFileInfo));**

  9. ret = FatLookupFile(FatVolume, Path, DeviceId, &TempFileInfo)**;**

  10. if (ret !**= ESUCCESS)**

  11. return ENOENT;

  12. // 判断是否是目录

  13. IsDirectory = (TempFileInfo.Attributes & ATTR_DIRECTORY) !**= 0;**

  14. if (IsDirectory &**& OpenMode !**= OpenDirectory)

  15. return EISDIR;

  16. else if (**!IsDirectory &**& OpenMode !**= OpenReadOnly)**

  17. return ENOTDIR;

  18. // 生成FAT_FILE_INFO结构,里面存放了文件的信息(开始的扇区等)

  19. FileHandle = MmHeapAlloc(sizeof(FAT_FILE_INFO)**)**;

  20. if (**!FileHandle)**

  21. return ENOMEM;

  22. RtlCopyMemory(FileHandle, &TempFileInfo, sizeof(FAT_FILE_INFO)**)**;

  23. FileHandle-**>Volume = FatVolume;**

  24. // 把这个结构和文件对应的FileData.Specific关联。之后进行FatRead等操作时可以直接获得这个结构了

  25. FsSetDeviceSpecific(*FileId, FileHandle)**;**

  26. return ESUCCESS;

  27. }

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)中。

1
2
3
4
5
6
7
8
9
VOID BootMain(LPSTR CmdLine)
{
......
MachInit(CmdLine);
FsInit();
......
RunLoader();
}

BootMain会对硬件(MachInit)和文件系统(FsInit)进行检测和初始化。所有准备工作进行完毕后就会调用RunLoader进行系统的加载工作。
Fs初始化和DEVICE、FILEDATA结构
下面看一下文件系统的初始化 FsInit(boot\freeldr\freeldr\fs\fs.c)

1
2
3
4
5
6
7
8
9
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];

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
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结构的链表头

1
2
3
4
5
6
7
8
9
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)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
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中

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
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)

1
2
3
4
5
6
7
8
9
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号分区实际表示硬盘本身。
之后

1
2
3
4
5
6
7
8
9
10
11
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

1
2
3
4
5
6
7
8
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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
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。
文件打开分为两步,第一步是开个文件所在的设备、创建设备的句柄。第二部才是打开文件本身。
这里是第一步打开设备的代码。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
......
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需要调用进行打开和文件系统的识别。我们仔细读读。

1
2
3
4
5
6
7
/* 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数组中找到空闲项,数组的索引即将成为设备句柄。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
/* 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在打开设备时都做了什么。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
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指针 :)

1
2
3
4
5
6
7
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函数,希望你还记得 :)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
/* 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

1
2
3
4
5
6
for (i = 0; i < MAX_FDS; i++)
if (!FileData[i].FuncTable)
break;
if (i == MAX_FDS)
return EMFILE;

跳过文件名开始的 “\” 字符

1
2
3
if (*FileName == '\\')
FileName++;

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

1
2
3
4
5
6
7
8
9
10
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函数。以后再说。 :)