[操作系统原理与实现]Multiboot与GRUB

最新推荐文章于 2024-10-08 17:04:41 发布
最新推荐文章于 2024-10-08 17:04:41 发布
阅读量3.3k 收藏 19
点赞数 7
分类专栏： 操作系统原理与实现 文章标签： multiboot grub
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cloudblaze/article/details/106430819
版权

最后更新于2020年6月7日。

Multiboot与GRUB

一、Multiboot2规范 v2.0

  • 本规范是汉化版本，最后更新于2020年6月1日。由于能力有限，翻译可能存在错误。现附上规范原文The Multiboot2 Specification version 2.0
    ，如果错误之处，请指正。
  • 本翻译先通过金山词霸在线翻译，然后对机器翻译的结果进行调整。译者尽可能从原始的角度翻译原规范，有一部分内容是从理解的角度翻译的，如果翻译有误，请遵照原文。

1、介绍

本章粗略地描述了关于Multiboot2规范的一些信息。 请注意，这不是规范本身的一部分。

1.1、背景内容

当前设计的每个操作系统可能都有其自己的引导程序。在机器上安装一个新的操作系统通常需要安装一套全新的引导机制，这些引导机制在安装过程中及引导过程都有一个相互完全不同用户界面。在一台机器上安装有多个操作系统，如果用典型的链式引导机制让这些操作系统可靠地共存，这是不现实的。对于一个特定的操作系统来说，可选的引导加载器不是很多，甚至根本没有可选的解决方案。如果不能按照您的要求随心所欲地使用操作系统随附的引导加载器，或者引导加载器无法在您的机器上工作，这个时候您会感到非常困惑甚至无所适从。

因为版权问题，我们可能无法在私有操作系统中解决这个问题。但对于自由操作系统社区的一些人来说，他们可以通过各种方式聚在一起为流行的自由操作系统解决此类问题不是很困难。这就是制定这个规范的目的所在。基本上，该规范指定了引导加载程序与操作系统之间的接口，这样任何符合规范的引导加载程序都应该能够加载任何符合的操作系统。本规范没有指定引导加载程序应该如何工作，只是规定了它们必须如何与正在加载的操作系统一起使用该接口。

1.2、目标架构

此规范主要针对PC，因为它们是最常见的，同时在其上运行着大量的操作系统和引导程序。 但是，如果需要在其他体系结构上引导内核，而在该架构上还没有合适的引导规范，则可以将本规范中特定于x86平台的细节去掉并做出适当的调整，即可将本规范适应于特定的体系架构。

1.3、目标系统

本规范主要针对的是自由的32为操作系统。这些操作系统不经过大幅度调整，就可以很容易地进行修改以支持规范。本规范主要是为Linux、Free BSD、Net BSD、Mach以及VSTa等操作系统或内核设计，同时也希望其他新兴的自由操作系统从一开始就采用它，从而能使用现有的引导加载器。很高兴能有私有操作系统供应商最终也采用这个规范，但这可能不太现实。

1.4、启动方式

应该编写可以兼容的引导加载程序，这样操作系统镜像就可以从诸如软盘、硬盘，甚至网络等不同来源被加载。

基于磁盘的引导加载器可以使用各种技术来查找磁盘上的操作系统映像和引导模块。例如，可以通过特定的文件系统加载系统（BSD/Mach 引导加载器）；也可以使用预先规定好的磁盘块列表加载系统（LILO）；还可以从特定的启动分区加载系统（OS/2）；甚至，还可以另一个操作系统中加载系统（例如，可以从DOS中加载VSTa引导代码）；类似地，基于网络的引导加载器可以使用各种不同的网络硬件和协议。

同时，我们都希望创建的引导加载器可以支持多种不同的加载机制，这样可以提高其可移植性、健壮性和用户友好性。

1.5、在引导阶段配置操作系统

处于某种原因，用户往往希望在加载启动时能够动态地向操作系统提供一些配置信息。虽然本规范不应该规定引导加载程序如何获取此配置信息，但它应该为此提供一个标准化的途径。

1.6、如何更容易地开发操作系统

操作系统映像应该是很容易被生成的。理想情况下，操作系统映像应该是一个普通的32位可执行文件，这个可执行文件可以是操作系统通常使用的任何一种文件格式。操作系统映像应该是可以被nm工具或反汇编的，看起来就像是一个正常可执行文件。不应该要求使用专门的工具以一种特殊的文件格式来创建系统映像。因为，引导加载程序所使用的内存空间通常可在引导结束后再次被使用，而通常系统映像中的所有代码都必须永远保持在内存中。所以，将一些工作从操作系统转移到引导加载程序是合适的。如果要将操作系统数据加载到1MB以上的内存空间，则必须提前将CPU工作模式从16位实模式切换到32位保护模式。操作系统不应该承担这一过程的责任，因为这一部分的代码通常是在引导加载程序中的。如果在设计操作系统时不遵守这种约定，那么将会导致创建操作系统映像会变得更加困难。

不幸的是，即便是在自由的类Unix的PC操作系统中，也有各种各样形式不同的可执行文件格式。通常，不同的操作系统都会采用不同的可执行文件格式。虽然，大多数自由操作系统都在使用一种基于a.out的变体格式，但好在其中的一些正在向ELF可执行文件格式迁移。不需要解释所有已存在的不同类型的可执行文件格式来加载操作系统映像，这是一件对于引导加载器来说很期望的事情。否则，引导加载器将不再是通用型的了，从而变成只针对于某些特定操作系统的“专属加载器”了。

为了解决这个问题，本规范采用了一种折衷的解决方案。这个解决方案要求符合Multiboot2规范的操作系统映像必须包含一个特殊的Multiboot2头（查看3.1节 [操作系统镜像格式]）。操作系统映像包含Multiboot2头后，引导加载程序在加载映像时不再需要理解各种不同的a.out的变体或其他可执行格式。这个特殊的结构体（Multiboot2头）不需要出现在可执行文件最开始的地方。这样，内核映像就可以同时符合特定的可执行文件格式和Multiboot2规范了。

1.7、启动模块

许多现代操作系统内核，诸如Mach和VSTa中的微内核，它们自身并不包含足够的机制来使系统独立运行。相反，它们需要在系统启动时加载额外的软件模块，以便能够访问设备、安装文件系统等。虽然这些附加的模块可以与内核本身一起嵌入到磁盘映像中，但是，如果引导加载程序能够首先独立地加载这些附加模块，然后操作系统映像在控制序列的操控下分割磁盘映像并逐一加载，这样会让操作系统和用户都感觉更加灵活，更加节省空间，也更加方便。

因此，本规范为引导加载程序提供了一种标准方法，这种方法使得引导加载程序向操作系统告知了这些辅助引导模块如何被加载。虽然引导程序不是必须要加载这些辅助引导模块，但是对于那些特定的操作系统这是必须的。因为没有这些辅助引导模块，那些操作系统将无法完成引导启动。

2、措辞与术语

【在将措辞与术语的解释进行翻译的过程中，会不可避免地引进一些误差或错误，而这些措辞属于比较号理解。为了表述的严谨性，这一节只列出措辞术语的名词，相关解释请查阅本规范原文】

  • must
  • should
  • may
  • boot loader
  • OS image, kernel
  • boot module
  • Multiboot2-compliant
  • u8
  • u16
  • u32
  • u64

3、Multiboot2规范的确切定义

引导加载器与操作系统映像之间的接口主要有三个方面：

  1. 引导加载程序所看到的操作系统映像的格式。
  2. 引导加载程序启动操作系统时机器的状态。
  3. 引导加载程序传递给操作系统的信息格式。

3.1、操作系统映像格式

操作系统映像可以是某一特定操作系统采用的标准的普通的32可执行文件，但它也可以被链接在一个非默认的加载地址，这样可以避免加载在PC顶部的I/O地址空间或其他保留的地址空间。并且，磁盘映像文件不允许使用共享库或其他有趣的特性功能。

