[BACK]Return to pmap.c CVS log [TXT][DIR] Up to [cvs.NetBSD.org] / src / sys / arch / ia64 / ia64

Please note that diffs are not public domain; they are subject to the copyright notices on the relevant files.

Diff for /src/sys/arch/ia64/ia64/pmap.c between version 1.11 and 1.12

version 1.11, 2007/10/25 13:03:04 version 1.12, 2008/03/20 09:09:20
Line 128  static uint64_t pmap_ptc_e_count1 = 3;
Line 128  static uint64_t pmap_ptc_e_count1 = 3;
 static uint64_t pmap_ptc_e_count2 = 2;  static uint64_t pmap_ptc_e_count2 = 2;
 static uint64_t pmap_ptc_e_stride1 = 0x2000;  static uint64_t pmap_ptc_e_stride1 = 0x2000;
 static uint64_t pmap_ptc_e_stride2 = 0x100000000;  static uint64_t pmap_ptc_e_stride2 = 0x100000000;
 struct lock pmap_ptc_lock;  kmutex_t pmap_ptc_lock;                 /* Global PTC lock */
   
 /* VHPT Base */  /* VHPT Base */
   
Line 137  vaddr_t pmap_vhpt_log2size;
Line 137  vaddr_t pmap_vhpt_log2size;
   
 struct ia64_bucket *pmap_vhpt_bucket;  struct ia64_bucket *pmap_vhpt_bucket;
 int pmap_vhpt_nbuckets;  int pmap_vhpt_nbuckets;
 struct lock pmap_vhptlock;  kmutex_t pmap_vhptlock;                /* VHPT collision chain lock */
   
 int pmap_vhpt_inserts;  int pmap_vhpt_inserts;
 int pmap_vhpt_resident;  int pmap_vhpt_resident;
Line 155  static int pmap_rididx;
Line 155  static int pmap_rididx;
 static int pmap_ridmapsz;  static int pmap_ridmapsz;
 static int pmap_ridmax;  static int pmap_ridmax;
 static uint64_t *pmap_ridmap;  static uint64_t *pmap_ridmap;
 struct lock pmap_rid_lock;  kmutex_t pmap_rid_lock;                 /* RID allocator lock */
   
   
 bool            pmap_initialized;       /* Has pmap_init completed? */  bool            pmap_initialized;       /* Has pmap_init completed? */
Line 204  struct pool pmap_pmap_pool;
Line 204  struct pool pmap_pmap_pool;
 struct pool pmap_ia64_lpte_pool;  struct pool pmap_ia64_lpte_pool;
 struct pool pmap_pv_pool;  struct pool pmap_pv_pool;
   
 struct lock pmap_main_lock;  kmutex_t pmap_main_lock;
 struct simplelock pmap_all_pmaps_slock;  kmutex_t pmap_all_pmaps_slock;
   
 #if defined(MULTIPROCESSOR) || defined(LOCKDEBUG)  #if defined(MULTIPROCESSOR) || defined(LOCKDEBUG)
   /* XXX(kochi) need to use only spin lock? */
 #define PMAP_MAP_TO_HEAD_LOCK() \  #define PMAP_MAP_TO_HEAD_LOCK() \
         spinlockmgr(&pmap_main_lock, LK_SHARED, NULL)          spinlockmgr(&pmap_main_lock, LK_SHARED, NULL)
 #define PMAP_MAP_TO_HEAD_UNLOCK() \  #define PMAP_MAP_TO_HEAD_UNLOCK() \
Line 244  struct simplelock pmap_all_pmaps_slock;
Line 245  struct simplelock pmap_all_pmaps_slock;
  * The VHPT bucket head structure.   * The VHPT bucket head structure.
  */   */
 struct ia64_bucket {  struct ia64_bucket {
         uint64_t        chain;          uint64_t        chain;
         struct lock     lock;          kmutex_t        lock;
         u_int           length;          u_int           length;
 };  };
   
   
