6.S081-Lab4 traps实验笔记

发表于 更新于 分类于 ， 阅读次数： 本文字数： 8.2k 阅读时长 ≈ 7 分钟

RISC-V assembly

There is a file user/call.c in your xv6 repo. make fs.img compiles it and also produces a readable assembly version of the program in user/call.asm.

我们启动qemu可以看到有call.c文件，执行make fs.img可以生成汇编文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include "kernel/param.h"
#include "kernel/types.h"
#include "kernel/stat.h"
#include "user/user.h"

int g(int x) {
  return x+3;
}

int f(int x) {
  return g(x);
}

void main(void) {
  printf("%d %d\n", f(8)+1, 13);
  exit(0);
}

Which registers contain arguments to functions? For example, which register holds 13 in main's call to printf?

那几个寄存器保存了函数的参数，例如main函数里面那个寄存器保存了printf的入参13这个值

1
2
3
4
5
6
7
void main(void) {
  1c:	1141                	addi	sp,sp,-16
  1e:	e406                	sd	ra,8(sp)
  20:	e022                	sd	s0,0(sp)
  22:	0800                	addi	s0,sp,16
  printf("%d %d\n", f(8)+1, 13);
  24:	4635                	li	a2,13

从上面可以看出li a2,13 。将13加载到了a2寄存器中，从下图中可以看出，a2寄存器一般是用来传递函数的参数的

Where is the call to function f in the assembly code for main? Where is the call to g? (Hint: the compiler may inline functions.)

没有这样的代码。 g(x) 被内链到 f(x) 中，然后 f(x) 又被进一步内链到 main() 中

At what address is the function printf located?

可以看出printf的入口地址是0x630

1
2
3
4
5
6
7
0000000000000630 <printf>:

void
printf(const char *fmt, ...)
{
 630:	711d                	addi	sp,sp,-96
 632:	ec06                	sd	ra,24(sp)

What value is in the register ra just after the jalr to printf in main?

1
34:	600080e7          	jalr	1536(ra) # 630 <printf>

jalr,参考riscv指令集发现，其功能是

  1. 把pc + 4 的值记为t
  2. 把pc的值设置成 $ra + 1536
  3. 把ra寄存器的值设置成t

所以要跳转的位置是ra+1536

可以看出。ra寄存器里面存的是0x30，1536在16进制下就是0x600.所以最后就是跳转到printf的入口函数地址

Run the following code.

1
2
3
unsigned int i = 0x00646c72;
printf("H%x Wo%s", 57616, &i);

What is the output? Here's an ASCII table that maps bytes to characters.

The output depends on that fact that the RISC-V is little-endian. If the RISC-V were instead big-endian what would you set i to in order to yield the same output? Would you need to change 57616 to a different value?

执行上述代码的输出是HE110 World

为了知道ox00646c72是怎么代表字母的：

大端序：高位字节在低地址。

小端序：低位字节在低地址。

RSIC-V是小端序的所以高字节在低地址显示出来就是rld

要是大端序的话需要换一下顺序：ox00726c64

Backtrace

在调试的过程中，有一个发生错误的点之上的堆栈上的函数调用列表通常很有用

Implement a backtrace() function in kernel/printf.c. Insert a call to this function in sys_sleep, and then run bttest, which calls sys_sleep. Your output should be as follows。将写好的backtrace函数加入到sys_sleep系统调用里面，方便后面的测试。

1
2
3
4
backtrace:
0x0000000080002cda
0x0000000080002bb6
0x0000000080002898

The compiler puts in each stack frame a frame pointer that holds the address of the caller's frame pointer. Your backtrace should use these frame pointers to walk up the stack and print the saved return address in each stack frame.

栈帧

The compiler puts in each stack frame a frame pointer that holds the address of the caller's frame pointer. Your backtrace should use these frame pointers to walk up the stack and print the saved return address in each stack frame.

编译器在每一个栈帧里面存放一个栈的指针,这个栈的指针保存了调用这个栈帧的栈帧的地址

  • 函数调用栈（Stack）
  1. 由高地址往低地址增长
  2. 在xv6里，栈有一页大小（4KB）
  3. 栈指针（stack pointer）保存在sp寄存器里

gdb调试一下理解栈帧的调用

  • 栈帧（Stack Frame）
  1. 当前栈帧的地址保存在 s0/fp寄存器 里
  2. 当前栈帧的地址也叫栈帧的指针（frame pointer， fp），指向该栈帧的最高处
  3. 栈帧指针往下偏移8个字节是函数返回地址 return address
  4. 往下偏移16个字节是上一个栈帧的栈帧指针（previous frame pointer）

栈从高地址向低地址增长，每个大的box叫一个stack frame（栈帧），栈帧由函数调用来分配，每个栈帧大小不一定一样，但是栈帧的最高处一定是return address

sp是stack pointer，用于指向栈顶（低地址），保存在寄存器中

fp是frame pointer，用于指向当前帧底部（高地址），保存在寄存器中，同时每个函数栈帧中保存了调用当前函数的函数（父函数）的fp（保存在to prev frame那一栏中）

这些栈帧都是由编译器编译生成的汇编文件生成的

首先我们在backtrace函数打断点后，启动gdb调试。此时我们info frame可看到当前的栈帧情况：

可以看出现在的栈帧的地址是image-20240329234303847

我们可以看出这个栈的上一个栈在image-20240329234417086

这个上一栈的地址是存在fp寄存器里面的：

image-20240329234516532

比如我们打印栈帧1，可以看出ra里面存的返回寄存器里面存的栈针的内容就是syscall函数的地址

hints

  • Add the prototype for backtrace to kernel/defs.h so that you can invoke backtrace in sys_sleep.

    在 defs.h 中添加声明

    1
    2
    3
    4
    5
    6

    void            printf(char*, ...);
    void            panic(char*) __attribute__((noreturn));
    void            printfinit(void);
    void            backtrace(void); // new function for backtrace

  • The GCC compiler stores the frame pointer of the currently executing function in the register s0. GCC编译器把当前执行函数的栈帧指针存储在寄存器s0里面

  • Add the following function to kernel/riscv.h:

    1
    2
    3
    4
    5
    6
    7
    static inline uint64
    r_fp()
    {
      uint64 x;
      asm volatile("mv %0, s0" : "=r" (x) );
      return x;
    }

    asm volatile("mv %0, s0" : "=r" (x) );：这是内联汇编的部分。asm volatile 是内联汇编的开始标记，mv 是 MIPS 汇编指令，用于将寄存器 s0 的值移动到 %0 中。%0 是内联汇编语法中的占位符，表示第一个输出操作数（output operand）。= 表示这是一个输出操作数。(x) 表示要将结果存储到变量 x 中。r 表示使用寄存器约束，告诉编译器将变量 x 放置在一个通用寄存器中。

    and call this function inbacktrace to read the current frame pointer. This function usesin-line assembly to read s0.

实现 backtrace 函数

小技巧,因为是栈指针往下偏移8个字节是函数返回地址,为了更好偏移8个字节,可以指定为uint_64指针,这样一个就是8个字节,因栈的地址是从高地址向低地址生长的所以是-1

Xv6 allocates one page for each stack in the xv6 kernel at PAGE-aligned address. You can compute the top and bottom address of the stack page by using PGROUNDDOWN(fp) and PGROUNDUP(fp) (see kernel/riscv.h. These number are helpful for backtrace to terminate its loop. 可以通过判断是否超过一页的大小判断栈指针是否越界来终止循环

函数实现:

Once your backtrace is working, call it from panic in kernel/printf.c so that you see the kernel's backtrace when it panics.

实现后,将backtrace函数放到panic里面,当函数出现问题的时候就能看到backtrace

1
2
3
4
5
6
7
8
9
10
11
12
void
panic(char *s)
{
  pr.locking = 0;
  printf("panic: ");
  printf(s);
  printf("\n");
  panicked = 1; // freeze uart output from other CPUs
  backtrace();
  for(;;)
    ;
}

trap 的原理

Alarm

In this exercise you'll add a feature to xv6 that periodically alerts a process as it uses CPU time.

给XV6内核增添一个周期性报警的功能来限制进程使用CPU的时间

This might be useful for compute-bound processes that want to limit how much CPU time they chew up, or for processes that want to compute but also want to take some periodic action.

More generally, you'll be implementing a primitive form of user-level interrupt/fault handlers; 实现一种更原始的用户级别的中断错误处理接口

you could use something similar to handle page faults in the application可以用相似的方式去处理页错误.

  • You should add a new sigalarm(interval, handler) system call.新增一个系统调用,功能:当应用程序调用sigalarm(n, fn)

    then after every n "ticks" of CPU time that the program consumes, the kernel should cause application function fn to be called. (有点类似软中断的定时器功能)

    When fn returns, the application should resume where it left off. A tick is a fairly arbitrary unit of time in xv6, determined by how often a hardware timer generates interrupts. If an application calls sigalarm(0, 0), the kernel should stop generating periodic alarm calls.

  • 首先修改Makefile*以使alarmtest.c*被编译为xv6用户程序.

  • 到user/user.h声明

1
2
int sigalarm(int ticks, void (*handler)());
int sigreturn(void);
  • 更新user/usys.pl（此文件生成user/usys.S）、kernel/syscall.h和kernel/syscall.c以允许alarmtest调用sigalarm和sigreturn系统调用。然后在sysproc.c里面实现这两个系统调用的函数体

invoke handler(调用处理程序)

  • 你的sys_sigalarm()应该将报警间隔和指向处理程序函数的指针存储在struct proc的新字段中（位于*kernel/proc.h*）。
  • 你也需要在struct proc新增一个新字段。用于跟踪自上一次调用（或直到下一次调用）到进程的报警处理程序间经历了多少滴答；您可以在*proc.c*的allocproc()中初始化proc字段。
  • 每一个滴答声，硬件时钟就会强制一个中断，这个中断在kernel/trap.c中的usertrap()中处理。
  • 如果产生了计时器中断，您只想操纵进程的报警滴答；你需要写类似下面的代码
1
if(which_dev == 2) ...

  • 仅当进程有未完成的计时器时才调用报警函数。请注意，用户报警函数的地址可能是0（例如，在user/alarmtest.asm中，periodic位于地址0）。

  • 您需要修改usertrap()，以便当进程的报警间隔期满时，用户进程执行处理程序函数。当RISC-V上的陷阱返回到用户空间时，什么决定了用户空间代码恢复执行的指令地址？

    首先我们知道,32个通用寄存器的值都保存在了proc结构体的trapframe里面struct trapframe *trapframe; // data page for trampoline.S

    用户程序的pc指针保存在epc里面.所以我们想让trap恢复后去执行handler的函数只需要把这里的epc指向handler就可以

    注意:如果您告诉qemu只使用一个CPU，那么使用gdb查看陷阱会更容易，这可以通过运行

1
make CPUS=1 qemu-gdb

在 proc 结构体的定义中，增加 alarm 相关字段：

  • alarm_interval：时钟周期，0 为禁用
  • alarm_handler：时钟回调处理函数
  • alarm_ticks：下一次时钟响起前还剩下的 ticks 数
  • alarm_trapframe：时钟中断时刻的 trapframe，用于中断处理完成后恢复原程序的正常执行
  • alarm_goingoff：是否已经有一个时钟回调正在执行且还未返回（用于防止在 alarm_handler 中途闹钟到期再次调用 alarm_handler，导致 alarm_trapframe 被覆盖）

函数句柄,定义一个函数指针来保存: void(*alarm_handler)();

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
uint64
sys_sigalarm(void){
  int ticks;
  uint64 handler;
  //接收传进来的两个参数
  if(argint(0, &ticks) < 0)
    return -1;
  if(argaddr(1, &handler) < 0)
    return -1;
  //设置proc结构体
  struct proc *p = myproc();
  p->alarm_interval = ticks;
  p->alarm_handler =(void(*)()) handler;
  p->alarm_ticks = ticks;

  return 0;
}

在allocproc的时候进行初始化工作:

1
2
3
4
5
6
7
8
9
10
// Allocate a trapframe page for alarm_trapframe.
  if((p->alarm_trapframe = (struct trapframe *)kalloc()) == 0){
    release(&p->lock);
    return 0;
  }

  p->alarm_interval = 0;
  p->alarm_handler = 0;
  p->alarm_ticks = 0;
  p->alarm_goingoff = 0;

freefroc的时候同样要进行操作

1
2
3
4
5
6
7
if(p->alarm_trapframe)
  kfree((void*)p->alarm_trapframe);
p->alarm_trapframe = 0;
p->alarm_goingoff=0;
p->alarm_handler=0;
p->alarm_interval=0;
p->alarm_ticks=0;

在 usertrap() 函数中，实现时钟机制:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
if(which_dev == 2){
     if(p->alarm_interval!=0){   //设定了时钟事件
       if(--p->alarm_ticks<=0){//检查是否到达定时时间
       //确保没有时钟正在运行,如果此时有另一个时钟到期的处理函数在执行，则推迟
       //有可能在一个handler没执行完的时候，用户设置了新的定时且时间刚好到了
       if(!p->alarm_goingoff)
           *p->alarm_trapframe=*p->trapframe;//保存以前的内容
           //执行handler 函数句柄
           p->trapframe->epc=(uint64) p->alarm_handler;
           p->alarm_goingoff=1;
       }

     }
     yield();
  }

执行完handel后恢复原来的执行流现场:

1
2
3
4
5
6
7
8
uint64
sys_sigreturn(void){
  //将 trapframe 恢复到时钟中断之前的状态，恢复原本正在执行的程序流
  struct proc *p =myproc();
  *p->trapframe=*p->alarm_trapframe;
  p->alarm_goingoff=0;
  return 0;
}