OS映像自身使用某一种格式的文件头，但除此之外，它还必须包含一个称为Multiboot2的头部。Multiboot2头必须包含在OS映像的前32768字节内，而且不许是64位对齐，也就是4字节对齐。通常情况下，应该将Multiboot头放在尽可能前的地方。它通常是嵌入到可执行文件头部之后代码段的起始部位。

3.1.1、Multiboot2头的定义

以下为Multiboot2头的格式：

OffsetTypeField NameNote
0u32magicrequired
4u32architecturerequired
8u32header_lengthrequired
12u32checksumrequired
16-XXtagsrequired
  • 字段magic、architecture、header_length和checksum在3.1.2 [Multiboot2头中的字段] 中定义；
  • 字段tags在3.1.3 [标签tag结构体] 中定义；
  • 所有的字段的存储顺序依据当前系统是大端还是小端。
3.1.2、Multiboot2头中的字段
3.1.2.1、 magic

字段magic是指示Multiboot头的魔数，该字段必须为16进制值0xE85250D6。

3.1.2.2、 architecture

字段architecture指定CPU指令集体系结构。由于magic字段不是回文，Multiboot2规范具体实现可以据此来确定当前平台的大小端情况。architecture字段的值为0时，则表示是i386的32位（受保护）模式；如果是4则表示是32位MIPS。

3.1.2.3、 header_length

字段header_length以字节为单位指定Multiboot2头的长度，其中包括magic字段。

3.1.2.4、 checksum

字段checksum是一个32位无符号值，使得magic、architecture、header_length、checksum这四个字段的值的和必须是32位无符号0。

3.1.3、标签tag结构体

标签tag是结构体缓冲区，这个结构体缓冲区在必要的时候进行填充，以便每个标签tag会从8字节对齐的地址处开始。所有的标签tag排列组成一个标签列表，作为终止标签的最后一个标签，其类型为0、大小为8。每一个标签tag结构体都具有以下结构：

大小名称
u16type
u16flags
u32size
  • type分为两部分。type类型的低字节部分包含了标签tag的类型。
  • size字段包含了该标签tag中所有字段的大小总和。
  • flags字段的位0指示了该标签tag是可选的。如果flags字段的位0被置位，那么当缺少相关支持时，引导加载程序会忽略此标签tag。
3.1.4、Multiboot2 information request
大小名称
u16type = 1
u16flags
u32size
u32mbi_tag_types

字段mbi_tag_types是一个32位无符号整型数组，每一个元素表示一个请求信息。

对于这个标签tag，如果设置字段flags中可选标志位位0，则引导加载程序必须支持这个请求的标签tag，并且如果图形模式可用，则必须为操作系统提供相关的图形模式信息。如果引导加载程序不支持所请求的标记的含义，则必须以错误失败结束。然而，如果引导加载程序支持给定的标记，但为其所传递的信息不可用，则引导加载程序就不会在Multiboot2信息结构中提供所请求的标记，并且将控制权交给被加载的系统映像。

注：以上说明意味着不能保证任何类型的mbi_tag_types标签实际上都是存在的。例如，在视频系统中，即便您请求标签类型为8的标签tag，同时引导加载程序也支持它，但Multiboot2信息结构中也不会出现对应的标签tag。

3.1.5、Multiboot2头中的地址标签tag
大小名称
u16type = 2
u16flags
u32size
u32header_addr
u32load_addr
u32load_end_addr
u32bss_end_addr

该标签tag中的所有的地址字段均时物理地址。每个字段的含义如下：

3.1.5.1、header_addr

该字段包含将操作系统映像加载到内存后，Multiboot2在内存中的物理内存地址。该字段用于同步操作系统内核与物理内存地址之间的映射。

3.1.5.2、load_addr

该字段包含Multiboot2头所在代码段的起始物理地址。在操作系统内核映像中，引导加载器确定文本段相对于Multiboot2头的相对偏移是通过计算得到的：header_addr - load_addr。这样就可以正确地确定映像中文本段的起始位置。load_addr字段必须小于或等于header_addr，这样所得到的相对偏移数值为正。另外，也可以赋值为特殊值-1，表明必须从磁盘映像文件的起始处开始加载。

3.1.5.3、load_end_addr

该字段包含数据段末尾的物理地址。load_end_addr - load_addr表示有多少字节的数据需要被加载进内存。这也意味着文本段和数据段在操作系统映像中必须是连续的。现有的a.out可执行文件格式是否和此要求的。对于特殊值0，表示代码段和数据段占用了整个操作系统磁盘映像文件。

3.1.5.4、bss_end_addr
3.1.6、Multiboot2头中的项目地址Tag
3.1.7、Multiboot2头中的EFI i386项目地址Tag
3.1.8、Multiboot2头中的EFI amd64项目地址Tag
3.1.9、标志Tag
3.1.10、帧缓冲Tag
3.1.11、模块对齐Tag
3.1.12、EFI启动服务Tag
3.1.13、重定位头Tag

3.2、MIPS机器状态

3.3、I386机器状态

3.4、具有可启动服务的EFI i386机器状态

3.5、具有可启动服务的EFI amd64机器状态

3.6、启动信息格式

3.6.1、启动信息格式

引导加载程序将控制权交给操作系统后，EBX寄存器包含Multiboot2信息数据结构的物理地址，引导加载程序通过该结构将重要信息传递给操作系统。操作系统可以选择或忽略Multiboot2信息数据结构中的任何部分。引导加载程序传递的所有信息仅仅只能作为查询使用。

Multiboot2信息结构及其相关子结构可以由引导加载程序放置在内存的任何地方。当然，这些数据不会被放置在内核加载以及引导模块保留的内存区域中。当引导加载程序将控制权交给操作系统后，操作系统在使用完这些信息之前，必须确保这块区域不能被覆盖。

3.6.2、基本标签tag结构体

启动引导信息是由固定部分和一系列标签组成。这些标签的起始地址是以8字节对齐的。固定部分如下：

大小名称
u32total_size
u32reserved
  • 字段total_size包含引导信息的大小总和，这其中也包括了该字段本身以及以字节为单位的终止标记。
  • 字段reserved总是被设定为0，操作系统应该总是忽略这个字段。

每一个标签tag都以以下字段开始：

大小名称
u32type
u32size
  • 字段type包含标签tag其余部分内容的标识符，也就是标签tag的类型。
  • 字段size包含标签tag的大小，其中包括头字段，但不包括填充部分。

这些标签必须相互跟随（原文在此处的描述是：“Tags follow one another padded when necessary in order for each tag to start at 8-bytes aligned address.”），也就是说在内存空间中紧密排列，以便每个标签都是从8字节对齐的地址开始。这些标签组成了一个标签列表，这个列表以type为0并且size为8的标签结束。

3.6.3、基本内存信息
大小名称
u32type = 4
u32size = 16
u32mem_lower
u32mem_upper

字段mem_lower和mem_upper指示低端内存和高端内存的大小，其值是以KB为单位。低端内存从是从地址0处开始的，高端内存是从1MB地址处开始的。低端内存的最大值可能是640KB。高端内存的值是存储器最大存储值减去1MB的数值。但是，引导加载程序不能保证这些值的有效性。

在一些EFI平台上，如果启用了EFI启动服务并且可以加载映像，引导加载器可能不会支持这个标签。在Multiboot2信息结构中存在未终止的标签tag（原文在此的描述是：“EFI boot services not terminated tag exists in Multiboot2 information structure”）。

3.6.4、BIOS启动设备
大小名称
u32type = 5
u32size = 20
u32biosdev
u32partition
u32sub_parition

