Lab 4 traps

This lab explores how system calls are implemented using traps. You will first do a warm-up exercises with stacks and then you will implement an example of user-level trap handling.

Before you start coding, read Chapter 4 of the xv6 book, and related source files:

• kernel/trampoline.S: the assembly involved in changing from user space to kernel space and back
• kernel/trap.c: code handling all interrupts

To start the lab, switch to the trap branch:

$ git fetch
$ git checkout traps
$ make clean  

RISC-V assembly (easy)

It will be important to understand a bit of RISC-V assembly, which you were exposed to in 6.1910 (6.004). 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.

// user/call.asm
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
  26:   45b1                    li  a1,12
  28:   00000517            auipc   a0,0x0
  2c:   7b850513            addi    a0,a0,1976 # 7e0 <malloc+0xe6>
  30:   00000097            auipc   ra,0x0
  34:   612080e7            jalr    1554(ra) # 642 <printf>
  exit(0);
  38:   4501                    li  a0,0
  3a:   00000097            auipc   ra,0x0
  3e:   28e080e7            jalr    654(ra) # 2c8 <exit>

0000000000000042 <_main>:

Read the code in call.asm for the functions g, f, and main. The instruction manual for RISC-V is on the reference page. Answer the following questions in answers-traps.txt:

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

Solution:

a0 到 a7 寄存器是用来作为函数的参数，如果一个函数有超过 8 个参数，我们就需要用内存了

li a2,13. Therefore the register a2 holds the 13.

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.)

Solution:

没有跳转，被编译器 inline 了。正常情况下，main 在调用 printf 之前，应该是要通过 jalr 跳转到 f 的首址的，同样的 f 也要跳转到 g 去。但这里没有这样的语句，而是直接算出了结果 12，这是因为 g 被 inline 进 f 了，同时 f 也被 inline 进了 main

At what address is the function printf located?

Solution:

30: 00000097            auipc   ra,0x0
34: 612080e7            jalr    1554(ra) # 642 <printf>

0x30+0x61a=0x64a

首先，RISC-V 的 () 运算符是加立即数的操作，1562(ra) <=> ra + 1562。auipc 和 jalr 为常用的跳转命令组合。其中 auipc a, i 指将 i 左移 12 位然后和 pc 相加，值赋给寄存器 a，jalr a 指无条件跳转到 a 所存地址处。这里进行 auipc 时 pc == 0x30，i = 0，因此 ra == 0x30，故最终跳转位置为 0x30 + 0x61a(1562) = 0x64a，即 printf 的地址.

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

Solution:

0x34 + 4 = 0x38。auipc 通过 ra 来存储返回地址，其在更新 pc 为跳转地址之前，将当前 pc + 4 赋值给 ra，即返回处的指令地址.

Run the following code.

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?

Here's a description of little- and big-endian and a more whimsical description.

Solution: He110 World。%x 输出 57616 的十六进制格式 110，%s 输出以 &i 为首址的字符串，因为是小端对齐，所以从低地址到高地址依次是 “0x72”、“0x6c”、“0x64”，遇 0 结尾，即 “rld” 。若为大端对齐，i 需要改为 0x726c6400， 57616 不需要改.

In the following code, what is going to be printed after 'y='? (note: the answer is not a specific value.) Why does this happen?

printf("x=%d y=%d", 3);    

Solution:

取决于寄存器 a2 的值，上述指令需要读取 a1 和 a2 的参数，a1 为 3，a2 没有传入，用 gdb 看一下 a2 的值为多少即可.

Backtrace (moderate)

For debugging it is often useful to have a backtrace: a list of the function calls on the stack above the point at which the error occurred. To help with backtraces, the compiler generates machine code that maintains a stack frame on the stack corresponding to each function in the current call chain. Each stack frame consists of the return address and a "frame pointer" to the caller's stack frame. Register s0 contains a pointer to the current stack frame (it actually points to the the address of the saved return address on the stack plus 8). Your backtrace should use the frame pointers to walk up the stack and print the saved return address in each stack frame.

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 a list of return addresses with this form (but the numbers will likely be different):

backtrace:
0x0000000080002cda
0x0000000080002bb6
0x0000000080002898  

After bttest exit qemu. In a terminal window: run addr2line -e kernel/kernel (or riscv64-unknown-elf-addr2line -e kernel/kernel) and cut-and-paste the addresses from your backtrace, like this:

$ addr2line -e kernel/kernel
0x0000000080002de2
0x0000000080002f4a
0x0000000080002bfc
Ctrl-D  

