2020 MIT6.s081 os Lab: page tables

已于 2022-09-27 15:32:29 修改
阅读量669 收藏 2
点赞数
分类专栏： MIT6.S081学习笔记 文章标签： mit6.s081 xv6 lab page tables
于 2022-07-21 14:25:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014110320/article/details/125911497
版权

文章目录

友情链接：全部实验哟

实验链接

https://pdos.csail.mit.edu/6.S081/2020/labs/pgtbl.html

Print a page table

代码更改如下：

  1. kernel/defs.h

    // vm.c
void            vmprint(pagetable_t  pagetable);

  2. kernel/exec.c

    // 函数exec的return argc之前
if (p->pid == 1) {
      vmprint(p->pagetable);
  }

  3. kernel/vm.c

    void dotprinter(int level, int indexid) {
    int dotcnt = 3 - level;
    for (int j = 0; j < dotcnt - 1; j++) {
        printf(".. ");
    }
    printf("..%d: ");
}

void vmprinthelper(pagetable_t pagetable, int level) {
    if (level < 0) {
        return;
    }

    for (int i = 0; i < 512; i++) {
        pte_t pte = pagetable[i];
        if ((pte & PTE_V) == 0) // invalid pte
            continue;
        dotprinter(level, i);
        // printf(" pte %p pa %p useraccessable: %d \n", pte, PTE2PA(pte), (pte & PTE_U));
        printf("pte %p pa %p\n", pte, PTE2PA(pte));
        vmprinthelper((pagetable_t)PTE2PA(pte), level - 1);
    }
}

void
vmprint(pagetable_t  pagetable)
{
    printf("page table %p\n", pagetable);
    vmprinthelper(pagetable, 2);
}

A kernel page table per process

代码更改如下：

  1. 在文件kernel/proc.h中，为结构体proc添加如下字段

    pagetable_t kernel_pagetable;

  2. 在文件kernel/vm.c中，添加如下函数；

    // 注意添加头文件，否则编译失败
#include "spinlock.h"
#include "proc.h"

pagetable_t
kvmbuild(void)
{
    pagetable_t  pagetable = (pagetable_t) kalloc();
    memset(pagetable, 0, PGSIZE);

    // uart registers
    mappages(pagetable, UART0, PGSIZE, UART0, PTE_R | PTE_W);

    // virtio mmio disk interface
    mappages(pagetable, VIRTIO0, PGSIZE, VIRTIO0, PTE_R | PTE_W);

    // CLINT
    mappages(pagetable, CLINT, 0x10000, CLINT, PTE_R | PTE_W);

    // PLIC
    mappages(pagetable, PLIC, 0x400000, PLIC, PTE_R | PTE_W);

    // map kernel text executable and read-only.
    mappages(pagetable, KERNBASE, (uint64)etext-KERNBASE, KERNBASE, PTE_R | PTE_X);

    // map kernel data and the physical RAM we'll make use of.
    mappages(pagetable, (uint64)etext, PHYSTOP-(uint64)etext, (uint64)etext, PTE_R | PTE_W);

    // map the trampoline for trap entry/exit to
    // the highest virtual address in the kernel.
    mappages(pagetable, TRAMPOLINE, PGSIZE, (uint64)trampoline, PTE_R | PTE_X);

    return pagetable;
}

  3. 在文件kernel/proc.c中，做如下更改，主要作用是为进程创建内核页表，并建立内核页表与kstack的映射。

    void
procinit(void)
{
  struct proc *p;
  
  initlock(&pid_lock, "nextpid");
  for(p = proc; p < &proc[NPROC]; p++) {
      initlock(&p->lock, "proc");
      // 注释如下内容，因为此时全局的内核页表已经不需要kstack
      // kstack需在process私有的内核页表中进行映射
      // Allocate a page for the process's kernel stack.
      // Map it high in memory, followed by an invalid
      // guard page.
//      char *pa = kalloc();
//      if(pa == 0)
//        panic("kalloc");
//      uint64 va = KSTACK((int) (p - proc));
//      kvmmap(va, (uint64)pa, PGSIZE, PTE_R | PTE_W);
//      p->kstack = va;
  }
//  kvminithart();
}