这个标签tag指明了引导加载程序是从哪一个BIOS磁盘设备加载这个操作系统映像的。如果操作系统映像不是从一个BIOS磁盘设备引导的，那么这个标签tag不会出现。操作系统可以使用这个字段来确定其根设备，但并不是必须这么作。

剩余的三个字段指明了引导分区。（原文在此的描述是：“The three remaining bytes specify the boot partition.”，并且位置也不在此处。如果有疑问，请阅读本节的原文描述。）

  • 字段biosdev包含了BIOS设备号，这个设备号是由底层磁盘接口BIOS INT 0x13 中断提供的。例如：第一个软盘的设备号是0x00，第二个硬盘的设备号是0x80。
  • 字段partition指明了引导分区的主分区号。
  • 字段sub_partition指明了引导分区在所在主分区中的次分区号。

分区号总是从0开始的。未使用的字段必须被设置为0xFFFFFFFF，例如，如果一个磁盘被分区为一个简单的单级DOS分区格式，那么字段partition中保存着DOS分区号，并且字段sub_partition被设置为0xFFFFFFFF。在另一个例子中，如果把DOS主分区进一步划分为几个BSD分区，那么字段partition中保存着DOS主分区号，同时字段sub_partition保存着在BSD分区子级分区在DOS主分区中的子分区号。

DOS扩展分区的分区号是从4开始的，并且递增。这一点和嵌套的子分区不同，尽管扩展分区的底层磁盘布局具有层次性。（原文在此的描述是：“DOS extended partitions are indicated as partition numbers starting from 4 and increasing, rather than as nested sub-partitions, even though the underlying disk layout of extended partitions is hierarchical in nature.”）举个例子，在一个DOS分区格式的磁盘上，如果引导加载程序是从磁盘第二个扩展分区引导系统的，那么字段partition将是5，而字段sub_partiton将是0xFFFFFFFF。

3.6.5、启动命令行
大小名称
u32type = 1
u32size
u8[n]string
  • 字段string中包含了启动命令行。这个命令行是一个UTF-8编码的以0结束的普通的C风格字符串。
3.6.6、模块
大小名称
u32type = 3
u32size
u32mod_start
u32mod_end
u32string

这个标签tag向内核指示了有哪些引导模块是与内核映像一同被加载进内存的，以及在内存何处可以被找到这些模块。

  • 字段mod_start包含了引导模块的起始物理地址。
  • 字段mod_end包含了引导模块的结束物理地址。
  • 字段string包含了与特定引导模块相关的一个描述性字符串。与内核命令行一样，这是一个UTF-8编码的以0结束的字符串。

通常，字符串可能是命令行（如果操作系统将引导模块视为可执行程序），也可能是路径名（如果操作系统将引导模块视为文件系统中的文件），但其确切用途是依据特定操作系统而定的。

每一个模块会对应一个标签tag。这个标签tag可能会出现多次。

3.6.7、ELF节头表
大小名称
u32type = 9
u32size
u16num
u16entsize
u16shndx
u16reserved
u16section headers

（依据给出的头文件multiboot2.h判断，字段size、entsize、shndx、reserved应该是u32类型的，字段section headers应该是u8的数组。这一点与规范中此处的描述不符。）

如果被加载的内核映像是一个ELF文件内核，则此标签tag包含了其节头表（section header table），节头表中的每一个条目的大小，以及字符串表中用来引用节名的偏移量（原文使用“index”）。它们相当于ELF规范中在ELF头（原文使用“the program header”，但ELF中另有程序头表）的“shdr_*”这样的条目（例如“shdr_num”）。所有的节都会被加载。

  • 字段num中保存ELF节头表中的项数。
  • 字段entsize中保存ELF节头表中每一项的大小。
  • 字段shndx中保存节名表在节表中的的序号。
  • 字段section headers中保存节头表内容。此内容和ELF中的节头表内容完全一致。

ELF节头表条目结构如下：

#define EI_NIDENT (16)

typedef struct
{
  unsigned char	e_ident[EI_NIDENT];	/* Magic number and other info */
  Elf32_Half	e_type;			/* Object file type */
  Elf32_Half	e_machine;		/* Architecture */
  Elf32_Word	e_version;		/* Object file version */
  Elf32_Addr	e_entry;		/* Entry point virtual address */
  Elf32_Off	e_phoff;		/* Program header table file offset */
  Elf32_Off	e_shoff;		/* Section header table file offset */
  Elf32_Word	e_flags;		/* Processor-specific flags */
  Elf32_Half	e_ehsize;		/* ELF header size in bytes */
  Elf32_Half	e_phentsize;		/* Program header table entry size */
  Elf32_Half	e_phnum;		/* Program header table entry count */
  Elf32_Half	e_shentsize;		/* Section header table entry size */
  Elf32_Half	e_shnum;		/* Section header table entry count */
  Elf32_Half	e_shstrndx;		/* Section header string table index */
} Elf32_Ehdr;
3.6.8、内存映射

这个标签tag提供内存映射。

大小名称
u32type = 6
u32size
u32entry_size
u32entry_version
variesentries
  • 字段size包含了这个标签tag的大小，且包括字段entries。（原文在此的描述是：“‘size’ contains the size of current entry including this field itself.”，且位置也不再此处。）
  • 字段entry_size包含每一个条目的大小，以便将来可以在其中添加新字段。这个字段的值必须是8的倍数。
  • 字段entry_version当前必须被设置为0。在未来的版本中会递增这个字段，当然未来的版本是向后兼容旧版本的。

每一个条目有下面的结构：

大小名称
u64base_addr
u64length
u32type
u32reserved
  • 字段base_addr是所表示内存区域的起始地址。
  • 字段length是所表示内存区域的大小。
  • 字段type是所表示内存区域的类型。其中，数值1表示可用RAM；数值3表示保存ACPI信息的可用内存；数值4表示需要在休眠时保存数据用的保留内存（原文在此的描述是：“value of 4 indicates reserved memory which needs to be preserved on hibernation“）；数值5表示有缺陷的RAM模块（原文在此的描述是：“value of 5 indicates a memory which is occupied by defective RAM modules“）；所有其他的值当前都表示保留的内存区域。
  • 字段reserved被引导加载程序设置为0，操作系统内核应该忽略这个字段。
type值助记符含义
1AddressRangeMemory这一段内存是可以供操作系统使用的
2AddressRangeReserved这一段内存已经被用了，或者保留起来的，不被OS的memory manager去分配
3AddressRangeACPI当OS 读过ACPI 表之后，就可使用的一段范围
4AddressRangeNVSACPI NVS 内存,这一段内存已经被用了或者保留起来，是不能被OS去用的
5AddressRangeUnusuable这是一段不能有的地址，因为检测到了错误
6AddressRangeDisabled一段没有被enabled的地址， 也是ospm 不可以用的
其他Undefined未定义，保留或者将来用。

提供的内存映射都是可被正常使用的，这些区域中可能包含内核、mbi数据、段和模块。内核不应该覆盖这些区域。（原文在此的描述是：“This type however includes the regions occupied by kernel, mbi, segments
and modules. Kernel must take care not to overwrite these regions.”）

在一些EFI平台上，如果启用了EFI启动服务并且可以加载映像，引导加载器可能不会支持这个标签。在Multiboot2信息结构中存在未终止的标签tag（原文在此的描述是：“EFI boot services not terminated tag exists in Multiboot2 information structure”）。

3.6.9、引导加载器名称
大小名称
u32type = 2
u32size
u8[n]string
  • 字段string包含了加载内核的引导加载器的名称。这个名称是一个UTF-8编码的以0结束的C风格字符串。