You should see something like this:

kernel/sysproc.c:74
kernel/syscall.c:224
kernel/trap.c:85

Some hints:

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

• The GCC compiler stores the frame pointer of the currently executing function in the register s0. Add the following function to kernel/riscv.h:

c static inline uint64 r_fp() { uint64 x; asm volatile("mv %0, s0" : "=r" (x) ); return x; }

and call this function in backtrace to read the current frame pointer.r_fp()uses in-line assembly to read s0.

• These lecture notes have a picture of the layout of stack frames. Note that the return address lives at a fixed offset (-8) from the frame pointer of a stackframe, and that the saved frame pointer lives at fixed offset (-16) from the frame pointer.

• Your backtrace() will need a way to recognize that it has seen the last stack frame, and should stop. A useful fact is that the memory allocated for each kernel stack consists of a single page-aligned page, so that all the stack frames for a given stack are on the same page. You can use PGROUNDDOWN(fp) (see kernel/riscv.h) to identify the page that a frame pointer refers to.

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

//kernel/defs.h
...
// printf.c
void            printf(char*, ...);
void            panic(char*) __attribute__((noreturn));
void            printfinit(void);
void            backtrace(void);
...

//kernel/riscv.h
...
typedef uint64 *pagetable_t; // 512 PTEs

//Lab 4
static inline uint64
r_fp()
{
    uint64 x;
    asm volatile("mv %0, s0" : "=r" (x));
    return x;
}

#endif // __ASSEMBLER__
...

// kernel/printf.c
...
void
backtrace()
{
    uint64 fp = r_fp();
    printf("backtrace:\n");
    while (fp >= PGROUNDDOWN(fp) && fp < PGROUNDUP(fp))
    {
        printf("%p\n", * ((uint64 *) (fp-8)));  // 取值，找到当前栈帧返回的地址;
        fp = * ((uint64 *) (fp - 16)); // 取值，获取上一栈帧;
    }
}
...

// kernel/printf.c
void
panic(char *s)
{
  pr.locking = 0;
  printf("panic: ");
  printf(s);
  printf("\n");
  panicked = 1; // freeze uart output from other CPUs
  backtrace();
  for(;;)
    ;
}

// kernel/sysproc.c
uint64
sys_sleep(void)
{
  backtrace(); // Lab 4
  int n;
  uint ticks0;

  argint(0, &n);
  if(n < 0)
    n = 0;

  acquire(&tickslock);
  ticks0 = ticks;
  while(ticks - ticks0 < n){
    if(myproc()->killed){
      release(&tickslock);
      return -1;
    }
    sleep(&ticks, &tickslock);
  }
  release(&tickslock);
  return 0;
}

Alarm (hard)

In this exercise you'll add a feature to xv6 that periodically alerts a process as it uses CPU time. 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, for example. Your solution is correct if it passes alarmtest and 'usertests -q'

You should add a new sigalarm(interval, handler) system call. If an application calls 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.

You'll find a file user/alarmtest.c in your xv6 repository. Add it to the Makefile. It won't compile correctly until you've added sigalarm and sigreturn system calls (see below).

alarmtest calls sigalarm(2, periodic) in test0 to ask the kernel to force a call to periodic() every 2 ticks, and then spins for a while. You can see the assembly code for alarmtest in user/alarmtest.asm, which may be handy for debugging. Your solution is correct when alarmtest produces output like this and usertests -q also runs correctly:

$ alarmtest
test0 start
........alarm!
test0 passed
test1 start
...alarm!
..alarm!
...alarm!
..alarm!
...alarm!
..alarm!
...alarm!
..alarm!
...alarm!
..alarm!
test1 passed
test2 start
................alarm!
test2 passed
test3 start
test3 passed
$ usertest -q
...
ALL TESTS PASSED
$

When you're done, your solution will be only a few lines of code, but it may be tricky to get it right. We'll test your code with the version of alarmtest.c in the original repository. You can modify alarmtest.c to help you debug, but make sure the original alarmtest says that all the tests pass.

test0: invoke handler

Get started by modifying the kernel to jump to the alarm handler in user space, which will cause test0 to print "alarm!". Don't worry yet what happens after the "alarm!" output; it's OK for now if your program crashes after printing "alarm!". Here are some hints:

• You'll need to modify the Makefile to cause alarmtest.c to be compiled as an xv6 user program.

• The right declarations to put in user/user.h

are:

int sigalarm(int ticks, void (*handler)());
int sigreturn(void);