Line 384  pmap_steal_memory(vsize_t size, vaddr_t 
Line 385  pmap_steal_memory(vsize_t size, vaddr_t 
                 va = IA64_PHYS_TO_RR7(pa);                  va = IA64_PHYS_TO_RR7(pa);
                 memset((void *)va, 0, size);                  memset((void *)va, 0, size);
                 pmap_pages_stolen += npgs;                  pmap_pages_stolen += npgs;
                 return (va);                  return va;
         }          }
   
         /*          /*
Line 517  pmap_steal_vhpt_memory(vsize_t size)
Line 518  pmap_steal_vhpt_memory(vsize_t size)
         va = IA64_PHYS_TO_RR7(pa);          va = IA64_PHYS_TO_RR7(pa);
         memset((void *)va, 0, size);          memset((void *)va, 0, size);
         pmap_pages_stolen += npgs;          pmap_pages_stolen += npgs;
         return (va);          return va;
 }  }
   
   
Line 561  pmap_bootstrap()
Line 562  pmap_bootstrap()
                        pmap_ptc_e_count2,                         pmap_ptc_e_count2,
                        pmap_ptc_e_stride1,                         pmap_ptc_e_stride1,
                        pmap_ptc_e_stride2);                         pmap_ptc_e_stride2);
         spinlockinit(&pmap_ptc_lock, "Global PTC lock", LK_RECURSE_FAIL);          mutex_init(&pmap_ptc_lock, MUTEX_SPIN, IPL_VM);
   
         /*          /*
          * Setup RIDs. RIDs 0..7 are reserved for the kernel.           * Setup RIDs. RIDs 0..7 are reserved for the kernel.
Line 609  pmap_bootstrap()
Line 610  pmap_bootstrap()
          *      mtx_init(&pmap_ridmutex, "RID allocator lock", NULL, MTX_DEF);           *      mtx_init(&pmap_ridmutex, "RID allocator lock", NULL, MTX_DEF);
          *      MTX_DEF can *sleep*.           *      MTX_DEF can *sleep*.
          */           */
         lockinit(&pmap_rid_lock, 0, "RID allocator lock", 0, LK_RECURSEFAIL);          mutex_init(&pmap_rid_lock, MUTEX_ADAPTIVE, IPL_VM);
   
   
         /*          /*
Line 713  pmap_bootstrap()
Line 714  pmap_bootstrap()
         if (bootverbose)          if (bootverbose)
                 printf("Putting VHPT at 0x%lx\n", base);                  printf("Putting VHPT at 0x%lx\n", base);
   
         spinlockinit(&pmap_vhptlock, "VHPT collision chain lock", LK_RECURSEFAIL);          mutex_init(&pmap_vhptlock, MUTEX_SPIN, IPL_VM);
   
         __asm __volatile("mov cr.pta=%0;; srlz.i;;" ::          __asm __volatile("mov cr.pta=%0;; srlz.i;;" ::
             "r" (vhpt_base + (1<<8) + (pmap_vhpt_log2size<<2) + 1));              "r" (vhpt_base + (1<<8) + (pmap_vhpt_log2size<<2) + 1));
Line 740  pmap_bootstrap()
Line 741  pmap_bootstrap()
                 pte[i].tag = 1UL << 63; /* Invalid tag */                  pte[i].tag = 1UL << 63; /* Invalid tag */
                 pte[i].chain = (uintptr_t)(pmap_vhpt_bucket + i);                  pte[i].chain = (uintptr_t)(pmap_vhpt_bucket + i);
                 /* Stolen memory is zeroed! */                  /* Stolen memory is zeroed! */
                 spinlockinit(&pmap_vhpt_bucket[i].lock, "VHPT bucket lock", LK_RECURSEFAIL);                  mutex_init(&pmap_vhpt_bucket[i].lock, MUTEX_SPIN,
                       IPL_VM);
         }          }
   
         /*          /*
          * Initialize the locks.           * Initialize the locks.
          */           */
         spinlockinit(&pmap_main_lock, "pmaplk", 0);          mutex_init(&pmap_main_lock, MUTEX_ADAPTIVE, IPL_VM);
         simple_lock_init(&pmap_all_pmaps_slock);          mutex_init(&pmap_all_pmaps_slock, MUTEX_SPIN, IPL_VM);
   
         /*          /*
          * Initialize the kernel pmap (which is statically allocated).           * Initialize the kernel pmap (which is statically allocated).
          */           */
         memset(pmap_kernel(), 0, sizeof(struct pmap));          memset(pmap_kernel(), 0, sizeof(struct pmap));
   
         simple_lock_init(pmap_kernel()->pm_slock);          mutex_init(&pmap_kernel()->pm_slock, MUTEX_SPIN, IPL_VM);
         for (i = 0; i < 5; i++)          for (i = 0; i < 5; i++)
                 pmap_kernel()->pm_rid[i] = 0;                  pmap_kernel()->pm_rid[i] = 0;
         pmap_kernel()->pm_active = 1;          pmap_kernel()->pm_active = 1;