3.6.10、APM表
3.6.11、VBE信息
3.6.12、帧缓冲信息
3.6.13、ELF32位系统表指针
3.6.14、ELF64位系统表指针
3.6.15、SMBIOS表
3.6.16、旧RSDP（ACPI 1.0）
3.6.17、新RSDP（ACPI 2.0及以上）
3.6.18、网络信息
3.6.19、EFI内存映射
3.6.20、EFI启动服务未被终止
3.6.21、EFI32位映像处理指针
3.6.22、EFI64位映像处理指针
3.6.23、映像加载物理基地址

4、示例

4.1、C结构体成员对齐与填充

4.2、在PC上需要注意的问题

4.3、BIOS设备映射技术

4.3.1、数据比较技术
4.3.2、I/O限制技术

4.4、操作系统示例代码

4.4.1、multiboot2.h
4.4.2、boot.S
4.4.3、kernel.c
4.4.4、Makefile
4.4.5、其他Multiboot2内核

4.5、引导程序示例代码

5、本规范更新日志

6、索引

二、GRUB

三、代码实例

multiboot2.h

/* multiboot2.h - Multiboot 2 header file. */
/* Copyright (C) 1999,2003,2007,2008,2009,2010 Free Software Foundation, Inc.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to
* deal in the Software without restriction, including without limitation the
* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
* sell copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL A
* DEVELOPER OR DISTRIBUTOR BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
* IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/

#ifndef MULTIBOOT_HEADER
#define MULTIBOOT_HEADER 1

/* How many bytes from the start of the file we search for the header. */
#define MULTIBOOT_SEARCH 32768
#define MULTIBOOT_HEADER_ALIGN 8

/* The magic field should contain this. */
#define MULTIBOOT2_HEADER_MAGIC 0xe85250d6

/* This should be in %eax. */
#define MULTIBOOT2_BOOTLOADER_MAGIC 0x36d76289

/* Alignment of multiboot modules. */
#define MULTIBOOT_MOD_ALIGN 0x00001000

/* Alignment of the multiboot info structure. */
#define MULTIBOOT_INFO_ALIGN 0x00000008

/* Flags set in the ’flags’ member of the multiboot header. */

#define MULTIBOOT_TAG_ALIGN 8
#define MULTIBOOT_TAG_TYPE_END 0
#define MULTIBOOT_TAG_TYPE_CMDLINE 1
#define MULTIBOOT_TAG_TYPE_BOOT_LOADER_NAME 2
#define MULTIBOOT_TAG_TYPE_MODULE 3
#define MULTIBOOT_TAG_TYPE_BASIC_MEMINFO 4
#define MULTIBOOT_TAG_TYPE_BOOTDEV 5
#define MULTIBOOT_TAG_TYPE_MMAP 6
#define MULTIBOOT_TAG_TYPE_VBE 7
#define MULTIBOOT_TAG_TYPE_FRAMEBUFFER 8
#define MULTIBOOT_TAG_TYPE_ELF_SECTIONS 9
#define MULTIBOOT_TAG_TYPE_APM 10
#define MULTIBOOT_TAG_TYPE_EFI32 11
#define MULTIBOOT_TAG_TYPE_EFI64 12
#define MULTIBOOT_TAG_TYPE_SMBIOS 13
#define MULTIBOOT_TAG_TYPE_ACPI_OLD 14
#define MULTIBOOT_TAG_TYPE_ACPI_NEW 15
#define MULTIBOOT_TAG_TYPE_NETWORK 16
#define MULTIBOOT_TAG_TYPE_EFI_MMAP 17
#define MULTIBOOT_TAG_TYPE_EFI_BS 18
#define MULTIBOOT_TAG_TYPE_EFI32_IH 19
#define MULTIBOOT_TAG_TYPE_EFI64_IH 20
#define MULTIBOOT_TAG_TYPE_LOAD_BASE_ADDR 21

#define MULTIBOOT_HEADER_TAG_END 0
#define MULTIBOOT_HEADER_TAG_INFORMATION_REQUEST 1
#define MULTIBOOT_HEADER_TAG_ADDRESS 2
#define MULTIBOOT_HEADER_TAG_ENTRY_ADDRESS 3
#define MULTIBOOT_HEADER_TAG_CONSOLE_FLAGS 4
#define MULTIBOOT_HEADER_TAG_FRAMEBUFFER 5
#define MULTIBOOT_HEADER_TAG_MODULE_ALIGN 6
#define MULTIBOOT_HEADER_TAG_EFI_BS 7
#define MULTIBOOT_HEADER_TAG_ENTRY_ADDRESS_EFI32 8
#define MULTIBOOT_HEADER_TAG_ENTRY_ADDRESS_EFI64 9
#define MULTIBOOT_HEADER_TAG_RELOCATABLE 10

#define MULTIBOOT_ARCHITECTURE_I386 0
#define MULTIBOOT_ARCHITECTURE_MIPS32 4
#define MULTIBOOT_HEADER_TAG_OPTIONAL 1

#define MULTIBOOT_LOAD_PREFERENCE_NONE 0
#define MULTIBOOT_LOAD_PREFERENCE_LOW 1
#define MULTIBOOT_LOAD_PREFERENCE_HIGH 2

#define MULTIBOOT_CONSOLE_FLAGS_CONSOLE_REQUIRED 1
#define MULTIBOOT_CONSOLE_FLAGS_EGA_TEXT_SUPPORTED 2

#ifndef ASM_FILE

typedef unsigned char multiboot_uint8_t;
typedef unsigned short multiboot_uint16_t;
typedef unsigned int multiboot_uint32_t;
typedef unsigned long long multiboot_uint64_t;

struct multiboot_header
{
	/* Must be MULTIBOOT MAGIC - see above. */
	multiboot_uint32_t magic;

	/* ISA */
	multiboot_uint32_t architecture;

	/* Total header length. */
	multiboot_uint32_t header_length;

	/* The above fields plus this one must equal 0 mod 2^32. */
	multiboot_uint32_t checksum;
};

struct multiboot_header_tag
{
	multiboot_uint16_t type;
	multiboot_uint16_t flags;
	multiboot_uint32_t size;
};

struct multiboot_header_tag_information_request
{
	multiboot_uint16_t type;
	multiboot_uint16_t flags;
	multiboot_uint32_t size;
	multiboot_uint32_t requests[0];
};

struct multiboot_header_tag_address
{
	multiboot_uint16_t type;
	multiboot_uint16_t flags;
	multiboot_uint32_t size;
	multiboot_uint32_t header_addr;
	multiboot_uint32_t load_addr;
	multiboot_uint32_t load_end_addr;
	multiboot_uint32_t bss_end_addr;
};

struct multiboot_header_tag_entry_address
{
	multiboot_uint16_t type;
	multiboot_uint16_t flags;
	multiboot_uint32_t size;
	multiboot_uint32_t entry_addr;
};

struct multiboot_header_tag_console_flags
{
	multiboot_uint16_t type;
	multiboot_uint16_t flags;
	multiboot_uint32_t size;
	multiboot_uint32_t console_flags;
};

struct multiboot_header_tag_framebuffer
{
	multiboot_uint16_t type;
	multiboot_uint16_t flags;
	multiboot_uint32_t size;
	multiboot_uint32_t width;
	multiboot_uint32_t height;
	multiboot_uint32_t depth;
};

struct multiboot_header_tag_module_align
{
	multiboot_uint16_t type;
	multiboot_uint16_t flags;
	multiboot_uint32_t size;
};

struct multiboot_header_tag_relocatable
{
	multiboot_uint16_t type;
	multiboot_uint16_t flags;
	multiboot_uint32_t size;
	multiboot_uint32_t min_addr;
	multiboot_uint32_t max_addr;
	multiboot_uint32_t align;
	multiboot_uint32_t preference;
};

struct multiboot_color
{
	multiboot_uint8_t red;
	multiboot_uint8_t green;
	multiboot_uint8_t blue;
};

