static void i386_detect_memory(void) {
  size_t basemem, extmem, ext16mem, totalmem;

  // Use CMOS calls to measure available base & extended memory.
  // (CMOS calls return results in kilobytes.)
  basemem = nvram_read(NVRAM_BASELO);
  extmem = nvram_read(NVRAM_EXTLO);
  ext16mem = nvram_read(NVRAM_EXT16LO) * 64;

  // Calculate the number of physical pages available in both base
  // and extended memory.
  if (ext16mem) {
    totalmem = 16 * 1024 + ext16mem;
  } else if (extmem) {
    totalmem = 1 * 1024 + extmem;
  } else {
    totalmem = basemem;
  }

  npages = totalmem / (PGSIZE / 1024);
  npages_basemem = basemem / (PGSIZE / 1024);

  printf("Physical memory: %dK available, base = %dK, extended = %dK\n", totalmem, basemem, totalmem - basemem);
}

  // create initial page directory.
  kern_pgdir = (pde_t *)boot_alloc(PGSIZE);
  memset(kern_pgdir, 0, PGSIZE);

  // Recursively insert PD in itself as a page table, to form
  // a virtual page table at virtual address UVPT.
  // (For now, you don't have understand the greater purpose of the
  // following line.)

  // Permissions: kernel R, user R
  kern_pgdir[PDX(UVPT)] = PADDR(kern_pgdir) | PTE_U | PTE_P;

  // Allocate an array of npages 'struct PageInfo's and store it in 'pages'.
  // The kernel uses this array to keep track of physical pages: for
  // each physical page, there is a corresponding struct PageInfo in this
  // array.  'npages' is the number of physical pages in memory.  Use memset
  // to initialize all fields of each struct PageInfo to 0.
  // Your code goes here:
  pages = (struct PageInfo *)boot_alloc(npages * sizeof(struct PageInfo));
  memset(pages, 0, npages * sizeof(struct PageInfo));

static inline physaddr_t page2pa(struct PageInfo *pp) {
  return (pp - pages) << PGSHIFT;
}

  // Now that we've allocated the initial kernel data structures, we set
  // up the list of free physical pages. Once we've done so, all further
  // memory management will go through the page_* functions. In particular,
  // we can now map memory using boot_map_region or page_insert
  page_init();

struct PageInfo *page_alloc(int alloc_flags) {
  // Fill this function in
  struct PageInfo *pp;

  if (page_free_list == NULL) {
    return NULL;
  }
  pp = page_free_list;
  page_free_list = page_free_list->pp_link;
  pp->pp_link = NULL;

  if (alloc_flags & ALLOC_ZERO) {
    memset(page2kva(pp), 0, PGSIZE);
  }

  return pp;
}

void page_free(struct PageInfo *pp) {
  // Fill this function in
  // Hint: You may want to panic if pp->pp_ref is nonzero or
  // pp->pp_link is not NULL.
  if (pp->pp_ref != 0) {
    panic("page_free: pp->pp_ref != nonzero");
  }
  if (pp->pp_link) {
    panic("page_free: pp->pp_link != NULL");
  }

  pp->pp_link = page_free_list;
  page_free_list = pp;
}

pte_t *pgdir_walk(pde_t *pgdir, const void *va, int create) {
  // Fill this function in
  struct PageInfo *pp;
  pte_t *pgtable;

  pgtable = (pte_t *)PTE_ADDR(pgdir[PDX(va)]);
  if (pgtable == NULL) {
    if (!create) {
      return NULL;
    }
    pp = page_alloc(ALLOC_ZERO);
    if (pp == NULL) {
      return NULL;
    }
    pp->pp_ref++;
    pgtable = (pte_t *)page2pa(pp);
    pgdir[PDX(va)] = (uintptr_t)pgtable | PTE_P | PTE_W;
  }
  pgtable = (pte_t *)KADDR((physaddr_t)pgtable);
  return &pgtable[PTX(va)];
}

int page_insert(pde_t *pgdir, struct PageInfo *pp, void *va, int perm) {
  // Fill this function in
  pte_t *ppte;

  ppte = pgdir_walk(pgdir, va, true);
  if (ppte == NULL) {
    return -E_NO_MEM;
  }

  if (*ppte != 0) {
    if (PTE_ADDR(*ppte) != page2pa(pp)) {
      page_remove(pgdir, va);
      pp->pp_ref++;
    }
  } else {
    pp->pp_ref++;
  }

  pgdir[PDX(va)] = PTE_ADDR(pgdir[PDX(va)]) | perm | PTE_P;
  *ppte = page2pa(pp) | perm | PTE_P;

  return 0;
}

//
// Map [va, va+size) of virtual address space to physical [pa, pa+size)
// in the page table rooted at pgdir.  Size is a multiple of PGSIZE, and
// va and pa are both page-aligned.
// Use permission bits perm|PTE_P for the entries.
//
// This function is only intended to set up the ``static'' mappings
// above UTOP. As such, it should *not* change the pp_ref field on the
// mapped pages.
//
// Hint: the TA solution uses pgdir_walk
static void boot_map_region(pde_t *pgdir, uintptr_t va, size_t size, physaddr_t pa, int perm) {
  // Fill this function in
  assert(va % PGSIZE == 0);
  assert(pa % PGSIZE == 0);
  assert(size % PGSIZE == 0);

  uint64_t __u64_va = (uint64_t)va;
  uint64_t __u64_va_end = __u64_va + size;
  uint64_t __u64_pa = (uint64_t)pa;
  pte_t *ppte;

  while (__u64_va < __u64_va_end) {
    va = (uintptr_t)__u64_va;
    pa = (uintptr_t)__u64_pa;
    ppte = pgdir_walk(pgdir, (const void *)va, true);
    assert(ppte);
    *ppte = pa | perm | PTE_P;

    __u64_va += PGSIZE;
    __u64_pa += PGSIZE;
  }
}

  // Switch from the minimal entry page directory to the full kern_pgdir
  // page table we just created.	Our instruction pointer should be
  // somewhere between KERNBASE and KERNBASE+4MB right now, which is
  // mapped the same way by both page tables.
  //
  // If the machine reboots at this point, you've probably set up your
  // kern_pgdir wrong.
  lcr3(PADDR(kern_pgdir));