C++博客-lwch-随笔分类-操作系统

自制虚拟机框架

lwch — Sun, 10 Jul 2011 04:30:00 GMT

1.首先我们需要一个结构来表示CPU所有的16位和8位寄存器(见Library\Struct\Register.h)

1 #pragma once
2 #include "..\Common\Base.h"
3
4 struct Register_16_Bit
5 {
6     // General Register
7     struct
8     {
9         BYTE AH; // 8Bit
10         BYTE AL; // 8Bit
11     }AX;
12     struct
13     {
14         BYTE BH; // 8Bit
15         BYTE BL; // 8Bit
16     }BX;
17     struct
18     {
19         BYTE CH; // 8Bit
20         BYTE CL; // 8Bit
21     }CX;
22     struct
23     {
24         BYTE DH; // 8Bit
25         BYTE DL; // 8Bit
26     }DX;
27
28     // Segment Register
29     USHORT CS;
30     USHORT DS;
31     USHORT SS;
32     USHORT ES;
33
34     // Special Register
35     USHORT IP;
36     USHORT SP;
37     USHORT BP;
38     USHORT SI;
39     USHORT DI;
40     struct
41     {
42         BYTE OF : 1;
43         BYTE DF : 1;
44         BYTE IF : 1;
45         BYTE TF : 1;
46         BYTE SF : 1;
47         BYTE ZF : 1;
48         BYTE AF : 1;
49         BYTE PF : 1;
50         BYTE CF : 1;
51         BYTE Reserve : 7;
52     }FR;
53
54     Register_16_Bit()
55     {
56         memset(this,0,sizeof(Register_16_Bit));
57     }
58 };

2.然后我们定义一个接口来抽象出分析过程(见Library\Disasm\DisasmContext.h)

1 #pragma once
2 #include "..\Common\Base.h"
3
4 class CDisasmContext
5 {
6 public:
7 virtual bool Disasm(BYTE*& ptr)=0;
8 protected:
9 enum OpCodeHeader;
10 };

Disasm函数用于对机器码进行分析并确定语义
OpCodeHeader是个枚举类型用于枚举每条指令的指令头(详情见8086指令手册)
3.我们定义一个Jmp类来对Jmp指令进行分析(见Library\Disasm\Jmp)

1 #pragma once
2 #include "..\DisasmContext.h"
3
4 class CJmp : public CDisasmContext
5 {
6 public:
7     virtual bool Disasm(BYTE*& ptr);
8 protected:
9     enum OpCodeHeader
10     {
11         JMP_SHORT = 0xEB,    // 段内直接短跳
12         JMP_NEAR = 0xE9,    // 段内直接跳
13         JMP_FAR = 0xEA,        // 段间直接跳
14         JMP_IND = 0xFF,        // 段内(外)间接跳
15     };
16
17     bool Jmp_Short(BYTE*& ptr);
18     bool Jmp_Near(BYTE*& ptr);
19     bool Jmp_Far(BYTE*& ptr);
20 };

其Disasm函数为

1 bool CJmp::Disasm(BYTE*& ptr)
2 {
3     if(Jmp_Short(ptr)) return true;
4     else if(Jmp_Near(ptr)) return true;
5     else if(Jmp_Far(ptr)) return true;
6     else return false;
7 }

4.我们同样定义一个CMov类来对Mov指令进行分析(见Library\Disasm\Mov)
5.最后我们定义一个CDisasm类来驱动整体框架(见Library\Disasm\Disasm.h)

1 class CDisasm
2 {
3 public:
4     bool Disasm(BYTE* ptr,int size);
5 protected:
6     CJmp Jmp;
7     CMov Mov;
8 };

其Disasm函数为(见Library\Disasm\Disasm.cpp)

1 bool CDisasm::Disasm(BYTE* ptr,int size)
2 {
3     BYTE* end = ptr + size;
4     while(ptr < end)
5     {
6         if(Jmp.Disasm(ptr));
7         else if(Mov.Disasm(ptr));
8         else return false;
9     }
10     return true;
11 }

具体的分析过程其实就是查表的过程,这里不一一列举出来了.
目前只翻译了部分Jmp和Mov指令,有兴趣的同学可以查表对其进行扩充.
所有代码及指令手册打包下载

lwch 2011-07-10 12:30 发表评论

CosmosKernel初探

lwch — Fri, 10 Jun 2011 09:24:00 GMT

CosmosKernel是一个开源项目，意在使C#可以开发操作系统。它首先将C#代码编译为IL中间件，然后交由IL2CPU将IL中间件编译为可执行代码。

下面是测试步骤:
1.下载Userkit
2.安装Userkit
3.启动VS2010并创建CosmosKernelTest项目
4.我们为其编写一个Process的结构表示一个进程

1     public class Process
2     {
3         protected string name;
4         protected Process next;
5
6         public Process(string name)
7         {
8             this.name = name;
9         }
10
11         public string Name
12         {
13             get
14             {
15                 return name;
16             }
17             set
18             {
19                 name = value;
20             }
21         }
22
23         public Process Next
24         {
25             get
26             {
27                 return next;
28             }
29             set
30             {
31                 next = value;
32             }
33         }
34     }

5.我们创建一个ProcessSchedule类来保存Process表以及进行进程调度