struct multiboot_mmap_entry
{
	multiboot_uint64_t addr;
	multiboot_uint64_t len;
#define MULTIBOOT_MEMORY_AVAILABLE 1
#define MULTIBOOT_MEMORY_RESERVED 2
#define MULTIBOOT_MEMORY_ACPI_RECLAIMABLE 3
#define MULTIBOOT_MEMORY_NVS 4
#define MULTIBOOT_MEMORY_BADRAM 5
	multiboot_uint32_t type;
	multiboot_uint32_t zero;
};
typedef struct multiboot_mmap_entry multiboot_memory_map_t;

struct multiboot_tag
{
	multiboot_uint32_t type;
	multiboot_uint32_t size;
};

struct multiboot_tag_string
{
	multiboot_uint32_t type;
	multiboot_uint32_t size;
	char string[0];
};

struct multiboot_tag_module
{
	multiboot_uint32_t type;
	multiboot_uint32_t size;
	multiboot_uint32_t mod_start;
	multiboot_uint32_t mod_end;
	char cmdline[0];
};

struct multiboot_tag_basic_meminfo
{
	multiboot_uint32_t type;
	multiboot_uint32_t size;
	multiboot_uint32_t mem_lower;
	multiboot_uint32_t mem_upper;
};

struct multiboot_tag_bootdev
{
	multiboot_uint32_t type;
	multiboot_uint32_t size;
	multiboot_uint32_t biosdev;
	multiboot_uint32_t slice;
	multiboot_uint32_t part;
};

struct multiboot_tag_mmap
{
	multiboot_uint32_t type;
	multiboot_uint32_t size;
	multiboot_uint32_t entry_size;
	multiboot_uint32_t entry_version;
	struct multiboot_mmap_entry entries[0];
};

struct multiboot_vbe_info_block
{
	multiboot_uint8_t external_specification[512];
};

struct multiboot_vbe_mode_info_block
{
	multiboot_uint8_t external_specification[256];
};

struct multiboot_tag_vbe
{
	multiboot_uint32_t type;
	multiboot_uint32_t size;

	multiboot_uint16_t vbe_mode;
	multiboot_uint16_t vbe_interface_seg;
	multiboot_uint16_t vbe_interface_off;
	multiboot_uint16_t vbe_interface_len;

	struct multiboot_vbe_info_block vbe_control_info;

	struct multiboot_vbe_mode_info_block vbe_mode_info;
};

struct multiboot_tag_framebuffer_common
{
	multiboot_uint32_t type;
	multiboot_uint32_t size;

	multiboot_uint64_t framebuffer_addr;
	multiboot_uint32_t framebuffer_pitch;
	multiboot_uint32_t framebuffer_width;
	multiboot_uint32_t framebuffer_height;
	multiboot_uint8_t framebuffer_bpp;
#define MULTIBOOT_FRAMEBUFFER_TYPE_INDEXED 0
#define MULTIBOOT_FRAMEBUFFER_TYPE_RGB 1
#define MULTIBOOT_FRAMEBUFFER_TYPE_EGA_TEXT 2
	multiboot_uint8_t framebuffer_type;
	multiboot_uint16_t reserved;
};

struct multiboot_tag_framebuffer
{
	struct multiboot_tag_framebuffer_common common;
	union {
		struct
		{
			multiboot_uint16_t framebuffer_palette_num_colors;
			struct multiboot_color framebuffer_palette[0];
		};
		struct
		{
			multiboot_uint8_t framebuffer_red_field_position;
			multiboot_uint8_t framebuffer_red_mask_size;
			multiboot_uint8_t framebuffer_green_field_position;
			multiboot_uint8_t framebuffer_green_mask_size;
			multiboot_uint8_t framebuffer_blue_field_position;
			multiboot_uint8_t framebuffer_blue_mask_size;
		};
	};
};

struct multiboot_tag_elf_sections
{
	multiboot_uint32_t type;
	multiboot_uint32_t size;

	multiboot_uint32_t num;
	multiboot_uint32_t entsize;
	multiboot_uint32_t shndx;
	char sections[0];
};

struct multiboot_tag_apm
{
	multiboot_uint32_t type;
	multiboot_uint32_t size;
	multiboot_uint16_t version;
	multiboot_uint16_t cseg;
	multiboot_uint32_t offset;
	multiboot_uint16_t cseg_16;
	multiboot_uint16_t dseg;
	multiboot_uint16_t flags;
	multiboot_uint16_t cseg_len;
	multiboot_uint16_t cseg_16_len;
	multiboot_uint16_t dseg_len;
};

struct multiboot_tag_efi32
{
	multiboot_uint32_t type;
	multiboot_uint32_t size;
	multiboot_uint32_t pointer;
};

struct multiboot_tag_efi64
{
	multiboot_uint32_t type;
	multiboot_uint32_t size;
	multiboot_uint64_t pointer;
};

struct multiboot_tag_smbios
{
	multiboot_uint32_t type;
	multiboot_uint32_t size;
	multiboot_uint8_t major;
	multiboot_uint8_t minor;
	multiboot_uint8_t reserved[6];
	multiboot_uint8_t tables[0];
};

struct multiboot_tag_old_acpi
{
	multiboot_uint32_t type;
	multiboot_uint32_t size;
	multiboot_uint8_t rsdp[0];
};

struct multiboot_tag_new_acpi
{
	multiboot_uint32_t type;
	multiboot_uint32_t size;
	multiboot_uint8_t rsdp[0];
};

struct multiboot_tag_network
{
	multiboot_uint32_t type;
	multiboot_uint32_t size;
	multiboot_uint8_t dhcpack[0];
};

struct multiboot_tag_efi_mmap
{
	multiboot_uint32_t type;
	multiboot_uint32_t size;
	multiboot_uint32_t descr_size;
	multiboot_uint32_t descr_vers;
	multiboot_uint8_t efi_mmap[0];
};

struct multiboot_tag_efi32_ih
{
	multiboot_uint32_t type;
	multiboot_uint32_t size;
	multiboot_uint32_t pointer;
};

struct multiboot_tag_efi64_ih
{
	multiboot_uint32_t type;
	multiboot_uint32_t size;
	multiboot_uint64_t pointer;
};

struct multiboot_tag_load_base_addr
{
	multiboot_uint32_t type;
	multiboot_uint32_t size;
	multiboot_uint32_t load_base_addr;
};

#endif /* ! ASM FILE */

#endif /* ! MULTIBOOT HEADER */

boot.S

/* boot.S - bootstrap the kernel */
/* Copyright (C) 1999, 2001, 2010 Free Software Foundation, Inc.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/

#define ASM_FILE 1
#include "multiboot2.h"

/* C symbol format. HAVE ASM USCORE is defined by configure. */
#ifdef HAVE_ASM_USCORE
# define EXT_C(sym) _ ## sym
#else
# define EXT_C(sym) sym
#endif

/* The size of our stack (16KB). */
#define STACK_SIZE 0x4000

/* The flags for the Multiboot header. */
#ifdef __ELF__
# define AOUT_KLUDGE 0
#else
# define AOUT_KLUDGE MULTIBOOT_AOUT_KLUDGE
#endif

#define GRUB_MULTIBOOT_ARCHITECTURE_I386 MULTIBOOT_ARCHITECTURE_I386

	.text
	.globl start, _start
start:
_start:
	jmp multiboot_entry

	/* Align 64 bits boundary. */
	.align 8

	/* Multiboot header. */
multiboot_header:
	/* magic */
	.long MULTIBOOT2_HEADER_MAGIC
	/* ISA: i386 */
	.long GRUB_MULTIBOOT_ARCHITECTURE_I386
	/* Header length. */
	.long multiboot_header_end - multiboot_header
	/* checksum */
	.long -(MULTIBOOT2_HEADER_MAGIC + GRUB_MULTIBOOT_ARCHITECTURE_I386 + (multiboot_header_end - multiboot_header))
