用 GRUB 引导自己的操作系统

柔情只为你懂 2022-05-28 11:00 434阅读 0赞

### [用 GRUB 引导自己的操作系统][GRUB] ###

分类： [操作系统][Link 1] 2012-05-19 21:02  136人阅读  [评论][Link 2](2)  收藏  [举报][Link 3]

在 PC 机上捣鼓自己的操作系统遇到的第一个难题就是如何将内核加载到内存中执行。如果读过于渊写的《自己动手写操作系统》就会知道这部分的工作还是蛮繁琐的。而且实际上这部分工作和操作系统没太大的关系。好在随着 linux 等开源操作系统的发展，开源的引导加载程序也已经发展的很成熟了。我们可以利用前人的成果，将自己的操作系统改造成可以用现有引导加载程序引导的内核。  
   
引导加载程序（BootLoader）是系统加电后运行的第一段软件代码。x86 系统中的引导加载程序由 BIOS(Basic Input Output System，基本输入输出系统)和位于硬盘主引导记录（MBR，Master Boot Record）中的操作系统引导加载程序（比如，LILO 和 GRUB 等）一起组成。BIOS 在完成硬件检测和资源分配后，将硬盘 MBR 中的引导加载程序读到系统的 RAM 中，然后将控制权交给操作系统引导加载程序。引导加载程序的主要运行任务就是将内核映象从硬盘上读到 RAM 中，然后跳转到内核的入口点去运行，也即开始启动操作系统。   
   
引导加载程序并非操作系统的一部分，但是没有引导加载程序加载操作系统，操作系统是无法自动运行起来的。可以在 x86 系统中运行的操作系统超过 100 种，其中较为有名的如微软公司出品的 DOS、Windows 系列，开放源代码的 Linux、FreeBS D等也不下 10 余种。这些各具特色的操作系统几乎都有其专用的引导加载程序，并且互相之间并不兼容。  
   
经过对比各种常见的引导加载程序的功能和可靠性，我选择了多重操作系统启动管理器 GRUB 作为引导加载程序。GRUB 是一个来自自由软件基金会项目的多操作系统启动程序，它允许用户可以在计算机内同时拥有多个操作系统，并在计算机启动时选择希望运行的操作系统。GRUB 可用于选择操作系统分区上的不同内核，也可用于向这些内核传递启动参数。  
   
GRUB 引导加载程序广泛应用于 Linux、各种 BSD 系统的引导，具有极高的可靠性。满足多重引导规范（The Multiboot Specification），可以引导各种满足多重引导规范的操作系统内核。并且可以通过配置文件配置为多引导模式，当加载的系统出现故障无法工作时可以自动启用备用系统，极大的提高了系统的可靠性。  
   
多重引导规范   
   
多重引导规范并不强制要求内核的格式，但是如果采用 ELF 格式，将会带来许多方便。本文下面的介绍都是基于内核采用 ELF 格式。如果您的内核碰巧不能采用 ELF 格式，请您参考多重引导规范的官方文本中 3.1 节关于 Multiboot Header 的介绍。  
   
能够被 GRUB 引导的内核有两个条件：   
(1) 需要有一个 Multiboot Header ，这个  Multiboot Header 必须在内核镜像的前 8192 个字节内，并且是首地址是 4 字节对其的。    
(2) 内核的加载地址在 1MB 以上的内存中，这个要求是 GRUB 附加的，并非多重引导规范的规定。   
   
Multiboot Header   
   
Multiboot Header的分布必须如下所示：   
   
偏移量    类型    域名                 备注   
0     u32     magic                       必需   
4     u32     flags                         必需   
8     u32     checksum               必需   
12     u32     header\_addr        如果flags\[16\]被置位   
16     u32     load\_addr             如果flags\[16\]被置位   
20     u32     load\_end\_addr    如果flags\[16\]被置位   
24     u32     bss\_end\_addr     如果flags\[16\]被置位   
28     u32     entry\_addr            如果flags\[16\]被置位   
32     u32     mode\_type           如果flags\[2\]被置位   
36     u32     width                      如果flags\[2\]被置位   
40     u32     height                    如果flags\[2\]被置位   
44     u32     depth                     如果flags\[2\]被置位    
   
