xv6(3) 内存管理部分

struct run {
  struct run *next;    //指向下一个空闲物理页
};

struct {
  struct spinlock lock;   //自旋锁
  int use_lock;           //现下是否使用锁？
  struct run *freelist;   //空闲链表头
} kmem;

char* kalloc(void)
{
  struct run *r;       //声明run结构体指针

  if(kmem.use_lock)    //如果使用了锁，取锁
    acquire(&kmem.lock);
  r = kmem.freelist;      //第一个空闲页地址赋给r
  if(r)
    kmem.freelist = r->next;  //链头移动到下一页，相当于把链头给分配出去了
  if(kmem.use_lock)    //如果使用了锁，解锁
    release(&kmem.lock);
  return (char*)r;    //返回第一个空闲页的地址
}

void kfree(char *v)   //释放页v
{
  struct run *r;
  //这个页应该在这些范围内且边界为4K的倍数
  if((uint)v % PGSIZE || v < end || V2P(v) >= PHYSTOP) 
    panic("kfree");

  // Fill with junk to catch dangling refs.
  memset(v, 1, PGSIZE);  //将这个页填充无用信息，全置为1

  if(kmem.use_lock)        //如果使用了锁，取锁
    acquire(&kmem.lock);
  r = (struct run*)v;       //头插法将这个页放在链头
  r->next = kmem.freelist;  //当前页指向链头
  kmem.freelist = r;        //链头移到当前页
  if(kmem.use_lock)         //如果使用了锁，解锁
    release(&kmem.lock);
}

void freerange(void *vstart, void *vend)   //连续释放vstart到vend之间的页
{
  char *p;
  p = (char*)PGROUNDUP((uint)vstart);
  for(; p + PGSIZE <= (char*)vend; p += PGSIZE)
    kfree(p);
}

void kinit1(void *vstart, void *vend)    //kinit1(end, P2V(4*1024*1024));
{
  initlock(&kmem.lock, "kmem");
  kmem.use_lock = 0;
  freerange(vstart, vend);
}

void kinit2(void *vstart, void *vend)   //kinit2(P2V(4*1024*1024), P2V(PHYSTOP));
{
  freerange(vstart, vend);
  kmem.use_lock = 1;
}

#define EXTMEM  0x100000            // Start of extended memory
#define PHYSTOP 0xE000000           // Top physical memory

#define DEVSPACE 0xFE000000         // 一些设备的地址，比如apic的一些寄存器

// Key addresses for address space layout (see kmap in vm.c for layout)
#define KERNBASE 0x80000000         // 内核的起始虚拟地址
#define KERNLINK (KERNBASE+EXTMEM)  // 内核文件的链接地址

#define V2P(a) (((uint) (a)) - KERNBASE)    //内核虚拟地址转物理地址
#define P2V(a) ((void *)(((char *) (a)) + KERNBASE))  //物理地址转内核虚拟地址

static struct kmap {     
  void *virt;
  uint phys_start;
  uint phys_end;
  int perm;
} kmap[] = {
 { (void*)KERNBASE, 0,             EXTMEM,    PTE_W}, // I/O space
 { (void*)KERNLINK, V2P(KERNLINK), V2P(data), 0},     // kern text+rodata
 { (void*)data,     V2P(data),     PHYSTOP,   PTE_W}, // kern data+memory
 { (void*)DEVSPACE, DEVSPACE,      0,         PTE_W}, // more devices
};

#define PDX(va)         (((uint)(va) >> PDXSHIFT) & 0x3FF)  //高10位
#define PTX(va)         (((uint)(va) >> PTXSHIFT) & 0x3FF)  //中10位
#define PGADDR(d, t, o) ((uint)((d) << PDXSHIFT | (t) << PTXSHIFT | (o)))   //d为高10位，t为中10位，o为低12位，将他们组合成虚拟地址