• Update user/usys.pl (which generates user/usys.S), kernel/syscall.h, and kernel/syscall.c to allow alarmtest to invoke the sigalarm and sigreturn system calls.

• For now, your sys_sigreturn should just return zero.

• Your sys_sigalarm() should store the alarm interval and the pointer to the handler function in new fields in the proc structure (in kernel/proc.h).

• You'll need to keep track of how many ticks have passed since the last call (or are left until the next call) to a process's alarm handler; you'll need a new field in struct proc for this too. You can initialize proc fields in allocproc() in proc.c.

• Every tick, the hardware clock forces an interrupt, which is handled in usertrap() in kernel/trap.c.

• You only want to manipulate a process's alarm ticks if there's a timer interrupt; you want something like

if(which_dev == 2) ...

• Only invoke the alarm function if the process has a timer outstanding. Note that the address of the user's alarm function might be 0 (e.g., in user/alarmtest.asm, periodic is at address 0).

• You'll need to modify usertrap() so that when a process's alarm interval expires, the user process executes the handler function. When a trap on the RISC-V returns to user space, what determines the instruction address at which user-space code resumes execution?

• It will be easier to look at traps with gdb if you tell qemu to use only one CPU, which you can do by running

make CPUS=1 qemu-gdb

• You've succeeded if alarmtest prints "alarm!".

Solution:

// Makefile
...
    $U/_zombie\
    $U/_alarmtest\
...

// user/user.h
//system calls
...
int sigalarm(int ticks, void (*handler)());
int sigreturn(void);
...

// user/usys.pl
...
entry("uptime");
entry("sigalarm");
entry("sigreturn")

// kernel/syscall.h
...
#define SYS_close  21
#define SYS_sigalarm 22
#define SYS_sigreturn 23

// kernel/syscall.c
...
extern uint64 sys_close(void);
extern uint64 sys_sigalarm(void);
extern uint64 sys_sigreturn(void);
...
[SYS_close]   sys_close,
[SYS_sigalarm] sys_sigalarm,
[SYS_sigreturn] sys_sigreturn,
};
...

// kernel/sysproc.c
...

// set an alarm to call the handler function
// every period ticks
// For now, your `sys_sigreturn` should just return zero.
// set an alarm to call the handler function
// every period ticks
// For now, your `sys_sigreturn` should just return zero.
uint64
sys_sigalarm(void) {
    int ticks;
    uint64 handler;

    argint(0, &ticks);

    argaddr(1, &handler);

    struct proc *p = myproc(); // 用myproc()来获取当前进程

    p->ticks = ticks;
    p->handler = handler;
    p->ticks_cnt = 0;
    return 0;
}

uint64
sys_sigreturn(void){
    return 0;
}

//kernel/proc.h
// Per-process state
struct proc {
...
  char name[16];               // Process name (debugging)

  //lab 4
  int ticks;
  uint64 handler;
  // You'll need to keep track of how many ticks have passed since the last call
  // (or are left until the next call) to a process's alarm handler;
  // you'll need a new field in `struct proc` for this too.
  int ticks_cnt;
};

//kernel/proc.c
//   
...
found:
  p->pid = allocpid();
...
  // Lab4
  p->ticks = 0;
  return p;
}

//kernel/trap.c
...
void
usertrap(void)
{
 ...
 // give up the CPU if this is a timer interrupt.
    if(which_dev == 2) {
        // todo
        if (p->ticks > 0){
            p->ticks_cnt++;
            if (p->ticks_cnt > p->ticks){
                p->ticks_cnt = 0;
                p->trapframe->epc = p->handler;
            }
        }

        yield();
    }
    usertrapret();
}

test1/test2()/test3(): resume interrupted code

Chances are that alarmtest crashes in test0 or test1 after it prints "alarm!", or that alarmtest (eventually) prints "test1 failed", or that alarmtest exits without printing "test1 passed". To fix this, you must ensure that, when the alarm handler is done, control returns to the instruction at which the user program was originally interrupted by the timer interrupt. You must ensure that the register contents are restored to the values they held at the time of the interrupt, so that the user program can continue undisturbed after the alarm. Finally, you should "re-arm" the alarm counter after each time it goes off, so that the handler is called periodically.

As a starting point, we've made a design decision for you: user alarm handlers are required to call the sigreturn system call when they have finished. Have a look at periodic in alarmtest.c for an example. This means that you can add code to usertrap and sys_sigreturn that cooperate to cause the user process to resume properly after it has handled the alarm.

