操作系统实现----多进程（无特权级转移）

在上一篇的基础之上，写一个多进程程序：程序切换原理：在定时中断的时候将当前进程的现场保存在当前进程的堆栈中（中断时并自动压入eflag，cs，eip，因为没有特权级的转变，所以也没有堆栈的切换），然后将栈设为目标进程的堆栈，并弹出该进程现场，中断最后的iret指令会将程序接着目标进程的eip运行。

kernel.s因为将所有的段偏移设为0，所以编程时地址的处理非常容易。

boot.s

%define KERNEL_SEG 0x1000 ;内核开始运行的段位置
%define KERNEL_LEN 20 ;内核扇区所占数目

org 0x7c00

mov ax,cs
mov ds,ax
mov es,ax

mov ax,msg
mov bp,ax
mov ax,0x1301
mov bx,0x000c
mov cx,msgLen
mov dx,0x0000
int 10h;

load:
mov ax,KERNEL_SEG
mov es,ax
mov ah,02
mov al,KERNEL_LEN
xor bx,bx
mov ch,0
mov cl,2
mov dh,0
mov dl,0
int 13h

movKernel:
mov ax,KERNEL_SEG
mov ds,ax
xor ax,ax
mov es,ax
xor si,si
xor di,di
mov cx,KERNEL_LEN * 512
cli
copy:
mov al,[ds:si]
mov [es:di],al
inc si
inc di
loop copy

jmp 0:0

msg: db "Loading kernel"
msgLen equ $-msg

times 510-($-$$) db 0
dw 0xaa55

kernel.s:

%define STACK_LEN 1024		;内核栈空间、进程栈空间大小

jmp start
;gdt
gdt:	db 0,0,0,0,0,0,0,0
gdt_cs:	db 0xff,0x7,0,0,0,0x9a,0xc0,0
gdt_ds:	db 0xff,0x7,0,0,0,0x92,0xc0,0
gdt_gs:	db 0x02,0,0,0x80,0x0b,0x92,0xc0,0

gdtLen equ $-gdt

selector_cs equ gdt_cs - gdt
selector_ds equ gdt_ds - gdt
selector_gs equ gdt_gs - gdt

gdtPtr:
dw	gdtLen - 1
dd	gdt

idt:
%rep 8
dw 	intHandler	;offset
dw	selector_cs	;selector
dw	0x8e00		;property
dw	0			;offset
%endrep
dw 	timeInt		;offset
dw	selector_cs	;selector
dw	0x8e00		;property
dw	0			;offset
%rep 256-9
dw 	intHandler	;offset
dw	selector_cs	;selector
dw	0x8e00		;property
dw	0			;offset
%endrep

idtLen	equ $ - idt

idtPtr:
dw	idtLen - 1
dd	idt

start:
mov ax,cs
mov ds,ax
mov es,ax

lgdt [gdtPtr]

cli

lidt [idtPtr]

in al,0x92
or al,00000010b
out 0x92,al

mov eax,cr0
or eax,1
mov cr0,eax

jmp selector_cs:start_32

[bits 32]
start_32:
mov ax,selector_ds
mov ds,ax			;数据段初始化
mov ss,ax			;堆栈段初始化
mov esp,stack_top	;堆栈栈底

mov ah,0x0c
mov al,'P'
call dis_str
int 0x80
int 0x80

mov al,0x36		;控制字：通道0工作方式3、计数初值采用二进制
out 0x43,al
mov ax,11930	;频率为100hz
out 0x40,al		;低位
mov al,ah
out 0x40,al		;高位

sti

;初始化两个进程，主要是进程对应的堆栈区，事先要压入现场信息
;初始化进程1的堆栈
mov ax,selector_ds
mov ss,ax			;堆栈段初始化
mov esp,stack_top_1	;堆栈栈底

pushf
push dword selector_cs		;push cs
push dword task_1			;push eip

push ds
push es
push fs
push gs
pushad
mov [stack_1],esp		;保存进程1现在的栈指针

;初始化进程0的堆栈
mov ax,selector_ds
mov ss,ax			;堆栈段初始化
mov esp,stack_top_0	;堆栈栈底

mov [stack_0],esp	;进程0的堆栈指针

pushf
push dword selector_cs		;push cs
push dword task_0			;push eip

iret		;启动进程0

jmp $		;等待时钟中断去切换执行两个任务
;
dis_str:
push ebx
mov bx,selector_gs
mov gs,bx
mov bx,selector_ds
mov ds,bx
mov ebx,[cursor_i]
shl ebx,1
mov [gs:ebx],ax
shr ebx,1
inc ebx
cmp ebx,80*25
jne .1
mov ebx,0
.1:	mov [cursor_i],ebx
pop ebx
ret

intHandler:
iret
mov ah,0x0c
mov al,'I'
call dis_str
mov al,'n'
call dis_str
mov al,'t'
call dis_str
;	mov al,0x20			;发送EOI 	;为什么这些中断不需要写这句话？
;	out 0x20,al			;中断处理结束，要是没有这一句的话，只能响应中断一次
iret

timeInt:
push ds
push es
push fs
push gs
pushad
;由于已经保存了现场，这些寄存器可以使用了
;切换到内核空间
mov	ax,selector_ds
mov ds,ax
mov al,[process_now]
cmp al,0

jne	j1
;如果是进程0
mov [stack_0],esp	;保存进程0的堆栈指针
mov al,1
mov [process_now],al
mov ax,selector_ds
mov ss,ax			;切换到进程1的堆栈
mov esp,[stack_1]	;
jmp j2
j1:
;如果是进程1
mov [stack_1],esp
mov al,0
mov [process_now],al
mov ax,selector_ds
mov ss,ax			;
mov esp,[stack_0]	;切换到进程0的堆栈,
j2:	mov al,0x20			;发送EOI
out 0x20,al			;中断处理结束，要是没有这一句的话，只能响应中断一次

;将目标进程的现场回复
popad	;popad 将通用寄存器弹出（除了esp）
pop gs
pop fs
pop es
pop ds

iret

task_0:
loo:
mov ah,0x0c
mov al,'A'
call dis_str
mov ecx,0xfffff		;delay
loop $
jmp loo
task_1:
loo2:
mov ah,0x0b
mov al,'B'
call dis_str
mov ecx,0xfffff		;delay
loop $
jmp loo2

data_label:
cursor_i dd 80		;显示屏幕位置
process_now	db	0	;当前运行进程
stack_0	dd	0		;0进程的栈指针
stack_1	dd	0		;1进程的栈指针

times STACK_LEN db 0
stack_top:		;内核栈底
times STACK_LEN db 0
stack_top_0:	;进程0使用的堆栈
times STACK_LEN db 0
stack_top_1:	;进程1使用的堆栈

times (512*20 - ($-$$)) db 0