标签：
很久以前就对操作系统很好奇，用了这么多年Windows，对他的运作机理也不是很清楚，所以一直想自己动手写一个，研究一下操作系统究竟是怎么实现的。后来在网上也找到过一些教程（比如：《自己动手写操作系统》），大都是先要用汇编写活动分区的第一个扇区（MBR）。13年4月左右我也曾经跟着教程尝试过，用汇编调用BIOS中断读扇区、加载Bootstrap。不得不说用汇编很容易出错，可读性也不好，所以这次我就想能不能完全不用汇编写操作系统。
经过一番搜索，我找到了一个叫UEFI的东西，下面是它的简单介绍：
统一可扩展固件接口（Unified Extensible Firmware Interface, UEFI）是一种个人电脑系统规格，用来定义操作系统与系统固件之间的软件界面，作为BIOS的替代方案。可扩展固件接口负责加电自检（POST）、连系操作系统以及提供连接操作系统与硬件的接口。
——摘自维基百科
简而言之，(U)EFI就是一个用来替代传统BIOS的规范，OS启动阶段我们可以不再和麻烦的BIOS打交道了。而且因为UEFI完全使用C风格的编程接口，意味着我们可以只用C、C++来引导我们的OS。开发UEFI可以使用EDK，然而进过一番比较，intel的EFI Toolkit虽然已经不再更新，但使用简单，对于我们开发Bootloader来说已经足够了，因此我选择了使用EFI Toolkit来开发EFI程序。
1. 编译 EFI Toolkit
下载好EFI Toolkit以后，我们把他解压到方便找到的目录里：
由于我是开发运行于intel 64 架构的EFI程序，所以进入build\em64t目录，打开sdk.env并修改配置：
将选中部分修改为VC AMD64编译器的目录（"XXX\Microsoft Visual Studio 14.0\VC\bin\amd64"，记得要加双引号）。
然后打开VS 2015（其他版本也可以）x64本地工具命令提示符，切换到EFI Toolkit目录，执行build em64t，然后执行nmake。
一段时间后EFI Toolkit就编译完成了。
2.编写一个Bootloader
BootLoader是系统加电启运行的第一段软件代码，回忆一下PC的体系结构我们可以知道，PC机中的引导加载程序由BIOS（其本质就是一段固件程序）和位于硬盘MBR中的引导程序一起组成。BIOS在完成硬件检测和资源分配后，将硬盘MBR中的引导程序读到系统的RAM中，然后将控制权交给引导程序。引导程序的主要运行任务就是将内核映象从硬盘上读到RAM中 然后跳转到内核的入口点去运行，也即开始启动操作系统。
——摘自互动百科
2.1配置项目
EFI程序有很多种类型，我们写的Bootloader属于EFI Application中的OSLoader。EFI在启动OS时会寻找启动盘EFI\Boot目录下的bootx64.efi文件，而这个文件实际上是一个PE32+格式的应用程序，同时VC也提供了编译这种程序的支持，所以我们可以直接使用VS来编写Bootloader。创建项目以后为了方便管理我们可以设置输出目录和输出文件名。
这样在部署OS的时候我们只需要将整个输出目录复制到启动分区上。
另外还要设置链接选项，将子系统设置为 EFI Application（重要）：
另外要设置以下编译选项：
设置以下链接选项：
同时设置VC++目录，添加以下目录到Include目录中：
添加一下目录到Lib目录中：
一大堆东西。。终于弄好了之后就可以编写我们的代码了。
2.2编写代码
EFI程序的入口定义如下：
EFI_STATUS __cdecl efi_main(EFI_HANDLE ImageHandle, EFI_SYSTEM_TABLE *SystemTable)
其中efi_main的名字随便起，记得在链接选项中设置入口点就好。另外有两个参数：
2.2.1 加载内核文件
Bootloader要做的最重要事之一就是加载内核，而第一步我们需要从硬盘或者其他存储设备读取内核文件到内存，EFI给我们提供了很方便的手段来进行这个过程。
我们假定内核文件和Bootloader在同一个分区，我们可以获取这个分区的句柄。
在入口函数加载 efilib
InitializeLib(ImageHandle, SystemTable);
获取Bootloader所在的卷的句柄：
void KernelFile::LoadKernelFile()
{
EFI_LOADED_IMAGE* loadedImage;
EFI_FILE_IO_INTERFACE* volume;
// 获取 Loader 所在的卷
BS->HandleProtocol(imageHandle, &LoadedImageProtocol, (void**)&loadedImage);
BS->HandleProtocol(loadedImage->DeviceHandle, &FileSystemProtocol, (void**)&volume);
所谓Protocol就类似与接口的概念，一个句柄就相当于一个类的实例，我们利用BootServices提供的HandleProtocol函数可以获取这个类的一个接口——第一个参数是句柄，第二个参数是Protocol的GUID，第三个参数是Protocol的指针。看到这种用法不知道有没有人想起COM ←_←。
接下来是LoadKernelFile方法的剩余部分：
EFI_FILE_HANDLE rootFS, fileHandle; volume->OpenVolume(volume, &rootFS); // 读取文件 EXIT_IF_NOT_SUCCESS(rootFS->Open(rootFS, &fileHandle, (CHAR16*)KernelFilePath, EFI_FILE_MODE_READ, 0), imageHandle, L"Cannot Open Tomato Kernel File.\r\n"); UINT8* kernelBuffer; EXIT_IF_NOT_SUCCESS(BS->AllocatePool(EfiLoaderData, KernelPoolSize, (void**)&kernelBuffer), imageHandle, L"Cannot Allocate Tomato Kernel Buffer.\r\n"); EXIT_IF_NOT_SUCCESS(fileHandle->Read(fileHandle, &KernelPoolSize, kernelBuffer), imageHandle, L"Cannot Read Tomato Kernel File.\r\n"); fileHandle->Close(fileHandle); kernelFileBuffer = kernelBuffer; }
这段代码中我们从上面获取的分区接口得到一个根目录的接口，又利用这个根目录接口得到我们内核文件的接口，其中第三个参数是文件的路径：
static const wchar_t KernelFilePath[] = LR"(Tomato\System\OSKernel.exe)";
之后我们利用BootServices提供的内存管理功能分配一个KernelPoolSize大小的内存，然后利用刚刚获取的内核文件接口将文件内容读取到内存中。
2.2.2 解析内核文件
内核文件已经加载到内存了，由于内核文件实际上是一个PE格式的应用程序，我们需要像Windows一样解析他，并将需要的内容读取出来放到内存该放的地方。
PE文件的头部在 pe.h 中有定义。
首先我们验证PE文件的有效性：
bool KernelFile::ValidateKernel()
{
IMAGE_DOS_HEADER* dosHeader = (IMAGE_DOS_HEADER*)kernelFileBuffer;
if (dosHeader->e_magic != IMAGE_DOS_SIGNATURE)
return FALSE;
IMAGE_NT_HEADERS* ntHeaders = (IMAGE_NT_HEADERS*)(kernelFileBuffer + dosHeader->e_lfanew);
if (ntHeaders->Signature != IMAGE_NT_SIGNATURE)
return FALSE;
return TRUE;
}
具体算法是验证DOS头的MZ标志和PE头的PE00标志。
如果文件是有效的PE映像，我们接下来需要解析包含的每一个节，并复制到另一块内存里：
void Bootloader::PrepareKernel(KernelFile& file)
{
if (file.ValidateKernel())
{
auto kernelImageBase = file.GetKernelFileBuffer();
IMAGE_DOS_HEADER* dosHeader = (IMAGE_DOS_HEADER*)kernelImageBase;
IMAGE_NT_HEADERS* ntHeaders = (IMAGE_NT_HEADERS*)(kernelImageBase + dosHeader->e_lfanew);
sectionStart = (IMAGE_SECTION_HEADER*)(((UINT8*)ntHeaders) + sizeof(IMAGE_NT_HEADERS)
- sizeof(IMAGE_OPTIONAL_HEADER) + ntHeaders->FileHeader.SizeOfOptionalHeader);
sectionCount = ntHeaders->FileHeader.NumberOfSections;
UINTN sectionAlign = ntHeaders->OptionalHeader.SectionAlignment;
UINTN fileAlign = ntHeaders->OptionalHeader.FileAlignment;
UINTN memAllocPages = GetAllSectionsMemoryPages(sectionStart, sectionCount);
EXIT_IF_NOT_SUCCESS(BS->AllocatePages(AllocateAnyPages, KernelPoolType, memAllocPages,
&kernelMemBuffer), imageHandle, L"Cannot allocate Kernel Memory.\r\n");
上面这段函数中我们通过GetAllSectionsMemoryPages函数计算得到PE文件中所有节的总页数，然后利用BootServices的AllocatePages函数分配内存页，至于为什么要按页的大小对齐，是因为我们之后做内存分页的要求。
IMAGE_SECTION_HEADER* section = sectionStart;
UINT8* memBuffer = (UINT8*)kernelMemBuffer;
for (UINTN i = 0; i < sectionCount; i++, section++)
{
BOOLEAN dataInFile = section->PointerToRawData != 0;
UINT8* sectionData = kernelImageBase + section->PointerToRawData;
UINTN memAllocSize = AlignSize(section->SizeOfRawData, EFI_PAGE_SIZE);
if (memAllocSize)
{
if (dataInFile)
CopyMem(memBuffer, sectionData, section->SizeOfRawData);
memBuffer += memAllocSize;
}
}
接下来我们将每一节的内容复制到刚才分配的内存中去。
2.2.3 分页
我们到目前为止一直使用的是内存的物理地址，这样虽然简单但有一个问题：如果内核的基址很大，超出了物理内存范围那么我们将没有办法执行内核。为了解决这个问题我们需要引入虚拟地址。关于分页intel的手册上有详尽的说明，在这里我是用IA32e分页模式，这种模式工作在64位模式下，我们可以使用48位虚拟地址，管理256TB的内存（物理或虚拟）。
然而如果对整个地址空间进行分页，内存会被极大地浪费，甚至会装不下，因此IA32e分页模式可以使用4级页表。这样我们就可以针对其中的一段地址空间将页表保存在物理内存中，其他地址空间我们可以将其页表的Present位设为0，以表示不在物理内存中，大大减少内存的占用。
我的内核基址是0x140000000，也就是5GB的位置。
void MappingKernelAddress(EFI_HANDLE ImageHandle, EFI_PHYSICAL_ADDRESS kernelMemBuffer,
IMAGE_SECTION_HEADER* section, UINTN sectionCount, PDPTable& pdpTable)
{
enum : uint64_t {
KernelPML4EIndex = KernelImageBase / PML4EntryManageSize,
KernelPML4ERest = KernelImageBase % PML4EntryManageSize,
KernelPDPEIndex = KernelPML4ERest / PDPEntryManageSize,
KernelPDPERest = KernelPML4ERest % PDPEntryManageSize,
KernelPDEIndex = KernelPDPERest / PDEntryManageSize,
KernelPDERest = KernelPDPERest % PDEntryManageSize,
KernelPTEIndex = KernelPDERest / PTEntryManageSize,
KernelPTERest = KernelPDERest % PTEntryManageSize
};
auto& kernelPageDir = *AllocatePageDirectory(ImageHandle);
auto& kernelPageDirRef = pdpTable[KernelPDPEIndex];
kernelPageDirRef.Present = TRUE;
kernelPageDirRef.ReadWrite = TRUE;
kernelPageDirRef.SetPTEntryAddress(kernelPageDir);
我们先分配一个Page Directory（页目录，映射 1 GB），将其Present设为TRUE，表示在物理内存中，并将其挂在到上一级Page Directory Pointer Table （映射 512 GB）上。然后按内核的每一个节的虚拟地址填写对应的页表和页表项，并映射到物理地址：
uint8_t* physicalAddr = (uint8_t*)kernelMemBuffer;
for (size_t i = 0; i < sectionCount; i++)
{
auto& curSection = section[i];
if (curSection.SizeOfRawData)
{
auto dataSize = AlignSize(curSection.SizeOfRawData, EFI_PAGE_SIZE);
// 起始 Page Table Index
auto curPTIndex = curSection.VirtualAddress / PDEntryManageSize;
auto restToMap = dataSize;
uint8_t* startVirtualAddress = (uint8_t*)(KernelPDPEIndex * PDPEntryManageSize +
curPTIndex * PDEntryManageSize);
for (; restToMap; curPTIndex++)
{
auto& pageTableRef = kernelPageDir[curPTIndex];
// 如果未分配则分配页表
if (!pageTableRef.Present)
{
pageTableRef.SetPageTableAddress(*AllocatePageTable(ImageHandle));
pageTableRef.Present = TRUE;
pageTableRef.ReadWrite = TRUE;
}
PageTable& pageTable = pageTableRef.GetPageTableAddress();
auto curPEIndex = (curSection.VirtualAddress % PDEntryManageSize)
/ PTEntryManageSize;
auto curVirtualAddress = startVirtualAddress + curPEIndex * PTEntryManageSize;
for (size_t j = curPEIndex; j < __crt_countof(pageTable); j++)
{
auto& ptEntry = pageTable[j];
ptEntry.SetPhysicalAddress(physicalAddr);
ptEntry.Present = TRUE;
ptEntry.ReadWrite = TRUE;
physicalAddr += EFI_PAGE_SIZE;
curVirtualAddress += PTEntryManageSize;
restToMap -= PTEntryManageSize;
if (!restToMap)break;
}
}
}
}
}
接下来用类似的方法映射内存的前 1 GB（EFI的Runtime Services会用到），之后启用分页：
// 启用分页
void Bootloader::EnablePaging()
{
// 分配 PML4Table
auto& pml4Table = *AllocatePML4Table(imageHandle);
// 分配 PDPTable
auto& pdpTable = *AllocatePDPTable(imageHandle);
// 映射前 1 GB
MappingLow1GB(imageHandle, pdpTable);
// 映射内核所在的 1 GB
MappingKernelAddress(imageHandle, kernelMemBuffer, sectionStart, sectionCount, pdpTable);
// 映射前 512 GB
auto& pdpTableRef = pml4Table[0];
pdpTableRef.SetPDPTableAddress(pdpTable);
pdpTableRef.Present = TRUE;
pdpTableRef.ReadWrite = TRUE;
EnableIA32ePaging(pml4Table);
}
启用IA32e分页需要设置一系列寄存器：
inline void EnableIA32ePaging(const PML4Table& pml4Table)
{
const PML4Entry* addr = pml4Table;
uint64_t cr3 = __readcr3();
cr3 &= ~CR3_PML4_MASK;
cr3 |= ((uint64_t)addr) & CR3_PML4_MASK;
// 将页表存入 cr3
__writecr3(cr3);
// 启用分页
tagCR0 cr0 = __readcr0();
cr0.PG = 1;
__writecr0(cr0.value);
// 启用 PAE
tagCR4 cr4 = __readcr4();
cr4.PAE = 1;
__writecr4(cr4.value);
// 启用 IA32e 分页
tagMSR_IA32_EFER ia32Efer = __readmsr(MSR_IA32_EFER);
ia32Efer.LME = 1;
__writemsr(MSR_IA32_EFER, ia32Efer.value);
}
至此分页完成。
2.2.4 配置 EFI Runtime Services
由于我们进入了分页模式，使用了虚拟地址，我们需要通知EFI更改他内部的指针，以适应这个变化。不过由于我做的前1GB分页是1:1分页，虚拟地址=物理地址，所以只需要简单的赋值：
void Bootloader::PrepareVirtualMemoryMapping()
{
UINTN entries, mapKey, descriptorSize;
UINT32 descriptorVersion;
EFI_MEMORY_DESCRIPTOR* descriptor = LibMemoryMap(&entries, &mapKey, &descriptorSize, &descriptorVersion);
BS->ExitBootServices(imageHandle, mapKey);
EFI_MEMORY_DESCRIPTOR* memoryMapEntry = descriptor;
for (UINTN i = 0; i < entries; i++)
{
if (memoryMapEntry->Attribute & EFI_MEMORY_RUNTIME)
{
memoryMapEntry->VirtualStart = memoryMapEntry->PhysicalStart;
}
memoryMapEntry = NextMemoryDescriptor(memoryMapEntry, descriptorSize);
}
EFI_STATUS status = RT->SetVirtualAddressMap(entries * descriptorSize, descriptorSize,
EFI_MEMORY_DESCRIPTOR_VERSION, descriptor);
if (EFI_ERROR(status))
RT->ResetSystem(EfiResetWarm, EFI_LOAD_ERROR, 62, (CHAR16*)L"Setting Memory mapping failed.");
params.MemoryDescriptor = descriptor;
params.MemoryDescriptorSize = descriptorSize;
params.MemoryDescriptorEntryCount = entries;
}
先利用LibMemoryMap获取当前的内存分布图，并针对属性带有EFI_MEMORY_RUNTIME的每一项设置他的VirtualStart（本例中=物理地址），最后调用Runtime Services的SetVirtualAddressMap函数通知EFI更改指针。
2.2.5 启动内核
内核加载了，分页也做了，EFI也配置过了，终于我们要进入新的世界了（←_←
从内核文件中读出入口点，调用，over~
void Bootloader::RunKernel(KernelEntryPoint entryPoint)
{
entryPoint(params);
}
第一次写博客，可能代码堆得多了点，今后会努力改进。另外由于EFI开发的资料很少，我也是第一次接触这个，肯定有很多错误理解的地方，还请各位园友不吝赐教。
最近对开发操作系统很有兴趣，在学习过程中也希望和大家深入交流，谢谢 :)
C++编写操作系统（1）：基于 EFI 的 Bootloader
标签：
原文地址：http://www.cnblogs.com/sunnycase/p/write-os-in-cpp-1-efi-based-bootloader.html
