lab6、7

创建一个用户空间的多线程。

uthread的入口如下
```c
int
main(int argc, char *argv[])
{
a_started = b_started = c_started = 0;
a_n = b_n = c_n = 0;
thread_init();
thread_create(thread_a);
thread_create(thread_b);
thread_create(thread_c);
thread_schedule();
exit(0);
}
```
通过开始的init初始化一个线程表，之后每次create都会分配除一个线程，之后启动shedule后就会一直调度。
1. 首先借鉴内核的上下文保存和swtch
```c
struct context {
uint64 ra;
uint64 sp;
// callee-saved
uint64 s0;
uint64 s1;
uint64 s2;
uint64 s3;
uint64 s4;
uint64 s5;
uint64 s6;
uint64 s7;
uint64 s8;
uint64 s9;
uint64 s10;
uint64 s11;
};
struct thread {
char stack[STACK_SIZE]; /* the thread's stack */
int state; /* FREE, RUNNING, RUNNABLE */
struct context context;
};
```

```asm
.text

/*
* save the old thread's registers,
* restore the new thread's registers.
*/

.globl thread_switch
thread_switch:
/* YOUR CODE HERE */
sd ra, 0(a0)
sd sp, 8(a0)
sd s0, 16(a0)
sd s1, 24(a0)
sd s2, 32(a0)
sd s3, 40(a0)
sd s4, 48(a0)
sd s5, 56(a0)
sd s6, 64(a0)
sd s7, 72(a0)
sd s8, 80(a0)
sd s9, 88(a0)
sd s10, 96(a0)
sd s11, 104(a0)

ld ra, 0(a1)
ld sp, 8(a1)
ld s0, 16(a1)
ld s1, 24(a1)
ld s2, 32(a1)
ld s3, 40(a1)
ld s4, 48(a1)
ld s5, 56(a1)
ld s6, 64(a1)
ld s7, 72(a1)
ld s8, 80(a1)
ld s9, 88(a1)
ld s10, 96(a1)
ld s11, 104(a1)

ret /* return to ra */

```

```c
void
thread_schedule(void)
{
...
// 这里的witch注意是保存第一个参数，读取第二个参数
thread_switch((uint64)&t->context, (uint64)&current_thread->context);
...
```
2. 在每次分配时，将ra分配到需要执行的线程（也就是函数）的地址处。这样只要第一次switch到这个函数，就会开始执行。并且之后会自动记录执行的位置。
```c

t->context.ra = (uint64)func; // 返回地址

t->context.sp = (uint64)&t->stack + (STACK_SIZE - 1); // 栈指针
```

 

这两个是过年前后，忘了写博客了。记录下自己做完了吧。