Line 828  vtophys(va)
Line 829  vtophys(va)
         paddr_t pa;          paddr_t pa;
   
         if (pmap_extract(pmap_kernel(), va, &pa) == true)          if (pmap_extract(pmap_kernel(), va, &pa) == true)
                 return (pa);                  return pa;
         return (0);          return 0;
 }  }
   
 /*  /*
Line 1108  pmap_create(void)
Line 1109  pmap_create(void)
         TAILQ_INIT(&pmap->pm_pvlist);          TAILQ_INIT(&pmap->pm_pvlist);
         memset(&pmap->pm_stats, 0, sizeof (pmap->pm_stats) );          memset(&pmap->pm_stats, 0, sizeof (pmap->pm_stats) );
   
         simple_lock_init(&pmap->pm_slock);          mutex_init(&pmap->pm_slock, MUTEX_SPIN, IPL_VM);
   
         simple_lock(&pmap_all_pmaps_slock);          mutex_enter(&pmap_all_pmaps_slock);
         TAILQ_INSERT_TAIL(&pmap_all_pmaps, pmap, pm_list);          TAILQ_INSERT_TAIL(&pmap_all_pmaps, pmap, pm_list);
         simple_unlock(&pmap_all_pmaps_slock);          mutex_exit(&pmap_all_pmaps_slock);
   
         return (pmap);          return pmap;
 }  }
   
 /*  /*
Line 1138  pmap_destroy(pmap_t pmap)
Line 1139  pmap_destroy(pmap_t pmap)
         /*          /*
          * Remove it from the global list of all pmaps.           * Remove it from the global list of all pmaps.
          */           */
         simple_lock(&pmap_all_pmaps_slock);          mutex_enter(&pmap_all_pmaps_slock);
         TAILQ_REMOVE(&pmap_all_pmaps, pmap, pm_list);          TAILQ_REMOVE(&pmap_all_pmaps, pmap, pm_list);
         simple_unlock(&pmap_all_pmaps_slock);          mutex_exit(&pmap_all_pmaps_slock);
   
         pool_put(&pmap_pmap_pool, pmap);          pool_put(&pmap_pmap_pool, pmap);
   