Some hints:

• Your solution will require you to save and restore registers---what registers do you need to save and restore to resume the interrupted code correctly? (Hint: it will be many).
• Have usertrap save enough state in struct proc when the timer goes off that sigreturn can correctly return to the interrupted user code.
• Prevent re-entrant calls to the handler----if a handler hasn't returned yet, the kernel shouldn't call it again. test2 tests this.
• Make sure to restore a0. sigreturn is a system call, and its return value is stored in a0.

Once you pass test0, test1, test2, and test3 run usertests -q to make sure you didn't break any other parts of the kernel.

//kernel/proc.h
// Per-process state
struct proc {
...
  char name[16];               // Process name (debugging)

  //lab 4
  int ticks;
  uint64 handler;
  // You'll need to keep track of how many ticks have passed since the last call
  // (or are left until the next call) to a process's alarm handler;
  // you'll need a new field in `struct proc` for this too.
  int ticks_cnt;
  uint64 tick_epc;
};

//kernel/trap.c
...
void
store(void){
    struct proc *p = myproc();
    p->tick_ra = p->trapframe->ra;
    p->tick_sp = p->trapframe->sp;
    p->tick_gp = p->trapframe->gp;
    p->tick_tp = p->trapframe->tp;
    p->tick_t0 = p->trapframe->t0;
    p->tick_t1 = p->trapframe->t1;
    p->tick_t2 = p->trapframe->t2;
    p->tick_s0 = p->trapframe->s0;
    p->tick_s1 = p->trapframe->s1;
    p->tick_a0 = p->trapframe->a0;
    p->tick_a1 = p->trapframe->a1;
    p->tick_a2 = p->trapframe->a2;
    p->tick_a3 = p->trapframe->a3;
    p->tick_a4 = p->trapframe->a4;
    p->tick_a5 = p->trapframe->a5;
    p->tick_a6 = p->trapframe->a6;
    p->tick_a7 = p->trapframe->a7;
    p->tick_s2 = p->trapframe->s2;
    p->tick_s3 = p->trapframe->s3;
    p->tick_s4 = p->trapframe->s4;
    p->tick_s5 = p->trapframe->s5;
    p->tick_s6 = p->trapframe->s6;
    p->tick_s7 = p->trapframe->s7;
    p->tick_s8 = p->trapframe->s8;
    p->tick_s9 = p->trapframe->s9;
    p->tick_s10 = p->trapframe->s10;
    p->tick_s11 = p->trapframe->s11;
    p->tick_t3 = p->trapframe->t3;
    p->tick_t4 = p->trapframe->t4;
    p->tick_t5 = p->trapframe->t5;
    p->tick_t6 = p->trapframe->t6;
}
//
// handle an interrupt, exception, or system call from user space.
// called from trampoline.S
//
void
usertrap(void)
{
  int which_dev = 0;

  if((r_sstatus() & SSTATUS_SPP) != 0)
    panic("usertrap: not from user mode");

  // send interrupts and exceptions to kerneltrap(),
  // since we're now in the kernel.
  w_stvec((uint64)kernelvec);

  struct proc *p = myproc();

  // save user program counter.
  p->trapframe->epc = r_sepc();

  if(r_scause() == 8){
    // system call

    if(killed(p))
      exit(-1);

    // sepc points to the ecall instruction,
    // but we want to return to the next instruction.
    p->trapframe->epc += 4;

    // an interrupt will change sepc, scause, and sstatus,
    // so enable only now that we're done with those registers.
    intr_on();

    syscall();
  } else if((which_dev = devintr()) != 0){
    // ok
  } else {
    printf("usertrap(): unexpected scause %p pid=%d\n", r_scause(), p->pid);
    printf("            sepc=%p stval=%p\n", r_sepc(), r_stval());
    setkilled(p);
  }

  if(killed(p))
    exit(-1);

  // give up the CPU if this is a timer interrupt.
//  if(which_dev == 2)
//    yield();

    // give up the CPU if this is a timer interrupt.
    if(which_dev == 2) {
        // todo
        if (p->ticks > 0){
            p->ticks_cnt++;
            if (p->handler_executing == 0 && p->ticks_cnt > p->ticks){
                p->ticks_cnt = 0;
                p->tick_epc = p->trapframe->epc;
                store();
                p->handler_executing = 1;
                p->trapframe->epc = p->handler;
            }
        }

        yield();
    }
    usertrapret();
}

//
// return to user space
//

// kernel/sysproc.c
...