static struct proc*
allocproc(void)
{
  struct proc *p;

  for(p = proc; p < &proc[NPROC]; p++) {
    acquire(&p->lock);
    if(p->state == UNUSED) {
      goto found;
    } else {
      release(&p->lock);
    }
  }
  return 0;

found:
  p->pid = allocpid();

  // Allocate a trapframe page.
  if((p->trapframe = (struct trapframe *)kalloc()) == 0){
    release(&p->lock);
    return 0;
  }

  // An empty user page table.
  p->pagetable = proc_pagetable(p);
  if(p->pagetable == 0){
    freeproc(p);
    release(&p->lock);
    return 0;
  }

  // 以下为新添加内容
  // 为process创建私有的内核页表
  p->kernel_pagetable = kvmbuild();
  // 为内核页表建立与kstack的映射  
  char *pa = kalloc();
  if(pa == 0)
      panic("kalloc");
  uint64 va = KSTACK((int) (p - proc));
  mappages(p->kernel_pagetable, va, PGSIZE, (uint64)pa, PTE_R | PTE_W);
  p->kstack = va;
  // 结束，注意，上边添加的代码必须在下面代码之前
  // 因为下边的代码会用到p->kstack的值，而在此之前，我们
  // 必须对其进行赋值  

  // Set up new context to start executing at forkret,
  // which returns to user space.
  memset(&p->context, 0, sizeof(p->context));
  p->context.ra = (uint64)forkret;
  p->context.sp = p->kstack + PGSIZE;
  return p;
}

  4. 在文件kernel/proc.c中，对函数scheduler进行如下更改：

    void
scheduler(void)
{
  struct proc *p;
  struct cpu *c = mycpu();
  
  c->proc = 0;
  for(;;) {
    // Avoid deadlock by ensuring that devices can interrupt.
    intr_on();
    
    int found = 0;
    for(p = proc; p < &proc[NPROC]; p++) {
      acquire(&p->lock);
      if(p->state == RUNNABLE) {
        // Switch to chosen process.  It is the process's job
        // to release its lock and then reacquire it
        // before jumping back to us.
        p->state = RUNNING;
        c->proc = p;

        // begin +++++++++，
        //  切换页表地址为该进程私有页表的地址
        w_satp(MAKE_SATP(p->kernel_pagetable));
        sfence_vma();
        // end -----------    
        swtch(&c->context, &p->context);

        // Process is done running for now.
        // It should have changed its p->state before coming back.
        // begin +++++++++     
        // 切换为全局的kernel页表地址
        kvminithart(); // use kernel page table
        // end -----------    
        c->proc = 0;


        found = 1;
      }
      release(&p->lock);
    }
#if !defined (LAB_FS)
    if(found == 0) {
      intr_on();
      asm volatile("wfi");
    }
#else
    ;
#endif
  }
}

  5. 在文件kernel/proc.c的函数freeproc函数中，增加如下内容

    // begin +++++
extern char etext[];  // kernel.ld sets this to end of kernel code.
// end-------

static void
freeproc(struct proc *p)
{
  if(p->trapframe)
     kfree((void*)p->trapframe);
  p->trapframe = 0;

  // begin ++++++  
  // 取消kstack映射，并销毁kstack对应的物理内存  
  if (p->kstack)
      uvmunmap(p->kernel_pagetable, p->kstack, 1, 1);
  p->kstack = 0;
  // 释放私有页表  
  if(p->kernel_pagetable)
      proc_free_kernel_pagetable(p->kernel_pagetable);
  p->kernel_pagetable = 0;
  // end ---------

  if(p->pagetable)
    proc_freepagetable(p->pagetable, p->sz);
  p->pagetable = 0;

  p->sz = 0;
  p->pid = 0;
  p->parent = 0;
  p->name[0] = 0;
  p->chan = 0;
  p->killed = 0;
  p->xstate = 0;
  p->state = UNUSED;
}

// 新增函数，用于取消映射和销毁页表
void
proc_free_kernel_pagetable(pagetable_t pagetable)
{
    uvmunmap(pagetable, UART0, 1, 0);
    uvmunmap(pagetable, VIRTIO0, 1, 0);
    uvmunmap(pagetable, CLINT, 0x10000/PGSIZE, 0);
    uvmunmap(pagetable, PLIC, 0x400000/PGSIZE, 0);
    uvmunmap(pagetable, KERNBASE, ((uint64)etext-KERNBASE)/PGSIZE, 0);
    uvmunmap(pagetable, (uint64)etext, (PHYSTOP-(uint64)etext)/PGSIZE, 0);
    uvmunmap(pagetable, TRAMPOLINE, 1, 0);

    freewalk(pagetable);
}

  6. 在kernel/def.h中，增加我们新添加的函数

    +void            proc_free_kernel_pagetable(pagetable_t);