Line 1205  pmap_protect(pmap_t pmap, vaddr_t sva, v
Line 1206  pmap_protect(pmap_t pmap, vaddr_t sva, v
         if ((sva & PAGE_MASK) || (eva & PAGE_MASK))          if ((sva & PAGE_MASK) || (eva & PAGE_MASK))
                 panic("pmap_protect: unaligned addresses");                  panic("pmap_protect: unaligned addresses");
   
         uvm_lock_pageq();          //uvm_lock_pageq();
         PMAP_LOCK(pmap);          PMAP_LOCK(pmap);
         oldpmap = pmap_install(pmap);          oldpmap = pmap_install(pmap);
         while (sva < eva) {          while (sva < eva) {
Line 1233  pmap_protect(pmap_t pmap, vaddr_t sva, v
Line 1234  pmap_protect(pmap_t pmap, vaddr_t sva, v
   
                 sva += PAGE_SIZE;                  sva += PAGE_SIZE;
         }          }
         uvm_unlock_pageq();          //uvm_unlock_pageq();
         pmap_install(oldpmap);          pmap_install(oldpmap);
         PMAP_UNLOCK(pmap);          PMAP_UNLOCK(pmap);
 }  }
Line 1253  pmap_extract(pmap_t pmap, vaddr_t va, pa
Line 1254  pmap_extract(pmap_t pmap, vaddr_t va, pa
         paddr_t pa;          paddr_t pa;
   
         pa = 0;          pa = 0;
         simple_lock(pmap->pm_slock);          mutex_enter(&pmap->pm_slock);
         oldpmap = pmap_install(pmap); /* XXX: isn't this a little inefficient ? */          oldpmap = pmap_install(pmap); /* XXX: isn't this a little inefficient ? */
         pte = pmap_find_vhpt(va);          pte = pmap_find_vhpt(va);
         if (pte != NULL && pmap_present(pte))          if (pte != NULL && pmap_present(pte))
Line 1261  pmap_extract(pmap_t pmap, vaddr_t va, pa
Line 1262  pmap_extract(pmap_t pmap, vaddr_t va, pa
         else          else
                 return false;                  return false;
         pmap_install(oldpmap);          pmap_install(oldpmap);
         simple_unlock(pmap->pm_slock);          mutex_exit(&pmap->pm_slock);
         return true;          return true;
   
 }  }
Line 1328  pmap_page_protect(struct vm_page *pg, vm
Line 1329  pmap_page_protect(struct vm_page *pg, vm
                         PMAP_UNLOCK(pmap);                          PMAP_UNLOCK(pmap);
                 }                  }
   
                 UVM_LOCK_ASSERT_PAGEQ();                  //UVM_LOCK_ASSERT_PAGEQ();
   
                 pg->flags |= PG_RDONLY;                  pg->flags |= PG_RDONLY;
         } else {          } else {
Line 1362  pmap_reference(pmap_t pmap)
Line 1363  pmap_reference(pmap_t pmap)
 bool  bool
 pmap_clear_reference(struct vm_page *pg)  pmap_clear_reference(struct vm_page *pg)
 {  {
         return (false);          return false;
 }  }
   
 /*  /*
Line 1378  paddr_t
Line 1379  paddr_t
 pmap_phys_address(paddr_t ppn)  pmap_phys_address(paddr_t ppn)
 {  {
   
         return (ia64_ptob(ppn));          return ia64_ptob(ppn);
 }  }
   
   
Line 1546  pmap_page_purge(struct vm_page * pg)
Line 1547  pmap_page_purge(struct vm_page * pg)
                 panic("pmap_page_protect: illegal for unmanaged page, va: 0x%lx", VM_PAGE_TO_PHYS(pg));                  panic("pmap_page_protect: illegal for unmanaged page, va: 0x%lx", VM_PAGE_TO_PHYS(pg));
         }          }
 #endif  #endif
         UVM_LOCK_ASSERT_PAGEQ();          //UVM_LOCK_ASSERT_PAGEQ();
   
         while ((pv = TAILQ_FIRST(&pg->mdpage.pv_list)) != NULL) {          while ((pv = TAILQ_FIRST(&pg->mdpage.pv_list)) != NULL) {
                 struct ia64_lpte *pte;                  struct ia64_lpte *pte;
Line 1564  pmap_page_purge(struct vm_page * pg)
Line 1565  pmap_page_purge(struct vm_page * pg)
                 PMAP_UNLOCK(pmap);                  PMAP_UNLOCK(pmap);
         }          }
   
         UVM_LOCK_ASSERT_PAGEQ();          //UVM_LOCK_ASSERT_PAGEQ();
         pg->flags |= PG_RDONLY;          pg->flags |= PG_RDONLY;
   
 }  }
Line 1576  pmap_switch(pmap_t pm)
Line 1577  pmap_switch(pmap_t pm)
         pmap_t prevpm;          pmap_t prevpm;
         int i;          int i;
   
         LOCK_ASSERT(simple_lock_held(&sched_lock));          //LOCK_ASSERT(simple_lock_held(&sched_lock));
   
         prevpm = curcpu()->ci_pmap;          prevpm = curcpu()->ci_pmap;
         if (prevpm == pm)          if (prevpm == pm)
                 return (prevpm);                  return prevpm;
 //        if (prevpm != NULL)  //        if (prevpm != NULL)
 //                atomic_clear_32(&prevpm->pm_active, PCPU_GET(cpumask));  //                atomic_clear_32(&prevpm->pm_active, PCPU_GET(cpumask));
         if (pm == NULL) {          if (pm == NULL) {
Line 1597  pmap_switch(pmap_t pm)
Line 1598  pmap_switch(pmap_t pm)
         }          }
         curcpu()->ci_pmap = pm;          curcpu()->ci_pmap = pm;
         __asm __volatile("srlz.d");          __asm __volatile("srlz.d");
         return (prevpm);          return prevpm;
 }  }
   
 static pmap_t  static pmap_t
Line 1610  pmap_install(pmap_t pm)
Line 1611  pmap_install(pmap_t pm)
         splsched = splsched();          splsched = splsched();
         prevpm = pmap_switch(pm);          prevpm = pmap_switch(pm);
         splx(splsched);          splx(splsched);
         return (prevpm);          return prevpm;
 }  }
   
 static uint32_t  static uint32_t
Line 1619  pmap_allocate_rid(void)
Line 1620  pmap_allocate_rid(void)
         uint64_t bit, bits;          uint64_t bit, bits;
         int rid;          int rid;
   
         lockmgr(&pmap_rid_lock, LK_EXCLUSIVE, NULL);          mutex_enter(&pmap_rid_lock);
         if (pmap_ridcount == pmap_ridmax)          if (pmap_ridcount == pmap_ridmax)
                 panic("pmap_allocate_rid: All Region IDs used");                  panic("pmap_allocate_rid: All Region IDs used");
   
Line 1640  pmap_allocate_rid(void)
Line 1641  pmap_allocate_rid(void)
   
         pmap_ridmap[pmap_rididx] |= bit;          pmap_ridmap[pmap_rididx] |= bit;
         pmap_ridcount++;          pmap_ridcount++;
         lockmgr(&pmap_rid_lock, LK_RELEASE, NULL);          mutex_exit(&pmap_rid_lock);
   
         return rid;          return rid;
 }  }
Line 1654  pmap_free_rid(uint32_t rid)
Line 1655  pmap_free_rid(uint32_t rid)
         idx = rid / 64;          idx = rid / 64;
         bit = ~(1UL << (rid & 63));          bit = ~(1UL << (rid & 63));
   
         simple_lock(&pmap_rid_lock);          mutex_enter(&pmap_rid_lock);
         pmap_ridmap[idx] &= bit;          pmap_ridmap[idx] &= bit;
         pmap_ridcount--;          pmap_ridcount--;
         simple_unlock(&pmap_rid_lock);          mutex_exit(&pmap_rid_lock);
 }  }
   
 /***************************************************  /***************************************************
Line 1717  pmap_find_kpte(vaddr_t va)
Line 1718  pmap_find_kpte(vaddr_t va)
 {  {
         KASSERT((va >> 61) == 5);          KASSERT((va >> 61) == 5);
         KASSERT(IA64_RR_MASK(va) < (nkpt * PAGE_SIZE * NKPTEPG));          KASSERT(IA64_RR_MASK(va) < (nkpt * PAGE_SIZE * NKPTEPG));
         return (&ia64_kptdir[KPTE_DIR_INDEX(va)][KPTE_PTE_INDEX(va)]);          return &ia64_kptdir[KPTE_DIR_INDEX(va)][KPTE_PTE_INDEX(va)];
 }  }
   
   
Line 1888  get_pv_entry(pmap_t locked_pmap)
Line 1889  get_pv_entry(pmap_t locked_pmap)
 {  {
         pv_entry_t allocated_pv;          pv_entry_t allocated_pv;
   
         LOCK_ASSERT(simple_lock_held(locked_pmap->slock));          //LOCK_ASSERT(simple_lock_held(locked_pmap->slock));
         UVM_LOCK_ASSERT_PAGEQ();          //UVM_LOCK_ASSERT_PAGEQ();
         allocated_pv =  pool_get(&pmap_pv_pool, PR_NOWAIT);          allocated_pv =  pool_get(&pmap_pv_pool, PR_NOWAIT);
         return (allocated_pv);          return allocated_pv;
   
   
         /* XXX: Nice to have all this stuff later:          /* XXX: Nice to have all this stuff later:
Line 1927  pmap_enter_vhpt(struct ia64_lpte *pte, v
Line 1928  pmap_enter_vhpt(struct ia64_lpte *pte, v
         vhpte = (struct ia64_lpte *)ia64_thash(va);          vhpte = (struct ia64_lpte *)ia64_thash(va);
         bckt = (struct ia64_bucket *)vhpte->chain;          bckt = (struct ia64_bucket *)vhpte->chain;
         /* XXX: fixme */          /* XXX: fixme */
         KASSERT(!spinlockmgr(&bckt->lock, LK_EXCLUSIVE, NULL));          mutex_enter(&bckt->lock);
         pte->chain = bckt->chain;          pte->chain = bckt->chain;
         ia64_mf();          ia64_mf();
         bckt->chain = pte_pa;          bckt->chain = pte_pa;
Line 1935  pmap_enter_vhpt(struct ia64_lpte *pte, v
Line 1936  pmap_enter_vhpt(struct ia64_lpte *pte, v
         pmap_vhpt_inserts++;          pmap_vhpt_inserts++;
         bckt->length++;          bckt->length++;
         /*XXX : fixme */          /*XXX : fixme */
         KASSERT(!spinlockmgr(&bckt->lock, LK_RELEASE, NULL));          mutex_exit(&bckt->lock);
   
 }  }
   
Line 1957  pmap_remove_vhpt(vaddr_t va)
Line 1958  pmap_remove_vhpt(vaddr_t va)
         bckt = (struct ia64_bucket *)vhpte->chain;          bckt = (struct ia64_bucket *)vhpte->chain;
   
         lpte = NULL;          lpte = NULL;
         KASSERT(!spinlockmgr(&bckt->lock, LK_EXCLUSIVE, NULL));          mutex_enter(&bckt->lock);
   
   
         chain = bckt->chain;          chain = bckt->chain;
Line 1968  pmap_remove_vhpt(vaddr_t va)
Line 1969  pmap_remove_vhpt(vaddr_t va)
                 pte = (struct ia64_lpte *)IA64_PHYS_TO_RR7(chain);                  pte = (struct ia64_lpte *)IA64_PHYS_TO_RR7(chain);
         }          }
         if (chain == 0) {          if (chain == 0) {
                 KASSERT(!spinlockmgr(&bckt->lock, LK_RELEASE, NULL));                  mutex_exit(&bckt->lock);
                 return (ENOENT);                  return ENOENT;
         }          }
   
         /* Snip this pv_entry out of the collision chain. */          /* Snip this pv_entry out of the collision chain. */
Line 1980  pmap_remove_vhpt(vaddr_t va)
Line 1981  pmap_remove_vhpt(vaddr_t va)
         ia64_mf();          ia64_mf();
   
         bckt->length--;          bckt->length--;
         KASSERT(!spinlockmgr(&bckt->lock, LK_RELEASE, NULL));          mutex_exit(&bckt->lock);
         return (0);          return 0;
 }  }
   
   