1     public class ProcessSchedule
2     {
3         protected Process Head = null;
4         protected Process Tail = null;
5         protected Process Current = null;
6
7         public void AddProcess(Process P)
8         {
9             if (Head == null) Head = Tail = Current = P;
10             else
11             {
12                 P.Next = Head;
13                 Tail.Next = P;
14                 Tail = P;
15             }
16         }
17
18         public void Schedule()
19         {
20             Console.Write(Current.Name + " ");
21             Current = Current.Next;
22         }
23     }

6.我们修改Kernel.cs文件的代码来实现进程调度

1     public class Kernel : Sys.Kernel
2     {
3         protected ProcessSchedule ps = new ProcessSchedule();
4
5         protected override void BeforeRun()
6         {
7             Console.WriteLine("Cosmos booted successfully. Type a line of text to get it echoed back.");
8             Process ProcessA = new Process("ProcessA");
9             Process ProcessB = new Process("ProcessB");
10             Process ProcessC = new Process("ProcessC");
11             ps.AddProcess(ProcessA);
12             ps.AddProcess(ProcessB);
13             ps.AddProcess(ProcessC);
14         }
15
16         protected override void Run()
17         {
18             ps.Schedule();
19         }
20     }

7.选择编译为Release版本，并完成编译生成CosmosKernelTestBoot.iso光盘镜像文件
8.使用虚拟机调试这个操作系统，你会看到屏幕上3个进程在来回切换，但是速度非常快。于是我们为其添加一些循环来降低切换速度

1             for (int i = 0; i < 1000; i++)
2                 for (int j = 0; j < 1000; j++)
3                     for (int k = 0; k < 100; k++) ;

9.编译运行后可以看到运行结果

值得注意的是目前这个项目并不成熟，应此只能实现单任务的操作系统（即一个任务执行完成后再调度另一个任务）。

所有文件打包下载

lwch 2011-06-10 17:24 发表评论

linix0.02添加了任务0

lwch — Mon, 10 Jan 2011 10:44:00 GMT

按《自己动手写操作系统》修改了代码,并添加了任务0

源码打包下载

lwch 2011-01-10 18:44 发表评论

linix0.01添加了键盘中断

lwch — Sat, 25 Dec 2010 08:02:00 GMT

主要完成了键盘中断和printf,printf_c,print_c等内核函数并删除了一些无用的代码
添加了编译环境

源码打包下载
接下来研究进程调度

lwch 2010-12-25 16:02 发表评论

已经初步完成键盘中断处理程序

lwch — Fri, 24 Dec 2010 15:29:00 GMT

明天放出源码..

lwch 2010-12-24 23:29 发表评论

修改Linux0.00时钟中断为键盘中断

lwch — Sat, 11 Dec 2010 09:46:00 GMT

首先修改task1的代码使其运行一次后进入无限循环
将jmp _task1修改为jmp $
将timer_interrupt修改为:

1 _timer_interrupt:
2     PUSH ds
3     PUSH edx
4     PUSH ecx
5     PUSH ebx
6     PUSH eax
7     ;MOV eax,0x10
8     ;MOV dx,ax
9     in al,0x21            ; ┓
10     or al,(1 << 1)    ; ┣ 屏蔽当前中断
11     out 0x21,al            ; ┛
12     mov al,0x20            ; ┓置EOI位,其后8259A才能相应新的中断
13     out 0x20,al            ; ┛
14     sti                            ; 允许响应新中断
15     in al,0x60            ; 从0x60端口读出扫描码
16     ;MOV eax,1
17     ;cmp DWORD [current],eax
18     ;je y1
19     ;MOV DWORD [current],eax
20     ;JMP TSS1_SEL : 0
21     ;jmp y2
22 y1:
23     ;MOV DWORD [current],0
24     ;JMP TSS0_SEL : 0
25     ;MOV eax,0x17
26     ;MOV ds,ax
27     ;MOV al,65
28     call write_char    ; 这里仅简单的将扫描码作为ANSI码打印出来
29     ;MOV ecx,0xfff
30 y2:
31     cli
32     in al,0x21                ; ┓
33     and al,~(1 << 1)    ; ┣ 恢复接受当前中断
34     out 0x21,al                ; ┛
35     POP eax
36     POP ebx
37     POP ecx
38     POP edx
39     POP ds
40     IRET

注:因为键盘中断处理过程运行于Ring0,应此可以直接调用内核函数write_char
然后修改IDT表的0x21(0x21对应于IRQ1,表示键盘中断)项的offset_l和offset_h使其指向timer_interrupt中断处理过程.

1 void init_idt()
2 {
3     int i;
4     for(i=0;i<256;i++)
5     {
6         if(0x21 == i || 0x80 == i)
7         {
8             continue;
9         }
10         setup_int_gate((dword)ignore_int,i);
11     }
12     //setup_int_gate((dword)timer_interrupt,0x20);
13     setup_int_gate((dword)timer_interrupt,0x21);
14     setup_trap_gate((dword)system_interrupt,0x80);
15
16     idtr[0] = 8 * 256;
17     idtr[1] = ((dword)&idt_[0] + KERNEL_BASE) & 0xffff;
18     idtr[2] = ((dword)&idt_[0] + KERNEL_BASE)>>16;
19 }

最后启动键盘中断,将8259A主片的IRQ0位设为1,IRQ1位设为0

1     MOV edx,0x21
2     in al,dx
3     AND al,0xFD
4     OUT dx,al

注:0xFD对应二进制码11111101
调试结果:

按下a键输出一个字符,弹起a键输出另一个字符
由于直接将扫描码作为ANSI码输出因此会出现两个乱码字符

完整代码打包下载

lwch 2010-12-11 17:46 发表评论