magic    
    域是标志头的魔数，它必须等于十六进制值 0x1BADB002。   
   
flags   
    flags域指出OS映像需要引导程序提供或支持的特性。0-15 位指出需求：如果引导程序发现某些值被设置但出于某种原因不理解或不能不能满足相应的需求，它必须告知用户并宣告引导失败。16-31位指出可选的特性：如果引导程序不能支持某些位，它可以简单的忽略它们并正常引导。自然，所有 flags 字中尚未定义的位必须被置为 0。这样，flags 域既可以用于版本控制也可以用于简单的特性选择。  
   
    如果设置了 flags 字中的 0 位，所有的引导模块将按页（4KB）边界对齐。有些操作系统能够在启动时将包含引导模块的页直接映射到一个分页的地址空间，因此需要引导模块是页对齐的。  
   
    如果设置了 flags 字中的 1 位，则必须通过 Multiboot 信息结构（参见引导信息格式）的 mem\_\* 域包括可用内存的信息。如果引导程序能够传递内存分布（mmap\_\*域）并且它确实存在，则也包括它。  
   
    如果设置了 flags 字中的 2 位，有关视频模式表（参见引导信息格式）的信息必须对内核有效。   
   
    如果设置了 flags 字中的 16 位，则 Multiboot 头中偏移量 8-24 的域有效，引导程序应该使用它们而不是实际可执行头中的域来计算将 OS 映象载入到那里。如果内核映象为 ELF 格式则不必提供这样的信息，但是如果映象是 a.out 格式或者其他什么格式的话就必须提供这些信息。  
   
checksum   
    域 checksum 是一个 32 位的无符号值，当与其他的 magic 域（也就是 magic 和 flags）相加时，结果必须是 32 位的无符号值 0（即magic + flags + checksum = 0）  
   
header\_addr    
    这里往后的 32 个字节不是必须的，并且对于内核为 ELF 格式时是不需要的，因此就不介绍了。   
   
当引导程序调用32位操作系统时，机器状态必须如下：   
   
EAX   
    必须包含魔数 0x2BADB002；这个值指出操作系统是被一个符合 Multiboot 规范的引导程序载入的。   
EBX   
    必须包含由引导程序提供的 Multiboot 信息结构的物理地址（参见引导信息格式）。   
CS   
    必须是一个偏移量位于 0 到 0xFFFFFFFF 之间的 32 位可读/可执行代码段。这里的精确值未定义。   
DS   
ES   
FS   
GS   
SS   
    必须是一个偏移量位于 0 到 0xFFFFFFFF 之间的 32 位可读/可执行代码段。这里的精确值未定义。   
A20 gate   
    必须已经开启。   
CR0   
    第31位（PG）必须为 0。第 0 位（PE）必须为 1。其他位未定义。   
EFLAGS   
    第17位（VM）必须为 0。第 9 位（IF）必须为 1 。其他位未定义。   
   
所有其他的处理器寄存器和标志位未定义。这包括：   
   
ESP   
    当需要使用堆栈时，OS 映象必须自己创建一个。   
GDTR   
    尽管段寄存器像上面那样定义了，GDTR 也可能是无效的，所以 OS 映象决不能载入任何段寄存器（即使是载入相同的值也不行！）直到它设定了自己的 GDT。   
IDTR   
    OS 映象必须在设置完它的 IDT 之后才能开中断。   
   