Line 1999  pmap_find_vhpt(vaddr_t va)
Line 2000  pmap_find_vhpt(vaddr_t va)
         pte = (struct ia64_lpte *)ia64_thash(va);          pte = (struct ia64_lpte *)ia64_thash(va);
         bckt = (struct ia64_bucket *)pte->chain;          bckt = (struct ia64_bucket *)pte->chain;
   
         KASSERT(!spinlockmgr(&bckt->lock, LK_EXCLUSIVE, NULL));          mutex_enter(&bckt->lock);
         chain = bckt->chain;          chain = bckt->chain;
         pte = (struct ia64_lpte *)IA64_PHYS_TO_RR7(chain);          pte = (struct ia64_lpte *)IA64_PHYS_TO_RR7(chain);
         while (chain != 0 && pte->tag != tag) {          while (chain != 0 && pte->tag != tag) {
                 chain = pte->chain;                  chain = pte->chain;
                 pte = (struct ia64_lpte *)IA64_PHYS_TO_RR7(chain);                  pte = (struct ia64_lpte *)IA64_PHYS_TO_RR7(chain);
         }          }
         KASSERT(!spinlockmgr(&bckt->lock, LK_EXCLUSIVE, NULL));          mutex_exit(&bckt->lock);
         return ((chain != 0) ? pte : NULL);          return (chain != 0) ? pte : NULL;
 }  }
   
   