static pte_t * walkpgdir(pde_t *pgdir, const void *va, int alloc) //根据虚拟地址 va 返回相应的页表项地址
{
  pde_t *pde;      //页目录项地址
  pte_t *pgtab;    //一级页表地址

  pde = &pgdir[PDX(va)];   //va取高12位->页目录项
  if(*pde & PTE_P){        //若一级页表存在
    pgtab = (pte_t*)P2V(PTE_ADDR(*pde));   //取一级页表的物理地址，转化成虚拟地址
  } else {
    if(!alloc || (pgtab = (pte_t*)kalloc()) == 0)   //否则分配一页出来做页表
      return 0;
    // Make sure all those PTE_P bits are zero.
    memset(pgtab, 0, PGSIZE);  //初始化置0
    *pde = V2P(pgtab) | PTE_P | PTE_W | PTE_U;    //将新分配出来的以及页表记录在页目录中，标识存在，可读可写，用户可访问
  }
  return &pgtab[PTX(va)];  //va取中10位->页表项
}

static int mappages(pde_t *pgdir, void *va, uint size, uint pa, int perm)
{
  char *a, *last;
  pte_t *pte;

  a = (char*)PGROUNDDOWN((uint)va);    //虚拟地址va以4K为单位的下边界
  last = (char*)PGROUNDDOWN(((uint)va) + size - 1);   //偏移量，所以减1
  for(;;){
    if((pte = walkpgdir(pgdir, a, 1)) == 0)   //获取地址a的页表项地址
      return -1;
    if(*pte & PTE_P)     //如果该页本来就存在
      panic("remap");
    *pte = pa | perm | PTE_P;   //填写地址a相应的页表项
    if(a == last)   //映射完了退出循环
      break;
    a += PGSIZE;
    pa += PGSIZE;
  }
  return 0;
}

#define NELEM(x) (sizeof(x)/sizeof((x)[0]))  //x有多少项
pde_t* setupkvm(void)      //建立内核页表
{
  pde_t *pgdir;
  struct kmap *k;

  if((pgdir = (pde_t*)kalloc()) == 0)    //分配一页作为页目录表
    return 0; 
  memset(pgdir, 0, PGSIZE);              //页目录表置0
  if (P2V(PHYSTOP) > (void*)DEVSPACE)    //PHYSTOP的地址不能高于DEVSPACE
    panic("PHYSTOP too high");
  for(k = kmap; k < &kmap[NELEM(kmap)]; k++)    //映射4项，循环4次
    if(mappages(pgdir, k->virt, k->phys_end - k->phys_start, (uint)k->phys_start, k->perm) < 0) {
      freevm(pgdir);
      return 0;
    }
  return pgdir;
}

pde_t *kpgdir;        //全局变量kpgdir表示内核页表
void kvmalloc(void)
{
  kpgdir = setupkvm();  //建立页表
  switchkvm();    //切换页表
}
void switchkvm(void)
{
  lcr3(V2P(kpgdir));   //加载内核页表到cr3寄存器，cr3存放的是页目录物理地址
}

void seginit(void)    //设置内核用户的代码段和数据段
{
  struct cpu *c;
  c = &cpus[cpuid()];  //获取当前CPU
  //建立段描述符，内核态用户态的代码段和数据段 
  c->gdt[SEG_KCODE] = SEG(STA_X|STA_R, 0, 0xffffffff, 0);
  c->gdt[SEG_KDATA] = SEG(STA_W, 0, 0xffffffff, 0);
  c->gdt[SEG_UCODE] = SEG(STA_X|STA_R, 0, 0xffffffff, DPL_USER);
  c->gdt[SEG_UDATA] = SEG(STA_W, 0, 0xffffffff, DPL_USER);
  lgdt(c->gdt, sizeof(c->gdt));     //加载到GDTR
}

int main(void)
{
  kinit1(end, P2V(4*1024*1024)); // phys page allocator
  kvmalloc();      // kernel page table
 /*********/
  seginit();       // segment descriptors
 /*********/
  startothers();   // start other processors
  kinit2(P2V(4*1024*1024), P2V(PHYSTOP)); // must come after startothers()
 /*********/ 
}