Multiboot 信息结构（就目前为止定义的）的格式如下：   
   
             +-------------------+   
     0       | flags                |    (必需)   
             +-------------------+   
     4       | mem\_lower         |    (如果flags\[0\]被置位则出现)   
     8       | mem\_upper         |    (如果flags\[0\]被置位则出现)   
             +-------------------+   
     12      | boot\_device       |    (如果flags\[1\]被置位则出现)   
             +-------------------+   
     16      | cmdline           |    (如果flags\[2\]被置位则出现)   
             +-------------------+   
     20      | mods\_count        |    (如果flags\[3\]被置位则出现)   
     24      | mods\_addr         |    (如果flags\[3\]被置位则出现)   
             +-------------------+   
     28 - 40 | syms              |    (如果flags\[4\]或flags\[5\]被置位则出现)   
             |                   |                    
             +-------------------+   
     44      | mmap\_length       |    (如果flags\[6\]被置位则出现)   
     48      | mmap\_addr         |    (如果flags\[6\]被置位则出现)   
             +-------------------+   
     52      | drives\_length     |    (如果flags\[7\]被置位则出现)   
     56      | drives\_addr       |    (如果flags\[7\]被置位则出现)   
             +-------------------+   
     60      | config\_table      |    (如果flags\[8\]被置位则出现)   
             +-------------------+   
     64      | boot\_loader\_name  |    (如果flags\[9\]被置位则出现)   
             +-------------------+   
     68      | apm\_table         |    (如果flags\[10\]被置位则出现)   
             +-------------------+   
     72      | vbe\_control\_info  |    (如果flags\[11\]被置位则出现)   
     76      | vbe\_mode\_info     |   
     80      | vbe\_mode          |   
     82      | vbe\_interface\_seg |   
     84      | vbe\_interface\_off |   
     86      | vbe\_interface\_len |   
             +-------------------+   
        
第一个 longword 指出 Multiboot 信息结构中的其它域是否有效。所有目前未定义的位必须被引导程序设为 0。操作系统应该忽略任何它不理解的位。因此，flags 域也可以视作一个版本标志符，这样可以无破坏的扩展Multiboot信息结构。  
   
如果设置了 flags 中的第 0 位，则 mem\_\* 域有效。mem\_lower 和 mem\_upper 分别指出了低端和高端内存的大小，单位是 K。低端内存的首地址是 0，高端内存的首地址是 1M。低端内存的最大可能值是 640K。返回的高端内存的最大可能值是最大值减去 1M。但并不保证是这个值。  
   
flags 的其他位我没有用到，这里就不介绍了。需要了解的请自己阅读相关文档。   
   
下面是一个最简单的例子：

**\[plain\]**  [view plain][] [copy][view plain]

1.  /\*\*  
2.   \* boot.S  
3.   \*/  
4.     
5.  \#define MULTIBOOT\_HEADER\_MAGIC          0x1BADB002  
6.  \#define MULTIBOOT\_HEADER\_FLAGS          0x00000003  
7.  \#define STACK\_SIZE                      0x4000  
8.     
9.  .text  
10.         .globl  start, \_start  
11.    
12. start:  
13. \_start:  
14.         jmp     multiboot\_entry  
15.    
16.         .align  4  
17.    
18. multiboot\_header:  
19.         .long   MULTIBOOT\_HEADER\_MAGIC  
20.         .long   MULTIBOOT\_HEADER\_FLAGS  
21.         .long   -(MULTIBOOT\_HEADER\_MAGIC + MULTIBOOT\_HEADER\_FLAGS)  
22.    
23. multiboot\_entry:  
24.         /\* 初始化堆栈指针。 \*/  
25.         movl    $(stack + STACK\_SIZE), %esp  
26.    
27.         /\* 重置 EFLAGS。 \*/  
28.         pushl   $0  
29.         popf  
30.    
31.         pushl   %ebx  
32.         pushl   %eax  
33.    
34.         /\* 现在进入 C main 函数... \*/  
35.         call    cmain  
36.    
37. loop:   hlt  
38.         jmp     loop  
39.    
40.         .comm   stack, STACK\_SIZE

**\[cpp\]**  [view plain][] [copy][view plain]