uint64
sys_uptime(void)
{
  uint xticks;

  acquire(&tickslock);
  xticks = ticks;
  release(&tickslock);
  return xticks;
}


// set an alarm to call the handler function
// every period ticks
// For now, your `sys_sigreturn` should just return zero.
uint64
sys_sigalarm(void) {
    int ticks;
    uint64 handler;

    argint(0, &ticks);
    if(&ticks < 0){
        return -1;
    }

    argaddr(1, &handler);
    if(handler <0){
        return -1;
    }
    struct proc *p = myproc(); // 用myproc()来获取当前进程

    p->ticks = ticks;
    p->handler = handler;
    p->ticks_cnt = 0;

    return 0;
}

void restore(){
    struct proc *p = myproc();
    p->trapframe->ra = p->tick_ra;
    p->trapframe->sp = p->tick_sp;
    p->trapframe->gp = p->tick_gp;
    p->trapframe->tp = p->tick_tp;
    p->trapframe->t0 = p->tick_t0;
    p->trapframe->t1 = p->tick_t1;
    p->trapframe->t2 = p->tick_t2;
    p->trapframe->s0 = p->tick_s0;
    p->trapframe->s1 = p->tick_s1;
    p->trapframe->a0 = p->tick_a0;
    p->trapframe->a1 = p->tick_a1;
    p->trapframe->a2 = p->tick_a2;
    p->trapframe->a3 = p->tick_a3;
    p->trapframe->a4 = p->tick_a4;
    p->trapframe->a5 = p->tick_a5;
    p->trapframe->a6 = p->tick_a6;
    p->trapframe->a7 = p->tick_a7;
    p->trapframe->s2 = p->tick_s2;
    p->trapframe->s3 = p->tick_s3;
    p->trapframe->s4 = p->tick_s4;
    p->trapframe->s5 = p->tick_s5;
    p->trapframe->s6 = p->tick_s6;
    p->trapframe->s7 = p->tick_s7;
    p->trapframe->s8 = p->tick_s8;
    p->trapframe->s9 = p->tick_s9;
    p->trapframe->s10 = p->tick_s10;
    p->trapframe->s11 = p->tick_s11;
    p->trapframe->t3 = p->tick_t3;
    p->trapframe->t4 = p->tick_t4;
    p->trapframe->t5 = p->tick_t5;
    p->trapframe->t6 = p->tick_t6;
}

uint64
sys_sigreturn(void){
    acquire(&tickslock);
    struct proc *p = myproc();
    p->trapframe->epc = p->tick_epc;
    restore();
    p->handler_executing = 0;

    release(&tickslock);
    return p->trapframe->a0;
    // cuz this func return value would be set into a0 test 3


}

// kernel/proc.h
// Saved registers for kernel context switches.
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;
};

// Per-CPU state.
struct cpu {
  struct proc *proc;          // The process running on this cpu, or null.
  struct context context;     // swtch() here to enter scheduler().
  int noff;                   // Depth of push_off() nesting.
  int intena;                 // Were interrupts enabled before push_off()?
};

extern struct cpu cpus[NCPU];

// per-process data for the trap handling code in trampoline.S.
// sits in a page by itself just under the trampoline page in the
// user page table. not specially mapped in the kernel page table.
// uservec in trampoline.S saves user registers in the trapframe,
// then initializes registers from the trapframe's
// kernel_sp, kernel_hartid, kernel_satp, and jumps to kernel_trap.
// usertrapret() and userret in trampoline.S set up
// the trapframe's kernel_*, restore user registers from the
// trapframe, switch to the user page table, and enter user space.
// the trapframe includes callee-saved user registers like s0-s11 because the
// return-to-user path via usertrapret() doesn't return through
// the entire kernel call stack.
struct trapframe {
  /*   0 */ uint64 kernel_satp;   // kernel page table
  /*   8 */ uint64 kernel_sp;     // top of process's kernel stack
  /*  16 */ uint64 kernel_trap;   // usertrap()
  /*  24 */ uint64 epc;           // saved user program counter
  /*  32 */ uint64 kernel_hartid; // saved kernel tp
  /*  40 */ uint64 ra;
  /*  48 */ uint64 sp;
  /*  56 */ uint64 gp;
  /*  64 */ uint64 tp;
  /*  72 */ uint64 t0;
  /*  80 */ uint64 t1;
  /*  88 */ uint64 t2;
  /*  96 */ uint64 s0;
  /* 104 */ uint64 s1;
  /* 112 */ uint64 a0;
  /* 120 */ uint64 a1;
  /* 128 */ uint64 a2;
  /* 136 */ uint64 a3;
  /* 144 */ uint64 a4;
  /* 152 */ uint64 a5;
  /* 160 */ uint64 a6;
  /* 168 */ uint64 a7;
  /* 176 */ uint64 s2;
  /* 184 */ uint64 s3;
  /* 192 */ uint64 s4;
  /* 200 */ uint64 s5;
  /* 208 */ uint64 s6;
  /* 216 */ uint64 s7;
  /* 224 */ uint64 s8;
  /* 232 */ uint64 s9;
  /* 240 */ uint64 s10;
  /* 248 */ uint64 s11;
  /* 256 */ uint64 t3;
  /* 264 */ uint64 t4;
  /* 272 */ uint64 t5;
  /* 280 */ uint64 t6;
};

