实验目的
- 了解内核线程创建/执行的管理过程
- 了解内核线程的切换和基本调度过程
实验内容
练习一：分配并初始化一个进程控制块
1.内核线程及管理
内核线程是一种特殊的进程，内核线程与用户进程的区别有两个：内核线程只运行在内核态，用户进程会在在用户态和内核态交替运行；所有内核线程直接使用共同的ucore内核内存空间，不需为每个内核线程维护单独的内存空间，而用户进程需要拥有各自的内存空间。
把内核线程看作轻量级的进程，对内核线程的管理和对进程的管理是一样的。对进程的管理是通过进程控制块结构实现的，将所有的进程控制块通过链表链接在一起，形成进程控制块链表，对进程的管理和调度就通过从链表中查找对应的进程控制块来完成。
2.进程控制块
保存进程信息的进程控制块结构的定义在kern/process/proc.h中定义如下：
struct proc_struct {
enum proc_state state; // Process state
int pid; // Process ID
int runs; // the running times of Proces
uintptr_t kstack; // Process kernel stack
volatile bool need_resched; // need to be rescheduled to release CPU?
struct proc_struct *parent; // the parent process
struct mm_struct *mm; // Process's memory management field
struct context context; // Switch here to run process
struct trapframe *tf; // Trap frame for current interrupt
uintptr_t cr3; // the base addr of Page Directroy Table(PDT)
uint32_t flags; // Process flag
char name[PROC_NAME_LEN + 1]; // Process name
list_entry_t list_link; // Process link list
list_entry_t hash_link; // Process hash list
};
- mm：在Lab3中，该结构用于内存管理。在对内核线程管理时，由于内核线程不需要考虑换入换出，该结构不需要使用，因此设置为NULL。唯一需要使用的是mm中的页目录地址，保存在cr3变量中。
- state：进程状态，有以下几种
- PROC_UNINIT：未初始化
- PROC_SLEEPING：睡眠状态
- PROC_RUNNABLE：可运行（可能正在运行）
- PROC_ZOMBIE：等待回收
- parent：父进程
- context：进程上下文，用于进程切换
- tf：中断帧指针，用于中断后恢复进程状态
- cr3：页目录的物理地址，用于进程切换时快速找到页表位置
- kstack：线程所使用的内核栈
- list_link：所有进程控制块链接形成的链表的节点
- hash_link：所有进程控制块有一个根据pid建立的哈希表，hash_link是该链表的节点
为了管理系统中的所有进程控制块，ucore还维护了以下全局变量：
- static struct proc *current：当前占用CPU且处于“运行”状态进程控制块指针。通常这个变量是只读的，只有在进程切换的时候才进行修改，并且整个切换和修改过程需要保证操作的原子性，需要屏蔽中断。
- static struct proc *initproc：本实验中，指向一个内核线程。本实验以后，此指针将指向第一个用户态进程。
- static list_entry_t hash_list[HASH_LIST_SIZE]：所有进程控制块的哈希表，proc_struct中的成员变量hash_link将基于pid链接入这个哈希表中。
- list_entry_t proc_list：所有进程控制块的双向线性列表，proc_struct中的成员变量list_link将链接入这个链表中。
3.分配并初始化一个进程控制块
内核线程创建之前，需要先创建一个进程控制块管理保存进程信息。alloc_proc函数负责分配创建一个proc_struct结构，并进行基本的初始化。此时仅是创建了进程块，内核线程本身还没有创建。这是练习一需要完成的部分，具体的实现如下：
static struct proc_struct *
alloc_proc(void) {
struct proc_struct *proc = kmalloc(sizeof(struct proc_struct));
if (proc != NULL) {
proc->state=PROC_UNINIT; //初始状态
proc->pid=-1; //初始PID设为-1
proc->runs=0;
proc->kstack=0;
proc->need_resched=0;
proc->parent=NULL;
proc->mm=NULL;
memset(&(proc -> context), 0, sizeof(struct context));
proc->tf=NULL;
proc->cr3=boot_cr3; //内核线程在内核运行，使用内核页目录
proc->flags=0;
memset(proc->name,0,PROC_NAME_LEN);
}
return proc;
}
4.问题一
请说明proc_struct中struct context context和struct trapframe *tf成员变量含义和在本实验中的作用为？
context保存了进程的上下文信息，即各个寄存器的值，用于进程切换时恢复上下文。tf是中断帧的指针，指向中断帧。中断帧记录了进程被中断前的信息，除寄存器外还有中断号，错误码等信息，用于中断处理后进程状态的恢复。发生中断时，首先从TSS中找到进程内核栈的指针切换到内核栈，然后在内核栈顶建立trapframe，进入内核态。当中断服务例程运行结束，从中断返回时，再从trapframe恢复寄存器的值，并切换回用户态。用户程序在用户态通过系统调用进入内核态，以及在内核态新创建的进程，都通过tf指向的中断帧恢复寄存器的值，从而回到用户态继续运行。
练习二：为新创建的内核线程分配资源
1.进程资源的分配
练习一中实现的alloc_proc为进程创建了进程控制块，将新的进程创建还需要为其分配资源。具体为分配内核栈，将当前的进程的代码及数据，上下文等信息复制给新进程。分配资源的工作是由do_fork函数完成的。do_fork函数会完成分配资源，将新进程添加到进程列表，并把进程设置为可运行状态，最后返回新进程号。
使用do_fork完成资源分配需要使用一些其他函数，这些函数都定义在pro.c中。首先是练习一中实现的创建进程控制块的alloc_proc函数，接下来分配资源的同时也会设置进程控制块中的信息。分配内核栈使用的是setup_kstack函数，通过调用alloc_pages分配大小为KPAGESIZE的页用于栈空间。复制内存管理信息使用的是copy_mm函数，由于本实验创建的是内核线程，常驻内存，不需要进行这个工作。最后是copy_thread函数，完成对原进程的上下文和中断帧的复制。
其中中断帧和上下文的一些内容需要单独进行设置，子进程将在上下文切换后完成进程切换，准备运行，因此上下文的eip设置为forkret，上下文的esp设置为中断帧tf位置，在forkret将从中断帧恢复进程状态，运行进程。中断帧的eax设置为0，因为子进程会返回0，esp设置为父进程的用户栈指针，本实验中创建内核线程，创建出的线程将与父线程共享数据。对于用户进程，copy_mm将复制父进程的内存空间，建立新的页表及映射，使子进程有自己的内存空间。
//分配内核栈空间
static int setup_kstack(struct proc_struct *proc) {
struct Page *page = alloc_pages(KSTACKPAGE);
if (page != NULL) {
proc->kstack = (uintptr_t)page2kva(page);
return 0;
}
return -E_NO_MEM;
}
//copy_mm，根据clone_flags判断复制还是共享内存管理信息
static int copy_mm(uint32_t clone_flags, struct proc_struct *proc) {
assert(current->mm == NULL);
/* do nothing in this project */
return 0;
}
//复制原进程的上下文
static void
copy_thread(struct proc_struct *proc, uintptr_t esp, struct trapframe *tf) {
proc->tf = (struct trapframe *)(proc->kstack + KSTACKSIZE) - 1; //内核栈顶
*(proc->tf) = *tf;
proc->tf->tf_regs.reg_eax = 0; //子进程返回0
proc->tf->tf_esp = esp; //父进程的用户栈指针
proc->tf->tf_eflags |= FL_IF; //设置能够响应中断
proc->context.eip = (uintptr_t)forkret; //返回
proc->context.esp = (uintptr_t)(proc->tf); //trapframe
}
通过以上三个函数，就可以为新进程分配资源，并复制原进程的状态。接下来就可以给这个进程设置一个pid，放入进程列表了。设置pid使用get_pid函数，这个函数在下面的问题一中进行分析。将进程加入进程的哈希列表使用hash_proc函数，还需要使用wakeup_proc函数将进程设置为可运行状态，最后返回该进程的pid，do_fork函数就完成了进程的资源分配。
//将proc加入到hash_list
static void hash_proc(struct proc_struct *proc) {
list_add(hash_list + pid_hashfn(proc->pid), &(proc->hash_link));
}
//sched.c中的wakeup_proc
void wakeup_proc(struct proc_struct *proc) {
assert(proc->state != PROC_ZOMBIE && proc->state != PROC_RUNNABLE);
proc->state = PROC_RUNNABLE;
}
在获取pid和将进程加入链表的操作中，需要使用进程链表，而进程链表是一个全局变量，为了保证多进程下对共享数据的使用不会产生错误，需要添加互斥。此处可能产生的错误在下面问题一中具体分析，此处先说明互斥是如何实现的。对共享数据的使用会产生错误，是因为调度的不可控，可能产生多个线程同时访问临界区的情况。因此只要避免在临界区代码处发生调度就可以实现互斥。在ucore中，提供了local_intr_save和local_intr_restore函数屏蔽和使能中断。这两个函数在kern\sync中，通过一系列调用，最终使用cli和sti进行中断的屏蔽和使能。
static inline bool
__intr_save(void) {
if (read_eflags() & FL_IF) {
intr_disable();
return 1;
}
return 0;
}
static inline void
__intr_restore(bool flag) {
if (flag) {
intr_enable();
}
}
#define local_intr_save(x) do { x = __intr_save(); } while (0)
#define local_intr_restore(x) __intr_restore(x);
//使用方式如下：
bool intr_flag;
local_intr_save(intr_flag);
//临界区代码
local_intr_restore(intr_flag);
2.do_fork分配资源的实现
使用以上提到的相关函数，就可以实现do_fork，为新创建的内核线程分配资源。需要注意的是如果分配资源的某一步不成功，需要把之前分配的资源回收。最终do_fork的实现如下，clone_flags为是否与父进程共享内存管理信息的标志，stack为父进程的用户栈，tf为父进程的中断栈。这是练习二需要完成的部分，代码如下：
int
do_fork(uint32_t clone_flags, uintptr_t stack, struct trapframe *tf) {
int ret = -E_NO_FREE_PROC;
struct proc_struct *proc;
if (nr_process >= MAX_PROCESS) {
goto fork_out;
}
ret = -E_NO_MEM;
//资源分配
if((proc=alloc_proc())==NULL) {
goto fork_out;
}
proc->parent = current; //父进程为当前进程（current为全局变量）
if(setup_kstack(proc)) {
goto bad_fork_cleanup_proc;
}
if(copy_mm(clone_flags,proc)) {
goto bad_fork_cleanup_kstack;
}
copy_thread(proc, stack, tf); //复制上下文和中断帧
//设置pid，加入进程列表，设置为可运行
bool intr_flag;
local_intr_save(intr_flag); //关中断
｛
proc->pid = get_pid();
hash_proc(proc);
list_add(&proc_list, &(proc->list_link));
nr_process ++;
｝
local_intr_restore(intr_flag);
wakeup_proc(proc);
ret=proc->pid;
fork_out:
return ret;
bad_fork_cleanup_kstack:
put_kstack(proc);
bad_fork_cleanup_proc:
kfree(proc);
goto fork_out;
}
make qemu运行后，可以看到init_main内核线程运行，该线程只输出字符串，在后续实验用于创建其他内核线程或用户进程。
...
this initproc, pid = 1, name = "init"
To U: "Hello world!!".
To U: "en.., Bye, Bye. :)"
kernel panic at kern/process/proc.c:347:
process exit!!.
...
3.问题一
请说明ucore是否做到给每个新fork的线程一个唯一的id？请说明你的分析和理由。
ucore通过调用get_pid函数分配pid，对get_pid函数进行分析。
分配pid前，get_pid会先确认可用进程号大于最大进程数。该函数定义了两个静态全局变量，next_safe最初被设置为最大进程号，last_pid最初设置为1，[last_pid，next_safe]就是合法的pid区间。如果last_pid++在这个区间内，就可以直接返回last_pid作为新分配的进程号。如果last_pid>=next_safe，就将next_safe设置为MAX_PID，遍历链表确保last_pid和已有进程的pid不相同，并更新next_safe。维护last_pid到next_safe这个区间将可用的pid范围缩小，以提高了分配的效率，如果区间不合法，也会重新更新区间，并排除和已有进程进程号相同的情况，因此最终产生的进程的pid是唯一的。但是需要注意的是进程链表是全局变量，如果有另一个进程get_pid后还没有把进程加入链表，调度到了当前进程，而当前进程又需要遍历链表排除进程号相同的情况，就可能产生错误，因此要在get_pid和将进程加入链表的位置添加互斥。保证互斥的方法为在do_fork中分配进程号和进程加入进程链表的部分关中断，避免进程调度。
static int
get_pid(void) {
static_assert(MAX_PID > MAX_PROCESS);
struct proc_struct *proc;
list_entry_t *list = &proc_list, *le;
static int next_safe = MAX_PID, last_pid = MAX_PID;
if (++ last_pid >= MAX_PID) {
last_pid = 1;
goto inside;
}
//区间合法性判断
if (last_pid >= next_safe) {
inside:
next_safe = MAX_PID;
repeat:
le = list;
//遍历进程链表
while ((le = list_next(le)) != list) {
proc = le2proc(le, list_link);
if (proc->pid == last_pid) {
if (++ last_pid >= next_safe) {
if (last_pid >= MAX_PID) {
last_pid = 1;
}
next_safe = MAX_PID;
goto repeat; //区间不合法，重新遍历链表
}
}
else if (proc->pid > last_pid && next_safe > proc->pid) {
next_safe = proc->pid; //更新next_safe
}
}
}
return last_pid;
}
练习三：proc_run 函数及进程切换
1.proc_run
proc_run函数用于进程切换时，运行要切换到的进程。当发生进程调度时，调度程序schedule会在进程链表中寻找一个就绪（state == PROC_RUNNABLE）的进程，并向proc_run传入进程控制块，切换运行这个进程。proc_run完成的工作为将当前进程设置为要运行的新进程，设置任务状态段tss中特权态0下的栈顶指针esp0为要运行的进程内核栈的栈顶，切换到要运行进程的页表，最后进行上下文切换。
void proc_run(struct proc_struct *proc) {
if (proc != current) {
bool intr_flag;
struct proc_struct *prev = current, *next = proc;
local_intr_save(intr_flag);
{
current = proc; //当前进程设置为要运行的进程
load_esp0(next->kstack + KSTACKSIZE); //设置TSS中特权级0的栈顶指针
lcr3(next->cr3); //切换页表
switch_to(&(prev->context), &(next->context)); //上下文切换
}
local_intr_restore(intr_flag);
}
}
设置任务状态段tss中特权态0下的栈顶指针esp0是为了在未来进程运行时的特权级切换做好准备。在发生中断时，需要切换到内核栈，并保存当前的运行状态。esp0就是进程的内核栈的栈顶指针，通过这个指针就可以找到进程的内核栈，并从这里开始压栈保存当前的状态（trapframe），每个进程都有自己的内核栈，因此这个值需要随进程切换而重新设置。
//pmm.c中定义的load_esp0
void load_esp0(uintptr_t esp0) {
ts.ts_esp0 = esp0;
}
切换页表需要使用lcr3函数重新加载cr3寄存器。在本实验中，内核线程都使用内核的地址空间，页目录都是boot_cr3，这一步在本实验没有作用。
//x86.h中定义的lcr3
static inline void lcr3(uintptr_t cr3) {
asm volatile ("mov %0, %%cr3" :: "r" (cr3) : "memory");
}
上下文切换是调用Switch.S中定义的switch_to函数完成的。函数调用时，调用者的esp+4，esp+8会依次存放传入的参数。此处开始的esp+4就是原进程的context结构，call指令调用函数时，会将返回地址压栈，因此esp处的值为返回地址，首先将这个值出栈保存，接下来就是将context包括的寄存器保存到相应的位置。esp+8的位置是新进程的context，但是由于之前使用了pop指令，因此此时esp+4就是切换到的进程的context，将切换到的进程的上下文恢复，最后的push指令会将返回地址入栈，最后的ret指令就会返回到要切换到的进程，运行要切换到的进程，这样就完成了进程的切换。
switch_to: # switch_to(from, to)
# save from's registers
movl 4(%esp), %eax # eax points to from
popl 0(%eax) # save eip !popl
movl %esp, 4(%eax) # save esp::context of from
movl %ebx, 8(%eax) # save ebx::context of from
movl %ecx, 12(%eax) # save ecx::context of from
movl %edx, 16(%eax) # save edx::context of from
movl %esi, 20(%eax) # save esi::context of from
movl %edi, 24(%eax) # save edi::context of from
movl %ebp, 28(%eax) # save ebp::context of from
# restore to's registers
movl 4(%esp), %eax # not 8(%esp): popped return address already
# eax now points to to
movl 28(%eax), %ebp # restore ebp::context of to
movl 24(%eax), %edi # restore edi::context of to
movl 20(%eax), %esi # restore esi::context of to
movl 16(%eax), %edx # restore edx::context of to
movl 12(%eax), %ecx # restore ecx::context of to
movl 8(%eax), %ebx # restore ebx::context of to
movl 4(%eax), %esp # restore esp::context of to
pushl 0(%eax) # push eip
ret
综上，一个新内核线程建立后切换运行经历了以下步骤：
中断发生，向内核栈顶压入当前寄存器值，建立trapframe
---->schedule()选择需要切换到的线程
---->proc_run()设置新进程的内核栈顶(为下次中断做准备)
---->switch_to()上下文切换
---->forkret()->forkrets()->__trapret从trapframe恢复寄存器（do_fork中设置上下文切换后执行forkret）
---->kernel_thread_entry中执行call指令，执行内核线程代码
2.问题一
在本实验的执行过程中，创建且运行了几个内核线程？
在本实验中，共创建并运行了两个内核线程。一个是idleproc，另一个是initproc。
idleproc
idlepro是0号内核线程。kern_init调用了proc_init，在proc_init中会创建该线程。该线程的need_resched设置为1，运行cpu_idle函数，总是要求调度器切换到其他线程。
//proc_init中创建idle_proc
if ((idleproc = alloc_proc()) == NULL) {
panic("cannot alloc idleproc.\n");
}
//线程初始化
idleproc->pid = 0; //0号线程
idleproc->state = PROC_RUNNABLE; //设置为可运行
idleproc->kstack = (uintptr_t)bootstack; //启动后的内核栈被设置为该线程的内核栈
idleproc->need_resched = 1;
set_proc_name(idleproc, "idle");
nr_process ++;
current = idleproc;
//kern_init最后会运行该内核线程，调度到其他线程
void cpu_idle(void) {
while (1) {
if (current->need_resched) {
schedule();
}
}
}
initproc
initproc是第1号线程，未来所有的进程都是由该线程fork产生的。init_proc也是在proc_init中创建的，通过调用kernel_thread创建，该线程运行init_main并输出字符串。
//init_proc的创建
int pid = kernel_thread(init_main, "Hello world!!", 0);
if (pid <= 0) {
panic("create init_main failed.\n");
}
initproc = find_proc(pid);
set_proc_name(initproc, "init");
kernel_thread中定义了一个trapframe结构，然后将该结构传入do_fork完成线程的建立。
int kernel_thread(int (*fn)(void *), void *arg, uint32_t clone_flags) {
struct trapframe tf;
memset(&tf, 0, sizeof(struct trapframe));
tf.tf_cs = KERNEL_CS;
tf.tf_ds = tf.tf_es = tf.tf_ss = KERNEL_DS; //使用内核的代码和数据段
tf.tf_regs.reg_ebx = (uint32_t)fn; //函数地址
tf.tf_regs.reg_edx = (uint32_t)arg; //参数
tf.tf_eip = (uint32_t)kernel_thread_entry; //kernel_thread_entry中将进入ebx指定的函数执行
return do_fork(clone_flags | CLONE_VM, 0, &tf);
}
该线程创建完成后，proc_init也完成了工作，返回到kern_init，kern_init会运行idle_proc的cpu_idle，进行进程调度，从而切换运行init_proc。切换线程是调度器schedule函数完成的，该函数会在进程链表中寻找一个就绪的进程，调用proc_run切换到改进程。proc_run会进行上下文切换，而在do_fork中调用的copy_thread函数中，将context.eip设置为了forkret，进程切换完成后从forkret开始运行。forkret实际上是forkrets，forkrets会从当前进程的trapframe恢复上下文，然后跳转到设置好的kernel_thread_entry。
.globl forkrets
forkrets:
# set stack to this new process's trapframe
movl 4(%esp), %esp
jmp __trapret
.globl __trapret
__trapret:
# restore registers from stack
popal
# restore %ds, %es, %fs and %gs
popl %gs
popl %fs
popl %es
popl %ds
# get rid of the trap number and error code
addl $0x8, %esp
iret //tf.tf_eip = (uint32_t)kernel_thread_entry;
kernel_thread_entry会压入edx保存的参数，调用ebx指向的函数，保存返回值，然后do_exit回收资源。通过kernel_thread_entry，内核线程可以执行对应的函数，并在执行结束后自动调用do_exit终止线程并回收资源。
.globl kernel_thread_entry
kernel_thread_entry: # void kernel_thread(void)
pushl %edx # push arg
call *%ebx # call fn
pushl %eax # save the return value of fn(arg)
call do_exit # call do_exit to terminate current thread
3.问题二
语句local_intr_save(intr_flag);…local_intr_restore(intr_flag);在这里有何作用？请说明理由。
在练习二的do_fork实现中，已经使用了这两个语句。这两个函数的作用是屏蔽和使能中断，他们的定义在kern\sync中，通过一系列调用，最终使用cli和sti进行中断的屏蔽和使能。在临界区使用这两个函数暂时屏蔽中断，避免进程调度，从而提供互斥。在proc_run中完成了上下文切换等重要工作，如果没有互斥，当前进程被设置为要切换运行的进程，但还没有完成上下文的切换，如果在此时发生了进程调度，就可能产生错误。
实验总结
重要知识点
- 内核线程和用户进程的区别
- 进程控制块
- 内核线程的创建
- 内核线程资源分配
- 进程(线程)切换的过程
本实验主要是内核线程创建与切换的具体实现。在ucore中，首先创建idle_proc这个第0号内核线程，然后调用kernel_thread建立init_proc第1号内核线程，最后回到kern_init执行idle_proc线程，idle_proc总是调度到其他线程。线程具体的创建是由do_fork完成的，do_fork调用alloc_proc等函数，完成进程控制块的创建，内核栈和pid的分配，父进程上下文和中断帧的复制，还会进行一些设置，如将上下文的eip设置为fork_ret，在trapframe中将返回值设置为0等。创建完毕后返回pid，当调度器调度该线程时，调度器调用proc_run完成上下文切换后就会执行fork_ret，恢复中断帧，从而开始执行指定的程序。