+void            freewalk(pagetable_t);
+pagetable_t     kvmbuild(void);

  7. 在kernel/vm.c中，更改以下函数（注意，该函数的更改在作业提示中并未给出）

    uint64
kvmpa(uint64 va)
{
  uint64 off = va % PGSIZE;
  pte_t *pte;
  uint64 pa;

  // 将walk函数的第一个参数改为进程私有的内核页表  
  struct proc* p = myproc();
  pte = walk(p->kernel_pagetable, va, 0);
  if(pte == 0)
    panic("kvmpa");
  if((*pte & PTE_V) == 0)
    panic("kvmpa");
  pa = PTE2PA(*pte);
  return pa+off;
}

Simplify

还是按照题目的步骤来：

  1. 在文件kernel/vm.c中，更改函数copyin和copyinstr。

    int
copyin(pagetable_t pagetable, char *dst, uint64 srcva, uint64 len)
{
    return copyin_new(pagetable, dst, srcva, len);
}

// Copy a null-terminated string from user to kernel.
// Copy bytes to dst from virtual address srcva in a given page table,
// until a '\0', or max.
// Return 0 on success, -1 on error.
int
copyinstr(pagetable_t pagetable, char *dst, uint64 srcva, uint64 max)
{
  return copyinstr_new(pagetable, dst, srcva, max);
}

  2. 在文件kernel/defs.h中，添加如下内容

    // vmcopyin.c
int copyin_new(pagetable_t pagetable, char *dst, uint64 srcva, uint64 len);
int copyinstr_new(pagetable_t pagetable, char *dst, uint64 srcva, uint64 max);

  3. 在文件kernel/vm.c中，添加用户态pagetable拷贝至kernel态pagetable的函数。

    void
uvm2kvm(pagetable_t pagetable, pagetable_t kpagetable, uint64 old_size, uint64 new_size)
{
    if (new_size < old_size)
        panic("new size lower than old size");

    if (PGROUNDUP(new_size) >= PLIC)
        panic("new size too big");

    uint64 begin = PGROUNDUP(old_size);
    uint64 end = PGROUNDUP(new_size);
    // printf("begin: %x, end: %x\n", begin, end);
    for (uint64 va = begin; va < end; va += PGSIZE) {
        pte_t* pte = walk(pagetable, va, 0);
        if (pte == 0)
            panic("user page table not found");
        pte_t* kpte = walk(kpagetable, va, 1);
        if (kpte == 0)
            panic("kernel page table not found");
        *kpte = (*pte) & (~PTE_U);
    }
}

  4. 在文件kernel/defs.h中添加步骤三函数的声明

    void             uvm2kvm(pagetable_t, pagetable_t, uint64, uint64);

  5. 在kernel/proc.c中的函数userinit中添加映射

      p->state = RUNNABLE;

  // begin ++++++++
  uvm2kvm(p->pagetable, p->kernel_pagetable, 0, p->sz);
  // end ++++++++

  release(&p->lock);

  6. 在kernel/proc.c中的函数fork中添加映射

      // increment reference counts on open file descriptors.
  for(i = 0; i < NOFILE; i++)
    if(p->ofile[i])
      np->ofile[i] = filedup(p->ofile[i]);
  np->cwd = idup(p->cwd);
  // begin ++++++++
  uvm2kvm(np->pagetable, np->kernel_pagetable, 0, np->sz);
  // end ++++++++

  safestrcpy(np->name, p->name, sizeof(p->name));

  7. 在kernel/exec.c中的函数exec中添加映射

     .....
   // Load program into memory.
  for(i=0, off=elf.phoff; i<elf.phnum; i++, off+=sizeof(ph)){
    if(readi(ip, 0, (uint64)&ph, off, sizeof(ph)) != sizeof(ph))
      goto bad;
    if(ph.type != ELF_PROG_LOAD)
      continue;
    if(ph.memsz < ph.filesz)
      goto bad;
    if(ph.vaddr + ph.memsz < ph.vaddr)
      goto bad;
    uint64 sz1;
    if((sz1 = uvmalloc(pagetable, sz, ph.vaddr + ph.memsz)) == 0)
      goto bad;
    sz = sz1;
    if(ph.vaddr % PGSIZE != 0)
      goto bad;
    if(loadseg(pagetable, ph.vaddr, ip, ph.off, ph.filesz) < 0)
      goto bad;
    // begin ++++++++  
    if (sz1 >= PLIC)
      goto bad;
    // end ++++++++  
  }    
 .....    

 if(copyout(pagetable, sp, (char *)ustack, (argc+1)*sizeof(uint64)) < 0)
    goto bad;

  // begin ++++++++
  // 因为exec函数会重新装载新进程，因此我们需要重新映射其内核的pagetable
  uvmunmap(p->kernel_pagetable, 0, PGROUNDUP(oldsz)/PGSIZE, 0);
  // 将新的pagetable拷贝至kernel的pagetable
  uvm2kvm(pagetable, p->kernel_pagetable, 0, sz);
  // end ++++++++

  8. 在kernel/proc.c中的函数growproc中添加映射(也就是sys_sbrk函数)

    int