enum procstate { UNUSED, USED, SLEEPING, RUNNABLE, RUNNING, ZOMBIE };

// Per-process state
struct proc {
  struct spinlock lock;

  // p->lock must be held when using these:
  enum procstate state;        // Process state
  void *chan;                  // If non-zero, sleeping on chan
  int killed;                  // If non-zero, have been killed
  int xstate;                  // Exit status to be returned to parent's wait
  int pid;                     // Process ID

  // wait_lock must be held when using this:
  struct proc *parent;         // Parent process

  // these are private to the process, so p->lock need not be held.
  uint64 kstack;               // Virtual address of kernel stack
  uint64 sz;                   // Size of process memory (bytes)
  pagetable_t pagetable;       // User page table
  struct trapframe *trapframe; // data page for trampoline.S
  struct context context;      // swtch() here to run process
  struct file *ofile[NOFILE];  // Open files
  struct inode *cwd;           // Current directory
  char name[16];               // Process name (debugging)

  //lab 4
  int ticks;
  uint64 handler;
  int handler_executing;

  // You'll need to keep track of how many ticks have passed since the last call
  // (or are left until the next call) to a process's alarm handler;
  // you'll need a new field in `struct proc` for this too.
  int ticks_cnt;

  uint64 tick_epc;

  uint64 tick_ra;
  uint64 tick_sp;
  uint64 tick_gp;
  uint64 tick_tp;
  uint64 tick_t0;
  uint64 tick_t1;
  uint64 tick_t2;
  uint64 tick_s0;
  uint64 tick_s1;
  uint64 tick_a0;
  uint64 tick_a1;
  uint64 tick_a2;
  uint64 tick_a3;
  uint64 tick_a4;
  uint64 tick_a5;
  uint64 tick_a6;
  uint64 tick_a7;
  uint64 tick_s2;
  uint64 tick_s3;
  uint64 tick_s4;
  uint64 tick_s5;
  uint64 tick_s6;
  uint64 tick_s7;
  uint64 tick_s8;
  uint64 tick_s9;
  uint64 tick_s10;
  uint64 tick_s11;
  uint64 tick_t3;
  uint64 tick_t4;
  uint64 tick_t5;
  uint64 tick_t6;

};

//kernel/proc.c
//   
...
found:
  p->pid = allocpid();
...
  // Lab4
  p->ticks = 0;
  p->handler_executing = 0;

    return p;
}

Submit the lab

Time spent

Create a new file, time.txt, and put in a single integer, the number of hours you spent on the lab. git add and git commit the file.

Answers

If this lab had questions, write up your answers in answers-*.txt. git add and git commit these files.

Submit

Assignment submissions are handled by Gradescope. You will need an MIT gradescope account. See Piazza for the entry code to join the class. Use this link if you need more help joining.

When you're ready to submit, run make zipball, which will generate lab.zip. Upload this zip file to the corresponding Gradescope assignment.

If you run make zipball and you have either uncomitted changes or untracked files, you will see output similar to the following:

M hello.c
?? bar.c
?? foo.pyc
Untracked files will not be handed in.  Continue? [y/N]

Inspect the above lines and make sure all files that your lab solution needs are tracked, i.e., not listed in a line that begins with ??. You can cause git to track a new file that you create using git add {filename}.

• Please run make grade to ensure that your code passes all of the tests. The Gradescope autograder will use the same grading program to assign your submission a grade.
• Commit any modified source code before running make zipball.
• You can inspect the status of your submission and download the submitted code at Gradescope. The Gradescope lab grade is your final lab grade.

Optional challenge exercises

• Print the names of the functions and line numbers in backtrace() instead of numerical addresses (hard).

Comments