[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.27 and 1.27.8.2

version 1.27, 2010/11/12 07:59:26 version 1.27.8.2, 2013/01/16 05:33:00
Line 273  pmap_remove_entry(pmap_t pmap, struct vm
Line 273  pmap_remove_entry(pmap_t pmap, struct vm
 static void  static void
 pmap_insert_entry(pmap_t pmap, vaddr_t va, struct vm_page *pg);  pmap_insert_entry(pmap_t pmap, vaddr_t va, struct vm_page *pg);
   
 static __inline int  
 pmap_track_modified(vaddr_t va);  
   
 static void  static void
 pmap_enter_vhpt(struct ia64_lpte *, vaddr_t);  pmap_enter_vhpt(struct ia64_lpte *, vaddr_t);
 static int pmap_remove_vhpt(vaddr_t);  static int pmap_remove_vhpt(vaddr_t);
Line 1162  pmap_protect(pmap_t pmap, vaddr_t sva, v
Line 1159  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();  
         PMAP_LOCK(pmap);          PMAP_LOCK(pmap);
         oldpmap = pmap_install(pmap);          oldpmap = pmap_install(pmap);
         while (sva < eva) {          while (sva < eva) {
Line 1179  pmap_protect(pmap_t pmap, vaddr_t sva, v
Line 1175  pmap_protect(pmap_t pmap, vaddr_t sva, v
                         if (pmap_managed(pte)) {                          if (pmap_managed(pte)) {
                                 pa = pmap_ppn(pte);                                  pa = pmap_ppn(pte);
                                 pg = PHYS_TO_VM_PAGE(pa);                                  pg = PHYS_TO_VM_PAGE(pa);
                                 if (pmap_dirty(pte)) pmap_clear_dirty(pte);                                  if (pmap_dirty(pte))
                                           pmap_clear_dirty(pte);
                                 if (pmap_accessed(pte)) {                                  if (pmap_accessed(pte)) {
                                         pmap_clear_accessed(pte);                                          pmap_clear_accessed(pte);
                                 }                                  }
Line 1190  pmap_protect(pmap_t pmap, vaddr_t sva, v
Line 1187  pmap_protect(pmap_t pmap, vaddr_t sva, v
   
                 sva += PAGE_SIZE;                  sva += PAGE_SIZE;
         }          }
         //uvm_unlock_pageq();  
         pmap_install(oldpmap);          pmap_install(oldpmap);
         PMAP_UNLOCK(pmap);          PMAP_UNLOCK(pmap);
 }  }
Line 1239  pmap_clear_modify(struct vm_page *pg)
Line 1235  pmap_clear_modify(struct vm_page *pg)
         pmap_t oldpmap;          pmap_t oldpmap;
         pv_entry_t pv;          pv_entry_t pv;
   
         if (pg->flags & PG_FAKE)  
                 return rv;  
   
         TAILQ_FOREACH(pv, &md->pv_list, pv_list) {          TAILQ_FOREACH(pv, &md->pv_list, pv_list) {
                 PMAP_LOCK(pv->pv_pmap);                  PMAP_LOCK(pv->pv_pmap);
                 oldpmap = pmap_install(pv->pv_pmap);                  oldpmap = pmap_install(pv->pv_pmap);
Line 1289  pmap_page_protect(struct vm_page *pg, vm
Line 1282  pmap_page_protect(struct vm_page *pg, vm
                         PMAP_UNLOCK(pmap);                          PMAP_UNLOCK(pmap);
                 }                  }
   
                 //UVM_LOCK_ASSERT_PAGEQ();  
   
                 pg->flags |= PG_RDONLY;                  pg->flags |= PG_RDONLY;
         } else {          } else {
                 pmap_page_purge(pg);                  pmap_page_purge(pg);
Line 1428  pmap_enter(pmap_t pmap, vaddr_t va, padd
Line 1419  pmap_enter(pmap_t pmap, vaddr_t va, padd
                  * We might be turning off write access to the page,                   * We might be turning off write access to the page,
                  * so we go ahead and sense modify status.                   * so we go ahead and sense modify status.
                  */                   */
                 if (managed && pmap_dirty(&origpte) && pmap_track_modified(va))                  if (managed && pmap_dirty(&origpte))
                         pg->flags &= ~PG_CLEAN;                          pg->flags &= ~PG_CLEAN;
   
                 pmap_invalidate_page(pmap, va);                  pmap_invalidate_page(pmap, va);
Line 1448  pmap_enter(pmap_t pmap, vaddr_t va, padd
Line 1439  pmap_enter(pmap_t pmap, vaddr_t va, padd
          * Enter on the PV list if part of our managed memory.           * Enter on the PV list if part of our managed memory.
          */           */
   
         if ((flags & (PG_FAKE)) == 0) {          if (pg != NULL) {
                 pmap_insert_entry(pmap, va, pg);                  pmap_insert_entry(pmap, va, pg);
                 managed = true;                  managed = true;
         }          }
Line 1478  validate:
Line 1469  validate:
   
   
 /*  /*
  *      Routine:        pmap_page_purge: => was: pmap_remove_all   *      Routine:        pmap_page_purge
  *      Function:   *      Function:
  *              Removes this physical page from   *              Removes this physical page from
  *              all physical maps in which it resides.   *              all physical maps in which it resides.
Line 1497  pmap_page_purge(struct vm_page *pg)
Line 1488  pmap_page_purge(struct vm_page *pg)
         pmap_t oldpmap;          pmap_t oldpmap;
         pv_entry_t pv;          pv_entry_t pv;
   
 #if defined(DIAGNOSTIC)  
         /*  
          * XXX this makes pmap_page_protect(NONE) illegal for non-managed  
          * pages!  
          */  
         if (pg->flags & PG_FAKE) {  
                 panic("pmap_page_protect: illegal for unmanaged page, va: 0x%lx", VM_PAGE_TO_PHYS(pg));  
         }  
 #endif  
         //UVM_LOCK_ASSERT_PAGEQ();  
   
         while ((pv = TAILQ_FIRST(&md->pv_list)) != NULL) {          while ((pv = TAILQ_FIRST(&md->pv_list)) != NULL) {
                 struct ia64_lpte *pte;                  struct ia64_lpte *pte;
                 pmap_t pmap = pv->pv_pmap;                  pmap_t pmap = pv->pv_pmap;
Line 1524  pmap_page_purge(struct vm_page *pg)
Line 1504  pmap_page_purge(struct vm_page *pg)
                 PMAP_UNLOCK(pmap);                  PMAP_UNLOCK(pmap);
         }          }
   
         //UVM_LOCK_ASSERT_PAGEQ();  
         pg->flags |= PG_RDONLY;          pg->flags |= PG_RDONLY;
   
 }  }
Line 1778  pmap_remove_pte(pmap_t pmap, struct ia64
Line 1757  pmap_remove_pte(pmap_t pmap, struct ia64
         if (pmap_managed(pte)) {          if (pmap_managed(pte)) {
                 pg = PHYS_TO_VM_PAGE(pmap_ppn(pte));                  pg = PHYS_TO_VM_PAGE(pmap_ppn(pte));
                 if (pmap_dirty(pte))                  if (pmap_dirty(pte))
                         if (pmap_track_modified(va))                          pg->flags &= ~(PG_CLEAN);
                                 pg->flags &= ~(PG_CLEAN);  
                 if (pmap_accessed(pte))                  if (pmap_accessed(pte))
                         pg->flags &= ~PG_CLEAN; /* XXX: Do we need this ? */                          pg->flags &= ~PG_CLEAN; /* XXX: Do we need this ? */
   
Line 1813  pmap_free_pte(struct ia64_lpte *pte, vad
Line 1791  pmap_free_pte(struct ia64_lpte *pte, vad
 }  }
   
   
 /*  
  * this routine defines the region(s) of memory that should  
  * not be tested for the modified bit.  
  */  
 static __inline int  
 pmap_track_modified(vaddr_t va)  
 {  
         extern char *kmembase, kmemlimit;  
         if ((va < (vaddr_t) kmembase) || (va >= (vaddr_t) kmemlimit))  
                 return 1;  
         else  
                 return 0;  
 }  
   
   
 /***************************************************  /***************************************************
  * page management routines.   * page management routines.
  ***************************************************/   ***************************************************/
Line 1849  get_pv_entry(pmap_t locked_pmap)
Line 1812  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();  
         allocated_pv =  pool_get(&pmap_pv_pool, PR_NOWAIT);          allocated_pv =  pool_get(&pmap_pv_pool, PR_NOWAIT);
         return allocated_pv;          return allocated_pv;
   
Line 1997  pmap_remove_entry(pmap_t pmap, struct vm
Line 1959  pmap_remove_entry(pmap_t pmap, struct vm
                 TAILQ_REMOVE(&md->pv_list, pv, pv_list);                  TAILQ_REMOVE(&md->pv_list, pv, pv_list);
                 md->pv_list_count--;                  md->pv_list_count--;
                 if (TAILQ_FIRST(&md->pv_list) == NULL) {                  if (TAILQ_FIRST(&md->pv_list) == NULL) {
                         //UVM_LOCK_ASSERT_PAGEQ();  
                         pg->flags |= PG_RDONLY;                          pg->flags |= PG_RDONLY;
                 }                  }
   
Line 2025  pmap_insert_entry(pmap_t pmap, vaddr_t v
Line 1986  pmap_insert_entry(pmap_t pmap, vaddr_t v
         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();  
         TAILQ_INSERT_TAIL(&pmap->pm_pvlist, pv, pv_plist);          TAILQ_INSERT_TAIL(&pmap->pm_pvlist, pv, pv_plist);
         TAILQ_INSERT_TAIL(&md->pv_list, pv, pv_list);          TAILQ_INSERT_TAIL(&md->pv_list, pv, pv_list);
         md->pv_list_count++;          md->pv_list_count++;

Legend:
Removed from v.1.27  
changed lines
  Added in v.1.27.8.2

CVSweb <webmaster@jp.NetBSD.org>