一、Makefile
这个 Makefile 要比之前的文件夹中的 Makefile 更加复杂，是因为之前的文件夹都是对操作系统特定部分的一个编译指导，所以基本上是实现的功能就是“对应的 C 文件和汇编文件编译成目标文件”这一个功能，最后合成一个整体。但是 user 的 Makefile 指导的是多个用户程序的编译，最后生成的是多个用户目标文件，同时还需要给每个用户文件装备上库目标文件。
首先先补充一下 makefile 的一些知识
自动化变量
$@表示目标（target）文件，就是冒号前面的那个文件$^表示所有的依赖文件，就是冒号后面的那一堆文件$<表示第一个依赖文件，就是紧挨着冒号后面的一个文件$*这个变量表示目标模式中%及其之前的部分。如果目标是dir/a.foo.b，并且目标的模式是a.%.b，那么，$*的值就是dir/a.foo。
静态模式
就是带有 % 的那种 target 和 prereq。主要用于同时匹配多个，之前似乎介绍过了。这里只是强调，对于匹配，是用 target 里面的集合元素去匹配 prereq 中的元素，换句话说，是一个从上到下的结构，比如说
all: a.x b.x
%.x: %.o #这里
a.o: a.c
gcc -o $@ $<
b.o: b.c
gcc -o $@ $<
c.o: c.c
gcc -o $@ $<对于用注释标注出来的地方，虽然看上去，有 a.o, b.o, c.o 三个文件符合 %.o 的匹配条件，但是请注意，真正匹配到的只有 a.o, b.o 这是因为 all 作为总目标，指定了只要 a.x, b.x ，那么 %.x 就是 a.x, b.x 。所以就只会匹配到 a.o, b.o 。
中间文件
似乎 make 有一种特性是不保存中间文件，正是因为这种特性，我们在 user 下才会找不到 .b.c 文件，也找不到很多 .o 文件。
然后就可以来看文件了（考虑到理解问题，我们从下往上看）：
%.o: lib.h这个只是在保证 user 下有 lib.h 这个文件，不然编译就会报错。
%.o: %.c
$(CC) $(CFLAGS) $(INCLUDES) -c -o $@ $<
%.o: %.S
$(CC) $(CFLAGS) $(INCLUDES) -c -o $@ $<这两句比较正常，就是把“对应的 C 文件和汇编文件编译成目标文件”。
接下来需要先从上往下看，这是因为本质上 makefile 是一个“需求决定工作”，而不是“工作决定需求”的东西，所以本源方法是从上往下看。
USERLIB := printf.o \
print.o \
libos.o \
fork.o \
pgfault.o \
syscall_lib.o \
ipc.o \
string.o
all: tltest.x tltest.b fktest.x fktest.b pingpong.x pingpong.b idle.x \
$(USERLIB) entry.o syscall_wrap.o这里我们可以看到，我们的目标文件有很多，但是我们可以将其分成三类，一类是库目标文件，也就是前面变量定义的
USERLIB := printf.o \
print.o \
libos.o \
fork.o \
pgfault.o \
syscall_lib.o \
ipc.o \
string.o一类是普通包装文件（瞎起的名字），他们是每个程序链接必须用到的（库文件则不一定，虽然这里是一定的）
entry.o syscall_wrap.o最后是我们真的需要编译成成果的东西，即下面这个三个
tltest.x tltest.b fktest.x fktest.b pingpong.x pingpong.b idle.x到最后我们用到的东西（也就是链接到整体的项目中的）是 .x 文件，它是一个二进制文件，.b 同样是一个二进制文件。只不过 .b 文件更接近我们通常的理解，而 .x 文件只是一个字符数组的二进制化。
然后我们来看 .x 文件是怎样来的
%.x: %.b.c
$(CC) $(CFLAGS) -c -o $@ $<可以看出，他是由一个名字相对应的 .b.c 的 C 文件编译而来的，但是这个 C 文件又是从何而？
%.b.c: %.b
chmod +x ./bintoc
./bintoc $* $< > $@~ && mv -f $@~ $@我们可以看到，是由 .b 文件经过一个叫做 bintoc 的工具转换而来，首先是第一句
chmod +x ./bintoc这是在赋予 bintoc 一个可执行的权限，这个工具的功能就是把一个二进制文件（这里是 .b ）转换为一个字符数组，我们可以在 user 文件夹下输入如下命令
make tltest.b.c就会显式的得到 tltest.b.c 文件（如果是直接 make ，.b.c 会被判定为中间文件，不会保留），其内容如下
unsigned char binary_user_tltest_start[] = {
0x7f, 0x45, 0x4c, 0x46, 0x1, 0x2, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x2, 0x0, 0x8, 0x0, 0x0, 0x0, 0x1, 0x0, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x34,
0x0, 0x0, 0x68, 0x44, 0x0, 0x0, 0x10, 0x1, 0x0, 0x34, 0x0, 0x20, 0x0, 0x2, 0x0, 0x28,
0x0, 0xa, 0x0, 0x7, 0x70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x25, 0xa0, 0x0, 0x40, 0x15, 0xa0,
0x0, 0x40, 0x15, 0xa0, 0x0, 0x0, 0x0, 0x18, 0x0, 0x0, 0x0, 0x18, 0x0, 0x0, 0x0, 0x4,
0x0, 0x0, 0x0, 0x4, 0x0, 0x0, 0x0, 0x1, 0x0, 0x0, 0x10, 0x0, 0x0, 0x40, 0x0, 0x0,
0x0, 0x40, 0x0, 0x0, 0x0, 0x0, 0x53, 0x1a, 0x0, 0x0, 0x53, 0x24, 0x0, 0x0, 0x0, 0x7,
0x0, 0x0, 0x10, ...
0x73, 0x79, 0x73, 0x63, 0x61, 0x6c, 0x6c, 0x5f, 0x69, 0x70, 0x63, 0x5f, 0x63, 0x61, 0x6e, 0x5f,
0x73, 0x65, 0x6e, 0x64, 0x0, 0x70, 0x61, 0x67, 0x65, 0x73, 0x0, 0x0
};
unsigned int binary_user_tltest_size = 29051;这就与宏契合上了
#define ENV_CREATE(x) \
{ \
extern u_char binary_##x##_start[]; \
extern u_int binary_##x##_size; \
env_create(binary_##x##_start, \
(u_int)binary_##x##_size); \
}然后我们就利用这个工具进行如下操作
./bintoc $* $< > $@~ && mv -f $@~ $@我们会把这个内容输入到一个以 .b.c~ 结尾的临时文件中，然后再用 mv 指令将其存入正式的 .b.c 文件中，我不知道其深意。
那么 .b 文件又是如何来的呢？
%.b: entry.o syscall_wrap.o %.o $(USERLIB)
echo ld $@
$(LD) -o $@ $(LDFLAGS) -G 0 -static -n -nostdlib -T ./user.lds $^这里强调一下，无论是 .b, .b.c, .x 那个文件，其实没有 entry.o, fork.o 之类的事情，所有的文件名，都是围绕这四个名字展开的
tltest fktest pingpong idle然后看代码
%.b: entry.o syscall_wrap.o %.o $(USERLIB)
$(LD) -o $@ $(LDFLAGS) -G 0 -static -n -nostdlib -T ./user.lds $^这里做的其实是把上面编译好的东西链接起来，也就是给每个 tltest fktest pingpong idle 的东西链接上 entry.o syscall_wrap.o 和库目标文件。
至此，我们可以有一个大致的思路，我们首先编译出很多个目标文件，这其中有真正我们的程序目标文件，有的则是库文件，我们的目的是将库文件链接到每一个写好的程序上。这个时候会生成 .b 文件，这是可执行文件。但是因为此时我们没有文件系统，所以读不了它，所以我们需要将其转换成字符数组的形式，我们用这个工具bintoc 生成了 .b.c 的 C 文件，这个时候我们只需要将其重新编译成二进文件即可，即 .x 文件。
二、user.lds
这个链接脚本就很普通
OUTPUT_ARCH(mips)
ENTRY(_start)
SECTIONS
{
. = 0x00400000;
_text = .; /* Text and read-only data */
.text : {
*(.text)
*(.fixup)
*(.gnu.warning)
}
_etext = .; /* End of text section */
.data : { /* Data */
*(.data)
*(.rodata)
*(.rodata.*)
*(.eh_frame)
CONSTRUCTORS
}
_edata = .; /* End of data section */
. = ALIGN(0x1000);
__bss_start = .; /* BSS */
.bss : {
*(.bss)
}
/DISCARD/ : {
*(.comment)
*(.debug_*)
}
end = . ;
}只是指定了入口函数是 _start （注意是用户进程的 _start ，在 entry.S中）。
然后将所有的代码从低地址区开始链接
. = 0x00400000;三、启动流程
这个 _start 还是很简单的，其简单的最主要原因就是很多事情都是由内核完成的，所以才会使这里这么简单，其中在 env_alloc 中有
e->env_tf.cp0_status = 0x1000100c;
e->env_tf.regs[29] = USTACKTOP;可以看到这里设置了栈指针和 CP0_STATUS。于是当调度的时候，sp 已经是用户栈指针了。所以对于 _start 。做的事情就是从用户栈上给 libmain 传入两个参数，就是大名鼎鼎的 argc, argv 。
.text
.globl _start
_start:
lw a0, 0(sp)
lw a1, 4(sp)
nop
jal libmain
nop对于libmain
void exit(void)
{
syscall_env_destroy(0);
}
struct Env *env;
void libmain(int argc, char **argv)
{
env = 0;
int envid;
envid = syscall_getenvid();
envid = ENVX(envid);
env = &envs[envid];
umain(argc, argv);
exit();
}首先是先定义了一个 env 全局指针，这个指针指向了这个进程对应的进程控制块。还是挺有意思的。
struct Env *env;
envid = ENVX(envid);
env = &envs[envid];可以看到 libmain 主要还是起一个包装的作用，在正式开始前获得进程控制块，然后进行了一个参数传参。在正式结束后把进程控制块在操作系统中注销。
void exit(void)
{
syscall_env_destroy(0);
}最后举一个 umain 的例子
#include "lib.h"
void umain()
{
while (1)
{
writef("IDLE!");
}
}可以看到在这里的时候，就很像我们平时写的程序了。到了这里，我们可以说，我们终于对于用户完成了封装。用户只需要引用用户可知的头文件，就可以实现相应的功能，而不需要了解操作系统的实现细节。
四、库函数
这里说明，这里的库函数包括我在 makefile 这一节中提出的库函数和普通包装函数，放在这里一并记录了。
4.1 entry.S
__asm_pgfault_handler
.globl __pgfault_handler
__pgfault_handler:
.word 0
.set noreorder
.text
.globl __asm_pgfault_handler
__asm_pgfault_handler:
nop
lw a0, TF_BADVADDR(sp)
lw t1, __pgfault_handler
jalr t1
nop
lw v1,TF_LO(sp)
mtlo v1
lw v0,TF_HI(sp)
lw v1,TF_EPC(sp)
mthi v0
mtc0 v1,CP0_EPC
lw $31,TF_REG31(sp)
lw $30,TF_REG30(sp)
lw $28,TF_REG28(sp)
lw $25,TF_REG25(sp)
lw $24,TF_REG24(sp)
lw $23,TF_REG23(sp)
lw $22,TF_REG22(sp)
lw $21,TF_REG21(sp)
lw $20,TF_REG20(sp)
lw $19,TF_REG19(sp)
lw $18,TF_REG18(sp)
lw $17,TF_REG17(sp)
lw $16,TF_REG16(sp)
lw $15,TF_REG15(sp)
lw $14,TF_REG14(sp)
lw $13,TF_REG13(sp)
lw $12,TF_REG12(sp)
lw $11,TF_REG11(sp)
lw $10,TF_REG10(sp)
lw $9,TF_REG9(sp)
lw $8,TF_REG8(sp)
lw $7,TF_REG7(sp)
lw $6,TF_REG6(sp)
lw $5,TF_REG5(sp)
lw $4,TF_REG4(sp)
lw $3,TF_REG3(sp)
lw $2,TF_REG2(sp)
lw $1,TF_REG1(sp)
lw k0,TF_EPC(sp)
jr k0
lw sp,TF_REG29(sp) 这个函数在“异常处理流”中讲过了，主要是跳转到函数指针 __pgfault_handler 指向的异常处理函数主体（pgfault），然后进行现场的恢复。
在这个文件中还有与自映射有关的两个变量
.globl vpt
vpt:
.word UVPT
.globl vpd
vpd:
.word (UVPT+(UVPT>>12)*4)其实就类似与
unsigned int vpt = UVPT;
unsigned int vpd = (UVPT+(UVPT>>12)*4);关于为啥不直接使用原来定义好的宏，我觉得是因为原来的宏是属于操作系统的，而在库函数的实现的时候尽量少的接触操作系统的细节，是很有必要的，因为这样可以提高可移植性。
4.2 fork.c
首先先吐槽一下，这个函数分类真的是烂透了，为什么 fork.c 中要有 user_bcopy() ，真的理解不了啊。
user_bcopy
实现就类似与 bcopy
void user_bcopy(const void *src, void *dst, size_t len)
{
void *max;
max = dst + len;
// copy machine words while possible
if (((int)src % 4 == 0) && ((int)dst % 4 == 0))
{
while (dst + 3 < max)
{
*(int *)dst = *(int *)src;
dst += 4;
src += 4;
}
}
// finish remaining 0-3 bytes
while (dst < max)
{
*(char *)dst = *(char *)src;
dst += 1;
src += 1;
}
}user_bzero
与 user_bcopy 类似
void user_bzero(void *v, u_int n)
{
char *p;
int m;
p = v;
m = n;
while (--m >= 0)
{
*p++ = 0;
}
}pgfault
这个函数实现的是根据虚拟地址 va 为其分配一个物理页面，而且这个新的物理页面要有一些内容。
最有意思的是，这个 va 之前是对应了一个物理页面的（这是一个子进程函数，所以之前是和父进程共享这个页面）。那么我们要实现的，似乎是让一个 va 对应两个物理页面。显然是不合理的。所以严谨地阐述这个函数的功能，是将 va 对应到新的物理页面，并将原来的物理页面映射关系去掉。这个新的物理页面的内容跟原来的物理页面内容一致。
static void pgfault(u_int va)
{
u_int *tmp = USTACKTOP;
// writef("fork.c:pgfault():\t va:%x\n",va);
u_long perm = ((Pte *)(*vpt))[VPN(va)] & 0xfff;
if ((perm & PTE_COW) == 0)
{
user_panic("pgfault err: COW not found");
}
perm -= PTE_COW;
// map the new page at a temporary place
syscall_mem_alloc(0, tmp, perm);
// copy the content
user_bcopy(ROUNDDOWN(va, BY2PG), tmp, BY2PG);
// map the page on the appropriate place
syscall_mem_map(0, tmp, 0, va, perm);
// unmap the temporary place
syscall_mem_unmap(0, tmp);
}duppage
这个函数用于根据父进程的映射关系，去复制子进程的映射关系，pn 是虚拟页面号的意思。复制最困难的是对于权限位的考量，其实就是对于 COW 的设置。如果一个页面，他不是只读的（说明有写的可能），而且也没有明确说是可以共享的（只共享写），那么就是应该增设 PTE_COW 位，这种增设是对于父子进程都要设置的。所以尽管这里有两个map，但是第一个 map 是用于子进程建立页面映射，而第二个是用于修改父进程的映射权限。
static void duppage(u_int envid, u_int pn)
{
// addr is the va we need to process
u_int addr = pn << PGSHIFT;
// *vpt + pn is the adress of page_table_entry which is corresponded to the va
u_int perm = ((Pte *)(*vpt))[pn] & 0xfff;
// if the page can be write and is not shared, so the page need to be COW and map twice
int flag = 0;
if ((perm & PTE_R) && !(perm & PTE_LIBRARY))
{
perm |= PTE_COW;
flag = 1;
}
syscall_mem_map(0, addr, envid, addr, perm);
if (flag)
{
syscall_mem_map(0, addr, 0, addr, perm);
}
// user_panic("duppage not implemented");
}fork
这个函数用于产生一个子进程，并且设置其状态和各种配置。这里需要强调的一个有趣的点是，fork 本身并不是系统调用函数，他是由一系列系统调用函数组成的一个用户函数。
int fork(void)
{
u_int newenvid;
extern struct Env *envs;
extern struct Env *env;
u_int i;
// The parent installs pgfault using set_pgfault_handler
set_pgfault_handler(pgfault);
// alloc a new alloc
newenvid = syscall_env_alloc();
if (newenvid == 0)
{
env = envs + ENVX(syscall_getenvid());
return 0;
}
for (i = 0; i < VPN(USTACKTOP); ++i)
{
if (((*vpd)[i >> 10] & PTE_V) && ((*vpt)[i] & PTE_V))
{
duppage(newenvid, i);
}
}
syscall_mem_alloc(newenvid, UXSTACKTOP - BY2PG, PTE_V | PTE_R);
syscall_set_pgfault_handler(newenvid, __asm_pgfault_handler, UXSTACKTOP);
syscall_set_env_status(newenvid, ENV_RUNNABLE);
return newenvid;
}首先我们先进行了一个父进程的配置，我们用这个函数为父进程分配了处理 COW 的时候的栈，还指定了处理 pgfault 异常的函数。至于为啥不一早就分配好了呢？我觉得是因为不是每个进程都需要用到这个栈，所以为了避免页面的浪费，就没有改成了用函数手动配置，而不是默认配置。
set_pgfault_handler(pgfault);然后我们利用系统调用创造一个进程
newenvid = syscall_env_alloc();我们先看子进程，它会被时钟中断调度（先别管咋调度的），那么就会从内存控制块里恢复现场，那么此时被恢复的 v0 就是 0，返回的 PC 就是 syscall_env_alloc 所导致的 syscall 的下一条，也就是 msyscall 中的这条
LEAF(msyscall)
syscall
nop // 这条
jr ra
nop
END(msyscall)那么再次返回的时候 syscall_env_alloc 的返回值就变成了 0。然后就会进入下面这个分支判断
if (newenvid == 0)
{
env = envs + ENVX(syscall_getenvid());
return 0;
}env 是对于用户进程的一个全局变量，他表示正在运行的进程块，一般会在 start 到 main 之间设置，但是以为 fork 出的子进程没有设置这个，所以需要在这里设置，然后就可以结束 fork 了，返回值是 0。
但是对于父进程来说，对于子进程的修改还没有结束，他还需要将虚拟环境完全的复制给子进程，也就是下面的语句。这里的 i 是虚页号，我们可以用 (*vpd)[i >> 10] 的找出这个虚页号对应的一级页表项，用 (*vpt)[i] 找出二级页表项，为什么可以这样呢？
for (i = 0; i < VPN(USTACKTOP); ++i)
{
if (((*vpd)[i >> 10] & PTE_V) && ((*vpt)[i] & PTE_V))
{
duppage(newenvid, i);
}
}首先我们需要弄清 extern 的用法，这似乎是理解的最难点，对于一个在 file1 中定义的全局变量 a
int a = 1; // 假设地址 &a = 0x8000_5000那么在文件 file2 的时候需要引入这个变量，那么可以有两种写法（虽然正常人只会用第一种）
extern int a;
extern int a[];但是两者的结果是不同的，如果我们打印第一个变量 a，那么会出现 1，如果打印第二个变量（我都感觉这是个指针常量了），那么就会出现 a = 0x80005000 。我不知道为啥是这样的，但是确实是这样的。
然后我们来看一下 vpt 和 vpd 的定义，在 user 文件夹下的 entry.S 下
.globl vpt
vpt:
.word UVPT
.globl vpd
vpd:
.word (UVPT+(UVPT>>12)*4)可以看到是一个自映射的标准写法，相关的宏就是我们在 mmu.h 中定义的，而且我们在进程创建之初，就完成了这个设置，
e->env_pgdir[PDX(UVPT)] = e->env_cr3 | PTE_V;但是最让人困惑的莫过于教程中“指针的指针”这一说法，我个人觉得直接认为他是错误的就好了。因为在引入的时候，我们用的是这种方法
extern volatile Pte *vpt[];
extern volatile Pde *vpd[];按照 c 的语法，vpt 应该是一个指针数组，但是这个操作 (*vpt)[i] 如果需要先按照数组方式理解，然后再按照指针方式理解，那么就会变成这样 *(vpt[0] + i) 或者直观一些 vpt[0][i] 。这都是无厘头的，因为类似于我们声明了一个指针数组，但是只用它的第一个元素当指针，为啥我们不直接声明一个指针 Pte* vpt。这是个未解之谜，我与叶哥哥讨论，叶哥哥也认为如果写成
u_int *vpt = (u_int*) UVPT;
// use vpt[i]会很好看，鬼知道他为啥写成这样。
但是既然写了，就要从语法上解释通，对于 (*vpt) 操作，结合上面介绍的 extern 知识，可以知道，vpt 的值不再是 0x7fc0 0000了，而是 vpt 的地址（恶心）。然后 (*vpt) 的值才是 0x7fc0 0000 。所以再结合 (*vpt) + VPN ，知道这是在计算二级页表项的虚拟地址，然后取地址，就可以得到二级页表项 *((*vpt) + VPN) = (*vpt)[VPN] 。
在有了这些知识打底的基础上，我们就可以看到底要干啥了，我们遍历了所有的二级页表项和一级页表项，如果他是有效的，那么就要给子进程复制他，人物交给了 duppage。
for (i = 0; i < VPN(USTACKTOP); ++i)
{
if (((*vpd)[i >> 10] & PTE_V) && ((*vpt)[i] & PTE_V))
{
duppage(newenvid, i);
}
}然后我们需要设置一些子进程的对于 COW 的设置
syscall_mem_alloc(newenvid, UXSTACKTOP - BY2PG, PTE_V | PTE_R);
syscall_set_pgfault_handler(newenvid, __asm_pgfault_handler, UXSTACKTOP);上面两句话的作用其实跟父进程的 set_pgfault_handler(pgfault) 作用一样，就是没有设置 pgout 因为之前似乎已经设置了。
最后我们需要让子进程进入调度序列，就是底下这个函数实现的
syscall_set_env_status(newenvid, ENV_RUNNABLE);4.3 ipc.c
这个文件中记录着与进程通信有关的函数。
ipc_send
void ipc_send(u_int whom, u_int val, u_int srcva, u_int perm)
{
int r;
while ((r = syscall_ipc_can_send(whom, val, srcva, perm)) == -E_IPC_NOT_RECV)
{
syscall_yield();
}
if (r == 0) {
return;
}
user_panic("error in ipc_send: %d", r);
}这个函数主要是一个忙等的实现，通过不断的尝试
syscall_ipc_can_send(whom, val, srcva, perm)这个函数就是一个尝试并获得的过程。如果没有获得成功，就会被 yield 。
ipc_recv
这个函数就没有忙等，是因为其系统调用的实现中实现了 wait-notify 机制。
u_int ipc_recv(u_int *whom, u_int dstva, u_int *perm)
{
syscall_ipc_recv(dstva);
if (whom)
{
*whom = env->env_ipc_from;
}
if (perm)
{
*perm = env->env_ipc_perm;
}
return env->env_ipc_value;
}4.4 lib.h
这个头文件里包括了所有的库函数声明（丑爆了）。
4.5 pgfault.c
set_pgfault_handler
这个函数看着很奇怪，是因为把函数调用写到了条件里，其实比较好看懂的写法应该是这样（不严谨）
void set_pgfault_handler(void (*fn)(u_int va))
{
if (__pgfault_handler == 0)
{
syscall_mem_alloc(0, UXSTACKTOP - BY2PG, PTE_V | PTE_R);
syscall_set_pgfault_handler(0, __asm_pgfault_handler, UXSTACKTOP);
}
// Save handler pointer for assembly to call.
__pgfault_handler = fn;
}也就是说，当一个进程第一次调用 fork 的时候（对应的就是 __pgfault_handler == 0 ）。那么这个函数就会为他分配出一个用来处理 pgfault 异常的栈，而且设置他处理这种异常的函数是 __asm_pgfault_handler 。
每次这个函数都会将 __pgfault_handler 设置成 fn，在 fork 中是传入参数是 pgfault。
void set_pgfault_handler(void (*fn)(u_int va))
{
if (__pgfault_handler == 0)
{
// Your code here:
// map one page of exception stack with top at UXSTACKTOP
// register assembly handler and stack with operating system
if (syscall_mem_alloc(0, UXSTACKTOP - BY2PG, PTE_V | PTE_R) < 0 ||
syscall_set_pgfault_handler(0, __asm_pgfault_handler, UXSTACKTOP) < 0)
{
writef("cannot set pgfault handler\n");
return;
}
// panic("set_pgfault_handler not implemented");
}
// Save handler pointer for assembly to call.
__pgfault_handler = fn;
}4.6 print.c
就不记录了，因为跟内核态的 print.c 一模一样。
4.7 printf.c
writef
writef 对应的就是用户态的 printf。这个名字烂爆了，因为 write 有写的意思，很容易跟人造成“写”的错觉，而不是“打印”。
static void user_myoutput(void *arg, const char *s, int l)
{
int i;
// special termination call
if ((l == 1) && (s[0] == '\0'))
{
return;
}
for (i = 0; i < l; i++)
{
syscall_putchar(s[i]);
if (s[i] == '\n')
{
syscall_putchar('\n');
}
}
}
void writef(char *fmt, ...)
{
va_list ap;
va_start(ap, fmt);
user_lp_Print(user_myoutput, 0, fmt, ap);
va_end(ap);
}_user_panic
跟 panic 的实现完全相同。
#define user_panic(...) _user_panic(__FILE__, __LINE__, __VA_ARGS__)
void _user_panic(const char *file, int line, const char *fmt, ...)
{
va_list ap;
va_start(ap, fmt);
writef("panic at %s:%d: ", file, line);
user_lp_Print(user_myoutput, 0, (char *)fmt, ap);
writef("\n");
va_end(ap);
for (;;);
}4.8 string.c
这里面定义了一些简单的字符串处理函数，但是在此时还没用到，猜测会在文件系统中使用。
strlen
求字符串长度，这里唯一一个亮点是 const char *s 保证了 s 指向的字符串不会被更改。
int strlen(const char *s)
{
int n;
for (n = 0; *s; s++)
{
n++;
}
return n;
}strcpy
字符串拷贝函数。
char *strcpy(char *dst, const char *src)
{
char *ret;
ret = dst;
while ((*dst++ = *src++) != 0);
return ret;
}strchr
这个函数用于找寻字符串中有无特定的字符，如果有，就返回字符串中指向这个字符首次出现位置的指针。
const char *strchr(const char *s, char c)
{
for (; *s; s++)
if (*s == c)
{
return s;
}
return 0;
}strcmp
用于进行字符串之间的比较，比较方法就是普通的字典序比较。
int strcmp(const char *p, const char *q)
{
while (*p && *p == *q)
{
p++, q++;
}
if ((u_int)*p < (u_int)*q)
{
return -1;
}
if ((u_int)*p > (u_int)*q)
{
return 1;
}
return 0;
}memcpy
复制一段东西。有一说一，我不知道在有了 user_bcopy 后，为啥还要用这个（还慢）
void *memcpy(void *destaddr, void const *srcaddr, u_int len)
{
char *dest = destaddr;
char const *src = srcaddr;
while (len-- > 0)
{
*dest++ = *src++;
}
return destaddr;
}4.9 syscall_lib.c
就是一大堆函数调用 msyscall ，一般格式就这样（会有参数占位符）
#include <unistd.h>
void syscall_putchar(char ch)
{
msyscall(SYS_putchar, (int)ch, 0, 0, 0, 0);
}4.10 syscall_wrap.S
msyscall
LEAF(msyscall)
syscall
nop
jr ra
nop
END(msyscall)