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

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

Diff for /src/sys/arch/powerpc/oea/pmap.c between version 1.10.2.8 and 1.10.2.9

version 1.10.2.8, 2005/03/04 16:39:02 version 1.10.2.9, 2005/11/10 13:58:26
Line 243  STATIC void pmap_pvo_check(const struct 
Line 243  STATIC void pmap_pvo_check(const struct 
 STATIC int pmap_pte_insert(int, struct pte *);  STATIC int pmap_pte_insert(int, struct pte *);
 STATIC int pmap_pvo_enter(pmap_t, struct pool *, struct pvo_head *,  STATIC int pmap_pvo_enter(pmap_t, struct pool *, struct pvo_head *,
         vaddr_t, paddr_t, register_t, int);          vaddr_t, paddr_t, register_t, int);
 STATIC void pmap_pvo_remove(struct pvo_entry *, int, boolean_t);  STATIC void pmap_pvo_remove(struct pvo_entry *, int, struct pvo_head *);
   STATIC void pmap_pvo_free(struct pvo_entry *);
   STATIC void pmap_pvo_free_list(struct pvo_head *);
 STATIC struct pvo_entry *pmap_pvo_find_va(pmap_t, vaddr_t, int *);  STATIC struct pvo_entry *pmap_pvo_find_va(pmap_t, vaddr_t, int *);
 STATIC volatile struct pte *pmap_pvo_to_pte(const struct pvo_entry *, int);  STATIC volatile struct pte *pmap_pvo_to_pte(const struct pvo_entry *, int);
 STATIC struct pvo_entry *pmap_pvo_reclaim(struct pmap *);  STATIC struct pvo_entry *pmap_pvo_reclaim(struct pmap *);
Line 1520  pmap_pvo_reclaim(struct pmap *pm)
Line 1522  pmap_pvo_reclaim(struct pmap *pm)
                 pvoh = &pmap_pvo_table[idx];                  pvoh = &pmap_pvo_table[idx];
                 TAILQ_FOREACH(pvo, pvoh, pvo_olink) {                  TAILQ_FOREACH(pvo, pvoh, pvo_olink) {
                         if ((pvo->pvo_vaddr & PVO_WIRED) == 0) {                          if ((pvo->pvo_vaddr & PVO_WIRED) == 0) {
                                 pmap_pvo_remove(pvo, -1, FALSE);                                  pmap_pvo_remove(pvo, -1, NULL);
                                 pmap_pvo_reclaim_nextidx = idx;                                  pmap_pvo_reclaim_nextidx = idx;
                                 PMAPCOUNT(pvos_reclaimed);                                  PMAPCOUNT(pvos_reclaimed);
                                 return pvo;                                  return pvo;
Line 1582  pmap_pvo_enter(pmap_t pm, struct pool *p
Line 1584  pmap_pvo_enter(pmap_t pm, struct pool *p
                         }                          }
 #endif  #endif
                         PMAPCOUNT(mappings_replaced);                          PMAPCOUNT(mappings_replaced);
                         pmap_pvo_remove(pvo, -1, TRUE);                          pmap_pvo_remove(pvo, -1, NULL);
                         break;                          break;
                 }                  }
         }          }
Line 1594  pmap_pvo_enter(pmap_t pm, struct pool *p
Line 1596  pmap_pvo_enter(pmap_t pm, struct pool *p
         --pmap_pvo_enter_depth;          --pmap_pvo_enter_depth;
 #endif  #endif
         pmap_interrupts_restore(msr);          pmap_interrupts_restore(msr);
           if (pvo) {
                   pmap_pvo_free(pvo);
           }
         pvo = pool_get(pl, poolflags);          pvo = pool_get(pl, poolflags);
   
 #ifdef DEBUG  #ifdef DEBUG
Line 1690  pmap_pvo_enter(pmap_t pm, struct pool *p
Line 1695  pmap_pvo_enter(pmap_t pm, struct pool *p
 }  }
   
 void  void
 pmap_pvo_remove(struct pvo_entry *pvo, int pteidx, boolean_t free)  pmap_pvo_remove(struct pvo_entry *pvo, int pteidx, struct pvo_head *pvol)
 {  {
         volatile struct pte *pt;          volatile struct pte *pt;
         int ptegidx;          int ptegidx;
Line 1761  pmap_pvo_remove(struct pvo_entry *pvo, i
Line 1766  pmap_pvo_remove(struct pvo_entry *pvo, i
          */           */
         LIST_REMOVE(pvo, pvo_vlink);          LIST_REMOVE(pvo, pvo_vlink);
         TAILQ_REMOVE(&pmap_pvo_table[ptegidx], pvo, pvo_olink);          TAILQ_REMOVE(&pmap_pvo_table[ptegidx], pvo, pvo_olink);
         if (free) {          if (pvol) {
                 pool_put(pvo->pvo_vaddr & PVO_MANAGED ? &pmap_mpvo_pool :                  LIST_INSERT_HEAD(pvol, pvo, pvo_vlink);
                          &pmap_upvo_pool, pvo);  
         }          }
 #if defined(DIAGNOSTIC) || defined(DEBUG) || defined(PMAPCHECK)  #if defined(DIAGNOSTIC) || defined(DEBUG) || defined(PMAPCHECK)
         pmap_pvo_remove_depth--;          pmap_pvo_remove_depth--;
 #endif  #endif
 }  }
   
   void
   pmap_pvo_free(struct pvo_entry *pvo)
   {
   
           pool_put(pvo->pvo_vaddr & PVO_MANAGED ? &pmap_mpvo_pool :
                    &pmap_upvo_pool, pvo);
   }
   
   void
   pmap_pvo_free_list(struct pvo_head *pvol)
   {
           struct pvo_entry *pvo, *npvo;
   
           for (pvo = LIST_FIRST(pvol); pvo != NULL; pvo = npvo) {
                   npvo = LIST_NEXT(pvo, pvo_vlink);
                   LIST_REMOVE(pvo, pvo_vlink);
                   pmap_pvo_free(pvo);
           }
   }
   
 /*  /*
  * Mark a mapping as executable.   * Mark a mapping as executable.
  * If this is the first executable mapping in the segment,   * If this is the first executable mapping in the segment,
Line 1884  pmap_enter(pmap_t pm, vaddr_t va, paddr_
Line 1908  pmap_enter(pmap_t pm, vaddr_t va, paddr_
          */           */
         if (flags & VM_PROT_WRITE)          if (flags & VM_PROT_WRITE)
                 pte_lo |= PTE_CHG;                  pte_lo |= PTE_CHG;
         if (flags & (VM_PROT_READ|VM_PROT_WRITE))          if (flags & VM_PROT_ALL)
                 pte_lo |= PTE_REF;                  pte_lo |= PTE_REF;
   
         /*          /*
Line 1991  pmap_kremove(vaddr_t va, vsize_t len)
Line 2015  pmap_kremove(vaddr_t va, vsize_t len)
 void  void
 pmap_remove(pmap_t pm, vaddr_t va, vaddr_t endva)  pmap_remove(pmap_t pm, vaddr_t va, vaddr_t endva)
 {  {
           struct pvo_head pvol;
         struct pvo_entry *pvo;          struct pvo_entry *pvo;
         register_t msr;          register_t msr;
         int pteidx;          int pteidx;
   
           LIST_INIT(&pvol);
         msr = pmap_interrupts_off();          msr = pmap_interrupts_off();
         for (; va < endva; va += PAGE_SIZE) {          for (; va < endva; va += PAGE_SIZE) {
                 pvo = pmap_pvo_find_va(pm, va, &pteidx);                  pvo = pmap_pvo_find_va(pm, va, &pteidx);
                 if (pvo != NULL) {                  if (pvo != NULL) {
                         pmap_pvo_remove(pvo, pteidx, TRUE);                          pmap_pvo_remove(pvo, pteidx, &pvol);
                 }                  }
         }          }
         pmap_interrupts_restore(msr);          pmap_interrupts_restore(msr);
           pmap_pvo_free_list(&pvol);
 }  }
   
 /*  /*
Line 2165  pmap_unwire(pmap_t pm, vaddr_t va)
Line 2192  pmap_unwire(pmap_t pm, vaddr_t va)
 void  void
 pmap_page_protect(struct vm_page *pg, vm_prot_t prot)  pmap_page_protect(struct vm_page *pg, vm_prot_t prot)
 {  {
         struct pvo_head *pvo_head;          struct pvo_head *pvo_head, pvol;
         struct pvo_entry *pvo, *next_pvo;          struct pvo_entry *pvo, *next_pvo;
         volatile struct pte *pt;          volatile struct pte *pt;
         register_t msr;          register_t msr;
   
         KASSERT(prot != VM_PROT_ALL);          KASSERT(prot != VM_PROT_ALL);
           LIST_INIT(&pvol);
         msr = pmap_interrupts_off();          msr = pmap_interrupts_off();
   
         /*          /*
Line 2196  pmap_page_protect(struct vm_page *pg, vm
Line 2224  pmap_page_protect(struct vm_page *pg, vm
                  * Downgrading to no mapping at all, we just remove the entry.                   * Downgrading to no mapping at all, we just remove the entry.
                  */                   */
                 if ((prot & VM_PROT_READ) == 0) {                  if ((prot & VM_PROT_READ) == 0) {
                         pmap_pvo_remove(pvo, -1, TRUE);                          pmap_pvo_remove(pvo, -1, &pvol);
                         continue;                          continue;
                 }                  }
   
Line 2232  pmap_page_protect(struct vm_page *pg, vm
Line 2260  pmap_page_protect(struct vm_page *pg, vm
                 PMAP_PVO_CHECK(pvo);            /* sanity check */                  PMAP_PVO_CHECK(pvo);            /* sanity check */
         }          }
         pmap_interrupts_restore(msr);          pmap_interrupts_restore(msr);
           pmap_pvo_free_list(&pvol);
 }  }
   
 /*  /*
Line 3092  pmap_bootstrap(paddr_t kernelstart, padd
Line 3121  pmap_bootstrap(paddr_t kernelstart, padd
                     pmap_pteg_table, size);                      pmap_pteg_table, size);
 #endif  #endif
   
         memset((void *)pmap_pteg_table, 0, pmap_pteg_cnt * sizeof(struct pteg));          memset(__UNVOLATILE(pmap_pteg_table), 0,
                   pmap_pteg_cnt * sizeof(struct pteg));
         pmap_pteg_mask = pmap_pteg_cnt - 1;          pmap_pteg_mask = pmap_pteg_cnt - 1;
   
         /*          /*
Legend:
Removed from v.1.10.2.8  
changed lines
  Added in v.1.10.2.9
CVSweb <webmaster@jp.NetBSD.org>