growproc(int n)
{
  uint sz;
  struct proc *p = myproc();

  sz = p->sz;
  if(n > 0) {
    if((sz = uvmalloc(p->pagetable, sz, sz + n)) == 0) {
      return -1;
    }
     // begin ++++++++  
    uvm2kvm(p->pagetable, p->kernel_pagetable, sz - n, sz);
     // end ++++++++  
  } else if(n < 0) {
    sz = uvmdealloc(p->pagetable, sz, sz + n);
     // begin ++++++++  
    uvmunmap(p->kernel_pagetable, PGROUNDUP(sz), (-n)/PGSIZE, 0);
     // end ++++++++  
  }
  p->sz = sz;
  return 0;
}

  9. 修改kernel/vm.c文件中为每个进程创建内核页表的函数时，注意将Client的映射注释掉。（因为client的映射地址为0x10000， 而PLIC的映射地址为0x400000，即client低于PLIC的地址，而进程的pagetable拷贝至内核时的pagetable时，会导致原本0x10000多次被映射）

        // CLINT
//    mappages(pagetable, CLINT, 0x10000, CLINT, PTE_R | PTE_W);

  10. 在kernel/proc.c文件中，修改释放kernel_pagetable的函数.(将client相关的代码也删掉，同时释放低地址空间的映射)

    void
proc_free_kernel_pagetable(pagetable_t pagetable, uint64 sz)
{
    uvmunmap(pagetable, UART0, 1, 0);
    uvmunmap(pagetable, VIRTIO0, 1, 0);
//    uvmunmap(pagetable, CLINT, 0x10000/PGSIZE, 0);
    uvmunmap(pagetable, PLIC, 0x400000/PGSIZE, 0);
    uvmunmap(pagetable, KERNBASE, ((uint64)etext-KERNBASE)/PGSIZE, 0);
    uvmunmap(pagetable, (uint64)etext, (PHYSTOP-(uint64)etext)/PGSIZE, 0);
    uvmunmap(pagetable, TRAMPOLINE, 1, 0);
    // begin++++++++
    uvmunmap(pagetable, 0, PGROUNDUP(sz)/PGSIZE, 0);
    // end++++++++++

    freewalk(pagetable);
}

实验结果

在这里插入图片描述

提交实验

$ git commit -m "lab page tabls"
$ make handin

查看结果

登录网站https://6828.scripts.mit.edu/2020/handin.py/student，可以看到提交的结果。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hdax6MS0-1658384528631)()]
在这里插入图片描述

参考链接

https://mit-public-courses-cn-translatio.gitbook.io/mit6-s081

https://blog.csdn.net/u012419550/article/details/114701482

https://blog.csdn.net/u013577996/article/details/109582932

https://blog.csdn.net/rocketeerLi/article/details/121524760

github地址

https://github.com/aerfalwl/mit-xv6-labs-2020.git