#ifndef __ELF__

	.align 8
address_tag_start:
	.short MULTIBOOT_HEADER_TAG_ADDRESS
	.short MULTIBOOT_HEADER_TAG_OPTIONAL
	.long address_tag_end - address_tag_start
	/* header_addr */
	.long multiboot_header
	/* load_addr */
	.long _start
	/* load_end_addr */
	.long _edata
	/* bss end addr */
	.long _end
address_tag_end:

	.align 8
entry_address_tag_start:
	.short MULTIBOOT_HEADER_TAG_ENTRY_ADDRESS
	.short MULTIBOOT_HEADER_TAG_OPTIONAL
	.long entry_address_tag_end - entry_address_tag_start
	/* entry addr */
	.long multiboot_entry
entry_address_tag_end:
#endif /* ELF */

	.align 8
framebuffer_tag_start:
	.short MULTIBOOT_HEADER_TAG_FRAMEBUFFER
	.short MULTIBOOT_HEADER_TAG_OPTIONAL
	.long framebuffer_tag_end - framebuffer_tag_start
	.long 1024
	.long 768
	.long 32
framebuffer_tag_end:

	.align 8
	.short MULTIBOOT_HEADER_TAG_END
	.short 0
	.long 8
multiboot_header_end:
multiboot_entry:
	/* Initialize the stack pointer. */
	movl $(stack + STACK_SIZE), %esp

	/* Reset EFLAGS. */
	pushl $0
	popf

	/* Push the pointer to the Multiboot information structure. */
	pushl %ebx
	/* Push the magic value. */
	pushl %eax

	/* Now enter the C main function... */
	call EXT_C(cmain)

	/* Halt. */
	pushl $halt_message
	call EXT_C(printf)

loop:
	hlt
	jmp loop

halt_message:
	.asciz "Halted."

	/* Our stack area. */
	.comm stack, STACK_SIZE

kernel.c

/* kernel.c - the C part of the kernel */
/* Copyright (C) 1999, 2010 Free Software Foundation, Inc.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/

#include "multiboot2.h"

/* Macros. */

/* Some screen stuff. */
/* The number of columns. */
#define COLUMNS 80
/* The number of lines. */
#define LINES 24
/* The attribute of an character. */
#define ATTRIBUTE 7
/* The video memory address. */
#define VIDEO 0xB8000

/* Variables. */
/* Save the X position. */
static int xpos;
/* Save the Y position. */
static int ypos;
/* Point to the video memory. */
static volatile unsigned char *video;

/* Forward declarations. */
void cmain(unsigned long magic, unsigned long addr);
static void cls(void);
static void itoa(char *buf, int base, int d);
static void putchar(int c);
void printf(const char *format, ...);

/* Check if MAGIC is valid and print the Multiboot information structure pointed by ADDR. */
void cmain(unsigned long magic, unsigned long addr)
{
	struct multiboot_tag *tag;
	unsigned size;

	/* Clear the screen. */
	cls();

	/* Am I booted by a Multiboot-compliant boot loader? */
	if (magic != MULTIBOOT2_BOOTLOADER_MAGIC)
	{
		printf("Invalid magic number: 0x%x\n", (unsigned)magic);
		return;
	}

	if (addr & 7)
	{
		printf("Unaligned mbi: 0x%x\n", addr);
		return;
	}

	size = *(unsigned *)addr;
	printf("Announced mbi size 0x%x\n", size);
	for (tag = (struct multiboot_tag *)(addr + 8);
		 tag->type != MULTIBOOT_TAG_TYPE_END;
		 tag = (struct multiboot_tag *)((multiboot_uint8_t *)tag + ((tag->size + 7) & ~7)))
	{
		printf("Tag 0x%x, Size 0x%x\n", tag->type, tag->size);
		switch (tag->type)
		{
		case MULTIBOOT_TAG_TYPE_CMDLINE:
			printf("Command line = %s\n", ((struct multiboot_tag_string *)tag)->string);
			break;
		case MULTIBOOT_TAG_TYPE_BOOT_LOADER_NAME:
			printf("Boot loader name = %s\n", ((struct multiboot_tag_string *)tag)->string);
			break;
		case MULTIBOOT_TAG_TYPE_MODULE:
			printf("Module at 0x%x-0x%x. Command line %s\n",
				   ((struct multiboot_tag_module *)tag)->mod_start,
				   ((struct multiboot_tag_module *)tag)->mod_end,
				   ((struct multiboot_tag_module *)tag)->cmdline);
			break;
		case MULTIBOOT_TAG_TYPE_BASIC_MEMINFO:
			printf("mem_lower = %uKB, mem_upper = %uKB\n",
				   ((struct multiboot_tag_basic_meminfo *)tag)->mem_lower,
				   ((struct multiboot_tag_basic_meminfo *)tag)->mem_upper);
			break;
		case MULTIBOOT_TAG_TYPE_BOOTDEV:
			printf("Boot device 0x%x,%u,%u\n",
				   ((struct multiboot_tag_bootdev *)tag)->biosdev,
				   ((struct multiboot_tag_bootdev *)tag)->slice,
				   ((struct multiboot_tag_bootdev *)tag)->part);
			break;
		case MULTIBOOT_TAG_TYPE_MMAP:
		{
			multiboot_memory_map_t *mmap;

			printf("mmap\n");

			for (mmap = ((struct multiboot_tag_mmap *)tag)->entries;
				 (multiboot_uint8_t *)mmap < (multiboot_uint8_t *)tag + tag->size;
				 mmap = (multiboot_memory_map_t *)((unsigned long)mmap + ((struct multiboot_tag_mmap *)tag)->entry_size))
				printf(" base_addr = 0x%x%x,"
					   " length = 0x%x%x, type = 0x%x\n",
					   (unsigned)(mmap->addr >> 32),
					   (unsigned)(mmap->addr & 0xffffffff),
					   (unsigned)(mmap->len >> 32),
					   (unsigned)(mmap->len & 0xffffffff),
					   (unsigned)mmap->type);
		}
		break;
		case MULTIBOOT_TAG_TYPE_FRAMEBUFFER:
		{
			multiboot_uint32_t color;
			unsigned i;
			struct multiboot_tag_framebuffer *tagfb = (struct multiboot_tag_framebuffer *)tag;
			void *fb = (void *)(unsigned long)tagfb->common.framebuffer_addr;

			switch (tagfb->common.framebuffer_type)
			{
			case MULTIBOOT_FRAMEBUFFER_TYPE_INDEXED:
			{
				unsigned best_distance, distance;
				struct multiboot_color *palette;

				palette = tagfb->framebuffer_palette;

				color = 0;
				best_distance = 4 * 256 * 256;

				for (i = 0; i < tagfb->framebuffer_palette_num_colors; i++)
				{
					distance = (0xff - palette[i].blue) * (0xff - palette[i].blue) + palette[i].red * palette[i].red + palette[i].green * palette[i].green;
					if (distance < best_distance)
					{
						color = i;
						best_distance = distance;
					}
				}
			}
			break;

			case MULTIBOOT_FRAMEBUFFER_TYPE_RGB:
				color = ((1 << tagfb->framebuffer_blue_mask_size) - 1) << tagfb->framebuffer_blue_field_position;
				break;

			case MULTIBOOT_FRAMEBUFFER_TYPE_EGA_TEXT:
				color = '\\' | 0x0100;
				break;

			default:
				color = 0xffffffff;
				break;
			}

			for (i = 0; i < tagfb->common.framebuffer_width && i < tagfb->common.framebuffer_height; i++)
			{
				switch (tagfb->common.framebuffer_bpp)
				{
				case 8:
				{
					multiboot_uint8_t *pixel = fb + tagfb->common.framebuffer_pitch * i + i;
					*pixel = color;
				}
				break;
				case 15:
				case 16:
				{
					multiboot_uint16_t *pixel = fb + tagfb->common.framebuffer_pitch * i + 2 * i;
					*pixel = color;
				}
				break;
				case 24:
				{
					multiboot_uint32_t *pixel = fb + tagfb->common.framebuffer_pitch * i + 3 * i;
					*pixel = (color & 0xffffff) | (*pixel & 0xff000000);
				}
				break;
				case 32:
				{
					multiboot_uint32_t *pixel = fb + tagfb->common.framebuffer_pitch * i + 4 * i;
					*pixel = color;
				}
				break;
				}
			}
			break;
		}
		}
	}
	tag = (struct multiboot_tag *)((multiboot_uint8_t *)tag + ((tag->size + 7) & ~7));
	printf("Total mbi size 0x%x\n", (unsigned)tag - addr);
}

