|
|
## 第六章．（实验5）进程的封装
|
|
|
|
|
|
### 6.1 实验内容
|
|
|
|
|
|
实验要求：在APP里写fork调用，其执行过程将fork出一个子进程。在代理内核中实现fork的处理例程（trap），使其能够支撑APP程序的正确执行。
|
|
|
|
|
|
在本次实验的app4.c文件中，将会测试fork（）函数。代码中170及172系统调用分别对应着sys_fork（）和sys_getpid（）系统调用。调用fork函数后，将会有两个返回。在父进程中，fork返回新创建子进程的进程ID；而在子进程中，fork返回0。你需要阅读proc.c文件，完善相关代码，是的app4.c可以正常运行。
|
|
|
|
|
|
|
|
|
|
|
|
**6.1.1 练习一：alloc_proc（需要编程）**
|
|
|
|
|
|
完善"pk/proc.c"中的alloc_proc()，你需要对以下属性进行初始化：
|
|
|
|
|
|
l enum proc_state state;
|
|
|
|
|
|
l int pid;
|
|
|
|
|
|
l int runs;
|
|
|
|
|
|
l uintptr_t kstack;
|
|
|
|
|
|
l volatile bool need_resched;
|
|
|
|
|
|
l struct proc_struct *parent;
|
|
|
|
|
|
l struct mm_struct *mm;
|
|
|
|
|
|
l struct context context;
|
|
|
|
|
|
l struct trapframe *tf;
|
|
|
|
|
|
l uintptr_t cr3;
|
|
|
|
|
|
l uint32_t flags;
|
|
|
|
|
|
l char name[PROC_NAME_LEN + 1];
|
|
|
|
|
|
|
|
|
|
|
|
**6.1.2 练习二：do_fork（需要编程）**
|
|
|
|
|
|
完善"pk/proc.c"中的do_fork函数，你需要进行以下工作：
|
|
|
|
|
|
l 调用alloc_proc()来为子进程创建进程控制块
|
|
|
|
|
|
l 调用setup_kstack来设置栈空间
|
|
|
|
|
|
l 用copy_mm来拷贝页表
|
|
|
|
|
|
l 调用copy_thread来拷贝进程
|
|
|
|
|
|
l 为子进程设置pid
|
|
|
|
|
|
l 设置子进程状态为就绪
|
|
|
|
|
|
l 将子进程加入到链表中
|
|
|
|
|
|
|
|
|
|
|
|
完成以上代码后，你可以进行如下测试，然后输入如下命令：
|
|
|
|
|
|
`$ riscv64-unknown-elf-gcc ../app/app5.c -o ../app/elf/app5`
|
|
|
|
|
|
`$ spike ./obj/pke app/elf/app5`
|
|
|
|
|
|
预期的输出如下：
|
|
|
|
|
|
```
|
|
|
PKE IS RUNNING
|
|
|
page fault vaddr:0x00000000000100c2
|
|
|
page fault vaddr:0x000000000001e17f
|
|
|
page fault vaddr:0x0000000000018d5a
|
|
|
page fault vaddr:0x000000000001a8ba
|
|
|
page fault vaddr:0x000000000001d218
|
|
|
page fault vaddr:0x000000007f7e8bf0
|
|
|
page fault vaddr:0x0000000000014a68
|
|
|
page fault vaddr:0x00000000000162ce
|
|
|
page fault vaddr:0x000000000001c6e0
|
|
|
page fault vaddr:0x0000000000012572
|
|
|
page fault vaddr:0x0000000000011fa6
|
|
|
page fault vaddr:0x0000000000019064
|
|
|
page fault vaddr:0x0000000000015304
|
|
|
page fault vaddr:0x0000000000017fd4
|
|
|
this is farther process;my pid = 1
|
|
|
sys_exit pid=1
|
|
|
page fault vaddr:0x0000000000010166
|
|
|
page fault vaddr:0x000000000001e160
|
|
|
page fault vaddr:0x000000000001d030
|
|
|
page fault vaddr:0x0000000000014a68
|
|
|
page fault vaddr:0x00000000000162ce
|
|
|
page fault vaddr:0x000000000001c6e0
|
|
|
page fault vaddr:0x0000000000012572
|
|
|
page fault vaddr:0x0000000000011fa6
|
|
|
page fault vaddr:0x0000000000019064
|
|
|
page fault vaddr:0x000000000001abb6
|
|
|
page fault vaddr:0x0000000000015304
|
|
|
page fault vaddr:0x0000000000017fd4
|
|
|
page fault vaddr:0x0000000000018cd4
|
|
|
this is child process;my pid = 2
|
|
|
sys_exit pid=2
|
|
|
```
|
|
|
|
|
|
如果你的app可以正确输出的话，那么运行检查的python脚本：
|
|
|
|
|
|
`./pke-lab5`
|
|
|
|
|
|
若得到如下输出，那么恭喜你，你已经成功完成了实验六！！！
|
|
|
|
|
|
|
|
|
|
|
|
```
|
|
|
build pk : OK
|
|
|
running app5 : OK
|
|
|
test fork : OK
|
|
|
Score: 20/20
|
|
|
```
|
|
|
|
|
|
### 6.2 基础知识
|
|
|
|
|
|
**6.2.1 进程结构**
|
|
|
|
|
|
在pk/proc.h中，我们定义进程的结构如下：
|
|
|
|
|
|
```
|
|
|
42 struct proc_struct {
|
|
|
43 enum proc_state state;
|
|
|
44 int pid;
|
|
|
45 int runs;
|
|
|
46 uintptr_t kstack;
|
|
|
47 volatile bool need_resched;
|
|
|
48 struct proc_struct *parent;
|
|
|
50 struct context context;
|
|
|
51 trapframe_t *tf;
|
|
|
52 uintptr_t cr3;
|
|
|
53 uint32_t flags;
|
|
|
54 char name[PROC_NAME_LEN + 1];
|
|
|
55 list_entry_t list_link;
|
|
|
56 list_entry_t hash_link;
|
|
|
57 };
|
|
|
```
|
|
|
|
|
|
可以看到在41行的枚举中，我们定义了进程的四种状态，其定义如下：
|
|
|
|
|
|
```
|
|
|
11 enum proc_state {
|
|
|
12 PROC_UNINIT = 0,
|
|
|
13 PROC_SLEEPING,
|
|
|
14 PROC_RUNNABLE,
|
|
|
15 PROC_ZOMBIE,
|
|
|
16 };
|
|
|
```
|
|
|
|
|
|
四种状态分别为未初始化(PROC_UNINIT)、睡眠（PROC_SLEEPING）、可运行（PROC_RUNNABLE）以及僵死（PROC_ZOMBIE）状态。
|
|
|
|
|
|
除却状态，进程还有以下重要属性：
|
|
|
|
|
|
l pid：进程id，是进程的标识符
|
|
|
|
|
|
l runs：进程已经运行的时间
|
|
|
|
|
|
l kstack：进程的内核栈空间
|
|
|
|
|
|
l need_resched：是否需要释放CPU
|
|
|
|
|
|
l parent：进程的父进程
|
|
|
|
|
|
l context：进程的上下文
|
|
|
|
|
|
l tf：当前中断的栈帧
|
|
|
|
|
|
l cr3：进程的页表地址
|
|
|
|
|
|
l name：进程名
|
|
|
|
|
|
除了上述属性，可以看到在55、56行还维护了两个进程的链表，这是操作系统内进程的组织方式，系统维护一个进程链表，以组织要管理的进程。
|
|
|
|
|
|
|
|
|
|
|
|
**6.2.2 设置第一个内核进程idleproc**
|
|
|
|
|
|
在"pk/pk.c"的rest_of_boot_loader函数中调用了proc_init来设置第一个内核进程：
|
|
|
|
|
|
```
|
|
|
317 void
|
|
|
318 proc_init() {
|
|
|
319 int i;
|
|
|
320 extern uintptr_t kernel_stack_top;
|
|
|
321
|
|
|
322 list_init(&proc_list);
|
|
|
323 for (i = 0; i < HASH_LIST_SIZE; i ++) {
|
|
|
324 list_init(hash_list + i);
|
|
|
325 }
|
|
|
326
|
|
|
327 if ((idleproc = alloc_proc()) == NULL) {
|
|
|
328 panic("cannot alloc idleproc.\n");
|
|
|
329 }
|
|
|
330
|
|
|
331 idleproc->pid = 0;
|
|
|
332 idleproc->state = PROC_RUNNABLE;
|
|
|
333 idleproc->kstack = kernel_stack_top;
|
|
|
334 idleproc->need_resched = 1;
|
|
|
335 set_proc_name(idleproc, "idle");
|
|
|
336 nr_process ++;
|
|
|
337
|
|
|
338 currentproc = idleproc;
|
|
|
339
|
|
|
340 }
|
|
|
```
|
|
|
|
|
|
322行的proc_list是系统所维护的进程链表，324行的hash_list是一个大小为1024的list_entry_t的hash数组。在对系统所维护的两个list都初始化完成后，系统为idleproc分配进程结构体。然后对idleproc的各个属性进行设置，最终将currentproc改为idleproc。
|
|
|
|
|
|
在上述代码中，我们只是为idleproc分配了进程控制块，但并没有切换到idleproc，真正的切换代码在proc_init函数后面的run_loaded_program以及cpu_idle函数中进行。
|
|
|
|
|
|
|
|
|
|
|
|
**6.2.3 do_fork**
|
|
|
|
|
|
在run_loaded_program中有如下代码：
|
|
|
|
|
|
```
|
|
|
140 trapframe_t tf;
|
|
|
141 init_tf(&tf, current.entry, stack_top);
|
|
|
142 __clear_cache(0, 0);
|
|
|
143 do_fork(0,stack_top,&tf);
|
|
|
144 write_csr(sscratch, kstack_top);
|
|
|
```
|
|
|
|
|
|
在这里，声明了一个trapframe，并且将它的gpr[2]（sp）设置为内核栈指针，将它的epc设置为current.entry，其中current.entry是elf文件的入口地址也就是app的起始执行位置，随即，我们调用了do_frok函数，其中传入参数stack为0表示我们正在fork一个内核进程。
|
|
|
|
|
|
在do_frok函数中，你会调用alloc_proc()来为子进程创建进程控制块、调用setup_kstack来设置栈空间，调用copy_mm来拷贝页表，调用copy_thread来拷贝进程。现在，我们来对以上函数进行分析。
|
|
|
|
|
|
setup_kstack函数代码如下，在函数中，我们为进程分配栈空间，然后返回：
|
|
|
|
|
|
```
|
|
|
210 static int
|
|
|
211 setup_kstack(struct proc_struct *proc) {
|
|
|
212 proc->kstack = (uintptr_t)__page_alloc();
|
|
|
213 return 0;
|
|
|
214 }
|
|
|
```
|
|
|
|
|
|
copy_mm k函数代码如下，在函数中，我们对页表进行拷贝。
|
|
|
|
|
|
```
|
|
|
228 static int
|
|
|
229 copy_mm(uint32_t clone_flags, struct proc_struct *proc) {
|
|
|
230 //assert(currentproc->mm == NULL);
|
|
|
231 /* do nothing in this project */
|
|
|
232 uintptr_t cr3=(uintptr_t)__page_alloc();
|
|
|
233 memcpy((void *)cr3,(void *)proc->cr3,RISCV_PGSIZE);
|
|
|
234 proc->cr3=cr3;
|
|
|
235 return 0;
|
|
|
236 }
|
|
|
```
|
|
|
|
|
|
最后是copy_thread函数：
|
|
|
|
|
|
```
|
|
|
240 static void
|
|
|
241 copy_thread(struct proc_struct *proc, uintptr_t esp, trapframe_t *tf) {
|
|
|
242 proc->tf = (trapframe_t *)(proc->kstack + KSTACKSIZE - sizeof(trapframe_t));
|
|
|
243 *(proc->tf) = *tf;
|
|
|
244
|
|
|
245 proc->tf->gpr[10] = 0;
|
|
|
246 proc->tf->gpr[2] = (esp == 0) ? (uintptr_t)proc->tf -4 : esp;
|
|
|
247
|
|
|
248 proc->context.ra = (uintptr_t)forkret;
|
|
|
249 proc->context.sp = (uintptr_t)(proc->tf);
|
|
|
250 }
|
|
|
```
|
|
|
|
|
|
在函数中，首先对传入的栈帧进行拷贝，并且将上下文中的ra设置为地址forkret，将sp设置为该栈帧。
|
|
|
|
|
|
完成以上几步后，我们为子进程设置pid，将其加入到进程链表当中，并且设置其状态为就绪。
|
|
|
|
|
|
|
|
|
|
|
|
**6.2.3 上下文切换**
|
|
|
|
|
|
每个进程都有着自己的上下文，在进程间切换时，需要对上下文一并切换。
|
|
|
|
|
|
在pk/proc.c的cpu_idle中有以下代码：
|
|
|
|
|
|
```
|
|
|
374 void
|
|
|
375 cpu_idle(void) {
|
|
|
376 while (1) {
|
|
|
377 if (currentproc->need_resched) {
|
|
|
378 schedule();
|
|
|
379 }
|
|
|
380 }
|
|
|
381 }
|
|
|
```
|
|
|
|
|
|
在当前进程处于need_resched状态时，会执行调度算法schedule，其代码如下：
|
|
|
|
|
|
```
|
|
|
16 void
|
|
|
17 schedule(void) {
|
|
|
18 list_entry_t *le, *last;
|
|
|
19 struct proc_struct *next = NULL;
|
|
|
20 {
|
|
|
21 currentproc->need_resched = 0;
|
|
|
22 last = (currentproc == idleproc) ? &proc_list : &(currentproc->list_link);
|
|
|
23 le = last;
|
|
|
24 do {
|
|
|
25 if ((le = list_next(le)) != &proc_list) {
|
|
|
26 next = le2proc(le, list_link);
|
|
|
27 if (next->state == PROC_RUNNABLE) {
|
|
|
28 break;
|
|
|
29 }
|
|
|
30 }
|
|
|
31 } while (le != last);
|
|
|
32 if (next == NULL || next->state != PROC_RUNNABLE) {
|
|
|
33 next = idleproc;
|
|
|
34 }
|
|
|
35 next->runs ++;
|
|
|
36 if (next != currentproc) {
|
|
|
37 proc_run(next);
|
|
|
38 }
|
|
|
39 }
|
|
|
40 }
|
|
|
```
|
|
|
|
|
|
在schedule函数中找到下一个需要执行的进程，并执行，执行代码proc_run如下：
|
|
|
|
|
|
```
|
|
|
145 void
|
|
|
146 proc_run(struct proc_struct *proc) {
|
|
|
147 if (proc != currentproc) {
|
|
|
148 bool intr_flag;
|
|
|
149 struct proc_struct *prev = currentproc, *next = proc;
|
|
|
150 currentproc = proc;
|
|
|
151 write_csr(sptbr, ((uintptr_t)next->cr3 >> RISCV_PGSHIFT) | SATP_MODE_CHOICE);
|
|
|
152 switch_to(&(prev->context), &(next->context));
|
|
|
153
|
|
|
154 }
|
|
|
155 }
|
|
|
```
|
|
|
|
|
|
当传入的proc不为当前进程时，执行切换操作：
|
|
|
|
|
|
```
|
|
|
7 switch_to:
|
|
|
8 # save from's registers
|
|
|
9 STORE ra, 0*REGBYTES(a0)
|
|
|
10 STORE sp, 1*REGBYTES(a0)
|
|
|
11 STORE s0, 2*REGBYTES(a0)
|
|
|
12 STORE s1, 3*REGBYTES(a0)
|
|
|
13 STORE s2, 4*REGBYTES(a0)
|
|
|
14 STORE s3, 5*REGBYTES(a0)
|
|
|
15 STORE s4, 6*REGBYTES(a0)
|
|
|
16 STORE s5, 7*REGBYTES(a0)
|
|
|
17 STORE s6, 8*REGBYTES(a0)
|
|
|
18 STORE s7, 9*REGBYTES(a0)
|
|
|
19 STORE s8, 10*REGBYTES(a0)
|
|
|
20 STORE s9, 11*REGBYTES(a0)
|
|
|
21 STORE s10, 12*REGBYTES(a0)
|
|
|
22 STORE s11, 13*REGBYTES(a0)
|
|
|
23
|
|
|
24 # restore to's registers
|
|
|
25 LOAD ra, 0*REGBYTES(a1)
|
|
|
26 LOAD sp, 1*REGBYTES(a1)
|
|
|
27 LOAD s0, 2*REGBYTES(a1)
|
|
|
28 LOAD s1, 3*REGBYTES(a1)
|
|
|
29 LOAD s2, 4*REGBYTES(a1)
|
|
|
30 LOAD s3, 5*REGBYTES(a1)
|
|
|
31 LOAD s4, 6*REGBYTES(a1)
|
|
|
32 LOAD s5, 7*REGBYTES(a1)
|
|
|
33 LOAD s6, 8*REGBYTES(a1)
|
|
|
34 LOAD s7, 9*REGBYTES(a1)
|
|
|
35 LOAD s8, 10*REGBYTES(a1)
|
|
|
36 LOAD s9, 11*REGBYTES(a1)
|
|
|
37 LOAD s10, 12*REGBYTES(a1)
|
|
|
38 LOAD s11, 13*REGBYTES(a1)
|
|
|
39
|
|
|
40 ret
|
|
|
```
|
|
|
|
|
|
可以看到，在switch_to中，我们正真执行了上一个进程的上下文保存，以及下一个进程的上下文加载。在switch_to的最后一行，我们执行ret指令，该指令是一条从子过程返回的伪指令，会将pc设置为x1（ra）寄存器的值，还记得我们在copy_thread中层将ra设置为forkret嘛？现在程序将从forkret继续执行：
|
|
|
|
|
|
```
|
|
|
160 static void
|
|
|
161 forkret(void) {
|
|
|
162 extern elf_info current;
|
|
|
163 load_elf(current.file_name,¤t);
|
|
|
164
|
|
|
165 int pid=currentproc->pid;
|
|
|
166 struct proc_struct * proc=find_proc(pid);
|
|
|
167 write_csr(sscratch, proc->tf);
|
|
|
168 set_csr(sstatus, SSTATUS_SUM | SSTATUS_FS);
|
|
|
169 currentproc->tf->status = (read_csr(sstatus) &~ SSTATUS_SPP &~ SSTATUS_SIE) | SSTATUS_SPIE;
|
|
|
170 forkrets(currentproc->tf);
|
|
|
171 }
|
|
|
```
|
|
|
|
|
|
|
|
|
|
|
|
我们进入forkrets：
|
|
|
|
|
|
```
|
|
|
121 forkrets:
|
|
|
122 # set stack to this new process's trapframe
|
|
|
123 move sp, a0
|
|
|
124 addi sp,sp,320
|
|
|
125 csrw sscratch,sp
|
|
|
126 j start_user
|
|
|
```
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
```
|
|
|
76 .globl start_user
|
|
|
77 start_user:
|
|
|
78 LOAD t0, 32*REGBYTES(a0)
|
|
|
79 LOAD t1, 33*REGBYTES(a0)
|
|
|
80 csrw sstatus, t0
|
|
|
81 csrw sepc, t1
|
|
|
82
|
|
|
83 # restore x registers
|
|
|
84 LOAD x1,1*REGBYTES(a0)
|
|
|
85 LOAD x2,2*REGBYTES(a0)
|
|
|
86 LOAD x3,3*REGBYTES(a0)
|
|
|
87 LOAD x4,4*REGBYTES(a0)
|
|
|
88 LOAD x5,5*REGBYTES(a0)
|
|
|
89 LOAD x6,6*REGBYTES(a0)
|
|
|
90 LOAD x7,7*REGBYTES(a0)
|
|
|
91 LOAD x8,8*REGBYTES(a0)
|
|
|
92 LOAD x9,9*REGBYTES(a0)
|
|
|
93 LOAD x11,11*REGBYTES(a0)
|
|
|
94 LOAD x12,12*REGBYTES(a0)
|
|
|
95 LOAD x13,13*REGBYTES(a0)
|
|
|
96 LOAD x14,14*REGBYTES(a0)
|
|
|
97 LOAD x15,15*REGBYTES(a0)
|
|
|
98 LOAD x16,16*REGBYTES(a0)
|
|
|
99 LOAD x17,17*REGBYTES(a0)
|
|
|
100 LOAD x18,18*REGBYTES(a0)
|
|
|
101 LOAD x19,19*REGBYTES(a0)
|
|
|
102 LOAD x20,20*REGBYTES(a0)
|
|
|
103 LOAD x21,21*REGBYTES(a0)
|
|
|
104 LOAD x22,22*REGBYTES(a0)
|
|
|
105 LOAD x23,23*REGBYTES(a0)
|
|
|
106 LOAD x24,24*REGBYTES(a0)
|
|
|
107 LOAD x25,25*REGBYTES(a0)
|
|
|
108 LOAD x26,26*REGBYTES(a0)
|
|
|
109 LOAD x27,27*REGBYTES(a0)
|
|
|
110 LOAD x28,28*REGBYTES(a0)
|
|
|
111 LOAD x29,29*REGBYTES(a0)
|
|
|
112 LOAD x30,30*REGBYTES(a0)
|
|
|
113 LOAD x31,31*REGBYTES(a0)
|
|
|
114 # restore a0 last
|
|
|
115 LOAD x10,10*REGBYTES(a0)
|
|
|
116
|
|
|
117 # gtfo
|
|
|
118 sret
|
|
|
```
|
|
|
|
|
|
可以看到在forkrets最后执行了sret，程序就此由内核切换至用户程序执行！！
|
|
|
|
|
|
|