codefreestyle
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
MIT6.s081-2020 Lab3 Page Tables
weixin_44505310的博客
02-20 888
本系列内容涉及操作系统入门，通过对MIT6.s081-2020 中lab的巩固，辅之以课程，加深对操作系统的认识。本篇是关于lab 3:Page Tables
MIT6.S081-2020-Lab: page tables
Valishment的博客
08-02 743
继续上次的xv6实验，从做完第一个实验后，到现在已经过去很久了6.S081-Lab: Xv6 and Unix utilities 操作系统实验分享。中途只做完了系统调用，也没有写上笔记。 这次学习页表一章，从看书到看代码再到编写实验，花费了很多时间，遇到了很多坑，反反复复修改代码才得到正确的结果。 还是和以前一样，对操作系统有兴趣的千万不要错过这个实验。这次的实验会接触到很多内核知识，尤其是编写实验代码过程中，将页表理论知识化为实际的代码，别说有多舒服了。 分页可谓是操作系统中一个非常重要的思想，在操作系
Lab3：Page Tables(1) —— 源码解读
最新发布
weixin_44752577的博客
05-21 139
--------24.6.13------------   目前，我通过了 的实验，通过各种办法，阅读 的中文译本，参考别人的思路、代码等等，不完全是自己的思路，但也总算是将该实验完成了。   所以就有了一些想法，想要通过博客的方式记录自己做 的过程，以及对操作系统的相关收获，预计会写几篇博客来叙述，目前还没有怎么构思好，因为在这个lab着实花费了不少时间，踩了不少坑，想要更完整地记录学习的过程。该部分具体内容可以查看xv6参考书，这里进行简单介绍
【MIT-6.1810】Lab: page tables
weixin_46322986的博客
06-26 933
页表的初始化位于函数 proc_pagetable 中，通过 mappages 在页表中注册新的 PTE，参考 TRAPFRAME 的方式，将 USYSCALL 映射到 p->usyscall 中。实验要求实现一个系统调用 sys_pgaccess，其会从一个虚拟地址对应的 PTE 开始，往下搜索一定数量的被访问（read/write）过的页表，并把结果通过 mask 的方式返回给用户。但是，该 lab 是利用页表，而不是编写页表，所以比较简单。其次，PTE 是连续的，那么对应的虚拟地址也应是连续的。
CLINT和PLIC，risc-v中断
Leo ICer的博客
03-03 7329
中断这个东西理论上属于CPU核心的东西。一般来说并不需要重新设计。实际的实现中是比较繁琐的，此处只介绍原理。ARM基本上会用NVIC(Nested Vectored Interrupt Controller) 的东西，RISC-V目前实现了一个比较简单的东西（有人称之为简洁高效），不支持嵌套的中断，所以讲原理起来还是比较简单的。只是我隐隐觉得，ARM之所以中断比较复杂，那是因为踩过无数坑以后慢慢变复杂的。RISC-V的中断机制是不是too young too simple还有待生产生活的检验。 一、R
Lab3: page tables (hard!) 详解
qq_53111905的博客
10-27 1997
Lab3: page tables (hard!) 这个实验难度被MIT的老师评价为第一 文章目录Lab3: page tables (hard!)Print a page table (easy)第一步第二步第三步给每一个进程弄一个kernel_pagetable (hard)第一步 添加一个内核页表第二步 确保内核页表映射到该进程的内核栈第三步 修改scheduler第四步 释放内核页表简化 `copyin`/`copyinstr`（hard）第一步 替换`copyin()`、`copyinstr`
MIT6.S081-2020fall:麻省理工学院本科操作系统课程
05-28
MIT 6.S081 2020秋季 该存储库包含我对MIT 6.S081操作系统实验室的解决方案。 如何使用它 ？ 首先，您需要通过以下方式克隆此存储库 git clone https: // github.com/PKUFlyingPig/MIT6.S081-2020fall.git 然后cd...
xv6-labs-2020:MIT 6.S081 2020秋季操作系统
03-30
xv6-riscv-lab MIT 6.S081 / 2020年秋季实验室 进度 Lab1 Lab2 Lab3 Lab4陷阱 Lab5延迟分配 Lab6写时复制 Lab7多线程 Lab8锁 Lab9文件系统 Lab10 mmap Lab11网络驱动程序 文件 Lab1 Lab2 Lab3
MIT_OS：MIT 6.S081操作系统简介（2020年秋季）
02-04
MIT_OS分数 :check_mark: 通过所有测试：1、4、5、6、7、8、9、10 :cross_mark: 部分通过：2、3、11实验手册开始拥有Linux系统（Ubuntu，Debian .etc）或Mac系统，其硬盘空间至少为20GB（建议30GB +）。 Windows + ...
操作系统：操作系统（MIT 6.S081 2020年秋季）代码
02-15
MIT 6.S081操作系统2020秋季 课程网页： : 我们在课程中实施实验室实验。 我们还将实现讲义中的一些示例 以及讲座视频。 当文件来自分配时，文件名与分配中的文件名相同。 当它们是示例时，我们使用“ example_...
MIT6.S081
02-07
【标题】"MIT6.S081" 是麻省理工学院（MIT）提供的一门计算机科学课程，专注于操作系统（Operating System）的实现。这门课程深入讲解了操作系统的基础概念、设计原理以及实际开发技巧，主要使用C语言进行教学。通过...
lab pagetable
maoyl0506的博客
07-29 324
lab pgtbl
【MIT 6.S081】Lab3: page tables
juruo_c的博客
03-23 496
PgtblPrint a page tableA kernel page table per processSimplify copyin/copyinstr 本Lab简单优化了系统的页表功能，使得程序在内核态时可以直接解析用户态的指针。 笔者用时约8h Print a page table 第一部分是为系统添加一个打印给定页表的函数vmprint，该函数接收一个参数pagetable（根页表的物理地址），递归遍历整张页表，打印有效的表项。 参考freewalk函数（定义在kernel/vm.c:331），
【MIT6.S081】Lab3: page tables(详细解答版)
lllllllllljg的博客
04-13 1279
实验内容网址：https://xv6.dgs.zone/labs/requirements/lab3.html本实验的代码分支：https://gitee.com/dragonlalala/xv6-labs-2020/tree/pgtbl2/
Lab3: page tables
weixin_52435933的博客
11-18 558
兄弟们，我XV6又回来啦，这个栏目的灰都能把人埋了，鸽子王实锤(当然不是因为懒(⁎⁍̴̛ᴗ⁍̴̛⁎))。不过虽迟但到！主要有时候看完文档和课程后又去搞其他飞机了，回来时，发现一切回到原点。这周发现再不搞真搞不完了，Lab3是关于页表的，文档戳这。 ❖ Coding ☑︎ Speed up system calls (easy)由于用户在使用系统调用时需要从用户空间跳转到...
动手实现操作系统！详细剖析 MIT 6.S081 课程 Lab 3 : page tables - 1 Speed up system calls
weixin_45762157的博客
02-05 1690
本文细致的剖析了 2021 FALL MIT 6.S081 课程的一项实验，有些操作系统（例如 Linux）通过在用户空间和内核之间的只读区域共享数据，加速特定的系统调用。这消除了在执行这些系统调用时进行内核切换的需要。为了学习如何建立页表映射，本实验在 xv6 中为 getpid() 系统调用实现了这种优化。
RISC-V SiFive U54内核——CLINT中断控制器
嵌入式Linux充电站
12-01 926
RISC-V SiFive U54内核的有两个中断控制器：CLINT和PLIC。CLINT用于本地中断（软件中断和定时器中断），PLIC用于全局中断。
手把手教你设计CPU-2
nerohero的博客
08-06 812
中断和异常 中断和异常最大区别在于中断往往时一种外因，而异常是由处理器内部事件或程序执行中的事件引起的，譬如本身硬件故障、程序故常。 中断和异常是狭义的划分，广义的异常，通常分为同步异常和异步异常。 RISC-V中断有机器模式、用户模式、监督模式。蜂鸟R200只实现了机器模式。 进入异常时，RISC-V架构规定的硬件行为可以简述如下。 （1）停止执行当前程序流，转而从CSR寄存器mtvec定义的PC地址开始执行。 （2）进入异常不仅会让处理器跳转到上述的PC地址开始执行，还会让硬件同时更新其他几个CSR寄存
2021 MIT6.S081 Lab: page table
m0_52394388的博客
08-03 557
2021的Lab3在设计上相比2020精简了许多内容，很快就做完了，第三个assignment的边界检查没做也能过就懒得做了
mit 6.s081 2020 lab6
12-10
MIT 6.S081是麻省理工学院的一个...总的来说，MIT 6.S081 2020 lab6是一个具有挑战性的实验项目，通过完成这个实验，学生们将深入了解操作系统中网络编程和多线程方面的知识，为他们今后的学习和工作打下坚实的基础。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值