/* Clear the screen and initialize VIDEO, XPOS and YPOS. */
static void cls(void)
{
	int i;

	video = (unsigned char *)VIDEO;

	for (i = 0; i < COLUMNS * LINES * 2; i++)
		*(video + i) = 0;

	xpos = 0;
	ypos = 0;
}

/* Convert the integer D to a string and save the string in BUF. If
BASE is equal to ’d’, interpret that D is decimal, and if BASE is
equal to ’x’, interpret that D is hexadecimal. */
static void itoa(char *buf, int base, int d)
{
	char *p = buf;
	char *p1, *p2;
	unsigned long ud = d;
	int divisor = 10;

	/* If %d is specified and D is minus, put ‘-’ in the head. */
	if (base == 'd' && d < 0)
	{
		*p++ = '-';
		buf++;
		ud = -d;
	}
	else if (base == 'x')
		divisor = 16;

	/* Divide UD by DIVISOR until UD == 0. */
	do
	{
		int remainder = ud % divisor;
		*p++ = (remainder < 10) ? remainder + '0' : remainder + 'a' - 10;
	} while (ud /= divisor);

	/* Terminate BUF. */
	*p = 0;

	/* Reverse BUF. */
	p1 = buf;
	p2 = p - 1;
	while (p1 < p2)
	{
		char tmp = *p1;
		*p1 = *p2;
		*p2 = tmp;
		p1++;
		p2--;
	}
}

/* Put the character C on the screen. */
static void putchar(int c)
{
	if (c == '\n' || c == '\r')
	{
	newline:
		xpos = 0;
		ypos++;
		if (ypos >= LINES)
			ypos = 0;
		return;
	}

	*(video + (xpos + ypos * COLUMNS) * 2) = c & 0xFF;
	*(video + (xpos + ypos * COLUMNS) * 2 + 1) = ATTRIBUTE;

	xpos++;
	if (xpos >= COLUMNS)
		goto newline;
}

/* Format a string and print it on the screen, just like the libc
function printf. */
void printf(const char *format, ...)
{
	char **arg = (char **)&format;
	int c;
	char buf[20];

	arg++;

	while ((c = *format++) != 0)
	{
		if (c != '%')
			putchar(c);
		else
		{
			char *p, *p2;
			int pad0 = 0, pad = 0;

			c = *format++;
			if (c == '0')
			{
				pad0 = 1;
				c = *format++;
			}

			if (c >= '0' && c <= '9')
			{
				pad = c - '0';
				c = *format++;
			}
			switch (c)
			{
			case 'd':
			case 'u':
			case 'x':
				itoa(buf, c, *((int *)arg++));
				p = buf;
				goto string;
				break;

			case 's':
				p = *arg++;
				if (!p)
					p = "(null)";

			string:
				for (p2 = p; *p2; p2++)
					;
				for (; p2 < p + pad; p2++)
					putchar(pad0 ? '0' : ' ');
				while (*p)
					putchar(*p++);
				break;

			default:
				putchar(*((int *)arg++));
				break;
			}
		}
	}
}

Makefile

CC			= gcc
LD			= ld

# -g -- 生成符号表以供调试使用
# -m32 -- 编译成32位目标文件
# -Wall -- 打开绝大多数警告
# -Wno-implicit-function-declaration -- 
# -std=c11 -- 遵循C11标准
# -std=gnu11 -- 遵循C11标准并且打开GNU的相关扩展
# -ffreestanding -- 采用独立环境
# -fno-pic -- 解决“对‘_GLOBAL_OFFSET_TABLE_’未定义的引用”问题
# -nostdinc -- 项目中的头文件可能会和开发环境中的系统头文件文件名称发生冲突，采用这个编译选项时不检索系统默认的头文件目录，但之后需要手动添加需检索的提供独立环境头文件的目录。
# -Iinclude -- 指定包含文件目录
# -fomit-frame-pointer -- 函数操作时不保存栈帧到寄存器(%ebp)（如果使用这个编译参数，则在gdb中调试会出错，因为gdb调试依赖栈帧）
CFLAGS		= -g -m32 -Wall -Wno-implicit-function-declaration -std=gnu11 -ffreestanding -fno-pic -nostdinc #-fomit-frame-pointer

# -Ttext -- 设置 .text 节的地址
# -m -- 设置仿真
LDFLAGS		= -Ttext 0x100000 -m elf_i386

%.o: %.S
	$(CC) $(CFLAGS) -c $< -o $@
%.o: %.c
	$(CC) $(CFLAGS) -c $< -o $@
%: %.o
	$(LD) $^ -o $@ $(LDFLAGS)

LOOP_DEVICE_NUMBER			= 12
LOOP_DEVICE					= /dev/loop$(LOOP_DEVICE_NUMBER)
LOOP_DEVICE_MOUNT_ROOT_DIR	= /mnt/vdisk

KERNEL_NAME			= kernel
DISK_IMAGE			= hd.img
DISK_IMAGE_SECTORS	= 20160

all: mkimage

boot.o: boot.S

kernel.o: kernel.c

$(KERNEL_NAME): boot.o kernel.o

mkimage: kernel $(DISK_IMAGE)
	make mount
	sudo cp $(KERNEL_NAME) $(LOOP_DEVICE_MOUNT_ROOT_DIR)/p1
	make umount

$(DISK_IMAGE):
	dd if=/dev/zero of=$(DISK_IMAGE) bs=512 count=$(DISK_IMAGE_SECTORS)
	parted $(DISK_IMAGE) 'mklabel msdos mkpart primary fat16 1MB -1 set 1 boot on'
	sudo losetup -P $(LOOP_DEVICE) $(DISK_IMAGE)
	sudo mkfs.msdos $(LOOP_DEVICE)p1
	sudo mount $(LOOP_DEVICE)p1 $(LOOP_DEVICE_MOUNT_ROOT_DIR)/p1
	sudo grub-install --boot-directory=$(LOOP_DEVICE_MOUNT_ROOT_DIR)/p1 --target=i386-pc $(LOOP_DEVICE)
	echo "echo \"multiboot (hd0,msdos1)/kernel\nboot\" > $(LOOP_DEVICE_MOUNT_ROOT_DIR)/p1/grub/grub.cfg" | sudo sh
	sync
	make umount

mount:
	sudo losetup -P $(LOOP_DEVICE) $(DISK_IMAGE)
	sudo mount $(LOOP_DEVICE)p1 $(LOOP_DEVICE_MOUNT_ROOT_DIR)/p1

umount:
	sudo umount $(LOOP_DEVICE_MOUNT_ROOT_DIR)/p1
	sudo losetup -d $(LOOP_DEVICE)

clean:
	rm -f *.o kernel $(DISK_IMAGE)