1.  /\*\* 
2.   \* kernel.c 
3.   \*/  
4.    
5.  /\* a.out 符号表。 \*/  
6.  **typedef** **struct** aout\_symbol\_table  
7.  \{  
8.      unsigned **long** tabsize;  
9.      unsigned **long** strsize;  
10.     unsigned **long** addr;  
11.     unsigned **long** reserved;  
12. \} aout\_symbol\_table\_t;  
13.   
14. /\* ELF 的 section header table。 \*/  
15. **typedef** **struct** elf\_section\_header\_table  
16. \{  
17.     unsigned **long** num;  
18.     unsigned **long** size;  
19.     unsigned **long** addr;  
20.     unsigned **long** shndx;  
21. \} elf\_section\_header\_table\_t;  
22.   
23. /\* Multiboot 信息。 \*/  
24. **typedef** **struct** multiboot\_info  
25. \{  
26.     unsigned **long** flags;  
27.     unsigned **long** mem\_lower;  
28.     unsigned **long** mem\_upper;  
29.     unsigned **long** boot\_device;  
30.     unsigned **long** cmdline;  
31.     unsigned **long** mods\_count;  
32.     unsigned **long** mods\_addr;  
33.     **union**  
34.     \{  
35.         aout\_symbol\_table\_t aout\_sym;  
36.         elf\_section\_header\_table\_t elf\_sec;  
37.     \} u;  
38.     unsigned **long** mmap\_length;  
39.     unsigned **long** mmap\_addr;  
40. \} multiboot\_info\_t;  
41.   
42. /\* 检测 FLAGS 中的位 BIT 是否被置位。 \*/  
43. \#define CHECK\_FLAG(flags,bit)   ((flags) & (1 << (bit)))  
44.   
45. /\* 与显示相关的设置。 \*/  
46. \#define COLUMNS                 80  
47. \#define LINES                   24  
48. \#define ATTRIBUTE               7  
49. \#define VIDEO                   0xB8000  
50.   
51. **static** **int** xpos; /\* X 坐标。 \*/  
52. **static** **int** ypos; /\* Y 坐标。 \*/  
53. **static** **volatile** unsigned **char** \*video; /\* 指向显存。 \*/  
54.   
55. **static** **void** cls (**void**);  
56. **static** **void** itoa (**char** \*buf, **int** base, **int** d);  
57. **static** **void** putchar (**int** c);  
58. **void** printf (**const** **char** \*format, ...);  
59.   
60. **void** cmain (unsigned **long** magic, unsigned **long** addr)  
61. \{  
62.     multiboot\_info\_t \*mbi;  
63.   
64.     /\* 清屏。 \*/  
65.     cls ();  
66.   
67.     /\* 将 MBI 指向 Multiboot 信息结构。 \*/  
68.     mbi = (multiboot\_info\_t \*) addr;  
69.   
70.     /\* mem\_\* 是否有效？ \*/  
71.     **if** (CHECK\_FLAG (mbi->flags, 0))  
72.         printf ("mem\_lower = %uKB, mem\_upper = %uKB\\n", (unsigned) mbi->mem\_lower, (unsigned) mbi->mem\_upper);  
73.       
74.     /\* your code here. \*/  
75. \}  
76.   
77. /\* 清屏并初始化 VIDEO，XPOS 和 YPOS。 \*/  
78. **static** **void** cls (**void**)  
79. \{  
80.     **int** i;  
81.   
82.     video = (unsigned **char** \*) VIDEO;  
83.   
84.     **for** (i = 0; i < COLUMNS \* LINES \* 2; i++)  
85.         \*(video + i) = 0;  
86.   
87.     xpos = 0;  
88.     ypos = 0;  
89. \}  
90.   
91. /\* 将整数 D 转换为字符串并保存在 BUF 中。如果 BASE 为 'd'，则 D 为十进制，如果 BASE 为 'x'，则 D 为十六进制。 \*/  
92. **static** **void** itoa (**char** \*buf, **int** base, **int** d)  
93. \{  
94.     **char** \*p = buf;  
95.     **char** \*p1, \*p2;  
96.     unsigned **long** ud = d;  
97.     **int** divisor = 10;  
98.   
99.     /\* 如果指定了 %d 并且 D 是负数，在开始添上负号。 \*/  
100.     **if** (base == 'd' && d < 0)  
101.     \{  
102.         \*p++ = '-';  
103.         buf++;  
104.         ud = -d;  
105.     \}  
106.     **else** **if** (base == 'x')  
107.         divisor = 16;  
108.   
109.     /\* 用 DIVISOR 去除 UD 直到 UD == 0。 \*/  
110.     **do**  
111.     \{  
112.         **int** remainder = ud % divisor;  
113.   
114.         \*p++ = (remainder < 10) ? remainder + '0' : remainder + 'a' - 10;  
115.     \}  
116.     **while** (ud /= divisor);  
117.   
118.     /\* 在字符串尾添上终结符。 \*/  
119.     \*p = 0;  
120.   
121.     /\* 反转 BUF。 \*/  
122.     p1 = buf;  
123.     p2 = p - 1;  
124.     **while** (p1 < p2)  
125.     \{  
126.         **char** tmp = \*p1;  
127.         \*p1 = \*p2;  
128.         \*p2 = tmp;  
129.         p1++;  
130.         p2--;  
131.     \}  
132. \}  
133.   
134. /\* 在屏幕上输出字符 C 。 \*/  
135. **static** **void** putchar (**int** c)  
136. \{  
137.     **if** (c == '\\n' || c == '\\r')  
138.     \{  
139. newline:  
140.         xpos = 0;  
141.         ypos++;  
142.         **if** (ypos >= LINES)  
143.             ypos = 0;  
144.         **return**;  
145.     \}  
146.   
147.     \*(video + (xpos + ypos \* COLUMNS) \* 2) = c & 0xFF;  
148.     \*(video + (xpos + ypos \* COLUMNS) \* 2 + 1) = ATTRIBUTE;  
149.   
150.     xpos++;  
151.     **if** (xpos >= COLUMNS)  
152.         **goto** newline;  
153. \}  
154.   
155. /\* 格式化字符串并在屏幕上输出，就像 libc 函数 printf 一样。 \*/  
156. **void** printf (**const** **char** \*format, ...)  
157. \{  
158.     **char** \*\*arg = (**char** \*\*) &format;  
159.     **int** c;  
160.     **char** buf\[20\];  
161.   
162.     arg++;  
163.   
164.     **while** ((c = \*format++) != 0)  
165.     \{  
166.         **if** (c != '%')  
167.             putchar (c);  
168.         **else**  
169.         \{  
170.             **char** \*p;  
171.   
172.             c = \*format++;  
173.             **switch** (c)  
174.             \{  
175.             **case** 'd':  
176.             **case** 'u':  
177.             **case** 'x':  
178.                 itoa (buf, c, \*((**int** \*) arg++));  
179.                 p = buf;  
180.                 **goto** string;  
181.                 **break**;  
182.   
183.             **case** 's':  
184.                 p = \*arg++;  
185.                 **if** (! p)  
186.                     p = "(null)";  
187.   
188. string:  
189.                 **while** (\*p)  
190.                     putchar (\*p++);  
191.                 **break**;  
192.   
193.             **default**:  
194.                 putchar (\*((**int** \*) arg++));  
195.                 **break**;  
196.             \}  
197.         \}  
198.     \}  
199. \}

下面是编译命令：

gcc kernel.c -c -fno-builtin  
gcc boot.S -c  
ld kernel.o boot.o -o kernel -s -Ttext 0x100000 --entry=start

最后是用 bochs 运行的结果：

![1337432781_5086.png][]

如何运行自己的内核，可以参考我的文章：[制作带有 GRUB 引导功能的软盘镜像文件][GRUB 1]

[GRUB]: http://blog.csdn.net/liyuanbhu/article/details/7583595
[Link 1]: http://blog.csdn.net/liyuanbhu/article/category/1145111
[Link 2]: http://blog.csdn.net/liyuanbhu/article/details/7583595#comments
[Link 3]: http://blog.csdn.net/liyuanbhu/article/details/7583595#report
[view plain]: http://blog.csdn.net/liyuanbhu/article/details/7583595#
[1337432781_5086.png]: https://img-my.csdn.net/uploads/201205/19/1337432781_5086.png
[GRUB 1]: http://blog.csdn.net/liyuanbhu/article/details/7559953