Line 2035  pmap_remove_entry(pmap_t pmap, struct vm
Line 2036  pmap_remove_entry(pmap_t pmap, struct vm
                 TAILQ_REMOVE(&pg->mdpage.pv_list, pv, pv_list);                  TAILQ_REMOVE(&pg->mdpage.pv_list, pv, pv_list);
                 pg->mdpage.pv_list_count--;                  pg->mdpage.pv_list_count--;
                 if (TAILQ_FIRST(&pg->mdpage.pv_list) == NULL) {                  if (TAILQ_FIRST(&pg->mdpage.pv_list) == NULL) {
                         UVM_LOCK_ASSERT_PAGEQ();                          //UVM_LOCK_ASSERT_PAGEQ();
                         pg->flags |= PG_RDONLY;                          pg->flags |= PG_RDONLY;
                 }                  }
   
Line 2061  pmap_insert_entry(pmap_t pmap, vaddr_t v
Line 2062  pmap_insert_entry(pmap_t pmap, vaddr_t v
         pv->pv_pmap = pmap;          pv->pv_pmap = pmap;
         pv->pv_va = va;          pv->pv_va = va;
   
         LOCK_ASSERT(simple_lock_held(pmap->slock));          //LOCK_ASSERT(simple_lock_held(pmap->slock));
         UVM_LOCK_ASSERT_PAGEQ();          //UVM_LOCK_ASSERT_PAGEQ();
         TAILQ_INSERT_TAIL(&pmap->pm_pvlist, pv, pv_plist);          TAILQ_INSERT_TAIL(&pmap->pm_pvlist, pv, pv_plist);
         TAILQ_INSERT_TAIL(&pg->mdpage.pv_list, pv, pv_list);          TAILQ_INSERT_TAIL(&pg->mdpage.pv_list, pv, pv_list);
         pg->mdpage.pv_list_count++;          pg->mdpage.pv_list_count++;
Line 2100  pmap_pv_page_alloc(struct pool *pp, int 
Line 2101  pmap_pv_page_alloc(struct pool *pp, int 
         paddr_t pg;          paddr_t pg;
   
         if (pmap_poolpage_alloc(&pg))          if (pmap_poolpage_alloc(&pg))
                 return ((void *)IA64_PHYS_TO_RR7(pg));                  return (void *)IA64_PHYS_TO_RR7(pg);
         return (NULL);          return NULL;
 }  }
   
 /*  /*
Line 2135  pmap_poolpage_alloc(paddr_t *pap)
Line 2136  pmap_poolpage_alloc(paddr_t *pap)
                 pa = VM_PAGE_TO_PHYS(pg);                  pa = VM_PAGE_TO_PHYS(pg);
   
 #ifdef DEBUG  #ifdef DEBUG
                 simple_lock(&pg->mdpage.pv_slock);                  mutex_enter(&pg->mdpage.pv_mutex);
                 if (pg->wire_count != 0) {                  if (pg->wire_count != 0) {
                         printf("pmap_physpage_alloc: page 0x%lx has "                          printf("pmap_physpage_alloc: page 0x%lx has "
                             "%d references\n", pa, pg->wire_count);                              "%d references\n", pa, pg->wire_count);
                         panic("pmap_physpage_alloc");                          panic("pmap_physpage_alloc");
                 }                  }
                 simple_unlock(&pg->mdpage.pv_slock);                  mutex_exit(&pg->mdpage.pv_mutex);
 #endif  #endif
                 *pap = pa;                  *pap = pa;
                 return (true);                  return true;
         }          }
         return (false);          return false;
 }  }
   
 /*  /*
Line 2163  pmap_poolpage_free(paddr_t pa)
Line 2164  pmap_poolpage_free(paddr_t pa)
                 panic("pmap_physpage_free: bogus physical page address");                  panic("pmap_physpage_free: bogus physical page address");
   
 #ifdef DEBUG  #ifdef DEBUG
         simple_lock(&pg->mdpage.pv_slock);          mutex_enter(&pg->mdpage.pv_mutex);
         if (pg->wire_count != 0)          if (pg->wire_count != 0)
                 panic("pmap_physpage_free: page still has references");                  panic("pmap_physpage_free: page still has references");
         simple_unlock(&pg->mdpage.pv_slock);          mutex_exit(&pg->mdpage.pv_mutex);
 #endif  #endif
   
         uvm_pagefree(pg);          uvm_pagefree(pg);

Legend:
Removed from v.1.11  
changed lines
  Added in v.1.12

CVSweb <webmaster@jp.NetBSD.org>