使用grub2引导multiboot内核
lzg666456的专栏
10-11 2453
最近在使用grub2的cli时偶然发现有个multiboot命令，于是拿来使用了一下 ，便有了这篇文章。 最小multiboot内核 最小multiboot内核的源码来自multiboot spec 0.6.96。 {CSDN:CODE:CC=gcc -m32 -march=i386 -I. -Wall -Wextra -nostdlib -fno-builtin -nostartf
基于Multiboot制作最小OS内核
Aspiresky的专栏
03-12 558
Multiboot规范里提供了一个例程，演示了如何编写支持Multiboot引导的操作系统。至此，一个支持multiboot引导的启动盘制作完成，后面可以使用虚拟机来加载启动盘运行。接下来，我们将这个内核烧录到启动盘并使用虚拟机运行。上面的命令创建了一个64MB大小的空白磁盘镜像文件。可以看到，系统为我们生成了一个新的loop设备。，并且还有一个分区设备。
Rust OSDev Multiboot2 项目教程
gitblog_00595的博客
09-02 949
Rust OSDev Multiboot2 项目教程 multiboot2The multiboot2 crate helps to parse the Multiboot2 information structure (MBI) and is relevant in kernels, that get booted by a bootloader such as GRUB, for examp...
第三章 在屏幕上显示点什么 - 从零开始开发UEFI引导的64位操作系统内核
指向BIOS的野指针
12-18 1121
声明：此文章为本人在首发的原创文章。
通过GRUB Multiboot2引导自制操作系统
最新发布
ThousandPine的博客
10-08 1765
本文通过 GRUB Multiboot2 引导自制操作系统的完整过程，从 Multiboot2 规范解析到代码实现、镜像制作，再到虚拟机测试，展示了如何使用 GRUB 引导自制的操作系统，并修复官方文档中的代码错误，确保系统在 QEMU 和 VirtualBox 环境中成功运行。
Grub Multiboot规范
Working...
11-25 3075
因为自己最近在尝试着写一个简单的小型操作系统（跟着JamesM’s kernel学习）,所以没有自己写引导程序，而是用的grub作为引导来加载OS,所以在写程序的时候就要求代码符合Multiboot规范，然后就看了一下文档，感觉内容挺多的，就决定自己将规范简化一下（提前声明，这篇博客中只是介绍了我自己编程中用到的一些知识，可能不全面，如果大家还想看更多详细的，下面是网址：http://www.cn
GRUB multiboot
devehe的山寨
04-21 3316
http://hi.baidu.com/bznr/blog/item/a641b745c5e4b726cffca3b7.html Multiboot的研究（grub）2006-10-10 16:411.1 Multiboot规范的背景每一个操作系统一般都有自己的boot loader，由于这些boot loader安装与
GRUB Multiboot规范
KarlSzp
05-27 536
GRUB Multiboot规范 ​ 为记录设计引导程序时需要注意的相关规范，本文不对Multiboot作系统介绍，仅作为记录参考用。 $1 术语定义 必须 术语“必须”表示引导程序或OS映像需要服从某一规则，否则的话，引导程序或者OS映像就不能称为符合Multiboot规范的。 应该 术语“应该”表示引导程序或OS映像最好服从某一规则，但如果没有服从也是可以的。 可以 术语“可以”表示引导程...
grub2引导linux内核,使用grub2引导multiboot内核
weixin_35838394的博客
05-01 828
grub2中直接提供了multiboot和multiboot2命令，可分别用于引导符合multiboot v1规范和multiboot v2规范的内核。最小multiboot内核以下是最小multiboot内核源码包下载页面http://www.pudn.com/downloads566/sourcecode/os/detail2327975.html源码包中使用的是syslinux引导的硬盘镜像...
深入理解QEMU与Multiboot协议：实现操作系统启动实验报告
资源摘要信息:"本资源是一份关于操作系统实验的报告，主题为通过QEMU和Multiboot启动实现操作系统的基本引导。实验报告详细描述了实验的目的、步骤和所用技术，同时附带源代码。以下为报告中所涉及的知识点： 1. **...
grub4dos是一个遵从Multiboot（多重启动）规范的启动管理程序
02-03
GRUB 是一个遵从Multiboot（多重启动）规范的启动管理程序。现在接触到的有3种，即GNU Grub Lagecy , GNU Grub2 和 Grub for dos（grub4dos）。 GNU GRUB Lagecy其实就是原来的 GNU GRUB 0.xx ，最新版是2005年发布的GNU GRUB 0.97。 目前已停止开发，并改名为 GNU GRUB Lagecy。 GNU GRUB2是第二代GRUB，它将取代原来的GNU GRUB（例如0.9x版），但目前还处于开发阶段，尚未发布正式版。 GNU GRUB Lagecy和GNU GRUB2都是 GNU 组织的项目。 GRUB for DOS（GRUB4DOS）是一个以 GNU GRUB 为基础的功能强大的引导器。它可以在 DOS 和 LINUX下运行，也可以通过其他引导器来运行，还可以作为MBR运行。GRUB4DOS内置了功能完善的 BIOS 级磁盘仿真。 下面以比较广泛使用的GRUB4DOS为基础进行说明。GNU GRUB与GRUB4DOS的不同之处，可参看相关说明文件。
grub2 loader加载kernel和输出helloworld(x86)
03-27
GRUB2的多引导规范（multiboot specification）允许它加载多种不同类型的kernel，而不局限于特定的操作系统。这个规范定义了一种通用的header格式，kernel必须遵循这个格式，GRUB2才能正确识别和加载。在我们的`...
incos：您好世界操作系统
02-04
"incos：您好世界操作系统" 是一个以学习和探索操作系统原理为目标的项目。这个系统可能是由初学者或者爱好者创建的，旨在理解操作系统的基本构建块，包括内核、引导加载器、内存管理、多任务处理等核心概念。让我们...
Multiboot程序跳转实现原理与操作教程
7. Multiboot的实现原理：Multiboot的实现依赖于一系列的步骤，包括安装和配置引导加载器、准备操作系统映像、编辑启动配置文件以及最终的多操作系统选择和启动过程。程序跳转的实现是这一系列步骤中的一部分。 8. ...
grub4dos入门与应用教程
它是一个遵循Multiboot规范的加载器，允许用户在计算机启动时选择要运行的操作系统。grub4dos不仅功能强大，而且具有高度灵活性，能够处理各种复杂的引导场景。 在入门篇中，教程将介绍grub4dos的基础知识，包括...
GRUB基础 — Multiboot规范
Take Easy，Work Hard！
03-01 1220
GRUB是兼容Mutliboot规范的一种实现，本文主要介绍Mutliboot规范并与Mutliboot2规范对比，分析两者在扩展性和平台支持方面的优缺点
操作系统开发 – 开发multiboot内核要小心的一个东西
操作系统开发
10-12 1040
开发multiboot内核要小心的一个东西: multiboot的spec说multiboot的header要放在内核文件的头8192 bytes里， 但看以下图， 有一个叫.note.gnu.build-i的section占了最头的位置， 其实它不是叫.note.gnu.build-i, 它是叫.note.gnu.build-id, 在你的linker script里可以加以下句子在最
推荐开源项目：GRUB2 Live ISO Multiboot
gitblog_00036的博客
05-19 454
推荐开源项目：GRUB2 Live ISO Multiboot 去发现同类优质开源项目:https://gitcode.com/ 项目介绍 GRUB2 Live ISO Multiboot，简称GLIM，是一个创新的GRUB2配置集合，将USB闪存驱动器转化为一个多启动设备，可以让你从一个简单的VFAT格式化的USB存储设备上轻松启动多个GNU/Linux发行版的ISO镜像。这个项目旨在提供一种便...
MultiBoot 和 QuickBoot
ToFPGA的博客
05-10 3054
7系列 MultiBoot 功能可用于控制 FPGA 加载两个及以上程序，可指定 FPGA 从指定的 Flash 地址加载程序。Fallback 加载 golden 程序MultiBoot 加载 update 程序注：Virtex®-7 HT FPGA不支持 Fallback MultiBoot 功能。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值